···

       
1
       
 
       
import { DAY, HOUR, cborEncode } from '@atproto/common'

     

       
2
       
 
       
import * as plc from '@did-plc/lib'

     

       
3
       
 
       
import { ServerError } from './error'

     

       
4
       
-
       
import { extractMultikey, parseDidKey } from '@atproto/crypto'

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
5
       
 
       


     

       
6
       
 
       
const MAX_OP_BYTES = 4000

     

       
7
       
 
       
const MAX_AKA_ENTRIES = 10

     
···

       
10
       
 
       
const MAX_SERVICE_ENTRIES = 10

     

       
11
       
 
       
const MAX_SERVICE_TYPE_LENGTH = 256

     

       
12
       
 
       
const MAX_SERVICE_ENDPOINT_LENGTH = 512

     

       
0
       
 
       

     

       
13
       
 
       
const MAX_ID_LENGTH = 32

     

       
0
       
 
       

     

       
14
       
 
       


     

       
15
       
 
       
export function validateIncomingOp(input: unknown): plc.OpOrTombstone {

     

       
16
       
 
       
  const byteLength = cborEncode(input).byteLength

     
···

       
104
       
 
       
    }

     

       
105
       
 
       
  }

     

       
106
       
 
       
  const verifyMethods = Object.entries(op.verificationMethods)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
107
       
 
       
  for (const [id, key] of verifyMethods) {

     

       
108
       
 
       
    if (id.length > MAX_ID_LENGTH) {

     

       
109
       
 
       
      throw new ServerError(

     
···

       
111
       
 
       
        `Verification Method id too long (max ${MAX_ID_LENGTH}): ${id}`,

     

       
112
       
 
       
      )

     

       
113
       
 
       
    }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
114
       
 
       
    try {

     

       
115
       
 
       
      // perform only minimal did:key syntax checking, with no restrictions on

     

       
116
       
 
       
      // key types

     

       
117
       
-
       
      extractMultikey(key)

     

       
0
       
 
       

     

       
118
       
 
       
    } catch (err) {

     

       
119
       
 
       
      throw new ServerError(400, `Invalid verificationMethod key: ${key}`)

     

       
120
       
 
       
    }

     

···

       
1
       
 
       
import { DAY, HOUR, cborEncode } from '@atproto/common'

     

       
2
       
 
       
import * as plc from '@did-plc/lib'

     

       
3
       
 
       
import { ServerError } from './error'

     

       
4
       
+
       
import {

     

       
5
       
+
       
  extractPrefixedBytes,

     

       
6
       
+
       
  extractMultikey,

     

       
7
       
+
       
  parseDidKey,

     

       
8
       
+
       
} from '@atproto/crypto'

     

       
9
       
 
       


     

       
10
       
 
       
const MAX_OP_BYTES = 4000

     

       
11
       
 
       
const MAX_AKA_ENTRIES = 10

     
···

       
14
       
 
       
const MAX_SERVICE_ENTRIES = 10

     

       
15
       
 
       
const MAX_SERVICE_TYPE_LENGTH = 256

     

       
16
       
 
       
const MAX_SERVICE_ENDPOINT_LENGTH = 512

     

       
17
       
+
       
const MAX_VERIF_METHOD_ENTRIES = 10

     

       
18
       
 
       
const MAX_ID_LENGTH = 32

     

       
19
       
+
       
const MAX_DID_KEY_LENGTH = 256 // k256 = 57, BLS12-381 = 143

     

       
20
       
 
       


     

       
21
       
 
       
export function validateIncomingOp(input: unknown): plc.OpOrTombstone {

     

       
22
       
 
       
  const byteLength = cborEncode(input).byteLength

     
···

       
110
       
 
       
    }

     

       
111
       
 
       
  }

     

       
112
       
 
       
  const verifyMethods = Object.entries(op.verificationMethods)

     

       
113
       
+
       
  if (verifyMethods.length > MAX_VERIF_METHOD_ENTRIES) {

     

       
114
       
+
       
    throw new ServerError(

     

       
115
       
+
       
      400,

     

       
116
       
+
       
      `Too many Verification Method entries (max ${MAX_VERIF_METHOD_ENTRIES})`,

     

       
117
       
+
       
    )

     

       
118
       
+
       
  }

     

       
119
       
 
       
  for (const [id, key] of verifyMethods) {

     

       
120
       
 
       
    if (id.length > MAX_ID_LENGTH) {

     

       
121
       
 
       
      throw new ServerError(

     
···

       
123
       
 
       
        `Verification Method id too long (max ${MAX_ID_LENGTH}): ${id}`,

     

       
124
       
 
       
      )

     

       
125
       
 
       
    }

     

       
126
       
+
       
    if (key.length > MAX_DID_KEY_LENGTH) {

     

       
127
       
+
       
      throw new ServerError(

     

       
128
       
+
       
        400,

     

       
129
       
+
       
        `Verification Method key too long (max ${MAX_DID_KEY_LENGTH}): ${id}`,

     

       
130
       
+
       
      )

     

       
131
       
+
       
    }

     

       
132
       
 
       
    try {

     

       
133
       
 
       
      // perform only minimal did:key syntax checking, with no restrictions on

     

       
134
       
 
       
      // key types

     

       
135
       
+
       
      const multikey = extractMultikey(key) // enforces did:key: prefix

     

       
136
       
+
       
      extractPrefixedBytes(multikey) // enforces base58-btc encoding

     

       
137
       
 
       
    } catch (err) {

     

       
138
       
 
       
      throw new ServerError(400, `Invalid verificationMethod key: ${key}`)

     

       
139
       
 
       
    }