mirror of https://github.com/ARMmbed/mbed-os.git
299 lines
8.0 KiB
C
299 lines
8.0 KiB
C
/*
|
|
* Copyright (c) 2015 ARM Limited. All Rights Reserved.
|
|
*/
|
|
|
|
#include "mbedtls_stub.h"
|
|
|
|
mbedtls_stub_def mbedtls_stub;
|
|
|
|
//From ssl.h
|
|
int mbedtls_ssl_handshake_step( mbedtls_ssl_context *ssl )
|
|
{
|
|
if( mbedtls_stub.useCounter ){
|
|
if( mbedtls_stub.retArray[mbedtls_stub.counter] == HANDSHAKE_FINISHED_VALUE){
|
|
ssl->state = MBEDTLS_SSL_HANDSHAKE_OVER;
|
|
}
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|
|
|
|
int mbedtls_ssl_close_notify( mbedtls_ssl_context *a )
|
|
{
|
|
if( mbedtls_stub.useCounter ){
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|
|
|
|
void mbedtls_ssl_init( mbedtls_ssl_context *a ){
|
|
|
|
}
|
|
|
|
void mbedtls_ssl_config_init( mbedtls_ssl_config *a ){
|
|
|
|
}
|
|
|
|
void mbedtls_ssl_conf_handshake_timeout( mbedtls_ssl_config *a, uint32_t b, uint32_t c)
|
|
{
|
|
|
|
}
|
|
|
|
void mbedtls_ssl_free( mbedtls_ssl_context *a ){
|
|
|
|
}
|
|
|
|
int mbedtls_ssl_conf_own_cert( mbedtls_ssl_config *a,
|
|
mbedtls_x509_crt *b,
|
|
mbedtls_pk_context *c ){
|
|
if( mbedtls_stub.useCounter ){
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|
|
|
|
void mbedtls_ssl_conf_authmode( mbedtls_ssl_config *a, int c ){
|
|
|
|
}
|
|
|
|
void mbedtls_ssl_conf_ca_chain( mbedtls_ssl_config *a,
|
|
mbedtls_x509_crt *b,
|
|
mbedtls_x509_crl *c ){
|
|
|
|
}
|
|
|
|
int mbedtls_ssl_conf_psk( mbedtls_ssl_config *a,
|
|
const unsigned char *b, size_t c,
|
|
const unsigned char *d, size_t e ){
|
|
if( mbedtls_stub.useCounter ){
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|
|
|
|
int mbedtls_ssl_config_defaults( mbedtls_ssl_config *a,
|
|
int b, int c, int d){
|
|
if( mbedtls_stub.useCounter ){
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|
|
|
|
void mbedtls_ssl_conf_rng( mbedtls_ssl_config *a,
|
|
int (*f_rng)(void *, unsigned char *, size_t),
|
|
void *b ){
|
|
|
|
}
|
|
|
|
void mbedtls_ssl_conf_ciphersuites( mbedtls_ssl_config *a,
|
|
const int *b)
|
|
{
|
|
|
|
}
|
|
|
|
int mbedtls_ssl_setup( mbedtls_ssl_context *a,
|
|
const mbedtls_ssl_config *b ){
|
|
if( mbedtls_stub.useCounter ){
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|
|
|
|
void mbedtls_ssl_set_bio( mbedtls_ssl_context *ssl,
|
|
void *p_bio,
|
|
int (*f_send)(void *, const unsigned char *, size_t),
|
|
int (*f_recv)(void *, unsigned char *, size_t),
|
|
int (*f_recv_timeout)(void *, unsigned char *, size_t, uint32_t) ){
|
|
if( p_bio != NULL ){
|
|
if( f_send )
|
|
f_send( p_bio, NULL, 0 );
|
|
if( f_recv )
|
|
f_recv( p_bio, NULL, 0 );
|
|
if( f_recv_timeout )
|
|
f_recv_timeout( p_bio, NULL, 0, 0 );
|
|
}
|
|
}
|
|
|
|
void mbedtls_ssl_set_timer_cb( mbedtls_ssl_context *a,
|
|
void *ctx,
|
|
void (*f_set_timer)(void *, uint32_t int_ms, uint32_t fin_ms),
|
|
int (*f_get_timer)(void *) ){
|
|
f_set_timer(ctx, 1, 2);
|
|
f_get_timer(ctx);
|
|
if(mbedtls_stub.invalidate_timer){
|
|
f_set_timer(ctx, 0, 0);
|
|
}
|
|
f_get_timer(ctx);
|
|
}
|
|
|
|
int mbedtls_ssl_handshake( mbedtls_ssl_context *ssl ){
|
|
if( mbedtls_stub.useCounter ){
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|
|
|
|
uint32_t mbedtls_ssl_get_verify_result( const mbedtls_ssl_context *a ){
|
|
return mbedtls_stub.uint32_value;
|
|
}
|
|
|
|
int mbedtls_ssl_read( mbedtls_ssl_context *a, unsigned char *b, size_t c){
|
|
if( mbedtls_stub.useCounter ){
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|
|
|
|
int mbedtls_ssl_write( mbedtls_ssl_context *a, const unsigned char *b, size_t c ){
|
|
if( mbedtls_stub.useCounter ){
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|
|
|
|
|
|
|
|
//From crt_drbg.h
|
|
int mbedtls_ctr_drbg_seed( mbedtls_ctr_drbg_context *a,
|
|
int (*f_entropy)(void *, unsigned char *, size_t),
|
|
void *b,
|
|
const unsigned char *c,
|
|
size_t d ){
|
|
return mbedtls_stub.crt_expected_int;
|
|
}
|
|
|
|
void mbedtls_ctr_drbg_init( mbedtls_ctr_drbg_context *a ){
|
|
|
|
}
|
|
|
|
void mbedtls_ctr_drbg_free( mbedtls_ctr_drbg_context *a ){
|
|
|
|
}
|
|
|
|
int mbedtls_ctr_drbg_random_with_add( void *a,
|
|
unsigned char *b, size_t c,
|
|
const unsigned char *d, size_t e ){
|
|
return mbedtls_stub.crt_expected_int;
|
|
}
|
|
|
|
int mbedtls_ctr_drbg_random( void *p_rng,
|
|
unsigned char *output, size_t output_len ){
|
|
return mbedtls_stub.crt_expected_int;
|
|
}
|
|
|
|
//From x509_crt.h
|
|
void mbedtls_x509_crt_init( mbedtls_x509_crt *a ){
|
|
|
|
}
|
|
|
|
void mbedtls_x509_crt_free( mbedtls_x509_crt *a ){
|
|
|
|
}
|
|
|
|
int mbedtls_x509_crt_parse( mbedtls_x509_crt *a, const unsigned char *b, size_t c ){
|
|
if( mbedtls_stub.useCounter ){
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|
|
|
|
//From entropy.h
|
|
void mbedtls_entropy_init( mbedtls_entropy_context *a ){
|
|
|
|
}
|
|
|
|
void mbedtls_entropy_free( mbedtls_entropy_context *ctx ){
|
|
|
|
}
|
|
|
|
int mbedtls_entropy_func( void *a, unsigned char *b, size_t c ){
|
|
if( mbedtls_stub.useCounter ){
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|
|
|
|
int mbedtls_entropy_add_source( mbedtls_entropy_context *a,
|
|
mbedtls_entropy_f_source_ptr f_source, void *b,
|
|
size_t c, int d ){
|
|
unsigned char buf[2];
|
|
size_t len;
|
|
f_source(NULL, buf, 1, &len);
|
|
|
|
if( mbedtls_stub.useCounter ){
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|
|
|
|
//From pk.h
|
|
int mbedtls_pk_parse_key( mbedtls_pk_context *a,
|
|
const unsigned char *b, size_t c,
|
|
const unsigned char *d, size_t e ){
|
|
if( mbedtls_stub.useCounter ){
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|
|
|
|
void mbedtls_pk_init( mbedtls_pk_context *ctx )
|
|
{
|
|
|
|
}
|
|
|
|
void mbedtls_pk_free( mbedtls_pk_context *ctx )
|
|
{
|
|
|
|
}
|
|
|
|
void mbedtls_ssl_config_free( mbedtls_ssl_config *a)
|
|
{
|
|
|
|
}
|
|
|
|
int mbedtls_ssl_set_hs_ecjpake_password( mbedtls_ssl_context *ssl,
|
|
const unsigned char *pw,
|
|
size_t pw_len )
|
|
{
|
|
if( mbedtls_stub.useCounter ){
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|
|
|
|
void mbedtls_ssl_conf_dtls_cookies( mbedtls_ssl_config *conf,
|
|
mbedtls_ssl_cookie_write_t *f_cookie_write,
|
|
mbedtls_ssl_cookie_check_t *f_cookie_check,
|
|
void *p_cookie )
|
|
{
|
|
if( mbedtls_stub.cookie_obj && f_cookie_check && mbedtls_stub.cookie_len > 0 ){
|
|
f_cookie_check(mbedtls_stub.cookie_obj, &mbedtls_stub.cookie_value, mbedtls_stub.cookie_len, NULL, 0);
|
|
}
|
|
if( mbedtls_stub.cookie_obj && f_cookie_write && mbedtls_stub.cookie_len > 0 ){
|
|
unsigned char out[16];
|
|
unsigned char *ptr = &out;
|
|
f_cookie_write(mbedtls_stub.cookie_obj, &ptr, ptr+mbedtls_stub.cookie_len, NULL, 0);
|
|
}
|
|
}
|
|
|
|
void mbedtls_ssl_conf_export_keys_cb( mbedtls_ssl_config *conf,
|
|
mbedtls_ssl_export_keys_t *f_export_keys,
|
|
void *p_export_keys )
|
|
{
|
|
if( f_export_keys && p_export_keys){
|
|
unsigned char value[40];
|
|
memset(&value, 1, 40);
|
|
f_export_keys(p_export_keys, &value, "", 0, 0,0); //failure case
|
|
|
|
f_export_keys(p_export_keys, &value, "", 0, 20,0); //success case
|
|
}
|
|
}
|
|
|
|
int mbedtls_ssl_session_reset( mbedtls_ssl_context *ssl )
|
|
{
|
|
if( mbedtls_stub.useCounter ){
|
|
return mbedtls_stub.retArray[mbedtls_stub.counter++];
|
|
}
|
|
return mbedtls_stub.expected_int;
|
|
}
|