从零开发区块链应用(十一)--以太坊地址生成

const (
 BitcoinSeed = "Bitcoin seed"
 Mnemonic    = "search crime session tag file joke leaf express interest slender file hawk"
)

func NewAccount(password string) string {
 seed := pbkdf2.Key([]byte(Mnemonic), []byte("mnemonic"+password), 2048, 64, sha512.New)
 hmac := hmac.New(sha512.New, []byte(BitcoinSeed))
 _, err := hmac.Write([]byte(seed))
 if err != nil {
  return ""
 }
 intermediary := hmac.Sum(nil)
 keyBytes := intermediary[:32] // 私钥
 _, pub := ecdsa.PrivKeyFromBytes(ecdsa.S256(), keyBytes)
 return pub.ToAddress().String()
}

DK = PBKDF2(PRF, Password, Salt, c, dkLen ,Hash algorithm)

package pbkdf2

import (
 "crypto/rand"
 "crypto/sha512"
 "golang.org/x/crypto/pbkdf2"
)

const (
    Mnemonic =  "search crime conversation tag directory joke leaf express interest password = ""
)
func encryptPwdWithSalt(password string) (*ecdsa.PrivateKey, *ecdsa.PublicKey) {
  seed := pbkdf2.Key([]byte(Mnemonic), []byte("mnemonic"+password), 2048, 64, sha512.New)
}

// []byte(Mnemonic)：助记词
// []byte("mnemonic"+password) ：salt盐值
// 2048：重复计算的次数
// 64：返回的秘钥长度
// sha512.New：哈希算法

//创建运算对象，HMAC需要两个参数：hash函数和key
hmac := hmac.New(sha512.New, []byte(BitcoinSeed))
//将明文写入到hmac中
 _, err := hmac.Write([]byte(seed))
 if err != nil {
  return nil, nil
 }
//hmac对象对写入数据的运算，生成的参数为字节
intermediary := hmac.Sum(nil)

package main

import (
    "crypto/hmac"
    "crypto/md5"
    "crypto/sha1"
    "encoding/hex"
    "fmt"
)

func Md5(data string) string {
    md5 := md5.New()
    md5.Write([]byte(data))
    md5Data := md5.Sum([]byte(""))
    return hex.EncodeToString(md5Data)
}

func Hmac(key, data string) string {
    hmac := hmac.New(md5.New, []byte(key))
    hmac.Write([]byte(data))
    return hex.EncodeToString(hmac.Sum(nil)
}

func Sha1(data string) string {
    sha1 := sha1.New()
    sha1.Write([]byte(data))
    return hex.EncodeToString(sha1.Sum(nil))
}

func main() {
    fmt.Println(Md5("hello"))
    fmt.Println(Hmac("key2", "hello"))
    fmt.Println(Sha1("hello"))
}

// ToPubKey 返回与此私钥对应的公钥
func (p *PrivateKey) ToPubKey() *PublicKey {
 return (*PublicKey)(&p.PublicKey)
}

// PrivKeyFromBytes 根据私钥随机数D返回公私钥
func PrivKeyFromBytes(curve elliptic.Curve, pk []byte) (*PrivateKey, *PublicKey) {
 // 根据字节pk，返回x，y
 x, y := curve.ScalarBaseMult(pk)
 // 定义一个私钥结构体，结构体中包含：公钥结构体
 priv := &PrivateKey{
  PublicKey: e.PublicKey{
   Curve: curve,
   X:     x,
   Y:     y,
  },
  D: new(big.Int).SetBytes(pk),
 }
 return priv, (*PublicKey)(&priv.PublicKey)
}

// Address 表示20字节地址
type Address [AddressLength]byte

// PubkeyToAddress 公钥转地址方法
func (p *PublicKey) ToAddress() Address {
 pubBytes := p.FromECDSAPub()
 i := sha3.Keccak256(pubBytes[1:])[12:]
 return BytesToAddress(i)
}

// FromECDSAPub 椭圆加密公钥转坐标
func (p *PublicKey) FromECDSAPub() []byte {
 if p == nil || p.X == nil || p.Y == nil {
  return nil
 }
 return elliptic.Marshal(S256(), p.X, p.Y)
}

// S256()是特定的椭圆曲线，在程序启动的时候进行初始化，后来调用只是获取其引用而已。

// elliptic.Marshal(...)为标准库函数，按照非压缩形式得到相应的[]byte
func Marshal(curve Curve, x, y *big.Int) []byte {
 byteLen := (curve.Params().BitSize + 7) / 8

 ret := make([]byte, 1+2*byteLen)
 ret[0] = 4 // uncompressed point

 x.FillBytes(ret[1 : 1+byteLen])
 y.FillBytes(ret[1+byteLen : 1+2*byteLen])

 return ret
}

// Keccak256 使用sha3 256加密内容
func Keccak256(data ...[]byte) []byte {
 d := NewKeccak256()
 for _, b := range data {
  d.Write(b)
 }
 return d.Sum(nil)
}

// BytesToAddress其实就是字节拷贝
// BytesToAddress byte转address
func BytesToAddress(b []byte) Address {
 var a Address
 a.SetBytes(b)
 return a
}


// SetBytes 将地址设置为b的值。如果b大于len(a)，会宕机
// SetBytes()考虑到了字节数量不匹配的情况
func (a *Address) SetBytes(b []byte) {
 if len(b) > len(a) {
  b = b[len(b)-AddressLength:]
 }
 copy(a[AddressLength-len(b):], b)
}