github.com/n1ghtfa1l/go-vnt@v0.6.4-alpha.6/accounts/keystore/keystore_plain_test.go (about) 1 // Copyright 2014 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/rand" 21 "encoding/hex" 22 "fmt" 23 "io/ioutil" 24 "os" 25 "path/filepath" 26 "reflect" 27 "strings" 28 "testing" 29 30 "github.com/vntchain/go-vnt/common" 31 "github.com/vntchain/go-vnt/crypto" 32 ) 33 34 func tmpKeyStoreIface(t *testing.T, encrypted bool) (dir string, ks keyStore) { 35 d, err := ioutil.TempDir("", "gvnt-keystore-test") 36 if err != nil { 37 t.Fatal(err) 38 } 39 if encrypted { 40 ks = &keyStorePassphrase{d, veryLightScryptN, veryLightScryptP} 41 } else { 42 ks = &keyStorePlain{d} 43 } 44 return d, ks 45 } 46 47 func TestKeyStorePlain(t *testing.T) { 48 dir, ks := tmpKeyStoreIface(t, false) 49 defer os.RemoveAll(dir) 50 51 pass := "" // not used but required by API 52 k1, account, err := storeNewKey(ks, rand.Reader, pass) 53 if err != nil { 54 t.Fatal(err) 55 } 56 k2, err := ks.GetKey(k1.Address, account.URL.Path, pass) 57 if err != nil { 58 t.Fatal(err) 59 } 60 if !reflect.DeepEqual(k1.Address, k2.Address) { 61 t.Fatal(err) 62 } 63 if !reflect.DeepEqual(k1.PrivateKey, k2.PrivateKey) { 64 t.Fatal(err) 65 } 66 } 67 68 func TestKeyStorePassphrase(t *testing.T) { 69 dir, ks := tmpKeyStoreIface(t, true) 70 defer os.RemoveAll(dir) 71 72 pass := "foo" 73 k1, account, err := storeNewKey(ks, rand.Reader, pass) 74 if err != nil { 75 t.Fatal(err) 76 } 77 k2, err := ks.GetKey(k1.Address, account.URL.Path, pass) 78 if err != nil { 79 t.Fatal(err) 80 } 81 if !reflect.DeepEqual(k1.Address, k2.Address) { 82 t.Fatal(err) 83 } 84 if !reflect.DeepEqual(k1.PrivateKey, k2.PrivateKey) { 85 t.Fatal(err) 86 } 87 } 88 89 func TestKeyStorePassphraseDecryptionFail(t *testing.T) { 90 dir, ks := tmpKeyStoreIface(t, true) 91 defer os.RemoveAll(dir) 92 93 pass := "foo" 94 k1, account, err := storeNewKey(ks, rand.Reader, pass) 95 if err != nil { 96 t.Fatal(err) 97 } 98 if _, err = ks.GetKey(k1.Address, account.URL.Path, "bar"); err != ErrDecrypt { 99 t.Fatalf("wrong error for invalid passphrase\ngot %q\nwant %q", err, ErrDecrypt) 100 } 101 } 102 103 func TestImportPreSaleKey(t *testing.T) { 104 dir, ks := tmpKeyStoreIface(t, true) 105 defer os.RemoveAll(dir) 106 107 // file content of a presale key file generated with: 108 // with password "foo" 109 fileContent := "{\"encseed\": \"26d87f5f2bf9835f9a47eefae571bc09f9107bb13d54ff12a4ec095d01f83897494cf34f7bed2ed34126ecba9db7b62de56c9d7cd136520a0427bfb11b8954ba7ac39b90d4650d3448e31185affcd74226a68f1e94b1108e6e0a4a91cdd83eba\", \"vntaddr\": \"d4584b5f6229b7be90727b0fc8c6b91bb427821f\", \"email\": \"gustav.simonsson@gmail.com\", \"btcaddr\": \"1EVknXyFC68kKNLkh6YnKzW41svSRoaAcx\"}" 110 pass := "foo" 111 account, _, err := importPreSaleKey(ks, []byte(fileContent), pass) 112 if err != nil { 113 t.Fatal(err) 114 } 115 if account.Address != common.HexToAddress("d4584b5f6229b7be90727b0fc8c6b91bb427821f") { 116 t.Errorf("imported account has wrong address %x", account.Address) 117 } 118 if !strings.HasPrefix(account.URL.Path, dir) { 119 t.Errorf("imported account file not in keystore directory: %q", account.URL) 120 } 121 } 122 123 // Test and utils for the key store tests in the VNT JSON tests; 124 // testdataKeyStoreTests/basic_tests.json 125 type KeyStoreTestV3 struct { 126 Json encryptedKeyJSONV3 127 Password string 128 Priv string 129 } 130 131 type KeyStoreTestV1 struct { 132 Json encryptedKeyJSONV1 133 Password string 134 Priv string 135 } 136 137 func TestV3_PBKDF2_1(t *testing.T) { 138 t.Parallel() 139 tests := loadKeyStoreTestV3("testdata/v3_test_vector.json", t) 140 testDecryptV3(tests["wikipage_test_vector_pbkdf2"], t) 141 } 142 143 var testsSubmodule = filepath.Join("..", "..", "tests", "testdata", "KeyStoreTests") 144 145 func skipIfSubmoduleMissing(t *testing.T) { 146 if !common.FileExist(testsSubmodule) { 147 t.Skipf("can't find JSON tests from submodule at %s", testsSubmodule) 148 } 149 } 150 151 func TestV3_PBKDF2_2(t *testing.T) { 152 skipIfSubmoduleMissing(t) 153 t.Parallel() 154 tests := loadKeyStoreTestV3(filepath.Join(testsSubmodule, "basic_tests.json"), t) 155 testDecryptV3(tests["test1"], t) 156 } 157 158 func TestV3_PBKDF2_3(t *testing.T) { 159 skipIfSubmoduleMissing(t) 160 t.Parallel() 161 tests := loadKeyStoreTestV3(filepath.Join(testsSubmodule, "basic_tests.json"), t) 162 testDecryptV3(tests["python_generated_test_with_odd_iv"], t) 163 } 164 165 func TestV3_PBKDF2_4(t *testing.T) { 166 skipIfSubmoduleMissing(t) 167 t.Parallel() 168 tests := loadKeyStoreTestV3(filepath.Join(testsSubmodule, "basic_tests.json"), t) 169 testDecryptV3(tests["evilnonce"], t) 170 } 171 172 func TestV3_Scrypt_1(t *testing.T) { 173 t.Parallel() 174 tests := loadKeyStoreTestV3("testdata/v3_test_vector.json", t) 175 testDecryptV3(tests["wikipage_test_vector_scrypt"], t) 176 } 177 178 func TestV3_Scrypt_2(t *testing.T) { 179 skipIfSubmoduleMissing(t) 180 t.Parallel() 181 tests := loadKeyStoreTestV3(filepath.Join(testsSubmodule, "basic_tests.json"), t) 182 testDecryptV3(tests["test2"], t) 183 } 184 185 func TestV1_1(t *testing.T) { 186 t.Parallel() 187 tests := loadKeyStoreTestV1("testdata/v1_test_vector.json", t) 188 testDecryptV1(tests["test1"], t) 189 } 190 191 func TestV1_2(t *testing.T) { 192 t.Parallel() 193 ks := &keyStorePassphrase{"testdata/v1", LightScryptN, LightScryptP} 194 addr := common.HexToAddress("cb61d5a9c4896fb9658090b597ef0e7be6f7b67e") 195 file := "testdata/v1/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e" 196 k, err := ks.GetKey(addr, file, "g") 197 if err != nil { 198 t.Fatal(err) 199 } 200 privHex := hex.EncodeToString(crypto.FromECDSA(k.PrivateKey)) 201 expectedHex := "d1b1178d3529626a1a93e073f65028370d14c7eb0936eb42abef05db6f37ad7d" 202 if privHex != expectedHex { 203 t.Fatal(fmt.Errorf("Unexpected privkey: %v, expected %v", privHex, expectedHex)) 204 } 205 } 206 207 func testDecryptV3(test KeyStoreTestV3, t *testing.T) { 208 privBytes, _, err := decryptKeyV3(&test.Json, test.Password) 209 if err != nil { 210 t.Fatal(err) 211 } 212 privHex := hex.EncodeToString(privBytes) 213 if test.Priv != privHex { 214 t.Fatal(fmt.Errorf("Decrypted bytes not equal to test, expected %v have %v", test.Priv, privHex)) 215 } 216 } 217 218 func testDecryptV1(test KeyStoreTestV1, t *testing.T) { 219 privBytes, _, err := decryptKeyV1(&test.Json, test.Password) 220 if err != nil { 221 t.Fatal(err) 222 } 223 privHex := hex.EncodeToString(privBytes) 224 if test.Priv != privHex { 225 t.Fatal(fmt.Errorf("Decrypted bytes not equal to test, expected %v have %v", test.Priv, privHex)) 226 } 227 } 228 229 func loadKeyStoreTestV3(file string, t *testing.T) map[string]KeyStoreTestV3 { 230 tests := make(map[string]KeyStoreTestV3) 231 err := common.LoadJSON(file, &tests) 232 if err != nil { 233 t.Fatal(err) 234 } 235 return tests 236 } 237 238 func loadKeyStoreTestV1(file string, t *testing.T) map[string]KeyStoreTestV1 { 239 tests := make(map[string]KeyStoreTestV1) 240 err := common.LoadJSON(file, &tests) 241 if err != nil { 242 t.Fatal(err) 243 } 244 return tests 245 } 246 247 func TestKeyForDirectICAP(t *testing.T) { 248 t.Parallel() 249 key := NewKeyForDirectICAP(rand.Reader) 250 if !strings.HasPrefix(key.Address.Hex(), "0x00") { 251 t.Errorf("Expected first address byte to be zero, have: %s", key.Address.Hex()) 252 } 253 } 254 255 func TestV3_31_Byte_Key(t *testing.T) { 256 t.Parallel() 257 tests := loadKeyStoreTestV3("testdata/v3_test_vector.json", t) 258 testDecryptV3(tests["31_byte_key"], t) 259 } 260 261 func TestV3_30_Byte_Key(t *testing.T) { 262 t.Parallel() 263 tests := loadKeyStoreTestV3("testdata/v3_test_vector.json", t) 264 testDecryptV3(tests["30_byte_key"], t) 265 }