Branch data     Line data    Source code

       1                 :            : /*
       2                 :            :  * Common and shared functions used by multiple modules in the Mbed TLS
       3                 :            :  * library.
       4                 :            :  *
       5                 :            :  *  Copyright The Mbed TLS Contributors
       6                 :            :  *  SPDX-License-Identifier: Apache-2.0
       7                 :            :  *
       8                 :            :  *  Licensed under the Apache License, Version 2.0 (the "License"); you may
       9                 :            :  *  not use this file except in compliance with the License.
      10                 :            :  *  You may obtain a copy of the License at
      11                 :            :  *
      12                 :            :  *  http://www.apache.org/licenses/LICENSE-2.0
      13                 :            :  *
      14                 :            :  *  Unless required by applicable law or agreed to in writing, software
      15                 :            :  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
      16                 :            :  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      17                 :            :  *  See the License for the specific language governing permissions and
      18                 :            :  *  limitations under the License.
      19                 :            :  */
      20                 :            : 
      21                 :            : /*
      22                 :            :  * Ensure gmtime_r is available even with -std=c99; must be defined before
      23                 :            :  * mbedtls_config.h, which pulls in glibc's features.h. Harmless on other platforms.
      24                 :            :  */
      25                 :            : #if !defined(_POSIX_C_SOURCE)
      26                 :            : #define _POSIX_C_SOURCE 200112L
      27                 :            : #endif
      28                 :            : 
      29                 :            : #include "common.h"
      30                 :            : 
      31                 :            : #include "mbedtls/platform_util.h"
      32                 :            : #include "mbedtls/platform.h"
      33                 :            : #include "mbedtls/threading.h"
      34                 :            : 
      35                 :            : #include <stddef.h>
      36                 :            : #include <string.h>
      37                 :            : 
      38                 :            : #if !defined(MBEDTLS_PLATFORM_ZEROIZE_ALT)
      39                 :            : /*
      40                 :            :  * This implementation should never be optimized out by the compiler
      41                 :            :  *
      42                 :            :  * This implementation for mbedtls_platform_zeroize() was inspired from Colin
      43                 :            :  * Percival's blog article at:
      44                 :            :  *
      45                 :            :  * http://www.daemonology.net/blog/2014-09-04-how-to-zero-a-buffer.html
      46                 :            :  *
      47                 :            :  * It uses a volatile function pointer to the standard memset(). Because the
      48                 :            :  * pointer is volatile the compiler expects it to change at
      49                 :            :  * any time and will not optimize out the call that could potentially perform
      50                 :            :  * other operations on the input buffer instead of just setting it to 0.
      51                 :            :  * Nevertheless, as pointed out by davidtgoldblatt on Hacker News
      52                 :            :  * (refer to http://www.daemonology.net/blog/2014-09-05-erratum.html for
      53                 :            :  * details), optimizations of the following form are still possible:
      54                 :            :  *
      55                 :            :  * if( memset_func != memset )
      56                 :            :  *     memset_func( buf, 0, len );
      57                 :            :  *
      58                 :            :  * Note that it is extremely difficult to guarantee that
      59                 :            :  * mbedtls_platform_zeroize() will not be optimized out by aggressive compilers
      60                 :            :  * in a portable way. For this reason, Mbed TLS also provides the configuration
      61                 :            :  * option MBEDTLS_PLATFORM_ZEROIZE_ALT, which allows users to configure
      62                 :            :  * mbedtls_platform_zeroize() to use a suitable implementation for their
      63                 :            :  * platform and needs.
      64                 :            :  */
      65                 :            : static void * (* const volatile memset_func)( void *, int, size_t ) = memset;
      66                 :            : 
      67                 :     355470 : void mbedtls_platform_zeroize( void *buf, size_t len )
      68                 :            : {
      69                 :     355470 :     MBEDTLS_INTERNAL_VALIDATE( len == 0 || buf != NULL );
      70                 :            : 
      71         [ +  - ]:     355470 :     if( len > 0 )
      72                 :     355470 :         memset_func( buf, 0, len );
      73                 :     355470 : }
      74                 :            : #endif /* MBEDTLS_PLATFORM_ZEROIZE_ALT */
      75                 :            : 
      76                 :            : #if defined(MBEDTLS_HAVE_TIME_DATE) && !defined(MBEDTLS_PLATFORM_GMTIME_R_ALT)
      77                 :            : #include <time.h>
      78                 :            : #if !defined(_WIN32) && (defined(unix) || \
      79                 :            :     defined(__unix) || defined(__unix__) || (defined(__APPLE__) && \
      80                 :            :     defined(__MACH__)))
      81                 :            : #include <unistd.h>
      82                 :            : #endif /* !_WIN32 && (unix || __unix || __unix__ ||
      83                 :            :         * (__APPLE__ && __MACH__)) */
      84                 :            : 
      85                 :            : #if !( ( defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L ) ||     \
      86                 :            :        ( defined(_POSIX_THREAD_SAFE_FUNCTIONS ) &&                     \
      87                 :            :          _POSIX_THREAD_SAFE_FUNCTIONS >= 200112L ) )
      88                 :            : /*
      89                 :            :  * This is a convenience shorthand macro to avoid checking the long
      90                 :            :  * preprocessor conditions above. Ideally, we could expose this macro in
      91                 :            :  * platform_util.h and simply use it in platform_util.c, threading.c and
      92                 :            :  * threading.h. However, this macro is not part of the Mbed TLS public API, so
      93                 :            :  * we keep it private by only defining it in this file
      94                 :            :  */
      95                 :            : #if ! ( defined(_WIN32) && !defined(EFIX64) && !defined(EFI32) )
      96                 :            : #define PLATFORM_UTIL_USE_GMTIME
      97                 :            : #endif /* ! ( defined(_WIN32) && !defined(EFIX64) && !defined(EFI32) ) */
      98                 :            : 
      99                 :            : #endif /* !( ( defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L ) ||     \
     100                 :            :              ( defined(_POSIX_THREAD_SAFE_FUNCTIONS ) &&                     \
     101                 :            :                 _POSIX_THREAD_SAFE_FUNCTIONS >= 200112L ) ) */
     102                 :            : 
     103                 :            : struct tm *mbedtls_platform_gmtime_r( const mbedtls_time_t *tt,
     104                 :            :                                       struct tm *tm_buf )
     105                 :            : {
     106                 :            : #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
     107                 :            :     return( ( gmtime_s( tm_buf, tt ) == 0 ) ? tm_buf : NULL );
     108                 :            : #elif !defined(PLATFORM_UTIL_USE_GMTIME)
     109                 :            :     return( gmtime_r( tt, tm_buf ) );
     110                 :            : #else
     111                 :            :     struct tm *lt;
     112                 :            : 
     113                 :            : #if defined(MBEDTLS_THREADING_C)
     114                 :            :     if( mbedtls_mutex_lock( &mbedtls_threading_gmtime_mutex ) != 0 )
     115                 :            :         return( NULL );
     116                 :            : #endif /* MBEDTLS_THREADING_C */
     117                 :            : 
     118                 :            :     lt = gmtime( tt );
     119                 :            : 
     120                 :            :     if( lt != NULL )
     121                 :            :     {
     122                 :            :         memcpy( tm_buf, lt, sizeof( struct tm ) );
     123                 :            :     }
     124                 :            : 
     125                 :            : #if defined(MBEDTLS_THREADING_C)
     126                 :            :     if( mbedtls_mutex_unlock( &mbedtls_threading_gmtime_mutex ) != 0 )
     127                 :            :         return( NULL );
     128                 :            : #endif /* MBEDTLS_THREADING_C */
     129                 :            : 
     130                 :            :     return( ( lt == NULL ) ? NULL : tm_buf );
     131                 :            : #endif /* _WIN32 && !EFIX64 && !EFI32 */
     132                 :            : }
     133                 :            : #endif /* MBEDTLS_HAVE_TIME_DATE && MBEDTLS_PLATFORM_GMTIME_R_ALT */
     134                 :            : 
     135                 :            : #if defined(MBEDTLS_TEST_HOOKS)
     136                 :            : void (*mbedtls_test_hook_test_fail)( const char *, int, const char *);
     137                 :            : #endif /* MBEDTLS_TEST_HOOKS */
     138                 :            :