{start of file CRYP612.INC ***************************************************}
CONST
  NAME       = 'CRYP - A data encryption system written in TURBO PASCAL';
  VERSION    = 'Version 6.12, 05/16/86, 1600 hours';
  AUTHOR     = 'COPYRIGHT (c) 1986 By Author: Harry J Smith, Saratoga, CA';

{*****************************************************************************}

{This program will encipher or decipher a file of data and rewrite
  it into a new file}

{$I- do our own i/o error checks}
{$R- Don't Range check Array Indexes}
{$U- Do NOT Allow User Interrupts, nomonal}
{$V- Allow any length SRTINGs passed to PROCEDURES}

LABEL CONTINUE, EXIT;

CONST
  LASTLINE   = 24;    {Used in GOTOXY to go to last line of CRT, 25 for IBM-PC}
  FIRSTCOL   = 1;     {Used in GOTOXY to go to first column of CRT}
  BUFRECSIZE = 128;   {NUMBER OF 128-BYTE RECORDS IN A BUFFER}
  BUFINTSIZE = 8192;  {INTEGERS IN BUFFER, 64 * BUFRECSIZE}
  BUFBYTSIZE = 16384; {BYTES IN BUFFER, 128 * BUFRECSIZE}
  POOLSIZE   = 2048;  {INTEGERS IN RANDOM NUMBER POOL}

TYPE
  BUFFER   = RECORD CASE INTEGER OF  {I/O BUFFERS}
               1: (INT : PACKED ARRAY[1..BUFINTSIZE] OF INTEGER);
               2: (BYT : PACKED ARRAY[1..BUFBYTSIZE] OF CHAR);
             END;

VAR
  RI       : ARRAY [0..8] OF INTEGER; {CURRENT RANDOM INT. FROM 9 GENERATORS}
  RS       : ARRAY [0..8] OF INTEGER; {INITIAL RANDOM SEEDS FOR 9 GENERATORS}
  RC       : ARRAY [0..8] OF INTEGER; {CURRENT VALUE OF CLEAR CONTINU SEEDS}
  POOL     : ARRAY [0..2047] OF INTEGER; {POOL OF RANDOM INTEGERS}
  RR       : INTEGER;     {RANDOM INT. RUNNING COMBINATION OF RI[0] THRU RI[8]}
  NEXT     : INTEGER;     {RANDOM INT. RUNNING COMBINATION OF RI[0] THRU RI[8]}
  INNAME   : STRING[14];  {INPUT FILE NAME}
  OUTNAME  : STRING[14];  {OUTPUT FILE NAME}
  ANS      : STRING[14];  {OPERATORS ANSWER}
  TEMPNAME : STRING[14];  {TEMPARORY NAME OF OUTPUT FILE "d:ffffffff.$$$"}
  DDRIVE   : STRING[2];   {DEFAULT DRIVE, e.g. B:}
  ANSKEY   : STRING[72];  {INPUT KEY STRING}
  KEY      : STRING[24];  {INPUT KEY STRING IN STANDARD FORM}
  INFILE   : FILE;        {INPUT FILE}
  OUTFILE  : FILE;        {OUTPUT FILE}
  CONFILE  : FILE;        {CONTINUATION FILE 'CRYP.CON'}
  TBYTES   : REAL;        {TOTAL BYTES PROCESSED}
  FERROR   : BOOLEAN;     {FILE CONVERSION ERROR FLAG}
  EXISTS   : BOOLEAN;     {OUTPUT FILE ALREADY EXISTS FLAG}
  ENCIPHER : BOOLEAN;     {ENCIPHER A FILE, FALSE => DECIPHER}
  INITCON  : BOOLEAN;     {INITIALIZING CRYP.CON, FALSE => ENCIPHER/DECIPHER}
  REPEAT2  : BOOLEAN;     {REPEAT FLAG USED IN RN(2)}
  READRECS : INTEGER;     {NO. OF 128-BYTE RECORDS TO READ THIS READ}
  REMRECS  : INTEGER;     {NO. OF 128-BYTE RECORDS REMAINING IN FILE}
  INCNT    : INTEGER;     {# OF BYTES READ}
  BUFIO    : BUFFER;      {I/O BUFFER}
  KEYI     : ARRAY [1..24] OF INTEGER; {KEY IN INTEGER FORM, 6 BITS EACH}

FUNCTION RN(N : INTEGER): INTEGER;
  {Returns the next random integer from RI[I], 0 <= N <= 8}
LABEL EXIT2;
VAR I, RT : INTEGER;
BEGIN
  CASE N OF
    0: {1st Congruential Generator, 16 bits}
       {Random integer from -32768 to 32767 inclusive}
       {Cycle length = 65536 = 2^16}
       BEGIN
         RI[0]:= 25173 * RI[0] + 6925;
         RN:= RI[0];
       END;

    1: {1st Shift-register Generator, 16 bits}
       {Random integer from -32768 to 32767 inclusive, zero not generated}
       {Generator = -22620, Cycle length = 65535 = 3 * 5 * 17 * 257}
       BEGIN
         IF ODD(RI[1]) THEN
           RI[1]:= (RI[1] SHR 1) XOR -22620
         ELSE
           RI[1]:= RI[1] SHR 1;
         RN:= RI[1];
       END;

    2: {2nd Congruential Generator, 16 bits}
       {Random integer from -32768 to 32767 inclusive}
       {Cycle length = 65537 = prime, zero repeats once}
       BEGIN
         IF RI[2] = 0 THEN BEGIN
           IF REPEAT2 THEN BEGIN
             REPEAT2:= FALSE;
             GOTO EXIT2;
           END ELSE
             REPEAT2:= TRUE;
         END;
         RI[2]:= 23629 * RI[2] + 13849;
EXIT2:
         RN:= RI[2];
       END;

    3: {2nd Shift-register Generator, 16 bits}
       {Random integer from -32768 to 32767, not all generated}
       {Generator = -07493, Cycle length = 65521 = prime, (65535 - 15)}
       BEGIN
         IF ODD(RI[3]) THEN
           RI[3]:= (RI[3] SHR 1) XOR -7493
         ELSE
           RI[3]:= RI[3] SHR 1;
         IF RI[3] = 1 THEN
           FOR I := 1 TO 14 DO RT:= RN(3); {THROW 14 AWAY}
         RN:= RI[3];
       END;

    4: {3rd Congruential Generator, 16 bits}
       {Random integer from -32768 to 32767, not all generated}
       {Cycle length = 65519 = prime, (65536 - 17)}
       BEGIN
         RI[4]:= 4821 * RI[4] + 13001;
         IF RI[4] = 0 THEN
           FOR I:= 1 TO 17 DO RT:= RN(4); {THROW 17 AWAY}
         RN:= RI[4];
       END;

    5: {3rd Shift-register Generator, 16 bits}
       {Random integer from -32768 to 32767, not all generated}
       {Generator = -25501, Cycle length = 65497 = prime, (65535 - 39)}
       BEGIN
         IF ODD(RI[5]) THEN
           RI[5]:= (RI[5] SHR 1) XOR -25501
         ELSE
           RI[5]:= RI[5] SHR 1;
         IF RI[5] = 1 THEN
           FOR I:= 1 TO 38 DO RT:= RN(5); {THROW 38 AWAY}
         RN:= RI[5];
       END;

    6: {4th Congruential Generator, 16 bits}
       {Random integer from -32768 to 32767, not all generated}
       {Cycle length = 65479 = prime, (65536 - 57)}
       BEGIN
         RI[6]:= 10349 * RI[6] + 7001;
         IF RI[6] = 0 THEN
           FOR I:= 1 TO 57 DO RT:= RN(6); {THROW 57 AWAY}
         RN:= RI[6];
       END;

    7: {4th Shift-register Generator, 16 bits}
       {Random integer from -32768 to 32767, not all generated}
       {Generator = -18916, Cycle length = 65449 = prime, (65535 - 87)}
       BEGIN
         IF ODD(RI[7]) THEN
           RI[7]:= (RI[7] SHR 1) XOR -18916
         ELSE
           RI[7]:= RI[7] SHR 1;
         IF RI[7] = 1 THEN
           FOR I:= 1 TO 86 DO RT:= RN(7); {THROW 86 AWAY}
         RN:= RI[7];
       END;

    8: {5th Congruential Generator, 16 bits}
       {Random integer from -32768 to 32767, not all generated}
       {Cycle length = 65447 = prime, (65536 - 89)}
       BEGIN
         RI[8]:= 30133 * RI[8] + 14001;
         IF RI[8] = 0 THEN
           FOR I:= 1 TO 89 DO RT:= RN(8); {THROW 89 AWAY}
         RN:= RI[8];
       END;
  END; {CASE N}
END; {RN}

FUNCTION RC9 : INTEGER; {Combination of RN(0) thru RN(8) one each}
VAR I, RC : INTEGER;
BEGIN
  RC:= 0;
  FOR I:= 0 TO 8 DO
    RC:= RC + RN(I);
  RC9:= RC;
END; {RC9}

PROCEDURE CHANGEIT(VAR BUFE : BUFFER; BYTES : INTEGER);
  {Apply Pseudo Key to BYTES bytes in place in BUFE}
VAR I, IND : INTEGER;
BEGIN
       {This is the heart of the encryption method}

  WITH BUFE DO BEGIN
    FOR I:= 1 TO ((BYTES+1) DIV 2) DO BEGIN
      IND:= RR AND 2047;
      INT[I]:= INT[I] XOR POOL[IND];
      RR:= RR + RN(NEXT);
      POOL[IND]:= POOL[IND] XOR RR;
      NEXT:= NEXT + 1;
      IF NEXT = 9 THEN NEXT:= 0;
    END;
  END;
END; {CHANGEIT}

PROCEDURE CONVKEY; {Convert the encryption key to 9 seeds}
                   { input: KEY[J], J = 1, ..., 24}
                   { output: RS[I], I = 0, ..., 8}
VAR I, J, K : INTEGER;
{
    [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]  ...   [22]   [23]
  111111 111111 111111 111111 111111 111111 111111 111111      111111 111111
     6      6     4  2    6      6    2  4     6      6           6      6
  ****** seed0 *****...... seed1 ......***** seed2 ****** ... * seed8 ******
        16 BITS           16 BITS           16 BITS            16 BITS

  144 bit key converted to 144 bits of seed, seeds of zero are changed to 1.
}
BEGIN
  FOR I:= 1 TO 24 DO KEYI[I]:= ORD(KEY[I]) AND 63;
  I:= 0;  J:= 1;
  FOR K:= 0 TO 2 DO BEGIN
    RS[I]:=   (KEYI[J]   SHL 10) OR (KEYI[J+1] SHL 4) OR (KEYI[J+2] SHR 2);

    RS[I+1]:= (KEYI[J+2] SHL 14) OR (KEYI[J+3] SHL 8) OR (KEYI[J+4] SHL 2) OR
              (KEYI[J+5] SHR 4);

    RS[I+2]:= (KEYI[J+5] SHL 12) OR (KEYI[J+6] SHL 6) OR KEYI[J+7];
        I:= I + 3;  J:= J + 8;
  END;
  REPEAT2:= TRUE;
END; {CONVKEY}

PROCEDURE STANDARD(VAR KEY : STRINGP); {Convert a KEY to Standard format}
VAR I : INTEGER; {UTILITY INDEX}
BEGIN
  FOR I:= 1 TO LENGTH(KEY) DO BEGIN
    KEY[I]:= CHR(ORD(KEY[I]) AND 127);
    IF ORD(KEY[I]) > 95 THEN KEY[I]:= CHR(ORD(KEY[I]) - 32);
    IF ORD(KEY[I]) < 32 THEN KEY[I]:= CHR(ORD(KEY[I]) + 32);
    IF KEY[I] = ' ' THEN KEY[I]:= '/';
  END;
END; {STANDARD}

PROCEDURE GETKEY; {Get Encryption Key from Operator}
LABEL EXIT;
VAR  I,J  : INTEGER;    {UTILITY INDEXES}
     DONE : BOOLEAN;    {UTILITY DONE FLAG}
     CH   : CHAR;       {UTILITY CHARACTER}
BEGIN
  WRITELN;
  DONE:= FALSE;
  REPEAT
    WRITELN;
    REPEAT
      WRITELN(
      'Input a KEY of 0 to 72 characters that you can rember or hit return:');
      WRITELN('(Type Control-X to Exit, Control-Q for help)   .<-- col. 48');
      PROM(FIRSTCOL, LASTLINE, 72, ANSKEY, ANSKEY);
      IF STOPTYPED OR ESCTYPED THEN GOTO EXIT;
      IF HELPTYPED THEN HELPPROM;
    UNTIL NOT HELPTYPED;
    WRITELN;
    CHGLEN(KEY, 24); {24 LONG}
    STANDARD(ANSKEY);
    WRITELN(ANSKEY, ' = Input KEY in standard form');
    FOR I:= 1 TO 24 DO KEY[I]:= CHR(0);
    J:= 1;
    FOR I:= 1 TO LENGTH(ANSKEY) DO BEGIN
      KEY[J]:= CHR(ORD(KEY[J]) + ORD(ANSKEY[I]));
      J:= J MOD 24 + 1;
    END;
    FOR I:= 1 TO 24 DO
      IF (KEY[I] = CHR(0)) THEN KEY[I]:= ' ';
    STANDARD(KEY);
    CONVKEY;
    WRITELN(KEY, ' = Short KEY in standard form');
    WRITELN;
    WRITE('Is this KEY what you want? (Y/N): ');
    GETYESNO(DONE);
    IF STOPTYPED OR ESCTYPED THEN GOTO EXIT;
    IF NOT DONE THEN WRITELN('KEY rejected');
  UNTIL DONE;
  WRITELN('KEY accepted');
EXIT:
END; {GETKEY}

PROCEDURE GETTEMPNAME; {Generate a temporary name for the output file}
VAR  I,J : INTEGER; {UTILITY INDEXES}
BEGIN
  IF EXISTS THEN BEGIN
    TEMPNAME:= '              '; {14 blanks}
    FOR I:= 1 TO LENGTH(OUTNAME) DO TEMPNAME[I]:= OUTNAME[I];
    J:= 0;
    FOR I:= 1 TO 14 DO BEGIN
      IF (TEMPNAME[I] = '.') OR (TEMPNAME[I] = ' ') THEN
        IF J = 0 THEN J:= I;
    END;
    IF J > 11 THEN J:= 11;
    INSERT('.$$$', TEMPNAME, J);
  END ELSE
    TEMPNAME:= OUTNAME;
END; {GETTEMPNAME}

PROCEDURE FIXNAME; {Add default drive d: to file name or set default drive}
BEGIN
  IF (LENGTH(ANS) < 2) OR (ANS[2] <> ':') THEN
    ANS:= DDRIVE + ANS;
  IF LENGTH(ANS) = 2 THEN BEGIN
    DDRIVE:= ANS;
    ANS:= '';
  END;
END; {FIXNAME}

PROCEDURE GETINNAME; {Get name of input file and open for reading}
LABEL EXIT;
VAR DONE : BOOLEAN; {UTILITY DONE FLAG}
BEGIN
  DONE:= FALSE;
  REPEAT
    REPEAT
      WRITELN;
      ANS:= INNAME;
      REPEAT
        WRITE('Default Drive = ', DDRIVE, '  Enter name of INPUT file: ');
        PROM(FIRSTCOL+47, LASTLINE, 14, ANS, ANS);
        IF STOPTYPED OR ESCTYPED THEN GOTO EXIT;
        IF HELPTYPED THEN HELPPROM;
      UNTIL NOT HELPTYPED;
      FIXNAME;
      INNAME:= ANS;
    UNTIL (LENGTH(INNAME) > 0);
    WRITELN;
    ASSIGN(INFILE, INNAME);
    RESET(INFILE);
    IF IORESULT = 0 THEN BEGIN
      REMRECS:= FILESIZE(INFILE);
      IF REMRECS = 0
        THEN WRITELN('File "', INNAME, '" has zero length')
        ELSE DONE:= TRUE;
    END ELSE
      WRITELN('File "', INNAME, '" not found');
  UNTIL DONE;
EXIT:
END; {GETINNAME}

PROCEDURE GETOUTNAME; {Get name of output file and open for rewrite}
LABEL EXIT;
VAR DONE : BOOLEAN;   {UTILITY DONE FLAG}
BEGIN
  DONE:= FALSE;
  REPEAT
    REPEAT
      WRITELN;
      ANS:= OUTNAME;
      REPEAT
        WRITE('Default Drive = ', DDRIVE, '  Enter name of OUTPUT file: ');
        PROM(FIRSTCOL+47, LASTLINE, 14, ANS, ANS);
        IF STOPTYPED OR ESCTYPED THEN GOTO EXIT;
        IF HELPTYPED THEN HELPPROM;
      UNTIL NOT HELPTYPED;
      FIXNAME;
      OUTNAME:= ANS;
    UNTIL (LENGTH(OUTNAME) > 0);
    WRITELN;
    ASSIGN(OUTFILE, OUTNAME);
    RESET(OUTFILE);
    EXISTS:= FALSE;
    IF IORESULT = 0 THEN BEGIN
      EXISTS:= TRUE;
      WRITE('File "', OUTNAME,
        '" already exists, erase it after conversion? (Y/N): ');
      GETYESNO(DONE);
      IF STOPTYPED OR ESCTYPED THEN GOTO EXIT;
    END ELSE
      DONE:= TRUE;
    IF DONE THEN BEGIN
      GETTEMPNAME;
      ASSIGN(OUTFILE, TEMPNAME);
      REWRITE(OUTFILE);
      IF IORESULT <> 0 THEN BEGIN
        WRITELN('Cannot open output file');
        DONE:= FALSE;
      END;
    END;
  UNTIL DONE;
EXIT:
END; {GETOUTNAME}

PROCEDURE ENCORDEC; {Ask operator for Encipher or Decipher option}
VAR CH : CHAR;  DONE : BOOLEAN;
BEGIN
  WRITELN;
  WRITE('Encipher, Decipher or Init File CRYP.CON? (E/D/I): ');
  WRITE('E', BS);
  REPEAT
    READ(KBD, CH);
    DONE:= CH IN ['E', 'e', 'D', 'd', 'I', 'i', CR, STOPC, ESC];
    IF NOT DONE THEN WRITE(BELL);
  UNTIL DONE;
  INITCON:=   CH IN ['I', 'i'];
  ENCIPHER:=  CH IN ['E', 'e', CR];
  STOPTYPED:= (CH = STOPC);
  ESCTYPED:=  (CH = ESC);
  IF INITCON THEN WRITELN('Init CRYP.CON')
  ELSE IF ENCIPHER THEN WRITELN('Encipher')
  ELSE IF CH IN ['D', 'd'] THEN WRITELN('Decipher');
END; {ENCORDEC}

PROCEDURE WRITEIT; {Write a multiple of 128 byte records}
BEGIN
  BLOCKWRITE(OUTFILE, BUFIO, READRECS);
  IF IORESULT <> 0 THEN BEGIN
    WRITELN('Unable to write output file');
    FERROR:= TRUE;
  END;
END; {WRITEIT}

PROCEDURE INITEN; {Initialize for enciphering}
VAR RECS : INTEGER;
BEGIN
  ASSIGN(CONFILE, 'CRYP.CON');
  RESET(CONFILE);
  IF IORESULT = 0 THEN BEGIN
    RECS:= FILESIZE(CONFILE);
    IF RECS <> 1 THEN BEGIN
      WRITELN('File CRYP.CON not of proper length');
      FERROR:= TRUE;
    END;
  END ELSE BEGIN
    WRITELN('File CRYP.CON not found');
    FERROR:= TRUE;
  END;
  IF NOT FERROR THEN BEGIN
    BLOCKREAD(CONFILE, POOL, 1);
    IF IORESULT <> 0 THEN BEGIN
      WRITELN('Can not read file CRYP.CON');
      FERROR:= TRUE;
    END ELSE BEGIN
      BLOCKWRITE(OUTFILE, POOL, 1);
      IF IORESULT <> 0 THEN BEGIN
        WRITELN('Unable to write 1st record of output file');
        FERROR:= TRUE;
      END;
    END;
  END;
  CLOSE(CONFILE);
  IF IORESULT <> 0 THEN BEGIN
    WRITELN('Can close file CRYP.CON');
    FERROR:= TRUE;
  END;
END; {INITEN}

PROCEDURE INITDE; {Initialize for deciphering}
BEGIN
  REMRECS:= REMRECS - 1;
  IF REMRECS = 0 THEN BEGIN
    WRITELN('File "', INNAME, '" is too short for an enciphered file');
    FERROR:= TRUE;
  END ELSE BEGIN
    BLOCKREAD (INFILE, POOL, 1);
    IF IORESULT <> 0 THEN BEGIN
      WRITELN('Unable to read 1st record of input file');
      FERROR:= TRUE;
    END;
  END;
END; {INITDE}

PROCEDURE WRITECON; {Write CRYP.CON to disk}
VAR I : INTEGER;
BEGIN
  ASSIGN(CONFILE, 'CRYP.CON');
  REWRITE(CONFILE);
  IF IORESULT <> 0 THEN BEGIN
    WRITELN('Can not open file CRYP.CON');
    FERROR:= TRUE;
  END ELSE BEGIN
    FOR I:= 0 TO 8 DO
      RI[I]:= RC[I];
    FOR I:= 63 DOWNTO 0 DO
      POOL[I]:= RC9;
    BLOCKWRITE(CONFILE, POOL, 1);
    IF IORESULT <> 0 THEN BEGIN
      WRITELN('Unable to write file CRYP.CON');
      FERROR:= TRUE;
    END;
    CLOSE(CONFILE);
    IF IORESULT <> 0 THEN BEGIN
      WRITELN('Can close file CRYP.CON');
      FERROR:= TRUE;
    END;
  END;
  IF FERROR THEN
    WRITE('File CRYP.CON update ABORTED');
END; {WRITECON}

PROCEDURE INITPOOL; {Initialize pool of random integers}
VAR I : INTEGER;
BEGIN
  FOR I:= 0 TO 8 DO BEGIN
    RC[I]:= POOL[I];
    RI[I]:= RS[I] XOR POOL[I];
    IF RI[I] = 0 THEN RI[I]:= 1;
  END;
  RR:= RC9;
  FOR I:= 0 TO POOLSIZE-1 DO BEGIN
    RR:= RR + RN(NEXT);
    POOL[I]:= RR;
    NEXT:= NEXT + 1;
    IF NEXT = 9 THEN NEXT:= 0;
  END;
  RR:= RC9;
END; {INITPOOL}

PROCEDURE DOINITCON; {Initialize file CRYP.CON}
VAR I  : INTEGER;
    CH : CHAR;
BEGIN
  FERROR:= FALSE;
  ASSIGN(CONFILE, 'CRYP.CON');
  REWRITE(CONFILE);
  IF IORESULT <> 0 THEN BEGIN
    WRITELN('Can not open file CRYP.CON');
    FERROR:= TRUE;
  END ELSE BEGIN
    FOR I:= 0 TO 8 DO
      RI[I]:= RS[I];
    FOR I:= 63 DOWNTO 0 DO
      POOL[I]:= RC9;
    BLOCKWRITE(CONFILE, POOL, 1);
    IF IORESULT <> 0 THEN BEGIN
      WRITELN('Unable to write file CRYP.CON');
      FERROR:= TRUE;
    END;
    CLOSE(CONFILE);
    IF IORESULT <> 0 THEN BEGIN
      WRITELN('Can close file CRYP.CON');
      FERROR:= TRUE;
    END;
  END;
  IF FERROR THEN
    WRITE('File CRYP.CON initialization ABORTED')
  ELSE
    WRITE('File CRYP.CON initialized successfully');
  WRITELN(', hit any key to continue ...');
  READ(KBD, CH);
END; {DOINITCON}

PROCEDURE ERASEKEY; {Erase all trace of the encryption key}
VAR I : INTEGER;
BEGIN
  FOR I:= 1 TO 72 DO ANSKEY[I]:= ' ';
  FOR I:= 1 TO 24 DO BEGIN
    KEY[I]:= ' ';  KEYI[I]:= 0;
  END;
  FOR I:= 0 TO 8  DO BEGIN
    RI[I]:= 0;  RS[I]:= 0;
  END;
  RR:= 0;
END; {ERASEKEY}

PROCEDURE PROCESS; {Process input file to output file}
VAR ANS : STRING[1]; {UTILITY OPERATOR'S ANSWER}
    CH  : CHAR;      {UTILITY CHARACTER}
    I   : INTEGER;
BEGIN
  TBYTES:= 0;
  FERROR:= FALSE;
  IF ENCIPHER
    THEN INITEN
    ELSE INITDE;
  IF NOT FERROR THEN BEGIN
    INITPOOL;
{DIAG
FOR I:= 0 TO 8 DO WRITE('RS[', I, '] = ', RS[I], '  ');
FOR I:= 0 TO 8 DO WRITE('RI[', I, '] = ', RI[I], '  ');}
    REPEAT
{DIAG  WRITELN('DIAG: REMRECS = ', REMRECS);}
      IF BUFRECSIZE < REMRECS
        THEN READRECS:= BUFRECSIZE
        ELSE READRECS:= REMRECS;
      BLOCKREAD (INFILE,  BUFIO, READRECS);
      IF IORESULT = 0 THEN BEGIN
        INCNT:= 128 * READRECS;
        TBYTES:= TBYTES + INCNT;
        CHANGEIT(BUFIO, INCNT); {Apply Pseudo Key}
        WRITEIT;
        REMRECS:= REMRECS - READRECS;
      END ELSE BEGIN
        WRITELN('Unable to read input file');
        FERROR:= TRUE;
      END;
      WRITELN(TBYTES:8:0, ' Bytes Processed');
    UNTIL (REMRECS = 0) OR FERROR;
  END;
  CLOSE(OUTFILE);
  IF IORESULT <> 0 THEN BEGIN
    WRITELN('Unable to close output file');
    FERROR:= TRUE;
  END;
  CLOSE(INFILE);
  IF IORESULT <> 0 THEN WRITELN('Unable to close input file');
  IF FERROR THEN BEGIN
    IF EXISTS THEN ERASE(OUTFILE);
    WRITE('File conversion ABORTED');
  END ELSE BEGIN
    IF EXISTS THEN BEGIN
      ASSIGN(OUTFILE, OUTNAME);
      ERASE(OUTFILE);
      ASSIGN(OUTFILE, TEMPNAME);
      RENAME(OUTFILE, OUTNAME);
    END;
    WRITECON;
    WRITE('File converted successfully');
  END;
  WRITELN(', hit any key to continue ...');
  READ(KBD, CH);
END; {PROCESS}

PROCEDURE INIT; {Initialize program only once}
VAR I : INTEGER; {UTILITY INDEX}
BEGIN
  INITPROM;
  ClrScr;
  GOTOXY(FIRSTCOL, LASTLINE);
  WRITELN;
  WRITELN(NAME);
  WRITELN(VERSION);
  WRITELN(AUTHOR);
  ANSKEY:= 'ABCDEF';
  DDRIVE:=  'A:';
  INNAME:=  'B:';
  OUTNAME:= 'B:';
  WRITELN;
  WRITELN
    ('Select characters for your KEY from the folling list of 64 characters:');
  WRITELN; WRITE(' ':27);
  FOR I:= 0 TO 15 DO WRITE(CHR(I+64));  WRITELN; WRITE(' ':27);
  FOR I:= 0 TO 15 DO WRITE(CHR(I+80));  WRITELN; WRITE(' ':27);
  FOR I:= 0 TO 15 DO WRITE(CHR(I+32));  WRITELN; WRITE(' ':27);
  FOR I:= 0 TO 15 DO WRITE(CHR(I+48));  WRITELN;
  WRITELN; WRITELN(
'Your KEY will be converted to a KEY in standard form.'
  ); WRITELN(
'The standard form is then used to compute seeds for the nine different random'
  ); WRITELN(
'number generators used to produce the pseudo infinite key.'
  ); WRITELN(
'The generated pseudo infinite key will not repeat itself until after it is'
  ); WRITELN(
'about 2**148 bits long.'
  );
END; {INIT}

BEGIN {MAIN PROGRAM (CRYP)}
  INIT;
  REPEAT
    NEXT:= 0;
    GETKEY;     IF STOPTYPED THEN GOTO EXIT;
                IF ESCTYPED  THEN GOTO CONTINUE;
    ENCORDEC;   IF STOPTYPED THEN GOTO EXIT;
                IF ESCTYPED  THEN GOTO CONTINUE;
    IF INITCON THEN DOINITCON
    ELSE BEGIN
      INNAME:= OUTNAME; {Default INNAME is last OUTNAME}
      GETINNAME;  IF STOPTYPED THEN GOTO EXIT;
                  IF ESCTYPED  THEN GOTO CONTINUE;
      OUTNAME:= INNAME; {Default OUTNAME is last INNAME}
      GETOUTNAME; IF STOPTYPED THEN GOTO EXIT;
                  IF ESCTYPED  THEN GOTO CONTINUE;
    PROCESS;
    END;
    CONTINUE:
  UNTIL FALSE; {Control-X to stop}
  EXIT:
  ERASEKEY;
END. {MAIN PROGRAM (CRYP)}

{end of file CRYP612.INC *****************************************************}