crypt.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 CRYPT_H
#define CRYPT_H
 
#include <stdint.h>
#include "hitls_crypt_type.h"
#include "tls.h"
#include "hitls_crypt_reg.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* The maximum length of the RSA signature is 512. The maximum length of the ECC signature does not reach 1024. */
#define MAX_SIGN_SIZE 1024
 
/* Used to transfer key derivation parameters. */
typedef struct {
    HITLS_HashAlgo hashAlgo;    /* Hash algorithm */
    const uint8_t *secret;      /* Initialization key */
    uint32_t secretLen;         /* Key length */
    const uint8_t *label;       /* Label */
    uint32_t labelLen;          /* Label length */
    const uint8_t *seed;        /* Seed */
    uint32_t seedLen;           /* Seed length */
    HITLS_Lib_Ctx *libCtx;
    const char *attrName;
} CRYPT_KeyDeriveParameters;
 
enum HITLS_CryptoCallBack {
    HITLS_CRYPT_CALLBACK_RAND_BYTES = 0,
    HITLS_CRYPT_CALLBACK_HMAC_SIZE,
    HITLS_CRYPT_CALLBACK_HMAC_INIT,
    HITLS_CRYPT_CALLBACK_HMAC_FREE,
    HITLS_CRYPT_CALLBACK_HMAC_UPDATE,
    HITLS_CRYPT_CALLBACK_HMAC_FINAL,
    HITLS_CRYPT_CALLBACK_HMAC,
    HITLS_CRYPT_CALLBACK_DIGEST_SIZE,
    HITLS_CRYPT_CALLBACK_DIGEST_INIT,
    HITLS_CRYPT_CALLBACK_DIGEST_COPY,
    HITLS_CRYPT_CALLBACK_DIGEST_FREE,
    HITLS_CRYPT_CALLBACK_DIGEST_UPDATE,
    HITLS_CRYPT_CALLBACK_DIGEST_FINAL,
    HITLS_CRYPT_CALLBACK_DIGEST,
    HITLS_CRYPT_CALLBACK_ENCRYPT,
    HITLS_CRYPT_CALLBACK_DECRYPT,
 
    HITLS_CRYPT_CALLBACK_GENERATE_ECDH_KEY_PAIR,
    HITLS_CRYPT_CALLBACK_FREE_ECDH_KEY,
    HITLS_CRYPT_CALLBACK_GET_ECDH_ENCODED_PUBKEY,
    HITLS_CRYPT_CALLBACK_CALC_ECDH_SHARED_SECRET,
    HITLS_CRYPT_CALLBACK_SM2_CALC_ECDH_SHARED_SECRET,
 
    HITLS_CRYPT_CALLBACK_GENERATE_DH_KEY_BY_SECBITS,
    HITLS_CRYPT_CALLBACK_GENERATE_DH_KEY_BY_PARAMS,
    HITLS_CRYPT_CALLBACK_DUP_DH_KEY,
    HITLS_CRYPT_CALLBACK_FREE_DH_KEY,
    HITLS_CRYPT_CALLBACK_DH_GET_PARAMETERS,
    HITLS_CRYPT_CALLBACK_GET_DH_ENCODED_PUBKEY,
    HITLS_CRYPT_CALLBACK_CALC_DH_SHARED_SECRET,
 
    HITLS_CRYPT_CALLBACK_HKDF_EXTRACT,
    HITLS_CRYPT_CALLBACK_HKDF_EXPAND,
    HITLS_CRYPT_CALLBACK_KEM_ENCAPSULATE,
    HITLS_CRYPT_CALLBACK_KEM_DECAPSULATE,
};

int32_t SAL_CRYPT_Rand(HITLS_Lib_Ctx *libCtx, uint8_t *buf, uint32_t len);

uint32_t SAL_CRYPT_HmacSize(HITLS_HashAlgo hashAlgo);

HITLS_HMAC_Ctx *SAL_CRYPT_HmacInit(HITLS_Lib_Ctx *libCtx, const char *attrName,
    HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t len);

int32_t SAL_CRYPT_HmacReInit(HITLS_HMAC_Ctx *ctx);

void SAL_CRYPT_HmacFree(HITLS_HMAC_Ctx *hmac);

int32_t SAL_CRYPT_HmacUpdate(HITLS_HMAC_Ctx *hmac, const uint8_t *data, uint32_t len);

int32_t SAL_CRYPT_HmacFinal(HITLS_HMAC_Ctx *hmac, uint8_t *out, uint32_t *len);

int32_t SAL_CRYPT_Hmac(HITLS_Lib_Ctx *libCtx, const char *attrName,
    HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t keyLen,
    const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen);

int32_t SAL_CRYPT_PRF(CRYPT_KeyDeriveParameters *input, uint8_t *out, uint32_t outLen);

uint32_t SAL_CRYPT_DigestSize(HITLS_HashAlgo hashAlgo);

HITLS_HASH_Ctx *SAL_CRYPT_DigestInit(HITLS_Lib_Ctx *libCtx, const char *attrName, HITLS_HashAlgo hashAlgo);

HITLS_HASH_Ctx *SAL_CRYPT_DigestCopy(HITLS_HASH_Ctx *ctx);

void SAL_CRYPT_DigestFree(HITLS_HASH_Ctx *ctx);

int32_t SAL_CRYPT_DigestUpdate(HITLS_HASH_Ctx *ctx, const uint8_t *data, uint32_t len);

int32_t SAL_CRYPT_DigestFinal(HITLS_HASH_Ctx *ctx, uint8_t *out, uint32_t *len);

int32_t SAL_CRYPT_Digest(HITLS_Lib_Ctx *libCtx, const char *attrName,
    HITLS_HashAlgo hashAlgo, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen);

int32_t SAL_CRYPT_Encrypt(HITLS_Lib_Ctx *libCtx, const char *attrName,
    const HITLS_CipherParameters *cipher, const uint8_t *in, uint32_t inLen,
    uint8_t *out, uint32_t *outLen);

int32_t SAL_CRYPT_Decrypt(HITLS_Lib_Ctx *libCtx, const char *attrName,
    const HITLS_CipherParameters *cipher, const uint8_t *in, uint32_t inLen,
    uint8_t *out, uint32_t *outLen);

void SAL_CRYPT_CipherFree(HITLS_Cipher_Ctx *ctx);

HITLS_CRYPT_Key *SAL_CRYPT_GenEcdhKeyPair(TLS_Ctx *ctx, const HITLS_ECParameters *curveParams);

void SAL_CRYPT_FreeEcdhKey(HITLS_CRYPT_Key *key);

int32_t SAL_CRYPT_EncodeEcdhPubKey(HITLS_CRYPT_Key *key, uint8_t *pubKeyBuf, uint32_t bufLen, uint32_t *usedLen);

int32_t SAL_CRYPT_CalcEcdhSharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
    HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
    uint8_t *sharedSecret, uint32_t *sharedSecretLen);

int32_t SAL_CRYPT_CalcSm2dhSharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
    HITLS_Sm2GenShareKeyParameters *sm2ShareKeyParam, uint8_t *sharedSecret,
    uint32_t *sharedSecretLen);

HITLS_CRYPT_Key *SAL_CRYPT_GenerateDhKeyBySecbits(TLS_Ctx *ctx,
    int32_t secBits);

HITLS_CRYPT_Key *SAL_CRYPT_GenerateDhKeyByParams(HITLS_Lib_Ctx *libCtx,
    const char *attrName, uint8_t *p, uint16_t plen, uint8_t *g, uint16_t glen);

HITLS_CRYPT_Key *SAL_CRYPT_DupDhKey(HITLS_CRYPT_Key *key);

void SAL_CRYPT_FreeDhKey(HITLS_CRYPT_Key *key);

int32_t SAL_CRYPT_GetDhParameters(HITLS_CRYPT_Key *key, uint8_t *p, uint16_t *plen,
    uint8_t *g, uint16_t *glen);

int32_t SAL_CRYPT_EncodeDhPubKey(HITLS_CRYPT_Key *key, uint8_t *pubKeyBuf, uint32_t bufLen, uint32_t *usedLen);

int32_t SAL_CRYPT_CalcDhSharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
    HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
    uint8_t *sharedSecret, uint32_t *sharedSecretLen);

int32_t SAL_CRYPT_HkdfExtract(HITLS_Lib_Ctx *libCtx, const char *attrName,
    HITLS_CRYPT_HkdfExtractInput *input, uint8_t *prk, uint32_t *prkLen);

int32_t SAL_CRYPT_HkdfExpand(HITLS_Lib_Ctx *libCtx, const char *attrName,
    HITLS_CRYPT_HkdfExpandInput *input, uint8_t *okm, uint32_t okmLen);

int32_t SAL_CRYPT_HkdfExpandLabel(CRYPT_KeyDeriveParameters *deriveInfo,
    uint8_t *outSecret, uint32_t outLen);

int32_t SAL_CRYPT_KemEncapsulate(TLS_Ctx *ctx, HITLS_KemEncapsulateParams *params);

int32_t SAL_CRYPT_KemDecapsulate(HITLS_CRYPT_Key *key, const uint8_t *ciphertext, uint32_t ciphertextLen,
    uint8_t *sharedSecret, uint32_t *sharedSecretLen);
 
 
#ifdef __cplusplus
}
#endif
#endif