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