mbedtls_stub.cpp

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