aboutsummaryrefslogtreecommitdiffstats
path: root/crypto/key_store_plain.go
blob: 6a8afe27d72309e9701eb5960fa42bf3dbaf1cd1 (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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
/*
    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 (
    "encoding/hex"
    "encoding/json"
    "fmt"
    "github.com/ethereum/go-ethereum/common"
    "io"
    "io/ioutil"
    "os"
    "path/filepath"
)

// TODO: rename to KeyStore when replacing existing KeyStore
type KeyStore2 interface {
    // create new key using io.Reader entropy source and optionally using auth string
    GenerateNewKey(io.Reader, string) (*Key, error)
    GetKey(common.Address, string) (*Key, error) // key from addr and auth string
    GetKeyAddresses() ([]common.Address, error)  // get all addresses
    StoreKey(*Key, string) error                 // store key optionally using auth string
    DeleteKey(common.Address, string) error      // delete key by addr and auth string
}

type keyStorePlain struct {
    keysDirPath string
}

func NewKeyStorePlain(path string) KeyStore2 {
    return &keyStorePlain{path}
}

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

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

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

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

func (ks keyStorePlain) GetKeyAddresses() (addresses []common.Address, err error) {
    return GetKeyAddresses(ks.keysDirPath)
}

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

func (ks keyStorePlain) DeleteKey(keyAddr common.Address, auth string) (err error) {
    keyDirPath := filepath.Join(ks.keysDirPath, keyAddr.Hex())
    err = os.RemoveAll(keyDirPath)
    return err
}

func GetKeyFile(keysDirPath string, keyAddr common.Address) (fileContent []byte, err error) {
    fileName := hex.EncodeToString(keyAddr[:])
    return ioutil.ReadFile(filepath.Join(keysDirPath, fileName, fileName))
}

func WriteKeyFile(addr common.Address, keysDirPath string, content []byte) (err error) {
    addrHex := hex.EncodeToString(addr[:])
    keyDirPath := filepath.Join(keysDirPath, addrHex)
    keyFilePath := filepath.Join(keyDirPath, addrHex)
    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
}

func GetKeyAddresses(keysDirPath string) (addresses []common.Address, err error) {
    fileInfos, err := ioutil.ReadDir(keysDirPath)
    if err != nil {
        return nil, err
    }
    for _, fileInfo := range fileInfos {
        address, err := hex.DecodeString(fileInfo.Name())
        if err != nil {
            continue
        }
        addresses = append(addresses, common.BytesToAddress(address))
    }
    return addresses, err
}