jwt.h

Go to the documentation of this file.

#ifndef JWT_CPP_JWT_H
#define JWT_CPP_JWT_H
 
#ifndef JWT_DISABLE_PICOJSON
#ifndef PICOJSON_USE_INT64
#define PICOJSON_USE_INT64
#endif
#include "picojson/picojson.h"
#endif
 
#ifndef JWT_DISABLE_BASE64
#include "base.h"
#endif
 
#include <openssl/ec.h>
#include <openssl/ecdsa.h>
#include <openssl/err.h>
#include <openssl/evp.h>
#include <openssl/hmac.h>
#include <openssl/pem.h>
#include <openssl/rsa.h>
#include <openssl/ssl.h>
 
#include <algorithm>
#include <chrono>
#include <cmath>
#include <functional>
#include <iterator>
#include <locale>
#include <memory>
#include <set>
#include <system_error>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>
 
#if __cplusplus > 201103L
#include <codecvt>
#endif
 
#if __cplusplus >= 201402L
#ifdef __has_include
#if __has_include(<experimental/type_traits>)
#include <experimental/type_traits>
#endif
#endif
#endif
 
#if OPENSSL_VERSION_NUMBER >= 0x30000000L // 3.0.0
#define JWT_OPENSSL_3_0
#elif OPENSSL_VERSION_NUMBER >= 0x10101000L // 1.1.1
#define JWT_OPENSSL_1_1_1
#elif OPENSSL_VERSION_NUMBER >= 0x10100000L // 1.1.0
#define JWT_OPENSSL_1_1_0
#elif OPENSSL_VERSION_NUMBER >= 0x10000000L // 1.0.0
#define JWT_OPENSSL_1_0_0
#endif
 
#if defined(LIBRESSL_VERSION_NUMBER)
#if LIBRESSL_VERSION_NUMBER >= 0x3050300fL
#define JWT_OPENSSL_1_1_0
#else
#define JWT_OPENSSL_1_0_0
#endif
#endif
 
#if defined(LIBWOLFSSL_VERSION_HEX)
#define JWT_OPENSSL_1_1_1
#endif
 
#ifndef JWT_CLAIM_EXPLICIT
#define JWT_CLAIM_EXPLICIT explicit
#endif
 
namespace jwt {
    using date = std::chrono::system_clock::time_point;
 
    namespace error {
        struct signature_verification_exception : public std::system_error {
            using system_error::system_error;
        };
        struct signature_generation_exception : public std::system_error {
            using system_error::system_error;
        };
        struct rsa_exception : public std::system_error {
            using system_error::system_error;
        };
        struct ecdsa_exception : public std::system_error {
            using system_error::system_error;
        };
        struct token_verification_exception : public std::system_error {
            using system_error::system_error;
        };
        enum class rsa_error {
            ok = 0,
            cert_load_failed = 10,
            get_key_failed,
            write_key_failed,
            write_cert_failed,
            convert_to_pem_failed,
            load_key_bio_write,
            load_key_bio_read,
            create_mem_bio_failed,
            no_key_provided
        };
        inline std::error_category& rsa_error_category() {
            class rsa_error_cat : public std::error_category {
            public:
                const char* name() const noexcept override { return "rsa_error"; };
                std::string message(int ev) const override {
                    switch (static_cast<rsa_error>(ev)) {
                    case rsa_error::ok: return "no error";
                    case rsa_error::cert_load_failed: return "error loading cert into memory";
                    case rsa_error::get_key_failed: return "error getting key from certificate";
                    case rsa_error::write_key_failed: return "error writing key data in PEM format";
                    case rsa_error::write_cert_failed: return "error writing cert data in PEM format";
                    case rsa_error::convert_to_pem_failed: return "failed to convert key to pem";
                    case rsa_error::load_key_bio_write: return "failed to load key: bio write failed";
                    case rsa_error::load_key_bio_read: return "failed to load key: bio read failed";
                    case rsa_error::create_mem_bio_failed: return "failed to create memory bio";
                    case rsa_error::no_key_provided: return "at least one of public or private key need to be present";
                    default: return "unknown RSA error";
                    }
                }
            };
            static rsa_error_cat cat;
            return cat;
        }
 
        inline std::error_code make_error_code(rsa_error e) { return {static_cast<int>(e), rsa_error_category()}; }
        enum class ecdsa_error {
            ok = 0,
            load_key_bio_write = 10,
            load_key_bio_read,
            create_mem_bio_failed,
            no_key_provided,
            invalid_key_size,
            invalid_key,
            create_context_failed
        };
        inline std::error_category& ecdsa_error_category() {
            class ecdsa_error_cat : public std::error_category {
            public:
                const char* name() const noexcept override { return "ecdsa_error"; };
                std::string message(int ev) const override {
                    switch (static_cast<ecdsa_error>(ev)) {
                    case ecdsa_error::ok: return "no error";
                    case ecdsa_error::load_key_bio_write: return "failed to load key: bio write failed";
                    case ecdsa_error::load_key_bio_read: return "failed to load key: bio read failed";
                    case ecdsa_error::create_mem_bio_failed: return "failed to create memory bio";
                    case ecdsa_error::no_key_provided:
                        return "at least one of public or private key need to be present";
                    case ecdsa_error::invalid_key_size: return "invalid key size";
                    case ecdsa_error::invalid_key: return "invalid key";
                    case ecdsa_error::create_context_failed: return "failed to create context";
                    default: return "unknown ECDSA error";
                    }
                }
            };
            static ecdsa_error_cat cat;
            return cat;
        }
 
        inline std::error_code make_error_code(ecdsa_error e) { return {static_cast<int>(e), ecdsa_error_category()}; }
 
        enum class signature_verification_error {
            ok = 0,
            invalid_signature = 10,
            create_context_failed,
            verifyinit_failed,
            verifyupdate_failed,
            verifyfinal_failed,
            get_key_failed,
            set_rsa_pss_saltlen_failed,
            signature_encoding_failed
        };
        inline std::error_category& signature_verification_error_category() {
            class verification_error_cat : public std::error_category {
            public:
                const char* name() const noexcept override { return "signature_verification_error"; };
                std::string message(int ev) const override {
                    switch (static_cast<signature_verification_error>(ev)) {
                    case signature_verification_error::ok: return "no error";
                    case signature_verification_error::invalid_signature: return "invalid signature";
                    case signature_verification_error::create_context_failed:
                        return "failed to verify signature: could not create context";
                    case signature_verification_error::verifyinit_failed:
                        return "failed to verify signature: VerifyInit failed";
                    case signature_verification_error::verifyupdate_failed:
                        return "failed to verify signature: VerifyUpdate failed";
                    case signature_verification_error::verifyfinal_failed:
                        return "failed to verify signature: VerifyFinal failed";
                    case signature_verification_error::get_key_failed:
                        return "failed to verify signature: Could not get key";
                    case signature_verification_error::set_rsa_pss_saltlen_failed:
                        return "failed to verify signature: EVP_PKEY_CTX_set_rsa_pss_saltlen failed";
                    case signature_verification_error::signature_encoding_failed:
                        return "failed to verify signature: i2d_ECDSA_SIG failed";
                    default: return "unknown signature verification error";
                    }
                }
            };
            static verification_error_cat cat;
            return cat;
        }
 
        inline std::error_code make_error_code(signature_verification_error e) {
            return {static_cast<int>(e), signature_verification_error_category()};
        }
 
        enum class signature_generation_error {
            ok = 0,
            hmac_failed = 10,
            create_context_failed,
            signinit_failed,
            signupdate_failed,
            signfinal_failed,
            ecdsa_do_sign_failed,
            digestinit_failed,
            digestupdate_failed,
            digestfinal_failed,
            rsa_padding_failed,
            rsa_private_encrypt_failed,
            get_key_failed,
            set_rsa_pss_saltlen_failed,
            signature_decoding_failed
        };
        inline std::error_category& signature_generation_error_category() {
            class signature_generation_error_cat : public std::error_category {
            public:
                const char* name() const noexcept override { return "signature_generation_error"; };
                std::string message(int ev) const override {
                    switch (static_cast<signature_generation_error>(ev)) {
                    case signature_generation_error::ok: return "no error";
                    case signature_generation_error::hmac_failed: return "hmac failed";
                    case signature_generation_error::create_context_failed:
                        return "failed to create signature: could not create context";
                    case signature_generation_error::signinit_failed:
                        return "failed to create signature: SignInit failed";
                    case signature_generation_error::signupdate_failed:
                        return "failed to create signature: SignUpdate failed";
                    case signature_generation_error::signfinal_failed:
                        return "failed to create signature: SignFinal failed";
                    case signature_generation_error::ecdsa_do_sign_failed: return "failed to generate ecdsa signature";
                    case signature_generation_error::digestinit_failed:
                        return "failed to create signature: DigestInit failed";
                    case signature_generation_error::digestupdate_failed:
                        return "failed to create signature: DigestUpdate failed";
                    case signature_generation_error::digestfinal_failed:
                        return "failed to create signature: DigestFinal failed";
                    case signature_generation_error::rsa_padding_failed:
                        return "failed to create signature: EVP_PKEY_CTX_set_rsa_padding failed";
                    case signature_generation_error::rsa_private_encrypt_failed:
                        return "failed to create signature: RSA_private_encrypt failed";
                    case signature_generation_error::get_key_failed:
                        return "failed to generate signature: Could not get key";
                    case signature_generation_error::set_rsa_pss_saltlen_failed:
                        return "failed to create signature: EVP_PKEY_CTX_set_rsa_pss_saltlen failed";
                    case signature_generation_error::signature_decoding_failed:
                        return "failed to create signature: d2i_ECDSA_SIG failed";
                    default: return "unknown signature generation error";
                    }
                }
            };
            static signature_generation_error_cat cat = {};
            return cat;
        }
 
        inline std::error_code make_error_code(signature_generation_error e) {
            return {static_cast<int>(e), signature_generation_error_category()};
        }
 
        enum class token_verification_error {
            ok = 0,
            wrong_algorithm = 10,
            missing_claim,
            claim_type_missmatch,
            claim_value_missmatch,
            token_expired,
            audience_missmatch
        };
        inline std::error_category& token_verification_error_category() {
            class token_verification_error_cat : public std::error_category {
            public:
                const char* name() const noexcept override { return "token_verification_error"; };
                std::string message(int ev) const override {
                    switch (static_cast<token_verification_error>(ev)) {
                    case token_verification_error::ok: return "no error";
                    case token_verification_error::wrong_algorithm: return "wrong algorithm";
                    case token_verification_error::missing_claim: return "decoded JWT is missing required claim(s)";
                    case token_verification_error::claim_type_missmatch:
                        return "claim type does not match expected type";
                    case token_verification_error::claim_value_missmatch:
                        return "claim value does not match expected value";
                    case token_verification_error::token_expired: return "token expired";
                    case token_verification_error::audience_missmatch:
                        return "token doesn't contain the required audience";
                    default: return "unknown token verification error";
                    }
                }
            };
            static token_verification_error_cat cat = {};
            return cat;
        }
 
        inline std::error_code make_error_code(token_verification_error e) {
            return {static_cast<int>(e), token_verification_error_category()};
        }
 
        inline void throw_if_error(std::error_code ec) {
            if (ec) {
                if (ec.category() == rsa_error_category()) throw rsa_exception(ec);
                if (ec.category() == ecdsa_error_category()) throw ecdsa_exception(ec);
                if (ec.category() == signature_verification_error_category())
                    throw signature_verification_exception(ec);
                if (ec.category() == signature_generation_error_category()) throw signature_generation_exception(ec);
                if (ec.category() == token_verification_error_category()) throw token_verification_exception(ec);
            }
        }
    } // namespace error
} // namespace jwt
 
namespace std {
    template<>
    struct is_error_code_enum<jwt::error::rsa_error> : true_type {};
    template<>
    struct is_error_code_enum<jwt::error::ecdsa_error> : true_type {};
    template<>
    struct is_error_code_enum<jwt::error::signature_verification_error> : true_type {};
    template<>
    struct is_error_code_enum<jwt::error::signature_generation_error> : true_type {};
    template<>
    struct is_error_code_enum<jwt::error::token_verification_error> : true_type {};
} // namespace std
 
namespace jwt {
    namespace helper {
        class evp_pkey_handle {
        public:
            constexpr evp_pkey_handle() noexcept = default;
#ifdef JWT_OPENSSL_1_0_0
 
            explicit evp_pkey_handle(EVP_PKEY* key) { m_key = std::shared_ptr<EVP_PKEY>(key, EVP_PKEY_free); }
 
            EVP_PKEY* get() const noexcept { return m_key.get(); }
            bool operator!() const noexcept { return m_key == nullptr; }
            explicit operator bool() const noexcept { return m_key != nullptr; }
 
        private:
            std::shared_ptr<EVP_PKEY> m_key{nullptr};
#else
 
            explicit constexpr evp_pkey_handle(EVP_PKEY* key) noexcept : m_key{key} {}
            evp_pkey_handle(const evp_pkey_handle& other) : m_key{other.m_key} {
                if (m_key != nullptr && EVP_PKEY_up_ref(m_key) != 1) throw std::runtime_error("EVP_PKEY_up_ref failed");
            }
// C++11 requires the body of a constexpr constructor to be empty
#if __cplusplus >= 201402L
            constexpr
#endif
                evp_pkey_handle(evp_pkey_handle&& other) noexcept
                : m_key{other.m_key} {
                other.m_key = nullptr;
            }
            evp_pkey_handle& operator=(const evp_pkey_handle& other) {
                if (&other == this) return *this;
                decrement_ref_count(m_key);
                m_key = other.m_key;
                increment_ref_count(m_key);
                return *this;
            }
            evp_pkey_handle& operator=(evp_pkey_handle&& other) noexcept {
                if (&other == this) return *this;
                decrement_ref_count(m_key);
                m_key = other.m_key;
                other.m_key = nullptr;
                return *this;
            }
            evp_pkey_handle& operator=(EVP_PKEY* key) {
                decrement_ref_count(m_key);
                m_key = key;
                increment_ref_count(m_key);
                return *this;
            }
            ~evp_pkey_handle() noexcept { decrement_ref_count(m_key); }
 
            EVP_PKEY* get() const noexcept { return m_key; }
            bool operator!() const noexcept { return m_key == nullptr; }
            explicit operator bool() const noexcept { return m_key != nullptr; }
 
        private:
            EVP_PKEY* m_key{nullptr};
 
            static void increment_ref_count(EVP_PKEY* key) {
                if (key != nullptr && EVP_PKEY_up_ref(key) != 1) throw std::runtime_error("EVP_PKEY_up_ref failed");
            }
            static void decrement_ref_count(EVP_PKEY* key) noexcept {
                if (key != nullptr) EVP_PKEY_free(key);
            }
#endif
        };
 
        inline std::unique_ptr<BIO, decltype(&BIO_free_all)> make_mem_buf_bio() {
            return std::unique_ptr<BIO, decltype(&BIO_free_all)>(BIO_new(BIO_s_mem()), BIO_free_all);
        }
 
        inline std::unique_ptr<BIO, decltype(&BIO_free_all)> make_mem_buf_bio(const std::string& data) {
            return std::unique_ptr<BIO, decltype(&BIO_free_all)>(
#if OPENSSL_VERSION_NUMBER <= 0x10100003L
                BIO_new_mem_buf(const_cast<char*>(data.data()), static_cast<int>(data.size())), BIO_free_all
#else
                BIO_new_mem_buf(data.data(), static_cast<int>(data.size())), BIO_free_all
#endif
            );
        }
 
        inline std::unique_ptr<EVP_MD_CTX, void (*)(EVP_MD_CTX*)> make_evp_md_ctx() {
            return
#ifdef JWT_OPENSSL_1_0_0
                std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_destroy)>(EVP_MD_CTX_create(), &EVP_MD_CTX_destroy);
#else
                std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)>(EVP_MD_CTX_new(), &EVP_MD_CTX_free);
#endif
        }
 
        inline std::string extract_pubkey_from_cert(const std::string& certstr, const std::string& pw,
                                                    std::error_code& ec) {
            ec.clear();
            auto certbio = make_mem_buf_bio(certstr);
            auto keybio = make_mem_buf_bio();
            if (!certbio || !keybio) {
                ec = error::rsa_error::create_mem_bio_failed;
                return {};
            }
 
            std::unique_ptr<X509, decltype(&X509_free)> cert(
                PEM_read_bio_X509(certbio.get(), nullptr, nullptr, const_cast<char*>(pw.c_str())), X509_free);
            if (!cert) {
                ec = error::rsa_error::cert_load_failed;
                return {};
            }
            std::unique_ptr<EVP_PKEY, decltype(&EVP_PKEY_free)> key(X509_get_pubkey(cert.get()), EVP_PKEY_free);
            if (!key) {
                ec = error::rsa_error::get_key_failed;
                return {};
            }
            if (PEM_write_bio_PUBKEY(keybio.get(), key.get()) == 0) {
                ec = error::rsa_error::write_key_failed;
                return {};
            }
            char* ptr = nullptr;
            auto len = BIO_get_mem_data(keybio.get(), &ptr);
            if (len <= 0 || ptr == nullptr) {
                ec = error::rsa_error::convert_to_pem_failed;
                return {};
            }
            return {ptr, static_cast<size_t>(len)};
        }
 
        inline std::string extract_pubkey_from_cert(const std::string& certstr, const std::string& pw = "") {
            std::error_code ec;
            auto res = extract_pubkey_from_cert(certstr, pw, ec);
            error::throw_if_error(ec);
            return res;
        }
 
        template<typename Decode>
        std::string convert_base64_der_to_pem(const std::string& cert_base64_der_str, Decode decode,
                                              std::error_code& ec) {
            ec.clear();
            const auto decodedStr = decode(cert_base64_der_str);
            auto c_str = reinterpret_cast<const unsigned char*>(decodedStr.c_str());
 
            std::unique_ptr<X509, decltype(&X509_free)> cert(
                d2i_X509(NULL, &c_str, static_cast<int>(decodedStr.size())), X509_free);
            auto certbio = make_mem_buf_bio();
            if (!cert || !certbio) {
                ec = error::rsa_error::create_mem_bio_failed;
                return {};
            }
 
            if (!PEM_write_bio_X509(certbio.get(), cert.get())) {
                ec = error::rsa_error::write_cert_failed;
                return {};
            }
 
            char* ptr = nullptr;
            const auto len = BIO_get_mem_data(certbio.get(), &ptr);
            if (len <= 0 || ptr == nullptr) {
                ec = error::rsa_error::convert_to_pem_failed;
                return {};
            }
 
            return {ptr, static_cast<size_t>(len)};
        }
 
        template<typename Decode>
        std::string convert_base64_der_to_pem(const std::string& cert_base64_der_str, Decode decode) {
            std::error_code ec;
            auto res = convert_base64_der_to_pem(cert_base64_der_str, std::move(decode), ec);
            error::throw_if_error(ec);
            return res;
        }
#ifndef JWT_DISABLE_BASE64
 
        inline std::string convert_base64_der_to_pem(const std::string& cert_base64_der_str, std::error_code& ec) {
            auto decode = [](const std::string& token) {
                return base::decode<alphabet::base64>(base::pad<alphabet::base64>(token));
            };
            return convert_base64_der_to_pem(cert_base64_der_str, std::move(decode), ec);
        }
 
        inline std::string convert_base64_der_to_pem(const std::string& cert_base64_der_str) {
            std::error_code ec;
            auto res = convert_base64_der_to_pem(cert_base64_der_str, ec);
            error::throw_if_error(ec);
            return res;
        }
#endif
 
        inline evp_pkey_handle load_public_key_from_string(const std::string& key, const std::string& password,
                                                           std::error_code& ec) {
            ec.clear();
            auto pubkey_bio = make_mem_buf_bio();
            if (!pubkey_bio) {
                ec = error::rsa_error::create_mem_bio_failed;
                return {};
            }
            if (key.substr(0, 27) == "-----BEGIN CERTIFICATE-----") {
                auto epkey = helper::extract_pubkey_from_cert(key, password, ec);
                if (ec) return {};
                const int len = static_cast<int>(epkey.size());
                if (BIO_write(pubkey_bio.get(), epkey.data(), len) != len) {
                    ec = error::rsa_error::load_key_bio_write;
                    return {};
                }
            } else {
                const int len = static_cast<int>(key.size());
                if (BIO_write(pubkey_bio.get(), key.data(), len) != len) {
                    ec = error::rsa_error::load_key_bio_write;
                    return {};
                }
            }
 
            evp_pkey_handle pkey(PEM_read_bio_PUBKEY(
                pubkey_bio.get(), nullptr, nullptr,
                (void*)password.data())); // NOLINT(google-readability-casting) requires `const_cast`
            if (!pkey) ec = error::rsa_error::load_key_bio_read;
            return pkey;
        }
 
        inline evp_pkey_handle load_public_key_from_string(const std::string& key, const std::string& password = "") {
            std::error_code ec;
            auto res = load_public_key_from_string(key, password, ec);
            error::throw_if_error(ec);
            return res;
        }
 
        inline evp_pkey_handle load_private_key_from_string(const std::string& key, const std::string& password,
                                                            std::error_code& ec) {
            auto privkey_bio = make_mem_buf_bio();
            if (!privkey_bio) {
                ec = error::rsa_error::create_mem_bio_failed;
                return {};
            }
            const int len = static_cast<int>(key.size());
            if (BIO_write(privkey_bio.get(), key.data(), len) != len) {
                ec = error::rsa_error::load_key_bio_write;
                return {};
            }
            evp_pkey_handle pkey(
                PEM_read_bio_PrivateKey(privkey_bio.get(), nullptr, nullptr, const_cast<char*>(password.c_str())));
            if (!pkey) ec = error::rsa_error::load_key_bio_read;
            return pkey;
        }
 
        inline evp_pkey_handle load_private_key_from_string(const std::string& key, const std::string& password = "") {
            std::error_code ec;
            auto res = load_private_key_from_string(key, password, ec);
            error::throw_if_error(ec);
            return res;
        }
 
        inline evp_pkey_handle load_public_ec_key_from_string(const std::string& key, const std::string& password,
                                                              std::error_code& ec) {
            ec.clear();
            auto pubkey_bio = make_mem_buf_bio();
            if (!pubkey_bio) {
                ec = error::ecdsa_error::create_mem_bio_failed;
                return {};
            }
            if (key.substr(0, 27) == "-----BEGIN CERTIFICATE-----") {
                auto epkey = helper::extract_pubkey_from_cert(key, password, ec);
                if (ec) return {};
                const int len = static_cast<int>(epkey.size());
                if (BIO_write(pubkey_bio.get(), epkey.data(), len) != len) {
                    ec = error::ecdsa_error::load_key_bio_write;
                    return {};
                }
            } else {
                const int len = static_cast<int>(key.size());
                if (BIO_write(pubkey_bio.get(), key.data(), len) != len) {
                    ec = error::ecdsa_error::load_key_bio_write;
                    return {};
                }
            }
 
            evp_pkey_handle pkey(PEM_read_bio_PUBKEY(
                pubkey_bio.get(), nullptr, nullptr,
                (void*)password.data())); // NOLINT(google-readability-casting) requires `const_cast`
            if (!pkey) ec = error::ecdsa_error::load_key_bio_read;
            return pkey;
        }
 
        inline evp_pkey_handle load_public_ec_key_from_string(const std::string& key,
                                                              const std::string& password = "") {
            std::error_code ec;
            auto res = load_public_ec_key_from_string(key, password, ec);
            error::throw_if_error(ec);
            return res;
        }
 
        inline evp_pkey_handle load_private_ec_key_from_string(const std::string& key, const std::string& password,
                                                               std::error_code& ec) {
            auto privkey_bio = make_mem_buf_bio();
            if (!privkey_bio) {
                ec = error::ecdsa_error::create_mem_bio_failed;
                return {};
            }
            const int len = static_cast<int>(key.size());
            if (BIO_write(privkey_bio.get(), key.data(), len) != len) {
                ec = error::ecdsa_error::load_key_bio_write;
                return {};
            }
            evp_pkey_handle pkey(
                PEM_read_bio_PrivateKey(privkey_bio.get(), nullptr, nullptr, const_cast<char*>(password.c_str())));
            if (!pkey) ec = error::ecdsa_error::load_key_bio_read;
            return pkey;
        }
 
        inline evp_pkey_handle load_private_ec_key_from_string(const std::string& key,
                                                               const std::string& password = "") {
            std::error_code ec;
            auto res = load_private_ec_key_from_string(key, password, ec);
            error::throw_if_error(ec);
            return res;
        }
 
        inline
#ifdef JWT_OPENSSL_1_0_0
            std::string
            bn2raw(BIGNUM* bn)
#else
            std::string
            bn2raw(const BIGNUM* bn)
#endif
        {
            std::string res(BN_num_bytes(bn), '\0');
            BN_bn2bin(bn, (unsigned char*)res.data()); // NOLINT(google-readability-casting) requires `const_cast`
            return res;
        }
        inline std::unique_ptr<BIGNUM, decltype(&BN_free)> raw2bn(const std::string& raw) {
            return std::unique_ptr<BIGNUM, decltype(&BN_free)>(
                BN_bin2bn(reinterpret_cast<const unsigned char*>(raw.data()), static_cast<int>(raw.size()), nullptr),
                BN_free);
        }
    } // namespace helper
 
    namespace algorithm {
        struct none {
            std::string sign(const std::string& /*unused*/, std::error_code& ec) const {
                ec.clear();
                return {};
            }
            void verify(const std::string& /*unused*/, const std::string& signature, std::error_code& ec) const {
                ec.clear();
                if (!signature.empty()) { ec = error::signature_verification_error::invalid_signature; }
            }
            std::string name() const { return "none"; }
        };
        struct hmacsha {
            hmacsha(std::string key, const EVP_MD* (*md)(), std::string name)
                : secret(std::move(key)), md(md), alg_name(std::move(name)) {}
            std::string sign(const std::string& data, std::error_code& ec) const {
                ec.clear();
                std::string res(static_cast<size_t>(EVP_MAX_MD_SIZE), '\0');
                auto len = static_cast<unsigned int>(res.size());
                if (HMAC(md(), secret.data(), static_cast<int>(secret.size()),
                         reinterpret_cast<const unsigned char*>(data.data()), static_cast<int>(data.size()),
                         (unsigned char*)res.data(), // NOLINT(google-readability-casting) requires `const_cast`
                         &len) == nullptr) {
                    ec = error::signature_generation_error::hmac_failed;
                    return {};
                }
                res.resize(len);
                return res;
            }
            void verify(const std::string& data, const std::string& signature, std::error_code& ec) const {
                ec.clear();
                auto res = sign(data, ec);
                if (ec) return;
 
                bool matched = true;
                for (size_t i = 0; i < std::min<size_t>(res.size(), signature.size()); i++)
                    if (res[i] != signature[i]) matched = false;
                if (res.size() != signature.size()) matched = false;
                if (!matched) {
                    ec = error::signature_verification_error::invalid_signature;
                    return;
                }
            }
            std::string name() const { return alg_name; }
 
        private:
            const std::string secret;
            const EVP_MD* (*md)();
            const std::string alg_name;
        };
        struct rsa {
            rsa(const std::string& public_key, const std::string& private_key, const std::string& public_key_password,
                const std::string& private_key_password, const EVP_MD* (*md)(), std::string name)
                : md(md), alg_name(std::move(name)) {
                if (!private_key.empty()) {
                    pkey = helper::load_private_key_from_string(private_key, private_key_password);
                } else if (!public_key.empty()) {
                    pkey = helper::load_public_key_from_string(public_key, public_key_password);
                } else
                    throw error::rsa_exception(error::rsa_error::no_key_provided);
            }
            std::string sign(const std::string& data, std::error_code& ec) const {
                ec.clear();
                auto ctx = helper::make_evp_md_ctx();
                if (!ctx) {
                    ec = error::signature_generation_error::create_context_failed;
                    return {};
                }
                if (!EVP_SignInit(ctx.get(), md())) {
                    ec = error::signature_generation_error::signinit_failed;
                    return {};
                }
 
                std::string res(EVP_PKEY_size(pkey.get()), '\0');
                unsigned int len = 0;
 
                if (!EVP_SignUpdate(ctx.get(), data.data(), data.size())) {
                    ec = error::signature_generation_error::signupdate_failed;
                    return {};
                }
                if (EVP_SignFinal(ctx.get(), (unsigned char*)res.data(), &len, pkey.get()) == 0) {
                    ec = error::signature_generation_error::signfinal_failed;
                    return {};
                }
 
                res.resize(len);
                return res;
            }
            void verify(const std::string& data, const std::string& signature, std::error_code& ec) const {
                ec.clear();
                auto ctx = helper::make_evp_md_ctx();
                if (!ctx) {
                    ec = error::signature_verification_error::create_context_failed;
                    return;
                }
                if (!EVP_VerifyInit(ctx.get(), md())) {
                    ec = error::signature_verification_error::verifyinit_failed;
                    return;
                }
                if (!EVP_VerifyUpdate(ctx.get(), data.data(), data.size())) {
                    ec = error::signature_verification_error::verifyupdate_failed;
                    return;
                }
                auto res = EVP_VerifyFinal(ctx.get(), reinterpret_cast<const unsigned char*>(signature.data()),
                                           static_cast<unsigned int>(signature.size()), pkey.get());
                if (res != 1) {
                    ec = error::signature_verification_error::verifyfinal_failed;
                    return;
                }
            }
            std::string name() const { return alg_name; }
 
        private:
            helper::evp_pkey_handle pkey;
            const EVP_MD* (*md)();
            const std::string alg_name;
        };
        struct ecdsa {
            ecdsa(const std::string& public_key, const std::string& private_key, const std::string& public_key_password,
                  const std::string& private_key_password, const EVP_MD* (*md)(), std::string name, size_t siglen)
                : md(md), alg_name(std::move(name)), signature_length(siglen) {
                if (!private_key.empty()) {
                    pkey = helper::load_private_ec_key_from_string(private_key, private_key_password);
                    check_private_key(pkey.get());
                } else if (!public_key.empty()) {
                    pkey = helper::load_public_ec_key_from_string(public_key, public_key_password);
                    check_public_key(pkey.get());
                } else {
                    throw error::ecdsa_exception(error::ecdsa_error::no_key_provided);
                }
                if (!pkey) throw error::ecdsa_exception(error::ecdsa_error::invalid_key);
 
                size_t keysize = EVP_PKEY_bits(pkey.get());
                if (keysize != signature_length * 4 && (signature_length != 132 || keysize != 521))
                    throw error::ecdsa_exception(error::ecdsa_error::invalid_key_size);
            }
 
            std::string sign(const std::string& data, std::error_code& ec) const {
                ec.clear();
                auto ctx = helper::make_evp_md_ctx();
                if (!ctx) {
                    ec = error::signature_generation_error::create_context_failed;
                    return {};
                }
                if (!EVP_DigestSignInit(ctx.get(), nullptr, md(), nullptr, pkey.get())) {
                    ec = error::signature_generation_error::signinit_failed;
                    return {};
                }
                if (!EVP_DigestUpdate(ctx.get(), data.data(), data.size())) {
                    ec = error::signature_generation_error::digestupdate_failed;
                    return {};
                }
 
                size_t len = 0;
                if (!EVP_DigestSignFinal(ctx.get(), nullptr, &len)) {
                    ec = error::signature_generation_error::signfinal_failed;
                    return {};
                }
                std::string res(len, '\0');
                if (!EVP_DigestSignFinal(ctx.get(), (unsigned char*)res.data(), &len)) {
                    ec = error::signature_generation_error::signfinal_failed;
                    return {};
                }
 
                res.resize(len);
                return der_to_p1363_signature(res, ec);
            }
 
            void verify(const std::string& data, const std::string& signature, std::error_code& ec) const {
                ec.clear();
                std::string der_signature = p1363_to_der_signature(signature, ec);
                if (ec) { return; }
 
                auto ctx = helper::make_evp_md_ctx();
                if (!ctx) {
                    ec = error::signature_verification_error::create_context_failed;
                    return;
                }
                if (!EVP_DigestVerifyInit(ctx.get(), nullptr, md(), nullptr, pkey.get())) {
                    ec = error::signature_verification_error::verifyinit_failed;
                    return;
                }
                if (!EVP_DigestUpdate(ctx.get(), data.data(), data.size())) {
                    ec = error::signature_verification_error::verifyupdate_failed;
                    return;
                }
 
#if OPENSSL_VERSION_NUMBER < 0x10002000L
                unsigned char* der_sig_data = reinterpret_cast<unsigned char*>(const_cast<char*>(der_signature.data()));
#else
                const unsigned char* der_sig_data = reinterpret_cast<const unsigned char*>(der_signature.data());
#endif
                auto res =
                    EVP_DigestVerifyFinal(ctx.get(), der_sig_data, static_cast<unsigned int>(der_signature.length()));
                if (res == 0) {
                    ec = error::signature_verification_error::invalid_signature;
                    return;
                }
                if (res == -1) {
                    ec = error::signature_verification_error::verifyfinal_failed;
                    return;
                }
            }
            std::string name() const { return alg_name; }
 
        private:
            static void check_public_key(EVP_PKEY* pkey) {
#ifdef JWT_OPENSSL_3_0
                std::unique_ptr<EVP_PKEY_CTX, decltype(&EVP_PKEY_CTX_free)> ctx(
                    EVP_PKEY_CTX_new_from_pkey(nullptr, pkey, nullptr), EVP_PKEY_CTX_free);
                if (!ctx) { throw error::ecdsa_exception(error::ecdsa_error::create_context_failed); }
                if (EVP_PKEY_public_check(ctx.get()) != 1) {
                    throw error::ecdsa_exception(error::ecdsa_error::invalid_key);
                }
#else
                std::unique_ptr<EC_KEY, decltype(&EC_KEY_free)> eckey(EVP_PKEY_get1_EC_KEY(pkey), EC_KEY_free);
                if (!eckey) { throw error::ecdsa_exception(error::ecdsa_error::invalid_key); }
                if (EC_KEY_check_key(eckey.get()) == 0) throw error::ecdsa_exception(error::ecdsa_error::invalid_key);
#endif
            }
 
            static void check_private_key(EVP_PKEY* pkey) {
#ifdef JWT_OPENSSL_3_0
                std::unique_ptr<EVP_PKEY_CTX, decltype(&EVP_PKEY_CTX_free)> ctx(
                    EVP_PKEY_CTX_new_from_pkey(nullptr, pkey, nullptr), EVP_PKEY_CTX_free);
                if (!ctx) { throw error::ecdsa_exception(error::ecdsa_error::create_context_failed); }
                if (EVP_PKEY_private_check(ctx.get()) != 1) {
                    throw error::ecdsa_exception(error::ecdsa_error::invalid_key);
                }
#else
                std::unique_ptr<EC_KEY, decltype(&EC_KEY_free)> eckey(EVP_PKEY_get1_EC_KEY(pkey), EC_KEY_free);
                if (!eckey) { throw error::ecdsa_exception(error::ecdsa_error::invalid_key); }
                if (EC_KEY_check_key(eckey.get()) == 0) throw error::ecdsa_exception(error::ecdsa_error::invalid_key);
#endif
            }
 
            std::string der_to_p1363_signature(const std::string& der_signature, std::error_code& ec) const {
                const unsigned char* possl_signature = reinterpret_cast<const unsigned char*>(der_signature.data());
                std::unique_ptr<ECDSA_SIG, decltype(&ECDSA_SIG_free)> sig(
                    d2i_ECDSA_SIG(nullptr, &possl_signature, der_signature.length()), ECDSA_SIG_free);
                if (!sig) {
                    ec = error::signature_generation_error::signature_decoding_failed;
                    return {};
                }
 
#ifdef JWT_OPENSSL_1_0_0
 
                auto rr = helper::bn2raw(sig->r);
                auto rs = helper::bn2raw(sig->s);
#else
                const BIGNUM* r;
                const BIGNUM* s;
                ECDSA_SIG_get0(sig.get(), &r, &s);
                auto rr = helper::bn2raw(r);
                auto rs = helper::bn2raw(s);
#endif
                if (rr.size() > signature_length / 2 || rs.size() > signature_length / 2)
                    throw std::logic_error("bignum size exceeded expected length");
                rr.insert(0, signature_length / 2 - rr.size(), '\0');
                rs.insert(0, signature_length / 2 - rs.size(), '\0');
                return rr + rs;
            }
 
            std::string p1363_to_der_signature(const std::string& signature, std::error_code& ec) const {
                ec.clear();
                auto r = helper::raw2bn(signature.substr(0, signature.size() / 2));
                auto s = helper::raw2bn(signature.substr(signature.size() / 2));
 
                ECDSA_SIG* psig;
#ifdef JWT_OPENSSL_1_0_0
                ECDSA_SIG sig;
                sig.r = r.get();
                sig.s = s.get();
                psig = &sig;
#else
                std::unique_ptr<ECDSA_SIG, decltype(&ECDSA_SIG_free)> sig(ECDSA_SIG_new(), ECDSA_SIG_free);
                if (!sig) {
                    ec = error::signature_verification_error::create_context_failed;
                    return {};
                }
                ECDSA_SIG_set0(sig.get(), r.release(), s.release());
                psig = sig.get();
#endif
 
                int length = i2d_ECDSA_SIG(psig, nullptr);
                if (length < 0) {
                    ec = error::signature_verification_error::signature_encoding_failed;
                    return {};
                }
                std::string der_signature(length, '\0');
                unsigned char* psbuffer = (unsigned char*)der_signature.data();
                length = i2d_ECDSA_SIG(psig, &psbuffer);
                if (length < 0) {
                    ec = error::signature_verification_error::signature_encoding_failed;
                    return {};
                }
                der_signature.resize(length);
                return der_signature;
            }
 
            helper::evp_pkey_handle pkey;
            const EVP_MD* (*md)();
            const std::string alg_name;
            const size_t signature_length;
        };
 
#if !defined(JWT_OPENSSL_1_0_0) && !defined(JWT_OPENSSL_1_1_0)
 
        struct eddsa {
            eddsa(const std::string& public_key, const std::string& private_key, const std::string& public_key_password,
                  const std::string& private_key_password, std::string name)
                : alg_name(std::move(name)) {
                if (!private_key.empty()) {
                    pkey = helper::load_private_key_from_string(private_key, private_key_password);
                } else if (!public_key.empty()) {
                    pkey = helper::load_public_key_from_string(public_key, public_key_password);
                } else
                    throw error::ecdsa_exception(error::ecdsa_error::load_key_bio_read);
            }
            std::string sign(const std::string& data, std::error_code& ec) const {
                ec.clear();
                auto ctx = helper::make_evp_md_ctx();
                if (!ctx) {
                    ec = error::signature_generation_error::create_context_failed;
                    return {};
                }
                if (!EVP_DigestSignInit(ctx.get(), nullptr, nullptr, nullptr, pkey.get())) {
                    ec = error::signature_generation_error::signinit_failed;
                    return {};
                }
 
                size_t len = EVP_PKEY_size(pkey.get());
                std::string res(len, '\0');
 
// LibreSSL is the special kid in the block, as it does not support EVP_DigestSign.
// OpenSSL on the otherhand does not support using EVP_DigestSignUpdate for eddsa, which is why we end up with this
// mess.
#if defined(LIBRESSL_VERSION_NUMBER) || defined(LIBWOLFSSL_VERSION_HEX)
                ERR_clear_error();
                if (EVP_DigestSignUpdate(ctx.get(), reinterpret_cast<const unsigned char*>(data.data()), data.size()) !=
                    1) {
                    std::cout << ERR_error_string(ERR_get_error(), NULL) << std::endl;
                    ec = error::signature_generation_error::signupdate_failed;
                    return {};
                }
                if (EVP_DigestSignFinal(ctx.get(), reinterpret_cast<unsigned char*>(&res[0]), &len) != 1) {
                    ec = error::signature_generation_error::signfinal_failed;
                    return {};
                }
#else
                if (EVP_DigestSign(ctx.get(), reinterpret_cast<unsigned char*>(&res[0]), &len,
                                   reinterpret_cast<const unsigned char*>(data.data()), data.size()) != 1) {
                    ec = error::signature_generation_error::signfinal_failed;
                    return {};
                }
#endif
 
                res.resize(len);
                return res;
            }
 
            void verify(const std::string& data, const std::string& signature, std::error_code& ec) const {
                ec.clear();
                auto ctx = helper::make_evp_md_ctx();
                if (!ctx) {
                    ec = error::signature_verification_error::create_context_failed;
                    return;
                }
                if (!EVP_DigestVerifyInit(ctx.get(), nullptr, nullptr, nullptr, pkey.get())) {
                    ec = error::signature_verification_error::verifyinit_failed;
                    return;
                }
// LibreSSL is the special kid in the block, as it does not support EVP_DigestVerify.
// OpenSSL on the otherhand does not support using EVP_DigestVerifyUpdate for eddsa, which is why we end up with this
// mess.
#if defined(LIBRESSL_VERSION_NUMBER) || defined(LIBWOLFSSL_VERSION_HEX)
                if (EVP_DigestVerifyUpdate(ctx.get(), reinterpret_cast<const unsigned char*>(data.data()),
                                           data.size()) != 1) {
                    ec = error::signature_verification_error::verifyupdate_failed;
                    return;
                }
                if (EVP_DigestVerifyFinal(ctx.get(), reinterpret_cast<const unsigned char*>(signature.data()),
                                          signature.size()) != 1) {
                    ec = error::signature_verification_error::verifyfinal_failed;
                    return;
                }
#else
                auto res = EVP_DigestVerify(ctx.get(), reinterpret_cast<const unsigned char*>(signature.data()),
                                            signature.size(), reinterpret_cast<const unsigned char*>(data.data()),
                                            data.size());
                if (res != 1) {
                    ec = error::signature_verification_error::verifyfinal_failed;
                    return;
                }
#endif
            }
            std::string name() const { return alg_name; }
 
        private:
            helper::evp_pkey_handle pkey;
            const std::string alg_name;
        };
#endif
 
        struct pss {
            pss(const std::string& public_key, const std::string& private_key, const std::string& public_key_password,
                const std::string& private_key_password, const EVP_MD* (*md)(), std::string name)
                : md(md), alg_name(std::move(name)) {
                if (!private_key.empty()) {
                    pkey = helper::load_private_key_from_string(private_key, private_key_password);
                } else if (!public_key.empty()) {
                    pkey = helper::load_public_key_from_string(public_key, public_key_password);
                } else
                    throw error::rsa_exception(error::rsa_error::no_key_provided);
            }
 
            std::string sign(const std::string& data, std::error_code& ec) const {
                ec.clear();
                auto md_ctx = helper::make_evp_md_ctx();
                if (!md_ctx) {
                    ec = error::signature_generation_error::create_context_failed;
                    return {};
                }
                EVP_PKEY_CTX* ctx = nullptr;
                if (EVP_DigestSignInit(md_ctx.get(), &ctx, md(), nullptr, pkey.get()) != 1) {
                    ec = error::signature_generation_error::signinit_failed;
                    return {};
                }
                if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PSS_PADDING) <= 0) {
                    ec = error::signature_generation_error::rsa_padding_failed;
                    return {};
                }
// wolfSSL does not require EVP_PKEY_CTX_set_rsa_pss_saltlen. The default behavior
// sets the salt length to the hash length. Unlike OpenSSL which exposes this functionality.
#ifndef LIBWOLFSSL_VERSION_HEX
                if (EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, -1) <= 0) {
                    ec = error::signature_generation_error::set_rsa_pss_saltlen_failed;
                    return {};
                }
#endif
                if (EVP_DigestUpdate(md_ctx.get(), data.data(), data.size()) != 1) {
                    ec = error::signature_generation_error::digestupdate_failed;
                    return {};
                }
 
                size_t size = EVP_PKEY_size(pkey.get());
                std::string res(size, 0x00);
                if (EVP_DigestSignFinal(
                        md_ctx.get(),
                        (unsigned char*)res.data(), // NOLINT(google-readability-casting) requires `const_cast`
                        &size) <= 0) {
                    ec = error::signature_generation_error::signfinal_failed;
                    return {};
                }
 
                return res;
            }
 
            void verify(const std::string& data, const std::string& signature, std::error_code& ec) const {
                ec.clear();
 
                auto md_ctx = helper::make_evp_md_ctx();
                if (!md_ctx) {
                    ec = error::signature_verification_error::create_context_failed;
                    return;
                }
                EVP_PKEY_CTX* ctx = nullptr;
                if (EVP_DigestVerifyInit(md_ctx.get(), &ctx, md(), nullptr, pkey.get()) != 1) {
                    ec = error::signature_verification_error::verifyinit_failed;
                    return;
                }
                if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PSS_PADDING) <= 0) {
                    ec = error::signature_generation_error::rsa_padding_failed;
                    return;
                }
// wolfSSL does not require EVP_PKEY_CTX_set_rsa_pss_saltlen. The default behavior
// sets the salt length to the hash length. Unlike OpenSSL which exposes this functionality.
#ifndef LIBWOLFSSL_VERSION_HEX
                if (EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, -1) <= 0) {
                    ec = error::signature_verification_error::set_rsa_pss_saltlen_failed;
                    return;
                }
#endif
                if (EVP_DigestUpdate(md_ctx.get(), data.data(), data.size()) != 1) {
                    ec = error::signature_verification_error::verifyupdate_failed;
                    return;
                }
 
                if (EVP_DigestVerifyFinal(md_ctx.get(), (unsigned char*)signature.data(), signature.size()) <= 0) {
                    ec = error::signature_verification_error::verifyfinal_failed;
                    return;
                }
            }
            std::string name() const { return alg_name; }
 
        private:
            helper::evp_pkey_handle pkey;
            const EVP_MD* (*md)();
            const std::string alg_name;
        };
 
        struct hs256 : public hmacsha {
            explicit hs256(std::string key) : hmacsha(std::move(key), EVP_sha256, "HS256") {}
        };
        struct hs384 : public hmacsha {
            explicit hs384(std::string key) : hmacsha(std::move(key), EVP_sha384, "HS384") {}
        };
        struct hs512 : public hmacsha {
            explicit hs512(std::string key) : hmacsha(std::move(key), EVP_sha512, "HS512") {}
        };
        struct rs256 : public rsa {
            explicit rs256(const std::string& public_key, const std::string& private_key = "",
                           const std::string& public_key_password = "", const std::string& private_key_password = "")
                : rsa(public_key, private_key, public_key_password, private_key_password, EVP_sha256, "RS256") {}
        };
        struct rs384 : public rsa {
            explicit rs384(const std::string& public_key, const std::string& private_key = "",
                           const std::string& public_key_password = "", const std::string& private_key_password = "")
                : rsa(public_key, private_key, public_key_password, private_key_password, EVP_sha384, "RS384") {}
        };
        struct rs512 : public rsa {
            explicit rs512(const std::string& public_key, const std::string& private_key = "",
                           const std::string& public_key_password = "", const std::string& private_key_password = "")
                : rsa(public_key, private_key, public_key_password, private_key_password, EVP_sha512, "RS512") {}
        };
        struct es256 : public ecdsa {
            explicit es256(const std::string& public_key, const std::string& private_key = "",
                           const std::string& public_key_password = "", const std::string& private_key_password = "")
                : ecdsa(public_key, private_key, public_key_password, private_key_password, EVP_sha256, "ES256", 64) {}
        };
        struct es384 : public ecdsa {
            explicit es384(const std::string& public_key, const std::string& private_key = "",
                           const std::string& public_key_password = "", const std::string& private_key_password = "")
                : ecdsa(public_key, private_key, public_key_password, private_key_password, EVP_sha384, "ES384", 96) {}
        };
        struct es512 : public ecdsa {
            explicit es512(const std::string& public_key, const std::string& private_key = "",
                           const std::string& public_key_password = "", const std::string& private_key_password = "")
                : ecdsa(public_key, private_key, public_key_password, private_key_password, EVP_sha512, "ES512", 132) {}
        };
        struct es256k : public ecdsa {
            explicit es256k(const std::string& public_key, const std::string& private_key = "",
                            const std::string& public_key_password = "", const std::string& private_key_password = "")
                : ecdsa(public_key, private_key, public_key_password, private_key_password, EVP_sha256, "ES256K", 64) {}
        };
 
#if !defined(JWT_OPENSSL_1_0_0) && !defined(JWT_OPENSSL_1_1_0)
 
        struct ed25519 : public eddsa {
            explicit ed25519(const std::string& public_key, const std::string& private_key = "",
                             const std::string& public_key_password = "", const std::string& private_key_password = "")
                : eddsa(public_key, private_key, public_key_password, private_key_password, "EdDSA") {}
        };
 
        struct ed448 : public eddsa {
            explicit ed448(const std::string& public_key, const std::string& private_key = "",
                           const std::string& public_key_password = "", const std::string& private_key_password = "")
                : eddsa(public_key, private_key, public_key_password, private_key_password, "EdDSA") {}
        };
#endif
 
        struct ps256 : public pss {
            explicit ps256(const std::string& public_key, const std::string& private_key = "",
                           const std::string& public_key_password = "", const std::string& private_key_password = "")
                : pss(public_key, private_key, public_key_password, private_key_password, EVP_sha256, "PS256") {}
        };
        struct ps384 : public pss {
            explicit ps384(const std::string& public_key, const std::string& private_key = "",
                           const std::string& public_key_password = "", const std::string& private_key_password = "")
                : pss(public_key, private_key, public_key_password, private_key_password, EVP_sha384, "PS384") {}
        };
        struct ps512 : public pss {
            explicit ps512(const std::string& public_key, const std::string& private_key = "",
                           const std::string& public_key_password = "", const std::string& private_key_password = "")
                : pss(public_key, private_key, public_key_password, private_key_password, EVP_sha512, "PS512") {}
        };
    } // namespace algorithm
 
    namespace json {
        enum class type { boolean, integer, number, string, array, object };
    } // namespace json
 
    namespace details {
#ifdef __cpp_lib_void_t
        template<typename... Ts>
        using void_t = std::void_t<Ts...>;
#else
        // https://en.cppreference.com/w/cpp/types/void_t
        template<typename... Ts>
        struct make_void {
            using type = void;
        };
 
        template<typename... Ts>
        using void_t = typename make_void<Ts...>::type;
#endif
 
#ifdef __cpp_lib_experimental_detect
        template<template<typename...> class _Op, typename... _Args>
        using is_detected = std::experimental::is_detected<_Op, _Args...>;
 
        template<template<typename...> class _Op, typename... _Args>
        using is_detected_t = std::experimental::detected_t<_Op, _Args...>;
#else
        struct nonesuch {
            nonesuch() = delete;
            ~nonesuch() = delete;
            nonesuch(nonesuch const&) = delete;
            nonesuch(nonesuch const&&) = delete;
            void operator=(nonesuch const&) = delete;
            void operator=(nonesuch&&) = delete;
        };
 
        // https://en.cppreference.com/w/cpp/experimental/is_detected
        template<class Default, class AlwaysVoid, template<class...> class Op, class... Args>
        struct detector {
            using value = std::false_type;
            using type = Default;
        };
 
        template<class Default, template<class...> class Op, class... Args>
        struct detector<Default, void_t<Op<Args...>>, Op, Args...> {
            using value = std::true_type;
            using type = Op<Args...>;
        };
 
        template<template<class...> class Op, class... Args>
        using is_detected = typename detector<nonesuch, void, Op, Args...>::value;
 
        template<template<class...> class Op, class... Args>
        using is_detected_t = typename detector<nonesuch, void, Op, Args...>::type;
#endif
 
        template<typename traits_type>
        using get_type_function = decltype(traits_type::get_type);
 
        template<typename traits_type, typename value_type>
        using is_get_type_signature =
            typename std::is_same<get_type_function<traits_type>, json::type(const value_type&)>;
 
        template<typename traits_type, typename value_type>
        struct supports_get_type {
            static constexpr auto value = is_detected<get_type_function, traits_type>::value &&
                                          std::is_function<get_type_function<traits_type>>::value &&
                                          is_get_type_signature<traits_type, value_type>::value;
        };
 
        template<typename traits_type>
        using as_object_function = decltype(traits_type::as_object);
 
        template<typename traits_type, typename value_type, typename object_type>
        using is_as_object_signature =
            typename std::is_same<as_object_function<traits_type>, object_type(const value_type&)>;
 
        template<typename traits_type, typename value_type, typename object_type>
        struct supports_as_object {
            static constexpr auto value = std::is_constructible<value_type, object_type>::value &&
                                          is_detected<as_object_function, traits_type>::value &&
                                          std::is_function<as_object_function<traits_type>>::value &&
                                          is_as_object_signature<traits_type, value_type, object_type>::value;
        };
 
        template<typename traits_type>
        using as_array_function = decltype(traits_type::as_array);
 
        template<typename traits_type, typename value_type, typename array_type>
        using is_as_array_signature =
            typename std::is_same<as_array_function<traits_type>, array_type(const value_type&)>;
 
        template<typename traits_type, typename value_type, typename array_type>
        struct supports_as_array {
            static constexpr auto value = std::is_constructible<value_type, array_type>::value &&
                                          is_detected<as_array_function, traits_type>::value &&
                                          std::is_function<as_array_function<traits_type>>::value &&
                                          is_as_array_signature<traits_type, value_type, array_type>::value;
        };
 
        template<typename traits_type>
        using as_string_function = decltype(traits_type::as_string);
 
        template<typename traits_type, typename value_type, typename string_type>
        using is_as_string_signature =
            typename std::is_same<as_string_function<traits_type>, string_type(const value_type&)>;
 
        template<typename traits_type, typename value_type, typename string_type>
        struct supports_as_string {
            static constexpr auto value = std::is_constructible<value_type, string_type>::value &&
                                          is_detected<as_string_function, traits_type>::value &&
                                          std::is_function<as_string_function<traits_type>>::value &&
                                          is_as_string_signature<traits_type, value_type, string_type>::value;
        };
 
        template<typename traits_type>
        using as_number_function = decltype(traits_type::as_number);
 
        template<typename traits_type, typename value_type, typename number_type>
        using is_as_number_signature =
            typename std::is_same<as_number_function<traits_type>, number_type(const value_type&)>;
 
        template<typename traits_type, typename value_type, typename number_type>
        struct supports_as_number {
            static constexpr auto value = std::is_floating_point<number_type>::value &&
                                          std::is_constructible<value_type, number_type>::value &&
                                          is_detected<as_number_function, traits_type>::value &&
                                          std::is_function<as_number_function<traits_type>>::value &&
                                          is_as_number_signature<traits_type, value_type, number_type>::value;
        };
 
        template<typename traits_type>
        using as_integer_function = decltype(traits_type::as_int);
 
        template<typename traits_type, typename value_type, typename integer_type>
        using is_as_integer_signature =
            typename std::is_same<as_integer_function<traits_type>, integer_type(const value_type&)>;
 
        template<typename traits_type, typename value_type, typename integer_type>
        struct supports_as_integer {
            static constexpr auto value = std::is_signed<integer_type>::value &&
                                          !std::is_floating_point<integer_type>::value &&
                                          std::is_constructible<value_type, integer_type>::value &&
                                          is_detected<as_integer_function, traits_type>::value &&
                                          std::is_function<as_integer_function<traits_type>>::value &&
                                          is_as_integer_signature<traits_type, value_type, integer_type>::value;
        };
 
        template<typename traits_type>
        using as_boolean_function = decltype(traits_type::as_bool);
 
        template<typename traits_type, typename value_type, typename boolean_type>
        using is_as_boolean_signature =
            typename std::is_same<as_boolean_function<traits_type>, boolean_type(const value_type&)>;
 
        template<typename traits_type, typename value_type, typename boolean_type>
        struct supports_as_boolean {
            static constexpr auto value = std::is_convertible<boolean_type, bool>::value &&
                                          std::is_constructible<value_type, boolean_type>::value &&
                                          is_detected<as_boolean_function, traits_type>::value &&
                                          std::is_function<as_boolean_function<traits_type>>::value &&
                                          is_as_boolean_signature<traits_type, value_type, boolean_type>::value;
        };
 
        template<typename traits>
        struct is_valid_traits {
            // Internal assertions for better feedback
            static_assert(supports_get_type<traits, typename traits::value_type>::value,
                          "traits must provide `jwt::json::type get_type(const value_type&)`");
            static_assert(supports_as_object<traits, typename traits::value_type, typename traits::object_type>::value,
                          "traits must provide `object_type as_object(const value_type&)`");
            static_assert(supports_as_array<traits, typename traits::value_type, typename traits::array_type>::value,
                          "traits must provide `array_type as_array(const value_type&)`");
            static_assert(supports_as_string<traits, typename traits::value_type, typename traits::string_type>::value,
                          "traits must provide `string_type as_string(const value_type&)`");
            static_assert(supports_as_number<traits, typename traits::value_type, typename traits::number_type>::value,
                          "traits must provide `number_type as_number(const value_type&)`");
            static_assert(
                supports_as_integer<traits, typename traits::value_type, typename traits::integer_type>::value,
                "traits must provide `integer_type as_int(const value_type&)`");
            static_assert(
                supports_as_boolean<traits, typename traits::value_type, typename traits::boolean_type>::value,
                "traits must provide `boolean_type as_bool(const value_type&)`");
 
            static constexpr auto value =
                supports_get_type<traits, typename traits::value_type>::value &&
                supports_as_object<traits, typename traits::value_type, typename traits::object_type>::value &&
                supports_as_array<traits, typename traits::value_type, typename traits::array_type>::value &&
                supports_as_string<traits, typename traits::value_type, typename traits::string_type>::value &&
                supports_as_number<traits, typename traits::value_type, typename traits::number_type>::value &&
                supports_as_integer<traits, typename traits::value_type, typename traits::integer_type>::value &&
                supports_as_boolean<traits, typename traits::value_type, typename traits::boolean_type>::value;
        };
 
        template<typename value_type>
        struct is_valid_json_value {
            static constexpr auto value =
                std::is_default_constructible<value_type>::value &&
                std::is_constructible<value_type, const value_type&>::value && // a more generic is_copy_constructible
                std::is_move_constructible<value_type>::value && std::is_assignable<value_type, value_type>::value &&
                std::is_copy_assignable<value_type>::value && std::is_move_assignable<value_type>::value;
            // TODO(prince-chrismc): Stream operators
        };
 
        template<typename traits_type>
        using has_mapped_type = typename traits_type::mapped_type;
 
        template<typename traits_type>
        using has_key_type = typename traits_type::key_type;
 
        template<typename traits_type>
        using has_value_type = typename traits_type::value_type;
 
        template<typename object_type>
        using has_iterator = typename object_type::iterator;
 
        template<typename object_type>
        using has_const_iterator = typename object_type::const_iterator;
 
        template<typename object_type>
        using is_begin_signature =
            typename std::is_same<decltype(std::declval<object_type>().begin()), has_iterator<object_type>>;
 
        template<typename object_type>
        using is_begin_const_signature =
            typename std::is_same<decltype(std::declval<const object_type>().begin()), has_const_iterator<object_type>>;
 
        template<typename object_type>
        struct supports_begin {
            static constexpr auto value =
                is_detected<has_iterator, object_type>::value && is_detected<has_const_iterator, object_type>::value &&
                is_begin_signature<object_type>::value && is_begin_const_signature<object_type>::value;
        };
 
        template<typename object_type>
        using is_end_signature =
            typename std::is_same<decltype(std::declval<object_type>().end()), has_iterator<object_type>>;
 
        template<typename object_type>
        using is_end_const_signature =
            typename std::is_same<decltype(std::declval<const object_type>().end()), has_const_iterator<object_type>>;
 
        template<typename object_type>
        struct supports_end {
            static constexpr auto value =
                is_detected<has_iterator, object_type>::value && is_detected<has_const_iterator, object_type>::value &&
                is_end_signature<object_type>::value && is_end_const_signature<object_type>::value;
        };
 
        template<typename object_type, typename string_type>
        using is_count_signature = typename std::is_integral<decltype(std::declval<const object_type>().count(
            std::declval<const string_type>()))>;
 
        template<typename object_type, typename string_type>
        struct has_subcription_operator {
            template<class>
            struct sfinae_true : std::true_type {};
 
            template<class T, class A0>
            static auto test_operator_plus(int)
                -> sfinae_true<decltype(std::declval<T>().operator[](std::declval<A0>()))>;
            template<class, class A0>
            static auto test_operator_plus(long) -> std::false_type;
 
            static constexpr auto value = decltype(test_operator_plus<object_type, string_type>(0)){};
        };
 
        template<typename object_type, typename value_type, typename string_type>
        struct is_subcription_operator_signature {
            static constexpr auto has_subscription_operator = has_subcription_operator<object_type, string_type>::value;
            static_assert(has_subscription_operator,
                          "object_type must implementate the subscription operator '[]' for this library");
 
            static constexpr auto value = has_subscription_operator;
        };
 
        template<typename object_type, typename value_type, typename string_type>
        using is_at_const_signature =
            typename std::is_same<decltype(std::declval<const object_type>().at(std::declval<const string_type>())),
                                  const value_type&>;
 
        template<typename value_type, typename string_type, typename object_type>
        struct is_valid_json_object {
            static constexpr auto value =
                is_detected<has_mapped_type, object_type>::value &&
                std::is_same<typename object_type::mapped_type, value_type>::value &&
                is_detected<has_key_type, object_type>::value &&
                (std::is_same<typename object_type::key_type, string_type>::value ||
                 std::is_constructible<typename object_type::key_type, string_type>::value) &&
                supports_begin<object_type>::value && supports_end<object_type>::value &&
                is_count_signature<object_type, string_type>::value &&
                is_subcription_operator_signature<object_type, value_type, string_type>::value &&
                is_at_const_signature<object_type, value_type, string_type>::value;
        };
 
        template<typename value_type, typename array_type>
        struct is_valid_json_array {
            static constexpr auto value = std::is_same<typename array_type::value_type, value_type>::value;
        };
 
        template<typename string_type, typename integer_type>
        using is_substr_start_end_index_signature =
            typename std::is_same<decltype(std::declval<string_type>().substr(std::declval<integer_type>(),
                                                                              std::declval<integer_type>())),
                                  string_type>;
 
        template<typename string_type, typename integer_type>
        using is_substr_start_index_signature =
            typename std::is_same<decltype(std::declval<string_type>().substr(std::declval<integer_type>())),
                                  string_type>;
 
        template<typename string_type>
        struct has_operate_plus_method { // https://stackoverflow.com/a/9154394/8480874
            template<class>
            struct sfinae_true : std::true_type {};
 
            template<class T, class A0>
            static auto test_operator_plus(int)
                -> sfinae_true<decltype(std::declval<T>().operator+(std::declval<A0>()))>;
            template<class, class A0>
            static auto test_operator_plus(long) -> std::false_type;
 
            static constexpr auto value = decltype(test_operator_plus<string_type, string_type>(0)){};
        };
 
        template<typename string_type>
        using is_std_operate_plus_signature =
            typename std::is_same<decltype(std::operator+(std::declval<string_type>(), std::declval<string_type>())),
                                  string_type>;
 
        template<typename string_type, typename integer_type>
        struct is_valid_json_string {
            static constexpr auto substr = is_substr_start_end_index_signature<string_type, integer_type>::value &&
                                           is_substr_start_index_signature<string_type, integer_type>::value;
            static_assert(substr, "string_type must have a substr method taking only a start index and an overload "
                                  "taking a start and end index, both must return a string_type");
 
            static constexpr auto operator_plus =
                has_operate_plus_method<string_type>::value || is_std_operate_plus_signature<string_type>::value;
            static_assert(operator_plus,
                          "string_type must have a '+' operator implemented which returns the concatenated string");
 
            static constexpr auto value = substr && operator_plus;
        };
 
        template<typename value_type, typename string_type, typename integer_type, typename object_type,
                 typename array_type>
        struct is_valid_json_types {
            // Internal assertions for better feedback
            static_assert(is_valid_json_value<value_type>::value,
                          "value_type must meet basic requirements, default constructor, copyable, moveable");
            static_assert(is_valid_json_object<value_type, string_type, object_type>::value,
                          "object_type must be a string_type to value_type container");
            static_assert(is_valid_json_array<value_type, array_type>::value,
                          "array_type must be a container of value_type");
 
            static constexpr auto value = is_valid_json_object<value_type, string_type, object_type>::value &&
                                          is_valid_json_value<value_type>::value &&
                                          is_valid_json_array<value_type, array_type>::value &&
                                          is_valid_json_string<string_type, integer_type>::value;
        };
    } // namespace details
 
    template<typename json_traits>
    class basic_claim {
        static_assert(std::is_same<typename json_traits::string_type, std::string>::value ||
                          std::is_convertible<typename json_traits::string_type, std::string>::value ||
                          std::is_constructible<typename json_traits::string_type, std::string>::value,
                      "string_type must be a std::string, convertible to a std::string, or construct a std::string.");
 
        static_assert(
            details::is_valid_json_types<typename json_traits::value_type, typename json_traits::string_type,
                                         typename json_traits::integer_type, typename json_traits::object_type,
                                         typename json_traits::array_type>::value,
            "must staisfy json container requirements");
        static_assert(details::is_valid_traits<json_traits>::value, "traits must satisfy requirements");
 
        typename json_traits::value_type val;
 
    public:
        using set_t = std::set<typename json_traits::string_type>;
 
        basic_claim() = default;
        basic_claim(const basic_claim&) = default;
        basic_claim(basic_claim&&) = default;
        basic_claim& operator=(const basic_claim&) = default;
        basic_claim& operator=(basic_claim&&) = default;
        ~basic_claim() = default;
 
        JWT_CLAIM_EXPLICIT basic_claim(typename json_traits::string_type s) : val(std::move(s)) {}
        JWT_CLAIM_EXPLICIT basic_claim(const date& d)
            : val(typename json_traits::integer_type(std::chrono::system_clock::to_time_t(d))) {}
        JWT_CLAIM_EXPLICIT basic_claim(typename json_traits::array_type a) : val(std::move(a)) {}
        JWT_CLAIM_EXPLICIT basic_claim(typename json_traits::value_type v) : val(std::move(v)) {}
        JWT_CLAIM_EXPLICIT basic_claim(const set_t& s) : val(typename json_traits::array_type(s.begin(), s.end())) {}
        template<typename Iterator>
        basic_claim(Iterator begin, Iterator end) : val(typename json_traits::array_type(begin, end)) {}
 
        typename json_traits::value_type to_json() const { return val; }
 
        std::istream& operator>>(std::istream& is) { return is >> val; }
 
        std::ostream& operator<<(std::ostream& os) { return os << val; }
 
        json::type get_type() const { return json_traits::get_type(val); }
 
        typename json_traits::string_type as_string() const { return json_traits::as_string(val); }
 
        date as_date() const {
            using std::chrono::system_clock;
            if (get_type() == json::type::number) return system_clock::from_time_t(std::round(as_number()));
            return system_clock::from_time_t(as_int());
        }
 
        typename json_traits::array_type as_array() const { return json_traits::as_array(val); }
 
        set_t as_set() const {
            set_t res;
            for (const auto& e : json_traits::as_array(val)) {
                res.insert(json_traits::as_string(e));
            }
            return res;
        }
 
        typename json_traits::integer_type as_int() const { return json_traits::as_int(val); }
 
        typename json_traits::boolean_type as_bool() const { return json_traits::as_bool(val); }
 
        typename json_traits::number_type as_number() const { return json_traits::as_number(val); }
    };
 
    namespace error {
        struct invalid_json_exception : public std::runtime_error {
            invalid_json_exception() : runtime_error("invalid json") {}
        };
        struct claim_not_present_exception : public std::out_of_range {
            claim_not_present_exception() : out_of_range("claim not found") {}
        };
    } // namespace error
 
    namespace details {
        template<typename json_traits>
        struct map_of_claims {
            typename json_traits::object_type claims;
            using basic_claim_t = basic_claim<json_traits>;
            using iterator = typename json_traits::object_type::iterator;
            using const_iterator = typename json_traits::object_type::const_iterator;
 
            map_of_claims() = default;
            map_of_claims(const map_of_claims&) = default;
            map_of_claims(map_of_claims&&) = default;
            map_of_claims& operator=(const map_of_claims&) = default;
            map_of_claims& operator=(map_of_claims&&) = default;
 
            map_of_claims(typename json_traits::object_type json) : claims(std::move(json)) {}
 
            iterator begin() { return claims.begin(); }
            iterator end() { return claims.end(); }
            const_iterator cbegin() const { return claims.begin(); }
            const_iterator cend() const { return claims.end(); }
            const_iterator begin() const { return claims.begin(); }
            const_iterator end() const { return claims.end(); }
 
            static typename json_traits::object_type parse_claims(const typename json_traits::string_type& str) {
                typename json_traits::value_type val;
                if (!json_traits::parse(val, str)) throw error::invalid_json_exception();
 
                return json_traits::as_object(val);
            };
 
            bool has_claim(const typename json_traits::string_type& name) const noexcept {
                return claims.count(name) != 0;
            }
 
            basic_claim_t get_claim(const typename json_traits::string_type& name) const {
                if (!has_claim(name)) throw error::claim_not_present_exception();
                return basic_claim_t{claims.at(name)};
            }
        };
    } // namespace details
 
    template<typename json_traits>
    class payload {
    protected:
        details::map_of_claims<json_traits> payload_claims;
 
    public:
        using basic_claim_t = basic_claim<json_traits>;
 
        bool has_issuer() const noexcept { return has_payload_claim("iss"); }
        bool has_subject() const noexcept { return has_payload_claim("sub"); }
        bool has_audience() const noexcept { return has_payload_claim("aud"); }
        bool has_expires_at() const noexcept { return has_payload_claim("exp"); }
        bool has_not_before() const noexcept { return has_payload_claim("nbf"); }
        bool has_issued_at() const noexcept { return has_payload_claim("iat"); }
        bool has_id() const noexcept { return has_payload_claim("jti"); }
        typename json_traits::string_type get_issuer() const { return get_payload_claim("iss").as_string(); }
        typename json_traits::string_type get_subject() const { return get_payload_claim("sub").as_string(); }
        typename basic_claim_t::set_t get_audience() const {
            auto aud = get_payload_claim("aud");
            if (aud.get_type() == json::type::string) return {aud.as_string()};
 
            return aud.as_set();
        }
        date get_expires_at() const { return get_payload_claim("exp").as_date(); }
        date get_not_before() const { return get_payload_claim("nbf").as_date(); }
        date get_issued_at() const { return get_payload_claim("iat").as_date(); }
        typename json_traits::string_type get_id() const { return get_payload_claim("jti").as_string(); }
        bool has_payload_claim(const typename json_traits::string_type& name) const noexcept {
            return payload_claims.has_claim(name);
        }
        basic_claim_t get_payload_claim(const typename json_traits::string_type& name) const {
            return payload_claims.get_claim(name);
        }
    };
 
    template<typename json_traits>
    class header {
    protected:
        details::map_of_claims<json_traits> header_claims;
 
    public:
        using basic_claim_t = basic_claim<json_traits>;
        bool has_algorithm() const noexcept { return has_header_claim("alg"); }
        bool has_type() const noexcept { return has_header_claim("typ"); }
        bool has_content_type() const noexcept { return has_header_claim("cty"); }
        bool has_key_id() const noexcept { return has_header_claim("kid"); }
        typename json_traits::string_type get_algorithm() const { return get_header_claim("alg").as_string(); }
        typename json_traits::string_type get_type() const { return get_header_claim("typ").as_string(); }
        typename json_traits::string_type get_content_type() const { return get_header_claim("cty").as_string(); }
        typename json_traits::string_type get_key_id() const { return get_header_claim("kid").as_string(); }
        bool has_header_claim(const typename json_traits::string_type& name) const noexcept {
            return header_claims.has_claim(name);
        }
        basic_claim_t get_header_claim(const typename json_traits::string_type& name) const {
            return header_claims.get_claim(name);
        }
    };
 
    template<typename json_traits>
    class decoded_jwt : public header<json_traits>, public payload<json_traits> {
    protected:
        typename json_traits::string_type token;
        typename json_traits::string_type header;
        typename json_traits::string_type header_base64;
        typename json_traits::string_type payload;
        typename json_traits::string_type payload_base64;
        typename json_traits::string_type signature;
        typename json_traits::string_type signature_base64;
 
    public:
        using basic_claim_t = basic_claim<json_traits>;
#ifndef JWT_DISABLE_BASE64
 
        JWT_CLAIM_EXPLICIT decoded_jwt(const typename json_traits::string_type& token)
            : decoded_jwt(token, [](const typename json_traits::string_type& str) {
                  return base::decode<alphabet::base64url>(base::pad<alphabet::base64url>(str));
              }) {}
#endif
 
        template<typename Decode>
        decoded_jwt(const typename json_traits::string_type& token, Decode decode) : token(token) {
            auto hdr_end = token.find('.');
            if (hdr_end == json_traits::string_type::npos) throw std::invalid_argument("invalid token supplied");
            auto payload_end = token.find('.', hdr_end + 1);
            if (payload_end == json_traits::string_type::npos) throw std::invalid_argument("invalid token supplied");
            header_base64 = token.substr(0, hdr_end);
            payload_base64 = token.substr(hdr_end + 1, payload_end - hdr_end - 1);
            signature_base64 = token.substr(payload_end + 1);
 
            header = decode(header_base64);
            payload = decode(payload_base64);
            signature = decode(signature_base64);
 
            this->header_claims = details::map_of_claims<json_traits>::parse_claims(header);
            this->payload_claims = details::map_of_claims<json_traits>::parse_claims(payload);
        }
 
        const typename json_traits::string_type& get_token() const noexcept { return token; }
        const typename json_traits::string_type& get_header() const noexcept { return header; }
        const typename json_traits::string_type& get_payload() const noexcept { return payload; }
        const typename json_traits::string_type& get_signature() const noexcept { return signature; }
        const typename json_traits::string_type& get_header_base64() const noexcept { return header_base64; }
        const typename json_traits::string_type& get_payload_base64() const noexcept { return payload_base64; }
        const typename json_traits::string_type& get_signature_base64() const noexcept { return signature_base64; }
        typename json_traits::object_type get_payload_json() const { return this->payload_claims.claims; }
        typename json_traits::object_type get_header_json() const { return this->header_claims.claims; }
        basic_claim_t get_payload_claim(const typename json_traits::string_type& name) const {
            return this->payload_claims.get_claim(name);
        }
        basic_claim_t get_header_claim(const typename json_traits::string_type& name) const {
            return this->header_claims.get_claim(name);
        }
    };
 
    template<typename json_traits>
    class builder {
        typename json_traits::object_type header_claims;
        typename json_traits::object_type payload_claims;
 
    public:
        builder() = default;
        builder& set_header_claim(const typename json_traits::string_type& id, typename json_traits::value_type c) {
            header_claims[id] = std::move(c);
            return *this;
        }
 
        builder& set_header_claim(const typename json_traits::string_type& id, basic_claim<json_traits> c) {
            header_claims[id] = c.to_json();
            return *this;
        }
        builder& set_payload_claim(const typename json_traits::string_type& id, typename json_traits::value_type c) {
            payload_claims[id] = std::move(c);
            return *this;
        }
        builder& set_payload_claim(const typename json_traits::string_type& id, basic_claim<json_traits> c) {
            payload_claims[id] = c.to_json();
            return *this;
        }
        builder& set_algorithm(typename json_traits::string_type str) {
            return set_header_claim("alg", typename json_traits::value_type(str));
        }
        builder& set_type(typename json_traits::string_type str) {
            return set_header_claim("typ", typename json_traits::value_type(str));
        }
        builder& set_content_type(typename json_traits::string_type str) {
            return set_header_claim("cty", typename json_traits::value_type(str));
        }
        builder& set_key_id(typename json_traits::string_type str) {
            return set_header_claim("kid", typename json_traits::value_type(str));
        }
        builder& set_issuer(typename json_traits::string_type str) {
            return set_payload_claim("iss", typename json_traits::value_type(str));
        }
        builder& set_subject(typename json_traits::string_type str) {
            return set_payload_claim("sub", typename json_traits::value_type(str));
        }
        builder& set_audience(typename json_traits::array_type a) {
            return set_payload_claim("aud", typename json_traits::value_type(a));
        }
        builder& set_audience(typename json_traits::string_type aud) {
            return set_payload_claim("aud", typename json_traits::value_type(aud));
        }
        builder& set_expires_at(const date& d) { return set_payload_claim("exp", basic_claim<json_traits>(d)); }
        builder& set_not_before(const date& d) { return set_payload_claim("nbf", basic_claim<json_traits>(d)); }
        builder& set_issued_at(const date& d) { return set_payload_claim("iat", basic_claim<json_traits>(d)); }
        builder& set_id(const typename json_traits::string_type& str) {
            return set_payload_claim("jti", typename json_traits::value_type(str));
        }
 
        template<typename Algo, typename Encode>
        typename json_traits::string_type sign(const Algo& algo, Encode encode) const {
            std::error_code ec;
            auto res = sign(algo, encode, ec);
            error::throw_if_error(ec);
            return res;
        }
#ifndef JWT_DISABLE_BASE64
 
        template<typename Algo>
        typename json_traits::string_type sign(const Algo& algo) const {
            std::error_code ec;
            auto res = sign(algo, ec);
            error::throw_if_error(ec);
            return res;
        }
#endif
 
        template<typename Algo, typename Encode>
        typename json_traits::string_type sign(const Algo& algo, Encode encode, std::error_code& ec) const {
            // make a copy such that a builder can be re-used
            typename json_traits::object_type obj_header = header_claims;
            if (header_claims.count("alg") == 0) obj_header["alg"] = typename json_traits::value_type(algo.name());
 
            const auto header = encode(json_traits::serialize(typename json_traits::value_type(obj_header)));
            const auto payload = encode(json_traits::serialize(typename json_traits::value_type(payload_claims)));
            const auto token = header + "." + payload;
 
            auto signature = algo.sign(token, ec);
            if (ec) return {};
 
            return token + "." + encode(signature);
        }
#ifndef JWT_DISABLE_BASE64
 
        template<typename Algo>
        typename json_traits::string_type sign(const Algo& algo, std::error_code& ec) const {
            return sign(
                algo,
                [](const typename json_traits::string_type& data) {
                    return base::trim<alphabet::base64url>(base::encode<alphabet::base64url>(data));
                },
                ec);
        }
#endif
    };
 
    namespace verify_ops {
        template<typename json_traits>
        struct verify_context {
            verify_context(date ctime, const decoded_jwt<json_traits>& j, size_t l)
                : current_time(ctime), jwt(j), default_leeway(l) {}
            // Current time, retrieved from the verifiers clock and cached for performance and consistency
            date current_time;
            // The jwt passed to the verifier
            const decoded_jwt<json_traits>& jwt;
            // The configured default leeway for this verification
            size_t default_leeway{0};
 
            // The claim key to apply this comparision on
            typename json_traits::string_type claim_key{};
 
            // Helper method to get a claim from the jwt in this context
            basic_claim<json_traits> get_claim(bool in_header, std::error_code& ec) const {
                if (in_header) {
                    if (!jwt.has_header_claim(claim_key)) {
                        ec = error::token_verification_error::missing_claim;
                        return {};
                    }
                    return jwt.get_header_claim(claim_key);
                } else {
                    if (!jwt.has_payload_claim(claim_key)) {
                        ec = error::token_verification_error::missing_claim;
                        return {};
                    }
                    return jwt.get_payload_claim(claim_key);
                }
            }
            basic_claim<json_traits> get_claim(bool in_header, json::type t, std::error_code& ec) const {
                auto c = get_claim(in_header, ec);
                if (ec) return {};
                if (c.get_type() != t) {
                    ec = error::token_verification_error::claim_type_missmatch;
                    return {};
                }
                return c;
            }
            basic_claim<json_traits> get_claim(std::error_code& ec) const { return get_claim(false, ec); }
            basic_claim<json_traits> get_claim(json::type t, std::error_code& ec) const {
                return get_claim(false, t, ec);
            }
        };
 
        template<typename json_traits, bool in_header = false>
        struct equals_claim {
            const basic_claim<json_traits> expected;
            void operator()(const verify_context<json_traits>& ctx, std::error_code& ec) const {
                auto jc = ctx.get_claim(in_header, expected.get_type(), ec);
                if (ec) return;
                const bool matches = [&]() {
                    switch (expected.get_type()) {
                    case json::type::boolean: return expected.as_bool() == jc.as_bool();
                    case json::type::integer: return expected.as_int() == jc.as_int();
                    case json::type::number: return expected.as_number() == jc.as_number();
                    case json::type::string: return expected.as_string() == jc.as_string();
                    case json::type::array:
                    case json::type::object:
                        return json_traits::serialize(expected.to_json()) == json_traits::serialize(jc.to_json());
                    default: throw std::logic_error("internal error, should be unreachable");
                    }
                }();
                if (!matches) {
                    ec = error::token_verification_error::claim_value_missmatch;
                    return;
                }
            }
        };
 
        template<typename json_traits, bool in_header = false>
        struct date_before_claim {
            const size_t leeway;
            void operator()(const verify_context<json_traits>& ctx, std::error_code& ec) const {
                auto jc = ctx.get_claim(in_header, json::type::integer, ec);
                if (ec) return;
                auto c = jc.as_date();
                if (ctx.current_time > c + std::chrono::seconds(leeway)) {
                    ec = error::token_verification_error::token_expired;
                }
            }
        };
 
        template<typename json_traits, bool in_header = false>
        struct date_after_claim {
            const size_t leeway;
            void operator()(const verify_context<json_traits>& ctx, std::error_code& ec) const {
                auto jc = ctx.get_claim(in_header, json::type::integer, ec);
                if (ec) return;
                auto c = jc.as_date();
                if (ctx.current_time < c - std::chrono::seconds(leeway)) {
                    ec = error::token_verification_error::token_expired;
                }
            }
        };
 
        template<typename json_traits, bool in_header = false>
        struct is_subset_claim {
            const typename basic_claim<json_traits>::set_t expected;
            void operator()(const verify_context<json_traits>& ctx, std::error_code& ec) const {
                auto c = ctx.get_claim(in_header, ec);
                if (ec) return;
                if (c.get_type() == json::type::string) {
                    if (expected.size() != 1 || *expected.begin() != c.as_string()) {
                        ec = error::token_verification_error::audience_missmatch;
                        return;
                    }
                } else if (c.get_type() == json::type::array) {
                    auto jc = c.as_set();
                    for (auto& e : expected) {
                        if (jc.find(e) == jc.end()) {
                            ec = error::token_verification_error::audience_missmatch;
                            return;
                        }
                    }
                } else {
                    ec = error::token_verification_error::claim_type_missmatch;
                    return;
                }
            }
        };
 
        template<typename json_traits, bool in_header = false>
        struct insensitive_string_claim {
            const typename json_traits::string_type expected;
            std::locale locale;
            insensitive_string_claim(const typename json_traits::string_type& e, std::locale loc)
                : expected(to_lower_unicode(e, loc)), locale(loc) {}
 
            void operator()(const verify_context<json_traits>& ctx, std::error_code& ec) const {
                const auto c = ctx.get_claim(in_header, json::type::string, ec);
                if (ec) return;
                if (to_lower_unicode(c.as_string(), locale) != expected) {
                    ec = error::token_verification_error::claim_value_missmatch;
                }
            }
 
            static std::string to_lower_unicode(const std::string& str, const std::locale& loc) {
#if __cplusplus > 201103L
                std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> conv;
                auto wide = conv.from_bytes(str);
                auto& f = std::use_facet<std::ctype<wchar_t>>(loc);
                f.tolower(&wide[0], &wide[0] + wide.size());
                return conv.to_bytes(wide);
#else
                std::string result;
                std::transform(str.begin(), str.end(), std::back_inserter(result),
                               [&loc](unsigned char c) { return std::tolower(c, loc); });
                return result;
#endif
            }
        };
    } // namespace verify_ops
 
    template<typename Clock, typename json_traits>
    class verifier {
    public:
        using basic_claim_t = basic_claim<json_traits>;
        using verify_check_fn_t =
            std::function<void(const verify_ops::verify_context<json_traits>&, std::error_code& ec)>;
 
    private:
        struct algo_base {
            virtual ~algo_base() = default;
            virtual void verify(const std::string& data, const std::string& sig, std::error_code& ec) = 0;
        };
        template<typename T>
        struct algo : public algo_base {
            T alg;
            explicit algo(T a) : alg(a) {}
            void verify(const std::string& data, const std::string& sig, std::error_code& ec) override {
                alg.verify(data, sig, ec);
            }
        };
        std::unordered_map<typename json_traits::string_type, verify_check_fn_t> claims;
        size_t default_leeway = 0;
        Clock clock;
        std::unordered_map<std::string, std::shared_ptr<algo_base>> algs;
 
    public:
        explicit verifier(Clock c) : clock(c) {
            claims["exp"] = [](const verify_ops::verify_context<json_traits>& ctx, std::error_code& ec) {
                if (!ctx.jwt.has_expires_at()) return;
                auto exp = ctx.jwt.get_expires_at();
                if (ctx.current_time > exp + std::chrono::seconds(ctx.default_leeway)) {
                    ec = error::token_verification_error::token_expired;
                }
            };
            claims["iat"] = [](const verify_ops::verify_context<json_traits>& ctx, std::error_code& ec) {
                if (!ctx.jwt.has_issued_at()) return;
                auto iat = ctx.jwt.get_issued_at();
                if (ctx.current_time < iat - std::chrono::seconds(ctx.default_leeway)) {
                    ec = error::token_verification_error::token_expired;
                }
            };
            claims["nbf"] = [](const verify_ops::verify_context<json_traits>& ctx, std::error_code& ec) {
                if (!ctx.jwt.has_not_before()) return;
                auto nbf = ctx.jwt.get_not_before();
                if (ctx.current_time < nbf - std::chrono::seconds(ctx.default_leeway)) {
                    ec = error::token_verification_error::token_expired;
                }
            };
        }
 
        verifier& leeway(size_t leeway) {
            default_leeway = leeway;
            return *this;
        }
        verifier& expires_at_leeway(size_t leeway) {
            claims["exp"] = verify_ops::date_before_claim<json_traits>{leeway};
            return *this;
        }
        verifier& not_before_leeway(size_t leeway) {
            claims["nbf"] = verify_ops::date_after_claim<json_traits>{leeway};
            return *this;
        }
        verifier& issued_at_leeway(size_t leeway) {
            claims["iat"] = verify_ops::date_after_claim<json_traits>{leeway};
            return *this;
        }
 
        verifier& with_type(const typename json_traits::string_type& type, std::locale locale = std::locale{}) {
            return with_claim("typ", verify_ops::insensitive_string_claim<json_traits, true>{type, std::move(locale)});
        }
 
        verifier& with_issuer(const typename json_traits::string_type& iss) {
            return with_claim("iss", basic_claim_t(iss));
        }
 
        verifier& with_subject(const typename json_traits::string_type& sub) {
            return with_claim("sub", basic_claim_t(sub));
        }
        verifier& with_audience(const typename basic_claim_t::set_t& aud) {
            claims["aud"] = verify_ops::is_subset_claim<json_traits>{aud};
            return *this;
        }
        verifier& with_audience(const typename json_traits::string_type& aud) {
            typename basic_claim_t::set_t s;
            s.insert(aud);
            return with_audience(s);
        }
        verifier& with_id(const typename json_traits::string_type& id) { return with_claim("jti", basic_claim_t(id)); }
 
        verifier& with_claim(const typename json_traits::string_type& name, verify_check_fn_t fn) {
            claims[name] = fn;
            return *this;
        }
 
        verifier& with_claim(const typename json_traits::string_type& name, basic_claim_t c) {
            return with_claim(name, verify_ops::equals_claim<json_traits>{c});
        }
 
        template<typename Algorithm>
        verifier& allow_algorithm(Algorithm alg) {
            algs[alg.name()] = std::make_shared<algo<Algorithm>>(alg);
            return *this;
        }
 
        void verify(const decoded_jwt<json_traits>& jwt) const {
            std::error_code ec;
            verify(jwt, ec);
            error::throw_if_error(ec);
        }
        void verify(const decoded_jwt<json_traits>& jwt, std::error_code& ec) const {
            ec.clear();
            const typename json_traits::string_type data = jwt.get_header_base64() + "." + jwt.get_payload_base64();
            const typename json_traits::string_type sig = jwt.get_signature();
            const std::string algo = jwt.get_algorithm();
            if (algs.count(algo) == 0) {
                ec = error::token_verification_error::wrong_algorithm;
                return;
            }
            algs.at(algo)->verify(data, sig, ec);
            if (ec) return;
 
            verify_ops::verify_context<json_traits> ctx{clock.now(), jwt, default_leeway};
            for (auto& c : claims) {
                ctx.claim_key = c.first;
                c.second(ctx, ec);
                if (ec) return;
            }
        }
    };
 
    template<typename json_traits>
    class jwk {
        using basic_claim_t = basic_claim<json_traits>;
        const details::map_of_claims<json_traits> jwk_claims;
 
    public:
        JWT_CLAIM_EXPLICIT jwk(const typename json_traits::string_type& str)
            : jwk_claims(details::map_of_claims<json_traits>::parse_claims(str)) {}
 
        JWT_CLAIM_EXPLICIT jwk(const typename json_traits::value_type& json)
            : jwk_claims(json_traits::as_object(json)) {}
 
        typename json_traits::string_type get_key_type() const { return get_jwk_claim("kty").as_string(); }
 
        typename json_traits::string_type get_use() const { return get_jwk_claim("use").as_string(); }
 
        typename basic_claim_t::set_t get_key_operations() const { return get_jwk_claim("key_ops").as_set(); }
 
        typename json_traits::string_type get_algorithm() const { return get_jwk_claim("alg").as_string(); }
 
        typename json_traits::string_type get_key_id() const { return get_jwk_claim("kid").as_string(); }
 
        typename json_traits::string_type get_curve() const { return get_jwk_claim("crv").as_string(); }
 
        typename json_traits::array_type get_x5c() const { return get_jwk_claim("x5c").as_array(); };
 
        typename json_traits::string_type get_x5u() const { return get_jwk_claim("x5u").as_string(); };
 
        typename json_traits::string_type get_x5t() const { return get_jwk_claim("x5t").as_string(); };
 
        typename json_traits::string_type get_x5t_sha256() const { return get_jwk_claim("x5t#S256").as_string(); };
 
        typename json_traits::string_type get_x5c_key_value() const {
            auto x5c_array = get_jwk_claim("x5c").as_array();
            if (x5c_array.size() == 0) throw error::claim_not_present_exception();
 
            return json_traits::as_string(x5c_array.front());
        };
 
        bool has_key_type() const noexcept { return has_jwk_claim("kty"); }
 
        bool has_use() const noexcept { return has_jwk_claim("use"); }
 
        bool has_key_operations() const noexcept { return has_jwk_claim("key_ops"); }
 
        bool has_algorithm() const noexcept { return has_jwk_claim("alg"); }
 
        bool has_curve() const noexcept { return has_jwk_claim("crv"); }
 
        bool has_key_id() const noexcept { return has_jwk_claim("kid"); }
 
        bool has_x5u() const noexcept { return has_jwk_claim("x5u"); }
 
        bool has_x5c() const noexcept { return has_jwk_claim("x5c"); }
 
        bool has_x5t() const noexcept { return has_jwk_claim("x5t"); }
 
        bool has_x5t_sha256() const noexcept { return has_jwk_claim("x5t#S256"); }
 
        bool has_jwk_claim(const typename json_traits::string_type& name) const noexcept {
            return jwk_claims.has_claim(name);
        }
 
        basic_claim_t get_jwk_claim(const typename json_traits::string_type& name) const {
            return jwk_claims.get_claim(name);
        }
 
        bool empty() const noexcept { return jwk_claims.empty(); }
 
        typename json_traits::object_type get_claims() const { return this->jwk_claims.claims; }
    };
 
    template<typename json_traits>
    class jwks {
    public:
        using jwk_t = jwk<json_traits>;
        using jwt_vector_t = std::vector<jwk_t>;
        using iterator = typename jwt_vector_t::iterator;
        using const_iterator = typename jwt_vector_t::const_iterator;
 
        JWT_CLAIM_EXPLICIT jwks(const typename json_traits::string_type& str) {
            typename json_traits::value_type parsed_val;
            if (!json_traits::parse(parsed_val, str)) throw error::invalid_json_exception();
 
            const details::map_of_claims<json_traits> jwks_json = json_traits::as_object(parsed_val);
            if (!jwks_json.has_claim("keys")) throw error::invalid_json_exception();
 
            auto jwk_list = jwks_json.get_claim("keys").as_array();
            std::transform(jwk_list.begin(), jwk_list.end(), std::back_inserter(jwk_claims),
                           [](const typename json_traits::value_type& val) { return jwk_t{val}; });
        }
 
        iterator begin() { return jwk_claims.begin(); }
        iterator end() { return jwk_claims.end(); }
        const_iterator cbegin() const { return jwk_claims.begin(); }
        const_iterator cend() const { return jwk_claims.end(); }
        const_iterator begin() const { return jwk_claims.begin(); }
        const_iterator end() const { return jwk_claims.end(); }
 
        bool has_jwk(const typename json_traits::string_type& key_id) const noexcept {
            return find_by_kid(key_id) != end();
        }
 
        jwk_t get_jwk(const typename json_traits::string_type& key_id) const {
            const auto maybe = find_by_kid(key_id);
            if (maybe == end()) throw error::claim_not_present_exception();
            return *maybe;
        }
 
    private:
        jwt_vector_t jwk_claims;
 
        const_iterator find_by_kid(const typename json_traits::string_type& key_id) const noexcept {
            return std::find_if(cbegin(), cend(), [key_id](const jwk_t& jwk) {
                if (!jwk.has_key_id()) { return false; }
                return jwk.get_key_id() == key_id;
            });
        }
    };
 
    template<typename Clock, typename json_traits>
    verifier<Clock, json_traits> verify(Clock c) {
        return verifier<Clock, json_traits>(c);
    }
 
    struct default_clock {
        date now() const { return date::clock::now(); }
    };
 
    template<typename json_traits>
    verifier<default_clock, json_traits> verify(default_clock c = {}) {
        return verifier<default_clock, json_traits>(c);
    }
 
    template<typename json_traits>
    builder<json_traits> create() {
        return builder<json_traits>();
    }
 
    template<typename json_traits, typename Decode>
    decoded_jwt<json_traits> decode(const typename json_traits::string_type& token, Decode decode) {
        return decoded_jwt<json_traits>(token, decode);
    }
 
    template<typename json_traits>
    decoded_jwt<json_traits> decode(const typename json_traits::string_type& token) {
        return decoded_jwt<json_traits>(token);
    }
 
    template<typename json_traits>
    jwk<json_traits> parse_jwk(const typename json_traits::string_type& token) {
        return jwk<json_traits>(token);
    }
 
    template<typename json_traits>
    jwks<json_traits> parse_jwks(const typename json_traits::string_type& token) {
        return jwks<json_traits>(token);
    }
} // namespace jwt
 
template<typename json_traits>
std::istream& operator>>(std::istream& is, jwt::basic_claim<json_traits>& c) {
    return c.operator>>(is);
}
 
template<typename json_traits>
std::ostream& operator<<(std::ostream& os, const jwt::basic_claim<json_traits>& c) {
    return os << c.to_json();
}
 
#ifndef JWT_DISABLE_PICOJSON
#include "traits/kazuho-picojson/defaults.h"
#endif
 
#endif