Return to crypt.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin

Annotation of coherent/d/bin/crypt.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: 
        !             3: unsigned int seed1, seed2;
        !             4: unsigned char rotor[256];
        !             5: unsigned char deck[256];
        !             6: char key[12];
        !             7: char padkey[] = {
        !             8:        003, 022, 006, 007, 034,
        !             9:        023, 031, 001, 027, 036
        !            10: };
        !            11: char   *getpass();
        !            12: char   *crypt();
        !            13: 
        !            14: main(ac, av)
        !            15: int ac;
        !            16: char *av[];
        !            17: {
        !            18:        getkey(ac, av);
        !            19:        pervertkey();
        !            20:        makerotor();
        !            21:        cryptext();
        !            22:        return (0);
        !            23: }
        !            24: 
        !            25: /*
        !            26:  * Get the password and destroy all traces in the system.
        !            27:  */
        !            28: getkey(ac, av)
        !            29: int ac;
        !            30: char *av[];
        !            31: {
        !            32:        register char *ps;
        !            33:        register int i;
        !            34: 
        !            35:        if (ac == 2)
        !            36:                ps = av[1];
        !            37:        else if (ac == 1) {
        !            38:                ps = getpass("Password? ");
        !            39:                if (*ps == '\0')
        !            40:                        derror("Empty password not allowed.");
        !            41:        }
        !            42:        else
        !            43:                derror("USAGE: crypt [password]");
        !            44:        for (i = 0; i < 10  &&  (key[i] = *ps) != '\0'; ++i)
        !            45:                *ps++ = '\0';
        !            46:        while (*ps)
        !            47:                *ps++ = '\0';
        !            48: }
        !            49: 
        !            50: /*
        !            51:  * Pad key to 10 chars, coerce the last two into `salt' range [./0-9A-Za-z].
        !            52:  * Feed this to crypt(3), and copy the last 11 chars of the result into key.
        !            53:  */
        !            54: pervertkey()
        !            55: {
        !            56:        register char *cp;
        !            57:        register char *kp = key;
        !            58: 
        !            59:        strncat(key, padkey, 10 - strlen(key));
        !            60:        key[10] = legal(key[9]);
        !            61:        key[9] = legal(key[8]);
        !            62:        key[11] = key[8] = '\0';
        !            63:        cp = crypt(&key[0], &key[9]);
        !            64:        cp += 2;
        !            65:        while ((*kp++ = *cp++) != 0)
        !            66:                ;
        !            67: }
        !            68: 
        !            69: /*
        !            70:  * Coerce a char into a legal salt character if it is not.
        !            71:  */
        !            72: legal(c)
        !            73: register int c;
        !            74: {
        !            75:        if (c < 12)
        !            76:                return (c + '.');
        !            77:        else if (c < 38)
        !            78:                return (c - 12 + 'A');
        !            79:        else if (c < '.')
        !            80:                return (c - 38 + 'a');
        !            81:        else if ('9' < c &&  c < 'A')
        !            82:                return ('o' + 1 - ('A' - c));
        !            83:        else if ('Z' < c  &&  c < 'a')
        !            84:                return ('u' + 1 - ('a' - c));
        !            85:        else if (c > 'z')
        !            86:                return ('z' + 1 - (0200 - c));
        !            87:        else
        !            88:                return (c);
        !            89: }
        !            90: 
        !            91: 
        !            92: /*
        !            93:  * Makerotor() uses key to initialize two seeds for rand(). Seed1 is used to
        !            94:  *     build the rotor. Seed2 initializes the `random' sequence of offsets.
        !            95:  */
        !            96: makerotor()
        !            97: {
        !            98:        register int i, j;
        !            99:        register unsigned char uc;
        !           100: 
        !           101:        /* Initialize seeds. */
        !           102:        for (i = 0; i < 6; ++i) {
        !           103:                seed1 = (++seed1) * key[i];
        !           104:                seed2 = (++seed2) * key[i + 5];
        !           105:        }
        !           106: 
        !           107:        /* Initialize and shuffle deck. */
        !           108:        srand(seed1);
        !           109:        for (i = 0; i < 256; ++i)
        !           110:                deck[i] = i;
        !           111:        for (i = 0; i < 256; ++i) {
        !           112:                j = i + rand() % (256 - i);
        !           113:                uc = deck[i];
        !           114:                deck[i] = deck[j];
        !           115:                deck[j] = uc;
        !           116:        }
        !           117: 
        !           118:        /* Initialize rotor. */
        !           119:        for (i = 0; i < 256; i+=2) {
        !           120:                rotor[deck[i]] = deck[i + 1];
        !           121:                rotor[deck[i + 1]] = deck[i];
        !           122:        }
        !           123: }
        !           124: 
        !           125: cryptext()
        !           126: {
        !           127:        register int c, j;
        !           128: 
        !           129:        srand(seed2);
        !           130:        while ((c = getchar()) != EOF) {
        !           131:                j = rand() % 256;
        !           132:                putchar((rotor[(c + j) % 256] + 256 - j) % 256);
        !           133:        }
        !           134: }
        !           135: 
        !           136: derror(s)
        !           137: register char *s;
        !           138: {
        !           139:        fprintf(stderr, "%s\n", s);
        !           140:        exit(1);
        !           141: }
        !           142: 

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