Add android-key attestation format support

acme/challenge_test.go

@@ -31,6 +31,10 @@ import (
 	"time"
 
 	"github.com/fxamacker/cbor/v2"
+	"github.com/mbreban/attestation"
+	"github.com/smallstep/certificates/authority/config"
+	"github.com/smallstep/certificates/authority/provisioner"
+	wireprovisioner "github.com/smallstep/certificates/authority/provisioner/wire"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -98,6 +102,24 @@ func mustAttestationProvisioner(t *testing.T, roots []byte) Provisioner {
 	return prov
 }
 
+func mustNonCRLAttestationProvisioner(t *testing.T, roots []byte, CRLs []string) Provisioner {
+	t.Helper()
+
+	prov := &provisioner.ACME{
+		Type:                      "ACME",
+		Name:                      "acme",
+		Challenges:                []provisioner.ACMEChallenge{provisioner.DEVICE_ATTEST_01},
+		AttestationRoots:          roots,
+		RevokedCertificateSerials: CRLs,
+	}
+	if err := prov.Init(provisioner.Config{
+		Claims: config.GlobalProvisionerClaims,
+	}); err != nil {
+		t.Fatal(err)
+	}
+	return prov
+}
+
 func mustAccountAndKeyAuthorization(t *testing.T, token string) (*jose.JSONWebKey, string) {
 	t.Helper()
 
@@ -109,6 +131,62 @@ func mustAccountAndKeyAuthorization(t *testing.T, token string) (*jose.JSONWebKe
 	return jwk, keyAuth
 }
 
+func mustAttestAndroid(t *testing.T, keyAuthorization string) ([]byte, *x509.Certificate, *x509.Certificate) {
+	t.Helper()
+
+	ca, err := minica.New()
+	fatalError(t, err)
+
+	signer, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	fatalError(t, err)
+
+	keyAuthSum := sha256.Sum256([]byte(keyAuthorization))
+	fatalError(t, err)
+
+	sig, err := signer.Sign(rand.Reader, keyAuthSum[:], crypto.SHA256)
+	fatalError(t, err)
+
+	atts := attestation.KeyDescription{
+		AttestationVersion:       300,
+		AttestationSecurityLevel: 1,
+		AttestationChallenge:     sig,
+		TeeEnforced: attestation.AuthorizationList{
+			AttestationIdSerial: []byte("serial-number"),
+		},
+	}
+	attestByte, err := attestation.CreateKeyDescription(&atts)
+	fatalError(t, err)
+
+	leaf, err := ca.Sign(&x509.Certificate{
+		Subject:   pkix.Name{CommonName: "attestation cert"},
+		PublicKey: signer.Public(),
+		ExtraExtensions: []pkix.Extension{
+			{Id: oidAndroidAttestation, Value: attestByte},
+		},
+	})
+	fatalError(t, err)
+
+	attObj, err := cbor.Marshal(struct {
+		Format       string         `json:"fmt"`
+		AttStatement map[string]any `json:"attStmt,omitempty"`
+	}{
+		Format: "android-key",
+		AttStatement: map[string]any{
+			"x5c": []any{leaf.Raw, ca.Intermediate.Raw, ca.Root.Raw},
+		},
+	})
+	fatalError(t, err)
+
+	payload, err := json.Marshal(struct {
+		AttObj string `json:"attObj"`
+	}{
+		AttObj: base64.RawURLEncoding.EncodeToString(attObj),
+	})
+	require.NoError(t, err)
+
+	return payload, leaf, ca.Root
+}
+
 func mustAttestApple(t *testing.T, nonce string) ([]byte, *x509.Certificate, *x509.Certificate) {
 	t.Helper()
 
@@ -4503,6 +4581,95 @@ func Test_deviceAttest01Validate(t *testing.T) {
 				wantErr: nil,
 			}
 		},
+		"ok/doAndroidAttestationFormat": func(t *testing.T) test {
+
+			jwk, keyAuth := mustAccountAndKeyAuthorization(t, "token")
+			payload, _, root := mustAttestAndroid(t, keyAuth)
+
+			caRoot := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: root.Raw})
+			ctx := NewProvisionerContext(context.Background(), mustAttestationProvisioner(t, caRoot))
+			return test{
+				args: args{
+					ctx: ctx,
+					jwk: jwk,
+					ch: &Challenge{
+						ID:              "chID",
+						AuthorizationID: "azID",
+						Token:           "nonce",
+						Type:            "device-attest-01",
+						Status:          StatusPending,
+						Value:           "serial-number",
+					},
+					payload: payload,
+					db: &MockDB{
+						MockGetAuthorization: func(ctx context.Context, id string) (*Authorization, error) {
+							assert.Equal(t, "azID", id)
+							return &Authorization{ID: "azID"}, nil
+						},
+						MockUpdateChallenge: func(ctx context.Context, updch *Challenge) error {
+							assert.Equal(t, "chID", updch.ID)
+							assert.Equal(t, "nonce", updch.Token)
+							assert.Equal(t, StatusInvalid, updch.Status)
+							assert.Equal(t, ChallengeType("device-attest-01"), updch.Type)
+							assert.Equal(t, "serial-number", updch.Value)
+							assert.Nil(t, updch.Payload)
+							assert.Empty(t, updch.PayloadFormat)
+
+							return nil
+						},
+					},
+				},
+				wantErr: nil,
+			}
+		},
+		"ok/doAndroidAttestationFormat-invalid-root": func(t *testing.T) test {
+
+			jwk, keyAuth := mustAccountAndKeyAuthorization(t, "token")
+			payload, _, root := mustAttestAndroid(t, keyAuth)
+			caRoot := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: root.Raw})
+			ctx := NewProvisionerContext(context.Background(), mustNonCRLAttestationProvisioner(t, caRoot, []string{root.SerialNumber.String()}))
+			return test{
+				args: args{
+					ctx: ctx,
+					jwk: jwk,
+					ch: &Challenge{
+						ID:              "chID",
+						AuthorizationID: "azID",
+						Token:           "nonce",
+						Type:            "device-attest-01",
+						Status:          StatusPending,
+						Value:           "serial-number",
+					},
+					payload: payload,
+					db: &MockDB{
+						MockGetAuthorization: func(ctx context.Context, id string) (*Authorization, error) {
+							assert.Equal(t, "azID", id)
+							return &Authorization{ID: "azID"}, nil
+						},
+						MockUpdateChallenge: func(ctx context.Context, updch *Challenge) error {
+							assert.Equal(t, "chID", updch.ID)
+							assert.Equal(t, "nonce", updch.Token)
+							assert.Equal(t, StatusInvalid, updch.Status)
+							assert.Equal(t, ChallengeType("device-attest-01"), updch.Type)
+							assert.Equal(t, "serial-number", updch.Value)
+							assert.Nil(t, updch.Payload)
+							assert.Empty(t, updch.PayloadFormat)
+
+							err := NewDetailedError(ErrorBadAttestationStatementType, "x5c element contain a revoked certificate")
+
+							assert.EqualError(t, updch.Error.Err, err.Err.Error())
+							assert.Equal(t, err.Type, updch.Error.Type)
+							assert.Equal(t, err.Detail, updch.Error.Detail)
+							assert.Equal(t, err.Status, updch.Error.Status)
+							assert.Equal(t, err.Subproblems, updch.Error.Subproblems)
+
+							return nil
+						},
+					},
+				},
+				wantErr: nil,
+			}
+		},
 		"ok/doStepAttestationFormat-storeError": func(t *testing.T) test {
 			ca, err := minica.New()
 			require.NoError(t, err)
@@ -4930,6 +5097,74 @@ func Test_deviceAttest01Validate(t *testing.T) {
 	}
 }
 
+func Test_doAndroidKeyAttestionFormat_noAttestationRoots(t *testing.T) {
+	// This test exercises the fallback path when no attestation roots
+	// are configured (the !attOk branch), verifying that:
+	// 1. The ECDSA root parsing and type assertion works correctly
+	// 2. Non-Google roots are properly rejected
+	ca, err := minica.New()
+	require.NoError(t, err)
+
+	signer, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	require.NoError(t, err)
+
+	jwk, keyAuth := mustAccountAndKeyAuthorization(t, "token")
+	keyAuthSum := sha256.Sum256([]byte(keyAuth))
+	sig, err := signer.Sign(rand.Reader, keyAuthSum[:], crypto.SHA256)
+	require.NoError(t, err)
+
+	atts := attestation.KeyDescription{
+		AttestationVersion:       300,
+		AttestationSecurityLevel: 1,
+		AttestationChallenge:     sig,
+		TeeEnforced: attestation.AuthorizationList{
+			AttestationIdSerial: []byte("serial-number"),
+		},
+	}
+	attestByte, err := attestation.CreateKeyDescription(&atts)
+	require.NoError(t, err)
+
+	leaf, err := ca.Sign(&x509.Certificate{
+		Subject:   pkix.Name{CommonName: "attestation cert"},
+		PublicKey: signer.Public(),
+		ExtraExtensions: []pkix.Extension{
+			{Id: oidAndroidAttestation, Value: attestByte},
+		},
+	})
+	require.NoError(t, err)
+
+	att := &attestationObject{
+		Format: "android-key",
+		AttStatement: map[string]any{
+			"x5c": []any{leaf.Raw, ca.Intermediate.Raw, ca.Root.Raw},
+		},
+	}
+
+	// Create provisioner without attestation roots
+	prov := &provisioner.ACME{
+		Type:       "ACME",
+		Name:       "acme",
+		Challenges: []provisioner.ACMEChallenge{provisioner.DEVICE_ATTEST_01},
+	}
+	require.NoError(t, prov.Init(provisioner.Config{
+		Claims: config.GlobalProvisionerClaims,
+	}))
+
+	ch := &Challenge{
+		ID:    "chID",
+		Token: "nonce",
+		Type:  "device-attest-01",
+		Value: "serial-number",
+	}
+
+	_, err = doAndroidKeyAttestionFormat(context.Background(), prov, ch, jwk, att)
+	require.Error(t, err)
+
+	var acmeErr *Error
+	require.ErrorAs(t, err, &acmeErr)
+	assert.Contains(t, acmeErr.Error(), "root certificate not signed by Google")
+}
+
 var (
 	oidTPMManufacturer = asn1.ObjectIdentifier{2, 23, 133, 2, 1}
 	oidTPMModel        = asn1.ObjectIdentifier{2, 23, 133, 2, 2}

authority/provisioner/acme.go

@@ -3,9 +3,14 @@ package provisioner
 import (
 	"context"
 	"crypto/x509"
+	"encoding/json"
 	"encoding/pem"
 	"fmt"
+	"io"
+	"log"
 	"net"
+	"net/http"
+	"slices"
 	"strings"
 	"time"
 
@@ -53,6 +58,10 @@ func (c ACMEChallenge) Validate() error {
 type ACMEAttestationFormat string
 
 const (
+	// ANDROIDKEY is the format used to enable device-attest-01 for Android
+	// devices using Android Key Attestation.
+	ANDROIDKEY ACMEAttestationFormat = "android-key"
+
 	// APPLE is the format used to enable device-attest-01 on Apple devices.
 	APPLE ACMEAttestationFormat = "apple"
 
@@ -74,7 +83,7 @@ func (f ACMEAttestationFormat) String() string {
 // Validate returns an error if the attestation format is not a valid one.
 func (f ACMEAttestationFormat) Validate() error {
 	switch ACMEAttestationFormat(f.String()) {
-	case APPLE, STEP, TPM:
+	case APPLE, STEP, TPM, ANDROIDKEY:
 		return nil
 	default:
 		return fmt.Errorf("acme attestation format %q is not supported", f)
@@ -117,11 +126,13 @@ type ACME struct {
 	// AttestationRoots contains a bundle of root certificates in PEM format
 	// that will be used to verify the attestation certificates. If provided,
 	// this bundle will be used even for well-known CAs like Apple and Yubico.
-	AttestationRoots    []byte   `json:"attestationRoots,omitempty"`
-	Claims              *Claims  `json:"claims,omitempty"`
-	Options             *Options `json:"options,omitempty"`
-	attestationRootPool *x509.CertPool
-	ctl                 *Controller
+	AttestationRoots          []byte   `json:"attestationRoots,omitempty"`
+	Claims                    *Claims  `json:"claims,omitempty"`
+	Options                   *Options `json:"options,omitempty"`
+	RevokedCertificateSerials []string `json:"revokedCertificateSerials,omitempty"`
+	androidCRLTimeout         time.Time
+	attestationRootPool       *x509.CertPool
+	ctl                       *Controller
 }
 
 // GetID returns the provisioner unique identifier.
@@ -217,10 +228,51 @@ func (p *ACME) Init(config Config) (err error) {
 		return fmt.Errorf("failed initializing Wire options: %w", err)
 	}
 
+	if slices.Contains(p.AttestationFormats, ANDROIDKEY) && len(p.RevokedCertificateSerials) == 0 {
+		p.fetchAndroidCRL()
+	}
+
 	p.ctl, err = NewController(p, p.Claims, config, p.Options)
 	return
 }
 
+const androidAttestationStatusURL = "https://android.googleapis.com/attestation/status"
+
+// fetch CRL https://android.googleapis.com/attestation/status and build a list of revoked serial numbers
+func (p *ACME) fetchAndroidCRL() error {
+	log.Printf("Updating Android CRL list for %s ACME provisioner", p.Name)
+	var crlResponse struct {
+		Entries map[string]struct {
+			Status string `json:"status"`
+			Reason string `json:"reason"`
+		} `json:"entries"`
+	}
+	// res, err := p.ctl.GetHTTPClient().Get(androidAttestationStatusURL)
+	res, err := http.Get(androidAttestationStatusURL)
+	if err != nil {
+		return fmt.Errorf("client: error making Android CRL request: %s\n", err)
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != http.StatusOK {
+		bodyBytes, _ := io.ReadAll(res.Body)
+		return fmt.Errorf("unexpected Android CRL response %d: %s", res.StatusCode, string(bodyBytes))
+	}
+
+	if err := json.NewDecoder(res.Body).Decode(&crlResponse); err != nil {
+		return fmt.Errorf("error decoding Android CRL JSON: %w", err)
+	}
+
+	// Extract keys into a slice
+	keys := make([]string, 0, len(crlResponse.Entries))
+	for k := range crlResponse.Entries {
+		keys = append(keys, k)
+	}
+	p.RevokedCertificateSerials = keys
+	p.androidCRLTimeout = time.Now().Add(24 * time.Hour)
+	return nil
+}
+
 // initializeWireOptions initializes the options for the ACME Wire
 // integration. It'll return early if no Wire challenge types are
 // enabled.
@@ -372,7 +424,7 @@ func (p *ACME) IsChallengeEnabled(_ context.Context, challenge ACMEChallenge) bo
 // AttestationFormat provisioner property should have at least one element.
 func (p *ACME) IsAttestationFormatEnabled(_ context.Context, format ACMEAttestationFormat) bool {
 	enabledFormats := []ACMEAttestationFormat{
-		APPLE, STEP, TPM,
+		APPLE, STEP, TPM, ANDROIDKEY,
 	}
 	if len(p.AttestationFormats) > 0 {
 		enabledFormats = p.AttestationFormats
@@ -393,3 +445,13 @@ func (p *ACME) IsAttestationFormatEnabled(_ context.Context, format ACMEAttestat
 func (p *ACME) GetAttestationRoots() (*x509.CertPool, bool) {
 	return p.attestationRootPool, p.attestationRootPool != nil
 }
+
+// IsCertificateRevoked returns true if the provided serialNumber is in the list of revoked
+// certificate serial number.
+// It will also be in charge of updating the list periodically if no CRL list is provided at configuration.
+func (p *ACME) IsCertificateRevoked(serialNumber string) bool {
+	if slices.Contains(p.AttestationFormats, ANDROIDKEY) && !p.androidCRLTimeout.IsZero() && time.Now().After(p.androidCRLTimeout) {
+		p.fetchAndroidCRL()
+	}
+	return slices.Contains(p.RevokedCertificateSerials, serialNumber)
+}