hitls_session.h

浏览该文件的文档.

/*---------------------------------------------------------------------------------------------
 *  This file is part of the openHiTLS project.
 *  Copyright © 2023 Huawei Technologies Co.,Ltd. All rights reserved.
 *  Licensed under the openHiTLS Software license agreement 1.0. See LICENSE in the project root
 *  for license information.
 *---------------------------------------------------------------------------------------------
 */
 
#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, uint8_t *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);
 
int32_t HITLS_CFG_SetNewSessionCb(HITLS_Config *config, HITLS_NewSessionCb newSessionCb);
 
#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, HITLS_SESS_CACHE_MODE mode);
 
int32_t HITLS_CFG_GetSessionCacheMode(HITLS_Config *config, HITLS_SESS_CACHE_MODE *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, uint8_t *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(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, uint8_t *haveExtMasterSecret);
 
int32_t HITLS_SESS_SetTimeout(HITLS_Session *sess, uint64_t timeout);
 
bool HITLS_SESS_IsResumable(const HITLS_Session *sess);
 
bool HITLS_SESS_HasTicket(const HITLS_Session *sess);
 
#ifdef __cplusplus
}
#endif
 
#endif /* HITLS_SESSION_H */