jwt.h

Go to the documentation of this file.

/* Copyright (C) 2015-2024 maClara, LLC <info@maclara-llc.com>
   This file is part of the JWT C Library
 
   SPDX-License-Identifier:  MPL-2.0
   This Source Code Form is subject to the terms of the Mozilla Public
   License, v. 2.0. If a copy of the MPL was not distributed with this
   file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
#ifndef JWT_H
#define JWT_H
 
#include <stdio.h>
#include <time.h>
 
#ifdef _MSC_VER
 
    #define DEPR(__msg) __declspec(deprecated)
 
    #define alloca _alloca
    #define strcasecmp _stricmp
    #define strdup _strdup
 
    #ifdef JWT_DLL_CONFIG
        #ifdef JWT_BUILD_SHARED_LIBRARY
            #define JWT_EX __declspec(dllexport)
        #else
            #define JWT_EX __declspec(dllimport)
        #endif
    #else
        #define JWT_EX
    #endif
 
#else
 
    #define DEPR(__msg) [[deprecated(__msg)]]
    #define JWT_EX
 
#endif
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct jwt jwt_t;
 
typedef struct jwt_valid jwt_valid_t;
 
typedef struct jwk_set jwk_set_t;
 
typedef enum {
    JWT_ALG_NONE = 0,   
    JWT_ALG_HS256,      
    JWT_ALG_HS384,      
    JWT_ALG_HS512,      
    JWT_ALG_RS256,      
    JWT_ALG_RS384,      
    JWT_ALG_RS512,      
    JWT_ALG_ES256,      
    JWT_ALG_ES384,      
    JWT_ALG_ES512,      
    JWT_ALG_PS256,      
    JWT_ALG_PS384,      
    JWT_ALG_PS512,      
    JWT_ALG_ES256K,     
    JWT_ALG_EDDSA,      
    JWT_ALG_INVAL,      
} jwt_alg_t;
 
typedef enum {
    JWT_CRYPTO_OPS_NONE = 0,    
    JWT_CRYPTO_OPS_OPENSSL,     
    JWT_CRYPTO_OPS_GNUTLS,      
    JWT_CRYPTO_OPS_MBEDTLS,     
} jwt_crypto_provider_t;
 
typedef enum {
    JWK_KEY_TYPE_NONE = 0,      
    JWK_KEY_TYPE_EC,        
    JWK_KEY_TYPE_RSA,       
    JWK_KEY_TYPE_OKP,       
} jwk_key_type_t;
 
typedef enum {
    JWK_PUB_KEY_USE_NONE = 0,   
    JWK_PUB_KEY_USE_SIG,        
    JWK_PUB_KEY_USE_ENC,        
} jwk_pub_key_use_t;
 
typedef enum {
    JWK_KEY_OP_NONE     = 0x0000,   
    JWK_KEY_OP_SIGN     = 0x0001,   
    JWK_KEY_OP_VERIFY   = 0x0002,   
    JWK_KEY_OP_ENCRYPT  = 0x0004,   
    JWK_KEY_OP_DECRYPT  = 0x0008,   
    JWK_KEY_OP_WRAP     = 0x0010,   
    JWK_KEY_OP_UNWRAP   = 0x0020,   
    JWK_KEY_OP_DERIVE_KEY   = 0x0040,   
    JWK_KEY_OP_DERIVE_BITS  = 0x0080,   
    JWK_KEY_OP_INVALID  = 0xffff,   
} jwk_key_op_t;
 
typedef struct {
    jwk_key_type_t kty; 
    char *pem;      
    jwt_crypto_provider_t provider; 
    void *provider_data;    
    int is_private_key; 
    char curve[256];    
    size_t bits;        
    int error;      
    char error_msg[256];    
    jwk_pub_key_use_t use;  
    jwk_key_op_t key_ops;   
    jwt_alg_t alg;      
    char *kid;      
} jwk_item_t;
 
typedef enum {
    JWT_VALIDATION_SUCCESS      = 0x0000,   
    JWT_VALIDATION_ERROR        = 0x0001,   
    JWT_VALIDATION_ALG_MISMATCH = 0x0002,   
    JWT_VALIDATION_EXPIRED      = 0x0004,   
    JWT_VALIDATION_TOO_NEW      = 0x0008,   
    JWT_VALIDATION_ISS_MISMATCH = 0x0010,   
    JWT_VALIDATION_SUB_MISMATCH = 0x0020,   
    JWT_VALIDATION_AUD_MISMATCH = 0x0040,   
    JWT_VALIDATION_GRANT_MISSING    = 0x0080,   
    JWT_VALIDATION_GRANT_MISMATCH   = 0x0100,   
} jwt_valid_exception_t;
 
typedef void *(*jwt_malloc_t)(size_t);
 
typedef void *(*jwt_realloc_t)(void *, size_t);
 
typedef void (*jwt_free_t)(void *);
 
JWT_EX int jwt_new(jwt_t **jwt);
 
JWT_EX void jwt_free(jwt_t *jwt);
 
#if defined(__GNUC__) || defined(__clang__)
static inline void jwt_freep(jwt_t **jwt) {
    if (jwt) {
        jwt_free(*jwt);
        *jwt = NULL;
    }
}
#define jwt_auto_t jwt_t __attribute__((cleanup(jwt_freep)))
#endif
 
JWT_EX jwt_t *jwt_dup(jwt_t *jwt);
 
typedef struct {
    union {
        const void *key;    
        DEPR("use key") const void *jwt_key;
    };
    union {
        size_t key_len;     
        DEPR("use key_len") int jwt_key_len;
    };
    jwt_alg_t alg;          
    void *ctx;          
} jwt_config_t;
 
JWT_EX
void jwt_config_init(jwt_config_t *config);
 
#define JWT_CONFIG_DECLARE(__name) \
    jwt_config_t __name = { { NULL }, { 0 }, JWT_ALG_NONE, NULL}
 
typedef int (*jwt_callback_t)(const jwt_t *, jwt_config_t *);
 
#define jwt_key_p_t jwt_callback_t
 
#define jwt_key_t jwt_config_t
JWT_EX
int jwt_verify(jwt_t **jwt, const char *token, jwt_config_t *config);
 
JWT_EX
int jwt_verify_wcb(jwt_t **jwt, const char *token,
           jwt_config_t *config, jwt_callback_t cb);
 
JWT_EX DEPR("Migrate your code to jwt_verify()")
int jwt_decode(jwt_t **jwt, const char *token,
           const unsigned char *key, int key_len);
 
JWT_EX DEPR("Migriate your code to jwt_verify_wcb()")
int jwt_decode_2(jwt_t **jwt, const char *token,
         jwt_callback_t cb);
 
JWT_EX const char *jwt_get_grant(jwt_t *jwt, const char *grant);
 
JWT_EX long jwt_get_grant_int(jwt_t *jwt, const char *grant);
 
JWT_EX int jwt_get_grant_bool(jwt_t *jwt, const char *grant);
 
JWT_EX char *jwt_get_grants_json(jwt_t *jwt, const char *grant);
 
JWT_EX int jwt_add_grant(jwt_t *jwt, const char *grant, const char *val);
 
JWT_EX int jwt_add_grant_int(jwt_t *jwt, const char *grant, long val);
 
JWT_EX int jwt_add_grant_bool(jwt_t *jwt, const char *grant, int val);
 
JWT_EX int jwt_add_grants_json(jwt_t *jwt, const char *json);
 
JWT_EX int jwt_del_grants(jwt_t *jwt, const char *grant);
 
JWT_EX const char *jwt_get_header(jwt_t *jwt, const char *header);
 
JWT_EX long jwt_get_header_int(jwt_t *jwt, const char *header);
 
JWT_EX int jwt_get_header_bool(jwt_t *jwt, const char *header);
 
JWT_EX char *jwt_get_headers_json(jwt_t *jwt, const char *header);
 
JWT_EX int jwt_add_header(jwt_t *jwt, const char *header, const char *val);
 
JWT_EX int jwt_add_header_int(jwt_t *jwt, const char *header, long val);
 
JWT_EX int jwt_add_header_bool(jwt_t *jwt, const char *header, int val);
 
JWT_EX int jwt_add_headers_json(jwt_t *jwt, const char *json);
 
JWT_EX int jwt_del_headers(jwt_t *jwt, const char *header);
 
JWT_EX int jwt_dump_fp(jwt_t *jwt, FILE *fp, int pretty);
 
JWT_EX char *jwt_dump_str(jwt_t *jwt, int pretty);
 
JWT_EX char *jwt_dump_grants_str(jwt_t *jwt, int pretty);
 
JWT_EX int jwt_encode_fp(jwt_t *jwt, FILE *fp);
 
JWT_EX char *jwt_encode_str(jwt_t *jwt);
 
JWT_EX void jwt_free_str(char *str);
 
JWT_EX
int jwt_set_alg(jwt_t *jwt, jwt_alg_t alg, const unsigned char *key, int len);
 
JWT_EX jwt_alg_t jwt_get_alg(const jwt_t *jwt);
 
JWT_EX const char *jwt_alg_str(jwt_alg_t alg);
 
JWT_EX jwt_alg_t jwt_str_alg(const char *alg);
 
JWT_EX jwk_set_t *jwks_create(const char *jwk_json_str);
 
JWT_EX int jwks_item_add(jwk_set_t *jwk_set, jwk_item_t *item);
 
JWT_EX int jwks_error(jwk_set_t *jwk_set);
 
JWT_EX int jwks_error_any(jwk_set_t *jwk_set);
 
JWT_EX const char *jwks_error_msg(jwk_set_t *jwk_set);
 
JWT_EX jwk_item_t *jwks_item_get(jwk_set_t *jwk_set, size_t index);
 
JWT_EX void jwks_free(jwk_set_t *jwk_set);
 
JWT_EX int jwks_item_free(jwk_set_t *jwk_set, size_t index);
 
JWT_EX int jwks_item_free_all(jwk_set_t *jwk_set);
 
JWT_EX jwt_valid_exception_t jwt_validate(jwt_t *jwt, jwt_valid_t *jwt_valid);
 
JWT_EX int jwt_valid_new(jwt_valid_t **jwt_valid, jwt_alg_t alg);
 
JWT_EX void jwt_valid_free(jwt_valid_t *jwt_valid);
 
JWT_EX jwt_valid_exception_t jwt_valid_get_status(jwt_valid_t *jwt_valid);
 
JWT_EX time_t jwt_valid_get_nbf_leeway(jwt_valid_t *jwt_valid);
 
JWT_EX time_t jwt_valid_get_exp_leeway(jwt_valid_t *jwt_valid);
 
JWT_EX int jwt_valid_add_grant(jwt_valid_t *jwt_valid, const char *grant, const char *val);
 
JWT_EX const char *jwt_valid_get_grant(jwt_valid_t *jwt_valid, const char *grant);
 
JWT_EX int jwt_valid_add_grant_int(jwt_valid_t *jwt_valid, const char *grant, long val);
 
JWT_EX long jwt_valid_get_grant_int(jwt_valid_t *jwt_valid, const char *grant);
 
JWT_EX int jwt_valid_add_grant_bool(jwt_valid_t *jwt_valid, const char *grant, int val);
 
JWT_EX int jwt_valid_get_grant_bool(jwt_valid_t *jwt_valid, const char *grant);
 
JWT_EX int jwt_valid_add_grants_json(jwt_valid_t *jwt_valid, const char *json);
 
JWT_EX char* jwt_valid_get_grants_json(jwt_valid_t *jwt_valid, const char *grant);
 
JWT_EX int jwt_valid_del_grants(jwt_valid_t *jwt_valid, const char *grant);
 
JWT_EX int jwt_valid_set_now(jwt_valid_t *jwt_valid, const time_t now);
 
JWT_EX int jwt_valid_set_nbf_leeway(jwt_valid_t *jwt_valid, const time_t nbf_leeway);
 
JWT_EX int jwt_valid_set_exp_leeway(jwt_valid_t *jwt_valid, const time_t exp_leeway);
 
JWT_EX int jwt_valid_set_headers(jwt_valid_t *jwt_valid, int hdr);
 
JWT_EX char *jwt_exception_str(unsigned int exceptions);
 
JWT_EX int jwt_set_alloc(jwt_malloc_t pmalloc, jwt_realloc_t prealloc,
             jwt_free_t pfree);
 
JWT_EX void jwt_get_alloc(jwt_malloc_t *pmalloc, jwt_realloc_t *prealloc,
              jwt_free_t *pfree);
 
JWT_EX const char *jwt_get_crypto_ops(void);
 
JWT_EX jwt_crypto_provider_t jwt_get_crypto_ops_t(void);
 
JWT_EX int jwt_set_crypto_ops(const char *opname);
 
JWT_EX int jwt_set_crypto_ops_t(jwt_crypto_provider_t opname);
 
JWT_EX int jwt_crypto_ops_supports_jwk(void);
 
#ifdef __cplusplus
}
#endif
 
#endif /* JWT_H */