···

       
1
       
-
       
import { check, cidForCbor, DAY, HOUR } from '@atproto/common'

     

       
2
       
 
       
import { EcdsaKeypair, Keypair, Secp256k1Keypair } from '@atproto/crypto'

     

       
3
       
-
       
import { create } from 'domain'

     

       
4
       
 
       
import { CID } from 'multiformats/cid'

     

       
5
       
-
       
import {

     

       
6
       
-
       
  GenesisHashError,

     

       
7
       
-
       
  ImproperOperationError,

     

       
8
       
-
       
  InvalidSignatureError,

     

       
9
       
-
       
  MisorderedOperationError,

     

       
10
       
-
       
} from '../src'

     

       
11
       
 
       
import * as data from '../src/data'

     

       
12
       
 
       
import * as operations from '../src/operations'

     

       
13
       
 
       
import * as t from '../src/types'

     
···

       
18
       
 
       
  let rotationKey2: EcdsaKeypair

     

       
19
       
 
       
  let rotationKey3: EcdsaKeypair

     

       
20
       
 
       
  let did: string

     

       
21
       
-
       
  let handle = 'alice.example.com'

     

       
22
       
-
       
  let atpPds = 'https://example.com'

     

       
23
       
 
       


     

       
24
       
 
       
  let log: t.IndexedOperation[] = []

     

       
25
       
 
       


     

       
26
       
 
       
  let createCid: CID

     

       
27
       
-
       
  const key3AttackCids: CID[] = []

     

       
28
       
-
       
  const key2AttackCid: CID[] = []

     

       
29
       
 
       


     

       
30
       
 
       
  beforeAll(async () => {

     

       
31
       
 
       
    signingKey = await Secp256k1Keypair.create()

     
···

       
119
       
 
       
    await expect(data.assureValidNextOp(did, log, rotate.op)).rejects.toThrow(

     

       
120
       
 
       
      InvalidSignatureError,

     

       
121
       
 
       
    )

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
122
       
 
       
  })

     

       
123
       
 
       
})

     

···

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

     

       
2
       
 
       
import { EcdsaKeypair, Keypair, Secp256k1Keypair } from '@atproto/crypto'

     

       
0
       
 
       

     

       
3
       
 
       
import { CID } from 'multiformats/cid'

     

       
4
       
+
       
import { InvalidSignatureError, LateRecoveryError } from '../src'

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
5
       
 
       
import * as data from '../src/data'

     

       
6
       
 
       
import * as operations from '../src/operations'

     

       
7
       
 
       
import * as t from '../src/types'

     
···

       
12
       
 
       
  let rotationKey2: EcdsaKeypair

     

       
13
       
 
       
  let rotationKey3: EcdsaKeypair

     

       
14
       
 
       
  let did: string

     

       
15
       
+
       
  const handle = 'alice.example.com'

     

       
16
       
+
       
  const atpPds = 'https://example.com'

     

       
17
       
 
       


     

       
18
       
 
       
  let log: t.IndexedOperation[] = []

     

       
19
       
 
       


     

       
20
       
 
       
  let createCid: CID

     

       
0
       
 
       

     

       
0
       
 
       

     

       
21
       
 
       


     

       
22
       
 
       
  beforeAll(async () => {

     

       
23
       
 
       
    signingKey = await Secp256k1Keypair.create()

     
···

       
111
       
 
       
    await expect(data.assureValidNextOp(did, log, rotate.op)).rejects.toThrow(

     

       
112
       
 
       
      InvalidSignatureError,

     

       
113
       
 
       
    )

     

       
114
       
+
       
  })

     

       
115
       
+
       


     

       
116
       
+
       
  it('allows a rotation key with even higher authority to rewrite history', async () => {

     

       
117
       
+
       
    const rotate = await signOpForKeys([rotationKey1], createCid, rotationKey1)

     

       
118
       
+
       


     

       
119
       
+
       
    const res = await data.assureValidNextOp(did, log, rotate.op)

     

       
120
       
+
       
    expect(res.nullified.length).toBe(1)

     

       
121
       
+
       
    expect(res.nullified[0].equals(log[1].cid))

     

       
122
       
+
       
    expect(res.prev?.equals(createCid))

     

       
123
       
+
       


     

       
124
       
+
       
    log = [log[0], rotate.indexed]

     

       
125
       
+
       
  })

     

       
126
       
+
       


     

       
127
       
+
       
  it('does not allow the either invalidated key to take control back', async () => {

     

       
128
       
+
       
    const rotate1 = await signOpForKeys([rotationKey3], createCid, rotationKey3)

     

       
129
       
+
       
    await expect(data.assureValidNextOp(did, log, rotate1.op)).rejects.toThrow(

     

       
130
       
+
       
      InvalidSignatureError,

     

       
131
       
+
       
    )

     

       
132
       
+
       


     

       
133
       
+
       
    const rotate2 = await signOpForKeys([rotationKey2], createCid, rotationKey2)

     

       
134
       
+
       
    await expect(data.assureValidNextOp(did, log, rotate2.op)).rejects.toThrow(

     

       
135
       
+
       
      InvalidSignatureError,

     

       
136
       
+
       
    )

     

       
137
       
+
       
  })

     

       
138
       
+
       


     

       
139
       
+
       
  it('does not allow recovery outside of 72 hrs', async () => {

     

       
140
       
+
       
    const rotate = await signOpForKeys([rotationKey3], createCid, rotationKey3)

     

       
141
       
+
       
    const timeOutOps = [

     

       
142
       
+
       
      log[0],

     

       
143
       
+
       
      {

     

       
144
       
+
       
        ...rotate.indexed,

     

       
145
       
+
       
        createdAt: new Date(Date.now() - 4 * DAY),

     

       
146
       
+
       
      },

     

       
147
       
+
       
    ]

     

       
148
       
+
       
    const rotateBack = await signOpForKeys(

     

       
149
       
+
       
      [rotationKey2],

     

       
150
       
+
       
      createCid,

     

       
151
       
+
       
      rotationKey2,

     

       
152
       
+
       
    )

     

       
153
       
+
       
    await expect(

     

       
154
       
+
       
      data.assureValidNextOp(did, timeOutOps, rotateBack.op),

     

       
155
       
+
       
    ).rejects.toThrow(LateRecoveryError)

     

       
156
       
 
       
  })

     

       
157
       
 
       
})