commit 05440ebbfc16a0b9efe60b9711b462e5b992728e · gmstn.systems/shard

+8 -2

src/lib/handlers/handshake.ts

···

       29
       29
        
               });

     

       30
       30
        
           }

     

       31
       31
        
       

     

       32
       32
       -
           const { interServiceJwt } = handshakeData;

     

       32
       32
       +
           const { interServiceJwt, channelAtUris: channelAtUriStrings } =

     

       33
       33
       +
               handshakeData;

     

       34
       34
       +
           const allowedChannels = channelAtUriStrings.map((channel) => {

     

       35
       35
       +
               const res = stringToAtUri(channel);

     

       36
       36
       +
               if (!res.ok) return;

     

       37
       37
       +
               return res.data;

     

       38
       38
       +
           });

     

       33
       39
        
       

     

       34
       40
        
           const verifyJwtResult = await verifyServiceJwt(interServiceJwt);

     

       35
       41
        
           if (!verifyJwtResult.ok) {

     
···

       176
       182
        
       

     

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

     

       178
       184
        
       

     

       179
       179
       -
           const sessionInfo = issueNewHandshakeToken();

     

       185
       185
       +
           const sessionInfo = issueNewHandshakeToken(allowedChannels);

     

       180
       186
        
       

     

       181
       187
        
           return newSuccessResponse({ sessionInfo });

     

       182
       188
        
       };

+15 -4

src/lib/sessions.ts

···

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

     

       4
       4
        
       import { z } from "zod";

     

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

     

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

     

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

     

       6
       8
        
       

     

       7
       9
        
       export const sessionInfoSchema = z.object({

     

       8
       10
        
           id: z.string(),

     

       9
       11
        
           token: z.string(),

     

       10
       12
        
           fingerprint: z.string(),

     

       13
       13
       +
           allowedChannels: z.array(atUriSchema),

     

       11
       14
        
       });

     

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

     

       13
       16
        
       

     
···

       15
       18
        
           return crypto.randomUUID();

     

       16
       19
        
       };

     

       17
       20
        
       

     

       18
       18
       -
       export const generateSessionInfo = (sessionId: string): SessionInfo => {

     

       21
       21
       +
       export const generateSessionInfo = (

     

       22
       22
       +
           sessionId: string,

     

       23
       23
       +
           allowedChannels: Array<AtUri>,

     

       24
       24
       +
       ): SessionInfo => {

     

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

     

       20
       26
        
       

     

       21
       27
        
           const hmac = crypto.createHmac("sha256", SESSIONS_SECRET);

     

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

     

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

     

       24
       30
        
       

     

       25
       25
       -
           return { id: sessionId, token, fingerprint };

     

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

     

       26
       32
        
       };

     

       27
       33
        
       

     

       28
       34
        
       export const verifyHandshakeToken = ({

     
···

       46
       52
        
       

     

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

     

       48
       54
        
       

     

       49
       49
       -
       export const issueNewHandshakeToken = () => {

     

       55
       55
       +
       export const issueNewHandshakeToken = (

     

       56
       56
       +
           allowedChannels: Array<AtUri | undefined>,

     

       57
       57
       +
       ) => {

     

       58
       58
       +
           const filteredChannels = allowedChannels.filter(

     

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

     

       60
       60
       +
           );

     

       50
       61
        
           const sessionId = generateSessionId();

     

       51
       51
       -
           const sessionInfo = generateSessionInfo(sessionId);

     

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

     

       52
       63
        
           issuedHandshakes.set(sessionInfo.id, sessionInfo);

     

       53
       64
        
           return sessionInfo;

     

       54
       65
        
       };