@ledgerhq/revault-sdk 0.12.2 → 0.16.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/bake.cjs +90 -42
- package/lib/bake.cjs.map +1 -1
- package/lib/bake.d.cts +227 -103
- package/lib/bake.d.ts +227 -103
- package/lib/bake.js +90 -42
- package/lib/bake.js.map +1 -1
- package/lib/{chunk-DPHEFR6E.js → chunk-BGVGHXMO.js} +7 -3
- package/lib/chunk-BGVGHXMO.js.map +1 -0
- package/lib/{chunk-VCAQTGQE.cjs → chunk-R2LW7L74.cjs} +7 -3
- package/lib/chunk-R2LW7L74.cjs.map +1 -0
- package/lib/device.cjs +2 -2
- package/lib/device.d.cts +1 -1
- package/lib/device.d.ts +1 -1
- package/lib/device.js +1 -1
- package/lib/engine.cjs +107 -44
- package/lib/engine.cjs.map +1 -1
- package/lib/engine.d.cts +3 -3
- package/lib/engine.d.ts +3 -3
- package/lib/engine.js +87 -24
- package/lib/engine.js.map +1 -1
- package/lib/onboarding.cjs +30 -15
- package/lib/onboarding.cjs.map +1 -1
- package/lib/onboarding.d.cts +262 -262
- package/lib/onboarding.d.ts +262 -262
- package/lib/onboarding.js +26 -11
- package/lib/onboarding.js.map +1 -1
- package/lib/{types-DHZzeq9X.d.ts → types-BxfmwEOw.d.cts} +3 -7
- package/lib/{types-CsvE9Mlb.d.cts → types-DJfbanPz.d.cts} +11 -3
- package/lib/{types-CsvE9Mlb.d.ts → types-DJfbanPz.d.ts} +11 -3
- package/lib/{types-BYNH6EdK.d.cts → types-ZEEgdlx2.d.ts} +3 -7
- package/package.json +17 -17
- package/lib/chunk-DPHEFR6E.js.map +0 -1
- package/lib/chunk-VCAQTGQE.cjs.map +0 -1
package/lib/onboarding.d.ts
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
import { OnboardingFullStateResponse, OnboardingStep } from '@ledgerhq/revault-api';
|
|
2
2
|
import { Logger } from './index.js';
|
|
3
|
-
import { E as Engine, W as WithOnboarding } from './types-
|
|
4
|
-
import './types-
|
|
3
|
+
import { E as Engine, W as WithOnboarding } from './types-ZEEgdlx2.js';
|
|
4
|
+
import './types-DJfbanPz.js';
|
|
5
5
|
import '@trpc/client';
|
|
6
6
|
import '@trpc/server';
|
|
7
7
|
|
|
@@ -13,26 +13,26 @@ declare const STEPS: {
|
|
|
13
13
|
engine: Engine<WithOnboarding>;
|
|
14
14
|
state: OnboardingFullStateResponse;
|
|
15
15
|
}, logger: Logger) => Promise<{
|
|
16
|
-
id: string;
|
|
17
16
|
workspaceName: string;
|
|
17
|
+
id: string;
|
|
18
18
|
createdAt: Date;
|
|
19
19
|
wrappingKey: {
|
|
20
20
|
ephemeralPubKey: string;
|
|
21
21
|
ephemeralCertificate: {
|
|
22
|
-
signature: string;
|
|
23
22
|
codeHash: string;
|
|
24
23
|
attestationPub: string;
|
|
25
24
|
certificate: string;
|
|
25
|
+
signature: string;
|
|
26
26
|
};
|
|
27
27
|
fragments: {
|
|
28
|
-
pubKey: string;
|
|
29
28
|
blob: string;
|
|
29
|
+
pubKey: string;
|
|
30
30
|
ephemeralPubKey: string;
|
|
31
31
|
ephemeralCertificate: {
|
|
32
|
-
signature: string;
|
|
33
32
|
codeHash: string;
|
|
34
33
|
attestationPub: string;
|
|
35
34
|
certificate: string;
|
|
35
|
+
signature: string;
|
|
36
36
|
};
|
|
37
37
|
}[];
|
|
38
38
|
} | null;
|
|
@@ -40,98 +40,98 @@ declare const STEPS: {
|
|
|
40
40
|
completedAt: Date | null;
|
|
41
41
|
claimedDevices: {
|
|
42
42
|
pubKey: string;
|
|
43
|
+
role: "SHARED_OWNER" | "WRAPPING_KEY_OWNER" | "MASTER_ADMIN";
|
|
43
44
|
deviceUserId: string;
|
|
44
|
-
role: "WRAPPING_KEY_OWNER" | "SHARED_OWNER" | "MASTER_ADMIN";
|
|
45
45
|
deviceName: string;
|
|
46
46
|
}[];
|
|
47
47
|
masterAdmins: {
|
|
48
48
|
name: string;
|
|
49
|
+
psdModel: "BLUE" | "STAX";
|
|
49
50
|
pubKey: string;
|
|
50
51
|
role: "MASTER_ADMIN";
|
|
51
|
-
psdModel: "BLUE" | "STAX";
|
|
52
52
|
registrationChallenge: {
|
|
53
|
-
requestId: string;
|
|
54
|
-
challenge: string;
|
|
55
53
|
handshake: string;
|
|
56
54
|
handshakeAttestation: {
|
|
57
|
-
signature: string;
|
|
58
55
|
codeHash: string;
|
|
59
56
|
attestationPub: string;
|
|
60
57
|
certificate: string;
|
|
58
|
+
signature: string;
|
|
61
59
|
};
|
|
60
|
+
challenge: string;
|
|
62
61
|
ephemeralPublicKey: string;
|
|
63
62
|
ephemeralPublicKeyAttestation: {
|
|
64
|
-
signature: string;
|
|
65
63
|
codeHash: string;
|
|
66
64
|
attestationPub: string;
|
|
67
65
|
certificate: string;
|
|
66
|
+
signature: string;
|
|
68
67
|
};
|
|
69
68
|
u2fRegisterData: string;
|
|
70
69
|
ciphertext: string;
|
|
70
|
+
requestId: string;
|
|
71
71
|
};
|
|
72
72
|
registrationResponse: {
|
|
73
|
-
u2fKeyHandle: string;
|
|
74
73
|
certificate: {
|
|
75
|
-
signature: string;
|
|
76
74
|
codeHash: string;
|
|
77
75
|
attestationPub: string;
|
|
78
76
|
certificate: string;
|
|
77
|
+
signature: string;
|
|
79
78
|
};
|
|
80
79
|
u2fRegister: string;
|
|
80
|
+
u2fKeyHandle: string;
|
|
81
81
|
registerData: string;
|
|
82
82
|
validationKey: string;
|
|
83
83
|
pairingPayload: string;
|
|
84
84
|
} | null;
|
|
85
85
|
review: {
|
|
86
|
+
signature: string | null;
|
|
86
87
|
challenge: {
|
|
87
88
|
challengeType: "PSD";
|
|
88
89
|
wActions: string[];
|
|
89
90
|
handshake: string;
|
|
90
91
|
handshakeAttestation: {
|
|
91
|
-
signature: string;
|
|
92
92
|
codeHash: string;
|
|
93
93
|
attestationPub: string;
|
|
94
94
|
certificate: string;
|
|
95
|
+
signature: string;
|
|
95
96
|
};
|
|
96
97
|
partitionId: string;
|
|
97
98
|
};
|
|
98
|
-
signature: string | null;
|
|
99
99
|
} | null;
|
|
100
100
|
}[];
|
|
101
101
|
sharedOwners: {
|
|
102
102
|
name: string;
|
|
103
|
+
psdModel: "BLUE" | "STAX";
|
|
103
104
|
pubKey: string;
|
|
104
105
|
role: "SHARED_OWNER";
|
|
105
|
-
psdModel: "BLUE" | "STAX";
|
|
106
106
|
registrationChallenge: {
|
|
107
|
-
requestId: string;
|
|
108
|
-
challenge: string;
|
|
109
107
|
handshake: string;
|
|
110
108
|
handshakeAttestation: {
|
|
111
|
-
signature: string;
|
|
112
109
|
codeHash: string;
|
|
113
110
|
attestationPub: string;
|
|
114
111
|
certificate: string;
|
|
112
|
+
signature: string;
|
|
115
113
|
};
|
|
114
|
+
challenge: string;
|
|
116
115
|
ephemeralPublicKey: string;
|
|
117
116
|
ephemeralPublicKeyAttestation: {
|
|
118
|
-
signature: string;
|
|
119
117
|
codeHash: string;
|
|
120
118
|
attestationPub: string;
|
|
121
119
|
certificate: string;
|
|
120
|
+
signature: string;
|
|
122
121
|
};
|
|
123
122
|
u2fRegisterData: string;
|
|
124
123
|
ciphertext: string;
|
|
124
|
+
requestId: string;
|
|
125
125
|
};
|
|
126
126
|
registrationResponse: {
|
|
127
|
-
u2fKeyHandle: string;
|
|
128
127
|
certificate: {
|
|
129
|
-
signature: string;
|
|
130
128
|
codeHash: string;
|
|
131
129
|
attestationPub: string;
|
|
132
130
|
certificate: string;
|
|
131
|
+
signature: string;
|
|
133
132
|
};
|
|
134
133
|
u2fRegister: string;
|
|
134
|
+
u2fKeyHandle: string;
|
|
135
135
|
registerData: string;
|
|
136
136
|
validationKey: string;
|
|
137
137
|
pairingPayload: string;
|
|
@@ -139,38 +139,38 @@ declare const STEPS: {
|
|
|
139
139
|
review: {
|
|
140
140
|
seedChallenge: {
|
|
141
141
|
blob: string;
|
|
142
|
-
challengeType: "PSD";
|
|
143
142
|
certificate: {
|
|
144
|
-
signature: string;
|
|
145
143
|
codeHash: string;
|
|
146
144
|
attestationPub: string;
|
|
147
145
|
certificate: string;
|
|
146
|
+
signature: string;
|
|
148
147
|
};
|
|
148
|
+
challengeType: "PSD";
|
|
149
149
|
wActions: string[];
|
|
150
150
|
handshake: string;
|
|
151
151
|
handshakeAttestation: {
|
|
152
|
-
signature: string;
|
|
153
152
|
codeHash: string;
|
|
154
153
|
attestationPub: string;
|
|
155
154
|
certificate: string;
|
|
155
|
+
signature: string;
|
|
156
156
|
};
|
|
157
157
|
partitionId: string;
|
|
158
158
|
ephemeralPublicKey: string;
|
|
159
159
|
kkHandshake: string;
|
|
160
160
|
kkHandshakeAttestation: {
|
|
161
|
-
signature: string;
|
|
162
161
|
codeHash: string;
|
|
163
162
|
attestationPub: string;
|
|
164
163
|
certificate: string;
|
|
164
|
+
signature: string;
|
|
165
165
|
};
|
|
166
166
|
};
|
|
167
167
|
seedFragment: {
|
|
168
168
|
handshake: string;
|
|
169
169
|
handshakeAttestation: {
|
|
170
|
-
signature: string;
|
|
171
170
|
codeHash: string;
|
|
172
171
|
attestationPub: string;
|
|
173
172
|
certificate: string;
|
|
173
|
+
signature: string;
|
|
174
174
|
};
|
|
175
175
|
approverBlob: string;
|
|
176
176
|
challengeResponse: string;
|
|
@@ -185,26 +185,26 @@ declare const STEPS: {
|
|
|
185
185
|
engine: Engine<WithOnboarding>;
|
|
186
186
|
state: OnboardingFullStateResponse;
|
|
187
187
|
}, logger: Logger) => Promise<{
|
|
188
|
-
id: string;
|
|
189
188
|
workspaceName: string;
|
|
189
|
+
id: string;
|
|
190
190
|
createdAt: Date;
|
|
191
191
|
wrappingKey: {
|
|
192
192
|
ephemeralPubKey: string;
|
|
193
193
|
ephemeralCertificate: {
|
|
194
|
-
signature: string;
|
|
195
194
|
codeHash: string;
|
|
196
195
|
attestationPub: string;
|
|
197
196
|
certificate: string;
|
|
197
|
+
signature: string;
|
|
198
198
|
};
|
|
199
199
|
fragments: {
|
|
200
|
-
pubKey: string;
|
|
201
200
|
blob: string;
|
|
201
|
+
pubKey: string;
|
|
202
202
|
ephemeralPubKey: string;
|
|
203
203
|
ephemeralCertificate: {
|
|
204
|
-
signature: string;
|
|
205
204
|
codeHash: string;
|
|
206
205
|
attestationPub: string;
|
|
207
206
|
certificate: string;
|
|
207
|
+
signature: string;
|
|
208
208
|
};
|
|
209
209
|
}[];
|
|
210
210
|
} | null;
|
|
@@ -212,98 +212,98 @@ declare const STEPS: {
|
|
|
212
212
|
completedAt: Date | null;
|
|
213
213
|
claimedDevices: {
|
|
214
214
|
pubKey: string;
|
|
215
|
+
role: "SHARED_OWNER" | "WRAPPING_KEY_OWNER" | "MASTER_ADMIN";
|
|
215
216
|
deviceUserId: string;
|
|
216
|
-
role: "WRAPPING_KEY_OWNER" | "SHARED_OWNER" | "MASTER_ADMIN";
|
|
217
217
|
deviceName: string;
|
|
218
218
|
}[];
|
|
219
219
|
masterAdmins: {
|
|
220
220
|
name: string;
|
|
221
|
+
psdModel: "BLUE" | "STAX";
|
|
221
222
|
pubKey: string;
|
|
222
223
|
role: "MASTER_ADMIN";
|
|
223
|
-
psdModel: "BLUE" | "STAX";
|
|
224
224
|
registrationChallenge: {
|
|
225
|
-
requestId: string;
|
|
226
|
-
challenge: string;
|
|
227
225
|
handshake: string;
|
|
228
226
|
handshakeAttestation: {
|
|
229
|
-
signature: string;
|
|
230
227
|
codeHash: string;
|
|
231
228
|
attestationPub: string;
|
|
232
229
|
certificate: string;
|
|
230
|
+
signature: string;
|
|
233
231
|
};
|
|
232
|
+
challenge: string;
|
|
234
233
|
ephemeralPublicKey: string;
|
|
235
234
|
ephemeralPublicKeyAttestation: {
|
|
236
|
-
signature: string;
|
|
237
235
|
codeHash: string;
|
|
238
236
|
attestationPub: string;
|
|
239
237
|
certificate: string;
|
|
238
|
+
signature: string;
|
|
240
239
|
};
|
|
241
240
|
u2fRegisterData: string;
|
|
242
241
|
ciphertext: string;
|
|
242
|
+
requestId: string;
|
|
243
243
|
};
|
|
244
244
|
registrationResponse: {
|
|
245
|
-
u2fKeyHandle: string;
|
|
246
245
|
certificate: {
|
|
247
|
-
signature: string;
|
|
248
246
|
codeHash: string;
|
|
249
247
|
attestationPub: string;
|
|
250
248
|
certificate: string;
|
|
249
|
+
signature: string;
|
|
251
250
|
};
|
|
252
251
|
u2fRegister: string;
|
|
252
|
+
u2fKeyHandle: string;
|
|
253
253
|
registerData: string;
|
|
254
254
|
validationKey: string;
|
|
255
255
|
pairingPayload: string;
|
|
256
256
|
} | null;
|
|
257
257
|
review: {
|
|
258
|
+
signature: string | null;
|
|
258
259
|
challenge: {
|
|
259
260
|
challengeType: "PSD";
|
|
260
261
|
wActions: string[];
|
|
261
262
|
handshake: string;
|
|
262
263
|
handshakeAttestation: {
|
|
263
|
-
signature: string;
|
|
264
264
|
codeHash: string;
|
|
265
265
|
attestationPub: string;
|
|
266
266
|
certificate: string;
|
|
267
|
+
signature: string;
|
|
267
268
|
};
|
|
268
269
|
partitionId: string;
|
|
269
270
|
};
|
|
270
|
-
signature: string | null;
|
|
271
271
|
} | null;
|
|
272
272
|
}[];
|
|
273
273
|
sharedOwners: {
|
|
274
274
|
name: string;
|
|
275
|
+
psdModel: "BLUE" | "STAX";
|
|
275
276
|
pubKey: string;
|
|
276
277
|
role: "SHARED_OWNER";
|
|
277
|
-
psdModel: "BLUE" | "STAX";
|
|
278
278
|
registrationChallenge: {
|
|
279
|
-
requestId: string;
|
|
280
|
-
challenge: string;
|
|
281
279
|
handshake: string;
|
|
282
280
|
handshakeAttestation: {
|
|
283
|
-
signature: string;
|
|
284
281
|
codeHash: string;
|
|
285
282
|
attestationPub: string;
|
|
286
283
|
certificate: string;
|
|
284
|
+
signature: string;
|
|
287
285
|
};
|
|
286
|
+
challenge: string;
|
|
288
287
|
ephemeralPublicKey: string;
|
|
289
288
|
ephemeralPublicKeyAttestation: {
|
|
290
|
-
signature: string;
|
|
291
289
|
codeHash: string;
|
|
292
290
|
attestationPub: string;
|
|
293
291
|
certificate: string;
|
|
292
|
+
signature: string;
|
|
294
293
|
};
|
|
295
294
|
u2fRegisterData: string;
|
|
296
295
|
ciphertext: string;
|
|
296
|
+
requestId: string;
|
|
297
297
|
};
|
|
298
298
|
registrationResponse: {
|
|
299
|
-
u2fKeyHandle: string;
|
|
300
299
|
certificate: {
|
|
301
|
-
signature: string;
|
|
302
300
|
codeHash: string;
|
|
303
301
|
attestationPub: string;
|
|
304
302
|
certificate: string;
|
|
303
|
+
signature: string;
|
|
305
304
|
};
|
|
306
305
|
u2fRegister: string;
|
|
306
|
+
u2fKeyHandle: string;
|
|
307
307
|
registerData: string;
|
|
308
308
|
validationKey: string;
|
|
309
309
|
pairingPayload: string;
|
|
@@ -311,38 +311,38 @@ declare const STEPS: {
|
|
|
311
311
|
review: {
|
|
312
312
|
seedChallenge: {
|
|
313
313
|
blob: string;
|
|
314
|
-
challengeType: "PSD";
|
|
315
314
|
certificate: {
|
|
316
|
-
signature: string;
|
|
317
315
|
codeHash: string;
|
|
318
316
|
attestationPub: string;
|
|
319
317
|
certificate: string;
|
|
318
|
+
signature: string;
|
|
320
319
|
};
|
|
320
|
+
challengeType: "PSD";
|
|
321
321
|
wActions: string[];
|
|
322
322
|
handshake: string;
|
|
323
323
|
handshakeAttestation: {
|
|
324
|
-
signature: string;
|
|
325
324
|
codeHash: string;
|
|
326
325
|
attestationPub: string;
|
|
327
326
|
certificate: string;
|
|
327
|
+
signature: string;
|
|
328
328
|
};
|
|
329
329
|
partitionId: string;
|
|
330
330
|
ephemeralPublicKey: string;
|
|
331
331
|
kkHandshake: string;
|
|
332
332
|
kkHandshakeAttestation: {
|
|
333
|
-
signature: string;
|
|
334
333
|
codeHash: string;
|
|
335
334
|
attestationPub: string;
|
|
336
335
|
certificate: string;
|
|
336
|
+
signature: string;
|
|
337
337
|
};
|
|
338
338
|
};
|
|
339
339
|
seedFragment: {
|
|
340
340
|
handshake: string;
|
|
341
341
|
handshakeAttestation: {
|
|
342
|
-
signature: string;
|
|
343
342
|
codeHash: string;
|
|
344
343
|
attestationPub: string;
|
|
345
344
|
certificate: string;
|
|
345
|
+
signature: string;
|
|
346
346
|
};
|
|
347
347
|
approverBlob: string;
|
|
348
348
|
challengeResponse: string;
|
|
@@ -357,26 +357,26 @@ declare const STEPS: {
|
|
|
357
357
|
engine: Engine<WithOnboarding>;
|
|
358
358
|
state: OnboardingFullStateResponse;
|
|
359
359
|
}) => Promise<{
|
|
360
|
-
id: string;
|
|
361
360
|
workspaceName: string;
|
|
361
|
+
id: string;
|
|
362
362
|
createdAt: Date;
|
|
363
363
|
wrappingKey: {
|
|
364
364
|
ephemeralPubKey: string;
|
|
365
365
|
ephemeralCertificate: {
|
|
366
|
-
signature: string;
|
|
367
366
|
codeHash: string;
|
|
368
367
|
attestationPub: string;
|
|
369
368
|
certificate: string;
|
|
369
|
+
signature: string;
|
|
370
370
|
};
|
|
371
371
|
fragments: {
|
|
372
|
-
pubKey: string;
|
|
373
372
|
blob: string;
|
|
373
|
+
pubKey: string;
|
|
374
374
|
ephemeralPubKey: string;
|
|
375
375
|
ephemeralCertificate: {
|
|
376
|
-
signature: string;
|
|
377
376
|
codeHash: string;
|
|
378
377
|
attestationPub: string;
|
|
379
378
|
certificate: string;
|
|
379
|
+
signature: string;
|
|
380
380
|
};
|
|
381
381
|
}[];
|
|
382
382
|
} | null;
|
|
@@ -384,98 +384,98 @@ declare const STEPS: {
|
|
|
384
384
|
completedAt: Date | null;
|
|
385
385
|
claimedDevices: {
|
|
386
386
|
pubKey: string;
|
|
387
|
+
role: "SHARED_OWNER" | "WRAPPING_KEY_OWNER" | "MASTER_ADMIN";
|
|
387
388
|
deviceUserId: string;
|
|
388
|
-
role: "WRAPPING_KEY_OWNER" | "SHARED_OWNER" | "MASTER_ADMIN";
|
|
389
389
|
deviceName: string;
|
|
390
390
|
}[];
|
|
391
391
|
masterAdmins: {
|
|
392
392
|
name: string;
|
|
393
|
+
psdModel: "BLUE" | "STAX";
|
|
393
394
|
pubKey: string;
|
|
394
395
|
role: "MASTER_ADMIN";
|
|
395
|
-
psdModel: "BLUE" | "STAX";
|
|
396
396
|
registrationChallenge: {
|
|
397
|
-
requestId: string;
|
|
398
|
-
challenge: string;
|
|
399
397
|
handshake: string;
|
|
400
398
|
handshakeAttestation: {
|
|
401
|
-
signature: string;
|
|
402
399
|
codeHash: string;
|
|
403
400
|
attestationPub: string;
|
|
404
401
|
certificate: string;
|
|
402
|
+
signature: string;
|
|
405
403
|
};
|
|
404
|
+
challenge: string;
|
|
406
405
|
ephemeralPublicKey: string;
|
|
407
406
|
ephemeralPublicKeyAttestation: {
|
|
408
|
-
signature: string;
|
|
409
407
|
codeHash: string;
|
|
410
408
|
attestationPub: string;
|
|
411
409
|
certificate: string;
|
|
410
|
+
signature: string;
|
|
412
411
|
};
|
|
413
412
|
u2fRegisterData: string;
|
|
414
413
|
ciphertext: string;
|
|
414
|
+
requestId: string;
|
|
415
415
|
};
|
|
416
416
|
registrationResponse: {
|
|
417
|
-
u2fKeyHandle: string;
|
|
418
417
|
certificate: {
|
|
419
|
-
signature: string;
|
|
420
418
|
codeHash: string;
|
|
421
419
|
attestationPub: string;
|
|
422
420
|
certificate: string;
|
|
421
|
+
signature: string;
|
|
423
422
|
};
|
|
424
423
|
u2fRegister: string;
|
|
424
|
+
u2fKeyHandle: string;
|
|
425
425
|
registerData: string;
|
|
426
426
|
validationKey: string;
|
|
427
427
|
pairingPayload: string;
|
|
428
428
|
} | null;
|
|
429
429
|
review: {
|
|
430
|
+
signature: string | null;
|
|
430
431
|
challenge: {
|
|
431
432
|
challengeType: "PSD";
|
|
432
433
|
wActions: string[];
|
|
433
434
|
handshake: string;
|
|
434
435
|
handshakeAttestation: {
|
|
435
|
-
signature: string;
|
|
436
436
|
codeHash: string;
|
|
437
437
|
attestationPub: string;
|
|
438
438
|
certificate: string;
|
|
439
|
+
signature: string;
|
|
439
440
|
};
|
|
440
441
|
partitionId: string;
|
|
441
442
|
};
|
|
442
|
-
signature: string | null;
|
|
443
443
|
} | null;
|
|
444
444
|
}[];
|
|
445
445
|
sharedOwners: {
|
|
446
446
|
name: string;
|
|
447
|
+
psdModel: "BLUE" | "STAX";
|
|
447
448
|
pubKey: string;
|
|
448
449
|
role: "SHARED_OWNER";
|
|
449
|
-
psdModel: "BLUE" | "STAX";
|
|
450
450
|
registrationChallenge: {
|
|
451
|
-
requestId: string;
|
|
452
|
-
challenge: string;
|
|
453
451
|
handshake: string;
|
|
454
452
|
handshakeAttestation: {
|
|
455
|
-
signature: string;
|
|
456
453
|
codeHash: string;
|
|
457
454
|
attestationPub: string;
|
|
458
455
|
certificate: string;
|
|
456
|
+
signature: string;
|
|
459
457
|
};
|
|
458
|
+
challenge: string;
|
|
460
459
|
ephemeralPublicKey: string;
|
|
461
460
|
ephemeralPublicKeyAttestation: {
|
|
462
|
-
signature: string;
|
|
463
461
|
codeHash: string;
|
|
464
462
|
attestationPub: string;
|
|
465
463
|
certificate: string;
|
|
464
|
+
signature: string;
|
|
466
465
|
};
|
|
467
466
|
u2fRegisterData: string;
|
|
468
467
|
ciphertext: string;
|
|
468
|
+
requestId: string;
|
|
469
469
|
};
|
|
470
470
|
registrationResponse: {
|
|
471
|
-
u2fKeyHandle: string;
|
|
472
471
|
certificate: {
|
|
473
|
-
signature: string;
|
|
474
472
|
codeHash: string;
|
|
475
473
|
attestationPub: string;
|
|
476
474
|
certificate: string;
|
|
475
|
+
signature: string;
|
|
477
476
|
};
|
|
478
477
|
u2fRegister: string;
|
|
478
|
+
u2fKeyHandle: string;
|
|
479
479
|
registerData: string;
|
|
480
480
|
validationKey: string;
|
|
481
481
|
pairingPayload: string;
|
|
@@ -483,38 +483,38 @@ declare const STEPS: {
|
|
|
483
483
|
review: {
|
|
484
484
|
seedChallenge: {
|
|
485
485
|
blob: string;
|
|
486
|
-
challengeType: "PSD";
|
|
487
486
|
certificate: {
|
|
488
|
-
signature: string;
|
|
489
487
|
codeHash: string;
|
|
490
488
|
attestationPub: string;
|
|
491
489
|
certificate: string;
|
|
490
|
+
signature: string;
|
|
492
491
|
};
|
|
492
|
+
challengeType: "PSD";
|
|
493
493
|
wActions: string[];
|
|
494
494
|
handshake: string;
|
|
495
495
|
handshakeAttestation: {
|
|
496
|
-
signature: string;
|
|
497
496
|
codeHash: string;
|
|
498
497
|
attestationPub: string;
|
|
499
498
|
certificate: string;
|
|
499
|
+
signature: string;
|
|
500
500
|
};
|
|
501
501
|
partitionId: string;
|
|
502
502
|
ephemeralPublicKey: string;
|
|
503
503
|
kkHandshake: string;
|
|
504
504
|
kkHandshakeAttestation: {
|
|
505
|
-
signature: string;
|
|
506
505
|
codeHash: string;
|
|
507
506
|
attestationPub: string;
|
|
508
507
|
certificate: string;
|
|
508
|
+
signature: string;
|
|
509
509
|
};
|
|
510
510
|
};
|
|
511
511
|
seedFragment: {
|
|
512
512
|
handshake: string;
|
|
513
513
|
handshakeAttestation: {
|
|
514
|
-
signature: string;
|
|
515
514
|
codeHash: string;
|
|
516
515
|
attestationPub: string;
|
|
517
516
|
certificate: string;
|
|
517
|
+
signature: string;
|
|
518
518
|
};
|
|
519
519
|
approverBlob: string;
|
|
520
520
|
challengeResponse: string;
|
|
@@ -529,26 +529,26 @@ declare const STEPS: {
|
|
|
529
529
|
engine: Engine<WithOnboarding>;
|
|
530
530
|
state: OnboardingFullStateResponse;
|
|
531
531
|
}, logger: Logger) => Promise<{
|
|
532
|
-
id: string;
|
|
533
532
|
workspaceName: string;
|
|
533
|
+
id: string;
|
|
534
534
|
createdAt: Date;
|
|
535
535
|
wrappingKey: {
|
|
536
536
|
ephemeralPubKey: string;
|
|
537
537
|
ephemeralCertificate: {
|
|
538
|
-
signature: string;
|
|
539
538
|
codeHash: string;
|
|
540
539
|
attestationPub: string;
|
|
541
540
|
certificate: string;
|
|
541
|
+
signature: string;
|
|
542
542
|
};
|
|
543
543
|
fragments: {
|
|
544
|
-
pubKey: string;
|
|
545
544
|
blob: string;
|
|
545
|
+
pubKey: string;
|
|
546
546
|
ephemeralPubKey: string;
|
|
547
547
|
ephemeralCertificate: {
|
|
548
|
-
signature: string;
|
|
549
548
|
codeHash: string;
|
|
550
549
|
attestationPub: string;
|
|
551
550
|
certificate: string;
|
|
551
|
+
signature: string;
|
|
552
552
|
};
|
|
553
553
|
}[];
|
|
554
554
|
} | null;
|
|
@@ -556,98 +556,98 @@ declare const STEPS: {
|
|
|
556
556
|
completedAt: Date | null;
|
|
557
557
|
claimedDevices: {
|
|
558
558
|
pubKey: string;
|
|
559
|
+
role: "SHARED_OWNER" | "WRAPPING_KEY_OWNER" | "MASTER_ADMIN";
|
|
559
560
|
deviceUserId: string;
|
|
560
|
-
role: "WRAPPING_KEY_OWNER" | "SHARED_OWNER" | "MASTER_ADMIN";
|
|
561
561
|
deviceName: string;
|
|
562
562
|
}[];
|
|
563
563
|
masterAdmins: {
|
|
564
564
|
name: string;
|
|
565
|
+
psdModel: "BLUE" | "STAX";
|
|
565
566
|
pubKey: string;
|
|
566
567
|
role: "MASTER_ADMIN";
|
|
567
|
-
psdModel: "BLUE" | "STAX";
|
|
568
568
|
registrationChallenge: {
|
|
569
|
-
requestId: string;
|
|
570
|
-
challenge: string;
|
|
571
569
|
handshake: string;
|
|
572
570
|
handshakeAttestation: {
|
|
573
|
-
signature: string;
|
|
574
571
|
codeHash: string;
|
|
575
572
|
attestationPub: string;
|
|
576
573
|
certificate: string;
|
|
574
|
+
signature: string;
|
|
577
575
|
};
|
|
576
|
+
challenge: string;
|
|
578
577
|
ephemeralPublicKey: string;
|
|
579
578
|
ephemeralPublicKeyAttestation: {
|
|
580
|
-
signature: string;
|
|
581
579
|
codeHash: string;
|
|
582
580
|
attestationPub: string;
|
|
583
581
|
certificate: string;
|
|
582
|
+
signature: string;
|
|
584
583
|
};
|
|
585
584
|
u2fRegisterData: string;
|
|
586
585
|
ciphertext: string;
|
|
586
|
+
requestId: string;
|
|
587
587
|
};
|
|
588
588
|
registrationResponse: {
|
|
589
|
-
u2fKeyHandle: string;
|
|
590
589
|
certificate: {
|
|
591
|
-
signature: string;
|
|
592
590
|
codeHash: string;
|
|
593
591
|
attestationPub: string;
|
|
594
592
|
certificate: string;
|
|
593
|
+
signature: string;
|
|
595
594
|
};
|
|
596
595
|
u2fRegister: string;
|
|
596
|
+
u2fKeyHandle: string;
|
|
597
597
|
registerData: string;
|
|
598
598
|
validationKey: string;
|
|
599
599
|
pairingPayload: string;
|
|
600
600
|
} | null;
|
|
601
601
|
review: {
|
|
602
|
+
signature: string | null;
|
|
602
603
|
challenge: {
|
|
603
604
|
challengeType: "PSD";
|
|
604
605
|
wActions: string[];
|
|
605
606
|
handshake: string;
|
|
606
607
|
handshakeAttestation: {
|
|
607
|
-
signature: string;
|
|
608
608
|
codeHash: string;
|
|
609
609
|
attestationPub: string;
|
|
610
610
|
certificate: string;
|
|
611
|
+
signature: string;
|
|
611
612
|
};
|
|
612
613
|
partitionId: string;
|
|
613
614
|
};
|
|
614
|
-
signature: string | null;
|
|
615
615
|
} | null;
|
|
616
616
|
}[];
|
|
617
617
|
sharedOwners: {
|
|
618
618
|
name: string;
|
|
619
|
+
psdModel: "BLUE" | "STAX";
|
|
619
620
|
pubKey: string;
|
|
620
621
|
role: "SHARED_OWNER";
|
|
621
|
-
psdModel: "BLUE" | "STAX";
|
|
622
622
|
registrationChallenge: {
|
|
623
|
-
requestId: string;
|
|
624
|
-
challenge: string;
|
|
625
623
|
handshake: string;
|
|
626
624
|
handshakeAttestation: {
|
|
627
|
-
signature: string;
|
|
628
625
|
codeHash: string;
|
|
629
626
|
attestationPub: string;
|
|
630
627
|
certificate: string;
|
|
628
|
+
signature: string;
|
|
631
629
|
};
|
|
630
|
+
challenge: string;
|
|
632
631
|
ephemeralPublicKey: string;
|
|
633
632
|
ephemeralPublicKeyAttestation: {
|
|
634
|
-
signature: string;
|
|
635
633
|
codeHash: string;
|
|
636
634
|
attestationPub: string;
|
|
637
635
|
certificate: string;
|
|
636
|
+
signature: string;
|
|
638
637
|
};
|
|
639
638
|
u2fRegisterData: string;
|
|
640
639
|
ciphertext: string;
|
|
640
|
+
requestId: string;
|
|
641
641
|
};
|
|
642
642
|
registrationResponse: {
|
|
643
|
-
u2fKeyHandle: string;
|
|
644
643
|
certificate: {
|
|
645
|
-
signature: string;
|
|
646
644
|
codeHash: string;
|
|
647
645
|
attestationPub: string;
|
|
648
646
|
certificate: string;
|
|
647
|
+
signature: string;
|
|
649
648
|
};
|
|
650
649
|
u2fRegister: string;
|
|
650
|
+
u2fKeyHandle: string;
|
|
651
651
|
registerData: string;
|
|
652
652
|
validationKey: string;
|
|
653
653
|
pairingPayload: string;
|
|
@@ -655,38 +655,38 @@ declare const STEPS: {
|
|
|
655
655
|
review: {
|
|
656
656
|
seedChallenge: {
|
|
657
657
|
blob: string;
|
|
658
|
-
challengeType: "PSD";
|
|
659
658
|
certificate: {
|
|
660
|
-
signature: string;
|
|
661
659
|
codeHash: string;
|
|
662
660
|
attestationPub: string;
|
|
663
661
|
certificate: string;
|
|
662
|
+
signature: string;
|
|
664
663
|
};
|
|
664
|
+
challengeType: "PSD";
|
|
665
665
|
wActions: string[];
|
|
666
666
|
handshake: string;
|
|
667
667
|
handshakeAttestation: {
|
|
668
|
-
signature: string;
|
|
669
668
|
codeHash: string;
|
|
670
669
|
attestationPub: string;
|
|
671
670
|
certificate: string;
|
|
671
|
+
signature: string;
|
|
672
672
|
};
|
|
673
673
|
partitionId: string;
|
|
674
674
|
ephemeralPublicKey: string;
|
|
675
675
|
kkHandshake: string;
|
|
676
676
|
kkHandshakeAttestation: {
|
|
677
|
-
signature: string;
|
|
678
677
|
codeHash: string;
|
|
679
678
|
attestationPub: string;
|
|
680
679
|
certificate: string;
|
|
680
|
+
signature: string;
|
|
681
681
|
};
|
|
682
682
|
};
|
|
683
683
|
seedFragment: {
|
|
684
684
|
handshake: string;
|
|
685
685
|
handshakeAttestation: {
|
|
686
|
-
signature: string;
|
|
687
686
|
codeHash: string;
|
|
688
687
|
attestationPub: string;
|
|
689
688
|
certificate: string;
|
|
689
|
+
signature: string;
|
|
690
690
|
};
|
|
691
691
|
approverBlob: string;
|
|
692
692
|
challengeResponse: string;
|
|
@@ -701,26 +701,26 @@ declare const STEPS: {
|
|
|
701
701
|
engine: Engine<WithOnboarding>;
|
|
702
702
|
state: OnboardingFullStateResponse;
|
|
703
703
|
}) => Promise<{
|
|
704
|
-
id: string;
|
|
705
704
|
workspaceName: string;
|
|
705
|
+
id: string;
|
|
706
706
|
createdAt: Date;
|
|
707
707
|
wrappingKey: {
|
|
708
708
|
ephemeralPubKey: string;
|
|
709
709
|
ephemeralCertificate: {
|
|
710
|
-
signature: string;
|
|
711
710
|
codeHash: string;
|
|
712
711
|
attestationPub: string;
|
|
713
712
|
certificate: string;
|
|
713
|
+
signature: string;
|
|
714
714
|
};
|
|
715
715
|
fragments: {
|
|
716
|
-
pubKey: string;
|
|
717
716
|
blob: string;
|
|
717
|
+
pubKey: string;
|
|
718
718
|
ephemeralPubKey: string;
|
|
719
719
|
ephemeralCertificate: {
|
|
720
|
-
signature: string;
|
|
721
720
|
codeHash: string;
|
|
722
721
|
attestationPub: string;
|
|
723
722
|
certificate: string;
|
|
723
|
+
signature: string;
|
|
724
724
|
};
|
|
725
725
|
}[];
|
|
726
726
|
} | null;
|
|
@@ -728,98 +728,98 @@ declare const STEPS: {
|
|
|
728
728
|
completedAt: Date | null;
|
|
729
729
|
claimedDevices: {
|
|
730
730
|
pubKey: string;
|
|
731
|
+
role: "SHARED_OWNER" | "WRAPPING_KEY_OWNER" | "MASTER_ADMIN";
|
|
731
732
|
deviceUserId: string;
|
|
732
|
-
role: "WRAPPING_KEY_OWNER" | "SHARED_OWNER" | "MASTER_ADMIN";
|
|
733
733
|
deviceName: string;
|
|
734
734
|
}[];
|
|
735
735
|
masterAdmins: {
|
|
736
736
|
name: string;
|
|
737
|
+
psdModel: "BLUE" | "STAX";
|
|
737
738
|
pubKey: string;
|
|
738
739
|
role: "MASTER_ADMIN";
|
|
739
|
-
psdModel: "BLUE" | "STAX";
|
|
740
740
|
registrationChallenge: {
|
|
741
|
-
requestId: string;
|
|
742
|
-
challenge: string;
|
|
743
741
|
handshake: string;
|
|
744
742
|
handshakeAttestation: {
|
|
745
|
-
signature: string;
|
|
746
743
|
codeHash: string;
|
|
747
744
|
attestationPub: string;
|
|
748
745
|
certificate: string;
|
|
746
|
+
signature: string;
|
|
749
747
|
};
|
|
748
|
+
challenge: string;
|
|
750
749
|
ephemeralPublicKey: string;
|
|
751
750
|
ephemeralPublicKeyAttestation: {
|
|
752
|
-
signature: string;
|
|
753
751
|
codeHash: string;
|
|
754
752
|
attestationPub: string;
|
|
755
753
|
certificate: string;
|
|
754
|
+
signature: string;
|
|
756
755
|
};
|
|
757
756
|
u2fRegisterData: string;
|
|
758
757
|
ciphertext: string;
|
|
758
|
+
requestId: string;
|
|
759
759
|
};
|
|
760
760
|
registrationResponse: {
|
|
761
|
-
u2fKeyHandle: string;
|
|
762
761
|
certificate: {
|
|
763
|
-
signature: string;
|
|
764
762
|
codeHash: string;
|
|
765
763
|
attestationPub: string;
|
|
766
764
|
certificate: string;
|
|
765
|
+
signature: string;
|
|
767
766
|
};
|
|
768
767
|
u2fRegister: string;
|
|
768
|
+
u2fKeyHandle: string;
|
|
769
769
|
registerData: string;
|
|
770
770
|
validationKey: string;
|
|
771
771
|
pairingPayload: string;
|
|
772
772
|
} | null;
|
|
773
773
|
review: {
|
|
774
|
+
signature: string | null;
|
|
774
775
|
challenge: {
|
|
775
776
|
challengeType: "PSD";
|
|
776
777
|
wActions: string[];
|
|
777
778
|
handshake: string;
|
|
778
779
|
handshakeAttestation: {
|
|
779
|
-
signature: string;
|
|
780
780
|
codeHash: string;
|
|
781
781
|
attestationPub: string;
|
|
782
782
|
certificate: string;
|
|
783
|
+
signature: string;
|
|
783
784
|
};
|
|
784
785
|
partitionId: string;
|
|
785
786
|
};
|
|
786
|
-
signature: string | null;
|
|
787
787
|
} | null;
|
|
788
788
|
}[];
|
|
789
789
|
sharedOwners: {
|
|
790
790
|
name: string;
|
|
791
|
+
psdModel: "BLUE" | "STAX";
|
|
791
792
|
pubKey: string;
|
|
792
793
|
role: "SHARED_OWNER";
|
|
793
|
-
psdModel: "BLUE" | "STAX";
|
|
794
794
|
registrationChallenge: {
|
|
795
|
-
requestId: string;
|
|
796
|
-
challenge: string;
|
|
797
795
|
handshake: string;
|
|
798
796
|
handshakeAttestation: {
|
|
799
|
-
signature: string;
|
|
800
797
|
codeHash: string;
|
|
801
798
|
attestationPub: string;
|
|
802
799
|
certificate: string;
|
|
800
|
+
signature: string;
|
|
803
801
|
};
|
|
802
|
+
challenge: string;
|
|
804
803
|
ephemeralPublicKey: string;
|
|
805
804
|
ephemeralPublicKeyAttestation: {
|
|
806
|
-
signature: string;
|
|
807
805
|
codeHash: string;
|
|
808
806
|
attestationPub: string;
|
|
809
807
|
certificate: string;
|
|
808
|
+
signature: string;
|
|
810
809
|
};
|
|
811
810
|
u2fRegisterData: string;
|
|
812
811
|
ciphertext: string;
|
|
812
|
+
requestId: string;
|
|
813
813
|
};
|
|
814
814
|
registrationResponse: {
|
|
815
|
-
u2fKeyHandle: string;
|
|
816
815
|
certificate: {
|
|
817
|
-
signature: string;
|
|
818
816
|
codeHash: string;
|
|
819
817
|
attestationPub: string;
|
|
820
818
|
certificate: string;
|
|
819
|
+
signature: string;
|
|
821
820
|
};
|
|
822
821
|
u2fRegister: string;
|
|
822
|
+
u2fKeyHandle: string;
|
|
823
823
|
registerData: string;
|
|
824
824
|
validationKey: string;
|
|
825
825
|
pairingPayload: string;
|
|
@@ -827,38 +827,38 @@ declare const STEPS: {
|
|
|
827
827
|
review: {
|
|
828
828
|
seedChallenge: {
|
|
829
829
|
blob: string;
|
|
830
|
-
challengeType: "PSD";
|
|
831
830
|
certificate: {
|
|
832
|
-
signature: string;
|
|
833
831
|
codeHash: string;
|
|
834
832
|
attestationPub: string;
|
|
835
833
|
certificate: string;
|
|
834
|
+
signature: string;
|
|
836
835
|
};
|
|
836
|
+
challengeType: "PSD";
|
|
837
837
|
wActions: string[];
|
|
838
838
|
handshake: string;
|
|
839
839
|
handshakeAttestation: {
|
|
840
|
-
signature: string;
|
|
841
840
|
codeHash: string;
|
|
842
841
|
attestationPub: string;
|
|
843
842
|
certificate: string;
|
|
843
|
+
signature: string;
|
|
844
844
|
};
|
|
845
845
|
partitionId: string;
|
|
846
846
|
ephemeralPublicKey: string;
|
|
847
847
|
kkHandshake: string;
|
|
848
848
|
kkHandshakeAttestation: {
|
|
849
|
-
signature: string;
|
|
850
849
|
codeHash: string;
|
|
851
850
|
attestationPub: string;
|
|
852
851
|
certificate: string;
|
|
852
|
+
signature: string;
|
|
853
853
|
};
|
|
854
854
|
};
|
|
855
855
|
seedFragment: {
|
|
856
856
|
handshake: string;
|
|
857
857
|
handshakeAttestation: {
|
|
858
|
-
signature: string;
|
|
859
858
|
codeHash: string;
|
|
860
859
|
attestationPub: string;
|
|
861
860
|
certificate: string;
|
|
861
|
+
signature: string;
|
|
862
862
|
};
|
|
863
863
|
approverBlob: string;
|
|
864
864
|
challengeResponse: string;
|
|
@@ -873,26 +873,26 @@ declare const STEPS: {
|
|
|
873
873
|
engine: Engine<WithOnboarding>;
|
|
874
874
|
state: OnboardingFullStateResponse;
|
|
875
875
|
}, logger: Logger) => Promise<{
|
|
876
|
-
id: string;
|
|
877
876
|
workspaceName: string;
|
|
877
|
+
id: string;
|
|
878
878
|
createdAt: Date;
|
|
879
879
|
wrappingKey: {
|
|
880
880
|
ephemeralPubKey: string;
|
|
881
881
|
ephemeralCertificate: {
|
|
882
|
-
signature: string;
|
|
883
882
|
codeHash: string;
|
|
884
883
|
attestationPub: string;
|
|
885
884
|
certificate: string;
|
|
885
|
+
signature: string;
|
|
886
886
|
};
|
|
887
887
|
fragments: {
|
|
888
|
-
pubKey: string;
|
|
889
888
|
blob: string;
|
|
889
|
+
pubKey: string;
|
|
890
890
|
ephemeralPubKey: string;
|
|
891
891
|
ephemeralCertificate: {
|
|
892
|
-
signature: string;
|
|
893
892
|
codeHash: string;
|
|
894
893
|
attestationPub: string;
|
|
895
894
|
certificate: string;
|
|
895
|
+
signature: string;
|
|
896
896
|
};
|
|
897
897
|
}[];
|
|
898
898
|
} | null;
|
|
@@ -900,98 +900,98 @@ declare const STEPS: {
|
|
|
900
900
|
completedAt: Date | null;
|
|
901
901
|
claimedDevices: {
|
|
902
902
|
pubKey: string;
|
|
903
|
+
role: "SHARED_OWNER" | "WRAPPING_KEY_OWNER" | "MASTER_ADMIN";
|
|
903
904
|
deviceUserId: string;
|
|
904
|
-
role: "WRAPPING_KEY_OWNER" | "SHARED_OWNER" | "MASTER_ADMIN";
|
|
905
905
|
deviceName: string;
|
|
906
906
|
}[];
|
|
907
907
|
masterAdmins: {
|
|
908
908
|
name: string;
|
|
909
|
+
psdModel: "BLUE" | "STAX";
|
|
909
910
|
pubKey: string;
|
|
910
911
|
role: "MASTER_ADMIN";
|
|
911
|
-
psdModel: "BLUE" | "STAX";
|
|
912
912
|
registrationChallenge: {
|
|
913
|
-
requestId: string;
|
|
914
|
-
challenge: string;
|
|
915
913
|
handshake: string;
|
|
916
914
|
handshakeAttestation: {
|
|
917
|
-
signature: string;
|
|
918
915
|
codeHash: string;
|
|
919
916
|
attestationPub: string;
|
|
920
917
|
certificate: string;
|
|
918
|
+
signature: string;
|
|
921
919
|
};
|
|
920
|
+
challenge: string;
|
|
922
921
|
ephemeralPublicKey: string;
|
|
923
922
|
ephemeralPublicKeyAttestation: {
|
|
924
|
-
signature: string;
|
|
925
923
|
codeHash: string;
|
|
926
924
|
attestationPub: string;
|
|
927
925
|
certificate: string;
|
|
926
|
+
signature: string;
|
|
928
927
|
};
|
|
929
928
|
u2fRegisterData: string;
|
|
930
929
|
ciphertext: string;
|
|
930
|
+
requestId: string;
|
|
931
931
|
};
|
|
932
932
|
registrationResponse: {
|
|
933
|
-
u2fKeyHandle: string;
|
|
934
933
|
certificate: {
|
|
935
|
-
signature: string;
|
|
936
934
|
codeHash: string;
|
|
937
935
|
attestationPub: string;
|
|
938
936
|
certificate: string;
|
|
937
|
+
signature: string;
|
|
939
938
|
};
|
|
940
939
|
u2fRegister: string;
|
|
940
|
+
u2fKeyHandle: string;
|
|
941
941
|
registerData: string;
|
|
942
942
|
validationKey: string;
|
|
943
943
|
pairingPayload: string;
|
|
944
944
|
} | null;
|
|
945
945
|
review: {
|
|
946
|
+
signature: string | null;
|
|
946
947
|
challenge: {
|
|
947
948
|
challengeType: "PSD";
|
|
948
949
|
wActions: string[];
|
|
949
950
|
handshake: string;
|
|
950
951
|
handshakeAttestation: {
|
|
951
|
-
signature: string;
|
|
952
952
|
codeHash: string;
|
|
953
953
|
attestationPub: string;
|
|
954
954
|
certificate: string;
|
|
955
|
+
signature: string;
|
|
955
956
|
};
|
|
956
957
|
partitionId: string;
|
|
957
958
|
};
|
|
958
|
-
signature: string | null;
|
|
959
959
|
} | null;
|
|
960
960
|
}[];
|
|
961
961
|
sharedOwners: {
|
|
962
962
|
name: string;
|
|
963
|
+
psdModel: "BLUE" | "STAX";
|
|
963
964
|
pubKey: string;
|
|
964
965
|
role: "SHARED_OWNER";
|
|
965
|
-
psdModel: "BLUE" | "STAX";
|
|
966
966
|
registrationChallenge: {
|
|
967
|
-
requestId: string;
|
|
968
|
-
challenge: string;
|
|
969
967
|
handshake: string;
|
|
970
968
|
handshakeAttestation: {
|
|
971
|
-
signature: string;
|
|
972
969
|
codeHash: string;
|
|
973
970
|
attestationPub: string;
|
|
974
971
|
certificate: string;
|
|
972
|
+
signature: string;
|
|
975
973
|
};
|
|
974
|
+
challenge: string;
|
|
976
975
|
ephemeralPublicKey: string;
|
|
977
976
|
ephemeralPublicKeyAttestation: {
|
|
978
|
-
signature: string;
|
|
979
977
|
codeHash: string;
|
|
980
978
|
attestationPub: string;
|
|
981
979
|
certificate: string;
|
|
980
|
+
signature: string;
|
|
982
981
|
};
|
|
983
982
|
u2fRegisterData: string;
|
|
984
983
|
ciphertext: string;
|
|
984
|
+
requestId: string;
|
|
985
985
|
};
|
|
986
986
|
registrationResponse: {
|
|
987
|
-
u2fKeyHandle: string;
|
|
988
987
|
certificate: {
|
|
989
|
-
signature: string;
|
|
990
988
|
codeHash: string;
|
|
991
989
|
attestationPub: string;
|
|
992
990
|
certificate: string;
|
|
991
|
+
signature: string;
|
|
993
992
|
};
|
|
994
993
|
u2fRegister: string;
|
|
994
|
+
u2fKeyHandle: string;
|
|
995
995
|
registerData: string;
|
|
996
996
|
validationKey: string;
|
|
997
997
|
pairingPayload: string;
|
|
@@ -999,38 +999,38 @@ declare const STEPS: {
|
|
|
999
999
|
review: {
|
|
1000
1000
|
seedChallenge: {
|
|
1001
1001
|
blob: string;
|
|
1002
|
-
challengeType: "PSD";
|
|
1003
1002
|
certificate: {
|
|
1004
|
-
signature: string;
|
|
1005
1003
|
codeHash: string;
|
|
1006
1004
|
attestationPub: string;
|
|
1007
1005
|
certificate: string;
|
|
1006
|
+
signature: string;
|
|
1008
1007
|
};
|
|
1008
|
+
challengeType: "PSD";
|
|
1009
1009
|
wActions: string[];
|
|
1010
1010
|
handshake: string;
|
|
1011
1011
|
handshakeAttestation: {
|
|
1012
|
-
signature: string;
|
|
1013
1012
|
codeHash: string;
|
|
1014
1013
|
attestationPub: string;
|
|
1015
1014
|
certificate: string;
|
|
1015
|
+
signature: string;
|
|
1016
1016
|
};
|
|
1017
1017
|
partitionId: string;
|
|
1018
1018
|
ephemeralPublicKey: string;
|
|
1019
1019
|
kkHandshake: string;
|
|
1020
1020
|
kkHandshakeAttestation: {
|
|
1021
|
-
signature: string;
|
|
1022
1021
|
codeHash: string;
|
|
1023
1022
|
attestationPub: string;
|
|
1024
1023
|
certificate: string;
|
|
1024
|
+
signature: string;
|
|
1025
1025
|
};
|
|
1026
1026
|
};
|
|
1027
1027
|
seedFragment: {
|
|
1028
1028
|
handshake: string;
|
|
1029
1029
|
handshakeAttestation: {
|
|
1030
|
-
signature: string;
|
|
1031
1030
|
codeHash: string;
|
|
1032
1031
|
attestationPub: string;
|
|
1033
1032
|
certificate: string;
|
|
1033
|
+
signature: string;
|
|
1034
1034
|
};
|
|
1035
1035
|
approverBlob: string;
|
|
1036
1036
|
challengeResponse: string;
|
|
@@ -1045,26 +1045,26 @@ declare const STEPS: {
|
|
|
1045
1045
|
engine: Engine<WithOnboarding>;
|
|
1046
1046
|
state: OnboardingFullStateResponse;
|
|
1047
1047
|
}, logger: Logger) => Promise<{
|
|
1048
|
-
id: string;
|
|
1049
1048
|
workspaceName: string;
|
|
1049
|
+
id: string;
|
|
1050
1050
|
createdAt: Date;
|
|
1051
1051
|
wrappingKey: {
|
|
1052
1052
|
ephemeralPubKey: string;
|
|
1053
1053
|
ephemeralCertificate: {
|
|
1054
|
-
signature: string;
|
|
1055
1054
|
codeHash: string;
|
|
1056
1055
|
attestationPub: string;
|
|
1057
1056
|
certificate: string;
|
|
1057
|
+
signature: string;
|
|
1058
1058
|
};
|
|
1059
1059
|
fragments: {
|
|
1060
|
-
pubKey: string;
|
|
1061
1060
|
blob: string;
|
|
1061
|
+
pubKey: string;
|
|
1062
1062
|
ephemeralPubKey: string;
|
|
1063
1063
|
ephemeralCertificate: {
|
|
1064
|
-
signature: string;
|
|
1065
1064
|
codeHash: string;
|
|
1066
1065
|
attestationPub: string;
|
|
1067
1066
|
certificate: string;
|
|
1067
|
+
signature: string;
|
|
1068
1068
|
};
|
|
1069
1069
|
}[];
|
|
1070
1070
|
} | null;
|
|
@@ -1072,98 +1072,98 @@ declare const STEPS: {
|
|
|
1072
1072
|
completedAt: Date | null;
|
|
1073
1073
|
claimedDevices: {
|
|
1074
1074
|
pubKey: string;
|
|
1075
|
+
role: "SHARED_OWNER" | "WRAPPING_KEY_OWNER" | "MASTER_ADMIN";
|
|
1075
1076
|
deviceUserId: string;
|
|
1076
|
-
role: "WRAPPING_KEY_OWNER" | "SHARED_OWNER" | "MASTER_ADMIN";
|
|
1077
1077
|
deviceName: string;
|
|
1078
1078
|
}[];
|
|
1079
1079
|
masterAdmins: {
|
|
1080
1080
|
name: string;
|
|
1081
|
+
psdModel: "BLUE" | "STAX";
|
|
1081
1082
|
pubKey: string;
|
|
1082
1083
|
role: "MASTER_ADMIN";
|
|
1083
|
-
psdModel: "BLUE" | "STAX";
|
|
1084
1084
|
registrationChallenge: {
|
|
1085
|
-
requestId: string;
|
|
1086
|
-
challenge: string;
|
|
1087
1085
|
handshake: string;
|
|
1088
1086
|
handshakeAttestation: {
|
|
1089
|
-
signature: string;
|
|
1090
1087
|
codeHash: string;
|
|
1091
1088
|
attestationPub: string;
|
|
1092
1089
|
certificate: string;
|
|
1090
|
+
signature: string;
|
|
1093
1091
|
};
|
|
1092
|
+
challenge: string;
|
|
1094
1093
|
ephemeralPublicKey: string;
|
|
1095
1094
|
ephemeralPublicKeyAttestation: {
|
|
1096
|
-
signature: string;
|
|
1097
1095
|
codeHash: string;
|
|
1098
1096
|
attestationPub: string;
|
|
1099
1097
|
certificate: string;
|
|
1098
|
+
signature: string;
|
|
1100
1099
|
};
|
|
1101
1100
|
u2fRegisterData: string;
|
|
1102
1101
|
ciphertext: string;
|
|
1102
|
+
requestId: string;
|
|
1103
1103
|
};
|
|
1104
1104
|
registrationResponse: {
|
|
1105
|
-
u2fKeyHandle: string;
|
|
1106
1105
|
certificate: {
|
|
1107
|
-
signature: string;
|
|
1108
1106
|
codeHash: string;
|
|
1109
1107
|
attestationPub: string;
|
|
1110
1108
|
certificate: string;
|
|
1109
|
+
signature: string;
|
|
1111
1110
|
};
|
|
1112
1111
|
u2fRegister: string;
|
|
1112
|
+
u2fKeyHandle: string;
|
|
1113
1113
|
registerData: string;
|
|
1114
1114
|
validationKey: string;
|
|
1115
1115
|
pairingPayload: string;
|
|
1116
1116
|
} | null;
|
|
1117
1117
|
review: {
|
|
1118
|
+
signature: string | null;
|
|
1118
1119
|
challenge: {
|
|
1119
1120
|
challengeType: "PSD";
|
|
1120
1121
|
wActions: string[];
|
|
1121
1122
|
handshake: string;
|
|
1122
1123
|
handshakeAttestation: {
|
|
1123
|
-
signature: string;
|
|
1124
1124
|
codeHash: string;
|
|
1125
1125
|
attestationPub: string;
|
|
1126
1126
|
certificate: string;
|
|
1127
|
+
signature: string;
|
|
1127
1128
|
};
|
|
1128
1129
|
partitionId: string;
|
|
1129
1130
|
};
|
|
1130
|
-
signature: string | null;
|
|
1131
1131
|
} | null;
|
|
1132
1132
|
}[];
|
|
1133
1133
|
sharedOwners: {
|
|
1134
1134
|
name: string;
|
|
1135
|
+
psdModel: "BLUE" | "STAX";
|
|
1135
1136
|
pubKey: string;
|
|
1136
1137
|
role: "SHARED_OWNER";
|
|
1137
|
-
psdModel: "BLUE" | "STAX";
|
|
1138
1138
|
registrationChallenge: {
|
|
1139
|
-
requestId: string;
|
|
1140
|
-
challenge: string;
|
|
1141
1139
|
handshake: string;
|
|
1142
1140
|
handshakeAttestation: {
|
|
1143
|
-
signature: string;
|
|
1144
1141
|
codeHash: string;
|
|
1145
1142
|
attestationPub: string;
|
|
1146
1143
|
certificate: string;
|
|
1144
|
+
signature: string;
|
|
1147
1145
|
};
|
|
1146
|
+
challenge: string;
|
|
1148
1147
|
ephemeralPublicKey: string;
|
|
1149
1148
|
ephemeralPublicKeyAttestation: {
|
|
1150
|
-
signature: string;
|
|
1151
1149
|
codeHash: string;
|
|
1152
1150
|
attestationPub: string;
|
|
1153
1151
|
certificate: string;
|
|
1152
|
+
signature: string;
|
|
1154
1153
|
};
|
|
1155
1154
|
u2fRegisterData: string;
|
|
1156
1155
|
ciphertext: string;
|
|
1156
|
+
requestId: string;
|
|
1157
1157
|
};
|
|
1158
1158
|
registrationResponse: {
|
|
1159
|
-
u2fKeyHandle: string;
|
|
1160
1159
|
certificate: {
|
|
1161
|
-
signature: string;
|
|
1162
1160
|
codeHash: string;
|
|
1163
1161
|
attestationPub: string;
|
|
1164
1162
|
certificate: string;
|
|
1163
|
+
signature: string;
|
|
1165
1164
|
};
|
|
1166
1165
|
u2fRegister: string;
|
|
1166
|
+
u2fKeyHandle: string;
|
|
1167
1167
|
registerData: string;
|
|
1168
1168
|
validationKey: string;
|
|
1169
1169
|
pairingPayload: string;
|
|
@@ -1171,38 +1171,38 @@ declare const STEPS: {
|
|
|
1171
1171
|
review: {
|
|
1172
1172
|
seedChallenge: {
|
|
1173
1173
|
blob: string;
|
|
1174
|
-
challengeType: "PSD";
|
|
1175
1174
|
certificate: {
|
|
1176
|
-
signature: string;
|
|
1177
1175
|
codeHash: string;
|
|
1178
1176
|
attestationPub: string;
|
|
1179
1177
|
certificate: string;
|
|
1178
|
+
signature: string;
|
|
1180
1179
|
};
|
|
1180
|
+
challengeType: "PSD";
|
|
1181
1181
|
wActions: string[];
|
|
1182
1182
|
handshake: string;
|
|
1183
1183
|
handshakeAttestation: {
|
|
1184
|
-
signature: string;
|
|
1185
1184
|
codeHash: string;
|
|
1186
1185
|
attestationPub: string;
|
|
1187
1186
|
certificate: string;
|
|
1187
|
+
signature: string;
|
|
1188
1188
|
};
|
|
1189
1189
|
partitionId: string;
|
|
1190
1190
|
ephemeralPublicKey: string;
|
|
1191
1191
|
kkHandshake: string;
|
|
1192
1192
|
kkHandshakeAttestation: {
|
|
1193
|
-
signature: string;
|
|
1194
1193
|
codeHash: string;
|
|
1195
1194
|
attestationPub: string;
|
|
1196
1195
|
certificate: string;
|
|
1196
|
+
signature: string;
|
|
1197
1197
|
};
|
|
1198
1198
|
};
|
|
1199
1199
|
seedFragment: {
|
|
1200
1200
|
handshake: string;
|
|
1201
1201
|
handshakeAttestation: {
|
|
1202
|
-
signature: string;
|
|
1203
1202
|
codeHash: string;
|
|
1204
1203
|
attestationPub: string;
|
|
1205
1204
|
certificate: string;
|
|
1205
|
+
signature: string;
|
|
1206
1206
|
};
|
|
1207
1207
|
approverBlob: string;
|
|
1208
1208
|
challengeResponse: string;
|
|
@@ -1217,26 +1217,26 @@ declare const STEPS: {
|
|
|
1217
1217
|
engine: Engine<WithOnboarding>;
|
|
1218
1218
|
state: OnboardingFullStateResponse;
|
|
1219
1219
|
}, logger: Logger) => Promise<{
|
|
1220
|
-
id: string;
|
|
1221
1220
|
workspaceName: string;
|
|
1221
|
+
id: string;
|
|
1222
1222
|
createdAt: Date;
|
|
1223
1223
|
wrappingKey: {
|
|
1224
1224
|
ephemeralPubKey: string;
|
|
1225
1225
|
ephemeralCertificate: {
|
|
1226
|
-
signature: string;
|
|
1227
1226
|
codeHash: string;
|
|
1228
1227
|
attestationPub: string;
|
|
1229
1228
|
certificate: string;
|
|
1229
|
+
signature: string;
|
|
1230
1230
|
};
|
|
1231
1231
|
fragments: {
|
|
1232
|
-
pubKey: string;
|
|
1233
1232
|
blob: string;
|
|
1233
|
+
pubKey: string;
|
|
1234
1234
|
ephemeralPubKey: string;
|
|
1235
1235
|
ephemeralCertificate: {
|
|
1236
|
-
signature: string;
|
|
1237
1236
|
codeHash: string;
|
|
1238
1237
|
attestationPub: string;
|
|
1239
1238
|
certificate: string;
|
|
1239
|
+
signature: string;
|
|
1240
1240
|
};
|
|
1241
1241
|
}[];
|
|
1242
1242
|
} | null;
|
|
@@ -1244,98 +1244,98 @@ declare const STEPS: {
|
|
|
1244
1244
|
completedAt: Date | null;
|
|
1245
1245
|
claimedDevices: {
|
|
1246
1246
|
pubKey: string;
|
|
1247
|
+
role: "SHARED_OWNER" | "WRAPPING_KEY_OWNER" | "MASTER_ADMIN";
|
|
1247
1248
|
deviceUserId: string;
|
|
1248
|
-
role: "WRAPPING_KEY_OWNER" | "SHARED_OWNER" | "MASTER_ADMIN";
|
|
1249
1249
|
deviceName: string;
|
|
1250
1250
|
}[];
|
|
1251
1251
|
masterAdmins: {
|
|
1252
1252
|
name: string;
|
|
1253
|
+
psdModel: "BLUE" | "STAX";
|
|
1253
1254
|
pubKey: string;
|
|
1254
1255
|
role: "MASTER_ADMIN";
|
|
1255
|
-
psdModel: "BLUE" | "STAX";
|
|
1256
1256
|
registrationChallenge: {
|
|
1257
|
-
requestId: string;
|
|
1258
|
-
challenge: string;
|
|
1259
1257
|
handshake: string;
|
|
1260
1258
|
handshakeAttestation: {
|
|
1261
|
-
signature: string;
|
|
1262
1259
|
codeHash: string;
|
|
1263
1260
|
attestationPub: string;
|
|
1264
1261
|
certificate: string;
|
|
1262
|
+
signature: string;
|
|
1265
1263
|
};
|
|
1264
|
+
challenge: string;
|
|
1266
1265
|
ephemeralPublicKey: string;
|
|
1267
1266
|
ephemeralPublicKeyAttestation: {
|
|
1268
|
-
signature: string;
|
|
1269
1267
|
codeHash: string;
|
|
1270
1268
|
attestationPub: string;
|
|
1271
1269
|
certificate: string;
|
|
1270
|
+
signature: string;
|
|
1272
1271
|
};
|
|
1273
1272
|
u2fRegisterData: string;
|
|
1274
1273
|
ciphertext: string;
|
|
1274
|
+
requestId: string;
|
|
1275
1275
|
};
|
|
1276
1276
|
registrationResponse: {
|
|
1277
|
-
u2fKeyHandle: string;
|
|
1278
1277
|
certificate: {
|
|
1279
|
-
signature: string;
|
|
1280
1278
|
codeHash: string;
|
|
1281
1279
|
attestationPub: string;
|
|
1282
1280
|
certificate: string;
|
|
1281
|
+
signature: string;
|
|
1283
1282
|
};
|
|
1284
1283
|
u2fRegister: string;
|
|
1284
|
+
u2fKeyHandle: string;
|
|
1285
1285
|
registerData: string;
|
|
1286
1286
|
validationKey: string;
|
|
1287
1287
|
pairingPayload: string;
|
|
1288
1288
|
} | null;
|
|
1289
1289
|
review: {
|
|
1290
|
+
signature: string | null;
|
|
1290
1291
|
challenge: {
|
|
1291
1292
|
challengeType: "PSD";
|
|
1292
1293
|
wActions: string[];
|
|
1293
1294
|
handshake: string;
|
|
1294
1295
|
handshakeAttestation: {
|
|
1295
|
-
signature: string;
|
|
1296
1296
|
codeHash: string;
|
|
1297
1297
|
attestationPub: string;
|
|
1298
1298
|
certificate: string;
|
|
1299
|
+
signature: string;
|
|
1299
1300
|
};
|
|
1300
1301
|
partitionId: string;
|
|
1301
1302
|
};
|
|
1302
|
-
signature: string | null;
|
|
1303
1303
|
} | null;
|
|
1304
1304
|
}[];
|
|
1305
1305
|
sharedOwners: {
|
|
1306
1306
|
name: string;
|
|
1307
|
+
psdModel: "BLUE" | "STAX";
|
|
1307
1308
|
pubKey: string;
|
|
1308
1309
|
role: "SHARED_OWNER";
|
|
1309
|
-
psdModel: "BLUE" | "STAX";
|
|
1310
1310
|
registrationChallenge: {
|
|
1311
|
-
requestId: string;
|
|
1312
|
-
challenge: string;
|
|
1313
1311
|
handshake: string;
|
|
1314
1312
|
handshakeAttestation: {
|
|
1315
|
-
signature: string;
|
|
1316
1313
|
codeHash: string;
|
|
1317
1314
|
attestationPub: string;
|
|
1318
1315
|
certificate: string;
|
|
1316
|
+
signature: string;
|
|
1319
1317
|
};
|
|
1318
|
+
challenge: string;
|
|
1320
1319
|
ephemeralPublicKey: string;
|
|
1321
1320
|
ephemeralPublicKeyAttestation: {
|
|
1322
|
-
signature: string;
|
|
1323
1321
|
codeHash: string;
|
|
1324
1322
|
attestationPub: string;
|
|
1325
1323
|
certificate: string;
|
|
1324
|
+
signature: string;
|
|
1326
1325
|
};
|
|
1327
1326
|
u2fRegisterData: string;
|
|
1328
1327
|
ciphertext: string;
|
|
1328
|
+
requestId: string;
|
|
1329
1329
|
};
|
|
1330
1330
|
registrationResponse: {
|
|
1331
|
-
u2fKeyHandle: string;
|
|
1332
1331
|
certificate: {
|
|
1333
|
-
signature: string;
|
|
1334
1332
|
codeHash: string;
|
|
1335
1333
|
attestationPub: string;
|
|
1336
1334
|
certificate: string;
|
|
1335
|
+
signature: string;
|
|
1337
1336
|
};
|
|
1338
1337
|
u2fRegister: string;
|
|
1338
|
+
u2fKeyHandle: string;
|
|
1339
1339
|
registerData: string;
|
|
1340
1340
|
validationKey: string;
|
|
1341
1341
|
pairingPayload: string;
|
|
@@ -1343,38 +1343,38 @@ declare const STEPS: {
|
|
|
1343
1343
|
review: {
|
|
1344
1344
|
seedChallenge: {
|
|
1345
1345
|
blob: string;
|
|
1346
|
-
challengeType: "PSD";
|
|
1347
1346
|
certificate: {
|
|
1348
|
-
signature: string;
|
|
1349
1347
|
codeHash: string;
|
|
1350
1348
|
attestationPub: string;
|
|
1351
1349
|
certificate: string;
|
|
1350
|
+
signature: string;
|
|
1352
1351
|
};
|
|
1352
|
+
challengeType: "PSD";
|
|
1353
1353
|
wActions: string[];
|
|
1354
1354
|
handshake: string;
|
|
1355
1355
|
handshakeAttestation: {
|
|
1356
|
-
signature: string;
|
|
1357
1356
|
codeHash: string;
|
|
1358
1357
|
attestationPub: string;
|
|
1359
1358
|
certificate: string;
|
|
1359
|
+
signature: string;
|
|
1360
1360
|
};
|
|
1361
1361
|
partitionId: string;
|
|
1362
1362
|
ephemeralPublicKey: string;
|
|
1363
1363
|
kkHandshake: string;
|
|
1364
1364
|
kkHandshakeAttestation: {
|
|
1365
|
-
signature: string;
|
|
1366
1365
|
codeHash: string;
|
|
1367
1366
|
attestationPub: string;
|
|
1368
1367
|
certificate: string;
|
|
1368
|
+
signature: string;
|
|
1369
1369
|
};
|
|
1370
1370
|
};
|
|
1371
1371
|
seedFragment: {
|
|
1372
1372
|
handshake: string;
|
|
1373
1373
|
handshakeAttestation: {
|
|
1374
|
-
signature: string;
|
|
1375
1374
|
codeHash: string;
|
|
1376
1375
|
attestationPub: string;
|
|
1377
1376
|
certificate: string;
|
|
1377
|
+
signature: string;
|
|
1378
1378
|
};
|
|
1379
1379
|
approverBlob: string;
|
|
1380
1380
|
challengeResponse: string;
|
|
@@ -1389,26 +1389,26 @@ declare const STEPS: {
|
|
|
1389
1389
|
engine: Engine<WithOnboarding>;
|
|
1390
1390
|
state: OnboardingFullStateResponse;
|
|
1391
1391
|
}) => Promise<{
|
|
1392
|
-
id: string;
|
|
1393
1392
|
workspaceName: string;
|
|
1393
|
+
id: string;
|
|
1394
1394
|
createdAt: Date;
|
|
1395
1395
|
wrappingKey: {
|
|
1396
1396
|
ephemeralPubKey: string;
|
|
1397
1397
|
ephemeralCertificate: {
|
|
1398
|
-
signature: string;
|
|
1399
1398
|
codeHash: string;
|
|
1400
1399
|
attestationPub: string;
|
|
1401
1400
|
certificate: string;
|
|
1401
|
+
signature: string;
|
|
1402
1402
|
};
|
|
1403
1403
|
fragments: {
|
|
1404
|
-
pubKey: string;
|
|
1405
1404
|
blob: string;
|
|
1405
|
+
pubKey: string;
|
|
1406
1406
|
ephemeralPubKey: string;
|
|
1407
1407
|
ephemeralCertificate: {
|
|
1408
|
-
signature: string;
|
|
1409
1408
|
codeHash: string;
|
|
1410
1409
|
attestationPub: string;
|
|
1411
1410
|
certificate: string;
|
|
1411
|
+
signature: string;
|
|
1412
1412
|
};
|
|
1413
1413
|
}[];
|
|
1414
1414
|
} | null;
|
|
@@ -1416,98 +1416,98 @@ declare const STEPS: {
|
|
|
1416
1416
|
completedAt: Date | null;
|
|
1417
1417
|
claimedDevices: {
|
|
1418
1418
|
pubKey: string;
|
|
1419
|
+
role: "SHARED_OWNER" | "WRAPPING_KEY_OWNER" | "MASTER_ADMIN";
|
|
1419
1420
|
deviceUserId: string;
|
|
1420
|
-
role: "WRAPPING_KEY_OWNER" | "SHARED_OWNER" | "MASTER_ADMIN";
|
|
1421
1421
|
deviceName: string;
|
|
1422
1422
|
}[];
|
|
1423
1423
|
masterAdmins: {
|
|
1424
1424
|
name: string;
|
|
1425
|
+
psdModel: "BLUE" | "STAX";
|
|
1425
1426
|
pubKey: string;
|
|
1426
1427
|
role: "MASTER_ADMIN";
|
|
1427
|
-
psdModel: "BLUE" | "STAX";
|
|
1428
1428
|
registrationChallenge: {
|
|
1429
|
-
requestId: string;
|
|
1430
|
-
challenge: string;
|
|
1431
1429
|
handshake: string;
|
|
1432
1430
|
handshakeAttestation: {
|
|
1433
|
-
signature: string;
|
|
1434
1431
|
codeHash: string;
|
|
1435
1432
|
attestationPub: string;
|
|
1436
1433
|
certificate: string;
|
|
1434
|
+
signature: string;
|
|
1437
1435
|
};
|
|
1436
|
+
challenge: string;
|
|
1438
1437
|
ephemeralPublicKey: string;
|
|
1439
1438
|
ephemeralPublicKeyAttestation: {
|
|
1440
|
-
signature: string;
|
|
1441
1439
|
codeHash: string;
|
|
1442
1440
|
attestationPub: string;
|
|
1443
1441
|
certificate: string;
|
|
1442
|
+
signature: string;
|
|
1444
1443
|
};
|
|
1445
1444
|
u2fRegisterData: string;
|
|
1446
1445
|
ciphertext: string;
|
|
1446
|
+
requestId: string;
|
|
1447
1447
|
};
|
|
1448
1448
|
registrationResponse: {
|
|
1449
|
-
u2fKeyHandle: string;
|
|
1450
1449
|
certificate: {
|
|
1451
|
-
signature: string;
|
|
1452
1450
|
codeHash: string;
|
|
1453
1451
|
attestationPub: string;
|
|
1454
1452
|
certificate: string;
|
|
1453
|
+
signature: string;
|
|
1455
1454
|
};
|
|
1456
1455
|
u2fRegister: string;
|
|
1456
|
+
u2fKeyHandle: string;
|
|
1457
1457
|
registerData: string;
|
|
1458
1458
|
validationKey: string;
|
|
1459
1459
|
pairingPayload: string;
|
|
1460
1460
|
} | null;
|
|
1461
1461
|
review: {
|
|
1462
|
+
signature: string | null;
|
|
1462
1463
|
challenge: {
|
|
1463
1464
|
challengeType: "PSD";
|
|
1464
1465
|
wActions: string[];
|
|
1465
1466
|
handshake: string;
|
|
1466
1467
|
handshakeAttestation: {
|
|
1467
|
-
signature: string;
|
|
1468
1468
|
codeHash: string;
|
|
1469
1469
|
attestationPub: string;
|
|
1470
1470
|
certificate: string;
|
|
1471
|
+
signature: string;
|
|
1471
1472
|
};
|
|
1472
1473
|
partitionId: string;
|
|
1473
1474
|
};
|
|
1474
|
-
signature: string | null;
|
|
1475
1475
|
} | null;
|
|
1476
1476
|
}[];
|
|
1477
1477
|
sharedOwners: {
|
|
1478
1478
|
name: string;
|
|
1479
|
+
psdModel: "BLUE" | "STAX";
|
|
1479
1480
|
pubKey: string;
|
|
1480
1481
|
role: "SHARED_OWNER";
|
|
1481
|
-
psdModel: "BLUE" | "STAX";
|
|
1482
1482
|
registrationChallenge: {
|
|
1483
|
-
requestId: string;
|
|
1484
|
-
challenge: string;
|
|
1485
1483
|
handshake: string;
|
|
1486
1484
|
handshakeAttestation: {
|
|
1487
|
-
signature: string;
|
|
1488
1485
|
codeHash: string;
|
|
1489
1486
|
attestationPub: string;
|
|
1490
1487
|
certificate: string;
|
|
1488
|
+
signature: string;
|
|
1491
1489
|
};
|
|
1490
|
+
challenge: string;
|
|
1492
1491
|
ephemeralPublicKey: string;
|
|
1493
1492
|
ephemeralPublicKeyAttestation: {
|
|
1494
|
-
signature: string;
|
|
1495
1493
|
codeHash: string;
|
|
1496
1494
|
attestationPub: string;
|
|
1497
1495
|
certificate: string;
|
|
1496
|
+
signature: string;
|
|
1498
1497
|
};
|
|
1499
1498
|
u2fRegisterData: string;
|
|
1500
1499
|
ciphertext: string;
|
|
1500
|
+
requestId: string;
|
|
1501
1501
|
};
|
|
1502
1502
|
registrationResponse: {
|
|
1503
|
-
u2fKeyHandle: string;
|
|
1504
1503
|
certificate: {
|
|
1505
|
-
signature: string;
|
|
1506
1504
|
codeHash: string;
|
|
1507
1505
|
attestationPub: string;
|
|
1508
1506
|
certificate: string;
|
|
1507
|
+
signature: string;
|
|
1509
1508
|
};
|
|
1510
1509
|
u2fRegister: string;
|
|
1510
|
+
u2fKeyHandle: string;
|
|
1511
1511
|
registerData: string;
|
|
1512
1512
|
validationKey: string;
|
|
1513
1513
|
pairingPayload: string;
|
|
@@ -1515,38 +1515,38 @@ declare const STEPS: {
|
|
|
1515
1515
|
review: {
|
|
1516
1516
|
seedChallenge: {
|
|
1517
1517
|
blob: string;
|
|
1518
|
-
challengeType: "PSD";
|
|
1519
1518
|
certificate: {
|
|
1520
|
-
signature: string;
|
|
1521
1519
|
codeHash: string;
|
|
1522
1520
|
attestationPub: string;
|
|
1523
1521
|
certificate: string;
|
|
1522
|
+
signature: string;
|
|
1524
1523
|
};
|
|
1524
|
+
challengeType: "PSD";
|
|
1525
1525
|
wActions: string[];
|
|
1526
1526
|
handshake: string;
|
|
1527
1527
|
handshakeAttestation: {
|
|
1528
|
-
signature: string;
|
|
1529
1528
|
codeHash: string;
|
|
1530
1529
|
attestationPub: string;
|
|
1531
1530
|
certificate: string;
|
|
1531
|
+
signature: string;
|
|
1532
1532
|
};
|
|
1533
1533
|
partitionId: string;
|
|
1534
1534
|
ephemeralPublicKey: string;
|
|
1535
1535
|
kkHandshake: string;
|
|
1536
1536
|
kkHandshakeAttestation: {
|
|
1537
|
-
signature: string;
|
|
1538
1537
|
codeHash: string;
|
|
1539
1538
|
attestationPub: string;
|
|
1540
1539
|
certificate: string;
|
|
1540
|
+
signature: string;
|
|
1541
1541
|
};
|
|
1542
1542
|
};
|
|
1543
1543
|
seedFragment: {
|
|
1544
1544
|
handshake: string;
|
|
1545
1545
|
handshakeAttestation: {
|
|
1546
|
-
signature: string;
|
|
1547
1546
|
codeHash: string;
|
|
1548
1547
|
attestationPub: string;
|
|
1549
1548
|
certificate: string;
|
|
1549
|
+
signature: string;
|
|
1550
1550
|
};
|
|
1551
1551
|
approverBlob: string;
|
|
1552
1552
|
challengeResponse: string;
|
|
@@ -1561,26 +1561,26 @@ declare const STEPS: {
|
|
|
1561
1561
|
engine: Engine<WithOnboarding>;
|
|
1562
1562
|
state: OnboardingFullStateResponse;
|
|
1563
1563
|
}) => Promise<{
|
|
1564
|
-
id: string;
|
|
1565
1564
|
workspaceName: string;
|
|
1565
|
+
id: string;
|
|
1566
1566
|
createdAt: Date;
|
|
1567
1567
|
wrappingKey: {
|
|
1568
1568
|
ephemeralPubKey: string;
|
|
1569
1569
|
ephemeralCertificate: {
|
|
1570
|
-
signature: string;
|
|
1571
1570
|
codeHash: string;
|
|
1572
1571
|
attestationPub: string;
|
|
1573
1572
|
certificate: string;
|
|
1573
|
+
signature: string;
|
|
1574
1574
|
};
|
|
1575
1575
|
fragments: {
|
|
1576
|
-
pubKey: string;
|
|
1577
1576
|
blob: string;
|
|
1577
|
+
pubKey: string;
|
|
1578
1578
|
ephemeralPubKey: string;
|
|
1579
1579
|
ephemeralCertificate: {
|
|
1580
|
-
signature: string;
|
|
1581
1580
|
codeHash: string;
|
|
1582
1581
|
attestationPub: string;
|
|
1583
1582
|
certificate: string;
|
|
1583
|
+
signature: string;
|
|
1584
1584
|
};
|
|
1585
1585
|
}[];
|
|
1586
1586
|
} | null;
|
|
@@ -1588,98 +1588,98 @@ declare const STEPS: {
|
|
|
1588
1588
|
completedAt: Date | null;
|
|
1589
1589
|
claimedDevices: {
|
|
1590
1590
|
pubKey: string;
|
|
1591
|
+
role: "SHARED_OWNER" | "WRAPPING_KEY_OWNER" | "MASTER_ADMIN";
|
|
1591
1592
|
deviceUserId: string;
|
|
1592
|
-
role: "WRAPPING_KEY_OWNER" | "SHARED_OWNER" | "MASTER_ADMIN";
|
|
1593
1593
|
deviceName: string;
|
|
1594
1594
|
}[];
|
|
1595
1595
|
masterAdmins: {
|
|
1596
1596
|
name: string;
|
|
1597
|
+
psdModel: "BLUE" | "STAX";
|
|
1597
1598
|
pubKey: string;
|
|
1598
1599
|
role: "MASTER_ADMIN";
|
|
1599
|
-
psdModel: "BLUE" | "STAX";
|
|
1600
1600
|
registrationChallenge: {
|
|
1601
|
-
requestId: string;
|
|
1602
|
-
challenge: string;
|
|
1603
1601
|
handshake: string;
|
|
1604
1602
|
handshakeAttestation: {
|
|
1605
|
-
signature: string;
|
|
1606
1603
|
codeHash: string;
|
|
1607
1604
|
attestationPub: string;
|
|
1608
1605
|
certificate: string;
|
|
1606
|
+
signature: string;
|
|
1609
1607
|
};
|
|
1608
|
+
challenge: string;
|
|
1610
1609
|
ephemeralPublicKey: string;
|
|
1611
1610
|
ephemeralPublicKeyAttestation: {
|
|
1612
|
-
signature: string;
|
|
1613
1611
|
codeHash: string;
|
|
1614
1612
|
attestationPub: string;
|
|
1615
1613
|
certificate: string;
|
|
1614
|
+
signature: string;
|
|
1616
1615
|
};
|
|
1617
1616
|
u2fRegisterData: string;
|
|
1618
1617
|
ciphertext: string;
|
|
1618
|
+
requestId: string;
|
|
1619
1619
|
};
|
|
1620
1620
|
registrationResponse: {
|
|
1621
|
-
u2fKeyHandle: string;
|
|
1622
1621
|
certificate: {
|
|
1623
|
-
signature: string;
|
|
1624
1622
|
codeHash: string;
|
|
1625
1623
|
attestationPub: string;
|
|
1626
1624
|
certificate: string;
|
|
1625
|
+
signature: string;
|
|
1627
1626
|
};
|
|
1628
1627
|
u2fRegister: string;
|
|
1628
|
+
u2fKeyHandle: string;
|
|
1629
1629
|
registerData: string;
|
|
1630
1630
|
validationKey: string;
|
|
1631
1631
|
pairingPayload: string;
|
|
1632
1632
|
} | null;
|
|
1633
1633
|
review: {
|
|
1634
|
+
signature: string | null;
|
|
1634
1635
|
challenge: {
|
|
1635
1636
|
challengeType: "PSD";
|
|
1636
1637
|
wActions: string[];
|
|
1637
1638
|
handshake: string;
|
|
1638
1639
|
handshakeAttestation: {
|
|
1639
|
-
signature: string;
|
|
1640
1640
|
codeHash: string;
|
|
1641
1641
|
attestationPub: string;
|
|
1642
1642
|
certificate: string;
|
|
1643
|
+
signature: string;
|
|
1643
1644
|
};
|
|
1644
1645
|
partitionId: string;
|
|
1645
1646
|
};
|
|
1646
|
-
signature: string | null;
|
|
1647
1647
|
} | null;
|
|
1648
1648
|
}[];
|
|
1649
1649
|
sharedOwners: {
|
|
1650
1650
|
name: string;
|
|
1651
|
+
psdModel: "BLUE" | "STAX";
|
|
1651
1652
|
pubKey: string;
|
|
1652
1653
|
role: "SHARED_OWNER";
|
|
1653
|
-
psdModel: "BLUE" | "STAX";
|
|
1654
1654
|
registrationChallenge: {
|
|
1655
|
-
requestId: string;
|
|
1656
|
-
challenge: string;
|
|
1657
1655
|
handshake: string;
|
|
1658
1656
|
handshakeAttestation: {
|
|
1659
|
-
signature: string;
|
|
1660
1657
|
codeHash: string;
|
|
1661
1658
|
attestationPub: string;
|
|
1662
1659
|
certificate: string;
|
|
1660
|
+
signature: string;
|
|
1663
1661
|
};
|
|
1662
|
+
challenge: string;
|
|
1664
1663
|
ephemeralPublicKey: string;
|
|
1665
1664
|
ephemeralPublicKeyAttestation: {
|
|
1666
|
-
signature: string;
|
|
1667
1665
|
codeHash: string;
|
|
1668
1666
|
attestationPub: string;
|
|
1669
1667
|
certificate: string;
|
|
1668
|
+
signature: string;
|
|
1670
1669
|
};
|
|
1671
1670
|
u2fRegisterData: string;
|
|
1672
1671
|
ciphertext: string;
|
|
1672
|
+
requestId: string;
|
|
1673
1673
|
};
|
|
1674
1674
|
registrationResponse: {
|
|
1675
|
-
u2fKeyHandle: string;
|
|
1676
1675
|
certificate: {
|
|
1677
|
-
signature: string;
|
|
1678
1676
|
codeHash: string;
|
|
1679
1677
|
attestationPub: string;
|
|
1680
1678
|
certificate: string;
|
|
1679
|
+
signature: string;
|
|
1681
1680
|
};
|
|
1682
1681
|
u2fRegister: string;
|
|
1682
|
+
u2fKeyHandle: string;
|
|
1683
1683
|
registerData: string;
|
|
1684
1684
|
validationKey: string;
|
|
1685
1685
|
pairingPayload: string;
|
|
@@ -1687,38 +1687,38 @@ declare const STEPS: {
|
|
|
1687
1687
|
review: {
|
|
1688
1688
|
seedChallenge: {
|
|
1689
1689
|
blob: string;
|
|
1690
|
-
challengeType: "PSD";
|
|
1691
1690
|
certificate: {
|
|
1692
|
-
signature: string;
|
|
1693
1691
|
codeHash: string;
|
|
1694
1692
|
attestationPub: string;
|
|
1695
1693
|
certificate: string;
|
|
1694
|
+
signature: string;
|
|
1696
1695
|
};
|
|
1696
|
+
challengeType: "PSD";
|
|
1697
1697
|
wActions: string[];
|
|
1698
1698
|
handshake: string;
|
|
1699
1699
|
handshakeAttestation: {
|
|
1700
|
-
signature: string;
|
|
1701
1700
|
codeHash: string;
|
|
1702
1701
|
attestationPub: string;
|
|
1703
1702
|
certificate: string;
|
|
1703
|
+
signature: string;
|
|
1704
1704
|
};
|
|
1705
1705
|
partitionId: string;
|
|
1706
1706
|
ephemeralPublicKey: string;
|
|
1707
1707
|
kkHandshake: string;
|
|
1708
1708
|
kkHandshakeAttestation: {
|
|
1709
|
-
signature: string;
|
|
1710
1709
|
codeHash: string;
|
|
1711
1710
|
attestationPub: string;
|
|
1712
1711
|
certificate: string;
|
|
1712
|
+
signature: string;
|
|
1713
1713
|
};
|
|
1714
1714
|
};
|
|
1715
1715
|
seedFragment: {
|
|
1716
1716
|
handshake: string;
|
|
1717
1717
|
handshakeAttestation: {
|
|
1718
|
-
signature: string;
|
|
1719
1718
|
codeHash: string;
|
|
1720
1719
|
attestationPub: string;
|
|
1721
1720
|
certificate: string;
|
|
1721
|
+
signature: string;
|
|
1722
1722
|
};
|
|
1723
1723
|
approverBlob: string;
|
|
1724
1724
|
challengeResponse: string;
|