commit 00baf9cee93198366d8225bc2c4b00efaccd47b3 · gmstn.systems/shard

+4 -1

src/lib/handlers/handshake.ts

···

       182
        
       

     

       183
        
           // yipee, it's a valid request :3

     

       184
        
       

     

       185
       -
           const sessionInfo = issueNewHandshakeToken(allowedChannels);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       186
        
       

     

       187
        
           return newSuccessResponse({ sessionInfo });

     

       188
        
       };

···

       182
        
       

     

       183
        
           // yipee, it's a valid request :3

     

       184
        
       

     

       185
       +
           const sessionInfo = issueNewHandshakeToken({

     

       186
       +
               allowedChannels,

     

       187
       +
               latticeDid: verifyJwtResult.value.issuer,

     

       188
       +
           });

     

       189
        
       

     

       190
        
           return newSuccessResponse({ sessionInfo });

     

       191
        
       };

+28 -7

src/lib/sessions.ts

···

       3
        
       import { SESSIONS_SECRET } from "@/lib/utils/crypto";

     

       4
        
       import { z } from "zod";

     

       5
        
       import type { Result } from "@/lib/utils/result";

     

       6
       -
       import type { AtUri } from "@/lib/types/atproto";

     

       7
       -
       import { atUriSchema } from "@/lib/types/atproto";

     

       0
        
       
     

       8
        
       

     

       9
        
       export const sessionInfoSchema = z.object({

     

       10
        
           id: z.string(),

     

       11
        
           token: z.string(),

     

       12
        
           fingerprint: z.string(),

     

       13
        
           allowedChannels: z.array(atUriSchema),

     

       0
        
       
     

       0
        
       
     

       14
        
       });

     

       15
        
       export type SessionInfo = z.infer<typeof sessionInfoSchema>;

     

       16
        
       

     
···

       21
        
       export const generateSessionInfo = (

     

       22
        
           sessionId: string,

     

       23
        
           allowedChannels: Array<AtUri>,

     

       0
        
       
     

       24
        
       ): SessionInfo => {

     

       25
        
           const token = crypto.randomBytes(32).toString("base64url");

     

       26
        
       

     
···

       28
        
           hmac.update(`${token}:${sessionId}`);

     

       29
        
           const fingerprint = hmac.digest("hex");

     

       30
        
       

     

       31
       -
           return { id: sessionId, token, fingerprint, allowedChannels };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       32
        
       };

     

       33
        
       

     

       34
        
       export const verifyHandshakeToken = ({

     
···

       52
        
       

     

       53
        
       export const issuedHandshakes = new Map<string, SessionInfo>();

     

       54
        
       

     

       55
       -
       export const issueNewHandshakeToken = (

     

       56
       -
           allowedChannels: Array<AtUri | undefined>,

     

       57
       -
       ) => {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       58
        
           const filteredChannels = allowedChannels.filter(

     

       59
        
               (channels) => channels !== undefined,

     

       60
        
           );

     

       61
        
           const sessionId = generateSessionId();

     

       62
       -
           const sessionInfo = generateSessionInfo(sessionId, filteredChannels);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       63
        
           issuedHandshakes.set(sessionInfo.token, sessionInfo);

     

       64
        
           return sessionInfo;

     

       65
        
       };

···

       3
        
       import { SESSIONS_SECRET } from "@/lib/utils/crypto";

     

       4
        
       import { z } from "zod";

     

       5
        
       import type { Result } from "@/lib/utils/result";

     

       6
       +
       import type { AtUri, Did } from "@/lib/types/atproto";

     

       7
       +
       import { atUriSchema, didSchema } from "@/lib/types/atproto";

     

       8
       +
       import { SERVICE_DID } from "@/lib/env";

     

       9
        
       

     

       10
        
       export const sessionInfoSchema = z.object({

     

       11
        
           id: z.string(),

     

       12
        
           token: z.string(),

     

       13
        
           fingerprint: z.string(),

     

       14
        
           allowedChannels: z.array(atUriSchema),

     

       15
       +
           shardDid: didSchema,

     

       16
       +
           latticeDid: didSchema,

     

       17
        
       });

     

       18
        
       export type SessionInfo = z.infer<typeof sessionInfoSchema>;

     

       19
        
       

     
···

       24
        
       export const generateSessionInfo = (

     

       25
        
           sessionId: string,

     

       26
        
           allowedChannels: Array<AtUri>,

     

       27
       +
           latticeDid: Did,

     

       28
        
       ): SessionInfo => {

     

       29
        
           const token = crypto.randomBytes(32).toString("base64url");

     

       30
        
       

     
···

       32
        
           hmac.update(`${token}:${sessionId}`);

     

       33
        
           const fingerprint = hmac.digest("hex");

     

       34
        
       

     

       35
       +
           const shardDid = SERVICE_DID;

     

       36
       +
       

     

       37
       +
           return {

     

       38
       +
               id: sessionId,

     

       39
       +
               token,

     

       40
       +
               fingerprint,

     

       41
       +
               allowedChannels,

     

       42
       +
               latticeDid,

     

       43
       +
               shardDid,

     

       44
       +
           };

     

       45
        
       };

     

       46
        
       

     

       47
        
       export const verifyHandshakeToken = ({

     
···

       65
        
       

     

       66
        
       export const issuedHandshakes = new Map<string, SessionInfo>();

     

       67
        
       

     

       68
       +
       export const issueNewHandshakeToken = ({

     

       69
       +
           allowedChannels,

     

       70
       +
           latticeDid,

     

       71
       +
       }: {

     

       72
       +
           allowedChannels: Array<AtUri | undefined>;

     

       73
       +
           latticeDid: Did;

     

       74
       +
       }) => {

     

       75
        
           const filteredChannels = allowedChannels.filter(

     

       76
        
               (channels) => channels !== undefined,

     

       77
        
           );

     

       78
        
           const sessionId = generateSessionId();

     

       79
       +
           const sessionInfo = generateSessionInfo(

     

       80
       +
               sessionId,

     

       81
       +
               filteredChannels,

     

       82
       +
               latticeDid,

     

       83
       +
           );

     

       84
        
           issuedHandshakes.set(sessionInfo.token, sessionInfo);

     

       85
        
           return sessionInfo;

     

       86
        
       };