Return to caesar.c CVS log

Up to [Research Unix] / researchv10no / cmd / netnews / src

Annotation of researchv10no/cmd/netnews/src/caesar.c, revision 1.1.1.1

1.1       root        1: /* program to to decrypt caesar(tm) cypher */
                      2: /* (caesar is a trademark of the roman empire)
                      3: /*
                      4: /* to compile:
                      5: /*
                      6: /*     cc decrypt.c -lm -o decrypt.c
                      7: /*
                      8: /* usage:
                      9: /*
                     10: /*     decrypt [n] < file
                     11: /*
                     12: /* where n is an optional forced rotation.
                     13: /*
                     14: /* */
                     15: 
                     16: /* authors: Stan King, John Eldridge, based on algorithm suggested by
                     17: /*             Bob Morris
                     18: /* 29-Sep-82
                     19: /* Changed 30-Sep-82 to do each line separately.
                     20: /* */
                     21: 
                     22: #include <stdio.h>
                     23: #include <ctype.h>
                     24: #include <math.h>
                     25: extern char *calloc();
                     26: 
                     27: main( argc, argv )
                     28: int argc;
                     29: char *argv[];
                     30: {
                     31:        /* letter frequencies (taken from some unix(tm) documentation) */
                     32:        /* (unix is a trademark of Bell Laboratories) */
                     33:        static double stdf[ 26 ] =
                     34:        {
                     35:                7.97, 1.35, 3.61, 4.78, 12.37, 2.01, 1.46, 4.49,
                     36:                6.39, 0.04, 0.42, 3.81, 2.69, 5.92, 6.96, 2.91,
                     37:                0.08, 6.63, 8.77, 9.68, 2.62, 0.81, 1.88, 0.23,
                     38:                2.07, 0.06,
                     39:        };
                     40:        int obs[26];
                     41:        int bufsize;
                     42:        int c, i, try;
                     43:        double dot, winnerdot;  /* .. */
                     44:        int winner, forced;
                     45:        char *inbuf;
                     46: 
                     47:        bufsize = 0;
                     48:        if( argc > 1 )
                     49:                sscanf( argv[1], "%d", &forced );
                     50:        if( forced == 0 )
                     51:                forced = -1000;
                     52:                
                     53:        inbuf = calloc( BUFSIZ, 1 );
                     54: 
                     55:        /* adjust frequency table to weight low probs REAL low */
                     56:        for (i=0; i<26; i++)    {
                     57:                stdf[i] = log(stdf[i]) + log(26.0/100.0);
                     58:        }
                     59: 
                     60:        /* Decode each line separately */
                     61:        for (;;) {
                     62:                for (i=0; i<=25; obs[i++]=0)
                     63:                        ;
                     64: 
                     65:                /* get a sample of the text */
                     66:                for( i = 0; i < BUFSIZ; i++ ) {
                     67:                        if( (inbuf[i] = c = getchar()) == EOF ) {
                     68:                                return;
                     69:                        }       
                     70:                        if (c == '\n') {
                     71:                                bufsize = i+1; 
                     72:                                break;
                     73:                        }
                     74:                        if (islower(c))
                     75:                                obs[c-'a'] += 1;
                     76:                        else if (isupper(c))
                     77:                                obs[c-'A'] += 1;
                     78:                };
                     79: 
                     80:                /* now "dot" the freqs with the observed letter freqs
                     81:                /*      and keep track of best fit */
                     82:                winner = 0;     
                     83:                for (try = 0; try<26; try++) {
                     84:                        dot = 0;
                     85:                        for ( i=0; i<26; i++ ) {
                     86:                                dot += obs[i] * stdf[ (i+try) % 26 ];
                     87:                                };
                     88:                        /* initialize winning score */
                     89:                        if( try == 0 )
                     90:                                winnerdot = dot;
                     91:                        if( dot > winnerdot ) {
                     92:                                /* got a new winner! */
                     93:                                winner = try;
                     94:                                winnerdot = dot;
                     95:                        }
                     96:                }
                     97: 
                     98:                if (forced != -1000)
                     99:                        winner = forced;
                    100: 
                    101:                /* print out sample buffer */
                    102:                for( i = 0; i < bufsize; i++ )
                    103:                        putchar( rotate( inbuf[i], winner ) );
                    104:        }
                    105:  }
                    106: 
                    107: 
                    108: static int
                    109: rotate( c, perm )
                    110: char c;
                    111: int perm;
                    112: {
                    113:        if (isupper(c)) {
                    114:                return 'A' + (c - 'A' + perm) % 26 ;
                    115:        }
                    116:        else if (islower(c)) {
                    117:                return 'a' + (c-'a'+perm) % 26 ;
                    118:        }
                    119:        else return c;
                    120: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.