jose_jwk_private.h

#ifndef SOURCEMETA_CORE_JOSE_JWK_PRIVATE_H_
#define SOURCEMETA_CORE_JOSE_JWK_PRIVATE_H_
 
#ifndef SOURCEMETA_CORE_JOSE_EXPORT
#include <sourcemeta/core/jose_export.h>
#endif
 
#include <sourcemeta/core/jose_algorithm.h>
 
#include <sourcemeta/core/crypto.h>
#include <sourcemeta/core/json.h>
 
#include <cstdint>     // std::uint8_t
#include <optional>    // std::optional, std::nullopt
#include <string>      // std::string
#include <string_view> // std::string_view
 
namespace sourcemeta::core {

class SOURCEMETA_CORE_JOSE_EXPORT JWKPrivate {
public:
  enum class Type : std::uint8_t {
    RSA,
    EllipticCurve,
    OctetKeyPair,
    Octet
  };

  JWKPrivate(JWKPrivate &&other) noexcept = default;
  auto operator=(JWKPrivate &&other) noexcept -> JWKPrivate & = default;
  JWKPrivate(const JWKPrivate &) = delete;
  auto operator=(const JWKPrivate &) -> JWKPrivate & = delete;
  ~JWKPrivate() = default;

  [[nodiscard]] static auto from(const JSON &value)
      -> std::optional<JWKPrivate>;

  [[nodiscard]] static auto from(JSON &&value) -> std::optional<JWKPrivate>;

  [[nodiscard]] static auto from_pem(const std::string_view pem)
      -> std::optional<JWKPrivate>;

  [[nodiscard]] static auto from_octets(const std::string_view secret)
      -> JWKPrivate;

  [[nodiscard]] auto type() const noexcept -> Type { return this->type_; }

  [[nodiscard]] auto key_id() const noexcept
      -> std::optional<std::string_view> {
    if (this->key_id_.has_value()) {
      return std::string_view{*this->key_id_};
    }
 
    return std::nullopt;
  }

  [[nodiscard]] auto algorithm() const noexcept -> std::optional<JWSAlgorithm> {
    return this->algorithm_;
  }
 
  // Elliptic curve keys (RFC 7518 Section 6.2) and octet key pairs (RFC 8037
  // Section 2) carry a curve name, which the elliptic curve algorithms pin to
  // exactly one curve. A key parsed from a PEM document carries it once its
  // public part has been recovered, and it stays empty for a key that carries
  // no curve, such as an RSA or symmetric key
  [[nodiscard]] auto curve() const noexcept -> std::string_view {
    return this->curve_;
  }
 
  // The parsed platform key, built once from the decoded material so that
  // signing reuses it rather than reconstructing it per signature. It is null
  // when the material could not be turned into a key
  [[nodiscard]] auto private_key() const noexcept -> const PrivateKey * {
    return this->private_key_.has_value() ? &*this->private_key_ : nullptr;
  }
 
  // Symmetric keys carry their raw secret rather than a parsed platform key
  // (RFC 7518 Section 6.4), and knowing the secret is required for both
  // producing and checking an HMAC, so the private key class carries it
  [[nodiscard]] auto secret() const noexcept -> std::string_view {
    return this->secret_;
  }

  [[nodiscard]] auto public_jwk() const -> std::optional<JSON>;

  [[nodiscard]] auto thumbprint() const -> std::optional<std::string>;
 
private:
  JWKPrivate() = default;
  static auto parse(const JSON &value, JWKPrivate &result) -> bool;
 
#if defined(_MSC_VER)
#pragma warning(disable : 4251)
#endif
  Type type_{Type::RSA};
  std::optional<std::string> key_id_;
  std::optional<JWSAlgorithm> algorithm_;
  std::string curve_;
  std::optional<PrivateKey> private_key_;
  std::string secret_;
  std::string modulus_;
  std::string exponent_;
  std::string coordinate_x_;
  std::string coordinate_y_;
  std::string public_point_;
#if defined(_MSC_VER)
#pragma warning(default : 4251)
#endif
};
 
} // namespace sourcemeta::core
 
#endif