From 697bc4cb16d3cfc8755bd946b55b9699e76a4510 Mon Sep 17 00:00:00 2001 From: Alex Seigler Date: Fri, 7 Oct 2022 21:13:47 -0400 Subject: [PATCH] feat(metadata): mds3 support (#54) This feature migrates from MDS2 to MDS3. --- metadata/metadata.go | 536 ++++++++++-------- metadata/metadata_test.go | 347 ++++++++++-- protocol/attestation.go | 40 +- protocol/attestation_androidkey.go | 37 +- protocol/attestation_androidkey_test.go | 86 +++ protocol/attestation_apple.go | 23 +- protocol/attestation_apple_test.go | 61 ++ protocol/attestation_packed.go | 98 ++-- protocol/attestation_packed_test.go | 88 ++- protocol/attestation_safetynet.go | 44 +- protocol/attestation_safetynet_test.go | 8 +- protocol/attestation_tpm.go | 71 ++- protocol/attestation_tpm_test.go | 2 +- protocol/attestation_u2f.go | 36 +- protocol/attestation_u2f_test.go | 62 ++ protocol/webauthncose/webauthncose.go | 118 ++-- testdata/MetadataTOCParsing-F1.jwt | 1 - testdata/MetadataTOCParsing-F2.jwt | 1 - testdata/MetadataTOCParsing-F3.jwt | 1 - testdata/MetadataTOCParsing-F4.jwt | 1 - testdata/MetadataTOCParsing-P1.jwt | 1 - testdata/TestMetadataStatementParsing-F1.json | 1 - testdata/TestMetadataStatementParsing-P1.json | 1 - 23 files changed, 1107 insertions(+), 557 deletions(-) create mode 100644 protocol/attestation_androidkey_test.go create mode 100644 protocol/attestation_apple_test.go create mode 100644 protocol/attestation_u2f_test.go delete mode 100755 testdata/MetadataTOCParsing-F1.jwt delete mode 100755 testdata/MetadataTOCParsing-F2.jwt delete mode 100755 testdata/MetadataTOCParsing-F3.jwt delete mode 100755 testdata/MetadataTOCParsing-F4.jwt delete mode 100755 testdata/MetadataTOCParsing-P1.jwt delete mode 100644 testdata/TestMetadataStatementParsing-F1.json delete mode 100644 testdata/TestMetadataStatementParsing-P1.json diff --git a/metadata/metadata.go b/metadata/metadata.go index 66fa704e..c34d25de 100644 --- a/metadata/metadata.go +++ b/metadata/metadata.go @@ -1,75 +1,161 @@ package metadata import ( - "bytes" - "crypto" "crypto/x509" "encoding/base64" - "encoding/json" "errors" - "io/ioutil" "net/http" + "reflect" "github.com/go-webauthn/revoke" - "github.com/golang-jwt/jwt/v4" + "github.com/go-webauthn/webauthn/protocol/webauthncose" "github.com/google/uuid" "github.com/mitchellh/mapstructure" + + jwt "github.com/golang-jwt/jwt/v4" +) + +type PublicKeyCredentialParameters struct { + Type string `json:"type"` + Alg webauthncose.COSEAlgorithmIdentifier `json:"alg"` +} + +const ( + // https://secure.globalsign.com/cacert/root-r3.crt + ProductionMDSRoot = "MIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8RgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsTgHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmmKPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zdQQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZXriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+oLkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZURUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMpjjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQXmcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecsMx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpHWD9f" + // https://mds3.certinfra.fidoalliance.org/pki/MDS3ROOT.crt + ConformanceMDSRoot = "MIICaDCCAe6gAwIBAgIPBCqih0DiJLW7+UHXx/o1MAoGCCqGSM49BAMDMGcxCzAJBgNVBAYTAlVTMRYwFAYDVQQKDA1GSURPIEFsbGlhbmNlMScwJQYDVQQLDB5GQUtFIE1ldGFkYXRhIDMgQkxPQiBST09UIEZBS0UxFzAVBgNVBAMMDkZBS0UgUm9vdCBGQUtFMB4XDTE3MDIwMTAwMDAwMFoXDTQ1MDEzMTIzNTk1OVowZzELMAkGA1UEBhMCVVMxFjAUBgNVBAoMDUZJRE8gQWxsaWFuY2UxJzAlBgNVBAsMHkZBS0UgTWV0YWRhdGEgMyBCTE9CIFJPT1QgRkFLRTEXMBUGA1UEAwwORkFLRSBSb290IEZBS0UwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAASKYiz3YltC6+lmxhPKwA1WFZlIqnX8yL5RybSLTKFAPEQeTD9O6mOz+tg8wcSdnVxHzwnXiQKJwhrav70rKc2ierQi/4QUrdsPes8TEirZOkCVJurpDFbXZOgs++pa4XmjYDBeMAsGA1UdDwQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQGcfeCs0Y8D+lh6U5B2xSrR74eHTAfBgNVHSMEGDAWgBQGcfeCs0Y8D+lh6U5B2xSrR74eHTAKBggqhkjOPQQDAwNoADBlAjEA/xFsgri0xubSa3y3v5ormpPqCwfqn9s0MLBAtzCIgxQ/zkzPKctkiwoPtDzI51KnAjAmeMygX2S5Ht8+e+EQnezLJBJXtnkRWY+Zt491wgt/AwSs5PHHMv5QgjELOuMxQBc=" + // Example from https://fidoalliance.org/specs/mds/fido-metadata-service-v3.0-ps-20210518.html + ExampleMDSRoot = "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" ) // Metadata is a map of authenticator AAGUIDs to corresponding metadata statements -var Metadata = make(map[uuid.UUID]MetadataTOCPayloadEntry) +var Metadata = make(map[uuid.UUID]MetadataBLOBPayloadEntry) // Conformance indicates if test metadata is currently being used var Conformance = false +var MDSRoot = ProductionMDSRoot + +// MetadataBLOBPayloadEntry - Represents the MetadataBLOBPayloadEntry +// https://fidoalliance.org/specs/mds/fido-metadata-service-v3.0-ps-20210518.html#metadata-blob-payload-entry-dictionary +type MetadataBLOBPayloadEntry struct { + // The Authenticator Attestation ID. + Aaid string `json:"aaid"` + // The Authenticator Attestation GUID. + AaGUID string `json:"aaguid"` + // A list of the attestation certificate public key identifiers encoded as hex string. + AttestationCertificateKeyIdentifiers []string `json:"attestationCertificateKeyIdentifiers"` + // The metadataStatement JSON object as defined in FIDOMetadataStatement. + MetadataStatement MetadataStatement `json:"metadataStatement"` + // Status of the FIDO Biometric Certification of one or more biometric components of the Authenticator + BiometricStatusReports []BiometricStatusReport `json:"biometricStatusReports"` + // An array of status reports applicable to this authenticator. + StatusReports []StatusReport `json:"statusReports"` + // ISO-8601 formatted date since when the status report array was set to the current value. + TimeOfLastStatusChange string `json:"timeOfLastStatusChange"` + // URL of a list of rogue (i.e. untrusted) individual authenticators. + RogueListURL string `json:"rogueListURL"` + // The hash value computed over the Base64url encoding of the UTF-8 representation of the JSON encoded rogueList available at rogueListURL (with type rogueListEntry[]). + RogueListHash string `json:"rogueListHash"` +} + +// https://fidoalliance.org/specs/mds/fido-metadata-service-v3.0-ps-20210518.html#biometricstatusreport-dictionary +// BiometricStatusReport - Contains the current BiometricStatusReport of one of the authenticator's biometric component. +type BiometricStatusReport struct { + // Achieved level of the biometric certification of this biometric component of the authenticator + CertLevel uint16 `json:"certLevel"` + // A single USER_VERIFY constant indicating the modality of the biometric component + Modality string `json:"modality"` + // ISO-8601 formatted date since when the certLevel achieved, if applicable. If no date is given, the status is assumed to be effective while present. + EffectiveDate string `json:"effectiveDate"` + // Describes the externally visible aspects of the Biometric Certification evaluation. + CertificationDescriptor string `json:"certificationDescriptor"` + // The unique identifier for the issued Biometric Certification. + CertificateNumber string `json:"certificateNumber"` + // The version of the Biometric Certification Policy the implementation is Certified to, e.g. "1.0.0". + CertificationPolicyVersion string `json:"certificationPolicyVersion"` + // The version of the Biometric Requirements [FIDOBiometricsRequirements] the implementation is certified to, e.g. "1.0.0". + CertificationRequirementsVersion string `json:"certificationRequirementsVersion"` +} + +// StatusReport - Contains the current BiometricStatusReport of one of the authenticator's biometric component. +// https://fidoalliance.org/specs/mds/fido-metadata-service-v3.0-ps-20210518.html#statusreport-dictionary +type StatusReport struct { + // Status of the authenticator. Additional fields MAY be set depending on this value. + Status AuthenticatorStatus `json:"status"` + // ISO-8601 formatted date since when the status code was set, if applicable. If no date is given, the status is assumed to be effective while present. + EffectiveDate string `json:"effectiveDate"` + // The authenticatorVersion that this status report relates to. In the case of FIDO_CERTIFIED* status values, the status applies to higher authenticatorVersions until there is a new statusReport. + AuthenticatorVersion uint32 `json:"authenticatorVersion"` + // Base64-encoded [RFC4648] (not base64url!) DER [ITU-X690-2008] PKIX certificate value related to the current status, if applicable. + Certificate string `json:"certificate"` + // HTTPS URL where additional information may be found related to the current status, if applicable. + URL string `json:"url"` + // Describes the externally visible aspects of the Authenticator Certification evaluation. + CertificationDescriptor string `json:"certificationDescriptor"` + // The unique identifier for the issued Certification. + CertificateNumber string `json:"certificateNumber"` + // The version of the Authenticator Certification Policy the implementation is Certified to, e.g. "1.0.0". + CertificationPolicyVersion string `json:"certificationPolicyVersion"` + // The Document Version of the Authenticator Security Requirements (DV) [FIDOAuthenticatorSecurityRequirements] the implementation is certified to, e.g. "1.2.0". + CertificationRequirementsVersion string `json:"certificationRequirementsVersion"` +} + // AuthenticatorAttestationType - The ATTESTATION constants are 16 bit long integers indicating the specific attestation that authenticator supports. -type AuthenticatorAttestationType uint16 +// Each constant has a case-sensitive string representation (in quotes), which is used in the authoritative metadata for FIDO authenticators. +type AuthenticatorAttestationType string const ( // BasicFull - Indicates full basic attestation, based on an attestation private key shared among a class of authenticators (e.g. same model). Authenticators must provide its attestation signature during the registration process for the same reason. The attestation trust anchor is shared with FIDO Servers out of band (as part of the Metadata). This sharing process shouldt be done according to [UAFMetadataService]. - BasicFull AuthenticatorAttestationType = 0x3E07 + BasicFull AuthenticatorAttestationType = "basic_full" // BasicSurrogate - Just syntactically a Basic Attestation. The attestation object self-signed, i.e. it is signed using the UAuth.priv key, i.e. the key corresponding to the UAuth.pub key included in the attestation object. As a consequence it does not provide a cryptographic proof of the security characteristics. But it is the best thing we can do if the authenticator is not able to have an attestation private key. - BasicSurrogate + BasicSurrogate AuthenticatorAttestationType = "basic_surrogate" // Ecdaa - Indicates use of elliptic curve based direct anonymous attestation as defined in [FIDOEcdaaAlgorithm]. Support for this attestation type is optional at this time. It might be required by FIDO Certification. - Ecdaa + Ecdaa AuthenticatorAttestationType = "ecdaa" // AttCA - Indicates PrivacyCA attestation as defined in [TCG-CMCProfile-AIKCertEnroll]. Support for this attestation type is optional at this time. It might be required by FIDO Certification. - AttCA + AttCA AuthenticatorAttestationType = "attca" + // AnonCA In this case, the authenticator uses an Anonymization CA which dynamically generates per-credential attestation certificates such that the attestation statements presented to Relying Parties do not provide uniquely identifiable information, e.g., that might be used for tracking purposes. The applicable [WebAuthn] attestation formats "fmt" are Google SafetyNet Attestation "android-safetynet", Android Keystore Attestation "android-key", Apple Anonymous Attestation "apple", and Apple Application Attestation "apple-appattest". + AnonCA AuthenticatorAttestationType = "anonca" + // None - Indicates absence of attestation + None AuthenticatorAttestationType = "none" ) // AuthenticatorStatus - This enumeration describes the status of an authenticator model as identified by its AAID and potentially some additional information (such as a specific attestation key). +// https://fidoalliance.org/specs/mds/fido-metadata-service-v3.0-ps-20210518.html#authenticatorstatus-enum type AuthenticatorStatus string const ( // NotFidoCertified - This authenticator is not FIDO certified. - NotFidoCertified = "NOT_FIDO_CERTIFIED" + NotFidoCertified AuthenticatorStatus = "NOT_FIDO_CERTIFIED" // FidoCertified - This authenticator has passed FIDO functional certification. This certification scheme is phased out and will be replaced by FIDO_CERTIFIED_L1. - FidoCertified = "FIDO_CERTIFIED" + FidoCertified AuthenticatorStatus = "FIDO_CERTIFIED" // UserVerificationBypass - Indicates that malware is able to bypass the user verification. This means that the authenticator could be used without the user's consent and potentially even without the user's knowledge. - UserVerificationBypass = "USER_VERIFICATION_BYPASS" + UserVerificationBypass AuthenticatorStatus = "USER_VERIFICATION_BYPASS" // AttestationKeyCompromise - Indicates that an attestation key for this authenticator is known to be compromised. Additional data should be supplied, including the key identifier and the date of compromise, if known. - AttestationKeyCompromise = "ATTESTATION_KEY_COMPROMISE" + AttestationKeyCompromise AuthenticatorStatus = "ATTESTATION_KEY_COMPROMISE" // UserKeyRemoteCompromise - This authenticator has identified weaknesses that allow registered keys to be compromised and should not be trusted. This would include both, e.g. weak entropy that causes predictable keys to be generated or side channels that allow keys or signatures to be forged, guessed or extracted. - UserKeyRemoteCompromise = "USER_KEY_REMOTE_COMPROMISE" + UserKeyRemoteCompromise AuthenticatorStatus = "USER_KEY_REMOTE_COMPROMISE" // UserKeyPhysicalCompromise - This authenticator has known weaknesses in its key protection mechanism(s) that allow user keys to be extracted by an adversary in physical possession of the device. - UserKeyPhysicalCompromise = "USER_KEY_PHYSICAL_COMPROMISE" + UserKeyPhysicalCompromise AuthenticatorStatus = "USER_KEY_PHYSICAL_COMPROMISE" // UpdateAvailable - A software or firmware update is available for the device. Additional data should be supplied including a URL where users can obtain an update and the date the update was published. - UpdateAvailable = "UPDATE_AVAILABLE" + UpdateAvailable AuthenticatorStatus = "UPDATE_AVAILABLE" // Revoked - The FIDO Alliance has determined that this authenticator should not be trusted for any reason, for example if it is known to be a fraudulent product or contain a deliberate backdoor. - Revoked = "REVOKED" + Revoked AuthenticatorStatus = "REVOKED" // SelfAssertionSubmitted - The authenticator vendor has completed and submitted the self-certification checklist to the FIDO Alliance. If this completed checklist is publicly available, the URL will be specified in StatusReport.url. - SelfAssertionSubmitted = "SELF_ASSERTION_SUBMITTED" + SelfAssertionSubmitted AuthenticatorStatus = "SELF_ASSERTION_SUBMITTED" // FidoCertifiedL1 - The authenticator has passed FIDO Authenticator certification at level 1. This level is the more strict successor of FIDO_CERTIFIED. - FidoCertifiedL1 = "FIDO_CERTIFIED_L1" + FidoCertifiedL1 AuthenticatorStatus = "FIDO_CERTIFIED_L1" // FidoCertifiedL1plus - The authenticator has passed FIDO Authenticator certification at level 1+. This level is the more than level 1. - FidoCertifiedL1plus = "FIDO_CERTIFIED_L1plus" + FidoCertifiedL1plus AuthenticatorStatus = "FIDO_CERTIFIED_L1plus" // FidoCertifiedL2 - The authenticator has passed FIDO Authenticator certification at level 2. This level is more strict than level 1+. - FidoCertifiedL2 = "FIDO_CERTIFIED_L2" + FidoCertifiedL2 AuthenticatorStatus = "FIDO_CERTIFIED_L2" // FidoCertifiedL2plus - The authenticator has passed FIDO Authenticator certification at level 2+. This level is more strict than level 2. - FidoCertifiedL2plus = "FIDO_CERTIFIED_L2plus" + FidoCertifiedL2plus AuthenticatorStatus = "FIDO_CERTIFIED_L2plus" // FidoCertifiedL3 - The authenticator has passed FIDO Authenticator certification at level 3. This level is more strict than level 2+. - FidoCertifiedL3 = "FIDO_CERTIFIED_L3" + FidoCertifiedL3 AuthenticatorStatus = "FIDO_CERTIFIED_L3" // FidoCertifiedL3plus - The authenticator has passed FIDO Authenticator certification at level 3+. This level is more strict than level 3. - FidoCertifiedL3plus = "FIDO_CERTIFIED_L3plus" + FidoCertifiedL3plus AuthenticatorStatus = "FIDO_CERTIFIED_L3plus" ) // UndesiredAuthenticatorStatus is an array of undesirable authenticator statuses @@ -91,69 +177,6 @@ func IsUndesiredAuthenticatorStatus(status AuthenticatorStatus) bool { return false } -// StatusReport - Contains the current BiometricStatusReport of one of the authenticator's biometric component. -type StatusReport struct { - // Status of the authenticator. Additional fields MAY be set depending on this value. - Status string `json:"status"` - // ISO-8601 formatted date since when the status code was set, if applicable. If no date is given, the status is assumed to be effective while present. - EffectiveDate string `json:"effectiveDate"` - // Base64-encoded [RFC4648] (not base64url!) DER [ITU-X690-2008] PKIX certificate value related to the current status, if applicable. - Certificate string `json:"certificate"` - // HTTPS URL where additional information may be found related to the current status, if applicable. - URL string `json:"url"` - // Describes the externally visible aspects of the Authenticator Certification evaluation. - CertificationDescriptor string `json:"certificationDescriptor"` - // The unique identifier for the issued Certification. - CertificateNumber string `json:"certificateNumber"` - // The version of the Authenticator Certification Policy the implementation is Certified to, e.g. "1.0.0". - CertificationPolicyVersion string `json:"certificationPolicyVersion"` - // The Document Version of the Authenticator Security Requirements (DV) [FIDOAuthenticatorSecurityRequirements] the implementation is certified to, e.g. "1.2.0". - CertificationRequirementsVersion string `json:"certificationRequirementsVersion"` -} - -// BiometricStatusReport - Contains the current BiometricStatusReport of one of the authenticator's biometric component. -type BiometricStatusReport struct { - // Achieved level of the biometric certification of this biometric component of the authenticator - CertLevel uint16 `json:"certLevel"` - // A single USER_VERIFY constant indicating the modality of the biometric component - Modality uint32 `json:"modality"` - // ISO-8601 formatted date since when the certLevel achieved, if applicable. If no date is given, the status is assumed to be effective while present. - EffectiveDate string `json:"effectiveDate"` - // Describes the externally visible aspects of the Biometric Certification evaluation. - CertificationDescriptor string `json:"certificationDescriptor"` - // The unique identifier for the issued Biometric Certification. - CertificateNumber string `json:"certificateNumber"` - // The version of the Biometric Certification Policy the implementation is Certified to, e.g. "1.0.0". - CertificationPolicyVersion string `json:"certificationPolicyVersion"` - // The version of the Biometric Requirements [FIDOBiometricsRequirements] the implementation is certified to, e.g. "1.0.0". - CertificationRequirementsVersion string `json:"certificationRequirementsVersion"` -} - -// MetadataTOCPayloadEntry - Represents the MetadataTOCPayloadEntry -type MetadataTOCPayloadEntry struct { - // The AAID of the authenticator this metadata TOC payload entry relates to. - Aaid string `json:"aaid"` - // The Authenticator Attestation GUID. - AaGUID string `json:"aaguid"` - // A list of the attestation certificate public key identifiers encoded as hex string. - AttestationCertificateKeyIdentifiers []string `json:"attestationCertificateKeyIdentifiers"` - // The hash value computed over the base64url encoding of the UTF-8 representation of the JSON encoded metadata statement available at url and as defined in [FIDOMetadataStatement]. - Hash string `json:"hash"` - // Uniform resource locator (URL) of the encoded metadata statement for this authenticator model (identified by its AAID, AAGUID or attestationCertificateKeyIdentifier). - URL string `json:"url"` - // Status of the FIDO Biometric Certification of one or more biometric components of the Authenticator - BiometricStatusReports []BiometricStatusReport `json:"biometricStatusReports"` - // An array of status reports applicable to this authenticator. - StatusReports []StatusReport `json:"statusReports"` - // ISO-8601 formatted date since when the status report array was set to the current value. - TimeOfLastStatusChange string `json:"timeOfLastStatusChange"` - // URL of a list of rogue (i.e. untrusted) individual authenticators. - RogueListURL string `json:"rogueListURL"` - // The hash value computed over the Base64url encoding of the UTF-8 representation of the JSON encoded rogueList available at rogueListURL (with type rogueListEntry[]). - RogueListHash string `json:"rogueListHash"` - MetadataStatement MetadataStatement -} - // RogueListEntry - Contains a list of individual authenticators known to be rogue type RogueListEntry struct { // Base64url encoding of the rogue authenticator's secret key @@ -162,8 +185,8 @@ type RogueListEntry struct { Date string `json:"date"` } -// MetadataTOCPayload - Represents the MetadataTOCPayload -type MetadataTOCPayload struct { +// MetadataBLOBPayload - Represents the MetadataBLOBPayload +type MetadataBLOBPayload struct { // The legalHeader, if present, contains a legal guide for accessing and using metadata, which itself MAY contain URL(s) pointing to further information, such as a full Terms and Conditions statement. LegalHeader string `json:"legalHeader"` // The serial number of this UAF Metadata TOC Payload. Serial numbers MUST be consecutive and strictly monotonic, i.e. the successor TOC will have a no value exactly incremented by one. @@ -171,15 +194,7 @@ type MetadataTOCPayload struct { // ISO-8601 formatted date when the next update will be provided at latest. NextUpdate string `json:"nextUpdate"` // List of zero or more MetadataTOCPayloadEntry objects. - Entries []MetadataTOCPayloadEntry `json:"entries"` -} - -// Version - Represents a generic version with major and minor fields. -type Version struct { - // Major version. - Major uint16 `json:"major"` - // Minor version. - Minor uint16 `json:"minor"` + Entries []MetadataBLOBPayloadEntry `json:"entries"` } // CodeAccuracyDescriptor describes the relevant accuracy/complexity aspects of passcode user verification methods. @@ -227,7 +242,7 @@ type PatternAccuracyDescriptor struct { // VerificationMethodDescriptor - A descriptor for a specific base user verification method as implemented by the authenticator. type VerificationMethodDescriptor struct { // a single USER_VERIFY constant (see [FIDORegistry]), not a bit flag combination. This value MUST be non-zero. - UserVerification uint32 `json:"userVerification"` + UserVerificationMethod string `json:"userVerification"` // May optionally be used in the case of method USER_VERIFY_PASSCODE. CaDesc CodeAccuracyDescriptor `json:"caDesc"` // May optionally be used in the case of method USER_VERIFY_FINGERPRINT, USER_VERIFY_VOICEPRINT, USER_VERIFY_FACEPRINT, USER_VERIFY_EYEPRINT, or USER_VERIFY_HANDPRINT. @@ -236,13 +251,6 @@ type VerificationMethodDescriptor struct { PaDesc PatternAccuracyDescriptor `json:"paDesc"` } -// VerificationMethodANDCombinations MUST be non-empty. It is a list containing the base user verification methods which must be passed as part of a successful user verification. -type VerificationMethodANDCombinations struct { - //This list will contain only a single entry if using a single user verification method is sufficient. - // If this list contains multiple entries, then all of the listed user verification methods MUST be passed as part of the user verification process. - VerificationMethodAndCombinations []VerificationMethodDescriptor `json:"verificationMethodANDCombinations"` -} - // The rgbPaletteEntry is an RGB three-sample tuple palette entry type rgbPaletteEntry struct { // Red channel sample value @@ -276,9 +284,9 @@ type DisplayPNGCharacteristicsDescriptor struct { // EcdaaTrustAnchor - In the case of ECDAA attestation, the ECDAA-Issuer's trust anchor MUST be specified in this field. type EcdaaTrustAnchor struct { // base64url encoding of the result of ECPoint2ToB of the ECPoint2 X - X string `json:"x"` + X string `json:"X"` // base64url encoding of the result of ECPoint2ToB of the ECPoint2 Y - Y string `json:"y"` + Y string `json:"Y"` // base64url encoding of the result of BigNumberToB(c) C string `json:"c"` // base64url encoding of the result of BigNumberToB(sx) @@ -316,27 +324,21 @@ type MetadataStatement struct { // A list of human-readable short descriptions of the authenticator in different languages. AlternativeDescriptions map[string]string `json:"alternativeDescriptions"` // Earliest (i.e. lowest) trustworthy authenticatorVersion meeting the requirements specified in this metadata statement. - AuthenticatorVersion uint16 `json:"authenticatorVersion"` + AuthenticatorVersion uint32 `json:"authenticatorVersion"` // The FIDO protocol family. The values "uaf", "u2f", and "fido2" are supported. ProtocolFamily string `json:"protocolFamily"` // The FIDO unified protocol version(s) (related to the specific protocol family) supported by this authenticator. Upv []Version `json:"upv"` - // The assertion scheme supported by the authenticator. - AssertionScheme string `json:"assertionScheme"` - // The preferred authentication algorithm supported by the authenticator. - AuthenticationAlgorithm uint16 `json:"authenticationAlgorithm"` // The list of authentication algorithms supported by the authenticator. - AuthenticationAlgorithms []uint16 `json:"authenticationAlgorithms"` - // The preferred public key format used by the authenticator during registration operations. - PublicKeyAlgAndEncoding uint16 `json:"publicKeyAlgAndEncoding"` + AuthenticationAlgorithms []AuthenticationAlgorithm `json:"authenticationAlgorithms"` // The list of public key formats supported by the authenticator during registration operations. - PublicKeyAlgAndEncodings []uint16 `json:"publicKeyAlgAndEncodings"` + PublicKeyAlgAndEncodings []PublicKeyAlgAndEncoding `json:"publicKeyAlgAndEncodings"` // The supported attestation type(s). - AttestationTypes []uint16 `json:"attestationTypes"` + AttestationTypes []AuthenticatorAttestationType `json:"attestationTypes"` // A list of alternative VerificationMethodANDCombinations. UserVerificationDetails [][]VerificationMethodDescriptor `json:"userVerificationDetails"` // A 16-bit number representing the bit fields defined by the KEY_PROTECTION constants in the FIDO Registry of Predefined Values - KeyProtection uint16 `json:"keyProtection"` + KeyProtection []string `json:"keyProtection"` // This entry is set to true or it is ommitted, if the Uauth private key is restricted by the authenticator to only sign valid FIDO signature assertions. // This entry is set to false, if the authenticator doesn't restrict the Uauth key to only sign valid FIDO signature assertions. IsKeyRestricted bool `json:"isKeyRestricted"` @@ -344,17 +346,13 @@ type MetadataStatement struct { // This entry is set to false, if the Uauth key can be used without requiring a fresh user verification, e.g. without any additional user interaction, if the user was verified a (potentially configurable) caching time ago. IsFreshUserVerificationRequired bool `json:"isFreshUserVerificationRequired"` // A 16-bit number representing the bit fields defined by the MATCHER_PROTECTION constants in the FIDO Registry of Predefined Values - MatcherProtection uint16 `json:"matcherProtection"` + MatcherProtection []string `json:"matcherProtection"` // The authenticator's overall claimed cryptographic strength in bits (sometimes also called security strength or security level). CryptoStrength uint16 `json:"cryptoStrength"` - // Description of the particular operating environment that is used for the Authenticator. - OperatingEnv string `json:"operatingEnv"` // A 32-bit number representing the bit fields defined by the ATTACHMENT_HINT constants in the FIDO Registry of Predefined Values - AttachmentHint uint32 `json:"attachmentHint"` - // Indicates if the authenticator is designed to be used only as a second factor, i.e. requiring some other authentication method as a first factor (e.g. username+password). - IsSecondFactorOnly bool `json:"isSecondFactorOnly"` + AttachmentHint []string `json:"attachmentHint"` // A 16-bit number representing a combination of the bit flags defined by the TRANSACTION_CONFIRMATION_DISPLAY constants in the FIDO Registry of Predefined Values - TcDisplay uint16 `json:"tcDisplay"` + TcDisplay []string `json:"tcDisplay"` // Supported MIME content type [RFC2049] for the transaction confirmation display, such as text/plain or image/png. TcDisplayContentType string `json:"tcDisplayContentType"` // A list of alternative DisplayPNGCharacteristicsDescriptor. Each of these entries is one alternative of supported image characteristics for displaying a PNG image. @@ -370,6 +368,159 @@ type MetadataStatement struct { Icon string `json:"icon"` // List of extensions supported by the authenticator. SupportedExtensions []ExtensionDescriptor `json:"supportedExtensions"` + // Describes supported versions, extensions, AAGUID of the device and its capabilities + AuthenticatorGetInfo AuthenticatorGetInfo `json:"authenticatorGetInfo"` +} + +type AuthenticationAlgorithm string + +const ( + // An ECDSA signature on the NIST secp256r1 curve which must have raw R and S buffers, encoded in big-endian order. + ALG_SIGN_SECP256R1_ECDSA_SHA256_RAW AuthenticationAlgorithm = "secp256r1_ecdsa_sha256_raw" + // DER ITU-X690-2008 encoded ECDSA signature RFC5480 on the NIST secp256r1 curve. + ALG_SIGN_SECP256R1_ECDSA_SHA256_DER AuthenticationAlgorithm = "secp256r1_ecdsa_sha256_der" + // RSASSA-PSS RFC3447 signature must have raw S buffers, encoded in big-endian order RFC4055 RFC4056. + ALG_SIGN_RSASSA_PSS_SHA256_RAW AuthenticationAlgorithm = "rsassa_pss_sha256_raw" + // DER ITU-X690-2008 encoded OCTET STRING (not BIT STRING!) containing the RSASSA-PSS RFC3447 signature RFC4055 RFC4056. + ALG_SIGN_RSASSA_PSS_SHA256_DER AuthenticationAlgorithm = "rsassa_pss_sha256_der" + // An ECDSA signature on the secp256k1 curve which must have raw R and S buffers, encoded in big-endian order. + ALG_SIGN_SECP256K1_ECDSA_SHA256_RAW AuthenticationAlgorithm = "secp256k1_ecdsa_sha256_raw" + // DER ITU-X690-2008 encoded ECDSA signature RFC5480 on the secp256k1 curve. + ALG_SIGN_SECP256K1_ECDSA_SHA256_DER AuthenticationAlgorithm = "secp256k1_ecdsa_sha256_der" + // Chinese SM2 elliptic curve based signature algorithm combined with SM3 hash algorithm OSCCA-SM2 OSCCA-SM3. + ALG_SIGN_SM2_SM3_RAW AuthenticationAlgorithm = "sm2_sm3_raw" + // This is the EMSA-PKCS1-v1_5 signature as defined in RFC3447. + ALG_SIGN_RSA_EMSA_PKCS1_SHA256_RAW AuthenticationAlgorithm = "rsa_emsa_pkcs1_sha256_raw" + // DER ITU-X690-2008 encoded OCTET STRING (not BIT STRING!) containing the EMSA-PKCS1-v1_5 signature as defined in RFC3447. + ALG_SIGN_RSA_EMSA_PKCS1_SHA256_DER AuthenticationAlgorithm = "rsa_emsa_pkcs1_sha256_der" + // RSASSA-PSS RFC3447 signature must have raw S buffers, encoded in big-endian order RFC4055 RFC4056. + ALG_SIGN_RSASSA_PSS_SHA384_RAW AuthenticationAlgorithm = "rsassa_pss_sha384_raw" + // RSASSA-PSS RFC3447 signature must have raw S buffers, encoded in big-endian order RFC4055 RFC4056. + ALG_SIGN_RSASSA_PSS_SHA512_RAW AuthenticationAlgorithm = "rsassa_pss_sha512_raw" + // RSASSA-PKCS1-v1_5 RFC3447 with SHA256(aka RS256) signature must have raw S buffers, encoded in big-endian order RFC8017 RFC4056 + ALG_SIGN_RSASSA_PKCSV15_SHA256_RAW AuthenticationAlgorithm = "rsassa_pkcsv15_sha256_raw" + // RSASSA-PKCS1-v1_5 RFC3447 with SHA384(aka RS384) signature must have raw S buffers, encoded in big-endian order RFC8017 RFC4056 + ALG_SIGN_RSASSA_PKCSV15_SHA384_RAW AuthenticationAlgorithm = "rsassa_pkcsv15_sha384_raw" + // RSASSA-PKCS1-v1_5 RFC3447 with SHA512(aka RS512) signature must have raw S buffers, encoded in big-endian order RFC8017 RFC4056 + ALG_SIGN_RSASSA_PKCSV15_SHA512_RAW AuthenticationAlgorithm = "rsassa_pkcsv15_sha512_raw" + // RSASSA-PKCS1-v1_5 RFC3447 with SHA1(aka RS1) signature must have raw S buffers, encoded in big-endian order RFC8017 RFC4056 + ALG_SIGN_RSASSA_PKCSV15_SHA1_RAW AuthenticationAlgorithm = "rsassa_pkcsv15_sha1_raw" + // An ECDSA signature on the NIST secp384r1 curve with SHA384(aka: ES384) which must have raw R and S buffers, encoded in big-endian order. + ALG_SIGN_SECP384R1_ECDSA_SHA384_RAW AuthenticationAlgorithm = "secp384r1_ecdsa_sha384_raw" + // An ECDSA signature on the NIST secp512r1 curve with SHA512(aka: ES512) which must have raw R and S buffers, encoded in big-endian order. + ALG_SIGN_SECP521R1_ECDSA_SHA512_RAW AuthenticationAlgorithm = "secp521r1_ecdsa_sha512_raw" + // An EdDSA signature on the curve 25519, which must have raw R and S buffers, encoded in big-endian order. + ALG_SIGN_ED25519_EDDSA_SHA512_RAW AuthenticationAlgorithm = "ed25519_eddsa_sha512_raw" + // An EdDSA signature on the curve Ed448, which must have raw R and S buffers, encoded in big-endian order. + ALG_SIGN_ED448_EDDSA_SHA512_RAW AuthenticationAlgorithm = "ed448_eddsa_sha512_raw" +) + +// TODO: this goes away after webauthncose.CredentialPublicKey gets implemented +type algKeyCose struct { + KeyType webauthncose.COSEKeyType + Algorithm webauthncose.COSEAlgorithmIdentifier + Curve webauthncose.COSEEllipticCurve +} + +func algKeyCoseDictionary() func(AuthenticationAlgorithm) algKeyCose { + mapping := map[AuthenticationAlgorithm]algKeyCose{ + ALG_SIGN_SECP256R1_ECDSA_SHA256_RAW: {KeyType: webauthncose.EllipticKey, Algorithm: webauthncose.AlgES256, Curve: webauthncose.P256}, + ALG_SIGN_SECP256R1_ECDSA_SHA256_DER: {KeyType: webauthncose.EllipticKey, Algorithm: webauthncose.AlgES256, Curve: webauthncose.P256}, + ALG_SIGN_RSASSA_PSS_SHA256_RAW: {KeyType: webauthncose.RSAKey, Algorithm: webauthncose.AlgPS256}, + ALG_SIGN_RSASSA_PSS_SHA256_DER: {KeyType: webauthncose.RSAKey, Algorithm: webauthncose.AlgPS256}, + ALG_SIGN_SECP256K1_ECDSA_SHA256_RAW: {KeyType: webauthncose.EllipticKey, Algorithm: webauthncose.AlgES256K, Curve: webauthncose.Secp256k1}, + ALG_SIGN_SECP256K1_ECDSA_SHA256_DER: {KeyType: webauthncose.EllipticKey, Algorithm: webauthncose.AlgES256K, Curve: webauthncose.Secp256k1}, + ALG_SIGN_RSASSA_PSS_SHA384_RAW: {KeyType: webauthncose.RSAKey, Algorithm: webauthncose.AlgPS384}, + ALG_SIGN_RSASSA_PSS_SHA512_RAW: {KeyType: webauthncose.RSAKey, Algorithm: webauthncose.AlgPS512}, + ALG_SIGN_RSASSA_PKCSV15_SHA256_RAW: {KeyType: webauthncose.RSAKey, Algorithm: webauthncose.AlgRS256}, + ALG_SIGN_RSASSA_PKCSV15_SHA384_RAW: {KeyType: webauthncose.RSAKey, Algorithm: webauthncose.AlgRS384}, + ALG_SIGN_RSASSA_PKCSV15_SHA512_RAW: {KeyType: webauthncose.RSAKey, Algorithm: webauthncose.AlgRS512}, + ALG_SIGN_RSASSA_PKCSV15_SHA1_RAW: {KeyType: webauthncose.RSAKey, Algorithm: webauthncose.AlgRS1}, + ALG_SIGN_SECP384R1_ECDSA_SHA384_RAW: {KeyType: webauthncose.EllipticKey, Algorithm: webauthncose.AlgES384, Curve: webauthncose.P384}, + ALG_SIGN_SECP521R1_ECDSA_SHA512_RAW: {KeyType: webauthncose.EllipticKey, Algorithm: webauthncose.AlgES512, Curve: webauthncose.P521}, + ALG_SIGN_ED25519_EDDSA_SHA512_RAW: {KeyType: webauthncose.OctetKey, Algorithm: webauthncose.AlgEdDSA, Curve: webauthncose.Ed25519}, + ALG_SIGN_ED448_EDDSA_SHA512_RAW: {KeyType: webauthncose.OctetKey, Algorithm: webauthncose.AlgEdDSA, Curve: webauthncose.Ed448}, + } + return func(key AuthenticationAlgorithm) algKeyCose { + return mapping[key] + } +} + +func AlgKeyMatch(key algKeyCose, algs []AuthenticationAlgorithm) bool { + for _, alg := range algs { + if reflect.DeepEqual(algKeyCoseDictionary()(alg), key) { + return true + } + } + return false +} + +type PublicKeyAlgAndEncoding string + +const ( + // Raw ANSI X9.62 formatted Elliptic Curve public key. + ALG_KEY_ECC_X962_RAW PublicKeyAlgAndEncoding = "ecc_x962_raw" + // DER ITU-X690-2008 encoded ANSI X.9.62 formatted SubjectPublicKeyInfo RFC5480 specifying an elliptic curve public key. + ALG_KEY_ECC_X962_DER PublicKeyAlgAndEncoding = "ecc_x962_der" + // Raw encoded 2048-bit RSA public key RFC3447. + ALG_KEY_RSA_2048_RAW PublicKeyAlgAndEncoding = "rsa_2048_raw" + // ASN.1 DER [ITU-X690-2008] encoded 2048-bit RSA RFC3447 public key RFC4055. + ALG_KEY_RSA_2048_DER PublicKeyAlgAndEncoding = "rsa_2048_der" + // COSE_Key format, as defined in Section 7 of RFC8152. This encoding includes its own field for indicating the public key algorithm. + ALG_KEY_COSE PublicKeyAlgAndEncoding = "cose" +) + +// Version - Represents a generic version with major and minor fields. +type Version struct { + // Major version. + Major uint16 `json:"major"` + // Minor version. + Minor uint16 `json:"minor"` +} + +type AuthenticatorGetInfo struct { + // List of supported versions. + Versions []string `json:"versions"` + // List of supported extensions. + Extensions []string `json:"extensions"` + // The claimed AAGUID. + AaGUID string `json:"aaguid"` + // List of supported options. + Options map[string]bool `json:"options"` + // Maximum message size supported by the authenticator. + MaxMsgSize uint `json:"maxMsgSize"` + // List of supported PIN/UV auth protocols in order of decreasing authenticator preference. + PivUvAuthProtocols []uint `json:"pinUvAuthProtocols"` + // Maximum number of credentials supported in credentialID list at a time by the authenticator. + MaxCredentialCountInList uint `json:"maxCredentialCountInList"` + // Maximum Credential ID Length supported by the authenticator. + MaxCredentialIdLength uint `json:"maxCredentialLength"` + // List of supported transports. + Transports []string `json:"transports"` + // List of supported algorithms for credential generation, as specified in WebAuthn. + Algorithms []PublicKeyCredentialParameters `json:"algorithms"` + // The maximum size, in bytes, of the serialized large-blob array that this authenticator can store. + MaxSerializedLargeBlobArray uint `json:"maxSerializedLargeBlobArray"` + // If this member is present and set to true, the PIN must be changed. + ForcePINChange bool `json:"forcePINChange"` + // This specifies the current minimum PIN length, in Unicode code points, the authenticator enforces for ClientPIN. + MinPINLength uint `json:"minPINLength"` + // Indicates the firmware version of the authenticator model identified by AAGUID. + FirmwareVersion uint `json:"firmwareVersion"` + // Maximum credBlob length in bytes supported by the authenticator. + MaxCredBlobLength uint `json:"maxCredBlobLength"` + // This specifies the max number of RP IDs that authenticator can set via setMinPINLength subcommand. + MaxRPIDsForSetMinPINLength uint `json:"maxRPIDsForSetMinPINLength"` + // This specifies the preferred number of invocations of the getPinUvAuthTokenUsingUvWithPermissions subCommand the platform may attempt before falling back to the getPinUvAuthTokenUsingPinWithPermissions subCommand or displaying an error. + PreferredPlatformUvAttempts uint `json:"preferredPlatformUvAttempts"` + // This specifies the user verification modality supported by the authenticator via authenticatorClientPIN's getPinUvAuthTokenUsingUvWithPermissions subcommand. + UvModality uint `json:"uvModality"` + // This specifies a list of authenticator certifications. + Certifications map[string]float64 `json:"certifications"` + // If this member is present it indicates the estimated number of additional discoverable credentials that can be stored. + RemainingDiscoverableCredentials uint `json:"remainingDiscoverableCredentials"` + // If present the authenticator supports the authenticatorConfig vendorPrototype subcommand, and its value is a list of authenticatorConfig vendorCommandId values supported, which MAY be empty. + VendorPrototypeConfigCommands []uint `json:"vendorPrototypeConfigCommands"` } // MDSGetEndpointsRequest is the request sent to the conformance metadata getEndpoints endpoint @@ -386,24 +537,8 @@ type MDSGetEndpointsResponse struct { Result []string `json:"result"` } -// ProcessMDSTOC processes a FIDO metadata table of contents object per §3.1.8, steps 1 through 5 -// FIDO Authenticator Metadata Service -// https://fidoalliance.org/specs/fido-v2.0-rd-20180702/fido-metadata-service-v2.0-rd-20180702.html#metadata-toc-object-processing-rules -func ProcessMDSTOC(url string, suffix string, c http.Client) (MetadataTOCPayload, string, error) { - var tocAlg string - var payload MetadataTOCPayload - // 1. The FIDO Server MUST be able to download the latest metadata TOC object from the well-known URL, when appropriate. - body, err := downloadBytes(url+suffix, c) - if err != nil { - return payload, tocAlg, err - } - // Steps 2 - 4 done in unmarshalMDSTOC. Caller is responsible for step 5. - return unmarshalMDSTOC(body, c) -} - -func unmarshalMDSTOC(body []byte, c http.Client) (MetadataTOCPayload, string, error) { - var tocAlg string - var payload MetadataTOCPayload +func unmarshalMDSBLOB(body []byte, c http.Client) (MetadataBLOBPayload, error) { + var payload MetadataBLOBPayload token, err := jwt.Parse(string(body), func(token *jwt.Token) (interface{}, error) { // 2. If the x5u attribute is present in the JWT Header, then if _, ok := token.Header["x5u"].([]interface{}); ok { @@ -415,11 +550,7 @@ func unmarshalMDSTOC(body []byte, c http.Client) (MetadataTOCPayload, string, er if x5c, ok := token.Header["x5c"].([]interface{}); !ok { // If that attribute is missing as well, Metadata TOC signing trust anchor is considered the TOC signing certificate chain. - root, err := getMetdataTOCSigningTrustAnchor(c) - if nil != err { - return nil, err - } - chain[0] = root + chain[0] = MDSRoot } else { chain = x5c } @@ -435,6 +566,9 @@ func unmarshalMDSTOC(body []byte, c http.Client) (MetadataTOCPayload, string, er o := make([]byte, base64.StdEncoding.DecodedLen(len(chain[0].(string)))) // base64 decode the certificate into the buffer n, err := base64.StdEncoding.Decode(o, []byte(chain[0].(string))) + if err != nil { + return nil, err + } // parse the certificate from the buffer cert, err := x509.ParseCertificate(o[:n]) if err != nil { @@ -445,38 +579,28 @@ func unmarshalMDSTOC(body []byte, c http.Client) (MetadataTOCPayload, string, er return cert.PublicKey, err }) if err != nil { - return payload, tocAlg, err + return payload, err } - tocAlg = token.Header["alg"].(string) err = mapstructure.Decode(token.Claims, &payload) - return payload, tocAlg, err -} - -func getMetdataTOCSigningTrustAnchor(c http.Client) ([]byte, error) { - rooturl := "" - if Conformance { - rooturl = "https://fidoalliance.co.nz/mds/pki/MDSROOT.crt" - } else { - rooturl = "https://mds.fidoalliance.org/Root.cer" - } - - return downloadBytes(rooturl, c) + return payload, err } func validateChain(chain []interface{}, c http.Client) (bool, error) { - root, err := getMetdataTOCSigningTrustAnchor(c) + oRoot := make([]byte, base64.StdEncoding.DecodedLen(len(MDSRoot))) + nRoot, err := base64.StdEncoding.Decode(oRoot, []byte(MDSRoot)) + if err != nil { + return false, err + } + rootcert, err := x509.ParseCertificate(oRoot[:nRoot]) if err != nil { return false, err } roots := x509.NewCertPool() - ok := roots.AppendCertsFromPEM(root) - if !ok { - return false, err - } + roots.AddCert(rootcert) o := make([]byte, base64.StdEncoding.DecodedLen(len(chain[1].(string)))) n, err := base64.StdEncoding.Decode(o, []byte(chain[1].(string))) @@ -489,7 +613,10 @@ func validateChain(chain []interface{}, c http.Client) (bool, error) { } if revoked, ok := revoke.VerifyCertificate(intcert); !ok { - return false, errCRLUnavailable + issuer := intcert.IssuingCertificateURL + if issuer != nil { + return false, errCRLUnavailable + } } else if revoked { return false, errIntermediateCertRevoked } @@ -520,69 +647,6 @@ func validateChain(chain []interface{}, c http.Client) (bool, error) { return err == nil, err } -// GetMetadataStatement iterates through a list of payload entries within a FIDO metadata table of contents object per §3.1.8, step 6 -// FIDO Authenticator Metadata Service -// https://fidoalliance.org/specs/fido-v2.0-rd-20180702/fido-metadata-service-v2.0-rd-20180702.html#metadata-toc-object-processing-rules -func GetMetadataStatement(entry MetadataTOCPayloadEntry, suffix string, alg string, c http.Client) (MetadataStatement, error) { - var statement MetadataStatement - // 1. Ignore the entry if the AAID, AAGUID or attestationCertificateKeyIdentifiers is not relevant to the relying party (e.g. not acceptable by any policy) - // Caller is responsible for determining if entry is relevant. - - // 2. Download the metadata statement from the URL specified by the field url. - body, err := downloadBytes(entry.URL+suffix, c) - if err != nil { - return statement, err - } - // 3. Check whether the status report of the authenticator model has changed compared to the cached entry by looking at the fields timeOfLastStatusChange and statusReport. - // Caller is responsible for cache - - // step 4 done in unmarshalMetadataStatement, caller is responsible for step 5 - return unmarshalMetadataStatement(body, entry.Hash) -} - -func unmarshalMetadataStatement(body []byte, hash string) (MetadataStatement, error) { - // 4. Compute the hash value of the metadata statement downloaded from the URL and verify the hash value to the hash specified in the field hash of the metadata TOC object. - var statement MetadataStatement - - entryHash, err := base64.URLEncoding.DecodeString(hash) - if err != nil { - entryHash, err = base64.RawURLEncoding.DecodeString(hash) - } - if err != nil { - return statement, err - } - - // TODO: Get hasher based on MDS TOC alg instead of assuming SHA256 - hasher := crypto.SHA256.New() - _, _ = hasher.Write(body) - hashed := hasher.Sum(nil) - // Ignore the downloaded metadata statement if the hash value doesn't match. - if !bytes.Equal(hashed, entryHash) { - return statement, errHashValueMismatch - } - - // Extract the metadata statement from base64 encoded form - n := base64.URLEncoding.DecodedLen(len(body)) - out := make([]byte, n) - m, err := base64.URLEncoding.Decode(out, body) - if err != nil { - return statement, err - } - // Unmarshal the metadata statement into a MetadataStatement structure and return it to caller - err = json.Unmarshal(out[:m], &statement) - return statement, err -} - -func downloadBytes(url string, c http.Client) ([]byte, error) { - res, err := c.Get(url) - if err != nil { - return nil, err - } - defer res.Body.Close() - body, _ := ioutil.ReadAll(res.Body) - return body, err -} - type MetadataError struct { // Short name for the type of error that has occurred Type string `json:"type"` @@ -593,10 +657,6 @@ type MetadataError struct { } var ( - errHashValueMismatch = &MetadataError{ - Type: "hash_mismatch", - Details: "Hash value mismatch between entry.Hash and downloaded bytes", - } errIntermediateCertRevoked = &MetadataError{ Type: "intermediate_revoked", Details: "Intermediate certificate is on issuers revocation list", diff --git a/metadata/metadata_test.go b/metadata/metadata_test.go index 42288fda..402e85a1 100644 --- a/metadata/metadata_test.go +++ b/metadata/metadata_test.go @@ -1,98 +1,345 @@ package metadata import ( - "io/ioutil" + "bytes" + "encoding/json" + "io" "net/http" "testing" "time" - "github.com/golang-jwt/jwt/v4" + "github.com/go-webauthn/webauthn/protocol/webauthncose" + "github.com/google/uuid" ) -func TestMetadataTOCParsing(t *testing.T) { +func downloadBytes(url string, c http.Client) ([]byte, error) { + res, err := c.Get(url) + if err != nil { + return nil, err + } + defer res.Body.Close() + body, _ := io.ReadAll(res.Body) + return body, err +} + +func getEndpoints(c http.Client) ([]string, error) { + jsonReq, err := json.Marshal(MDSGetEndpointsRequest{Endpoint: "https://webauthn.io"}) + if err != nil { + return nil, err + } + + req, err := c.Post("https://mds3.certinfra.fidoalliance.org/getEndpoints", "application/json", bytes.NewBuffer(jsonReq)) + if err != nil { + return nil, err + } + + defer req.Body.Close() + body, _ := io.ReadAll(req.Body) + + var resp MDSGetEndpointsResponse + + err = json.Unmarshal(body, &resp) + if err != nil { + return nil, err + } + return resp.Result, err +} + +func getTestMetadata(s string, c http.Client) (MetadataStatement, error) { + var statement MetadataStatement + + // MDSGetEndpointsRequest is the request sent to the conformance metadata getEndpoints endpoint + type MDSGetTestMetadata struct { + // The URL of the local server endpoint, e.g. https://webauthn.io/ + Endpoint string `json:"endpoint"` + TestCase string `json:"testcase"` + } + + jsonReq, err := json.Marshal(MDSGetTestMetadata{Endpoint: "https://webauthn.io", TestCase: s}) + if err != nil { + return statement, err + } + + req, err := c.Post("https://mds3.certinfra.fidoalliance.org/getTestMetadata", "application/json", bytes.NewBuffer(jsonReq)) + if err != nil { + return statement, err + } + + defer req.Body.Close() + body, err := io.ReadAll(req.Body) + if err != nil { + return statement, err + } + + type ConformanceResponse struct { + Status string `json:"status"` + Result MetadataStatement `json:"result"` + } + + var resp ConformanceResponse + err = json.Unmarshal(body, &resp) + if err != nil { + return statement, err + } + + statement = resp.Result + return statement, err +} + +func TestProductionMetadataTOCParsing(t *testing.T) { + httpClient := &http.Client{ + Timeout: time.Second * 30, + } + bytes, err := downloadBytes("https://mds.fidoalliance.org/", *httpClient) + if err != nil { + t.Fatal(err) + } + _, err = unmarshalMDSBLOB(bytes, *httpClient) + if err != nil { + t.Fail() + } +} + +func TestConformanceMetadataTOCParsing(t *testing.T) { + MDSRoot = ConformanceMDSRoot Conformance = true httpClient := &http.Client{ Timeout: time.Second * 30, } tests := []struct { - name string - file string - wantErr error + name string + pass bool }{ { - "success", - "../testdata/MetadataTOCParsing-P1.jwt", - nil, + "fido2_good", + true, + }, + { + "fido2_badReports", + false, }, { - "verification_failure", - "../testdata/MetadataTOCParsing-F1.jwt", - errIntermediateCertRevoked, + "fido2_badSignature", + false, }, { - "intermediate_revoked", - "../testdata/MetadataTOCParsing-F2.jwt", - jwt.ErrECDSAVerification, + "fido2_badCertificateChain", + false, }, { - "leaf_revoked", - "../testdata/MetadataTOCParsing-F3.jwt", - errLeafCertRevoked, + "fido2_intermediateCertificateRevoked", + false, }, { - "asn1_parse_error", - "../testdata/MetadataTOCParsing-F4.jwt", - errCRLUnavailable, + "fido2_subjectCertificateRevoked", + false, }, } + endpoints, err := getEndpoints(*httpClient) + if err != nil { + t.Fatal(err) + } + + for _, endpoint := range endpoints { + bytes, err := downloadBytes(endpoint, *httpClient) + if err != nil { + t.Fatal(err) + } + + blob, err := unmarshalMDSBLOB(bytes, *httpClient) + if err != nil { + if me, ok := err.(*MetadataError); ok { + t.Log(me.Details) + } + } + for _, entry := range blob.Entries { + aaguid, _ := uuid.Parse(entry.AaGUID) + Metadata[aaguid] = entry + } + } + for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - b, _ := ioutil.ReadFile(tt.file) - _, _, err := unmarshalMDSTOC(b, *httpClient) - failed := true - if tt.wantErr == nil { - failed = err != nil - } else if err != nil { - failed = (err.Error() != tt.wantErr.Error()) - } else { - failed = tt.wantErr != nil + statement, err := getTestMetadata(tt.name, *httpClient) + if err != nil { + t.Fatal(err) } - if failed { - t.Errorf("unmarshalMDSTOC() got %v, wanted %v", err, tt.wantErr) + aaguid, _ := uuid.Parse(statement.AaGUID) + if meta, ok := Metadata[aaguid]; ok { + if tt.pass { + t.Logf("Found aaguid %s in test metadata", meta.AaGUID) + } else { + if IsUndesiredAuthenticatorStatus(AuthenticatorStatus(meta.StatusReports[0].Status)) { + t.Logf("Found authenticator %s with bad status in test metadata, %s", meta.AaGUID, meta.StatusReports[0].Status) + } else { + t.Fail() + } + } + } else { + if !tt.pass { + t.Logf("Metadata for aaguid %s not found in test metadata", statement.AaGUID) + } else { + t.Fail() + } } }) } } -func TestMetadataStatementParsing(t *testing.T) { +const ( + exampleMetadataBLOB = "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.{"legalHeader":"Retrieval and use of this BLOB indicates acceptance of the appropriate agreement located at https://fidoalliance.org/metadata/metadata-legal-terms/","no":15,"nextUpdate":"2020-03-30","entries":[{"aaid":"1234#5678","metadataStatement":{"legalHeader":"https://fidoalliance.org/metadata/metadata-statement-legal-header/","description":"FIDO Alliance Sample UAF Authenticator","aaid":"1234#5678","alternativeDescriptions":{"ru-RU":"Пример UAF аутентификатора от FIDO Alliance","fr-FR":"Exemple UAF authenticator de FIDO Alliance"},"authenticatorVersion":2,"protocolFamily":"uaf","schema":3,"upv":[{"major":1,"minor":0},{"major":1,"minor":1}],"authenticationAlgorithms":["secp256r1_ecdsa_sha256_raw"],"publicKeyAlgAndEncodings":["ecc_x962_raw"],"attestationTypes":["basic_full"],"userVerificationDetails":[[{"userVerificationMethod":"fingerprint_internal","baDesc":{"selfAttestedFAR":0.00002,"maxRetries":5,"blockSlowdown":30,"maxTemplates":5}}]],"keyProtection":["hardware","tee"],"isKeyRestricted":true,"matcherProtection":["tee"],"cryptoStrength":128,"attachmentHint":["internal"],"tcDisplay":["any","tee"],"tcDisplayContentType":"image/png","tcDisplayPNGCharacteristics":[{"width":320,"height":480,"bitDepth":16,"colorType":2,"compression":0,"filter":0,"interlace":0}],"attestationRootCertificates":["MIICPTCCAeOgAwIBAgIJAOuexvU3Oy2wMAoGCCqGSM49BAMCMHsxIDAeBgNVBAMMF1NhbXBsZSBBdHRlc3RhdGlvbiBSb290MRYwFAYDVQQKDA1GSURPIEFsbGlhbmNlMREwDwYDVQQLDAhVQUYgVFdHLDESMBAGA1UEBwwJUGFsbyBBbHRvMQswCQYDVQQIDAJDQTELMAkGA1UEBhMCVVMwHhcNMTQwNjE4MTMzMzMyWhcNNDExMTAzMTMzMzMyWjB7MSAwHgYDVQQDDBdTYW1wbGUgQXR0ZXN0YXRpb24gUm9vdDEWMBQGA1UECgwNRklETyBBbGxpYW5jZTERMA8GA1UECwwIVUFGIFRXRywxEjAQBgNVBAcMCVBhbG8gQWx0bzELMAkGA1UECAwCQ0ExCzAJBgNVBAYTAlVTMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEH8hv2D0HXa59/BmpQ7RZehL/FMGzFd1QBg9vAUpOZ3ajnuQ94PR7aMzH33nUSBr8fHYDrqOBb58pxGqHJRyX/6NQME4wHQYDVR0OBBYEFPoHA3CLhxFbC0It7zE4w8hk5EJ/MB8GA1UdIwQYMBaAFPoHA3CLhxFbC0It7zE4w8hk5EJ/MAwGA1UdEwQFMAMBAf8wCgYIKoZIzj0EAwIDSAAwRQIhAJ06QSXt9ihIbEKYKIjsPkriVdLIgtfsbDSu7ErJfzr4AiBqoYCZf0+zI55aQeAHjIzA9Xm63rruAxBZ9ps9z2XNlQ=="],"icon":"data:image/png;base64,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"},"statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2014-01-04"}],"timeOfLastStatusChange":"2014-01-04"},{"aaguid":"0132d110-bf4e-4208-a403-ab4f5f12efe5","metadataStatement":{"legalHeader":"https://fidoalliance.org/metadata/metadata-statement-legal-header/","description":"FIDO Alliance Sample FIDO2 Authenticator","aaguid":"0132d110-bf4e-4208-a403-ab4f5f12efe5","alternativeDescriptions":{"ru-RU":"Пример FIDO2 аутентификатора от FIDO Alliance","fr-FR":"Exemple FIDO2 authenticator de FIDO Alliance","zh-CN":"來自FIDO Alliance的示例FIDO2身份驗證器"},"protocolFamily":"fido2","schema":3,"authenticatorVersion":5,"upv":[{"major":1,"minor":0}],"authenticationAlgorithms":["secp256r1_ecdsa_sha256_raw","rsassa_pkcsv15_sha256_raw"],"publicKeyAlgAndEncodings":["cose"],"attestationTypes":["basic_full"],"userVerificationDetails":[[{"userVerificationMethod":"none"}],[{"userVerificationMethod":"presence_internal"}],[{"userVerificationMethod":"passcode_external","caDesc":{"base":10,"minLength":4}}],[{"userVerificationMethod":"passcode_external","caDesc":{"base":10,"minLength":4}},{"userVerificationMethod":"presence_internal"}]],"keyProtection":["hardware","secure_element"],"matcherProtection":["on_chip"],"cryptoStrength":128,"attachmentHint":["external","wired","wireless","nfc"],"tcDisplay":[],"attestationRootCertificates":["MIICPTCCAeOgAwIBAgIJAOuexvU3Oy2wMAoGCCqGSM49BAMCMHsxIDAeBgNVBAMMF1NhbXBsZSBBdHRlc3RhdGlvbiBSb290MRYwFAYDVQQKDA1GSURPIEFsbGlhbmNlMREwDwYDVQQLDAhVQUYgVFdHLDESMBAGA1UEBwwJUGFsbyBBbHRvMQswCQYDVQQIDAJDQTELMAkGA1UEBhMCVVMwHhcNMTQwNjE4MTMzMzMyWhcNNDExMTAzMTMzMzMyWjB7MSAwHgYDVQQDDBdTYW1wbGUgQXR0ZXN0YXRpb24gUm9vdDEWMBQGA1UECgwNRklETyBBbGxpYW5jZTERMA8GA1UECwwIVUFGIFRXRywxEjAQBgNVBAcMCVBhbG8gQWx0bzELMAkGA1UECAwCQ0ExCzAJBgNVBAYTAlVTMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEH8hv2D0HXa59/BmpQ7RZehL/FMGzFd1QBg9vAUpOZ3ajnuQ94PR7aMzH33nUSBr8fHYDrqOBb58pxGqHJRyX/6NQME4wHQYDVR0OBBYEFPoHA3CLhxFbC0It7zE4w8hk5EJ/MB8GA1UdIwQYMBaAFPoHA3CLhxFbC0It7zE4w8hk5EJ/MAwGA1UdEwQFMAMBAf8wCgYIKoZIzj0EAwIDSAAwRQIhAJ06QSXt9ihIbEKYKIjsPkriVdLIgtfsbDSu7ErJfzr4AiBqoYCZf0+zI55aQeAHjIzA9Xm63rruAxBZ9ps9z2XNlQ=="],"icon":"data:image/png;base64,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","supportedExtensions":[{"id":"hmac-secret","fail_if_unknown":false},{"id":"credProtect","fail_if_unknown":false}],"authenticatorGetInfo":{"versions":["U2F_V2","FIDO_2_0"],"extensions":["credProtect","hmac-secret"],"aaguid":"0132d110bf4e4208a403ab4f5f12efe5","options":{"plat":false,"rk":true,"clientPin":true,"up":true,"uv":true,"uvToken":false,"config":false},"maxMsgSize":1200,"pinUvAuthProtocols":[1],"maxCredentialCountInList":16,"maxCredentialIdLength":128,"transports":["usb","nfc"],"algorithms":[{"type":"public-key","alg":-7},{"type":"public-key","alg":-257}],"maxAuthenticatorConfigLength":1024,"defaultCredProtect":2,"firmwareVersion":5}},"statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2019-01-04"},{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2020-11-19","certificationDescriptor":"FIDO Alliance Sample FIDO2 Authenticator","certificateNumber":"FIDO2100020151221001","certificationPolicyVersion":"1.0.1","certificationRequirementsVersion":"1.0.1"}],"timeOfLastStatusChange":"2019-01-04"}]}._tmf5mXw0RPlK3RgYlMqmtog9wsHjY-BjHGSZrrDhTrFwHj-g5CiG-AXgNnHLUHEm2_2DOJonEte7PbJEkeLeA" +) + +func TestExampleMetadataTOCParsing(t *testing.T) { + MDSRoot = ExampleMDSRoot + httpClient := &http.Client{ + Timeout: time.Second * 30, + } + exampleMetadataBLOBBytes := bytes.NewBufferString(exampleMetadataBLOB) + _, err := unmarshalMDSBLOB(exampleMetadataBLOBBytes.Bytes(), *httpClient) + if err != nil { + t.Fail() + } +} + +func TestIsUndesiredAuthenticatorStatus(t *testing.T) { tests := []struct { - name string - file string - hash string - wantErr error + status AuthenticatorStatus + fail bool }{ { - "success", - "../testdata/TestMetadataStatementParsing-P1.json", - "bEtEyoVkc-X-ypuFoAIj8s4xKKTZw3wzD7IuDnoBUE8", - nil, + NotFidoCertified, + false, }, { - "hash_value_mismatch", - "../testdata/TestMetadataStatementParsing-F1.json", - "eq28frELluGyBesOw_xE_10Tj25NG0pDS7Oa0DP2kVk", - errHashValueMismatch, + FidoCertified, + false, + }, + { + UserVerificationBypass, + true, + }, + { + AttestationKeyCompromise, + true, + }, + { + UserKeyRemoteCompromise, + true, + }, + { + UserKeyPhysicalCompromise, + true, + }, + { + UpdateAvailable, + false, + }, + { + Revoked, + true, + }, + { + SelfAssertionSubmitted, + false, + }, + { + FidoCertifiedL1, + false, + }, + { + FidoCertifiedL1plus, + false, + }, + { + FidoCertifiedL2, + false, + }, + { + FidoCertifiedL2plus, + false, + }, + { + FidoCertifiedL3, + false, + }, + { + FidoCertifiedL3plus, + false, }, } for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - b, _ := ioutil.ReadFile(tt.file) - _, err := unmarshalMetadataStatement(b, tt.hash) - if err != tt.wantErr { - t.Errorf("unmarshalMetadataStatement() error %v, wantErr %v", err, tt.wantErr) + t.Run(string(tt.status), func(t *testing.T) { + if tt.fail != IsUndesiredAuthenticatorStatus(tt.status) { + t.Fail() + } + }) + } +} + +func TestAlgKeyMatch(t *testing.T) { + tests := []struct { + name string + alg algKeyCose + algs []AuthenticationAlgorithm + fail bool + }{ + { + "Positive match RS256", + algKeyCose{KeyType: webauthncose.RSAKey, Algorithm: webauthncose.AlgRS256}, + []AuthenticationAlgorithm{ALG_SIGN_RSASSA_PKCSV15_SHA256_RAW}, + true, + }, + { + "Positive match ES256", + algKeyCose{KeyType: webauthncose.EllipticKey, Algorithm: webauthncose.AlgES256, Curve: webauthncose.P256}, + []AuthenticationAlgorithm{ALG_SIGN_SECP256R1_ECDSA_SHA256_RAW, ALG_SIGN_SECP256R1_ECDSA_SHA256_DER}, + true, + }, + { + "Positive match Ed25519", + algKeyCose{KeyType: webauthncose.OctetKey, Algorithm: webauthncose.AlgEdDSA, Curve: webauthncose.Ed25519}, + []AuthenticationAlgorithm{ALG_SIGN_SECP256R1_ECDSA_SHA256_RAW, ALG_SIGN_ED25519_EDDSA_SHA512_RAW}, + true, + }, + { + "Negative match Ed25519, array missing Ed25519", + algKeyCose{KeyType: webauthncose.OctetKey, Algorithm: webauthncose.AlgEdDSA, Curve: webauthncose.Ed25519}, + []AuthenticationAlgorithm{ALG_SIGN_RSASSA_PKCSV15_SHA256_RAW, ALG_SIGN_SECP256R1_ECDSA_SHA256_RAW, ALG_SIGN_SECP256R1_ECDSA_SHA256_DER}, + false, + }, + { + "Negative match RS256, array missing RS256", + algKeyCose{KeyType: webauthncose.RSAKey, Algorithm: webauthncose.AlgRS256}, + []AuthenticationAlgorithm{ALG_SIGN_SECP256R1_ECDSA_SHA256_RAW, ALG_SIGN_SECP256R1_ECDSA_SHA256_DER, ALG_SIGN_ED25519_EDDSA_SHA512_RAW}, + false, + }, + { + "Negative match ES256, array missing ES256", + algKeyCose{KeyType: webauthncose.EllipticKey, Algorithm: webauthncose.AlgES256}, + []AuthenticationAlgorithm{ALG_SIGN_RSASSA_PKCSV15_SHA256_RAW, ALG_SIGN_ED25519_EDDSA_SHA512_RAW}, + false, + }, + { + "Negative match, curve/alg mismatch", + algKeyCose{KeyType: webauthncose.EllipticKey, Algorithm: webauthncose.AlgES256, Curve: webauthncose.P384}, + []AuthenticationAlgorithm{ALG_SIGN_SECP256R1_ECDSA_SHA256_RAW, ALG_SIGN_SECP256R1_ECDSA_SHA256_DER, ALG_SIGN_SECP384R1_ECDSA_SHA384_RAW}, + false, + }, + { + "Negative match, kty/crv mismatch", + algKeyCose{KeyType: webauthncose.RSAKey, Algorithm: webauthncose.AlgRS256, Curve: webauthncose.P256}, + []AuthenticationAlgorithm{ALG_SIGN_SECP256R1_ECDSA_SHA256_RAW, ALG_SIGN_SECP256R1_ECDSA_SHA256_DER, ALG_SIGN_SECP384R1_ECDSA_SHA384_RAW}, + false, + }, + } + for _, tt := range tests { + t.Run(string(tt.name), func(t *testing.T) { + if tt.fail != AlgKeyMatch(tt.alg, tt.algs) { + t.Fail() } }) } diff --git a/protocol/attestation.go b/protocol/attestation.go index 6e632715..4da9c282 100644 --- a/protocol/attestation.go +++ b/protocol/attestation.go @@ -2,10 +2,13 @@ package protocol import ( "crypto/sha256" + "crypto/x509" "encoding/json" "fmt" + "github.com/go-webauthn/webauthn/metadata" "github.com/go-webauthn/webauthn/protocol/webauthncbor" + "github.com/google/uuid" ) // From §5.2.1 (https://www.w3.org/TR/webauthn/#authenticatorattestationresponse) @@ -52,7 +55,6 @@ type ParsedAttestationResponse struct { // perform self attestation of the credential public key with the corresponding credential private key. // All this information is returned by authenticators any time a new public key credential is generated, in // the overall form of an attestation object. (https://www.w3.org/TR/webauthn/#attestation-object) -// type AttestationObject struct { // The authenticator data, including the newly created public key. See AuthenticatorData for more info AuthData AuthenticatorData @@ -147,10 +149,44 @@ func (attestationObject *AttestationObject) Verify(relyingPartyID string, client // Step 14. Verify that attStmt is a correct attestation statement, conveying a valid attestation signature, by using // the attestation statement format fmt’s verification procedure given attStmt, authData and the hash of the serialized // client data computed in step 7. - attestationType, _, err := formatHandler(*attestationObject, clientDataHash) + attestationType, x5c, err := formatHandler(*attestationObject, clientDataHash) if err != nil { return err.(*Error).WithInfo(attestationType) } + uuid, err := uuid.FromBytes(attestationObject.AuthData.AttData.AAGUID) + if err != nil { + return err + } + if meta, ok := metadata.Metadata[uuid]; ok { + for _, s := range meta.StatusReports { + if metadata.IsUndesiredAuthenticatorStatus(s.Status) { + return ErrInvalidAttestation.WithDetails("Authenticator with undesirable status encountered") + } + } + + if x5c != nil { + attestnCert, err := x509.ParseCertificate(x5c[0].([]byte)) + if err != nil { + return ErrInvalidAttestation.WithDetails("Unable to parse attestation certificate from x5c") + } + if attestnCert.Subject.CommonName != attestnCert.Issuer.CommonName { + var hasBasicFull = false + for _, a := range meta.MetadataStatement.AttestationTypes { + if metadata.AuthenticatorAttestationType(a) == metadata.BasicFull { + hasBasicFull = true + } + } + if !hasBasicFull { + return ErrInvalidAttestation.WithDetails("Attestation with full attestation from authentictor that does not support full attestation") + } + } + } + } else { + if metadata.Conformance { + return ErrInvalidAttestation.WithDetails(fmt.Sprintf("AAGUID %s not found in metadata during conformance testing", uuid.String())) + } + } + return nil } diff --git a/protocol/attestation_androidkey.go b/protocol/attestation_androidkey.go index fc6f07b5..9aed5b37 100644 --- a/protocol/attestation_androidkey.go +++ b/protocol/attestation_androidkey.go @@ -6,6 +6,7 @@ import ( "encoding/asn1" "fmt" + "github.com/go-webauthn/webauthn/metadata" "github.com/go-webauthn/webauthn/protocol/webauthncose" ) @@ -38,51 +39,51 @@ func verifyAndroidKeyFormat(att AttestationObject, clientDataHash []byte) (strin // used to generate the attestation signature. alg, present := att.AttStatement["alg"].(int64) if !present { - return androidAttestationKey, nil, ErrAttestationFormat.WithDetails("Error retreiving alg value") + return "", nil, ErrAttestationFormat.WithDetails("Error retreiving alg value") } // Get the sig value - A byte string containing the attestation signature. sig, present := att.AttStatement["sig"].([]byte) if !present { - return androidAttestationKey, nil, ErrAttestationFormat.WithDetails("Error retreiving sig value") + return "", nil, ErrAttestationFormat.WithDetails("Error retreiving sig value") } // If x5c is not present, return an error x5c, x509present := att.AttStatement["x5c"].([]interface{}) if !x509present { // Handle Basic Attestation steps for the x509 Certificate - return androidAttestationKey, nil, ErrAttestationFormat.WithDetails("Error retreiving x5c value") + return "", nil, ErrAttestationFormat.WithDetails("Error retreiving x5c value") } // §8.4.2. Verify that sig is a valid signature over the concatenation of authenticatorData and clientDataHash // using the public key in the first certificate in x5c with the algorithm specified in alg. attCertBytes, valid := x5c[0].([]byte) if !valid { - return androidAttestationKey, nil, ErrAttestation.WithDetails("Error getting certificate from x5c cert chain") + return "", nil, ErrAttestation.WithDetails("Error getting certificate from x5c cert chain") } signatureData := append(att.RawAuthData, clientDataHash...) attCert, err := x509.ParseCertificate(attCertBytes) if err != nil { - return androidAttestationKey, nil, ErrAttestationFormat.WithDetails(fmt.Sprintf("Error parsing certificate from ASN.1 data: %+v", err)) + return "", nil, ErrAttestationFormat.WithDetails(fmt.Sprintf("Error parsing certificate from ASN.1 data: %+v", err)) } coseAlg := webauthncose.COSEAlgorithmIdentifier(alg) sigAlg := webauthncose.SigAlgFromCOSEAlg(coseAlg) - - if err = attCert.CheckSignature(x509.SignatureAlgorithm(sigAlg), signatureData, sig); err != nil { - return androidAttestationKey, nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Signature validation error: %+v", err)) + err = attCert.CheckSignature(x509.SignatureAlgorithm(sigAlg), signatureData, sig) + if err != nil { + return "", nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Signature validation error: %+v\n", err)) } // Verify that the public key in the first certificate in x5c matches the credentialPublicKey in the attestedCredentialData in authenticatorData. pubKey, err := webauthncose.ParsePublicKey(att.AuthData.AttData.CredentialPublicKey) if err != nil { - return androidAttestationKey, nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Error parsing public key: %+v", err)) + return "", nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Error parsing public key: %+v\n", err)) } e := pubKey.(webauthncose.EC2PublicKeyData) valid, err = e.Verify(signatureData, sig) - if err != nil || !valid { - return androidAttestationKey, nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Error parsing public key: %+v", err)) + if err != nil || valid != true { + return "", nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Error parsing public key: %+v\n", err)) } // §8.4.3. Verify that the attestationChallenge field in the attestation certificate extension data is identical to clientDataHash. // attCert.Extensions @@ -93,33 +94,33 @@ func verifyAndroidKeyFormat(att AttestationObject, clientDataHash []byte) (strin } } if len(attExtBytes) == 0 { - return androidAttestationKey, nil, ErrAttestationFormat.WithDetails("Attestation certificate extensions missing 1.3.6.1.4.1.11129.2.1.17") + return "", nil, ErrAttestationFormat.WithDetails("Attestation certificate extensions missing 1.3.6.1.4.1.11129.2.1.17") } // As noted in §8.4.1 (https://w3c.github.io/webauthn/#key-attstn-cert-requirements) the Android Key Attestation attestation certificate's // android key attestation certificate extension data is identified by the OID "1.3.6.1.4.1.11129.2.1.17". decoded := keyDescription{} _, err = asn1.Unmarshal([]byte(attExtBytes), &decoded) if err != nil { - return androidAttestationKey, nil, ErrAttestationFormat.WithDetails("Unable to parse Android key attestation certificate extensions") + return "", nil, ErrAttestationFormat.WithDetails("Unable to parse Android key attestation certificate extensions") } // Verify that the attestationChallenge field in the attestation certificate extension data is identical to clientDataHash. if 0 != bytes.Compare(decoded.AttestationChallenge, clientDataHash) { - return androidAttestationKey, nil, ErrAttestationFormat.WithDetails("Attestation challenge not equal to clientDataHash") + return "", nil, ErrAttestationFormat.WithDetails("Attestation challenge not equal to clientDataHash") } // The AuthorizationList.allApplications field is not present on either authorization list (softwareEnforced nor teeEnforced), since PublicKeyCredential MUST be scoped to the RP ID. if nil != decoded.SoftwareEnforced.AllApplications || nil != decoded.TeeEnforced.AllApplications { - return androidAttestationKey, nil, ErrAttestationFormat.WithDetails("Attestation certificate extensions contains all applications field") + return "", nil, ErrAttestationFormat.WithDetails("Attestation certificate extensions contains all applications field") } // For the following, use only the teeEnforced authorization list if the RP wants to accept only keys from a trusted execution environment, otherwise use the union of teeEnforced and softwareEnforced. // The value in the AuthorizationList.origin field is equal to KM_ORIGIN_GENERATED. (which == 0) if KM_ORIGIN_GENERATED != decoded.SoftwareEnforced.Origin || KM_ORIGIN_GENERATED != decoded.TeeEnforced.Origin { - return androidAttestationKey, nil, ErrAttestationFormat.WithDetails("Attestation certificate extensions contains authorization list with origin not equal KM_ORIGIN_GENERATED") + return "", nil, ErrAttestationFormat.WithDetails("Attestation certificate extensions contains authorization list with origin not equal KM_ORIGIN_GENERATED") } // The value in the AuthorizationList.purpose field is equal to KM_PURPOSE_SIGN. (which == 2) if !contains(decoded.SoftwareEnforced.Purpose, KM_PURPOSE_SIGN) && !contains(decoded.TeeEnforced.Purpose, KM_PURPOSE_SIGN) { - return androidAttestationKey, nil, ErrAttestationFormat.WithDetails("Attestation certificate extensions contains authorization list with purpose not equal KM_PURPOSE_SIGN") + return "", nil, ErrAttestationFormat.WithDetails("Attestation certificate extensions contains authorization list with purpose not equal KM_PURPOSE_SIGN") } - return androidAttestationKey, x5c, err + return string(metadata.BasicFull), x5c, err } func contains(s []int, e int) bool { diff --git a/protocol/attestation_androidkey_test.go b/protocol/attestation_androidkey_test.go new file mode 100644 index 00000000..bde1730f --- /dev/null +++ b/protocol/attestation_androidkey_test.go @@ -0,0 +1,86 @@ +package protocol + +import ( + "crypto/sha256" + "testing" + + "github.com/go-webauthn/webauthn/metadata" +) + +func TestVerifyAndroidKeyFormat(t *testing.T) { + type args struct { + att AttestationObject + clientDataHash []byte + } + successAttResponse0 := attestationTestUnpackResponse(t, androidKeyTestResponse0["success"]).Response.AttestationObject + successClientDataHash0 := sha256.Sum256(attestationTestUnpackResponse(t, androidKeyTestResponse0["success"]).Raw.AttestationResponse.ClientDataJSON) + successAttResponse1 := attestationTestUnpackResponse(t, androidKeyTestResponse1["success"]).Response.AttestationObject + successClientDataHash1 := sha256.Sum256(attestationTestUnpackResponse(t, androidKeyTestResponse1["success"]).Raw.AttestationResponse.ClientDataJSON) + tests := []struct { + name string + args args + want string + want1 []interface{} + wantErr bool + }{ + { + "success", + args{ + successAttResponse0, + successClientDataHash0[:], + }, + string(metadata.BasicFull), + nil, + false, + }, + { + "success", + args{ + successAttResponse1, + successClientDataHash1[:], + }, + string(metadata.BasicFull), + nil, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, _, err := verifyAndroidKeyFormat(tt.args.att, tt.args.clientDataHash) + if (err != nil) != tt.wantErr { + t.Errorf("verifyAndroidKeyFormat() error = %v, wantErr %v", err, tt.wantErr) + return + } + if got != tt.want { + t.Errorf("verifyAndroidKeyFormat() got = %v, want %v", got, tt.want) + } + //if !reflect.DeepEqual(got1, tt.want1) { + // t.Errorf("verifySafetyNetFormat() got1 = %v, want %v", got1, tt.want1) + //} + }) + } +} + +var androidKeyTestResponse0 = map[string]string{ + `success`: `{ + "rawId": "U5cxFNxLbU9-SAi1K7k9atYwXhghkAMbxpL__VPtBlw", + "id": "U5cxFNxLbU9-SAi1K7k9atYwXhghkAMbxpL__VPtBlw", + "response": { + "clientDataJSON": "eyJvcmlnaW4iOiJodHRwczovL2xvY2FsaG9zdDo0NDMyOSIsImNoYWxsZW5nZSI6IjlNNWY3bGp5MVl2UWNzOE9pV1FWQ3ciLCJ0eXBlIjoid2ViYXV0aG4uY3JlYXRlIn0", + "attestationObject": "o2NmbXRrYW5kcm9pZC1rZXlnYXR0U3RtdKNjYWxnJmNzaWdYSDBGAiEAlbQ-jtl8o9GtEstcEFH1Z_NlYsTYSn96lilEF17oEsMCIQDza5_axjn2jKZO63RlVf47DDFZbceW9b_tsh1nwOYQbmN4NWOCWQMFMIIDATCCAqegAwIBAgIBATAKBggqhkjOPQQDAjCBzjFFMEMGA1UEAww8RkFLRSBBbmRyb2lkIEtleXN0b3JlIFNvZnR3YXJlIEF0dGVzdGF0aW9uIEludGVybWVkaWF0ZSBGQUtFMTEwLwYJKoZIhvcNAQkBFiJjb25mb3JtYW5jZS10b29sc0BmaWRvYWxsaWFuY2Uub3JnMRYwFAYDVQQKDA1GSURPIEFsbGlhbmNlMQwwCgYDVQQLDANDV0cxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJNWTESMBAGA1UEBwwJV2FrZWZpZWxkMCAXDTcwMDIwMTAwMDAwMFoYDzIwOTkwMTMxMjM1OTU5WjApMScwJQYDVQQDDB5GQUtFIEFuZHJvaWQgS2V5c3RvcmUgS2V5IEZBS0UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQbh-BQBJz7JeQ27dVvu3tyRieiEeXyDYoaWatRdy_D7q3TK96jumKlwIl5ZA2zHmKNLz4K2zsANq1X4tHp8MNZo4IBFjCCARIwCwYDVR0PBAQDAgeAMIHhBgorBgEEAdZ5AgERBIHSMIHPAgECCgEAAgEBCgEABCDc0UoXtU1CwwItW3ne2faKDcFCabFI31BufXEFVK_ENwQAMGm_hT0IAgYBXtPjz6C_hUVZBFcwVTEvMC0EKGNvbS5hbmRyb2lkLmtleXN0b3JlLmFuZHJvaWRrZXlzdG9yZWRlbW8CAQExIgQgdM_LUHSI9SkQhZHHpQWRnzJ3MvvB2ANSauqYAAbS2JgwMqEFMQMCAQKiAwIBA6MEAgIBAKUFMQMCAQSqAwIBAb-DeAMCAQK_hT4DAgEAv4U_AgUAMB8GA1UdIwQYMBaAFFKaGzLgVqrNUQ_vX4A3BovykSMdMAoGCCqGSM49BAMCA0gAMEUCIQDAPV7eQIWfL5BCmj82NszDlQ2IJsOZq_WxidwxD7On_QIgFipplgUF6OHvmHiDdaHJfFweeo60OtCDGDftjQEmF7FZAu4wggLqMIICkaADAgECAgECMAoGCCqGSM49BAMCMIHGMT0wOwYDVQQDDDRGQUtFIEFuZHJvaWQgS2V5c3RvcmUgU29mdHdhcmUgQXR0ZXN0YXRpb24gUm9vdCBGQUtFMTEwLwYJKoZIhvcNAQkBFiJjb25mb3JtYW5jZS10b29sc0BmaWRvYWxsaWFuY2Uub3JnMRYwFAYDVQQKDA1GSURPIEFsbGlhbmNlMQwwCgYDVQQLDANDV0cxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJNWTESMBAGA1UEBwwJV2FrZWZpZWxkMB4XDTE4MDUwOTEyMzE0NFoXDTQ1MDkyNDEyMzE0NFowgc4xRTBDBgNVBAMMPEZBS0UgQW5kcm9pZCBLZXlzdG9yZSBTb2Z0d2FyZSBBdHRlc3RhdGlvbiBJbnRlcm1lZGlhdGUgRkFLRTExMC8GCSqGSIb3DQEJARYiY29uZm9ybWFuY2UtdG9vbHNAZmlkb2FsbGlhbmNlLm9yZzEWMBQGA1UECgwNRklETyBBbGxpYW5jZTEMMAoGA1UECwwDQ1dHMQswCQYDVQQGEwJVUzELMAkGA1UECAwCTVkxEjAQBgNVBAcMCVdha2VmaWVsZDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKtQYStiTRe7w7UbBEk7BUkLjB-LnbzzebLe3KB8UqHXtg3TIXXcK37dvCbbCNVfhvZxtpTcME2kooqMTgOm9cejZjBkMBIGA1UdEwEB_wQIMAYBAf8CAQAwDgYDVR0PAQH_BAQDAgKEMB0GA1UdDgQWBBSj0qos7w2M8iQC1Ry0YLy_alskFDAfBgNVHSMEGDAWgBRSmhsy4FaqzVEP71-ANwaL8pEjHTAKBggqhkjOPQQDAgNHADBEAiBp3Z6j8YH7Qko5rRoK37nS4zPXhv65RWBV-j3MmXi50gIgPtMPpvcGtVbpFCQqsGbyhxPdkji8ltcYXQVfMhdUpRZoYXV0aERhdGFYpEmWDeWIDoxodDQXD2R2YFuP5K65ooYyx5lc87qDHZdjQQAAAFpVDktUqkdAn5qVGrdsEwExACBTlzEU3EttT35ICLUruT1q1jBeGCGQAxvGkv_9U-0GXKUBAgMmIAEhWCAbh-BQBJz7JeQ27dVvu3tyRieiEeXyDYoaWatRdy_D7iJYIK3TK96jumKlwIl5ZA2zHmKNLz4K2zsANq1X4tHp8MNZ" + }, + "type": "public-key" + }`, +} + +var androidKeyTestResponse1 = map[string]string{ + `success`: `{ + "id": "V51GE29tGbhby7sbg1cZ_qL8V8njqEsXpAnwQBobvgw", + "rawId": "V51GE29tGbhby7sbg1cZ_qL8V8njqEsXpAnwQBobvgw", + "response": { + "attestationObject": "o2NmbXRrYW5kcm9pZC1rZXlnYXR0U3RtdKNjYWxnJmNzaWdYRzBFAiAbZhfcF0KSXj5rdEevvnBcC8ZfRQlNl9XYWRTiIGKSHwIhAIerc7jWjOF_lJ71n_GAcaHwDUtPxkjAAdYugnZ4QxkmY3g1Y4JZAxowggMWMIICvaADAgECAgEBMAoGCCqGSM49BAMCMIHkMUUwQwYDVQQDDDxGQUtFIEFuZHJvaWQgS2V5c3RvcmUgU29mdHdhcmUgQXR0ZXN0YXRpb24gSW50ZXJtZWRpYXRlIEZBS0UxMTAvBgkqhkiG9w0BCQEWImNvbmZvcm1hbmNlLXRvb2xzQGZpZG9hbGxpYW5jZS5vcmcxFjAUBgNVBAoMDUZJRE8gQWxsaWFuY2UxIjAgBgNVBAsMGUF1dGhlbnRpY2F0b3IgQXR0ZXN0YXRpb24xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJNWTESMBAGA1UEBwwJV2FrZWZpZWxkMCAXDTcwMDIwMTAwMDAwMFoYDzIwOTkwMTMxMjM1OTU5WjApMScwJQYDVQQDDB5GQUtFIEFuZHJvaWQgS2V5c3RvcmUgS2V5IEZBS0UwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARuowgSu5AoRj8Vi_ZNSFBbGUZJXFG9MkDT6jADlr7tOK9NEgjVX53-ergXpyPaFZrAR9py-xnzfjILn_Kzb8Iqo4IBFjCCARIwCwYDVR0PBAQDAgeAMIHhBgorBgEEAdZ5AgERBIHSMIHPAgECCgEAAgEBCgEABCCfVEl83pSDSerk9I3pcICNTdzc5N3u4jt21cXdzBuJjgQAMGm_hT0IAgYBXtPjz6C_hUVZBFcwVTEvMC0EKGNvbS5hbmRyb2lkLmtleXN0b3JlLmFuZHJvaWRrZXlzdG9yZWRlbW8CAQExIgQgdM_LUHSI9SkQhZHHpQWRnzJ3MvvB2ANSauqYAAbS2JgwMqEFMQMCAQKiAwIBA6MEAgIBAKUFMQMCAQSqAwIBAb-DeAMCAQK_hT4DAgEAv4U_AgUAMB8GA1UdIwQYMBaAFKPSqizvDYzyJALVHLRgvL9qWyQUMAoGCCqGSM49BAMCA0cAMEQCIC7WHb2PyULnjp1M1TVI3Wti_eDhe6sFweuQAdecXtHhAiAS_eZkFsx_VNsrTu3XfZ2D7wIt-vT6nTljfHZ4zqU5xlkDGDCCAxQwggK6oAMCAQICAQIwCgYIKoZIzj0EAwIwgdwxPTA7BgNVBAMMNEZBS0UgQW5kcm9pZCBLZXlzdG9yZSBTb2Z0d2FyZSBBdHRlc3RhdGlvbiBSb290IEZBS0UxMTAvBgkqhkiG9w0BCQEWImNvbmZvcm1hbmNlLXRvb2xzQGZpZG9hbGxpYW5jZS5vcmcxFjAUBgNVBAoMDUZJRE8gQWxsaWFuY2UxIjAgBgNVBAsMGUF1dGhlbnRpY2F0b3IgQXR0ZXN0YXRpb24xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJNWTESMBAGA1UEBwwJV2FrZWZpZWxkMB4XDTE5MDQyNTA1NDkzMloXDTQ2MDkxMDA1NDkzMlowgeQxRTBDBgNVBAMMPEZBS0UgQW5kcm9pZCBLZXlzdG9yZSBTb2Z0d2FyZSBBdHRlc3RhdGlvbiBJbnRlcm1lZGlhdGUgRkFLRTExMC8GCSqGSIb3DQEJARYiY29uZm9ybWFuY2UtdG9vbHNAZmlkb2FsbGlhbmNlLm9yZzEWMBQGA1UECgwNRklETyBBbGxpYW5jZTEiMCAGA1UECwwZQXV0aGVudGljYXRvciBBdHRlc3RhdGlvbjELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAk1ZMRIwEAYDVQQHDAlXYWtlZmllbGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASrUGErYk0Xu8O1GwRJOwVJC4wfi52883my3tygfFKh17YN0yF13Ct-3bwm2wjVX4b2cbaU3DBNpKKKjE4DpvXHo2MwYTAPBgNVHRMBAf8EBTADAQH_MA4GA1UdDwEB_wQEAwIChDAdBgNVHQ4EFgQUo9KqLO8NjPIkAtUctGC8v2pbJBQwHwYDVR0jBBgwFoAUUpobMuBWqs1RD-9fgDcGi_KRIx0wCgYIKoZIzj0EAwIDSAAwRQIhALFvLkAvtHrObTmN8P0-yLIT496P_weSEEbB6vCJWSh9AiBu-UOorCeLcF4WixOG9E5Li2nXe4uM2q6mbKGkll8u-WhhdXRoRGF0YVikPdxHEOnAiLIp26idVjIguzn3Ipr_RlsKZWsa-5qK-KBBAAAAYFUOS1SqR0CfmpUat2wTATEAIFedRhNvbRm4W8u7G4NXGf6i_FfJ46hLF6QJ8EAaG74MpQECAyYgASFYIG6jCBK7kChGPxWL9k1IUFsZRklcUb0yQNPqMAOWvu04Ilggr00SCNVfnf56uBenI9oVmsBH2nL7GfN-Mguf8rNvwio", + "clientDataJSON": "eyJvcmlnaW4iOiJodHRwczovL2Rldi5kb250bmVlZGEucHciLCJjaGFsbGVuZ2UiOiI0YWI3ZGZkMS1hNjk1LTQ3NzctOTg1Zi1hZDI5OTM4MjhlOTkiLCJ0eXBlIjoid2ViYXV0aG4uY3JlYXRlIn0" + }, + "type": "public-key" + }`, +} diff --git a/protocol/attestation_apple.go b/protocol/attestation_apple.go index 3424801a..8ea8e051 100644 --- a/protocol/attestation_apple.go +++ b/protocol/attestation_apple.go @@ -10,13 +10,14 @@ import ( "fmt" "math/big" + "github.com/go-webauthn/webauthn/metadata" "github.com/go-webauthn/webauthn/protocol/webauthncose" ) var appleAttestationKey = "apple" func init() { - RegisterAttestationFormat(appleAttestationKey, verifyAppleKeyFormat) + RegisterAttestationFormat(appleAttestationKey, verifyAppleFormat) } // From §8.8. https://www.w3.org/TR/webauthn-2/#sctn-apple-anonymous-attestation @@ -31,7 +32,7 @@ func init() { // appleStmtFormat = { // x5c: [ credCert: bytes, * (caCert: bytes) ] // } -func verifyAppleKeyFormat(att AttestationObject, clientDataHash []byte) (string, []interface{}, error) { +func verifyAppleFormat(att AttestationObject, clientDataHash []byte) (string, []interface{}, error) { // Step 1. Verify that attStmt is valid CBOR conforming to the syntax defined // above and perform CBOR decoding on it to extract the contained fields. @@ -40,17 +41,17 @@ func verifyAppleKeyFormat(att AttestationObject, clientDataHash []byte) (string, x5c, x509present := att.AttStatement["x5c"].([]interface{}) if !x509present { // Handle Basic Attestation steps for the x509 Certificate - return appleAttestationKey, nil, ErrAttestationFormat.WithDetails("Error retreiving x5c value") + return "", nil, ErrAttestationFormat.WithDetails("Error retreiving x5c value") } credCertBytes, valid := x5c[0].([]byte) if !valid { - return appleAttestationKey, nil, ErrAttestation.WithDetails("Error getting certificate from x5c cert chain") + return "", nil, ErrAttestation.WithDetails("Error getting certificate from x5c cert chain") } credCert, err := x509.ParseCertificate(credCertBytes) if err != nil { - return appleAttestationKey, nil, ErrAttestationFormat.WithDetails(fmt.Sprintf("Error parsing certificate from ASN.1 data: %+v", err)) + return "", nil, ErrAttestationFormat.WithDetails(fmt.Sprintf("Error parsing certificate from ASN.1 data: %+v", err)) } // Step 2. Concatenate authenticatorData and clientDataHash to form nonceToHash. @@ -67,24 +68,24 @@ func verifyAppleKeyFormat(att AttestationObject, clientDataHash []byte) (string, } } if len(attExtBytes) == 0 { - return appleAttestationKey, nil, ErrAttestationFormat.WithDetails("Attestation certificate extensions missing 1.2.840.113635.100.8.2") + return "", nil, ErrAttestationFormat.WithDetails("Attestation certificate extensions missing 1.2.840.113635.100.8.2") } decoded := AppleAnonymousAttestation{} _, err = asn1.Unmarshal([]byte(attExtBytes), &decoded) if err != nil { - return appleAttestationKey, nil, ErrAttestationFormat.WithDetails("Unable to parse apple attestation certificate extensions") + return "", nil, ErrAttestationFormat.WithDetails("Unable to parse apple attestation certificate extensions") } if !bytes.Equal(decoded.Nonce, nonce[:]) || err != nil { - return appleAttestationKey, nil, ErrInvalidAttestation.WithDetails("Attestation certificate does not contain expected nonce") + return "", nil, ErrInvalidAttestation.WithDetails("Attestation certificate does not contain expected nonce") } // Step 5. Verify that the credential public key equals the Subject Public Key of credCert. // TODO: Probably move this part to webauthncose.go pubKey, err := webauthncose.ParsePublicKey(att.AuthData.AttData.CredentialPublicKey) if err != nil { - return appleAttestationKey, nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Error parsing public key: %+v", err)) + return "", nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Error parsing public key: %+v\n", err)) } credPK := pubKey.(webauthncose.EC2PublicKeyData) subjectPK := credCert.PublicKey.(*ecdsa.PublicKey) @@ -94,11 +95,11 @@ func verifyAppleKeyFormat(att AttestationObject, clientDataHash []byte) (string, Y: big.NewInt(0).SetBytes(credPK.YCoord), } if !credPKInfo.Equal(subjectPK) { - return appleAttestationKey, nil, ErrInvalidAttestation.WithDetails("Certificate public key does not match public key in authData") + return "", nil, ErrInvalidAttestation.WithDetails("Certificate public key does not match public key in authData") } // Step 6. If successful, return implementation-specific values representing attestation type Anonymization CA and attestation trust path x5c. - return appleAttestationKey, x5c, nil + return string(metadata.AnonCA), x5c, nil } // Apple has not yet publish schema for the extension(as of JULY 2021.) diff --git a/protocol/attestation_apple_test.go b/protocol/attestation_apple_test.go new file mode 100644 index 00000000..29d63f3f --- /dev/null +++ b/protocol/attestation_apple_test.go @@ -0,0 +1,61 @@ +package protocol + +import ( + "crypto/sha256" + "testing" + + "github.com/go-webauthn/webauthn/metadata" +) + +func Test_verifyAppleFormat(t *testing.T) { + type args struct { + att AttestationObject + clientDataHash []byte + } + successAttResponse := attestationTestUnpackResponse(t, appleTestResponse["success"]).Response.AttestationObject + successClientDataHash := sha256.Sum256(attestationTestUnpackResponse(t, appleTestResponse["success"]).Raw.AttestationResponse.ClientDataJSON) + tests := []struct { + name string + args args + want string + want1 []interface{} + wantErr bool + }{ + { + "success", + args{ + successAttResponse, + successClientDataHash[:], + }, + string(metadata.AnonCA), + nil, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, _, err := verifyAppleFormat(tt.args.att, tt.args.clientDataHash) + if (err != nil) != tt.wantErr { + t.Errorf("verifyAppleFormat() error = %v, wantErr %v", err, tt.wantErr) + return + } + if got != tt.want { + t.Errorf("verifyAppleFormat() got = %v, want %v", got, tt.want) + } + //if !reflect.DeepEqual(got1, tt.want1) { + // t.Errorf("verifyPackedFormat() got1 = %v, want %v", got1, tt.want1) + //} + }) + } +} + +var appleTestResponse = map[string]string{ + `success`: `{ + "rawId": "U5cxFNxLbU9-SAi1K7k9atYwXhghkAMbxpL__VPtBlw", + "id": "U5cxFNxLbU9-SAi1K7k9atYwXhghkAMbxpL__VPtBlw", + "response": { + "clientDataJSON": "eyJ0eXBlIjoid2ViYXV0aG4uY3JlYXRlIiwiY2hhbGxlbmdlIjoia093TXZFMm1RTzZvdTBCMGpqRDBWQSIsIm9yaWdpbiI6Imh0dHBzOi8vNmNjM2M5ZTc5NjdhLm5ncm9rLmlvIn0", + "attestationObject": "o2NmbXRlYXBwbGVnYXR0U3RtdKJjYWxnJmN4NWOCWQJIMIICRDCCAcmgAwIBAgIGAXUCfWGDMAoGCCqGSM49BAMCMEgxHDAaBgNVBAMME0FwcGxlIFdlYkF1dGhuIENBIDExEzARBgNVBAoMCkFwcGxlIEluYy4xEzARBgNVBAgMCkNhbGlmb3JuaWEwHhcNMjAxMDA3MDk0NjEyWhcNMjAxMDA4MDk1NjEyWjCBkTFJMEcGA1UEAwxANjEyNzZmYzAyZDNmZThkMTZiMzNiNTU0OWQ4MTkyMzZjODE3NDZhODNmMmU5NGE2ZTRiZWUxYzcwZjgxYjViYzEaMBgGA1UECwwRQUFBIENlcnRpZmljYXRpb24xEzARBgNVBAoMCkFwcGxlIEluYy4xEzARBgNVBAgMCkNhbGlmb3JuaWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAR5_lkIu1EpyAk4t1TATSs0DvpmFbmHaYv1naTlPqPm_vsD2qEnDVgE6KthwVqsokNcfb82nXHKFcUjsABKG3W3o1UwUzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB_wQEAwIE8DAzBgkqhkiG92NkCAIEJjAkoSIEIJxgAhVAs-GYNN_jfsYkRcieGylPeSzka5QTwyMO84aBMAoGCCqGSM49BAMCA2kAMGYCMQDaHBjrI75xAF7SXzyF5zSQB_Lg9PjTdyye-w7stiqy84K6lmo8d3fIptYjLQx81bsCMQCvC8MSN-aewiaU0bMsdxRbdDerCJJj3xJb3KZwloevJ3daCmCcrZrAPYfLp2kDOshZAjgwggI0MIIBuqADAgECAhBWJVOVx6f7QOviKNgmCFO2MAoGCCqGSM49BAMDMEsxHzAdBgNVBAMMFkFwcGxlIFdlYkF1dGhuIFJvb3QgQ0ExEzARBgNVBAoMCkFwcGxlIEluYy4xEzARBgNVBAgMCkNhbGlmb3JuaWEwHhcNMjAwMzE4MTgzODAxWhcNMzAwMzEzMDAwMDAwWjBIMRwwGgYDVQQDDBNBcHBsZSBXZWJBdXRobiBDQSAxMRMwEQYDVQQKDApBcHBsZSBJbmMuMRMwEQYDVQQIDApDYWxpZm9ybmlhMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEgy6HLyYUkYECJbn1_Na7Y3i19V8_ywRbxzWZNHX9VJBE35v-GSEXZcaaHdoFCzjUUINAGkNPsk0RLVbD4c-_y5iR_sBpYIG--Wy8d8iN3a9Gpa7h3VFbWvqrk76cCyaRo2YwZDASBgNVHRMBAf8ECDAGAQH_AgEAMB8GA1UdIwQYMBaAFCbXZNnFeMJaZ9Gn3msS0Btj8cbXMB0GA1UdDgQWBBTrroLE_6GsW1HUzyRhBQC-Y713iDAOBgNVHQ8BAf8EBAMCAQYwCgYIKoZIzj0EAwMDaAAwZQIxAN2LGjSBpfrZ27TnZXuEHhRMJ7dbh2pBhsKxR1dQM3In7-VURX72SJUMYy5cSD5wwQIwLIpgRNwgH8_lm8NNKTDBSHhR2WDtanXx60rKvjjNJbiX0MgFvvDH94sHpXHG6A4HaGF1dGhEYXRhWJhWHo8_bWPQzAMKYRIrGXu__PkMUfuqHM4RH7Jea4WDgkUAAAAAAAAAAAAAAAAAAAAAAAAAAAAUomGfdaNI-cYgWrq2klNk97zkcg-lAQIDJiABIVggef5ZCLtRKcgJOLdUwE0rNA76ZhW5h2mL9Z2k5T6j5v4iWCD7A9qhJw1YBOirYcFarKJDXH2_Np1xyhXFI7AASht1tw"}, + "type": "public-key" + }`, +} diff --git a/protocol/attestation_packed.go b/protocol/attestation_packed.go index cad0bb79..fb30984e 100644 --- a/protocol/attestation_packed.go +++ b/protocol/attestation_packed.go @@ -8,9 +8,8 @@ import ( "strings" "time" - "github.com/google/uuid" - "github.com/go-webauthn/webauthn/metadata" + "github.com/go-webauthn/webauthn/protocol/webauthncose" ) @@ -78,39 +77,37 @@ func verifyPackedFormat(att AttestationObject, clientDataHash []byte) (string, [ func handleBasicAttestation(signature, clientDataHash, authData, aaguid []byte, alg int64, x5c []interface{}) (string, []interface{}, error) { // Step 2.1. Verify that sig is a valid signature over the concatenation of authenticatorData // and clientDataHash using the attestation public key in attestnCert with the algorithm specified in alg. - attestationType := "Packed (Basic)" - for _, c := range x5c { cb, cv := c.([]byte) if !cv { - return attestationType, x5c, ErrAttestation.WithDetails("Error getting certificate from x5c cert chain") + return "", x5c, ErrAttestation.WithDetails("Error getting certificate from x5c cert chain") } ct, err := x509.ParseCertificate(cb) if err != nil { - return attestationType, x5c, ErrAttestationFormat.WithDetails(fmt.Sprintf("Error parsing certificate from ASN.1 data: %+v", err)) + return "", x5c, ErrAttestationFormat.WithDetails(fmt.Sprintf("Error parsing certificate from ASN.1 data: %+v", err)) } if ct.NotBefore.After(time.Now()) || ct.NotAfter.Before(time.Now()) { - return attestationType, x5c, ErrAttestationFormat.WithDetails("Cert in chain not time valid") + return "", x5c, ErrAttestationFormat.WithDetails("Cert in chain not time valid") } } attCertBytes, valid := x5c[0].([]byte) if !valid { - return attestationType, x5c, ErrAttestation.WithDetails("Error getting certificate from x5c cert chain") + return "", x5c, ErrAttestation.WithDetails("Error getting certificate from x5c cert chain") } signatureData := append(authData, clientDataHash...) attCert, err := x509.ParseCertificate(attCertBytes) if err != nil { - return attestationType, x5c, ErrAttestationFormat.WithDetails(fmt.Sprintf("Error parsing certificate from ASN.1 data: %+v", err)) + return "", x5c, ErrAttestationFormat.WithDetails(fmt.Sprintf("Error parsing certificate from ASN.1 data: %+v", err)) } coseAlg := webauthncose.COSEAlgorithmIdentifier(alg) sigAlg := webauthncose.SigAlgFromCOSEAlg(coseAlg) - - if err = attCert.CheckSignature(x509.SignatureAlgorithm(sigAlg), signatureData, signature); err != nil { - return attestationType, x5c, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Signature validation error: %+v", err)) + err = attCert.CheckSignature(x509.SignatureAlgorithm(sigAlg), signatureData, signature) + if err != nil { + return "", x5c, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Signature validation error: %+v\n", err)) } // Step 2.2 Verify that attestnCert meets the requirements in §8.2.1 Packed attestation statement certificate requirements. @@ -118,7 +115,7 @@ func handleBasicAttestation(signature, clientDataHash, authData, aaguid []byte, // Step 2.2.1 (from §8.2.1) Version MUST be set to 3 (which is indicated by an ASN.1 INTEGER with value 2). if attCert.Version != 3 { - return attestationType, x5c, ErrAttestationCertificate.WithDetails("Attestation Certificate is incorrect version") + return "", x5c, ErrAttestationCertificate.WithDetails("Attestation Certificate is incorrect version") } // Step 2.2.2 (from §8.2.1) Subject field MUST be set to: @@ -129,14 +126,14 @@ func handleBasicAttestation(signature, clientDataHash, authData, aaguid []byte, // TODO: Find a good, useable, country code library. For now, check stringy-ness subjectString := strings.Join(attCert.Subject.Country, "") if subjectString == "" { - return attestationType, x5c, ErrAttestationCertificate.WithDetails("Attestation Certificate Country Code is invalid") + return "", x5c, ErrAttestationCertificate.WithDetails("Attestation Certificate Country Code is invalid") } // Subject-O // Legal name of the Authenticator vendor (UTF8String) subjectString = strings.Join(attCert.Subject.Organization, "") if subjectString == "" { - return attestationType, x5c, ErrAttestationCertificate.WithDetails("Attestation Certificate Organization is invalid") + return "", x5c, ErrAttestationCertificate.WithDetails("Attestation Certificate Organization is invalid") } // Subject-OU @@ -150,7 +147,7 @@ func handleBasicAttestation(signature, clientDataHash, authData, aaguid []byte, // A UTF8String of the vendor’s choosing subjectString = attCert.Subject.CommonName if subjectString == "" { - return attestationType, x5c, ErrAttestationCertificate.WithDetails("Attestation Certificate Common Name not set") + return "", x5c, ErrAttestationCertificate.WithDetails("Attestation Certificate Common Name not set") } // TODO: And then what @@ -163,7 +160,7 @@ func handleBasicAttestation(signature, clientDataHash, authData, aaguid []byte, for _, extension := range attCert.Extensions { if extension.Id.Equal(idFido) { if extension.Critical { - return attestationType, x5c, ErrInvalidAttestation.WithDetails("Attestation certificate FIDO extension marked as critical") + return "", x5c, ErrInvalidAttestation.WithDetails("Attestation certificate FIDO extension marked as critical") } foundAAGUID = extension.Value } @@ -176,48 +173,15 @@ func handleBasicAttestation(signature, clientDataHash, authData, aaguid []byte, // AAGUID MUST be wrapped in two OCTET STRINGS to be valid. if len(foundAAGUID) > 0 { unMarshalledAAGUID := []byte{} - _, err = asn1.Unmarshal(foundAAGUID, &unMarshalledAAGUID) - if err != nil { - return attestationType, x5c, ErrInvalidAttestation.WithDetails(fmt.Sprintf("AAGUID could not be unmarshalled: %v", err)) - } - + asn1.Unmarshal(foundAAGUID, &unMarshalledAAGUID) if !bytes.Equal(aaguid, unMarshalledAAGUID) { - return attestationType, x5c, ErrInvalidAttestation.WithDetails("Certificate AAGUID does not match Auth Data certificate") - } - } - - parsedAAGUID, err := uuid.FromBytes(aaguid) - if err != nil { - return attestationType, x5c, ErrInvalidAttestation.WithDetails(fmt.Sprintf("AAGUID could not be parsed: %v", err)) - } - - if meta, ok := metadata.Metadata[parsedAAGUID]; ok { - for _, s := range meta.StatusReports { - if metadata.IsUndesiredAuthenticatorStatus(metadata.AuthenticatorStatus(s.Status)) { - return attestationType, x5c, ErrInvalidAttestation.WithDetails("Authenticator with undesirable status encountered") - } - } - - if attCert.Subject.CommonName != attCert.Issuer.CommonName { - var hasBasicFull = false - for _, a := range meta.MetadataStatement.AttestationTypes { - if metadata.AuthenticatorAttestationType(a) == metadata.BasicFull { - hasBasicFull = true - } - } - if !hasBasicFull { - return attestationType, x5c, ErrInvalidAttestation.WithDetails("Attestation with full attestation from authenticator that does not support full attestation") - } - } - } else { - if metadata.Conformance { - return attestationType, x5c, ErrInvalidAttestation.WithDetails("AAGUID not found in metadata during conformance testing") + return "", x5c, ErrInvalidAttestation.WithDetails("Certificate AAGUID does not match Auth Data certificate") } } // Step 2.2.4 The Basic Constraints extension MUST have the CA component set to false. if attCert.IsCA { - return attestationType, x5c, ErrInvalidAttestation.WithDetails("Attestation certificate's Basic Constraints marked as CA") + return "", x5c, ErrInvalidAttestation.WithDetails("Attestation certificate's Basic Constraints marked as CA") } // Note for 2.2.5 An Authority Information Access (AIA) extension with entry id-ad-ocsp and a CRL @@ -228,7 +192,7 @@ func handleBasicAttestation(signature, clientDataHash, authData, aaguid []byte, // Step 2.4 If successful, return attestation type Basic and attestation trust path x5c. // We don't handle trust paths yet but we're done - return attestationType, x5c, nil + return string(metadata.BasicFull), x5c, nil } func handleECDAAAttesation(signature, clientDataHash, ecdaaKeyID []byte) (string, []interface{}, error) { @@ -236,7 +200,6 @@ func handleECDAAAttesation(signature, clientDataHash, ecdaaKeyID []byte) (string } func handleSelfAttestation(alg int64, pubKey, authData, clientDataHash, signature []byte) (string, []interface{}, error) { - attestationType := "Packed (Self)" // §4.1 Validate that alg matches the algorithm of the credentialPublicKey in authenticatorData. // §4.2 Verify that sig is a valid signature over the concatenation of authenticatorData and @@ -245,35 +208,38 @@ func handleSelfAttestation(alg int64, pubKey, authData, clientDataHash, signatur key, err := webauthncose.ParsePublicKey(pubKey) if err != nil { - return attestationType, nil, ErrAttestationFormat.WithDetails(fmt.Sprintf("Error parsing the public key: %+v", err)) + return "", nil, ErrAttestationFormat.WithDetails(fmt.Sprintf("Error parsing the public key: %+v\n", err)) } - switch k := key.(type) { + switch key.(type) { case webauthncose.OKPPublicKeyData: - err = verifyKeyAlgorithm(k.Algorithm, alg) + k := key.(webauthncose.OKPPublicKeyData) + err := verifyKeyAlgorithm(k.Algorithm, alg) if err != nil { - return attestationType, nil, err + return "", nil, err } case webauthncose.EC2PublicKeyData: - err = verifyKeyAlgorithm(k.Algorithm, alg) + k := key.(webauthncose.EC2PublicKeyData) + err := verifyKeyAlgorithm(k.Algorithm, alg) if err != nil { - return attestationType, nil, err + return "", nil, err } case webauthncose.RSAPublicKeyData: - err = verifyKeyAlgorithm(k.Algorithm, alg) + k := key.(webauthncose.RSAPublicKeyData) + err := verifyKeyAlgorithm(k.Algorithm, alg) if err != nil { - return attestationType, nil, err + return "", nil, err } default: - return attestationType, nil, ErrInvalidAttestation.WithDetails("Error verifying the public key data") + return "", nil, ErrInvalidAttestation.WithDetails("Error verifying the public key data") } valid, err := webauthncose.VerifySignature(key, verificationData, signature) if !valid && err == nil { - return attestationType, nil, ErrInvalidAttestation.WithDetails("Unable to verify signature") + return "", nil, ErrInvalidAttestation.WithDetails("Unabled to verify signature") } - return attestationType, nil, err + return string(metadata.BasicSurrogate), nil, err } func verifyKeyAlgorithm(keyAlgorithm, attestedAlgorithm int64) error { diff --git a/protocol/attestation_packed_test.go b/protocol/attestation_packed_test.go index ed27cdc3..b0befdaf 100644 --- a/protocol/attestation_packed_test.go +++ b/protocol/attestation_packed_test.go @@ -1,8 +1,10 @@ package protocol import ( - "reflect" + "crypto/sha256" "testing" + + "github.com/go-webauthn/webauthn/metadata" ) func Test_verifyPackedFormat(t *testing.T) { @@ -10,6 +12,12 @@ func Test_verifyPackedFormat(t *testing.T) { att AttestationObject clientDataHash []byte } + successAttResponseES256 := attestationTestUnpackResponse(t, packedTestResponseES256["success"]).Response.AttestationObject + successClientDataHashES256 := sha256.Sum256(attestationTestUnpackResponse(t, packedTestResponseES256["success"]).Raw.AttestationResponse.ClientDataJSON) + successAttResponseES512 := attestationTestUnpackResponse(t, packedTestResponseES512["success"]).Response.AttestationObject + successClientDataHashES512 := sha256.Sum256(attestationTestUnpackResponse(t, packedTestResponseES512["success"]).Raw.AttestationResponse.ClientDataJSON) + successAttResponseSolo2 := attestationTestUnpackResponse(t, packedTestResponseSolo2["success"]).Response.AttestationObject + successClientDataHashSolo2 := sha256.Sum256(attestationTestUnpackResponse(t, packedTestResponseSolo2["success"]).Raw.AttestationResponse.ClientDataJSON) tests := []struct { name string args args @@ -17,16 +25,40 @@ func Test_verifyPackedFormat(t *testing.T) { want1 []interface{} wantErr bool }{ - // { - // name: "Successful Self Attestation", - // args: args{ - // att: AttestationObject - // } - // } + { + "success", + args{ + successAttResponseES256, + successClientDataHashES256[:], + }, + string(metadata.BasicFull), + nil, + false, + }, + { + "success 512", + args{ + successAttResponseES512, + successClientDataHashES512[:], + }, + string(metadata.BasicSurrogate), + nil, + false, + }, + { + "success Solo2", + args{ + successAttResponseSolo2, + successClientDataHashSolo2[:], + }, + string(metadata.BasicFull), + nil, + false, + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - got, got1, err := verifyPackedFormat(tt.args.att, tt.args.clientDataHash) + got, _, err := verifyPackedFormat(tt.args.att, tt.args.clientDataHash) if (err != nil) != tt.wantErr { t.Errorf("verifyPackedFormat() error = %v, wantErr %v", err, tt.wantErr) return @@ -34,13 +66,43 @@ func Test_verifyPackedFormat(t *testing.T) { if got != tt.want { t.Errorf("verifyPackedFormat() got = %v, want %v", got, tt.want) } - if !reflect.DeepEqual(got1, tt.want1) { - t.Errorf("verifyPackedFormat() got1 = %v, want %v", got1, tt.want1) - } + // TODO: Consider doing something with the second return value from verifyPackedFormat, x5c }) } } -var testPackedAttestationOptions = []string{} +var packedTestResponseES256 = map[string]string{ + `success`: `{ + "rawId": "hUf7WI3IZmoLOzYhHFe7U-df4QD17lQBMi9iS-z3dWFlr79MXOoTR8dJzb_Y7sAstHBrcC1nv8pOr6aFz50K65juYXWt8k26bKu-Hu4CulPo53bIStJ4kpOr2Dlr6Z4D", + "id": "hUf7WI3IZmoLOzYhHFe7U-df4QD17lQBMi9iS-z3dWFlr79MXOoTR8dJzb_Y7sAstHBrcC1nv8pOr6aFz50K65juYXWt8k26bKu-Hu4CulPo53bIStJ4kpOr2Dlr6Z4D", + "response": { + "clientDataJSON": "ew0KCSJ0eXBlIiA6ICJ3ZWJhdXRobi5jcmVhdGUiLA0KCSJjaGFsbGVuZ2UiIDogIlBfSktRaWQxdHZzNEJsdGlaMUNzRWZYbDNHWjBJcG1MUFVRRmxZLW8weDlzZ3ZDS3lXNXpQUkpjTzc3M2VpOE93WEN5Rjl1Wk42X3B5elhOT0FKUjdBIiwNCgkib3JpZ2luIiA6ICJodHRwczovL2xvY2FsaG9zdDo0NDMyOSIsDQoJInRva2VuQmluZGluZyIgOiANCgl7DQoJCSJzdGF0dXMiIDogInN1cHBvcnRlZCINCgl9DQp9", + "attestationObject": "o2NmbXRmcGFja2VkaGF1dGhEYXRhWORJlg3liA6MaHQ0Fw9kdmBbj-SuuaKGMseZXPO6gx2XY0UAAChiQjgyRUQ3M0M4RkI0RTVBMgBghUf7WI3IZmoLOzYhHFe7U-df4QD17lQBMi9iS-z3dWFlr79MXOoTR8dJzb_Y7sAstHBrcC1nv8pOr6aFz50K65juYXWt8k26bKu-Hu4CulPo53bIStJ4kpOr2Dlr6Z4DpQECAyYgASFYIA9RHvpjfWoWN_Im7eYwG1Y8kA77s7QH9uf9TePknT3mIlggJ8tNsMrPPrewstqf65ItALMxBIi4VUoTIZEyAkXN6U1nYXR0U3RtdKNjYWxnJmNzaWdYRzBFAiBsbcx3U1xgYinrnczLOUDOlYGvYENDGzv77WdM1W3FTQIhAJ16HUK8XyG83cOVQFKkijdgHyDV97XylRMU_rWHAkP_Y3g1Y4NZAkUwggJBMIIB6KADAgECAhAVn3vCzYkY8Shrk0j6nzPiMAoGCCqGSM49BAMCMEkxCzAJBgNVBAYTAkNOMR0wGwYDVQQKDBRGZWl0aWFuIFRlY2hub2xvZ2llczEbMBkGA1UEAwwSRmVpdGlhbiBGSURPMiBDQS0xMCAXDTE4MDQxMTAwMDAwMFoYDzIwMzMwNDEwMjM1OTU5WjBvMQswCQYDVQQGEwJDTjEdMBsGA1UECgwURmVpdGlhbiBUZWNobm9sb2dpZXMxIjAgBgNVBAsMGUF1dGhlbnRpY2F0b3IgQXR0ZXN0YXRpb24xHTAbBgNVBAMMFEZUIEJpb1Bhc3MgRklETzIgVVNCMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgAZ1XFn7yUmwFajSCpJYl76DCrLv6Cz4j-2gkJZj5UjHHxEnBTO0JEZ4nUz-4QFDipTpgz3iACwvKh3Xb03bXaOBiTCBhjAdBgNVHQ4EFgQUelSCQoBi2Irnr4SYJcSvkak0mPIwHwYDVR0jBBgwFoAUTTvYxGcVG7sT6POE2DBPnWkVwIMwDAYDVR0TAQH_BAIwADATBgsrBgEEAYLlHAIBAQQEAwIFIDAhBgsrBgEEAYLlHAEBBAQSBBBCODJFRDczQzhGQjRFNUEyMAoGCCqGSM49BAMCA0cAMEQCICRLRaO-iNy34CWixqMSz_uG7bwnSiLBBS4xSFHw6LCHAiA0Gr9OHCTyCxpz1T2swqn5FbQbsjprAW8f7_jg5_iQwFkB_zCCAfswggGgoAMCAQICEBWfe8LNiRjxKGuTSPqfM-EwCgYIKoZIzj0EAwIwSzELMAkGA1UEBhMCQ04xHTAbBgNVBAoMFEZlaXRpYW4gVGVjaG5vbG9naWVzMR0wGwYDVQQDDBRGZWl0aWFuIEZJRE8gUm9vdCBDQTAgFw0xODA0MTAwMDAwMDBaGA8yMDM4MDQwOTIzNTk1OVowSTELMAkGA1UEBhMCQ04xHTAbBgNVBAoMFEZlaXRpYW4gVGVjaG5vbG9naWVzMRswGQYDVQQDDBJGZWl0aWFuIEZJRE8yIENBLTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASOfmAJ7MEWZcyg-sPpb-UIO5VtVyUR61sy9NZnOVfdZ9i2FzUd_0u5gOYLqbkzuZo0MPMX6iETB1a9agd03nWPo2YwZDAdBgNVHQ4EFgQUTTvYxGcVG7sT6POE2DBPnWkVwIMwHwYDVR0jBBgwFoAU0aGYTYF_w7lr9gdnvVAS_pBF8VQwEgYDVR0TAQH_BAgwBgEB_wIBADAOBgNVHQ8BAf8EBAMCAQYwCgYIKoZIzj0EAwIDSQAwRgIhAPt_o9JAR6ERUMJ4Vm0hzJAWmOyhf087SDRTecpg5MJlAiEA6wpDwYjB172IPpEkYFbCsLlbWKJ0bwufPKkcKS0rWexZAdwwggHYMIIBfqADAgECAhAVn3vCzYkY8Shrk0j6nzPWMAoGCCqGSM49BAMCMEsxCzAJBgNVBAYTAkNOMR0wGwYDVQQKDBRGZWl0aWFuIFRlY2hub2xvZ2llczEdMBsGA1UEAwwURmVpdGlhbiBGSURPIFJvb3QgQ0EwIBcNMTgwNDAxMDAwMDAwWhgPMjA0ODAzMzEyMzU5NTlaMEsxCzAJBgNVBAYTAkNOMR0wGwYDVQQKDBRGZWl0aWFuIFRlY2hub2xvZ2llczEdMBsGA1UEAwwURmVpdGlhbiBGSURPIFJvb3QgQ0EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASd8ApuO8xfUTLVvqT5ZBB01Uy30mAZbInc-8zgFIrlepN-j77SgCP_i2fDIgvQcUFH1K36S2OpJcN-OJcC6uzzo0IwQDAdBgNVHQ4EFgQU0aGYTYF_w7lr9gdnvVAS_pBF8VQwDwYDVR0TAQH_BAUwAwEB_zAOBgNVHQ8BAf8EBAMCAQYwCgYIKoZIzj0EAwIDSAAwRQIhALexPWUGMZ4X7EpOnNXUphTZyRqFN3iYsnLNg6Foe_iKAiAPYliR_IflDgGmjyuug7Qi3uhiMXaSDL95JndT0aVqrA" + }, + "type": "public-key" + }`, +} + +var packedTestResponseES512 = map[string]string{ + `success`: `{ + "rawId": "6YIJExgLDzTvfys9WgQlIGTL1L9Ys9bhaaA1Pr-OAPc", + "id": "6YIJExgLDzTvfys9WgQlIGTL1L9Ys9bhaaA1Pr-OAPc", + "response": { + "clientDataJSON": "eyJvcmlnaW4iOiJodHRwczovL2xvY2FsaG9zdDo0NDMyOSIsImNoYWxsZW5nZSI6IlFQQS1GckNTd2ctcUhoell2UklkbkEiLCJ0eXBlIjoid2ViYXV0aG4uY3JlYXRlIn0", + "attestationObject": "o2NmbXRmcGFja2VkZ2F0dFN0bXSiY2FsZzgjY3NpZ1iKMIGHAkE9Vr0j3zGzH6_YASuNse-D4bIDPU4ralNkJqgbCyv_tPNdt27VKaPDnK3WKWgv1qna04qMA7yukZeOPods8arRVQJCAZibACvAfmwBNT4cvR32MNvgGienLXmi2q8MwytcGrtOMnyhnxgco0pOFH7eWHXzn64mVqdSD-wPRTIfJ3McBxW0aGF1dGhEYXRhWOlJlg3liA6MaHQ0Fw9kdmBbj-SuuaKGMseZXPO6gx2XY0EAAABmI4irjYkVQUaTutQ-Zx0lOAAg6YIJExgLDzTvfys9WgQlIGTL1L9Ys9bhaaA1Pr-OAPelAQIDOCMgAyFYQgGzEwyupDz8u1IHtClxewg8CYWBRqD6_SufCj6-LevV57awHyeFGbyfS78ZB4e_I7RmndDI-jO24T3WZ1JMoE1mMCJYQgCpx32yAvYCfKWILgd5aLYuE5L8lEWuN5lhzGwNXoi6pj0JcQR60yCzI8HPlESzEvpqtCNBqF99eD2JETVIqkiwvQ" + }, + "type": "public-key" + }`, +} -var testPackedAttestationResponses = []string{} +var packedTestResponseSolo2 = map[string]string{ + `success`: `{ + "id":"owBY6F5857tda9Pg5iFNCg6ksHpGOYhrNqIn46pkvhEMKIgNGcKS-vDGAUEroq0-VHnl1LhzQkPRQmYBTHjGcpLKZKSLa2m2ANI-91HjXzoJd_zFOiEnu7CDwQTff9KZ6uPlx7kUK-JJOHar-IyRKcNhc_kOJ2ezglmj1JYuIJLoDEyXlKkkviFdwk1vbWLnO3p_oWROUeIgH_S4CLVLPIJXkPe0YvMgp3ESs9CsrN6kvMTysVRIt_h5KUqpZo0TKCL96zwFk1X_2PwCLKWmOxVL35lJfUKOHG9rc3bmKlqZR6aOgZjerY6BpU8BTJkAqfOvdVlqFeEcywJQgveR7FOvnVtoqzd5oaEwjA", + "rawId":"owBY6F5857tda9Pg5iFNCg6ksHpGOYhrNqIn46pkvhEMKIgNGcKS-vDGAUEroq0-VHnl1LhzQkPRQmYBTHjGcpLKZKSLa2m2ANI-91HjXzoJd_zFOiEnu7CDwQTff9KZ6uPlx7kUK-JJOHar-IyRKcNhc_kOJ2ezglmj1JYuIJLoDEyXlKkkviFdwk1vbWLnO3p_oWROUeIgH_S4CLVLPIJXkPe0YvMgp3ESs9CsrN6kvMTysVRIt_h5KUqpZo0TKCL96zwFk1X_2PwCLKWmOxVL35lJfUKOHG9rc3bmKlqZR6aOgZjerY6BpU8BTJkAqfOvdVlqFeEcywJQgveR7FOvnVtoqzd5oaEwjA", + "response":{ + "attestationObject":"o2NmbXRmcGFja2VkZ2F0dFN0bXSjY2FsZyZjc2lnWEgwRgIhAIXRMqmC2_bHTkKUwOvLvmAikuQPCk__9clILwjhOz3VAiEApJXTrN4WMiPwFXqTIh0oI8AZBm3vs-y_UotbQFSnX99jeDVjgVkCqzCCAqcwggJMoAMCAQICFGqj6W3EVhRWQJPun0qqCMyTlnqKMAoGCCqGSM49BAMCMC0xETAPBgNVBAoMCFNvbG9LZXlzMQswCQYDVQQGEwJDSDELMAkGA1UEAwwCRjEwIBcNMjEwNTIzMDA1MjA2WhgPMjA3MTA1MTEwMDUyMDZaMIGDMQswCQYDVQQGEwJVUzERMA8GA1UECgwIU29sb0tleXMxIjAgBgNVBAsMGUF1dGhlbnRpY2F0b3IgQXR0ZXN0YXRpb24xPTA7BgNVBAMMNFNvbG8gMiBORkMrVVNCLUMgMjM2OUQ0RDAxM0NFNDhDQjlGMjZGN0VEOEM5QTYwNjggQjIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAS6N5V2fT-agh34bRiW--Wl6CQPSsnLqqSEID0t5RRKjjl1NDI__mzuyYuOrWyb5yzGZRHgnHq65cm2ROpxo6AOo4HwMIHtMB0GA1UdDgQWBBQ6CEDC5W8_zAMOhVgV8wHJI8n3bzAfBgNVHSMEGDAWgBRBa7ZL76IZDeRiX_0pBJa5gim0-DAJBgNVHRMEAjAAMAsGA1UdDwQEAwIE8DAyBggrBgEFBQcBAQQmMCQwIgYIKwYBBQUHMAKGFmh0dHA6Ly9pLnMycGtpLm5ldC9mMS8wJwYDVR0fBCAwHjAcoBqgGIYWaHR0cDovL2MuczJwa2kubmV0L3IxLzAhBgsrBgEEAYLlHAEBBAQSBBAjadTQE85Iy58m9-2MmmBoMBMGCysGAQQBguUcAgEBBAQDAgQwMAoGCCqGSM49BAMCA0kAMEYCIQCP82Rolr0U2FvOJq53AZYcA6xfC4-cNDczvf0FtU1SQAIhAIvb21Z3D8RCvwk2-Ryn4wpsGnn2vma6Bw3E1f48hyVwaGF1dGhEYXRhWQFtarm78N-aFvkduzO7sTL6-dF8eCxIJsbscOzuWNl-9SpBAAAAJyNp1NATzkjLnyb37YyaYGgBDKMAWOhefOe7XWvT4OYhTQoOpLB6RjmIazaiJ-OqZL4RDCiIDRnCkvrwxgFBK6KtPlR55dS4c0JD0UJmAUx4xnKSymSki2tptgDSPvdR4186CXf8xTohJ7uwg8EE33_Smerj5ce5FCviSTh2q_iMkSnDYXP5Didns4JZo9SWLiCS6AxMl5SpJL4hXcJNb21i5zt6f6FkTlHiIB_0uAi1SzyCV5D3tGLzIKdxErPQrKzepLzE8rFUSLf4eSlKqWaNEygi_es8BZNV_9j8AiylpjsVS9-ZSX1Cjhxva3N25ipamUemjoGY3q2OgaVPAUyZAKnzr3VZahXhHMsCUIL3kexTr51baKs3eaGhMIykAQEDJyAGIVggjz9UkJ7cKooE3blSuzlqxkdLppMuFl3CIiST8odWS6k", + "clientDataJSON":"eyJ0eXBlIjoid2ViYXV0aG4uY3JlYXRlIiwiY2hhbGxlbmdlIjoiQ1dieENUMEc0TDJ5T1JwQkw2U1dWaWd3ZTJrUUVYQmhvNUw2d0U0Ny1FcyIsIm9yaWdpbiI6Imh0dHBzOi8vd2ViYXV0aG4uZmlyc3R5ZWFyLmlkLmF1IiwiY3Jvc3NPcmlnaW4iOmZhbHNlfQ" + }, + "type":"public-key" + }`, +} diff --git a/protocol/attestation_safetynet.go b/protocol/attestation_safetynet.go index 311c5df3..c9eeb7ba 100644 --- a/protocol/attestation_safetynet.go +++ b/protocol/attestation_safetynet.go @@ -8,10 +8,10 @@ import ( "fmt" "time" - "github.com/golang-jwt/jwt/v4" - "github.com/mitchellh/mapstructure" - "github.com/go-webauthn/webauthn/metadata" + + jwt "github.com/golang-jwt/jwt/v4" + "github.com/mitchellh/mapstructure" ) var safetyNetAttestationKey = "android-safetynet" @@ -36,7 +36,9 @@ type SafetyNetResponse struct { // When the authenticator in question is a platform-provided Authenticator on certain Android platforms, the attestation // statement is based on the SafetyNet API. In this case the authenticator data is completely controlled by the caller of // the SafetyNet API (typically an application running on the Android platform) and the attestation statement only provides -// some statements about the health of the platform and the identity of the calling application. This attestation does not +// +// some statements about the health of the platform and the identity of the calling application. This attestation does not +// // provide information regarding provenance of the authenticator and its associated data. Therefore platform-provided // authenticators SHOULD make use of the Android Key Attestation when available, even if the SafetyNet API is also present. func verifySafetyNetFormat(att AttestationObject, clientDataHash []byte) (string, []interface{}, error) { @@ -58,44 +60,36 @@ func verifySafetyNetFormat(att AttestationObject, clientDataHash []byte) (string // §8.5.2 Verify that response is a valid SafetyNet response of version ver. version, present := att.AttStatement["ver"].(string) if !present { - return safetyNetAttestationKey, nil, ErrAttestationFormat.WithDetails("Unable to find the version of SafetyNet") + return "", nil, ErrAttestationFormat.WithDetails("Unable to find the version of SafetyNet") } if version == "" { - return safetyNetAttestationKey, nil, ErrAttestationFormat.WithDetails("Not a proper version for SafetyNet") + return "", nil, ErrAttestationFormat.WithDetails("Not a proper version for SafetyNet") } // TODO: provide user the ability to designate their supported versions response, present := att.AttStatement["response"].([]byte) if !present { - return safetyNetAttestationKey, nil, ErrAttestationFormat.WithDetails("Unable to find the SafetyNet response") + return "", nil, ErrAttestationFormat.WithDetails("Unable to find the SafetyNet response") } token, err := jwt.Parse(string(response), func(token *jwt.Token) (interface{}, error) { chain := token.Header["x5c"].([]interface{}) - o := make([]byte, base64.StdEncoding.DecodedLen(len(chain[0].(string)))) - n, err := base64.StdEncoding.Decode(o, []byte(chain[0].(string))) - if err != nil { - return nil, err - } - cert, err := x509.ParseCertificate(o[:n]) - return cert.PublicKey, err }) - if err != nil { - return safetyNetAttestationKey, nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Error finding cert issued to correct hostname: %+v", err)) + return "", nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Error finding cert issued to correct hostname: %+v", err)) } // marshall the JWT payload into the safetynet response json var safetyNetResponse SafetyNetResponse err = mapstructure.Decode(token.Claims, &safetyNetResponse) if err != nil { - return safetyNetAttestationKey, nil, ErrAttestationFormat.WithDetails(fmt.Sprintf("Error parsing the SafetyNet response: %+v", err)) + return "", nil, ErrAttestationFormat.WithDetails(fmt.Sprintf("Error parsing the SafetyNet response: %+v", err)) } // §8.5.3 Verify that the nonce in the response is identical to the Base64 encoding of the SHA-256 hash of the concatenation @@ -103,7 +97,7 @@ func verifySafetyNetFormat(att AttestationObject, clientDataHash []byte) (string nonceBuffer := sha256.Sum256(append(att.RawAuthData, clientDataHash...)) nonceBytes, err := base64.StdEncoding.DecodeString(safetyNetResponse.Nonce) if !bytes.Equal(nonceBuffer[:], nonceBytes) || err != nil { - return safetyNetAttestationKey, nil, ErrInvalidAttestation.WithDetails("Invalid nonce for in SafetyNet response") + return "", nil, ErrInvalidAttestation.WithDetails("Invalid nonce for in SafetyNet response") } // §8.5.4 Let attestationCert be the attestation certificate (https://www.w3.org/TR/webauthn/#attestation-certificate) @@ -111,22 +105,22 @@ func verifySafetyNetFormat(att AttestationObject, clientDataHash []byte) (string l := make([]byte, base64.StdEncoding.DecodedLen(len(certChain[0].(string)))) n, err := base64.StdEncoding.Decode(l, []byte(certChain[0].(string))) if err != nil { - return safetyNetAttestationKey, nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Error finding cert issued to correct hostname: %+v", err)) + return "", nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Error finding cert issued to correct hostname: %+v", err)) } attestationCert, err := x509.ParseCertificate(l[:n]) if err != nil { - return safetyNetAttestationKey, nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Error finding cert issued to correct hostname: %+v", err)) + return "", nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Error finding cert issued to correct hostname: %+v", err)) } // §8.5.5 Verify that attestationCert is issued to the hostname "attest.android.com" err = attestationCert.VerifyHostname("attest.android.com") if err != nil { - return safetyNetAttestationKey, nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Error finding cert issued to correct hostname: %+v", err)) + return "", nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Error finding cert issued to correct hostname: %+v", err)) } // §8.5.6 Verify that the ctsProfileMatch attribute in the payload of response is true. if !safetyNetResponse.CtsProfileMatch { - return safetyNetAttestationKey, nil, ErrInvalidAttestation.WithDetails("ctsProfileMatch attribute of the JWT payload is false") + return "", nil, ErrInvalidAttestation.WithDetails("ctsProfileMatch attribute of the JWT payload is false") } // Verify sanity of timestamp in the payload @@ -135,17 +129,17 @@ func verifySafetyNetFormat(att AttestationObject, clientDataHash []byte) (string t := time.Unix(safetyNetResponse.TimestampMs/1000, 0) if t.After(now) { // zero tolerance for post-dated timestamps - return "Basic attestation with SafetyNet", nil, ErrInvalidAttestation.WithDetails("SafetyNet response with timestamp after current time") + return "", nil, ErrInvalidAttestation.WithDetails("SafetyNet response with timestamp after current time") } else if t.Before(oneMinuteAgo) { // allow old timestamp for testing purposes // TODO: Make this user configurable msg := "SafetyNet response with timestamp before one minute ago" if metadata.Conformance { - return "Basic attestation with SafetyNet", nil, ErrInvalidAttestation.WithDetails(msg) + return "", nil, ErrInvalidAttestation.WithDetails(msg) } } // §8.5.7 If successful, return implementation-specific values representing attestation type Basic and attestation // trust path attestationCert. - return "Basic attestation with SafetyNet", nil, nil + return string(metadata.BasicFull), nil, nil } diff --git a/protocol/attestation_safetynet_test.go b/protocol/attestation_safetynet_test.go index ba99dbfa..304a8819 100644 --- a/protocol/attestation_safetynet_test.go +++ b/protocol/attestation_safetynet_test.go @@ -4,6 +4,8 @@ import ( "crypto/sha256" "reflect" "testing" + + "github.com/go-webauthn/webauthn/metadata" ) func Test_verifySafetyNetFormat(t *testing.T) { @@ -12,7 +14,7 @@ func Test_verifySafetyNetFormat(t *testing.T) { clientDataHash []byte } successAttResponse := attestationTestUnpackResponse(t, safetyNetTestResponse["success"]).Response.AttestationObject - successClienDataHash := sha256.Sum256(attestationTestUnpackResponse(t, safetyNetTestResponse["success"]).Raw.AttestationResponse.ClientDataJSON) + successClientDataHash := sha256.Sum256(attestationTestUnpackResponse(t, safetyNetTestResponse["success"]).Raw.AttestationResponse.ClientDataJSON) tests := []struct { name string args args @@ -24,9 +26,9 @@ func Test_verifySafetyNetFormat(t *testing.T) { "success", args{ successAttResponse, - successClienDataHash[:], + successClientDataHash[:], }, - "Basic attestation with SafetyNet", + string(metadata.BasicFull), nil, false, }, diff --git a/protocol/attestation_tpm.go b/protocol/attestation_tpm.go index 971f0372..90f9532b 100644 --- a/protocol/attestation_tpm.go +++ b/protocol/attestation_tpm.go @@ -10,8 +10,10 @@ import ( "math/big" "strings" - "github.com/go-webauthn/webauthn/protocol/googletpm" + "github.com/go-webauthn/webauthn/metadata" "github.com/go-webauthn/webauthn/protocol/webauthncose" + + "github.com/go-webauthn/webauthn/protocol/googletpm" ) var tpmAttestationKey = "tpm" @@ -30,16 +32,16 @@ func verifyTPMFormat(att AttestationObject, clientDataHash []byte) (string, []in ver, present := att.AttStatement["ver"].(string) if !present { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("Error retreiving ver value") + return "", nil, ErrAttestationFormat.WithDetails("Error retreiving ver value") } if ver != "2.0" { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("WebAuthn only supports TPM 2.0 currently") + return "", nil, ErrAttestationFormat.WithDetails("WebAuthn only supports TPM 2.0 currently") } alg, present := att.AttStatement["alg"].(int64) if !present { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("Error retreiving alg value") + return "", nil, ErrAttestationFormat.WithDetails("Error retreiving alg value") } coseAlg := webauthncose.COSEAlgorithmIdentifier(alg) @@ -47,54 +49,53 @@ func verifyTPMFormat(att AttestationObject, clientDataHash []byte) (string, []in x5c, x509present := att.AttStatement["x5c"].([]interface{}) if !x509present { // Handle Basic Attestation steps for the x509 Certificate - return tpmAttestationKey, nil, ErrNotImplemented + return "", nil, ErrNotImplemented } _, ecdaaKeyPresent := att.AttStatement["ecdaaKeyId"].([]byte) if ecdaaKeyPresent { - return tpmAttestationKey, nil, ErrNotImplemented + return "", nil, ErrNotImplemented } sigBytes, present := att.AttStatement["sig"].([]byte) if !present { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("Error retreiving sig value") + return "", nil, ErrAttestationFormat.WithDetails("Error retreiving sig value") } certInfoBytes, present := att.AttStatement["certInfo"].([]byte) if !present { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("Error retreiving certInfo value") + return "", nil, ErrAttestationFormat.WithDetails("Error retreiving certInfo value") } pubAreaBytes, present := att.AttStatement["pubArea"].([]byte) if !present { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("Error retreiving pubArea value") + return "", nil, ErrAttestationFormat.WithDetails("Error retreiving pubArea value") } // Verify that the public key specified by the parameters and unique fields of pubArea // is identical to the credentialPublicKey in the attestedCredentialData in authenticatorData. pubArea, err := googletpm.DecodePublic(pubAreaBytes) if err != nil { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("Unable to decode TPMT_PUBLIC in attestation statement") + return "", nil, ErrAttestationFormat.WithDetails("Unable to decode TPMT_PUBLIC in attestation statement") } key, err := webauthncose.ParsePublicKey(att.AuthData.AttData.CredentialPublicKey) if err != nil { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails(fmt.Sprintf("Public Key could not be parsed in the COSE format: %v", err)) + return tpmAttestationKey, nil, err } - - switch k := key.(type) { + switch key := key.(type) { case webauthncose.EC2PublicKeyData: - if pubArea.ECCParameters.CurveID != k.TPMCurveID() || - pubArea.ECCParameters.Point.X.Cmp(new(big.Int).SetBytes(k.XCoord)) != 0 || - pubArea.ECCParameters.Point.Y.Cmp(new(big.Int).SetBytes(k.YCoord)) != 0 { + if pubArea.ECCParameters.CurveID != key.TPMCurveID() || + pubArea.ECCParameters.Point.X.Cmp(new(big.Int).SetBytes(key.XCoord)) != 0 || + pubArea.ECCParameters.Point.Y.Cmp(new(big.Int).SetBytes(key.YCoord)) != 0 { return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("Mismatch between ECCParameters in pubArea and credentialPublicKey") } case webauthncose.RSAPublicKeyData: - mod := new(big.Int).SetBytes(k.Modulus) - exp := uint32(k.Exponent[0]) + uint32(k.Exponent[1])<<8 + uint32(k.Exponent[2])<<16 + mod := new(big.Int).SetBytes(key.Modulus) + exp := uint32(key.Exponent[0]) + uint32(key.Exponent[1])<<8 + uint32(key.Exponent[2])<<16 if pubArea.RSAParameters.Modulus.Cmp(mod) != 0 || pubArea.RSAParameters.Exponent != exp { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("Mismatch between RSAParameters in pubArea and credentialPublicKey") + return "", nil, ErrAttestationFormat.WithDetails("Mismatch between RSAParameters in pubArea and credentialPublicKey") } default: return "", nil, ErrUnsupportedKey @@ -106,16 +107,15 @@ func verifyTPMFormat(att AttestationObject, clientDataHash []byte) (string, []in // Validate that certInfo is valid: certInfo, err := googletpm.DecodeAttestationData(certInfoBytes) if err != nil { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails(fmt.Sprintf("Could not decode Attestation data, %v", err)) + return tpmAttestationKey, nil, err } - // 1/4 Verify that magic is set to TPM_GENERATED_VALUE. if certInfo.Magic != 0xff544347 { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("Magic is not set to TPM_GENERATED_VALUE") + return "", nil, ErrAttestationFormat.WithDetails("Magic is not set to TPM_GENERATED_VALUE") } // 2/4 Verify that type is set to TPM_ST_ATTEST_CERTIFY. if certInfo.Type != googletpm.TagAttestCertify { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("Type is not set to TPM_ST_ATTEST_CERTIFY") + return "", nil, ErrAttestationFormat.WithDetails("Type is not set to TPM_ST_ATTEST_CERTIFY") } // 3/4 Verify that extraData is set to the hash of attToBeSigned using the hash algorithm employed in "alg". f := webauthncose.HasherFromCOSEAlg(coseAlg) @@ -145,28 +145,29 @@ func verifyTPMFormat(att AttestationObject, clientDataHash []byte) (string, []in // Verify the sig is a valid signature over certInfo using the attestation public key in aikCert with the algorithm specified in alg. aikCertBytes, valid := x5c[0].([]byte) if !valid { - return tpmAttestationKey, nil, ErrAttestation.WithDetails("Error getting certificate from x5c cert chain") + return "", nil, ErrAttestation.WithDetails("Error getting certificate from x5c cert chain") } aikCert, err := x509.ParseCertificate(aikCertBytes) if err != nil { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("Error parsing certificate from ASN.1") + return "", nil, ErrAttestationFormat.WithDetails("Error parsing certificate from ASN.1") } sigAlg := webauthncose.SigAlgFromCOSEAlg(coseAlg) - if err = aikCert.CheckSignature(x509.SignatureAlgorithm(sigAlg), certInfoBytes, sigBytes); err != nil { - return tpmAttestationKey, nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Signature validation error: %+v", err)) + err = aikCert.CheckSignature(x509.SignatureAlgorithm(sigAlg), certInfoBytes, sigBytes) + if err != nil { + return "", nil, ErrAttestationFormat.WithDetails(fmt.Sprintf("Signature validation error: %+v\n", err)) } // Verify that aikCert meets the requirements in §8.3.1 TPM Attestation Statement Certificate Requirements // 1/6 Version MUST be set to 3. if aikCert.Version != 3 { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("AIK certificate version must be 3") + return "", nil, ErrAttestationFormat.WithDetails("AIK certificate version must be 3") } // 2/6 Subject field MUST be set to empty. if aikCert.Subject.String() != "" { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("AIK certificate subject must be empty") + return "", nil, ErrAttestationFormat.WithDetails("AIK certificate subject must be empty") } // 3/6 The Subject Alternative Name extension MUST be set as defined in [TPMv2-EK-Profile] section 3.2.9{} @@ -181,7 +182,7 @@ func verifyTPMFormat(att AttestationObject, clientDataHash []byte) (string, []in } if manufacturer == "" || model == "" || version == "" { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("Invalid SAN data in AIK certificate") + return "", nil, ErrAttestationFormat.WithDetails("Invalid SAN data in AIK certificate") } if !isValidTPMManufacturer(manufacturer) { @@ -195,7 +196,7 @@ func verifyTPMFormat(att AttestationObject, clientDataHash []byte) (string, []in if ext.Id.Equal([]int{2, 5, 29, 37}) { rest, err := asn1.Unmarshal(ext.Value, &eku) if len(rest) != 0 || err != nil || !eku[0].Equal(tcgKpAIKCertificate) { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("AIK certificate EKU missing 2.23.133.8.3") + return "", nil, ErrAttestationFormat.WithDetails("AIK certificate EKU missing 2.23.133.8.3") } ekuValid = true } @@ -213,13 +214,12 @@ func verifyTPMFormat(att AttestationObject, clientDataHash []byte) (string, []in for _, ext := range aikCert.Extensions { if ext.Id.Equal([]int{2, 5, 29, 19}) { if rest, err := asn1.Unmarshal(ext.Value, &constraints); err != nil { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("AIK certificate basic constraints malformed") + return "", nil, ErrAttestationFormat.WithDetails("AIK certificate basic constraints malformed") } else if len(rest) != 0 { - return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("AIK certificate basic constraints contains extra data") + return "", nil, ErrAttestationFormat.WithDetails("AIK certificate basic constraints contains extra data") } } } - if constraints.IsCA { return tpmAttestationKey, nil, ErrAttestationFormat.WithDetails("AIK certificate basic constraints missing or CA is true") } @@ -228,9 +228,8 @@ func verifyTPMFormat(att AttestationObject, clientDataHash []byte) (string, []in // through metadata services. See, for example, the FIDO Metadata Service. } - return tpmAttestationKey, x5c, err + return string(metadata.AttCA), x5c, err } - func forEachSAN(extension []byte, callback func(tag int, data []byte) error) error { // RFC 5280, 4.2.1.6 diff --git a/protocol/attestation_tpm_test.go b/protocol/attestation_tpm_test.go index b52d9a6c..55d9c43f 100644 --- a/protocol/attestation_tpm_test.go +++ b/protocol/attestation_tpm_test.go @@ -18,7 +18,7 @@ func TestTPMAttestationVerificationSuccess(t *testing.T) { if err != nil { t.Fatalf("Not valid: %+v", err) } - assert.Equal(t, "tpm", attestationKey) + assert.Equal(t, "attca", attestationKey) }) } } diff --git a/protocol/attestation_u2f.go b/protocol/attestation_u2f.go index 44c5de52..42ee0128 100644 --- a/protocol/attestation_u2f.go +++ b/protocol/attestation_u2f.go @@ -5,13 +5,14 @@ import ( "crypto/ecdsa" "crypto/elliptic" "crypto/x509" - "fmt" + "github.com/go-webauthn/webauthn/metadata" "github.com/go-webauthn/webauthn/protocol/webauthncbor" + "github.com/go-webauthn/webauthn/protocol/webauthncose" ) -var u2fAttestationKey = CredentialTypeFIDOU2F +var u2fAttestationKey = "fido-u2f" func init() { RegisterAttestationFormat(u2fAttestationKey, verifyU2FFormat) @@ -21,19 +22,15 @@ func init() { func verifyU2FFormat(att AttestationObject, clientDataHash []byte) (string, []interface{}, error) { if !bytes.Equal(att.AuthData.AttData.AAGUID, []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}) { - return u2fAttestationKey, nil, ErrUnsupportedAlgorithm.WithDetails("U2F attestation format AAGUID not set to 0x00") + return "", nil, ErrUnsupportedAlgorithm.WithDetails("U2F attestation format AAGUID not set to 0x00") } // Signing procedure step - If the credential public key of the given credential is not of // algorithm -7 ("ES256"), stop and return an error. key := webauthncose.EC2PublicKeyData{} - - err := webauthncbor.Unmarshal(att.AuthData.AttData.CredentialPublicKey, &key) - if err != nil { - return u2fAttestationKey, nil, ErrAttestationFormat.WithDetails(fmt.Sprintf("Could not unmarshal Credential Public Key: %v", err)) - } + webauthncbor.Unmarshal(att.AuthData.AttData.CredentialPublicKey, &key) if webauthncose.COSEAlgorithmIdentifier(key.PublicKeyData.Algorithm) != webauthncose.AlgES256 { - return u2fAttestationKey, nil, ErrUnsupportedAlgorithm.WithDetails("Non-ES256 Public Key algorithm used") + return "", nil, ErrUnsupportedAlgorithm.WithDetails("Non-ES256 Public Key algorithm used") } // U2F Step 1. Verify that attStmt is valid CBOR conforming to the syntax defined above @@ -48,7 +45,7 @@ func verifyU2FFormat(att AttestationObject, clientDataHash []byte) (string, []in // Check for "x5c" which is a single element array containing the attestation certificate in X.509 format. x5c, present := att.AttStatement["x5c"].([]interface{}) if !present { - return u2fAttestationKey, nil, ErrAttestationFormat.WithDetails("Missing properly formatted x5c data") + return "", nil, ErrAttestationFormat.WithDetails("Missing properly formatted x5c data") } // Check for "sig" which is The attestation signature. The signature was calculated over the (raw) U2F @@ -56,7 +53,7 @@ func verifyU2FFormat(att AttestationObject, clientDataHash []byte) (string, []in // received by the client from the authenticator. signature, present := att.AttStatement["sig"].([]byte) if !present { - return u2fAttestationKey, nil, ErrAttestationFormat.WithDetails("Missing sig data") + return "", nil, ErrAttestationFormat.WithDetails("Missing sig data") } // U2F Step 2. (1) Check that x5c has exactly one element and let attCert be that element. (2) Let certificate public @@ -65,7 +62,7 @@ func verifyU2FFormat(att AttestationObject, clientDataHash []byte) (string, []in // Step 2.1 if len(x5c) > 1 { - return u2fAttestationKey, nil, ErrAttestationFormat.WithDetails("Received more than one element in x5c values") + return "", nil, ErrAttestationFormat.WithDetails("Received more than one element in x5c values") } // Note: Packed Attestation, FIDO U2F Attestation, and Assertion Signatures support ASN.1,but it is recommended @@ -77,17 +74,17 @@ func verifyU2FFormat(att AttestationObject, clientDataHash []byte) (string, []in // Step 2.2 asn1Bytes, decoded := x5c[0].([]byte) if !decoded { - return u2fAttestationKey, nil, ErrAttestationFormat.WithDetails("Error decoding ASN.1 data from x5c") + return "", nil, ErrAttestationFormat.WithDetails("Error decoding ASN.1 data from x5c") } attCert, err := x509.ParseCertificate(asn1Bytes) if err != nil { - return u2fAttestationKey, nil, ErrAttestationFormat.WithDetails("Error parsing certificate from ASN.1 data into certificate") + return "", nil, ErrAttestationFormat.WithDetails("Error parsing certificate from ASN.1 data into certificate") } // Step 2.3 if attCert.PublicKeyAlgorithm != x509.ECDSA && attCert.PublicKey.(*ecdsa.PublicKey).Curve != elliptic.P256() { - return u2fAttestationKey, nil, ErrAttestationFormat.WithDetails("Attestation certificate is in invalid format") + return "", nil, ErrAttestationFormat.WithDetails("Attestation certificate is in invalid format") } // Step 3. Extract the claimed rpIdHash from authenticatorData, and the claimed credentialId and credentialPublicKey @@ -112,7 +109,7 @@ func verifyU2FFormat(att AttestationObject, clientDataHash []byte) (string, []in // return an appropriate error. if len(key.XCoord) > 32 || len(key.YCoord) > 32 { - return u2fAttestationKey, nil, ErrAttestation.WithDetails("X or Y Coordinate for key is invalid length") + return "", nil, ErrAttestation.WithDetails("X or Y Coordinate for key is invalid length") } // Let publicKeyU2F be the concatenation 0x04 || x || y. @@ -130,10 +127,11 @@ func verifyU2FFormat(att AttestationObject, clientDataHash []byte) (string, []in verificationData.Write(publicKeyU2F.Bytes()) // Step 6. Verify the sig using verificationData and certificate public key per SEC1[https://www.w3.org/TR/webauthn/#biblio-sec1]. - if err = attCert.CheckSignature(x509.ECDSAWithSHA256, verificationData.Bytes(), signature); err != nil { - return u2fAttestationKey, nil, ErrInvalidAttestation.WithDetails(fmt.Sprintf("Signature validation error: %+v", err)) + sigErr := attCert.CheckSignature(x509.ECDSAWithSHA256, verificationData.Bytes(), signature) + if sigErr != nil { + return "", nil, sigErr } // Step 7. If successful, return attestation type Basic with the attestation trust path set to x5c. - return "Fido U2F Basic", x5c, nil + return string(metadata.BasicFull), x5c, sigErr } diff --git a/protocol/attestation_u2f_test.go b/protocol/attestation_u2f_test.go new file mode 100644 index 00000000..61950472 --- /dev/null +++ b/protocol/attestation_u2f_test.go @@ -0,0 +1,62 @@ +package protocol + +import ( + "crypto/sha256" + "testing" + + "github.com/go-webauthn/webauthn/metadata" +) + +func TestVerifyU2FFormat(t *testing.T) { + type args struct { + att AttestationObject + clientDataHash []byte + } + successAttResponse := attestationTestUnpackResponse(t, u2fTestResponse["success"]).Response.AttestationObject + successClientDataHash := sha256.Sum256(attestationTestUnpackResponse(t, u2fTestResponse["success"]).Raw.AttestationResponse.ClientDataJSON) + tests := []struct { + name string + args args + want string + want1 []interface{} + wantErr bool + }{ + { + "success", + args{ + successAttResponse, + successClientDataHash[:], + }, + string(metadata.BasicFull), + nil, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, _, err := verifyU2FFormat(tt.args.att, tt.args.clientDataHash) + if (err != nil) != tt.wantErr { + t.Errorf("verifyU2FFormat() error = %v, wantErr %v", err, tt.wantErr) + return + } + if got != tt.want { + t.Errorf("verifyU2FFormat() got = %v, want %v", got, tt.want) + } + //if !reflect.DeepEqual(got1, tt.want1) { + // t.Errorf("verifyU2FFormat() got1 = %v, want %v", got1, tt.want1) + //} + }) + } +} + +var u2fTestResponse = map[string]string{ + `success`: `{ + "rawId": "7nJsttr4dLSsmrWnaHB3espJ0ua9rsJ2ws-93BFcNOP64g_s_4wLFDvklrNYcg0BCN6ddUjJLxDfDSBreKQLAw", + "id": "7nJsttr4dLSsmrWnaHB3espJ0ua9rsJ2ws-93BFcNOP64g_s_4wLFDvklrNYcg0BCN6ddUjJLxDfDSBreKQLAw", + "response": { + "clientDataJSON": "eyJjaGFsbGVuZ2UiOiJhTDJ1d0FwZ3d1bUJ6VFlDY29MMF80RFJ2X21mWXlremdxSkJGb0pqX1dDS05aT3B2VVFueWpkd01XSVdLY1k4NDR0eUROTE81cFFQQk1KckhQel8zZyIsImNsaWVudEV4dGVuc2lvbnMiOnt9LCJoYXNoQWxnb3JpdGhtIjoiU0hBLTI1NiIsIm9yaWdpbiI6Imh0dHBzOi8vbG9jYWxob3N0OjQ0MzI5IiwidHlwZSI6IndlYmF1dGhuLmNyZWF0ZSJ9", + "attestationObject": "o2NmbXRoZmlkby11MmZnYXR0U3RtdKJjc2lnWEcwRQIgRMxowC__Z-mgVR6netL6C7Q15weqiTCPwwq1EaeJVqMCIQCHb9cCad1VloGhQ60mw7KTJhkx61mfgKKwHUVZf1wR6mN4NWOBWQLCMIICvjCCAaagAwIBAgIEdIb9wjANBgkqhkiG9w0BAQsFADAuMSwwKgYDVQQDEyNZdWJpY28gVTJGIFJvb3QgQ0EgU2VyaWFsIDQ1NzIwMDYzMTAgFw0xNDA4MDEwMDAwMDBaGA8yMDUwMDkwNDAwMDAwMFowbzELMAkGA1UEBhMCU0UxEjAQBgNVBAoMCVl1YmljbyBBQjEiMCAGA1UECwwZQXV0aGVudGljYXRvciBBdHRlc3RhdGlvbjEoMCYGA1UEAwwfWXViaWNvIFUyRiBFRSBTZXJpYWwgMTk1NTAwMzg0MjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJVd8633JH0xde_9nMTzGk6HjrrhgQlWYVD7OIsuX2Unv1dAmqWBpQ0KxS8YRFwKE1SKE1PIpOWacE5SO8BN6-2jbDBqMCIGCSsGAQQBgsQKAgQVMS4zLjYuMS40LjEuNDE0ODIuMS4xMBMGCysGAQQBguUcAgEBBAQDAgUgMCEGCysGAQQBguUcAQEEBBIEEPigEfOMCk0VgAYXER-e3H0wDAYDVR0TAQH_BAIwADANBgkqhkiG9w0BAQsFAAOCAQEAMVxIgOaaUn44Zom9af0KqG9J655OhUVBVW-q0As6AIod3AH5bHb2aDYakeIyyBCnnGMHTJtuekbrHbXYXERIn4aKdkPSKlyGLsA_A-WEi-OAfXrNVfjhrh7iE6xzq0sg4_vVJoywe4eAJx0fS-Dl3axzTTpYl71Nc7p_NX6iCMmdik0pAuYJegBcTckE3AoYEg4K99AM_JaaKIblsbFh8-3LxnemeNf7UwOczaGGvjS6UzGVI0Odf9lKcPIwYhuTxM5CaNMXTZQ7xq4_yTfC3kPWtE4hFT34UJJflZBiLrxG4OsYxkHw_n5vKgmpspB3GfYuYTWhkDKiE8CYtyg87mhhdXRoRGF0YVjESZYN5YgOjGh0NBcPZHZgW4_krrmihjLHmVzzuoMdl2NBAAAAAAAAAAAAAAAAAAAAAAAAAAAAQO5ybLba-HS0rJq1p2hwd3rKSdLmva7CdsLPvdwRXDTj-uIP7P-MCxQ75JazWHINAQjenXVIyS8Q3w0ga3ikCwOlAQIDJiABIVggUOAo5xqsJoPfJWsU50h7c2S7_llP0KwGI6vJkEj1N48iWCA2TMSeBfhJ84HyMQQgjJvBiA6JnHA0chxSlmuZeT9Xgg" + }, + "type": "public-key" + }`, +} diff --git a/protocol/webauthncose/webauthncose.go b/protocol/webauthncose/webauthncose.go index 9c566944..3e066205 100644 --- a/protocol/webauthncose/webauthncose.go +++ b/protocol/webauthncose/webauthncose.go @@ -8,7 +8,6 @@ import ( "crypto/x509" "encoding/asn1" "encoding/pem" - "fmt" "hash" "math/big" @@ -159,60 +158,37 @@ func HasherFromCOSEAlg(coseAlg COSEAlgorithmIdentifier) func() hash.Hash { } // Figure out what kind of COSE material was provided and create the data for the new key -func ParsePublicKey(keyBytes []byte) (k interface{}, err error) { +func ParsePublicKey(keyBytes []byte) (interface{}, error) { pk := PublicKeyData{} - - if err = webauthncbor.Unmarshal(keyBytes, &pk); err != nil { - return nil, ErrUnsupportedKey.WithDetails(fmt.Sprintf("Could not unmarshall Public Key data: %v", err)) - } - + webauthncbor.Unmarshal(keyBytes, &pk) switch COSEKeyType(pk.KeyType) { case OctetKey: var o OKPPublicKeyData - - if err = webauthncbor.Unmarshal(keyBytes, &o); err != nil { - return nil, ErrUnsupportedKey.WithDetails(fmt.Sprintf("Could not unmarshall OK Public Key data: %v", err)) - } - + webauthncbor.Unmarshal(keyBytes, &o) o.PublicKeyData = pk - return o, nil case EllipticKey: var e EC2PublicKeyData - - if err = webauthncbor.Unmarshal(keyBytes, &e); err != nil { - return nil, ErrUnsupportedKey.WithDetails(fmt.Sprintf("Could not unmarshall EC2 Public Key data: %v", err)) - } - + webauthncbor.Unmarshal(keyBytes, &e) e.PublicKeyData = pk - return e, nil case RSAKey: var r RSAPublicKeyData - - if err = webauthncbor.Unmarshal(keyBytes, &r); err != nil { - return nil, ErrUnsupportedKey.WithDetails(fmt.Sprintf("Could not unmarshall RSA Public Key data: %v", err)) - } - + webauthncbor.Unmarshal(keyBytes, &r) r.PublicKeyData = pk - return r, nil default: return nil, ErrUnsupportedKey } } -func ParseFIDOPublicKey(keyBytes []byte) (interface{}, error) { +// ParseFIDOPublicKey is only used when the appID extension is configured by the assertion response. +func ParseFIDOPublicKey(keyBytes []byte) (EC2PublicKeyData, error) { x, y := elliptic.Unmarshal(elliptic.P256(), keyBytes) - if x == nil || y == nil { - return nil, ErrUnsupportedKey.WithDetails("Could not unmarshall EC2 Public Key data") - } - return EC2PublicKeyData{ PublicKeyData: PublicKeyData{ Algorithm: int64(AlgES256), - KeyType: int64(EllipticKey), }, XCoord: x.Bytes(), YCoord: y.Bytes(), @@ -249,18 +225,27 @@ const ( AlgPS512 COSEAlgorithmIdentifier = -39 // AlgEdDSA EdDSA AlgEdDSA COSEAlgorithmIdentifier = -8 + // ECDSA using secp256k1 curve and SHA-256 + AlgES256K COSEAlgorithmIdentifier = -47 ) // The Key Type derived from the IANA COSE AuthData type COSEKeyType int const ( + // Reserved value + KeyTypeReserved COSEKeyType = iota // OctetKey is an Octet Key - OctetKey COSEKeyType = 1 + OctetKey // EllipticKey is an Elliptic Curve Public Key - EllipticKey COSEKeyType = 2 + EllipticKey // RSAKey is an RSA Public Key - RSAKey COSEKeyType = 3 + RSAKey + // Symmetric Keys + Symmetric + // Public key for HSS/LMS hash-based digital signature + HSSLMS + // WalnutDSA public key ) // The COSE Elliptic Curves @@ -268,22 +253,24 @@ const ( type COSEEllipticCurve int const ( - // EC2 NIST P-256 also known as secp256r1 - P256 COSEEllipticCurve = 1 - // EC2 NIST P-384 also known as secp384r1 - P384 COSEEllipticCurve = 2 - // EC2 NIST P-521 also known as secp521r1 - P521 COSEEllipticCurve = 3 - // OKP X25519 for use w/ ECDH only - X25519 COSEEllipticCurve = 4 - // OKP X448 for use w/ ECDH only - X448 COSEEllipticCurve = 5 - // OKP Ed25519 for use w/ EdDSA only - Ed25519 COSEEllipticCurve = 6 - // OKP Ed448 for use w/ EdDSA only - Ed448 COSEEllipticCurve = 7 - // EC2 SECG secp256k1 curve - secp256k1 COSEEllipticCurve = 8 + // Reserved value + EllipticCurveReserved COSEEllipticCurve = iota + // NIST P-256 also known as secp256r1 + P256 + // NIST P-384 also known as secp384r1 + P384 + // NIST P-521 also known as secp521r1 + P521 + // X25519 for use w/ ECDH only + X25519 + // X448 for use w/ ECDH only + X448 + // Ed25519 for use w/ EdDSA only + Ed25519 + // Ed448 for use w/ EdDSA only + Ed448 + // SECG secp256k1 curve + Secp256k1 ) func (k *EC2PublicKeyData) TPMCurveID() googletpm.EllipticCurve { @@ -300,13 +287,17 @@ func (k *EC2PublicKeyData) TPMCurveID() googletpm.EllipticCurve { } func VerifySignature(key interface{}, data []byte, sig []byte) (bool, error) { - switch k := key.(type) { + + switch key.(type) { case OKPPublicKeyData: - return k.Verify(data, sig) + o := key.(OKPPublicKeyData) + return o.Verify(data, sig) case EC2PublicKeyData: - return k.Verify(data, sig) + e := key.(EC2PublicKeyData) + return e.Verify(data, sig) case RSAPublicKeyData: - return k.Verify(data, sig) + r := key.(RSAPublicKeyData) + return r.Verify(data, sig) default: return false, ErrUnsupportedKey } @@ -317,27 +308,25 @@ func DisplayPublicKey(cpk []byte) string { if err != nil { return "Cannot display key" } - switch pKey := parsedKey.(type) { + switch parsedKey.(type) { case RSAPublicKeyData: + pKey := parsedKey.(RSAPublicKeyData) rKey := &rsa.PublicKey{ N: big.NewInt(0).SetBytes(pKey.Modulus), E: int(uint(pKey.Exponent[2]) | uint(pKey.Exponent[1])<<8 | uint(pKey.Exponent[0])<<16), } - data, err := x509.MarshalPKIXPublicKey(rKey) if err != nil { return "Cannot display key" } - pemBytes := pem.EncodeToMemory(&pem.Block{ Type: "RSA PUBLIC KEY", Bytes: data, }) - return string(pemBytes) case EC2PublicKeyData: + pKey := parsedKey.(EC2PublicKeyData) var curve elliptic.Curve - switch COSEAlgorithmIdentifier(pKey.Algorithm) { case AlgES256: curve = elliptic.P256() @@ -348,44 +337,37 @@ func DisplayPublicKey(cpk []byte) string { default: return "Cannot display key" } - eKey := &ecdsa.PublicKey{ Curve: curve, X: big.NewInt(0).SetBytes(pKey.XCoord), Y: big.NewInt(0).SetBytes(pKey.YCoord), } - data, err := x509.MarshalPKIXPublicKey(eKey) if err != nil { return "Cannot display key" } - pemBytes := pem.EncodeToMemory(&pem.Block{ Type: "PUBLIC KEY", Bytes: data, }) - return string(pemBytes) case OKPPublicKeyData: + pKey := parsedKey.(OKPPublicKeyData) if len(pKey.XCoord) != ed25519.PublicKeySize { return "Cannot display key" } - var oKey ed25519.PublicKey = make([]byte, ed25519.PublicKeySize) - copy(oKey, pKey.XCoord) - data, err := marshalEd25519PublicKey(oKey) if err != nil { return "Cannot display key" } - pemBytes := pem.EncodeToMemory(&pem.Block{ Type: "PUBLIC KEY", Bytes: data, }) - return string(pemBytes) + default: return "Cannot display key of this type" } diff --git a/testdata/MetadataTOCParsing-F1.jwt b/testdata/MetadataTOCParsing-F1.jwt deleted file mode 100755 index 98b8ee02..00000000 --- a/testdata/MetadataTOCParsing-F1.jwt +++ /dev/null @@ -1 +0,0 @@ -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.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.Y39V3S3YgMLbX1wq1sO823CRE1tL1bfUYHxYbVT6i8HDtzYATj7oatxFBIb3aKiZgYcSMTr_nfqEKxcS19lPBQ \ No newline at end of file diff --git a/testdata/MetadataTOCParsing-F2.jwt b/testdata/MetadataTOCParsing-F2.jwt deleted file mode 100755 index dca96c5d..00000000 --- a/testdata/MetadataTOCParsing-F2.jwt +++ /dev/null @@ -1 +0,0 @@ -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.{"legalHeader":"By using this metadata service, you are solemly swear not to do evil!","no":42,"nextUpdate":"2020-04-08","entries":[{"aaguid":"9256ec28-b4f0-4481-9a36-7d4249cb8d75","hash":"RyLo-7ga8Gg66hiilFskQcWCjfd0FQ9qlO_A7a3MyBc","url":"https://fidoalliance.co.nz/mds/metadata/9256ec28-b4f0-4481-9a36-7d4249cb8d75.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2014-11-26"}],"timeOfLastStatusChange":"2017-06-10"},{"aaguid":"f7ef9b25-f7f9-467a-aeaf-46217a02f236","hash":"NDPXOmqj7KzxTI8lQMCvFGJ_9fjrzWTG7RWzxWb9OW0","url":"https://fidoalliance.co.nz/mds/metadata/f7ef9b25-f7f9-467a-aeaf-46217a02f236.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2016-08-14"}],"timeOfLastStatusChange":"2017-10-22"},{"aaguid":"19e96de2-c61e-4819-82ee-9f4e2e66682d","hash":"eVhz1I4qlCLSI2CtTeMoaSJ7QAWzJFaskVzpFdsStuU","url":"https://fidoalliance.co.nz/mds/metadata/19e96de2-c61e-4819-82ee-9f4e2e66682d.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2014-08-10"}],"timeOfLastStatusChange":"2017-02-05"},{"aaguid":"83918b92-6b07-4ac4-bde6-e531a7b583db","hash":"cS5cNMriKsK74ip8YnxkeJtWaxTaR0Bk9of862r7wtg","url":"https://fidoalliance.co.nz/mds/metadata/83918b92-6b07-4ac4-bde6-e531a7b583db.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-10-21"}],"timeOfLastStatusChange":"2017-07-17"},{"aaguid":"296f1daa-97d0-4175-b791-3ce12817766a","hash":"VviBpv4RkaBjBHCvW1yxx5cdetKTX_phT6_4yrZYNlI","url":"https://fidoalliance.co.nz/mds/metadata/296f1daa-97d0-4175-b791-3ce12817766a.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2016-02-06"}],"timeOfLastStatusChange":"2017-11-11"},{"aaguid":"da9f50fe-baf5-415f-a249-0c099b0c5b8f","hash":"4n_IOrtAHcp74b60im1wMj4Nc06k9XW9rjnPutjnpf0","url":"https://fidoalliance.co.nz/mds/metadata/da9f50fe-baf5-415f-a249-0c099b0c5b8f.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2016-12-21"}],"timeOfLastStatusChange":"2017-10-02"},{"aaguid":"dd8fa8a5-3677-4818-bfcf-e5d90532cf1c","hash":"z1GWLAFvTtnqdoShi513KULcCrqd_SRjQ9N-ETwdqN4","url":"https://fidoalliance.co.nz/mds/metadata/dd8fa8a5-3677-4818-bfcf-e5d90532cf1c.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2015-10-27"}],"timeOfLastStatusChange":"2017-04-06"},{"aaguid":"b9f9b9ab-8871-4920-b25a-8707af68a663","hash":"zeHy27iK-9fPe_W3K4jVPPGBnSo5g5IpBAhEw2Br53s","url":"https://fidoalliance.co.nz/mds/metadata/b9f9b9ab-8871-4920-b25a-8707af68a663.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2015-02-10"}],"timeOfLastStatusChange":"2017-11-10"},{"aaguid":"5508a2ab-681c-4c5e-af75-d8f9082140f7","hash":"C7er2KADqD-RHkrTUU0gR57Ni_3dvgIGEupKysnSj0I","url":"https://fidoalliance.co.nz/mds/metadata/5508a2ab-681c-4c5e-af75-d8f9082140f7.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2015-06-12"}],"timeOfLastStatusChange":"2017-03-04"},{"aaguid":"df4c01d4-4a1f-40a0-afd8-1291b9d12dbb","hash":"t1yco5jE_K_tGTgy66yrB-uBzUwzcFnJEpbgGBJ6gNQ","url":"https://fidoalliance.co.nz/mds/metadata/df4c01d4-4a1f-40a0-afd8-1291b9d12dbb.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2014-11-09"}],"timeOfLastStatusChange":"2017-12-13"},{"aaguid":"a165378b-3671-4692-8d90-f442d6048eda","hash":"0eT2Al5uBo013RABlXjc62QtakUAQUpMBLQvW3mMgbs","url":"https://fidoalliance.co.nz/mds/metadata/a165378b-3671-4692-8d90-f442d6048eda.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2015-08-27"}],"timeOfLastStatusChange":"2017-09-26"},{"aaguid":"90d272f7-81e5-4e87-9267-5da82b2ac300","hash":"-gPAQMV071qZO5Jk_MpuSu3feYRL_XjDoMuQS_oZQnM","url":"https://fidoalliance.co.nz/mds/metadata/90d272f7-81e5-4e87-9267-5da82b2ac300.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2015-05-01"}],"timeOfLastStatusChange":"2017-05-25"},{"aaguid":"21f468b8-eed8-4397-9929-805b2bf9d0cd","hash":"TACldSriNPp2dwTJLNCRiTVkdQSRDd3NyfSBl__hgtI","url":"https://fidoalliance.co.nz/mds/metadata/21f468b8-eed8-4397-9929-805b2bf9d0cd.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-02-25"}],"timeOfLastStatusChange":"2017-10-17"},{"aaguid":"8a1f1e13-75f0-4fe0-938c-b29f13c28281","hash":"yiMhPJHcLKRWGd3vUjb1j4XUQ7T8gmr7QJnOcPxRoe4","url":"https://fidoalliance.co.nz/mds/metadata/8a1f1e13-75f0-4fe0-938c-b29f13c28281.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2014-01-10"}],"timeOfLastStatusChange":"2017-06-18"},{"aaguid":"d4700e33-b8dc-47ff-9f56-92a4ce388c3f","hash":"VFgbhQ3V5MBF31pYeIduEV80TIOYv9Jk-RQJaRbfYUQ","url":"https://fidoalliance.co.nz/mds/metadata/d4700e33-b8dc-47ff-9f56-92a4ce388c3f.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2016-09-04"}],"timeOfLastStatusChange":"2017-02-21"},{"aaguid":"1762b198-0f7d-455f-b814-87b5e1bb5bff","hash":"M-tsA0sRNP0JAX4095u50MdQgsOk3oJ3971uC_lzLys","url":"https://fidoalliance.co.nz/mds/metadata/1762b198-0f7d-455f-b814-87b5e1bb5bff.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-02-21"}],"timeOfLastStatusChange":"2017-02-01"},{"aaguid":"be38212b-bc10-492b-a078-39bea433739d","hash":"1CLCJgphHS0fpOf5sd5yQOfVkb5nq2B3fPPGKsTMcGA","url":"https://fidoalliance.co.nz/mds/metadata/be38212b-bc10-492b-a078-39bea433739d.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2015-12-03"}],"timeOfLastStatusChange":"2017-01-13"},{"aaguid":"7610ff43-1ebd-49b7-89cc-288a350d57e2","hash":"gI305QQdX7vnO_Hgq8Qwmrnkb8ifPRNkQTm04n1WeG0","url":"https://fidoalliance.co.nz/mds/metadata/7610ff43-1ebd-49b7-89cc-288a350d57e2.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2016-11-25"}],"timeOfLastStatusChange":"2017-08-27"},{"aaguid":"60103a99-5421-442e-8271-f824bedf6662","hash":"pYO1od4U_5JFyET6qXA1PUMi8N8lI0fR11qii6UW5Us","url":"https://fidoalliance.co.nz/mds/metadata/60103a99-5421-442e-8271-f824bedf6662.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2016-06-09"}],"timeOfLastStatusChange":"2017-08-20"},{"aaguid":"c5ee8c50-dbbf-475f-b5fe-0982728a5a22","hash":"9EJq9vDKKXy1sAr1PePERMHX6ADdJAxN3DncFFhoJrM","url":"https://fidoalliance.co.nz/mds/metadata/c5ee8c50-dbbf-475f-b5fe-0982728a5a22.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2014-04-21"}],"timeOfLastStatusChange":"2017-09-17"},{"aaguid":"efef6493-eef9-44ce-b1bc-6e83e51c207a","hash":"DSu3v8ZtHWXaLVh7MDiWBYcinVz2SVaAWcqFNcKP8PM","url":"https://fidoalliance.co.nz/mds/metadata/efef6493-eef9-44ce-b1bc-6e83e51c207a.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2016-02-20"}],"timeOfLastStatusChange":"2017-07-15"},{"aaguid":"ca0bc075-9aad-4ad3-b38f-9da25dc5caf1","hash":"mVaqqpvkSPJRllkM2IUPI7zLsiGv2ciFLC1qAgmgAPc","url":"https://fidoalliance.co.nz/mds/metadata/ca0bc075-9aad-4ad3-b38f-9da25dc5caf1.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2016-01-19"}],"timeOfLastStatusChange":"2017-12-17"},{"aaguid":"5f39c415-d0b6-4418-9feb-10f45993bdf4","hash":"Uc0wBY60paLMFx9F0Aa2iyZ1208pZTQkQM8Tww3A9t4","url":"https://fidoalliance.co.nz/mds/metadata/5f39c415-d0b6-4418-9feb-10f45993bdf4.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2014-02-11"}],"timeOfLastStatusChange":"2017-08-17"},{"aaguid":"75e14215-0d64-4543-aa88-0cb396c517e8","hash":"YLv0-ZraIgBix_bo3JH-BwSEdUptUGDLTz8YmHdETwU","url":"https://fidoalliance.co.nz/mds/metadata/75e14215-0d64-4543-aa88-0cb396c517e8.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2015-07-18"}],"timeOfLastStatusChange":"2017-05-09"},{"aaguid":"d3af89d0-fa0f-4fc8-8c86-fbe1e763bf2e","hash":"UG0CySpwJE7lx7LHZTPmtUcKaR-66O-1IFs54LjlUag","url":"https://fidoalliance.co.nz/mds/metadata/d3af89d0-fa0f-4fc8-8c86-fbe1e763bf2e.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2016-02-02"}],"timeOfLastStatusChange":"2017-02-08"},{"aaguid":"fbfe4d20-cf81-4e59-92cc-ca2347c40845","hash":"BiQcBhH4ctNNe_LZmUZaceuklqrmm09KDlYW8sITwTI","url":"https://fidoalliance.co.nz/mds/metadata/fbfe4d20-cf81-4e59-92cc-ca2347c40845.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2014-05-14"}],"timeOfLastStatusChange":"2017-01-26"},{"aaguid":"019299f1-c340-4e86-874e-b4b2ed1a1442","hash":"w-PPLo32K_OJJevrJYDo5XtUQwiLY_W04RCheaRikJA","url":"https://fidoalliance.co.nz/mds/metadata/019299f1-c340-4e86-874e-b4b2ed1a1442.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2016-11-03"}],"timeOfLastStatusChange":"2017-08-04"},{"aaguid":"0db982ba-5bd3-48b9-aac7-0860f3239859","hash":"zzoJuluyyJ_WhWaPqRd1AHc1O6ebxxdrLZZosxee6sI","url":"https://fidoalliance.co.nz/mds/metadata/0db982ba-5bd3-48b9-aac7-0860f3239859.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2015-06-19"}],"timeOfLastStatusChange":"2017-10-16"},{"aaguid":"6aa1189d-e88a-44da-85b9-5e424dfd1f68","hash":"lIxQ8W4uGrYgaM_LNNVdnXZIMECk2VU1E4jw0G09KoM","url":"https://fidoalliance.co.nz/mds/metadata/6aa1189d-e88a-44da-85b9-5e424dfd1f68.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2015-12-13"}],"timeOfLastStatusChange":"2017-05-27"},{"aaguid":"dfcb00ad-828a-4c87-b332-2c1be59de825","hash":"4Gpuwk5iKNG_unSkc_drew_uL-OzJQGZfNr57bzlXHY","url":"https://fidoalliance.co.nz/mds/metadata/dfcb00ad-828a-4c87-b332-2c1be59de825.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2016-10-23"}],"timeOfLastStatusChange":"2017-05-06"},{"aaguid":"803892c4-96c5-4e0d-a378-17e8a3de2a2b","hash":"pB0rUP8jBye27tep7u2yQy-vCcm2v7coixcFMBz8R8k","url":"https://fidoalliance.co.nz/mds/metadata/803892c4-96c5-4e0d-a378-17e8a3de2a2b.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2014-02-01"}],"timeOfLastStatusChange":"2017-07-26"},{"aaguid":"6924133d-3ca5-43ca-a6a3-5ffb0d8376a8","hash":"XPe4PKj1VnXzRjGiKWv-6srLArCNyLrYnFkX41XLi0Y","url":"https://fidoalliance.co.nz/mds/metadata/6924133d-3ca5-43ca-a6a3-5ffb0d8376a8.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2015-07-01"}],"timeOfLastStatusChange":"2017-09-24"},{"aaguid":"1cc96d78-2b63-4faf-a266-3d19f7234ac2","hash":"db5p887OYMLlfGQC7Otz4OCFc2dzwKbIvP_QedVEXf4","url":"https://fidoalliance.co.nz/mds/metadata/1cc96d78-2b63-4faf-a266-3d19f7234ac2.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2015-10-21"}],"timeOfLastStatusChange":"2017-08-25"},{"aaguid":"d2261810-2fe8-4a55-8566-d206f792a6be","hash":"u6GLEWlcjXsVVJcVqhLR1zSX4qTK_WMpBX4_RhT6Xso","url":"https://fidoalliance.co.nz/mds/metadata/d2261810-2fe8-4a55-8566-d206f792a6be.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2016-04-11"}],"timeOfLastStatusChange":"2017-03-25"},{"aaguid":"0de3c781-6758-413d-b630-3b49d9b891f8","hash":"NIA5V7SAc0wfecljIo9dOvtkroxFg_0pmJo_ZF-TlHE","url":"https://fidoalliance.co.nz/mds/metadata/0de3c781-6758-413d-b630-3b49d9b891f8.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2014-08-06"}],"timeOfLastStatusChange":"2017-08-05"},{"aaguid":"b24c66cd-0636-4708-8b21-c68c75b75217","hash":"dth1C8tz9sHxlBM5JX1nOmzLDCtMKiS71wF98YCB_Uo","url":"https://fidoalliance.co.nz/mds/metadata/b24c66cd-0636-4708-8b21-c68c75b75217.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2014-01-26"}],"timeOfLastStatusChange":"2017-05-14"},{"aaguid":"39bdfa33-2552-4826-8515-1e6dcdd9cefa","hash":"kgkFTSNLM0MS03g7CKHPxHl-L_UPenxZeWCtQMfRrps","url":"https://fidoalliance.co.nz/mds/metadata/39bdfa33-2552-4826-8515-1e6dcdd9cefa.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2015-08-27"}],"timeOfLastStatusChange":"2017-09-26"},{"aaguid":"4c538266-f510-438c-a6f1-08d8160431aa","hash":"R62bz3LP_rtNrC0s-vTrTE6HBvZRSnbJDtkqH4X088M","url":"https://fidoalliance.co.nz/mds/metadata/4c538266-f510-438c-a6f1-08d8160431aa.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2016-01-11"}],"timeOfLastStatusChange":"2017-09-16"},{"aaguid":"bfe572e8-6069-4d83-a79e-aa855e3899e8","hash":"KDoRdqIby2G5mfnZca2H0z5xYMaJR_NUduIxquXaQwk","url":"https://fidoalliance.co.nz/mds/metadata/bfe572e8-6069-4d83-a79e-aa855e3899e8.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2015-09-06"}],"timeOfLastStatusChange":"2017-06-11"},{"aaguid":"118c2f20-4756-4089-ac69-803669e1acab","hash":"KgcLXhQEJr3FLGxsvJGp2k_xkDMnc4BrpVV_WYLGeGw","url":"https://fidoalliance.co.nz/mds/metadata/118c2f20-4756-4089-ac69-803669e1acab.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2016-04-22"}],"timeOfLastStatusChange":"2017-09-27"},{"aaguid":"492b139d-4cf3-4544-a941-f4bfecfef091","hash":"n9iHFtml93TSWEJNfdN1LkMbCbe-jYIRcZYr69-vMdA","url":"https://fidoalliance.co.nz/mds/metadata/492b139d-4cf3-4544-a941-f4bfecfef091.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2014-02-26"}],"timeOfLastStatusChange":"2017-04-22"},{"aaguid":"89c2231b-b99f-48fd-86c4-9b9822aeb846","hash":"58C8V6nw2aXd6cKLhPVl_keCcNb-G8RWzrau2vGbdxk","url":"https://fidoalliance.co.nz/mds/metadata/89c2231b-b99f-48fd-86c4-9b9822aeb846.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2016-08-24"}],"timeOfLastStatusChange":"2017-02-03"},{"aaguid":"9717f53e-b040-4d50-8f82-1b0d4a6ffafa","hash":"NRi9kAzZG9UZWv_DX9sE356rEvzqIAD97jRNNXJ8dlY","url":"https://fidoalliance.co.nz/mds/metadata/9717f53e-b040-4d50-8f82-1b0d4a6ffafa.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2014-04-03"}],"timeOfLastStatusChange":"2017-10-14"},{"aaguid":"9a013739-07e8-4570-8eac-79ebf52e0262","hash":"SCCfXrZNFtAFPlfUGOCpRXq-TgwT7JT5m2Cn4-oaId4","url":"https://fidoalliance.co.nz/mds/metadata/9a013739-07e8-4570-8eac-79ebf52e0262.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2016-04-09"}],"timeOfLastStatusChange":"2017-05-28"},{"aaguid":"b8ab4ecf-6a83-4216-b3d5-e74a64ad7737","hash":"pgv6Yf7MeUa4FvNV1oKsJVaxbpp9zYZ7b7JjyYrWLj4","url":"https://fidoalliance.co.nz/mds/metadata/b8ab4ecf-6a83-4216-b3d5-e74a64ad7737.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2014-04-07"}],"timeOfLastStatusChange":"2017-11-26"},{"aaguid":"91b1f174-c235-4d1a-932d-ad8ad9d42af2","hash":"Z6D_7SBHBN3DdF3vJHsCR4_rJdtjXNTWWiSi0el1JII","url":"https://fidoalliance.co.nz/mds/metadata/91b1f174-c235-4d1a-932d-ad8ad9d42af2.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2014-12-15"}],"timeOfLastStatusChange":"2017-08-17"},{"aaguid":"aad96b5c-26eb-47ff-a1dd-2b134647232f","hash":"OhCD1DBbu5LCl95VvqtYWiXMm2lWIACCXtDNwQ4zhn0","url":"https://fidoalliance.co.nz/mds/metadata/aad96b5c-26eb-47ff-a1dd-2b134647232f.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-02-11"}],"timeOfLastStatusChange":"2017-05-23"},{"aaguid":"dca17f47-2498-4975-8046-f86481e2d6a5","hash":"xrYFuhtMdJneeYaJkjj2lrwn67eZfbP8iq51woj-nvE","url":"https://fidoalliance.co.nz/mds/metadata/dca17f47-2498-4975-8046-f86481e2d6a5.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2016-08-07"}],"timeOfLastStatusChange":"2017-09-07"},{"aaguid":"cbf08aef-8424-4231-9b0e-d831a45ff600","hash":"fH0yWEud22P5aiewDv_pksQdq-vXFmV8eocA25jQtUY","url":"https://fidoalliance.co.nz/mds/metadata/cbf08aef-8424-4231-9b0e-d831a45ff600.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2014-06-05"}],"timeOfLastStatusChange":"2017-06-16"},{"aaguid":"5522e255-2d20-4c13-a8fd-eff241896e0d","hash":"DcYGUdWNESEG0jEe_WWTNXSuJt3YPJKzG1oCag4I6yo","url":"https://fidoalliance.co.nz/mds/metadata/5522e255-2d20-4c13-a8fd-eff241896e0d.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2016-04-17"}],"timeOfLastStatusChange":"2017-10-08"},{"aaguid":"6ca46668-e0ba-45ef-8d26-06fe0ba2fb6c","hash":"QLgRCdINoU9vtq9dA79WU_axFeEUj6d3tk38mZIzbN0","url":"https://fidoalliance.co.nz/mds/metadata/6ca46668-e0ba-45ef-8d26-06fe0ba2fb6c.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2016-12-22"}],"timeOfLastStatusChange":"2017-07-25"},{"aaguid":"a921a7dd-8a7e-430b-84f2-8bca4c1a92ad","hash":"_q7dh0yOsXv-fRl6gqeHpjTxUPVXQ8FWQhT6mZxQh7E","url":"https://fidoalliance.co.nz/mds/metadata/a921a7dd-8a7e-430b-84f2-8bca4c1a92ad.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2016-06-13"}],"timeOfLastStatusChange":"2017-10-26"},{"aaguid":"4e69b0da-e8d1-4fcb-88a6-27c0438908e3","hash":"Ea6Jw6vPgKSwxgLg4LwZ9RRe37_URWc84CJChf-tPCM","url":"https://fidoalliance.co.nz/mds/metadata/4e69b0da-e8d1-4fcb-88a6-27c0438908e3.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2015-09-28"}],"timeOfLastStatusChange":"2017-11-08"},{"aaguid":"905c4a88-6bfc-461b-857d-c4ee61afeb13","hash":"LTd86K3BNj9cV1kGSzChiZm3gvPsuntrkKMrjGjqLik","url":"https://fidoalliance.co.nz/mds/metadata/905c4a88-6bfc-461b-857d-c4ee61afeb13.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2016-10-01"}],"timeOfLastStatusChange":"2017-07-23"},{"aaguid":"a0d8a410-377b-485f-a072-d5ef3574db7e","hash":"NYAg4-r7nSDdMHN6A4TS2PIosAhyW4flIYxbRHzMRdg","url":"https://fidoalliance.co.nz/mds/metadata/a0d8a410-377b-485f-a072-d5ef3574db7e.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-12-24"}],"timeOfLastStatusChange":"2017-06-12"},{"aaguid":"d82b873d-e53d-423b-82c1-5891bd43b10f","hash":"Mc3ohMHPayanvw0dWfwqW5wYxMfvDofggJsO3aVeNh4","url":"https://fidoalliance.co.nz/mds/metadata/d82b873d-e53d-423b-82c1-5891bd43b10f.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2016-09-21"}],"timeOfLastStatusChange":"2017-03-25"},{"aaguid":"b11086c6-028d-4d43-942b-efd7806bf9d7","hash":"jqrOS253UdB60EBM-XC7r39lLGUnplotJx2lgoeqMfs","url":"https://fidoalliance.co.nz/mds/metadata/b11086c6-028d-4d43-942b-efd7806bf9d7.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2015-03-16"}],"timeOfLastStatusChange":"2017-02-01"},{"aaguid":"abc6abad-67b1-4890-a1d2-bc9386277919","hash":"0SgEHok-9blPVn-XXHTbEKCkHZLzJXwNlI2hEmguEWQ","url":"https://fidoalliance.co.nz/mds/metadata/abc6abad-67b1-4890-a1d2-bc9386277919.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2015-01-02"}],"timeOfLastStatusChange":"2017-09-09"},{"aaguid":"f403b675-581a-4493-bf86-78a0121214b5","hash":"lg6QjKy5zV3snJCIcnVfQk702fWzoCO2P3rdrFVDGlk","url":"https://fidoalliance.co.nz/mds/metadata/f403b675-581a-4493-bf86-78a0121214b5.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2014-07-14"}],"timeOfLastStatusChange":"2017-04-02"},{"aaguid":"b8270c3c-53e7-45ef-946f-4229979b8642","hash":"5MvqkVqSRKaNrC2KY1L-Fk8EqQoTVVvn67JhaF05e98","url":"https://fidoalliance.co.nz/mds/metadata/b8270c3c-53e7-45ef-946f-4229979b8642.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-04-03"}],"timeOfLastStatusChange":"2017-07-01"},{"aaguid":"5695999c-aaef-4864-8737-fcffc53d63f9","hash":"3yeKJKG_ujXLHzCn7G2Aj4nqnjdsCF3e8lTTmkVg7uI","url":"https://fidoalliance.co.nz/mds/metadata/5695999c-aaef-4864-8737-fcffc53d63f9.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2015-01-13"}],"timeOfLastStatusChange":"2017-06-03"},{"aaguid":"bb075163-c6b8-4b93-b32d-41024e83505d","hash":"uP3HJMywf1043gH7GnOEEF2dDkNLlZZWBicVi3-jnD0","url":"https://fidoalliance.co.nz/mds/metadata/bb075163-c6b8-4b93-b32d-41024e83505d.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2016-02-05"}],"timeOfLastStatusChange":"2017-02-18"},{"aaguid":"c1481ee1-6bb7-4189-b83d-171832a51004","hash":"C2uncxPIuAs-7cfmyz5KFogXJ202Uw_1eP1wMErA6gA","url":"https://fidoalliance.co.nz/mds/metadata/c1481ee1-6bb7-4189-b83d-171832a51004.json","statusReports":[{"status":"NOT_FIDO_CERTIFIED","effectiveDate":"2015-05-23"}],"timeOfLastStatusChange":"2017-02-24"},{"aaguid":"9b0b7c7b-eb61-4df5-a9a8-67f28f198337","hash":"UHaDCljuKtfDwVULiewLC484HiYPjrSGBZv3qG1iWXs","url":"https://fidoalliance.co.nz/mds/metadata/9b0b7c7b-eb61-4df5-a9a8-67f28f198337.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2016-09-20"}],"timeOfLastStatusChange":"2017-08-07"},{"aaguid":"517119f9-47fd-44ce-83dd-50364edca67a","hash":"MzsCbbq1B4rCa1ETuK8lKTkeXTxbxKqTDXc88NRMgTw","url":"https://fidoalliance.co.nz/mds/metadata/517119f9-47fd-44ce-83dd-50364edca67a.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2016-12-10"}],"timeOfLastStatusChange":"2017-07-09"},{"aaguid":"c3ca5864-73e6-4ae3-8aec-5a47f341cf1f","hash":"ZDHNLWS00ivag799hvK8lLyxoeKD5_uYJo4YCDcD8MA","url":"https://fidoalliance.co.nz/mds/metadata/c3ca5864-73e6-4ae3-8aec-5a47f341cf1f.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2014-04-18"}],"timeOfLastStatusChange":"2017-02-25"},{"aaguid":"eeeb6cf4-997d-4ce3-b716-b0c827f58d97","hash":"tggnutiN60aUU0oese4azyXI3axY_oD0AXcWl1wRmxQ","url":"https://fidoalliance.co.nz/mds/metadata/eeeb6cf4-997d-4ce3-b716-b0c827f58d97.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2016-08-12"}],"timeOfLastStatusChange":"2017-02-24"},{"aaguid":"3e6e8bd8-13e8-4224-aa8e-a56295d37d8d","hash":"cbRMP-PwLZsoTf4-DyoOqgx-OIOjDdJRorlVp5-bhOw","url":"https://fidoalliance.co.nz/mds/metadata/3e6e8bd8-13e8-4224-aa8e-a56295d37d8d.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2016-04-17"}],"timeOfLastStatusChange":"2017-04-24"},{"aaguid":"c1a86f0a-5853-4c3e-a174-ed63c369c011","hash":"Uo7yfha4JHdBkI2wcbqRb7PAOfhg6X8VYEaKKb27zzs","url":"https://fidoalliance.co.nz/mds/metadata/c1a86f0a-5853-4c3e-a174-ed63c369c011.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2014-04-17"}],"timeOfLastStatusChange":"2017-05-23"},{"aaguid":"88b18175-05dd-4037-a4ac-cfb48c53eb67","hash":"2Byf-6Yuh0lyyQnUlmbTubeE6AlQEdlvkl-E2nbyMnA","url":"https://fidoalliance.co.nz/mds/metadata/88b18175-05dd-4037-a4ac-cfb48c53eb67.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2014-11-28"}],"timeOfLastStatusChange":"2017-04-02"},{"aaguid":"28f74780-24d5-44fb-9fd4-21fd041b3628","hash":"xPmG_u8OfLUCL1svmrynFYt2D7xBmW82XDN7v2Bxr-w","url":"https://fidoalliance.co.nz/mds/metadata/28f74780-24d5-44fb-9fd4-21fd041b3628.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2014-09-05"}],"timeOfLastStatusChange":"2017-07-06"},{"aaguid":"04e3d37f-f46a-45ce-a6f9-4f5c7d371068","hash":"ZZpzcSWr2uiLmlD09dYyEz-dANpPx9IHURfZd44AzNE","url":"https://fidoalliance.co.nz/mds/metadata/04e3d37f-f46a-45ce-a6f9-4f5c7d371068.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2015-01-13"}],"timeOfLastStatusChange":"2017-09-02"},{"aaguid":"ce32d339-0ca3-4b93-a33e-21469f928ce8","hash":"11I3JY3UYiBIjRbY5PS1j0uZG1ttASRWvWGG4qLBRqY","url":"https://fidoalliance.co.nz/mds/metadata/ce32d339-0ca3-4b93-a33e-21469f928ce8.json","statusReports":[{"status":"NOT_FIDO_CERTIFIED","effectiveDate":"2015-11-27"}],"timeOfLastStatusChange":"2017-07-17"},{"aaguid":"2ad9c47a-35db-4dbd-82a4-e38e5ea0de68","hash":"FyPdVrMnRrdKhZlQGdgf34cY2W1d4ubIWq7ailA-YHM","url":"https://fidoalliance.co.nz/mds/metadata/2ad9c47a-35db-4dbd-82a4-e38e5ea0de68.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2015-03-19"}],"timeOfLastStatusChange":"2017-07-16"},{"aaguid":"613a770c-f525-44df-86d7-a82427f197df","hash":"4dJddg1J0Guefunrbdlj6jMvdHmyStaKYIt2ESkejII","url":"https://fidoalliance.co.nz/mds/metadata/613a770c-f525-44df-86d7-a82427f197df.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2014-10-06"}],"timeOfLastStatusChange":"2017-06-26"},{"aaguid":"5c536bbf-58f4-47eb-afe0-373b68a70bcd","hash":"3oKGoJMOSLwoV2PUhE25CaOTe5U8D61heUpH0Ufl7kM","url":"https://fidoalliance.co.nz/mds/metadata/5c536bbf-58f4-47eb-afe0-373b68a70bcd.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2015-07-14"}],"timeOfLastStatusChange":"2017-07-05"},{"aaguid":"99727b2a-e9cc-4a82-a5fd-557f1c15cd69","hash":"hsyIbxx-KlnuyYBAQDB2Qb12hfe0_NFYSUtBr2d4bSM","url":"https://fidoalliance.co.nz/mds/metadata/99727b2a-e9cc-4a82-a5fd-557f1c15cd69.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2014-05-11"}],"timeOfLastStatusChange":"2017-07-10"},{"aaguid":"0584b14e-88d5-4b21-a9e8-a573c685d576","hash":"lJ28bwNjg8uEfIn96Di-4YwiQ0W0XQnCYiqy4lVWSUA","url":"https://fidoalliance.co.nz/mds/metadata/0584b14e-88d5-4b21-a9e8-a573c685d576.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2016-07-27"}],"timeOfLastStatusChange":"2017-05-06"},{"aaguid":"ac5cdd9b-d557-4d2d-bd8b-4f27647d253a","hash":"h8dnhi_6UcT7hf68R9iRg30_shb2MVij4tww2I7d-6M","url":"https://fidoalliance.co.nz/mds/metadata/ac5cdd9b-d557-4d2d-bd8b-4f27647d253a.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2015-04-14"}],"timeOfLastStatusChange":"2017-01-20"},{"aaguid":"efbad274-4826-4e26-b0af-035b3cf5d56f","hash":"focFAoHT2uCxPqCSHXoHesTnI3AfnqqLvgBy9Wc68GM","url":"https://fidoalliance.co.nz/mds/metadata/efbad274-4826-4e26-b0af-035b3cf5d56f.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2014-04-25"}],"timeOfLastStatusChange":"2017-11-08"},{"aaguid":"b35b1b32-57b3-4214-ae13-9162235aa1e9","hash":"b1j_r2IwdLSDQDftU2ZOYZB55Qpcapip7pkAJiMM7kA","url":"https://fidoalliance.co.nz/mds/metadata/b35b1b32-57b3-4214-ae13-9162235aa1e9.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2016-12-26"}],"timeOfLastStatusChange":"2017-05-04"},{"aaguid":"276ba118-1551-4499-b9da-e9334927d56c","hash":"xCxiNz8_tGp_XSWbqcDCfZDaDDOa59Q9VMZosx6J7Ww","url":"https://fidoalliance.co.nz/mds/metadata/276ba118-1551-4499-b9da-e9334927d56c.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2015-05-23"}],"timeOfLastStatusChange":"2017-06-17"},{"aaguid":"75a9e140-47c4-4d7b-94b5-1d6906625485","hash":"zTqup26Mv8XaoXILgV1EHIU1P3C2H-qjr-KvPMDUjsE","url":"https://fidoalliance.co.nz/mds/metadata/75a9e140-47c4-4d7b-94b5-1d6906625485.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-06-16"}],"timeOfLastStatusChange":"2017-04-04"},{"aaguid":"97c4148b-5562-465a-a1ba-13932ba33947","hash":"DLOsCbQdRVWSGujDcz73Bg7DhxbHkrZ0K5Duwbgtms8","url":"https://fidoalliance.co.nz/mds/metadata/97c4148b-5562-465a-a1ba-13932ba33947.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2014-10-14"}],"timeOfLastStatusChange":"2017-03-23"},{"aaguid":"73858145-9bce-4875-aa08-404611b25e62","hash":"ecAtzr2qT79fJ_uPmLRWLPdDqXOz1AzwYksQsIHgoss","url":"https://fidoalliance.co.nz/mds/metadata/73858145-9bce-4875-aa08-404611b25e62.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2014-07-08"}],"timeOfLastStatusChange":"2017-12-01"},{"aaguid":"8bb79381-c452-4f37-b30e-47cc10df72f8","hash":"pYjZY2bumDz1aqup-5ifcjMgARdcE_i66qG-TwVpqlU","url":"https://fidoalliance.co.nz/mds/metadata/8bb79381-c452-4f37-b30e-47cc10df72f8.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2014-09-19"}],"timeOfLastStatusChange":"2017-09-17"},{"aaguid":"04b9622b-ac29-496e-af85-2002aaff8353","hash":"7KaMcJpgZsyTjR-MX-Ln_5P4wDv2KYhGCn_t3N0w74c","url":"https://fidoalliance.co.nz/mds/metadata/04b9622b-ac29-496e-af85-2002aaff8353.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2016-03-28"}],"timeOfLastStatusChange":"2017-07-12"},{"aaguid":"daeab4f7-2e00-4cd2-b335-c4f19562a89b","hash":"HlT90z80HQQEtlaN5cPruKEG_Yhxpl8Ji9FKpv1Yz1o","url":"https://fidoalliance.co.nz/mds/metadata/daeab4f7-2e00-4cd2-b335-c4f19562a89b.json","statusReports":[{"status":"NOT_FIDO_CERTIFIED","effectiveDate":"2015-01-22"}],"timeOfLastStatusChange":"2017-01-11"},{"aaguid":"da37c495-094f-40ad-812f-5eaba236a14f","hash":"XHCsfqAIn1x3PTe2xiU2H_TkrIaL-LI9G0a93kZFido","url":"https://fidoalliance.co.nz/mds/metadata/da37c495-094f-40ad-812f-5eaba236a14f.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2015-09-20"}],"timeOfLastStatusChange":"2017-04-01"},{"aaguid":"e33bf36c-0fd8-4b35-91c9-76f579abac4d","hash":"P7q9WxYdnwzNqOWzatyZ9c5QQciZpojxXlr01z06fjc","url":"https://fidoalliance.co.nz/mds/metadata/e33bf36c-0fd8-4b35-91c9-76f579abac4d.json","statusReports":[{"status":"NOT_FIDO_CERTIFIED","effectiveDate":"2016-09-20"}],"timeOfLastStatusChange":"2017-03-09"},{"aaguid":"71a30c1d-8aef-42df-9ab4-a13bb24c3fb0","hash":"M-SX2q_sasbLbPRSx9d03AYqoe5rSocdpN0KQosFmGA","url":"https://fidoalliance.co.nz/mds/metadata/71a30c1d-8aef-42df-9ab4-a13bb24c3fb0.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2015-09-08"}],"timeOfLastStatusChange":"2017-11-26"},{"aaguid":"d725fd4d-d6de-4184-8ad7-c1f9ae15fb7f","hash":"dM8ry9metBwZeEcz2fTvuY8x3UR6NF0hfif9BP59ydU","url":"https://fidoalliance.co.nz/mds/metadata/d725fd4d-d6de-4184-8ad7-c1f9ae15fb7f.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2016-03-23"}],"timeOfLastStatusChange":"2017-09-22"},{"aaguid":"217debc4-ddb2-4282-a51b-13bead25ba90","hash":"O7Puau69b9xxC0AVacmnDqv0ekhbQr5wKzN7Du1SW_4","url":"https://fidoalliance.co.nz/mds/metadata/217debc4-ddb2-4282-a51b-13bead25ba90.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2016-08-11"}],"timeOfLastStatusChange":"2017-04-16"},{"aaguid":"2c0af8b2-5ddf-4645-a8a3-d21e1ce12709","hash":"zcNhVZyC0pP2cqOWF1wEq7y8xa8hoJhbnxAmo__tasY","url":"https://fidoalliance.co.nz/mds/metadata/2c0af8b2-5ddf-4645-a8a3-d21e1ce12709.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2015-07-08"}],"timeOfLastStatusChange":"2017-01-19"},{"aaguid":"5055e219-40e6-4480-a5b6-ae61491d79e1","hash":"WUIOgCm_8-ThacdzyNkubJOioXvURRsdZssX_l2BIPA","url":"https://fidoalliance.co.nz/mds/metadata/5055e219-40e6-4480-a5b6-ae61491d79e1.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-10-11"}],"timeOfLastStatusChange":"2017-09-03"},{"aaguid":"120ba6ce-52fe-4487-8845-d5bc2615c634","hash":"5V2L9UqVRUXAHCN43MJX0dNjpB9q5T14ox2bgrHVR_w","url":"https://fidoalliance.co.nz/mds/metadata/120ba6ce-52fe-4487-8845-d5bc2615c634.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2015-07-19"}],"timeOfLastStatusChange":"2017-09-05"},{"aaguid":"7049c03a-5632-4a20-9514-ef828d24f5e0","hash":"-nf5WrzYa2BjAfMLFdDsOf3YOrWer6w8rI-VDTuHbpI","url":"https://fidoalliance.co.nz/mds/metadata/7049c03a-5632-4a20-9514-ef828d24f5e0.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2014-12-13"}],"timeOfLastStatusChange":"2017-08-22"},{"aaguid":"be8d9eb1-5a9e-4620-88e8-b5992f578e02","hash":"KuqDTewCM024ZhPTsCMo1deiOR35YYuoWSOpOjofQL0","url":"https://fidoalliance.co.nz/mds/metadata/be8d9eb1-5a9e-4620-88e8-b5992f578e02.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2015-08-14"}],"timeOfLastStatusChange":"2017-08-08"},{"aaguid":"1e7115c0-4f23-4fd8-8340-8f0019ed9fe9","hash":"6cjBOlZYYg8F9qQGL8zN2sBy80qvxH-DpiO9DIhtKmI","url":"https://fidoalliance.co.nz/mds/metadata/1e7115c0-4f23-4fd8-8340-8f0019ed9fe9.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2014-04-18"}],"timeOfLastStatusChange":"2017-12-07"},{"aaguid":"be9eb0da-6307-4804-8afd-e2ef1b1fcdf5","hash":"pkKkbbYQPJxhBQwa8oodlaDiUJgiAtCx3-5L_Tu4mOM","url":"https://fidoalliance.co.nz/mds/metadata/be9eb0da-6307-4804-8afd-e2ef1b1fcdf5.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2016-08-04"}],"timeOfLastStatusChange":"2017-07-19"}]}.zcJYY99FeiSNCKYpRb5zVW9zUyX2E8CjnuMm9DxsEAHGjp4w3X1ThwOACqP3Owd_18Sf2D7cpjtyE5HFnqTmkA \ No newline at end of file diff --git a/testdata/MetadataTOCParsing-F3.jwt b/testdata/MetadataTOCParsing-F3.jwt deleted file mode 100755 index 7d0f6163..00000000 --- a/testdata/MetadataTOCParsing-F3.jwt +++ /dev/null @@ -1 +0,0 @@ -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.{"legalHeader":"By using this metadata service, you are solemly swear not to do evil!","no":42,"nextUpdate":"2020-04-08","entries":[{"aaguid":"ad03a7d8-995c-40ba-ab35-a3d3654c7bc4","hash":"hNR-i8ndQeHmPoyj4vGrvkpxYDHxqBnviYi3-NVJovI","url":"https://fidoalliance.co.nz/mds/metadata/ad03a7d8-995c-40ba-ab35-a3d3654c7bc4.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2015-05-02"}],"timeOfLastStatusChange":"2017-05-14"},{"aaguid":"8742d4c1-f45b-43bf-a58e-3b1eb16417a4","hash":"nO9iNZNBCQK7W2w9wyFI6uvpolEUE7TMUTnYOETAfuc","url":"https://fidoalliance.co.nz/mds/metadata/8742d4c1-f45b-43bf-a58e-3b1eb16417a4.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2016-10-04"}],"timeOfLastStatusChange":"2017-06-17"},{"aaguid":"6c99ca8a-134a-466e-880b-a7cf3063be1b","hash":"vdVEge1OGVH431apTjbEdNxGjti9GJc960_MGbzPxuU","url":"https://fidoalliance.co.nz/mds/metadata/6c99ca8a-134a-466e-880b-a7cf3063be1b.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2014-05-12"}],"timeOfLastStatusChange":"2017-03-24"},{"aaguid":"88e044cc-54bd-4c9f-a024-3dbeb1d4259b","hash":"_SuIkerXvwM3_CcpAJS0B5uoikEgnrnOnONEfNsx9ME","url":"https://fidoalliance.co.nz/mds/metadata/88e044cc-54bd-4c9f-a024-3dbeb1d4259b.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2015-01-12"}],"timeOfLastStatusChange":"2017-03-18"},{"aaguid":"1c226a68-55f4-4293-b873-862d21bf8538","hash":"ghO8ahzLFNru99y8BhoxNO2-yK7wgEF9X5dZfPZlJRU","url":"https://fidoalliance.co.nz/mds/metadata/1c226a68-55f4-4293-b873-862d21bf8538.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-01-20"}],"timeOfLastStatusChange":"2017-08-20"},{"aaguid":"70a9e695-51b4-4c11-ab16-e3be4c7cdaf7","hash":"Abja1i8Rfl8mRxaYWVFUgUzalbX0s74ZXs7HU7PSR6E","url":"https://fidoalliance.co.nz/mds/metadata/70a9e695-51b4-4c11-ab16-e3be4c7cdaf7.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2014-06-17"}],"timeOfLastStatusChange":"2017-08-05"},{"aaguid":"623eae96-1ace-4476-8e1b-559606528f6e","hash":"5pLz7sZEXoDewDqdyTv1aMjTDYOisVzROVvmJ4zaVBw","url":"https://fidoalliance.co.nz/mds/metadata/623eae96-1ace-4476-8e1b-559606528f6e.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2015-11-08"}],"timeOfLastStatusChange":"2017-07-06"},{"aaguid":"149c1f19-8ba1-415c-9b6f-2673a9545a3e","hash":"kDFMqEtX_ONTfzsr4SmetW3b8KNrKjdVUr5z6rr2Z10","url":"https://fidoalliance.co.nz/mds/metadata/149c1f19-8ba1-415c-9b6f-2673a9545a3e.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2014-06-26"}],"timeOfLastStatusChange":"2017-12-16"},{"aaguid":"be885f6f-b9d4-476b-a8b0-00f09fa6e084","hash":"NoWqaefNIMUc59LhGfqPurwathslpBu7e6gjfv4oTPg","url":"https://fidoalliance.co.nz/mds/metadata/be885f6f-b9d4-476b-a8b0-00f09fa6e084.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2016-03-14"}],"timeOfLastStatusChange":"2017-09-13"},{"aaguid":"8b43c8d6-ff14-418a-b94a-680884933936","hash":"-oLXv2EfmVTrqwONBE9uGko98zqx63BqrKSCdnBZnwE","url":"https://fidoalliance.co.nz/mds/metadata/8b43c8d6-ff14-418a-b94a-680884933936.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-07-03"}],"timeOfLastStatusChange":"2017-01-16"},{"aaguid":"fe5034ed-8af3-4ae2-8bc5-16bd711cd62b","hash":"UYQ02ApRPmSvDwRTzJe_56y6_sNeWwvTd-YUXd4SuYo","url":"https://fidoalliance.co.nz/mds/metadata/fe5034ed-8af3-4ae2-8bc5-16bd711cd62b.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2016-03-04"}],"timeOfLastStatusChange":"2017-01-20"},{"aaguid":"5d871da8-67e4-4476-864d-3e72e2d667fa","hash":"efG7HepK-afpcsKzD-mo5X7nZscTNH9I_EYKzeC9YGM","url":"https://fidoalliance.co.nz/mds/metadata/5d871da8-67e4-4476-864d-3e72e2d667fa.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2016-10-13"}],"timeOfLastStatusChange":"2017-06-07"},{"aaguid":"47715e8f-f520-48e7-ae1e-e83c791b803a","hash":"JhdhJ_ASdbDLE1JqirjpawK591ke6jOasqNtWXmMOvk","url":"https://fidoalliance.co.nz/mds/metadata/47715e8f-f520-48e7-ae1e-e83c791b803a.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2016-12-09"}],"timeOfLastStatusChange":"2017-11-06"},{"aaguid":"48c29579-26b1-4507-848c-a44d734e3361","hash":"ARpE431E_iWWQuT-39ycq2lBuYCXNyMChLYYXOVuaU8","url":"https://fidoalliance.co.nz/mds/metadata/48c29579-26b1-4507-848c-a44d734e3361.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2015-10-20"}],"timeOfLastStatusChange":"2017-02-23"},{"aaguid":"d8436f14-b57a-40aa-9df5-6f5211b3bb27","hash":"NCNN1DaYSIrGuwf6hw3YlzSA0QhWe43G9Jhj0ZsNoqs","url":"https://fidoalliance.co.nz/mds/metadata/d8436f14-b57a-40aa-9df5-6f5211b3bb27.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-08-25"}],"timeOfLastStatusChange":"2017-01-04"},{"aaguid":"b266674b-b640-435b-8711-2d3fbee07d4b","hash":"OWi1fBeXPeeZQq6GEEXPUB25fKw9FPL1BiVVKGOAG2I","url":"https://fidoalliance.co.nz/mds/metadata/b266674b-b640-435b-8711-2d3fbee07d4b.json","statusReports":[{"status":"NOT_FIDO_CERTIFIED","effectiveDate":"2015-04-24"}],"timeOfLastStatusChange":"2017-07-05"},{"aaguid":"d7922289-ecda-4608-84d7-002fff4a4f98","hash":"tSZBMLReLvPX-gUdP4eiglzFIzMa__htBldXNOS7BUY","url":"https://fidoalliance.co.nz/mds/metadata/d7922289-ecda-4608-84d7-002fff4a4f98.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2016-01-16"}],"timeOfLastStatusChange":"2017-11-15"},{"aaguid":"342a749b-6fdf-4433-b2a7-391de49a0815","hash":"2AnlR_qdGusC_mD62uhCj70UozNb9N1CfIKrHN2WcUM","url":"https://fidoalliance.co.nz/mds/metadata/342a749b-6fdf-4433-b2a7-391de49a0815.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2014-05-06"}],"timeOfLastStatusChange":"2017-09-17"},{"aaguid":"4cce4100-4702-4501-91bd-09dd0b611889","hash":"N_UX6RUOlf8fu7fwIjpQdqQFzOL2GVBgtelM0As9oUc","url":"https://fidoalliance.co.nz/mds/metadata/4cce4100-4702-4501-91bd-09dd0b611889.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2016-07-28"}],"timeOfLastStatusChange":"2017-11-21"},{"aaguid":"1d9adbc1-1325-40aa-aafc-76aca7ec7ed8","hash":"6QdOhiUPs0dVCvKFgWyLcG76m7zKYhHs-zx-wi_3QOY","url":"https://fidoalliance.co.nz/mds/metadata/1d9adbc1-1325-40aa-aafc-76aca7ec7ed8.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2016-05-24"}],"timeOfLastStatusChange":"2017-05-01"},{"aaguid":"71148daa-35d4-498a-bed9-d84388b514c4","hash":"LZYHkUB6d83aS_kRphSR_20F-zPT-wgbtr636Ew2ecI","url":"https://fidoalliance.co.nz/mds/metadata/71148daa-35d4-498a-bed9-d84388b514c4.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2015-07-28"}],"timeOfLastStatusChange":"2017-08-20"},{"aaguid":"4f868ab9-7c99-47e7-afbb-620e06546039","hash":"7Tz8a76JwyMKcVv9l90rlyxhFd20mp4aUqne7Rv2OC0","url":"https://fidoalliance.co.nz/mds/metadata/4f868ab9-7c99-47e7-afbb-620e06546039.json","statusReports":[{"status":"NOT_FIDO_CERTIFIED","effectiveDate":"2014-07-22"}],"timeOfLastStatusChange":"2017-11-23"},{"aaguid":"1881eb49-db5c-4882-8e4c-a5ef818f5407","hash":"XguTxLy3OIEkdK8XXKLVJJy0M8q-xlmg5mFa7l3f6mY","url":"https://fidoalliance.co.nz/mds/metadata/1881eb49-db5c-4882-8e4c-a5ef818f5407.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2016-08-28"}],"timeOfLastStatusChange":"2017-04-15"},{"aaguid":"5d7103e0-42f5-4457-9eb1-578dc99ef9cc","hash":"cUEMUZRO7FS1b4uDIu3Vb-VQ4bx_OxjkbXwqvIg6GGg","url":"https://fidoalliance.co.nz/mds/metadata/5d7103e0-42f5-4457-9eb1-578dc99ef9cc.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2014-04-18"}],"timeOfLastStatusChange":"2017-10-10"},{"aaguid":"87c6affb-e772-4566-b632-424550c747dc","hash":"bz4xH48v4WH8oakcEvg6xLFqd4AOjOYVOgIwCMhL9Bw","url":"https://fidoalliance.co.nz/mds/metadata/87c6affb-e772-4566-b632-424550c747dc.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2015-12-28"}],"timeOfLastStatusChange":"2017-11-19"},{"aaguid":"63fe7882-ee7a-415d-9608-4909b6e426e1","hash":"eWDbLUXFdcwg1FsGj0iFdrKC9jw5K_HzVry7l14EACA","url":"https://fidoalliance.co.nz/mds/metadata/63fe7882-ee7a-415d-9608-4909b6e426e1.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2015-05-04"}],"timeOfLastStatusChange":"2017-03-18"},{"aaguid":"e96580e0-e2e2-464b-a259-bca9e4dbfef0","hash":"MX8bMagVPYxQ50bUmj-KIZjid0ZuVQV5DRs_0r1CR8s","url":"https://fidoalliance.co.nz/mds/metadata/e96580e0-e2e2-464b-a259-bca9e4dbfef0.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2014-11-06"}],"timeOfLastStatusChange":"2017-02-11"},{"aaguid":"b1751581-3a07-4796-8b7b-902b4e4cc684","hash":"2MvrbIyh4fXY1Qxs9gBKIDR_MBhaIh4joh-fyjsSLGs","url":"https://fidoalliance.co.nz/mds/metadata/b1751581-3a07-4796-8b7b-902b4e4cc684.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2014-01-19"}],"timeOfLastStatusChange":"2017-10-18"},{"aaguid":"2a3f98aa-706f-4085-bc77-49b8a59366eb","hash":"nMfhBuocX_gZ4ji612F6__bIerZCoS_ZWgWRbk-nZ0c","url":"https://fidoalliance.co.nz/mds/metadata/2a3f98aa-706f-4085-bc77-49b8a59366eb.json","statusReports":[{"status":"NOT_FIDO_CERTIFIED","effectiveDate":"2016-04-23"}],"timeOfLastStatusChange":"2017-09-26"},{"aaguid":"113cbe52-2ab2-4f88-aa0b-787ac252ce5e","hash":"TaaksT1yPhzwYPPnfo7KCFHMILhsrvDXMf029riIX-Q","url":"https://fidoalliance.co.nz/mds/metadata/113cbe52-2ab2-4f88-aa0b-787ac252ce5e.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2015-05-12"}],"timeOfLastStatusChange":"2017-12-20"},{"aaguid":"75d42319-b5d4-4063-ab8f-cd6b6fa883b6","hash":"Vp1yjNPAUE5ZF02dY-ZI1zKU3FDOdUP0qw8IL0OYDvI","url":"https://fidoalliance.co.nz/mds/metadata/75d42319-b5d4-4063-ab8f-cd6b6fa883b6.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2016-12-17"}],"timeOfLastStatusChange":"2017-08-08"},{"aaguid":"686221c9-fdbf-4c75-9f65-e634a362b72e","hash":"c3hHe5Q4hEJIIF2vLavAnQjjWKZOAiHlwWVGYY3Ox1M","url":"https://fidoalliance.co.nz/mds/metadata/686221c9-fdbf-4c75-9f65-e634a362b72e.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2015-03-23"}],"timeOfLastStatusChange":"2017-02-22"},{"aaguid":"e56f39ea-cb6c-4386-a8bc-e9851338ea31","hash":"d9mWzYwKZr2nYx6vWYeq8cGIifbwAoDCeLde0C8-kKI","url":"https://fidoalliance.co.nz/mds/metadata/e56f39ea-cb6c-4386-a8bc-e9851338ea31.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2014-05-21"}],"timeOfLastStatusChange":"2017-05-08"},{"aaguid":"b86b3642-fc25-44a9-a927-cef741bffd41","hash":"zJ9Pkmzo5jVSOxzZMkoQybHPesDbtf60snSiPygREos","url":"https://fidoalliance.co.nz/mds/metadata/b86b3642-fc25-44a9-a927-cef741bffd41.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2016-01-05"}],"timeOfLastStatusChange":"2017-04-14"},{"aaguid":"966c5099-eb16-4389-847a-10f0eb444b51","hash":"yiboPM-Alw-A_7aqk5XLcRe3ku_h2XdhqbeZVlYUw_Q","url":"https://fidoalliance.co.nz/mds/metadata/966c5099-eb16-4389-847a-10f0eb444b51.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-06-07"}],"timeOfLastStatusChange":"2017-01-06"},{"aaguid":"367e9f26-8638-4af4-85fa-095b0c0171e6","hash":"ZJIOpWEnZYWOa8r_2UdFQ05Hqp2i9Qkp4P-FVlWRc5g","url":"https://fidoalliance.co.nz/mds/metadata/367e9f26-8638-4af4-85fa-095b0c0171e6.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2015-06-03"}],"timeOfLastStatusChange":"2017-12-17"},{"aaguid":"2d43d865-ba37-45e6-b6fe-eee221c00c41","hash":"aoFjG5WkX1PJB4qlgep0Ijua_6u4ZtN55HCPeHFKwK8","url":"https://fidoalliance.co.nz/mds/metadata/2d43d865-ba37-45e6-b6fe-eee221c00c41.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2014-09-21"}],"timeOfLastStatusChange":"2017-08-02"},{"aaguid":"54b3ff78-3dca-4745-a738-08c55deb7acf","hash":"mnNwdhZMCf96YZQWmdkWZZYtw2p95PFNGtNxURc87VA","url":"https://fidoalliance.co.nz/mds/metadata/54b3ff78-3dca-4745-a738-08c55deb7acf.json","statusReports":[{"status":"NOT_FIDO_CERTIFIED","effectiveDate":"2016-02-03"}],"timeOfLastStatusChange":"2017-08-06"},{"aaguid":"c37c91f7-0285-43e4-a421-08fa85b751e7","hash":"JNkqc0LnTbYZwtNWwnCBC3r77F5FVYGY7IKXnzrj0Yc","url":"https://fidoalliance.co.nz/mds/metadata/c37c91f7-0285-43e4-a421-08fa85b751e7.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2014-10-06"}],"timeOfLastStatusChange":"2017-05-11"},{"aaguid":"b6a310a5-fde1-472c-8a83-d982bf1cbed9","hash":"FqE6cTLK5omtg_jDKzHNEf_AUqS0IPRFHvtahYQcZv8","url":"https://fidoalliance.co.nz/mds/metadata/b6a310a5-fde1-472c-8a83-d982bf1cbed9.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2014-10-20"}],"timeOfLastStatusChange":"2017-09-16"},{"aaguid":"6674fa85-0160-4984-b4d1-08d2daa10bb2","hash":"72kOl0wPbM8LdRzPDeG6jXCtgMKH9i10LngLG1Uii5U","url":"https://fidoalliance.co.nz/mds/metadata/6674fa85-0160-4984-b4d1-08d2daa10bb2.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2014-08-22"}],"timeOfLastStatusChange":"2017-07-13"},{"aaguid":"9bced650-385c-4fbf-8c63-5355e9531616","hash":"yE-wPMG4UIo1Q_D4i9mVwlLvxvEGyp7KnbpK39a4dgQ","url":"https://fidoalliance.co.nz/mds/metadata/9bced650-385c-4fbf-8c63-5355e9531616.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2014-02-22"}],"timeOfLastStatusChange":"2017-03-18"},{"aaguid":"0b07514e-4bd8-441c-9abf-bda179c2c607","hash":"zpr5kE8gEupT3x6ZaF6oyXKbzBWEd9poLlsvxaLuVT0","url":"https://fidoalliance.co.nz/mds/metadata/0b07514e-4bd8-441c-9abf-bda179c2c607.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2015-10-24"}],"timeOfLastStatusChange":"2017-06-18"},{"aaguid":"2f8f9478-43e9-478a-8d60-c37165842068","hash":"Y1Re3oK7wQwvQ_0RCQ8CwoQfRFLf8t6Tb1xtCpA9iro","url":"https://fidoalliance.co.nz/mds/metadata/2f8f9478-43e9-478a-8d60-c37165842068.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2016-06-18"}],"timeOfLastStatusChange":"2017-02-26"},{"aaguid":"2e5ddac0-3774-4ee3-9c3d-3b64721662e2","hash":"hz66RHDV7n8gm-1yx7mx2CIqVWOM-FB9Pad7a4a5Jms","url":"https://fidoalliance.co.nz/mds/metadata/2e5ddac0-3774-4ee3-9c3d-3b64721662e2.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2016-01-28"}],"timeOfLastStatusChange":"2017-05-04"},{"aaguid":"67c0a9ff-453c-417f-b374-670734078191","hash":"h5txC52XHOeWZQwi9mQRbHq9ZbZl1cwBFXHW8oPq8aI","url":"https://fidoalliance.co.nz/mds/metadata/67c0a9ff-453c-417f-b374-670734078191.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2014-09-05"}],"timeOfLastStatusChange":"2017-01-02"},{"aaguid":"794ce425-9a3b-4c60-8f02-133ff3bcf216","hash":"4NiKvUeAaFNYS7wJYPWMa4-mIvsOH9NJ47Xy-xIL9sA","url":"https://fidoalliance.co.nz/mds/metadata/794ce425-9a3b-4c60-8f02-133ff3bcf216.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2016-08-18"}],"timeOfLastStatusChange":"2017-05-20"},{"aaguid":"422fe7cb-a75c-4b44-a6e2-b80e07bba3ff","hash":"LJRQEmBvF_jokWSfmue5vBJdNe9V0SkjusieW5FkKWU","url":"https://fidoalliance.co.nz/mds/metadata/422fe7cb-a75c-4b44-a6e2-b80e07bba3ff.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2015-01-22"}],"timeOfLastStatusChange":"2017-08-12"},{"aaguid":"6393b6ff-856a-4a28-a9f6-ff0dae8bcdb5","hash":"24TPra6JBQ2YEY8hqBeJLqT8X1ql343OIfLZ7KzJcXw","url":"https://fidoalliance.co.nz/mds/metadata/6393b6ff-856a-4a28-a9f6-ff0dae8bcdb5.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2016-12-27"}],"timeOfLastStatusChange":"2017-04-16"},{"aaguid":"3abe3d80-fc5f-40b8-8540-9f9683f01e45","hash":"WKY1BY1EJra_BvqBw2k20g08H4y-pxEQP4eiuRt9X58","url":"https://fidoalliance.co.nz/mds/metadata/3abe3d80-fc5f-40b8-8540-9f9683f01e45.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2014-11-25"}],"timeOfLastStatusChange":"2017-04-07"},{"aaguid":"dcbf7bec-aa4e-4339-a292-9ee1c9f8b823","hash":"W78-AF-YPP7lrTHoetS5tGleOGm-e0hMqzrDjP1VG4U","url":"https://fidoalliance.co.nz/mds/metadata/dcbf7bec-aa4e-4339-a292-9ee1c9f8b823.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2015-09-18"}],"timeOfLastStatusChange":"2017-05-19"},{"aaguid":"590dcf75-d1ca-4445-8f6a-626fecbca03e","hash":"bt1XILZyJjTXlEaNTFWuVbEOAQm-VG2UIBgh1-5yjUM","url":"https://fidoalliance.co.nz/mds/metadata/590dcf75-d1ca-4445-8f6a-626fecbca03e.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2015-08-24"}],"timeOfLastStatusChange":"2017-12-04"},{"aaguid":"2e73ef6e-b68a-4526-8480-a078562d69ca","hash":"WKlOB65vHnk7XdAn9H8Z-XPFWuyXyJXEEH1qi7wEzJY","url":"https://fidoalliance.co.nz/mds/metadata/2e73ef6e-b68a-4526-8480-a078562d69ca.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2016-12-23"}],"timeOfLastStatusChange":"2017-06-16"},{"aaguid":"2fa17d1d-2f17-4245-b062-565cf20696f2","hash":"Xqe61_7upSjHNuugJmpl0qyU95X1P4NgI6GIt18tr70","url":"https://fidoalliance.co.nz/mds/metadata/2fa17d1d-2f17-4245-b062-565cf20696f2.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2014-09-25"}],"timeOfLastStatusChange":"2017-05-08"},{"aaguid":"c5b4cebf-a8bd-41a2-9b7b-9489954d6c13","hash":"fDjeSN3nV1K9yCpWP8qDEfrBdstIN-5GUpX_9LSEUTg","url":"https://fidoalliance.co.nz/mds/metadata/c5b4cebf-a8bd-41a2-9b7b-9489954d6c13.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2016-06-07"}],"timeOfLastStatusChange":"2017-06-07"},{"aaguid":"d8daddcc-f0e3-43f3-8510-1fd40ff160e5","hash":"WsNDQ8T-jmCJAbcNrvGDtA5Uq_k1Yvhaokb2Br08Kfc","url":"https://fidoalliance.co.nz/mds/metadata/d8daddcc-f0e3-43f3-8510-1fd40ff160e5.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2016-03-03"}],"timeOfLastStatusChange":"2017-11-28"},{"aaguid":"d39e6a86-6be9-40e3-91d1-31279c046bf4","hash":"cHAAty-g65VOgSgMoKALLuZPNbY_K_WGdyvi8ULySvo","url":"https://fidoalliance.co.nz/mds/metadata/d39e6a86-6be9-40e3-91d1-31279c046bf4.json","statusReports":[{"status":"NOT_FIDO_CERTIFIED","effectiveDate":"2015-01-12"}],"timeOfLastStatusChange":"2017-07-06"},{"aaguid":"443f08e5-9f77-4915-a7e0-a7f41fa9d647","hash":"cvZm2xNuaHBpB5bfyHwGAikeJOm19wLdjcVoWgcstlY","url":"https://fidoalliance.co.nz/mds/metadata/443f08e5-9f77-4915-a7e0-a7f41fa9d647.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-10-15"}],"timeOfLastStatusChange":"2017-02-01"},{"aaguid":"621948d9-34d8-430b-b697-53f6d6b5e366","hash":"VX9LfjuHn1MXM6J79UBoAbc28TczmAnLZhsX7zOXRZk","url":"https://fidoalliance.co.nz/mds/metadata/621948d9-34d8-430b-b697-53f6d6b5e366.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2015-11-09"}],"timeOfLastStatusChange":"2017-08-01"},{"aaguid":"36595be1-2e72-453d-81a4-a226d0c20c78","hash":"2M7hPHDR1lIJj9pe7m0XcVVRLarq7tQFfgkLc6s7XpQ","url":"https://fidoalliance.co.nz/mds/metadata/36595be1-2e72-453d-81a4-a226d0c20c78.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2014-07-06"}],"timeOfLastStatusChange":"2017-07-04"},{"aaguid":"997abd94-0ef8-4bc5-82cc-a722a0681939","hash":"36-ZsQgFbhQv2Zb0qECBLausg4bSIMoy3L8DqXrZ_VU","url":"https://fidoalliance.co.nz/mds/metadata/997abd94-0ef8-4bc5-82cc-a722a0681939.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2015-01-26"}],"timeOfLastStatusChange":"2017-05-24"},{"aaguid":"807d7748-f9e9-4041-b5d3-db18d3bed1dc","hash":"N6gyhzvb6PEa6tQMR09zoFWhCQLTlsZt46fKIxNscjY","url":"https://fidoalliance.co.nz/mds/metadata/807d7748-f9e9-4041-b5d3-db18d3bed1dc.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-11-04"}],"timeOfLastStatusChange":"2017-10-20"},{"aaguid":"91c173dc-6a8d-43f2-88ed-87697ba6b256","hash":"YlnB1sAhJ_DWMIvkFZX00GkzLz-1NEa8yUpYRJxeVWA","url":"https://fidoalliance.co.nz/mds/metadata/91c173dc-6a8d-43f2-88ed-87697ba6b256.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2015-11-12"}],"timeOfLastStatusChange":"2017-08-02"},{"aaguid":"ac19a0c8-d96c-4ff4-8c2b-ae05d77f4846","hash":"DPYdsvNcRXC5GXQWYeSEue_FN0lc7BBsNu50K6EOcR8","url":"https://fidoalliance.co.nz/mds/metadata/ac19a0c8-d96c-4ff4-8c2b-ae05d77f4846.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2016-02-03"}],"timeOfLastStatusChange":"2017-02-25"},{"aaguid":"e952bf33-b689-41e2-9cb7-8bcd739930c5","hash":"_35eWAF_N2CZzA3vxYkcjah71cHD7RW2OR9l19bmpfc","url":"https://fidoalliance.co.nz/mds/metadata/e952bf33-b689-41e2-9cb7-8bcd739930c5.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2015-07-27"}],"timeOfLastStatusChange":"2017-03-17"},{"aaguid":"665b3362-9360-4d0e-b000-5f3225f5de68","hash":"UqbhT7cyO_8dPhZy0JqmiNhHK9m1ecrAKDIEo212k_E","url":"https://fidoalliance.co.nz/mds/metadata/665b3362-9360-4d0e-b000-5f3225f5de68.json","statusReports":[{"status":"FIDO_CERTIFIED_L1plus","effectiveDate":"2014-08-15"}],"timeOfLastStatusChange":"2017-08-23"},{"aaguid":"1b8bab04-b02e-4c6d-863c-ff8bb6a440d1","hash":"PIdmTsQKSY-4RSKiu_1fPO_gurkgFYiF6iXr-NaW7Pw","url":"https://fidoalliance.co.nz/mds/metadata/1b8bab04-b02e-4c6d-863c-ff8bb6a440d1.json","statusReports":[{"status":"FIDO_CERTIFIED_L1","effectiveDate":"2016-09-13"}],"timeOfLastStatusChange":"2017-11-02"},{"aaguid":"aa6b561e-3fdc-4a52-89ea-65c2b189bd71","hash":"FTYMOlNZWesuN5rbezCtpwCckucvILotZhps3JEONYQ","url":"https://fidoalliance.co.nz/mds/metadata/aa6b561e-3fdc-4a52-89ea-65c2b189bd71.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2016-07-17"}],"timeOfLastStatusChange":"2017-12-08"},{"aaguid":"a9d8cbb7-6132-4a0e-81ba-2f520f490282","hash":"9LomRoTpPpQzxSp-Uxoy8g4tH7_tpDci8bsgPCmrx9I","url":"https://fidoalliance.co.nz/mds/metadata/a9d8cbb7-6132-4a0e-81ba-2f520f490282.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2016-03-14"}],"timeOfLastStatusChange":"2017-08-23"},{"aaguid":"6b06f24d-0020-4fd0-85bb-7db8c39ae5f3","hash":"kOll3iyGnipIWp7DiCaN1WzAqM89Oq_wIbem4H7TiaE","url":"https://fidoalliance.co.nz/mds/metadata/6b06f24d-0020-4fd0-85bb-7db8c39ae5f3.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2015-04-21"}],"timeOfLastStatusChange":"2017-12-10"},{"aaguid":"2ea386c5-be1f-463a-9873-7102a3302c47","hash":"I9mhWGKnerUrL8nzLbOR-5nfS9WK86QMlBE3safMNOs","url":"https://fidoalliance.co.nz/mds/metadata/2ea386c5-be1f-463a-9873-7102a3302c47.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-09-26"}],"timeOfLastStatusChange":"2017-10-21"},{"aaguid":"ba4ad1c7-db7b-4bc1-8a12-8a98d2f96703","hash":"Kxxcx-LBuVXEW2So4NyDjt9k8wwDifG1XwnOXWYWpNo","url":"https://fidoalliance.co.nz/mds/metadata/ba4ad1c7-db7b-4bc1-8a12-8a98d2f96703.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2015-01-26"}],"timeOfLastStatusChange":"2017-07-02"},{"aaguid":"513c6b1f-5fc2-4af3-bf6e-951f552a08d0","hash":"1CHhJF5ih_x8SH7kyqRD0mf2G21_qRmjg-0Tg0rpAqM","url":"https://fidoalliance.co.nz/mds/metadata/513c6b1f-5fc2-4af3-bf6e-951f552a08d0.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2015-02-18"}],"timeOfLastStatusChange":"2017-11-02"},{"aaguid":"40c2c159-ca85-4a26-99cc-97c177e58345","hash":"1I0J4tUjy1HKVR65kKRvmgJnKIszNBhA-PZ72osFQF4","url":"https://fidoalliance.co.nz/mds/metadata/40c2c159-ca85-4a26-99cc-97c177e58345.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2015-06-24"}],"timeOfLastStatusChange":"2017-04-13"},{"aaguid":"295ac5c5-2d2e-4b01-bc03-aecae2ffa887","hash":"b7D77F3uSP4jufciY39x7tYF6Bu825cUm8lJCSvU5Oc","url":"https://fidoalliance.co.nz/mds/metadata/295ac5c5-2d2e-4b01-bc03-aecae2ffa887.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2014-08-03"}],"timeOfLastStatusChange":"2017-11-24"},{"aaguid":"4fa91711-b07b-42cb-8024-bb933dc674fd","hash":"d8o6YVcih5w5qpDz3_kU_zPUPnqzbPmVpIWwF2N24PY","url":"https://fidoalliance.co.nz/mds/metadata/4fa91711-b07b-42cb-8024-bb933dc674fd.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2016-02-23"}],"timeOfLastStatusChange":"2017-03-05"},{"aaguid":"4e54d139-f56d-4434-a622-2cb222ee111e","hash":"HEvFbCOfUoz4lOoiE8z_NDhF6vC0mTOd2woH3z63D2o","url":"https://fidoalliance.co.nz/mds/metadata/4e54d139-f56d-4434-a622-2cb222ee111e.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2014-01-28"}],"timeOfLastStatusChange":"2017-06-04"},{"aaguid":"8762b536-84b1-43eb-8b67-78d319d29529","hash":"zPLvNVd60jlZLqWHLjfCOu46s5fn_t5ps1QgYQQ_K3o","url":"https://fidoalliance.co.nz/mds/metadata/8762b536-84b1-43eb-8b67-78d319d29529.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2014-10-10"}],"timeOfLastStatusChange":"2017-07-02"},{"aaguid":"2ab3da1e-2921-40f2-83c8-d64a2c0bdf99","hash":"_IntGolc7bGWTkEn16B-w6GGbIbxTX4O0tuTVXYNfWY","url":"https://fidoalliance.co.nz/mds/metadata/2ab3da1e-2921-40f2-83c8-d64a2c0bdf99.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2015-06-21"}],"timeOfLastStatusChange":"2017-05-24"},{"aaguid":"e8b66845-6cf8-405a-b8a9-a426bd6e43fa","hash":"tNCV552GRQZEWuBMF99lqZqC36p304LvDyofhai4o3U","url":"https://fidoalliance.co.nz/mds/metadata/e8b66845-6cf8-405a-b8a9-a426bd6e43fa.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2016-11-14"}],"timeOfLastStatusChange":"2017-01-01"},{"aaguid":"25946939-3663-4aa4-a8bc-c74ea94852b6","hash":"EQd-I66aBrYxk9qRP5yc3F6VIvdJGRd4Qe_p7oCEW8U","url":"https://fidoalliance.co.nz/mds/metadata/25946939-3663-4aa4-a8bc-c74ea94852b6.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2015-09-14"}],"timeOfLastStatusChange":"2017-09-14"},{"aaguid":"33d7f121-6196-4dec-b24d-c59df174dc96","hash":"8P9SCDXpx5h7mgvKC9UHcIcAKo7x6DW92DV0v7fKh9M","url":"https://fidoalliance.co.nz/mds/metadata/33d7f121-6196-4dec-b24d-c59df174dc96.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2016-10-26"}],"timeOfLastStatusChange":"2017-12-03"},{"aaguid":"cdf544de-4e27-406e-95e6-1e27eed0c31a","hash":"AiJgvPTF2lO7IJBo5yhsv4aQeIvaO7WotaTIIEhsK2g","url":"https://fidoalliance.co.nz/mds/metadata/cdf544de-4e27-406e-95e6-1e27eed0c31a.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2016-03-04"}],"timeOfLastStatusChange":"2017-06-25"},{"aaguid":"af7a45d4-4697-44dc-af2e-dfb1b4664bd4","hash":"ham-ugu1hKahyoVVLPUU-_Awu6F5K_8uGRe1w-iEUUU","url":"https://fidoalliance.co.nz/mds/metadata/af7a45d4-4697-44dc-af2e-dfb1b4664bd4.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2016-12-16"}],"timeOfLastStatusChange":"2017-03-08"},{"aaguid":"6eeee36e-5738-4826-b5db-c715110fde1d","hash":"OnuG27WMPQCDL_YyaLG7hkX00GfMNvFM_npJua1opxg","url":"https://fidoalliance.co.nz/mds/metadata/6eeee36e-5738-4826-b5db-c715110fde1d.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2016-09-26"}],"timeOfLastStatusChange":"2017-07-18"},{"aaguid":"188b728d-1585-4ab1-a6ea-3735c3c5d3a4","hash":"2AwDt1zqWRgjXBN44gMAqSdS7CXr1CeLcfv5HJr9kSY","url":"https://fidoalliance.co.nz/mds/metadata/188b728d-1585-4ab1-a6ea-3735c3c5d3a4.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2015-03-13"}],"timeOfLastStatusChange":"2017-05-01"},{"aaguid":"53a41463-7d2f-4ffa-9ade-4bafc5b822ea","hash":"4RD8HZbvGiA77jZX40IlPrdHRpx1ZCgxlyVgSSfn2g8","url":"https://fidoalliance.co.nz/mds/metadata/53a41463-7d2f-4ffa-9ade-4bafc5b822ea.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2014-02-01"}],"timeOfLastStatusChange":"2017-05-23"},{"aaguid":"e1ddf7b0-b1c0-4447-a90c-469d9eb34299","hash":"NVRpDU4T7PD5X4rXwTFEjUQoFIVMvMUxgbbeJSuGTuU","url":"https://fidoalliance.co.nz/mds/metadata/e1ddf7b0-b1c0-4447-a90c-469d9eb34299.json","statusReports":[{"status":"FIDO_CERTIFIED","effectiveDate":"2016-06-28"}],"timeOfLastStatusChange":"2017-02-02"},{"aaguid":"47322fc3-8376-4bb9-a9b6-d10ec76bde06","hash":"6pX_wtcj30XYScD5563Q5wewK8eSJAQd0jJswchv_Bg","url":"https://fidoalliance.co.nz/mds/metadata/47322fc3-8376-4bb9-a9b6-d10ec76bde06.json","statusReports":[{"status":"NOT_FIDO_CERTIFIED","effectiveDate":"2016-02-14"}],"timeOfLastStatusChange":"2017-07-11"},{"aaguid":"7139f6c8-ae68-4556-bda9-fe6011b49d1e","hash":"UFiHA1ghivgDKaBpFi2U27eJPkiXWFSJ9oqsTJWa-cI","url":"https://fidoalliance.co.nz/mds/metadata/7139f6c8-ae68-4556-bda9-fe6011b49d1e.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2014-12-25"}],"timeOfLastStatusChange":"2017-07-27"},{"aaguid":"f4b7743c-3023-4ebe-8c07-c3fab80311ad","hash":"vY39w1i20Jk6nEQmj4mrerVyY9runCRDMHVpgYsPkMA","url":"https://fidoalliance.co.nz/mds/metadata/f4b7743c-3023-4ebe-8c07-c3fab80311ad.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2014-02-03"}],"timeOfLastStatusChange":"2017-01-23"},{"aaguid":"9849cd31-2b6c-4185-9e92-ad2ab25c46de","hash":"ItMjIOzSE7CVSXX2RGFWOxlfyuidKkFFhJo-XRYV2n4","url":"https://fidoalliance.co.nz/mds/metadata/9849cd31-2b6c-4185-9e92-ad2ab25c46de.json","statusReports":[{"status":"SELF_ASSERTION_SUBMITTED","effectiveDate":"2016-06-23"}],"timeOfLastStatusChange":"2017-01-27"},{"aaguid":"ca9d8b1e-c7c6-4bc9-bb82-4fbffd7839e0","hash":"acOPwmWn3Dbo1E9xwuhYh81Z1V7mI14HQeTm_zOP6a0","url":"https://fidoalliance.co.nz/mds/metadata/ca9d8b1e-c7c6-4bc9-bb82-4fbffd7839e0.json","statusReports":[{"status":"FIDO_CERTIFIED_L3","effectiveDate":"2015-06-25"}],"timeOfLastStatusChange":"2017-07-25"},{"aaguid":"0cb9c197-0fb0-4a82-be29-9b54c09cd9c7","hash":"kBN3JDWhtwc78kZjoQ7X9ASLHCbNVaENWrlf5JC2uwY","url":"https://fidoalliance.co.nz/mds/metadata/0cb9c197-0fb0-4a82-be29-9b54c09cd9c7.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2015-10-24"}],"timeOfLastStatusChange":"2017-07-06"},{"aaguid":"4d436671-8fe0-4071-b410-68df4addfc41","hash":"vMKRghu__pTi_fV66RXdBPBPf-XHDwRccBdRGoKSYnY","url":"https://fidoalliance.co.nz/mds/metadata/4d436671-8fe0-4071-b410-68df4addfc41.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2016-10-04"}],"timeOfLastStatusChange":"2017-07-18"},{"aaguid":"fabd0195-0105-405a-b4af-596b34fa41c6","hash":"HIcAO6ShrCtGgX58OaFdyfpTIpK9qa1sKdlNXa3VAEk","url":"https://fidoalliance.co.nz/mds/metadata/fabd0195-0105-405a-b4af-596b34fa41c6.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2014-09-24"}],"timeOfLastStatusChange":"2017-09-06"},{"aaguid":"cad726a0-9c0d-4e89-aede-be3f61600d4f","hash":"0DBDfbheGKsJcIso8Q9vU9gB2SySVKqj9bT9kY7hZaE","url":"https://fidoalliance.co.nz/mds/metadata/cad726a0-9c0d-4e89-aede-be3f61600d4f.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2015-11-25"}],"timeOfLastStatusChange":"2017-04-04"},{"aaguid":"2a1c8020-7cc3-42ed-8b10-7c0388b0e586","hash":"SLs-uatFSKK5JNHPEszC65dVpoSiIzgf0kmdv8zPXJo","url":"https://fidoalliance.co.nz/mds/metadata/2a1c8020-7cc3-42ed-8b10-7c0388b0e586.json","statusReports":[{"status":"FIDO_CERTIFIED_L2","effectiveDate":"2015-09-04"}],"timeOfLastStatusChange":"2017-02-10"},{"aaguid":"58a57fcb-9132-4c98-b322-40234aedc5c2","hash":"YGh5rpeUFiVzjPaV9mYsiXuZk6Uzv4klRXcyg8OIIQg","url":"https://fidoalliance.co.nz/mds/metadata/58a57fcb-9132-4c98-b322-40234aedc5c2.json","statusReports":[{"status":"FIDO_CERTIFIED_L2plus","effectiveDate":"2014-05-15"}],"timeOfLastStatusChange":"2017-02-20"},{"aaguid":"c7988854-1e60-4046-8f42-319d90266634","hash":"0D8oSnAA8njCs7ub-FhOUYBceg0OkbSGcLliuG4k2mY","url":"https://fidoalliance.co.nz/mds/metadata/c7988854-1e60-4046-8f42-319d90266634.json","statusReports":[{"status":"FIDO_CERTIFIED_L3plus","effectiveDate":"2015-04-28"}],"timeOfLastStatusChange":"2017-07-28"}]}.CUPr4wFz1-lf-w5QeTXw2uiAyO8bjwWF1BuVjQoCH90Cn-Ifmuf2w3l9fwV7T218yI1jqGz-1BydmM4FvCYDtg \ No newline at end of file diff --git a/testdata/MetadataTOCParsing-F4.jwt b/testdata/MetadataTOCParsing-F4.jwt deleted file mode 100755 index 992ffc3b..00000000 --- a/testdata/MetadataTOCParsing-F4.jwt +++ /dev/null @@ -1 +0,0 @@ -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.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.kWmSgoYyXzEXkFJuMrVPrjQYgbVh2c88wlNE8c1490iD6E_wVyYoHJ6ZWoDsvzpCj_vxKFuYEIOGid5fWdMmqg \ No newline at end of file diff --git a/testdata/MetadataTOCParsing-P1.jwt b/testdata/MetadataTOCParsing-P1.jwt deleted file mode 100755 index 28b1c722..00000000 --- a/testdata/MetadataTOCParsing-P1.jwt +++ /dev/null @@ -1 +0,0 @@ -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.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.SV4XvewlXWHFW0p734jaMKtRIlsyUV2SeAx8CoJ9Ffyhe-iCP4edn8SjducgDxFmz3JHrWswyvMjUfieYAIbNw \ No newline at end of file diff --git a/testdata/TestMetadataStatementParsing-F1.json b/testdata/TestMetadataStatementParsing-F1.json deleted file mode 100644 index 218cd509..00000000 --- a/testdata/TestMetadataStatementParsing-F1.json +++ /dev/null @@ -1 +0,0 @@ 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 \ No newline at end of file diff --git a/testdata/TestMetadataStatementParsing-P1.json b/testdata/TestMetadataStatementParsing-P1.json deleted file mode 100644 index 0a343cef..00000000 --- a/testdata/TestMetadataStatementParsing-P1.json +++ /dev/null @@ -1 +0,0 @@ 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 \ No newline at end of file