mirror of
https://github.com/yuzu-emu/mbedtls.git
synced 2024-12-27 04:46:08 +00:00
7decfe8c1e
When MBEDTLS_PLATFORM_MEMORY is defined but MBEDTLS_PLATFORM_FREE_MACRO or MBEDTLS_PLATFORM_CALLOC_MACRO are not defined then the actual functions used to allocate and free memory are stored in function pointers. These pointers are exposed to the caller, and it means that the caller and the library have to share a data section. In TF-A, we execute in a very constrained environment, where some images are executed from ROM and other images are executed from SRAM. The images that are executed from ROM cannot be modified. The SRAM size is very small and we are moving libraries to the ROM that can be shared between the different SRAM images. These SRAM images could import all the symbols used in mbedtls, but it would create an undesirable hard binary dependency between the different images. For this reason, all the library functions in ROM are accesed using a jump table whose base address is known, allowing the images to execute with different versions of the ROM. This commit changes the function pointers to actual functions, so that the SRAM images only have to use the new exported symbols (mbedtls_calloc and mbedtls_free) using the jump table. In our scenario, mbedtls_platform_set_calloc_free is called from mbedtls_memory_buffer_alloc_init which initializes the function pointers to the internal buffer_alloc_calloc and buffer_alloc_free functions. No functional changes to mbedtls_memory_buffer_alloc_init. Signed-off-by: Roberto Vargas <roberto.vargas@arm.com>
340 lines
8.9 KiB
C
340 lines
8.9 KiB
C
/*
|
|
* Platform abstraction layer
|
|
*
|
|
* Copyright (C) 2006-2016, ARM Limited, All Rights Reserved
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
* not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* This file is part of mbed TLS (https://tls.mbed.org)
|
|
*/
|
|
|
|
#if !defined(MBEDTLS_CONFIG_FILE)
|
|
#include "mbedtls/config.h"
|
|
#else
|
|
#include MBEDTLS_CONFIG_FILE
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_PLATFORM_C)
|
|
|
|
#include "mbedtls/platform.h"
|
|
#include "mbedtls/platform_util.h"
|
|
|
|
#if defined(MBEDTLS_PLATFORM_MEMORY)
|
|
#if !defined(MBEDTLS_PLATFORM_STD_CALLOC)
|
|
static void *platform_calloc_uninit( size_t n, size_t size )
|
|
{
|
|
((void) n);
|
|
((void) size);
|
|
return( NULL );
|
|
}
|
|
|
|
#define MBEDTLS_PLATFORM_STD_CALLOC platform_calloc_uninit
|
|
#endif /* !MBEDTLS_PLATFORM_STD_CALLOC */
|
|
|
|
#if !defined(MBEDTLS_PLATFORM_STD_FREE)
|
|
static void platform_free_uninit( void *ptr )
|
|
{
|
|
((void) ptr);
|
|
}
|
|
|
|
#define MBEDTLS_PLATFORM_STD_FREE platform_free_uninit
|
|
#endif /* !MBEDTLS_PLATFORM_STD_FREE */
|
|
|
|
static void * (*mbedtls_calloc_func)( size_t, size_t ) = MBEDTLS_PLATFORM_STD_CALLOC;
|
|
static void (*mbedtls_free_func)( void * ) = MBEDTLS_PLATFORM_STD_FREE;
|
|
|
|
void * mbedtls_calloc( size_t nmemb, size_t size )
|
|
{
|
|
return (*mbedtls_calloc_func)( nmemb, size );
|
|
}
|
|
|
|
void mbedtls_free( void * ptr )
|
|
{
|
|
(*mbedtls_free_func)( ptr );
|
|
}
|
|
|
|
int mbedtls_platform_set_calloc_free( void * (*calloc_func)( size_t, size_t ),
|
|
void (*free_func)( void * ) )
|
|
{
|
|
mbedtls_calloc_func = calloc_func;
|
|
mbedtls_free_func = free_func;
|
|
return( 0 );
|
|
}
|
|
#endif /* MBEDTLS_PLATFORM_MEMORY */
|
|
|
|
#if defined(_WIN32)
|
|
#include <stdarg.h>
|
|
int mbedtls_platform_win32_snprintf( char *s, size_t n, const char *fmt, ... )
|
|
{
|
|
int ret;
|
|
va_list argp;
|
|
|
|
/* Avoid calling the invalid parameter handler by checking ourselves */
|
|
if( s == NULL || n == 0 || fmt == NULL )
|
|
return( -1 );
|
|
|
|
va_start( argp, fmt );
|
|
#if defined(_TRUNCATE) && !defined(__MINGW32__)
|
|
ret = _vsnprintf_s( s, n, _TRUNCATE, fmt, argp );
|
|
#else
|
|
ret = _vsnprintf( s, n, fmt, argp );
|
|
if( ret < 0 || (size_t) ret == n )
|
|
{
|
|
s[n-1] = '\0';
|
|
ret = -1;
|
|
}
|
|
#endif
|
|
va_end( argp );
|
|
|
|
return( ret );
|
|
}
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_PLATFORM_SNPRINTF_ALT)
|
|
#if !defined(MBEDTLS_PLATFORM_STD_SNPRINTF)
|
|
/*
|
|
* Make dummy function to prevent NULL pointer dereferences
|
|
*/
|
|
static int platform_snprintf_uninit( char * s, size_t n,
|
|
const char * format, ... )
|
|
{
|
|
((void) s);
|
|
((void) n);
|
|
((void) format);
|
|
return( 0 );
|
|
}
|
|
|
|
#define MBEDTLS_PLATFORM_STD_SNPRINTF platform_snprintf_uninit
|
|
#endif /* !MBEDTLS_PLATFORM_STD_SNPRINTF */
|
|
|
|
int (*mbedtls_snprintf)( char * s, size_t n,
|
|
const char * format,
|
|
... ) = MBEDTLS_PLATFORM_STD_SNPRINTF;
|
|
|
|
int mbedtls_platform_set_snprintf( int (*snprintf_func)( char * s, size_t n,
|
|
const char * format,
|
|
... ) )
|
|
{
|
|
mbedtls_snprintf = snprintf_func;
|
|
return( 0 );
|
|
}
|
|
#endif /* MBEDTLS_PLATFORM_SNPRINTF_ALT */
|
|
|
|
#if defined(MBEDTLS_PLATFORM_PRINTF_ALT)
|
|
#if !defined(MBEDTLS_PLATFORM_STD_PRINTF)
|
|
/*
|
|
* Make dummy function to prevent NULL pointer dereferences
|
|
*/
|
|
static int platform_printf_uninit( const char *format, ... )
|
|
{
|
|
((void) format);
|
|
return( 0 );
|
|
}
|
|
|
|
#define MBEDTLS_PLATFORM_STD_PRINTF platform_printf_uninit
|
|
#endif /* !MBEDTLS_PLATFORM_STD_PRINTF */
|
|
|
|
int (*mbedtls_printf)( const char *, ... ) = MBEDTLS_PLATFORM_STD_PRINTF;
|
|
|
|
int mbedtls_platform_set_printf( int (*printf_func)( const char *, ... ) )
|
|
{
|
|
mbedtls_printf = printf_func;
|
|
return( 0 );
|
|
}
|
|
#endif /* MBEDTLS_PLATFORM_PRINTF_ALT */
|
|
|
|
#if defined(MBEDTLS_PLATFORM_FPRINTF_ALT)
|
|
#if !defined(MBEDTLS_PLATFORM_STD_FPRINTF)
|
|
/*
|
|
* Make dummy function to prevent NULL pointer dereferences
|
|
*/
|
|
static int platform_fprintf_uninit( FILE *stream, const char *format, ... )
|
|
{
|
|
((void) stream);
|
|
((void) format);
|
|
return( 0 );
|
|
}
|
|
|
|
#define MBEDTLS_PLATFORM_STD_FPRINTF platform_fprintf_uninit
|
|
#endif /* !MBEDTLS_PLATFORM_STD_FPRINTF */
|
|
|
|
int (*mbedtls_fprintf)( FILE *, const char *, ... ) =
|
|
MBEDTLS_PLATFORM_STD_FPRINTF;
|
|
|
|
int mbedtls_platform_set_fprintf( int (*fprintf_func)( FILE *, const char *, ... ) )
|
|
{
|
|
mbedtls_fprintf = fprintf_func;
|
|
return( 0 );
|
|
}
|
|
#endif /* MBEDTLS_PLATFORM_FPRINTF_ALT */
|
|
|
|
#if defined(MBEDTLS_PLATFORM_EXIT_ALT)
|
|
#if !defined(MBEDTLS_PLATFORM_STD_EXIT)
|
|
/*
|
|
* Make dummy function to prevent NULL pointer dereferences
|
|
*/
|
|
static void platform_exit_uninit( int status )
|
|
{
|
|
((void) status);
|
|
}
|
|
|
|
#define MBEDTLS_PLATFORM_STD_EXIT platform_exit_uninit
|
|
#endif /* !MBEDTLS_PLATFORM_STD_EXIT */
|
|
|
|
void (*mbedtls_exit)( int status ) = MBEDTLS_PLATFORM_STD_EXIT;
|
|
|
|
int mbedtls_platform_set_exit( void (*exit_func)( int status ) )
|
|
{
|
|
mbedtls_exit = exit_func;
|
|
return( 0 );
|
|
}
|
|
#endif /* MBEDTLS_PLATFORM_EXIT_ALT */
|
|
|
|
#if defined(MBEDTLS_HAVE_TIME)
|
|
|
|
#if defined(MBEDTLS_PLATFORM_TIME_ALT)
|
|
#if !defined(MBEDTLS_PLATFORM_STD_TIME)
|
|
/*
|
|
* Make dummy function to prevent NULL pointer dereferences
|
|
*/
|
|
static mbedtls_time_t platform_time_uninit( mbedtls_time_t* timer )
|
|
{
|
|
((void) timer);
|
|
return( 0 );
|
|
}
|
|
|
|
#define MBEDTLS_PLATFORM_STD_TIME platform_time_uninit
|
|
#endif /* !MBEDTLS_PLATFORM_STD_TIME */
|
|
|
|
mbedtls_time_t (*mbedtls_time)( mbedtls_time_t* timer ) = MBEDTLS_PLATFORM_STD_TIME;
|
|
|
|
int mbedtls_platform_set_time( mbedtls_time_t (*time_func)( mbedtls_time_t* timer ) )
|
|
{
|
|
mbedtls_time = time_func;
|
|
return( 0 );
|
|
}
|
|
#endif /* MBEDTLS_PLATFORM_TIME_ALT */
|
|
|
|
#endif /* MBEDTLS_HAVE_TIME */
|
|
|
|
#if defined(MBEDTLS_ENTROPY_NV_SEED)
|
|
#if !defined(MBEDTLS_PLATFORM_NO_STD_FUNCTIONS) && defined(MBEDTLS_FS_IO)
|
|
/* Default implementations for the platform independent seed functions use
|
|
* standard libc file functions to read from and write to a pre-defined filename
|
|
*/
|
|
int mbedtls_platform_std_nv_seed_read( unsigned char *buf, size_t buf_len )
|
|
{
|
|
FILE *file;
|
|
size_t n;
|
|
|
|
if( ( file = fopen( MBEDTLS_PLATFORM_STD_NV_SEED_FILE, "rb" ) ) == NULL )
|
|
return( -1 );
|
|
|
|
if( ( n = fread( buf, 1, buf_len, file ) ) != buf_len )
|
|
{
|
|
fclose( file );
|
|
mbedtls_platform_zeroize( buf, buf_len );
|
|
return( -1 );
|
|
}
|
|
|
|
fclose( file );
|
|
return( (int)n );
|
|
}
|
|
|
|
int mbedtls_platform_std_nv_seed_write( unsigned char *buf, size_t buf_len )
|
|
{
|
|
FILE *file;
|
|
size_t n;
|
|
|
|
if( ( file = fopen( MBEDTLS_PLATFORM_STD_NV_SEED_FILE, "w" ) ) == NULL )
|
|
return -1;
|
|
|
|
if( ( n = fwrite( buf, 1, buf_len, file ) ) != buf_len )
|
|
{
|
|
fclose( file );
|
|
return -1;
|
|
}
|
|
|
|
fclose( file );
|
|
return( (int)n );
|
|
}
|
|
#endif /* MBEDTLS_PLATFORM_NO_STD_FUNCTIONS */
|
|
|
|
#if defined(MBEDTLS_PLATFORM_NV_SEED_ALT)
|
|
#if !defined(MBEDTLS_PLATFORM_STD_NV_SEED_READ)
|
|
/*
|
|
* Make dummy function to prevent NULL pointer dereferences
|
|
*/
|
|
static int platform_nv_seed_read_uninit( unsigned char *buf, size_t buf_len )
|
|
{
|
|
((void) buf);
|
|
((void) buf_len);
|
|
return( -1 );
|
|
}
|
|
|
|
#define MBEDTLS_PLATFORM_STD_NV_SEED_READ platform_nv_seed_read_uninit
|
|
#endif /* !MBEDTLS_PLATFORM_STD_NV_SEED_READ */
|
|
|
|
#if !defined(MBEDTLS_PLATFORM_STD_NV_SEED_WRITE)
|
|
/*
|
|
* Make dummy function to prevent NULL pointer dereferences
|
|
*/
|
|
static int platform_nv_seed_write_uninit( unsigned char *buf, size_t buf_len )
|
|
{
|
|
((void) buf);
|
|
((void) buf_len);
|
|
return( -1 );
|
|
}
|
|
|
|
#define MBEDTLS_PLATFORM_STD_NV_SEED_WRITE platform_nv_seed_write_uninit
|
|
#endif /* !MBEDTLS_PLATFORM_STD_NV_SEED_WRITE */
|
|
|
|
int (*mbedtls_nv_seed_read)( unsigned char *buf, size_t buf_len ) =
|
|
MBEDTLS_PLATFORM_STD_NV_SEED_READ;
|
|
int (*mbedtls_nv_seed_write)( unsigned char *buf, size_t buf_len ) =
|
|
MBEDTLS_PLATFORM_STD_NV_SEED_WRITE;
|
|
|
|
int mbedtls_platform_set_nv_seed(
|
|
int (*nv_seed_read_func)( unsigned char *buf, size_t buf_len ),
|
|
int (*nv_seed_write_func)( unsigned char *buf, size_t buf_len ) )
|
|
{
|
|
mbedtls_nv_seed_read = nv_seed_read_func;
|
|
mbedtls_nv_seed_write = nv_seed_write_func;
|
|
return( 0 );
|
|
}
|
|
#endif /* MBEDTLS_PLATFORM_NV_SEED_ALT */
|
|
#endif /* MBEDTLS_ENTROPY_NV_SEED */
|
|
|
|
#if !defined(MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT)
|
|
/*
|
|
* Placeholder platform setup that does nothing by default
|
|
*/
|
|
int mbedtls_platform_setup( mbedtls_platform_context *ctx )
|
|
{
|
|
(void)ctx;
|
|
|
|
return( 0 );
|
|
}
|
|
|
|
/*
|
|
* Placeholder platform teardown that does nothing by default
|
|
*/
|
|
void mbedtls_platform_teardown( mbedtls_platform_context *ctx )
|
|
{
|
|
(void)ctx;
|
|
}
|
|
#endif /* MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT */
|
|
|
|
#endif /* MBEDTLS_PLATFORM_C */
|