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