android/libwvdrmengine/oemcrypto/test/fuzz_tests/oemcrypto_fuzz_helper.h

// Copyright 2020 Google LLC. All Rights Reserved. This file and proprietary
// source code may only be used and distributed under the Widevine
// License Agreement.

#ifndef OEMCRYPTO_FUZZ_HELPER_H_
#define OEMCRYPTO_FUZZ_HELPER_H_

#include <vector>

#include "FuzzedDataProvider.h"
#include "oec_device_features.h"
#include "oemcrypto_corpus_generator_helper.h"
#include "oemcrypto_session_tests_helper.h"

// Forward-declare the libFuzzer's mutator callback. Mark it weak so that
// the program links successfully even outside of --config=asan-fuzzer
// (apparently the only config in which LLVM uses our custom mutator).
extern "C" size_t LLVMFuzzerMutate(uint8_t* Data, size_t Size, size_t MaxSize)
    __attribute__((weak));

namespace wvoec {

constexpr size_t KB = 1024;

// Default maximum length of fuzzing output parameters.
constexpr size_t MAX_FUZZ_OUTPUT_LENGTH = 5 * KB;

// Fuzzed data region.
struct FuzzedData {
  const uint8_t* data;
  size_t size;
};

// Initial setup to create a valid OEMCrypto state such as initializing crypto
// firmware/hardware, installing golden key box etc. in order to fuzz
// OEMCrypto APIs.
void InitializeFuzz(SessionUtil& session_util);

class OEMCryptoLicenseAPIFuzz {
 public:
  OEMCryptoLicenseAPIFuzz() : license_messages_(&session_) {}

  void Initialize();

  void Terminate();

  void LoadLicense();

  LicenseRoundTrip& license_messages() { return license_messages_; }

  const LicenseRoundTrip& license_messages() const { return license_messages_; }

  Session& session() { return session_; }

  const Session& session() const { return session_; }

 private:
  SessionUtil session_util_;
  Session session_;
  LicenseRoundTrip license_messages_;
};

class OEMCryptoProvisioningAPIFuzz {
 public:
  OEMCryptoProvisioningAPIFuzz()
      : provisioning_messages_(&session_, session_util_.encoded_rsa_key_) {}

  void Intialize();

  void Terminate();

  void LoadProvisioning();

  ProvisioningRoundTrip& provisioning_messages() {
    return provisioning_messages_;
  }

  const ProvisioningRoundTrip& provisioning_messages() const {
    return provisioning_messages_;
  }

  Session& session() { return session_; }

  const Session& session() const { return session_; }

 private:
  SessionUtil session_util_;
  Session session_;
  ProvisioningRoundTrip provisioning_messages_;
};

// Initial setup to create a valid state such as creating session, installing
// golden key box etc. in order to fuzz Load Renewal API.
class OEMCryptoRenewalAPIFuzz {
 public:
  OEMCryptoRenewalAPIFuzz()
      : renewal_messages_(&license_api_fuzz_.license_messages()) {}

  void Intialize() { license_api_fuzz_.Initialize(); }

  void Terminate() { license_api_fuzz_.Terminate(); }

  LicenseRoundTrip& license_messages() {
    return license_api_fuzz_.license_messages();
  }

  const LicenseRoundTrip& license_messages() const {
    return license_api_fuzz_.license_messages();
  }

  RenewalRoundTrip& renewal_messages() { return renewal_messages_; }

  const RenewalRoundTrip& renewal_messages() const { return renewal_messages_; }

 private:
  OEMCryptoLicenseAPIFuzz license_api_fuzz_;
  RenewalRoundTrip renewal_messages_;
};

class LicenseWithUsageEntryFuzz {
 public:
  LicenseWithUsageEntryFuzz() : license_messages_(&session_) {
    license_messages_.set_pst("my_pst");
  }

  void Initialize() { InitializeFuzz(session_util_); }

  void InstallTestDrmKey(Session* session) {
    session_util_.InstallTestDrmKey(session);
  }

  void CreateUsageTableHeader();

  void LoadLicense();

  LicenseRoundTrip& license_messages() { return license_messages_; }

  const LicenseRoundTrip& license_messages() const { return license_messages_; }

  const vector<uint8_t>& encrypted_usage_header() const {
    return encrypted_usage_header_;
  }

 private:
  SessionUtil session_util_;
  vector<uint8_t> encrypted_usage_header_;
  LicenseRoundTrip license_messages_;
  Session session_;
};

// Convert data from FuzzedDataProvider to valid enum value.
template <typename T>
T ConvertDataToValidEnum(FuzzedDataProvider& fuzzed_data, T max_enum_value) {
  return static_cast<T>(fuzzed_data.ConsumeIntegralInRange<uint32_t>(
      0, static_cast<uint32_t>(max_enum_value)));
}

// Convert data to valid enum value in place.
template <typename T>
void ConvertDataToValidEnum(T max_enum_value, T* t) {
  FuzzedDataProvider fuzzed_enum_data(reinterpret_cast<uint8_t*>(t), sizeof(T));
  *t = ConvertDataToValidEnum(fuzzed_enum_data, max_enum_value);
}

// Redirect printf and log statements from oemcrypto functions to a file to
// reduce noise
void RedirectStdoutToFile();

// Split fuzzed data using delimiter "-_^_".
std::vector<FuzzedData> SplitFuzzedData(const uint8_t* data, size_t size);

// Check the status and exit fuzzer if arguments do not match. This is usually
// called to check status of APIs which are called to setup state for fuzzers.
void CheckStatusAndExitFuzzerOnFailure(OEMCryptoResult result,
                                       OEMCryptoResult expected_status);

}  // namespace wvoec

#endif  // OEMCRYPTO_FUZZ_HELPER_H_