JWT-CPP

https://thalhammer.github.io/jwt-cpp/
Admin
JWT-CPP is a header-only C++ library for creating and validating JSON Web Tokens (JWT) with support...
Tokens:18,637
Snippets:137
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### JWT-CPP - Installation

Source: https://thalhammer.github.io/jwt-cpp/pages.html

Instructions for installing the JWT-CPP library.

```APIDOC
## Installation

JWT-CPP is a header-only library, which simplifies the installation process. You typically only need to include the library's header files in your project.

### Prerequisites

- A C++ compiler supporting C++11 or later.
- CMake (optional, for building examples or tests).

### Including the Library

1. **Download**: Obtain the latest release of JWT-CPP from its repository.
2. **Include Path**: Add the `include` directory of the JWT-CPP library to your compiler's include path.

   For example, if you place the library in `/path/to/jwt-cpp`:
   ```bash
   g++ -I/path/to/jwt-cpp your_code.cpp -o your_executable
   ```

### Using CMake

If you are using CMake, you can add JWT-CPP as a subdirectory:

```cmake
add_subdirectory(/path/to/jwt-cpp)

target_link_libraries(your_target PRIVATE jwt_cpp)
```

This will make the `jwt_cpp` target available for linking.
```

--------------------------------

### CMake Integration with find_package

Source: https://thalhammer.github.io/jwt-cpp/md_docs_2install.html

Recommended method for integrating JWT-CPP using CMake. Ensure OpenSSL is installed and then link the jwt-cpp::jwt-cpp target to your application.

```cmake
cmake .
cmake --build .
cmake --install .

find_package(jwt-cpp CONFIG REQUIRED)
target_link_libraries(my_app PRIVATE jwt-cpp::jwt-cpp)
```

--------------------------------

### JWT-CPP Function Reference

Source: https://thalhammer.github.io/jwt-cpp/functions_func.html

Reference for various functions available in the JWT-CPP library, categorized by their starting letter.

```APIDOC
## JWT-CPP Function Reference

This section provides a detailed reference for the functions available in the JWT-CPP library.

### Functions starting with 'a'

*   **allow_algorithm()**: `jwt::verifier< Clock, json_traits >` - Allows a specific algorithm for token verification.
*   **as_array()**: `jwt::basic_claim< json_traits >` - Converts a claim to an array.
*   **as_boolean()**: `jwt::basic_claim< json_traits >` - Converts a claim to a boolean.
*   **as_date()**: `jwt::basic_claim< json_traits >` - Converts a claim to a date.
*   **as_integer()**: `jwt::basic_claim< json_traits >` - Converts a claim to an integer.
*   **as_number()**: `jwt::basic_claim< json_traits >` - Converts a claim to a number.
*   **as_set()**: `jwt::basic_claim< json_traits >` - Converts a claim to a set.
*   **as_string()**: `jwt::basic_claim< json_traits >` - Converts a claim to a string.

### Functions starting with 'b'

*   **builder()**: `jwt::builder< Clock, json_traits >` - Creates a JWT builder instance.

### Functions starting with 'd'

*   **decoded_jwt()**: `jwt::decoded_jwt< json_traits >` - Represents a decoded JWT.

### Functions starting with 'e'

*   **ecdsa()**: `jwt::algorithm::ecdsa` - ECDSA algorithm implementation.
*   **ed25519()**: `jwt::algorithm::ed25519` - Ed25519 algorithm implementation.
*   **ed448()**: `jwt::algorithm::ed448` - Ed448 algorithm implementation.
*   **eddsa()**: `jwt::algorithm::eddsa` - EdDSA algorithm implementation.
*   **empty()**: `jwt::jwk< json_traits >` - Checks if a JWK is empty.
*   **es256()**: `jwt::algorithm::es256` - ES256 algorithm implementation.
*   **es256k()**: `jwt::algorithm::es256k` - ES256K algorithm implementation.
*   **es384()**: `jwt::algorithm::es384` - ES384 algorithm implementation.
*   **es512()**: `jwt::algorithm::es512` - ES512 algorithm implementation.
*   **evp_pkey_handle()**: `jwt::helper::evp_pkey_handle` - Handle for EVP private key.
*   **expires_at_leeway()**: `jwt::verifier< Clock, json_traits >` - Sets leeway for expiration time verification.

### Functions starting with 'g'

*   **get_algorithm()**: `jwt::header< json_traits >, jwt::jwk< json_traits >` - Retrieves the algorithm used.
*   **get_audience()**: `jwt::payload< json_traits >` - Retrieves the audience claim.
*   **get_claim()**: `jwt::verify_ops::verify_context< json_traits >` - Retrieves a specific claim from the verification context.
*   **get_claims()**: `jwt::jwk< json_traits >` - Retrieves all claims from a JWK.
*   **get_content_type()**: `jwt::header< json_traits >` - Retrieves the content type from the header.
*   **get_curve()**: `jwt::jwk< json_traits >` - Retrieves the curve name for elliptic curve keys.
*   **get_expires_at()**: `jwt::payload< json_traits >` - Retrieves the expiration time claim.
*   **get_header()**: `jwt::decoded_jwt< json_traits >` - Retrieves the header of a decoded JWT.
*   **get_header_base64()**: `jwt::decoded_jwt< json_traits >` - Retrieves the base64 encoded header of a decoded JWT.
*   **get_header_claim()**: `jwt::decoded_jwt< json_traits >, jwt::header< json_traits >` - Retrieves a specific claim from the header.
*   **get_header_json()**: `jwt::decoded_jwt< json_traits >` - Retrieves the header as a JSON object.
*   **get_id()**: `jwt::payload< json_traits >` - Retrieves the JWT ID claim.
*   **get_issued_at()**: `jwt::payload< json_traits >` - Retrieves the issued at claim.
*   **get_issuer()**: `jwt::payload< json_traits >` - Retrieves the issuer claim.
*   **get_jwk()**: `jwt::jwks< json_traits >` - Retrieves a JWK from a JWKS set.
*   **get_jwk_claim()**: `jwt::jwk< json_traits >` - Retrieves a JWK claim.
*   **get_key_id()**: `jwt::header< json_traits >, jwt::jwk< json_traits >` - Retrieves the key ID.
*   **get_key_operations()**: `jwt::jwk< json_traits >` - Retrieves the key operations allowed for a JWK.
*   **get_key_type()**: `jwt::jwk< json_traits >` - Retrieves the type of the JWK (e.g., RSA, EC).
*   **get_not_before()**: `jwt::payload< json_traits >` - Retrieves the not before claim.
*   **get_payload()**: `jwt::decoded_jwt< json_traits >` - Retrieves the payload of a decoded JWT.
*   **get_payload_base64()**: `jwt::decoded_jwt< json_traits >` - Retrieves the base64 encoded payload of a decoded JWT.
*   **get_payload_claim()**: `jwt::decoded_jwt< json_traits >, jwt::payload< json_traits >` - Retrieves a specific claim from the payload.
*   **get_payload_json()**: `jwt::decoded_jwt< json_traits >` - Retrieves the payload as a JSON object.
*   **get_signature()**: `jwt::decoded_jwt< json_traits >` - Retrieves the signature of a decoded JWT.
*   **get_signature_base64()**: `jwt::decoded_jwt< json_traits >` - Retrieves the base64 encoded signature of a decoded JWT.
*   **get_subject()**: `jwt::payload< json_traits >` - Retrieves the subject claim.
*   **get_token()**: `jwt::decoded_jwt< json_traits >` - Retrieves the complete JWT string.
*   **get_type()**: `jwt::basic_claim< json_traits >, jwt::header< json_traits >` - Retrieves the type claim or header parameter.
*   **get_use()**: `jwt::jwk< json_traits >` - Retrieves the public key use for a JWK.
*   **get_x5c()**: `jwt::jwk< json_traits >` - Retrieves the X.509 certificate chain from a JWK.
*   **get_x5c_key_value()**: `jwt::jwk< json_traits >` - Retrieves the X.509 certificate chain as a key value.
*   **get_x5t()**: `jwt::jwk< json_traits >` - Retrieves the X.509 certificate thumbprint (SHA-1) from a JWK.
*   **get_x5t_sha256()**: `jwt::jwk< json_traits >` - Retrieves the X.509 certificate thumbprint (SHA-256) from a JWK.
*   **get_x5u()**: `jwt::jwk< json_traits >` - Retrieves the URI of the X.509 certificate chain from a JWK.
```

--------------------------------

### JWT-CPP Class Members

Source: https://thalhammer.github.io/jwt-cpp/functions.html

This section lists and describes various class members available in the JWT-CPP library, categorized by their starting letter.

```APIDOC
## JWT-CPP Class Members

This section provides a detailed list of class members within the JWT-CPP library.

### Class Members - a

*   **allow_algorithm()** : `jwt::verifier<Clock, json_traits>` - Allows specifying an algorithm for token verification.
*   **as_array()** : `jwt::basic_claim<json_traits>` - Converts a claim to an array type.
*   **as_boolean()** : `jwt::basic_claim<json_traits>` - Converts a claim to a boolean type.
*   **as_date()** : `jwt::basic_claim<json_traits>` - Converts a claim to a date type.
*   **as_integer()** : `jwt::basic_claim<json_traits>` - Converts a claim to an integer type.
*   **as_number()** : `jwt::basic_claim<json_traits>` - Converts a claim to a number type.
*   **as_set()** : `jwt::basic_claim<json_traits>` - Converts a claim to a set type.
*   **as_string()** : `jwt::basic_claim<json_traits>` - Converts a claim to a string type.

### Class Members - b

*   **builder()** : `jwt::builder<Clock, json_traits>` - Returns a builder object for constructing JWTs.

### Class Members - c

*   **claim_key** : `jwt::verify_ops::verify_context<json_traits>` - The key used for claim verification.
*   **current_time** : `jwt::verify_ops::verify_context<json_traits>` - The current time used for time-based claim validation.

### Class Members - d

*   **decoded_jwt()** : `jwt::decoded_jwt<json_traits>` - Represents a decoded JWT.
*   **default_leeway** : `jwt::verify_ops::verify_context<json_traits>` - The default leeway in seconds for time-based claim validation.

### Class Members - e

*   **ecdsa()** : `jwt::algorithm::ecdsa` - Represents the ECDSA algorithm.
*   **ed25519()** : `jwt::algorithm::ed25519` - Represents the Ed25519 algorithm.
*   **ed448()** : `jwt::algorithm::ed448` - Represents the Ed448 algorithm.
*   **eddsa()** : `jwt::algorithm::eddsa` - Represents the EdDSA algorithm.
*   **empty()** : `jwt::jwk<json_traits>` - Checks if a JWK is empty.
*   **es256()** : `jwt::algorithm::es256` - Represents the ES256 algorithm.
*   **es256k()** : `jwt::algorithm::es256k` - Represents the ES256K algorithm.
*   **es384()** : `jwt::algorithm::es384` - Represents the ES384 algorithm.
*   **es512()** : `jwt::algorithm::es512` - Represents the ES512 algorithm.
*   **evp_pkey_handle()** : `jwt::helper::evp_pkey_handle` - A handle for EVP private key operations.
*   **expires_at_leeway()** : `jwt::verifier<Clock, json_traits>` - Sets the leeway for the 'exp' claim validation.

### Class Members - g

*   **get_algorithm()** : `jwt::header<json_traits>`, `jwt::jwk<json_traits>` - Retrieves the algorithm used.
*   **get_audience()** : `jwt::payload<json_traits>` - Retrieves the audience claim.
*   **get_claim()** : `jwt::verify_ops::verify_context<json_traits>` - Retrieves a specific claim from the verification context.
*   **get_claims()** : `jwt::jwk<json_traits>` - Retrieves all claims from a JWK.
*   **get_content_type()** : `jwt::header<json_traits>` - Retrieves the content type header.
*   **get_curve()** : `jwt::jwk<json_traits>` - Retrieves the curve name for elliptic curve keys.
*   **get_expires_at()** : `jwt::payload<json_traits>` - Retrieves the expiration time claim.
*   **get_header()** : `jwt::decoded_jwt<json_traits>` - Retrieves the header of a decoded JWT.
*   **get_header_base64()** : `jwt::decoded_jwt<json_traits>` - Retrieves the base64 encoded header of a decoded JWT.
*   **get_header_claim()** : `jwt::decoded_jwt<json_traits>`, `jwt::header<json_traits>` - Retrieves a specific claim from the header.
*   **get_header_json()** : `jwt::decoded_jwt<json_traits>` - Retrieves the header as a JSON object.
*   **get_id()** : `jwt::payload<json_traits>` - Retrieves the JWT ID claim.
*   **get_issued_at()** : `jwt::payload<json_traits>` - Retrieves the issued at claim.
*   **get_issuer()** : `jwt::payload<json_traits>` - Retrieves the issuer claim.
*   **get_jwk()** : `jwt::jwks<json_traits>` - Retrieves a JWK from a JWKS set.
*   **get_jwk_claim()** : `jwt::jwk<json_traits>` - Retrieves a JWK claim.
*   **get_key_id()** : `jwt::header<json_traits>`, `jwt::jwk<json_traits>` - Retrieves the key ID.
*   **get_key_operations()** : `jwt::jwk<json_traits>` - Retrieves the key operations allowed for a JWK.
*   **get_key_type()** : `jwt::jwk<json_traits>` - Retrieves the type of the key (e.g., 'RSA', 'EC').
*   **get_not_before()** : `jwt::payload<json_traits>` - Retrieves the not before claim.
*   **get_payload()** : `jwt::decoded_jwt<json_traits>` - Retrieves the payload of a decoded JWT.
*   **get_payload_base64()** : `jwt::decoded_jwt<json_traits>` - Retrieves the base64 encoded payload of a decoded JWT.
*   **get_payload_claim()** : `jwt::decoded_jwt<json_traits>`, `jwt::payload<json_traits>` - Retrieves a specific claim from the payload.
*   **get_payload_json()** : `jwt::decoded_jwt<json_traits>` - Retrieves the payload as a JSON object.
*   **get_signature()** : `jwt::decoded_jwt<json_traits>` - Retrieves the signature of a decoded JWT.
*   **get_signature_base64()** : `jwt::decoded_jwt<json_traits>` - Retrieves the base64 encoded signature of a decoded JWT.
*   **get_subject()** : `jwt::payload<json_traits>` - Retrieves the subject claim.
*   **get_token()** : `jwt::decoded_jwt<json_traits>` - Retrieves the raw JWT string.
*   **get_type()** : `jwt::basic_claim<json_traits>`, `jwt::header<json_traits>` - Retrieves the type claim or header parameter.
*   **get_use()** : `jwt::jwk<json_traits>` - Retrieves the public key use for a JWK.
*   **get_x5c()** : `jwt::jwk<json_traits>` - Retrieves the X.509 certificate chain.
*   **get_x5c_key_value()** : `jwt::jwk<json_traits>` - Retrieves the X.509 certificate chain as key values.
*   **get_x5t()** : `jwt::jwk<json_traits>` - Retrieves the X.509 certificate SHA-1 thumbprint.
*   **get_x5t_sha256()** : `jwt::jwk<json_traits>` - Retrieves the X.509 certificate SHA-256 thumbprint.
*   **get_x5u()** : `jwt::jwk<json_traits>` - Retrieves the URI of the X.509 certificate chain.
```

--------------------------------

### Basic Claim Type and Value Retrieval

Source: https://thalhammer.github.io/jwt-cpp/classjwt_1_1basic__claim.html

Methods for getting the type of the JSON value and retrieving the underlying JSON value.

```APIDOC
## get_type()

### Description
Get type of contained JSON value.

### Method
`json::type get_type() const`

### Returns
`Type`

### Exceptions
`std::logic_error` - An internal error occurred

## to_json()

### Description
Get wrapped JSON value.

### Method
`json_traits::value_type to_json() const`

### Returns
`Wrapped JSON value`
```

--------------------------------

### Custom Signature Algorithms

Source: https://thalhammer.github.io/jwt-cpp/md_docs_2signing.html

Demonstrates how to implement and use custom signature algorithms with JWT-CPP.

```APIDOC
## Custom Signature Algorithms

The library's design is open, allowing for the implementation of custom signature algorithms. Refer to existing implementations for guidance.

### Example Custom Algorithm Structure

```cpp
struct your_algorithm{
std::string sign(const std::string& /*unused*/, std::error_code& ec) const {
  ec.clear();
  // CALL YOUR METHOD HERE
  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; }
  // CALL YOUR METHOD HERE
}

std::string name() const { return "your_algorithm"; }
};
```

### Usage Example

```cpp
auto token = jwt::create()
  .set_id("custom-algo-example")
  .set_issued_now()
  .set_expires_in(std::chrono::seconds{36000})
  .set_payload_claim("sample", jwt::claim(std::string{"test"}))
  .sign(your_algorithm{/* what ever you want */});
```
```

--------------------------------

### Select JSON Traits and Create/Decode/Verify JWT

Source: https://thalhammer.github.io/jwt-cpp/md_docs_2traits.html

Demonstrates selecting a JSON traits implementation (nlohmann_json) and using it to create, decode, and verify a JWT. Ensure the necessary headers are included.

```cpp
#include "jwt-cpp/traits/nlohmann-json/traits.h"
// There is also a "defaults.h" if you's like to skip providing the
// template specializations for the JSON traits
int main() {
// All the provided traits are in jwt::traits namespace
using traits = jwt::traits::nlohmann_json;
const auto time = jwt::date::clock::now();
const auto token = jwt::create<traits>()
.set_type("JWT")
.set_issuer("auth.mydomain.io")
.set_audience("mydomain.io")
.set_issued_at(time)
.set_not_before(time)
.set_expires_at(time + std::chrono::minutes{2} + std::chrono::seconds{15})
.sign(jwt::algorithm::none{});
const auto decoded = jwt::decode<traits>(token);
jwt::verify<traits>()
.allow_algorithm(jwt::algorithm::none{})
.with_issuer("auth.mydomain.io")
.with_audience("mydomain.io")
.verify(decoded);
}
```

--------------------------------

### Configure JWT-CPP with wolfSSL

Source: https://thalhammer.github.io/jwt-cpp/md_docs_2ssl.html

Use this command to configure the build system to use wolfSSL as the cryptography library for JWT-CPP. Ensure only one SSL library is included during compilation to avoid linking errors.

```bash
cmake . -DJWT_SSL_LIBRARY:STRING=wolfSSL
```

--------------------------------

### Create a Token with a Custom Algorithm

Source: https://thalhammer.github.io/jwt-cpp/md_docs_2signing.html

Pass an instance of the custom algorithm implementation to the sign method when building a token.

```cpp
auto token = jwt::create()
.set_id("custom-algo-example")
.set_issued_now()
.set_expires_in(std::chrono::seconds{36000})
.set_payload_claim("sample", jwt::claim(std::string{"test"}))
.sign(your_algorithm{/* what ever you want */});
```

--------------------------------

### CMake Integration with FetchContent

Source: https://thalhammer.github.io/jwt-cpp/md_docs_2install.html

Alternative CMake integration using FetchContent to pull the JWT-CPP repository directly into your build tree. This method requires setting JWT_BUILD_EXAMPLES to OFF.

```cmake
include(FetchContent)
fetchcontent_declare(jwt-cpp 
GIT_REPOSITORY https://github.com/Thalhammer/jwt-cpp.git
GIT_TAG 08bcf77a687fb06e34138e9e9fa12a4ecbe12332 # v0.7.0 release
)
set(JWT_BUILD_EXAMPLES OFF CACHE BOOL "disable building examples" FORCE)
fetchcontent_makeavailable(jwt-cpp)
target_link_libraries(my_app PRIVATE jwt-cpp::jwt-cpp)
```

--------------------------------

### Create a JWT with expiration

Source: https://thalhammer.github.io/jwt-cpp/md_docs_2faqs.html

Demonstrates how to generate a token that expires one hour after issuance using the HS256 algorithm.

```cpp
auto token = jwt::create()
.set_issued_now()
.set_expires_in(std::chrono::seconds{3600})
.sign(jwt::algorithm::hs256{"secret"});
```

--------------------------------

### jwt::create()

Source: https://thalhammer.github.io/jwt-cpp/namespacejwt.html

Functions to initialize a builder for creating new JWT tokens.

```APIDOC
## jwt::create()

### Description
Creates a builder instance used to construct a new JWT token.

### Parameters
#### Arguments
- **c** (Clock) - Optional - Clock instance to use for token creation. Defaults to default_clock.

### Response
- **builder** (Object) - Returns a builder instance for token construction.
```

--------------------------------

### JWT-CPP Library Overview

Source: https://thalhammer.github.io/jwt-cpp/pages.html

This section provides an overview of the JWT-CPP library and its documentation structure.

```APIDOC
## JWT-CPP Library

JWT-CPP is a header-only library for creating and validating JSON Web Tokens (JWT) in C++.

### Documentation Sections

- **Main Page**: General information about the library.
- **Frequently Asked Questions**: Answers to common questions.
- **Installation**: Instructions on how to install the library.
- **Signing Tokens**: Details on how to sign JWTs.
- **Cryptography Libraries**: Information on supported cryptography libraries.
- **JSON Traits**: Explanation of JSON traits used by the library.
- **Reporting Security Issues**: How to report security vulnerabilities.
- **Deprecated List**: List of deprecated features.
- **Namespaces**: Documentation for namespaces.
- **Classes**: Documentation for classes.
- **Files**: Documentation for files.
```

--------------------------------

### Implement a Custom Signature Algorithm

Source: https://thalhammer.github.io/jwt-cpp/md_docs_2signing.html

Define a struct with sign, verify, and name methods to integrate a custom algorithm into the library.

```cpp
struct your_algorithm{
std::string sign(const std::string& /*unused*/, std::error_code& ec) const {
ec.clear();
// CALL YOUR METHOD HERE
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; }
// CALL YOUR METHOD HERE
}
std::string name() const { return "your_algorithm"; };
```

--------------------------------

### JWT-CPP - Signing Tokens

Source: https://thalhammer.github.io/jwt-cpp/pages.html

This section details how to sign JSON Web Tokens (JWT) using the JWT-CPP library.

```APIDOC
## Signing Tokens

This section explains the process of signing JWTs with JWT-CPP. It covers the necessary steps and considerations for secure token generation.

### Key Concepts

- **Payload**: The data to be included in the token.
- **Secret Key**: The key used for signing the token.
- **Algorithm**: The signing algorithm to be used (e.g., HS256, RS256).

### Usage Example (Conceptual)

```cpp
#include "jwt-cpp/jwt.h"

// Assume payload and secret_key are defined
auto token = jwt::create()
    .set_payload({ {"some", "payload"} })
    .sign(jwt::algorithm::hs256("your-secret-key"));

// 'token' now holds the signed JWT string
```

### Supported Algorithms

JWT-CPP supports various signing algorithms, including but not limited to:

- HS256
- RS256
- ES256

Refer to the 'Cryptography Libraries' section for more details on cryptographic backends.
```

--------------------------------

### JWT Verification Utilities (JSONCPP)

Source: https://thalhammer.github.io/jwt-cpp/hierarchy.html

Explains the verification context and verifier class when using JSONCPP traits.

```APIDOC
## JWT Verification Utilities (JSONCPP)

### Description
This section details the JWT verifier and verification context classes when `jwt-cpp` is configured to use `jsoncpp` for JSON handling.

### Classes

- `Cjwt::verifier< Clock, json_traits >`
  - A generic verifier class templated on a clock type and JSON traits. When `json_traits` is `Cjwt::traits::open_source_parsers_jsoncpp`, this class is configured for JSONCPP.

- `Cjwt::verify_ops::verify_context< json_traits >`
  - Represents the context for JWT verification operations. When `json_traits` is `Cjwt::traits::open_source_parsers_jsoncpp`, this context is tailored for JSONCPP.
```

--------------------------------

### JWT-CPP HS256 Algorithm

Source: https://thalhammer.github.io/jwt-cpp/structjwt_1_1algorithm_1_1hs256.html

Documentation for the HS256 algorithm, including its constructor, signing, and verification functionalities.

```APIDOC
## jwt::algorithm::hs256

### Description
HS256 algorithm implementation for signing and verifying JWTs using HMAC-SHA256.

### Constructor
```cpp
jwt::algorithm::hs256(std::string key)
```

**Description:** Constructs a new instance of the HS256 algorithm.

**Parameters:**
- **key** (std::string) - The HMAC signing key.

### Member Functions

#### sign
```cpp
std::string sign(const std::string &data, std::error_code &ec) const
```

**Description:** Signs the given data using the HS256 algorithm.

**Parameters:**
- **data** (const std::string &) - The data to sign.
- **ec** (std::error_code &) - An error code to report any errors.

**Returns:** The generated signature as a std::string.

#### verify
```cpp
void verify(const std::string &data, const std::string &signature, std::error_code &ec) const
```

**Description:** Verifies the given signature against the data using the HS256 algorithm.

**Parameters:**
- **data** (const std::string &) - The data to verify.
- **signature** (const std::string &) - The signature to verify.
- **ec** (std::error_code &) - An error code to report any errors.

#### name
```cpp
std::string name() const
```

**Description:** Returns the name of the algorithm.

**Returns:** The algorithm name as a std::string (e.g., "HS256").
```

--------------------------------

### Verify JWT

Source: https://thalhammer.github.io/jwt-cpp/namespacejwt.html

Verifies a JWT token using the default clock and boost_json.

```cpp
verifier< default_clock, traits::boost_json > | verify ()
```

```cpp
template<typename Clock, typename json_traits>
verifier< Clock, json_traits > | verify (Clock c)
```

```cpp
template<typename json_traits>
verifier< default_clock, json_traits > | verify (default_clock c={})
```

--------------------------------

### Supported Version

Source: https://thalhammer.github.io/jwt-cpp/md__8github_2security.html

Information regarding the versioning and patching policy for JWT-CPP.

```APIDOC
## Supported Version

Typically, fixes will be immediately released as a new patch release. However, older affected versions may receive a new patch upon request.
```

--------------------------------

### jwt::create

Source: https://thalhammer.github.io/jwt-cpp/index.html

Creates a builder object to construct and sign new JSON Web Tokens.

```APIDOC
## jwt::create

### Description
Initializes a builder instance to construct a new JWT. Supports setting headers, payload claims, and signing the token.

### Methods
- **set_type(string)** - Sets the 'typ' header.
- **set_issuer(string)** - Sets the 'iss' claim.
- **set_payload_claim(string, claim)** - Adds a custom claim to the payload.
- **sign(algorithm)** - Signs the token using the provided cryptographic algorithm and returns the final JWT string.
```

--------------------------------

### Provide Custom JSON Traits

Source: https://thalhammer.github.io/jwt-cpp/index.html

Instantiate a jwt::basic_claim with custom JSON traits for your preferred JSON library. This allows for flexible JSON handling within the jwt-cpp framework.

```cpp
jwt::basic_claim<my_favorite_json_library_traits> claim(json::object({{"json", true},{"example", 0}}));
```

--------------------------------

### Create JWT Builder

Source: https://thalhammer.github.io/jwt-cpp/namespacejwt.html

Creates a builder instance to construct a new JWT. This overload uses the default clock and reflectcpp_json.

```cpp
template<typename Clock, typename json_traits>
builder< Clock, json_traits > | create (Clock c)
```

```cpp
template<typename json_traits>
builder< default_clock, json_traits > | create (default_clock c={})
```

```cpp
builder< default_clock, traits::boost_json > | create ()
```

```cpp
template<typename json_traits>
builder< default_clock, json_traits > jwt::create  | ( | default_clock | _c_ = {}| ) |   
```

```cpp
template<typename Clock, typename json_traits>
builder< Clock, json_traits > jwt::create  | ( | Clock | _c_| ) |   
Create a builder using the given clock 
Parameters
     c| Clock instance to use   
Returns
    builder instance   
```

```cpp
| builder< default_clock, traits::reflectcpp_json > jwt::create  | ( | __| ) |   
inline  
Create a builder using the default clock 
Returns
    builder instance to create a new token 
```

--------------------------------

### Basic Claim Serialization and Deserialization

Source: https://thalhammer.github.io/jwt-cpp/classjwt_1_1basic__claim.html

Methods for serializing a claim to an output stream and parsing a claim from an input stream.

```APIDOC
## operator<<()

### Description
Serialize claim to output stream from wrapped JSON value.

### Method
`std::ostream & operator<<(std::ostream & _os)`

### Returns
`output stream`

## operator>>()

### Description
Parse input stream into underlying JSON value.

### Method
`std::istream & operator>>(std::istream & _is)`

### Returns
`input stream`
```

--------------------------------

### Classes

Source: https://thalhammer.github.io/jwt-cpp/namespacejwt.html

The JWT-CPP library provides several classes for managing JWTs, their headers, payloads, and keys.

```APIDOC
## Classes

### `basic_claim`
A class to store a generic JSON value as a claim.

### `builder`
Used for constructing JWTs.

### `decoded_jwt`
Represents a decoded JWT.

### `default_clock`
A struct providing a default clock implementation.

### `header`
Represents the header of a JWT.

### `jwk`
JSON Web Key. Used for representing cryptographic keys.

### `jwks`
JWK Set. Used for representing a collection of JWKs.

### `payload`
Represents the payload of a JWT.

### `verifier`
Used for verifying JWTs.
```

--------------------------------

### Library Namespaces Overview

Source: https://thalhammer.github.io/jwt-cpp/namespaces.html

Overview of the core namespaces provided by the jwt-cpp library for token management and cryptography.

```APIDOC
## Namespaces Overview

### Description
The library is organized into several namespaces to handle specific aspects of JWT processing.

### Namespaces
- **jwt** - Core functionality for JSON Web Tokens.
- **algorithm** - Cryptographic algorithms used for signing and verification.
- **alphabet** - Character maps for encoding and decoding operations.
- **base** - Utility functions for base64 and base64url operations.
- **error** - Error codes and handling mechanisms.
- **helper** - Certificate management utilities.
- **json** - JSON abstractions for library-agnostic JSON handling.
- **traits** - JSON trait implementations for jwt::basic_claim.
```

--------------------------------

### JWT Creation and Verification

Source: https://thalhammer.github.io/jwt-cpp/md_docs_2signing.html

Core functions for creating and verifying JWTs using JWT-CPP.

```APIDOC
## JWT Creation and Verification

### `jwt::verify`

**Definition**: jwt.h:4164

This function is used for verifying JWTs. It takes a clock type as a parameter.

```cpp
verifier< Clock, json_traits > verify(Clock c)
```

### `jwt::create`

**Definition**: defaults.h:31

This function is used for creating JWTs. It returns a builder with default clock and JSON traits.

```cpp
builder< default_clock, traits::boost_json > create()
```

### `jwt::claim`

**Definition**: defaults.h:17

A class to store a generic Boost.JSON value as a claim.

```cpp
basic_claim< traits::boost_json > claim
```
```

--------------------------------

### Reporting Security Issues

Source: https://thalhammer.github.io/jwt-cpp/md__8github_2security.html

Instructions on how to report security vulnerabilities found in the JWT-CPP library.

```APIDOC
## Reporting Security Issues

If you believe you have found a security vulnerability in JWT-CPP, we encourage you to let us know right away. We will investigate all legitimate reports and do our best to quickly fix the problem.

Please provide as many details as possible about version, platform, and workflow as possible. Having steps and reproducible code is better and is always greatly appreciated.

### Contact

Please contact one or more of the maintainers using the email advertised on their GitHub profiles:

* @Thalhammer
* @prince-chrismc

### Disclosure Policy

Please refer to the section below for our responsible disclosure policy.
```

--------------------------------

### Create and Sign JWT

Source: https://thalhammer.github.io/jwt-cpp/index.html

Creates a new JWT with specified type, issuer, and payload claim, then signs it using the HS256 algorithm with a secret key.

```cpp
auto token = jwt::create()
.set_type("JWS")
.set_issuer("auth0")
.set_payload_claim("sample", jwt::claim(std::string("test")))
.sign(jwt::algorithm::hs256{"secret"});
```

--------------------------------

### Namespaces

Source: https://thalhammer.github.io/jwt-cpp/namespacejwt.html

The JWT-CPP library is organized into several namespaces, each serving a specific purpose.

```APIDOC
## Namespaces

### `algorithm`
Various cryptographic algorithms when working with JWT.

### `alphabet`
Character maps when encoding and decoding.

### `base`
A collection of functions for working with base64 and base64url.

### `error`
Everything related to error codes issued by the library.

### `helper`
A collection for working with certificates.

### `json`
JSON Abstractions for working with any library.

### `traits`
Namespace containing all the `json_trait` implementations for a `jwt::basic_claim`.
```

--------------------------------

### Cryptographic Helper Functions

Source: https://thalhammer.github.io/jwt-cpp/namespacemembers.html

Utility functions for handling keys and cryptographic conversions.

```APIDOC
## jwt::helper::load_private_key_from_string()

### Description
Loads a private key from a string representation.

## jwt::helper::load_public_key_from_string()

### Description
Loads a public key from a string representation.

## jwt::helper::convert_der_to_pem()

### Description
Converts a key from DER format to PEM format.

## jwt::helper::extract_pubkey_from_cert()

### Description
Extracts a public key from a certificate string.
```

--------------------------------

### jwt::verify

Source: https://thalhammer.github.io/jwt-cpp/index.html

Creates a verifier object to validate the authenticity and claims of a decoded JWT.

```APIDOC
## jwt::verify

### Description
Initializes a verifier instance used to validate tokens against specific criteria such as issuer, claims, and cryptographic algorithms.

### Methods
- **with_issuer(string)** - Sets the expected issuer claim.
- **with_claim(string, claim)** - Sets a required claim and its expected value.
- **allow_algorithm(algorithm)** - Specifies the allowed cryptographic algorithm for verification.
- **verify(decoded_jwt)** - Executes the verification process against a decoded token.
```

--------------------------------

### JWT Verify Builder

Source: https://thalhammer.github.io/jwt-cpp/md_docs_2traits.html

Function signature for the JWT verify builder, used for setting up verification parameters with specified traits and clock.

```cpp
jwt::verify
verifier< default_clock, traits::boost_json > verify()
```

--------------------------------

### Loading Private EC Keys

Source: https://thalhammer.github.io/jwt-cpp/deprecated.html

Functions for loading private Elliptic Curve (EC) keys from a string, with and without an error code parameter, and with optional password protection.

```APIDOC
## Load Private EC Key from String

### Description
Loads a private Elliptic Curve (EC) key from a string. This function is a wrapper around a templated version and is intended for use with `error::ecdsa_error`.

### Method
Not applicable (C++ function)

### Endpoint
Not applicable (C++ function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```cpp
// Example usage (conceptual)
std::string privateKeyString = "-----BEGIN EC PRIVATE KEY-----\n...\n-----END EC PRIVATE KEY-----";
std::string password = "mysecretpassword";
std::error_code ec;
auto key = jwt::helper::load_private_ec_key_from_string(privateKeyString, password, ec);
```

### Response
#### Success Response (200)
Not applicable (C++ function returns a key object or throws)

#### Response Example
```cpp
// Example return value (conceptual)
// auto key object representing the loaded private key
```

## Load Private EC Key from String (No Error Code)

### Description
Loads a private Elliptic Curve (EC) key from a string without an explicit error code parameter. This overload defaults to an empty password and is a wrapper around a templated version for use with `error::ecdsa_error`.

### Method
Not applicable (C++ function)

### Endpoint
Not applicable (C++ function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```cpp
// Example usage (conceptual)
std::string privateKeyString = "-----BEGIN EC PRIVATE KEY-----\n...\n-----END EC PRIVATE KEY-----";
auto key = jwt::helper::load_private_ec_key_from_string(privateKeyString);
```

### Response
#### Success Response (200)
Not applicable (C++ function returns a key object or throws)

#### Response Example
```cpp
// Example return value (conceptual)
// auto key object representing the loaded private key
```
```

--------------------------------

### JWT-CPP Library Members

Source: https://thalhammer.github.io/jwt-cpp/functions_vars.html

This section lists the documented variables within the JWT-CPP library, along with their associated class documentation.

```APIDOC
## JWT-CPP Library Variables

### Description
This section lists the documented variables within the JWT-CPP library, along with their associated class documentation.

### Variables
- **claim_key** (jwt::verify_ops::verify_context< json_traits >) - Description not available
- **current_time** (jwt::verify_ops::verify_context< json_traits >) - Description not available
- **default_leeway** (jwt::verify_ops::verify_context< json_traits >) - Description not available
- **header** (jwt::decoded_jwt< json_traits >) - Description not available
- **header_base64** (jwt::decoded_jwt< json_traits >) - Description not available
- **jwt** (jwt::verify_ops::verify_context< json_traits >) - Description not available
- **payload** (jwt::decoded_jwt< json_traits >) - Description not available
- **payload_base64** (jwt::decoded_jwt< json_traits >) - Description not available
- **signature** (jwt::decoded_jwt< json_traits >) - Description not available
- **signature_base64** (jwt::decoded_jwt< json_traits >) - Description not available
- **token** (jwt::decoded_jwt< json_traits >) - Description not available
```

--------------------------------

### JWT-CPP basic_claim Class

Source: https://thalhammer.github.io/jwt-cpp/classjwt_1_1basic__claim.html

Documentation for the jwt::basic_claim class, which stores a generic JSON value as a claim. It supports various data types and conversions.

```APIDOC
## Class jwt::basic_claim<json_traits>

A class to store a generic JSON value as claim.

Template Parameters:
* json_traits: JSON implementation traits.

See also:
* RFC 7519: JSON Web Token (JWT)

### Member Typedef Documentation

#### ◆ set_t

```cpp
template<typename json_traits>
using jwt::basic_claim< json_traits >::set_t = std::set<typename json_traits::string_type>;
```

Order list of strings.

### Member Function Documentation

#### ◆ as_array()

```cpp
template<typename json_traits>
json_traits::array_type jwt::basic_claim< json_traits >::as_array() const;
```

Get the contained JSON value as an array.

Returns:
* content as array

Exceptions:
* std::bad_cast: Content was not an array.

#### ◆ as_boolean()

```cpp
template<typename json_traits>
json_traits::boolean_type jwt::basic_claim< json_traits >::as_boolean() const;
```

Get the contained JSON value as a bool.

Returns:
* content as bool

Exceptions:
* std::bad_cast: Content was not a bool.

#### ◆ as_date()

```cpp
template<typename json_traits>
date jwt::basic_claim< json_traits >::as_date() const;
```

Get the contained JSON value as a date. If the value is a decimal, it is rounded to the closest integer.

Returns:
* content as date

Exceptions:
* std::bad_cast: Content was not a date.
```

--------------------------------

### Loading Public EC Keys

Source: https://thalhammer.github.io/jwt-cpp/deprecated.html

Functions for loading public Elliptic Curve (EC) keys from a string, with and without an error code parameter, and with optional password protection.

```APIDOC
## Load Public EC Key from String

### Description
Loads a public Elliptic Curve (EC) key from a string. This function is a wrapper around a templated version and is intended for use with `error::ecdsa_error`.

### Method
Not applicable (C++ function)

### Endpoint
Not applicable (C++ function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```cpp
// Example usage (conceptual)
std::string publicKeyString = "-----BEGIN PUBLIC KEY-----\n...\n-----END PUBLIC KEY-----";
std::string password = "mysecretpassword"; // Typically not needed for public keys, but signature exists
std::error_code ec;
auto key = jwt::helper::load_public_ec_key_from_string(publicKeyString, password, ec);
```

### Response
#### Success Response (200)
Not applicable (C++ function returns a key object or throws)

#### Response Example
```cpp
// Example return value (conceptual)
// auto key object representing the loaded public key
```

## Load Public EC Key from String (No Error Code)

### Description
Loads a public Elliptic Curve (EC) key from a string without an explicit error code parameter. This overload defaults to an empty password and is a wrapper around a templated version for use with `error::ecdsa_error`.

### Method
Not applicable (C++ function)

### Endpoint
Not applicable (C++ function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```cpp
// Example usage (conceptual)
std::string publicKeyString = "-----BEGIN PUBLIC KEY-----\n...\n-----END PUBLIC KEY-----";
auto key = jwt::helper::load_public_ec_key_from_string(publicKeyString);
```

### Response
#### Success Response (200)
Not applicable (C++ function returns a key object or throws)

#### Response Example
```cpp
// Example return value (conceptual)
// auto key object representing the loaded public key
```
```

--------------------------------

### JWT-CPP Library Overview

Source: https://thalhammer.github.io/jwt-cpp/functions_type.html

JWT-CPP is a header-only C++ library for creating and validating JSON Web Tokens (JWT). It supports various cryptographic algorithms for signing and verification.

```APIDOC
## JWT-CPP Library Overview

### Description
JWT-CPP is a header-only C++ library designed for the creation and validation of JSON Web Tokens (JWT). It provides functionalities to encode, decode, and verify JWTs using various cryptographic algorithms.

### Key Features
- Header-only library for easy integration.
- Support for various signing algorithms (e.g., HS256, RS256).
- Token creation and validation capabilities.
- Customizable JSON traits for different JSON libraries.

### Installation
To use JWT-CPP, simply include the necessary header files in your C++ project. As it's header-only, no separate compilation or linking is typically required.

### Usage
Refer to the specific sections on Signing Tokens, Cryptography Libraries, and JSON Traits for detailed usage instructions.
```

--------------------------------

### JWT Algorithms

Source: https://thalhammer.github.io/jwt-cpp/functions.html

Functions for various JWT signing algorithms.

```APIDOC
## JWT Algorithms

### Description
Functions for various JWT signing algorithms.

### Methods
- `hmacsha()`
- `hs256()`
- `hs384()`
- `hs512()`
- `ps256()`
- `ps384()`
- `ps512()`
- `pss()`
- `rs256()`
- `rs384()`
- `rs512()`
- `rsa()`
- `name()`
- `sign()`
```

--------------------------------

### Decode JWT and Print Claims

Source: https://thalhammer.github.io/jwt-cpp/index.html

Decodes a JWT and prints its claims to standard output. Ensure the JWT is valid before decoding.

```cpp
#include <jwt-cpp/jwt.h>
#include <iostream>

int main() {
std::string const token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXUyJ9.eyJpc3MiOiJhdXRoMCIsInNhbXBsZSI6InRlc3QifQ.lQm3N2bVlqt2-1L-FsOjtR6uE-L4E9zJutMWKIe1v1M";
auto decoded = jwt::decode(token);
for(auto& e : decoded.get_payload_json())
std::cout << e.first << " = " << e.second << '\n';
}
```

--------------------------------

### JWT Create Builder

Source: https://thalhammer.github.io/jwt-cpp/md_docs_2traits.html

Function signature for the JWT create builder, used for constructing JWTs with specified traits and clock.

```cpp
jwt::create
builder< default_clock, traits::boost_json > create()
```

--------------------------------

### Parse JWK

Source: https://thalhammer.github.io/jwt-cpp/namespacejwt.html

Parses a JWK (JSON Web Key) string into a JWK object. This overload uses boost_json.

```cpp
template<typename json_traits>
jwk< json_traits > | parse_jwk (const typename json_traits::string_type &jwk_)
```

```cpp
jwk< traits::boost_json > | parse_jwk (const traits::boost_json::string_type &token)
```
Tokens:
Raw