数据签名

image

image

• 随机数字K用作临时私钥，进而生成临时公钥（与生成比特币公钥方式相同）。
• R代表临时公钥x轴坐标

• k还是刚刚的临时私钥
• dA代表签名私钥(不是刚刚的临时私钥)
• z是交易数据的hash值—>hash(交易数据)
• p是素数，椭圆曲线的主要顺序(这一点没有理清楚，待定)

==R+S就是签名==

package main

import (
   "crypto/ecdsa"
   "crypto/elliptic"
   "crypto/rand"
   "crypto/sha256"
   "fmt"
   "log"
)

//生成私钥和公钥，生成的私钥为结构体ecdsa.PrivateKey的指针

//type PrivateKey struct {
// PublicKey
// D *big.Int
//}
func newKeyPair2() (ecdsa.PrivateKey, []byte) {
   //生成椭圆曲线
   curve := elliptic.P256()
   //产生的是一个结构体指针，结构体类型为ecdsa.PrivateKey
   private, err := ecdsa.GenerateKey(curve, rand.Reader)
   if err != nil {
      log.Panic(err)
   }
   //x坐标与y坐标拼接在一起，生成公钥
   pubKey := append(private.PublicKey.X.Bytes(), private.PublicKey.Y.Bytes()...)

   return *private, pubKey
}







func main(){
   //调用函数生成私钥与公钥
   privKey,_ := newKeyPair2()


   //信息的哈希,签名什么样的数据
   hash := sha256.Sum256([]byte("hello world\n"))

   //根据私钥和信息的哈希进行数字签名，产生r和s
   r, s, err := ecdsa.Sign(rand.Reader, &privKey, hash[:])

   if err != nil {
      log.Panic(err)
   }


   //r和s拼接在一起实现了数字签名
   signature := append(r.Bytes(), s.Bytes()...)
   //打印数字签名的16进制显示
   fmt.Printf("%x\n", signature)


   fmt.Printf("%x\n", r.Bytes())
   fmt.Printf("%x\n", s.Bytes())


   //补充：如何把一个字符串转换为16进制数据
   //m := big.Int{}
   //n := big.Int{}
   //rr,_:=hex.DecodeString("7dccc0f58639584a3f0c879c3688d2f4a0137697cbf34245d075c764e36233d2")
   //ss,_:=hex.DecodeString("cf3713bf4369eb1c02e476cdbefb7f76a25b572f53fb71d4e4742fa11c827526")
   //
   //m.SetBytes(rr)
   //n.SetBytes(ss)
   //
   //fmt.Printf("%x\n", m.Bytes())
   //fmt.Printf("%x\n", n.Bytes())
}

验证数据签名

验证是生成签名函数的倒数，使用R、S、公钥来计算一个P，这个P是椭圆曲线上的一个点，就是刚刚签名创建中生成的临时公钥

image

• R、S是签名值
• Qa是签名私钥(不是临时私钥)
• m是交易数据
• G是椭圆曲线发生器点(不同椭圆的G点不同，相同椭圆曲线G点相同)

如果计算的P点的x坐标等于R，则证明签名有效

==验证签名时，私钥既不知道，也不显示==

package main

import (
    "crypto/ecdsa"
    "crypto/rand"
    "crypto/sha256"
    "crypto/elliptic"
    "log"
    "fmt"
    "math/big"
)

//生成私钥和公钥，生成的私钥为结构体ecdsa.PrivateKey的指针

//type PrivateKey struct {
//  PublicKey
//  D *big.Int
//}
func newKeyPair3() (ecdsa.PrivateKey, []byte) {

    //生成secp256k1椭圆曲线
    curve := elliptic.P256()

    //产生的是一个结构体指针，结构体类型为ecdsa.PrivateKey
    private, err := ecdsa.GenerateKey(curve, rand.Reader)

    if err != nil {
        log.Panic(err)
    }

    //x坐标与y坐标拼接在一起，生成公钥
    pubKey := append(private.PublicKey.X.Bytes(), private.PublicKey.Y.Bytes()...)

    return *private, pubKey
}



func main(){

    //生成公钥和私钥
    privKey,pubkey := newKeyPair3()


    //生成某一串信息的哈希值，需要签名的数据
    hash := sha256.Sum256([]byte("ruok?\n"))


    //根据私钥和信息的哈希值生成数字签名的r和s，r和s拼接在一起就是数字签名，在这里省略了拼接的步骤，欲查看，请看3.数字签名
    r, s, _ := ecdsa.Sign(rand.Reader, &privKey, hash[:])

    //fmt.Printf("%v\n", *r)
    //fmt.Printf("%v\n", *s)
    ////生成secp256k1椭圆曲线
    curve := elliptic.P256()

    //公钥的长度
    keyLen := len(pubkey)

    //前一半为x轴坐标，后一半为y轴坐标
    x := big.Int{}
    y := big.Int{}
    x.SetBytes(pubkey[:(keyLen / 2)])
    y.SetBytes(pubkey[(keyLen / 2):])



    //rawPubKey为生成PublicKey结构体，作为下面ecdsa.Verify的参数
    //type PublicKey struct {
    //  elliptic.Curve
    //  X, Y * big.Int }

    //公钥
    rawPubKey := ecdsa.PublicKey{curve, &x, &y}

    //根据交易哈希、公钥、数字签名验证成功。ecdsa.Verify func Verify(pub *PublicKey, hash []byte, r *big.Int, s *big.Int) bool
    if ecdsa.Verify(&rawPubKey, hash[:], r, s) == false {
        fmt.Printf("%s\n", "验证失败")
    }else{
        fmt.Printf("%s\n", "验证成功")
    }


    //用其他的信息哈希——证明验证失败
    hash2 := sha256.Sum256([]byte("我要给你200愿\n"))

    if ecdsa.Verify(&rawPubKey, hash2[:], r, s) == false {
        fmt.Printf("%s\n", "验证失败")
    }else{
        fmt.Printf("%s\n", "验证成功")
    }
}