Source release 19.1.0

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.