common/mbedtls/platform.c

   1 /*
   2  *  Platform abstraction layer
   3  *
   4  *  Copyright The Mbed TLS Contributors
   5  *  SPDX-License-Identifier: Apache-2.0
   6  *
   7  *  Licensed under the Apache License, Version 2.0 (the "License"); you may
   8  *  not use this file except in compliance with the License.
   9  *  You may obtain a copy of the License at
  10  *
  11  *  http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  *  Unless required by applicable law or agreed to in writing, software
  14  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  15  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  *  See the License for the specific language governing permissions and
  17  *  limitations under the License.
  18  */
  19
  20 #include "common.h"
  21
  22 #if defined(MBEDTLS_PLATFORM_C)
  23
  24 #include "mbedtls/platform.h"
  25 #include "mbedtls/platform_util.h"
  26 #include "mbedtls/error.h"
  27
  28 /* The compile time configuration of memory allocation via the macros
  29  * MBEDTLS_PLATFORM_{FREE/CALLOC}_MACRO takes precedence over the runtime
  30  * configuration via mbedtls_platform_set_calloc_free(). So, omit everything
  31  * related to the latter if MBEDTLS_PLATFORM_{FREE/CALLOC}_MACRO are defined. */
  32 #if defined(MBEDTLS_PLATFORM_MEMORY) &&                 \
  33     !( defined(MBEDTLS_PLATFORM_CALLOC_MACRO) &&        \
  34        defined(MBEDTLS_PLATFORM_FREE_MACRO) )
  35
  36 #if !defined(MBEDTLS_PLATFORM_STD_CALLOC)
  37 static void *platform_calloc_uninit(size_t n, size_t size) {
  38     ((void) n);
  39     ((void) size);
  40     return (NULL);
  41 }
  42
  43 #define MBEDTLS_PLATFORM_STD_CALLOC   platform_calloc_uninit
  44 #endif /* !MBEDTLS_PLATFORM_STD_CALLOC */
  45
  46 #if !defined(MBEDTLS_PLATFORM_STD_FREE)
  47 static void platform_free_uninit(void *ptr) {
  48     ((void) ptr);
  49 }
  50
  51 #define MBEDTLS_PLATFORM_STD_FREE     platform_free_uninit
  52 #endif /* !MBEDTLS_PLATFORM_STD_FREE */
  53
  54 static void *(*mbedtls_calloc_func)(size_t, size_t) = MBEDTLS_PLATFORM_STD_CALLOC;
  55 static void (*mbedtls_free_func)(void *) = MBEDTLS_PLATFORM_STD_FREE;
  56
  57 void *mbedtls_calloc(size_t nmemb, size_t size) {
  58     return (*mbedtls_calloc_func)(nmemb, size);
  59 }
  60
  61 void mbedtls_free(void *ptr) {
  62     (*mbedtls_free_func)(ptr);
  63 }
  64
  65 int mbedtls_platform_set_calloc_free(void *(*calloc_func)(size_t, size_t),
  66                                      void (*free_func)(void *)) {
  67     mbedtls_calloc_func = calloc_func;
  68     mbedtls_free_func = free_func;
  69     return (0);
  70 }
  71 #endif /* MBEDTLS_PLATFORM_MEMORY &&
  72           !( defined(MBEDTLS_PLATFORM_CALLOC_MACRO) &&
  73              defined(MBEDTLS_PLATFORM_FREE_MACRO) ) */
  74
  75 #if defined(MBEDTLS_PLATFORM_HAS_NON_CONFORMING_SNPRINTF)
  76 #include <stdarg.h>
  77 int mbedtls_platform_win32_snprintf(char *s, size_t n, const char *fmt, ...) {
  78     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
  79     va_list argp;
  80
  81     va_start(argp, fmt);
  82     ret = mbedtls_vsnprintf(s, n, fmt, argp);
  83     va_end(argp);
  84
  85     return (ret);
  86 }
  87 #endif
  88
  89 #if defined(MBEDTLS_PLATFORM_SNPRINTF_ALT)
  90 #if !defined(MBEDTLS_PLATFORM_STD_SNPRINTF)
  91 /*
  92  * Make dummy function to prevent NULL pointer dereferences
  93  */
  94 static int platform_snprintf_uninit(char *s, size_t n,
  95                                     const char *format, ...) {
  96     ((void) s);
  97     ((void) n);
  98     ((void) format);
  99     return (0);
 100 }
 101
 102 #define MBEDTLS_PLATFORM_STD_SNPRINTF    platform_snprintf_uninit
 103 #endif /* !MBEDTLS_PLATFORM_STD_SNPRINTF */
 104
 105 int (*mbedtls_snprintf)(char *s, size_t n,
 106                         const char *format,
 107                         ...) = MBEDTLS_PLATFORM_STD_SNPRINTF;
 108
 109 int mbedtls_platform_set_snprintf(int (*snprintf_func)(char *s, size_t n,
 110                                                        const char *format,
 111                                                        ...)) {
 112     mbedtls_snprintf = snprintf_func;
 113     return (0);
 114 }
 115 #endif /* MBEDTLS_PLATFORM_SNPRINTF_ALT */
 116
 117 #if defined(MBEDTLS_PLATFORM_HAS_NON_CONFORMING_VSNPRINTF)
 118 #include <stdarg.h>
 119 int mbedtls_platform_win32_vsnprintf(char *s, size_t n, const char *fmt, va_list arg) {
 120     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
 121
 122     /* Avoid calling the invalid parameter handler by checking ourselves */
 123     if (s == NULL || n == 0 || fmt == NULL)
 124         return (-1);
 125
 126 #if defined(_TRUNCATE)
 127     ret = vsnprintf_s(s, n, _TRUNCATE, fmt, arg);
 128 #else
 129     ret = vsnprintf(s, n, fmt, arg);
 130     if (ret < 0 || (size_t) ret == n) {
 131         s[n - 1] = '\0';
 132         ret = -1;
 133     }
 134 #endif
 135
 136     return (ret);
 137 }
 138 #endif
 139
 140 #if defined(MBEDTLS_PLATFORM_VSNPRINTF_ALT)
 141 #if !defined(MBEDTLS_PLATFORM_STD_VSNPRINTF)
 142 /*
 143  * Make dummy function to prevent NULL pointer dereferences
 144  */
 145 static int platform_vsnprintf_uninit(char *s, size_t n,
 146                                      const char *format, va_list arg) {
 147     ((void) s);
 148     ((void) n);
 149     ((void) format);
 150     ((void) arg);
 151     return (-1);
 152 }
 153
 154 #define MBEDTLS_PLATFORM_STD_VSNPRINTF    platform_vsnprintf_uninit
 155 #endif /* !MBEDTLS_PLATFORM_STD_VSNPRINTF */
 156
 157 int (*mbedtls_vsnprintf)(char *s, size_t n,
 158                          const char *format,
 159                          va_list arg) = MBEDTLS_PLATFORM_STD_VSNPRINTF;
 160
 161 int mbedtls_platform_set_vsnprintf(int (*vsnprintf_func)(char *s, size_t n,
 162                                                          const char *format,
 163                                                          va_list arg)) {
 164     mbedtls_vsnprintf = vsnprintf_func;
 165     return (0);
 166 }
 167 #endif /* MBEDTLS_PLATFORM_VSNPRINTF_ALT */
 168
 169 #if defined(MBEDTLS_PLATFORM_PRINTF_ALT)
 170 #if !defined(MBEDTLS_PLATFORM_STD_PRINTF)
 171 /*
 172  * Make dummy function to prevent NULL pointer dereferences
 173  */
 174 static int platform_printf_uninit(const char *format, ...) {
 175     ((void) format);
 176     return (0);
 177 }
 178
 179 #define MBEDTLS_PLATFORM_STD_PRINTF    platform_printf_uninit
 180 #endif /* !MBEDTLS_PLATFORM_STD_PRINTF */
 181
 182 int (*mbedtls_printf)(const char *, ...) = MBEDTLS_PLATFORM_STD_PRINTF;
 183
 184 int mbedtls_platform_set_printf(int (*printf_func)(const char *, ...)) {
 185     mbedtls_printf = printf_func;
 186     return (0);
 187 }
 188 #endif /* MBEDTLS_PLATFORM_PRINTF_ALT */
 189
 190 #if defined(MBEDTLS_PLATFORM_FPRINTF_ALT)
 191 #if !defined(MBEDTLS_PLATFORM_STD_FPRINTF)
 192 /*
 193  * Make dummy function to prevent NULL pointer dereferences
 194  */
 195 static int platform_fprintf_uninit(FILE *stream, const char *format, ...) {
 196     ((void) stream);
 197     ((void) format);
 198     return (0);
 199 }
 200
 201 #define MBEDTLS_PLATFORM_STD_FPRINTF   platform_fprintf_uninit
 202 #endif /* !MBEDTLS_PLATFORM_STD_FPRINTF */
 203
 204 int (*mbedtls_fprintf)(FILE *, const char *, ...) =
 205     MBEDTLS_PLATFORM_STD_FPRINTF;
 206
 207 int mbedtls_platform_set_fprintf(int (*fprintf_func)(FILE *, const char *, ...)) {
 208     mbedtls_fprintf = fprintf_func;
 209     return (0);
 210 }
 211 #endif /* MBEDTLS_PLATFORM_FPRINTF_ALT */
 212
 213 #if defined(MBEDTLS_PLATFORM_EXIT_ALT)
 214 #if !defined(MBEDTLS_PLATFORM_STD_EXIT)
 215 /*
 216  * Make dummy function to prevent NULL pointer dereferences
 217  */
 218 static void platform_exit_uninit(int status) {
 219     ((void) status);
 220 }
 221
 222 #define MBEDTLS_PLATFORM_STD_EXIT   platform_exit_uninit
 223 #endif /* !MBEDTLS_PLATFORM_STD_EXIT */
 224
 225 void (*mbedtls_exit)(int status) = MBEDTLS_PLATFORM_STD_EXIT;
 226
 227 int mbedtls_platform_set_exit(void (*exit_func)(int status)) {
 228     mbedtls_exit = exit_func;
 229     return (0);
 230 }
 231 #endif /* MBEDTLS_PLATFORM_EXIT_ALT */
 232
 233 #if defined(MBEDTLS_HAVE_TIME)
 234
 235 #if defined(MBEDTLS_PLATFORM_TIME_ALT)
 236 #if !defined(MBEDTLS_PLATFORM_STD_TIME)
 237 /*
 238  * Make dummy function to prevent NULL pointer dereferences
 239  */
 240 static mbedtls_time_t platform_time_uninit(mbedtls_time_t *timer) {
 241     ((void) timer);
 242     return (0);
 243 }
 244
 245 #define MBEDTLS_PLATFORM_STD_TIME   platform_time_uninit
 246 #endif /* !MBEDTLS_PLATFORM_STD_TIME */
 247
 248 mbedtls_time_t (*mbedtls_time)(mbedtls_time_t *timer) = MBEDTLS_PLATFORM_STD_TIME;
 249
 250 int mbedtls_platform_set_time(mbedtls_time_t (*time_func)(mbedtls_time_t *timer)) {
 251     mbedtls_time = time_func;
 252     return (0);
 253 }
 254 #endif /* MBEDTLS_PLATFORM_TIME_ALT */
 255
 256 #endif /* MBEDTLS_HAVE_TIME */
 257
 258 #if defined(MBEDTLS_ENTROPY_NV_SEED)
 259 #if !defined(MBEDTLS_PLATFORM_NO_STD_FUNCTIONS) && defined(MBEDTLS_FS_IO)
 260 /* Default implementations for the platform independent seed functions use
 261  * standard libc file functions to read from and write to a pre-defined filename
 262  */
 263 int mbedtls_platform_std_nv_seed_read(unsigned char *buf, size_t buf_len) {
 264     FILE *file;
 265     size_t n;
 266
 267     if ((file = fopen(MBEDTLS_PLATFORM_STD_NV_SEED_FILE, "rb")) == NULL)
 268         return (-1);
 269
 270     if ((n = fread(buf, 1, buf_len, file)) != buf_len) {
 271         fclose(file);
 272         mbedtls_platform_zeroize(buf, buf_len);
 273         return (-1);
 274     }
 275
 276     fclose(file);
 277     return ((int)n);
 278 }
 279
 280 int mbedtls_platform_std_nv_seed_write(unsigned char *buf, size_t buf_len) {
 281     FILE *file;
 282     size_t n;
 283
 284     if ((file = fopen(MBEDTLS_PLATFORM_STD_NV_SEED_FILE, "w")) == NULL)
 285         return -1;
 286
 287     if ((n = fwrite(buf, 1, buf_len, file)) != buf_len) {
 288         fclose(file);
 289         return -1;
 290     }
 291
 292     fclose(file);
 293     return ((int)n);
 294 }
 295 #endif /* MBEDTLS_PLATFORM_NO_STD_FUNCTIONS */
 296
 297 #if defined(MBEDTLS_PLATFORM_NV_SEED_ALT)
 298 #if !defined(MBEDTLS_PLATFORM_STD_NV_SEED_READ)
 299 /*
 300  * Make dummy function to prevent NULL pointer dereferences
 301  */
 302 static int platform_nv_seed_read_uninit(unsigned char *buf, size_t buf_len) {
 303     ((void) buf);
 304     ((void) buf_len);
 305     return (-1);
 306 }
 307
 308 #define MBEDTLS_PLATFORM_STD_NV_SEED_READ   platform_nv_seed_read_uninit
 309 #endif /* !MBEDTLS_PLATFORM_STD_NV_SEED_READ */
 310
 311 #if !defined(MBEDTLS_PLATFORM_STD_NV_SEED_WRITE)
 312 /*
 313  * Make dummy function to prevent NULL pointer dereferences
 314  */
 315 static int platform_nv_seed_write_uninit(unsigned char *buf, size_t buf_len) {
 316     ((void) buf);
 317     ((void) buf_len);
 318     return (-1);
 319 }
 320
 321 #define MBEDTLS_PLATFORM_STD_NV_SEED_WRITE   platform_nv_seed_write_uninit
 322 #endif /* !MBEDTLS_PLATFORM_STD_NV_SEED_WRITE */
 323
 324 int (*mbedtls_nv_seed_read)(unsigned char *buf, size_t buf_len) =
 325     MBEDTLS_PLATFORM_STD_NV_SEED_READ;
 326 int (*mbedtls_nv_seed_write)(unsigned char *buf, size_t buf_len) =
 327     MBEDTLS_PLATFORM_STD_NV_SEED_WRITE;
 328
 329 int mbedtls_platform_set_nv_seed(
 330     int (*nv_seed_read_func)(unsigned char *buf, size_t buf_len),
 331     int (*nv_seed_write_func)(unsigned char *buf, size_t buf_len)) {
 332     mbedtls_nv_seed_read = nv_seed_read_func;
 333     mbedtls_nv_seed_write = nv_seed_write_func;
 334     return (0);
 335 }
 336 #endif /* MBEDTLS_PLATFORM_NV_SEED_ALT */
 337 #endif /* MBEDTLS_ENTROPY_NV_SEED */
 338
 339 #if !defined(MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT)
 340 /*
 341  * Placeholder platform setup that does nothing by default
 342  */
 343 int mbedtls_platform_setup(mbedtls_platform_context *ctx) {
 344     (void)ctx;
 345
 346     return (0);
 347 }
 348
 349 /*
 350  * Placeholder platform teardown that does nothing by default
 351  */
 352 void mbedtls_platform_teardown(mbedtls_platform_context *ctx) {
 353     (void)ctx;
 354 }
 355 #endif /* MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT */
 356
 357 #endif /* MBEDTLS_PLATFORM_C */