option_model.cc

Go to the documentation of this file.

/*
 * Copyright (C) Max Dymond, <cmeister2@gmail.com>, et al.
 *
 * SPDX-License-Identifier: curl
 */

 
#include "proto_fuzzer/option_model.h"
 
#include <curl/curl.h>
 
namespace proto_fuzzer {
 
namespace {
 
// Only the generated constants require curl headers. This translation unit
// makes no libcurl calls and can be linked into normalization-only tests.
namespace generated {
#include "curl_fuzzer_option_manifest.inc"
}  // namespace generated
 
}  // namespace

std::uint64_t DecodeIntegralOptionValue(const OptionDescriptor& descriptor,
                                        const curl::fuzzer::proto::SetOption& option) {
  if (descriptor.kind == OptionValueKind::kString) {
    return 0;
  }
  switch (option.value_case()) {
    case curl::fuzzer::proto::SetOption::kBoolValue:
      return option.bool_value() ? 1U : 0U;
    case curl::fuzzer::proto::SetOption::kUintValue:
      return descriptor.kind == OptionValueKind::kBool ? (option.uint_value() != 0 ? 1U : 0U) : option.uint_value();
    case curl::fuzzer::proto::SetOption::kStringValue:
    case curl::fuzzer::proto::SetOption::VALUE_NOT_SET:
      return 0;
  }
  return 0;
}

const OptionDescriptor* LookupOptionDescriptor(curl::fuzzer::proto::CurlOptionId id) {
  return generated::LookupOptionDescriptor(id);
}

bool UsesInMemoryPublicKeyPin(const std::string& value) { return value.rfind("sha256//", 0) == 0; }

void ConstrainPinnedPublicKeyValue(std::string* value) {
  if (value != nullptr && !UsesInMemoryPublicKeyPin(*value)) {
    value->insert(0, "sha256//");
  }
}

std::uint64_t DecodeIntegralOptionValue(const curl::fuzzer::proto::SetOption& option) {
  const OptionDescriptor* descriptor = LookupOptionDescriptor(option.option_id());
  return descriptor == nullptr ? 0 : DecodeIntegralOptionValue(*descriptor, option);
}

void CanonicalizeOptionValueCases(curl::fuzzer::proto::Scenario* scenario) {
  if (scenario == nullptr) {
    return;
  }
  for (auto& option : *scenario->mutable_options()) {
    const OptionDescriptor* descriptor = LookupOptionDescriptor(option.option_id());
    if (descriptor == nullptr) {
      continue;
    }
    switch (descriptor->kind) {
      case OptionValueKind::kString:
        if (option.value_case() != curl::fuzzer::proto::SetOption::kStringValue) {
          option.set_string_value("");
        }
        if (descriptor->id == curl::fuzzer::proto::CURLOPT_PINNEDPUBLICKEY) {
          ConstrainPinnedPublicKeyValue(option.mutable_string_value());
        }
        break;
      case OptionValueKind::kUint:
        if (option.value_case() != curl::fuzzer::proto::SetOption::kUintValue) {
          option.set_uint_value(DecodeIntegralOptionValue(*descriptor, option));
        }
        break;
      case OptionValueKind::kBool:
        if (option.value_case() != curl::fuzzer::proto::SetOption::kBoolValue) {
          option.set_bool_value(DecodeIntegralOptionValue(*descriptor, option) != 0);
        }
        break;
    }
  }
}
 
}  // namespace proto_fuzzer