![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to chunk.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / utils|
Return to chunk.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / utils |
1.1 misho 1: /*
2: * Copyright (C) 2008-2019 Tobias Brunner
3: * Copyright (C) 2005-2006 Martin Willi
4: * Copyright (C) 2005 Jan Hutter
5: * HSR Hochschule fuer Technik Rapperswil
6: *
7: * This program is free software; you can redistribute it and/or modify it
8: * under the terms of the GNU General Public License as published by the
9: * Free Software Foundation; either version 2 of the License, or (at your
10: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
11: *
12: * This program is distributed in the hope that it will be useful, but
13: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15: * for more details.
16: */
17:
18: #include <stdio.h>
19: #include <sys/types.h>
20: #include <sys/stat.h>
21: #ifdef HAVE_MMAP
22: # include <sys/mman.h>
23: #endif
24: #include <fcntl.h>
25: #include <unistd.h>
26: #include <errno.h>
27: #include <ctype.h>
28: #include <time.h>
29:
30: #include "chunk.h"
31:
32: /**
33: * Empty chunk.
34: */
35: chunk_t chunk_empty = { NULL, 0 };
36:
37: /**
38: * Described in header.
39: */
40: chunk_t chunk_create_clone(u_char *ptr, chunk_t chunk)
41: {
42: chunk_t clone = chunk_empty;
43:
44: if (chunk.ptr && chunk.len > 0)
45: {
46: clone.ptr = ptr;
47: clone.len = chunk.len;
48: memcpy(clone.ptr, chunk.ptr, chunk.len);
49: }
50:
51: return clone;
52: }
53:
54: /**
55: * Described in header.
56: */
57: size_t chunk_length(const char* mode, ...)
58: {
59: va_list chunks;
60: size_t length = 0;
61:
62: va_start(chunks, mode);
63: while (TRUE)
64: {
65: switch (*mode++)
66: {
67: case 'm':
68: case 'c':
69: case 's':
70: {
71: chunk_t ch = va_arg(chunks, chunk_t);
72: length += ch.len;
73: continue;
74: }
75: default:
76: break;
77: }
78: break;
79: }
80: va_end(chunks);
81: return length;
82: }
83:
84: /**
85: * Described in header.
86: */
87: chunk_t chunk_create_cat(u_char *ptr, const char* mode, ...)
88: {
89: va_list chunks;
90: chunk_t construct = chunk_create(ptr, 0);
91:
92: va_start(chunks, mode);
93: while (TRUE)
94: {
95: bool free_chunk = FALSE, clear_chunk = FALSE;
96: chunk_t ch;
97:
98: switch (*mode++)
99: {
100: case 's':
101: clear_chunk = TRUE;
102: /* FALL */
103: case 'm':
104: free_chunk = TRUE;
105: /* FALL */
106: case 'c':
107: ch = va_arg(chunks, chunk_t);
108: memcpy(ptr, ch.ptr, ch.len);
109: ptr += ch.len;
110: construct.len += ch.len;
111: if (clear_chunk)
112: {
113: chunk_clear(&ch);
114: }
115: else if (free_chunk)
116: {
117: free(ch.ptr);
118: }
119: continue;
120: default:
121: break;
122: }
123: break;
124: }
125: va_end(chunks);
126:
127: return construct;
128: }
129:
130: /**
131: * Described in header.
132: */
133: void chunk_split(chunk_t chunk, const char *mode, ...)
134: {
135: va_list chunks;
136: u_int len;
137: chunk_t *ch;
138:
139: va_start(chunks, mode);
140: while (TRUE)
141: {
142: if (*mode == '\0')
143: {
144: break;
145: }
146: len = va_arg(chunks, u_int);
147: ch = va_arg(chunks, chunk_t*);
148: /* a null chunk means skip len bytes */
149: if (ch == NULL)
150: {
151: chunk = chunk_skip(chunk, len);
152: continue;
153: }
154: switch (*mode++)
155: {
156: case 'm':
157: {
158: ch->len = min(chunk.len, len);
159: if (ch->len)
160: {
161: ch->ptr = chunk.ptr;
162: }
163: else
164: {
165: ch->ptr = NULL;
166: }
167: chunk = chunk_skip(chunk, ch->len);
168: continue;
169: }
170: case 'a':
171: {
172: ch->len = min(chunk.len, len);
173: if (ch->len)
174: {
175: ch->ptr = malloc(ch->len);
176: memcpy(ch->ptr, chunk.ptr, ch->len);
177: }
178: else
179: {
180: ch->ptr = NULL;
181: }
182: chunk = chunk_skip(chunk, ch->len);
183: continue;
184: }
185: case 'c':
186: {
187: ch->len = min(ch->len, chunk.len);
188: ch->len = min(ch->len, len);
189: if (ch->len)
190: {
191: memcpy(ch->ptr, chunk.ptr, ch->len);
192: }
193: else
194: {
195: ch->ptr = NULL;
196: }
197: chunk = chunk_skip(chunk, ch->len);
198: continue;
199: }
200: default:
201: break;
202: }
203: break;
204: }
205: va_end(chunks);
206: }
207:
208: /**
209: * Described in header.
210: */
211: bool chunk_write(chunk_t chunk, char *path, mode_t mask, bool force)
212: {
213: mode_t oldmask;
214: FILE *fd;
215: bool good = FALSE;
216: int tmp = 0;
217:
218: if (!force && access(path, F_OK) == 0)
219: {
220: errno = EEXIST;
221: return FALSE;
222: }
223: oldmask = umask(mask);
224: fd = fopen(path,
225: #ifdef WIN32
226: "wb"
227: #else
228: "w"
229: #endif
230: );
231:
232: if (fd)
233: {
234: if (fwrite(chunk.ptr, sizeof(u_char), chunk.len, fd) == chunk.len)
235: {
236: good = TRUE;
237: }
238: else
239: {
240: tmp = errno;
241: }
242: fclose(fd);
243: }
244: else
245: {
246: tmp = errno;
247: }
248: umask(oldmask);
249: errno = tmp;
250: return good;
251: }
252:
253: /**
254: * Described in header.
255: */
256: bool chunk_from_fd(int fd, chunk_t *out)
257: {
258: struct stat sb;
259: char *buf, *tmp;
260: ssize_t len, total = 0, bufsize;
261:
262: if (fstat(fd, &sb) == 0 && S_ISREG(sb.st_mode))
263: {
264: bufsize = sb.st_size;
265: }
266: else
267: {
268: bufsize = 256;
269: }
270: buf = malloc(bufsize);
271: if (!buf)
272: { /* for huge files */
273: return FALSE;
274: }
275:
276: while (TRUE)
277: {
278: len = read(fd, buf + total, bufsize - total);
279: #ifdef WIN32
280: if (len == -1 && errno == EBADF)
281: { /* operating on a Winsock socket? */
282: len = recv(fd, buf + total, bufsize - total, 0);
283: }
284: #endif
285: if (len < 0)
286: {
287: free(buf);
288: return FALSE;
289: }
290: if (len == 0)
291: {
292: break;
293: }
294: total += len;
295: if (total == bufsize)
296: {
297: bufsize *= 2;
298: tmp = realloc(buf, bufsize);
299: if (!tmp)
300: {
301: free(buf);
302: return FALSE;
303: }
304: buf = tmp;
305: }
306: }
307: if (total == 0)
308: {
309: free(buf);
310: buf = NULL;
311: }
312: else if (total < bufsize)
313: {
314: buf = realloc(buf, total);
315: }
316: *out = chunk_create(buf, total);
317: return TRUE;
318: }
319:
320: /**
321: * Implementation for mmap()ed chunks
322: */
323: typedef struct {
324: /* public chunk interface */
325: chunk_t public;
326: /* FD of open file */
327: int fd;
328: /* mmap() address */
329: void *map;
330: /* size of map */
331: size_t len;
332: /* do we write? */
333: bool wr;
334: } mmaped_chunk_t;
335:
336: /**
337: * See header.
338: */
339: chunk_t *chunk_map(char *path, bool wr)
340: {
341: mmaped_chunk_t *chunk;
342: struct stat sb;
343: int tmp, flags;
344:
345: flags = wr ? O_RDWR : O_RDONLY;
346: #ifdef WIN32
347: flags |= O_BINARY;
348: #endif
349:
350: INIT(chunk,
351: .fd = open(path, flags),
352: .wr = wr,
353: );
354:
355: if (chunk->fd == -1)
356: {
357: free(chunk);
358: return NULL;
359: }
360: if (fstat(chunk->fd, &sb) == -1)
361: {
362: tmp = errno;
363: chunk_unmap(&chunk->public);
364: errno = tmp;
365: return NULL;
366: }
367: #ifdef HAVE_MMAP
368: chunk->len = sb.st_size;
369: /* map non-empty files only, as mmap() complains otherwise */
370: if (chunk->len)
371: {
372: /* in read-only mode, we allow writes, but don't sync to disk */
373: chunk->map = mmap(NULL, chunk->len, PROT_READ | PROT_WRITE,
374: wr ? MAP_SHARED : MAP_PRIVATE, chunk->fd, 0);
375: if (chunk->map == MAP_FAILED)
376: {
377: tmp = errno;
378: chunk_unmap(&chunk->public);
379: errno = tmp;
380: return NULL;
381: }
382: }
383: chunk->public = chunk_create(chunk->map, chunk->len);
384: #else /* !HAVE_MMAP */
385: if (!chunk_from_fd(chunk->fd, &chunk->public))
386: {
387: tmp = errno;
388: chunk_unmap(&chunk->public);
389: errno = tmp;
390: return NULL;
391: }
392: chunk->map = chunk->public.ptr;
393: chunk->len = chunk->public.len;
394: #endif /* !HAVE_MMAP */
395: return &chunk->public;
396: }
397:
398: /**
399: * See header.
400: */
401: bool chunk_unmap(chunk_t *public)
402: {
403: mmaped_chunk_t *chunk;
404: bool ret = FALSE;
405: int tmp = 0;
406:
407: chunk = (mmaped_chunk_t*)public;
408: #ifdef HAVE_MMAP
409: if (chunk->map && chunk->map != MAP_FAILED)
410: {
411: ret = munmap(chunk->map, chunk->len) == 0;
412: tmp = errno;
413: }
414: #else /* !HAVE_MMAP */
415: if (chunk->wr)
416: {
417: if (lseek(chunk->fd, 0, SEEK_SET) != -1)
418: {
419: int len, total = 0;
420:
421: ret = TRUE;
422: while (total < chunk->len)
423: {
424: len = write(chunk->fd, chunk->map + total, chunk->len - total);
425: if (len <= 0)
426: {
427: ret = FALSE;
428: break;
429: }
430: total += len;
431: }
432: }
433: tmp = errno;
434: }
435: else
436: {
437: ret = TRUE;
438: }
439: free(chunk->map);
440: #endif /* !HAVE_MMAP */
441: close(chunk->fd);
442: free(chunk);
443: errno = tmp;
444:
445: return ret;
446: }
447:
448: /** hex conversion digits */
449: static char hexdig_upper[] = "0123456789ABCDEF";
450: static char hexdig_lower[] = "0123456789abcdef";
451:
452: /**
453: * Described in header.
454: */
455: chunk_t chunk_to_hex(chunk_t chunk, char *buf, bool uppercase)
456: {
457: int i, len;
458: char *hexdig = hexdig_lower;
459:
460: if (uppercase)
461: {
462: hexdig = hexdig_upper;
463: }
464:
465: len = chunk.len * 2;
466: if (!buf)
467: {
468: buf = malloc(len + 1);
469: }
470: buf[len] = '\0';
471:
472: for (i = 0; i < chunk.len; i++)
473: {
474: buf[i*2] = hexdig[(chunk.ptr[i] >> 4) & 0xF];
475: buf[i*2+1] = hexdig[(chunk.ptr[i] ) & 0xF];
476: }
477: return chunk_create(buf, len);
478: }
479:
480: /**
481: * convert a single hex character to its binary value
482: */
483: static char hex2bin(char hex)
484: {
485: switch (hex)
486: {
487: case '0' ... '9':
488: return hex - '0';
489: case 'A' ... 'F':
490: return hex - 'A' + 10;
491: case 'a' ... 'f':
492: return hex - 'a' + 10;
493: default:
494: return 0;
495: }
496: }
497:
498: /**
499: * Described in header.
500: */
501: chunk_t chunk_from_hex(chunk_t hex, char *buf)
502: {
503: int i, len;
504: u_char *ptr;
505: bool odd = FALSE;
506:
507: /* skip an optional 0x prefix */
508: if (hex.len > 1 && hex.ptr[1] == 'x' && hex.ptr[0] == '0')
509: {
510: hex = chunk_skip(hex, 2);
511: }
512:
513: /* subtract the number of optional ':' separation characters */
514: len = hex.len;
515: ptr = hex.ptr;
516: for (i = 0; i < hex.len; i++)
517: {
518: if (*ptr++ == ':')
519: {
520: len--;
521: }
522: }
523:
524: /* compute the number of binary bytes */
525: if (len % 2)
526: {
527: odd = TRUE;
528: len++;
529: }
530: len /= 2;
531:
532: /* allocate buffer memory unless provided by caller */
533: if (!buf)
534: {
535: buf = malloc(len);
536: }
537:
538: /* buffer is filled from the right */
539: memset(buf, 0, len);
540: hex.ptr += hex.len;
541:
542: for (i = len - 1; i >= 0; i--)
543: {
544: /* skip separation characters */
545: if (*(--hex.ptr) == ':')
546: {
547: --hex.ptr;
548: }
549: buf[i] = hex2bin(*hex.ptr);
550: if (i > 0 || !odd)
551: {
552: buf[i] |= hex2bin(*(--hex.ptr)) << 4;
553: }
554: }
555: return chunk_create(buf, len);
556: }
557:
558: /** base 64 conversion digits */
559: static char b64digits[] =
560: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
561:
562: /**
563: * Described in header.
564: */
565: chunk_t chunk_to_base64(chunk_t chunk, char *buf)
566: {
567: int i, len;
568: char *pos;
569:
570: len = chunk.len + ((3 - chunk.len % 3) % 3);
571: if (!buf)
572: {
573: buf = malloc(len * 4 / 3 + 1);
574: }
575: pos = buf;
576: for (i = 0; i < len; i+=3)
577: {
578: *pos++ = b64digits[chunk.ptr[i] >> 2];
579: if (i+1 >= chunk.len)
580: {
581: *pos++ = b64digits[(chunk.ptr[i] & 0x03) << 4];
582: *pos++ = '=';
583: *pos++ = '=';
584: break;
585: }
586: *pos++ = b64digits[((chunk.ptr[i] & 0x03) << 4) | (chunk.ptr[i+1] >> 4)];
587: if (i+2 >= chunk.len)
588: {
589: *pos++ = b64digits[(chunk.ptr[i+1] & 0x0F) << 2];
590: *pos++ = '=';
591: break;
592: }
593: *pos++ = b64digits[((chunk.ptr[i+1] & 0x0F) << 2) | (chunk.ptr[i+2] >> 6)];
594: *pos++ = b64digits[chunk.ptr[i+2] & 0x3F];
595: }
596: *pos = '\0';
597: return chunk_create(buf, len * 4 / 3);
598: }
599:
600: /**
601: * convert a base 64 digit to its binary form (inversion of b64digits array)
602: */
603: static int b642bin(char b64)
604: {
605: switch (b64)
606: {
607: case 'A' ... 'Z':
608: return b64 - 'A';
609: case 'a' ... 'z':
610: return ('Z' - 'A' + 1) + b64 - 'a';
611: case '0' ... '9':
612: return ('Z' - 'A' + 1) + ('z' - 'a' + 1) + b64 - '0';
613: case '+':
614: case '-':
615: return 62;
616: case '/':
617: case '_':
618: return 63;
619: case '=':
620: return 0;
621: default:
622: return -1;
623: }
624: }
625:
626: /**
627: * Described in header.
628: */
629: chunk_t chunk_from_base64(chunk_t base64, char *buf)
630: {
631: u_char *pos, byte[4];
632: int i, j, len, outlen;
633:
634: len = base64.len / 4 * 3;
635: if (!buf)
636: {
637: buf = malloc(len);
638: }
639: pos = base64.ptr;
640: outlen = 0;
641: for (i = 0; i < len; i+=3)
642: {
643: outlen += 3;
644: for (j = 0; j < 4; j++)
645: {
646: if (*pos == '=' && outlen > 0)
647: {
648: outlen--;
649: }
650: byte[j] = b642bin(*pos++);
651: }
652: buf[i] = (byte[0] << 2) | (byte[1] >> 4);
653: buf[i+1] = (byte[1] << 4) | (byte[2] >> 2);
654: buf[i+2] = (byte[2] << 6) | (byte[3]);
655: }
656: return chunk_create(buf, outlen);
657: }
658:
659: /** base 32 conversion digits */
660: static char b32digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
661:
662: /**
663: * Described in header.
664: */
665: chunk_t chunk_to_base32(chunk_t chunk, char *buf)
666: {
667: int i, len;
668: char *pos;
669:
670: len = chunk.len + ((5 - chunk.len % 5) % 5);
671: if (!buf)
672: {
673: buf = malloc(len * 8 / 5 + 1);
674: }
675: pos = buf;
676: for (i = 0; i < len; i+=5)
677: {
678: *pos++ = b32digits[chunk.ptr[i] >> 3];
679: if (i+1 >= chunk.len)
680: {
681: *pos++ = b32digits[(chunk.ptr[i] & 0x07) << 2];
682: memset(pos, '=', 6);
683: pos += 6;
684: break;
685: }
686: *pos++ = b32digits[((chunk.ptr[i] & 0x07) << 2) |
687: (chunk.ptr[i+1] >> 6)];
688: *pos++ = b32digits[(chunk.ptr[i+1] & 0x3E) >> 1];
689: if (i+2 >= chunk.len)
690: {
691: *pos++ = b32digits[(chunk.ptr[i+1] & 0x01) << 4];
692: memset(pos, '=', 4);
693: pos += 4;
694: break;
695: }
696: *pos++ = b32digits[((chunk.ptr[i+1] & 0x01) << 4) |
697: (chunk.ptr[i+2] >> 4)];
698: if (i+3 >= chunk.len)
699: {
700: *pos++ = b32digits[(chunk.ptr[i+2] & 0x0F) << 1];
701: memset(pos, '=', 3);
702: pos += 3;
703: break;
704: }
705: *pos++ = b32digits[((chunk.ptr[i+2] & 0x0F) << 1) |
706: (chunk.ptr[i+3] >> 7)];
707: *pos++ = b32digits[(chunk.ptr[i+3] & 0x7F) >> 2];
708: if (i+4 >= chunk.len)
709: {
710: *pos++ = b32digits[(chunk.ptr[i+3] & 0x03) << 3];
711: *pos++ = '=';
712: break;
713: }
714: *pos++ = b32digits[((chunk.ptr[i+3] & 0x03) << 3) |
715: (chunk.ptr[i+4] >> 5)];
716: *pos++ = b32digits[chunk.ptr[i+4] & 0x1F];
717: }
718: *pos = '\0';
719: return chunk_create(buf, len * 8 / 5);
720: }
721:
722: /**
723: * Described in header.
724: */
725: int chunk_compare(chunk_t a, chunk_t b)
726: {
727: int compare_len = a.len - b.len;
728: int len = (compare_len < 0)? a.len : b.len;
729:
730: if (compare_len != 0 || len == 0)
731: {
732: return compare_len;
733: }
734: return memcmp(a.ptr, b.ptr, len);
735: };
736:
737:
738: /**
739: * Described in header.
740: */
741: bool chunk_increment(chunk_t chunk)
742: {
743: int i;
744:
745: for (i = chunk.len - 1; i >= 0; i--)
746: {
747: if (++chunk.ptr[i] != 0)
748: {
749: return FALSE;
750: }
751: }
752: return TRUE;
753: }
754:
755: /*
756: * Described in header
757: */
758: chunk_t chunk_copy_pad(chunk_t dst, chunk_t src, u_char chr)
759: {
760: if (dst.ptr)
761: {
762: if (dst.len > src.len)
763: {
764: memcpy(dst.ptr + dst.len - src.len, src.ptr, src.len);
765: memset(dst.ptr, chr, dst.len - src.len);
766: }
767: else
768: {
769: memcpy(dst.ptr, src.ptr + src.len - dst.len, dst.len);
770: }
771: }
772: return dst;
773: }
774:
775: /**
776: * Remove non-printable characters from a chunk.
777: */
778: bool chunk_printable(chunk_t chunk, chunk_t *sane, char replace)
779: {
780: bool printable = TRUE;
781: int i;
782:
783: if (sane)
784: {
785: *sane = chunk_clone(chunk);
786: }
787: for (i = 0; i < chunk.len; i++)
788: {
789: if (!isprint(chunk.ptr[i]))
790: {
791: if (sane)
792: {
793: sane->ptr[i] = replace;
794: }
795: printable = FALSE;
796: }
797: }
798: return printable;
799: }
800:
801: /**
802: * Helper functions for chunk_mac()
803: */
804: static inline uint64_t sipget(u_char *in)
805: {
806: uint64_t v = 0;
807: int i;
808:
809: for (i = 0; i < 64; i += 8, ++in)
810: {
811: v |= ((uint64_t)*in) << i;
812: }
813: return v;
814: }
815:
816: static inline uint64_t siprotate(uint64_t v, int shift)
817: {
818: return (v << shift) | (v >> (64 - shift));
819: }
820:
821: static inline void sipround(uint64_t *v0, uint64_t *v1, uint64_t *v2,
822: uint64_t *v3)
823: {
824: *v0 += *v1;
825: *v1 = siprotate(*v1, 13);
826: *v1 ^= *v0;
827: *v0 = siprotate(*v0, 32);
828:
829: *v2 += *v3;
830: *v3 = siprotate(*v3, 16);
831: *v3 ^= *v2;
832:
833: *v2 += *v1;
834: *v1 = siprotate(*v1, 17);
835: *v1 ^= *v2;
836: *v2 = siprotate(*v2, 32);
837:
838: *v0 += *v3;
839: *v3 = siprotate(*v3, 21);
840: *v3 ^= *v0;
841: }
842:
843: static inline void sipcompress(uint64_t *v0, uint64_t *v1, uint64_t *v2,
844: uint64_t *v3, uint64_t m)
845: {
846: *v3 ^= m;
847: sipround(v0, v1, v2, v3);
848: sipround(v0, v1, v2, v3);
849: *v0 ^= m;
850: }
851:
852: static inline uint64_t siplast(size_t len, u_char *pos)
853: {
854: uint64_t b;
855: int rem = len & 7;
856:
857: b = ((uint64_t)len) << 56;
858: switch (rem)
859: {
860: case 7:
861: b |= ((uint64_t)pos[6]) << 48;
862: case 6:
863: b |= ((uint64_t)pos[5]) << 40;
864: case 5:
865: b |= ((uint64_t)pos[4]) << 32;
866: case 4:
867: b |= ((uint64_t)pos[3]) << 24;
868: case 3:
869: b |= ((uint64_t)pos[2]) << 16;
870: case 2:
871: b |= ((uint64_t)pos[1]) << 8;
872: case 1:
873: b |= ((uint64_t)pos[0]);
874: break;
875: case 0:
876: break;
877: }
878: return b;
879: }
880:
881: /**
882: * Calculate SipHash-2-4 with an optional first block given as argument.
883: */
884: static uint64_t chunk_mac_inc(chunk_t chunk, u_char *key, uint64_t m)
885: {
886: uint64_t v0, v1, v2, v3, k0, k1;
887: size_t len = chunk.len;
888: u_char *pos = chunk.ptr, *end;
889:
890: end = chunk.ptr + len - (len % 8);
891:
892: k0 = sipget(key);
893: k1 = sipget(key + 8);
894:
895: v0 = k0 ^ 0x736f6d6570736575ULL;
896: v1 = k1 ^ 0x646f72616e646f6dULL;
897: v2 = k0 ^ 0x6c7967656e657261ULL;
898: v3 = k1 ^ 0x7465646279746573ULL;
899:
900: if (m)
901: {
902: sipcompress(&v0, &v1, &v2, &v3, m);
903: }
904:
905: /* compression with c = 2 */
906: for (; pos != end; pos += 8)
907: {
908: m = sipget(pos);
909: sipcompress(&v0, &v1, &v2, &v3, m);
910: }
911: sipcompress(&v0, &v1, &v2, &v3, siplast(len, pos));
912:
913: /* finalization with d = 4 */
914: v2 ^= 0xff;
915: sipround(&v0, &v1, &v2, &v3);
916: sipround(&v0, &v1, &v2, &v3);
917: sipround(&v0, &v1, &v2, &v3);
918: sipround(&v0, &v1, &v2, &v3);
919: return v0 ^ v1 ^ v2 ^ v3;
920: }
921:
922: /**
923: * Described in header.
924: */
925: uint64_t chunk_mac(chunk_t chunk, u_char *key)
926: {
927: return chunk_mac_inc(chunk, key, 0);
928: }
929:
930: /**
931: * Secret key allocated randomly with chunk_hash_seed().
932: */
933: static u_char hash_key[16] = {};
934:
935: /**
936: * Static key used in case predictable hash values are required.
937: */
938: static u_char static_key[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
939: 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
940:
941: /**
942: * See header
943: */
944: void chunk_hash_seed()
945: {
946: static bool seeded = FALSE;
947: ssize_t len;
948: size_t done = 0;
949: int fd;
950:
951: if (seeded)
952: {
953: /* just once to have the same seed during the whole process lifetimes */
954: return;
955: }
956:
957: fd = open("/dev/urandom", O_RDONLY);
958: if (fd >= 0)
959: {
960: while (done < sizeof(hash_key))
961: {
962: len = read(fd, hash_key + done, sizeof(hash_key) - done);
963: if (len < 0)
964: {
965: break;
966: }
967: done += len;
968: }
969: close(fd);
970: }
971: /* on error we use random() to generate the key (better than nothing) */
972: if (done < sizeof(hash_key))
973: {
974: srandom(time(NULL) + getpid());
975: for (; done < sizeof(hash_key); done++)
976: {
977: hash_key[done] = (u_char)random();
978: }
979: }
980: seeded = TRUE;
981: }
982:
983: /**
984: * Described in header.
985: */
986: uint32_t chunk_hash_inc(chunk_t chunk, uint32_t hash)
987: {
988: /* we could use a mac of the previous hash, but this is faster */
989: return chunk_mac_inc(chunk, hash_key, ((uint64_t)hash) << 32 | hash);
990: }
991:
992: /**
993: * Described in header.
994: */
995: uint32_t chunk_hash(chunk_t chunk)
996: {
997: return chunk_mac(chunk, hash_key);
998: }
999:
1000: /**
1001: * Described in header.
1002: */
1003: uint32_t chunk_hash_static_inc(chunk_t chunk, uint32_t hash)
1004: { /* we could use a mac of the previous hash, but this is faster */
1005: return chunk_mac_inc(chunk, static_key, ((uint64_t)hash) << 32 | hash);
1006: }
1007:
1008: /**
1009: * Described in header.
1010: */
1011: uint32_t chunk_hash_static(chunk_t chunk)
1012: {
1013: return chunk_mac(chunk, static_key);
1014: }
1015:
1016: /**
1017: * Described in header.
1018: */
1019: uint16_t chunk_internet_checksum_inc(chunk_t data, uint16_t checksum)
1020: {
1021: uint32_t sum = ntohs((uint16_t)~checksum);
1022:
1023: while (data.len > 1)
1024: {
1025: sum += untoh16(data.ptr);
1026: data = chunk_skip(data, 2);
1027: }
1028: if (data.len)
1029: {
1030: sum += (uint16_t)*data.ptr << 8;
1031: }
1032: while (sum >> 16)
1033: {
1034: sum = (sum & 0xffff) + (sum >> 16);
1035: }
1036: return htons(~sum);
1037: }
1038:
1039: /**
1040: * Described in header.
1041: */
1042: uint16_t chunk_internet_checksum(chunk_t data)
1043: {
1044: return chunk_internet_checksum_inc(data, 0xffff);
1045: }
1046:
1047: /**
1048: * Described in header.
1049: */
1050: int chunk_printf_hook(printf_hook_data_t *data, printf_hook_spec_t *spec,
1051: const void *const *args)
1052: {
1053: chunk_t *chunk = *((chunk_t**)(args[0]));
1054: bool first = TRUE;
1055: chunk_t copy = *chunk;
1056: int written = 0;
1057:
1058: if (!spec->hash && !spec->plus)
1059: {
1060: u_int chunk_len = chunk->len;
1061: const void *new_args[] = {&chunk->ptr, &chunk_len};
1062: return mem_printf_hook(data, spec, new_args);
1063: }
1064:
1065: while (copy.len > 0)
1066: {
1067: if (first)
1068: {
1069: first = FALSE;
1070: }
1071: else if (!spec->plus)
1072: {
1073: written += print_in_hook(data, ":");
1074: }
1075: written += print_in_hook(data, "%02x", *copy.ptr++);
1076: copy.len--;
1077: }
1078: return written;
1079: }