home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS 1992 September / Simtel20_Sept92.cdr / msdos / ddjmag / ddj8605.arc / CRYPTO.MAY next >
Text File  |  1986-05-31  |  19KB  |  833 lines
  1.  
  2. è###################     L I S T I N G   1    ####################
  3.  
  4. /*    
  5. ** cypher.c    File Cypher Program    by F.A.Scacchitti  9/11/85
  6. **
  7. **        Written in Small-C Version 2.10 or later
  8. **
  9. **        Copies from original file to encrypted file
  10. **        using cypher key(s) passed to  encode or decode.
  11. */
  12.  
  13. #include <stdio.h>
  14.  
  15. #define BUFSIZE 16384
  16.  
  17. int fdin, fdout;    /* file  i/o channel pointers */
  18. int n, count;
  19. char *inbuf, *key;
  20.  
  21. main(argc,argv) int argc, argv[]; {
  22.  
  23.    inbuf = malloc(BUFSIZE);
  24.  
  25. /*
  26. ** Open file streams
  27. */
  28.    if(argc < 4) {
  29.       printf("\ncypher usage: cypher <source file> <new file>
  30.  <key1> <key2> . . . <keyN> <CR>\n");
  31.       exit();
  32.    }
  33.    if((fdin = fopen(argv[1],"r")) == NULL) {
  34.       printf("\nUnable to open %s\n", argv[1]);
  35.       exit();
  36.    }
  37.    if((fdout = fopen(argv[2],"w")) == NULL) {
  38.       printf("\nUnable to create %s\n", argv[2]);
  39.       exit();
  40.    }
  41.  
  42. /*
  43. ** Read file - encode it - write new file 
  44. */
  45.    do {
  46.       printf("-reading file\n");
  47.  
  48.       count = read(fdin,inbuf,BUFSIZE);
  49.  
  50.       n=3;
  51.  
  52.       while(n++ <argc){
  53.          key = argv[n-1];
  54.          cypher(inbuf,count,key);
  55.       }
  56.       printf("-writing %d byte file\n\n", count);è
  57.       write(fdout,inbuf,count);
  58.  
  59.    } while(count == BUFSIZE);
  60.  
  61.    /* close up shop */
  62.  
  63.       fclose(fdin);
  64.       fclose(fdout);
  65. }
  66.  
  67.  
  68. .paè###################     L I S T I N G   2    ####################
  69.  
  70. /*    cypher1.c    Cypher module        by F.A.Scacchitti
  71. **                            10/10/85
  72. **
  73. **    Simple cypher module - encodes directly with user keys
  74. **
  75. */
  76.  
  77. #include <stdio.h>
  78.  
  79. static int i, n, keylength;
  80.  
  81. cypher1(buffer, num, code) char *buffer, *code; int num;{
  82.  
  83. /*
  84. ** get keylength for each key
  85. */
  86.  
  87.    keylength = 0;
  88.    while(code[keylength++] != NULL);
  89.    keylength--;
  90.  
  91. /*
  92. ** encrypt the file with each key
  93. */
  94.  
  95.    printf("-encoding/decoding buffer\n");
  96.  
  97.    for(i=0; i<=num; i++)
  98.       buffer[i] = buffer[i] ^ code[i % keylength];
  99. }
  100.  
  101.  
  102.  
  103. .paè###################     L I S T I N G   3    ####################
  104.  
  105. /*    cypher2.c    Cypher module        by F.A.Scacchitti
  106. **                            10/11/85
  107. **
  108. **    Complex cypher module - generates a key of some prime length
  109. **                              between 1024 and 2028 bytes then
  110. **                              encrypts the buffer with this key
  111. **
  112. */
  113.  
  114. #include <stdio.h>
  115.  
  116. #define NEWBUF 2000
  117. #define NUMPRIMES 50
  118.  
  119. static int i, n, index, length, sum, keylength;
  120. static char *newkey;
  121. static int prime[] = {1009, 1999, 1013, 1997, 1019,
  122.                       1993, 1021, 1987, 1031, 1979,
  123.                       1033, 1973, 1039, 1951, 1049,
  124.                       1949, 1051, 1933, 1061, 1931,
  125.                       1063, 1913, 1069, 1907, 1087,
  126.                       1901, 1091, 1889, 1093, 1879,
  127.                       1097, 1877, 1103, 1873, 1109,
  128.                       1871, 1117, 1867, 1123, 1861,
  129.                       1129, 1847, 1151, 1831, 1153,
  130.                       1823, 1163, 1813, 1171, 1803};
  131.  
  132. cypher1(buffer, num, code) char *buffer, *code; int num;{
  133.  
  134. /*
  135. ** allocate a buffer for the generated key 
  136. */
  137.    newkey = malloc(NEWBUF);
  138.  
  139. /*
  140. ** get keylength and sumcheck for each key
  141. */
  142.  
  143.    keylength = sum = 0;
  144.    while((n = code[keylength]) != NULL){
  145.       sum += n;
  146.       keylength++;
  147.    }
  148.  
  149. /*
  150. ** Select a prime and generate a new key that length
  151. */
  152.  
  153.    length = prime[sum % NUMPRIMES];
  154.  
  155.    printf("-generating a %d byte key\n",length);
  156.  
  157.    for(i=0; i<length; i++){è      index = i % keylength;
  158.       sum = code[index] + sum & 255;
  159.       newkey[i] = code[index] ^ sum;
  160.    }
  161.  
  162. /*
  163. ** encrypt the file with the generated key
  164. */
  165.  
  166.    printf("-encoding/decoding buffer\n");
  167.  
  168.    for(i=0; i<=num; i++)
  169.       buffer[i] = buffer[i] ^ newkey[i % length];
  170.  
  171. /*
  172. ** get rid of the buffer
  173. */
  174.  
  175.    cfree(newkey);
  176.  
  177. }
  178.  
  179.  
  180.  
  181. .paè###################     L I S T I N G   4    ####################
  182.  
  183. /*    cypher3.c    Cypher module        by F.A.Scacchitti
  184. **                            11/09/85
  185. **
  186. **    Complex cypher module - generates a key of some prime length
  187. **                              between 1024 and 2028 bytes then
  188. **                              encrypts the buffer with this key
  189. **                        or
  190. **                if key starts with a '-' (dash)
  191. **                calculate a transposition block size
  192. **                and invert (transpose) the file in
  193. **                this size blocks 
  194. **
  195. */
  196.  
  197. #include <stdio.h>
  198.  
  199. #define DASH 45
  200. #define NEWBUF 2000
  201. #define NUMPRIMES 50
  202.  
  203. static int i, j, n, index, length, sum, keylength;
  204. static char *tbuff, c;
  205. static int prime[] = {1009, 1999, 1013, 1997, 1019,
  206.                       1993, 1021, 1987, 1031, 1979,
  207.                       1033, 1973, 1039, 1951, 1049,
  208.                       1949, 1051, 1933, 1061, 1931,
  209.                       1063, 1913, 1069, 1907, 1087,
  210.                       1901, 1091, 1889, 1093, 1879,
  211.                       1097, 1877, 1103, 1873, 1109,
  212.                       1871, 1117, 1867, 1123, 1861,
  213.                       1129, 1847, 1151, 1831, 1153,
  214.                       1823, 1163, 1813, 1171, 1803};
  215.  
  216. cypher(buffer, num, code) char *buffer, *code; int num;{
  217.  
  218. /*
  219. ** allocate a buffer for the new key or transposition
  220. */
  221.    tbuff = malloc(NEWBUF);
  222.  
  223. /*
  224. ** get keylength and sumcheck for each key
  225. */
  226.  
  227.    keylength = sum = 0;
  228.    while((n = code[keylength]) != NULL){
  229.       sum += n;
  230.       keylength++;
  231.    }
  232.  
  233. /*
  234. ** do we transpose or encode ?
  235. */è
  236.    if((c = *code) == DASH)
  237.       transpose(buffer, num, code);
  238.    else
  239.       encode(buffer, num, code);
  240.  
  241. /*
  242. ** get rid of the buffer
  243. */
  244.  
  245.    cfree(tbuff);
  246.  
  247. }
  248.  
  249. /*
  250. ** Here's where we transpose
  251. */
  252.  
  253. transpose(buffer, num, code) char *buffer, *code; int num;{
  254.  
  255.    length = (((sum + keylength) % 16) & 15) + 2;
  256.  
  257.    printf("-transposing file by %d\n",length);
  258.  
  259.    index = 0;
  260.  
  261.    do{
  262.       for(i = 0; i < length; i++){
  263.          j = length - i - 1;
  264.          tbuff[j] = buffer[index + i];
  265.       }
  266.       for(i = 0; i < length; i++){
  267.          buffer[index + i] = tbuff[i];
  268.       }
  269.       index += length;
  270.  
  271.    }while(index < count);
  272.  
  273. }
  274.  
  275. /*
  276. ** Here's where we encode
  277. */
  278.  
  279. encode(buffer, num, code) char *buffer, *code; int num;{
  280.  
  281. /*
  282. ** Select a prime and generate a new key that length
  283. */
  284.  
  285.    length = prime[sum % NUMPRIMES];
  286.  
  287.    printf("-generating a %d byte key\n",length);
  288.  
  289.    for(i=0; i<length; i++){è      index = i % keylength;
  290.       sum = code[index] + sum & 255;
  291.       tbuff[i] = code[index] ^ sum;
  292.    }
  293.  
  294. /*
  295. ** encrypt the file with the generated key
  296. */
  297.  
  298.    printf("-encoding/decoding buffer\n");
  299.  
  300.    for(i=0; i<=num; i++)
  301.       buffer[i] = buffer[i] ^ tbuff[i % length];
  302.  
  303.  
  304. }
  305.  
  306.  
  307.  
  308. .paè###################     L I S T I N G   5    ####################
  309.  
  310. /*    
  311. ** fv.c    File View/Compare Program    by F.A.Scacchitti  9/11/85
  312. **
  313. **        Written in Small-C Version 2.10 or later
  314. **
  315. **        Dumps contents of single file to screen
  316. **                or
  317. **        Dumps contents of 2 files and xored difference
  318. ** 
  319. **        Displays in hex and ascii form
  320. */
  321.  
  322. #include <stdio.h>
  323.  
  324. #define BUFSIZE 1024
  325.  
  326. int fdin1, fdin2;    /* file  i/o channel pointers */
  327. int i, j, k,  val, count, total, offset, numdisp;
  328. char *inbuf1, *inbuf2, *difbuf, c;
  329.  
  330. main(argc,argv) int argc, argv[]; {
  331.  
  332.    switch (argc) {
  333.    case 2:
  334.    case 3:
  335.       inbuf1 = malloc(BUFSIZE);
  336.       if((fdin1 = fopen(argv[1],"r")) == NULL) {
  337.          printf("\nUnable to open %s\n", argv[1]);
  338.          exit();
  339.       }
  340.       numdisp = 1;
  341.       if(argc == 2) break;
  342.    case 3:
  343.       inbuf2 = malloc(BUFSIZE);
  344.       difbuf = malloc(BUFSIZE);
  345.       if((fdin2 = fopen(argv[2],"r")) == NULL) {
  346.          printf("\nUnable to open %s\n", argv[2]);
  347.          exit();
  348.       }
  349.       numdisp = 3;
  350.       break;
  351.    default:
  352.       printf("\nfv usage: fv <file1>          -  dump file\n");
  353.       printf("          fv <file1> <file2>  -  compare 2 files\n");
  354.       exit();
  355.    }
  356.    total = offset = 0;
  357.  
  358.    printf("\n");
  359.  
  360.    do {
  361.       count = read(fdin1,inbuf1,BUFSIZE);
  362.       if(argc >= 3){è         read(fdin2,inbuf2,BUFSIZE);
  363.  
  364.          for(i=0; i< count; i++)
  365.             difbuf[i] = inbuf1[i] ^ inbuf2[i];
  366.       }
  367.  
  368.       for(i=0; i< count; i+=16){
  369.  
  370.          for(k=1; k <= numdisp; k++){
  371.  
  372.             switch (k) {
  373.             case 2:
  374.                offset = BUFSIZE;
  375.                break;
  376.             case 3:
  377.                offset = 2 * BUFSIZE;
  378.                break;
  379.             default:
  380.                offset = 0;
  381.                break;
  382.             }
  383.             if(k < 3)
  384.                printf("f-%d", k);
  385.             else
  386.                printf("dif");
  387.  
  388.             printf(" %04x  ",i+total);
  389.  
  390.             for(j=0; j<=15; j++){
  391.                val = inbuf1[i + j + offset];
  392.                printf("%02x ",val < 0 ? val - 65280 : val);
  393.  
  394.                if((c = bdos(6,255)) == 19){     /* hold on ^S */
  395.                   if((c = getchx()) == 3)
  396.                      exit();                    /* exit on ^C */
  397.  
  398.                }                                /* continue on ^Q */
  399.  
  400.             }
  401.             printf("  ");
  402.  
  403.             for(j=0; j<=15; j++){
  404.                c = inbuf1[i + j + offset];
  405.                if(c > 31)
  406.                   putchar(c);
  407.                else
  408.                   if(c==0)
  409.                      putchar(61);
  410.                   else
  411.                      putchar(94);
  412.             }
  413.             printf("\n");
  414.             if(k == 3) printf("\n");
  415.          }
  416.       }è      total += count;
  417.  
  418.    } while(count == BUFSIZE);
  419.  
  420.       /* close up shop */
  421.  
  422.    fclose(fdin1);
  423.    if(argc == 3)
  424.       fclose(fdin2);
  425. }
  426.  
  427.  
  428.  
  429. .paè###################     L I S T I N G   6    ####################
  430.  
  431. /*    
  432. ** fstat.c    File Statistics Program    by F.A.Scacchitti 10/8/85
  433. **
  434. **        Written in Small-C Version 2.10 or later
  435. **
  436. **        Scans file and displays distribution of 
  437. **        characters.
  438. **        Calculates and displays mean, mode, median 
  439. **        and range of file.
  440. **        Displays histogram of distribution.
  441. */
  442.  
  443. #include <stdio.h>
  444.  
  445. #define BUFSIZE 16384
  446.  
  447. int fdin;    /* file  pointer */
  448. int i, j, temp, value, count, total, *file, *sorted;
  449. int sum, hisum, meansum, himeansum, mean, eflag, changing;
  450. int median, oddmedian, range, min, max, mode;
  451. int *data, scale;
  452. char c, *inbuf;
  453.  
  454. main(argc,argv) int argc, argv[]; {
  455.  
  456.    if(argc < 2) {
  457.       printf("\nfstat usage: fstat <input file>\n");
  458.       exit();
  459.    }
  460.    if((fdin = fopen(argv[1],"r")) == NULL) {
  461.       printf("\nUnable to open file %s\n",argv[1]);
  462.       exit();
  463.    }
  464.  
  465.    inbuf = calloc(BUFSIZE,1);
  466.    file = calloc(256,2);
  467.    sorted = calloc(256,2);
  468.    data = calloc(17,2);
  469.    eflag = FALSE;
  470.    sum = hisum = meansum = himeansum = mean = mode = j = 0;
  471.  
  472.    printf("reading the file-");
  473.  
  474.    do {
  475.       count = read(fdin,inbuf,BUFSIZE);
  476.  
  477.       for(i=0; i< count; i++){
  478.  
  479.          value = inbuf[i];
  480.  
  481.                         
  482.          if(value < 0)
  483.             value = 256 + value;è         file[value]++;
  484.          if(++sum == 10000){
  485.             hisum++;
  486.             sum =0;
  487.          }
  488.          if((meansum += value) >= 10000){
  489.             himeansum++;
  490.             meansum -= 10000;
  491.          }
  492.       }
  493.    } while(count == BUFSIZE);
  494.  
  495. /*
  496. ** Calculate the mean
  497. */
  498.  
  499.    printf("calculating mean-");
  500.  
  501.    do{
  502.       if((meansum -= sum) < 0)
  503.          if(himeansum > 0){
  504.             himeansum--;
  505.             meansum += 10000;
  506.          }else{
  507.             meansum += sum;
  508.             eflag = TRUE;
  509.             mean--;
  510.          }
  511.       if((himeansum -= hisum) < 0){
  512.          himeansum += hisum;
  513.          eflag = TRUE;
  514.       }else{
  515.          mean++;
  516.       }
  517.    }while(eflag == FALSE);
  518.  
  519. /*
  520. ** Calculate range, find mode min and max, fill the sorted array
  521. */
  522.  
  523.    printf("calculating range-");
  524.  
  525.    min = max = file[0];
  526.  
  527.    for(i = 0; i <= 255; i++){
  528.       sorted[i] = file[i];
  529.       if(file[i] > max){
  530.          max = file[i];
  531.          mode = i;
  532.       }
  533.       if(file[i] < min)
  534.          min = file[i];
  535.    }
  536.    range = max - min + 1;
  537. è/*
  538. ** Sort the sorted array to calculate median
  539. */
  540.  
  541.    printf("sorting the array");
  542.  
  543.    changing = TRUE;
  544.  
  545.    while(changing){
  546.       changing = FALSE;
  547.       for(i = 0; i <= 254; i++)
  548.          if(sorted[i] > sorted[i+1]){
  549.             temp = sorted[i];
  550.             sorted[i] = sorted[i+1];
  551.             sorted[i+1] = temp;
  552.             changing = TRUE;
  553.          }
  554.    }
  555.  
  556.    median = (sorted[128] + sorted[127]) / 2;
  557.    oddmedian = (sorted[128] + sorted[127]) % 2;
  558.  
  559. /*
  560. ** Display the results
  561. */
  562.  
  563.    printf("\n    0    1    2    3    4    5    6    7    
  564.                  8    9    A    B    C    D    E    F\n");
  565.  
  566.    for(i = 0; i <= 255; i++) {
  567.       printf("%5d", file[i]);
  568.       chkkbd();
  569.    }
  570.  
  571.    printf("\n %d%04d characters read from file %s\n",
  572.                                      hisum, sum, argv[1]);
  573.    printf("file mean = %d  ",mean);
  574.    if((himeansum || meansum) > 0)
  575.       printf("%d%04d/%d%04d",himeansum,meansum,hisum,sum);
  576.    printf("         mode = %d  ( %x hex)", mode, mode);
  577.    printf("\n");
  578.    printf("file median = %d", median);
  579.    if(oddmedian)
  580.       printf(" 1/2 ");
  581.    else
  582.       printf("     ");
  583.    printf("    file range = %d  [ min = %d    max = %d ]\n",
  584.                                           range, min, max,);
  585.    printf("\nDepress spacebar to display histogram ");
  586.    getchar();
  587.  
  588. /*
  589. ** Sum the data in 16 groups of 16 elements and find max. value
  590. */
  591.    max = 0;è   for(i = 1; i <= 16; i++){
  592.       for(j = 0; j <= 15; j++)
  593.          data[i] += file[(i - 1) * 16 + j];
  594.       if(data[i] > max)
  595.          max = data[i];
  596.    }
  597. /*
  598. ** Calculate scaling for plot
  599. */
  600.    scale = max / 50;
  601.    temp = max % 50;
  602.    if(temp / scale > 7)
  603.       scale++;
  604.    printf("   scale = %4d\n\n", scale);
  605.  
  606. /*
  607. ** Print data and plot of histogram
  608. */
  609.  
  610.    for(i = 0; i <= 15; i++){
  611.       printf(" %3d to %3d = %5d ||",i  * 16, (i * 16) + 15,
  612.                                               data[i + 1]);
  613.       temp = data[i + 1] / scale;
  614.       if(data[i + 1] % scale > 0)
  615.          temp++;
  616.       while(temp-- > 0)
  617.          printf("*");
  618.       printf("\n");
  619.    }
  620.  
  621. /*
  622. ** close up shop
  623. */
  624.    fclose(fdin);
  625. }
  626.  
  627. chkkbd(){ char c;
  628.  
  629.    if((c = bdos(6,255)) == 19)     /* hold on ^S */
  630.       if((c = getchx()) == 3)
  631.          exit();                    /* exit on ^C */
  632. }                                   /* continue   */
  633.  
  634.  
  635.  
  636. .paè###################     L I S T I N G   7    ####################
  637.  
  638. /*    
  639. ** makef.c    File Generator Program     by F.A.Scacchitti 10/7/85
  640. **
  641. **        Written in Small-C Version 2.10 or later
  642. **
  643. **        Creates a seqential file of characters from
  644. **        0 to 255 in blocks of 255 bytes.
  645. **        The sequential characters can be replaced
  646. **        with any single character desired.
  647. */
  648.  
  649. #include <stdio.h>
  650.  
  651. #define BUFSIZE 256
  652.  
  653.  
  654. int fdout;        /* file  i/o channel pointers */
  655. int i, n, num;
  656. char *outbuf, value; 
  657.  
  658. main(argc,argv) int argc, argv[]; {
  659.  
  660. /*
  661. ** Allocate memory for buffer
  662. */
  663.  
  664.    outbuf = malloc(BUFSIZE);
  665.  
  666. /*
  667. ** Check arguments passed and open file stream
  668. */
  669.    if(argc < 3) {
  670.       printf("\nmakef usage: makef <new file> <nnnn> [ddd]\n");
  671.       printf(" nnnn = file size in 256 byte blocks\n");
  672.       printf(" ddd  = optional alternate value in decimal\n");
  673.       exit();
  674.    }
  675.    if((fdout = fopen(argv[1],"w")) == NULL) {
  676.       printf("\nUnable to create %s\n", argv[1]);
  677.       exit();
  678.    }
  679. /*
  680. ** Convert file size argument to integer
  681. */
  682.    if((n = atoi(argv[2])) == NULL) exit();
  683.  
  684. /*
  685. ** Fill the buffer with 0 to 255 sequence
  686. */
  687.    for(i = 0; i <=255; i++)
  688.       outbuf[i] = i;
  689.  
  690. /*è** Refill the buffer with a single character if directed by argument
  691. */
  692.    if(argc == 4)
  693.       if((value = atoi(argv[3])) < 256)
  694.          for(i = 0; i <=255; i++)
  695.             outbuf[i] = value;
  696.  
  697. /*
  698. ** Write blocks to file
  699. */
  700.    for(i=1; i <= n; i++)
  701.       if((num = write(fdout,outbuf,BUFSIZE)) < BUFSIZE) exit();
  702.  
  703. /*
  704. ** Close up shop
  705. */
  706.  
  707.    fclose(fdout);
  708. }
  709.  
  710.  
  711.  
  712. .paè###################     L I S T I N G   8    ####################
  713.  
  714. /*    
  715. ** sp.c           Search Pattern Program    by F.A.Scacchitti 10/15/85
  716. **
  717. **        Written in Small-C Version 2.10 or later
  718. **
  719. **        Searches file for repetitive pattern.
  720. **
  721. **
  722. */
  723.  
  724. #include <stdio.h>
  725.  
  726. #define BUFSIZE 16384
  727.  
  728.  
  729. int  fdin;        /* file  i/o channel pointers */
  730. int i, j, n, block, start, depth, count, limit;
  731. char *c, *inbuf; 
  732.  
  733. main(argc,argv) int argc, argv[]; {
  734.  
  735. /*
  736. ** Set defaults
  737. */
  738.    block = 128;
  739.    depth = 4;
  740.    start = 0;
  741.  
  742. /*
  743. ** Allocate memory for buffer
  744. */
  745.    inbuf = malloc(BUFSIZE);
  746.  
  747. /*
  748. ** Check arguments passed and open file stream
  749. */
  750.    if(argc < 2) {
  751.       printf("\nsp usage: sp <source file> [nnnn] [dddd] [ssss] [x]\n");
  752.       printf("    nnnn = block size to search   default = 128\n");
  753.       printf("    dddd = minimum depth of comparison  default = 4\n");
  754.       printf("    ssss = starting point in buffer default = 0\n");
  755.       printf("    x - any char. gen's difference buffer ((n+1)-n)\n");
  756.       exit();
  757.    }
  758.    if((fdin = fopen(argv[1],"r")) == NULL) {
  759.       printf("\nUnable to open %s\n", argv[1]);
  760.       exit();
  761.    }
  762.  
  763. /*
  764. ** Convert optional inputs to integer and implement
  765. */
  766.    if(argc > 2)è      if((n = atoi(argv[2])) != NULL) 
  767.          block = n;
  768.  
  769.    if(argc > 3)
  770.       if((n = atoi(argv[3])) != NULL) 
  771.          depth = n;
  772.  
  773.    if(argc > 4)
  774.       if((n = atoi(argv[4])) != NULL) 
  775.          start = n;
  776.  
  777. /*
  778. ** Fill the buffer with as much as possible
  779. */
  780.    count = read(fdin,inbuf,BUFSIZE);
  781.  
  782.    limit = count - depth;
  783.  
  784. /*
  785. ** If there's a sixth argument, convert the file to numerical sequence
  786. */
  787.  
  788.    if(argc > 5){
  789.       for(i = 0; i < count - 1; i++)
  790.          inbuf[i] = inbuf[i + 1] - inbuf[i];
  791.    }
  792.  
  793.    for(i = start; i < block; i++){
  794.       printf("%c", (i % 10 == 0) ? '|' : '.');
  795.       chkkbd();
  796.       for(j = i + 1; j <= limit; j++)
  797.          if(inbuf[i] == inbuf[j]){
  798.             if((n = chkdepth(i, j, 0)) >= depth)
  799.                printf("\nmatch at %d (%x hex) and %d (%x hex) -
  800.                                      %d deep\n", i, i, j, j, n);
  801.             if(n >= block) exit();
  802.          }
  803.    }
  804. /*
  805. ** Close up shop
  806. */
  807.    printf("\n");    /* Flush print buffer */
  808.  
  809.    fclose(fdin);
  810. }
  811.  
  812. chkdepth(pointer, offset, k)int pointer, offset, k;{
  813.  
  814.  
  815.    while(inbuf[pointer] == inbuf[offset] && k < count){
  816.       pointer++;
  817.       offset++;
  818.       k++;
  819.    }
  820.    return(k);è}
  821.  
  822. chkkbd(){
  823.  
  824. char c;
  825.  
  826.    if((c = bdos(6,255)) == 19){     /* hold on ^S */
  827.       if((c = getchx()) == 3)
  828.          exit();                    /* exit on ^C */
  829.  
  830.    }                                /* continue   */
  831. }
  832.  
  833.