vendor/github.com/tendermint/go-crypto/hd/hd_test.go

   1 package hd
   2
   3 import (
   4         "bytes"
   5         //"crypto/hmac"
   6         //"crypto/sha512"
   7         //"encoding/binary"
   8         "encoding/hex"
   9         "encoding/json"
  10         "fmt"
  11         "io/ioutil"
  12         "os"
  13         "testing"
  14
  15         "github.com/stretchr/testify/assert"
  16         "github.com/tyler-smith/go-bip39"
  17
  18         //"github.com/btcsuite/btcd/chaincfg"
  19         //"github.com/btcsuite/btcutil/hdkeychain"
  20         //"github.com/mndrix/btcutil"
  21         //"github.com/tyler-smith/go-bip32"
  22
  23         "github.com/tendermint/go-crypto"
  24 )
  25
  26 type addrData struct {
  27         Mnemonic string
  28         Master   string
  29         Seed     string
  30         Priv     string
  31         Pub      string
  32         Addr     string
  33 }
  34
  35 // NOTE: atom fundraiser address
  36 // var hdPath string = "m/44'/118'/0'/0/0"
  37 var hdToAddrTable []addrData
  38
  39 func init() {
  40
  41         b, err := ioutil.ReadFile("test.json")
  42         if err != nil {
  43                 fmt.Println(err)
  44                 os.Exit(1)
  45         }
  46
  47         err = json.Unmarshal(b, &hdToAddrTable)
  48         if err != nil {
  49                 fmt.Println(err)
  50                 os.Exit(1)
  51         }
  52 }
  53
  54 func TestHDToAddr(t *testing.T) {
  55
  56         for i, d := range hdToAddrTable {
  57                 privB, _ := hex.DecodeString(d.Priv)
  58                 pubB, _ := hex.DecodeString(d.Pub)
  59                 addrB, _ := hex.DecodeString(d.Addr)
  60                 seedB, _ := hex.DecodeString(d.Seed)
  61                 masterB, _ := hex.DecodeString(d.Master)
  62
  63                 seed := bip39.NewSeed(d.Mnemonic, "")
  64
  65                 fmt.Println("================================")
  66                 fmt.Println("ROUND:", i, "MNEMONIC:", d.Mnemonic)
  67
  68                 // master, priv, pub := tylerSmith(seed)
  69                 // master, priv, pub := btcsuite(seed)
  70                 master, priv, pub := gocrypto(seed)
  71
  72                 fmt.Printf("\tNODEJS GOLANG\n")
  73                 fmt.Printf("SEED \t%X %X\n", seedB, seed)
  74                 fmt.Printf("MSTR \t%X %X\n", masterB, master)
  75                 fmt.Printf("PRIV \t%X %X\n", privB, priv)
  76                 fmt.Printf("PUB  \t%X %X\n", pubB, pub)
  77                 _, _ = priv, privB
  78
  79                 assert.Equal(t, master, masterB, fmt.Sprintf("Expected masters to match for %d", i))
  80                 assert.Equal(t, priv, privB, "Expected priv keys to match")
  81                 assert.Equal(t, pub, pubB, fmt.Sprintf("Expected pub keys to match for %d", i))
  82
  83                 var pubT crypto.PubKeySecp256k1
  84                 copy(pubT[:], pub)
  85                 addr := pubT.Address()
  86                 fmt.Printf("ADDR  \t%X %X\n", addrB, addr)
  87                 assert.Equal(t, addr, addrB, fmt.Sprintf("Expected addresses to match %d", i))
  88
  89         }
  90 }
  91
  92 func TestReverseBytes(t *testing.T) {
  93         tests := [...]struct {
  94                 v    []byte
  95                 want []byte
  96         }{
  97                 {[]byte(""), []byte("")},
  98                 {nil, nil},
  99                 {[]byte("Tendermint"), []byte("tnimredneT")},
 100                 {[]byte("T"), []byte("T")},
 101                 {[]byte("Te"), []byte("eT")},
 102         }
 103
 104         for i, tt := range tests {
 105                 got := ReverseBytes(tt.v)
 106                 if !bytes.Equal(got, tt.want) {
 107                         t.Errorf("#%d:\ngot= (%x)\nwant=(%x)", i, got, tt.want)
 108                 }
 109         }
 110 }
 111
 112 /*
 113 func ifExit(err error, n int) {
 114         if err != nil {
 115                 fmt.Println(n, err)
 116                 os.Exit(1)
 117         }
 118 }
 119 */
 120
 121 func gocrypto(seed []byte) ([]byte, []byte, []byte) {
 122
 123         _, priv, ch, _ := ComputeMastersFromSeed(string(seed))
 124
 125         privBytes := DerivePrivateKeyForPath(
 126                 HexDecode(priv),
 127                 HexDecode(ch),
 128                 "44'/118'/0'/0/0",
 129         )
 130
 131         pubBytes := PubKeyBytesFromPrivKeyBytes(privBytes, true)
 132
 133         return HexDecode(priv), privBytes, pubBytes
 134 }
 135
 136 /*
 137 func btcsuite(seed []byte) ([]byte, []byte, []byte) {
 138         fmt.Println("HD")
 139         masterKey, err := hdkeychain.NewMaster(seed, &chaincfg.MainNetParams)
 140         if err != nil {
 141                 hmac := hmac.New(sha512.New, []byte("Bitcoin seed"))
 142                 hmac.Write([]byte(seed))
 143                 intermediary := hmac.Sum(nil)
 144
 145                 curve := btcutil.Secp256k1()
 146                 curveParams := curve.Params()
 147
 148                 // Split it into our key and chain code
 149                 keyBytes := intermediary[:32]
 150                 fmt.Printf("\t%X\n", keyBytes)
 151                 fmt.Printf("\t%X\n", curveParams.N.Bytes())
 152                 keyInt, _ := binary.ReadVarint(bytes.NewBuffer(keyBytes))
 153                 fmt.Printf("\t%d\n", keyInt)
 154         }
 155         fh := hdkeychain.HardenedKeyStart
 156         k, err := masterKey.Child(uint32(fh + 44))
 157         ifExit(err, 44)
 158         k, err = k.Child(uint32(fh + 118))
 159         ifExit(err, 118)
 160         k, err = k.Child(uint32(fh + 0))
 161         ifExit(err, 1)
 162         k, err = k.Child(uint32(0))
 163         ifExit(err, 2)
 164         k, err = k.Child(uint32(0))
 165         ifExit(err, 3)
 166         ecpriv, err := k.ECPrivKey()
 167         ifExit(err, 10)
 168         ecpub, err := k.ECPubKey()
 169         ifExit(err, 11)
 170
 171         priv := ecpriv.Serialize()
 172         pub := ecpub.SerializeCompressed()
 173         mkey, _ := masterKey.ECPrivKey()
 174         return mkey.Serialize(), priv, pub
 175 }
 176
 177 // return priv and pub
 178 func tylerSmith(seed []byte) ([]byte, []byte, []byte) {
 179         masterKey, err := bip32.NewMasterKey(seed)
 180         if err != nil {
 181                 hmac := hmac.New(sha512.New, []byte("Bitcoin seed"))
 182                 hmac.Write([]byte(seed))
 183                 intermediary := hmac.Sum(nil)
 184
 185                 curve := btcutil.Secp256k1()
 186                 curveParams := curve.Params()
 187
 188                 // Split it into our key and chain code
 189                 keyBytes := intermediary[:32]
 190                 fmt.Printf("\t%X\n", keyBytes)
 191                 fmt.Printf("\t%X\n", curveParams.N.Bytes())
 192                 keyInt, _ := binary.ReadVarint(bytes.NewBuffer(keyBytes))
 193                 fmt.Printf("\t%d\n", keyInt)
 194
 195         }
 196         ifExit(err, 0)
 197         fh := bip32.FirstHardenedChild
 198         k, err := masterKey.NewChildKey(fh + 44)
 199         ifExit(err, 44)
 200         k, err = k.NewChildKey(fh + 118)
 201         ifExit(err, 118)
 202         k, err = k.NewChildKey(fh + 0)
 203         ifExit(err, 1)
 204         k, err = k.NewChildKey(0)
 205         ifExit(err, 2)
 206         k, err = k.NewChildKey(0)
 207         ifExit(err, 3)
 208
 209         priv := k.Key
 210         pub := k.PublicKey().Key
 211         return masterKey.Key, priv, pub
 212 }
 213 */
 214
 215 // Benchmarks
 216 var revBytesCases = [][]byte{
 217         nil,
 218         []byte(""),
 219
 220         []byte("12"),
 221
 222         // 16byte case
 223         []byte("abcdefghijklmnop"),
 224
 225         // 32byte case
 226         []byte("abcdefghijklmnopqrstuvwxyz123456"),
 227
 228         // 64byte case
 229         []byte("abcdefghijklmnopqrstuvwxyz123456abcdefghijklmnopqrstuvwxyz123456"),
 230 }
 231
 232 func BenchmarkReverseBytes(b *testing.B) {
 233         var sink []byte
 234         for i := 0; i < b.N; i++ {
 235                 for _, tt := range revBytesCases {
 236                         sink = ReverseBytes(tt)
 237                 }
 238         }
 239         b.ReportAllocs()
 240
 241         // sink is necessary to ensure if the compiler tries
 242         // to smart, that it won't optimize away the benchmarks.
 243         if sink != nil {
 244                 _ = sink
 245         }
 246 }