aboutsummaryrefslogtreecommitdiffstats
path: root/crypto/key.go
blob: b9ad34f47d876d94732afce7e49dafdaa99d402f (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
/*
    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 (
    "bytes"
    "code.google.com/p/go-uuid/uuid"
    "crypto/ecdsa"
    "crypto/elliptic"
    "encoding/json"
    "io"
)

type Key struct {
    Id uuid.UUID // Version 4 "random" for unique id not derived from key data
    // to simplify lookups we also store the address
    Address []byte
    // we only store privkey as pubkey/address can be derived from it
    // privkey in this struct is always in plaintext
    PrivateKey *ecdsa.PrivateKey
}

type plainKeyJSON struct {
    Id         []byte
    Address    []byte
    PrivateKey []byte
}

type cipherJSON struct {
    Salt       []byte
    IV         []byte
    CipherText []byte
}

type encryptedKeyJSON struct {
    Id      []byte
    Address []byte
    Crypto  cipherJSON
}

func (k *Key) MarshalJSON() (j []byte, err error) {
    jStruct := plainKeyJSON{
        k.Id,
        k.Address,
        FromECDSA(k.PrivateKey),
    }
    j, err = json.Marshal(jStruct)
    return j, err
}

func (k *Key) UnmarshalJSON(j []byte) (err error) {
    keyJSON := new(plainKeyJSON)
    err = json.Unmarshal(j, &keyJSON)
    if err != nil {
        return err
    }

    u := new(uuid.UUID)
    *u = keyJSON.Id
    k.Id = *u
    k.Address = keyJSON.Address
    k.PrivateKey = ToECDSA(keyJSON.PrivateKey)

    return err
}

func NewKey(rand io.Reader) *Key {
    randBytes := make([]byte, 32)
    _, err := rand.Read(randBytes)
    if err != nil {
        panic("key generation: could not read from random source: " + err.Error())
    }
    reader := bytes.NewReader(randBytes)
    _, x, y, err := elliptic.GenerateKey(S256(), reader)
    if err != nil {
        panic("key generation: elliptic.GenerateKey failed: " + err.Error())
    }
    privateKeyMarshalled := elliptic.Marshal(S256(), x, y)
    privateKeyECDSA := ToECDSA(privateKeyMarshalled)

    id := uuid.NewRandom()
    key := &Key{
        Id:         id,
        Address:    PubkeyToAddress(privateKeyECDSA.PublicKey),
        PrivateKey: privateKeyECDSA,
    }
    return key
}