cc_internal.c

00001 /*
00002  *  cc_internal.c
00003  *
00004  *  Internal utility functions and definitions,
00005  *  used for converting mbedtls types to CC types, and vice versa
00006  *
00007  *  Copyright (C) 2018, Arm Limited, All Rights Reserved
00008  *  SPDX-License-Identifier: Apache-2.0
00009  *
00010  *  Licensed under the Apache License, Version 2.0 (the "License"); you may
00011  *  not use this file except in compliance with the License.
00012  *  You may obtain a copy of the License at
00013  *
00014  *  http://www.apache.org/licenses/LICENSE-2.0
00015  *
00016  *  Unless required by applicable law or agreed to in writing, software
00017  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
00018  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00019  *  See the License for the specific language governing permissions and
00020  *  limitations under the License.
00021  *
00022  */
00023 
00024 #include "cc_internal.h"
00025 #include "crys_ecpki_error.h"
00026 #include "crys_ec_mont_edw_error.h"
00027 
00028 CRYS_ECPKI_DomainID_t  convert_mbedtls_grp_id_to_crys_domain_id( mbedtls_ecp_group_id grp_id )
00029 {
00030     switch( grp_id )
00031     {
00032     case MBEDTLS_ECP_DP_SECP192K1:
00033         return ( CRYS_ECPKI_DomainID_secp192k1  );
00034     case MBEDTLS_ECP_DP_SECP192R1:
00035         return ( CRYS_ECPKI_DomainID_secp192r1  );
00036     case MBEDTLS_ECP_DP_SECP224K1:
00037         return ( CRYS_ECPKI_DomainID_secp224k1  );
00038     case MBEDTLS_ECP_DP_SECP224R1:
00039         return ( CRYS_ECPKI_DomainID_secp224r1  );
00040     case MBEDTLS_ECP_DP_SECP256K1:
00041         return ( CRYS_ECPKI_DomainID_secp256k1  );
00042     case MBEDTLS_ECP_DP_SECP256R1:
00043         return ( CRYS_ECPKI_DomainID_secp256r1  );
00044     case MBEDTLS_ECP_DP_SECP384R1:
00045         return ( CRYS_ECPKI_DomainID_secp384r1  );
00046     case MBEDTLS_ECP_DP_SECP521R1:
00047         return ( CRYS_ECPKI_DomainID_secp521r1  );
00048     default:
00049         return ( CRYS_ECPKI_DomainID_OffMode  );
00050     }
00051 
00052 }
00053 
00054 uint32_t convert_mbedtls_to_cc_rand( void* mbedtls_rnd_ctx, uint16_t outSizeBytes, uint8_t* out_ptr )
00055 {
00056     uint16_t i = 0;
00057     uint8_t temp = 0;
00058     mbedtls_rand_func_container* mbedtls_rand = (mbedtls_rand_func_container*)mbedtls_rnd_ctx;
00059 
00060     if( mbedtls_rand->f_rng( mbedtls_rand->ctx, out_ptr, outSizeBytes ) != 0 )
00061         return ( MBEDTLS_ERR_ECP_RANDOM_FAILED );
00062 
00063     /*
00064      * CC requires the random data as LE, so reversing the data
00065      * (although this is random, but test vectors are in specific Endianess)
00066      */
00067     while ( i < ( outSizeBytes / 2 ) )
00068     {
00069         temp = out_ptr[outSizeBytes - 1 - i];
00070         out_ptr[outSizeBytes - 1 - i] = out_ptr[i];
00071         out_ptr[i] = temp;
00072         ++i;
00073     }
00074     /*
00075      * CC increases the random data by one, to put the vector in the proper range (1 to  n),
00076      * The RFC tests supply a data buffer within range, and in order to generate the proper ephemeral key,
00077      * need to decrease one from this data, before CC increases the data, so the output will be as expected
00078      */
00079     i = 0;
00080     while( out_ptr[i] == 0 )
00081     {
00082         ++i;
00083     }
00084     while( i > 0 )
00085     {
00086         --out_ptr[i];
00087         --i;
00088     }
00089     --out_ptr[0];
00090     return ( 0 );
00091 }
00092 
00093 int convert_CrysError_to_mbedtls_err( CRYSError_t  Crys_err )
00094 {
00095     switch( Crys_err )
00096     {
00097     case CRYS_OK:
00098         return ( 0 );
00099 
00100     case CRYS_ECDH_SVDP_DH_INVALID_USER_PRIV_KEY_PTR_ERROR:
00101     case CRYS_ECDH_SVDP_DH_USER_PRIV_KEY_VALID_TAG_ERROR:
00102     case CRYS_ECDH_SVDP_DH_INVALID_PARTNER_PUBL_KEY_PTR_ERROR:
00103     case CRYS_ECDH_SVDP_DH_PARTNER_PUBL_KEY_VALID_TAG_ERROR:
00104     case CRYS_ECDH_SVDP_DH_INVALID_SHARED_SECRET_VALUE_PTR_ERROR:
00105     case CRYS_ECDH_SVDP_DH_INVALID_TEMP_DATA_PTR_ERROR:
00106     case CRYS_ECDH_SVDP_DH_INVALID_SHARED_SECRET_VALUE_SIZE_PTR_ERROR:
00107     case CRYS_ECDH_SVDP_DH_NOT_CONCENT_PUBL_AND_PRIV_DOMAIN_ID_ERROR:
00108     case CRYS_ECDH_SVDP_DH_INVALID_SHARED_SECRET_VALUE_SIZE_ERROR:
00109     case CRYS_ECMONT_INVALID_INPUT_POINTER_ERROR:
00110     case CRYS_ECMONT_INVALID_INPUT_SIZE_ERROR:
00111     case CRYS_ECMONT_INVALID_DOMAIN_ID_ERROR:
00112     case CRYS_ECDSA_SIGN_INVALID_USER_CONTEXT_PTR_ERROR:
00113     case CRYS_ECDSA_SIGN_INVALID_USER_PRIV_KEY_PTR_ERROR:
00114     case CRYS_ECDSA_SIGN_ILLEGAL_HASH_OP_MODE_ERROR:
00115     case CRYS_ECDSA_SIGN_USER_PRIV_KEY_VALIDATION_TAG_ERROR:
00116     case CRYS_ECDSA_SIGN_USER_CONTEXT_VALIDATION_TAG_ERROR:
00117     case CRYS_ECDSA_SIGN_INVALID_MESSAGE_DATA_IN_PTR_ERROR:
00118     case CRYS_ECDSA_SIGN_INVALID_MESSAGE_DATA_IN_SIZE_ERROR:
00119     case CRYS_ECDSA_SIGN_INVALID_SIGNATURE_OUT_PTR_ERROR:
00120     case CRYS_ECDSA_SIGN_INVALID_SIGNATURE_OUT_SIZE_PTR_ERROR:
00121     case CRYS_ECDSA_SIGN_INVALID_IS_EPHEMER_KEY_INTERNAL_ERROR:
00122     case CRYS_ECDSA_SIGN_INVALID_EPHEMERAL_KEY_PTR_ERROR:
00123     case CRYS_ECDSA_VERIFY_INVALID_SIGNER_PUBL_KEY_PTR_ERROR:
00124     case CRYS_ECDSA_VERIFY_SIGNER_PUBL_KEY_VALIDATION_TAG_ERROR:
00125     case CRYS_ECDSA_VERIFY_INVALID_USER_CONTEXT_PTR_ERROR:
00126     case CRYS_ECDSA_VERIFY_INVALID_SIGNATURE_IN_PTR_ERROR:
00127     case CRYS_ECDSA_VERIFY_INVALID_SIGNATURE_SIZE_ERROR:
00128     case CRYS_ECPKI_INVALID_RND_CTX_PTR_ERROR:
00129     case CRYS_ECPKI_INVALID_RND_FUNC_PTR_ERROR:
00130     case CRYS_ECDSA_SIGN_INVALID_SIGNATURE_OUT_SIZE_ERROR:
00131         return ( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
00132 
00133     case CRYS_ECDSA_VERIFY_INCONSISTENT_VERIFY_ERROR:
00134         return ( MBEDTLS_ERR_ECP_VERIFY_FAILED );
00135 
00136     case CRYS_ECMONT_IS_NOT_SUPPORTED:
00137     case CRYS_ECEDW_IS_NOT_SUPPORTED:
00138         return ( MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE );
00139 
00140     case CRYS_ECEDW_RND_GEN_VECTOR_FUNC_ERROR:
00141         return ( MBEDTLS_ERR_ECP_RANDOM_FAILED );
00142 
00143     case CRYS_ECPKI_GEN_KEY_INVALID_PRIVATE_KEY_PTR_ERROR:
00144     case CRYS_ECPKI_EXPORT_PUBL_KEY_INVALID_PUBL_KEY_DATA_ERROR:
00145     case CRYS_ECPKI_BUILD_KEY_INVALID_PRIV_KEY_DATA_ERROR:
00146         return ( MBEDTLS_ERR_ECP_INVALID_KEY );
00147 
00148     default:
00149         return ( MBEDTLS_ERR_ECP_HW_ACCEL_FAILED );
00150     }
00151 
00152 
00153 }