mbedtls_stub.c

00001 /*
00002  * Copyright (c) 2015-2017, Arm Limited and affiliates.
00003  * SPDX-License-Identifier: Apache-2.0
00004  *
00005  * Licensed under the Apache License, Version 2.0 (the "License");
00006  * you may not use this file except in compliance with the License.
00007  * You may obtain a copy of the License at
00008  *
00009  *     http://www.apache.org/licenses/LICENSE-2.0
00010  *
00011  * Unless required by applicable law or agreed to in writing, software
00012  * distributed under the License is distributed on an "AS IS" BASIS,
00013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014  * See the License for the specific language governing permissions and
00015  * limitations under the License.
00016  */
00017 
00018 #include "mbedtls_stub.h"
00019 
00020 mbedtls_stub_def mbedtls_stub;
00021 
00022 //From ssl.h
00023 int mbedtls_ssl_handshake_step( mbedtls_ssl_context *ssl )
00024 {
00025     if( mbedtls_stub.useCounter ){
00026 
00027         if( mbedtls_stub.retArray[mbedtls_stub.counter] == HANDSHAKE_FINISHED_VALUE ||
00028                 mbedtls_stub.retArray[mbedtls_stub.counter] == HANDSHAKE_FINISHED_VALUE_RETURN_ZERO){
00029 
00030             ssl->state = MBEDTLS_SSL_HANDSHAKE_OVER;
00031             if(mbedtls_stub.retArray[mbedtls_stub.counter] == HANDSHAKE_FINISHED_VALUE_RETURN_ZERO)
00032                 return 0;
00033         }
00034         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00035     }
00036     return mbedtls_stub.expected_int;
00037 }
00038 
00039 int mbedtls_ssl_close_notify( mbedtls_ssl_context *a )
00040 {
00041     if( mbedtls_stub.useCounter ){
00042         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00043     }
00044     return mbedtls_stub.expected_int;
00045 }
00046 
00047 void mbedtls_ssl_init( mbedtls_ssl_context *a ){
00048 
00049 }
00050 void mbedtls_ssl_conf_min_version( mbedtls_ssl_config *conf, int major, int minor ){
00051 
00052 }
00053 
00054 void mbedtls_ssl_conf_max_version( mbedtls_ssl_config *conf, int major, int minor ){
00055     
00056 }
00057 
00058 void mbedtls_ssl_config_init( mbedtls_ssl_config *a ){
00059 
00060 }
00061 
00062 void mbedtls_ssl_conf_handshake_timeout( mbedtls_ssl_config *a, uint32_t b, uint32_t c)
00063 {
00064 
00065 }
00066 
00067 void mbedtls_ssl_free( mbedtls_ssl_context *a ){
00068 
00069 }
00070 
00071 int mbedtls_ssl_conf_own_cert( mbedtls_ssl_config *a,
00072                               mbedtls_x509_crt *b,
00073                               mbedtls_pk_context *c ){
00074     if( mbedtls_stub.useCounter ){
00075         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00076     }
00077     return mbedtls_stub.expected_int;
00078 }
00079 
00080 void mbedtls_ssl_conf_authmode( mbedtls_ssl_config *a, int c ){
00081 
00082 }
00083 
00084 void mbedtls_ssl_conf_ca_chain( mbedtls_ssl_config *a,
00085                                mbedtls_x509_crt *b,
00086                                mbedtls_x509_crl *c ){
00087 
00088 }
00089 
00090 int mbedtls_ssl_conf_psk( mbedtls_ssl_config *a,
00091                 const unsigned char *b, size_t c,
00092                 const unsigned char *d, size_t e ){
00093     if( mbedtls_stub.useCounter ){
00094         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00095     }
00096     return mbedtls_stub.expected_int;
00097 }
00098 
00099 int mbedtls_ssl_config_defaults( mbedtls_ssl_config *a,
00100                                  int b, int c, int d){
00101     if( mbedtls_stub.useCounter ){
00102         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00103     }
00104     return mbedtls_stub.expected_int;
00105 }
00106 
00107 void mbedtls_ssl_conf_rng( mbedtls_ssl_config *a,
00108                   int (*f_rng)(void *, unsigned char *, size_t),
00109                   void *b ){
00110 
00111 }
00112 
00113 void mbedtls_ssl_conf_ciphersuites( mbedtls_ssl_config *a,
00114                                    const int *b)
00115 {
00116 
00117 }
00118 
00119 int mbedtls_ssl_setup( mbedtls_ssl_context *a,
00120                        const mbedtls_ssl_config *b ){
00121     if( mbedtls_stub.useCounter ){
00122         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00123     }
00124     return mbedtls_stub.expected_int;
00125 }
00126 
00127 void mbedtls_ssl_set_bio( mbedtls_ssl_context *ssl,
00128         void *p_bio,
00129         int (*f_send)(void *, const unsigned char *, size_t),
00130         int (*f_recv)(void *, unsigned char *, size_t),
00131         int (*f_recv_timeout)(void *, unsigned char *, size_t, uint32_t) ){
00132     if( p_bio != NULL ){
00133         if( f_send )
00134             f_send( p_bio, NULL, 0 );
00135         if( f_recv )
00136             f_recv( p_bio, NULL, 0 );
00137         if( f_recv_timeout )
00138             f_recv_timeout( p_bio, NULL, 0, 0 );
00139     }
00140 }
00141 
00142 void mbedtls_ssl_set_timer_cb( mbedtls_ssl_context *a,
00143                                void *ctx,
00144                                void (*f_set_timer)(void *, uint32_t int_ms, uint32_t fin_ms),
00145                                int (*f_get_timer)(void *) ){
00146     f_set_timer(ctx, 1, 2);
00147     f_get_timer(ctx);
00148     if(mbedtls_stub.invalidate_timer){
00149         f_set_timer(ctx, 0, 0);
00150     }
00151     f_get_timer(ctx);
00152 }
00153 
00154 int mbedtls_ssl_handshake( mbedtls_ssl_context *ssl ){
00155     if( mbedtls_stub.useCounter ){
00156         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00157     }
00158     return mbedtls_stub.expected_int;
00159 }
00160 
00161 uint32_t mbedtls_ssl_get_verify_result( const mbedtls_ssl_context *a ){
00162     return mbedtls_stub.uint32_value;
00163 }
00164 
00165 int mbedtls_ssl_read( mbedtls_ssl_context *a, unsigned char *b, size_t c){
00166     if( mbedtls_stub.useCounter ){
00167         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00168     }
00169     return mbedtls_stub.expected_int;
00170 }
00171 
00172 int mbedtls_ssl_write( mbedtls_ssl_context *a, const unsigned char *b, size_t c ){
00173     if( mbedtls_stub.useCounter ){
00174         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00175     }
00176     return mbedtls_stub.expected_int;
00177 }
00178 
00179 
00180 
00181 //From crt_drbg.h
00182 int mbedtls_ctr_drbg_seed( mbedtls_ctr_drbg_context *a,
00183                    int (*f_entropy)(void *, unsigned char *, size_t),
00184                    void *b,
00185                    const unsigned char *c,
00186                    size_t d ){
00187     return mbedtls_stub.crt_expected_int;
00188 }
00189 
00190 void mbedtls_ctr_drbg_init( mbedtls_ctr_drbg_context *a ){
00191 
00192 }
00193 
00194 void mbedtls_ctr_drbg_free( mbedtls_ctr_drbg_context *a ){
00195 
00196 }
00197 
00198 int mbedtls_ctr_drbg_random_with_add( void *a,
00199                               unsigned char *b, size_t c,
00200                               const unsigned char *d, size_t e ){
00201     return mbedtls_stub.crt_expected_int;
00202 }
00203 
00204 int mbedtls_ctr_drbg_random( void *p_rng,
00205                      unsigned char *output, size_t output_len ){
00206     return mbedtls_stub.crt_expected_int;
00207 }
00208 
00209 //From x509_crt.h
00210 void mbedtls_x509_crt_init( mbedtls_x509_crt *a ){
00211 
00212 }
00213 
00214 void mbedtls_x509_crt_free( mbedtls_x509_crt *a ){
00215 
00216 }
00217 
00218 int mbedtls_x509_crt_parse( mbedtls_x509_crt *a, const unsigned char *b, size_t c ){
00219     if( mbedtls_stub.useCounter ){
00220         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00221     }
00222     return mbedtls_stub.expected_int;
00223 }
00224 
00225 //From entropy.h
00226 void mbedtls_entropy_init( mbedtls_entropy_context *a ){
00227 
00228 }
00229 
00230 void mbedtls_entropy_free( mbedtls_entropy_context *ctx ){
00231 
00232 }
00233 
00234 int mbedtls_entropy_func( void *a, unsigned char *b, size_t c ){
00235     if( mbedtls_stub.useCounter ){
00236         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00237     }
00238     return mbedtls_stub.expected_int;
00239 }
00240 
00241 int mbedtls_entropy_add_source( mbedtls_entropy_context *a,
00242                         mbedtls_entropy_f_source_ptr f_source, void *b,
00243                         size_t c, int d ){
00244     unsigned char buf[2];
00245     size_t len;
00246     f_source(NULL, buf, 1, &len);
00247 
00248     if( mbedtls_stub.useCounter ){
00249         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00250     }
00251     return mbedtls_stub.expected_int;
00252 }
00253 
00254 //From pk.h
00255 int mbedtls_pk_parse_key( mbedtls_pk_context *a,
00256                   const unsigned char *b, size_t c,
00257                   const unsigned char *d, size_t e ){
00258     if( mbedtls_stub.useCounter ){
00259         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00260     }
00261     return mbedtls_stub.expected_int;
00262 }
00263 
00264 void mbedtls_pk_init( mbedtls_pk_context *ctx )
00265 {
00266 
00267 }
00268 
00269 void mbedtls_pk_free( mbedtls_pk_context *ctx )
00270 {
00271 
00272 }
00273 
00274 void mbedtls_ssl_config_free( mbedtls_ssl_config *a)
00275 {
00276 
00277 }
00278 
00279 int mbedtls_ssl_set_hs_ecjpake_password( mbedtls_ssl_context *ssl,
00280                                          const unsigned char *pw,
00281                                          size_t pw_len )
00282 {
00283     if( mbedtls_stub.useCounter ){
00284         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00285     }
00286     return mbedtls_stub.expected_int;
00287 }
00288 
00289 void mbedtls_ssl_conf_dtls_cookies( mbedtls_ssl_config *conf,
00290                            mbedtls_ssl_cookie_write_t *f_cookie_write,
00291                            mbedtls_ssl_cookie_check_t *f_cookie_check,
00292                            void *p_cookie )
00293 {
00294     if( mbedtls_stub.cookie_obj && f_cookie_check && mbedtls_stub.cookie_len > 0 ){
00295         f_cookie_check(mbedtls_stub.cookie_obj, &mbedtls_stub.cookie_value, mbedtls_stub.cookie_len, NULL, 0);
00296     }
00297     if( mbedtls_stub.cookie_obj && f_cookie_write && mbedtls_stub.cookie_len > 0 ){
00298         unsigned char out[16];
00299         unsigned char *ptr = &out;
00300         f_cookie_write(mbedtls_stub.cookie_obj, &ptr, ptr+mbedtls_stub.cookie_len, NULL, 0);
00301     }
00302 }
00303 
00304 void mbedtls_ssl_conf_export_keys_cb( mbedtls_ssl_config *conf,
00305         mbedtls_ssl_export_keys_t *f_export_keys,
00306         void *p_export_keys )
00307 {
00308     if( f_export_keys && p_export_keys){
00309         unsigned char value[40];
00310         memset(&value, 1, 40);
00311         f_export_keys(p_export_keys, &value, "", 0, 0,0); //failure case
00312 
00313         f_export_keys(p_export_keys, &value, "", 0, 20,0); //success case
00314     }
00315 }
00316 
00317 int mbedtls_ssl_session_reset( mbedtls_ssl_context *ssl )
00318 {
00319     if( mbedtls_stub.useCounter ){
00320         return mbedtls_stub.retArray[mbedtls_stub.counter++];
00321     }
00322     return mbedtls_stub.expected_int;
00323 }