Branch data Line data Source code
1 : : /*
2 : : *****************************************************************************
3 : : *
4 : : * File: fko_util.c
5 : : *
6 : : * Purpose: Provide a set of common utility functions that fwknop can use.
7 : : *
8 : : * Fwknop is developed primarily by the people listed in the file 'AUTHORS'.
9 : : * Copyright (C) 2009-2014 fwknop developers and contributors. For a full
10 : : * list of contributors, see the file 'CREDITS'.
11 : : *
12 : : * License (GNU General Public License):
13 : : *
14 : : * This program is free software; you can redistribute it and/or
15 : : * modify it under the terms of the GNU General Public License
16 : : * as published by the Free Software Foundation; either version 2
17 : : * of the License, or (at your option) any later version.
18 : : *
19 : : * This program is distributed in the hope that it will be useful,
20 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 : : * GNU General Public License for more details.
23 : : *
24 : : * You should have received a copy of the GNU General Public License
25 : : * along with this program; if not, write to the Free Software
26 : : * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
27 : : * USA
28 : : *
29 : : *****************************************************************************
30 : : */
31 : : #include "fko_common.h"
32 : : #include "fko_util.h"
33 : : #include <errno.h>
34 : : #include <stdarg.h>
35 : :
36 : : #ifndef WIN32
37 : : /* for inet_aton() IP validation
38 : : */
39 : : #include <sys/socket.h>
40 : : #include <netinet/in.h>
41 : : #include <arpa/inet.h>
42 : : #endif
43 : :
44 : : /* Check for a FKO error returned by a function an return the error code */
45 : : #define RETURN_ON_FKO_ERROR(e, f) do { if (((e)=(f)) != FKO_SUCCESS) { return (e); } } while(0);
46 : :
47 : : #define FKO_ENCRYPTION_MODE_BUFSIZE 16 /*!< Maximum size of an encryption mode string */
48 : : #define FKO_ENC_MODE_SUPPORTED 0 /*!< Defined a supported fko encryption mode */
49 : : #define FKO_ENC_MODE_NOT_SUPPORTED !FKO_ENC_MODE_SUPPORTED /*!< Defined an unsupported fko encryption mode */
50 : :
51 : : #define NULL_STRING "<NULL>" /*!< String which represents a NULL buffer */
52 : :
53 : : /**
54 : : * Structure to handle an encryption mode string string and its associated integer value
55 : : */
56 : : typedef struct fko_enc_mode_str
57 : : {
58 : : const char str[FKO_ENCRYPTION_MODE_BUFSIZE]; /*!< String which represents an encryption mode value for the FKO library */
59 : : int val; /*!< Value of the encryption mode according to the FKO library */
60 : : int supported; /*!< SUPPORTED or NOT_SUPPORTED */
61 : : } fko_enc_mode_str_t;
62 : :
63 : : /**
64 : : * Array to associate all of encryption modes with their respective string
65 : : */
66 : : static fko_enc_mode_str_t fko_enc_mode_strs[] =
67 : : {
68 : : { "CBC", FKO_ENC_MODE_CBC, FKO_ENC_MODE_SUPPORTED },
69 : : { "ECB", FKO_ENC_MODE_ECB, FKO_ENC_MODE_SUPPORTED },
70 : : { "CFB", FKO_ENC_MODE_CFB, FKO_ENC_MODE_SUPPORTED },
71 : : { "PCBC", FKO_ENC_MODE_PCBC, FKO_ENC_MODE_NOT_SUPPORTED },
72 : : { "OFB", FKO_ENC_MODE_OFB, FKO_ENC_MODE_SUPPORTED },
73 : : { "CTR", FKO_ENC_MODE_CTR, FKO_ENC_MODE_SUPPORTED },
74 : : { "Asymmetric", FKO_ENC_MODE_ASYMMETRIC, FKO_ENC_MODE_SUPPORTED },
75 : : { "legacy", FKO_ENC_MODE_CBC_LEGACY_IV, FKO_ENC_MODE_SUPPORTED }
76 : : };
77 : :
78 : : /* Compare all bytes with constant run time regardless of
79 : : * input characteristics (i.e. don't return early if a difference
80 : : * is found before comparing all bytes). This code was adapted
81 : : * from YaSSL which is GPLv2 after a timing bug was reported by
82 : : * Ryman through github (#85)
83 : : */
84 : : int
85 : 343 : constant_runtime_cmp(const char *a, const char *b, int len)
86 : : {
87 : 343 : int good = 0;
88 : 343 : int bad = 0;
89 : : int i;
90 : :
91 [ + + ]: 13924 : for(i=0; i < len; i++) {
92 [ + + ]: 13581 : if (a[i] == b[i])
93 : 259 : good++;
94 : : else
95 : 13322 : bad++;
96 : : }
97 : :
98 [ + - ]: 343 : if (good == len)
99 : : return 0;
100 : : else
101 : 343 : return 0 - bad;
102 : : }
103 : :
104 : : /* Validate encoded message length
105 : : */
106 : : int
107 : 4661 : is_valid_encoded_msg_len(const int len)
108 : : {
109 : : #if HAVE_LIBFIU
110 : : fiu_return_on("is_valid_encoded_msg_len_val", 0);
111 : : #endif
112 [ + + ]: 4661 : if(len < MIN_SPA_ENCODED_MSG_SIZE || len >= MAX_SPA_ENCODED_MSG_SIZE)
113 : : return(0);
114 : :
115 : 4647 : return(1);
116 : : }
117 : :
118 : : /* Validate an IPv4 address
119 : : */
120 : : int
121 : 8166 : is_valid_ipv4_addr(const char * const ip_str)
122 : : {
123 : 8166 : const char *ndx = ip_str;
124 : 8166 : int dot_ctr = 0, char_ctr = 0;
125 : 8166 : int res = 1;
126 : : #if HAVE_SYS_SOCKET_H
127 : : struct in_addr in;
128 : : #endif
129 : :
130 [ + - ]: 8166 : if(ip_str == NULL)
131 : : return 0;
132 : :
133 [ + + ]: 53054 : while(*ndx != '\0')
134 : : {
135 : 48106 : char_ctr++;
136 [ + - ]: 48106 : if(char_ctr >= MAX_IPV4_STR_LEN)
137 : : {
138 : : res = 0;
139 : : break;
140 : : }
141 [ + + ]: 48106 : if(*ndx == '.')
142 : 14198 : dot_ctr++;
143 [ + + ]: 33908 : else if(isdigit(*ndx) == 0)
144 : : {
145 : : res = 0;
146 : : break;
147 : : }
148 : 44888 : ndx++;
149 : : }
150 [ - + ]: 8166 : if(char_ctr >= MAX_IPV4_STR_LEN)
151 : 0 : res = 0;
152 : :
153 [ + + ]: 8166 : if ((res == 1) && (char_ctr < MIN_IPV4_STR_LEN))
154 : 700 : res = 0;
155 : :
156 [ + + ]: 8166 : if((res == 1) && dot_ctr != 3)
157 : 376 : res = 0;
158 : :
159 : : #if HAVE_SYS_SOCKET_H
160 : : /* Stronger IP validation now that we have a candidate that looks
161 : : * close enough
162 : : */
163 [ + + ][ + + ]: 8166 : if((res == 1) && (inet_aton(ip_str, &in) == 0))
164 : 13 : res = 0;
165 : : #endif
166 : :
167 : 8166 : return(res);
168 : : }
169 : :
170 : : /* Convert a digest_type string to its integer value.
171 : : */
172 : : short
173 : 4540 : digest_strtoint(const char *dt_str)
174 : : {
175 [ + - ]: 4540 : if(strcasecmp(dt_str, "md5") == 0)
176 : : return(FKO_DIGEST_MD5);
177 [ + + ]: 4540 : else if(strcasecmp(dt_str, "sha1") == 0)
178 : : return(FKO_DIGEST_SHA1);
179 [ + + ]: 4366 : else if(strcasecmp(dt_str, "sha256") == 0)
180 : : return(FKO_DIGEST_SHA256);
181 [ + - ]: 2261 : else if(strcasecmp(dt_str, "sha384") == 0)
182 : : return(FKO_DIGEST_SHA384);
183 [ + - ]: 2261 : else if(strcasecmp(dt_str, "sha512") == 0)
184 : : return(FKO_DIGEST_SHA512);
185 : : else
186 : 2261 : return(-1);
187 : : }
188 : :
189 : : /**
190 : : * \brief Return a digest string according to a digest integer value
191 : : *
192 : : * This function checks the digest integer is valid, and write the digest
193 : : * string associated.
194 : : *
195 : : * \param digest Digest inetger value (FKO_DIGEST_MD5, FKO_DIGEST_SHA1 ...)
196 : : * \param digest_str Buffer to write the digest string
197 : : * \param digest_size size of the digest string buffer
198 : : *
199 : : * \return -1 if the digest integer value is not supported, 0 otherwise
200 : : */
201 : : short
202 : 449 : digest_inttostr(int digest, char* digest_str, size_t digest_size)
203 : : {
204 : 449 : short digest_not_valid = 0;
205 : :
206 : : memset(digest_str, 0, digest_size);
207 : :
208 [ + + + + : 449 : switch (digest)
+ - ]
209 : : {
210 : : case FKO_DIGEST_MD5:
211 : 31 : strlcpy(digest_str, "MD5", digest_size);
212 : 31 : break;
213 : : case FKO_DIGEST_SHA1:
214 : 58 : strlcpy(digest_str, "SHA1", digest_size);
215 : 58 : break;
216 : : case FKO_DIGEST_SHA256:
217 : 356 : strlcpy(digest_str, "SHA256", digest_size);
218 : 356 : break;
219 : : case FKO_DIGEST_SHA384:
220 : 3 : strlcpy(digest_str, "SHA384", digest_size);
221 : 3 : break;
222 : : case FKO_DIGEST_SHA512:
223 : 1 : strlcpy(digest_str, "SHA512", digest_size);
224 : 1 : break;
225 : : default:
226 : 0 : strlcpy(digest_str, "Unknown", digest_size);
227 : 0 : digest_not_valid = -1;
228 : 0 : break;
229 : : }
230 : :
231 : 449 : return digest_not_valid;
232 : : }
233 : :
234 : : short
235 : 6176 : hmac_digest_strtoint(const char *dt_str)
236 : : {
237 [ + - ]: 6176 : if(strcasecmp(dt_str, "md5") == 0)
238 : : return(FKO_HMAC_MD5);
239 [ + + ]: 6176 : else if(strcasecmp(dt_str, "sha1") == 0)
240 : : return(FKO_HMAC_SHA1);
241 [ + + ]: 5462 : else if(strcasecmp(dt_str, "sha256") == 0)
242 : : return(FKO_HMAC_SHA256);
243 [ + - ]: 2619 : else if(strcasecmp(dt_str, "sha384") == 0)
244 : : return(FKO_HMAC_SHA384);
245 [ + + ]: 2619 : else if(strcasecmp(dt_str, "sha512") == 0)
246 : : return(FKO_HMAC_SHA512);
247 : : else
248 : 2606 : return(-1);
249 : : }
250 : :
251 : : /* Return encryption type string representation
252 : : */
253 : : const char *
254 : 449 : enc_type_inttostr(const int type)
255 : : {
256 [ + - ]: 449 : if(type == FKO_ENC_MODE_UNKNOWN)
257 : : return("Unknown encryption type");
258 [ - + ]: 449 : else if(type == FKO_ENCRYPTION_RIJNDAEL)
259 : : return("Rijndael");
260 [ # # ]: 0 : else if(type == FKO_ENCRYPTION_GPG)
261 : : return("GPG");
262 : :
263 : 0 : return("Unknown encryption type");
264 : : }
265 : :
266 : : /* Return message type string representation
267 : : */
268 : : const char *
269 : 449 : msg_type_inttostr(const int type)
270 : : {
271 [ + + ]: 449 : if(type == FKO_COMMAND_MSG)
272 : : return("Command msg");
273 [ + + ]: 444 : else if(type == FKO_ACCESS_MSG)
274 : : return("Access msg");
275 [ + + ]: 9 : else if(type == FKO_NAT_ACCESS_MSG)
276 : : return("NAT access msg");
277 [ + + ]: 7 : else if(type == FKO_CLIENT_TIMEOUT_ACCESS_MSG)
278 : : return("Client timeout access msg");
279 [ + + ]: 3 : else if(type == FKO_CLIENT_TIMEOUT_NAT_ACCESS_MSG)
280 : : return("Client timeout NAT access msg");
281 [ + + ]: 2 : else if(type == FKO_LOCAL_NAT_ACCESS_MSG)
282 : : return("Local NAT access msg");
283 [ - + ]: 1 : else if(type == FKO_CLIENT_TIMEOUT_LOCAL_NAT_ACCESS_MSG)
284 : : return("Client timeout local NAT access msg");
285 : :
286 : 0 : return("Unknown message type");
287 : : }
288 : :
289 : : /**
290 : : * \brief Return a hmac digest string according to a hmac digest integer value
291 : : *
292 : : * This function checks if the digest integer is valid, and write the digest
293 : : * string associated.
294 : : *
295 : : * \param digest Digest inetger value (FKO_HMAC_MD5, FKO_HMAC_SHA1 ...)
296 : : * \param digest_str Buffer to write the digest string
297 : : * \param digest_size size of the digest string buffer
298 : : *
299 : : * \return -1 if the digest integer value is not supported, 0 otherwise
300 : : */
301 : : short
302 : 343 : hmac_digest_inttostr(int digest, char* digest_str, size_t digest_size)
303 : : {
304 : 343 : short digest_not_valid = 0;
305 : :
306 : : memset(digest_str, 0, digest_size);
307 : :
308 [ - + + - : 343 : switch (digest)
- - ]
309 : : {
310 : : case FKO_HMAC_MD5:
311 : 0 : strlcpy(digest_str, "MD5", digest_size);
312 : 0 : break;
313 : : case FKO_HMAC_SHA1:
314 : 73 : strlcpy(digest_str, "SHA1", digest_size);
315 : 73 : break;
316 : : case FKO_HMAC_SHA256:
317 : 270 : strlcpy(digest_str, "SHA256", digest_size);
318 : 270 : break;
319 : : case FKO_HMAC_SHA384:
320 : 0 : strlcpy(digest_str, "SHA384", digest_size);
321 : 0 : break;
322 : : case FKO_HMAC_SHA512:
323 : 0 : strlcpy(digest_str, "SHA512", digest_size);
324 : 0 : break;
325 : : default:
326 : 0 : strlcpy(digest_str, "Unknown", digest_size);
327 : 0 : digest_not_valid = -1;
328 : 0 : break;
329 : : }
330 : :
331 : 343 : return digest_not_valid;
332 : : }
333 : :
334 : : /* Validate plaintext input size
335 : : */
336 : : int
337 : 412 : is_valid_pt_msg_len(const int len)
338 : : {
339 : : #if HAVE_LIBFIU
340 : : fiu_return_on("is_valid_pt_msg_len_val", 0);
341 : : #endif
342 [ + - ]: 412 : if(len < MIN_SPA_PLAINTEXT_MSG_SIZE || len >= MAX_SPA_PLAINTEXT_MSG_SIZE)
343 : : return(0);
344 : :
345 : 412 : return(1);
346 : : }
347 : :
348 : : /**
349 : : * @brief Convert an encryption mode string to its integer value.
350 : : *
351 : : * @param enc_mode_str Encryption mode string (CBC,ECB...)
352 : : *
353 : : * @return -1 if the encryption mode string is not supported,
354 : : * otherwise the encryption mode value
355 : : */
356 : : int
357 : 5625 : enc_mode_strtoint(const char *enc_mode_str)
358 : : {
359 : : unsigned char ndx_enc_mode;
360 : 5625 : int enc_mode_int = -1; /* Encryption mode integer value */
361 : : fko_enc_mode_str_t *enc_mode_str_pt;
362 : :
363 : : /* Look into the fko_enc_mode_strs array to find out the right encryption mode */
364 [ + + ]: 34697 : for (ndx_enc_mode = 0 ; ndx_enc_mode < ARRAY_SIZE(fko_enc_mode_strs) ; ndx_enc_mode++)
365 : : {
366 : 31879 : enc_mode_str_pt = &(fko_enc_mode_strs[ndx_enc_mode]);
367 : :
368 : : /* If the encryption mode matches, grab it */
369 [ + + ]: 31879 : if ( (strcasecmp(enc_mode_str, enc_mode_str_pt->str) == 0)
370 [ + + ]: 2825 : && (enc_mode_str_pt->supported == FKO_ENC_MODE_SUPPORTED) )
371 : : {
372 : 2807 : enc_mode_int = enc_mode_str_pt->val;
373 : 2807 : break;
374 : : }
375 : : }
376 : :
377 : 5625 : return enc_mode_int;
378 : : }
379 : :
380 : : /**
381 : : * @brief Return an encryption mode string according to an enc_mode integer value
382 : : *
383 : : * This function checks if the encryption mode integer is valid, and write the
384 : : * encryption mode string associated.
385 : : *
386 : : * @param enc_mode Encryption mode integer value (FKO_ENC_MODE_CBC, FKO_ENC_MODE_ECB ...)
387 : : * @param enc_mode_str Buffer to write the encryption mode string to
388 : : * @param enc_mode_size Size of the encryption mode string buffer
389 : : *
390 : : * @return -1 if the encryption mode integer value is not supported, 0 otherwise
391 : : */
392 : : short
393 : 449 : enc_mode_inttostr(int enc_mode, char* enc_mode_str, size_t enc_mode_size)
394 : : {
395 : 449 : short enc_mode_error = -1;
396 : : unsigned char ndx_enc_mode;
397 : : fko_enc_mode_str_t *enc_mode_str_pt;
398 : :
399 : : /* Initialize the protocol string */
400 : : memset(enc_mode_str, 0, enc_mode_size);
401 : :
402 : : /* Look into the fko_enc_mode_strs array to find out the right protocol */
403 [ + - ]: 497 : for (ndx_enc_mode = 0 ; ndx_enc_mode < ARRAY_SIZE(fko_enc_mode_strs) ; ndx_enc_mode++)
404 : : {
405 : 497 : enc_mode_str_pt = &(fko_enc_mode_strs[ndx_enc_mode]);
406 : :
407 : : /* If the encryption mode matches, grab it */
408 [ + + ]: 497 : if ( (enc_mode_str_pt->val == enc_mode)
409 [ + - ]: 449 : && (enc_mode_str_pt->supported == FKO_ENC_MODE_SUPPORTED) )
410 : : {
411 : 449 : strlcpy(enc_mode_str, enc_mode_str_pt->str, enc_mode_size);
412 : 449 : enc_mode_error = 0;
413 : 449 : break;
414 : : }
415 : : }
416 : :
417 : 449 : return enc_mode_error;
418 : : }
419 : :
420 : : int
421 : 28589 : strtol_wrapper(const char * const str, const int min,
422 : : const int max, const int exit_upon_err, int *err)
423 : : {
424 : : int val;
425 : :
426 : 28589 : errno = 0;
427 : 28589 : *err = FKO_SUCCESS;
428 : :
429 : 28589 : val = strtol(str, (char **) NULL, 10);
430 : :
431 [ + + ][ - + ]: 28589 : if ((errno == ERANGE || (errno != 0 && val == 0)))
[ # # ]
432 : : {
433 : 173 : *err = errno;
434 [ - + ]: 173 : if(exit_upon_err == EXIT_UPON_ERR)
435 : : {
436 : 0 : perror("strtol");
437 : 0 : fprintf(stderr, "[*] Value %d out of range [(%d)-(%d)]\n",
438 : : val, min, max);
439 : 0 : exit(EXIT_FAILURE);
440 : : }
441 : : }
442 : :
443 [ + + ]: 28589 : if(val < min)
444 : : {
445 : 344 : *err = FKO_ERROR_INVALID_DATA_UTIL_STRTOL_LT_MIN;
446 [ - + ]: 344 : if(exit_upon_err == EXIT_UPON_ERR)
447 : : {
448 : 0 : fprintf(stderr, "[*] Value %d out of range [(%d)-(%d)]\n",
449 : : val, min, max);
450 : 0 : exit(EXIT_FAILURE);
451 : : }
452 : : }
453 : :
454 : : /* allow max == -1 to be an exception where we don't care about the
455 : : * maximum - note that the ERANGE check is still in place above
456 : : */
457 [ + + ]: 28589 : if((max >= 0) && (val > max))
458 : : {
459 : 2014 : *err = FKO_ERROR_INVALID_DATA_UTIL_STRTOL_GT_MAX;
460 [ - + ]: 2014 : if(exit_upon_err == EXIT_UPON_ERR)
461 : : {
462 : 0 : fprintf(stderr, "[*] Value %d out of range [(%d)-(%d)]\n",
463 : : val, min, max);
464 : 0 : exit(EXIT_FAILURE);
465 : : }
466 : : }
467 : :
468 : : #if HAVE_LIBFIU
469 : : fiu_return_on("strtol_wrapper_lt_min",
470 : : FKO_ERROR_INVALID_DATA_UTIL_STRTOL_LT_MIN);
471 : : fiu_return_on("strtol_wrapper_gt_max",
472 : : FKO_ERROR_INVALID_DATA_UTIL_STRTOL_GT_MAX);
473 : : #endif
474 : :
475 : 28589 : return val;
476 : : }
477 : :
478 : : /* zero out a buffer before free()
479 : : */
480 : 5614 : int zero_free(char *buf, int len)
481 : : {
482 : 5614 : int res = FKO_SUCCESS;
483 : :
484 [ + - ]: 5614 : if(buf == NULL)
485 : : return res;
486 : :
487 [ + + ]: 5614 : if(len == 0)
488 : : {
489 : 1 : free(buf); /* always free() if buf != NULL */
490 : 1 : return res;
491 : : }
492 : :
493 : 5613 : res = zero_buf(buf, len);
494 : :
495 : 5613 : free(buf);
496 : :
497 : : #if HAVE_LIBFIU
498 : : fiu_return_on("zero_free_err", FKO_ERROR_ZERO_OUT_DATA);
499 : : #endif
500 : :
501 : 5613 : return res;
502 : : }
503 : :
504 : : /* zero out sensitive information in a way that isn't optimized out by the compiler
505 : : * since we force a comparision and return an error if there is a problem (though
506 : : * the caller should do something with this information too).
507 : : */
508 : : int
509 : 37753 : zero_buf(char *buf, int len)
510 : : {
511 : 37753 : int i, res = FKO_SUCCESS;
512 : :
513 : : #if HAVE_LIBFIU
514 : : fiu_return_on("zero_buf_err", FKO_ERROR_ZERO_OUT_DATA);
515 : : #endif
516 : :
517 [ + - ]: 37753 : if(buf == NULL || len == 0)
518 : : return res;
519 : :
520 [ + - ]: 37753 : if(len < 0 || len > MAX_SPA_ENCODED_MSG_SIZE)
521 : : return FKO_ERROR_ZERO_OUT_DATA;
522 : :
523 [ + + ]: 2570321 : for(i=0; i < len; i++)
524 : 2532568 : buf[i] = 0x0;
525 : :
526 [ + + ]: 2570321 : for(i=0; i < len; i++)
527 [ - + ]: 2532568 : if(buf[i] != 0x0)
528 : 0 : res = FKO_ERROR_ZERO_OUT_DATA;
529 : :
530 : 37753 : return res;
531 : : }
532 : :
533 : : #if defined(WIN32) || !defined(HAVE_STRNDUP)
534 : : /* Windows does not have strndup, so we well implement it here.
535 : : * This was the Public Domain C Library (PDCLib).
536 : : */
537 : : char
538 : : *strndup( const char * s, size_t len )
539 : : {
540 : : char* ns = NULL;
541 : : if(s) {
542 : : ns = calloc(1, len + 1);
543 : : if(ns) {
544 : : ns[len] = 0;
545 : : // strncpy to be pedantic about modification in multithreaded
546 : : // applications
547 : : return strncpy(ns, s, len);
548 : : }
549 : : }
550 : : return ns;
551 : : }
552 : : #endif
553 : :
554 : : /**
555 : : * @brief Add a printf style message to a buffer
556 : : *
557 : : * This function allows to append a printf style message to a buffer
558 : : * and prevents buffer overflow by taking care of the size the buffer.
559 : : * It returns the number of bytes really written to the buffer.
560 : : * Thus if an error is encoutered during the process the number of bytes
561 : : * written is set to 0. This way the user knows exactly how many bytes
562 : : * can be appended afterwards.
563 : : *
564 : : * @param buf Buffer to write the formated message to
565 : : * @param buf_size Maximum number of bytes to write to the buffer
566 : : * @param msg Message to format and to append to the buffer
567 : : *
568 : : * @return the number of bytes written to the buffer
569 : : */
570 : : static int
571 : 8082 : append_msg_to_buf(char *buf, size_t buf_size, const char* msg, ...)
572 : : {
573 : 8082 : int bytes_written = 0; /* Number of bytes written to buf */
574 : : va_list ap;
575 : :
576 : : /* Check if the buffer is valid */
577 [ + - ]: 8082 : if (buf_size > 0)
578 : : {
579 : 8082 : va_start(ap, msg);
580 : :
581 : : /* Format the message like a printf message */
582 : 8082 : bytes_written = vsnprintf(buf, buf_size, msg, ap);
583 : :
584 : : /* It looks like the message has been truncated or an error occured*/
585 [ + - ]: 8082 : if (bytes_written < 0)
586 : : bytes_written = 0;
587 : :
588 [ - + ]: 8082 : else if (bytes_written >= buf_size)
589 : 0 : bytes_written = buf_size;
590 : :
591 : : /* The messsage has been formatted correctly */
592 : : else;
593 : :
594 : 8082 : va_end(ap);
595 : : }
596 : :
597 : : /* No valid buffer has been supplied, thus we do not write anything */
598 : : else;
599 : :
600 : : /* Return the number of bytes written to the buffer */
601 : 8082 : return bytes_written;
602 : : }
603 : :
604 : : /* Determine if a buffer contains only characters from the base64
605 : : * encoding set
606 : : */
607 : : int
608 : 7262 : is_base64(const unsigned char * const buf, const unsigned short int len)
609 : : {
610 : : unsigned short int i;
611 : 7262 : int rv = 1;
612 : :
613 [ + + ]: 88509 : for(i=0; i<len; i++)
614 : : {
615 [ + + ][ + + ]: 84527 : if(!(isalnum(buf[i]) || buf[i] == '/' || buf[i] == '+' || buf[i] == '='))
[ + + ][ + + ]
616 : : {
617 : : rv = 0;
618 : : break;
619 : : }
620 : : }
621 : :
622 : 7262 : return rv;
623 : : }
624 : :
625 : : /**
626 : : * @brief Dump a FKO context to a buffer
627 : : *
628 : : * This function parses a FKO context and decodes each field to dump them to a
629 : : * buffer in a comprehensible way.
630 : : *
631 : : * @param ctx FKO context to dump
632 : : * @param dump_buf Buffer where to store the dump of the context
633 : : * @param dump_buf_len Number of bytes available in the dump_buf array
634 : : *
635 : : * @return a FKO error code. FKO_SUCCESS if successful.
636 : : */
637 : : int
638 : 449 : dump_ctx_to_buffer(fko_ctx_t ctx, char *dump_buf, size_t dump_buf_len)
639 : : {
640 : 449 : int cp = 0;
641 : 449 : int err = FKO_LAST_ERROR;
642 : :
643 : 449 : char *rand_val = NULL;
644 : 449 : char *username = NULL;
645 : 449 : char *version = NULL;
646 : 449 : char *spa_message = NULL;
647 : 449 : char *nat_access = NULL;
648 : 449 : char *server_auth = NULL;
649 : 449 : char *enc_data = NULL;
650 : 449 : char *hmac_data = NULL;
651 : 449 : char *spa_digest = NULL;
652 : : #if HAVE_LIBGPGME
653 : 449 : char *gpg_signer = NULL;
654 : 449 : char *gpg_recip = NULL;
655 : 449 : char *gpg_sig_id = NULL;
656 : 449 : unsigned char gpg_sig_verify = 0;
657 : 449 : unsigned char gpg_ignore_verify = 0;
658 : 449 : char *gpg_sig_fpr = NULL;
659 : 449 : char *gpg_home_dir = NULL;
660 : 449 : char *gpg_exe = NULL;
661 : 449 : int gpg_sigsum = -1;
662 : 449 : int gpg_sig_stat = -1;
663 : : #endif
664 : 449 : char *spa_data = NULL;
665 : 449 : char digest_str[24] = {0};
666 : 449 : char hmac_str[24] = {0};
667 : 449 : char enc_mode_str[FKO_ENCRYPTION_MODE_BUFSIZE] = {0};
668 : :
669 : 449 : time_t timestamp = 0;
670 : 449 : short msg_type = -1;
671 : 449 : short digest_type = -1;
672 : 449 : short hmac_type = -1;
673 : 449 : short encryption_type = -1;
674 : 449 : int encryption_mode = -1;
675 : 449 : int client_timeout = -1;
676 : :
677 : : /* Zero-ed the buffer */
678 : : memset(dump_buf, 0, dump_buf_len);
679 : :
680 : : /* Make sure the FKO context is initialized before printing it */
681 [ + - ][ + - ]: 449 : if(!CTX_INITIALIZED(ctx))
682 : : err = FKO_ERROR_CTX_NOT_INITIALIZED;
683 : :
684 : : else
685 : : {
686 : : /* Parse the FKO context and collect data */
687 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_rand_value(ctx, &rand_val));
688 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_username(ctx, &username));
689 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_timestamp(ctx, ×tamp));
690 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_version(ctx, &version));
691 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_spa_message_type(ctx, &msg_type));
692 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_spa_message(ctx, &spa_message));
693 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_spa_nat_access(ctx, &nat_access));
694 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_spa_server_auth(ctx, &server_auth));
695 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_spa_client_timeout(ctx, &client_timeout));
696 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_spa_digest_type(ctx, &digest_type));
697 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_spa_hmac_type(ctx, &hmac_type));
698 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_spa_encryption_type(ctx, &encryption_type));
699 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_spa_encryption_mode(ctx, &encryption_mode));
700 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_encoded_data(ctx, &enc_data));
701 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_spa_hmac(ctx, &hmac_data));
702 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_spa_digest(ctx, &spa_digest));
703 [ + - ]: 449 : RETURN_ON_FKO_ERROR(err, fko_get_spa_data(ctx, &spa_data));
704 : :
705 : : #if HAVE_LIBGPGME
706 [ - + ]: 449 : if(encryption_mode == FKO_ENC_MODE_ASYMMETRIC)
707 : : {
708 : : /* Populate GPG variables
709 : : */
710 [ # # ]: 0 : RETURN_ON_FKO_ERROR(err, fko_get_gpg_signer(ctx, &gpg_signer));
711 [ # # ]: 0 : RETURN_ON_FKO_ERROR(err, fko_get_gpg_recipient(ctx, &gpg_recip));
712 [ # # ]: 0 : RETURN_ON_FKO_ERROR(err, fko_get_gpg_signature_verify(ctx, &gpg_sig_verify));
713 [ # # ]: 0 : RETURN_ON_FKO_ERROR(err, fko_get_gpg_ignore_verify_error(ctx, &gpg_ignore_verify));
714 [ # # ]: 0 : RETURN_ON_FKO_ERROR(err, fko_get_gpg_home_dir(ctx, &gpg_home_dir));
715 [ # # ]: 0 : RETURN_ON_FKO_ERROR(err, fko_get_gpg_exe(ctx, &gpg_exe));
716 [ # # ]: 0 : if(fko_get_gpg_signature_id(ctx, &gpg_sig_id) != FKO_SUCCESS)
717 : 0 : gpg_sig_id = NULL;
718 [ # # ]: 0 : if(fko_get_gpg_signature_summary(ctx, &gpg_sigsum) != FKO_SUCCESS)
719 : 0 : gpg_sigsum = -1;
720 [ # # ]: 0 : if(fko_get_gpg_signature_status(ctx, &gpg_sig_stat) != FKO_SUCCESS)
721 : 0 : gpg_sig_stat = -1;
722 [ # # ]: 0 : if(fko_get_gpg_signature_fpr(ctx, &gpg_sig_fpr) != FKO_SUCCESS)
723 : 0 : gpg_sig_fpr = NULL;
724 : : }
725 : : #endif
726 : :
727 : : /* Convert the digest integer to a string */
728 [ + - ]: 449 : if (digest_inttostr(digest_type, digest_str, sizeof(digest_str)) != 0)
729 : : return (FKO_ERROR_INVALID_DIGEST_TYPE);
730 : :
731 : : /* Convert the encryption mode integer to a string */
732 [ + - ]: 449 : if (enc_mode_inttostr(encryption_mode, enc_mode_str, sizeof(enc_mode_str)) != 0)
733 : : return (FKO_ERROR_INVALID_ENCRYPTION_TYPE);
734 : :
735 : : /* Convert the HMAC digest integer to a string if a HMAC message is available */
736 [ + + ]: 449 : if (ctx->msg_hmac_len != 0)
737 : : {
738 [ + - ]: 343 : if (hmac_digest_inttostr(hmac_type, hmac_str, sizeof(hmac_str)) != 0)
739 : : return (FKO_ERROR_UNSUPPORTED_HMAC_MODE);
740 : : }
741 : :
742 : : /* Fill in the buffer to dump */
743 : 449 : cp = append_msg_to_buf(dump_buf, dump_buf_len, "SPA Field Values:\n=================\n");
744 [ + - ]: 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " Random Value: %s\n", rand_val == NULL ? NULL_STRING : rand_val);
745 [ + - ]: 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " Username: %s\n", username == NULL ? NULL_STRING : username);
746 : 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " Timestamp: %u\n", (unsigned int) timestamp);
747 [ + - ]: 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " FKO Version: %s\n", version == NULL ? NULL_STRING : version);
748 : 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " Message Type: %i (%s)\n", msg_type, msg_type_inttostr(msg_type));
749 [ + - ]: 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " Message String: %s\n", spa_message == NULL ? NULL_STRING : spa_message);
750 [ + + ]: 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " Nat Access: %s\n", nat_access == NULL ? NULL_STRING : nat_access);
751 [ + + ]: 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " Server Auth: %s\n", server_auth == NULL ? NULL_STRING : server_auth);
752 : 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " Client Timeout: %u\n", client_timeout);
753 : 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " Digest Type: %u (%s)\n", digest_type, digest_str);
754 [ + + ]: 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " HMAC Type: %u (%s)\n", hmac_type, hmac_type == 0 ? "None" : hmac_str);
755 : 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, "Encryption Type: %d (%s)\n", encryption_type, enc_type_inttostr(encryption_type));
756 : 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, "Encryption Mode: %d (%s)\n", encryption_mode, enc_mode_str);
757 : : #if HAVE_LIBGPGME
758 [ - + ]: 449 : if(encryption_mode == FKO_ENC_MODE_ASYMMETRIC)
759 : : {
760 [ # # ]: 0 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " GPG signer: %s\n", gpg_signer == NULL ? NULL_STRING : gpg_signer);
761 [ # # ]: 0 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " GPG recipient: %s\n", gpg_recip == NULL ? NULL_STRING : gpg_recip);
762 [ # # ]: 0 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " GPG sig verify: %s\n", gpg_sig_verify == 0 ? "No" : "Yes");
763 [ # # ]: 0 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " GPG ignore sig: %s\n", gpg_ignore_verify == 0 ? "No" : "Yes");
764 [ # # ]: 0 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " GPG sig ID: %s\n", gpg_sig_id == NULL ? NULL_STRING : gpg_sig_id);
765 [ # # ]: 0 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " GPG sig fpr: %s\n", gpg_sig_fpr == NULL ? NULL_STRING : gpg_sig_fpr);
766 : 0 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, "GPG sig summary: %d\n", gpg_sigsum);
767 : 0 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " GPG sig status: %d\n", gpg_sig_stat);
768 [ # # ]: 0 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " GPG home dir: %s\n", gpg_home_dir == NULL ? NULL_STRING : gpg_home_dir);
769 [ # # ]: 0 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " GPG exe: %s\n", gpg_exe == NULL ? GPG_EXE : gpg_exe);
770 : : }
771 : : #endif
772 [ + - ]: 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " Encoded Data: %s\n", enc_data == NULL ? NULL_STRING : enc_data);
773 [ + - ]: 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, "SPA Data Digest: %s\n", spa_digest == NULL ? NULL_STRING : spa_digest);
774 [ + + ]: 449 : cp += append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " HMAC: %s\n", hmac_data == NULL ? NULL_STRING : hmac_data);
775 : 449 : append_msg_to_buf(dump_buf+cp, dump_buf_len-cp, " Final SPA Data: %s\n", spa_data);
776 : :
777 : 449 : err = FKO_SUCCESS;
778 : : }
779 : :
780 : 449 : return (err);
781 : : }
782 : :
783 : : /***EOF***/
|
