| /* |
| * Copyright (C) 2017 C-SKY Microsystems Co., Ltd. All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /****************************************************************************** |
| * @file drv_rsa.h |
| * @brief header file for rsa driver |
| * @version V1.0 |
| * @date 02. June 2017 |
| ******************************************************************************/ |
| #ifndef _CSI_RSA_H_ |
| #define _CSI_RSA_H_ |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| #include <stdint.h> |
| #include <drv_common.h> |
| |
| |
| /// definition for rsa handle. |
| typedef void *rsa_handle_t; |
| |
| /****** RSA specific error codes *****/ |
| typedef enum { |
| RSA_ERROR_DATA_BITS , ///< Specified number of Data bits not supported |
| RSA_ERROR_ENDIAN ///< Specified endian not supported |
| } drv_rsa_error_e; |
| |
| /*----- RSA Control Codes: Mode Parameters: Data Bits -----*/ |
| typedef enum { |
| RSA_DATA_BITS_192 = 0, ///< 192 Data bits |
| RSA_DATA_BITS_256 , ///< 256 Data bits |
| RSA_DATA_BITS_512 , ///< 512 Data bits |
| RSA_DATA_BITS_1024 , ///< 1024 Data bits (default) |
| RSA_DATA_BITS_2048 ///< 2048 Data bits |
| } rsa_data_bits_e; |
| |
| /*----- RSA Control Codes: Mode Parameters: Endian -----*/ |
| typedef enum { |
| RSA_ENDIAN_MODE_LITTLE = 0, ///< RSA Little Endian Mode |
| RSA_ENDIAN_MODE_BIG ///< RSA Big Endian Mode |
| } rsa_endian_mode_e; |
| |
| typedef enum { |
| RSA_PADDING_MODE_PKCS1 = 1, ///< RSA PKCS1 Padding Mode |
| RSA_PADDING_MODE_NO , ///< RSA NO Padding Mode |
| RSA_PADDING_MODE_SSLV23 , ///< RSA SSLV23 Padding Mode |
| RSA_PADDING_MODE_PKCS1_OAEP , ///< RSA PKCS1 OAEP Padding Mode |
| RSA_PADDING_MODE_X931 , ///< RSA X931 Padding Mode |
| RSA_PADDING_MODE_PSS ///< RSA PSS Padding Mode |
| } rsa_padding_type_e; |
| |
| typedef enum { |
| RSA_HASH_TYPE_MD5 = 0, |
| RSA_HASH_TYPE_SHA1 , |
| RSA_HASH_TYPE_SHA224 , |
| RSA_HASH_TYPE_SHA256 , |
| RSA_HASH_TYPE_SHA384 , |
| RSA_HASH_TYPE_SHA512 |
| } rsa_hash_type_e; |
| |
| /*----- RSA Control Codes: Mode Parameters: Padding mode -----*/ |
| typedef struct { |
| rsa_padding_type_e padding_type; |
| rsa_hash_type_e hash_type; |
| } rsa_padding_t; |
| |
| /** |
| \brief RSA Status |
| */ |
| typedef struct { |
| uint32_t busy : 1; ///< Calculate busy flag |
| } rsa_status_t; |
| |
| /****** RSA Event *****/ |
| typedef enum { |
| RSA_EVENT_ENCRYPT_COMPLETE = 0, ///< Encrypt completed |
| RSA_EVENT_DECRYPT_COMPLETE , ///< Decrypt completed |
| RSA_EVENT_SIGN_COMPLETE , ///< Sign completed |
| RSA_EVENT_VERIFY_COMPLETE , ///< Verify completed |
| } rsa_event_e; |
| |
| typedef void (*rsa_event_cb_t)(rsa_event_e event); ///< Pointer to \ref rsa_event_cb_t : RSA Event call back. |
| |
| |
| /** |
| \brief RSA Device Driver Capabilities. |
| */ |
| typedef struct { |
| uint32_t bits_192 : 1; ///< supports 192bits modular length |
| uint32_t bits_256 : 1; ///< supports 256bits modular length |
| uint32_t bits_512 : 1; ///< supports 512bits modular length |
| uint32_t bits_1024 : 1; ///< supports 1024bits modular length |
| uint32_t bits_2048 : 1; ///< supports 2048bits modular length |
| } rsa_capabilities_t; |
| |
| |
| // Function documentation |
| |
| /** |
| \brief get rsa handle count. |
| \return rsa handle count |
| */ |
| int32_t csi_rsa_get_instance_count(void); |
| |
| /** |
| \brief Initialize RSA Interface. 1. Initializes the resources needed for the RSA interface 2.registers event callback function |
| \param[in] idx must not exceed return value of csi_rsa_get_instance_count() |
| \param[in] cb_event Pointer to \ref rsa_event_cb_t |
| \return pointer to rsa handle |
| */ |
| rsa_handle_t csi_rsa_initialize(int32_t idx, rsa_event_cb_t cb_event); |
| |
| /** |
| \brief De-initialize RSA Interface. stops operation and releases the software resources used by the interface |
| \param[in] handle rsa handle to operate. |
| \return error code |
| */ |
| int32_t csi_rsa_uninitialize(rsa_handle_t handle); |
| |
| /** |
| \brief Get driver capabilities. |
| \param[in] handle rsa handle to operate. |
| \return \ref rsa_capabilities_t |
| */ |
| rsa_capabilities_t csi_rsa_get_capabilities(rsa_handle_t handle); |
| |
| /** |
| \brief config rsa mode. |
| \param[in] handle rsa handle to operate. |
| \param[in] data_bits \ref rsa_data_bits_e |
| \param[in] endian \ref rsa_endian_mode_e |
| \return error code |
| */ |
| int32_t csi_rsa_config(rsa_handle_t handle, |
| rsa_data_bits_e data_bits, |
| rsa_endian_mode_e endian, |
| void *arg |
| ); |
| |
| /** |
| \brief encrypt |
| \param[in] handle rsa handle to operate. |
| \param[in] n Pointer to the public modulus |
| \param[in] e Pointer to the public exponent |
| \param[in] src Pointer to the source data. |
| \param[in] src_size the source data len |
| \param[out] out Pointer to the result buffer |
| \param[out] out_size the result size |
| \param[in] padding \ref rsa_padding_t |
| \return error code |
| */ |
| int32_t csi_rsa_encrypt(rsa_handle_t handle, void *n, void *e, void *src, int32_t src_size, void *out, uint32_t *out_size, rsa_padding_t padding); |
| |
| |
| /** |
| \brief decrypt |
| \param[in] handle rsa handle to operate. |
| \param[in] n Pointer to the public modulus |
| \param[in] d Pointer to the privte exponent |
| \param[in] src Pointer to the source data. |
| \param[in] src_size the source data len |
| \param[out] out Pointer to the result buffer |
| \param[out] out_size the result size |
| \param[in] padding \ref rsa_padding_t |
| \return error code |
| */ |
| int32_t csi_rsa_decrypt(rsa_handle_t handle, void *n, void *d, void *src, uint32_t src_size, void *out, uint32_t *out_size, rsa_padding_t padding); |
| |
| /** |
| \brief rsa sign |
| \param[in] handle rsa handle to operate. |
| \param[in] n Pointer to the public modulus |
| \param[in] d Pointer to the privte exponent |
| \param[in] src Pointer to the source data. |
| \param[in] src_size the source data len |
| \param[out] signature Pointer to the signature |
| \param[out] sig_size the signature size |
| \param[in] padding \ref rsa_padding_t |
| \return error code |
| */ |
| int32_t csi_rsa_sign(rsa_handle_t handle, void *n, void *d, void *src, uint32_t src_size, void *signature, void *sig_size, rsa_padding_t padding); |
| |
| /** |
| \brief rsa verify |
| \param[in] handle rsa handle to operate. |
| \param[in] n Pointer to the public modulus |
| \param[in] e Pointer to the public exponent |
| \param[in] src Pointer to the source data. |
| \param[in] src_size the source data len |
| \param[in] signature Pointer to the signature |
| \param[in] sig_size the signature size |
| \param[out] result Pointer to the result |
| \param[in] padding \ref rsa_padding_t |
| \return error code |
| */ |
| int32_t csi_rsa_verify(rsa_handle_t handle, void *n, void *e, void *src, uint32_t src_size, void *signature, uint32_t sig_size, void *result, rsa_padding_t padding); |
| /** |
| \brief Get RSA status. |
| \param[in] handle rsa handle to operate. |
| \return RSA status \ref rsa_status_t |
| */ |
| rsa_status_t csi_rsa_get_status(rsa_handle_t handle); |
| |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* _CSI_RSA_H_ */ |
