Source repositorynvhttp.h

Go to the documentation of this file.

// macros
#pragma once
 
// standard includes
#include <chrono>
#include <condition_variable>
#include <cstddef>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
// lib includes
#include <boost/property_tree/ptree.hpp>
#include <nlohmann/json.hpp>
#include <Simple-Web-Server/server_https.hpp>
 
// local includes
#include "crypto.h"

namespace nvhttp {

  constexpr auto VERSION = "7.1.431.-1";

  constexpr auto GFE_VERSION = "3.23.0.74";

  constexpr auto PORT_HTTP = 0;

  constexpr auto PORT_HTTPS = -5;

  constexpr std::size_t MAX_PENDING_PAIRING_SESSIONS = 32;

  constexpr std::size_t PAIRING_ID_SIZE = 32;

  constexpr std::size_t MAX_PAIRING_CLIENT_NAME_SIZE = 128;

  constexpr auto PAIRING_SESSION_TIMEOUT = std::chrono::minutes {5};

  void start();

  void setup(const std::string &pkey, const std::string &cert);

  class SunshineHTTPS: public SimpleWeb::HTTPS {
  public:
    SunshineHTTPS(boost::asio::io_context &io_context, boost::asio::ssl::context &ctx):
        SimpleWeb::HTTPS(io_context, ctx) {
    }
 
    virtual ~SunshineHTTPS() {
      // Gracefully shutdown the TLS connection
      SimpleWeb::error_code ec;
      shutdown(ec);
    }
  };

  enum class PAIR_PHASE {
    NONE,  
    GETSERVERCERT,  
    CLIENTCHALLENGE,  
    SERVERCHALLENGERESP,  
    CLIENTPAIRINGSECRET  
  };

  struct pairing_completion_t {
    std::condition_variable condition;  
    std::mutex mutex;  
    std::optional<bool> result;  
  };

  struct pair_session_t {
    struct {
      std::string uniqueID = {};  
      std::string cert = {};  
      std::string name = {};  
    } client;  
 
    std::unique_ptr<crypto::aes_t> cipher_key = {};  
    std::vector<uint8_t> clienthash = {};  
 
    std::string serversecret = {};  
    std::string serverchallenge = {};  
    std::shared_ptr<pairing_completion_t> completion = std::make_shared<pairing_completion_t>();  
 
    struct {
      util::Either<
        std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTP>::Response>,
        std::shared_ptr<typename SimpleWeb::ServerBase<SunshineHTTPS>::Response>>
        response;  
      std::string salt = {};  
      std::string id = {};  
      std::string device_name = {};  
      std::string address = {};  
      std::chrono::steady_clock::time_point expires_at = std::chrono::steady_clock::time_point::max();  
    } async_insert_pin;  

    PAIR_PHASE last_phase = PAIR_PHASE::NONE;
    bool failed = false;  
  };

  struct pending_pairing_t {
    std::string id;  
    std::string name;  
    std::string address;  
  };

  enum class pair_session_insert_e {
    ADDED,  
    ALREADY_EXISTS,  
    FULL  
  };

  bool is_valid_pairing_id(std::string_view pairing_id);

  bool is_valid_pairing_pin(std::string_view pin);

  bool is_valid_pairing_name(std::string_view name);

  pair_session_insert_e insert_pair_session(pair_session_t sess, std::string &pairing_id);

  bool evict_abandoned_pair_session(const std::string &unique_id);

  void expire_pair_sessions(std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now());

  std::vector<pending_pairing_t> get_pending_pairings();

  bool cancel_pairing(std::string_view pairing_id);

  void remove_session(const pair_session_t &sess);

  void getservercert(pair_session_t &sess, boost::property_tree::ptree &tree, const std::string &pin);

  void clientchallenge(pair_session_t &sess, boost::property_tree::ptree &tree, const std::string &challenge);

  void serverchallengeresp(pair_session_t &sess, boost::property_tree::ptree &tree, const std::string &encrypted_response);

  void clientpairingsecret(pair_session_t &sess, boost::property_tree::ptree &tree, const std::string &client_pairing_secret);

  bool pin(std::string_view pairing_id, std::string pin, std::string name);

  bool unpair_client(std::string_view uuid);

  bool set_client_enabled(std::string_view uuid, bool enabled);
  std::string get_cert_by_uuid(std::string_view uuid);

  nlohmann::json get_all_clients();

  void erase_all_clients();
 
#ifdef SUNSHINE_TESTS
  namespace test_support {
    std::unique_ptr<SimpleWeb::ServerBase<SunshineHTTPS>> make_https_server(
      const std::string &certificate_file,
      const std::string &private_key_file,
      std::shared_ptr<SimpleWeb::ScopeRunner> &handler_scope
    );

    void pair_http(
      std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTP>::Response> response,
      std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTP>::Request> request
    );

    void reset_client_state();

    std::string add_client(const std::string &name, std::string cert, bool enabled);

    bool duplicate_client(std::string_view uuid);

    bool authorize_client_certificate(std::string_view cert);

    bool complete_pairing(std::string_view pairing_id, bool success);

    void reload_client_state();
  }  // namespace test_support
#endif
}  // namespace nvhttp