OSDN Git Service

Add BlockWitness (#54)
[bytom/vapor.git] / crypto / sm2 / pkcs8.go
1 package sm2
2
3 import (
4         "crypto/aes"
5         "crypto/cipher"
6         "crypto/elliptic"
7         "crypto/hmac"
8         "crypto/md5"
9         "crypto/rand"
10         "crypto/sha1"
11         "crypto/sha256"
12         "crypto/sha512"
13         "crypto/x509/pkix"
14         "encoding/asn1"
15         "encoding/pem"
16         "errors"
17         "hash"
18         "io/ioutil"
19         "math/big"
20         "os"
21         "reflect"
22 )
23
24 /*
25  * reference to RFC5959 and RFC2898
26  */
27
28 var (
29         oidPBES1  = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 5, 3}  // pbeWithMD5AndDES-CBC(PBES1)
30         oidPBES2  = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 5, 13} // id-PBES2(PBES2)
31         oidPBKDF2 = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 5, 12} // id-PBKDF2
32
33         oidKEYMD5    = asn1.ObjectIdentifier{1, 2, 840, 113549, 2, 5}
34         oidKEYSHA1   = asn1.ObjectIdentifier{1, 2, 840, 113549, 2, 7}
35         oidKEYSHA256 = asn1.ObjectIdentifier{1, 2, 840, 113549, 2, 9}
36         oidKEYSHA512 = asn1.ObjectIdentifier{1, 2, 840, 113549, 2, 11}
37
38         oidAES128CBC = asn1.ObjectIdentifier{2, 16, 840, 1, 101, 3, 4, 1, 2}
39         oidAES256CBC = asn1.ObjectIdentifier{2, 16, 840, 1, 101, 3, 4, 1, 42}
40
41         oidSM2 = asn1.ObjectIdentifier{1, 2, 840, 10045, 2, 1}
42 )
43
44 // reference to https://www.rfc-editor.org/rfc/rfc5958.txt
45 type PrivateKeyInfo struct {
46         Version             int // v1 or v2
47         PrivateKeyAlgorithm []asn1.ObjectIdentifier
48         PrivateKey          []byte
49 }
50
51 // reference to https://www.rfc-editor.org/rfc/rfc5958.txt
52 type EncryptedPrivateKeyInfo struct {
53         EncryptionAlgorithm Pbes2Algorithms
54         EncryptedData       []byte
55 }
56
57 // reference to https://www.ietf.org/rfc/rfc2898.txt
58 type Pbes2Algorithms struct {
59         IdPBES2     asn1.ObjectIdentifier
60         Pbes2Params Pbes2Params
61 }
62
63 // reference to https://www.ietf.org/rfc/rfc2898.txt
64 type Pbes2Params struct {
65         KeyDerivationFunc Pbes2KDfs // PBES2-KDFs
66         EncryptionScheme  Pbes2Encs // PBES2-Encs
67 }
68
69 // reference to https://www.ietf.org/rfc/rfc2898.txt
70 type Pbes2KDfs struct {
71         IdPBKDF2    asn1.ObjectIdentifier
72         Pkdf2Params Pkdf2Params
73 }
74
75 type Pbes2Encs struct {
76         EncryAlgo asn1.ObjectIdentifier
77         IV        []byte
78 }
79
80 // reference to https://www.ietf.org/rfc/rfc2898.txt
81 type Pkdf2Params struct {
82         Salt           []byte
83         IterationCount int
84         Prf            pkix.AlgorithmIdentifier
85 }
86
87 type sm2PrivateKey struct {
88         Version       int
89         PrivateKey    []byte
90         NamedCurveOID asn1.ObjectIdentifier `asn1:"optional,explicit,tag:0"`
91         PublicKey     asn1.BitString        `asn1:"optional,explicit,tag:1"`
92 }
93
94 type pkcs8 struct {
95         Version    int
96         Algo       pkix.AlgorithmIdentifier
97         PrivateKey []byte
98 }
99
100 // copy from crypto/pbkdf2.go
101 func pbkdf(password, salt []byte, iter, keyLen int, h func() hash.Hash) []byte {
102         prf := hmac.New(h, password)
103         hashLen := prf.Size()
104         numBlocks := (keyLen + hashLen - 1) / hashLen
105
106         var buf [4]byte
107         dk := make([]byte, 0, numBlocks*hashLen)
108         U := make([]byte, hashLen)
109         for block := 1; block <= numBlocks; block++ {
110                 // N.B.: || means concatenation, ^ means XOR
111                 // for each block T_i = U_1 ^ U_2 ^ ... ^ U_iter
112                 // U_1 = PRF(password, salt || uint(i))
113                 prf.Reset()
114                 prf.Write(salt)
115                 buf[0] = byte(block >> 24)
116                 buf[1] = byte(block >> 16)
117                 buf[2] = byte(block >> 8)
118                 buf[3] = byte(block)
119                 prf.Write(buf[:4])
120                 dk = prf.Sum(dk)
121                 T := dk[len(dk)-hashLen:]
122                 copy(U, T)
123
124                 // U_n = PRF(password, U_(n-1))
125                 for n := 2; n <= iter; n++ {
126                         prf.Reset()
127                         prf.Write(U)
128                         U = U[:0]
129                         U = prf.Sum(U)
130                         for x := range U {
131                                 T[x] ^= U[x]
132                         }
133                 }
134         }
135         return dk[:keyLen]
136 }
137
138 func ParseSm2PublicKey(der []byte) (*PublicKey, error) {
139         var pubkey pkixPublicKey
140
141         if _, err := asn1.Unmarshal(der, &pubkey); err != nil {
142                 return nil, err
143         }
144         if !reflect.DeepEqual(pubkey.Algo.Algorithm, oidSM2) {
145                 return nil, errors.New("x509: not sm2 elliptic curve")
146         }
147         curve := P256Sm2()
148         x, y := elliptic.Unmarshal(curve, pubkey.BitString.Bytes)
149         pub := PublicKey{
150                 Curve: curve,
151                 X:     x,
152                 Y:     y,
153         }
154         return &pub, nil
155 }
156
157 func MarshalSm2PublicKey(key *PublicKey) ([]byte, error) {
158         var r pkixPublicKey
159         var algo pkix.AlgorithmIdentifier
160
161         algo.Algorithm = oidSM2
162         algo.Parameters.Class = 0
163         algo.Parameters.Tag = 6
164         algo.Parameters.IsCompound = false
165         algo.Parameters.FullBytes = []byte{6, 8, 42, 129, 28, 207, 85, 1, 130, 45} // asn1.Marshal(asn1.ObjectIdentifier{1, 2, 156, 10197, 1, 301})
166         r.Algo = algo
167         r.BitString = asn1.BitString{Bytes: elliptic.Marshal(key.Curve, key.X, key.Y)}
168         return asn1.Marshal(r)
169 }
170
171 func ParseSm2PrivateKey(der []byte) (*PrivateKey, error) {
172         var privKey sm2PrivateKey
173
174         if _, err := asn1.Unmarshal(der, &privKey); err != nil {
175                 return nil, errors.New("x509: failed to parse SM2 private key: " + err.Error())
176         }
177         curve := P256Sm2()
178         k := new(big.Int).SetBytes(privKey.PrivateKey)
179         curveOrder := curve.Params().N
180         if k.Cmp(curveOrder) >= 0 {
181                 return nil, errors.New("x509: invalid elliptic curve private key value")
182         }
183         priv := new(PrivateKey)
184         priv.Curve = curve
185         priv.D = k
186         privateKey := make([]byte, (curveOrder.BitLen()+7)/8)
187         for len(privKey.PrivateKey) > len(privateKey) {
188                 if privKey.PrivateKey[0] != 0 {
189                         return nil, errors.New("x509: invalid private key length")
190                 }
191                 privKey.PrivateKey = privKey.PrivateKey[1:]
192         }
193         copy(privateKey[len(privateKey)-len(privKey.PrivateKey):], privKey.PrivateKey)
194         priv.X, priv.Y = curve.ScalarBaseMult(privateKey)
195         return priv, nil
196 }
197
198 func ParsePKCS8UnecryptedPrivateKey(der []byte) (*PrivateKey, error) {
199         var privKey pkcs8
200
201         if _, err := asn1.Unmarshal(der, &privKey); err != nil {
202                 return nil, err
203         }
204         if !reflect.DeepEqual(privKey.Algo.Algorithm, oidSM2) {
205                 return nil, errors.New("x509: not sm2 elliptic curve")
206         }
207         return ParseSm2PrivateKey(privKey.PrivateKey)
208 }
209
210 func ParsePKCS8EcryptedPrivateKey(der, pwd []byte) (*PrivateKey, error) {
211         var keyInfo EncryptedPrivateKeyInfo
212
213         _, err := asn1.Unmarshal(der, &keyInfo)
214         if err != nil {
215                 return nil, errors.New("x509: unknown format")
216         }
217         if !reflect.DeepEqual(keyInfo.EncryptionAlgorithm.IdPBES2, oidPBES2) {
218                 return nil, errors.New("x509: only support PBES2")
219         }
220         encryptionScheme := keyInfo.EncryptionAlgorithm.Pbes2Params.EncryptionScheme
221         keyDerivationFunc := keyInfo.EncryptionAlgorithm.Pbes2Params.KeyDerivationFunc
222         if !reflect.DeepEqual(keyDerivationFunc.IdPBKDF2, oidPBKDF2) {
223                 return nil, errors.New("x509: only support PBKDF2")
224         }
225         pkdf2Params := keyDerivationFunc.Pkdf2Params
226         if !reflect.DeepEqual(encryptionScheme.EncryAlgo, oidAES128CBC) &&
227                 !reflect.DeepEqual(encryptionScheme.EncryAlgo, oidAES256CBC) {
228                 return nil, errors.New("x509: unknow encryption algorithm")
229         }
230         iv := encryptionScheme.IV
231         salt := pkdf2Params.Salt
232         iter := pkdf2Params.IterationCount
233         encryptedKey := keyInfo.EncryptedData
234         var key []byte
235         switch {
236         case pkdf2Params.Prf.Algorithm.Equal(oidKEYMD5):
237                 key = pbkdf(pwd, salt, iter, 32, md5.New)
238                 break
239         case pkdf2Params.Prf.Algorithm.Equal(oidKEYSHA1):
240                 key = pbkdf(pwd, salt, iter, 32, sha1.New)
241                 break
242         case pkdf2Params.Prf.Algorithm.Equal(oidKEYSHA256):
243                 key = pbkdf(pwd, salt, iter, 32, sha256.New)
244                 break
245         case pkdf2Params.Prf.Algorithm.Equal(oidKEYSHA512):
246                 key = pbkdf(pwd, salt, iter, 32, sha512.New)
247                 break
248         default:
249                 return nil, errors.New("x509: unknown hash algorithm")
250         }
251         block, err := aes.NewCipher(key)
252         if err != nil {
253                 return nil, err
254         }
255         mode := cipher.NewCBCDecrypter(block, iv)
256         mode.CryptBlocks(encryptedKey, encryptedKey)
257         rKey, err := ParsePKCS8UnecryptedPrivateKey(encryptedKey)
258         if err != nil {
259                 return nil, errors.New("pkcs8: incorrect password")
260         }
261         return rKey, nil
262 }
263
264 func ParsePKCS8PrivateKey(der, pwd []byte) (*PrivateKey, error) {
265         if pwd == nil {
266                 return ParsePKCS8UnecryptedPrivateKey(der)
267         }
268         return ParsePKCS8EcryptedPrivateKey(der, pwd)
269 }
270
271 func MarshalSm2UnecryptedPrivateKey(key *PrivateKey) ([]byte, error) {
272         var r pkcs8
273         var priv sm2PrivateKey
274         var algo pkix.AlgorithmIdentifier
275
276         algo.Algorithm = oidSM2
277         algo.Parameters.Class = 0
278         algo.Parameters.Tag = 6
279         algo.Parameters.IsCompound = false
280         algo.Parameters.FullBytes = []byte{6, 8, 42, 129, 28, 207, 85, 1, 130, 45} // asn1.Marshal(asn1.ObjectIdentifier{1, 2, 156, 10197, 1, 301})
281         priv.Version = 1
282         priv.NamedCurveOID = oidNamedCurveP256SM2
283         priv.PublicKey = asn1.BitString{Bytes: elliptic.Marshal(key.Curve, key.X, key.Y)}
284         priv.PrivateKey = key.D.Bytes()
285         r.Version = 0
286         r.Algo = algo
287         r.PrivateKey, _ = asn1.Marshal(priv)
288         return asn1.Marshal(r)
289 }
290
291 func MarshalSm2EcryptedPrivateKey(PrivKey *PrivateKey, pwd []byte) ([]byte, error) {
292         der, err := MarshalSm2UnecryptedPrivateKey(PrivKey)
293         if err != nil {
294                 return nil, err
295         }
296         iter := 2048
297         salt := make([]byte, 8)
298         iv := make([]byte, 16)
299         rand.Reader.Read(salt)
300         rand.Reader.Read(iv)
301         key := pbkdf(pwd, salt, iter, 32, sha1.New) // 默认是SHA1
302         padding := aes.BlockSize - len(der)%aes.BlockSize
303         if padding > 0 {
304                 n := len(der)
305                 der = append(der, make([]byte, padding)...)
306                 for i := 0; i < padding; i++ {
307                         der[n+i] = byte(padding)
308                 }
309         }
310         encryptedKey := make([]byte, len(der))
311         block, err := aes.NewCipher(key)
312         if err != nil {
313                 return nil, err
314         }
315         mode := cipher.NewCBCEncrypter(block, iv)
316         mode.CryptBlocks(encryptedKey, der)
317         var algorithmIdentifier pkix.AlgorithmIdentifier
318         algorithmIdentifier.Algorithm = oidKEYSHA1
319         algorithmIdentifier.Parameters.Tag = 5
320         algorithmIdentifier.Parameters.IsCompound = false
321         algorithmIdentifier.Parameters.FullBytes = []byte{5, 0}
322         keyDerivationFunc := Pbes2KDfs{
323                 oidPBKDF2,
324                 Pkdf2Params{
325                         salt,
326                         iter,
327                         algorithmIdentifier,
328                 },
329         }
330         encryptionScheme := Pbes2Encs{
331                 oidAES256CBC,
332                 iv,
333         }
334         pbes2Algorithms := Pbes2Algorithms{
335                 oidPBES2,
336                 Pbes2Params{
337                         keyDerivationFunc,
338                         encryptionScheme,
339                 },
340         }
341         encryptedPkey := EncryptedPrivateKeyInfo{
342                 pbes2Algorithms,
343                 encryptedKey,
344         }
345         return asn1.Marshal(encryptedPkey)
346 }
347
348 func MarshalSm2PrivateKey(key *PrivateKey, pwd []byte) ([]byte, error) {
349         if pwd == nil {
350                 return MarshalSm2UnecryptedPrivateKey(key)
351         }
352         return MarshalSm2EcryptedPrivateKey(key, pwd)
353 }
354
355 func ReadPrivateKeyFromMem(data []byte, pwd []byte) (*PrivateKey, error) {
356         var block *pem.Block
357
358         block, _ = pem.Decode(data)
359         if block == nil {
360                 return nil, errors.New("failed to decode private key")
361         }
362         priv, err := ParsePKCS8PrivateKey(block.Bytes, pwd)
363         return priv, err
364 }
365
366 func ReadPrivateKeyFromPem(FileName string, pwd []byte) (*PrivateKey, error) {
367         data, err := ioutil.ReadFile(FileName)
368         if err != nil {
369                 return nil, err
370         }
371         return ReadPrivateKeyFromMem(data, pwd)
372 }
373
374 func WritePrivateKeytoMem(key *PrivateKey, pwd []byte) ([]byte, error) {
375         var block *pem.Block
376
377         der, err := MarshalSm2PrivateKey(key, pwd)
378         if err != nil {
379                 return nil, err
380         }
381         if pwd != nil {
382                 block = &pem.Block{
383                         Type:  "ENCRYPTED PRIVATE KEY",
384                         Bytes: der,
385                 }
386         } else {
387                 block = &pem.Block{
388                         Type:  "PRIVATE KEY",
389                         Bytes: der,
390                 }
391         }
392         return pem.EncodeToMemory(block), nil
393 }
394
395 func WritePrivateKeytoPem(FileName string, key *PrivateKey, pwd []byte) (bool, error) {
396         var block *pem.Block
397
398         der, err := MarshalSm2PrivateKey(key, pwd)
399         if err != nil {
400                 return false, err
401         }
402         if pwd != nil {
403                 block = &pem.Block{
404                         Type:  "ENCRYPTED PRIVATE KEY",
405                         Bytes: der,
406                 }
407         } else {
408                 block = &pem.Block{
409                         Type:  "PRIVATE KEY",
410                         Bytes: der,
411                 }
412         }
413         file, err := os.Create(FileName)
414         if err != nil {
415                 return false, err
416         }
417         defer file.Close()
418         err = pem.Encode(file, block)
419         if err != nil {
420                 return false, err
421         }
422         return true, nil
423 }
424
425 func ReadPublicKeyFromMem(data []byte, _ []byte) (*PublicKey, error) {
426         block, _ := pem.Decode(data)
427         if block == nil || block.Type != "PUBLIC KEY" {
428                 return nil, errors.New("failed to decode public key")
429         }
430         pub, err := ParseSm2PublicKey(block.Bytes)
431         return pub, err
432 }
433
434 func ReadPublicKeyFromPem(FileName string, pwd []byte) (*PublicKey, error) {
435         data, err := ioutil.ReadFile(FileName)
436         if err != nil {
437                 return nil, err
438         }
439         return ReadPublicKeyFromMem(data, pwd)
440 }
441
442 func WritePublicKeytoMem(key *PublicKey, _ []byte) ([]byte, error) {
443         der, err := MarshalSm2PublicKey(key)
444         if err != nil {
445                 return nil, err
446         }
447         block := &pem.Block{
448                 Type:  "PUBLIC KEY",
449                 Bytes: der,
450         }
451         return pem.EncodeToMemory(block), nil
452 }
453
454 func WritePublicKeytoPem(FileName string, key *PublicKey, _ []byte) (bool, error) {
455         der, err := MarshalSm2PublicKey(key)
456         if err != nil {
457                 return false, err
458         }
459         block := &pem.Block{
460                 Type:  "PUBLIC KEY",
461                 Bytes: der,
462         }
463         file, err := os.Create(FileName)
464         defer file.Close()
465         if err != nil {
466                 return false, err
467         }
468         err = pem.Encode(file, block)
469         if err != nil {
470                 return false, err
471         }
472         return true, nil
473 }