Remove nitrite from Nitro attestation validation

Author: nadahalli

go.mod

@@ -21,7 +21,6 @@ require (
 	github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus v1.0.1
 	github.com/hashicorp/go-hclog v1.6.3
 	github.com/hashicorp/go-plugin v1.7.0
-	github.com/hf/nitrite v0.0.0-20241225144000-c2d5d3c4f303
 	github.com/iancoleman/strcase v0.3.0
 	github.com/invopop/jsonschema v0.13.0
 	github.com/jackc/pgx/v4 v4.18.3

go.sum

@@ -1,7 +1,7 @@
 // Package nitrofake provides an Attestor that produces structurally valid
-// COSE Sign1 attestation documents. These documents pass nitrite.Verify's
-// full validation chain (CBOR parsing, cert chain, ECDSA signature, UserData,
-// PCRs) without requiring real Nitro hardware.
+// COSE Sign1 attestation documents. These documents pass the local Nitro
+// attestation validator's full validation chain (CBOR parsing, cert chain,
+// ECDSA signature, UserData, PCRs) without requiring real Nitro hardware.
 package nitrofake
 
 import (
@@ -21,7 +21,7 @@ import (
 )
 
 // Attestor produces structurally valid COSE Sign1 attestation documents
-// that pass nitrite.Verify with a custom CA root.
+// that pass the local Nitro validator with a custom CA root.
 type Attestor struct {
 	rootKey     *ecdsa.PrivateKey
 	rootCert    *x509.Certificate

pkg/teeattestation/nitro/fake/fake.go

@@ -2,10 +2,10 @@ package nitrofake
 
 import (
 	"testing"
-	"time"
 
-	"github.com/hf/nitrite"
 	"github.com/stretchr/testify/require"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/teeattestation/nitro"
 )
 
 func TestAttestor_RoundTrip(t *testing.T) {
@@ -17,19 +17,8 @@ func TestAttestor_RoundTrip(t *testing.T) {
 	require.NoError(t, err)
 	require.NotEmpty(t, attestation)
 
-	result, err := nitrite.Verify(attestation, nitrite.VerifyOptions{
-		CurrentTime: time.Now(),
-		Roots:       fa.CARoots(),
-	})
+	err = nitro.ValidateAttestationWithRoots(attestation, userData, fa.TrustedPCRsJSON(), fa.CARootsPEM())
 	require.NoError(t, err)
-	require.True(t, result.SignatureOK, "ECDSA signature should be valid")
-	require.Equal(t, userData, result.Document.UserData)
-	require.Equal(t, "SHA384", result.Document.Digest)
-	require.Equal(t, "fake-enclave-module", result.Document.ModuleID)
-	require.Len(t, result.Document.PCRs, 3)
-	require.Len(t, result.Document.PCRs[0], 48)
-	require.Len(t, result.Document.PCRs[1], 48)
-	require.Len(t, result.Document.PCRs[2], 48)
 }
 
 func TestAttestor_TrustedPCRsJSON(t *testing.T) {

pkg/teeattestation/nitro/fake/fake_test.go

@@ -9,8 +9,6 @@ import (
 	"errors"
 	"fmt"
 	"time"
-
-	"github.com/hf/nitrite"
 )
 
 // HexBytes is a custom type that unmarshals hex strings into a byte slice
@@ -71,35 +69,32 @@ func ValidateAttestationWithRoots(attestation, expectedUserData, trustedMeasurem
 	if !ok {
 		return errors.New("failed to parse CA roots")
 	}
-	result, err := nitrite.Verify(attestation, nitrite.VerifyOptions{
-		CurrentTime: time.Now(),
-		Roots:       pool,
-	})
+	result, err := verifyAttestationDocument(attestation, pool, time.Now())
 	if err != nil {
 		return fmt.Errorf("failed to verify nitro attestation: %w", err)
 	}
-	if !result.SignatureOK {
+	if !result.signatureOK {
 		return errors.New("signature verification failed")
 	}
 
-	if !bytes.Equal(expectedUserData, result.Document.UserData) {
-		return fmt.Errorf("expected user data %x, got %x", expectedUserData, result.Document.UserData)
+	if !bytes.Equal(expectedUserData, result.document.UserData) {
+		return fmt.Errorf("expected user data %x, got %x", expectedUserData, result.document.UserData)
 	}
 
 	var trustedPCRs PCRs
 	if err := json.Unmarshal(trustedMeasurements, &trustedPCRs); err != nil {
 		return fmt.Errorf("failed to unmarshal trusted PCRs: %w", err)
 	}
-	if len(result.Document.PCRs) < 3 {
-		return fmt.Errorf("attestation document has %d PCRs, need at least 3", len(result.Document.PCRs))
+	if len(result.document.PCRs) < 3 {
+		return fmt.Errorf("attestation document has %d PCRs, need at least 3", len(result.document.PCRs))
 	}
-	if !bytes.Equal(result.Document.PCRs[0], trustedPCRs.PCR0) {
+	if !bytes.Equal(result.document.PCRs[0], trustedPCRs.PCR0) {
 		return fmt.Errorf("PCR0 mismatch: expected %x", trustedPCRs.PCR0)
 	}
-	if !bytes.Equal(result.Document.PCRs[1], trustedPCRs.PCR1) {
+	if !bytes.Equal(result.document.PCRs[1], trustedPCRs.PCR1) {
 		return fmt.Errorf("PCR1 mismatch: expected %x", trustedPCRs.PCR1)
 	}
-	if !bytes.Equal(result.Document.PCRs[2], trustedPCRs.PCR2) {
+	if !bytes.Equal(result.document.PCRs[2], trustedPCRs.PCR2) {
 		return fmt.Errorf("PCR2 mismatch: expected %x", trustedPCRs.PCR2)
 	}
 	return nil

pkg/teeattestation/nitro/validate.go

@@ -0,0 +1,251 @@
+package nitro
+
+import (
+	"crypto/ecdsa"
+	"crypto/sha256"
+	"crypto/sha512"
+	"crypto/x509"
+	"errors"
+	"fmt"
+	"math/big"
+	"time"
+
+	"github.com/fxamacker/cbor/v2"
+)
+
+var (
+	errBadCOSESign1Structure         = errors.New("data is not a COSE Sign1 array")
+	errEmptyProtectedSection         = errors.New("COSE Sign1 protected section is nil or empty")
+	errEmptyPayloadSection           = errors.New("COSE Sign1 payload section is nil or empty")
+	errEmptySignatureSection         = errors.New("COSE Sign1 signature section is nil or empty")
+	errUnsupportedSignatureAlgorithm = errors.New("COSE Sign1 algorithm is not ECDSA P-384")
+	errBadAttestationDocument        = errors.New("bad attestation document")
+	errMandatoryFieldsMissing        = errors.New("attestation document is missing mandatory fields")
+	errBadDigest                     = errors.New("attestation digest is not SHA384")
+	errBadTimestamp                  = errors.New("attestation timestamp is 0")
+	errBadPCRs                       = errors.New("attestation pcrs is less than 1 or more than 32")
+	errBadPCRIndex                   = errors.New("attestation pcr index is not in [0, 32)")
+	errBadPCRValue                   = errors.New("attestation pcr value length is invalid")
+	errBadCABundle                   = errors.New("attestation cabundle is empty")
+	errBadCABundleItem               = errors.New("attestation cabundle item is empty or too large")
+	errBadPublicKey                  = errors.New("attestation public_key length is invalid")
+	errBadUserData                   = errors.New("attestation user_data length is invalid")
+	errBadNonce                      = errors.New("attestation nonce length is invalid")
+	errBadCertificatePublicKeyAlgo   = errors.New("attestation certificate public key algorithm is not ECDSA")
+	errBadCertificateSigningAlgo     = errors.New("attestation certificate signature algorithm is not ECDSAWithSHA384")
+	errBadSignature                  = errors.New("attestation signature does not match certificate")
+)
+
+type verifyResult struct {
+	document    *attestationDocument
+	signatureOK bool
+}
+
+type attestationDocument struct {
+	ModuleID    string          `cbor:"module_id"`
+	Timestamp   uint64          `cbor:"timestamp"`
+	Digest      string          `cbor:"digest"`
+	PCRs        map[uint][]byte `cbor:"pcrs"`
+	Certificate []byte          `cbor:"certificate"`
+	CABundle    [][]byte        `cbor:"cabundle"`
+	PublicKey   []byte          `cbor:"public_key,omitempty"`
+	UserData    []byte          `cbor:"user_data,omitempty"`
+	Nonce       []byte          `cbor:"nonce,omitempty"`
+}
+
+type coseProtectedHeader struct {
+	Alg any `cbor:"1,keyasint,omitempty"`
+}
+
+type coseSign1 struct {
+	_           struct{} `cbor:",toarray"` //nolint:revive // idiomatic CBOR array encoding
+	Protected   []byte
+	Unprotected cbor.RawMessage
+	Payload     []byte
+	Signature   []byte
+}
+
+type coseSignatureInput struct {
+	_           struct{} `cbor:",toarray"` //nolint:revive // idiomatic CBOR array encoding
+	Context     string
+	Protected   []byte
+	ExternalAAD []byte
+	Payload     []byte
+}
+
+func verifyAttestationDocument(data []byte, roots *x509.CertPool, currentTime time.Time) (*verifyResult, error) {
+	var sign1 coseSign1
+	if err := cbor.Unmarshal(data, &sign1); err != nil {
+		return nil, errBadCOSESign1Structure
+	}
+	if len(sign1.Protected) == 0 {
+		return nil, errEmptyProtectedSection
+	}
+	if len(sign1.Payload) == 0 {
+		return nil, errEmptyPayloadSection
+	}
+	if len(sign1.Signature) == 0 {
+		return nil, errEmptySignatureSection
+	}
+
+	var protected coseProtectedHeader
+	if err := cbor.Unmarshal(sign1.Protected, &protected); err != nil {
+		return nil, errBadCOSESign1Structure
+	}
+	if err := validateProtectedAlgorithm(protected.Alg); err != nil {
+		return nil, err
+	}
+
+	var doc attestationDocument
+	if err := cbor.Unmarshal(sign1.Payload, &doc); err != nil {
+		return nil, errBadAttestationDocument
+	}
+	if err := validateAttestationPayload(&doc); err != nil {
+		return nil, err
+	}
+
+	leafCert, intermediates, err := parseCertificateChain(&doc)
+	if err != nil {
+		return nil, err
+	}
+	if currentTime.IsZero() {
+		currentTime = time.Now()
+	}
+	if _, err := leafCert.Verify(x509.VerifyOptions{
+		Intermediates: intermediates,
+		Roots:         roots,
+		CurrentTime:   currentTime,
+		KeyUsages:     []x509.ExtKeyUsage{x509.ExtKeyUsageAny},
+	}); err != nil {
+		return nil, err
+	}
+
+	sigStructure, err := cbor.Marshal(&coseSignatureInput{
+		Context:     "Signature1",
+		Protected:   sign1.Protected,
+		ExternalAAD: []byte{},
+		Payload:     sign1.Payload,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("build signature structure: %w", err)
+	}
+
+	pubKey, ok := leafCert.PublicKey.(*ecdsa.PublicKey)
+	if !ok {
+		return nil, errBadCertificatePublicKeyAlgo
+	}
+	signatureOK := verifyECDSASignature(pubKey, sigStructure, sign1.Signature)
+	if !signatureOK {
+		return &verifyResult{document: &doc, signatureOK: false}, errBadSignature
+	}
+
+	return &verifyResult{document: &doc, signatureOK: true}, nil
+}
+
+func validateProtectedAlgorithm(alg any) error {
+	switch v := alg.(type) {
+	case int64:
+		if v == -35 {
+			return nil
+		}
+	case string:
+		if v == "ES384" {
+			return nil
+		}
+	}
+	return errUnsupportedSignatureAlgorithm
+}
+
+func validateAttestationPayload(doc *attestationDocument) error {
+	if doc.ModuleID == "" || doc.Digest == "" || doc.Timestamp == 0 || doc.PCRs == nil || doc.Certificate == nil || doc.CABundle == nil {
+		return errMandatoryFieldsMissing
+	}
+	if doc.Digest != "SHA384" {
+		return errBadDigest
+	}
+	if doc.Timestamp < 1 {
+		return errBadTimestamp
+	}
+	if len(doc.PCRs) < 1 || len(doc.PCRs) > 32 {
+		return errBadPCRs
+	}
+	for idx, value := range doc.PCRs {
+		if idx > 31 {
+			return errBadPCRIndex
+		}
+		if value == nil || (len(value) != 32 && len(value) != 48 && len(value) != 64) {
+			return errBadPCRValue
+		}
+	}
+	if len(doc.CABundle) < 1 {
+		return errBadCABundle
+	}
+	for _, item := range doc.CABundle {
+		if item == nil || len(item) < 1 || len(item) > 1024 {
+			return errBadCABundleItem
+		}
+	}
+	if doc.PublicKey != nil && len(doc.PublicKey) > 1024 {
+		return errBadPublicKey
+	}
+	if doc.UserData != nil && len(doc.UserData) > 1024 {
+		return errBadUserData
+	}
+	if doc.Nonce != nil && len(doc.Nonce) > 1024 {
+		return errBadNonce
+	}
+	return nil
+}
+
+func parseCertificateChain(doc *attestationDocument) (*x509.Certificate, *x509.CertPool, error) {
+	leafCert, err := x509.ParseCertificate(doc.Certificate)
+	if err != nil {
+		return nil, nil, err
+	}
+	if leafCert.PublicKeyAlgorithm != x509.ECDSA {
+		return nil, nil, errBadCertificatePublicKeyAlgo
+	}
+	if leafCert.SignatureAlgorithm != x509.ECDSAWithSHA384 {
+		return nil, nil, errBadCertificateSigningAlgo
+	}
+
+	intermediates := x509.NewCertPool()
+	for _, der := range doc.CABundle {
+		cert, err := x509.ParseCertificate(der)
+		if err != nil {
+			return nil, nil, err
+		}
+		intermediates.AddCert(cert)
+	}
+	return leafCert, intermediates, nil
+}
+
+func verifyECDSASignature(publicKey *ecdsa.PublicKey, sigStructure, signature []byte) bool {
+	hash, ok := hashForCurve(publicKey, sigStructure)
+	if !ok || len(signature) != 2*len(hash) {
+		return false
+	}
+
+	r := new(big.Int).SetBytes(signature[:len(hash)])
+	s := new(big.Int).SetBytes(signature[len(hash):])
+	return ecdsa.Verify(publicKey, hash, r, s)
+}
+
+func hashForCurve(publicKey *ecdsa.PublicKey, sigStructure []byte) ([]byte, bool) {
+	switch publicKey.Curve.Params().Name {
+	case "P-224":
+		sum := sha256.Sum224(sigStructure)
+		return sum[:], true
+	case "P-256":
+		sum := sha256.Sum256(sigStructure)
+		return sum[:], true
+	case "P-384":
+		sum := sha512.Sum384(sigStructure)
+		return sum[:], true
+	case "P-512":
+		sum := sha512.Sum512(sigStructure)
+		return sum[:], true
+	default:
+		return nil, false
+	}
+}