source: trunk/src/sh_utils.c@ 206

Last change on this file since 206 was 185, checked in by katerina, 16 years ago

Bugfixes for log monitoring, samba logfile parser.
File size: 52.1 KB
Line 
1/* SAMHAIN file system integrity testing */
2/* Copyright (C) 1999, 2000 Rainer Wichmann */
3/* */
4/* This program is free software; you can redistribute it */
5/* and/or modify */
6/* it under the terms of the GNU General Public License as */
7/* published by */
8/* the Free Software Foundation; either version 2 of the License, or */
9/* (at your option) any later version. */
10/* */
11/* This program is distributed in the hope that it will be useful, */
12/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
13/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
14/* GNU General Public License for more details. */
15/* */
16/* You should have received a copy of the GNU General Public License */
17/* along with this program; if not, write to the Free Software */
18/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20#include "config_xor.h"
21
22
23#include <stdlib.h>
24#include <stdio.h>
25#include <string.h>
26#include <ctype.h>
27#include <unistd.h>
28
29#if TIME_WITH_SYS_TIME
30#include <sys/time.h>
31#include <time.h>
32#else
33#if HAVE_SYS_TIME_H
34#include <sys/time.h>
35#else
36#include <time.h>
37#endif
38#endif
39
40
41#include "samhain.h"
42#include "sh_error.h"
43#include "sh_utils.h"
44#include "sh_unix.h"
45#include "sh_tiger.h"
46#include "sh_entropy.h"
47#include "sh_pthread.h"
48
49#undef FIL__
50#define FIL__ _("sh_utils.c")
51
52UINT32 ErrFlag[2];
53
54int sh_util_flagval(const char * c, int * fval)
55{
56 SL_ENTER(_("sh_util_flagval"));
57 if (c == NULL)
58 SL_RETURN( (-1), _("sh_util_flagval"));
59 if ( c[0] == '1' || c[0] == 'y' || c[0] == 'Y' ||
60 c[0] == 't' || c[0] == 'T')
61 {
62 *fval = S_TRUE;
63 SL_RETURN( (0), _("sh_util_flagval"));
64 }
65 if ( c[0] == '0' || c[0] == 'n' || c[0] == 'N' ||
66 c[0] == 'f' || c[0] == 'F')
67 {
68 *fval = S_FALSE;
69 SL_RETURN( (0), _("sh_util_flagval"));
70 }
71 SL_RETURN( (-1), _("sh_util_flagval"));
72}
73
74int sh_util_timeout_check (SH_TIMEOUT * sh_timer)
75{
76 UINT64 now = (UINT64) time(NULL);
77 UINT64 dif;
78
79 if (sh_timer->flag_ok == S_FALSE)
80 {
81 /* first time
82 */
83 if (sh_timer->time_last == 0)
84 {
85 sh_timer->time_last = now;
86 return S_TRUE;
87 }
88 /* later on
89 */
90 dif = now - sh_timer->time_last;
91 if (dif < sh_timer->time_dist)
92 {
93 return S_FALSE;
94 }
95 sh_timer->time_last = now;
96 return S_TRUE;
97 }
98 sh_timer->time_last = now;
99 return S_FALSE;
100}
101
102static int sh_ask_update = S_FALSE;
103
104int sh_util_set_interactive(const char * str)
105{
106 (void) str;
107
108 sh_ask_update = S_TRUE;
109
110 sh_unix_setnodeamon(NULL);
111
112 return 0;
113}
114
115#if !defined(STDIN_FILENO)
116#define STDIN_FILENO 0
117#endif
118#if !defined(STDERR_FILENO)
119#define STDERR_FILENO 0
120#endif
121
122int sh_util_ask_update(char * path)
123{
124 int inchar, c;
125 int i = S_TRUE;
126 char * tmp = NULL;
127
128 SL_ENTER(_("sh_util_ask_update"));
129
130 if (sh_ask_update != S_TRUE)
131 {
132 SL_RETURN(i, _("sh_util_ask_update"));
133 }
134
135#ifdef HAVE_TTYNAME
136 if (!ttyname(STDIN_FILENO))
137 {
138 if (NULL != ttyname(STDERR_FILENO))
139 {
140 if (NULL == freopen(ttyname(STDERR_FILENO), "r", stdin))
141 {
142 sh_error_handle ((-1), FIL__, __LINE__, 0,
143 MSG_E_SUBGEN,
144 _("Cannot continue: stdin is not a terminal"),
145 _("sh_util_ask_update"));
146 exit(EXIT_FAILURE);
147 }
148 }
149 else
150 {
151 sh_error_handle ((-1), FIL__, __LINE__, 0,
152 MSG_E_SUBGEN,
153 _("Cannot continue: stdin is not a terminal"),
154 _("sh_util_ask_update"));
155 exit(EXIT_FAILURE);
156 }
157 }
158#endif
159
160 if (sh_ask_update == S_TRUE)
161 {
162 tmp = sh_util_safe_name (path);
163 fprintf (stderr, _("Update %s [Y/n] ? "), tmp);
164 SH_FREE(tmp);
165 while (1 == 1)
166 {
167 c = fgetc(stdin); inchar = c;
168 /*@+charintliteral@*/
169 while (c != '\n' && c != EOF)
170 c = fgetc(stdin);
171 /* fprintf(stderr, "CHAR (1): %c\n", inchar); */
172 if (inchar == 'Y' || inchar == 'y' || inchar == '\n')
173 {
174 break;
175 }
176 else if (inchar == 'n' || inchar == 'N')
177 {
178 i = S_FALSE;
179 break;
180 }
181 else
182 {
183 fprintf(stderr, _("Please answer y(es) or n(o)\n"));
184 }
185 /*@-charintliteral@*/
186 }
187 }
188
189 SL_RETURN(i, _("sh_util_ask_update"));
190}
191
192int sh_util_hidesetup(const char * c)
193{
194 int i;
195 SL_ENTER(_("sh_util_hidesetup"));
196 i = sh_util_flagval(c, &(sh.flag.hidefile));
197
198 SL_RETURN(i, _("sh_util_hidesetup"));
199}
200
201char * sh_util_acl_compact(char * buf, ssize_t len)
202{
203 unsigned char * p = (unsigned char *) buf;
204 int state = 0;
205 ssize_t rem = 0;
206 char * out;
207
208 SH_VALIDATE_NE(buf, NULL);
209 SH_VALIDATE_GE(len, 0);
210
211 out = SH_ALLOC(len + 1);
212
213 while (*p != '\0') {
214
215 /* -- not at start or after newline
216 */
217 if (state == 1) {
218 if (*p == '\n' || *p == ' ' || *p == '\t' || *p == '#') {
219 while (*p != '\n') {
220 ++p;
221 if (*p == '\0') {
222 goto exit_it;
223 }
224 }
225 out[rem] = ','; ++rem;
226 while (p[1] == '\n') ++p; /* scan over consecutive newlines */
227 state = 0;
228 if (p[1] == '\0') {
229 if (rem > 0) out[rem-1] = '\0';
230 break;
231 }
232 }
233 else {
234 if (*p <= 0x7F && isgraph((int) *p)) {
235 out[rem] = (char) *p; ++rem;
236 }
237 }
238 }
239
240 /* -- at start or after newline
241 */
242 else /* if (state == 0) */ {
243 if (0 == strncmp((char *) p, "user", 4)) {
244 out[rem] = 'u'; ++rem;
245 p += 3; state = 1;
246 } else if (0 == strncmp((char *) p, "group", 5)) {
247 out[rem] = 'g'; ++rem;
248 p += 4; state = 1;
249 } else if (0 == strncmp((char *) p, "mask", 4)) {
250 out[rem] = 'm'; ++rem;
251 p += 3; state = 1;
252 } else if (0 == strncmp((char *) p, "other", 5)) {
253 out[rem] = 'o';
254 p += 4; state = 1; ++rem;
255 } else if (*p == '\0') {
256 if (rem > 0) { out[rem-1] = '\0'; }
257 break;
258 } else {
259 if (*p <= 0x7F && isprint((int) *p)) {
260 out[rem] = (char) *p; ++rem;
261 }
262 }
263 state = 1;
264 }
265 ++p;
266 }
267 exit_it:
268 out[rem] = '\0';
269 return out;
270}
271
272
273char * sh_util_strdup_l (const char * str, size_t len)
274{
275 char * p = NULL;
276
277 SL_ENTER(_("sh_util_strdup_l"));
278
279 SH_VALIDATE_NE(str, NULL);
280 SH_VALIDATE_NE(len, 0);
281
282 if (sl_ok_adds (len, 1))
283 {
284 p = SH_ALLOC (len + 1);
285 (void) memcpy (p, str, len+1);
286 }
287 else
288 {
289 safe_fatal(_("integer overflow in sh_util_strdup_l"), FIL__, __LINE__);
290 }
291 SL_RETURN( p, _("sh_util_strdup_l"));
292}
293
294char * sh_util_strdup (const char * str)
295{
296 char * p = NULL;
297 size_t len;
298
299 SL_ENTER(_("sh_util_strdup"));
300
301 SH_VALIDATE_NE(str, NULL);
302
303 len = sl_strlen(str);
304 p = SH_ALLOC (len + 1);
305 (void) memcpy (p, str, len+1);
306
307 SL_RETURN( p, _("sh_util_strdup"));
308}
309
310/* by the eircom.net computer incident
311 * response team
312 */
313char * sh_util_strsep (char **str, const char *delim)
314{
315 char *ret, *c;
316 const char *d;
317
318 SL_ENTER(_("sh_util_strsep"));
319 ret = *str;
320
321 SH_VALIDATE_NE(ret, NULL);
322
323 for (c = *str; *c != '\0'; c++) {
324 for (d = delim; *d != '\0'; d++) {
325 if (*c == *d) {
326 *c = '\0';
327 *str = c + 1;
328 SL_RETURN(ret, _("sh_util_strsep"));
329 }
330 }
331 }
332
333 /* If we get to here, there's no delimiters in the string */
334 *str = NULL;
335 SL_RETURN(ret, _("sh_util_strsep"));
336}
337
338
339/* returned string must be free'd by caller.
340 */
341char * sh_util_formatted (const char * formatt, st_format * ftab)
342{
343 struct tm * time_ptr;
344 size_t size;
345 size_t isiz;
346 char * fmt = NULL;
347 char * p;
348 char * q;
349 char * outstr;
350 int i;
351 int j;
352 time_t inpp;
353
354 char * clist[16] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
355 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
356 int nn = 0;
357
358 SL_ENTER(_("sh_util_formatted"));
359
360 if (formatt == NULL || ftab == NULL || *formatt == '\0')
361 SL_RETURN(NULL, _("sh_util_formatted"));
362
363 /* -- save the format (we overwrite it !!) --
364 */
365 size = sl_strlen(formatt);
366
367 if (!sl_ok_adds(size, 1))
368 SL_RETURN(NULL, _("sh_util_formatted"));
369
370 ++size;
371 fmt = SH_ALLOC(size);
372 (void) sl_strlcpy(fmt, formatt, size);
373
374 p = fmt;
375
376 j = 0;
377 while (ftab[j].fchar != '\0') {
378 if (ftab[j].type != S_FMT_STRING)
379 ftab[j].data_str = NULL;
380 ++j;
381 }
382
383 while (p != NULL && *p != '\0' && NULL != (q = strchr(p, '%')))
384 {
385 ++q;
386
387 /* fprintf(stderr, "p == %s q == %s\n", p, q); */
388
389 /* -- end of string is a '%' --
390 */
391 if (*q == '\0')
392 {
393 --q;
394 *q = '\0';
395 break;
396 }
397
398 i = 0;
399 j = 0;
400
401 /* -- search the format char in input table --
402 * put (nn < 16) here -> all remaining %foo will be
403 * converted to %%
404 */
405 while (ftab[j].fchar != '\0' && nn < 16)
406 {
407 if (ftab[j].fchar == *q)
408 {
409 /* -- Convert it to a string format (%s). --
410 */
411 *q = 's'
412;
413 i = 1;
414
415 switch(ftab[j].type) {
416
417 case S_FMT_STRING:
418 {
419 isiz = sl_strlen(ftab[j].data_str);
420 if (isiz > 0 && sl_ok_adds(size, isiz))
421 {
422 size += isiz;
423 clist[nn] = ftab[j].data_str;
424 ++nn;
425 }
426 else
427 *q = '%';
428 goto endsrch;
429 }
430 break;
431
432 case S_FMT_ULONG:
433 {
434 ftab[j].data_str = (char *) SH_ALLOC(64);
435 /*@-bufferoverflowhigh@*/
436 sprintf (ftab[j].data_str, "%lu", /* known to fit */
437 ftab[j].data_ulong);
438 /*@+bufferoverflowhigh@*/
439 isiz = sl_strlen(ftab[j].data_str);
440 if (isiz > 0 && sl_ok_adds(size, isiz))
441 {
442 size += isiz;
443 clist[nn] = ftab[j].data_str;
444 ++nn;
445 }
446 else
447 *q = '%';
448 goto endsrch;
449 }
450 break;
451
452 case S_FMT_LONG:
453 {
454 ftab[j].data_str = (char *) SH_ALLOC(64);
455 /*@-bufferoverflowhigh@*/
456 sprintf (ftab[j].data_str, "%ld", /* known to fit */
457 ftab[j].data_long);
458 /*@+bufferoverflowhigh@*/
459 isiz = sl_strlen(ftab[j].data_str);
460 if (isiz > 0 && sl_ok_adds(size, isiz))
461 {
462 size += isiz;
463 clist[nn] = ftab[j].data_str;
464 ++nn;
465 }
466 else
467 *q = '%';
468 goto endsrch;
469 }
470 break;
471
472 case S_FMT_TIME:
473 {
474 ftab[j].data_str = (char *) SH_ALLOC(64);
475 inpp = (time_t)ftab[j].data_ulong;
476 if (inpp != 0)
477 {
478 time_ptr = localtime (&(inpp));
479 if (time_ptr != NULL)
480 (void) strftime(ftab[j].data_str, 64,
481 _("%d-%m-%Y %H:%M:%S"), time_ptr);
482 else
483 (void) sl_strlcpy(ftab[j].data_str,
484 _("00-00-0000 00:00:00"), 64);
485 }
486 else
487 {
488 (void) sl_strlcpy(ftab[j].data_str,
489 _("(None)"), 64);
490 }
491 isiz = sl_strlen(ftab[j].data_str);
492 if (isiz > 0 && sl_ok_adds(size, isiz))
493 {
494 size += isiz;
495 clist[nn] = ftab[j].data_str;
496 ++nn;
497 }
498 else
499 *q = '%';
500 goto endsrch;
501 }
502 break;
503
504 default:
505 /* do nothing */;
506 }
507
508 }
509 ++j;
510 }
511
512 endsrch:
513
514 p = q;
515
516 /* -- not found -- */
517 if (i == 0)
518 {
519 *q = '%';
520 ++p;
521 }
522
523 }
524
525 /* -- Format string evaluated.
526 clist[] List of strings
527 size Total size of format string + clist[] strings
528 -- */
529
530 /* -- closing '\0' --
531 */
532 if (sl_ok_adds(size, 1))
533 size++;
534 outstr = (char *) SH_ALLOC(size);
535
536 /* -- print it --
537 */
538 (void) sl_snprintf( outstr, size, fmt,
539 clist[0], clist[1], clist[2], clist[3],
540 clist[4], clist[5], clist[6], clist[7],
541 clist[8], clist[9], clist[10], clist[11],
542 clist[12], clist[13], clist[14], clist[15]);
543 outstr[size-1] = '\0';
544
545 /* -- cleanup --
546 */
547 j = 0;
548 while (ftab[j].fchar != '\0') {
549 if (ftab[j].type != S_FMT_STRING && ftab[j].data_str != NULL)
550 SH_FREE(ftab[j].data_str);
551 ++j;
552 }
553 SH_FREE(fmt);
554
555 SL_RETURN(outstr, _("sh_util_formatted"));
556}
557
558/* read a hexchar, return int value (0-15)
559 * can't inline (AIX)
560 */
561int sh_util_hexchar( const char c )
562{
563 /*@+charint@*/
564 if ( c >= '0' && c <= '9' )
565 return c - '0';
566 else if ( c >= 'a' && c <= 'f' )
567 return c - 'a' + 10;
568 else if ( c >= 'A' && c <= 'F' )
569 return c - 'A' + 10;
570 else return -1;
571 /*@-charint@*/
572}
573
574char * sh_util_charhex( unsigned char i , char * i2h)
575{
576 int j, k;
577
578 j = i / 16;
579 k = i - (j*16);
580
581 if (j < 10) i2h[0] = '0'+j;
582 else i2h[0] = 'A'+(j-10);
583
584 if (k < 10) i2h[1] = '0'+k;
585 else i2h[1] = 'A'+(k-10);
586
587 return i2h;
588}
589
590/* read a hexadecimal key, convert to binary
591 */
592int sh_util_hextobinary (char * binary, const char * hex, int bytes)
593{
594 int i = 0, j, k, l = 0;
595 char c;
596
597#define SH_HEXCHAR(x, y) \
598 c = (x); \
599 if ( c >= '0' && c <= '9' ) \
600 y = c - '0'; \
601 else if ( c >= 'a' && c <= 'f' ) \
602 y = c - 'a' + 10; \
603 else if ( c >= 'A' && c <= 'F' ) \
604 y = c - 'A' + 10; \
605 else \
606 SL_RETURN((-1), _("sh_util_hextobinary"))
607
608
609 SL_ENTER(_("sh_util_hextobinary"));
610
611 if (bytes < 2)
612 SL_RETURN((-1), _("sh_util_hextobinary"));
613
614 while (i < (bytes-1))
615 {
616 SH_HEXCHAR(hex[i], k);
617 SH_HEXCHAR(hex[i+1], j);
618
619 binary[l] = (char)(k * 16 + j);
620 ++l; i+= 2;
621 }
622
623 SL_RETURN((0), _("sh_util_hextobinary"));
624}
625
626static void copy_four (unsigned char * dest, UINT32 in)
627{
628 UINT32 i, j;
629 int count;
630
631 SL_ENTER(_("copy_four"));
632 for (count = 0; count < 4; ++count)
633 {
634 i = in / 256;
635 j = in - (i*256);
636 dest[count] = (unsigned char) j;
637 in = i;
638 }
639 SL_RET0(_("copy_four"));
640}
641
642/* compute HMAC-TIGER
643 */
644static char * sh_util_hmac_tiger (char * hexkey,
645 char * text, size_t textlen,
646 char * res, size_t len)
647{
648 static char opad[KEY_BLOCK] = {
649 (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C,
650 (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C,
651 (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C,
652 (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C
653 };
654 static char ipad[KEY_BLOCK] = {
655 (char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36,
656 (char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36,
657 (char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36,
658 (char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36
659 };
660 static char zap[KEY_BLOCK] = {
661 (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00,
662 (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00,
663 (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00,
664 (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00
665 };
666 char K[KEY_BLOCK];
667 char outer[KEY_BLOCK];
668 char * inner;
669 UINT32 * h1;
670 UINT32 * h2;
671 UINT32 cc[KEY_LEN/4];
672 UINT32 kbuf[KEY_BYT/sizeof(UINT32)];
673 char hashbuf[KEYBUF_SIZE];
674
675
676 size_t i;
677
678 SL_ENTER(_("sh_util_hmac_tiger"));
679 ASSERT((KEY_BLOCK <= (KEY_LEN/2)), _("KEY_BLOCK <= (KEY_LEN/2)"))
680
681 if (KEY_BLOCK > (KEY_LEN/2))
682 {
683 (void) sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
684 sl_strlcpy(res, hashbuf, len);
685 SL_RETURN(res, _("sh_util_hmac_tiger"));
686 }
687
688 memcpy (K, zap, KEY_BLOCK);
689
690 if (sh_util_hextobinary (K, hexkey, KEY_LEN) < 0)
691 {
692 (void) sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
693 sl_strlcpy(res, hashbuf, len);
694 SL_RETURN(res, _("sh_util_hmac_tiger"));
695 }
696
697 if (sl_ok_adds(textlen, KEY_BLOCK))
698 {
699 inner = (char *) SH_ALLOC (textlen + KEY_BLOCK);
700
701 for (i = 0; i < KEY_BLOCK; ++i)
702 {
703 outer[i] = K[i] ^ opad[i];
704 inner[i] = K[i] ^ ipad[i];
705 }
706 for (i = KEY_BLOCK; i < (KEY_BLOCK+textlen); ++i)
707 {
708 inner[i] = text[i - KEY_BLOCK];
709 }
710 }
711 else
712 {
713 sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
714 _("integer overflow"),
715 _("sh_util_hmac_tiger"));
716 (void) sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
717 sl_strlcpy(res, hashbuf, len);
718 SL_RETURN(res, _("sh_util_hmac_tiger"));
719 }
720
721 /* now compute the hash
722 */
723 h1 = sh_tiger_hash_uint32 ( outer,
724 TIGER_DATA,
725 KEY_BLOCK,
726 kbuf, KEY_BYT/sizeof(UINT32));
727 for (i = 0; i < (KEY_LEN/8); ++i)
728 {
729 /* cc[i] = h1[i]; */
730 copy_four ( (unsigned char *) &(cc[i]), h1[i]);
731 }
732
733 h2 = sh_tiger_hash_uint32 ( inner,
734 TIGER_DATA,
735 (unsigned long) KEY_BLOCK+textlen,
736 kbuf, KEY_BYT/sizeof(UINT32));
737 for (i = KEY_LEN/8; i < (KEY_LEN/4); ++i)
738 {
739 copy_four ( (unsigned char *) &(cc[i]), h2[i - (KEY_LEN/8)]);
740 /* cc[i] = h2[i - (KEY_LEN/8)]; */
741 }
742 SH_FREE(inner);
743
744 (void) sh_tiger_hash ((char *) &cc[0],
745 TIGER_DATA,
746 (unsigned long) (KEY_LEN/4 * sizeof(UINT32)),
747 hashbuf, sizeof(hashbuf));
748
749 sl_strlcpy(res, hashbuf, len);
750 SL_RETURN(res, _("sh_util_hmac_tiger"));
751}
752
753static char * sh_util_hash_tiger ( char * hexkey,
754 char * text, size_t textlen,
755 char * res, size_t len)
756{
757 char h2[2*KEY_LEN+1];
758 char hashbuf[KEYBUF_SIZE];
759
760 SL_ENTER(_("sh_util_hash_tiger"));
761
762 (void) sl_strlcpy(h2, hexkey, KEY_LEN+1);
763 (void) sl_strlcat(h2,
764 sh_tiger_hash(text, TIGER_DATA,
765 (unsigned long) textlen,
766 hashbuf, sizeof(hashbuf)),
767 2*KEY_LEN+1
768 );
769
770 (void) sh_tiger_hash(h2, TIGER_DATA, 2*KEY_LEN, hashbuf, sizeof(hashbuf));
771
772 sl_strlcpy(res, hashbuf, len);
773 SL_RETURN(res, _("sh_util_hash_tiger"));
774}
775
776/* --- compute signature on data ---
777 */
778#define TYPE_HMAC 0
779#define TYPE_HASH 1
780
781static int sigtype = TYPE_HMAC;
782
783int sh_util_sigtype (const char * c)
784{
785 SL_ENTER(_("sh_util_sigtype"));
786 if (c == NULL)
787 SL_RETURN( -1, _("sh_util_sigtype"));
788
789 if (0 == strcmp(_("HMAC-TIGER"), c))
790 sigtype = TYPE_HMAC;
791 else if (0 == strcmp(_("HASH-TIGER"), c))
792 sigtype = TYPE_HASH;
793 else
794 SL_RETURN( -1, _("sh_util_sigtype"));
795
796 SL_RETURN( 0, _("sh_util_sigtype"));
797}
798
799char * sh_util_siggen (char * hexkey,
800 char * text, size_t textlen,
801 char * res, size_t len)
802{
803 char * p;
804
805 SL_ENTER(_("sh_util_siggen"));
806 if (sigtype == TYPE_HMAC)
807 p = sh_util_hmac_tiger (hexkey,
808 text, textlen, res, len);
809 else
810 p = sh_util_hash_tiger (hexkey,
811 text, textlen, res, len);
812 SL_RETURN(p, _("sh_util_siggen"));
813}
814
815
816/* a simple compressor
817 */
818long sh_util_compress (char * dest, char * src, size_t dest_size)
819{
820 char * add;
821 char * get;
822 size_t count = 0;
823 size_t dest_end;
824
825 SL_ENTER(_("sh_util_compress"));
826
827 if (dest_size == 0)
828 SL_RETURN((0), _("sh_util_compress"));
829
830 if ((dest == NULL) || (src == NULL))
831 SL_RETURN((0), _("sh_util_compress"));
832
833 dest_end = sl_strlen(dest);
834
835 if (dest_end > dest_size)
836 SL_RETURN((0), _("sh_util_compress"));
837
838 add = &dest[dest_end];
839 get = src;
840
841 while (count < (dest_size-dest_end))
842 {
843 if (isalnum((int) *get))
844 {
845 *add = *get;
846 ++add;
847 ++count;
848 }
849 ++get;
850 if (*get == '\0' && (count < (dest_size-dest_end)))
851 /* end of src reached */
852 {
853 *add = *get; /* copy the '\0' */
854 break; /* and stop copying */
855 }
856 }
857
858 dest[dest_size-1] = '\0'; /* paranoia */
859 SL_RETURN(((long)count), _("sh_util_compress")); /* no of chars copied */
860}
861
862
863/* copy the four least significant bytes
864 */
865void sh_util_cpylong (char * dest, const char * src, int len )
866{
867 int i, j;
868 union
869 {
870 long l;
871 char c[sizeof(long)];
872 } u;
873
874 SL_ENTER(_("sh_util_cpylong"));
875
876 u.l = 1;
877
878 /* MSB is first
879 */
880 if (sizeof(long)>4 &&/*@+charint@*/(u.c[sizeof(long)-1] == 1)/*@-charint@*/)
881 {
882 j = (int) (sizeof(long)-4);
883 for (i = 0; i < j; ++i) ++src;
884 }
885
886 i = 0;
887
888 while (i < 4)
889 {
890 *dest = (*src);
891 ++dest; ++src;
892 if (i == (len-1)) break;
893 ++i;
894 }
895 SL_RET0(_("sh_util_cpylong"));
896}
897
898/* This is a maximally equidistributed combined Tausworthe
899 * generator. The sequence is,
900 *
901 * x_n = (s1_n ^ s2_n ^ s3_n)
902 *
903 * s1_{n+1} = (((s1_n & 4294967294) <<12) ^ (((s1_n <<13) ^ s1_n) >>19))
904 * s2_{n+1} = (((s2_n & 4294967288) << 4) ^ (((s2_n << 2) ^ s2_n) >>25))
905 * s3_{n+1} = (((s3_n & 4294967280) <<17) ^ (((s3_n << 3) ^ s3_n) >>11))
906 *
907 * computed modulo 2^32. In the three formulas above '^' means
908 * exclusive-or (C-notation), not exponentiation. Note that the
909 * algorithm relies on the properties of 32-bit unsigned integers (it
910 * is formally defined on bit-vectors of length 32).
911 *
912 * Stolen from GSL (GNU scientific library) and modified somewhat.
913 * I am using UINT32, which is guaranteed to be 32 bits. Also made
914 * sure that the initialization vector is valid.
915 */
916
917
918/* interval [0, 4294967296]
919 */
920static UINT32 taus_get_long (void *vstate)
921{
922 UINT32 * state = (UINT32 *) vstate;
923
924 /*
925 if (skey->rngI == BAD)
926 (void)taus_seed();
927 */
928
929#define TAUSWORTHE(s,a,b,c,d) ((s &c) <<d) ^ (((s <<a) ^s) >>b)
930 /*@+ignorequals@*/
931 state[0] = TAUSWORTHE (state[0], 13, 19, 4294967294UL, 12);
932 state[1] = TAUSWORTHE (state[1], 2, 25, 4294967288UL, 4);
933 state[2] = TAUSWORTHE (state[2], 3, 11, 4294967280UL, 17);
934 /*@-ignorequals@*/
935 return (state[0] ^ state[1] ^ state[2]);
936}
937
938/* Hide the internal state of the PRNG by using its output as
939 * input for a one-way hash function.
940 */
941
942UINT32 taus_get ()
943{
944#define TAUS_SAMPLE 12
945
946 UINT32 taus_svec[TAUS_SAMPLE];
947 UINT32 retval;
948 UINT32 * res;
949 UINT32 * res_vec = &(skey->res_vec[0]);
950 static int res_num = 0;
951 register int i;
952 UINT32 kbuf[KEY_BYT/sizeof(UINT32)];
953
954 SH_MUTEX_LOCK_UNSAFE(mutex_skey);
955 if (res_num > 0)
956 {
957 retval = res_vec[res_num];
958 res_num = (res_num == 5) ? 0 : (res_num + 1);
959 SH_MUTEX_UNLOCK_UNSAFE(mutex_skey); /* alternative path */
960 return retval;
961 }
962 SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
963
964 (void)taus_seed();
965
966 SH_MUTEX_LOCK_UNSAFE(mutex_skey);
967 for (i = 0; i < (TAUS_SAMPLE/3); ++i)
968 {
969 taus_svec[i*3] = taus_get_long (&(skey->rng0[0]));
970 taus_svec[i*3+1] = taus_get_long (&(skey->rng1[0]));
971 taus_svec[i*3+2] = taus_get_long (&(skey->rng2[0]));
972 }
973 SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
974
975 res = sh_tiger_hash_uint32 ( (char *) &taus_svec[0],
976 TIGER_DATA,
977 (unsigned long)(TAUS_SAMPLE * sizeof(UINT32)),
978 kbuf, KEY_BYT/sizeof(UINT32));
979
980 SH_MUTEX_LOCK_UNSAFE(mutex_skey);
981 for (i = 1; i < 6; ++i)
982 {
983 res_vec[i] = res[i];
984 }
985 retval = res[0];
986 res_num = 1;
987 SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
988
989 memset(taus_svec, '\0', TAUS_SAMPLE * sizeof(UINT32));
990
991 return retval;
992}
993
994/* interval [0,1)
995 */
996double taus_get_double (void *vstate)
997{
998 return taus_get_long (vstate) / (4294967296.0 + 1.0) ;
999}
1000
1001#define LCG(n) ((69069 * n) & 0xffffffffUL)
1002
1003/* TAKE CARE: state[0], state[1], state[2] must be > 2,8,16, respectively
1004 */
1005static void taus_set_from_ulong (void *vstate, unsigned long int s)
1006{
1007 UINT32 *state = (UINT32 *) vstate;
1008
1009 if (s == 0)
1010 s = 1; /* default seed is 1 */
1011
1012 state[0] = (UINT32)(LCG (s) | (UINT32) 0x03);
1013 state[1] = (UINT32)(LCG (state[0]) | (UINT32) 0x09);
1014 state[2] = (UINT32)(LCG (state[1]) | (UINT32) 0x17);
1015
1016 /* 'warm up'
1017 */
1018 (void) taus_get_long (state);
1019 (void) taus_get_long (state);
1020 (void) taus_get_long (state);
1021 (void) taus_get_long (state);
1022 (void) taus_get_long (state);
1023 (void) taus_get_long (state);
1024
1025 return;
1026}
1027
1028static void taus_set_from_state (void *vstate, void *init_state)
1029{
1030 UINT32 *state = (UINT32 *) vstate;
1031 UINT32 *state0 = (UINT32 *) init_state;
1032
1033 state[0] = state0[0] | (UINT32) 0x03;
1034 state[1] = state0[1] | (UINT32) 0x09;
1035 state[2] = state0[2] | (UINT32) 0x17;
1036
1037 return;
1038}
1039
1040
1041int taus_seed ()
1042{
1043 char bufx[9 * sizeof(UINT32) + 1];
1044 int status;
1045 static unsigned long seed_time = 0;
1046 unsigned long gtime;
1047
1048 SL_ENTER(_("taus_seed"));
1049
1050 if (skey->rngI == GOOD)
1051 {
1052 if ( (sh_unix_longtime () - seed_time) < 7200)
1053 SL_RETURN( (0), _("taus_seed"));
1054 }
1055
1056 seed_time = sh_unix_longtime ();
1057
1058 status = sh_entropy (24, bufx);
1059
1060 if (!SL_ISERROR(status))
1061 {
1062 SH_MUTEX_LOCK_UNSAFE(mutex_skey);
1063 memcpy (&skey->rng0[0], &bufx[0], 2*sizeof(UINT32));
1064 memcpy (&skey->rng1[0], &bufx[2*sizeof(UINT32)], 2*sizeof(UINT32));
1065 memcpy (&skey->rng2[0], &bufx[4*sizeof(UINT32)], 2*sizeof(UINT32));
1066 memset (bufx, 0, 9 * sizeof(UINT32) + 1);
1067
1068 skey->rng0[2] = 0;
1069 skey->rng1[2] = 0;
1070 skey->rng2[2] = 0;
1071
1072 taus_set_from_state( &(skey->rng0[0]), &(skey->rng0[0]));
1073 taus_set_from_state( &(skey->rng1[0]), &(skey->rng1[0]));
1074 taus_set_from_state( &(skey->rng2[0]), &(skey->rng2[0]));
1075
1076 skey->rngI = GOOD;
1077 SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
1078 SL_RETURN( (0), _("taus_seed"));
1079 }
1080
1081 sh_error_handle ((-1), FIL__, __LINE__, status, MSG_ES_ENT,
1082 _("sh_entropy"));
1083
1084 /* emergency backup - unsafe !
1085 */
1086#ifdef HAVE_GETTIMEOFDAY
1087 gtime = sh_unix_notime();
1088#else
1089 gtime = seed_time;
1090#endif
1091
1092 SH_MUTEX_LOCK_UNSAFE(mutex_skey);
1093 taus_set_from_ulong ( &(skey->rng0[0]), LCG (gtime) );
1094 taus_set_from_ulong ( &(skey->rng1[0]), LCG (skey->rng0[0]) );
1095 taus_set_from_ulong ( &(skey->rng2[0]), LCG (skey->rng1[0]) );
1096 skey->rngI = BAD;
1097 SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
1098
1099 SL_RETURN( (-1), _("taus_seed"));
1100}
1101
1102/*@+charint@*/
1103static unsigned char new_key[] = { 0xA7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xA7 };
1104/*@-charint@*/
1105static void copy_four (unsigned char * dest, UINT32 in);
1106
1107int sh_util_set_newkey (const char * new_in)
1108{
1109 size_t i, j = 0;
1110 size_t len;
1111 SL_TICKET fp;
1112 SL_TICKET fout;
1113 char * key;
1114 char * path;
1115 char * outpath = NULL;
1116 unsigned char * image = NULL;
1117 long s = 0;
1118 long ilen = 0;
1119 long ii, k = 0;
1120 UINT32 * h1;
1121 char * new = NULL;
1122
1123 if (0 != sl_is_suid())
1124 {
1125 fprintf(stderr, _("ERROR: insufficient privilege\n"));
1126 _exit (EXIT_FAILURE);
1127 /*@notreached@*/
1128 return -1; /* braindead MAC OSX compiler needs this */
1129 }
1130
1131 if (new_in == NULL || new_in[0] == '\0')
1132 {
1133 fprintf(stderr,
1134 _("ERROR: no key given\n Argument must be 'key@path'\n"));
1135 _exit (EXIT_FAILURE);
1136 /*@notreached@*/
1137 return -1;
1138 }
1139
1140 if (NULL == (new = malloc(strlen(new_in) + 1)))
1141 goto bail_mem;
1142 sl_strncpy(new, new_in, strlen(new_in) + 1);
1143
1144 key = new;
1145 len = strlen(new);
1146 for (i = 1; i < (len-2); ++i)
1147 {
1148 if (new[i] == '@' && new[i+1] == '/')
1149 {
1150 j = i+1; new[i] = '\0'; break;
1151 }
1152 }
1153 if (j == 0)
1154 {
1155 fprintf(stderr,
1156 _("ERROR: no path to executable given\n Argument must be 'key@path'\n"));
1157 free(new);
1158 _exit (EXIT_FAILURE);
1159 /*@notreached@*/
1160 return -1;
1161 }
1162 else
1163 path = &new[j];
1164
1165 len = strlen(path) + 1 + 4;
1166 /*@-usedef@*/
1167 if (NULL == (outpath = malloc(len)))
1168 goto bail_mem;
1169 /*@-usedef@*/
1170 sl_snprintf (outpath, len, _("%s.out"), path);
1171
1172 fp = sl_open_read(path, SL_NOPRIV);
1173 if (SL_ISERROR(fp))
1174 {
1175 fprintf(stderr,
1176 _("ERROR: cannot open %s for read (errnum = %ld)\n"), path, fp);
1177 free(new); free (outpath);
1178 _exit (EXIT_FAILURE);
1179 /*@notreached@*/
1180 return -1;
1181 }
1182
1183 fout = sl_open_write(outpath, SL_NOPRIV);
1184 if (SL_ISERROR(fout))
1185 {
1186 fprintf(stderr,
1187 _("ERROR: cannot open %s (errnum = %ld)\n"), outpath, fout);
1188 free(new); free (outpath);
1189 _exit (EXIT_FAILURE);
1190 /*@notreached@*/
1191 return -1;
1192 }
1193
1194
1195 image = malloc (4096);
1196 if (!image)
1197 goto bail_mem;
1198 while (0 < (ii = sl_read (fp, &image[s], 4096)))
1199 {
1200 ilen += ii;
1201 s += 4096;
1202 image = realloc (image, (size_t) (4096 + s));
1203 if (!image)
1204 goto bail_mem;
1205 }
1206
1207 printf(_("%ld bytes read\n"), ilen);
1208
1209
1210 for (k = 0; k < (ilen - 8); ++k)
1211 {
1212 if (image[k] == new_key[0] &&
1213 image[k+1] == new_key[1] &&
1214 image[k+2] == new_key[2] &&
1215 image[k+3] == new_key[3] &&
1216 image[k+4] == new_key[4] &&
1217 image[k+5] == new_key[5] &&
1218 image[k+6] == new_key[6] &&
1219 image[k+7] == new_key[7])
1220 {
1221 UINT32 kbuf[KEY_BYT/sizeof(UINT32)];
1222
1223 printf(_("old key found\n"));
1224 h1 = sh_tiger_hash_uint32 (key, TIGER_DATA,
1225 (unsigned long)strlen(key),
1226 kbuf, KEY_BYT/sizeof(UINT32));
1227 copy_four( (unsigned char *) &(image[k]), h1[0]);
1228 copy_four( (unsigned char *) &(image[k+4]), h1[1]);
1229 (void) sl_write (fout, image, ilen);
1230 (void) sl_close (fout);
1231 printf(_("new file %s written\n"), outpath);
1232 free(new); free (outpath); free(image);
1233 _exit (EXIT_SUCCESS);
1234 /*@notreached@*/
1235 return 0;
1236 }
1237 }
1238
1239 fprintf(stderr,
1240 _("ERROR: old key not found\n"));
1241 free(new); free (outpath); free(image);
1242 _exit (EXIT_FAILURE);
1243 /*@notreached@*/
1244 return -1;
1245
1246
1247 bail_mem:
1248 fprintf(stderr,
1249 _("ERROR: out of memory\n"));
1250 if (new) free(new);
1251 if (outpath) free (outpath);
1252 if (image) free (image);
1253 _exit (EXIT_FAILURE);
1254 /*@notreached@*/
1255 return -1;
1256}
1257
1258
1259
1260
1261/* A simple en-/decoder, based on Vernam cipher. We use the
1262 * message as salt to hide the key by obtaining a different one-time
1263 * pad each time.
1264 * Should be safe against a listener on the network, but not against someone
1265 * with read access to the binary.
1266 */
1267void sh_util_encode (char * data, char * salt, int mode, char fill)
1268{
1269 static char cc1[17] = N_("0123456789ABCDEF");
1270 char cc[17] = "\0";
1271 register int i, j, j1 = 0, j2 = 0, j3;
1272 char * dez;
1273 char hashbuf[KEYBUF_SIZE];
1274
1275 SL_ENTER(_("sh_util_encode"));
1276
1277 /* init
1278 */
1279 (void) sl_strlcpy( cc, _(cc1), sizeof(cc));
1280
1281 /* max 128 bits keyspace
1282 */
1283 memset (skey->vernam, (int)fill, KEY_LEN+1);
1284
1285 dez = (char *) &(skey->ErrFlag[0]);
1286 sh_util_cpylong (skey->vernam, dez, 4);
1287 dez = (char *) &(skey->ErrFlag[1]);
1288 sh_util_cpylong (&skey->vernam[4], dez, 4);
1289
1290 skey->vernam[KEY_LEN] = '\0';
1291
1292 (void) sl_strlcpy(skey->vernam,
1293 sh_tiger_hash(skey->vernam, TIGER_DATA, KEY_LEN,
1294 hashbuf, sizeof(hashbuf)),
1295 KEY_LEN+1);
1296
1297 (void) sl_strlcpy(skey->vernam,
1298 sh_util_hmac_tiger (skey->vernam, salt, strlen(salt),
1299 hashbuf, sizeof(hashbuf)),
1300 KEY_LEN+1);
1301
1302 (void) sl_strlcpy(skey->vernam,
1303 sh_util_hmac_tiger (skey->vernam, (char*) new_key, 8,
1304 hashbuf, sizeof(hashbuf)),
1305 KEY_LEN+1);
1306
1307 /* The following routine adds/subtracts data[j] and vernam[j] mod 16.
1308 */
1309 j = 0;
1310 while (j < KEY_LEN)
1311 {
1312 for (i = 0; i < 16; ++i)
1313 {
1314 if (cc[i] == data[j]) j1 = i;
1315 if (cc[i] == skey->vernam[j]) j2 = i;
1316 }
1317 if (mode == 0)
1318 {
1319 j3 = j1 + j2;
1320 if (j3 > 15) j3 -= 16;
1321 data[j] = cc[j3];
1322 }
1323 else
1324 {
1325 j3 = j1 - j2;
1326 if (j3 < 0) j3 += 16;
1327 data[j] = cc[j3];
1328 }
1329 ++j;
1330 }
1331 SL_RET0(_("sh_util_encode"));
1332}
1333
1334/* server mode
1335 */
1336int sh_util_setserver (const char * dummy)
1337{
1338 SL_ENTER(_("sh_util_setserver"));
1339
1340 (void) dummy;
1341 sh.flag.isserver = GOOD;
1342 SL_RETURN((0),_("sh_util_setserver"));
1343}
1344
1345
1346int sh_util_setlooptime (const char * str)
1347{
1348 int i = atoi (str);
1349
1350 SL_ENTER(_("sh_util_setlooptime"));
1351
1352 if (i >= 0 && i < INT_MAX) {
1353 sh.looptime = i;
1354 SL_RETURN((0),_("sh_util_setlooptime"));
1355 } else {
1356 sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
1357 _("loop time"), str);
1358 SL_RETURN((-1),_("sh_util_setlooptime"));
1359 }
1360}
1361
1362#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
1363int sh_util_setchecksum (const char * str)
1364{
1365 static int reject = 0;
1366
1367 SL_ENTER(_("sh_util_setchecksum"));
1368
1369 if (reject == 1)
1370 SL_RETURN((0), _("sh_util_setchecksum"));
1371 reject = 1;
1372
1373 if (sl_strncmp (str, _("init"), sizeof("init")-1) == 0)
1374 {
1375 sh.flag.checkSum = SH_CHECK_INIT;
1376 }
1377 else if (sl_strncmp (str, _("update"), sizeof("update")-1) == 0)
1378 {
1379 if (S_TRUE == file_is_remote())
1380 {
1381 sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
1382 _("checksum testing"), str);
1383 SL_RETURN((-1), _("sh_util_setchecksum"));
1384 }
1385 else
1386 {
1387 sh.flag.checkSum = SH_CHECK_CHECK;
1388 sh.flag.update = S_TRUE;
1389 }
1390 }
1391 else if (sl_strncmp (str, _("check"), sizeof("check")-1) == 0)
1392 {
1393 sh.flag.checkSum = SH_CHECK_CHECK;
1394 }
1395 /*
1396 else if (sl_strncmp (str, _("update"), sizeof("update")-1) == 0)
1397 {
1398 sh.flag.checkSum = SH_CHECK_INIT;
1399 sh.flag.update = S_TRUE;
1400 }
1401 */
1402 else if (sl_strncmp (str, _("none"), sizeof("none")-1) == 0)
1403 {
1404 sh.flag.checkSum = SH_CHECK_NONE;
1405 }
1406 else
1407 {
1408 sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
1409 _("checksum testing"), str);
1410 SL_RETURN((-1), _("sh_util_setchecksum"));
1411 }
1412 SL_RETURN((0), _("sh_util_setchecksum"));
1413}
1414#endif
1415
1416/*@+charint@*/
1417unsigned char TcpFlag[8][PW_LEN+1] = {
1418#if (POS_TF == 1)
1419 { 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
1420#endif
1421 { 0xFF,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xFF,0x00 },
1422#if (POS_TF == 2)
1423 { 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
1424#endif
1425 { 0xFF,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xFF,0x00 },
1426#if (POS_TF == 3)
1427 { 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
1428#endif
1429 { 0xFF,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xFF,0x00 },
1430#if (POS_TF == 4)
1431 { 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
1432#endif
1433 { 0xFF,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xFF,0x00 },
1434#if (POS_TF == 5)
1435 { 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
1436#endif
1437 { 0xFF,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xFF,0x00 },
1438#if (POS_TF == 6)
1439 { 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
1440#endif
1441 { 0xFF,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xFF,0x00 },
1442#if (POS_TF == 7)
1443 { 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
1444#endif
1445 { 0xFF,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xFF,0x00 },
1446#if (POS_TF == 8)
1447 { 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
1448#endif
1449};
1450/*@-charint@*/
1451
1452/* initialize a key to a random value
1453 * rev 0.8
1454 */
1455int sh_util_keyinit (char * buf, long size)
1456{
1457 UINT32 bufy[6];
1458 int i;
1459 int status = 0;
1460 char * p;
1461 char hashbuf[KEYBUF_SIZE];
1462
1463 SL_ENTER(_("sh_util_keyinit"));
1464
1465 ASSERT((size <= KEY_LEN+1), _("size <= KEY_LEN+1"))
1466
1467 if (size > KEY_LEN+1)
1468 size = KEY_LEN+1;
1469
1470 /* seed / re-seed the PRNG if required
1471 */
1472 status = taus_seed ();
1473
1474 if (status == -1)
1475 sh_error_handle ((-1), FIL__, __LINE__, -1, MSG_ES_KEY1,
1476 _("taus_seed"));
1477
1478 for (i = 0; i < 6; ++i)
1479 bufy[i] = taus_get();
1480
1481 p = sh_tiger_hash ((char *) bufy, TIGER_DATA,
1482 (unsigned long)(6*sizeof(UINT32)),
1483 hashbuf, sizeof(hashbuf));
1484
1485 i = sl_strlcpy(buf, p, (size_t)size);
1486
1487 memset (bufy, 0, 6*sizeof(UINT32));
1488
1489 if ((status == 0) && (!SL_ISERROR(i)) )
1490 SL_RETURN((0),_("sh_util_keyinit"));
1491
1492 if (SL_ISERROR(i))
1493 sh_error_handle ((-1), FIL__, __LINE__, i, MSG_ES_KEY2,
1494 _("sl_strlcpy"));
1495
1496 SL_RETURN((-1),_("sh_util_keyinit"));
1497}
1498
1499#if defined(SH_WITH_CLIENT) || defined(SH_STANDALONE)
1500
1501static unsigned char sh_obscure_index[256];
1502static int sh_obscure_no_check = S_FALSE;
1503
1504int sh_util_valid_utf8 (const unsigned char * str)
1505{
1506 const int sh_val_utf8_1 = 1;
1507 const int sh_val_utf8_2 = 2;
1508 const int sh_val_utf8_3 = 3;
1509 const int sh_val_utf8_4 = 4;
1510
1511 size_t len = strlen((const char *)str);
1512 size_t l = 0;
1513 int typ = 0;
1514 unsigned char c = '\0';
1515 unsigned char c2[2] = { 0x00, 0x00 };
1516 unsigned char c3[3] = { 0x00, 0x00, 0x00 };
1517
1518
1519#define SH_VAL_UTF8_1 ((c != '\0') && ((c & 0x80) == 0x00))
1520#define SH_VAL_UTF8_2 ((c != '\0') && ((c & 0xE0) == 0xC0)) /* 110x xxxx */
1521#define SH_VAL_UTF8_3 ((c != '\0') && ((c & 0xF0) == 0xE0)) /* 1110 xxxx */
1522#define SH_VAL_UTF8_4 ((c != '\0') && ((c & 0xF8) == 0xF0)) /* 1111 0xxx */
1523#define SH_VAL_UTF8_N ((c != '\0') && ((c & 0xC0) == 0x80)) /* 10xx xxxx */
1524#define SH_VAL_BAD ((c == '"') || (c == '\t') || (c == '\b') || \
1525 (c == '\f') || (c == '\n') || \
1526 (c == '\r') || (c == '\v') || iscntrl((int) c) || \
1527 (c != ' ' && !isgraph ((int) c)))
1528
1529 while(l < len)
1530 {
1531 c = str[l];
1532
1533 if (SH_VAL_UTF8_1)
1534 {
1535 if (!(SH_VAL_BAD && (sh_obscure_index[c] != 1)))
1536 {
1537 typ = sh_val_utf8_1;
1538 ++l; continue;
1539 }
1540 else
1541 {
1542 return S_FALSE;
1543 }
1544 }
1545 else if (SH_VAL_UTF8_2)
1546 {
1547 typ = sh_val_utf8_2;
1548 c2[0] = c;
1549 if ((c & 0x3e) != 0x00) /* !(overlong 2-byte seq.) */
1550 {
1551 ++l;
1552 if (l != len) {
1553 c = str[l];
1554 if(SH_VAL_UTF8_N) {
1555 c2[1] = c;
1556 ++l; continue;
1557 }
1558 else {
1559 return S_FALSE;
1560 }
1561 }
1562 else {
1563 return S_FALSE;
1564 }
1565 }
1566 else
1567 {
1568 return S_FALSE; /* overlong 2-byte seq. */
1569 }
1570 }
1571 else if (SH_VAL_UTF8_3)
1572 {
1573 typ = sh_val_utf8_3;
1574 c3[0] = c;
1575 ++l; if (l == len) return S_FALSE; c = str[l];
1576 if(!SH_VAL_UTF8_N) return S_FALSE;
1577 if (((str[l-1] & 0x1F) == 0x00) && ((c & 0x60) == 0x00))
1578 return S_FALSE; /* overlong 3-byte seq. */
1579 c3[1] = c;
1580 ++l; if (l == len) return S_FALSE; c = str[l];
1581 if(!SH_VAL_UTF8_N) return S_FALSE;
1582 c3[2] = c;
1583 ++l; continue;
1584 }
1585 else if (SH_VAL_UTF8_4)
1586 {
1587 typ = sh_val_utf8_4;
1588 ++l; if (l == len) return S_FALSE; c = str[l];
1589 if(!SH_VAL_UTF8_N) return S_FALSE;
1590 if (((str[l-1] & 0x0F) == 0x00) && ((c & 0x70) == 0x00))
1591 return S_FALSE; /* overlong 4-byte seq. */
1592 ++l; if (l == len) return S_FALSE; c = str[l];
1593 if(!SH_VAL_UTF8_N) return S_FALSE;
1594 ++l; if (l == len) return S_FALSE; c = str[l];
1595 if(!SH_VAL_UTF8_N) return S_FALSE;
1596 ++l; continue;
1597 }
1598 return S_FALSE;
1599 }
1600
1601 /* last character is invisible (space or else)
1602 */
1603 if (typ == sh_val_utf8_1)
1604 {
1605 if (c != ' ')
1606 return S_TRUE;
1607 else
1608 return S_FALSE;
1609 }
1610 else if (typ == sh_val_utf8_2)
1611 {
1612 if (c2[0] == 0xC2 && c2[1] == 0xA0) /* nbsp */
1613 return S_FALSE;
1614 else
1615 return S_TRUE;
1616 }
1617 else if (typ == sh_val_utf8_3)
1618 {
1619 if (c3[0] == 0xE2)
1620 {
1621 if (c3[1] == 0x80 && c3[2] >= 0x80 && c3[2] <= 0x8F)
1622 return S_FALSE; /* various spaces, left-to-right, right-to-left */
1623 else if (c3[1] == 0x80 && (c3[2] == 0xA8 || c3[2] == 0xA9 ||
1624 c3[2] == 0xAD || c3[2] == 0xAF))
1625 return S_FALSE; /* line sep, para sep, zw word joiner, nnbsp */
1626 else if (c3[1] == 0x81 && (c3[2] == 0xA0 || c3[2] == 0xA1 ||
1627 c3[2] == 0x9F))
1628 return S_FALSE; /* word joiner, function app, math space */
1629 else
1630 return S_TRUE;
1631 }
1632 else if (c3[0] == 0xE3 && c3[1] == 0x80 && c3[2] == 0x80)
1633 {
1634 return S_FALSE; /* ideographic space */
1635 }
1636 else if (c3[0] == 0xEF && c3[1] == 0xBB && c3[2] == 0xBF)
1637 {
1638 return S_FALSE; /* zwnbsp */
1639 }
1640 else
1641 {
1642 return S_TRUE;
1643 }
1644 }
1645 else
1646 {
1647 return S_TRUE;
1648 }
1649}
1650
1651
1652int sh_util_obscure_ok (const char * str)
1653{
1654 unsigned long i;
1655 char * endptr = NULL;
1656
1657 SL_ENTER(_("sh_util_obscure_ok"));
1658
1659 if (0 == sl_strncmp("all", str, 3))
1660 {
1661 for (i = 0; i < 255; ++i)
1662 {
1663 sh_obscure_index[i] = (unsigned char)1;
1664 }
1665 sh_obscure_no_check = S_TRUE;
1666 SL_RETURN(0, _("sh_util_obscure_ok"));
1667 }
1668
1669 sh_obscure_no_check = S_FALSE;
1670
1671 for (i = 0; i < 255; ++i)
1672 {
1673 sh_obscure_index[i] = (unsigned char)0;
1674 }
1675
1676 i = strtoul (str, &endptr, 0);
1677 if (i > 255)
1678 {
1679 SL_RETURN(-1, _("sh_util_obscure_ok"));
1680 }
1681 sh_obscure_index[i] = (unsigned char)1;
1682 if (*endptr == ',')
1683 ++endptr;
1684
1685 while (*endptr != '\0')
1686 {
1687 i = strtoul (endptr, &endptr, 0);
1688 if (i > 255)
1689 {
1690 SL_RETURN(-1, _("sh_util_obscure_ok"));
1691 }
1692 sh_obscure_index[i] = (unsigned char)1;
1693 if (*endptr == ',')
1694 ++endptr;
1695 }
1696 SL_RETURN(0, _("sh_util_obscure_ok"));
1697}
1698
1699static int sh_obscure_check_utf8 = S_FALSE;
1700
1701int sh_util_obscure_utf8 (const char * c)
1702{
1703 int i;
1704 SL_ENTER(_("sh_util_obscure_utf8"));
1705 i = sh_util_flagval(c, &(sh_obscure_check_utf8));
1706 if (sh_obscure_check_utf8 == S_TRUE)
1707 sh_obscure_no_check = S_FALSE;
1708 SL_RETURN(i, _("sh_util_obscure_utf8"));
1709}
1710
1711
1712int sh_util_obscurename (ShErrLevel level, char * name_orig, int flag)
1713{
1714 unsigned char * name = (unsigned char *) name_orig;
1715 char * safe;
1716 unsigned int i;
1717 size_t len = 0;
1718
1719 SL_ENTER(_("sh_util_obscurename"));
1720
1721 ASSERT_RET((name != NULL), _("name != NULL"), (0))
1722
1723 if (sh_obscure_no_check == S_FALSE)
1724 {
1725 if (sh_obscure_check_utf8 != S_TRUE)
1726 {
1727 /* -- Check name. --
1728 */
1729 while (*name != '\0')
1730 {
1731 if ( (*name) > 0x7F || (*name) == '"' || (*name) == '\t' ||
1732 (*name) == '\b' || (*name) == '\f' ||
1733 (*name) == '\n' || (*name) == '\r' ||
1734 (*name) == '\v' || iscntrl((int) *name) ||
1735 ((*name) != ' ' && !isgraph ((int) *name)) )
1736 {
1737 i = (unsigned char) *name;
1738 if (sh_obscure_index[i] != (unsigned char)1)
1739 {
1740 goto err;
1741 }
1742 }
1743 name++; ++len;
1744 }
1745
1746 /* Check for blank at end of name
1747 */
1748 if ((len > 0) && (name_orig[len-1] == ' '))
1749 {
1750 goto err;
1751 }
1752 }
1753 else
1754 {
1755 if (S_FALSE == sh_util_valid_utf8(name))
1756 {
1757 goto err;
1758 }
1759 SL_RETURN((0),_("sh_util_obscurename"));
1760 }
1761 }
1762
1763 SL_RETURN((0),_("sh_util_obscurename"));
1764
1765 err:
1766
1767 if (flag == S_TRUE)
1768 {
1769 safe = sh_util_safe_name (name_orig);
1770 sh_error_handle (level, FIL__, __LINE__, 0, MSG_FI_OBSC,
1771 safe);
1772 SH_FREE(safe);
1773 }
1774 SL_RETURN((-1),_("sh_util_obscurename"));
1775}
1776
1777#endif
1778
1779/* returns freshly allocated memory, return value should be free'd
1780 */
1781char * sh_util_dirname(const char * fullpath)
1782{
1783 char * retval;
1784 size_t len;
1785 char * tmp;
1786
1787 SL_ENTER(_("sh_util_dirname"));
1788
1789 ASSERT_RET ((fullpath != NULL), _("fullpath != NULL"), (NULL))
1790 ASSERT_RET ((*fullpath == '/'), _("*fullpath == '/'"), (NULL))
1791
1792 retval = sh_util_strdup(fullpath);
1793
1794 tmp = retval;
1795 while (*tmp == '/') ++tmp;
1796
1797 /* (1) only leading slashes -- return exact copy
1798 */
1799 if (*tmp == '\0')
1800 {
1801 SL_RETURN(retval, _("sh_util_dirname"));
1802 }
1803
1804 /* (2) there are non-slash characters, so delete trailing slashes
1805 */
1806 len = sl_strlen (retval); /* retval[len] is terminating '\0' */
1807
1808 while (len > 1 && retval[len-1] == '/') /* delete trailing slash */
1809 {
1810 retval[len-1] = '\0';
1811 --len;
1812 }
1813
1814 /* (3) now delete all non-slash characters up to the preceding slash
1815 */
1816 while (len > 1 && retval[len-1] != '/') {
1817 retval[len-1] = '\0';
1818 --len;
1819 }
1820
1821 /* (4a) only leading slashes left, so return this
1822 */
1823 if (&(retval[len]) == tmp)
1824 {
1825 SL_RETURN(retval, _("sh_util_dirname"));
1826 }
1827
1828 /* (4b) strip trailing slash(es) of parent directory
1829 */
1830 while (len > 1 && retval[len-1] == '/') {
1831 retval[len-1] = '\0';
1832 --len;
1833 }
1834 SL_RETURN(retval, _("sh_util_dirname"));
1835
1836}
1837
1838/* returns freshly allocated memory, return value should be free'd
1839 */
1840char * sh_util_basename(const char * fullpath)
1841{
1842 char * retval = NULL;
1843 const char * tmp;
1844 char * tmp2;
1845 char * c;
1846 size_t len;
1847
1848 SL_ENTER(_("sh_util_basename"));
1849
1850 ASSERT_RET ((fullpath != NULL), _("fullpath != NULL"), (NULL))
1851
1852 tmp = fullpath; while (*tmp == '/') ++tmp;
1853 if (*tmp == '\0')
1854 {
1855 retval = sh_util_strdup(fullpath);
1856 }
1857 else
1858 {
1859 tmp2 = sh_util_strdup(tmp);
1860 len = sl_strlen (tmp2);
1861
1862 while (len > 1 && tmp2[len-1] == '/')
1863 {
1864 tmp2[len-1] = '\0';
1865 --len;
1866 }
1867
1868 c = strrchr(tmp2, '/');
1869 if (c)
1870 {
1871 retval = sh_util_strdup(++c);
1872 SH_FREE(tmp2);
1873 }
1874 else
1875 {
1876 retval = tmp2;
1877 }
1878 }
1879
1880 SL_RETURN(retval, _("sh_util_basename"));
1881}
1882
1883#define SH_ESCAPE_SPACE 1
1884#define SH_DONT_ESCAPE_SPACE 0
1885char * sh_util_safe_name_int (const char * name, int escape_space);
1886
1887char * sh_util_safe_name (const char * name)
1888{
1889 return sh_util_safe_name_int (name, SH_ESCAPE_SPACE);
1890}
1891
1892char * sh_util_safe_name_keepspace (const char * name)
1893{
1894 return sh_util_safe_name_int (name, SH_DONT_ESCAPE_SPACE);
1895}
1896
1897/* returns freshly allocated memory, return value should be free'd
1898 */
1899char * sh_util_safe_name_int (const char * name, int escape_space)
1900{
1901 register int i = 0;
1902 const char * p;
1903 char * retval;
1904 char oct[32];
1905 char format[16];
1906 size_t len;
1907
1908 SL_ENTER(_("sh_util_safe_name"));
1909
1910 if (name == NULL)
1911 {
1912 /* return an allocated array
1913 */
1914 retval = SH_ALLOC(7);
1915 (void) sl_strlcpy(retval, _("(null)"), 7);
1916 SL_RETURN(retval, _("sh_util_safe_name"));
1917 }
1918
1919 /*
1920 ASSERT_RET ((name != NULL), _("name != NULL"), _("NULL"))
1921 */
1922
1923 len = sl_strlen(name);
1924 p = name;
1925
1926#ifdef SH_USE_XML
1927 if (sl_ok_muls (6, len) && sl_ok_adds ((6*len), 2))
1928 { retval = SH_ALLOC(6 * len + 2); }
1929 else
1930 {
1931 /* return an allocated array
1932 */
1933 retval = SH_ALLOC(11);
1934 (void) sl_strlcpy(retval, _("(overflow)"), 11);
1935 SL_RETURN(retval, _("sh_util_safe_name"));
1936 }
1937#else
1938 if (sl_ok_muls (4, len) && sl_ok_adds ((4*len), 2))
1939 { retval = SH_ALLOC(4 * len + 2); }
1940 else
1941 {
1942 /* return an allocated array
1943 */
1944 retval = SH_ALLOC(11);
1945 (void) sl_strlcpy(retval, _("(overflow)"), 11);
1946 SL_RETURN(retval, _("sh_util_safe_name"));
1947 }
1948#endif
1949
1950 (void) sl_strncpy(format, _("%c%03o"), 16);
1951
1952 while (*p != '\0') {
1953 /* Most frequent cases first
1954 */
1955 if ( ((*p) >= 'a' && (*p) <= 'z') || ((*p) == '/') || ((*p) == '.') ||
1956 ((*p) >= '0' && (*p) <= '9') ||
1957 ((*p) >= 'A' && (*p) <= 'Z')) {
1958 retval[i] = *p;
1959 } else if ( (*p) == '\\') { /* backslash */
1960 retval[i] = '\\'; ++i;
1961 retval[i] = '\\';
1962 } else if ( (*p) == '\n') { /* newline */
1963 retval[i] = '\\'; ++i;
1964 retval[i] = 'n';
1965 } else if ( (*p) == '\b') { /* backspace */
1966 retval[i] = '\\'; ++i;
1967 retval[i] = 'b';
1968 } else if ( (*p) == '\r') { /* carriage return */
1969 retval[i] = '\\'; ++i;
1970 retval[i] = 'r';
1971 } else if ( (*p) == '\t') { /* horizontal tab */
1972 retval[i] = '\\'; ++i;
1973 retval[i] = 't';
1974 } else if ( (*p) == '\v') { /* vertical tab */
1975 retval[i] = '\\'; ++i;
1976 retval[i] = 'v';
1977 } else if ( (*p) == '\f') { /* form-feed */
1978 retval[i] = '\\'; ++i;
1979 retval[i] = 'f';
1980#ifdef WITH_DATABASE
1981 } else if ( (*p) == '\'') { /* single quote */
1982 retval[i] = '\\'; ++i;
1983 retval[i] = '\'';
1984#endif
1985 } else if ( (*p) == ' ') { /* space */
1986 if (escape_space) {
1987 retval[i] = '\\'; ++i;
1988 retval[i] = ' ';
1989 }
1990 else {
1991 retval[i] = *p;
1992 }
1993#ifdef SH_USE_XML
1994 } else if ( (*p) == '"') { /* double quote */
1995 retval[i] = '&'; ++i;
1996 retval[i] = 'q'; ++i;
1997 retval[i] = 'u'; ++i;
1998 retval[i] = 'o'; ++i;
1999 retval[i] = 't'; ++i;
2000 retval[i] = ';';
2001 } else if ( (*p) == '&') { /* ampersand */
2002 retval[i] = '&'; ++i;
2003 retval[i] = 'a'; ++i;
2004 retval[i] = 'm'; ++i;
2005 retval[i] = 'p'; ++i;
2006 retval[i] = ';';
2007 } else if ( (*p) == '<') { /* left angle */
2008 retval[i] = '&'; ++i;
2009 retval[i] = 'l'; ++i;
2010 retval[i] = 't'; ++i;
2011 retval[i] = ';';
2012 } else if ( (*p) == '>') { /* right angle */
2013 retval[i] = '&'; ++i;
2014 retval[i] = 'g'; ++i;
2015 retval[i] = 't'; ++i;
2016 retval[i] = ';';
2017#else
2018 } else if ( (*p) == '"') { /* double quote */
2019 retval[i] = '\\'; ++i;
2020 retval[i] = '\"';
2021#endif
2022 } else if (!isgraph ((int) *p)) { /* not printable */
2023 /*@-bufferoverflowhigh -formatconst@*/
2024 /* flawfinder: ignore */
2025 sprintf(oct, format, '\\', /* known to fit */
2026 (unsigned char) *p);
2027 /*@+bufferoverflowhigh +formatconst@*/
2028 retval[i] = oct[0]; ++i;
2029 retval[i] = oct[1]; ++i;
2030 retval[i] = oct[2]; ++i;
2031 retval[i] = oct[3];
2032 } else {
2033 retval[i] = *p;
2034 }
2035 ++p;
2036 ++i;
2037 }
2038 retval[i] = '\0';
2039 SL_RETURN(retval, _("sh_util_safe_name"));
2040}
2041
2042int sh_util_isnum (const char *str)
2043{
2044 const char *p = str;
2045
2046 SL_ENTER(_("sh_util_isnum"));
2047
2048 ASSERT_RET ((str != NULL), _("str != NULL"), (-1))
2049
2050 while (p) {
2051 if (!isdigit((int) *p) )
2052 SL_RETURN((-1), _("sh_util_isnum"));
2053 ++p;
2054 }
2055 SL_RETURN((0), _("sh_util_isnum"));
2056}
2057
2058char * sh_util_strconcat (const char * arg1, ...)
2059{
2060 size_t length, l2;
2061 char * s;
2062 char * strnew;
2063 va_list vl;
2064
2065 SL_ENTER(_("sh_util_strconcat"));
2066
2067 ASSERT_RET ((arg1 != NULL), _("arg1 != NULL"), (NULL))
2068
2069 length = sl_strlen (arg1) + 1;
2070
2071 va_start (vl, arg1);
2072 s = va_arg (vl, char * );
2073 while (s != NULL)
2074 {
2075 l2 = sl_strlen (s);
2076 if (sl_ok_adds(length, l2))
2077 length += l2;
2078 else
2079 SL_RETURN(NULL, _("sh_util_strconcat"));
2080 s = va_arg (vl, char * );
2081 }
2082 va_end (vl);
2083
2084 if (sl_ok_adds(length, 2))
2085 strnew = SH_ALLOC( length + 2 );
2086 else
2087 SL_RETURN(NULL, _("sh_util_strconcat"));
2088
2089 strnew[0] = '\0';
2090
2091 (void) sl_strlcpy (strnew, arg1, length + 2);
2092
2093 va_start (vl, arg1);
2094 s = va_arg (vl, char * );
2095 while (s)
2096 {
2097 (void) sl_strlcat (strnew, s, length + 2);
2098 s = va_arg (vl, char * );
2099 }
2100 va_end (vl);
2101
2102 SL_RETURN(strnew, _("sh_util_strconcat"));
2103}
2104
2105static const char bto64_0[] = N_("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789()");
2106static char bto64[65] = { '\0' };
2107
2108
2109size_t sh_util_base64_enc (unsigned char * out, const unsigned char * instr,
2110 size_t lin)
2111{
2112 int ll;
2113 unsigned char a, b, c;
2114 size_t len = 0;
2115 size_t j = 0;
2116
2117 start:
2118 if (bto64[0] != '\0')
2119 {
2120 if (instr && *instr)
2121 {
2122 if (lin == 0)
2123 lin = strlen((const char *)instr);
2124
2125 do {
2126 ll = 0;
2127
2128 if (len < lin)
2129 { a = *instr; ++instr; ++len; ++ll; }
2130 else
2131 { a = 0; }
2132 if (len < lin)
2133 { b = *instr; ++instr; ++len; ++ll; }
2134 else
2135 { b = 0; }
2136 if (len < lin)
2137 { c = *instr; ++instr; ++len; ++ll; }
2138 else
2139 { c = 0; }
2140
2141 *out = bto64[ a >> 2 ];
2142 ++j; ++out;
2143 *out = bto64[ ((a & 0x03) << 4) | ((b & 0xf0) >> 4) ];
2144 ++j; ++out;
2145 *out = (unsigned char) (ll > 1 ? bto64[ ((b & 0x0f) << 2) | ((c & 0xc0) >> 6) ] : '?');
2146 ++j; ++out;
2147 *out = (unsigned char) (ll > 2 ? bto64[ c & 0x3f ] : '?');
2148 ++j; ++out;
2149 } while (len < lin);
2150 }
2151 *out = '\0';
2152 return j;
2153 }
2154
2155 memcpy(bto64, _(bto64_0), 65);
2156 goto start;
2157}
2158
2159size_t sh_util_base64_enc_alloc (char **out, const char *in, size_t inlen)
2160{
2161 size_t outlen = SH_B64_SIZ(inlen);
2162
2163 if (inlen > outlen) /* overflow */
2164 {
2165 *out = NULL;
2166 return 0;
2167 }
2168
2169 *out = SH_ALLOC(outlen);
2170 return sh_util_base64_enc((unsigned char *)*out, (const unsigned char *)in, inlen);
2171}
2172
2173size_t sh_util_base64_dec (unsigned char *out, const unsigned char *in,
2174 size_t lin)
2175{
2176 size_t i;
2177 unsigned char c;
2178 unsigned char b;
2179 size_t lout = 0;
2180 int w = 0;
2181
2182 if (out && in)
2183 {
2184 if (lin == 0)
2185 lin = strlen((const char *)in);
2186
2187 for (i = 0; i < lin; i++)
2188 {
2189 c = *in; ++in;
2190 b = 0;
2191
2192 if ((c >= 'A') && (c <= 'Z'))
2193 {
2194 b = (c - 'A');
2195 }
2196 else if ((c >= 'a') && (c <= 'z'))
2197 {
2198 b = (c - 'a' + 26);
2199 }
2200 else if ((c >= '0') && (c <= '9'))
2201 {
2202 b = (c - '0' + 52);
2203 }
2204 else if (c == '(' || c == '+')
2205 {
2206 b = 62;
2207 }
2208 else if (c == ')' || c == '/')
2209 {
2210 b = 63;
2211 }
2212 else if (c == '?' || c == '=')
2213 {
2214 /* last byte was written to, but will now get
2215 * truncated
2216 */
2217 if (lout > 0) --lout;
2218 break;
2219 }
2220
2221 if (w == 0)
2222 {
2223 *out = (b << 2) & 0xfc;
2224 ++lout;
2225 }
2226 else if (w == 1)
2227 {
2228 *out |= (b >> 4) & 0x03;
2229 ++out;
2230 *out = (b << 4) & 0xf0;
2231 ++lout;
2232 }
2233 else if (w == 2)
2234 {
2235 *out |= (b >> 2) & 0x0f;
2236 ++out;
2237 *out = (b << 6) & 0xc0;
2238 ++lout;
2239 }
2240 else if (w == 3)
2241 {
2242 *out |= b & 0x3f;
2243 ++out;
2244 }
2245
2246 ++w;
2247
2248 if (w == 4)
2249 {
2250 w = 0;
2251 }
2252 }
2253 *out = '\0';
2254 }
2255 return lout;
2256}
2257
2258size_t sh_util_base64_dec_alloc (unsigned char **out, const unsigned char *in,
2259 size_t lin)
2260{
2261 size_t lout = 3 * (lin / 4) + 2;
2262
2263 *out = SH_ALLOC(lout);
2264
2265 return sh_util_base64_dec (*out, in, lin);
2266}
2267
2268
2269#ifdef HAVE_REGEX_H
2270
2271#include <regex.h>
2272
2273int sh_util_regcmp (char * regex_str, char * in_str)
2274{
2275#if defined(REG_ESPACE)
2276 int status = REG_ESPACE;
2277#else
2278 int status = -1;
2279#endif
2280 regex_t preg;
2281 char * errbuf;
2282
2283 SL_ENTER(_("sh_util_regcmp"));
2284
2285 status = regcomp(&preg, regex_str, REG_NOSUB|REG_EXTENDED);
2286
2287 if (status == 0)
2288 {
2289 if ((status = regexec(&preg, in_str, 0, NULL, 0)) == 0)
2290 {
2291 regfree (&preg);
2292 SL_RETURN((0), _("sh_util_regcmp"));
2293 }
2294 }
2295
2296 if (status != 0 && status != REG_NOMATCH)
2297 {
2298 errbuf = SH_ALLOC(BUFSIZ);
2299 (void) regerror(status, &preg, errbuf, BUFSIZ);
2300 errbuf[BUFSIZ-1] = '\0';
2301 sh_error_handle ((-1), FIL__, __LINE__, status, MSG_E_REGEX,
2302 errbuf, regex_str);
2303 SH_FREE(errbuf);
2304 }
2305
2306 regfree (&preg);
2307 SL_RETURN((-1), _("sh_util_regcmp"));
2308}
2309
2310#endif
2311
2312
2313
2314
2315
2316
2317
2318
Note: See TracBrowser for help on using the repository browser.