aboutsummaryrefslogtreecommitdiffstats
path: root/crypto/key_store_plain.go
blob: 00d9767b680d7d4fd66b3bb130b6c4f200160126 (plain) (blame)
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
/*
    This file is part of go-ethereum

    go-ethereum is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    go-ethereum is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with go-ethereum.  If not, see <http://www.gnu.org/licenses/>.
*/
/**
 * @authors
 *  Gustav Simonsson <gustav.simonsson@gmail.com>
 * @date 2015
 *
 */

package crypto

import (
    "code.google.com/p/go-uuid/uuid"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "os"
    "os/user"
    "path"
)

// TODO: rename to KeyStore when replacing existing KeyStore
type KeyStore2 interface {
    GenerateNewKey(string) (*Key, error)     // create and store new key, optionally using auth string
    GetKey(*uuid.UUID, string) (*Key, error) // key from id and auth string
    StoreKey(*Key, string) error             // store key optionally using auth string
    DeleteKey(*uuid.UUID, string) error      // delete key by id and auth string
}

type keyStorePlain struct {
    keysDirPath string
}

// TODO: copied from cmd/ethereum/flags.go
func DefaultDataDir() string {
    usr, _ := user.Current()
    return path.Join(usr.HomeDir, ".ethereum")
}

func NewKeyStorePlain(path string) KeyStore2 {
    ks := new(keyStorePlain)
    ks.keysDirPath = path
    return ks
}

func (ks keyStorePlain) GenerateNewKey(auth string) (key *Key, err error) {
    return GenerateNewKeyDefault(ks, auth)
}

func GenerateNewKeyDefault(ks KeyStore2, auth string) (key *Key, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("GenerateNewKey error: %v", r)
        }
    }()
    key = NewKey()
    err = ks.StoreKey(key, auth)
    return key, err
}

func (ks keyStorePlain) GetKey(keyId *uuid.UUID, auth string) (key *Key, err error) {
    fileContent, err := GetKeyFile(ks.keysDirPath, keyId)
    if err != nil {
        return nil, err
    }

    key = new(Key)
    err = json.Unmarshal(fileContent, key)
    return key, err
}

func (ks keyStorePlain) StoreKey(key *Key, auth string) (err error) {
    keyJSON, err := json.Marshal(key)
    if err != nil {
        return err
    }
    err = WriteKeyFile(key.Id.String(), ks.keysDirPath, keyJSON)
    return err
}

func (ks keyStorePlain) DeleteKey(keyId *uuid.UUID, auth string) (err error) {
    keyDirPath := path.Join(ks.keysDirPath, keyId.String())
    err = os.RemoveAll(keyDirPath)
    return err
}

func GetKeyFile(keysDirPath string, keyId *uuid.UUID) (fileContent []byte, err error) {
    id := keyId.String()
    return ioutil.ReadFile(path.Join(keysDirPath, id, id))
}

func WriteKeyFile(id string, keysDirPath string, content []byte) (err error) {
    keyDirPath := path.Join(keysDirPath, id)
    keyFilePath := path.Join(keyDirPath, id)
    err = os.MkdirAll(keyDirPath, 0700) // read, write and dir search for user
    if err != nil {
        return err
    }
    return ioutil.WriteFile(keyFilePath, content, 0600) // read, write for user
}