mbedtls_stub.c

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