hitls_session.h

/*
 * This file is part of the openHiTLS project.
 *
 * openHiTLS is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
 * You may obtain a copy of Mulan PSL v2 at:
 *
 *     http://license.coscl.org.cn/MulanPSL2
 *
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 * See the Mulan PSL v2 for more details.
 */

 
#ifndef HITLS_SESSION_H
#define HITLS_SESSION_H
 
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include "hitls_type.h"
#include "hitls_crypt_type.h"
#include "bsl_uio.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define HITLS_SESSION_ID_CTX_MAX_SIZE 32u

#define HITLS_SESSION_ID_MAX_SIZE 32u

int32_t HITLS_CFG_SetSessionTicketSupport(HITLS_Config *config, bool support);

int32_t HITLS_CFG_GetSessionTicketSupport(const HITLS_Config *config, bool *isSupport);

int32_t HITLS_CFG_SetTicketNums(HITLS_Config *config, uint32_t ticketNums);

uint32_t HITLS_CFG_GetTicketNums(HITLS_Config *config);

int32_t HITLS_SetTicketNums(HITLS_Ctx *ctx, uint32_t ticketNums);

uint32_t HITLS_GetTicketNums(HITLS_Ctx *ctx);

typedef int32_t (*HITLS_NewSessionCb) (HITLS_Ctx *ctx, HITLS_Session *session);

typedef void (*HITLS_SessionRemoveCb)(HITLS_Config *config, HITLS_Session *sess);

typedef HITLS_Session *(*HITLS_SessionGetCb) (HITLS_Ctx *ctx, const uint8_t *data, int32_t len, int32_t *copy);

typedef int32_t (*HITLS_SessionTicketExtProcessCb)(HITLS_Ctx *ctx, const uint8_t *data, int32_t len, void *arg);

int32_t HITLS_CFG_SetNewSessionCb(HITLS_Config *config, const HITLS_NewSessionCb newSessionCb);

int32_t HITLS_CFG_SetSessionGetCb(HITLS_Config *config, const HITLS_SessionGetCb sessionGetCb);

int32_t HITLS_CFG_SetSessionRemoveCb(HITLS_Config *config, const HITLS_SessionRemoveCb sessionRemoveCb);

int32_t HITLS_SetSessionTicketExtProcessCb(HITLS_Ctx *ctx, const HITLS_SessionTicketExtProcessCb sessionTicketExtCb,
                                           void *arg);

int32_t HITLS_SetSessionTicketExtData(HITLS_Ctx *ctx, uint8_t *data, uint32_t dataSize);
 
#define HITLS_TICKET_KEY_RET_NEED_ALERT    (-1)   // callback fails. A fatal error occurs.
                                                  // You need to send an alert
#define HITLS_TICKET_KEY_RET_FAIL          0      // callback returns a failure, but the error is not a fatal error,
                                                  // for example, key_name matching fails.
#define HITLS_TICKET_KEY_RET_SUCCESS       1      // If the callback is successful,
                                                  // the key can be used for encryption and decryption
#define HITLS_TICKET_KEY_RET_SUCCESS_RENEW 2      // If the callback is successful, the key can be used for encryption
                                                  // and decryption. In the decryption scenario,
                                                  // the ticket needs to be renewed
typedef int32_t (*HITLS_TicketKeyCb)(uint8_t *keyName, uint32_t keyNameSize, HITLS_CipherParameters *cipher,
    uint8_t isEncrypt);

int32_t HITLS_CFG_SetTicketKeyCallback(HITLS_Config *config, HITLS_TicketKeyCb callback);

int32_t HITLS_CFG_GetSessionTicketKey(const HITLS_Config *config, uint8_t *key, uint32_t keySize, uint32_t *outSize);

int32_t HITLS_CFG_SetSessionTicketKey(HITLS_Config *config, const uint8_t *key, uint32_t keySize);

int32_t HITLS_CFG_SetSessionIdCtx(HITLS_Config *config, const uint8_t *sessionIdCtx, uint32_t len);

int32_t HITLS_CFG_SetSessionCacheMode(HITLS_Config *config, uint32_t mode);

int32_t HITLS_CFG_GetSessionCacheMode(HITLS_Config *config, uint32_t *mode);

int32_t HITLS_CFG_SetSessionCacheSize(HITLS_Config *config, uint32_t size);

int32_t HITLS_CFG_GetSessionCacheSize(HITLS_Config *config, uint32_t *size);

int32_t HITLS_CFG_SetSessionTimeout(HITLS_Config *config, uint64_t timeout);

int32_t HITLS_CFG_GetSessionTimeout(const HITLS_Config *config, uint64_t *timeout);

int32_t HITLS_IsSessionReused(HITLS_Ctx *ctx, bool *isReused);

int32_t HITLS_SetSessionIdCtx(HITLS_Ctx *ctx, const uint8_t *sessionIdCtx, uint32_t len);

int32_t HITLS_GetSessionTicketKey(const HITLS_Ctx *ctx, uint8_t *key, uint32_t keySize, uint32_t *outSize);

int32_t HITLS_SetSessionTicketKey(HITLS_Ctx *ctx, const uint8_t *key, uint32_t keySize);

int32_t HITLS_SetSession(HITLS_Ctx *ctx, HITLS_Session *session);

HITLS_Session *HITLS_GetSession(const HITLS_Ctx *ctx);

HITLS_Session *HITLS_GetDupSession(HITLS_Ctx *ctx);

HITLS_Session *HITLS_SESS_New(void);

HITLS_Session *HITLS_SESS_Dup(HITLS_Session *sess);

void HITLS_SESS_Free(HITLS_Session *sess);

int32_t HITLS_SESS_SetMasterKey(HITLS_Session *sess, const uint8_t *masterKey, uint32_t masterKeySize);

uint32_t HITLS_SESS_GetMasterKeyLen(const HITLS_Session *sess);

int32_t HITLS_SESS_GetMasterKey(const HITLS_Session *sess, uint8_t *masterKey, uint32_t *masterKeySize);

int32_t HITLS_SESS_GetProtocolVersion(const HITLS_Session *sess, uint16_t *version);

int32_t HITLS_SESS_SetProtocolVersion(HITLS_Session *sess, uint16_t version);

int32_t HITLS_SESS_SetCipherSuite(HITLS_Session *sess, uint16_t cipherSuite);

int32_t HITLS_SESS_GetCipherSuite(const HITLS_Session *sess, uint16_t *cipherSuite);

int32_t HITLS_SESS_SetSessionIdCtx(HITLS_Session *sess, uint8_t *sessionIdCtx, uint32_t sessionIdCtxSize);

int32_t HITLS_SESS_GetSessionIdCtx(const HITLS_Session *sess, uint8_t *sessionIdCtx, uint32_t *sessionIdCtxSize);

int32_t HITLS_SESS_SetSessionId(HITLS_Session *sess, uint8_t *sessionId, uint32_t sessionIdSize);

int32_t HITLS_SESS_GetSessionId(const HITLS_Session *sess, uint8_t *sessionId, uint32_t *sessionIdSize);

int32_t HITLS_SESS_SetHaveExtMasterSecret(HITLS_Session *sess, uint8_t haveExtMasterSecret);

int32_t HITLS_SESS_GetHaveExtMasterSecret(HITLS_Session *sess, bool *haveExtMasterSecret);

int32_t HITLS_SESS_SetTimeout(HITLS_Session *sess, uint64_t timeout);

uint64_t HITLS_SESS_GetTimeout(HITLS_Session *sess);

bool HITLS_SESS_IsResumable(const HITLS_Session *sess);

bool HITLS_SESS_HasTicket(const HITLS_Session *sess);

 
void *HITLS_SESS_GetUserData(const HITLS_Session *sess);

int32_t HITLS_SESS_SetUserData(HITLS_Session *sess, void *userData);
int32_t HITLS_CFG_ClearTimeoutSession(HITLS_Config *config, uint64_t nowTime);

int32_t HITLS_CFG_RemoveSession(HITLS_Config *config, HITLS_Session *sess);
#ifdef __cplusplus
}
#endif
 
#endif /* HITLS_SESSION_H */