Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
29 changes: 26 additions & 3 deletions agglayer/grpc/conversion_to_agglayer.go
Original file line number Diff line number Diff line change
Expand Up @@ -12,12 +12,15 @@ import (
agglayertypes "github.com/agglayer/aggkit/agglayer/types"
"github.com/agglayer/aggkit/bridgesync"
bridgetypes "github.com/agglayer/aggkit/bridgesync/types"
aggkitcommon "github.com/agglayer/aggkit/common"
treetypes "github.com/agglayer/aggkit/tree/types"
"github.com/ethereum/go-ethereum/common"
)

var (
ErrNilCertificate = errors.New("aggsender-validator nil certificate")
// ErrInvalidCertificate is returned when a field of the certificate is present but malformed
ErrInvalidCertificate = errors.New("aggsender-validator invalid certificate")
)

// ConvertProtoCertToAgglayer Convert a certificate from the gRPC (PROTO) format to the agglayer format
Expand Down Expand Up @@ -193,6 +196,9 @@ func grpcImportedBridgeExitToAgglayer(
func grpcClaimDataToAgglayer(claim interface{}) (agglayertypes.Claim, error) {
switch v := claim.(type) {
case *v1types.ImportedBridgeExit_Mainnet:
if v.Mainnet == nil {
return nil, fmt.Errorf("grpcClaimDataToAgglayer. mainnet claim is nil. %w", ErrNilCertificate)
}
proofs, err := grpcMerkleProofsToAgglayer(
v.Mainnet.ProofLeafMer,
v.Mainnet.ProofGerL1Root,
Expand All @@ -210,6 +216,9 @@ func grpcClaimDataToAgglayer(claim interface{}) (agglayertypes.Claim, error) {
L1Leaf: l1feaf,
}, nil
case *v1types.ImportedBridgeExit_Rollup:
if v.Rollup == nil {
return nil, fmt.Errorf("grpcClaimDataToAgglayer. rollup claim is nil. %w", ErrNilCertificate)
}
proofs, err := grpcMerkleProofsToAgglayer(
v.Rollup.ProofLeafLer,
v.Rollup.ProofLerRer,
Expand Down Expand Up @@ -258,7 +267,11 @@ func grpcMerkleProofToAgglayer(proof *v1types.MerkleProof) (*agglayertypes.Merkl
}
siblings := [treetypes.DefaultHeight]common.Hash{}
for i, sibling := range proof.Siblings {
siblings[i] = common.BytesToHash(sibling.Value)
if sibling == nil {
return nil, fmt.Errorf("grpcMerkleProofToAgglayer. proof has a nil sibling at index %d. %w",
i, ErrNilCertificate)
}
siblings[i] = common.BytesToHash(sibling.GetValue())
}

return &agglayertypes.MerkleProof{
Expand Down Expand Up @@ -362,9 +375,19 @@ func grpcMultisigToAgglayer(multisig *v1types.Multisig) (*agglayertypes.Multisig
}

for i, sig := range multisigEcdsa.Ecdsa.Signatures {
// An omitted optional field decodes to nil; reject it instead of dereferencing.
if sig == nil {
return nil, fmt.Errorf("grpcMultisigToAgglayer. signature entry at index %d is nil. %w",
i, ErrNilCertificate)
}
signature := sig.GetSignature().GetValue()
if len(signature) != aggkitcommon.SignatureSize {
return nil, fmt.Errorf("grpcMultisigToAgglayer. signature entry at index %d has an invalid length: "+
"%d. Expected: %d. %w", i, len(signature), aggkitcommon.SignatureSize, ErrInvalidCertificate)
}
multisigAgglayer.Signatures[i] = agglayertypes.ECDSAMultisigEntry{
Signature: sig.Signature.Value,
Index: sig.Index,
Signature: signature,
Index: sig.GetIndex(),
}
}

Expand Down
126 changes: 126 additions & 0 deletions agglayer/grpc/conversion_to_agglayer_survival_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,126 @@
package grpc_test

import (
"context"
"net"
"testing"
"time"

v1nodetypes "buf.build/gen/go/agglayer/agglayer/protocolbuffers/go/agglayer/node/types/v1"
v1types "buf.build/gen/go/agglayer/interop/protocolbuffers/go/agglayer/interop/types/v1"
agglayergrpc "github.com/agglayer/aggkit/agglayer/grpc"
validatorv1 "github.com/agglayer/aggkit/aggsender/validator/proto/v1"
"github.com/stretchr/testify/require"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/credentials/insecure"
"google.golang.org/grpc/status"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/types/known/emptypb"
)

// survivalServer mirrors the conversion and error mapping of the validator's
// ValidateCertificate handler: it converts the incoming certificate and answers an
// invalid argument when the conversion fails. It covers ConvertProtoCertToAgglayer and the
// gRPC error mapping, not the real validator service.
type survivalServer struct {
validatorv1.UnimplementedAggsenderValidatorServer
}

func (s *survivalServer) HealthCheck(
context.Context, *emptypb.Empty,
) (*validatorv1.HealthCheckResponse, error) {
return &validatorv1.HealthCheckResponse{Status: "ok"}, nil
}

func (s *survivalServer) ValidateCertificate(
_ context.Context, req *validatorv1.ValidateCertificateRequest,
) (*validatorv1.ValidateCertificateResponse, error) {
if req == nil || req.Certificate == nil {
return nil, status.Error(codes.NotFound, "required a certificate")
}
if _, err := agglayergrpc.ConvertProtoCertToAgglayer(req.Certificate); err != nil {
return nil, status.Error(codes.InvalidArgument, "Invalid certificate conversion: "+err.Error())
}
return &validatorv1.ValidateCertificateResponse{}, nil
}

// TestMalformedValidateCertificateRequestDoesNotKillServer sends the 88-byte request that
// used to panic the validator over a real gRPC connection and checks that the call is
// rejected and the server keeps serving.
func TestMalformedValidateCertificateRequestDoesNotKillServer(t *testing.T) {
lis, err := net.Listen("tcp", "127.0.0.1:0")
require.NoError(t, err)

server := grpc.NewServer()
validatorv1.RegisterAggsenderValidatorServer(server, &survivalServer{})
go func() { _ = server.Serve(lis) }()
t.Cleanup(server.Stop)

ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()

conn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
require.NoError(t, err)
t.Cleanup(func() { _ = conn.Close() })

client := validatorv1.NewAggsenderValidatorClient(conn)

// The certificate from the report: both exit roots, one L1 leaf and a multisig entry
// that carries an index but no signature. On the wire the signature field is omitted
// and decodes to nil.
request := &validatorv1.ValidateCertificateRequest{
Certificate: &v1nodetypes.Certificate{
NetworkId: 1,
Height: 1,
PrevLocalExitRoot: &v1types.FixedBytes32{Value: make([]byte, 32)},
NewLocalExitRoot: &v1types.FixedBytes32{Value: make([]byte, 32)},
L1InfoTreeLeafCount: proto.Uint32(1),
AggchainData: &v1types.AggchainData{
Data: &v1types.AggchainData_Multisig{
Multisig: &v1types.Multisig{
Data: &v1types.Multisig_Ecdsa{
Ecdsa: &v1types.ECDSAMultisig{
Signatures: []*v1types.ECDSAMultisig_ECDSAMultisigEntry{{Index: 0}},
},
},
},
},
},
},
}

payload, err := proto.Marshal(request)
require.NoError(t, err)
require.Len(t, payload, 88, "the request from the report serializes to 88 bytes")

// Send the bytes as received, so the test does not depend on the in-memory struct.
var wireRequest validatorv1.ValidateCertificateRequest
require.NoError(t, proto.Unmarshal(payload, &wireRequest))

_, err = client.ValidateCertificate(ctx, &wireRequest)
require.Error(t, err)
require.Equal(t, codes.InvalidArgument, status.Code(err))

// The server is still up: the panic is gone and the process did not exit.
health, err := client.HealthCheck(ctx, &emptypb.Empty{})
require.NoError(t, err)
require.Equal(t, "ok", health.GetStatus())
}

// FuzzConvertProtoCertToAgglayer feeds arbitrary bytes to the conversion and checks that a
// certificate decoded from them can never panic it.
func FuzzConvertProtoCertToAgglayer(f *testing.F) {
f.Add([]byte{})
f.Add([]byte{0x1a, 0x22, 0x0a, 0x20}) // a certificate with no aggchain data
f.Add([]byte{0x42, 0x06, 0x1a, 0x04, 0x0a, 0x02, 0x1a, 0x00}) // a multisig entry without signature
f.Fuzz(func(t *testing.T, data []byte) {
var cert v1nodetypes.Certificate
if err := proto.Unmarshal(data, &cert); err != nil {
t.Skip()
}
require.NotPanics(t, func() {
_, _ = agglayergrpc.ConvertProtoCertToAgglayer(&cert)
})
})
}
185 changes: 185 additions & 0 deletions agglayer/grpc/conversion_to_agglayer_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -516,3 +516,188 @@ func TestGrpcL1LeafToAgglayer(t *testing.T) {
require.ErrorIs(t, err, ErrNilCertificate)
})
}

// TestConvertProtoCertToAgglayerRejectsNilMultisigSignature covers the certificate that
// crashed the validator: a multisig entry whose optional signature field is omitted on the
// wire. The conversion must return an error instead of dereferencing the nil signature.
func TestConvertProtoCertToAgglayerRejectsNilMultisigSignature(t *testing.T) {
validProof := func() *v1types.AggchainProof {
return &v1types.AggchainProof{
Proof: &v1types.AggchainProof_Sp1Stark{
Sp1Stark: &v1types.SP1StarkProof{
Proof: []byte{0x01, 0x02, 0x03},
Version: "1.0",
Vkey: []byte{0x01, 0x02, 0x03},
},
},
AggchainParams: &v1types.FixedBytes32{
Value: common.HexToHash("0x0102030405060708090a0b0c0d0e0f1011121314151617181920212223242526").Bytes(),
},
Signature: &v1types.FixedBytes65{Value: make([]byte, aggkitcommon.SignatureSize)},
}
}

multisigWith := func(entries ...*v1types.ECDSAMultisig_ECDSAMultisigEntry) *v1types.Multisig {
return &v1types.Multisig{
Data: &v1types.Multisig_Ecdsa{
Ecdsa: &v1types.ECDSAMultisig{Signatures: entries},
},
}
}

tests := []struct {
name string
aggchainData *v1types.AggchainData
errContains string
wantErr error
}{
{
name: "multisig entry without signature",
aggchainData: &v1types.AggchainData{
Data: &v1types.AggchainData_Multisig{
Multisig: multisigWith(&v1types.ECDSAMultisig_ECDSAMultisigEntry{Index: 0}),
},
},
errContains: "signature entry at index 0 has an invalid length",
wantErr: ErrInvalidCertificate,
},
{
name: "multisig entry is nil",
aggchainData: &v1types.AggchainData{
Data: &v1types.AggchainData_Multisig{
Multisig: multisigWith(nil),
},
},
errContains: "signature entry at index 0 is nil",
wantErr: ErrNilCertificate,
},
{
name: "multisig entry with a short signature",
aggchainData: &v1types.AggchainData{
Data: &v1types.AggchainData_Multisig{
Multisig: multisigWith(&v1types.ECDSAMultisig_ECDSAMultisigEntry{
Index: 0,
Signature: &v1types.FixedBytes65{Value: make([]byte, aggkitcommon.SignatureSize-1)},
}),
},
},
errContains: "signature entry at index 0 has an invalid length",
wantErr: ErrInvalidCertificate,
},
{
name: "multisig and aggchain proof entry without signature",
aggchainData: &v1types.AggchainData{
Data: &v1types.AggchainData_MultisigAndAggchainProof{
MultisigAndAggchainProof: &v1types.AggchainProofWithMultisig{
Multisig: multisigWith(&v1types.ECDSAMultisig_ECDSAMultisigEntry{Index: 0}),
AggchainProof: validProof(),
},
},
},
errContains: "signature entry at index 0 has an invalid length",
wantErr: ErrInvalidCertificate,
},
}

for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
protoCert, err := ConvertCertToProtoCertificate(exampleTestAgglayerCert)
require.NoError(t, err)
protoCert.AggchainData = tt.aggchainData

var result *agglayertypes.Certificate
require.NotPanics(t, func() {
result, err = ConvertProtoCertToAgglayer(protoCert)
})
require.Nil(t, result)
require.ErrorIs(t, err, tt.wantErr)
require.ErrorContains(t, err, tt.errContains)
})
}

t.Run("valid 65-byte signature still converts", func(t *testing.T) {
protoCert, err := ConvertCertToProtoCertificate(exampleTestAgglayerCert)
require.NoError(t, err)
protoCert.AggchainData = &v1types.AggchainData{
Data: &v1types.AggchainData_Multisig{
Multisig: multisigWith(&v1types.ECDSAMultisig_ECDSAMultisigEntry{
Index: 3,
Signature: &v1types.FixedBytes65{Value: make([]byte, aggkitcommon.SignatureSize)},
}),
},
}

result, err := ConvertProtoCertToAgglayer(protoCert)
require.NoError(t, err)
multisig, ok := result.AggchainData.(*agglayertypes.AggchainDataMultisig)
require.True(t, ok)
require.Len(t, multisig.Multisig.Signatures, 1)
require.Equal(t, uint32(3), multisig.Multisig.Signatures[0].Index)
require.Len(t, multisig.Multisig.Signatures[0].Signature, aggkitcommon.SignatureSize)
})
}

// TestConvertProtoCertToAgglayerRejectsNilNestedMessages covers the other optional nested
// messages that the conversion dereferences, so a malformed request cannot panic it.
func TestConvertProtoCertToAgglayerRejectsNilNestedMessages(t *testing.T) {
t.Run("nil merkle proof sibling", func(t *testing.T) {
protoCert, err := ConvertCertToProtoCertificate(exampleTestAgglayerCert)
require.NoError(t, err)
protoCert.ImportedBridgeExits[0].Claim = &v1types.ImportedBridgeExit_Mainnet{
Mainnet: &v1types.ClaimFromMainnet{
ProofLeafMer: &v1types.MerkleProof{
Root: &v1types.FixedBytes32{Value: make([]byte, 32)},
Siblings: make([]*v1types.FixedBytes32, 32),
},
ProofGerL1Root: &v1types.MerkleProof{
Root: &v1types.FixedBytes32{Value: make([]byte, 32)},
Siblings: make([]*v1types.FixedBytes32, 32),
},
L1Leaf: &v1types.L1InfoTreeLeafWithContext{
Rer: &v1types.FixedBytes32{Value: make([]byte, 32)},
Mer: &v1types.FixedBytes32{Value: make([]byte, 32)},
Inner: &v1types.L1InfoTreeLeaf{
GlobalExitRoot: &v1types.FixedBytes32{Value: make([]byte, 32)},
BlockHash: &v1types.FixedBytes32{Value: make([]byte, 32)},
},
},
},
}

var result *agglayertypes.Certificate
require.NotPanics(t, func() {
result, err = ConvertProtoCertToAgglayer(protoCert)
})
require.Nil(t, result)
require.ErrorIs(t, err, ErrNilCertificate)
require.ErrorContains(t, err, "nil sibling")
})

t.Run("nil mainnet claim", func(t *testing.T) {
protoCert, err := ConvertCertToProtoCertificate(exampleTestAgglayerCert)
require.NoError(t, err)
protoCert.ImportedBridgeExits[0].Claim = &v1types.ImportedBridgeExit_Mainnet{}

var result *agglayertypes.Certificate
require.NotPanics(t, func() {
result, err = ConvertProtoCertToAgglayer(protoCert)
})
require.Nil(t, result)
require.ErrorIs(t, err, ErrNilCertificate)
require.ErrorContains(t, err, "mainnet claim is nil")
})

t.Run("nil rollup claim", func(t *testing.T) {
protoCert, err := ConvertCertToProtoCertificate(exampleTestAgglayerCert)
require.NoError(t, err)
protoCert.ImportedBridgeExits[1].Claim = &v1types.ImportedBridgeExit_Rollup{}

var result *agglayertypes.Certificate
require.NotPanics(t, func() {
result, err = ConvertProtoCertToAgglayer(protoCert)
})
require.Nil(t, result)
require.ErrorIs(t, err, ErrNilCertificate)
require.ErrorContains(t, err, "rollup claim is nil")
})
}
Loading