1package api
2
3import (
4	"context"
5	"errors"
6
7	"github.com/mitchellh/mapstructure"
8)
9
10func (c *Sys) RekeyStatus() (*RekeyStatusResponse, error) {
11	r := c.c.NewRequest("GET", "/v1/sys/rekey/init")
12
13	ctx, cancelFunc := context.WithCancel(context.Background())
14	defer cancelFunc()
15	resp, err := c.c.RawRequestWithContext(ctx, r)
16	if err != nil {
17		return nil, err
18	}
19	defer resp.Body.Close()
20
21	var result RekeyStatusResponse
22	err = resp.DecodeJSON(&result)
23	return &result, err
24}
25
26func (c *Sys) RekeyRecoveryKeyStatus() (*RekeyStatusResponse, error) {
27	r := c.c.NewRequest("GET", "/v1/sys/rekey-recovery-key/init")
28
29	ctx, cancelFunc := context.WithCancel(context.Background())
30	defer cancelFunc()
31	resp, err := c.c.RawRequestWithContext(ctx, r)
32	if err != nil {
33		return nil, err
34	}
35	defer resp.Body.Close()
36
37	var result RekeyStatusResponse
38	err = resp.DecodeJSON(&result)
39	return &result, err
40}
41
42func (c *Sys) RekeyVerificationStatus() (*RekeyVerificationStatusResponse, error) {
43	r := c.c.NewRequest("GET", "/v1/sys/rekey/verify")
44
45	ctx, cancelFunc := context.WithCancel(context.Background())
46	defer cancelFunc()
47	resp, err := c.c.RawRequestWithContext(ctx, r)
48	if err != nil {
49		return nil, err
50	}
51	defer resp.Body.Close()
52
53	var result RekeyVerificationStatusResponse
54	err = resp.DecodeJSON(&result)
55	return &result, err
56}
57
58func (c *Sys) RekeyRecoveryKeyVerificationStatus() (*RekeyVerificationStatusResponse, error) {
59	r := c.c.NewRequest("GET", "/v1/sys/rekey-recovery-key/verify")
60
61	ctx, cancelFunc := context.WithCancel(context.Background())
62	defer cancelFunc()
63	resp, err := c.c.RawRequestWithContext(ctx, r)
64	if err != nil {
65		return nil, err
66	}
67	defer resp.Body.Close()
68
69	var result RekeyVerificationStatusResponse
70	err = resp.DecodeJSON(&result)
71	return &result, err
72}
73
74func (c *Sys) RekeyInit(config *RekeyInitRequest) (*RekeyStatusResponse, error) {
75	r := c.c.NewRequest("PUT", "/v1/sys/rekey/init")
76	if err := r.SetJSONBody(config); err != nil {
77		return nil, err
78	}
79
80	ctx, cancelFunc := context.WithCancel(context.Background())
81	defer cancelFunc()
82	resp, err := c.c.RawRequestWithContext(ctx, r)
83	if err != nil {
84		return nil, err
85	}
86	defer resp.Body.Close()
87
88	var result RekeyStatusResponse
89	err = resp.DecodeJSON(&result)
90	return &result, err
91}
92
93func (c *Sys) RekeyRecoveryKeyInit(config *RekeyInitRequest) (*RekeyStatusResponse, error) {
94	r := c.c.NewRequest("PUT", "/v1/sys/rekey-recovery-key/init")
95	if err := r.SetJSONBody(config); err != nil {
96		return nil, err
97	}
98
99	ctx, cancelFunc := context.WithCancel(context.Background())
100	defer cancelFunc()
101	resp, err := c.c.RawRequestWithContext(ctx, r)
102	if err != nil {
103		return nil, err
104	}
105	defer resp.Body.Close()
106
107	var result RekeyStatusResponse
108	err = resp.DecodeJSON(&result)
109	return &result, err
110}
111
112func (c *Sys) RekeyCancel() error {
113	r := c.c.NewRequest("DELETE", "/v1/sys/rekey/init")
114
115	ctx, cancelFunc := context.WithCancel(context.Background())
116	defer cancelFunc()
117	resp, err := c.c.RawRequestWithContext(ctx, r)
118	if err == nil {
119		defer resp.Body.Close()
120	}
121	return err
122}
123
124func (c *Sys) RekeyRecoveryKeyCancel() error {
125	r := c.c.NewRequest("DELETE", "/v1/sys/rekey-recovery-key/init")
126
127	ctx, cancelFunc := context.WithCancel(context.Background())
128	defer cancelFunc()
129	resp, err := c.c.RawRequestWithContext(ctx, r)
130	if err == nil {
131		defer resp.Body.Close()
132	}
133	return err
134}
135
136func (c *Sys) RekeyVerificationCancel() error {
137	r := c.c.NewRequest("DELETE", "/v1/sys/rekey/verify")
138
139	ctx, cancelFunc := context.WithCancel(context.Background())
140	defer cancelFunc()
141	resp, err := c.c.RawRequestWithContext(ctx, r)
142	if err == nil {
143		defer resp.Body.Close()
144	}
145	return err
146}
147
148func (c *Sys) RekeyRecoveryKeyVerificationCancel() error {
149	r := c.c.NewRequest("DELETE", "/v1/sys/rekey-recovery-key/verify")
150
151	ctx, cancelFunc := context.WithCancel(context.Background())
152	defer cancelFunc()
153	resp, err := c.c.RawRequestWithContext(ctx, r)
154	if err == nil {
155		defer resp.Body.Close()
156	}
157	return err
158}
159
160func (c *Sys) RekeyUpdate(shard, nonce string) (*RekeyUpdateResponse, error) {
161	body := map[string]interface{}{
162		"key":   shard,
163		"nonce": nonce,
164	}
165
166	r := c.c.NewRequest("PUT", "/v1/sys/rekey/update")
167	if err := r.SetJSONBody(body); err != nil {
168		return nil, err
169	}
170
171	ctx, cancelFunc := context.WithCancel(context.Background())
172	defer cancelFunc()
173	resp, err := c.c.RawRequestWithContext(ctx, r)
174	if err != nil {
175		return nil, err
176	}
177	defer resp.Body.Close()
178
179	var result RekeyUpdateResponse
180	err = resp.DecodeJSON(&result)
181	return &result, err
182}
183
184func (c *Sys) RekeyRecoveryKeyUpdate(shard, nonce string) (*RekeyUpdateResponse, error) {
185	body := map[string]interface{}{
186		"key":   shard,
187		"nonce": nonce,
188	}
189
190	r := c.c.NewRequest("PUT", "/v1/sys/rekey-recovery-key/update")
191	if err := r.SetJSONBody(body); err != nil {
192		return nil, err
193	}
194
195	ctx, cancelFunc := context.WithCancel(context.Background())
196	defer cancelFunc()
197	resp, err := c.c.RawRequestWithContext(ctx, r)
198	if err != nil {
199		return nil, err
200	}
201	defer resp.Body.Close()
202
203	var result RekeyUpdateResponse
204	err = resp.DecodeJSON(&result)
205	return &result, err
206}
207
208func (c *Sys) RekeyRetrieveBackup() (*RekeyRetrieveResponse, error) {
209	r := c.c.NewRequest("GET", "/v1/sys/rekey/backup")
210
211	ctx, cancelFunc := context.WithCancel(context.Background())
212	defer cancelFunc()
213	resp, err := c.c.RawRequestWithContext(ctx, r)
214	if err != nil {
215		return nil, err
216	}
217	defer resp.Body.Close()
218
219	secret, err := ParseSecret(resp.Body)
220	if err != nil {
221		return nil, err
222	}
223	if secret == nil || secret.Data == nil {
224		return nil, errors.New("data from server response is empty")
225	}
226
227	var result RekeyRetrieveResponse
228	err = mapstructure.Decode(secret.Data, &result)
229	if err != nil {
230		return nil, err
231	}
232
233	return &result, err
234}
235
236func (c *Sys) RekeyRetrieveRecoveryBackup() (*RekeyRetrieveResponse, error) {
237	r := c.c.NewRequest("GET", "/v1/sys/rekey/recovery-key-backup")
238
239	ctx, cancelFunc := context.WithCancel(context.Background())
240	defer cancelFunc()
241	resp, err := c.c.RawRequestWithContext(ctx, r)
242	if err != nil {
243		return nil, err
244	}
245	defer resp.Body.Close()
246
247	secret, err := ParseSecret(resp.Body)
248	if err != nil {
249		return nil, err
250	}
251	if secret == nil || secret.Data == nil {
252		return nil, errors.New("data from server response is empty")
253	}
254
255	var result RekeyRetrieveResponse
256	err = mapstructure.Decode(secret.Data, &result)
257	if err != nil {
258		return nil, err
259	}
260
261	return &result, err
262}
263
264func (c *Sys) RekeyDeleteBackup() error {
265	r := c.c.NewRequest("DELETE", "/v1/sys/rekey/backup")
266
267	ctx, cancelFunc := context.WithCancel(context.Background())
268	defer cancelFunc()
269	resp, err := c.c.RawRequestWithContext(ctx, r)
270	if err == nil {
271		defer resp.Body.Close()
272	}
273
274	return err
275}
276
277func (c *Sys) RekeyDeleteRecoveryBackup() error {
278	r := c.c.NewRequest("DELETE", "/v1/sys/rekey/recovery-key-backup")
279
280	ctx, cancelFunc := context.WithCancel(context.Background())
281	defer cancelFunc()
282	resp, err := c.c.RawRequestWithContext(ctx, r)
283	if err == nil {
284		defer resp.Body.Close()
285	}
286
287	return err
288}
289
290func (c *Sys) RekeyVerificationUpdate(shard, nonce string) (*RekeyVerificationUpdateResponse, error) {
291	body := map[string]interface{}{
292		"key":   shard,
293		"nonce": nonce,
294	}
295
296	r := c.c.NewRequest("PUT", "/v1/sys/rekey/verify")
297	if err := r.SetJSONBody(body); err != nil {
298		return nil, err
299	}
300
301	ctx, cancelFunc := context.WithCancel(context.Background())
302	defer cancelFunc()
303	resp, err := c.c.RawRequestWithContext(ctx, r)
304	if err != nil {
305		return nil, err
306	}
307	defer resp.Body.Close()
308
309	var result RekeyVerificationUpdateResponse
310	err = resp.DecodeJSON(&result)
311	return &result, err
312}
313
314func (c *Sys) RekeyRecoveryKeyVerificationUpdate(shard, nonce string) (*RekeyVerificationUpdateResponse, error) {
315	body := map[string]interface{}{
316		"key":   shard,
317		"nonce": nonce,
318	}
319
320	r := c.c.NewRequest("PUT", "/v1/sys/rekey-recovery-key/verify")
321	if err := r.SetJSONBody(body); err != nil {
322		return nil, err
323	}
324
325	ctx, cancelFunc := context.WithCancel(context.Background())
326	defer cancelFunc()
327	resp, err := c.c.RawRequestWithContext(ctx, r)
328	if err != nil {
329		return nil, err
330	}
331	defer resp.Body.Close()
332
333	var result RekeyVerificationUpdateResponse
334	err = resp.DecodeJSON(&result)
335	return &result, err
336}
337
338type RekeyInitRequest struct {
339	SecretShares        int      `json:"secret_shares"`
340	SecretThreshold     int      `json:"secret_threshold"`
341	StoredShares        int      `json:"stored_shares"`
342	PGPKeys             []string `json:"pgp_keys"`
343	Backup              bool
344	RequireVerification bool `json:"require_verification"`
345}
346
347type RekeyStatusResponse struct {
348	Nonce                string   `json:"nonce"`
349	Started              bool     `json:"started"`
350	T                    int      `json:"t"`
351	N                    int      `json:"n"`
352	Progress             int      `json:"progress"`
353	Required             int      `json:"required"`
354	PGPFingerprints      []string `json:"pgp_fingerprints"`
355	Backup               bool     `json:"backup"`
356	VerificationRequired bool     `json:"verification_required"`
357	VerificationNonce    string   `json:"verification_nonce"`
358}
359
360type RekeyUpdateResponse struct {
361	Nonce                string   `json:"nonce"`
362	Complete             bool     `json:"complete"`
363	Keys                 []string `json:"keys"`
364	KeysB64              []string `json:"keys_base64"`
365	PGPFingerprints      []string `json:"pgp_fingerprints"`
366	Backup               bool     `json:"backup"`
367	VerificationRequired bool     `json:"verification_required"`
368	VerificationNonce    string   `json:"verification_nonce,omitempty"`
369}
370
371type RekeyRetrieveResponse struct {
372	Nonce   string              `json:"nonce" mapstructure:"nonce"`
373	Keys    map[string][]string `json:"keys" mapstructure:"keys"`
374	KeysB64 map[string][]string `json:"keys_base64" mapstructure:"keys_base64"`
375}
376
377type RekeyVerificationStatusResponse struct {
378	Nonce    string `json:"nonce"`
379	Started  bool   `json:"started"`
380	T        int    `json:"t"`
381	N        int    `json:"n"`
382	Progress int    `json:"progress"`
383}
384
385type RekeyVerificationUpdateResponse struct {
386	Nonce    string `json:"nonce"`
387	Complete bool   `json:"complete"`
388}
389