crypto_verify.h

#ifndef SOURCEMETA_CORE_CRYPTO_VERIFY_H_
#define SOURCEMETA_CORE_CRYPTO_VERIFY_H_
 
#ifndef SOURCEMETA_CORE_CRYPTO_EXPORT
#include <sourcemeta/core/crypto_export.h>
#endif
 
#include <cstdint>     // std::uint8_t
#include <optional>    // std::optional
#include <string>      // std::string
#include <string_view> // std::string_view
 
namespace sourcemeta::core {

enum class SignatureHashFunction : std::uint8_t {
  SHA256,
  SHA384,
  SHA512
};

enum class EllipticCurve : std::uint8_t {
  P256,
  P384,
  P521
};

enum class EdwardsCurve : std::uint8_t {
  Ed25519,
  Ed448
};

class SOURCEMETA_CORE_CRYPTO_EXPORT PublicKey {
public:
  enum class Type : std::uint8_t {
    RSA,
    EllipticCurve,
    Edwards
  };
 
  ~PublicKey();
  PublicKey(PublicKey &&other) noexcept;
  auto operator=(PublicKey &&other) noexcept -> PublicKey &;
  PublicKey(const PublicKey &) = delete;
  auto operator=(const PublicKey &) -> PublicKey & = delete;

  [[nodiscard]] auto type() const noexcept -> Type;

  struct Internal;
  explicit PublicKey(Internal *internal) noexcept;
  [[nodiscard]] auto internal() const noexcept -> const Internal * {
    return this->internal_;
  }
 
private:
  Internal *internal_;
};

auto SOURCEMETA_CORE_CRYPTO_EXPORT make_rsa_public_key(
    const std::string_view modulus, const std::string_view exponent)
    -> std::optional<PublicKey>;

auto SOURCEMETA_CORE_CRYPTO_EXPORT make_ec_public_key(
    const EllipticCurve curve, const std::string_view coordinate_x,
    const std::string_view coordinate_y) -> std::optional<PublicKey>;

auto SOURCEMETA_CORE_CRYPTO_EXPORT make_eddsa_public_key(
    const EdwardsCurve curve, const std::string_view public_key)
    -> std::optional<PublicKey>;

struct RSAPublicComponents {
  std::string modulus;
  std::string exponent;
};

struct ECPublicComponents {
  EllipticCurve curve;
  std::string x;
  std::string y;
};

struct EdwardsPublicComponents {
  EdwardsCurve curve;
  std::string point;
};

auto SOURCEMETA_CORE_CRYPTO_EXPORT rsa_public_components(const PublicKey &key)
    -> std::optional<RSAPublicComponents>;

auto SOURCEMETA_CORE_CRYPTO_EXPORT ec_public_components(const PublicKey &key)
    -> std::optional<ECPublicComponents>;

auto SOURCEMETA_CORE_CRYPTO_EXPORT edwards_public_components(
    const PublicKey &key) -> std::optional<EdwardsPublicComponents>;

auto SOURCEMETA_CORE_CRYPTO_EXPORT rsassa_pkcs1_v15_verify(
    const PublicKey &key, const SignatureHashFunction hash,
    const std::string_view message, const std::string_view signature) -> bool;

auto SOURCEMETA_CORE_CRYPTO_EXPORT rsassa_pss_verify(
    const PublicKey &key, const SignatureHashFunction hash,
    const std::string_view message, const std::string_view signature) -> bool;

auto SOURCEMETA_CORE_CRYPTO_EXPORT ecdsa_verify(
    const PublicKey &key, const SignatureHashFunction hash,
    const std::string_view message, const std::string_view signature) -> bool;

auto SOURCEMETA_CORE_CRYPTO_EXPORT
eddsa_verify(const PublicKey &key, const std::string_view message,
             const std::string_view signature) -> bool;
 
} // namespace sourcemeta::core
 
#endif