| /* crypto/des/des.c */ |
| /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) |
| * All rights reserved. |
| * |
| * This package is an SSL implementation written |
| * by Eric Young (eay@cryptsoft.com). |
| * The implementation was written so as to conform with Netscapes SSL. |
| * |
| * This library is free for commercial and non-commercial use as long as |
| * the following conditions are aheared to. The following conditions |
| * apply to all code found in this distribution, be it the RC4, RSA, |
| * lhash, DES, etc., code; not just the SSL code. The SSL documentation |
| * included with this distribution is covered by the same copyright terms |
| * except that the holder is Tim Hudson (tjh@cryptsoft.com). |
| * |
| * Copyright remains Eric Young's, and as such any Copyright notices in |
| * the code are not to be removed. |
| * If this package is used in a product, Eric Young should be given attribution |
| * as the author of the parts of the library used. |
| * This can be in the form of a textual message at program startup or |
| * in documentation (online or textual) provided with the package. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. All advertising materials mentioning features or use of this software |
| * must display the following acknowledgement: |
| * "This product includes cryptographic software written by |
| * Eric Young (eay@cryptsoft.com)" |
| * The word 'cryptographic' can be left out if the rouines from the library |
| * being used are not cryptographic related :-). |
| * 4. If you include any Windows specific code (or a derivative thereof) from |
| * the apps directory (application code) you must include an acknowledgement: |
| * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
| * |
| * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * |
| * The licence and distribution terms for any publically available version or |
| * derivative of this code cannot be changed. i.e. this code cannot simply be |
| * copied and put under another distribution licence |
| * [including the GNU Public Licence.] |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <openssl/opensslconf.h> |
| #ifndef OPENSSL_SYS_MSDOS |
| # ifndef OPENSSL_SYS_VMS |
| # include OPENSSL_UNISTD |
| # else /* OPENSSL_SYS_VMS */ |
| # ifdef __DECC |
| # include <unistd.h> |
| # else /* not __DECC */ |
| # include <math.h> |
| # endif /* __DECC */ |
| # endif /* OPENSSL_SYS_VMS */ |
| #else /* OPENSSL_SYS_MSDOS */ |
| # include <io.h> |
| #endif |
| |
| #include <time.h> |
| #include "des_ver.h" |
| |
| #ifdef OPENSSL_SYS_VMS |
| # include <types.h> |
| # include <stat.h> |
| #else |
| # ifndef _IRIX |
| # include <sys/types.h> |
| # endif |
| # include <sys/stat.h> |
| #endif |
| #include <openssl/des.h> |
| #include <openssl/rand.h> |
| #include <openssl/ui_compat.h> |
| |
| void usage(void); |
| void doencryption(void); |
| int uufwrite(unsigned char *data, int size, unsigned int num, FILE *fp); |
| void uufwriteEnd(FILE *fp); |
| int uufread(unsigned char *out, int size, unsigned int num, FILE *fp); |
| int uuencode(unsigned char *in, int num, unsigned char *out); |
| int uudecode(unsigned char *in, int num, unsigned char *out); |
| void DES_3cbc_encrypt(DES_cblock *input, DES_cblock *output, long length, |
| DES_key_schedule sk1, DES_key_schedule sk2, |
| DES_cblock *ivec1, DES_cblock *ivec2, int enc); |
| #ifdef OPENSSL_SYS_VMS |
| # define EXIT(a) exit(a&0x10000000L) |
| #else |
| # define EXIT(a) exit(a) |
| #endif |
| |
| #define BUFSIZE (8*1024) |
| #define VERIFY 1 |
| #define KEYSIZ 8 |
| #define KEYSIZB 1024 /* should hit tty line limit first :-) */ |
| char key[KEYSIZB + 1]; |
| int do_encrypt, longk = 0; |
| FILE *DES_IN, *DES_OUT, *CKSUM_OUT; |
| char uuname[200]; |
| unsigned char uubuf[50]; |
| int uubufnum = 0; |
| #define INUUBUFN (45*100) |
| #define OUTUUBUF (65*100) |
| unsigned char b[OUTUUBUF]; |
| unsigned char bb[300]; |
| DES_cblock cksum = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; |
| |
| char cksumname[200] = ""; |
| |
| int vflag, cflag, eflag, dflag, kflag, bflag, fflag, sflag, uflag, flag3, |
| hflag, error; |
| |
| int main(int argc, char **argv) |
| { |
| int i; |
| struct stat ins, outs; |
| char *p; |
| char *in = NULL, *out = NULL; |
| |
| vflag = cflag = eflag = dflag = kflag = hflag = bflag = fflag = sflag = |
| uflag = flag3 = 0; |
| error = 0; |
| memset(key, 0, sizeof(key)); |
| |
| for (i = 1; i < argc; i++) { |
| p = argv[i]; |
| if ((p[0] == '-') && (p[1] != '\0')) { |
| p++; |
| while (*p) { |
| switch (*(p++)) { |
| case '3': |
| flag3 = 1; |
| longk = 1; |
| break; |
| case 'c': |
| cflag = 1; |
| strncpy(cksumname, p, 200); |
| cksumname[sizeof(cksumname) - 1] = '\0'; |
| p += strlen(cksumname); |
| break; |
| case 'C': |
| cflag = 1; |
| longk = 1; |
| strncpy(cksumname, p, 200); |
| cksumname[sizeof(cksumname) - 1] = '\0'; |
| p += strlen(cksumname); |
| break; |
| case 'e': |
| eflag = 1; |
| break; |
| case 'v': |
| vflag = 1; |
| break; |
| case 'E': |
| eflag = 1; |
| longk = 1; |
| break; |
| case 'd': |
| dflag = 1; |
| break; |
| case 'D': |
| dflag = 1; |
| longk = 1; |
| break; |
| case 'b': |
| bflag = 1; |
| break; |
| case 'f': |
| fflag = 1; |
| break; |
| case 's': |
| sflag = 1; |
| break; |
| case 'u': |
| uflag = 1; |
| strncpy(uuname, p, 200); |
| uuname[sizeof(uuname) - 1] = '\0'; |
| p += strlen(uuname); |
| break; |
| case 'h': |
| hflag = 1; |
| break; |
| case 'k': |
| kflag = 1; |
| if ((i + 1) == argc) { |
| fputs("must have a key with the -k option\n", stderr); |
| error = 1; |
| } else { |
| int j; |
| |
| i++; |
| strncpy(key, argv[i], KEYSIZB); |
| for (j = strlen(argv[i]) - 1; j >= 0; j--) |
| argv[i][j] = '\0'; |
| } |
| break; |
| default: |
| fprintf(stderr, "'%c' unknown flag\n", p[-1]); |
| error = 1; |
| break; |
| } |
| } |
| } else { |
| if (in == NULL) |
| in = argv[i]; |
| else if (out == NULL) |
| out = argv[i]; |
| else |
| error = 1; |
| } |
| } |
| if (error) |
| usage(); |
| /*- |
| * We either |
| * do checksum or |
| * do encrypt or |
| * do decrypt or |
| * do decrypt then ckecksum or |
| * do checksum then encrypt |
| */ |
| if (((eflag + dflag) == 1) || cflag) { |
| if (eflag) |
| do_encrypt = DES_ENCRYPT; |
| if (dflag) |
| do_encrypt = DES_DECRYPT; |
| } else { |
| if (vflag) { |
| #ifndef _Windows |
| fprintf(stderr, "des(1) built with %s\n", libdes_version); |
| #endif |
| EXIT(1); |
| } else |
| usage(); |
| } |
| |
| #ifndef _Windows |
| if (vflag) |
| fprintf(stderr, "des(1) built with %s\n", libdes_version); |
| #endif |
| if ((in != NULL) && (out != NULL) && |
| #ifndef OPENSSL_SYS_MSDOS |
| (stat(in, &ins) != -1) && |
| (stat(out, &outs) != -1) && |
| (ins.st_dev == outs.st_dev) && (ins.st_ino == outs.st_ino)) |
| #else /* OPENSSL_SYS_MSDOS */ |
| (strcmp(in, out) == 0)) |
| #endif |
| { |
| fputs("input and output file are the same\n", stderr); |
| EXIT(3); |
| } |
| |
| if (!kflag) |
| if (des_read_pw_string |
| (key, KEYSIZB + 1, "Enter key:", eflag ? VERIFY : 0)) { |
| fputs("password error\n", stderr); |
| EXIT(2); |
| } |
| |
| if (in == NULL) |
| DES_IN = stdin; |
| else if ((DES_IN = fopen(in, "r")) == NULL) { |
| perror("opening input file"); |
| EXIT(4); |
| } |
| |
| CKSUM_OUT = stdout; |
| if (out == NULL) { |
| DES_OUT = stdout; |
| CKSUM_OUT = stderr; |
| } else if ((DES_OUT = fopen(out, "w")) == NULL) { |
| perror("opening output file"); |
| EXIT(5); |
| } |
| #ifdef OPENSSL_SYS_MSDOS |
| /* This should set the file to binary mode. */ |
| { |
| # include <fcntl.h> |
| if (!(uflag && dflag)) |
| setmode(fileno(DES_IN), O_BINARY); |
| if (!(uflag && eflag)) |
| setmode(fileno(DES_OUT), O_BINARY); |
| } |
| #endif |
| |
| doencryption(); |
| fclose(DES_IN); |
| fclose(DES_OUT); |
| EXIT(0); |
| } |
| |
| void usage(void) |
| { |
| char **u; |
| static const char *Usage[] = { |
| "des <options> [input-file [output-file]]", |
| "options:", |
| "-v : des(1) version number", |
| "-e : encrypt using SunOS compatible user key to DES key conversion.", |
| "-E : encrypt ", |
| "-d : decrypt using SunOS compatible user key to DES key conversion.", |
| "-D : decrypt ", |
| "-c[ckname] : generate a cbc_cksum using SunOS compatible user key to", |
| " DES key conversion and output to ckname (stdout default,", |
| " stderr if data being output on stdout). The checksum is", |
| " generated before encryption and after decryption if used", |
| " in conjunction with -[eEdD].", |
| "-C[ckname] : generate a cbc_cksum as for -c but compatible with -[ED].", |
| "-k key : use key 'key'", |
| "-h : the key that is entered will be a hexadecimal number", |
| " that is used directly as the des key", |
| "-u[uuname] : input file is uudecoded if -[dD] or output uuencoded data if -[eE]", |
| " (uuname is the filename to put in the uuencode header).", |
| "-b : encrypt using DES in ecb encryption mode, the default is cbc mode.", |
| "-3 : encrypt using triple DES encryption. This uses 2 keys", |
| " generated from the input key. If the input key is less", |
| " than 8 characters long, this is equivalent to normal", |
| " encryption. Default is triple cbc, -b makes it triple ecb.", |
| NULL |
| }; |
| for (u = (char **)Usage; *u; u++) { |
| fputs(*u, stderr); |
| fputc('\n', stderr); |
| } |
| |
| EXIT(1); |
| } |
| |
| void doencryption(void) |
| { |
| #ifdef _LIBC |
| extern unsigned long time(); |
| #endif |
| |
| register int i; |
| DES_key_schedule ks, ks2; |
| DES_cblock iv, iv2; |
| char *p; |
| int num = 0, j, k, l, rem, ll, len, last, ex = 0; |
| DES_cblock kk, k2; |
| FILE *O; |
| int Exit = 0; |
| #ifndef OPENSSL_SYS_MSDOS |
| static unsigned char buf[BUFSIZE + 8], obuf[BUFSIZE + 8]; |
| #else |
| static unsigned char *buf = NULL, *obuf = NULL; |
| |
| if (buf == NULL) { |
| if (((buf = OPENSSL_malloc(BUFSIZE + 8)) == NULL) || |
| ((obuf = OPENSSL_malloc(BUFSIZE + 8)) == NULL)) { |
| fputs("Not enough memory\n", stderr); |
| Exit = 10; |
| goto problems; |
| } |
| } |
| #endif |
| |
| if (hflag) { |
| j = (flag3 ? 16 : 8); |
| p = key; |
| for (i = 0; i < j; i++) { |
| k = 0; |
| if ((*p <= '9') && (*p >= '0')) |
| k = (*p - '0') << 4; |
| else if ((*p <= 'f') && (*p >= 'a')) |
| k = (*p - 'a' + 10) << 4; |
| else if ((*p <= 'F') && (*p >= 'A')) |
| k = (*p - 'A' + 10) << 4; |
| else { |
| fputs("Bad hex key\n", stderr); |
| Exit = 9; |
| goto problems; |
| } |
| p++; |
| if ((*p <= '9') && (*p >= '0')) |
| k |= (*p - '0'); |
| else if ((*p <= 'f') && (*p >= 'a')) |
| k |= (*p - 'a' + 10); |
| else if ((*p <= 'F') && (*p >= 'A')) |
| k |= (*p - 'A' + 10); |
| else { |
| fputs("Bad hex key\n", stderr); |
| Exit = 9; |
| goto problems; |
| } |
| p++; |
| if (i < 8) |
| kk[i] = k; |
| else |
| k2[i - 8] = k; |
| } |
| DES_set_key_unchecked(&k2, &ks2); |
| OPENSSL_cleanse(k2, sizeof(k2)); |
| } else if (longk || flag3) { |
| if (flag3) { |
| DES_string_to_2keys(key, &kk, &k2); |
| DES_set_key_unchecked(&k2, &ks2); |
| OPENSSL_cleanse(k2, sizeof(k2)); |
| } else |
| DES_string_to_key(key, &kk); |
| } else |
| for (i = 0; i < KEYSIZ; i++) { |
| l = 0; |
| k = key[i]; |
| for (j = 0; j < 8; j++) { |
| if (k & 1) |
| l++; |
| k >>= 1; |
| } |
| if (l & 1) |
| kk[i] = key[i] & 0x7f; |
| else |
| kk[i] = key[i] | 0x80; |
| } |
| |
| DES_set_key_unchecked(&kk, &ks); |
| OPENSSL_cleanse(key, sizeof(key)); |
| OPENSSL_cleanse(kk, sizeof(kk)); |
| /* woops - A bug that does not showup under unix :-( */ |
| memset(iv, 0, sizeof(iv)); |
| memset(iv2, 0, sizeof(iv2)); |
| |
| l = 1; |
| rem = 0; |
| /* first read */ |
| if (eflag || (!dflag && cflag)) { |
| for (;;) { |
| num = l = fread(&(buf[rem]), 1, BUFSIZE, DES_IN); |
| l += rem; |
| num += rem; |
| if (l < 0) { |
| perror("read error"); |
| Exit = 6; |
| goto problems; |
| } |
| |
| rem = l % 8; |
| len = l - rem; |
| if (feof(DES_IN)) { |
| for (i = 7 - rem; i > 0; i--) { |
| if (RAND_pseudo_bytes(buf + l++, 1) < 0) |
| goto problems; |
| } |
| buf[l++] = rem; |
| ex = 1; |
| len += rem; |
| } else |
| l -= rem; |
| |
| if (cflag) { |
| DES_cbc_cksum(buf, &cksum, (long)len, &ks, &cksum); |
| if (!eflag) { |
| if (feof(DES_IN)) |
| break; |
| else |
| continue; |
| } |
| } |
| |
| if (bflag && !flag3) |
| for (i = 0; i < l; i += 8) |
| DES_ecb_encrypt((DES_cblock *)&(buf[i]), |
| (DES_cblock *)&(obuf[i]), |
| &ks, do_encrypt); |
| else if (flag3 && bflag) |
| for (i = 0; i < l; i += 8) |
| DES_ecb2_encrypt((DES_cblock *)&(buf[i]), |
| (DES_cblock *)&(obuf[i]), |
| &ks, &ks2, do_encrypt); |
| else if (flag3 && !bflag) { |
| char tmpbuf[8]; |
| |
| if (rem) |
| memcpy(tmpbuf, &(buf[l]), (unsigned int)rem); |
| DES_3cbc_encrypt((DES_cblock *)buf, (DES_cblock *)obuf, |
| (long)l, ks, ks2, &iv, &iv2, do_encrypt); |
| if (rem) |
| memcpy(&(buf[l]), tmpbuf, (unsigned int)rem); |
| } else { |
| DES_cbc_encrypt(buf, obuf, (long)l, &ks, &iv, do_encrypt); |
| if (l >= 8) |
| memcpy(iv, &(obuf[l - 8]), 8); |
| } |
| if (rem) |
| memcpy(buf, &(buf[l]), (unsigned int)rem); |
| |
| i = 0; |
| while (i < l) { |
| if (uflag) |
| j = uufwrite(obuf, 1, (unsigned int)l - i, DES_OUT); |
| else |
| j = fwrite(obuf, 1, (unsigned int)l - i, DES_OUT); |
| if (j == -1) { |
| perror("Write error"); |
| Exit = 7; |
| goto problems; |
| } |
| i += j; |
| } |
| if (feof(DES_IN)) { |
| if (uflag) |
| uufwriteEnd(DES_OUT); |
| break; |
| } |
| } |
| } else { /* decrypt */ |
| |
| ex = 1; |
| for (;;) { |
| if (ex) { |
| if (uflag) |
| l = uufread(buf, 1, BUFSIZE, DES_IN); |
| else |
| l = fread(buf, 1, BUFSIZE, DES_IN); |
| ex = 0; |
| rem = l % 8; |
| l -= rem; |
| } |
| if (l < 0) { |
| perror("read error"); |
| Exit = 6; |
| goto problems; |
| } |
| |
| if (bflag && !flag3) |
| for (i = 0; i < l; i += 8) |
| DES_ecb_encrypt((DES_cblock *)&(buf[i]), |
| (DES_cblock *)&(obuf[i]), |
| &ks, do_encrypt); |
| else if (flag3 && bflag) |
| for (i = 0; i < l; i += 8) |
| DES_ecb2_encrypt((DES_cblock *)&(buf[i]), |
| (DES_cblock *)&(obuf[i]), |
| &ks, &ks2, do_encrypt); |
| else if (flag3 && !bflag) { |
| DES_3cbc_encrypt((DES_cblock *)buf, (DES_cblock *)obuf, |
| (long)l, ks, ks2, &iv, &iv2, do_encrypt); |
| } else { |
| DES_cbc_encrypt(buf, obuf, (long)l, &ks, &iv, do_encrypt); |
| if (l >= 8) |
| memcpy(iv, &(buf[l - 8]), 8); |
| } |
| |
| if (uflag) |
| ll = uufread(&(buf[rem]), 1, BUFSIZE, DES_IN); |
| else |
| ll = fread(&(buf[rem]), 1, BUFSIZE, DES_IN); |
| ll += rem; |
| rem = ll % 8; |
| ll -= rem; |
| if (feof(DES_IN) && (ll == 0)) { |
| last = obuf[l - 1]; |
| |
| if ((last > 7) || (last < 0)) { |
| fputs("The file was not decrypted correctly.\n", stderr); |
| Exit = 8; |
| last = 0; |
| } |
| l = l - 8 + last; |
| } |
| i = 0; |
| if (cflag) |
| DES_cbc_cksum(obuf, |
| (DES_cblock *)cksum, (long)l / 8 * 8, &ks, |
| (DES_cblock *)cksum); |
| while (i != l) { |
| j = fwrite(obuf, 1, (unsigned int)l - i, DES_OUT); |
| if (j == -1) { |
| perror("Write error"); |
| Exit = 7; |
| goto problems; |
| } |
| i += j; |
| } |
| l = ll; |
| if ((l == 0) && feof(DES_IN)) |
| break; |
| } |
| } |
| if (cflag) { |
| l = 0; |
| if (cksumname[0] != '\0') { |
| if ((O = fopen(cksumname, "w")) != NULL) { |
| CKSUM_OUT = O; |
| l = 1; |
| } |
| } |
| for (i = 0; i < 8; i++) |
| fprintf(CKSUM_OUT, "%02X", cksum[i]); |
| fprintf(CKSUM_OUT, "\n"); |
| if (l) |
| fclose(CKSUM_OUT); |
| } |
| problems: |
| OPENSSL_cleanse(buf, sizeof(buf)); |
| OPENSSL_cleanse(obuf, sizeof(obuf)); |
| OPENSSL_cleanse(&ks, sizeof(ks)); |
| OPENSSL_cleanse(&ks2, sizeof(ks2)); |
| OPENSSL_cleanse(iv, sizeof(iv)); |
| OPENSSL_cleanse(iv2, sizeof(iv2)); |
| OPENSSL_cleanse(kk, sizeof(kk)); |
| OPENSSL_cleanse(k2, sizeof(k2)); |
| OPENSSL_cleanse(uubuf, sizeof(uubuf)); |
| OPENSSL_cleanse(b, sizeof(b)); |
| OPENSSL_cleanse(bb, sizeof(bb)); |
| OPENSSL_cleanse(cksum, sizeof(cksum)); |
| if (Exit) |
| EXIT(Exit); |
| } |
| |
| /* We ignore this parameter but it should be > ~50 I believe */ |
| int uufwrite(unsigned char *data, int size, unsigned int num, FILE *fp) |
| { |
| int i, j, left, rem, ret = num; |
| static int start = 1; |
| |
| if (start) { |
| fprintf(fp, "begin 600 %s\n", |
| (uuname[0] == '\0') ? "text.d" : uuname); |
| start = 0; |
| } |
| |
| if (uubufnum) { |
| if (uubufnum + num < 45) { |
| memcpy(&(uubuf[uubufnum]), data, (unsigned int)num); |
| uubufnum += num; |
| return (num); |
| } else { |
| i = 45 - uubufnum; |
| memcpy(&(uubuf[uubufnum]), data, (unsigned int)i); |
| j = uuencode((unsigned char *)uubuf, 45, b); |
| fwrite(b, 1, (unsigned int)j, fp); |
| uubufnum = 0; |
| data += i; |
| num -= i; |
| } |
| } |
| |
| for (i = 0; i < (((int)num) - INUUBUFN); i += INUUBUFN) { |
| j = uuencode(&(data[i]), INUUBUFN, b); |
| fwrite(b, 1, (unsigned int)j, fp); |
| } |
| rem = (num - i) % 45; |
| left = (num - i - rem); |
| if (left) { |
| j = uuencode(&(data[i]), left, b); |
| fwrite(b, 1, (unsigned int)j, fp); |
| i += left; |
| } |
| if (i != num) { |
| memcpy(uubuf, &(data[i]), (unsigned int)rem); |
| uubufnum = rem; |
| } |
| return (ret); |
| } |
| |
| void uufwriteEnd(FILE *fp) |
| { |
| int j; |
| static const char *end = " \nend\n"; |
| |
| if (uubufnum != 0) { |
| uubuf[uubufnum] = '\0'; |
| uubuf[uubufnum + 1] = '\0'; |
| uubuf[uubufnum + 2] = '\0'; |
| j = uuencode(uubuf, uubufnum, b); |
| fwrite(b, 1, (unsigned int)j, fp); |
| } |
| fwrite(end, 1, strlen(end), fp); |
| } |
| |
| /* |
| * int size: should always be > ~ 60; I actually ignore this parameter :-) |
| */ |
| int uufread(unsigned char *out, int size, unsigned int num, FILE *fp) |
| { |
| int i, j, tot; |
| static int done = 0; |
| static int valid = 0; |
| static int start = 1; |
| |
| if (start) { |
| for (;;) { |
| b[0] = '\0'; |
| fgets((char *)b, 300, fp); |
| if (b[0] == '\0') { |
| fprintf(stderr, "no 'begin' found in uuencoded input\n"); |
| return (-1); |
| } |
| if (strncmp((char *)b, "begin ", 6) == 0) |
| break; |
| } |
| start = 0; |
| } |
| if (done) |
| return (0); |
| tot = 0; |
| if (valid) { |
| memcpy(out, bb, (unsigned int)valid); |
| tot = valid; |
| valid = 0; |
| } |
| for (;;) { |
| b[0] = '\0'; |
| fgets((char *)b, 300, fp); |
| if (b[0] == '\0') |
| break; |
| i = strlen((char *)b); |
| if ((b[0] == 'e') && (b[1] == 'n') && (b[2] == 'd')) { |
| done = 1; |
| while (!feof(fp)) { |
| fgets((char *)b, 300, fp); |
| } |
| break; |
| } |
| i = uudecode(b, i, bb); |
| if (i < 0) |
| break; |
| if ((i + tot + 8) > num) { |
| /* num to copy to make it a multiple of 8 */ |
| j = (num / 8 * 8) - tot - 8; |
| memcpy(&(out[tot]), bb, (unsigned int)j); |
| tot += j; |
| memcpy(bb, &(bb[j]), (unsigned int)i - j); |
| valid = i - j; |
| break; |
| } |
| memcpy(&(out[tot]), bb, (unsigned int)i); |
| tot += i; |
| } |
| return (tot); |
| } |
| |
| #define ccc2l(c,l) (l =((DES_LONG)(*((c)++)))<<16, \ |
| l|=((DES_LONG)(*((c)++)))<< 8, \ |
| l|=((DES_LONG)(*((c)++)))) |
| |
| #define l2ccc(l,c) (*((c)++)=(unsigned char)(((l)>>16)&0xff), \ |
| *((c)++)=(unsigned char)(((l)>> 8)&0xff), \ |
| *((c)++)=(unsigned char)(((l) )&0xff)) |
| |
| int uuencode(unsigned char *in, int num, unsigned char *out) |
| { |
| int j, i, n, tot = 0; |
| DES_LONG l; |
| register unsigned char *p; |
| p = out; |
| |
| for (j = 0; j < num; j += 45) { |
| if (j + 45 > num) |
| i = (num - j); |
| else |
| i = 45; |
| *(p++) = i + ' '; |
| for (n = 0; n < i; n += 3) { |
| ccc2l(in, l); |
| *(p++) = ((l >> 18) & 0x3f) + ' '; |
| *(p++) = ((l >> 12) & 0x3f) + ' '; |
| *(p++) = ((l >> 6) & 0x3f) + ' '; |
| *(p++) = ((l) & 0x3f) + ' '; |
| tot += 4; |
| } |
| *(p++) = '\n'; |
| tot += 2; |
| } |
| *p = '\0'; |
| l = 0; |
| return (tot); |
| } |
| |
| int uudecode(unsigned char *in, int num, unsigned char *out) |
| { |
| int j, i, k; |
| unsigned int n = 0, space = 0; |
| DES_LONG l; |
| DES_LONG w, x, y, z; |
| unsigned int blank = (unsigned int)'\n' - ' '; |
| |
| for (j = 0; j < num;) { |
| n = *(in++) - ' '; |
| if (n == blank) { |
| n = 0; |
| in--; |
| } |
| if (n > 60) { |
| fprintf(stderr, "uuencoded line length too long\n"); |
| return (-1); |
| } |
| j++; |
| |
| for (i = 0; i < n; j += 4, i += 3) { |
| /* |
| * the following is for cases where spaces are removed from |
| * lines. |
| */ |
| if (space) { |
| w = x = y = z = 0; |
| } else { |
| w = *(in++) - ' '; |
| x = *(in++) - ' '; |
| y = *(in++) - ' '; |
| z = *(in++) - ' '; |
| } |
| if ((w > 63) || (x > 63) || (y > 63) || (z > 63)) { |
| k = 0; |
| if (w == blank) |
| k = 1; |
| if (x == blank) |
| k = 2; |
| if (y == blank) |
| k = 3; |
| if (z == blank) |
| k = 4; |
| space = 1; |
| switch (k) { |
| case 1: |
| w = 0; |
| in--; |
| case 2: |
| x = 0; |
| in--; |
| case 3: |
| y = 0; |
| in--; |
| case 4: |
| z = 0; |
| in--; |
| break; |
| case 0: |
| space = 0; |
| fprintf(stderr, "bad uuencoded data values\n"); |
| w = x = y = z = 0; |
| return (-1); |
| break; |
| } |
| } |
| l = (w << 18) | (x << 12) | (y << 6) | (z); |
| l2ccc(l, out); |
| } |
| if (*(in++) != '\n') { |
| fprintf(stderr, "missing nl in uuencoded line\n"); |
| w = x = y = z = 0; |
| return (-1); |
| } |
| j++; |
| } |
| *out = '\0'; |
| w = x = y = z = 0; |
| return (n); |
| } |
