From 70dddb56440126d1820d3988d45b1c4d47d2b0b2 Mon Sep 17 00:00:00 2001 From: Sirapop Theeranantachai Date: Sun, 25 Oct 2026 17:59:50 -0700 Subject: [PATCH 1/4] fix(ndncert): generate fresh keys for each certificate session Initialize ECDH and IV state for every NEW request rather than once per Client. Cover sequential reuse, failed NEW attempts, and CA signature validation with distinct CA and requester keys. --- std/security/ndncert/client.go | 24 ++-- std/security/ndncert/client_protocol.go | 6 + std/security/ndncert/client_session_test.go | 135 ++++++++++++++++++++ 3 files changed, 156 insertions(+), 9 deletions(-) create mode 100644 std/security/ndncert/client_session_test.go diff --git a/std/security/ndncert/client.go b/std/security/ndncert/client.go index d06aefe3..452e26d7 100644 --- a/std/security/ndncert/client.go +++ b/std/security/ndncert/client.go @@ -15,6 +15,8 @@ import ( sig "github.com/named-data/ndnd/std/security/signer" ) +// Client supports one active certificate request at a time. Sequential requests +// generate fresh ECDH keys and IV state for each NEW step. type Client struct { engine ndn.Engine signer ndn.Signer @@ -46,12 +48,6 @@ func NewClient(engine ndn.Engine, caCert []byte) (*Client, error) { // returned by start due to multiple clients. client := object.NewClient(engine, storage.NewMemoryStore(), nil) - // Generate ECDH Key used for encryption - ecdhKey, err := EcdhKeygen() - if err != nil { - return nil, err - } - // Get CA prefix from CA certificate caPrefix, err := sec.GetIdentityFromCertName(cert.Name()) if err != nil { @@ -64,12 +60,22 @@ func NewClient(engine ndn.Engine, caCert []byte) (*Client, error) { caCert: cert, caPrefix: caPrefix, - client: client, - ecdhKey: ecdhKey, - aeadCtr: NewAeadCounter(), + client: client, }, nil } +// resetSession creates fresh key agreement and IV state for every NEW step, +// including sequential requests made with the same Client instance. +func (c *Client) resetSession() error { + c.ecdhKey, c.aeadCtr = nil, nil + key, err := EcdhKeygen() + if err != nil { + return err + } + c.ecdhKey, c.aeadCtr = key, NewAeadCounter() + return nil +} + // SetSigner sets the signer for the client. func (c *Client) SetSigner(signer ndn.Signer) { c.signer = signer diff --git a/std/security/ndncert/client_protocol.go b/std/security/ndncert/client_protocol.go index 5e61ff82..e79408be 100644 --- a/std/security/ndncert/client_protocol.go +++ b/std/security/ndncert/client_protocol.go @@ -131,6 +131,9 @@ func (c *Client) New(challenge Challenge, expiry time.Time) (*tlv.NewRes, error) } // Send NEW request to CA + if err := c.resetSession(); err != nil { + return nil, fmt.Errorf("failed to initialize certificate session: %w", err) + } newParams := tlv.NewReq{ EcdhPub: c.ecdhKey.Public().(*ecdh.PublicKey).Bytes(), CertReq: csr, @@ -191,6 +194,9 @@ func (c *Client) Challenge( newRes *tlv.NewRes, prevRes *tlv.ChallengeRes, ) (*tlv.ChallengeRes, error) { + if c.ecdhKey == nil || c.aeadCtr == nil { + return nil, fmt.Errorf("NEW must initialize a certificate session before CHALLENGE") + } var prevParams ParamMap = nil var prevStatus optional.Optional[string] diff --git a/std/security/ndncert/client_session_test.go b/std/security/ndncert/client_session_test.go new file mode 100644 index 00000000..a114236c --- /dev/null +++ b/std/security/ndncert/client_session_test.go @@ -0,0 +1,135 @@ +package ndncert + +import ( + "bytes" + "crypto/elliptic" + "strings" + "testing" + "time" + + enc "github.com/named-data/ndnd/std/encoding" + "github.com/named-data/ndnd/std/ndn" + spec "github.com/named-data/ndnd/std/ndn/spec_2022" + sec "github.com/named-data/ndnd/std/security" + "github.com/named-data/ndnd/std/security/ndncert/tlv" + sig "github.com/named-data/ndnd/std/security/signer" +) + +type sessionTestClient struct { + ndn.Client + express func(ndn.ExpressRArgs) +} + +func (c *sessionTestClient) ExpressR(args ndn.ExpressRArgs) { c.express(args) } + +func newSessionTestClient(t *testing.T) (*Client, ndn.Signer) { + t.Helper() + name, err := enc.NameFromStr("/ca") + if err != nil { + t.Fatal(err) + } + caSigner, err := sig.KeygenEcc(sec.MakeKeyName(name), elliptic.P256()) + if err != nil { + t.Fatal(err) + } + certWire, err := sec.SelfSign(sec.SignCertArgs{Signer: caSigner, NotBefore: time.Now().Add(-time.Hour), NotAfter: time.Now().Add(time.Hour)}) + if err != nil { + t.Fatal(err) + } + caCert, _, err := (spec.Spec{}).ReadData(enc.NewWireView(certWire)) + if err != nil { + t.Fatal(err) + } + identity := name.Append(enc.NewGenericComponent("alice")) + requester, err := sig.KeygenEcc(sec.MakeKeyName(identity), elliptic.P256()) + if err != nil { + t.Fatal(err) + } + return &Client{signer: requester, caCert: caCert, caPrefix: name}, caSigner +} + +func replySessionTest(t *testing.T, signer ndn.Signer, args ndn.ExpressRArgs, content enc.Wire) { + t.Helper() + wire, err := (spec.Spec{}).MakeData(args.Name, &ndn.DataConfig{}, content, signer) + if err != nil { + t.Fatal(err) + } + data, covered, err := (spec.Spec{}).ReadData(enc.NewWireView(wire.Wire)) + if err != nil { + t.Fatal(err) + } + args.Callback(ndn.ExpressCallbackArgs{Result: ndn.InterestResultData, Data: data, SigCovered: covered}) +} + +func TestClientNewSession(t *testing.T) { + c, caSigner := newSessionTestClient(t) + var previousPub []byte + var previousCounter *AeadCounter + request := 0 + c.client = &sessionTestClient{express: func(args ndn.ExpressRArgs) { + params, err := tlv.ParseNewReq(enc.NewWireView(args.AppParam), false) + if err != nil { + t.Fatal(err) + } + if !bytes.Equal(params.EcdhPub, c.ecdhKey.PublicKey().Bytes()) { + t.Fatal("NEW does not carry current session public key") + } + if bytes.Equal(params.EcdhPub, previousPub) { + t.Fatal("NEW reused an ephemeral ECDH key") + } + if c.aeadCtr == previousCounter || c.aeadCtr.block != 0 { + t.Fatal("NEW reused IV state") + } + previousPub = bytes.Clone(params.EcdhPub) + previousCounter = c.aeadCtr + request++ + if request == 2 { + // A failed NEW must not cause the next attempt to reuse its key. + args.Callback(ndn.ExpressCallbackArgs{Result: ndn.InterestResultTimeout}) + return + } + serverKey, err := EcdhKeygen() + if err != nil { + t.Fatal(err) + } + response := &tlv.NewRes{EcdhPub: serverKey.PublicKey().Bytes(), Salt: make([]byte, 32), ReqId: make([]byte, 8), Challenge: []string{KwEmail}} + clientSecret, err := EcdhHkdf(c.ecdhKey, response.EcdhPub, response.Salt, response.ReqId) + if err != nil { + t.Fatal(err) + } + serverSecret, err := EcdhHkdf(serverKey, params.EcdhPub, response.Salt, response.ReqId) + if err != nil || !bytes.Equal(clientSecret, serverSecret) { + t.Fatalf("session key agreement failed: %v", err) + } + replySessionTest(t, caSigner, args, response.Encode()) + }} + for i := 1; i <= 3; i++ { + _, err := c.New(&ChallengeEmail{}, time.Now().Add(time.Hour)) + if (err != nil) != (i == 2) { + t.Fatalf("request %d: unexpected error %v", i, err) + } + // Exercise reset of both sending and receiving state on reuse. + c.aeadCtr.block = 100 + } +} + +func TestClientNewRejectsRequesterSignedResponse(t *testing.T) { + c, _ := newSessionTestClient(t) + serverKey, err := EcdhKeygen() + if err != nil { + t.Fatal(err) + } + response := &tlv.NewRes{EcdhPub: serverKey.PublicKey().Bytes(), Salt: make([]byte, 32), ReqId: make([]byte, 8), Challenge: []string{KwEmail}} + c.client = &sessionTestClient{express: func(args ndn.ExpressRArgs) { + replySessionTest(t, c.signer, args, response.Encode()) + }} + if _, err := c.New(&ChallengeEmail{}, time.Now().Add(time.Hour)); err == nil || !strings.Contains(err.Error(), "validation failure") { + t.Fatalf("expected CA signature validation failure, got %v", err) + } +} + +func TestClientChallengeRequiresSession(t *testing.T) { + if _, err := new(Client).Challenge(&ChallengeEmail{}, nil, nil); err == nil { + t.Fatal("CHALLENGE accepted without NEW") + } +} From a1b19d52267651c3e99d4152119e3a93962c3f48 Mon Sep 17 00:00:00 2001 From: Sirapop Theeranantachai Date: Sun, 25 Oct 2026 18:00:15 -0700 Subject: [PATCH 2/4] fix(ndncert): encode and advance IV counters per v0.3 Start IV counters at zero, encode them in big-endian order, and advance after encryption using integer block counts. Reject empty plaintext, oversized GCM messages, and exhausted counters without wrapping. Add reference-encryption, block arithmetic, and send-exhaustion regression tests. --- std/security/ndncert/client_session_test.go | 4 +- std/security/ndncert/crypto_aes.go | 57 +++++++--- std/security/ndncert/crypto_aes_test.go | 110 ++++++++++++++++++++ 3 files changed, 157 insertions(+), 14 deletions(-) create mode 100644 std/security/ndncert/crypto_aes_test.go diff --git a/std/security/ndncert/client_session_test.go b/std/security/ndncert/client_session_test.go index a114236c..ac51efe2 100644 --- a/std/security/ndncert/client_session_test.go +++ b/std/security/ndncert/client_session_test.go @@ -77,7 +77,7 @@ func TestClientNewSession(t *testing.T) { if bytes.Equal(params.EcdhPub, previousPub) { t.Fatal("NEW reused an ephemeral ECDH key") } - if c.aeadCtr == previousCounter || c.aeadCtr.block != 0 { + if c.aeadCtr == previousCounter || c.aeadCtr.nextSendBlock != 0 { t.Fatal("NEW reused IV state") } previousPub = bytes.Clone(params.EcdhPub) @@ -109,7 +109,7 @@ func TestClientNewSession(t *testing.T) { t.Fatalf("request %d: unexpected error %v", i, err) } // Exercise reset of both sending and receiving state on reuse. - c.aeadCtr.block = 100 + c.aeadCtr.nextSendBlock = 100 } } diff --git a/std/security/ndncert/crypto_aes.go b/std/security/ndncert/crypto_aes.go index 96efe39b..33e2271b 100644 --- a/std/security/ndncert/crypto_aes.go +++ b/std/security/ndncert/crypto_aes.go @@ -5,8 +5,8 @@ import ( "crypto/cipher" "crypto/rand" "encoding/binary" + "fmt" "io" - "math" "github.com/named-data/ndnd/std/security/ndncert/tlv" ) @@ -37,9 +37,32 @@ func (m *AeadMessage) FromTLV(t *tlv.CipherMsg) { m.CipherText = t.Payload } +// AeadCounter holds the send IV state of one NDNCERT session. It must not be +// reused with a new session key or shared between concurrent operations. type AeadCounter struct { - block uint32 - random [AeadSizeRand]byte + // uint64 represents the exhausted state (2^32) without wrapping to zero. + nextSendBlock uint64 + sendPrefix [AeadSizeRand]byte +} + +const aeadCounterLimit = uint64(1) << 32 + +// Empty CHALLENGE plaintext is invalid and would otherwise reuse an IV because +// it consumes zero blocks. Integer division avoids floating-point rounding and +// adding 15 to a potentially large int. +func aeadBlocks(length int) (uint64, error) { + if length <= 0 { + return 0, fmt.Errorf("AEAD plaintext must not be empty") + } + blocks := uint64(length / aes.BlockSize) + if length%aes.BlockSize != 0 { + blocks++ + } + // GCM itself limits a message to 2^32-2 blocks. + if blocks > aeadCounterLimit-2 { + return 0, fmt.Errorf("AEAD message exceeds GCM block limit") + } + return blocks, nil } // (AI GENERATED DESCRIPTION): Creates a new AeadCounter initialized with a zero block counter and a freshly generated random byte sequence. @@ -49,8 +72,7 @@ func NewAeadCounter() *AeadCounter { panic(randReadErr.Error()) } return &AeadCounter{ - block: 0, - random: [AeadSizeRand]byte(randomBytes), + sendPrefix: [AeadSizeRand]byte(randomBytes), } } @@ -61,6 +83,16 @@ func AeadEncrypt( info []byte, counter *AeadCounter, ) (*AeadMessage, error) { + if counter == nil { + return nil, fmt.Errorf("AEAD session counter is required") + } + blocks, err := aeadBlocks(len(plaintext)) + if err != nil { + return nil, err + } + if counter.nextSendBlock >= aeadCounterLimit || blocks > aeadCounterLimit-counter.nextSendBlock { + return nil, fmt.Errorf("AEAD send counter exhausted") + } block, err := aes.NewCipher(key[:]) if err != nil { return nil, err @@ -71,17 +103,18 @@ func AeadEncrypt( return nil, err } - // Make initialization vector - counter.block += uint32(math.Ceil(float64(float32(len(plaintext)) / float32(AeadSizeTag)))) - cblock := make([]byte, 4) - binary.LittleEndian.PutUint32(cblock, counter.block) - iv := append(counter.random[:], cblock...) + // NDNCERT v0.3: use the current counter, in network byte order, then + // advance by the number of plaintext AES blocks after encryption. + var iv [AeadSizeNonce]byte + copy(iv[:], counter.sendPrefix[:]) + binary.BigEndian.PutUint32(iv[AeadSizeRand:], uint32(counter.nextSendBlock)) // Encrypt and seal - output := aesgcm.Seal(nil, iv, plaintext, info) + output := aesgcm.Seal(nil, iv[:], plaintext, info) + counter.nextSendBlock += blocks return &AeadMessage{ - IV: [AeadSizeNonce]byte(iv), + IV: iv, AuthTag: ([AeadSizeTag]byte)(output[len(plaintext):]), CipherText: output[:len(plaintext)], }, nil diff --git a/std/security/ndncert/crypto_aes_test.go b/std/security/ndncert/crypto_aes_test.go new file mode 100644 index 00000000..4e607342 --- /dev/null +++ b/std/security/ndncert/crypto_aes_test.go @@ -0,0 +1,110 @@ +package ndncert + +import ( + "bytes" + "crypto/aes" + "crypto/cipher" + "encoding/binary" + "testing" +) + +var testAeadKey = [16]byte{1, 2, 3} +var testAeadInfo = []byte("request-id") +var testLocalPrefix = [8]byte{1} +var testPeerPrefix = [8]byte{2} + +// Construct peer packets independently of AeadEncrypt, so a matching encoder +// and decoder bug cannot make the receive-side tests pass. +func referenceAeadMessage(t *testing.T, prefix [8]byte, counter uint32, size int) AeadMessage { + t.Helper() + block, err := aes.NewCipher(testAeadKey[:]) + if err != nil { + t.Fatal(err) + } + gcm, err := cipher.NewGCM(block) + if err != nil { + t.Fatal(err) + } + m := AeadMessage{} + copy(m.IV[:], prefix[:]) + binary.BigEndian.PutUint32(m.IV[8:], counter) + sealed := gcm.Seal(nil, m.IV[:], bytes.Repeat([]byte{42}, size), testAeadInfo) + m.CipherText = sealed[:size] + copy(m.AuthTag[:], sealed[size:]) + return m +} + +func TestAeadSendCounter(t *testing.T) { + counter := &AeadCounter{sendPrefix: testLocalPrefix} + var next uint64 + for _, size := range []int{1, 15, 16, 17, 32, 33} { + m, err := AeadEncrypt(testAeadKey, bytes.Repeat([]byte{42}, size), testAeadInfo, counter) + if err != nil { + t.Fatal(err) + } + want := referenceAeadMessage(t, testLocalPrefix, uint32(next), size) + if m.IV != want.IV || m.AuthTag != want.AuthTag || !bytes.Equal(m.CipherText, want.CipherText) { + t.Fatalf("size %d: encryption differs from reference at counter %d", size, next) + } + next += uint64((size + 15) / 16) + if counter.nextSendBlock != next { + t.Fatalf("size %d: next counter = %d, want %d", size, counter.nextSendBlock, next) + } + } + counter.nextSendBlock = 0x01020304 + m, err := AeadEncrypt(testAeadKey, []byte{42}, testAeadInfo, counter) + if err != nil { + t.Fatal(err) + } + if !bytes.Equal(m.IV[8:], []byte{1, 2, 3, 4}) { + t.Fatalf("counter is not big-endian: %x", m.IV) + } +} + +func TestAeadBlockArithmetic(t *testing.T) { + for _, size := range []int{1, 15, 16, 17, (1 << 24) + 1, int(^uint(0) >> 1)} { + want := uint64(size / 16) + if size%16 != 0 { + want++ + } + got, err := aeadBlocks(size) + if want > aeadCounterLimit-2 { + if err == nil { + t.Fatalf("size %d: accepted excessive GCM length", size) + } + } else if err != nil || got != want { + t.Fatalf("size %d: got %d, %v; want %d", size, got, err, want) + } + } + for _, size := range []int{0, -1} { + if _, err := aeadBlocks(size); err == nil { + t.Fatalf("accepted length %d", size) + } + } +} + +func TestAeadSendExhaustion(t *testing.T) { + c := &AeadCounter{sendPrefix: testLocalPrefix, nextSendBlock: aeadCounterLimit - 1} + if _, err := AeadEncrypt(testAeadKey, make([]byte, 17), testAeadInfo, c); err == nil { + t.Fatal("accepted wrapping counter") + } + if c.nextSendBlock != aeadCounterLimit-1 { + t.Fatal("failed send consumed counter") + } + m, err := AeadEncrypt(testAeadKey, []byte{1}, testAeadInfo, c) + if err != nil { + t.Fatal(err) + } + if binary.BigEndian.Uint32(m.IV[8:]) != ^uint32(0) || c.nextSendBlock != aeadCounterLimit { + t.Fatal("last counter was not used safely") + } + if _, err := AeadEncrypt(testAeadKey, []byte{1}, testAeadInfo, c); err == nil { + t.Fatal("accepted exhausted counter") + } + if _, err := AeadEncrypt(testAeadKey, nil, testAeadInfo, c); err == nil { + t.Fatal("accepted empty plaintext") + } + if _, err := AeadEncrypt(testAeadKey, []byte{1}, testAeadInfo, nil); err == nil { + t.Fatal("accepted missing session") + } +} From 9ba11b5f6493bdf3aa8306c59cb84782edb313e0 Mon Sep 17 00:00:00 2001 From: Sirapop Theeranantachai Date: Sun, 25 Oct 2026 18:00:25 -0700 Subject: [PATCH 3/4] fix(ndncert): validate authenticated peer IV state Reject malformed cipher messages, changing or colliding IV prefixes, replayed or overlapping block ranges, and receive-counter wraparound. Update peer state only after authentication and validation, and decrypt into a private buffer without modifying the packet. Cover authenticated receive-state transitions and a two-round client CHALLENGE exchange against an independent AES-GCM peer, including replay rejection. --- std/security/ndncert/client_protocol.go | 6 +- std/security/ndncert/client_session_test.go | 152 +++++++++++++++++++- std/security/ndncert/crypto_aes.go | 55 ++++++- std/security/ndncert/crypto_aes_test.go | 145 +++++++++++++++++++ 4 files changed, 349 insertions(+), 9 deletions(-) diff --git a/std/security/ndncert/client_protocol.go b/std/security/ndncert/client_protocol.go index e79408be..87c65e24 100644 --- a/std/security/ndncert/client_protocol.go +++ b/std/security/ndncert/client_protocol.go @@ -279,8 +279,10 @@ func (c *Client) Challenge( } chResAeadMsg := AeadMessage{} - chResAeadMsg.FromTLV(chResEnc) - chResBytes, err := AeadDecrypt([16]byte(symkey), chResAeadMsg, newRes.ReqId) + if err := chResAeadMsg.FromTLV(chResEnc); err != nil { + return nil, fmt.Errorf("invalid CHALLENGE cipher response: %w", err) + } + chResBytes, err := AeadDecrypt([16]byte(symkey), chResAeadMsg, newRes.ReqId, c.aeadCtr) if err != nil { return nil, fmt.Errorf("failed to decrypt CHALLENGE response: %w", err) } diff --git a/std/security/ndncert/client_session_test.go b/std/security/ndncert/client_session_test.go index ac51efe2..8b550c63 100644 --- a/std/security/ndncert/client_session_test.go +++ b/std/security/ndncert/client_session_test.go @@ -2,7 +2,10 @@ package ndncert import ( "bytes" + "crypto/aes" + "crypto/cipher" "crypto/elliptic" + "encoding/binary" "strings" "testing" "time" @@ -13,6 +16,7 @@ import ( sec "github.com/named-data/ndnd/std/security" "github.com/named-data/ndnd/std/security/ndncert/tlv" sig "github.com/named-data/ndnd/std/security/signer" + "github.com/named-data/ndnd/std/types/optional" ) type sessionTestClient struct { @@ -77,7 +81,7 @@ func TestClientNewSession(t *testing.T) { if bytes.Equal(params.EcdhPub, previousPub) { t.Fatal("NEW reused an ephemeral ECDH key") } - if c.aeadCtr == previousCounter || c.aeadCtr.nextSendBlock != 0 { + if c.aeadCtr == previousCounter || c.aeadCtr.nextSendBlock != 0 || c.aeadCtr.nextPeerBlock != 0 { t.Fatal("NEW reused IV state") } previousPub = bytes.Clone(params.EcdhPub) @@ -110,6 +114,152 @@ func TestClientNewSession(t *testing.T) { } // Exercise reset of both sending and receiving state on reuse. c.aeadCtr.nextSendBlock = 100 + c.aeadCtr.nextPeerBlock = 200 + } +} + +// Exercise the client protocol against a peer using the standard-library GCM +// API directly, so the client and test peer cannot share an IV-encoding bug. +func TestClientChallengeExchange(t *testing.T) { + for _, test := range []struct { + name string + replay bool + }{ + {"two-round success", false}, + {"replayed response", true}, + } { + t.Run(test.name, func(t *testing.T) { + c, caSigner := newSessionTestClient(t) + serverKey, err := EcdhKeygen() + if err != nil { + t.Fatal(err) + } + newResponse := &tlv.NewRes{ + EcdhPub: serverKey.PublicKey().Bytes(), Salt: bytes.Repeat([]byte{9}, 32), + ReqId: []byte("request1"), Challenge: []string{KwEmail}, + } + var gcm cipher.AEAD + issuedName := c.signer.KeyName().Append(enc.NewGenericComponent("ca"), enc.NewVersionComponent(1)) + peer := &sessionTestClient{} + c.client = peer + + // Complete NEW and derive the peer's session key before CHALLENGE. + peer.express = func(args ndn.ExpressRArgs) { + req, err := tlv.ParseNewReq(enc.NewWireView(args.AppParam), false) + if err != nil { + t.Fatal(err) + } + key, err := EcdhHkdf(serverKey, req.EcdhPub, newResponse.Salt, newResponse.ReqId) + if err != nil { + t.Fatal(err) + } + block, err := aes.NewCipher(key) + if err != nil { + t.Fatal(err) + } + gcm, err = cipher.NewGCM(block) + if err != nil { + t.Fatal(err) + } + replySessionTest(t, caSigner, args, newResponse.Encode()) + } + codesRequested := 0 + challenge := &ChallengeEmail{Email: "a@example.org", CodeCallback: func(status string) string { + if status != "need-code" { + t.Fatalf("unexpected challenge status: %s", status) + } + codesRequested++ + return "123456" + }} + result, err := c.New(challenge, time.Now().Add(time.Hour)) + if err != nil { + t.Fatal(err) + } + + // Verify each CHALLENGE request and return an encrypted response. + var nextSend, nextReceive uint32 + var clientPrefix []byte + var firstResponse enc.Wire + rounds := 0 + peer.express = func(args ndn.ExpressRArgs) { + if rounds >= 2 { + t.Fatal("client continued after success or replay") + } + msg, err := tlv.ParseCipherMsg(enc.NewWireView(args.AppParam), false) + if err != nil { + t.Fatal(err) + } + if len(msg.InitVec) != 12 || binary.BigEndian.Uint32(msg.InitVec[8:]) != nextReceive { + t.Fatal("wrong client IV or block counter") + } + if clientPrefix == nil { + clientPrefix = bytes.Clone(msg.InitVec[:8]) + } else if !bytes.Equal(clientPrefix, msg.InitVec[:8]) { + t.Fatal("client prefix changed") + } + plain, err := gcm.Open(nil, msg.InitVec, append(bytes.Clone(msg.Payload), msg.AuthNTag...), newResponse.ReqId) + if err != nil { + t.Fatal(err) + } + req, err := tlv.ParseChallengeReq(enc.NewBufferView(plain), false) + if err != nil { + t.Fatal(err) + } + if req.Challenge != KwEmail { + t.Fatal("wrong challenge") + } + param, value := KwEmail, "a@example.org" + if rounds == 1 { + param, value = KwCode, "123456" + } + if string(req.Params[param]) != value { + t.Fatalf("wrong %s parameter", param) + } + nextReceive += uint32((len(plain) + 15) / 16) + response := &tlv.ChallengeRes{Status: uint64(ChallengeStatusChallenge), ChalStatus: optional.Some("need-code")} + if rounds == 1 { + response = &tlv.ChallengeRes{ + Status: uint64(ChallengeStatusSuccess), + CertName: &spec.NameContainer{Name: issuedName}, + } + } + // Use a stable prefix guaranteed to differ from the client's. + iv := make([]byte, 12) + copy(iv[:8], clientPrefix) + iv[0] ^= 1 + binary.BigEndian.PutUint32(iv[8:], nextSend) + plain = response.Encode().Join() + sealed := gcm.Seal(nil, iv, plain, newResponse.ReqId) + nextSend += uint32((len(plain) + 15) / 16) + content := (&tlv.CipherMsg{InitVec: iv, Payload: sealed[:len(plain)], AuthNTag: sealed[len(plain):]}).Encode() + if rounds == 0 { + firstResponse = content + } else if test.replay { + content = firstResponse + } + rounds++ + replySessionTest(t, caSigner, args, content) + } + response, err := c.Challenge(challenge, result, nil) + if test.replay { + if err == nil || !strings.Contains(err.Error(), "counter was replayed") { + t.Fatalf("expected replay rejection, got %v", err) + } + } else { + if err != nil { + t.Fatalf("challenge failed: %v", err) + } + if response.Status != uint64(ChallengeStatusSuccess) { + t.Fatalf("unexpected status: %d", response.Status) + } + if response.CertName == nil || !response.CertName.Name.Equal(issuedName) { + t.Fatal("wrong issued certificate name") + } + } + if rounds != 2 || codesRequested != 1 { + t.Fatalf("got %d CHALLENGE rounds and %d code requests", rounds, codesRequested) + } + }) } } diff --git a/std/security/ndncert/crypto_aes.go b/std/security/ndncert/crypto_aes.go index 33e2271b..66c97804 100644 --- a/std/security/ndncert/crypto_aes.go +++ b/std/security/ndncert/crypto_aes.go @@ -1,6 +1,7 @@ package ndncert import ( + "bytes" "crypto/aes" "crypto/cipher" "crypto/rand" @@ -30,19 +31,28 @@ func (m *AeadMessage) TLV() *tlv.CipherMsg { } } -// (AI GENERATED DESCRIPTION): Populates an AeadMessage's IV, AuthTag, and CipherText fields from a provided tlv.CipherMsg. -func (m *AeadMessage) FromTLV(t *tlv.CipherMsg) { +// FromTLV decodes an AEAD message, rejecting invalid IV and tag lengths. +func (m *AeadMessage) FromTLV(t *tlv.CipherMsg) error { + if t == nil || len(t.InitVec) != AeadSizeNonce || len(t.AuthNTag) != AeadSizeTag { + return fmt.Errorf("invalid AEAD message: expected a %d-byte IV and %d-byte authentication tag", AeadSizeNonce, AeadSizeTag) + } m.IV = [AeadSizeNonce]byte(t.InitVec) m.AuthTag = [AeadSizeTag]byte(t.AuthNTag) m.CipherText = t.Payload + return nil } -// AeadCounter holds the send IV state of one NDNCERT session. It must not be +// AeadCounter holds both directions of one NDNCERT session. It must not be // reused with a new session key or shared between concurrent operations. type AeadCounter struct { // uint64 represents the exhausted state (2^32) without wrapping to zero. nextSendBlock uint64 sendPrefix [AeadSizeRand]byte + peerPrefix [AeadSizeRand]byte + + // Zero means no peer message has been accepted; messages consume at least + // one block, so every accepted message makes this positive. + nextPeerBlock uint64 } const aeadCounterLimit = uint64(1) << 32 @@ -120,12 +130,22 @@ func AeadEncrypt( }, nil } -// (AI GENERATED DESCRIPTION): Decrypts an AEAD‑protected message using AES‑GCM with the given key and additional authenticated data. +// AeadDecrypt authenticates a peer message and checks its IV against the session. +// Use the same counter for every encryption and decryption in one session; +// receive state advances only when authentication and IV validation succeed. func AeadDecrypt( key [AeadSizeTag]byte, message AeadMessage, info []byte, + counter *AeadCounter, ) ([]byte, error) { + if counter == nil { + return nil, fmt.Errorf("AEAD session counter is required") + } + blocks, err := aeadBlocks(len(message.CipherText)) + if err != nil { + return nil, err + } block, err := aes.NewCipher(key[:]) if err != nil { return nil, err @@ -137,12 +157,35 @@ func AeadDecrypt( return nil, err } - ciphertext := append(message.CipherText, message.AuthTag[:]...) + // Do not overwrite the caller's packet buffer while assembling GCM input. + ciphertext := make([]byte, len(message.CipherText)+AeadSizeTag) + copy(ciphertext, message.CipherText) + copy(ciphertext[len(message.CipherText):], message.AuthTag[:]) - plaintext, err := aesgcm.Open(nil, nonce, ciphertext, info[:]) + plaintext, err := aesgcm.Open(ciphertext[:0], nonce, ciphertext, info) if err != nil { return nil, err } + // Authenticate before changing receive state: forged packets cannot reserve + // counters or change the expected random prefix. Counter ranges may have + // gaps, but must never overlap or wrap. Each direction has its own prefix. + start := uint64(binary.BigEndian.Uint32(message.IV[AeadSizeRand:])) + if bytes.Equal(message.IV[:AeadSizeRand], counter.sendPrefix[:]) { + return nil, fmt.Errorf("AEAD peer reused the local IV random prefix") + } + if blocks > aeadCounterLimit-start { + return nil, fmt.Errorf("AEAD receive counter would wrap") + } + if counter.nextPeerBlock > 0 { + if !bytes.Equal(message.IV[:AeadSizeRand], counter.peerPrefix[:]) { + return nil, fmt.Errorf("AEAD peer IV prefix changed") + } + if start < counter.nextPeerBlock { + return nil, fmt.Errorf("AEAD counter was replayed or overlaps previously received blocks") + } + } + copy(counter.peerPrefix[:], message.IV[:AeadSizeRand]) + counter.nextPeerBlock = start + blocks return plaintext, nil } diff --git a/std/security/ndncert/crypto_aes_test.go b/std/security/ndncert/crypto_aes_test.go index 4e607342..68b9509b 100644 --- a/std/security/ndncert/crypto_aes_test.go +++ b/std/security/ndncert/crypto_aes_test.go @@ -5,7 +5,11 @@ import ( "crypto/aes" "crypto/cipher" "encoding/binary" + "fmt" + "strings" "testing" + + "github.com/named-data/ndnd/std/security/ndncert/tlv" ) var testAeadKey = [16]byte{1, 2, 3} @@ -108,3 +112,144 @@ func TestAeadSendExhaustion(t *testing.T) { t.Fatal("accepted missing session") } } + +func TestAeadReceiveValidation(t *testing.T) { + for _, test := range []struct { + name string + prefix [8]byte + counter uint32 + size int + wantErr string + }{ + {"replay", testPeerPrefix, 0, 17, "counter was replayed"}, + {"overlapping blocks", testPeerPrefix, 1, 1, "counter was replayed"}, + {"changed prefix", [8]byte{3}, 2, 1, "peer IV prefix changed"}, + {"local prefix", testLocalPrefix, 2, 1, "peer reused the local IV random prefix"}, + {"wrap", testPeerPrefix, ^uint32(0), 17, "receive counter would wrap"}, + } { + t.Run(test.name, func(t *testing.T) { + c := &AeadCounter{sendPrefix: testLocalPrefix} + if _, err := AeadDecrypt(testAeadKey, referenceAeadMessage(t, testPeerPrefix, 0, 17), testAeadInfo, c); err != nil { + t.Fatal(err) + } + before := *c + if _, err := AeadDecrypt(testAeadKey, referenceAeadMessage(t, test.prefix, test.counter, test.size), testAeadInfo, c); err == nil || !strings.Contains(err.Error(), test.wantErr) { + t.Fatalf("expected %q, got %v", test.wantErr, err) + } + if *c != before { + t.Fatal("invalid packet changed receive state") + } + // A rejected packet must not prevent the legitimate next packet. + if _, err := AeadDecrypt(testAeadKey, referenceAeadMessage(t, testPeerPrefix, 2, 1), testAeadInfo, c); err != nil { + t.Fatal(err) + } + }) + } +} + +func TestAeadReceiveAuthentication(t *testing.T) { + for _, initialized := range []bool{false, true} { + t.Run(fmt.Sprint(initialized), func(t *testing.T) { + c := &AeadCounter{sendPrefix: testLocalPrefix} + if initialized { + if _, err := AeadDecrypt(testAeadKey, referenceAeadMessage(t, testPeerPrefix, 0, 1), testAeadInfo, c); err != nil { + t.Fatal(err) + } + } + before := *c + m := referenceAeadMessage(t, [8]byte{3}, 100, 1) + m.AuthTag[0] ^= 1 + if _, err := AeadDecrypt(testAeadKey, m, testAeadInfo, c); err == nil { + t.Fatal("accepted forged tag") + } + if *c != before { + t.Fatal("unauthenticated packet changed receive state") + } + m = referenceAeadMessage(t, testPeerPrefix, 1, 1) + if _, err := AeadDecrypt(testAeadKey, m, []byte("wrong request"), c); err == nil { + t.Fatal("accepted wrong request ID") + } + if *c != before { + t.Fatal("wrong AAD changed receive state") + } + if _, err := AeadDecrypt(testAeadKey, m, testAeadInfo, c); err != nil { + t.Fatal(err) + } + }) + } +} + +func TestAeadReceiveExhaustion(t *testing.T) { + c := &AeadCounter{sendPrefix: testLocalPrefix} + // Gaps are permitted, including when earlier messages were lost. + m := referenceAeadMessage(t, testPeerPrefix, ^uint32(0), 16) + if _, err := AeadDecrypt(testAeadKey, m, testAeadInfo, c); err != nil { + t.Fatal(err) + } + if c.nextPeerBlock != aeadCounterLimit { + t.Fatal("receive counter wrapped") + } + if _, err := AeadDecrypt(testAeadKey, referenceAeadMessage(t, testPeerPrefix, 0, 1), testAeadInfo, c); err == nil { + t.Fatal("accepted wrapped counter") + } + if _, err := AeadDecrypt(testAeadKey, m, testAeadInfo, nil); err == nil { + t.Fatal("accepted missing session") + } + c = &AeadCounter{sendPrefix: testPeerPrefix} + if _, err := AeadDecrypt(testAeadKey, m, testAeadInfo, c); err == nil { + t.Fatal("accepted local prefix on first message") + } +} + +func TestAeadDoesNotModifyPacket(t *testing.T) { + m := referenceAeadMessage(t, testPeerPrefix, 0, 1) + packet := bytes.Repeat([]byte{0xaa}, 64) + copy(packet, m.CipherText) + m.CipherText = packet[:1] + before := bytes.Clone(packet) + if _, err := AeadDecrypt(testAeadKey, m, testAeadInfo, &AeadCounter{sendPrefix: testLocalPrefix}); err != nil { + t.Fatal(err) + } + if !bytes.Equal(packet, before) { + t.Fatal("decryption overwrote packet backing array") + } +} + +func TestAeadDuplex(t *testing.T) { + a := &AeadCounter{sendPrefix: testLocalPrefix} + b := &AeadCounter{sendPrefix: testPeerPrefix} + for i := 0; i < 3; i++ { + for _, pair := range [][2]*AeadCounter{{a, b}, {b, a}} { + m, err := AeadEncrypt(testAeadKey, []byte("challenge"), testAeadInfo, pair[0]) + if err != nil { + t.Fatal(err) + } + got, err := AeadDecrypt(testAeadKey, *m, testAeadInfo, pair[1]) + if err != nil || string(got) != "challenge" { + t.Fatalf("got %q, %v", got, err) + } + } + } +} + +func TestAeadFromTLV(t *testing.T) { + for _, input := range []*tlv.CipherMsg{ + nil, + {InitVec: make([]byte, 11), AuthNTag: make([]byte, 16)}, + {InitVec: make([]byte, 13), AuthNTag: make([]byte, 16)}, + {InitVec: make([]byte, 12), AuthNTag: make([]byte, 15)}, + {InitVec: make([]byte, 12), AuthNTag: make([]byte, 17)}, + } { + if err := new(AeadMessage).FromTLV(input); err == nil { + t.Fatal("accepted malformed AEAD TLV") + } + } + want := referenceAeadMessage(t, testPeerPrefix, 0, 1) + var got AeadMessage + if err := got.FromTLV(want.TLV()); err != nil { + t.Fatal(err) + } + if got.IV != want.IV || got.AuthTag != want.AuthTag || !bytes.Equal(got.CipherText, want.CipherText) { + t.Fatal("TLV round-trip changed message") + } +} From ed5e904713ebeac306e9a699651befb27118a859 Mon Sep 17 00:00:00 2001 From: Sirapop Theeranantachai Date: Fri, 30 Oct 2026 19:50:23 -0700 Subject: [PATCH 4/4] refactor(ndncert): isolate certificate request session state Move ECDH, AES, IV, signer, and CA state from Client into a per-request Session. Derive the symmetric key once after NEW, enforce explicit session transitions, and process CHALLENGE rounds iteratively. Add session lifecycle and isolation tests, and mark AI-generated descriptions consistently. --- std/security/ndncert/client.go | 69 +++++++--- std/security/ndncert/client_protocol.go | 135 ++++++++++++-------- std/security/ndncert/client_session_test.go | 119 +++++++++++++---- std/security/ndncert/crypto_aes.go | 20 +-- std/security/ndncert/crypto_aes_test.go | 22 ++-- 5 files changed, 249 insertions(+), 116 deletions(-) diff --git a/std/security/ndncert/client.go b/std/security/ndncert/client.go index 452e26d7..4176293b 100644 --- a/std/security/ndncert/client.go +++ b/std/security/ndncert/client.go @@ -15,8 +15,8 @@ import ( sig "github.com/named-data/ndnd/std/security/signer" ) -// Client supports one active certificate request at a time. Sequential requests -// generate fresh ECDH keys and IV state for each NEW step. +// (AI GENERATED DESCRIPTION): Client holds the long-lived configuration used for certificate requests. +// Each certificate request uses a separate Session. type Client struct { engine ndn.Engine signer ndn.Signer @@ -24,9 +24,31 @@ type Client struct { caCert ndn.Data caPrefix enc.Name - client ndn.Client - ecdhKey *ecdh.PrivateKey - aeadCtr *AeadCounter + client ndn.Client +} + +type sessionState uint8 + +const ( + sessionStateReady sessionState = iota + sessionStateNewAttempted + sessionStateChallenge +) + +// (AI GENERATED DESCRIPTION): Session holds the cryptographic and protocol state of one certificate request. +// A Session must not be reused for another NEW request or used concurrently. +type Session struct { + network ndn.Client + signer ndn.Signer + caCert ndn.Data + caPrefix enc.Name + + ecdhKey *ecdh.PrivateKey + aesKey [AeadSizeTag]byte + requestID []byte + aeadCtr *AeadCounter + challenge Challenge + state sessionState } // NewClient creates a new NDNCERT client. @@ -64,16 +86,29 @@ func NewClient(engine ndn.Engine, caCert []byte) (*Client, error) { }, nil } -// resetSession creates fresh key agreement and IV state for every NEW step, -// including sequential requests made with the same Client instance. -func (c *Client) resetSession() error { - c.ecdhKey, c.aeadCtr = nil, nil +// (AI GENERATED DESCRIPTION): NewSession creates the independent state for one certificate request. +func (c *Client) NewSession() (*Session, error) { + if c == nil { + return nil, fmt.Errorf("client is required") + } + if c.signer == nil { + return nil, fmt.Errorf("signer not set") + } + if c.client == nil { + return nil, fmt.Errorf("network client not set") + } key, err := EcdhKeygen() if err != nil { - return err + return nil, fmt.Errorf("failed to generate session ECDH key: %w", err) } - c.ecdhKey, c.aeadCtr = key, NewAeadCounter() - return nil + return &Session{ + network: c.client, + signer: c.signer, + caCert: c.caCert, + caPrefix: c.caPrefix.Clone(), + ecdhKey: key, + aeadCtr: NewAeadCounter(), + }, nil } // SetSigner sets the signer for the client. @@ -258,15 +293,19 @@ func (c *Client) RequestCert(args RequestCertArgs) (*RequestCertResult, error) { } // ====== Step 3: NEW ============== + session, err := c.NewSession() + if err != nil { + return nil, err + } // Use the longest possible validity period expiry := time.Now().Add(time.Second * time.Duration(profile.MaxValidPeriod-300)) - newRes, err := c.New(args.Challenge, expiry) + _, err = session.New(args.Challenge, expiry) if err != nil { return nil, err } // ====== Step 4: CHALLENGE ============== - chRes, err := c.Challenge(args.Challenge, newRes, nil) + chRes, err := session.Challenge() if err != nil { return nil, err } @@ -283,6 +322,6 @@ func (c *Client) RequestCert(args RequestCertArgs) (*RequestCertResult, error) { return &RequestCertResult{ CertData: certData, CertWire: certWire, - Signer: c.signer, + Signer: session.signer, }, nil } diff --git a/std/security/ndncert/client_protocol.go b/std/security/ndncert/client_protocol.go index 87c65e24..674a6514 100644 --- a/std/security/ndncert/client_protocol.go +++ b/std/security/ndncert/client_protocol.go @@ -113,16 +113,26 @@ func (c *Client) FetchProbeRedirect(params ParamMap) (probe *tlv.ProbeRes, err e return nil, fmt.Errorf("too many redirects") } -// New sends a NEW request to the CA (blocking). -func (c *Client) New(challenge Challenge, expiry time.Time) (*tlv.NewRes, error) { - // Signer must be set before this step - if c.signer == nil { - return nil, fmt.Errorf("signer not set") +// (AI GENERATED DESCRIPTION): New sends the NEW request for this certificate session (blocking). +func (s *Session) New(challenge Challenge, expiry time.Time) (*tlv.NewRes, error) { + if s == nil { + return nil, fmt.Errorf("invalid certificate session") } + if s.state != sessionStateReady { + return nil, fmt.Errorf("certificate session has already attempted NEW") + } + if s.network == nil || s.ecdhKey == nil || s.aeadCtr == nil { + return nil, fmt.Errorf("invalid certificate session") + } + if challenge == nil { + return nil, fmt.Errorf("challenge is required") + } + s.state = sessionStateNewAttempted + defer func() { s.ecdhKey = nil }() // Generate self-signed cert as CSR csr, err := sec.SelfSign(sec.SignCertArgs{ - Signer: c.signer, + Signer: s.signer, NotBefore: time.Now(), NotAfter: expiry, }) @@ -131,17 +141,14 @@ func (c *Client) New(challenge Challenge, expiry time.Time) (*tlv.NewRes, error) } // Send NEW request to CA - if err := c.resetSession(); err != nil { - return nil, fmt.Errorf("failed to initialize certificate session: %w", err) - } newParams := tlv.NewReq{ - EcdhPub: c.ecdhKey.Public().(*ecdh.PublicKey).Bytes(), + EcdhPub: s.ecdhKey.Public().(*ecdh.PublicKey).Bytes(), CertReq: csr, } ch := make(chan ndn.ExpressCallbackArgs, 1) - c.client.ExpressR(ndn.ExpressRArgs{ - Name: c.caPrefix.Append( + s.network.ExpressR(ndn.ExpressRArgs{ + Name: s.caPrefix.Append( enc.NewGenericComponent("CA"), enc.NewGenericComponent("NEW"), ), @@ -150,7 +157,7 @@ func (c *Client) New(challenge Challenge, expiry time.Time) (*tlv.NewRes, error) MustBeFresh: true, }, AppParam: newParams.Encode(), - Signer: c.signer, + Signer: s.signer, Retries: 3, Callback: func(args ndn.ExpressCallbackArgs) { ch <- args }, }) @@ -159,7 +166,7 @@ func (c *Client) New(challenge Challenge, expiry time.Time) (*tlv.NewRes, error) return nil, fmt.Errorf("failed NEW fetch: %s (%w)", args.Result, args.Error) } - if err := c.validate(args); err != nil { + if err := s.validate(args); err != nil { return nil, err } @@ -185,18 +192,49 @@ func (c *Client) New(challenge Challenge, expiry time.Time) (*tlv.NewRes, error) return nil, fmt.Errorf("challenge not supported by CA: %s", challenge.Name()) } + symkey, err := EcdhHkdf(s.ecdhKey, newRes.EcdhPub, newRes.Salt, newRes.ReqId) + if err != nil { + return nil, fmt.Errorf("failed to derive symmetric key: %w", err) + } + s.aesKey = [AeadSizeTag]byte(symkey) + s.requestID = append([]byte(nil), newRes.ReqId...) + s.challenge = challenge + s.state = sessionStateChallenge return newRes, nil } -// Challenge sends a CHALLENGE request to the CA (blocking). -func (c *Client) Challenge( - challenge Challenge, - newRes *tlv.NewRes, - prevRes *tlv.ChallengeRes, -) (*tlv.ChallengeRes, error) { - if c.ecdhKey == nil || c.aeadCtr == nil { - return nil, fmt.Errorf("NEW must initialize a certificate session before CHALLENGE") +// (AI GENERATED DESCRIPTION): Challenge completes the CHALLENGE exchange for this certificate session (blocking). +func (s *Session) Challenge() (*tlv.ChallengeRes, error) { + if s == nil || s.state != sessionStateChallenge { + return nil, fmt.Errorf("successful NEW required before CHALLENGE") } + + var prevRes *tlv.ChallengeRes + for { + chRes, err := s.challengeRound(prevRes) + if err != nil { + return nil, err + } + + switch ChallengeStatus(chRes.Status) { + case ChallengeStatusBefore: + return chRes, ErrChallengeBefore + case ChallengeStatusChallenge: + prevRes = chRes + case ChallengeStatusPending: + // TODO: likely need to wait and retry + return chRes, ErrChallengePending + case ChallengeStatusSuccess: + return chRes, nil + case ChallengeStatusFailure: + return chRes, ErrChallengeFailed + default: + return chRes, ErrChallengeStatusUnknown + } + } +} + +func (s *Session) challengeRound(prevRes *tlv.ChallengeRes) (*tlv.ChallengeRes, error) { var prevParams ParamMap = nil var prevStatus optional.Optional[string] @@ -216,27 +254,21 @@ func (c *Client) Challenge( } // Get challenge params - params, err := challenge.Request(prevParams, prevStatus) + params, err := s.challenge.Request(prevParams, prevStatus) if err != nil { return nil, fmt.Errorf("failed to get challenge params: %w", err) } // Create CHALLENGE request for CA chParams := tlv.ChallengeReq{ - Challenge: challenge.Name(), + Challenge: s.challenge.Name(), Params: params, } - // Derive symmetric key using ECDH-HKDF - symkey, err := EcdhHkdf(c.ecdhKey, newRes.EcdhPub, newRes.Salt, newRes.ReqId) - if err != nil { - return nil, fmt.Errorf("failed to derive symmetric key: %w", err) - } - // Encrypt and send CHALLENGE request chParamsC, err := AeadEncrypt( - [16]byte(symkey), chParams.Encode().Join(), - newRes.ReqId, c.aeadCtr) + s.aesKey, chParams.Encode().Join(), + s.requestID, s.aeadCtr) if err != nil { return nil, fmt.Errorf("failed to encrypt CHALLENGE: %w", err) } @@ -244,18 +276,18 @@ func (c *Client) Challenge( // TODO: implement retrying on failure // ExpressR will sign the packet again failure, this breaks the protocol ch := make(chan ndn.ExpressCallbackArgs, 1) - c.client.ExpressR(ndn.ExpressRArgs{ - Name: c.caPrefix.Append( + s.network.ExpressR(ndn.ExpressRArgs{ + Name: s.caPrefix.Append( enc.NewGenericComponent("CA"), enc.NewGenericComponent("CHALLENGE"), - enc.NewGenericBytesComponent(newRes.ReqId), + enc.NewGenericBytesComponent(s.requestID), ), Config: &ndn.InterestConfig{ CanBePrefix: false, MustBeFresh: true, }, AppParam: chParamsC.TLV().Encode(), - Signer: c.signer, + Signer: s.signer, Retries: 0, Callback: func(args ndn.ExpressCallbackArgs) { ch <- args }, }) @@ -264,7 +296,7 @@ func (c *Client) Challenge( return nil, fmt.Errorf("failed CHALLENGE fetch: %s (%w)", args.Result, args.Error) } - if err := c.validate(args); err != nil { + if err := s.validate(args); err != nil { return nil, err } @@ -282,7 +314,7 @@ func (c *Client) Challenge( if err := chResAeadMsg.FromTLV(chResEnc); err != nil { return nil, fmt.Errorf("invalid CHALLENGE cipher response: %w", err) } - chResBytes, err := AeadDecrypt([16]byte(symkey), chResAeadMsg, newRes.ReqId, c.aeadCtr) + chResBytes, err := AeadDecrypt(s.aesKey, chResAeadMsg, s.requestID, s.aeadCtr) if err != nil { return nil, fmt.Errorf("failed to decrypt CHALLENGE response: %w", err) } @@ -292,22 +324,7 @@ func (c *Client) Challenge( return nil, fmt.Errorf("failed to parse CHALLENGE response: %w", err) } - switch ChallengeStatus(chRes.Status) { - case ChallengeStatusBefore: - return chRes, ErrChallengeBefore - case ChallengeStatusChallenge: - // Continue with the challenge - return c.Challenge(challenge, newRes, chRes) - case ChallengeStatusPending: - // TODO: likely need to wait and retry - return chRes, ErrChallengePending - case ChallengeStatusSuccess: - return chRes, nil - case ChallengeStatusFailure: - return chRes, ErrChallengeFailed - default: - return chRes, ErrChallengeStatusUnknown - } + return chRes, nil } // FetchIssuedCert fetches the issued certificate from the CA (blocking). @@ -351,7 +368,15 @@ func (c *Client) fetchCert(name enc.Name, fwHint []enc.Name) (ndn.Data, enc.Wire // validate checks the signature of the data. func (c *Client) validate(args ndn.ExpressCallbackArgs) error { - valid, err := sig.ValidateData(args.Data, args.SigCovered, c.caCert) + return validate(args, c.caCert) +} + +func (s *Session) validate(args ndn.ExpressCallbackArgs) error { + return validate(args, s.caCert) +} + +func validate(args ndn.ExpressCallbackArgs, cert ndn.Data) error { + valid, err := sig.ValidateData(args.Data, args.SigCovered, cert) if err != nil || !valid { return fmt.Errorf("validation failure for %s: %w", args.Data.Name(), err) } diff --git a/std/security/ndncert/client_session_test.go b/std/security/ndncert/client_session_test.go index 8b550c63..423f3bb4 100644 --- a/std/security/ndncert/client_session_test.go +++ b/std/security/ndncert/client_session_test.go @@ -6,7 +6,6 @@ import ( "crypto/cipher" "crypto/elliptic" "encoding/binary" - "strings" "testing" "time" @@ -49,7 +48,10 @@ func newSessionTestClient(t *testing.T) (*Client, ndn.Signer) { if err != nil { t.Fatal(err) } - return &Client{signer: requester, caCert: caCert, caPrefix: name}, caSigner + network := &sessionTestClient{express: func(args ndn.ExpressRArgs) { + t.Fatal("unexpected network request") + }} + return &Client{signer: requester, caCert: caCert, caPrefix: name, client: network}, caSigner } func replySessionTest(t *testing.T, signer ndn.Signer, args ndn.ExpressRArgs, content enc.Wire) { @@ -65,30 +67,31 @@ func replySessionTest(t *testing.T, signer ndn.Signer, args ndn.ExpressRArgs, co args.Callback(ndn.ExpressCallbackArgs{Result: ndn.InterestResultData, Data: data, SigCovered: covered}) } -func TestClientNewSession(t *testing.T) { +func TestClientSessionIsolation(t *testing.T) { c, caSigner := newSessionTestClient(t) var previousPub []byte var previousCounter *AeadCounter + var session *Session request := 0 c.client = &sessionTestClient{express: func(args ndn.ExpressRArgs) { params, err := tlv.ParseNewReq(enc.NewWireView(args.AppParam), false) if err != nil { t.Fatal(err) } - if !bytes.Equal(params.EcdhPub, c.ecdhKey.PublicKey().Bytes()) { + if !bytes.Equal(params.EcdhPub, session.ecdhKey.PublicKey().Bytes()) { t.Fatal("NEW does not carry current session public key") } if bytes.Equal(params.EcdhPub, previousPub) { t.Fatal("NEW reused an ephemeral ECDH key") } - if c.aeadCtr == previousCounter || c.aeadCtr.nextSendBlock != 0 || c.aeadCtr.nextPeerBlock != 0 { + if session.aeadCtr == previousCounter || session.aeadCtr.nextSendBlock != 0 || session.aeadCtr.nextPeerBlock != 0 { t.Fatal("NEW reused IV state") } previousPub = bytes.Clone(params.EcdhPub) - previousCounter = c.aeadCtr + previousCounter = session.aeadCtr request++ if request == 2 { - // A failed NEW must not cause the next attempt to reuse its key. + // (AI GENERATED DESCRIPTION): A failed NEW must not cause the next attempt to reuse its key. args.Callback(ndn.ExpressCallbackArgs{Result: ndn.InterestResultTimeout}) return } @@ -97,7 +100,7 @@ func TestClientNewSession(t *testing.T) { t.Fatal(err) } response := &tlv.NewRes{EcdhPub: serverKey.PublicKey().Bytes(), Salt: make([]byte, 32), ReqId: make([]byte, 8), Challenge: []string{KwEmail}} - clientSecret, err := EcdhHkdf(c.ecdhKey, response.EcdhPub, response.Salt, response.ReqId) + clientSecret, err := EcdhHkdf(session.ecdhKey, response.EcdhPub, response.Salt, response.ReqId) if err != nil { t.Fatal(err) } @@ -108,19 +111,75 @@ func TestClientNewSession(t *testing.T) { replySessionTest(t, caSigner, args, response.Encode()) }} for i := 1; i <= 3; i++ { - _, err := c.New(&ChallengeEmail{}, time.Now().Add(time.Hour)) + var err error + session, err = c.NewSession() + if err != nil { + t.Fatal(err) + } + _, err = session.New(&ChallengeEmail{}, time.Now().Add(time.Hour)) if (err != nil) != (i == 2) { t.Fatalf("request %d: unexpected error %v", i, err) } - // Exercise reset of both sending and receiving state on reuse. - c.aeadCtr.nextSendBlock = 100 - c.aeadCtr.nextPeerBlock = 200 + // (AI GENERATED DESCRIPTION): Dirty state in this session must not affect the next session. + session.aeadCtr.nextSendBlock = 100 + session.aeadCtr.nextPeerBlock = 200 + } +} + +func TestSessionRejectsSecondNew(t *testing.T) { + c, _ := newSessionTestClient(t) + requests := 0 + c.client = &sessionTestClient{express: func(args ndn.ExpressRArgs) { + requests++ + args.Callback(ndn.ExpressCallbackArgs{Result: ndn.InterestResultTimeout}) + }} + session, err := c.NewSession() + if err != nil { + t.Fatal(err) + } + if _, err := session.New(&ChallengeEmail{}, time.Now().Add(time.Hour)); err == nil { + t.Fatal("first NEW unexpectedly succeeded") + } + if _, err := session.New(&ChallengeEmail{}, time.Now().Add(time.Hour)); err == nil { + t.Fatal("session accepted a second NEW") + } + if requests != 1 { + t.Fatalf("second NEW reached the network: got %d requests", requests) + } +} + +func TestSessionRequiresChallenge(t *testing.T) { + c, _ := newSessionTestClient(t) + session, err := c.NewSession() + if err != nil { + t.Fatal(err) + } + if _, err := session.New(nil, time.Now().Add(time.Hour)); err == nil { + t.Fatal("NEW accepted a nil challenge") + } +} + +func TestSessionSnapshotsSigner(t *testing.T) { + c, _ := newSessionTestClient(t) + session, err := c.NewSession() + if err != nil { + t.Fatal(err) + } + c.SetSigner(nil) + if session.signer == nil { + t.Fatal("client signer mutation changed an existing session") } } -// Exercise the client protocol against a peer using the standard-library GCM +func TestClientNewSessionRequiresSigner(t *testing.T) { + if _, err := new(Client).NewSession(); err == nil { + t.Fatal("client without a signer created a session") + } +} + +// (AI GENERATED DESCRIPTION): Exercise the client protocol against a peer using the standard-library GCM // API directly, so the client and test peer cannot share an IV-encoding bug. -func TestClientChallengeExchange(t *testing.T) { +func TestSessionChallengeExchange(t *testing.T) { for _, test := range []struct { name string replay bool @@ -142,8 +201,12 @@ func TestClientChallengeExchange(t *testing.T) { issuedName := c.signer.KeyName().Append(enc.NewGenericComponent("ca"), enc.NewVersionComponent(1)) peer := &sessionTestClient{} c.client = peer + session, err := c.NewSession() + if err != nil { + t.Fatal(err) + } - // Complete NEW and derive the peer's session key before CHALLENGE. + // (AI GENERATED DESCRIPTION): Complete NEW and derive the peer's session key before CHALLENGE. peer.express = func(args ndn.ExpressRArgs) { req, err := tlv.ParseNewReq(enc.NewWireView(args.AppParam), false) if err != nil { @@ -171,12 +234,16 @@ func TestClientChallengeExchange(t *testing.T) { codesRequested++ return "123456" }} - result, err := c.New(challenge, time.Now().Add(time.Hour)) + result, err := session.New(challenge, time.Now().Add(time.Hour)) if err != nil { t.Fatal(err) } + // (AI GENERATED DESCRIPTION): The returned response is caller-owned and must not alias session state. + result.EcdhPub[0] ^= 1 + result.Salt[0] ^= 1 + result.ReqId[0] ^= 1 - // Verify each CHALLENGE request and return an encrypted response. + // (AI GENERATED DESCRIPTION): Verify each CHALLENGE request and return an encrypted response. var nextSend, nextReceive uint32 var clientPrefix []byte var firstResponse enc.Wire @@ -223,7 +290,7 @@ func TestClientChallengeExchange(t *testing.T) { CertName: &spec.NameContainer{Name: issuedName}, } } - // Use a stable prefix guaranteed to differ from the client's. + // (AI GENERATED DESCRIPTION): Use a stable prefix guaranteed to differ from the client's. iv := make([]byte, 12) copy(iv[:8], clientPrefix) iv[0] ^= 1 @@ -240,9 +307,9 @@ func TestClientChallengeExchange(t *testing.T) { rounds++ replySessionTest(t, caSigner, args, content) } - response, err := c.Challenge(challenge, result, nil) + response, err := session.Challenge() if test.replay { - if err == nil || !strings.Contains(err.Error(), "counter was replayed") { + if err == nil { t.Fatalf("expected replay rejection, got %v", err) } } else { @@ -263,7 +330,7 @@ func TestClientChallengeExchange(t *testing.T) { } } -func TestClientNewRejectsRequesterSignedResponse(t *testing.T) { +func TestSessionNewRejectsRequesterSignedResponse(t *testing.T) { c, _ := newSessionTestClient(t) serverKey, err := EcdhKeygen() if err != nil { @@ -273,13 +340,17 @@ func TestClientNewRejectsRequesterSignedResponse(t *testing.T) { c.client = &sessionTestClient{express: func(args ndn.ExpressRArgs) { replySessionTest(t, c.signer, args, response.Encode()) }} - if _, err := c.New(&ChallengeEmail{}, time.Now().Add(time.Hour)); err == nil || !strings.Contains(err.Error(), "validation failure") { + session, err := c.NewSession() + if err != nil { + t.Fatal(err) + } + if _, err := session.New(&ChallengeEmail{}, time.Now().Add(time.Hour)); err == nil { t.Fatalf("expected CA signature validation failure, got %v", err) } } -func TestClientChallengeRequiresSession(t *testing.T) { - if _, err := new(Client).Challenge(&ChallengeEmail{}, nil, nil); err == nil { +func TestSessionChallengeRequiresNew(t *testing.T) { + if _, err := new(Session).Challenge(); err == nil { t.Fatal("CHALLENGE accepted without NEW") } } diff --git a/std/security/ndncert/crypto_aes.go b/std/security/ndncert/crypto_aes.go index 66c97804..294d74a3 100644 --- a/std/security/ndncert/crypto_aes.go +++ b/std/security/ndncert/crypto_aes.go @@ -31,7 +31,7 @@ func (m *AeadMessage) TLV() *tlv.CipherMsg { } } -// FromTLV decodes an AEAD message, rejecting invalid IV and tag lengths. +// (AI GENERATED DESCRIPTION): FromTLV decodes an AEAD message, rejecting invalid IV and tag lengths. func (m *AeadMessage) FromTLV(t *tlv.CipherMsg) error { if t == nil || len(t.InitVec) != AeadSizeNonce || len(t.AuthNTag) != AeadSizeTag { return fmt.Errorf("invalid AEAD message: expected a %d-byte IV and %d-byte authentication tag", AeadSizeNonce, AeadSizeTag) @@ -42,22 +42,22 @@ func (m *AeadMessage) FromTLV(t *tlv.CipherMsg) error { return nil } -// AeadCounter holds both directions of one NDNCERT session. It must not be +// (AI GENERATED DESCRIPTION): AeadCounter holds both directions of one NDNCERT session. It must not be // reused with a new session key or shared between concurrent operations. type AeadCounter struct { - // uint64 represents the exhausted state (2^32) without wrapping to zero. + // (AI GENERATED DESCRIPTION): uint64 represents the exhausted state (2^32) without wrapping to zero. nextSendBlock uint64 sendPrefix [AeadSizeRand]byte peerPrefix [AeadSizeRand]byte - // Zero means no peer message has been accepted; messages consume at least + // (AI GENERATED DESCRIPTION): Zero means no peer message has been accepted; messages consume at least // one block, so every accepted message makes this positive. nextPeerBlock uint64 } const aeadCounterLimit = uint64(1) << 32 -// Empty CHALLENGE plaintext is invalid and would otherwise reuse an IV because +// (AI GENERATED DESCRIPTION): Empty CHALLENGE plaintext is invalid and would otherwise reuse an IV because // it consumes zero blocks. Integer division avoids floating-point rounding and // adding 15 to a potentially large int. func aeadBlocks(length int) (uint64, error) { @@ -68,7 +68,7 @@ func aeadBlocks(length int) (uint64, error) { if length%aes.BlockSize != 0 { blocks++ } - // GCM itself limits a message to 2^32-2 blocks. + // (AI GENERATED DESCRIPTION): GCM itself limits a message to 2^32-2 blocks. if blocks > aeadCounterLimit-2 { return 0, fmt.Errorf("AEAD message exceeds GCM block limit") } @@ -113,7 +113,7 @@ func AeadEncrypt( return nil, err } - // NDNCERT v0.3: use the current counter, in network byte order, then + // (AI GENERATED DESCRIPTION): Use the current counter in network byte order, then // advance by the number of plaintext AES blocks after encryption. var iv [AeadSizeNonce]byte copy(iv[:], counter.sendPrefix[:]) @@ -130,7 +130,7 @@ func AeadEncrypt( }, nil } -// AeadDecrypt authenticates a peer message and checks its IV against the session. +// (AI GENERATED DESCRIPTION): AeadDecrypt authenticates a peer message and checks its IV against the session. // Use the same counter for every encryption and decryption in one session; // receive state advances only when authentication and IV validation succeed. func AeadDecrypt( @@ -157,7 +157,7 @@ func AeadDecrypt( return nil, err } - // Do not overwrite the caller's packet buffer while assembling GCM input. + // (AI GENERATED DESCRIPTION): Do not overwrite the caller's packet buffer while assembling GCM input. ciphertext := make([]byte, len(message.CipherText)+AeadSizeTag) copy(ciphertext, message.CipherText) copy(ciphertext[len(message.CipherText):], message.AuthTag[:]) @@ -166,7 +166,7 @@ func AeadDecrypt( if err != nil { return nil, err } - // Authenticate before changing receive state: forged packets cannot reserve + // (AI GENERATED DESCRIPTION): Authenticate before changing receive state: forged packets cannot reserve // counters or change the expected random prefix. Counter ranges may have // gaps, but must never overlap or wrap. Each direction has its own prefix. start := uint64(binary.BigEndian.Uint32(message.IV[AeadSizeRand:])) diff --git a/std/security/ndncert/crypto_aes_test.go b/std/security/ndncert/crypto_aes_test.go index 68b9509b..f07869dd 100644 --- a/std/security/ndncert/crypto_aes_test.go +++ b/std/security/ndncert/crypto_aes_test.go @@ -6,7 +6,6 @@ import ( "crypto/cipher" "encoding/binary" "fmt" - "strings" "testing" "github.com/named-data/ndnd/std/security/ndncert/tlv" @@ -17,7 +16,7 @@ var testAeadInfo = []byte("request-id") var testLocalPrefix = [8]byte{1} var testPeerPrefix = [8]byte{2} -// Construct peer packets independently of AeadEncrypt, so a matching encoder +// (AI GENERATED DESCRIPTION): Construct peer packets independently of AeadEncrypt, so a matching encoder // and decoder bug cannot make the receive-side tests pass. func referenceAeadMessage(t *testing.T, prefix [8]byte, counter uint32, size int) AeadMessage { t.Helper() @@ -119,13 +118,12 @@ func TestAeadReceiveValidation(t *testing.T) { prefix [8]byte counter uint32 size int - wantErr string }{ - {"replay", testPeerPrefix, 0, 17, "counter was replayed"}, - {"overlapping blocks", testPeerPrefix, 1, 1, "counter was replayed"}, - {"changed prefix", [8]byte{3}, 2, 1, "peer IV prefix changed"}, - {"local prefix", testLocalPrefix, 2, 1, "peer reused the local IV random prefix"}, - {"wrap", testPeerPrefix, ^uint32(0), 17, "receive counter would wrap"}, + {"replay", testPeerPrefix, 0, 17}, + {"overlapping blocks", testPeerPrefix, 1, 1}, + {"changed prefix", [8]byte{3}, 2, 1}, + {"local prefix", testLocalPrefix, 2, 1}, + {"wrap", testPeerPrefix, ^uint32(0), 17}, } { t.Run(test.name, func(t *testing.T) { c := &AeadCounter{sendPrefix: testLocalPrefix} @@ -133,13 +131,13 @@ func TestAeadReceiveValidation(t *testing.T) { t.Fatal(err) } before := *c - if _, err := AeadDecrypt(testAeadKey, referenceAeadMessage(t, test.prefix, test.counter, test.size), testAeadInfo, c); err == nil || !strings.Contains(err.Error(), test.wantErr) { - t.Fatalf("expected %q, got %v", test.wantErr, err) + if _, err := AeadDecrypt(testAeadKey, referenceAeadMessage(t, test.prefix, test.counter, test.size), testAeadInfo, c); err == nil { + t.Fatal("accepted invalid peer IV state") } if *c != before { t.Fatal("invalid packet changed receive state") } - // A rejected packet must not prevent the legitimate next packet. + // (AI GENERATED DESCRIPTION): A rejected packet must not prevent the legitimate next packet. if _, err := AeadDecrypt(testAeadKey, referenceAeadMessage(t, testPeerPrefix, 2, 1), testAeadInfo, c); err != nil { t.Fatal(err) } @@ -181,7 +179,7 @@ func TestAeadReceiveAuthentication(t *testing.T) { func TestAeadReceiveExhaustion(t *testing.T) { c := &AeadCounter{sendPrefix: testLocalPrefix} - // Gaps are permitted, including when earlier messages were lost. + // (AI GENERATED DESCRIPTION): Gaps are permitted, including when earlier messages were lost. m := referenceAeadMessage(t, testPeerPrefix, ^uint32(0), 16) if _, err := AeadDecrypt(testAeadKey, m, testAeadInfo, c); err != nil { t.Fatal(err)