luxfi/crypto
1
0
Fork 0
mirror of https://github.com/luxfi/crypto.git synced 2026-07-27 01:54:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update to use go-eth versions

Browse Source
This commit is contained in:
Zach Kelling
2025-08-03 01:35:05 +00:00
parent 1765dfc504
commit f6730ab3c1
15 changed files with 81 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crypto.go
+15 -13
View File
@@ -1,4 +1,4 @@
// Copyright (C) 2020-2025, Lux Industries Inc
// Copyright 2014 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
@@ -30,7 +30,9 @@ import (
"os"
"sync"
"github.com/luxfi/crypto/utils"
"github.com/luxfi/geth/common"
"github.com/luxfi/geth/common/math"
"github.com/luxfi/geth/rlp"
"golang.org/x/crypto/sha3"
)
@@ -79,7 +81,7 @@ var hasherPool = sync.Pool{
}
// HashData hashes the provided data using the KeccakState and returns a 32 byte hash
func HashData(kh KeccakState, data []byte) (h utils.Hash) {
func HashData(kh KeccakState, data []byte) (h common.Hash) {
kh.Reset()
kh.Write(data)
kh.Read(h[:])
@@ -101,7 +103,7 @@ func Keccak256(data ...[]byte) []byte {
// Keccak256Hash calculates and returns the Keccak256 hash of the input data,
// converting it to an internal Hash data structure.
func Keccak256Hash(data ...[]byte) (h utils.Hash) {
func Keccak256Hash(data ...[]byte) (h common.Hash) {
d := hasherPool.Get().(KeccakState)
d.Reset()
for _, b := range data {
@@ -122,15 +124,15 @@ func Keccak512(data ...[]byte) []byte {
}
// CreateAddress creates an ethereum address given the bytes and the nonce
func CreateAddress(b utils.Address, nonce uint64) utils.Address {
data, _ := utils.EncodeToBytes([]interface{}{b, nonce})
return utils.BytesToAddress(Keccak256(data)[12:])
func CreateAddress(b common.Address, nonce uint64) common.Address {
data, _ := rlp.EncodeToBytes([]interface{}{b, nonce})
return common.BytesToAddress(Keccak256(data)[12:])
}
// CreateAddress2 creates an ethereum address given the address bytes, initial
// contract code hash and a salt.
func CreateAddress2(b utils.Address, salt [32]byte, inithash []byte) utils.Address {
return utils.BytesToAddress(Keccak256([]byte{0xff}, b.Bytes(), salt[:], inithash)[12:])
func CreateAddress2(b common.Address, salt [32]byte, inithash []byte) common.Address {
return common.BytesToAddress(Keccak256([]byte{0xff}, b.Bytes(), salt[:], inithash)[12:])
}
// ToECDSA creates a private key with the given D value.
@@ -178,7 +180,7 @@ func FromECDSA(priv *ecdsa.PrivateKey) []byte {
if priv == nil {
return nil
}
return utils.PaddedBigBytes(priv.D, priv.Params().BitSize/8)
return math.PaddedBigBytes(priv.D, priv.Params().BitSize/8)
}
// UnmarshalPubkey converts bytes to a secp256k1 public key.
@@ -284,7 +286,7 @@ func GenerateKey() (*ecdsa.PrivateKey, error) {
// ValidateSignatureValues verifies whether the signature values are valid with
// the given chain rules. The v value is assumed to be either 0 or 1.
func ValidateSignatureValues(v byte, r, s *big.Int, homestead bool) bool {
if r.Cmp(utils.Big1) < 0 || s.Cmp(utils.Big1) < 0 {
if r.Cmp(common.Big1) < 0 || s.Cmp(common.Big1) < 0 {
return false
}
// reject upper range of s values (ECDSA malleability)
@@ -296,9 +298,9 @@ func ValidateSignatureValues(v byte, r, s *big.Int, homestead bool) bool {
return r.Cmp(secp256k1N) < 0 && s.Cmp(secp256k1N) < 0 && (v == 0 || v == 1)
}
func PubkeyToAddress(p ecdsa.PublicKey) utils.Address {
func PubkeyToAddress(p ecdsa.PublicKey) common.Address {
pubBytes := FromECDSAPub(&p)
return utils.BytesToAddress(Keccak256(pubBytes[1:])[12:])
return common.BytesToAddress(Keccak256(pubBytes[1:])[12:])
}
func zeroBytes(bytes []byte) {
crypto_test.go
+15 -22
View File
@@ -1,4 +1,4 @@
// Copyright (C) 2020-2025, Lux Industries Inc
// Copyright 2014 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
@@ -26,20 +26,13 @@ import (
"reflect"
"testing"
"github.com/luxfi/crypto/utils"
"github.com/luxfi/geth/common"
"github.com/luxfi/geth/common/hexutil"
)
var testAddrHex = "970e8128ab834e8eac17ab8e3812f010678cf791"
var testPrivHex = "289c2857d4598e37fb9647507e47a309d6133539bf21a8b9cb6df88fd5232032"
func mustDecodeBig(s string) *big.Int {
v, ok := utils.ParseBig256(s)
if !ok {
panic("invalid big integer")
}
return v
}
// These tests are sanity checks.
// They should ensure that we don't e.g. use Sha3-224 instead of Sha3-256
// and that the sha3 library uses keccak-f permutation.
@@ -86,8 +79,8 @@ func TestUnmarshalPubkey(t *testing.T) {
enc, _ = hex.DecodeString("04760c4460e5336ac9bbd87952a3c7ec4363fc0a97bd31c86430806e287b437fd1b01abc6e1db640cf3106b520344af1d58b00b57823db3e1407cbc433e1b6d04d")
dec = &ecdsa.PublicKey{
Curve: S256(),
X: mustDecodeBig("0x760c4460e5336ac9bbd87952a3c7ec4363fc0a97bd31c86430806e287b437fd1"),
Y: mustDecodeBig("0xb01abc6e1db640cf3106b520344af1d58b00b57823db3e1407cbc433e1b6d04d"),
X: hexutil.MustDecodeBig("0x760c4460e5336ac9bbd87952a3c7ec4363fc0a97bd31c86430806e287b437fd1"),
Y: hexutil.MustDecodeBig("0xb01abc6e1db640cf3106b520344af1d58b00b57823db3e1407cbc433e1b6d04d"),
}
)
key, err = UnmarshalPubkey(enc)
@@ -101,7 +94,7 @@ func TestUnmarshalPubkey(t *testing.T) {
func TestSign(t *testing.T) {
key, _ := HexToECDSA(testPrivHex)
addr := utils.HexToAddress(testAddrHex)
addr := common.HexToAddress(testAddrHex)
msg := Keccak256([]byte("foo"))
sig, err := Sign(msg, key)
@@ -140,7 +133,7 @@ func TestInvalidSign(t *testing.T) {
func TestNewContractAddress(t *testing.T) {
key, _ := HexToECDSA(testPrivHex)
addr := utils.HexToAddress(testAddrHex)
addr := common.HexToAddress(testAddrHex)
genAddr := PubkeyToAddress(key.PublicKey)
// sanity check before using addr to create contract address
checkAddr(t, genAddr, addr)
@@ -148,9 +141,9 @@ func TestNewContractAddress(t *testing.T) {
caddr0 := CreateAddress(addr, 0)
caddr1 := CreateAddress(addr, 1)
caddr2 := CreateAddress(addr, 2)
checkAddr(t, utils.HexToAddress("333c3310824b7c685133f2bedb2ca4b8b4df633d"), caddr0)
checkAddr(t, utils.HexToAddress("8bda78331c916a08481428e4b07c96d3e916d165"), caddr1)
checkAddr(t, utils.HexToAddress("c9ddedf451bc62ce88bf9292afb13df35b670699"), caddr2)
checkAddr(t, common.HexToAddress("333c3310824b7c685133f2bedb2ca4b8b4df633d"), caddr0)
checkAddr(t, common.HexToAddress("8bda78331c916a08481428e4b07c96d3e916d165"), caddr1)
checkAddr(t, common.HexToAddress("c9ddedf451bc62ce88bf9292afb13df35b670699"), caddr2)
}
func TestLoadECDSA(t *testing.T) {
@@ -238,9 +231,9 @@ func TestValidateSignatureValues(t *testing.T) {
}
}
minusOne := big.NewInt(-1)
one := utils.Big1
zero := utils.Big0
secp256k1nMinus1 := new(big.Int).Sub(secp256k1N, utils.Big1)
one := common.Big1
zero := common.Big0
secp256k1nMinus1 := new(big.Int).Sub(secp256k1N, common.Big1)
// correct v,r,s
check(true, 0, one, one)
@@ -284,7 +277,7 @@ func checkhash(t *testing.T, name string, f func([]byte) []byte, msg, exp []byte
}
}
func checkAddr(t *testing.T, addr0, addr1 utils.Address) {
func checkAddr(t *testing.T, addr0, addr1 common.Address) {
if addr0 != addr1 {
t.Fatalf("address mismatch: want: %x have: %x", addr0, addr1)
}
@@ -299,7 +292,7 @@ func TestPythonIntegration(t *testing.T) {
msg0 := Keccak256([]byte("foo"))
sig0, _ := Sign(msg0, k0)
msg1 := utils.FromHex("00000000000000000000000000000000")
msg1 := common.FromHex("00000000000000000000000000000000")
sig1, _ := Sign(msg0, k0)
t.Logf("msg: %x, privkey: %s sig: %x\n", msg0, kh, sig0)
ecies/ecies.go
+3 -3
View File
@@ -41,7 +41,7 @@ import (
"io"
"math/big"
ethcrypto "github.com/luxfi/crypto"
"github.com/luxfi/crypto"
)
var (
@@ -257,7 +257,7 @@ func Encrypt(rand io.Reader, pub *PublicKey, m, s1, s2 []byte) (ct []byte, err e
d := messageTag(params.Hash, Km, em, s2)
if curve, ok := pub.Curve.(ethcrypto.EllipticCurve); ok {
if curve, ok := pub.Curve.(crypto.EllipticCurve); ok {
Rb := curve.Marshal(R.PublicKey.X, R.PublicKey.Y)
ct = make([]byte, len(Rb)+len(em)+len(d))
copy(ct, Rb)
@@ -303,7 +303,7 @@ func (prv *PrivateKey) Decrypt(c, s1, s2 []byte) (m []byte, err error) {
R := new(PublicKey)
R.Curve = prv.PublicKey.Curve
if curve, ok := R.Curve.(ethcrypto.EllipticCurve); ok {
if curve, ok := R.Curve.(crypto.EllipticCurve); ok {
R.X, R.Y = curve.Unmarshal(c[:rLen])
if R.X == nil {
return nil, ErrInvalidPublicKey
kzg4844/kzg4844.go
+8 -8
View File
@@ -1,4 +1,4 @@
// Copyright (C) 2020-2025, Lux Industries Inc
// Copyright 2023 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
@@ -24,7 +24,7 @@ import (
"reflect"
"sync/atomic"
"github.com/luxfi/crypto/utils"
"github.com/luxfi/geth/common/hexutil"
)
//go:embed trusted_setup.json
@@ -43,12 +43,12 @@ type Blob [131072]byte
// UnmarshalJSON parses a blob in hex syntax.
func (b *Blob) UnmarshalJSON(input []byte) error {
return utils.UnmarshalFixedJSON(blobT, input, b[:])
return hexutil.UnmarshalFixedJSON(blobT, input, b[:])
}
// MarshalText returns the hex representation of b.
func (b *Blob) MarshalText() ([]byte, error) {
return utils.Bytes(b[:]).MarshalText()
return hexutil.Bytes(b[:]).MarshalText()
}
// Commitment is a serialized commitment to a polynomial.
@@ -56,12 +56,12 @@ type Commitment [48]byte
// UnmarshalJSON parses a commitment in hex syntax.
func (c *Commitment) UnmarshalJSON(input []byte) error {
return utils.UnmarshalFixedJSON(commitmentT, input, c[:])
return hexutil.UnmarshalFixedJSON(commitmentT, input, c[:])
}
// MarshalText returns the hex representation of c.
func (c Commitment) MarshalText() ([]byte, error) {
return utils.Bytes(c[:]).MarshalText()
return hexutil.Bytes(c[:]).MarshalText()
}
// Proof is a serialized commitment to the quotient polynomial.
@@ -69,12 +69,12 @@ type Proof [48]byte
// UnmarshalJSON parses a proof in hex syntax.
func (p *Proof) UnmarshalJSON(input []byte) error {
return utils.UnmarshalFixedJSON(proofT, input, p[:])
return hexutil.UnmarshalFixedJSON(proofT, input, p[:])
}
// MarshalText returns the hex representation of p.
func (p Proof) MarshalText() ([]byte, error) {
return utils.Bytes(p[:]).MarshalText()
return hexutil.Bytes(p[:]).MarshalText()
}
// Point is a BLS field element.
kzg4844/kzg4844_ckzg_cgo.go
+5 -5
View File
@@ -1,4 +1,4 @@
// Copyright (C) 2020-2025, Lux Industries Inc
// Copyright 2023 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
@@ -25,7 +25,7 @@ import (
gokzg4844 "github.com/crate-crypto/go-eth-kzg"
ckzg4844 "github.com/ethereum/c-kzg-4844/v2/bindings/go"
"github.com/luxfi/crypto/utils"
"github.com/luxfi/geth/common/hexutil"
)
// ckzgAvailable signals whether the library was compiled into Geth.
@@ -49,15 +49,15 @@ func ckzgInit() {
}
g1Lag := make([]byte, len(params.SetupG1Lagrange)*(len(params.SetupG1Lagrange[0])-2)/2)
for i, g1 := range params.SetupG1Lagrange {
copy(g1Lag[i*(len(g1)-2)/2:], utils.MustDecode(g1))
copy(g1Lag[i*(len(g1)-2)/2:], hexutil.MustDecode(g1))
}
g1s := make([]byte, len(params.SetupG1Monomial)*(len(params.SetupG1Monomial[0])-2)/2)
for i, g1 := range params.SetupG1Monomial {
copy(g1s[i*(len(g1)-2)/2:], utils.MustDecode(g1))
copy(g1s[i*(len(g1)-2)/2:], hexutil.MustDecode(g1))
}
g2s := make([]byte, len(params.SetupG2)*(len(params.SetupG2[0])-2)/2)
for i, g2 := range params.SetupG2 {
copy(g2s[i*(len(g2)-2)/2:], utils.MustDecode(g2))
copy(g2s[i*(len(g2)-2)/2:], hexutil.MustDecode(g2))
}
// The last parameter determines the multiplication table, see https://notes.ethereum.org/@jtraglia/windowed_multiplications
// I think 6 is an decent compromise between size and speed
kzg4844/kzg4844_ckzg_nocgo.go
+1 -1
View File
@@ -1,4 +1,4 @@
// Copyright (C) 2020-2025, Lux Industries Inc
// Copyright 2023 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
kzg4844/kzg4844_gokzg.go
+1 -1
View File
@@ -1,4 +1,4 @@
// Copyright (C) 2020-2025, Lux Industries Inc
// Copyright 2023 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
kzg4844/kzg4844_test.go
+1 -1
View File
@@ -1,4 +1,4 @@
// Copyright (C) 2020-2025, Lux Industries Inc
// Copyright 2023 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
secp256r1/verifier.go
+1 -1
View File
@@ -1,4 +1,4 @@
// Copyright (C) 2020-2025, Lux Industries Inc
// Copyright 2024 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
signature_cgo.go
+10 -43
View File
@@ -1,4 +1,4 @@
// Copyright (C) 2020-2025, Lux Industries Inc
// Copyright 2017 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
@@ -23,15 +23,14 @@ import (
"crypto/ecdsa"
"errors"
"fmt"
"math/big"
"github.com/luxfi/crypto/secp256k1"
"github.com/luxfi/crypto/utils"
"github.com/luxfi/geth/common/math"
luxSecp256k1 "github.com/luxfi/crypto/secp256k1"
)
// Ecrecover returns the uncompressed public key that created the given signature.
func Ecrecover(hash, sig []byte) ([]byte, error) {
return secp256k1.RecoverPubkey(hash, sig)
return luxSecp256k1.RecoverPubkey(hash, sig)
}
// SigToPub returns the public key that created the given signature.
@@ -55,21 +54,21 @@ func Sign(digestHash []byte, prv *ecdsa.PrivateKey) (sig []byte, err error) {
if len(digestHash) != DigestLength {
return nil, fmt.Errorf("hash is required to be exactly %d bytes (%d)", DigestLength, len(digestHash))
}
seckey := utils.PaddedBigBytes(prv.D, prv.Params().BitSize/8)
seckey := math.PaddedBigBytes(prv.D, prv.Params().BitSize/8)
defer zeroBytes(seckey)
return secp256k1.Sign(digestHash, seckey)
return luxSecp256k1.Sign(digestHash, seckey)
}
// VerifySignature checks that the given public key created signature over digest.
// The public key should be in compressed (33 bytes) or uncompressed (65 bytes) format.
// The signature should have the 64 byte [R || S] format.
func VerifySignature(pubkey, digestHash, signature []byte) bool {
return secp256k1.VerifySignature(pubkey, digestHash, signature)
return luxSecp256k1.VerifySignature(pubkey, digestHash, signature)
}
// DecompressPubkey parses a public key in the 33-byte compressed format.
func DecompressPubkey(pubkey []byte) (*ecdsa.PublicKey, error) {
x, y := secp256k1.DecompressPubkey(pubkey)
x, y := luxSecp256k1.DecompressPubkey(pubkey)
if x == nil {
return nil, errors.New("invalid public key")
}
@@ -78,42 +77,10 @@ func DecompressPubkey(pubkey []byte) (*ecdsa.PublicKey, error) {
// CompressPubkey encodes a public key to the 33-byte compressed format.
func CompressPubkey(pubkey *ecdsa.PublicKey) []byte {
return secp256k1.CompressPubkey(pubkey.X, pubkey.Y)
return luxSecp256k1.CompressPubkey(pubkey.X, pubkey.Y)
}
// S256 returns an instance of the secp256k1 curve.
func S256() EllipticCurve {
return btCurve{secp256k1.S256()}
}
type btCurve struct {
*secp256k1.BitCurve
}
// Marshal converts a point given as (x, y) into a byte slice.
func (curve btCurve) Marshal(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
}
// Unmarshal converts a point, serialised by Marshal, into an x, y pair. On
// error, x = nil.
func (curve btCurve) Unmarshal(data []byte) (x, y *big.Int) {
byteLen := (curve.Params().BitSize + 7) / 8
if len(data) != 1+2*byteLen {
return nil, nil
}
if data[0] != 4 { // uncompressed form
return nil, nil
}
x = new(big.Int).SetBytes(data[1 : 1+byteLen])
y = new(big.Int).SetBytes(data[1+byteLen:])
return
return luxSecp256k1.S256()
}
signature_nocgo.go
+1 -18
View File
@@ -1,4 +1,4 @@
// Copyright (C) 2020-2025, Lux Industries Inc
// Copyright 2017 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
@@ -21,7 +21,6 @@ package crypto
import (
"crypto/ecdsa"
"crypto/elliptic"
"errors"
"fmt"
"math/big"
@@ -165,22 +164,6 @@ type btCurve struct {
*secp256k1.KoblitzCurve
}
// Params returns the parameters for the curve.
func (curve btCurve) Params() *elliptic.CurveParams {
return curve.CurveParams
}
// IsOnCurve returns whether the given (x,y) lies on the curve.
func (curve btCurve) IsOnCurve(x, y *big.Int) bool {
return curve.KoblitzCurve.IsOnCurve(x, y)
}
// ScalarBaseMult returns k*G, where G is the base point of the group
// and k is an integer in big-endian form.
func (curve btCurve) ScalarBaseMult(k []byte) (x, y *big.Int) {
return curve.KoblitzCurve.ScalarBaseMult(k)
}
// Marshal converts a point given as (x, y) into a byte slice.
func (curve btCurve) Marshal(x, y *big.Int) []byte {
byteLen := (curve.Params().BitSize + 7) / 8
signature_test.go
+16 -22
View File
@@ -1,4 +1,4 @@
// Copyright (C) 2020-2025, Lux Industries Inc
// Copyright 2017 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
@@ -22,24 +22,18 @@ import (
"reflect"
"testing"
"github.com/luxfi/crypto/utils"
"github.com/luxfi/geth/common"
"github.com/luxfi/geth/common/hexutil"
"github.com/luxfi/geth/common/math"
)
var (
testmsg = mustDecode("0xce0677bb30baa8cf067c88db9811f4333d131bf8bcf12fe7065d211dce971008")
testsig = mustDecode("0x90f27b8b488db00b00606796d2987f6a5f59ae62ea05effe84fef5b8b0e549984a691139ad57a3f0b906637673aa2f63d1f55cb1a69199d4009eea23ceaddc9301")
testpubkey = mustDecode("0x04e32df42865e97135acfb65f3bae71bdc86f4d49150ad6a440b6f15878109880a0a2b2667f7e725ceea70c673093bf67663e0312623c8e091b13cf2c0f11ef652")
testpubkeyc = mustDecode("0x02e32df42865e97135acfb65f3bae71bdc86f4d49150ad6a440b6f15878109880a")
testmsg = hexutil.MustDecode("0xce0677bb30baa8cf067c88db9811f4333d131bf8bcf12fe7065d211dce971008")
testsig = hexutil.MustDecode("0x90f27b8b488db00b00606796d2987f6a5f59ae62ea05effe84fef5b8b0e549984a691139ad57a3f0b906637673aa2f63d1f55cb1a69199d4009eea23ceaddc9301")
testpubkey = hexutil.MustDecode("0x04e32df42865e97135acfb65f3bae71bdc86f4d49150ad6a440b6f15878109880a0a2b2667f7e725ceea70c673093bf67663e0312623c8e091b13cf2c0f11ef652")
testpubkeyc = hexutil.MustDecode("0x02e32df42865e97135acfb65f3bae71bdc86f4d49150ad6a440b6f15878109880a")
)
func mustDecode(s string) []byte {
b := utils.FromHex(s)
if b == nil {
panic("invalid hex string")
}
return b
}
func TestEcrecover(t *testing.T) {
pubkey, err := Ecrecover(testmsg, testsig)
if err != nil {
@@ -68,13 +62,13 @@ func TestVerifySignature(t *testing.T) {
if VerifySignature(testpubkey, testmsg, nil) {
t.Errorf("nil signature valid")
}
if VerifySignature(testpubkey, testmsg, append(utils.CopyBytes(sig), 1, 2, 3)) {
if VerifySignature(testpubkey, testmsg, append(common.CopyBytes(sig), 1, 2, 3)) {
t.Errorf("signature valid with extra bytes at the end")
}
if VerifySignature(testpubkey, testmsg, sig[:len(sig)-2]) {
t.Errorf("signature valid even though it's incomplete")
}
wrongkey := utils.CopyBytes(testpubkey)
wrongkey := common.CopyBytes(testpubkey)
wrongkey[10]++
if VerifySignature(wrongkey, testmsg, sig) {
t.Errorf("signature valid with wrong public key")
@@ -83,9 +77,9 @@ func TestVerifySignature(t *testing.T) {
// This test checks that VerifySignature rejects malleable signatures with s > N/2.
func TestVerifySignatureMalleable(t *testing.T) {
sig := mustDecode("0x638a54215d80a6713c8d523a6adc4e6e73652d859103a36b700851cb0e61b66b8ebfc1a610c57d732ec6e0a8f06a9a7a28df5051ece514702ff9cdff0b11f454")
key := mustDecode("0x03ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd3138")
msg := mustDecode("0xd301ce462d3e639518f482c7f03821fec1e602018630ce621e1e7851c12343a6")
sig := hexutil.MustDecode("0x638a54215d80a6713c8d523a6adc4e6e73652d859103a36b700851cb0e61b66b8ebfc1a610c57d732ec6e0a8f06a9a7a28df5051ece514702ff9cdff0b11f454")
key := hexutil.MustDecode("0x03ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd3138")
msg := hexutil.MustDecode("0xd301ce462d3e639518f482c7f03821fec1e602018630ce621e1e7851c12343a6")
if VerifySignature(key, msg, sig) {
t.Error("VerifySignature returned true for malleable signature")
}
@@ -105,7 +99,7 @@ func TestDecompressPubkey(t *testing.T) {
if _, err := DecompressPubkey(testpubkeyc[:5]); err == nil {
t.Errorf("no error for incomplete pubkey")
}
if _, err := DecompressPubkey(append(utils.CopyBytes(testpubkeyc), 1, 2, 3)); err == nil {
if _, err := DecompressPubkey(append(common.CopyBytes(testpubkeyc), 1, 2, 3)); err == nil {
t.Errorf("no error for pubkey with extra bytes at the end")
}
}
@@ -113,8 +107,8 @@ func TestDecompressPubkey(t *testing.T) {
func TestCompressPubkey(t *testing.T) {
key := &ecdsa.PublicKey{
Curve: S256(),
X: utils.MustParseBig256("0xe32df42865e97135acfb65f3bae71bdc86f4d49150ad6a440b6f15878109880a"),
Y: utils.MustParseBig256("0x0a2b2667f7e725ceea70c673093bf67663e0312623c8e091b13cf2c0f11ef652"),
X: math.MustParseBig256("0xe32df42865e97135acfb65f3bae71bdc86f4d49150ad6a440b6f15878109880a"),
Y: math.MustParseBig256("0x0a2b2667f7e725ceea70c673093bf67663e0312623c8e091b13cf2c0f11ef652"),
}
compressed := CompressPubkey(key)
if !bytes.Equal(compressed, testpubkeyc) {
signify/signify.go
+1 -1
View File
@@ -1,4 +1,4 @@
// Copyright (C) 2020-2025, Lux Industries Inc
// Copyright 2020 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
signify/signify_fuzz.go
+1 -1
View File
@@ -1,4 +1,4 @@
// Copyright (C) 2020-2025, Lux Industries Inc
// Copyright 2020 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
signify/signify_test.go
+2 -2
View File
@@ -1,4 +1,4 @@
// Copyright (C) 2020-2025, Lux Industries Inc
// Copyright 2020 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
@@ -24,7 +24,7 @@ import (
"os"
"testing"
minisign "github.com/jedisct1/go-minisign"
"github.com/jedisct1/go-minisign"
)
var (