diff --git a/std/security/ndncert/client.go b/std/security/ndncert/client.go index d06aefe3..4176293b 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" ) +// (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 @@ -22,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. @@ -46,12 +70,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,9 +82,32 @@ func NewClient(engine ndn.Engine, caCert []byte) (*Client, error) { caCert: cert, caPrefix: caPrefix, - client: client, - ecdhKey: ecdhKey, - aeadCtr: NewAeadCounter(), + client: client, + }, 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 nil, fmt.Errorf("failed to generate session ECDH key: %w", err) + } + return &Session{ + network: c.client, + signer: c.signer, + caCert: c.caCert, + caPrefix: c.caPrefix.Clone(), + ecdhKey: key, + aeadCtr: NewAeadCounter(), }, nil } @@ -252,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 } @@ -277,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 5e61ff82..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, }) @@ -132,13 +142,13 @@ func (c *Client) New(challenge Challenge, expiry time.Time) (*tlv.NewRes, error) // Send NEW request to CA 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"), ), @@ -147,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 }, }) @@ -156,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 } @@ -182,15 +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) { +// (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] @@ -210,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) } @@ -238,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 }, }) @@ -258,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 } @@ -273,8 +311,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(s.aesKey, chResAeadMsg, s.requestID, s.aeadCtr) if err != nil { return nil, fmt.Errorf("failed to decrypt CHALLENGE response: %w", err) } @@ -284,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). @@ -343,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 new file mode 100644 index 00000000..423f3bb4 --- /dev/null +++ b/std/security/ndncert/client_session_test.go @@ -0,0 +1,356 @@ +package ndncert + +import ( + "bytes" + "crypto/aes" + "crypto/cipher" + "crypto/elliptic" + "encoding/binary" + "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" + "github.com/named-data/ndnd/std/types/optional" +) + +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) + } + 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) { + 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 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, 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 session.aeadCtr == previousCounter || session.aeadCtr.nextSendBlock != 0 || session.aeadCtr.nextPeerBlock != 0 { + t.Fatal("NEW reused IV state") + } + previousPub = bytes.Clone(params.EcdhPub) + previousCounter = session.aeadCtr + request++ + if request == 2 { + // (AI GENERATED DESCRIPTION): 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(session.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++ { + 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) + } + // (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") + } +} + +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 TestSessionChallengeExchange(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 + session, err := c.NewSession() + if err != nil { + t.Fatal(err) + } + + // (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 { + 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 := 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 + + // (AI GENERATED DESCRIPTION): 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}, + } + } + // (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 + 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 := session.Challenge() + if test.replay { + if err == nil { + 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) + } + }) + } +} + +func TestSessionNewRejectsRequesterSignedResponse(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()) + }} + 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 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 96efe39b..294d74a3 100644 --- a/std/security/ndncert/crypto_aes.go +++ b/std/security/ndncert/crypto_aes.go @@ -1,12 +1,13 @@ package ndncert import ( + "bytes" "crypto/aes" "crypto/cipher" "crypto/rand" "encoding/binary" + "fmt" "io" - "math" "github.com/named-data/ndnd/std/security/ndncert/tlv" ) @@ -30,16 +31,48 @@ 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) { +// (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) + } m.IV = [AeadSizeNonce]byte(t.InitVec) m.AuthTag = [AeadSizeTag]byte(t.AuthNTag) m.CipherText = t.Payload + return nil } +// (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 { - block uint32 - random [AeadSizeRand]byte + // (AI GENERATED DESCRIPTION): uint64 represents the exhausted state (2^32) without wrapping to zero. + nextSendBlock uint64 + sendPrefix [AeadSizeRand]byte + peerPrefix [AeadSizeRand]byte + + // (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 + +// (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) { + if length <= 0 { + return 0, fmt.Errorf("AEAD plaintext must not be empty") + } + blocks := uint64(length / aes.BlockSize) + if length%aes.BlockSize != 0 { + 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") + } + 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 +82,7 @@ func NewAeadCounter() *AeadCounter { panic(randReadErr.Error()) } return &AeadCounter{ - block: 0, - random: [AeadSizeRand]byte(randomBytes), + sendPrefix: [AeadSizeRand]byte(randomBytes), } } @@ -61,6 +93,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,28 +113,39 @@ 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...) + // (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[:]) + 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 } -// (AI GENERATED DESCRIPTION): Decrypts an AEAD‑protected message using AES‑GCM with the given key and additional authenticated data. +// (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( 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 @@ -104,12 +157,35 @@ func AeadDecrypt( return nil, err } - ciphertext := append(message.CipherText, message.AuthTag[:]...) + // (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[:]) - plaintext, err := aesgcm.Open(nil, nonce, ciphertext, info[:]) + plaintext, err := aesgcm.Open(ciphertext[:0], nonce, ciphertext, info) if err != nil { return nil, err } + // (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:])) + 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 new file mode 100644 index 00000000..f07869dd --- /dev/null +++ b/std/security/ndncert/crypto_aes_test.go @@ -0,0 +1,253 @@ +package ndncert + +import ( + "bytes" + "crypto/aes" + "crypto/cipher" + "encoding/binary" + "fmt" + "testing" + + "github.com/named-data/ndnd/std/security/ndncert/tlv" +) + +var testAeadKey = [16]byte{1, 2, 3} +var testAeadInfo = []byte("request-id") +var testLocalPrefix = [8]byte{1} +var testPeerPrefix = [8]byte{2} + +// (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() + 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") + } +} + +func TestAeadReceiveValidation(t *testing.T) { + for _, test := range []struct { + name string + prefix [8]byte + counter uint32 + size int + }{ + {"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} + 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 { + t.Fatal("accepted invalid peer IV state") + } + if *c != before { + t.Fatal("invalid packet changed receive state") + } + // (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) + } + }) + } +} + +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} + // (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) + } + 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") + } +}