github.com/n1ghtfa1l/go-vnt@v0.6.4-alpha.6/accounts/keystore/presale.go (about) 1 // Copyright 2016 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package keystore 18 19 import ( 20 "crypto/aes" 21 "crypto/cipher" 22 "crypto/sha256" 23 "encoding/hex" 24 "encoding/json" 25 "errors" 26 "fmt" 27 28 "github.com/pborman/uuid" 29 "github.com/vntchain/go-vnt/accounts" 30 "github.com/vntchain/go-vnt/crypto" 31 "golang.org/x/crypto/pbkdf2" 32 ) 33 34 // creates a Key and stores that in the given KeyStore by decrypting a presale key JSON 35 func importPreSaleKey(keyStore keyStore, keyJSON []byte, password string) (accounts.Account, *Key, error) { 36 key, err := decryptPreSaleKey(keyJSON, password) 37 if err != nil { 38 return accounts.Account{}, nil, err 39 } 40 key.Id = uuid.NewRandom() 41 a := accounts.Account{Address: key.Address, URL: accounts.URL{Scheme: KeyStoreScheme, Path: keyStore.JoinPath(keyFileName(key.Address))}} 42 err = keyStore.StoreKey(a.URL.Path, key, password) 43 return a, key, err 44 } 45 46 func decryptPreSaleKey(fileContent []byte, password string) (key *Key, err error) { 47 preSaleKeyStruct := struct { 48 EncSeed string 49 VntAddr string 50 Email string 51 BtcAddr string 52 }{} 53 err = json.Unmarshal(fileContent, &preSaleKeyStruct) 54 if err != nil { 55 return nil, err 56 } 57 encSeedBytes, err := hex.DecodeString(preSaleKeyStruct.EncSeed) 58 if err != nil { 59 return nil, errors.New("invalid hex in encSeed") 60 } 61 if len(encSeedBytes) < 16 { 62 return nil, errors.New("invalid encSeed, too short") 63 } 64 iv := encSeedBytes[:16] 65 cipherText := encSeedBytes[16:] 66 passBytes := []byte(password) 67 derivedKey := pbkdf2.Key(passBytes, passBytes, 2000, 16, sha256.New) 68 plainText, err := aesCBCDecrypt(derivedKey, cipherText, iv) 69 if err != nil { 70 return nil, err 71 } 72 vntPriv := crypto.Keccak256(plainText) 73 ecKey := crypto.ToECDSAUnsafe(vntPriv) 74 75 key = &Key{ 76 Id: nil, 77 Address: crypto.PubkeyToAddress(ecKey.PublicKey), 78 PrivateKey: ecKey, 79 } 80 derivedAddr := hex.EncodeToString(key.Address.Bytes()) // needed because .Hex() gives leading "0x" 81 expectedAddr := preSaleKeyStruct.VntAddr 82 if derivedAddr != expectedAddr { 83 err = fmt.Errorf("decrypted addr '%s' not equal to expected addr '%s'", derivedAddr, expectedAddr) 84 } 85 return key, err 86 } 87 88 func aesCTRXOR(key, inText, iv []byte) ([]byte, error) { 89 // AES-128 is selected due to size of encryptKey. 90 aesBlock, err := aes.NewCipher(key) 91 if err != nil { 92 return nil, err 93 } 94 stream := cipher.NewCTR(aesBlock, iv) 95 outText := make([]byte, len(inText)) 96 stream.XORKeyStream(outText, inText) 97 return outText, err 98 } 99 100 func aesCBCDecrypt(key, cipherText, iv []byte) ([]byte, error) { 101 aesBlock, err := aes.NewCipher(key) 102 if err != nil { 103 return nil, err 104 } 105 decrypter := cipher.NewCBCDecrypter(aesBlock, iv) 106 paddedPlaintext := make([]byte, len(cipherText)) 107 decrypter.CryptBlocks(paddedPlaintext, cipherText) 108 plaintext := pkcs7Unpad(paddedPlaintext) 109 if plaintext == nil { 110 return nil, ErrDecrypt 111 } 112 return plaintext, err 113 } 114 115 // From https://leanpub.com/gocrypto/read#leanpub-auto-block-cipher-modes 116 func pkcs7Unpad(in []byte) []byte { 117 if len(in) == 0 { 118 return nil 119 } 120 121 padding := in[len(in)-1] 122 if int(padding) > len(in) || padding > aes.BlockSize { 123 return nil 124 } else if padding == 0 { 125 return nil 126 } 127 128 for i := len(in) - 1; i > len(in)-int(padding)-1; i-- { 129 if in[i] != padding { 130 return nil 131 } 132 } 133 return in[:len(in)-int(padding)] 134 }