Copy submitted odk fuzzing changes from cdm repository to android

Merging odk changes from http://go/wvgerrit/98084

Copy submitted changes for oemcrypto/odk/test/fuzzing from cdm
repository to android so that fuzzer scripts in odk can be run
using go/android-fuzzing

Google3 CLs:
http://cl/301943247
http://cl/304011238
http://cl/307142293
http://cl/307087692

Bug: 150900870
Test: The fuzzer scripts can be built once the code is moved to android
tree. Odk fuzzer scripts have been verified and successfully running in
google3

Change-Id: I92b8a357c32b145c7f80bdc93d05214862368957

libwvdrmengine/oemcrypto/odk/test/fuzzing/odk_fuzz_helper.cpp

@@ -0,0 +1,151 @@
+// Copyright 2020 Google LLC. All rights reserved. This file and proprietary
+// source code may only be used and distributed under the Widevine Master
+// License Agreement.
+#include "fuzzing/odk_fuzz_helper.h"
+
+#include "odk.h"
+
+namespace oemcrypto_core_message {
+
+bool convert_byte_to_valid_boolean(const bool* in) {
+  const char* buf = reinterpret_cast<const char*>(in);
+  for (int i = 0; i < sizeof(bool); i++) {
+    if (buf[i]) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void ConvertDataToValidBools(ODK_ParsedLicense* t) {
+  // Convert boolean flags in parsed_license to valid bytes to
+  // avoid errors from msan
+  t->nonce_required = convert_byte_to_valid_boolean(&t->nonce_required);
+  t->timer_limits.soft_enforce_playback_duration =
+      convert_byte_to_valid_boolean(
+          &t->timer_limits.soft_enforce_playback_duration);
+  t->timer_limits.soft_enforce_rental_duration = convert_byte_to_valid_boolean(
+      &t->timer_limits.soft_enforce_rental_duration);
+}
+
+void ConvertDataToValidBools(ODK_PreparedRenewalRequest* t) {}
+
+void ConvertDataToValidBools(ODK_ParsedProvisioning* t) {}
+
+OEMCryptoResult odk_serialize_LicenseRequest(
+    const void* in, uint8_t* out, size_t* size,
+    const ODK_LicenseRequest& core_license_request,
+    const ODK_NonceValues* nonce_values) {
+  return ODK_PrepareCoreLicenseRequest(out, SIZE_MAX, size, nonce_values);
+}
+
+OEMCryptoResult odk_serialize_RenewalRequest(
+    const void* in, uint8_t* out, size_t* size,
+    const ODK_RenewalRequest& core_renewal, ODK_NonceValues* nonce_values) {
+  ODK_ClockValues clock{};
+  memcpy(&clock, in, sizeof(ODK_ClockValues));
+  uint64_t system_time_seconds = core_renewal.playback_time_seconds;
+  return ODK_PrepareCoreRenewalRequest(out, SIZE_MAX, size, nonce_values,
+                                       &clock, system_time_seconds);
+}
+
+OEMCryptoResult odk_serialize_ProvisioningRequest(
+    const void* in, uint8_t* out, size_t* size,
+    const ODK_ProvisioningRequest& core_provisioning,
+    const ODK_NonceValues* nonce_values) {
+  const std::string& device_id = core_provisioning.device_id;
+  return ODK_PrepareCoreProvisioningRequest(
+      out, SIZE_MAX, size, nonce_values,
+      reinterpret_cast<const uint8_t*>(device_id.data()), device_id.size());
+}
+
+OEMCryptoResult odk_deserialize_LicenseResponse(const uint8_t* message,
+                                                size_t core_message_length,
+                                                ODK_ParseLicense_Args* a,
+                                                ODK_NonceValues* nonce_values,
+                                                ODK_ParsedLicense* parsed_lic) {
+  return ODK_ParseLicense(message, SIZE_MAX, core_message_length,
+                          static_cast<bool>(a->initial_license_load),
+                          static_cast<bool>(a->usage_entry_present),
+                          a->request_hash, &a->timer_limits, &a->clock_values,
+                          nonce_values, parsed_lic);
+}
+
+OEMCryptoResult odk_deserialize_RenewalResponse(
+    const uint8_t* buf, size_t len, ODK_ParseRenewal_Args* a,
+    ODK_NonceValues* nonce_values, ODK_PreparedRenewalRequest* renewal_msg) {
+  /* Address Sanitizer doesn't like values other than 0 OR 1 for boolean
+   * variables. Input from fuzzer can be parsed and any random bytes can be
+   * assigned to boolean variables. Using the workaround to mitigate sanitizer
+   * errors in fuzzer code and converting random bytes to 0 OR 1.
+   * This has no negative security impact*/
+  a->timer_limits.soft_enforce_playback_duration =
+      convert_byte_to_valid_boolean(
+          &a->timer_limits.soft_enforce_playback_duration);
+  a->timer_limits.soft_enforce_rental_duration = convert_byte_to_valid_boolean(
+      &a->timer_limits.soft_enforce_rental_duration);
+  uint64_t timer_value = 0;
+  OEMCryptoResult err =
+      ODK_ParseRenewal(buf, SIZE_MAX, len, nonce_values, a->system_time,
+                       &a->timer_limits, &a->clock_values, &timer_value);
+  if (OEMCrypto_SUCCESS == err) {
+    Message* msg = nullptr;
+    AllocateMessage(&msg, message_block);
+    InitMessage(msg, const_cast<uint8_t*>(buf), len);
+    SetSize(msg, len);
+    Unpack_ODK_PreparedRenewalRequest(msg, renewal_msg);
+    assert(ValidMessage(msg));
+  }
+  return err;
+}
+
+OEMCryptoResult odk_deserialize_ProvisioningResponse(
+    const uint8_t* buf, size_t len, ODK_ParseProvisioning_Args* a,
+    ODK_NonceValues* nonce_values, ODK_ParsedProvisioning* parsed_prov) {
+  return ODK_ParseProvisioning(buf, SIZE_MAX, len, nonce_values, a->device_id,
+                               a->device_id_length, parsed_prov);
+}
+
+bool kdo_serialize_LicenseResponse(const ODK_ParseLicense_Args* args,
+                                   const ODK_ParsedLicense& parsed_lic,
+                                   std::string* oemcrypto_core_message) {
+  const auto& nonce_values = args->nonce_values;
+  ODK_LicenseRequest core_request{nonce_values.api_minor_version,
+                                  nonce_values.api_major_version,
+                                  nonce_values.nonce, nonce_values.session_id};
+  std::string core_request_sha_256(
+      reinterpret_cast<const char*>(args->request_hash), ODK_SHA256_HASH_SIZE);
+  return serialize::CreateCoreLicenseResponse(
+      parsed_lic, core_request, core_request_sha_256, oemcrypto_core_message);
+}
+
+bool kdo_serialize_RenewalResponse(
+    const ODK_ParseRenewal_Args* args,
+    const ODK_PreparedRenewalRequest& renewal_msg,
+    std::string* oemcrypto_core_message) {
+  const auto& nonce_values = args->nonce_values;
+  ODK_RenewalRequest core_request{
+      nonce_values.api_minor_version, nonce_values.api_major_version,
+      nonce_values.nonce, nonce_values.session_id, renewal_msg.playback_time};
+  return serialize::CreateCoreRenewalResponse(
+      core_request, args->timer_limits.initial_renewal_duration_seconds,
+      oemcrypto_core_message);
+}
+
+bool kdo_serialize_ProvisioningResponse(
+    const ODK_ParseProvisioning_Args* args,
+    const ODK_ParsedProvisioning& parsed_prov,
+    std::string* oemcrypto_core_message) {
+  const auto& nonce_values = args->nonce_values;
+  if (args->device_id_length > sizeof(args->device_id)) {
+    return false;
+  }
+  ODK_ProvisioningRequest core_request{
+      nonce_values.api_minor_version, nonce_values.api_major_version,
+      nonce_values.nonce, nonce_values.session_id,
+      std::string(reinterpret_cast<const char*>(args->device_id),
+                  args->device_id_length)};
+  return serialize::CreateCoreProvisioningResponse(parsed_prov, core_request,
+                                                   oemcrypto_core_message);
+}
+}  // namespace oemcrypto_core_message