Return to encrypt.c CVS log

Up to [Research Unix] / researchv10no / games / des

Annotation of researchv10no/games/des/encrypt.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *     data encryption and decryption program
                      3:  */
                      4: #include <stdio.h>
                      5: 
                      6: typedef union {
                      7:        long words[2];
                      8:        char bytes[8];
                      9: } block;
                     10: extern long keys_L[], keys_H[];
                     11: 
                     12: main(argc, argv)
                     13: char *argv[];
                     14: {
                     15:        static block key;
                     16:        static block icv;
                     17:        static block in;
                     18:        register char *cp;
                     19:        register c;
                     20:        register i;
                     21:        char *cpretry;
                     22:        static char buf[512];
                     23:        extern char *getpass();
                     24: 
                     25:        /*
                     26:         *      generate key by crunching user supplied string.
                     27:         */
                     28:        if (argc > 2) {
                     29:                fprintf(stderr, "usage: %s key <stdin >stdout\n", argv[0]);
                     30:                exit(1);
                     31:        }
                     32:        if (argc == 2) {
                     33:                strncpy(buf, argv[1], 512);
                     34:                cp = argv[1];
                     35:                while (*cp)
                     36:                        *cp++ = '\0';
                     37:                cp = buf;
                     38:        }
                     39:        else {
                     40:                for (cp=cpretry=(char*)NULL; ;) {
                     41:                        cp = getpass("Enter Key: ");
                     42:                        cp = (char*)strcpy(buf,cp);
                     43:                        cpretry = getpass("Reenter Key for Verification: ");
                     44:                        if (strcmp(cp,cpretry))
                     45:                                fprintf(stderr,"Sorry, keys don't match.\n");
                     46:                        else {
                     47:                                while (*cpretry) *cpretry++ = '\0';
                     48:                                break;
                     49:                        }
                     50:                }
                     51:        }
                     52:        key.words[0] = 0;       /* modification April 28, 1982 */
                     53:        key.words[1] = 0;
                     54:        compkeys("canofbugs", 0);
                     55:        for (i = 0; *cp; i = ++i & 07) {
                     56:                key.bytes[i & 07] ^= *cp;
                     57:                *cp++ = '\0';
                     58:                if (i == 07)
                     59:                        des(&key, &key);
                     60:        }
                     61:        des(&key, &key);
                     62:        /*
                     63:         *      set initial chaining value
                     64:         */
                     65:        des("numbersoup", &icv);
                     66:        cp = argv[0];
                     67:        for (i = strlen(cp); i >= 0; --i)
                     68:                if (cp[i] == '/')
                     69:                        break;
                     70:        cp += i + 1;
                     71:        i = 0;
                     72:        if (strcmp(cp, "encrypt") == 0) {
                     73:                compkeys(&key, 0);
                     74:                while (i = fread(key.bytes, 1, 8, stdin)) {
                     75:                        if (i != 8)
                     76:                                des(&icv, &icv);
                     77:                        icv.words[0] ^= key.words[0];
                     78:                        icv.words[1] ^= key.words[1];
                     79:                        if (i == 8)
                     80:                                des(&icv, &icv);
                     81:                        fwrite(icv.bytes, 1, i, stdout);
                     82:                }
                     83:        } else if (strcmp(cp, "decrypt") == 0) {
                     84:                compkeys(&key, 1);
                     85:                while (i = fread(in.bytes, 1, 8, stdin)) {
                     86:                        if (i == 8) {
                     87:                                des(&in, &key);
                     88:                                icv.words[0] ^= key.words[0];
                     89:                                icv.words[1] ^= key.words[1];
                     90:                        } else {
                     91:                                keyreverse();
                     92:                                des(&icv, &icv);
                     93:                                icv.words[0] ^= in.words[0];
                     94:                                icv.words[1] ^= in.words[1];
                     95:                        }
                     96:                        fwrite(icv.bytes, 1, i, stdout);
                     97:                        icv.words[0] = in.words[0];
                     98:                        icv.words[1] = in.words[1];
                     99:                }
                    100:        } else {
                    101:                fprintf(stderr, "zeroth argument must be 'encrypt' or 'decrypt'\n");
                    102:                exit(1);
                    103:        }
                    104: }
                    105: keyreverse()
                    106: {
                    107:        register i;
                    108:        register j;
                    109: 
                    110:        for (i = 0; i < 8; i++) {
                    111:                j = keys_L[i];
                    112:                keys_L[i] = keys_L[15-i];
                    113:                keys_L[15-i] = j;
                    114:                j = keys_H[i];
                    115:                keys_H[i] = keys_H[15-i];
                    116:                keys_H[15-i] = j;
                    117:        }
                    118: }

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