// Recover retrieves the public key of the message signer.
func (self *Message) Recover() *ecdsa.PublicKey {
defer func() { recover() }() // in case of invalid signature
// Short circuit if no signature is present
if self.Signature == nil {
return nil
}
// Otherwise try and recover the signature
pub, err := crypto.SigToPub(self.hash(), self.Signature)
if err != nil {
glog.V(logger.Error).Infof("Could not get public key from signature: %v", err)
return nil
}
return pub
}
func (tx *Transaction) PublicKey() []byte {
hash := tx.Hash()
v, r, s := tx.Curve()
sig := append(r, s...)
sig = append(sig, v-27)
//pubkey := crypto.Ecrecover(append(hash[:], sig...))
//pubkey, _ := secp256k1.RecoverPubkey(hash[:], sig)
p, err := crypto.SigToPub(hash[:], sig)
if err != nil {
glog.V(logger.Error).Infof("Could not get pubkey from signature: ", err)
return nil
}
pubkey := crypto.FromECDSAPub(p)
return pubkey
}
// Verify libsecp256k1
func BitcoinVerify(msg []byte, sig string, key *ecdsa.PublicKey) (bool, error) {
hmsg := EncodeMessageHash(msg)
sigbytes, err := DecodeSignature(sig)
if err != nil {
return false, err
}
// Recover the public key from the msg + signature
recoveredkey, err := crypto.SigToPub(hmsg, sigbytes)
if err != nil {
return false, err
}
// If the recovered key is the key we expect, the signature is valid
if reflect.DeepEqual(key, recoveredkey) {
return true, nil
}
// The key is valid but is not the one we expect
return false, nil
}
func (tx *Transaction) PublicKey() ([]byte, error) {
if !crypto.ValidateSignatureValues(tx.V, tx.R, tx.S) {
return nil, errors.New("invalid v, r, s values")
}
hash := tx.Hash()
v, r, s := tx.GetSignatureValues()
sig := append(r, s...)
sig = append(sig, v-27)
p, err := crypto.SigToPub(hash[:], sig)
if err != nil {
glog.V(logger.Error).Infof("Could not get pubkey from signature: ", err)
return nil, err
}
pubkey := crypto.FromECDSAPub(p)
if len(pubkey) == 0 || pubkey[0] != 4 {
return nil, errors.New("invalid public key")
}
return pubkey, nil
}