mirror of
https://github.com/luxfi/precompile.git
synced 2026-09-24 00:26:21 +00:00
zeekay
a466c21334
ring's lsagVerify halted the chain from calldata. A scalar of 0 or >= N makes ScalarMult return a nil point and curve.Add dereferences it; geth's dispatch has no recover, so one transaction stops every validator. Its parser also left scalars unvalidated, and the two builds disagree about them -- cgo refuses an out-of-range scalar, pure-Go reduces it silently -- so the same calldata produced different verdicts depending on how the node was compiled. frost's Schnorr check was a total forgery. An unliftable x-only key fell through to the identity, collapsing z*G == R + c*Y to z*G == R, so choosing any z and publishing R = z*G verifies under every off-curve x. cggmp21 forges the same way if either coordinate comparison is dropped: one coordinate does not identify a secp256k1 point, since (P, -P) share x and (P, lambda*P, lambda^2*P) share y through the GLV endomorphism. pulsar returned the full supplied gas on four exits -- work done, nothing billed -- and ring had three arms returning zero. Corona quoted base + n*10000 with n an unbounded uint32 off the wire, up to 4.29e13 gas. Capping the charger alone would have left the exported EstimateGas disagreeing with the fee, so quote and charge are now one function. corona's deserializePoly ignored the count from bytes.Reader.Read, which returns a short read with a nil error, so a truncated blob was zero-filled and fabricated coefficients were accepted as signed material. Its exported ExpectedSignatureSize said 4096 against a real 163840 -- it omitted the A matrix and bTilde that its own parser reads -- so any caller sizing calldata by it built a call that could only be rejected. Per-party gas prices nothing: corona's verifier never referenced t or n (dead parameters, now gone), and frost and cggmp21 use totalSigners only for a structural check. All three charge a variable fee for constant work. The cap contains it; the schedule is consensus-visible and left alone. Vectors are frozen hex with the generators deleted, because a fresh-key round trip passes when signer and verifier are uniformly wrong together. Each carries a genuine signature by the same key over the same message under a sibling slot's context, which must be refused -- domain separation tested against a real signature rather than corrupted bytes. 189 mutations, one at a time with restore-and-reverify. Five survivors, each proven equivalent by a downstream check reaching the identical verdict.
71 lines
2.6 KiB
Go
71 lines
2.6 KiB
Go
// Copyright (C) 2025, Lux Industries, Inc. All rights reserved.
|
|
// See the file LICENSE for licensing terms.
|
|
|
|
package ring
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/luxfi/precompile/modules"
|
|
"github.com/luxfi/precompile/precompileconfig"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
type fakeConfig struct{}
|
|
|
|
func (f *fakeConfig) Key() string { return "fake" }
|
|
func (f *fakeConfig) Timestamp() *uint64 { return nil }
|
|
func (f *fakeConfig) IsDisabled() bool { return false }
|
|
func (f *fakeConfig) Equal(precompileconfig.Config) bool { return false }
|
|
func (f *fakeConfig) Verify(precompileconfig.ChainConfig) error { return nil }
|
|
|
|
type testChainCfg struct{}
|
|
|
|
func (t *testChainCfg) IsDurango(uint64) bool { return true }
|
|
|
|
func TestConfigLifecycle(t *testing.T) {
|
|
cfg := &Config{}
|
|
require.Equal(t, ConfigKey, cfg.Key())
|
|
require.Equal(t, "ringConfig", cfg.Key())
|
|
require.Nil(t, cfg.Timestamp())
|
|
require.False(t, cfg.IsDisabled())
|
|
require.NoError(t, cfg.Verify(&testChainCfg{}))
|
|
require.True(t, cfg.Equal(&Config{}))
|
|
require.False(t, cfg.Equal(&fakeConfig{}), "a config of another type is never equal")
|
|
require.False(t, cfg.Equal(nil), "nil is never equal")
|
|
|
|
ts := uint64(42)
|
|
cfg2 := &Config{Upgrade: precompileconfig.Upgrade{BlockTimestamp: &ts}}
|
|
require.Equal(t, &ts, cfg2.Timestamp())
|
|
require.False(t, cfg.Equal(cfg2), "configs differing in timestamp are not equal")
|
|
require.False(t, cfg2.Equal(cfg))
|
|
|
|
cfg3 := &Config{Upgrade: precompileconfig.Upgrade{Disable: true}}
|
|
require.True(t, cfg3.IsDisabled())
|
|
require.False(t, cfg.Equal(cfg3), "configs differing in disable are not equal")
|
|
}
|
|
|
|
func TestConfigurator(t *testing.T) {
|
|
c := &configurator{}
|
|
cfg := c.MakeConfig()
|
|
require.NotNil(t, cfg)
|
|
require.Equal(t, ConfigKey, cfg.Key())
|
|
require.NotSame(t, cfg, c.MakeConfig(), "MakeConfig hands out a fresh value each call")
|
|
require.NoError(t, c.Configure(&testChainCfg{}, cfg, nil, nil))
|
|
}
|
|
|
|
// The init() registration is what makes the precompile reachable at all;
|
|
// assert the registry actually holds this address, key and contract.
|
|
func TestModuleRegistered(t *testing.T) {
|
|
byAddr, ok := modules.GetPrecompileModuleByAddress(ContractAddress)
|
|
require.True(t, ok, "no module registered at 0x9202")
|
|
require.Equal(t, ConfigKey, byAddr.ConfigKey)
|
|
require.Same(t, RingSignaturePrecompile, byAddr.Contract)
|
|
|
|
byKey, ok := modules.GetPrecompileModule(ConfigKey)
|
|
require.True(t, ok)
|
|
require.Equal(t, ContractAddress, byKey.Address)
|
|
require.Equal(t, ContractAddress, RingSignaturePrecompile.Address(),
|
|
"the contract must answer with the address it is registered under")
|
|
}
|