jwt.h

Go to the documentation of this file.

#pragma once

 
#include "value.h"
#include "error.h"
 
#include <functional>
#include <string>
#include <vector>
#include <memory>
 
#include <ctime>

namespace JWTXX
{

void enableOpenSSLErrors() noexcept;

enum class Algorithm {
    HS256, 
    HS384, 
    HS512, 
    RS256, 
    RS384, 
    RS512, 
    ES256, 
    ES384, 
    ES512, 
    none   
};

std::string algToString(Algorithm alg) noexcept;

Algorithm stringToAlg(const std::string& value);

class Key
{
    public:
        using PasswordCallback = std::function<std::string ()>;

        struct Error : JWTXX::Error
        {
            explicit Error(const std::string& message) : JWTXX::Error(message) {}
        };

        static std::string noPasswordCallback();

        Key(Algorithm alg, const std::string& keyData, const PasswordCallback& cb = noPasswordCallback);
        ~Key();

        Key(Key&&) noexcept;
        Key& operator=(Key&&) noexcept;

        Algorithm alg() const noexcept { return m_alg; }

        std::string sign(const void* data, size_t size) const;
        bool verify(const void* data, size_t size, const std::string& signature) const;

        struct Impl;
    private:
        Algorithm m_alg;
        std::unique_ptr<Impl> m_impl;
};
 

class ValidationResult
{
    public:
        static ValidationResult ok() noexcept { return ValidationResult(); }
        static ValidationResult failure(const std::string& message) noexcept { return ValidationResult(message); }

        explicit operator bool() const noexcept { return m_message.empty(); }

        const std::string& message() const noexcept { return m_message; }
 
    private:
        std::string m_message;
 
        ValidationResult() noexcept {}
        explicit ValidationResult(const std::string& message) noexcept : m_message(message) {}
};

using Validator = std::function<ValidationResult (const Value::Object&)>;

using Validators = std::vector<Validator>;

namespace Validate
{

Validator exp(std::time_t now = std::time(nullptr)) noexcept;
Validator nbf(std::time_t now = std::time(nullptr)) noexcept;
Validator iat(std::time_t now = std::time(nullptr)) noexcept;
Validator iss(std::string issuer) noexcept;
Validator aud(std::string audience) noexcept;
Validator sub(std::string subject) noexcept;
 
}

class JWT
{
    public:
        struct Error : JWTXX::Error
        {
            explicit Error(const std::string& message) noexcept : JWTXX::Error(message) {}
        };

        struct ParseError : Error
        {
            explicit ParseError(const std::string& message) noexcept : Error(message) {}
        };

        struct ValidationError : Error
        {
            explicit ValidationError(const std::string& message) noexcept : Error(message) {}
        };

        JWT(const std::string& token, Key key, Validators validators = {Validate::exp()});

        JWT(Algorithm alg, Value::Object claims, Value::Object header = Value::Object{}) noexcept;

        static JWT parse(const std::string& token);

        static ValidationResult verify(const std::string& token, Key key, Validators validators = {Validate::exp()}) noexcept;

        Algorithm alg() const noexcept { return m_alg; }

        const Value::Object& claims() const noexcept { return m_claims; }

        const Value::Object& header() const noexcept { return m_header; }

        Value claim(const std::string& name) const noexcept;

        std::string token(const std::string& keyData, const Key::PasswordCallback& cb = Key::noPasswordCallback) const;

        std::string token(const Key& key) const;
 
    private:
        Algorithm m_alg;
        Value::Object m_header;
        Value::Object m_claims;
};
 
}