@@ -12,13 +12,13 @@ import (
1212 "slices"
1313)
1414
15- const KeySize = 32
15+ const SubKeySize = 32
1616
17- // a key is either: a public encryption, public signing, private encryption, or private signing key
18- type key [ KeySize ]byte
17+ // a subKey is either: a public encryption, public signing, private encryption, or private signing subKey
18+ type subKey [ SubKeySize ]byte
1919
2020// a subKey is zero if all it's bytes are zero
21- func (s key ) IsZero () bool {
21+ func (s subKey ) IsZero () bool {
2222 for _ , b := range s {
2323 if b != 0 {
2424 return false
@@ -27,74 +27,75 @@ func (s key) IsZero() bool {
2727 return true
2828}
2929
30- func (s key ) Bytes () []byte {
30+ func (s subKey ) Bytes () []byte {
3131 return s [:]
3232}
3333
3434func NewPeer () Peer {
35- return KeyPair {}
35+ return Key {}
3636}
3737
38- // a KeyPair is two (specifically one encryption and one signing) keys
39- type KeyPair [2 ]key
38+ // a Key is two (specifically one encryption and one signing) keys
39+ type Key [2 ]subKey
4040
41- func (k KeyPair ) MarshalJSON () ([]byte , error ) {
41+ func (k Key ) MarshalJSON () ([]byte , error ) {
4242 str := k .ToHex ()
4343 return json .Marshal (str )
4444}
4545
46- func (k KeyPair ) MarshalBinary () ([]byte , error ) {
46+ func (k Key ) MarshalBinary () ([]byte , error ) {
4747 return k .Bytes (), nil
4848}
4949
50- func (k * KeyPair ) UnmarshalBinary (b []byte ) error {
51- copy (k [0 ][:], b [:KeySize ])
52- copy (k [1 ][:], b [KeySize :])
50+ func (k * Key ) UnmarshalBinary (b []byte ) error {
51+ copy (k [0 ][:], b [:SubKeySize ])
52+ copy (k [1 ][:], b [SubKeySize :])
5353 return nil
5454}
5555
56- func (k * KeyPair ) UnmarshalJSON (b []byte ) error {
56+ func (k * Key ) UnmarshalJSON (b []byte ) error {
5757 j := KeyFromHex (string (b ))
5858 copy (k [:], j [:])
5959 return nil
6060}
6161
62- func (k KeyPair ) MarshalText () ([]byte , error ) {
62+ func (k Key ) MarshalText () ([]byte , error ) {
6363 return []byte (k .ToHex ()), nil
6464}
6565
6666// a Key is zero if all it's subKeys are zero
67- func (k KeyPair ) IsZero () bool {
67+ func (k Key ) IsZero () bool {
6868 return k [0 ].IsZero () && k [1 ].IsZero ()
6969}
7070
71- func (k KeyPair ) From (b []byte ) KeyPair {
72- var enc key
73- var sig key
74- copy (enc [:], b [:KeySize ])
75- copy (sig [:], b [KeySize :])
76- var j KeyPair
71+ func (k Key ) From (b []byte ) Key {
72+ // TODO: panic or error if the byte slice looks wrong
73+ var enc subKey
74+ var sig subKey
75+ copy (enc [:], b [:SubKeySize ])
76+ copy (sig [:], b [SubKeySize :])
77+ var j Key
7778 j [0 ] = enc
7879 j [1 ] = sig
7980 return j
8081}
8182
82- // a KeyChain is two [KeyPair ]s. One public, one private
83- type KeyChain [2 ]KeyPair
83+ // a KeyPair is two [Key ]s. One public, one private
84+ type KeyPair [2 ]Key
8485
8586// a KeyPair is zero if all it's keys are zero
86- func (kp KeyChain ) IsZero () bool {
87+ func (kp KeyPair ) IsZero () bool {
8788 return kp [0 ].IsZero () && kp [1 ].IsZero ()
8889}
8990
90- func (k KeyPair ) Bytes () []byte {
91- b := make ([]byte , 2 * KeySize )
92- copy (b [:KeySize ], k [0 ][:])
93- copy (b [KeySize :], k [1 ][:])
91+ func (k Key ) Bytes () []byte {
92+ b := make ([]byte , 2 * SubKeySize )
93+ copy (b [:SubKeySize ], k [0 ][:])
94+ copy (b [SubKeySize :], k [1 ][:])
9495 return b
9596}
9697
97- func (k KeyPair ) ToInt64 () int64 {
98+ func (k Key ) ToInt64 () int64 {
9899 var num int64
99100 buf := bytes .NewReader (k .Bytes ())
100101 err := binary .Read (buf , binary .BigEndian , & num )
@@ -104,7 +105,7 @@ func (k KeyPair) ToInt64() int64 {
104105 return num
105106}
106107
107- func (k KeyPair ) Equal (j KeyPair ) bool {
108+ func (k Key ) Equal (j Key ) bool {
108109 for i := range 2 {
109110
110111 jslice := j [i ][:]
@@ -122,62 +123,62 @@ func (k KeyPair) Equal(j KeyPair) bool {
122123 return true
123124}
124125
125- func (k KeyPair ) Signing () key {
126+ func (k Key ) Signing () subKey {
126127 return k [1 ]
127128}
128129
129- func (k KeyPair ) Encryption () key {
130+ func (k Key ) Encryption () subKey {
130131 return k [0 ]
131132}
132133
133- func (k KeyChain ) Bytes () []byte {
134- b := make ([]byte , 4 * KeySize )
135- copy (b [:2 * KeySize ], k [0 ].Bytes ()) // public
136- copy (b [2 * KeySize :], k [1 ].Bytes ()) // private
134+ func (k KeyPair ) Bytes () []byte {
135+ b := make ([]byte , 4 * SubKeySize )
136+ copy (b [:2 * SubKeySize ], k [0 ].Bytes ()) // public
137+ copy (b [2 * SubKeySize :], k [1 ].Bytes ()) // private
137138 return b
138139}
139140
140- func (k KeyPair ) ToHex () string {
141+ func (k Key ) ToHex () string {
141142 return hex .EncodeToString (k .Bytes ())
142143}
143144
144- func KeyFromHex (str string ) KeyPair {
145+ func KeyFromHex (str string ) Key {
145146 bin , err := hex .DecodeString (str )
146147 if err != nil {
147- return KeyPair {}
148+ return Key {}
148149 }
149150 return KeyFromBytes (bin )
150151}
151152
152- func KeyFromBytes (b []byte ) KeyPair {
153+ func KeyFromBytes (b []byte ) Key {
153154
154155 gotSize := len (b )
155- wantSize := KeySize * 2
156+ wantSize := SubKeySize * 2
156157
157158 if gotSize != wantSize {
158159 panic (fmt .Sprintf ("wrong length for key. Wanted %d but got %d" , wantSize , gotSize ))
159160 }
160- k := KeyPair {}
161- copy (k [0 ][:], b [:KeySize ])
162- copy (k [1 ][:], b [KeySize :])
161+ k := Key {}
162+ copy (k [0 ][:], b [:SubKeySize ])
163+ copy (k [1 ][:], b [SubKeySize :])
163164 return k
164165}
165166
166- func NewSubKey (randy io.Reader ) key {
167- sk := key {}
167+ func NewSubKey (randy io.Reader ) subKey {
168+ sk := subKey {}
168169 randy .Read (sk [:])
169170 return sk
170171}
171172
172- func NewKey (randy io.Reader ) KeyPair {
173+ func NewKey (randy io.Reader ) Key {
173174 if randy == nil {
174- return KeyPair {}
175+ return Key {}
175176 }
176- return KeyPair {NewSubKey (randy ), NewSubKey (randy )}
177+ return Key {NewSubKey (randy ), NewSubKey (randy )}
177178}
178179
179180// NewKeyPair generates valid ed25519 and X25519 keys
180- func NewKeyPair (randy io.Reader ) KeyChain {
181+ func NewKeyPair (randy io.Reader ) KeyPair {
181182
182183 /**
183184 * Layout:
@@ -187,7 +188,7 @@ func NewKeyPair(randy io.Reader) KeyChain {
187188 * 4th 32 bytes: private signing key
188189 **/
189190
190- var kp KeyChain
191+ var kp KeyPair
191192
192193 // encryption keys
193194 ed := ecdh .X25519 ()
@@ -197,17 +198,17 @@ func NewKeyPair(randy io.Reader) KeyChain {
197198 }
198199 encryptionPub := encryptionPriv .PublicKey ()
199200
200- kp [0 ][0 ] = key (encryptionPub .Bytes ())
201- kp [1 ][0 ] = key (encryptionPriv .Bytes ())
201+ kp [0 ][0 ] = subKey (encryptionPub .Bytes ())
202+ kp [1 ][0 ] = subKey (encryptionPriv .Bytes ())
202203
203204 // signing keys
204205 signPub , signPriv , err := ed25519 .GenerateKey (randy )
205206 if err != nil {
206207 panic (err )
207208 }
208209
209- kp [0 ][1 ] = key (signPub )
210- kp [1 ][1 ] = key (signPriv [:KeySize ])
210+ kp [0 ][1 ] = subKey (signPub )
211+ kp [1 ][1 ] = subKey (signPriv [:SubKeySize ])
211212
212213 return kp
213214}
0 commit comments