http_client.cpp

#include "shieldcore/http_client.hpp"

#include <curl/curl.h>

#include <chrono>
#include <iomanip>
#include <memory>
#include <random>
#include <sstream>
#include <string>

namespace shieldcore {

std::string generateNonce() {
  std::random_device randomDevice;
  std::mt19937 generator(randomDevice());
  std::uniform_int_distribution<int> distribution(0, 255);

  std::ostringstream stream;
  stream << std::hex << std::setfill('0');
  for (int index = 0; index < 16; ++index) {
    stream << std::setw(2) << distribution(generator);
  }
  return stream.str();
}

long long getCurrentTimestamp() {
  return std::chrono::duration_cast<std::chrono::seconds>(
      std::chrono::system_clock::now().time_since_epoch()).count();
}

namespace {

size_t writeCallback(char* contents, size_t size, size_t count, void* userData) {
  auto* response = static_cast<std::string*>(userData);
  response->append(contents, size * count);
  return size * count;
}

bool curlGlobalInit() {
  static const bool initialized = []() {
    return curl_global_init(CURL_GLOBAL_DEFAULT) == CURLE_OK;
  }();
  return initialized;
}

}  // namespace

bool validateWithBackend(const std::string& baseUrl,
                         const std::string& pluginId,
                         const std::string& hwid,
                         bool& isValid,
                         std::string& error) {
  isValid = false;

  if (!curlGlobalInit()) {
    error = "failed to initialize libcurl";
    return false;
  }

  CURL* raw = curl_easy_init();
  if (!raw) {
    error = "failed to create curl handle";
    return false;
  }

  std::unique_ptr<CURL, decltype(&curl_easy_cleanup)> curl(raw, curl_easy_cleanup);
  std::string response;
  const std::string requestBody = "{\"plugin_id\":\"" + pluginId + "\",\"hwid\":\"" + hwid + "\"}";

  struct curl_slist* headers = nullptr;
  headers = curl_slist_append(headers, "Content-Type: application/json");

  curl_easy_setopt(curl.get(), CURLOPT_URL, (baseUrl + "/validate").c_str());
  curl_easy_setopt(curl.get(), CURLOPT_HTTPHEADER, headers);
  curl_easy_setopt(curl.get(), CURLOPT_POST, 1L);
  curl_easy_setopt(curl.get(), CURLOPT_POSTFIELDS, requestBody.c_str());
  curl_easy_setopt(curl.get(), CURLOPT_POSTFIELDSIZE, static_cast<long>(requestBody.size()));
  curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, writeCallback);
  curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &response);

  CURLcode code = curl_easy_perform(curl.get());
  curl_slist_free_all(headers);
  if (code != CURLE_OK) {
    error = curl_easy_strerror(code);
    return false;
  }

  if (response.find("valid") != std::string::npos) {
    isValid = true;
    return true;
  }

  if (response.find("invalid") != std::string::npos) {
    isValid = false;
    return true;
  }

  error = "unexpected backend response: " + response;
  return false;
}

bool activateLicense(const std::string& baseUrl,
                     const LicenseValidationRequest& request,
                     LicenseValidationResponse& response,
                     std::string& error) {
  response = {};

  if (!curlGlobalInit()) {
    error = "failed to initialize libcurl";
    return false;
  }

  CURL* raw = curl_easy_init();
  if (!raw) {
    error = "failed to create curl handle";
    return false;
  }

  std::unique_ptr<CURL, decltype(&curl_easy_cleanup)> curl(raw, curl_easy_cleanup);
  std::string responseBody;
  const std::string requestBody =
      "{\"license_key\":\"" + request.licenseKey +
      "\",\"hwid\":\"" + request.hwid +
      "\",\"nonce\":\"" + request.nonce +
      "\",\"timestamp\":" + std::to_string(request.timestamp) + "}";

  struct curl_slist* headers = nullptr;
  headers = curl_slist_append(headers, "Content-Type: application/json");

  curl_easy_setopt(curl.get(), CURLOPT_URL, (baseUrl + "/activate").c_str());
  curl_easy_setopt(curl.get(), CURLOPT_HTTPHEADER, headers);
  curl_easy_setopt(curl.get(), CURLOPT_POST, 1L);
  curl_easy_setopt(curl.get(), CURLOPT_POSTFIELDS, requestBody.c_str());
  curl_easy_setopt(curl.get(), CURLOPT_POSTFIELDSIZE, static_cast<long>(requestBody.size()));
  curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, writeCallback);
  curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &responseBody);

  CURLcode code = curl_easy_perform(curl.get());
  curl_slist_free_all(headers);
  if (code != CURLE_OK) {
    error = curl_easy_strerror(code);
    return false;
  }

  if (responseBody.find("valid") != std::string::npos) {
    response.valid = true;
  }
  if (responseBody.find("revoked") != std::string::npos) {
    response.isRevoked = true;
  }

  return true;
}

}  // namespace shieldcore