diff --git a/.gitignore b/.gitignore
index 3219bdb..f46854f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,7 +3,6 @@
*.dll
*.so
*.dylib
-*.idea
# Test binary, build with `go test -c`
*.test
@@ -13,3 +12,5 @@
# Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
.glide/
+
+.idea/
diff --git a/README.md b/README.md
index 491dc68..d41dac9 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,36 @@
# gowallet
-A bitcoin wallet application written in golang.
+
+A bitcoin wallet application written in golang.
+Supports random wallet and brain wallet.
+
+The brain wallet uses a secret phrase and a salt phrase to generate the private key.
+
+Secret phrase at least 16 characters, containing uppercase letters, lowercase letters, numbers, and special characters.
+Salt phrase at least 6 characters.
+
+The secret phrase and the salt phrase support a hex notation similar to '\xFF' or '\xff' to represent a character.
+
+It is advisable to use more complex secret phrases and to write secret phrases on paper.
+It is also recommended that salt phrases be memorized in the brain.
+
+
+Usage of address:
+ -b Brain wallet mode.
+ -brain
+ Brain wallet mode.
+ -o string
+ Output file name.
+ -output string
+ Output file name.
+
+
+# go钱包
+go钱包是用GO语言编写的比特币钱包软件。支持随机钱包和脑钱包。
+
+**脑钱包使用一个秘密短语和一个盐短语生成私钥。**
+秘密短语至少16个字符，包含大写字母，小写字母，数字和特殊字符。
+盐短语至少6个字符。
+秘密短语和盐短语允许使用类似于'\xFF'这样的十六进制表示法表示一个字符
+
+建议使用较为复杂的秘密短语并将秘密短语记在纸上。
+同时建议将盐短语记在脑中。
diff --git a/address.go b/address.go
index fc46650..7c9c90c 100644
--- a/address.go
+++ b/address.go
@@ -2,137 +2,115 @@ package main
import (
"bytes"
+ "crypto/rand"
"crypto/sha1"
"crypto/sha256"
+ "encoding/hex"
"errors"
"flag"
"fmt"
"io/ioutil"
- "crypto/rand"
"os"
"regexp"
- "syscall"
- "./secp256k1/bitecdsa"
- "./secp256k1/bitelliptic"
"github.com/btcsuite/btcutil/base58"
"github.com/fatih/color"
+ "github.com/njones/bitcoin-crypto/bitelliptic"
"golang.org/x/crypto/pbkdf2"
"golang.org/x/crypto/ripemd160"
"golang.org/x/crypto/scrypt"
"golang.org/x/crypto/ssh/terminal"
)
-// WarpWallet encryption:
-// 1. s1 ← scrypt(key=passphrase||0x1, salt=salt||0x1, N=218, r=8, p=1, dkLen=32)
-// 2. s2 ← PBKDF2(key=passphrase||0x2, salt=salt||0x2, c=216, dkLen=32)
-// 3. private_key ← s1 ⊕ s2
-// 4. Generate public_key from private_key using standard Bitcoin EC crypto
-// 5. Output (private_key, public_key)
-
-//脑钱包使用一个秘密短语和一个盐短语生成私钥。
-//秘密短语至少16个字符，包含大写字母，小写字母，数字和特殊字符。
-//盐短语至少6个字符。
-//建议使用较为复杂的秘密短语并将秘密短语记在纸上。
-//同时建议将盐短语记在脑中。
-
const brainWalletTip = `
The brain wallet uses a secret phrase and a salt phrase to generate the private key.
Secret phrase at least 16 characters, containing uppercase letters, lowercase letters, numbers, and special characters.
Salt phrase at least 6 characters.
+Secret phrases and salt phrases allow the use of hexadecimal notation similar to ' \xff ' to represent a character.
It is advisable to use more complex secret phrases and to write secret phrases on paper.
It is also recommended that salt phrases be memorized in the brain.`
-const debug = true
+const debug = false
//Parse command line parameters
-func parseCommandParams() (private string, brain bool, output string) {
- flag.StringVar(&private, "private", "", "Private key wif string for test.")
+func parseCommandParams() (brain bool, output string) {
flag.BoolVar(&brain, "brain", false, "Brain wallet mode.")
- flag.BoolVar(&brain, "b", false, "...")
+ flag.BoolVar(&brain, "b", false, "Brain wallet mode.")
- flag.StringVar(&output, "output", "", "Output file name. (optional)")
- flag.StringVar(&output, "o", "", "...")
+ flag.StringVar(&output, "output", "", "Output file name.")
+ flag.StringVar(&output, "o", "", "Output file name.")
flag.Parse()
return
}
func main() {
- private, brain, output := parseCommandParams()
-
- var private_key [32]byte
- if private == "" {
- if brain == true {
- // Brain wallet
- secret, salt, err := inputBrainWalletSecret(brainWalletTip)
- if err != nil {
- println(err.Error())
- return
- }
- //secret, salt = []byte("www.aiportal.net"), []byte("aiportal")
- private_key, err = generateBrainWalletKey(secret, salt)
- if err != nil {
- println(err.Error())
- return
- }
- } else {
- // Random private key.
- private_key_bytes, err := generateRandomBytes(32)
- if err == nil {
- copy(private_key[:], private_key_bytes)
- } else {
- println(err)
- return
- }
+ brain, output := parseCommandParams()
+
+ var seed []byte
+ if brain == true {
+ // Brain wallet
+ secret, salt, err := inputBrainWalletSecret(brainWalletTip)
+ if err != nil {
+ return
+ }
+ seed, err = generateBrainWalletSeed(secret, salt)
+ if err != nil {
+ println(err.Error())
+ return
}
} else {
- // Private key from WIF string.
- private_key_bytes, _, _ := base58.CheckDecode(private)
- copy(private_key[:], private_key_bytes)
+ // Random wallet.
+ var err error
+ seed, err = generateRandomBytes(32)
+ if err != nil {
+ println(err.Error())
+ return
+ }
}
- private_wif := base58.CheckEncode(private_key[:], 0x80)
+ private_wif, address_wif, err := GenerateWalletWif(seed)
+ if err != nil {
+ println(err.Error())
+ return
+ }
+ println("")
println("private: " + private_wif)
-
- public_key := computePublicKey(private_key)
- public_wif := base58.CheckEncode(public_key[:], 0x00)
- println("address: " + public_wif)
+ println("address: " + address_wif)
if output != "" {
- err := ioutil.WriteFile(output, []byte(public_wif), os.ModeAppend)
+ ln := fmt.Sprintf("private: %s\naddress: %s", private_wif, address_wif)
+ err := ioutil.WriteFile(output, []byte(ln), os.ModeAppend)
if err != nil {
- fmt.Printf("Failed to write to file. %s", err)
+ println(err.Error())
}
}
}
-// Compute the public key from private key.
-func computePublicKey(privateKey [32]byte) []byte {
-
- reader := bytes.NewReader(privateKey[:])
- key, err := bitecdsa.GenerateKey(bitelliptic.S256(), reader)
+// Generate wallet private key and address
+func GenerateWalletWif(seed []byte) (privateWif string, addressWif string, err error) {
+ reader := bytes.NewReader(seed)
+ private_bytes, x, y, err := bitelliptic.S256().GenerateKey(reader)
if err != nil {
- println(err)
- return []byte{}
+ return
}
+ privateWif = base58.CheckEncode(private_bytes, 0x80)
- var public_key = [65]byte{0x04}
- x_bytes := key.X.Bytes()
- y_bytes := key.Y.Bytes()
- copy(public_key[33-len(x_bytes):], x_bytes)
- copy(public_key[65-len(y_bytes):], y_bytes)
+ var public_bytes = [65]byte{0x04}
+ copy(public_bytes[33 - len(x.Bytes()):], x.Bytes())
+ copy(public_bytes[65 - len(y.Bytes()):], y.Bytes())
- public_key_sha := sha256.Sum256(public_key[:])
+ public_sha := sha256.Sum256(public_bytes[:])
ripeHash := ripemd160.New()
- ripeHash.Write(public_key_sha[:])
- public_key_ripe := ripeHash.Sum(nil)
+ ripeHash.Write(public_sha[:])
+ public_ripe := ripeHash.Sum(nil)
- return public_key_ripe[:]
+ addressWif = base58.CheckEncode(public_ripe, 0x00)
+ return
}
//Generate secure random private key seed.
@@ -154,6 +132,7 @@ func inputBrainWalletSecret(tip string) (secret []byte, salt []byte, err error)
color.Yellow(tip)
println("")
+ terminal.MakeRaw(int(os.Stdin.Fd()))
t := terminal.NewTerminal(os.Stdin, "")
// Secret
@@ -196,7 +175,7 @@ func inputBrainWalletSecret(tip string) (secret []byte, salt []byte, err error)
}
if debug { print(salt1) }
println("")
- if len(salt1) < 6 {
+ if len(escapeHexString(salt1)) < 6 {
color.HiRed(" Salt at least 6 characters.")
err = errInput
return
@@ -217,6 +196,10 @@ func inputBrainWalletSecret(tip string) (secret []byte, salt []byte, err error)
secret = escapeHexString(secret1)
salt = escapeHexString(salt1)
+ if debug {
+ fmt.Printf("secret: %X\n", secret)
+ fmt.Printf("salt: %X\n", salt)
+ }
return
}
@@ -238,20 +221,29 @@ func escapeHexString(str string) []byte {
}
//Check secret strength
-func checkSecretStrength(secret string) (valid bool) {
+func checkSecretStrength(secret string) bool {
number, _ := regexp.MatchString("[0-9]+", secret)
lower, _ := regexp.MatchString("[a-z]+", secret)
upper, _ := regexp.MatchString("[A-Z]+", secret)
special, _ := regexp.MatchString("[^0-9a-zA-Z ]", secret)
- valid = number && lower && upper && special
- return
+ return number && lower && upper && special
}
-// Generate private key from secret and salt
-func generateBrainWalletKey(secret []byte, salt []byte) (key [32]byte, err error) {
-
- if len(secret) == 0 || len(salt) < 0 {
- err = errors.New("empty secret or salt")
+// Generate wallet seed from secret and salt
+func generateBrainWalletSeed(secret []byte, salt []byte) (seed []byte, err error) {
+ // WarpWallet encryption:
+ // 1. s1 ← scrypt(key=passphrase||0x1, salt=salt||0x1, N=218, r=8, p=1, dkLen=32)
+ // 2. s2 ← PBKDF2(key=passphrase||0x2, salt=salt||0x2, c=216, dkLen=32)
+ // 3. private_key ← s1 ⊕ s2
+ // 4. Generate public_key from private_key using standard Bitcoin EC crypto
+ // 5. Output (private_key, public_key)
+
+ if len(secret) == 0 {
+ err = errors.New("Empty secret")
+ return
+ }
+ if len(salt) < 0 {
+ err = errors.New("Empty salt")
return
}
@@ -261,32 +253,34 @@ func generateBrainWalletKey(secret []byte, salt []byte) (key [32]byte, err error
secret1[i] = v | 0x1
secret2[i] = v | 0x2
}
+
salt1 := make([]byte, len(salt))
salt2 := make([]byte, len(salt))
for i, v := range salt {
salt1[i] = v | 0x1
salt2[i] = v | 0x2
}
- key1, err := scrypt.Key(secret1, salt1, 16384, 8, 1, 32)
+
+ s1, err := scrypt.Key(secret1, salt1, 16384, 8, 1, 32)
if err != nil {
return
}
- key2 := pbkdf2.Key(secret2, salt2, 4096, 32, sha1.New)
+ s2 := pbkdf2.Key(secret2, salt2, 4096, 32, sha1.New)
- pk1, err := bitecdsa.GenerateKey(bitelliptic.S256(), bytes.NewReader(key1))
+ _, x1, y1, err := bitelliptic.S256().GenerateKey(bytes.NewReader(s1))
if err != nil {
return
}
- pk2, err := bitecdsa.GenerateKey(bitelliptic.S256(), bytes.NewReader(key2))
+ _, x2, y2, err := bitelliptic.S256().GenerateKey(bytes.NewReader(s2))
if err != nil {
return
}
- x, y := bitelliptic.S256().Add(pk1.X, pk1.Y, pk2.X, pk2.Y)
- key_bytes := []byte{0x04}
- key_bytes = append(key_bytes, x.Bytes()...)
- key_bytes = append(key_bytes, y.Bytes()...)
- key = sha256.Sum256(key_bytes[:])
+ x, y := bitelliptic.S256().Add(x1, y1, x2, y2)
+
+ seed = []byte{0x04}
+ seed = append(seed, x.Bytes()...)
+ seed = append(seed, y.Bytes()...)
return
}
diff --git a/secp256k1/bitecdsa/bitecdsa.go b/secp256k1/bitecdsa/bitecdsa.go
deleted file mode 100644
index d3cc7b3..0000000
--- a/secp256k1/bitecdsa/bitecdsa.go
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Copyright 2011 ThePiachu. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package ecdsa implements the Elliptic Curve Digital Signature Algorithm, as
-// defined in FIPS 186-3.
-package bitecdsa
-
-// References:
-// [NSA]: Suite B implementor's guide to FIPS 186-3,
-// http://www.nsa.gov/ia/_files/ecdsa.pdf
-// [SECG]: SECG, SEC1
-// http://www.secg.org/download/aid-780/sec1-v2.pdf
-
-import (
- "../bitelliptic"
- "io"
- "math/big"
-)
-
-// PublicKey represents an ECDSA public key.
-type PublicKey struct {
- *bitelliptic.BitCurve
- X, Y *big.Int
-}
-
-// PrivateKey represents a ECDSA private key.
-type PrivateKey struct {
- PublicKey
- D *big.Int
-}
-
-var one = new(big.Int).SetInt64(1)
-
-// randFieldElement returns a random element of the field underlying the given
-// curve using the procedure given in [NSA] A.2.1.
-func randFieldElement(c *bitelliptic.BitCurve, rand io.Reader) (k *big.Int, err error) {
- b := make([]byte, c.BitSize/8)
- _, err = io.ReadFull(rand, b)
- if err != nil {
- return
- }
-
- k = new(big.Int).SetBytes(b)
- //n := new(big.Int).Sub(c.N, one)
- //k.Mod(k, n)
- //k.Add(k, one)
- return
-}
-
-// GenerateKey generates a public&private key pair.
-func GenerateKey(c *bitelliptic.BitCurve, rand io.Reader) (priv *PrivateKey, err error) {
- k, err := randFieldElement(c, rand)
- if err != nil {
- return
- }
-
- priv = new(PrivateKey)
- priv.PublicKey.BitCurve = c
- priv.D = k
- priv.PublicKey.X, priv.PublicKey.Y = c.ScalarBaseMult(k.Bytes())
- return
-}
-
-// hashToInt converts a hash value to an integer. There is some disagreement
-// about how this is done. [NSA] suggests that this is done in the obvious
-// manner, but [SECG] truncates the hash to the bit-length of the curve order
-// first. We follow [SECG] because that's what OpenSSL does.
-func hashToInt(hash []byte, c *bitelliptic.BitCurve) *big.Int {
- orderBits := c.N.BitLen()
- orderBytes := (orderBits + 7) / 8
- if len(hash) > orderBytes {
- hash = hash[:orderBytes]
- }
-
- ret := new(big.Int).SetBytes(hash)
- excess := orderBytes*8 - orderBits
- if excess > 0 {
- ret.Rsh(ret, uint(excess))
- }
- return ret
-}
-
-// Sign signs an arbitrary length hash (which should be the result of hashing a
-// larger message) using the private key, priv. It returns the signature as a
-// pair of integers. The security of the private key depends on the entropy of
-// rand.
-func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err error) {
- // See [NSA] 3.4.1
- c := priv.PublicKey.BitCurve
-
- var k, kInv *big.Int
- for {
- for {
- k, err = randFieldElement(c, rand)
- if err != nil {
- r = nil
- return
- }
-
- kInv = new(big.Int).ModInverse(k, c.N)
- r, _ = priv.BitCurve.ScalarBaseMult(k.Bytes())
- r.Mod(r, priv.BitCurve.N)
- if r.Sign() != 0 {
- break
- }
- }
-
- e := hashToInt(hash, c)
- s = new(big.Int).Mul(priv.D, r)
- s.Add(s, e)
- s.Mul(s, kInv)
- s.Mod(s, priv.PublicKey.BitCurve.N)
- if s.Sign() != 0 {
- break
- }
- }
-
- return
-}
-
-// Verify verifies the signature in r, s of hash using the public key, pub. It
-// returns true iff the signature is valid.
-func Verify(pub *PublicKey, hash []byte, r, s *big.Int) bool {
- // See [NSA] 3.4.2
- c := pub.BitCurve
-
- if r.Sign() == 0 || s.Sign() == 0 {
- return false
- }
- if r.Cmp(c.N) >= 0 || s.Cmp(c.N) >= 0 {
- return false
- }
- e := hashToInt(hash, c)
- w := new(big.Int).ModInverse(s, c.N)
-
- u1 := e.Mul(e, w)
- u2 := w.Mul(r, w)
-
- x1, y1 := c.ScalarBaseMult(u1.Bytes())
- x2, y2 := c.ScalarMult(pub.X, pub.Y, u2.Bytes())
- if x1.Cmp(x2) == 0 {
- return false
- }
- x, _ := c.Add(x1, y1, x2, y2)
- x.Mod(x, c.N)
- return x.Cmp(r) == 0
-}
diff --git a/secp256k1/bitecdsa/bitecdsa_test.go b/secp256k1/bitecdsa/bitecdsa_test.go
deleted file mode 100644
index 53f992a..0000000
--- a/secp256k1/bitecdsa/bitecdsa_test.go
+++ /dev/null
@@ -1,228 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Copyright 2011 ThePiachu. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bitecdsa
-
-import (
- "big"
- "bitelliptic"
- "crypto/rand"
- "crypto/sha1"
- "encoding/hex"
- "testing"
-)
-
-func testKeyGeneration(t *testing.T, c *bitelliptic.BitCurve, tag string) {
- priv, err := GenerateKey(c, rand.Reader)
- if err != nil {
- t.Errorf("%s: error: %s", tag, err)
- return
- }
- if !c.IsOnCurve(priv.PublicKey.X, priv.PublicKey.Y) {
- t.Errorf("%s: public key invalid: %s", tag, err)
- }
-}
-
-func TestKeyGeneration(t *testing.T) {
- testKeyGeneration(t, bitelliptic.S256(), "S256")
- if testing.Short() {
- return
- }
- testKeyGeneration(t, bitelliptic.S160(), "S160")
- testKeyGeneration(t, bitelliptic.S192(), "S192")
- testKeyGeneration(t, bitelliptic.S224(), "S224")
-}
-
-func testSignAndVerify(t *testing.T, c *bitelliptic.BitCurve, tag string) {
- priv, _ := GenerateKey(c, rand.Reader)
-
- hashed := []byte("testing")
- r, s, err := Sign(rand.Reader, priv, hashed)
- if err != nil {
- t.Errorf("%s: error signing: %s", tag, err)
- return
- }
-
- if !Verify(&priv.PublicKey, hashed, r, s) {
- t.Errorf("%s: Verify failed", tag)
- }
-
- hashed[0] ^= 0xff
- if Verify(&priv.PublicKey, hashed, r, s) {
- t.Errorf("%s: Verify always works!", tag)
- }
-}
-
-func TestSignAndVerify(t *testing.T) {
- testSignAndVerify(t, bitelliptic.S256(), "S256")
- if testing.Short() {
- return
- }
- testSignAndVerify(t, bitelliptic.S160(), "S160")
- testSignAndVerify(t, bitelliptic.S192(), "S192")
- testSignAndVerify(t, bitelliptic.S224(), "S224")
-}
-
-func fromHex(s string) *big.Int {
- r, ok := new(big.Int).SetString(s, 16)
- if !ok {
- panic("bad hex")
- }
- return r
-}
-
-// These test vectors were taken from
-// http://csrc.nist.gov/groups/STM/cavp/documents/dss/ecdsatestvectors.zip
-var testVectors = []struct {
- msg string
- Qx, Qy string
- r, s string
- ok bool
-}{
- {
- "09626b45493672e48f3d1226a3aff3201960e577d33a7f72c7eb055302db8fe8ed61685dd036b554942a5737cd1512cdf811ee0c00e6dd2f08c69f08643be396e85dafda664801e772cdb7396868ac47b172245b41986aa2648cb77fbbfa562581be06651355a0c4b090f9d17d8f0ab6cced4e0c9d386cf465a516630f0231bd",
- "9504b5b82d97a264d8b3735e0568decabc4b6ca275bc53cbadfc1c40",
- "03426f80e477603b10dee670939623e3da91a94267fc4e51726009ed",
- "81d3ac609f9575d742028dd496450a58a60eea2dcf8b9842994916e1",
- "96a8c5f382c992e8f30ccce9af120b067ec1d74678fa8445232f75a5",
- false,
- },
- {
- "96b2b6536f6df29be8567a72528aceeaccbaa66c66c534f3868ca9778b02faadb182e4ed34662e73b9d52ecbe9dc8e875fc05033c493108b380689ebf47e5b062e6a0cdb3dd34ce5fe347d92768d72f7b9b377c20aea927043b509c078ed2467d7113405d2ddd458811e6faf41c403a2a239240180f1430a6f4330df5d77de37",
- "851e3100368a22478a0029353045ae40d1d8202ef4d6533cfdddafd8",
- "205302ac69457dd345e86465afa72ee8c74ca97e2b0b999aec1f10c2",
- "4450c2d38b697e990721aa2dbb56578d32b4f5aeb3b9072baa955ee0",
- "e26d4b589166f7b4ba4b1c8fce823fa47aad22f8c9c396b8c6526e12",
- false,
- },
- {
- "86778dbb4a068a01047a8d245d632f636c11d2ad350740b36fad90428b454ad0f120cb558d12ea5c8a23db595d87543d06d1ef489263d01ee529871eb68737efdb8ff85bc7787b61514bed85b7e01d6be209e0a4eb0db5c8df58a5c5bf706d76cb2bdf7800208639e05b89517155d11688236e6a47ed37d8e5a2b1e0adea338e",
- "ad5bda09d319a717c1721acd6688d17020b31b47eef1edea57ceeffc",
- "c8ce98e181770a7c9418c73c63d01494b8b80a41098c5ea50692c984",
- "de5558c257ab4134e52c19d8db3b224a1899cbd08cc508ce8721d5e9",
- "745db7af5a477e5046705c0a5eff1f52cb94a79d481f0c5a5e108ecd",
- true,
- },
- {
- "4bc6ef1958556686dab1e39c3700054a304cbd8f5928603dcd97fafd1f29e69394679b638f71c9344ce6a535d104803d22119f57b5f9477e253817a52afa9bfbc9811d6cc8c8be6b6566c6ef48b439bbb532abe30627548c598867f3861ba0b154dc1c3deca06eb28df8efd28258554b5179883a36fbb1eecf4f93ee19d41e3d",
- "cc5eea2edf964018bdc0504a3793e4d2145142caa09a72ac5fb8d3e8",
- "a48d78ae5d08aa725342773975a00d4219cf7a8029bb8cf3c17c374a",
- "67b861344b4e416d4094472faf4272f6d54a497177fbc5f9ef292836",
- "1d54f3fcdad795bf3b23408ecbac3e1321d1d66f2e4e3d05f41f7020",
- false,
- },
- {
- "bb658732acbf3147729959eb7318a2058308b2739ec58907dd5b11cfa3ecf69a1752b7b7d806fe00ec402d18f96039f0b78dbb90a59c4414fb33f1f4e02e4089de4122cd93df5263a95be4d7084e2126493892816e6a5b4ed123cb705bf930c8f67af0fb4514d5769232a9b008a803af225160ce63f675bd4872c4c97b146e5e",
- "6234c936e27bf141fc7534bfc0a7eedc657f91308203f1dcbd642855",
- "27983d87ca785ef4892c3591ef4a944b1deb125dd58bd351034a6f84",
- "e94e05b42d01d0b965ffdd6c3a97a36a771e8ea71003de76c4ecb13f",
- "1dc6464ffeefbd7872a081a5926e9fc3e66d123f1784340ba17737e9",
- false,
- },
- {
- "7c00be9123bfa2c4290be1d8bc2942c7f897d9a5b7917e3aabd97ef1aab890f148400a89abd554d19bec9d8ed911ce57b22fbcf6d30ca2115f13ce0a3f569a23bad39ee645f624c49c60dcfc11e7d2be24de9c905596d8f23624d63dc46591d1f740e46f982bfae453f107e80db23545782be23ce43708245896fc54e1ee5c43",
- "9f3f037282aaf14d4772edffff331bbdda845c3f65780498cde334f1",
- "8308ee5a16e3bcb721b6bc30000a0419bc1aaedd761be7f658334066",
- "6381d7804a8808e3c17901e4d283b89449096a8fba993388fa11dc54",
- "8e858f6b5b253686a86b757bad23658cda53115ac565abca4e3d9f57",
- false,
- },
- {
- "cffc122a44840dc705bb37130069921be313d8bde0b66201aebc48add028ca131914ef2e705d6bedd19dc6cf9459bbb0f27cdfe3c50483808ffcdaffbeaa5f062e097180f07a40ef4ab6ed03fe07ed6bcfb8afeb42c97eafa2e8a8df469de07317c5e1494c41547478eff4d8c7d9f0f484ad90fedf6e1c35ee68fa73f1691601",
- "a03b88a10d930002c7b17ca6af2fd3e88fa000edf787dc594f8d4fd4",
- "e0cf7acd6ddc758e64847fe4df9915ebda2f67cdd5ec979aa57421f5",
- "387b84dcf37dc343c7d2c5beb82f0bf8bd894b395a7b894565d296c1",
- "4adc12ce7d20a89ce3925e10491c731b15ddb3f339610857a21b53b4",
- false,
- },
- {
- "26e0e0cafd85b43d16255908ccfd1f061c680df75aba3081246b337495783052ba06c60f4a486c1591a4048bae11b4d7fec4f161d80bdc9a7b79d23e44433ed625eab280521a37f23dd3e1bdc5c6a6cfaa026f3c45cf703e76dab57add93fe844dd4cda67dc3bddd01f9152579e49df60969b10f09ce9372fdd806b0c7301866",
- "9a8983c42f2b5a87c37a00458b5970320d247f0c8a88536440173f7d",
- "15e489ec6355351361900299088cfe8359f04fe0cab78dde952be80c",
- "929a21baa173d438ec9f28d6a585a2f9abcfc0a4300898668e476dc0",
- "59a853f046da8318de77ff43f26fe95a92ee296fa3f7e56ce086c872",
- true,
- },
- {
- "1078eac124f48ae4f807e946971d0de3db3748dd349b14cca5c942560fb25401b2252744f18ad5e455d2d97ed5ae745f55ff509c6c8e64606afe17809affa855c4c4cdcaf6b69ab4846aa5624ed0687541aee6f2224d929685736c6a23906d974d3c257abce1a3fb8db5951b89ecb0cda92b5207d93f6618fd0f893c32cf6a6e",
- "d6e55820bb62c2be97650302d59d667a411956138306bd566e5c3c2b",
- "631ab0d64eaf28a71b9cbd27a7a88682a2167cee6251c44e3810894f",
- "65af72bc7721eb71c2298a0eb4eed3cec96a737cc49125706308b129",
- "bd5a987c78e2d51598dbd9c34a9035b0069c580edefdacee17ad892a",
- false,
- },
- {
- "919deb1fdd831c23481dfdb2475dcbe325b04c34f82561ced3d2df0b3d749b36e255c4928973769d46de8b95f162b53cd666cad9ae145e7fcfba97919f703d864efc11eac5f260a5d920d780c52899e5d76f8fe66936ff82130761231f536e6a3d59792f784902c469aa897aabf9a0678f93446610d56d5e0981e4c8a563556b",
- "269b455b1024eb92d860a420f143ac1286b8cce43031562ae7664574",
- "baeb6ca274a77c44a0247e5eb12ca72bdd9a698b3f3ae69c9f1aaa57",
- "cb4ec2160f04613eb0dfe4608486091a25eb12aa4dec1afe91cfb008",
- "40b01d8cd06589481574f958b98ca08ade9d2a8fe31024375c01bb40",
- false,
- },
- {
- "6e012361250dacf6166d2dd1aa7be544c3206a9d43464b3fcd90f3f8cf48d08ec099b59ba6fe7d9bdcfaf244120aed1695d8be32d1b1cd6f143982ab945d635fb48a7c76831c0460851a3d62b7209c30cd9c2abdbe3d2a5282a9fcde1a6f418dd23c409bc351896b9b34d7d3a1a63bbaf3d677e612d4a80fa14829386a64b33f",
- "6d2d695efc6b43b13c14111f2109608f1020e3e03b5e21cfdbc82fcd",
- "26a4859296b7e360b69cf40be7bd97ceaffa3d07743c8489fc47ca1b",
- "9a8cb5f2fdc288b7183c5b32d8e546fc2ed1ca4285eeae00c8b572ad",
- "8c623f357b5d0057b10cdb1a1593dab57cda7bdec9cf868157a79b97",
- true,
- },
- {
- "bf6bd7356a52b234fe24d25557200971fc803836f6fec3cade9642b13a8e7af10ab48b749de76aada9d8927f9b12f75a2c383ca7358e2566c4bb4f156fce1fd4e87ef8c8d2b6b1bdd351460feb22cdca0437ac10ca5e0abbbce9834483af20e4835386f8b1c96daaa41554ceee56730aac04f23a5c765812efa746051f396566",
- "14250131b2599939cf2d6bc491be80ddfe7ad9de644387ee67de2d40",
- "b5dc473b5d014cd504022043c475d3f93c319a8bdcb7262d9e741803",
- "4f21642f2201278a95339a80f75cc91f8321fcb3c9462562f6cbf145",
- "452a5f816ea1f75dee4fd514fa91a0d6a43622981966c59a1b371ff8",
- false,
- },
- {
- "0eb7f4032f90f0bd3cf9473d6d9525d264d14c031a10acd31a053443ed5fe919d5ac35e0be77813071b4062f0b5fdf58ad5f637b76b0b305aec18f82441b6e607b44cdf6e0e3c7c57f24e6fd565e39430af4a6b1d979821ed0175fa03e3125506847654d7e1ae904ce1190ae38dc5919e257bdac2db142a6e7cd4da6c2e83770",
- "d1f342b7790a1667370a1840255ac5bbbdc66f0bc00ae977d99260ac",
- "76416cabae2de9a1000b4646338b774baabfa3db4673790771220cdb",
- "bc85e3fc143d19a7271b2f9e1c04b86146073f3fab4dda1c3b1f35ca",
- "9a5c70ede3c48d5f43307a0c2a4871934424a3303b815df4bb0f128e",
- false,
- },
- {
- "5cc25348a05d85e56d4b03cec450128727bc537c66ec3a9fb613c151033b5e86878632249cba83adcefc6c1e35dcd31702929c3b57871cda5c18d1cf8f9650a25b917efaed56032e43b6fc398509f0d2997306d8f26675f3a8683b79ce17128e006aa0903b39eeb2f1001be65de0520115e6f919de902b32c38d691a69c58c92",
- "7e49a7abf16a792e4c7bbc4d251820a2abd22d9f2fc252a7bf59c9a6",
- "44236a8fb4791c228c26637c28ae59503a2f450d4cfb0dc42aa843b9",
- "084461b4050285a1a85b2113be76a17878d849e6bc489f4d84f15cd8",
- "079b5bddcc4d45de8dbdfd39f69817c7e5afa454a894d03ee1eaaac3",
- false,
- },
- {
- "1951533ce33afb58935e39e363d8497a8dd0442018fd96dff167b3b23d7206a3ee182a3194765df4768a3284e23b8696c199b4686e670d60c9d782f08794a4bccc05cffffbd1a12acd9eb1cfa01f7ebe124da66ecff4599ea7720c3be4bb7285daa1a86ebf53b042bd23208d468c1b3aa87381f8e1ad63e2b4c2ba5efcf05845",
- "31945d12ebaf4d81f02be2b1768ed80784bf35cf5e2ff53438c11493",
- "a62bebffac987e3b9d3ec451eb64c462cdf7b4aa0b1bbb131ceaa0a4",
- "bc3c32b19e42b710bca5c6aaa128564da3ddb2726b25f33603d2af3c",
- "ed1a719cc0c507edc5239d76fe50e2306c145ad252bd481da04180c0",
- false,
- },
-}
-
-func TestVectors(t *testing.T) {
- sha := sha1.New()
-
- for i, test := range testVectors {
- pub := PublicKey{
- BitCurve: bitelliptic.S256(),
- X: fromHex(test.Qx),
- Y: fromHex(test.Qy),
- }
- msg, _ := hex.DecodeString(test.msg)
- sha.Reset()
- sha.Write(msg)
- hashed := sha.Sum()
- r := fromHex(test.r)
- s := fromHex(test.s)
- if Verify(&pub, hashed, r, s) != test.ok {
- t.Errorf("%d: bad result", i)
- }
- if testing.Short() {
- break
- }
- }
-}
diff --git a/secp256k1/bitelliptic/bitelliptic.go b/secp256k1/bitelliptic/bitelliptic.go
deleted file mode 100644
index 36884d6..0000000
--- a/secp256k1/bitelliptic/bitelliptic.go
+++ /dev/null
@@ -1,358 +0,0 @@
-package bitelliptic
-
-// Copyright 2010 The Go Authors. All rights reserved.
-// Copyright 2011 ThePiachu. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package bitelliptic implements several Koblitz elliptic curves over prime
-// fields.
-
-// This package operates, internally, on Jacobian coordinates. For a given
-// (x, y) position on the curve, the Jacobian coordinates are (x1, y1, z1)
-// where x = x1/z1² and y = y1/z1³. The greatest speedups come when the whole
-// calculation can be performed within the transform (as in ScalarMult and
-// ScalarBaseMult). But even for Add and Double, it's faster to apply and
-// reverse the transform than to operate in affine coordinates.
-
-import (
- "io"
- "math/big"
- "sync"
-)
-
-// A BitCurve represents a Koblitz Curve with a=0.
-// See http://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
-type BitCurve struct {
- P *big.Int // the order of the underlying field
- N *big.Int // the order of the base point
- B *big.Int // the constant of the BitCurve equation
- Gx, Gy *big.Int // (x,y) of the base point
- BitSize int // the size of the underlying field
-}
-
-// IsOnBitCurve returns true if the given (x,y) lies on the BitCurve.
-func (BitCurve *BitCurve) IsOnCurve(x, y *big.Int) bool {
- // y² = x³ + b
- y2 := new(big.Int).Mul(y, y) //y²
- y2.Mod(y2, BitCurve.P) //y²%P
-
- x3 := new(big.Int).Mul(x, x) //x²
- x3.Mul(x3, x) //x³
-
- x3.Add(x3, BitCurve.B) //x³+B
- x3.Mod(x3, BitCurve.P) //(x³+B)%P
-
- return x3.Cmp(y2) == 0
-}
-
-//TODO: double check if the function is okay
-// affineFromJacobian reverses the Jacobian transform. See the comment at the
-// top of the file.
-func (BitCurve *BitCurve) affineFromJacobian(x, y, z *big.Int) (xOut, yOut *big.Int) {
- zinv := new(big.Int).ModInverse(z, BitCurve.P)
- zinvsq := new(big.Int).Mul(zinv, zinv)
-
- xOut = new(big.Int).Mul(x, zinvsq)
- xOut.Mod(xOut, BitCurve.P)
- zinvsq.Mul(zinvsq, zinv)
- yOut = new(big.Int).Mul(y, zinvsq)
- yOut.Mod(yOut, BitCurve.P)
- return
-}
-
-// Add returns the sum of (x1,y1) and (x2,y2)
-func (BitCurve *BitCurve) Add(x1, y1, x2, y2 *big.Int) (*big.Int, *big.Int) {
- z := new(big.Int).SetInt64(1)
- return BitCurve.affineFromJacobian(BitCurve.addJacobian(x1, y1, z, x2, y2, z))
-}
-
-// addJacobian takes two points in Jacobian coordinates, (x1, y1, z1) and
-// (x2, y2, z2) and returns their sum, also in Jacobian form.
-func (BitCurve *BitCurve) addJacobian(x1, y1, z1, x2, y2, z2 *big.Int) (*big.Int, *big.Int, *big.Int) {
- // See http://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#addition-add-2007-bl
- z1z1 := new(big.Int).Mul(z1, z1)
- z1z1.Mod(z1z1, BitCurve.P)
- z2z2 := new(big.Int).Mul(z2, z2)
- z2z2.Mod(z2z2, BitCurve.P)
-
- u1 := new(big.Int).Mul(x1, z2z2)
- u1.Mod(u1, BitCurve.P)
- u2 := new(big.Int).Mul(x2, z1z1)
- u2.Mod(u2, BitCurve.P)
- h := new(big.Int).Sub(u2, u1)
- if h.Sign() == -1 {
- h.Add(h, BitCurve.P)
- }
- i := new(big.Int).Lsh(h, 1)
- i.Mul(i, i)
- j := new(big.Int).Mul(h, i)
-
- s1 := new(big.Int).Mul(y1, z2)
- s1.Mul(s1, z2z2)
- s1.Mod(s1, BitCurve.P)
- s2 := new(big.Int).Mul(y2, z1)
- s2.Mul(s2, z1z1)
- s2.Mod(s2, BitCurve.P)
- r := new(big.Int).Sub(s2, s1)
- if r.Sign() == -1 {
- r.Add(r, BitCurve.P)
- }
- r.Lsh(r, 1)
- v := new(big.Int).Mul(u1, i)
-
- x3 := new(big.Int).Set(r)
- x3.Mul(x3, x3)
- x3.Sub(x3, j)
- x3.Sub(x3, v)
- x3.Sub(x3, v)
- x3.Mod(x3, BitCurve.P)
-
- y3 := new(big.Int).Set(r)
- v.Sub(v, x3)
- y3.Mul(y3, v)
- s1.Mul(s1, j)
- s1.Lsh(s1, 1)
- y3.Sub(y3, s1)
- y3.Mod(y3, BitCurve.P)
-
- z3 := new(big.Int).Add(z1, z2)
- z3.Mul(z3, z3)
- z3.Sub(z3, z1z1)
- if z3.Sign() == -1 {
- z3.Add(z3, BitCurve.P)
- }
- z3.Sub(z3, z2z2)
- if z3.Sign() == -1 {
- z3.Add(z3, BitCurve.P)
- }
- z3.Mul(z3, h)
- z3.Mod(z3, BitCurve.P)
-
- return x3, y3, z3
-}
-
-// Double returns 2*(x,y)
-func (BitCurve *BitCurve) Double(x1, y1 *big.Int) (*big.Int, *big.Int) {
- z1 := new(big.Int).SetInt64(1)
- return BitCurve.affineFromJacobian(BitCurve.doubleJacobian(x1, y1, z1))
-}
-
-// doubleJacobian takes a point in Jacobian coordinates, (x, y, z), and
-// returns its double, also in Jacobian form.
-func (BitCurve *BitCurve) doubleJacobian(x, y, z *big.Int) (*big.Int, *big.Int, *big.Int) {
- // See http://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#doubling-dbl-2009-l
-
- a := new(big.Int).Mul(x, x) //X1²
- b := new(big.Int).Mul(y, y) //Y1²
- c := new(big.Int).Mul(b, b) //B²
-
- d := new(big.Int).Add(x, b) //X1+B
- d.Mul(d, d) //(X1+B)²
- d.Sub(d, a) //(X1+B)²-A
- d.Sub(d, c) //(X1+B)²-A-C
- d.Mul(d, big.NewInt(2)) //2*((X1+B)²-A-C)
-
- e := new(big.Int).Mul(big.NewInt(3), a) //3*A
- f := new(big.Int).Mul(e, e) //E²
-
- x3 := new(big.Int).Mul(big.NewInt(2), d) //2*D
- x3.Sub(f, x3) //F-2*D
- x3.Mod(x3, BitCurve.P)
-
- y3 := new(big.Int).Sub(d, x3) //D-X3
- y3.Mul(e, y3) //E*(D-X3)
- y3.Sub(y3, new(big.Int).Mul(big.NewInt(8), c)) //E*(D-X3)-8*C
- y3.Mod(y3, BitCurve.P)
-
- z3 := new(big.Int).Mul(y, z) //Y1*Z1
- z3.Mul(big.NewInt(2), z3) //3*Y1*Z1
- z3.Mod(z3, BitCurve.P)
-
- return x3, y3, z3
-}
-
-//TODO: double check if it is okay
-// ScalarMult returns k*(Bx,By) where k is a number in big-endian form.
-func (BitCurve *BitCurve) ScalarMult(Bx, By *big.Int, k []byte) (*big.Int, *big.Int) {
- // We have a slight problem in that the identity of the group (the
- // point at infinity) cannot be represented in (x, y) form on a finite
- // machine. Thus the standard add/double algorithm has to be tweaked
- // slightly: our initial state is not the identity, but x, and we
- // ignore the first true bit in |k|. If we don't find any true bits in
- // |k|, then we return nil, nil, because we cannot return the identity
- // element.
-
- Bz := new(big.Int).SetInt64(1)
- x := Bx
- y := By
- z := Bz
-
- seenFirstTrue := false
- for _, byte := range k {
- for bitNum := 0; bitNum < 8; bitNum++ {
- if seenFirstTrue {
- x, y, z = BitCurve.doubleJacobian(x, y, z)
- }
- if byte&0x80 == 0x80 {
- if !seenFirstTrue {
- seenFirstTrue = true
- } else {
- x, y, z = BitCurve.addJacobian(Bx, By, Bz, x, y, z)
- }
- }
- byte <<= 1
- }
- }
-
- if !seenFirstTrue {
- return nil, nil
- }
-
- return BitCurve.affineFromJacobian(x, y, z)
-}
-
-// ScalarBaseMult returns k*G, where G is the base point of the group and k is
-// an integer in big-endian form.
-func (BitCurve *BitCurve) ScalarBaseMult(k []byte) (*big.Int, *big.Int) {
- return BitCurve.ScalarMult(BitCurve.Gx, BitCurve.Gy, k)
-}
-
-var mask = []byte{0xff, 0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f}
-
-//TODO: double check if it is okay
-// GenerateKey returns a public/private key pair. The private key is generated
-// using the given reader, which must return random data.
-func (BitCurve *BitCurve) GenerateKey(rand io.Reader) (priv []byte, x, y *big.Int, err error) {
- byteLen := (BitCurve.BitSize + 7) >> 3
- priv = make([]byte, byteLen)
-
- for x == nil {
- _, err = io.ReadFull(rand, priv)
- if err != nil {
- return
- }
- // We have to mask off any excess bits in the case that the size of the
- // underlying field is not a whole number of bytes.
- priv[0] &= mask[BitCurve.BitSize%8]
- // This is because, in tests, rand will return all zeros and we don't
- // want to get the point at infinity and loop forever.
- priv[1] ^= 0x42
- x, y = BitCurve.ScalarBaseMult(priv)
- }
- return
-}
-
-// Marshal converts a point into the form specified in section 4.3.6 of ANSI
-// X9.62.
-func (BitCurve *BitCurve) Marshal(x, y *big.Int) []byte {
- byteLen := (BitCurve.BitSize + 7) >> 3
-
- ret := make([]byte, 1+2*byteLen)
- ret[0] = 4 // uncompressed point
-
- xBytes := x.Bytes()
- copy(ret[1+byteLen-len(xBytes):], xBytes)
- yBytes := y.Bytes()
- copy(ret[1+2*byteLen-len(yBytes):], yBytes)
- return ret
-}
-
-// Unmarshal converts a point, serialised by Marshal, into an x, y pair. On
-// error, x = nil.
-func (BitCurve *BitCurve) Unmarshal(data []byte) (x, y *big.Int) {
- byteLen := (BitCurve.BitSize + 7) >> 3
- if len(data) != 1+2*byteLen {
- return
- }
- if data[0] != 4 { // uncompressed form
- return
- }
- x = new(big.Int).SetBytes(data[1 : 1+byteLen])
- y = new(big.Int).SetBytes(data[1+byteLen:])
- return
-}
-
-//curve parameters taken from:
-//http://www.secg.org/collateral/sec2_final.pdf
-
-var initonce sync.Once
-var secp160k1 *BitCurve
-var secp192k1 *BitCurve
-var secp224k1 *BitCurve
-var secp256k1 *BitCurve
-
-func initAll() {
- initS160()
- initS192()
- initS224()
- initS256()
-}
-
-func initS160() {
- // See SEC 2 section 2.4.1
- secp160k1 = new(BitCurve)
- secp160k1.P, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC73", 16)
- secp160k1.N, _ = new(big.Int).SetString("0100000000000000000001B8FA16DFAB9ACA16B6B3", 16)
- secp160k1.B, _ = new(big.Int).SetString("0000000000000000000000000000000000000007", 16)
- secp160k1.Gx, _ = new(big.Int).SetString("3B4C382CE37AA192A4019E763036F4F5DD4D7EBB", 16)
- secp160k1.Gy, _ = new(big.Int).SetString("938CF935318FDCED6BC28286531733C3F03C4FEE", 16)
- secp160k1.BitSize = 160
-}
-
-func initS192() {
- // See SEC 2 section 2.5.1
- secp192k1 = new(BitCurve)
- secp192k1.P, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFEE37", 16)
- secp192k1.N, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFE26F2FC170F69466A74DEFD8D", 16)
- secp192k1.B, _ = new(big.Int).SetString("000000000000000000000000000000000000000000000003", 16)
- secp192k1.Gx, _ = new(big.Int).SetString("DB4FF10EC057E9AE26B07D0280B7F4341DA5D1B1EAE06C7D", 16)
- secp192k1.Gy, _ = new(big.Int).SetString("9B2F2F6D9C5628A7844163D015BE86344082AA88D95E2F9D", 16)
- secp192k1.BitSize = 192
-}
-
-func initS224() {
- // See SEC 2 section 2.6.1
- secp224k1 = new(BitCurve)
- secp224k1.P, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFE56D", 16)
- secp224k1.N, _ = new(big.Int).SetString("010000000000000000000000000001DCE8D2EC6184CAF0A971769FB1F7", 16)
- secp224k1.B, _ = new(big.Int).SetString("00000000000000000000000000000000000000000000000000000005", 16)
- secp224k1.Gx, _ = new(big.Int).SetString("A1455B334DF099DF30FC28A169A467E9E47075A90F7E650EB6B7A45C", 16)
- secp224k1.Gy, _ = new(big.Int).SetString("7E089FED7FBA344282CAFBD6F7E319F7C0B0BD59E2CA4BDB556D61A5", 16)
- secp224k1.BitSize = 224
-}
-
-func initS256() {
- // See SEC 2 section 2.7.1
- secp256k1 = new(BitCurve)
- secp256k1.P, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16)
- secp256k1.N, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16)
- secp256k1.B, _ = new(big.Int).SetString("0000000000000000000000000000000000000000000000000000000000000007", 16)
- secp256k1.Gx, _ = new(big.Int).SetString("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", 16)
- secp256k1.Gy, _ = new(big.Int).SetString("483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8", 16)
- secp256k1.BitSize = 256
-}
-
-// S160 returns a BitCurve which implements secp160k1 (see SEC 2 section 2.4.1)
-func S160() *BitCurve {
- initonce.Do(initAll)
- return secp160k1
-}
-
-// S192 returns a BitCurve which implements secp192k1 (see SEC 2 section 2.5.1)
-func S192() *BitCurve {
- initonce.Do(initAll)
- return secp192k1
-}
-
-// S224 returns a BitCurve which implements secp224k1 (see SEC 2 section 2.6.1)
-func S224() *BitCurve {
- initonce.Do(initAll)
- return secp224k1
-}
-
-// S256 returns a BitCurve which implements secp256k1 (see SEC 2 section 2.7.1)
-func S256() *BitCurve {
- initonce.Do(initAll)
- return secp256k1
-}
diff --git a/secp256k1/bitelliptic/bitelliptic_test.go b/secp256k1/bitelliptic/bitelliptic_test.go
deleted file mode 100644
index deb5dbc..0000000
--- a/secp256k1/bitelliptic/bitelliptic_test.go
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Copyright 2011 ThePiachu. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bitelliptic
-
-import (
- "big"
- "crypto/rand"
- "fmt"
- "testing"
-)
-
-func TestOnCurve(t *testing.T) {
- s160 := S160()
- if !s160.IsOnCurve(s160.Gx, s160.Gy) {
- t.Errorf("FAIL S160")
- }
- s192 := S192()
- if !s192.IsOnCurve(s192.Gx, s192.Gy) {
- t.Errorf("FAIL S192")
- }
- s224 := S224()
- if !s224.IsOnCurve(s224.Gx, s224.Gy) {
- t.Errorf("FAIL S224")
- }
- s256 := S256()
- if !s256.IsOnCurve(s256.Gx, s256.Gy) {
- t.Errorf("FAIL S256")
- }
-}
-
-type baseMultTest struct {
- k string
- x, y string
-}
-
-//TODO: add more test vectors
-var s256BaseMultTests = []baseMultTest{
- {
- "AA5E28D6A97A2479A65527F7290311A3624D4CC0FA1578598EE3C2613BF99522",
- "34F9460F0E4F08393D192B3C5133A6BA099AA0AD9FD54EBCCFACDFA239FF49C6",
- "B71EA9BD730FD8923F6D25A7A91E7DD7728A960686CB5A901BB419E0F2CA232",
- },
- {
- "7E2B897B8CEBC6361663AD410835639826D590F393D90A9538881735256DFAE3",
- "D74BF844B0862475103D96A611CF2D898447E288D34B360BC885CB8CE7C00575",
- "131C670D414C4546B88AC3FF664611B1C38CEB1C21D76369D7A7A0969D61D97D",
- },
- {
- "6461E6DF0FE7DFD05329F41BF771B86578143D4DD1F7866FB4CA7E97C5FA945D",
- "E8AECC370AEDD953483719A116711963CE201AC3EB21D3F3257BB48668C6A72F",
- "C25CAF2F0EBA1DDB2F0F3F47866299EF907867B7D27E95B3873BF98397B24EE1",
- },
- {
- "376A3A2CDCD12581EFFF13EE4AD44C4044B8A0524C42422A7E1E181E4DEECCEC",
- "14890E61FCD4B0BD92E5B36C81372CA6FED471EF3AA60A3E415EE4FE987DABA1",
- "297B858D9F752AB42D3BCA67EE0EB6DCD1C2B7B0DBE23397E66ADC272263F982",
- },
- {
- "1B22644A7BE026548810C378D0B2994EEFA6D2B9881803CB02CEFF865287D1B9",
- "F73C65EAD01C5126F28F442D087689BFA08E12763E0CEC1D35B01751FD735ED3",
- "F449A8376906482A84ED01479BD18882B919C140D638307F0C0934BA12590BDE",
- },
-}
-
-//TODO: test different curves as well?
-func TestBaseMult(t *testing.T) {
- s256 := S256()
- for i, e := range s256BaseMultTests {
- k, ok := new(big.Int).SetString(e.k, 16)
- if !ok {
- t.Errorf("%d: bad value for k: %s", i, e.k)
- }
- x, y := s256.ScalarBaseMult(k.Bytes())
- if fmt.Sprintf("%X", x) != e.x || fmt.Sprintf("%X", y) != e.y {
- t.Errorf("%d: bad output for k=%s: got (%X, %X), want (%s, %s)", i, e.k, x, y, e.x, e.y)
- }
- if testing.Short() && i > 5 {
- break
- }
- }
-}
-
-//TODO: test more curves?
-func BenchmarkBaseMult(b *testing.B) {
- b.ResetTimer()
- s256 := S224()
- e := s256BaseMultTests[0] //TODO: check, used to be 25 instead of 0, but it's probably ok
- k, _ := new(big.Int).SetString(e.k, 16)
- b.StartTimer()
- for i := 0; i < b.N; i++ {
- s256.ScalarBaseMult(k.Bytes())
- }
-}
-
-//TODO: test more curves?
-func TestMarshal(t *testing.T) {
- s256 := S256()
- _, x, y, err := s256.GenerateKey(rand.Reader)
- if err != nil {
- t.Error(err)
- return
- }
- serialised := s256.Marshal(x, y)
- xx, yy := s256.Unmarshal(serialised)
- if xx == nil {
- t.Error("failed to unmarshal")
- return
- }
- if xx.Cmp(x) != 0 || yy.Cmp(y) != 0 {
- t.Error("unmarshal returned different values")
- return
- }
-}
diff --git a/vendor/github.com/njones/bitcoin-crypto b/vendor/github.com/njones/bitcoin-crypto
new file mode 160000
index 0000000..ea1e694
--- /dev/null
+++ b/vendor/github.com/njones/bitcoin-crypto
@@ -0,0 +1 @@
+Subproject commit ea1e694702736efbe373f7b98d7cb36f95f8dae6