home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1987 / 03 / crypt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-02-03  |  5.7 KB  |  155 lines
  1. /********************************************************************
  2. *  TITEL           :  Crypt                                         *
  3. *                                                                   *
  4. *  DATEI           :  crypt.c  Hauptprogramm                        *
  5. *  VERSION         :  1.0                                           *
  6. *  AUTOR           :  Joachim Eckart                                *
  7. *  DATUM           :  11/86                                         *
  8. ********************************************************************/
  9.  
  10. #include <stdio.h>
  11. #include "crypt.h"
  12.  
  13. /***             Fehlermeldungen                                 ***/
  14. char *err[]= {
  15.               "Usage:   crypt quelle [ziel] key ",        /*   0   */
  16.               "Oeffnen Eingabedatei nicht moeglich !",    /*   1   */
  17.               "Oeffnen Ausgabedatei nicht moeglich !",    /*   2   */
  18.               "Fehler beim Schreiben in Ausgabedatei !",  /*   3   */
  19.               "Fehler beim Lesen aus  Eingabedatei !",    /*   4   */
  20.               "Speichermangel !",                         /*   5   */
  21.               "Datei maximal 32KB !"                      /*   6   */
  22.              };
  23.  
  24. /***             Globalvariablen                                 ***/
  25. char *buffer,*buf_ptr;        /* Zeiger auf Einlesepuffer          */
  26. char key[MAXKEYL];            /* Schluessel                        */
  27. char infile[64],outfile[64];  /* Pfadname Ein/Ausgabedatei         */
  28. int nread,count;              /* Puffergroesse                     */
  29. int keylen;                   /* Laenge des Schluessels            */
  30.  
  31. /***             Main                                            ***/
  32. main(argc,argv)
  33. int argc;                     /* Anzahl beim Aufruf uebergebener   */
  34.                               /* Argumente                         */
  35. char *argv[];                 /* Vektor mit Zeigern auf Argumente  */
  36.  
  37. {
  38. int c;
  39.   cls();
  40.   crs_off();
  41.   pos(29,8);rev_on();put_s("DECRYPT ----- ENCRYPT");rev_off();
  42.   pos(14,10);put_s("ASCII oder Binaerdatei wird ent- oder verschluesselt.");
  43.   pos(17,12);put_s("Ein- und Ausgabedatei duerfen identisch sein !");
  44.   pos(25,14);put_s("!! Dateigroesse maximal 32KB !!");
  45.  
  46.   switch(argc)
  47.   {
  48.      case 1:
  49.      case 2:
  50.           usage(err[0]);
  51.           break;
  52.      case 3:
  53.           keylen = strlen(argv[2]); /* Zeiger auf Schluessel     */
  54.           strcpy(key,argv[2]);      /* Schluessel belegen        */
  55.           strcpy(infile,argv[1]);
  56.           strcpy(outfile,"SCREEN");
  57.           show_file();
  58.           open_in();                /* Eingabedatei oeffnen      */
  59.           crypt();                  /* Bufferinhalt verschl.     */
  60.           cls();
  61.           while((c = getc_buf()) != EOF) putc(c,stdout); /* CRT  */
  62.           buf_ptr = buffer;         /* wieder auf buffer zeigen  */
  63.           break;
  64.  
  65.      case 4:                     /* Zieldatei explizit angegeben */
  66.           keylen = strlen(argv[3]); /* Zeiger auf Schluessel     */
  67.           strcpy(key,argv[3]);      /* Schluessel belegen        */
  68.           strcpy(infile,argv[1]);
  69.           strcpy(outfile,argv[2]);
  70.           show_file();
  71.           open_in();                /* Eingabedatei oeffnen      */
  72.           crypt();                  /* Bufferinhalt verschl.     */
  73.           output();
  74.           break;
  75.      default:
  76.           usage(err[0]);
  77.    }                      /* end switch(argc) */
  78.  
  79.     rev_on();
  80.     pos(57,24);
  81.     put_s("READY -- PRESS ANY KEY");
  82.     rev_off();
  83.     get_hidden();
  84.     repair_scr(); /* falls bei binaerer Ausgabe auf Screen ........ */
  85.     free(buffer);                   /* Speicher freigeben           */
  86. }
  87.  
  88. usage(message)                      /* Fehlermeldung und Abbruch    */
  89. register char *message;
  90. {
  91.     pos(0,24);rev_on();
  92.     put_s(message);
  93.     rev_off();
  94.     get_hidden();
  95.     repair_scr();
  96.     exit();
  97. }
  98.  
  99. show_file()                        /* Dateiinfo anzeigen            */
  100. {
  101.     rev_on();
  102.     pos(1,1);put_s("EINGABE :");
  103.     pos(40,1);put_s("AUSGABE :");
  104.     rev_off();
  105.     pos(1,2);put_s(infile);
  106.     pos(40,2);put_s(outfile);
  107. }
  108.  
  109. int getc_buf()                    /* naechstes Zeichen aus Eingabe  */
  110. {
  111.     if (nread--) return( (int)(*buf_ptr++));
  112.     else return(EOF);
  113. }
  114. #define LAST (*(buf_ptr - 1))
  115. crypt()        /***                  crypt                        ***/
  116. {
  117. int i;
  118.     for(i=0;i<keylen;i++) key[i] ^= 0x7f; /* kein reiner alpha-key  */
  119.     i = 1;
  120.     while (getc_buf() != EOF)
  121.      {
  122.       LAST ^= (int)key[i-1];         /* exklusiv oder              */
  123.       i = (i % keylen) +1;           /* zyklisch naechstes Zeichen */
  124.      }
  125.     buf_ptr = buffer;
  126.     nread = count;
  127. }
  128. extern long lseek();
  129. open_in()     /*  Lesen Eingabedatei in Puffer                      */
  130. {
  131. int fildes;
  132. long size;
  133.     if ( (fildes = open(infile,PMODE)) == -1) usage(err[1]);
  134.     if ( (size = lseek(fildes,0L,2)) == -1 || size > MAXSIZE)
  135.                            { close(fildes); usage(err[6]);  }
  136.     if(lseek(fildes,0L,0) == -1) usage(err[4]);
  137.     if ( (buffer = malloc(MAXSIZE)) == (char *)0) usage(err[5]);
  138.     buf_ptr = buffer;
  139.     if ( (nread=read(fildes,buffer,(unsigned)size)) == -1) usage(err[4]);
  140.     count = nread;
  141.     close(fildes);
  142. }
  143.  
  144. output()        /***       Buffer in Datei schreiben              ***/
  145. {
  146. int fildes;
  147.     if((fildes = creat(outfile,PMODE)) == -1)
  148.     /* unter EOS an sich nur creat(outfile) - es geht aber auch so  */
  149.         usage(err[2]);       /* Oeffnen geklappt  ?                 */
  150.     if((nread =  write(fildes,buffer,count)) != count)
  151.         { close(fildes);
  152.           usage(err[3]);  }   /* zu wenig Zeichen ?                 */
  153.     close(fildes);
  154. }
  155.