github.com/piotrnar/gocoin@v0.0.0-20240512203912-faa0448c5e96/lib/secp256k1/ec.go (about)

     1  package secp256k1
     2  
     3  import (
     4  	//"encoding/hex"
     5  )
     6  
     7  
     8  func ecdsa_verify(pubkey, sig, msg []byte) int {
     9  	var m Number
    10  	var s Signature
    11  	m.SetBytes(msg)
    12  
    13  	var q XY
    14  	if !q.ParsePubkey(pubkey) {
    15  		return -1
    16  	}
    17  
    18  	if s.ParseBytes(sig)<0 {
    19  		return -2
    20  	}
    21  
    22  	if !s.Verify(&q, &m) {
    23  		return 0
    24  	}
    25  	return 1
    26  }
    27  
    28  func Verify(k, s, m []byte) bool {
    29  	return ecdsa_verify(k, s, m)==1
    30  }
    31  
    32  
    33  func DecompressPoint(X []byte, off bool, Y []byte) {
    34  	var rx, ry, c, x2, x3 Field
    35  	rx.SetB32(X)
    36  	rx.Sqr(&x2)
    37  	rx.Mul(&x3, &x2)
    38  	c.SetInt(7)
    39  	c.SetAdd(&x3)
    40  	c.Sqrt(&ry)
    41  	ry.Normalize()
    42  	if ry.IsOdd() != off {
    43  		ry.Negate(&ry, 1)
    44  	}
    45  	ry.Normalize()
    46  	ry.GetB32(Y)
    47  	return
    48  }
    49  
    50  
    51  func RecoverPublicKey(r, s, h []byte, recid int, pubkey *XY) bool {
    52  	var sig Signature
    53  	var msg Number
    54  	sig.R.SetBytes(r)
    55  	if sig.R.Sign()<=0 || sig.R.Cmp(&TheCurve.Order.Int)>=0 {
    56  		return false
    57  	}
    58  	sig.S.SetBytes(s)
    59  	if sig.S.Sign()<=0 || sig.S.Cmp(&TheCurve.Order.Int)>=0 {
    60  		return false
    61  	}
    62  	msg.SetBytes(h)
    63  	if !sig.recover(pubkey, &msg, recid) {
    64  		return false
    65  	}
    66  	return true
    67  }
    68  
    69  
    70  // Multiply does standard EC multiplication k(xy).
    71  // xy - is the standarized public key format (33 or 65 bytes long).
    72  // out - should be the buffer for 33 bytes (1st byte will be set to either 02 or 03).
    73  func Multiply(xy, k, out []byte) bool {
    74  	var pk XY
    75  	var xyz XYZ
    76  	var na, nzero Number
    77  	if !pk.ParsePubkey(xy) {
    78  		return false
    79  	}
    80  	xyz.SetXY(&pk)
    81  	na.SetBytes(k)
    82  	xyz.ECmult(&xyz, &na, &nzero)
    83  	pk.SetXYZ(&xyz)
    84  	pk.GetPublicKey(out)
    85  	return true
    86  }
    87  
    88  // BaseMultiply multiplies k by G.
    89  // out - should be the buffer for 33 bytes (1st byte will be set to either 02 or 03).
    90  func BaseMultiply(k, out []byte) bool {
    91  	var r XYZ
    92  	var n Number
    93  	var pk XY
    94  	n.SetBytes(k)
    95  	ECmultGen(&r, &n)
    96  	pk.SetXYZ(&r)
    97  	pk.GetPublicKey(out)
    98  	return true
    99  }
   100  
   101  
   102  // out = G*k + xy
   103  func BaseMultiplyAdd(xy, k, out []byte) bool {
   104  	var r XYZ
   105  	var n Number
   106  	var pk XY
   107  	if !pk.ParsePubkey(xy) {
   108  		return false
   109  	}
   110  	n.SetBytes(k)
   111  	ECmultGen(&r, &n)
   112  	r.AddXY(&r, &pk)
   113  	pk.SetXYZ(&r)
   114  	pk.GetPublicKey(out)
   115  	return true
   116  }