Source release 19.1.0

oemcrypto/util/include/bcc_validator.h

@@ -0,0 +1,81 @@
+// Copyright 2023 Google LLC. All Rights Reserved. This file and proprietary
+// source code may only be used and distributed under the Widevine License
+// Agreement.
+//
+//  Reference implementation utilities of OEMCrypto APIs
+//
+#ifndef WVOEC_UTIL_BCC_VALIDATOR_H_
+#define WVOEC_UTIL_BCC_VALIDATOR_H_
+
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "cbor_validator.h"
+#include "cppbor.h"
+
+namespace wvoec {
+namespace util {
+// Enums and struct to hold EC public key info
+enum BccSignatureAlgorithm {
+  kBccDefaultSignature = 0,
+  kBccEdDsa = 1,
+  kBccEcdsaSha256 = 2,
+  kBccEcdsaSha384 = 3
+};
+
+enum BccCurve {
+  kBccDefaultCurve = 0,
+  kBccEd25519 = 1,
+  kBccP256 = 2,
+  kBccP384 = 3
+};
+
+struct BccPublicKeyInfo {
+  BccSignatureAlgorithm signature_algorithm;
+  BccCurve curve;
+  // Raw EC key bytes extracted from BCC
+  std::vector<uint8_t> key_bytes;
+};
+
+// BccValidator processes a Provisioning 4.0 device root of trust. It extracts
+// and validates relevant pieces of information of BCC.
+// Relevant documents:
+// Android definition: go/remote-provisioning-hal#bcc.
+// Google Dice Profile: go/dice-profile
+class BccValidator : public CborValidator {
+ public:
+  explicit BccValidator() {}
+  virtual ~BccValidator() override = default;
+  BccValidator(const BccValidator&) = delete;
+  BccValidator& operator=(const BccValidator&) = delete;
+  // Verifies the Cbor struct of a client generated root of trust. This message
+  // is part of an attestation model conforming to the Google Open Dice Profile.
+  // This message is received from a client device to attest it is a valid
+  // Widevine device.
+  virtual CborMessageStatus Validate() override;
+  // Outputs BCC in YAML.
+  virtual std::string GetFormattedMessage() const override;
+
+ private:
+  // Processes CoseKey PubKeyEd25519 / PubKeyECDSA256, prints into |fmt_msgs|,
+  // and extracts the PubKey to *|public_key_info|.
+  CborMessageStatus ProcessSubjectPublicKeyInfo(
+      const cppbor::Map& public_key_info_map,
+      std::vector<std::string>& fmt_msgs, BccPublicKeyInfo* public_key_info);
+  // Processes DiceChainEntryPayload, which contains subject public key, prints
+  // into |fmt_msgs|, and extracts the PubKey to *|public_key_info|.
+  CborMessageStatus ProcessDiceChainEntryPayload(
+      const std::vector<uint8_t>& payload, std::vector<std::string>& fmt_msgs,
+      BccPublicKeyInfo* public_key_info);
+  // Verifies the raw EC signature |signature| with the public key
+  // |signing_key|. |signature| extracted from BCC is not ASN.1 DER encoded.
+  bool VerifySignature(const BccPublicKeyInfo& signing_key,
+                       const std::vector<uint8_t>& message,
+                       const std::vector<uint8_t>& signature);
+  // Used to generate formatted message.
+  std::stringstream msg_ss_;
+};
+}  // namespace util
+}  // namespace wvoec
+#endif  // WVOEC_UTIL_BCC_VALIDATOR_H_

oemcrypto/util/include/cbor_validator.h

@@ -0,0 +1,86 @@
+// Copyright 2023 Google LLC. All Rights Reserved. This file and proprietary
+// source code may only be used and distributed under the Widevine License
+// Agreement.
+//
+//  Reference implementation utilities of OEMCrypto APIs
+//
+#ifndef WVOEC_UTIL_CBOR_VALIDATOR_H_
+#define WVOEC_UTIL_CBOR_VALIDATOR_H_
+
+#include <string>
+#include <vector>
+
+#include "cppbor.h"
+#include "cppbor_parse.h"
+
+namespace wvoec {
+namespace util {
+// CborMessageStatus values are ranked in level of severity.
+// kCborUninitialized being the lowest severity, and
+// kCborValidateFatal being the highest.
+enum CborMessageStatus {
+  kCborUninitialized = 0,
+  kCborParseOk = 1,
+  kCborParseError = 2,
+  kCborValidateOk = 3,
+  kCborValidateWarning = 4,
+  kCborValidateError = 5,
+  kCborValidateFatal = 6
+};
+
+std::string CppborMajorTypeToString(cppbor::MajorType type);
+std::string CborMessageStatusToString(CborMessageStatus status);
+
+class CborValidator {
+ public:
+  explicit CborValidator() {}
+  virtual ~CborValidator() = default;
+  CborValidator(const CborValidator&) = delete;
+  CborValidator& operator=(const CborValidator&) = delete;
+
+  // Decodes |cbor| and sets |message_status_|.
+  virtual CborMessageStatus Parse(const std::vector<uint8_t>& cbor);
+  const cppbor::ParseResult* GetParseResult() const;
+  // Returns pretty-printed CBOR for |parse_result_|. Returns empty string if
+  // |parse_result_| is not valid.
+  std::string GetRawMessage() const;
+
+  // Verifies the fields in |parse_result_| to have expected types and values.
+  // Requires that Parse() is called first and |parse_result_| contains a valid
+  // CBOR message.
+  virtual CborMessageStatus Validate();
+  // Returns all validation messages from Validate().
+  const std::vector<std::pair<CborMessageStatus, std::string>>&
+  GetValidateMessages() const {
+    return validate_messages_;
+  }
+  // Prints |parse_result_| in readable format. Requires that Parse() is called
+  // first and |parse_result_| contains a valid CBOR message.
+  virtual std::string GetFormattedMessage() const;
+  const cppbor::ParseResult& parse_result() const { return parse_result_; }
+  const std::vector<std::pair<CborMessageStatus, std::string>>&
+  validate_messages() {
+    return validate_messages_;
+  }
+
+ protected:
+  void Reset();
+  // Writes validation output |msg| to |validate_messages_|, and updates
+  // |message_status_| if the |status| is more severe than the current value.
+  void AddValidationMessage(CborMessageStatus status, const std::string& msg);
+  static const cppbor::Item* GetMapEntry(const cppbor::Map& map,
+                                         const std::string& entry_name);
+  // Checks whether an entry with |entry_name| and |major_type| exists in |map|.
+  static std::string CheckMapEntry(const cppbor::Map& map,
+                                   cppbor::MajorType major_type,
+                                   const std::string& entry_name);
+  CborMessageStatus message_status_ = kCborUninitialized;
+
+ private:
+  // Internal status of parsing and validating.
+  cppbor::ParseResult parse_result_ = {};
+  std::vector<std::pair<CborMessageStatus, std::string>> validate_messages_;
+};
+}  // namespace util
+}  // namespace wvoec
+#endif  // WVOEC_UTIL_CBOR_VALIDATOR_H_

oemcrypto/util/include/device_info_validator.h

@@ -0,0 +1,54 @@
+// Copyright 2023 Google LLC. All Rights Reserved. This file and proprietary
+// source code may only be used and distributed under the Widevine License
+// Agreement.
+//
+//  Reference implementation utilities of OEMCrypto APIs
+//
+#ifndef WVOEC_UTIL_DEVICE_INFO_VALIDATOR_H_
+#define WVOEC_UTIL_DEVICE_INFO_VALIDATOR_H_
+
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "cbor_validator.h"
+#include "cppbor.h"
+
+namespace wvoec {
+namespace util {
+// DeviceInfoValidator parses and validates a Cbor struct of DeviceInfo used by
+// Provisioning 4.0. DeviceInfo definition:
+// https://source.corp.google.com/h/googleplex-android/platform/superproject/main/+/main:hardware/interfaces/security/rkp/aidl/android/hardware/security/keymint/DeviceInfoV3.cddl
+class DeviceInfoValidator : public CborValidator {
+ public:
+  explicit DeviceInfoValidator(int version_number)
+      : version_number_(version_number) {}
+  DeviceInfoValidator() = delete;
+  virtual ~DeviceInfoValidator() override = default;
+  DeviceInfoValidator(const DeviceInfoValidator&) = delete;
+  DeviceInfoValidator& operator=(const DeviceInfoValidator&) = delete;
+
+  // Decodes |device_info| and sets |message_status_|.
+  virtual CborMessageStatus Parse(
+      const std::vector<uint8_t>& device_info) override;
+  // Verifies the Cbor struct of a client generated device info.
+  virtual CborMessageStatus Validate() override;
+  // Outputs DeviceInfo in YAML.
+  virtual std::string GetFormattedMessage() const override;
+
+ private:
+  // Checks whether a device info entry with |entry_name| and |major_type|
+  // exists in |device_info| map.
+  void CheckDeviceInfoMapEntry(const cppbor::Map& device_info,
+                               cppbor::MajorType major_type,
+                               const std::string& entry_name);
+  // Used to generate formatted message.
+  std::stringstream msg_ss_;
+  // Device info version. Validations are done based on the version number.
+  int version_number_;
+  // Saved Cbor-encoded device info.
+  std::vector<uint8_t> device_info_bytes_;
+};
+}  // namespace util
+}  // namespace wvoec
+#endif  // WVOEC_UTIL_DEVICE_INFO_VALIDATOR_H_

oemcrypto/util/include/oemcrypto_ecc_key.h

@@ -60,6 +60,13 @@ class EccPublicKey {
                                             size_t length);
   static std::unique_ptr<EccPublicKey> Load(const std::string& buffer);
   static std::unique_ptr<EccPublicKey> Load(const std::vector<uint8_t>& buffer);
+  // Loads EC public key from the |curve| and |buffer|.
+  // The provided |buffer| must contain an EC point serialized from raw X9.62
+  // format. For uncompressed form, it is a 1-byte prefix plus two 32-byte
+  // integers representing X, Y coordinates.
+  static std::unique_ptr<EccPublicKey> LoadKeyPoint(EccCurve curve,
+                                                    const uint8_t* buffer,
+                                                    size_t length);
 
   // Loads a serialized ECC private key, but only converting the public key.
   static std::unique_ptr<EccPublicKey> LoadPrivateKeyInfo(const uint8_t* buffer,
@@ -107,6 +114,15 @@ class EccPublicKey {
                                   const std::string& signature) const;
   OEMCryptoResult VerifySignature(const std::vector<uint8_t>& message,
                                   const std::vector<uint8_t>& signature) const;
+  // Verifies the raw |signature| matches the provided |message| by the
+  // private equivalent of this public key.
+  // A raw ECDSA signature consists of a pair of integers (r,s). The |signature|
+  // is a concatenation of two octet strings resulting from the integer-to-octet
+  // encoding of the values of r and s, in the order of (r||s).
+  OEMCryptoResult VerifyRawSignature(const uint8_t* message,
+                                     size_t message_length,
+                                     const uint8_t* signature,
+                                     size_t signature_length) const;
 
   ~EccPublicKey();
 
@@ -125,6 +141,13 @@ class EccPublicKey {
   bool InitFromPrivateKeyInfo(const uint8_t* buffer, size_t length);
   // Initializes the public key object from a private.
   bool InitFromPrivateKey(const EccPrivateKey& private_key);
+  // Initializes the public key object from the provided curve and key point
+  // |buffer|.
+  bool InitFromKeyPoint(EccCurve curve, const uint8_t* buffer, size_t length);
+  // Digests the |message| and verifies signature against the provided signature
+  // point.
+  OEMCryptoResult DigestAndVerify(const uint8_t* message, size_t message_length,
+                                  const ECDSA_SIG* sig_point) const;
 
   // OpenSSL/BoringSSL implementation of an ECC key.
   // As a public key, this will only have key point initialized.

oemcrypto/util/include/signed_csr_payload_validator.h

@@ -0,0 +1,44 @@
+// Copyright 2023 Google LLC. All Rights Reserved. This file and proprietary
+// source code may only be used and distributed under the Widevine License
+// Agreement.
+//
+//  Reference implementation utilities of OEMCrypto APIs
+//
+#ifndef WVOEC_UTIL_SIGNED_CSR_PAYLOAD_VALIDATOR_H_
+#define WVOEC_UTIL_SIGNED_CSR_PAYLOAD_VALIDATOR_H_
+
+#include <sstream>
+#include <string>
+
+#include "cbor_validator.h"
+#include "cppbor.h"
+
+namespace wvoec {
+namespace util {
+// SignedCsrPayloadValidator parses and validates a Cbor struct of
+// SignedData<CsrPayload>. The definition of SignedData<T> and CsrPayload can be
+// found at:
+// https://source.corp.google.com/h/googleplex-android/platform/superproject/main/+/main:hardware/interfaces/security/rkp/aidl/android/hardware/security/keymint/generateCertificateRequestV2.cddl
+class SignedCsrPayloadValidator : public CborValidator {
+ public:
+  explicit SignedCsrPayloadValidator() {}
+  virtual ~SignedCsrPayloadValidator() override = default;
+  SignedCsrPayloadValidator(const SignedCsrPayloadValidator&) = delete;
+  SignedCsrPayloadValidator& operator=(const SignedCsrPayloadValidator&) =
+      delete;
+
+  // Verifies the Cbor struct of a client generated SignedData<CsrPayload>.
+  virtual CborMessageStatus Validate() override;
+  // Outputs SignedData<CsrPayload> in YAML.
+  virtual std::string GetFormattedMessage() const override;
+
+ private:
+  CborMessageStatus ValidateProtectedParams(
+      const cppbor::Bstr* protected_params);
+  CborMessageStatus ValidateDataToBeSigned(const cppbor::Bstr* data);
+  // Used to generate formatted message.
+  std::stringstream msg_ss_;
+};
+}  // namespace util
+}  // namespace wvoec
+#endif  // WVOEC_UTIL_SIGNED_CSR_PAYLOAD_VALIDATOR_H_