/**********************************************************************
 *
 *                        LCrypt.c 03/06/88
 *
 *       Original cipher code lifted, almost verbatim, from LUCIFER.C
 *    by R.W. Outerbridge. I'm not sure that this code is copyrighted,
 *    no mention of it's status was present in the orginal source file.
 *
 *       The original MS-DOS source was aquired from the Cryptography BBS,
 *    (703) 237-4322 McLean VA.
 *
 *       Command line interface code by Jack Radigan. This code is
 *    is free of any restrictions, You are free to include and/or
 *    modifiy for your use in any program, commercial or otherwise.
 *
 *       A one line blurb of credit in your source would be nice though...
 *
 *       Compiled with Aztec C vers. 3.40a
 *
 ***********************************************************************/

 
#include <stdio.h>

#define toascii(a)      ((a)&0177)
#define EN 0
#define DE 1

typedef char BYTE;

int IOedf, End, Once, crypt_flag;

char output[132], dir[35], temp[132], *rindex();
        
BYTE Block[16], Link[16], Temp[16], IV[16], Last[16];

BYTE DFLTKY[16] = { 1,35,69,103,137,171,205,239,254,220,186,152,118,84,50,16 };

FILE *fp_in, *fp_out;

main(argc, argv)
int argc;
char **argv;
{
   int c, i, j, k, count;
   char *filename, *s, *fn[500];
   char *scdir(), *malloc();
   BYTE kv[16];

   printf("LCrypt 1.0 1988 by Jack Radigan\n");

   if(*argv[1] == '?')
      help();
      
   if(argc < 3)
      useage_error();

   crypt_flag = EN;
   if(strlen(argv[1]) == 1) {      
      if(*argv[1] != 'e' && *argv[1] != 'E' && *argv[1] != 'd' &&
         *argv[1] != 'D')
            useage_error();

      if(*argv[1] == 'd' || *argv[1] == 'D')
         crypt_flag = DE;
      argv++;
      argc--;
   }
   if(*argv[1] == '-') {
      strcpy(dir, argv[1] + 1);
      if(dir[strlen(dir) - 1] != ':' && dir[strlen(dir) - 1] != '/') {
         printf("Illegal directory specification!\n");
         exit(0);
      }
      argv++;
      argc--;
   }
   getkey(argv[1], kv);

   j = 0;
   printf("Creating file list,");
   fflush(stdout);
   for(i = 2; i < argc; i++) {
      strcpy(temp, argv[i]);
      if(crypt_flag)
         if(strcmp(temp + strlen(temp) - 3, ".lu"))
            strcat(temp, ".lu");

      while((filename = scdir(temp)) && j < 500) {
         fn[j] = malloc(strlen(filename) + 1);
         strcpy(fn[j++], filename);
      }
   }
   printf(" %d files found.\n", j);
   for(i = 0; i < j; i++) {
      strcpy(output, fn[i]);

      if((fp_in = fopen(output, "r")) == NULL) {
         printf("Unable to open input file.\n");
         continue;
      }
      if((fp_out = fopen("ram:LCrypt.tmp", "w")) == NULL) {
         fclose(fp_in);
         printf("Unable to open temporary file in ram:, exiting.\n");
         exit(0);
      }
      printf("%s ", output);
      fflush(stdout);
      loadkey(kv, crypt_flag);
      initio(crypt_flag);

      while(get16(Block) != EOF) {
         lucifer(Block);
         put16(Block);
      }
      fclose(fp_in);
      fclose(fp_out);

      strcpy(temp, dir);
      if(s = rindex(output, '/'))
         s++;
      else if(s = rindex(output, ':'))
         s++;
      else
         s = output;
      strcat(temp, s);
      
      if((fp_in = fopen("ram:LCrypt.tmp", "r")) == NULL)
         continue;
      if((fp_out = fopen(temp, "w")) == NULL) {
         fclose(fp_in);
         exit(0);
      }
      count = 0;
      while((c = fgetc(fp_in)) != EOF) {
         fputc(c, fp_out);
         count++;
      }
      fclose(fp_in);
      fclose(fp_out);

      if((fp_in = fopen("ram:LCrypt.tmp", "w")) == NULL)
         continue;
      for(k = 0; k <= count; k++)
         fputc('\0', fp_in);
      fclose(fp_in);
      
      strcpy(output, temp);
      if(crypt_flag) {
         output[strlen(output) - 3] = '\0';
         Rename(temp, output);
         printf("decrypted.\n");
      }
      else {
         strcat(output, ".lu");
         Rename(temp, output);
         printf("encrypted.\n");
      }
   }
   DeleteFile("ram:LCrypt.tmp");
   printf("LCrypt finished.\n");
}

useage_error()
{
   printf("Usage: LCrypt [de] [-directory] key filename [filename...]\n");
   printf("       LCrypt ? for help.\n\n");
   exit(0);
}

help()
{
   printf("Usage: LCrypt [de] [-directory] key filename [filename...]\n\n");
   printf("               d - decrypt file.\n");
   printf("               e - encrypt file. [default mode]\n");
   printf("      -directory - optional directory for output, include\n");
   printf("                   trailing ':' or '/' for a sub-directory.\n");
   printf("             key - delimit with quotes if spaces are used.\n");
   printf("        filename - wildcards '?' and '*' can be used. AmigaDOS\n");
   printf("                   style wildcards are not supported.\n");
   exit(0);
}

copy16(from, to)
register BYTE *from, *to;
{
   register int i;
   for(i = 0; i < 16; i++)
      to[i] = from[i];
   return;
}

xor16(to, with)
register BYTE *to, *with;
{
   register int i;
   for(i = 0; i < 16; i++)
      to[i] ^= with[i];
   return;
}

put16(block)
register BYTE *block;
{
   if(IOedf == DE)
      copy16(block, Last);
   else
      vraiput(block, &block[16]);
   return;
}

get16(input)
register BYTE *input;
{
   register int i, j;
   if(End == 1)
      return(EOF);       /* no more input        */

   for(i=0; i < 16 && ((j = fgetc(fp_in)) != EOF); i++)
      *input++ = j;

   if(IOedf == DE) {       /* DECRYPTION   */

      /* complete block?  pending output?     */
      if(i == 16 && (Once > 0))
         vraiput(Last, &Last[16]);
      else if(j == EOF) {
         End = 1;
         if(Once > 0) {

            /* incomplete block means no nulls      */
            if(i != 0)
               i = 0;
            else {  
               i = Last[15]&0377;
               if(i > 16)
                  i = 0;       /* huh? */
            }
            vraiput(Last, &Last[16-i]);
         }
         return(EOF);
      }
   }
   else if(j == EOF) {     /* ENCRYPTION   */
      End = 1;
      if(i == 0 && (IOedf == EN || (Once > 0))) {

         /* if no padding to do, print a kludge  */
         if(IOedf == EN && (Once > 0))
            fputc('0', fp_out);
         return(EOF);
      }
      for(j=i; j < 15; j++)
         *input++ = NULL;
      *input = 16-i;
   }
   Once = 1;
   return(0);
}

getkey(aptr, kptr)
register BYTE *aptr;
register BYTE *kptr;
{
   register BYTE *store;
   register int i, first;
   BYTE hold[16];
   first = 1;
   loadkey(DFLTKY, EN);
   copy16(DFLTKY, hold);
   while(*aptr || first) {
      store = kptr;
      for(i=0; i<16 && (*aptr != NULL); i++) {
         *store++ = toascii(*aptr);
         *aptr++ = NULL;
      }
      while(i++ < 16)
         *store++ = NULL;
      xor16(kptr, hold);
      lucifer(kptr);
      copy16(kptr, hold);
      first = 0;
   }
   return;
}

vraiput(cp, ep)
register BYTE *cp, *ep;
{
   while(cp < ep)
      fputc((BYTE)*cp++, fp_out);
   return;
}

initio(edf)
int edf;
{
   IOedf = edf;
   End = Once = 0;
   return;
}

/* LUCIFER is a cryptographic algorithm developed by IBM in the early
 *      seventies.  It was a predecessor of the DES, and is much simpler
 *      than that algorithm.  In particular, it has only two substitution
 *      boxes.  It does, however, use a 128 bit key and operates on
 *      sixteen byte data blocks...
 *
 *      This implementation of LUCIFER was crafted by Graven Cyphers at the
 *      University of Toronto, Canada, with programming assistance from
 *      Richard Outerbridge.  It is based on the FORTRAN routines which
 *      concluded Arthur Sorkin's article "LUCIFER: A Cryptographic Algorithm",
 *      CRYPTOLOGIA, Volume 8, Number 1, January 1984, pp22-42.  The interested
 *      reader should refer to that article rather than this program for more
 *      details on LUCIFER.
 *
 *      These routines bear little resemblance to the actual LUCIFER algorithm,
 *      which has been severely twisted in the interests of speed.  They do
 *      perform the same transformations, and are believed to be UNIX portable.
 *      The package was developed for use on UNIX-like systems lacking crypto
 *      facilities.  They are not very fast, but the cipher is very strong.
 *      The routines in this file are suitable for use as a subroutine library
 *      after the fashion of crypt(3).  When linked together with applications
 *      routines they can also provide a high-level cryptographic system.
 *
 *      -DENHANCE : modify LUCIFER by changing the key schedule and performing
 *              an "autokeyed" encryption.  These may improve the algorithm.
 */

static BYTE Dps[64] = { /* Diffusion Pattern schedule   */
        4,16,32,2,1,8,64,128,   128,4,16,32,2,1,8,64,
        64,128,4,16,32,2,1,8,   8,64,128,4,16,32,2,1,
        1,8,64,128,4,16,32,2,   2,1,8,64,128,4,16,32,
        32,2,1,8,64,128,4,16,   16,32,2,1,8,64,128,4    };

/* Precomputed S&P Boxes, Two Varieties */

static BYTE TCB0[256] = {
        87, 21,117, 54, 23, 55, 20, 84,116,118, 22, 53, 85,119, 52, 86,
        223,157,253,190,159,191,156,220,252,254,158,189,221,255,188,222,
        207,141,237,174,143,175,140,204,236,238,142,173,205,239,172,206,
        211,145,241,178,147,179,144,208,240,242,146,177,209,243,176,210,
        215,149,245,182,151,183,148,212,244,246,150,181,213,247,180,214,
        95, 29,125, 62, 31, 63, 28, 92,124,126, 30, 61, 93,127, 60, 94,
        219,153,249,186,155,187,152,216,248,250,154,185,217,251,184,218,
        67,  1, 97, 34,  3, 35,  0, 64, 96, 98,  2, 33, 65, 99, 32, 66,
        195,129,225,162,131,163,128,192,224,226,130,161,193,227,160,194,
        199,133,229,166,135,167,132,196,228,230,134,165,197,231,164,198,
        203,137,233,170,139,171,136,200,232,234,138,169,201,235,168,202,
        75,  9,105, 42, 11, 43,  8, 72,104,106, 10, 41, 73,107, 40, 74,
        91, 25,121, 58, 27, 59, 24, 88,120,122, 26, 57, 89,123, 56, 90,
        71,  5,101, 38,  7, 39,  4, 68,100,102,  6, 37, 69,103, 36, 70,
        79, 13,109, 46, 15, 47, 12, 76,108,110, 14, 45, 77,111, 44, 78,
        83, 17,113, 50, 19, 51, 16, 80,112,114, 18, 49, 81,115, 48, 82 };

static BYTE TCB1[256] = {
        87,223,207,211,215, 95,219, 67,195,199,203, 75, 91, 71, 79, 83,
        21,157,141,145,149, 29,153,  1,129,133,137,  9, 25,  5, 13, 17,
        117,253,237,241,245,125,249, 97,225,229,233,105,121,101,109,113,
        54,190,174,178,182, 62,186, 34,162,166,170, 42, 58, 38, 46, 50,
        23,159,143,147,151, 31,155,  3,131,135,139, 11, 27,  7, 15, 19,
        55,191,175,179,183, 63,187, 35,163,167,171, 43, 59, 39, 47, 51,
        20,156,140,144,148, 28,152,  0,128,132,136,  8, 24,  4, 12, 16,
        84,220,204,208,212, 92,216, 64,192,196,200, 72, 88, 68, 76, 80,
        116,252,236,240,244,124,248, 96,224,228,232,104,120,100,108,112,
        118,254,238,242,246,126,250, 98,226,230,234,106,122,102,110,114,
        22,158,142,146,150, 30,154,  2,130,134,138, 10, 26,  6, 14, 18,
        53,189,173,177,181, 61,185, 33,161,165,169, 41, 57, 37, 45, 49,
        85,221,205,209,213, 93,217, 65,193,197,201, 73, 89, 69, 77, 81,
        119,255,239,243,247,127,251, 99,227,231,235,107,123,103,111,115,
        52,188,172,176,180, 60,184, 32,160,164,168, 40, 56, 36, 44, 48,
        86,222,206,210,214, 94,218, 66,194,198,202, 74, 90, 70, 78, 82 };

static BYTE Key[16], Pkey[128];
static int P[8] = { 3,5,0,4,2,1,7,6 };
static int Smask[16] = { 128,64,32,16,8,4,2,1 };

lucifer(bytes)
BYTE *bytes;    /* points to a 16-byte array    */
        {
        register BYTE *cp, *sp, *dp;
        register int val, *sbs, tcb, j, i;
        BYTE *h0, *h1, *kc, *ks;

        h0 = bytes;     /* the "lower" half     */
        h1 = bytes + 8; /* the "upper" half     */
        kc = Pkey;
        ks = Key;

        for(i=0; i<16; i++) {
                tcb = *ks++;
                sbs = Smask;
                dp = Dps;
                sp = &h0[8];
                for(j=0; j<8; j++) {
                        if(tcb&*sbs++) val = TCB1[h1[j]&0377];
                        else val = TCB0[h1[j]&0377];
                        val ^= *kc++;
                        for(cp=h0; cp<sp;) *cp++ ^= (val&*dp++);
                        }

                /* swap (virtual) halves        */
                cp = h0;
                h0 = h1;
                h1 = cp;
                }

        /* REALLY swap halves   */
        dp = bytes;
        cp = bytes + 8;
        for(sp=cp; dp<sp; dp++, cp++) {
                val = *dp;
                *dp = *cp;
                *cp = val;
                }
        return;
        } 

loadkey(keystr, edf)       /* precomputes the key schedules        */
BYTE *keystr;
register int edf;
        {
        register BYTE *ep, *cp, *pp;
        register int kc, i, j;
        BYTE kk[16], pk[16];
        cp = kk;
        pp = pk;
        ep = &kk[16];
        while(cp < ep) {
                *cp++ = *keystr;
                for(*pp=i=0; i<8; i++)
                        if(*keystr&Smask[i]) *pp |= Smask[P[i]];
                keystr++;
                pp++;
                }
        cp = Key;
        pp = Pkey;
        kc = (edf == DE) ? 8 : 0;
        for(i=0; i<16; i++) {
                if(edf == DE) kc = (++kc)&017;
                *cp++ = kk[kc];
                for(j=0; j<8; j++) {
                        *pp++ = pk[kc];
                        if(j<7 || (edf == DE)) kc = (++kc)&017;
                        }
                }
        return;
        }