source: zcrypt.c @ 09489b89

barnowl_perlaimdebianowlrelease-1.4release-1.5release-1.6release-1.7release-1.8release-1.9
Last change on this file since 09489b89 was 09489b89, checked in by James M. Kretchmar <kretch@mit.edu>, 17 years ago
First pass at making owl build without zephyr
  • Property mode set to 100644
File size: 16.9 KB
Line 
1/* This file is stolen and slightly modified code */
2
3/* zcrypt.c -- Read in a data stream from stdin & dump a decrypted/encrypted *
4 *   datastream.  Reads the string to make the key from from the first       *
5 *   parameter.  Encrypts or decrypts according to -d or -e flag.  (-e is    *
6 *   default.)  Will invoke zwrite if the -c option is provided for          *
7 *   encryption.  If a zephyr class is specified & the keyfile name omitted  *
8 *   the ~/.crypt-table will be checked for "crypt-classname" and then       *
9 *   "crypt-default" for the keyfile name.                                   */
10
11static const char fileIdent[] = "$Id$";
12
13#include <stdio.h>
14#include <stdlib.h>
15#include <string.h>
16#include <sys/types.h>
17#include <sys/wait.h>
18#include "owl.h"
19
20#ifdef OWL_ENABLE_ZCRYPT
21
22#define BASE_CODE 70
23#define LAST_CODE (BASE_CODE + 15)
24#define OUTPUT_BLOCK_SIZE 16
25#include <unistd.h>
26#include <sys/types.h>
27#include <des.h>
28
29#define MAX_KEY 128
30
31#ifndef TRUE
32#define TRUE -1
33#endif
34#ifndef FALSE
35#define FALSE 0
36#endif
37
38#define ZWRITE_OPT_NOAUTH     (1<<0)
39#define ZWRITE_OPT_SIGNATURE  (1<<1)
40#define ZWRITE_OPT_IGNOREVARS (1<<2)
41#define ZWRITE_OPT_VERBOSE    (1<<3)
42#define ZWRITE_OPT_QUIET      (1<<4)
43#define ZCRYPT_OPT_MESSAGE    (1<<5)
44#define ZCRYPT_OPT_IGNOREDOT  (1<<6)
45
46typedef struct
47{
48  int flags;
49  char *signature;
50  char *message;
51} ZWRITEOPTIONS;
52
53char *GetZephyrVarKeyFile(char *whoami, char *class, char *instance);
54char *BuildArgString(char **argv, int start, int end);
55static int do_encrypt(char *keystring, int zephyr, char *class, char *instance, ZWRITEOPTIONS *zoptions, char* keyfile);
56int do_decrypt(char *keystring);
57
58#ifndef HAVE_DES_ECB_ENCRYPT_PROTO
59int des_ecb_encrypt(char [], char [], des_key_schedule, int);
60#endif
61
62#define M_NONE            0
63#define M_ZEPHYR_ENCRYPT  1
64#define M_DECRYPT         2
65#define M_ENCRYPT         3
66#define M_RANDOMIZE       4
67#define M_SETKEY          5
68
69int zcrypt(int argc, char *argv[]) {
70  char *fname = NULL;
71  int error = FALSE;
72  int zephyr = FALSE;
73  char *class = NULL, *instance = NULL;
74  int mode = M_NONE;
75
76  extern int optind, opterr;
77  extern char *optarg;
78  char c;
79
80  int messageflag = FALSE;
81  ZWRITEOPTIONS zoptions;
82  zoptions.flags = 0;
83
84  while ((c = getopt(argc, argv, "ZDERSF:c:i:advqtluons:f:m")) != (char)EOF) {
85    switch(c) {
86      case 'Z':
87        /* Zephyr encrypt */
88        mode = M_ZEPHYR_ENCRYPT;
89        break;
90      case 'D':
91        /* Decrypt */
92        mode = M_DECRYPT;
93        break;
94      case 'E':
95        /* Encrypt */
96        mode = M_ENCRYPT;
97        break;
98      case 'R':
99        /* Randomize the keyfile */
100        mode = M_RANDOMIZE;
101        break;
102      case 'S':
103        /* Set a new key value from stdin */
104        mode = M_SETKEY;
105        break;
106      case 'F':
107        /* Specify the keyfile explicitly */
108        if (fname != NULL) error = TRUE;
109        fname = optarg;
110        break;
111      case 'c':
112        /* Zwrite/zcrypt: class name */
113        if (class != NULL) error = TRUE;
114        class = optarg;
115        break;
116      case 'i':
117        /* Zwrite/zcrypt: instance name */
118        if (instance != NULL) error = TRUE;
119        instance = optarg;
120        break;
121      case 'a':
122        /* Zwrite: authenticate (default) */
123        zoptions.flags &= ~ZWRITE_OPT_NOAUTH;
124        break;
125      case 'd':
126        /* Zwrite: do not authenticate */
127        zoptions.flags |= ZWRITE_OPT_NOAUTH;
128        break;
129      case 'v':
130        /* Zwrite: verbose */
131        zoptions.flags |= ZWRITE_OPT_VERBOSE;
132        break;
133      case 'q':
134        /* Zwrite: quiet */
135        zoptions.flags |= ZWRITE_OPT_QUIET;
136        break;
137      case 't':
138        /* Zwrite: no expand tabs (ignored) */
139        break;
140      case 'l':
141        /* Zwrite: ignore '.' on a line by itself (ignored) */
142        zoptions.flags |= ZCRYPT_OPT_IGNOREDOT;
143        break;
144      case 'u':
145        /* Zwrite: urgent message */
146        instance = "URGENT";
147        break;
148      case 'o':
149        /* Zwrite: ignore zephyr variables zwrite-class, zwrite-inst, */
150        /*         zwrite-opcode */
151        zoptions.flags |= ZWRITE_OPT_IGNOREVARS;
152        break;
153      case 'n':
154        /* Zwrite: prevent PING message (always used) */
155        break;
156      case 's':
157        /* Zwrite: signature */
158        zoptions.flags |= ZWRITE_OPT_SIGNATURE;
159        zoptions.signature = optarg;
160        break;
161      case 'f':
162        /* Zwrite: file system specification (ignored) */
163        break;
164      case 'm':
165        /* Message on rest of line */
166        messageflag = TRUE;
167        break;
168      case '?':
169        error = TRUE;
170        break;
171    }
172    if (error || messageflag) break;
173  }
174
175  if (class != NULL || instance != NULL) {
176    zephyr = TRUE;
177  }
178
179  if (messageflag) {
180    zoptions.flags |= ZCRYPT_OPT_MESSAGE;
181    zoptions.message = BuildArgString(argv, optind, argc);
182    if (!zoptions.message)
183    {
184      printf("Memory allocation error.\n");
185      error = TRUE;
186    }
187  } else if (optind < argc) {
188    error = TRUE;
189  }
190
191  if (mode == M_NONE) mode = (zephyr?M_ZEPHYR_ENCRYPT:M_ENCRYPT);
192
193  if (mode == M_ZEPHYR_ENCRYPT && !zephyr) error = TRUE;
194
195  if (!error && fname == NULL && (class != NULL || instance != NULL)) {
196    fname = GetZephyrVarKeyFile(argv[0], class, instance);
197  }
198
199 
200  if (error || fname == NULL) {
201    printf("Usage: %s [-Z|-D|-E|-R|-S] [-F Keyfile] [-c class] [-i instance]\n", argv[0]);
202    printf("       [-advqtluon] [-s signature] [-f arg] [-m message]\n");
203    printf("  One or more of class, instance, and keyfile must be specified.\n");
204  } else {
205    if (mode == M_RANDOMIZE) {
206      /* Choose a new, random key */
207/*
208      FILE *fkey = fopen(fname, "w");
209      if (!fkey)
210        printf("Could not open key file for writing: %s\n", fname);
211      else
212      {
213        char string[100];
214        fputs(fkey, string);
215        fclose(fkey);
216        }
217 */
218      printf("Feature not yet implemented.\n");
219    } else if (mode == M_SETKEY) {
220      /* Set a new, user-entered key */
221      char newkey[MAX_KEY];
222      FILE *fkey;
223     
224      if (isatty(0)) {
225        printf("Enter new key: ");
226        /* Really should read without echo!!! */
227        fgets(newkey, MAX_KEY - 1, stdin);
228      } else {
229        fgets(newkey, MAX_KEY - 1, stdin);
230      }
231
232      fkey = fopen(fname, "w");
233      if (!fkey) {
234        printf("Could not open key file for writing: %s\n", fname);
235      } else {
236        if (fputs(newkey, fkey) != strlen(newkey) || putc('\n', fkey) != '\n') {
237          printf("Error writing to key file.\n");
238          fclose(fkey);
239        } else {
240          fclose(fkey);
241          printf("Key update complete.\n");
242        }
243      }
244    } else {
245      /* Encrypt/decrypt */
246      FILE *fkey = fopen(fname, "r");
247      if (!fkey) {
248        printf("Could not open key file: %s\n", fname);
249      } else {
250        char keystring[MAX_KEY];
251        fgets(keystring, MAX_KEY-1, fkey);
252        if (mode == M_ZEPHYR_ENCRYPT || mode == M_ENCRYPT) {
253          do_encrypt(keystring, (mode == M_ZEPHYR_ENCRYPT), class, instance,
254                     &zoptions, fname);
255        } else {
256          do_decrypt(keystring);
257        }
258        fclose(fkey);
259      }
260    }
261  }
262
263  /* Always print the **END** message if -D is specified. */
264  if (mode == M_DECRYPT) printf("**END**\n");
265
266  exit(0);
267}
268
269int zcrypt_decrypt(char *out, char *in, char *class, char *instance) {
270  /* written by kretch for owl. */
271  /* return 0 on success, otherwise -1 */
272  char *fname, keystring[MAX_KEY], *inptr, *endptr;
273  FILE *fkey;
274  des_cblock key;
275  des_key_schedule schedule;
276  char input[8], output[9];
277  int i, c1, c2;
278 
279  fname=GetZephyrVarKeyFile("zcrypt", class, instance);
280  fkey=fopen(fname, "r");
281  if (!fkey) return(-1);
282  fgets(keystring, MAX_KEY-1, fkey);
283  fclose(fkey);
284
285  strcpy(out, "");
286
287  output[0] = '\0';    /* In case no message at all                 */
288  output[8] = '\0';    /* NULL at end will limit string length to 8 */
289
290  des_string_to_key(keystring, key);
291  des_key_sched(key, schedule);
292
293  inptr=in;
294  endptr=in+strlen(in)-1;
295  while (inptr<endptr) {
296    for (i=0; i<8; i++) {
297      c1=(inptr[0])-BASE_CODE;
298      c2=(inptr[1])-BASE_CODE;
299      input[i]=c1 * 0x10 + c2;
300      inptr+=2;
301    }
302    des_ecb_encrypt(input, output, schedule, FALSE);
303    strcat(out, output);
304  }
305
306  if (output[0]) {
307    if (output[strlen(output)-1] != '\n') {
308      strcat(out, "\n");
309    }
310  } else {
311    strcat(out, "\n");
312  }
313  return(0);
314}
315
316int zcrypt_encrypt(char *out, char *in, char *class, char *instance) {
317  return(0);
318}
319
320/* Build a space-separated string from argv from elements between start  *
321 * and end - 1.  malloc()'s the returned string. */
322char *BuildArgString(char **argv, int start, int end) {
323  int len = 1;
324  int i;
325  char *result;
326
327  /* Compute the length of the string.  (Plus 1 or 2) */
328  for (i = start; i < end; i++) {
329    len += strlen(argv[i]) + 1;
330  }
331
332  /* Allocate memory */
333  result = (char *)malloc(len);
334  if (result) {
335    /* Build the string */
336    char *ptr = result;
337    /* Start with an empty string, in case nothing is copied. */
338    *ptr = '\0';
339    /* Copy the arguments */
340    for (i = start; i < end; i++) {
341      char *temp = argv[i];
342      /* Add a space, if not the first argument */
343      if (i != start) *ptr++ = ' ';
344      /* Copy argv[i], leaving ptr pointing to the '\0' copied from temp */
345      while ((*ptr = *temp++)!=0) {
346        ptr++;
347      }
348    }
349  }
350
351  return(result);
352}
353
354#define MAX_BUFF 258
355#define MAX_SEARCH 3
356/* Find the class/instance in the .crypt-table */
357char *GetZephyrVarKeyFile(char *whoami, char *class, char *instance) {
358  char *keyfile = NULL;
359  char varname[MAX_SEARCH][128];
360  int length[MAX_SEARCH], i;
361  char buffer[MAX_BUFF];
362  char filename[MAX_BUFF];
363  char result[MAX_SEARCH][MAX_BUFF];
364  int numsearch = 0;
365  FILE *fsearch;
366
367  /* Determine names to look for in .crypt-table */
368  if (instance) {
369    sprintf(varname[numsearch++], "crypt-%s-%s:", (class?class:"message"), 
370            instance);
371  }
372  if (class) {
373    sprintf(varname[numsearch++], "crypt-%s:", class);
374  }
375  sprintf(varname[numsearch++], "crypt-default:");
376
377  /* Setup the result array, and determine string lengths */
378  for (i = 0; i < numsearch; i++) {
379    result[i][0] = '\0';
380    length[i] = strlen(varname[i]);
381  }
382
383  /* Open~/.crypt-table */
384  sprintf(filename, "%s/.crypt-table", getenv("HOME"));
385  fsearch = fopen(filename, "r");
386  if (fsearch) {
387    /* Scan file for a match */
388    while (!feof(fsearch)) {
389      fgets(buffer, MAX_BUFF - 3, fsearch);
390      for (i = 0; i < numsearch; i++) {
391        if (strncasecmp(varname[i], buffer, length[i]) == 0) {
392          int j;
393          for (j = length[i]; buffer[j] == ' '; j++)
394            ;
395          strcpy(result[i], &buffer[j]);
396          if (*result[i]) {
397            if (result[i][strlen(result[i])-1] == '\n') {
398              result[i][strlen(result[i])-1] = '\0';
399            }
400          }
401        }
402      }
403    }
404
405    /* Pick the "best" match found */
406    keyfile = NULL;
407    for (i = 0; i < numsearch; i++) {
408      if (*result[i]) {
409        keyfile = result[i];
410        break;
411      }
412    }
413
414    if (keyfile == NULL) {
415      printf("Could not find key table entry.\n");
416    } else {
417      /* Prepare result to be returned */
418      char *temp = keyfile;
419      keyfile = (char *)malloc(strlen(temp) + 1);
420      if (keyfile) {
421        strcpy(keyfile, temp);
422      } else {
423        printf("Memory allocation error.\n");
424      }
425    }
426   
427    fclose(fsearch);
428  } else {
429    printf("Could not open key table file: %s\n", filename);
430  }
431
432  return(keyfile);
433}
434
435static pid_t zephyrpipe_pid = 0;
436
437/* Open a pipe to zwrite */
438static FILE *GetZephyrPipe(char *class, char *instance, ZWRITEOPTIONS *zoptions) {
439  int fildes[2];
440  pid_t pid;
441  FILE *result;
442  char *argv[20];
443  int argc = 0;
444
445  if (pipe(fildes) < 0) return(NULL);
446  pid = fork();
447
448  if (pid < 0) {
449    /* Error: clean up */
450    close(fildes[0]);
451    close(fildes[1]);
452    result = NULL;
453  } else if (pid == 0) {
454    /* Setup child process */
455    argv[argc++] = "zwrite";
456    argv[argc++] = "-n";     /* Always send without ping */
457    if (class) {
458      argv[argc++] = "-c";
459      argv[argc++] = class;
460    }
461    if (instance) {
462      argv[argc++] = "-i";
463      argv[argc++] = instance;
464    }
465    if (zoptions->flags & ZWRITE_OPT_NOAUTH) argv[argc++] = "-d";
466    if (zoptions->flags & ZWRITE_OPT_QUIET) argv[argc++] = "-q";
467    if (zoptions->flags & ZWRITE_OPT_VERBOSE) argv[argc++] = "-v";
468    if (zoptions->flags & ZWRITE_OPT_SIGNATURE) {
469      argv[argc++] = "-s";
470      argv[argc++] = zoptions->signature;
471    }
472    argv[argc++] = "-O";
473    argv[argc++] = "crypt";
474    argv[argc] = NULL;
475    close(fildes[1]);
476    if (fildes[0] != STDIN_FILENO) {
477      if (dup2(fildes[0], STDIN_FILENO) != STDIN_FILENO) exit(0);
478      close(fildes[0]);
479    }
480    close(fildes[0]);
481    execvp(argv[0], argv);
482    printf("Exec error: could not run zwrite\n");
483    exit(0);
484  } else {
485    close(fildes[0]);
486    /* Create a FILE * for the zwrite pipe */
487    result = (FILE *)fdopen(fildes[1], "w");
488    zephyrpipe_pid = pid;
489  }
490
491  return(result);
492}
493
494/* Close the pipe to zwrite */
495void CloseZephyrPipe(FILE *pipe) {
496  fclose(pipe);
497  waitpid(zephyrpipe_pid, NULL, 0);
498  zephyrpipe_pid = 0;
499}
500
501#define MAX_RESULT 2048
502
503
504void block_to_ascii(char *output, FILE *outfile) {
505  int i;
506  for (i = 0; i < 8; i++) {
507    putc(((output[i] & 0xf0) >> 4) + BASE_CODE, outfile);
508    putc( (output[i] & 0x0f)       + BASE_CODE, outfile);
509  }
510}
511
512#define MAX_LINE 128
513
514/* Encrypt stdin, with prompt if isatty, and send to stdout, or to zwrite
515   if zephyr is set. */
516static int do_encrypt(char *keystring, int zephyr, char *class, char *instance, ZWRITEOPTIONS *zoptions, char* keyfile) {
517  des_cblock key;
518  des_key_schedule schedule;
519  char input[8], output[8];
520  int size;
521  FILE *outfile = stdout;
522  int error = FALSE;
523  char *inbuff = NULL, *inptr;
524  int freein = FALSE;
525  int use_buffer = FALSE;
526  int num_blocks=0, last_block_size=0;
527
528  des_string_to_key(keystring, key);
529  des_key_sched(key, schedule);
530
531  if (zephyr) {
532    if (zoptions->flags & ZCRYPT_OPT_MESSAGE) {
533      /* Use the -m message */
534      int length;
535      inbuff = zoptions->message;     
536      length = strlen(inbuff);
537      num_blocks = (length + 7) / 8;
538      last_block_size = ((length + 7) % 8) + 1;
539      use_buffer = TRUE;
540    } else if (isatty(0)) {
541      /* tty input, so show the "Type your message now..." message */
542      if (zoptions->flags & ZCRYPT_OPT_IGNOREDOT) {
543        printf("Type your message now.  End with the end-of-file character.\n");
544      } else {
545        printf("Type your message now.  End with control-D or a dot on a line by itself.\n");
546      }
547      use_buffer = TRUE;
548      if ((inptr = inbuff = (char *)malloc(MAX_RESULT)) == NULL) {
549        printf("Memory allocation error\n");
550        return FALSE;
551      }
552      while (inptr - inbuff < MAX_RESULT - MAX_LINE - 20) {
553        fgets(inptr, MAX_LINE, stdin);
554        if (inptr[0]) {
555          if (inptr[0] == '.' && inptr[1] == '\n' && 
556              !(zoptions->flags & ZCRYPT_OPT_IGNOREDOT)) {
557            inptr[0] = '\0';
558            break;
559          } else {
560            inptr += strlen(inptr);
561          }
562        } else {
563          break;
564        }
565      }
566      num_blocks = (inptr - inbuff + 7) / 8;
567      last_block_size = ((inptr - inbuff + 7) % 8) + 1;
568      freein = TRUE;
569    }
570
571    /* if (zephyr) */
572    outfile = GetZephyrPipe(class, instance, zoptions);
573    if (!outfile) {
574      printf("Could not run zwrite\n");
575      if (freein && inbuff) {
576        free(inbuff);
577      }
578      return(FALSE);
579    }
580  }
581
582  inptr = inbuff;
583
584  /* Encrypt the input (inbuff or stdin) and send it to outfile */
585  while (TRUE) {
586    if (use_buffer) {
587      /* Get 8 bytes from buffer */
588      if (num_blocks > 1) {
589        size = 8;
590        memcpy(input, inptr, size);
591        inptr += 8;
592        num_blocks--;
593      } else if (num_blocks == 1) {
594        size = last_block_size;
595        memcpy(input, inptr, size);
596        num_blocks--;
597      } else {
598        size = 0;
599      }
600    } else {
601      /* Get 8 bytes from stdin */
602      size = fread(input, 1, 8, stdin);
603    }
604
605    /* Check for EOF and pad the string to 8 chars, if needed */
606    if (size == 0) break;     /* END OF INPUT: BREAK FROM while LOOP! */
607     
608    if (size < 8) memset(input + size, 0, 8 - size);
609
610    /* Encrypt and output the block */
611    des_ecb_encrypt(input, output, schedule, TRUE);
612    block_to_ascii(output, outfile);
613
614    if (size < 8) break;
615  }
616
617  /* Close out the output */
618  if (!error) putc('\n', outfile);
619  if (zephyr) CloseZephyrPipe(outfile);
620
621  /* Free the input buffer, if necessary */
622  if (freein && inbuff) free(inbuff);
623
624  return(!error);
625}
626
627/* Read a half-byte from stdin, skipping invalid characters.  Returns -1
628   if at EOF or file error */
629int read_ascii_nybble() {
630  char c;
631
632  while (TRUE) {
633    if (fread(&c, 1, 1, stdin) == 0) {
634      return(-1);
635    } else if (c >= BASE_CODE && c <= LAST_CODE) {
636      return(c - BASE_CODE);
637    }
638  }
639}
640
641/* Read both halves of the byte and return the single byte.  Returns -1
642   if at EOF or file error. */
643int read_ascii_byte() {
644  int c1, c2;
645  c1 = read_ascii_nybble();
646  if (c1 >= 0) {
647    c2 = read_ascii_nybble();
648    if (c2 >= 0) {
649      return c1 * 0x10 + c2;
650    }
651  }
652  return(-1);
653}
654
655/* Read an 8-byte DES block from stdin */
656int read_ascii_block(char *input) {
657  int c, i;
658
659  for (i = 0; i < 8; i++) {
660    c = read_ascii_byte();
661    if (c < 0) return(FALSE);
662    input[i] = c;
663  }
664
665  return(TRUE);
666}
667
668/* Decrypt stdin */
669int do_decrypt(char *keystring) {
670  des_cblock key;
671  des_key_schedule schedule;
672  char input[8], output[9];
673
674  output[0] = '\0';    /* In case no message at all                 */
675  output[8] = '\0';    /* NULL at end will limit string length to 8 */
676
677  des_string_to_key(keystring, key);
678  des_key_sched(key, schedule);
679
680  while (read_ascii_block(input)) {
681    des_ecb_encrypt(input, output, schedule, FALSE);
682    printf("%s", output);
683  }
684
685  if (output[0]) {
686    if (output[strlen(output)-1] != '\n') {
687      printf("\n");
688    }
689  } else {
690    printf("\n");
691  }
692  return(0);
693}
694
695#endif
Note: See TracBrowser for help on using the repository browser.