github.com/jonasnick/go-ethereum@v0.7.12-0.20150216215225-22176f05d387/crypto/secp256k1/secp256_test.go (about) 1 package secp256k1 2 3 import ( 4 "bytes" 5 "fmt" 6 "log" 7 "testing" 8 9 "github.com/jonasnick/go-ethereum/crypto/randentropy" 10 ) 11 12 const TESTS = 10000 // how many tests 13 const SigSize = 65 //64+1 14 15 func Test_Secp256_00(t *testing.T) { 16 17 var nonce []byte = randentropy.GetEntropyMixed(32) //going to get bitcoins stolen! 18 19 if len(nonce) != 32 { 20 t.Fatal() 21 } 22 23 } 24 25 //tests for Malleability 26 //highest bit of S must be 0; 32nd byte 27 func CompactSigTest(sig []byte) { 28 29 var b int = int(sig[32]) 30 if b < 0 { 31 log.Panic() 32 } 33 if ((b >> 7) == 1) != ((b & 0x80) == 0x80) { 34 log.Panic("b= %v b2= %v \n", b, b>>7) 35 } 36 if (b & 0x80) == 0x80 { 37 log.Panic("b= %v b2= %v \n", b, b&0x80) 38 } 39 } 40 41 //test pubkey/private generation 42 func Test_Secp256_01(t *testing.T) { 43 pubkey, seckey := GenerateKeyPair() 44 if err := VerifySeckeyValidity(seckey); err != nil { 45 t.Fatal() 46 } 47 if err := VerifyPubkeyValidity(pubkey); err != nil { 48 t.Fatal() 49 } 50 } 51 52 //test size of messages 53 func Test_Secp256_02s(t *testing.T) { 54 pubkey, seckey := GenerateKeyPair() 55 msg := randentropy.GetEntropyMixed(32) 56 sig, _ := Sign(msg, seckey) 57 CompactSigTest(sig) 58 if sig == nil { 59 t.Fatal("Signature nil") 60 } 61 if len(pubkey) != 65 { 62 t.Fail() 63 } 64 if len(seckey) != 32 { 65 t.Fail() 66 } 67 if len(sig) != 64+1 { 68 t.Fail() 69 } 70 if int(sig[64]) > 4 { 71 t.Fail() 72 } //should be 0 to 4 73 } 74 75 //test signing message 76 func Test_Secp256_02(t *testing.T) { 77 pubkey1, seckey := GenerateKeyPair() 78 msg := randentropy.GetEntropyMixed(32) 79 sig, _ := Sign(msg, seckey) 80 if sig == nil { 81 t.Fatal("Signature nil") 82 } 83 84 pubkey2, _ := RecoverPubkey(msg, sig) 85 if pubkey2 == nil { 86 t.Fatal("Recovered pubkey invalid") 87 } 88 if bytes.Equal(pubkey1, pubkey2) == false { 89 t.Fatal("Recovered pubkey does not match") 90 } 91 92 err := VerifySignature(msg, sig, pubkey1) 93 if err != nil { 94 t.Fatal("Signature invalid") 95 } 96 } 97 98 //test pubkey recovery 99 func Test_Secp256_02a(t *testing.T) { 100 pubkey1, seckey1 := GenerateKeyPair() 101 msg := randentropy.GetEntropyMixed(32) 102 sig, _ := Sign(msg, seckey1) 103 104 if sig == nil { 105 t.Fatal("Signature nil") 106 } 107 err := VerifySignature(msg, sig, pubkey1) 108 if err != nil { 109 t.Fatal("Signature invalid") 110 } 111 112 pubkey2, _ := RecoverPubkey(msg, sig) 113 if len(pubkey1) != len(pubkey2) { 114 t.Fatal() 115 } 116 for i, _ := range pubkey1 { 117 if pubkey1[i] != pubkey2[i] { 118 t.Fatal() 119 } 120 } 121 if bytes.Equal(pubkey1, pubkey2) == false { 122 t.Fatal() 123 } 124 } 125 126 //test random messages for the same pub/private key 127 func Test_Secp256_03(t *testing.T) { 128 _, seckey := GenerateKeyPair() 129 for i := 0; i < TESTS; i++ { 130 msg := randentropy.GetEntropyMixed(32) 131 sig, _ := Sign(msg, seckey) 132 CompactSigTest(sig) 133 134 sig[len(sig)-1] %= 4 135 pubkey2, _ := RecoverPubkey(msg, sig) 136 if pubkey2 == nil { 137 t.Fail() 138 } 139 } 140 } 141 142 //test random messages for different pub/private keys 143 func Test_Secp256_04(t *testing.T) { 144 for i := 0; i < TESTS; i++ { 145 pubkey1, seckey := GenerateKeyPair() 146 msg := randentropy.GetEntropyMixed(32) 147 sig, _ := Sign(msg, seckey) 148 CompactSigTest(sig) 149 150 if sig[len(sig)-1] >= 4 { 151 t.Fail() 152 } 153 pubkey2, _ := RecoverPubkey(msg, sig) 154 if pubkey2 == nil { 155 t.Fail() 156 } 157 if bytes.Equal(pubkey1, pubkey2) == false { 158 t.Fail() 159 } 160 } 161 } 162 163 //test random signatures against fixed messages; should fail 164 165 //crashes: 166 // -SIPA look at this 167 168 func randSig() []byte { 169 sig := randentropy.GetEntropyMixed(65) 170 sig[32] &= 0x70 171 sig[64] %= 4 172 return sig 173 } 174 175 func Test_Secp256_06a_alt0(t *testing.T) { 176 pubkey1, seckey := GenerateKeyPair() 177 msg := randentropy.GetEntropyMixed(32) 178 sig, _ := Sign(msg, seckey) 179 180 if sig == nil { 181 t.Fail() 182 } 183 if len(sig) != 65 { 184 t.Fail() 185 } 186 for i := 0; i < TESTS; i++ { 187 sig = randSig() 188 pubkey2, _ := RecoverPubkey(msg, sig) 189 190 if bytes.Equal(pubkey1, pubkey2) == true { 191 t.Fail() 192 } 193 194 if pubkey2 != nil && VerifySignature(msg, sig, pubkey2) != nil { 195 t.Fail() 196 } 197 198 if VerifySignature(msg, sig, pubkey1) == nil { 199 t.Fail() 200 } 201 } 202 } 203 204 //test random messages against valid signature: should fail 205 206 func Test_Secp256_06b(t *testing.T) { 207 pubkey1, seckey := GenerateKeyPair() 208 msg := randentropy.GetEntropyMixed(32) 209 sig, _ := Sign(msg, seckey) 210 211 fail_count := 0 212 for i := 0; i < TESTS; i++ { 213 msg = randentropy.GetEntropyMixed(32) 214 pubkey2, _ := RecoverPubkey(msg, sig) 215 if bytes.Equal(pubkey1, pubkey2) == true { 216 t.Fail() 217 } 218 219 if pubkey2 != nil && VerifySignature(msg, sig, pubkey2) != nil { 220 t.Fail() 221 } 222 223 if VerifySignature(msg, sig, pubkey1) == nil { 224 t.Fail() 225 } 226 } 227 if fail_count != 0 { 228 fmt.Printf("ERROR: Accepted signature for %v of %v random messages\n", fail_count, TESTS) 229 } 230 } 231 232 func TestInvalidKey(t *testing.T) { 233 p1 := make([]byte, 32) 234 err := VerifySeckeyValidity(p1) 235 if err == nil { 236 t.Errorf("pvk %x varify sec key should have returned error", p1) 237 } 238 }