/
path_register.go
91 lines (75 loc) · 2.75 KB
/
path_register.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
package api
import (
"context"
"fmt"
"net/http"
"github.com/hashicorp/vault/sdk/framework"
"github.com/hashicorp/vault/sdk/logical"
"github.com/ryadavDeqode/dq-vault/api/helpers"
"github.com/ryadavDeqode/dq-vault/config"
"github.com/ryadavDeqode/dq-vault/lib"
"github.com/ryadavDeqode/dq-vault/logger"
)
// pathPassphrase corresponds to POST gen/passphrase.
func (b *backend) pathRegister(ctx context.Context, req *logical.Request, d *framework.FieldData) (*logical.Response, error) {
var err error
backendLogger := b.logger
if err = helpers.ValidateFields(req, d); err != nil {
logger.Log(backendLogger, config.Error, "register:", err.Error())
return nil, logical.CodedError(http.StatusUnprocessableEntity, err.Error())
}
// obatin username
username := d.Get("username").(string)
// obtain mnemonic and passphrase of user
mnemonic := d.Get("mnemonic").(string)
passphrase := d.Get("passphrase").(string)
// default entropy length
entropyLength := config.Entropy
logger.Log(backendLogger, config.Info, "register:", fmt.Sprintf("request username=%v ", username))
// generate new random UUID
uuid := helpers.NewUUID()
for helpers.UUIDExists(ctx, req, uuid) {
uuid = helpers.NewUUID()
}
// generated storage path to store user info
storagePath := config.StorageBasePath + uuid
if mnemonic == "" {
// generate new mnemonics if not provided by user
// obtain mnemonics from entropy
mnemonic, err = lib.MnemonicFromEntropy(entropyLength)
if err != nil {
logger.Log(backendLogger, config.Error, "register:", err.Error())
return nil, logical.CodedError(http.StatusExpectationFailed, err.Error())
}
}
// check if mnemonic is valid or not
if !lib.IsMnemonicValid(mnemonic) {
logger.Log(backendLogger, config.Error, "register:", fmt.Sprintf("invalid mnemonic=[%v]", mnemonic))
return nil, logical.CodedError(http.StatusExpectationFailed, "Invalid Mnemonic")
}
// create object to store user information
user := &helpers.User{
Username: username,
UUID: uuid,
Mnemonic: mnemonic,
Passphrase: passphrase,
}
// creates strorage entry with user JSON encoded value
store, err := logical.StorageEntryJSON(storagePath, user)
if err != nil {
logger.Log(backendLogger, config.Error, "register:", err.Error())
return nil, logical.CodedError(http.StatusExpectationFailed, err.Error())
}
// put user information in store
if err = req.Storage.Put(ctx, store); err != nil {
logger.Log(backendLogger, config.Error, "register:", err.Error())
return nil, logical.CodedError(http.StatusExpectationFailed, err.Error())
}
logger.Log(backendLogger, config.Info, "register:", fmt.Sprintf("user registered username=%v", username))
// return response
return &logical.Response{
Data: map[string]interface{}{
"uuid": uuid,
},
}, nil
}