Source release 17.1.2

oemcrypto/test/fuzz_tests/oemcrypto_generic_verify_fuzz.cc

@@ -2,66 +2,59 @@
 // source code may only be used and distributed under the Widevine
 // License Agreement.
 
-#include <openssl/hmac.h>
-#include <openssl/sha.h>
+#include <vector>
 
+#include "FuzzedDataProvider.h"
 #include "OEMCryptoCENC.h"
-#include "log.h"
 #include "oemcrypto_fuzz_helper.h"
 #include "oemcrypto_fuzz_structs.h"
-#include "oemcrypto_types.h"
 
-namespace wvoec {
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  // Redirect printf and log statements from oemcrypto functions to a file to
-  // reduce noise
-  RedirectStdoutToFile();
+namespace {
 
-  OEMCrypto_Generic_Verify_Fuzz fuzzed_structure;
-  if (size < sizeof(fuzzed_structure)) {
-    return 0;
-  }
-  // Copy OEMCrypto_Generic_Verify_Fuzz from input data.
-  memcpy(&fuzzed_structure, data, sizeof(fuzzed_structure));
-  ConvertDataToValidEnum(OEMCrypto_CipherMode_MaxValue,
-                         &fuzzed_structure.cipher_mode);
-  ConvertDataToValidEnum(OEMCrypto_Algorithm_MaxValue,
-                         &fuzzed_structure.algorithm);
+// Avoid calling non-trivial destructor.
+wvoec::OEMCryptoLicenseAPIFuzz& license_api_fuzz =
+    *new wvoec::OEMCryptoLicenseAPIFuzz;
 
-  size_t in_buffer_size = size - sizeof(fuzzed_structure);
-  if (in_buffer_size == 0) {
-    return 0;
-  }
-  // Copy clear buffer from input data.
-  vector<uint8_t> in_buffer(in_buffer_size);
-  memcpy(in_buffer.data(), data + sizeof(fuzzed_structure), in_buffer_size);
+}  // namespace
 
-  OEMCryptoLicenseAPIFuzz license_api_fuzz;
-  Session* session = license_api_fuzz.session();
-  // Load license and call generic_verify API.
-  license_api_fuzz.LoadLicense();
-  OEMCrypto_SelectKey(session->session_id(), session->license().keys[0].key_id,
-                      session->license().keys[0].key_id_length,
-                      OEMCrypto_CipherMode_CENC);
-  // Calculate signature for in buffer.
-  size_t signature_length = 0;
-  OEMCrypto_Generic_Sign(session->session_id(), in_buffer.data(),
-                         in_buffer.size(), fuzzed_structure.algorithm, nullptr,
-                         &signature_length);
-  vector<uint8_t> signature(signature_length);
-  OEMCrypto_Generic_Sign(session->session_id(), in_buffer.data(),
-                         in_buffer.size(), fuzzed_structure.algorithm,
-                         signature.data(), &signature_length);
-
-  OEMCrypto_SelectKey(session->session_id(), session->license().keys[0].key_id,
-                      session->license().keys[0].key_id_length,
-                      fuzzed_structure.cipher_mode);
-  signature_length =
-      std::min(MAX_FUZZ_SIGNATURE_LENGTH, fuzzed_structure.signature_length);
-  signature.resize(signature_length);
-  OEMCrypto_Generic_Verify(session->session_id(), in_buffer.data(),
-                           in_buffer.size(), fuzzed_structure.algorithm,
-                           signature.data(), signature_length);
+extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv) {
+  wvoec::RedirectStdoutToFile();
+  license_api_fuzz.Initialize();
+  license_api_fuzz.LoadLicenseWithGenericCryptoKeys();
+  return 0;
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  // Split data using separator.
+  const std::vector<wvoec::FuzzedData> inputs =
+      wvoec::SplitFuzzedData(data, size);
+  if (inputs.size() < 2) {
+    return 0;
+  }
+
+  // Deserialize fuzzed data.
+  wvoec::OEMCrypto_Generic_Api_Fuzz fuzzed_structure;
+  if (inputs[0].size < sizeof(fuzzed_structure)) {
+    return 0;
+  }
+  FuzzedDataProvider fuzzed_data(inputs[0].data, inputs[0].size);
+  fuzzed_data.ConsumeData(&fuzzed_structure, sizeof(fuzzed_structure));
+  wvoec::ConvertDataToValidEnum(OEMCrypto_CipherMode_MaxValue,
+                                fuzzed_structure.cipher_mode);
+  wvoec::ConvertDataToValidEnum(OEMCrypto_Algorithm_MaxValue,
+                                fuzzed_structure.algorithm);
+  const std::vector<uint8_t> buffer =
+      fuzzed_data.ConsumeRemainingBytes<uint8_t>();
+  const std::vector<uint8_t> signature(inputs[1].data,
+                                       inputs[1].data + inputs[1].size);
+
+  // Select key and verify.
+  wvoec::Session& session = license_api_fuzz.session();
+  OEMCrypto_SelectKey(session.session_id(), session.license().keys[3].key_id,
+                      session.license().keys[3].key_id_length,
+                      fuzzed_structure.cipher_mode);
+  OEMCrypto_Generic_Verify(session.session_id(), buffer.data(), buffer.size(),
+                           fuzzed_structure.algorithm, signature.data(),
+                           signature.size());
   return 0;
 }
-}  // namespace wvoec