asym_crypt.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2024 Texas Instruments Incorporated
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef ASYM_CRYPT_H_
#define ASYM_CRYPT_H_
 
/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
 
#include <stdint.h>
#include <kernel/dpl/SystemP.h>
#include <security_common/drivers/crypto/crypto_util.h>
 
#if defined (SOC_AM64X) || defined (SOC_AM243X)\
    || defined(SOC_AM263X) || defined(SOC_AM263PX)\
    || defined (SOC_AM273X) || defined (SOC_AWR294X)
#include <security_common/drivers/crypto/pka/pka.h>
#endif
 
#if defined(SOC_F29H85X) || defined (SOC_AM261X) || defined(SOC_F29P32X)
#include <security_common/drivers/crypto/pke/hw_include/pke_hw/inc/pke.h>
#include <security_common/drivers/crypto/pke/hw_include/pke_hw/src/pke4_driver.h>
#include <security_common/drivers/crypto/pke/hw_include/pke_hw/inc/pke_dpasl.h>
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ========================================================================== */
/*                           Macros & Typedefs                                */
/* ========================================================================== */
 
typedef enum AsymCrypt_Return_e
{
    ASYM_CRYPT_RETURN_SUCCESS                  = 0xCEF6A572U, 
    ASYM_CRYPT_RETURN_FAILURE                  = 0xD20341DDU, 
}AsymCrypt_Return_t;
 
typedef enum AsymCrypt_EdCurve_e
{
    ASYM_CRYPT_CURVE_TYPE_EDDSA_25519          = 0xBE2479A0U, 
    ASYM_CRYPT_CURVE_TYPE_EDDSA_448            = 0x57138CAFU, 
}AsymCrypt_EdCurveType_t;
 
typedef void *AsymCrypt_Handle;
 
#define RSA_MAX_LENGTH                      (130U)
 
#define ECDSA_MAX_LENGTH                    (18U)
 
#define EC_PARAM_MAXLEN                    (68U)
 
#define ASYM_CRYPT_LEN(bytelen)             (((bytelen) / 4U) + 1U)
 
#define RSA_KEY_E_MAXLEN                    (8U)
 
#define RSA_KEY_N_MAXLEN                    (520U)
 
#define RSA_KEY_PQ_MAXLEN                   ((RSA_KEY_N_MAXLEN / 2U) + 4U)
 
#define RSA_SIG_MAXLEN                      (RSA_KEY_N_MAXLEN)
 
#define EDDSA_MAX_KEY_LEN                   (57U)
 
#define EDDSA_MAX_BIGINT_LEN                (ASYM_CRYPT_LEN(EDDSA_MAX_KEY_LEN - 1U))
 
#define EDDSA_ED25519_KEY_LEN              (32U)
 
#define EDDSA_ED448_KEY_LEN                (57U)
 
#define EDDSA_ED25519_HASH_LEN             (64U)
 
#define EDDSA_ED448_HASH_LEN               (114U)
 
#define DEVTYPE_HSSE         (0x0AU)
 
/* ========================================================================== */
/*                         Structure Declarations                             */
/* ========================================================================== */
 
struct AsymCrypt_RSAPubkey {
    uint32_t    n[ASYM_CRYPT_LEN(RSA_KEY_N_MAXLEN)];
    uint32_t    e[ASYM_CRYPT_LEN(RSA_KEY_E_MAXLEN)];
};
 
struct AsymCrypt_RSAPrivkey {
    uint32_t    n[ASYM_CRYPT_LEN(RSA_KEY_N_MAXLEN)];
    uint32_t    e[ASYM_CRYPT_LEN(RSA_KEY_E_MAXLEN)];
    uint32_t    d[ASYM_CRYPT_LEN(RSA_KEY_N_MAXLEN)];
    uint32_t    p[ASYM_CRYPT_LEN(RSA_KEY_PQ_MAXLEN)];
    uint32_t    q[ASYM_CRYPT_LEN(RSA_KEY_PQ_MAXLEN)];
    uint32_t    dp[ASYM_CRYPT_LEN(RSA_KEY_PQ_MAXLEN)];
    uint32_t    dq[ASYM_CRYPT_LEN(RSA_KEY_PQ_MAXLEN)];
    uint32_t    coefficient[ASYM_CRYPT_LEN(RSA_KEY_PQ_MAXLEN)];
};
 
struct AsymCrypt_ECPoint {
    uint32_t    x[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
    uint32_t    y[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
};
 
struct AsymCrypt_ECPrimeCurveP {
    uint32_t        prime[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
    uint32_t        order[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
    uint32_t        a[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
    uint32_t        b[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
    struct AsymCrypt_ECPoint g;
};
 
struct AsymCrypt_ECMontCurveP {
    uint32_t        prime[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
    uint32_t        order[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
    uint32_t        cofactor[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
    uint32_t        A[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
    uint32_t        B[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
    struct AsymCrypt_ECPoint g;
};
 
struct AsymCrypt_ECDSASig {
    uint32_t    r[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
    uint32_t    s[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
};
 
struct AsymCrypt_EddsaPoint {
    uint32_t    x[ASYM_CRYPT_LEN(EDDSA_MAX_KEY_LEN)];
    uint32_t    y[ASYM_CRYPT_LEN(EDDSA_MAX_KEY_LEN)];
};
 
struct AsymCrypt_EdCurveParam {
    uint32_t        prime[ASYM_CRYPT_LEN(EDDSA_MAX_KEY_LEN)];
    uint32_t        order[ASYM_CRYPT_LEN(EDDSA_MAX_KEY_LEN)];
    uint32_t        cofactor[ASYM_CRYPT_LEN(EDDSA_MAX_KEY_LEN)];
    uint32_t        a[ASYM_CRYPT_LEN(EDDSA_MAX_KEY_LEN)];
    uint32_t        d[ASYM_CRYPT_LEN(EDDSA_MAX_KEY_LEN)];
    struct AsymCrypt_EddsaPoint g;
};
 
struct AsymCrypt_EddsaSig {
    uint8_t    R[EDDSA_MAX_KEY_LEN];
    uint8_t    s[EDDSA_MAX_KEY_LEN];
};
 
struct AsymCrypt_EddsaKey{
    uint8_t    privKey[EDDSA_MAX_KEY_LEN];
    uint8_t    pubKey[EDDSA_MAX_KEY_LEN];
};
 
struct AsymCrypt_SM2DSASig {
    uint32_t    r[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
    uint32_t    s[ASYM_CRYPT_LEN(EC_PARAM_MAXLEN)];
};
 
/* ========================================================================== */
/*                            Global Variables                                */
/* ========================================================================== */
 
/* ========================================================================== */
/*                              Function Definitions                          */
/* ========================================================================== */
 
typedef AsymCrypt_Return_t (*AsymCrypt_ExecuteShaCallback)(uint8_t *in_addr, uint32_t length, uint8_t *sha_addr);
 
AsymCrypt_Handle AsymCrypt_open(uint32_t index);
 
AsymCrypt_Return_t AsymCrypt_close(AsymCrypt_Handle handle);
 
AsymCrypt_Return_t AsymCrypt_RSAPrivate(AsymCrypt_Handle handle,
                    const uint32_t m[RSA_MAX_LENGTH],
                    const struct AsymCrypt_RSAPrivkey *k,
                    uint32_t result[RSA_MAX_LENGTH]);
 
AsymCrypt_Return_t AsymCrypt_RSAPublic(AsymCrypt_Handle handle,
                    const uint32_t m[RSA_MAX_LENGTH],
                    const struct AsymCrypt_RSAPubkey *k,
                    uint32_t result[RSA_MAX_LENGTH]);
 
AsymCrypt_Return_t AsymCrypt_RSAKeyGenPrivate(AsymCrypt_Handle handle,
                    struct AsymCrypt_RSAPrivkey *k,
                    uint32_t keybitsize);
 
AsymCrypt_Return_t AsymCrypt_RSAKeyGenPublic(AsymCrypt_Handle handle,
                    const struct AsymCrypt_RSAPrivkey *privKey,
                    struct AsymCrypt_RSAPubkey *pubKey,
                    uint32_t keybitsize);
 
AsymCrypt_Return_t AsymCrypt_ECDSASign(AsymCrypt_Handle handle,
                    const struct AsymCrypt_ECPrimeCurveP *cp,
                    const uint32_t priv[ECDSA_MAX_LENGTH],
                    const uint32_t k[ECDSA_MAX_LENGTH],
                    const uint32_t h[ECDSA_MAX_LENGTH],
                    struct AsymCrypt_ECDSASig *sig,
                    uint32_t curveId);
 
AsymCrypt_Return_t AsymCrypt_ECDSAVerify(AsymCrypt_Handle handle,
                        const struct AsymCrypt_ECPrimeCurveP *cp,
                        const struct AsymCrypt_ECPoint *pub,
                        const struct AsymCrypt_ECDSASig *sig,
                        const uint32_t h[ECDSA_MAX_LENGTH],
                        uint32_t curveId);
 
AsymCrypt_Return_t AsymCrypt_ECDSAKeyGenPrivate(AsymCrypt_Handle handle,
                        const struct AsymCrypt_ECPrimeCurveP *cp,
                        uint32_t priv[ECDSA_MAX_LENGTH],
                        uint32_t curveType);
 
AsymCrypt_Return_t AsymCrypt_ECDSAKeyGenPublic(AsymCrypt_Handle handle,
                        const struct AsymCrypt_ECPrimeCurveP *cp,
                        struct AsymCrypt_ECPoint *pub,
                        const uint32_t priv[ECDSA_MAX_LENGTH],
                        uint32_t curveType);
 
AsymCrypt_Return_t AsymCrypt_EddsaGetPubKey(AsymCrypt_Handle handle,
                                   AsymCrypt_ExecuteShaCallback shaCbFxn,
                                   uint8_t privKey[EDDSA_MAX_KEY_LEN],
                                   uint8_t pubKey[EDDSA_MAX_KEY_LEN],
                                   AsymCrypt_EdCurveType_t input_curve);
 
AsymCrypt_Return_t AsymCrypt_EddsaSign(AsymCrypt_Handle handle,
                             AsymCrypt_ExecuteShaCallback shaCbFxn,
                             const struct AsymCrypt_EddsaKey *key,
                             const uint8_t *ptrData,
                             const uint32_t dataSizeByte,
                             struct AsymCrypt_EddsaSig *sig,
                             AsymCrypt_EdCurveType_t input_curve);
 
AsymCrypt_Return_t AsymCrypt_EddsaVerify(AsymCrypt_Handle handle,
                            AsymCrypt_ExecuteShaCallback shaCbFxn,
                            const uint8_t pubKey[EDDSA_MAX_KEY_LEN],
                            const uint8_t *ptrData,
                            const uint32_t dataSizeByte,
                            const struct AsymCrypt_EddsaSig *sig,
                            AsymCrypt_EdCurveType_t input_curve);
 
AsymCrypt_Return_t AsymCrypt_EcdhGenSharedSecret(AsymCrypt_Handle handle,
                        const struct AsymCrypt_ECPrimeCurveP *cp,
                        const uint32_t priv[ECDSA_MAX_LENGTH],
                        const struct AsymCrypt_ECPoint *pubKey,
                        struct AsymCrypt_ECPoint *ecShSecret,
                        uint32_t curveType);
 
AsymCrypt_Return_t AsymCrypt_SM2DSASign(AsymCrypt_Handle handle,
                    const uint32_t priv[ECDSA_MAX_LENGTH],
                    const uint32_t k[ECDSA_MAX_LENGTH],
                    const uint32_t h[ECDSA_MAX_LENGTH],
                    struct AsymCrypt_SM2DSASig *sig);
 
AsymCrypt_Return_t AsymCrypt_SM2DSAVerify(AsymCrypt_Handle handle,
                        const struct AsymCrypt_ECPoint *pub,
                        const struct AsymCrypt_SM2DSASig *sig,
                        const uint32_t h[ECDSA_MAX_LENGTH]);
 
AsymCrypt_Return_t AsymCrypt_SM2DSAKeyGenPrivate(AsymCrypt_Handle handle,
                        uint32_t priv[ECDSA_MAX_LENGTH]);
 
AsymCrypt_Return_t AsymCrypt_SM2DSAKeyGenPublic(AsymCrypt_Handle handle,
                        struct AsymCrypt_ECPoint *pub,
                        const uint32_t priv[ECDSA_MAX_LENGTH]);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ASYM_CRYPT_H_ */