SqMod/vendor/POCO/JWT/include/Poco/JWT/Token.h

//
// Token.h
//
// Library: JWT
// Package: JWT
// Module:  Token
//
// Definition of the Token class.
//
// Copyright (c) 2019, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier:	BSL-1.0
//


#ifndef JWT_Token_INCLUDED
#define JWT_Token_INCLUDED


#include "Poco/JWT/JWT.h"
#include "Poco/JSON/Object.h"
#include "Poco/Timestamp.h"


namespace Poco {
namespace JWT {


class JWT_API Token
	/// This class represents a JSON Web Token (JWT) according to RFC 7519.
	///
	/// To create and sign a JWT (using the Signer class):
	///
	///     Token token;
	///     token.setType("JWT");
	///     token.setSubject("1234567890");
	///     token.payload().set("name", std::string("John Doe"));
	///     token.setIssuedAt(Poco::Timestamp()));
	///
	///     Signer signer("0123456789ABCDEF0123456789ABCDEF");
	///     std::string jwt = signer.sign(token, Signer::ALGO_HS256);
	///
	/// To verify a signed token:
	///
	///     std::string jwt(
	///     	"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9."
	///     	"eyJpYXQiOjE1MTYyMzkwMjIsIm5hbWUiOiJKb2huIERvZSIsInN1YiI6IjEyMzQ1Njc4OTAifQ."
	///     	"qn9G7NwFEOjIh-7hfCUDZA1aJeQmf7I7YvzCBcdenGw");
	///
	///     Signer signer("0123456789ABCDEF0123456789ABCDEF");
	///     Token token = signer.verify(jwt);
{
public:
	Token();
		/// Creates an empty JSON Web Token.

	explicit Token(const std::string& token);
		/// Creates a JSON Web Token from its serialized string representation.

	Token(const Token& token);
		/// Creates a JSON Web Token by copying another one.

	Token(Token&& token) noexcept;
		/// Creates a JSON Web Token by moving another one.

	~Token();
		/// Destroys the Token.

	Token& operator = (const Token& token);
		/// Assignment operator.

	Token& operator = (Token&& token) noexcept;
		/// Move assignment operator.

	Token& operator = (const std::string& token);
		/// Parses and assigns serialized JWT.

	std::string toString() const;
		/// Returns the serialized string representation of the JSON Web Token.

	const Poco::JSON::Object& header() const;
		/// Returns the header JSON object.

	Poco::JSON::Object& header();
		/// Returns the header JSON object.

	const Poco::JSON::Object& payload() const;
		/// Returns the payload JSON object.

	Poco::JSON::Object& payload();
		/// Returns the payload JSON object.

	const std::string& signature() const;
		/// Returns the signature string.

	void setIssuer(const std::string& issuer);
		/// Sets the issuer ("iss" claim in payload).

	std::string getIssuer() const;
		/// Returns the issuer, or an empty string if no issuer has been specified.

	void setSubject(const std::string& subject);
		/// Sets the subject ("sub" claim in paylod).

	std::string getSubject() const;
		/// Returns the subject, or an empty string if no issuer has been specified.

	void setAudience(const std::string& audience);
		/// Sets the audience ("aud" claim in payload) to a single value.

	void setAudience(const std::vector<std::string>& audience);
		/// Sets the audience ("aud" claim in payload).

	std::vector<std::string> getAudience() const;
		/// Returns the audience.

	void setExpiration(const Poco::Timestamp& expiration);
		/// Sets the expiration ("exp" claim in payload).

	Poco::Timestamp getExpiration() const;
		/// Returns the expiration, or a zero Poco::Timestamp if no expiration has been specified.

	void setNotBefore(const Poco::Timestamp& notBefore);
		/// Sets the not-before time ("nbf" claim in payload).

	Poco::Timestamp getNotBefore() const;
		/// Returns the not-before time, or a zero Poco::Timestamp if no not-before time has been specified.

	void setIssuedAt(const Poco::Timestamp& issuedAt);
		/// Sets the issued-at time ("iat" claim in payload).

	Poco::Timestamp getIssuedAt() const;
		/// Returns the issued-at time, or a zero Poco::Timestamp if no issued-at time has been specified.

	void setId(const std::string& id);
		/// Sets the JWT ID ("jti" claim in payload).

	std::string getId() const;
		/// Returns the JWT ID, or an empty string if no JWT ID has been specified.

	void setType(const std::string& type);
		/// Sets the JWT type ("typ" claim in payload).

	std::string getType() const;
		/// Returns the JWT type or an empty string if no type has been specified.

	void setAlgorithm(const std::string& algorithm);
		/// Sets the JWT signature algorithm ("alg" claim in header).

	std::string getAlgorithm() const;
		/// Returns the JWT signature algorithm, or an empty string if no algorithm has been specified.

	void setContentType(const std::string& contentType);
		/// Sets the JWT content type ("cty" claim in header").

	std::string getContentType() const;
		/// Returns the JWT content type, or an empty string if no content type has been specified.

	static const std::string CLAIM_ISSUER;
	static const std::string CLAIM_SUBJECT;
	static const std::string CLAIM_AUDIENCE;
	static const std::string CLAIM_EXPIRATION;
	static const std::string CLAIM_NOT_BEFORE;
	static const std::string CLAIM_ISSUED_AT;
	static const std::string CLAIM_JWT_ID;
	static const std::string CLAIM_TYPE;
	static const std::string CLAIM_ALGORITHM;
	static const std::string CLAIM_CONTENT_TYPE;

protected:
	Token(const std::string& header, const std::string& payload, const std::string& signature);

	void sign(const std::string& signature);
	void setTimestamp(const std::string& claim, const Poco::Timestamp& ts);
	Poco::Timestamp getTimestamp(const std::string& claim) const;
	void assign(const std::string& header, const std::string& payload, const std::string& signature);

private:
	Poco::JSON::Object::Ptr _pHeader;
	Poco::JSON::Object::Ptr _pPayload;
	std::string _signature;

	static const std::string EMPTY;

	friend class Signer;
};


//
// inlines
//


inline const Poco::JSON::Object& Token::header() const
{
	return *_pHeader;
}


inline Poco::JSON::Object& Token::header()
{
	return *_pHeader;
}


inline const Poco::JSON::Object& Token::payload() const
{
	return *_pPayload;
}


inline Poco::JSON::Object& Token::payload()
{
	return *_pPayload;
}


inline const std::string& Token::signature() const
{
	return _signature;
}


inline void Token::setIssuer(const std::string& issuer)
{
	_pPayload->set(CLAIM_ISSUER, issuer);
}


inline std::string Token::getIssuer() const
{
	return _pPayload->optValue(CLAIM_ISSUER, EMPTY);
}


inline void Token::setSubject(const std::string& subject)
{
	_pPayload->set(CLAIM_SUBJECT, subject);
}


inline std::string Token::getSubject() const
{
	return _pPayload->optValue(CLAIM_SUBJECT, EMPTY);
}


inline void Token::setAudience(const std::string& audience)
{
	_pPayload->set(CLAIM_AUDIENCE, audience);
}


inline void Token::setExpiration(const Poco::Timestamp& expiration)
{
	setTimestamp(CLAIM_EXPIRATION, expiration);
}


inline Poco::Timestamp Token::getExpiration() const
{
	return getTimestamp(CLAIM_EXPIRATION);
}


inline void Token::setNotBefore(const Poco::Timestamp& notBefore)
{
	setTimestamp(CLAIM_NOT_BEFORE, notBefore);
}


inline Poco::Timestamp Token::getNotBefore() const
{
	return getTimestamp(CLAIM_NOT_BEFORE);
}


inline void Token::setIssuedAt(const Poco::Timestamp& issuedAt)
{
	setTimestamp(CLAIM_ISSUED_AT, issuedAt);
}


inline Poco::Timestamp Token::getIssuedAt() const
{
	return getTimestamp(CLAIM_ISSUED_AT);
}


inline void Token::setId(const std::string& id)
{
	_pPayload->set(CLAIM_JWT_ID, id);
}


inline std::string Token::getId() const
{
	return _pPayload->optValue(CLAIM_JWT_ID, EMPTY);
}


inline void Token::setType(const std::string& type)
{
	_pHeader->set(CLAIM_TYPE, type);
}


inline std::string Token::getType() const
{
	return _pHeader->optValue(CLAIM_TYPE, EMPTY);
}


inline void Token::setAlgorithm(const std::string& algorithm)
{
	_pHeader->set(CLAIM_ALGORITHM, algorithm);
}


inline std::string Token::getAlgorithm() const
{
	return _pHeader->optValue(CLAIM_ALGORITHM, EMPTY);
}


inline void Token::setContentType(const std::string& contentType)
{
	_pHeader->set(CLAIM_CONTENT_TYPE, contentType);
}


inline std::string Token::getContentType() const
{
	return _pHeader->optValue(CLAIM_CONTENT_TYPE, EMPTY);
}


} } // namespace Poco::JWT


#endif // JWT_Token_INCLUDED