![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to armor.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [PGP] / pgp / src|
Return to armor.c CVS log | Up to [PGP] / pgp / src |
1.1 ! root 1: /* armor.c - ASCII/binary encoding/decoding based partly on PEM RFC1113. ! 2: PGP: Pretty Good(tm) Privacy - public key cryptography for the masses. ! 3: ! 4: (c) Copyright 1990-1992 by Philip Zimmermann. All rights reserved. ! 5: The author assumes no liability for damages resulting from the use ! 6: of this software, even if the damage results from defects in this ! 7: software. No warranty is expressed or implied. ! 8: ! 9: All the source code Philip Zimmermann wrote for PGP is available for ! 10: free under the "Copyleft" General Public License from the Free ! 11: Software Foundation. A copy of that license agreement is included in ! 12: the source release package of PGP. Code developed by others for PGP ! 13: is also freely available. Other code that has been incorporated into ! 14: PGP from other sources was either originally published in the public ! 15: domain or was used with permission from the various authors. See the ! 16: PGP User's Guide for more complete information about licensing, ! 17: patent restrictions on certain algorithms, trademarks, copyrights, ! 18: and export controls. ! 19: */ ! 20: ! 21: #include <ctype.h> ! 22: #include <stdio.h> ! 23: #include <string.h> ! 24: #include "mpilib.h" ! 25: #include "fileio.h" ! 26: #include "mpiio.h" ! 27: #include "language.h" ! 28: #include "pgp.h" ! 29: ! 30: /* Begin PEM routines. ! 31: This converts a binary file into printable ASCII characters, in a ! 32: radix-64 form mostly compatible with the PEM RFC1113 format. ! 33: This makes it easier to send encrypted files over a 7-bit channel. ! 34: */ ! 35: ! 36: /* Index this array by a 6 bit value to get the character corresponding ! 37: * to that value. ! 38: */ ! 39: unsigned char bintoasc[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ\ ! 40: abcdefghijklmnopqrstuvwxyz0123456789+/"; ! 41: ! 42: /* Index this array by a 7 bit value to get the 6-bit binary field ! 43: * corresponding to that value. Any illegal characters return high bit set. ! 44: */ ! 45: unsigned char asctobin[] = { ! 46: 0200,0200,0200,0200,0200,0200,0200,0200, ! 47: 0200,0200,0200,0200,0200,0200,0200,0200, ! 48: 0200,0200,0200,0200,0200,0200,0200,0200, ! 49: 0200,0200,0200,0200,0200,0200,0200,0200, ! 50: 0200,0200,0200,0200,0200,0200,0200,0200, ! 51: 0200,0200,0200,0076,0200,0200,0200,0077, ! 52: 0064,0065,0066,0067,0070,0071,0072,0073, ! 53: 0074,0075,0200,0200,0200,0200,0200,0200, ! 54: 0200,0000,0001,0002,0003,0004,0005,0006, ! 55: 0007,0010,0011,0012,0013,0014,0015,0016, ! 56: 0017,0020,0021,0022,0023,0024,0025,0026, ! 57: 0027,0030,0031,0200,0200,0200,0200,0200, ! 58: 0200,0032,0033,0034,0035,0036,0037,0040, ! 59: 0041,0042,0043,0044,0045,0046,0047,0050, ! 60: 0051,0052,0053,0054,0055,0056,0057,0060, ! 61: 0061,0062,0063,0200,0200,0200,0200,0200 ! 62: }; ! 63: static long infile_line; /* Current line number for mult decodes */ ! 64: ! 65: /************************************************************************/ ! 66: ! 67: /* CRC Routines. */ ! 68: /* These CRC functions are derived from code in chapter 19 of the book ! 69: "C Programmer's Guide to Serial Communications", by Joe Campbell. ! 70: Generalized to any CRC width by Philip Zimmermann. ! 71: */ ! 72: ! 73: #define byte unsigned char ! 74: ! 75: #define CRCBITS 24 /* may be 16, 24, or 32 */ ! 76: /* #define crcword unsigned short */ /* if CRCBITS is 16 */ ! 77: #define crcword unsigned long /* if CRCBITS is 24 or 32 */ ! 78: /* #define maskcrc(crc) ((crcword)(crc)) */ /* if CRCBITS is 16 or 32 */ ! 79: #define maskcrc(crc) ((crc) & 0xffffffL) /* if CRCBITS is 24 */ ! 80: #define CRCHIBIT ((crcword) (1L<<(CRCBITS-1))) /* 0x8000 if CRCBITS is 16 */ ! 81: #define CRCSHIFTS (CRCBITS-8) ! 82: ! 83: /* Notes on making a good 24-bit CRC-- ! 84: The primitive irreducible polynomial of degree 23 over GF(2), ! 85: 040435651 (octal), comes from Appendix C of "Error Correcting Codes, ! 86: 2nd edition" by Peterson and Weldon, page 490. This polynomial was ! 87: chosen for its uniform density of ones and zeros, which has better ! 88: error detection properties than polynomials with a minimal number of ! 89: nonzero terms. Multiplying this primitive degree-23 polynomial by ! 90: the polynomial x+1 yields the additional property of detecting any ! 91: odd number of bits in error, which means it adds parity. This ! 92: approach was recommended by Neal Glover. ! 93: ! 94: To multiply the polynomial 040435651 by x+1, shift it left 1 bit and ! 95: bitwise add (xor) the unshifted version back in. Dropping the unused ! 96: upper bit (bit 24) produces a CRC-24 generator bitmask of 041446373 ! 97: octal, or 0x864cfb hex. ! 98: ! 99: You can detect spurious leading zeros or framing errors in the ! 100: message by initializing the CRC accumulator to some agreed-upon ! 101: nonzero "random-like" value, but this is a bit nonstandard. ! 102: */ ! 103: ! 104: #define CCITTCRC 0x1021 /* CCITT's 16-bit CRC generator polynomial */ ! 105: #define PRZCRC 0x864cfbL /* PRZ's 24-bit CRC generator polynomial */ ! 106: #define CRCINIT 0xB704CEL /* Init value for CRC accumulator */ ! 107: ! 108: crcword crctable[256]; /* Table for speeding up CRC's */ ! 109: ! 110: /* crchware simulates CRC hardware circuit. Generates true CRC ! 111: directly, without requiring extra NULL bytes to be appended ! 112: to the message. ! 113: Returns new updated CRC accumulator. ! 114: */ ! 115: crcword crchware(byte ch, crcword poly, crcword accum) ! 116: { int i; ! 117: crcword data; ! 118: data = ch; ! 119: data <<= CRCSHIFTS; /* shift data to line up with MSB of accum */ ! 120: i = 8; /* counts 8 bits of data */ ! 121: do ! 122: { /* if MSB of (data XOR accum) is TRUE, shift and subtract poly */ ! 123: if ((data ^ accum) & CRCHIBIT) ! 124: accum = (accum<<1) ^ poly; ! 125: else ! 126: accum <<= 1; ! 127: data <<= 1; ! 128: } while (--i); /* counts 8 bits of data */ ! 129: return (maskcrc(accum)); ! 130: } /* crchware */ ! 131: ! 132: ! 133: /* mk_crctbl derives a CRC lookup table from the CRC polynomial. ! 134: The table is used later by crcupdate function given below. ! 135: mk_crctbl only needs to be called once at the dawn of time. ! 136: */ ! 137: void mk_crctbl(crcword poly) ! 138: { int i; ! 139: for (i=0; i<256; i++) ! 140: crctable[i] = crchware((byte) i, poly, 0); ! 141: } /* mk_crctbl */ ! 142: ! 143: ! 144: /* crcupdate calculates a CRC using the fast table-lookup method. ! 145: Returns new updated CRC accumulator. ! 146: */ ! 147: crcword crcupdate(byte data, register crcword accum) ! 148: { byte combined_value; ! 149: ! 150: /* XOR the MSByte of the accum with the data byte */ ! 151: combined_value = (accum >> CRCSHIFTS) ^ data; ! 152: accum = (accum << 8) ^ crctable[combined_value]; ! 153: return (maskcrc(accum)); ! 154: } /* crcupdate */ ! 155: ! 156: /* Initialize the CRC table using our codes */ ! 157: void init_crc() ! 158: { mk_crctbl(PRZCRC); ! 159: } ! 160: ! 161: ! 162: /************************************************************************/ ! 163: ! 164: ! 165: /* ENC is the basic 1 character encoding function to make a char printing */ ! 166: #define ENC(c) ((int)bintoasc[((c) & 077)]) ! 167: #define PAD '=' ! 168: ! 169: /* ! 170: * output one group of up to 3 bytes, pointed at by p, on file f. ! 171: * if fewer than 3 are present, the 1 or two extras must be zeros. ! 172: */ ! 173: static void outdec(char *p, FILE *f, int count) ! 174: { ! 175: int c1, c2, c3, c4; ! 176: ! 177: c1 = *p >> 2; ! 178: c2 = ((*p << 4) & 060) | ((p[1] >> 4) & 017); ! 179: c3 = ((p[1] << 2) & 074) | ((p[2] >> 6) & 03); ! 180: c4 = p[2] & 077; ! 181: putc(ENC(c1), f); ! 182: putc(ENC(c2), f); ! 183: if (count == 1) ! 184: { putc(PAD, f); ! 185: putc(PAD, f); ! 186: } ! 187: else ! 188: { putc(ENC(c3), f); ! 189: if (count == 2) ! 190: putc(PAD, f); ! 191: else ! 192: putc(ENC(c4), f); ! 193: } ! 194: } /* outdec */ ! 195: ! 196: ! 197: /* Output the CRC value, MSB first per normal CRC conventions */ ! 198: static void outcrc (word32 crc, FILE *outFile) ! 199: { /* Output crc */ ! 200: char crcbuf[4]; ! 201: crcbuf[0] = (crc>>16) & 0xff; ! 202: crcbuf[1] = (crc>>8) & 0xff; ! 203: crcbuf[2] = (crc>>0) & 0xff; ! 204: putc(PAD,outFile); ! 205: outdec (crcbuf,outFile,3); ! 206: putc('\n',outFile); ! 207: } /* outcrc */ ! 208: ! 209: /* Return filename for output (text mode), but replace last letter of ! 210: * filename with the ascii for num (last two letters if num > 10). ! 211: */ ! 212: static char *numFilename( char *fname, int num) ! 213: { static char fnamenum[MAX_PATH]; ! 214: int len; ! 215: ! 216: strcpy (fnamenum, fname); ! 217: len = strlen (fnamenum); ! 218: if (num < 10) ! 219: fnamenum[len-1] = '0' + num; ! 220: else /* If num > 100, this will be slightly screwy */ ! 221: { fnamenum[len-2] = '0' + (num / 10); ! 222: fnamenum[len-1] = '0' + (num % 10); ! 223: } ! 224: return(fnamenum); ! 225: } ! 226: ! 227: /* Encode a file in sections. 64 ASCII bytes * 720 lines = 46K, ! 228: recommended max. Usenet message size is 50K so this leaves a nice ! 229: margin for .signature. In the interests of orthogonality and ! 230: programmer laziness no check is made for a message containing only ! 231: a few lines (or even just an 'end') after a section break. ! 232: */ ! 233: #define LINE_LEN 48L ! 234: int pem_lines = 720; ! 235: #define BYTES_PER_SECTION (LINE_LEN * pem_lines) ! 236: ! 237: extern boolean verbose; /* Undocumented command mode in PGP.C */ ! 238: extern boolean filter_mode; ! 239: ! 240: /* ! 241: * Copy from infilename to outfilename, PEM encoding as you go along, ! 242: * and with breaks every ! 243: * pem_lines lines. ! 244: */ ! 245: int pem_file(char *infilename, char *outfilename) ! 246: { ! 247: char buffer[80]; ! 248: int i,bytesRead,lines = 0; ! 249: int noSections, currentSection = 1; ! 250: long fileLen; ! 251: crcword crc; ! 252: FILE *inFile, *outFile; ! 253: char *blocktype = "MESSAGE"; ! 254: ! 255: if (verbose) ! 256: fprintf(pgpout,PSTR("Converting output to ASCII armor format.\n")); ! 257: ! 258: /* open input file as binary */ ! 259: if ((inFile = fopen(infilename,"rb")) == NULL) ! 260: { ! 261: return(1); ! 262: } ! 263: ! 264: if (filter_mode || pem_lines == 0) ! 265: noSections = 1; ! 266: else ! 267: { /* Evaluate how many parts this file will comprise */ ! 268: fseek(inFile,0L,SEEK_END); ! 269: fileLen = ftell(inFile); ! 270: rewind(inFile); ! 271: noSections = (fileLen + BYTES_PER_SECTION - 1) / BYTES_PER_SECTION; ! 272: } ! 273: ! 274: if (noSections > 1) ! 275: { force_extension(outfilename, ASC_EXTENSION); ! 276: outFile = fopen (numFilename (outfilename, 1), "w"); ! 277: } ! 278: else ! 279: outFile = fopen(outfilename,"w"); ! 280: ! 281: if (outFile == NULL) ! 282: { fclose(inFile); ! 283: return(1); ! 284: } ! 285: ! 286: if (noSections == 1) ! 287: { ! 288: byte ctb = 0; ! 289: ctb = getc(inFile); ! 290: if (is_ctb_type(ctb, CTB_CERT_PUBKEY_TYPE)) ! 291: blocktype = "PUBLIC KEY BLOCK"; ! 292: fprintf (outFile, "-----BEGIN PGP %s-----\n",blocktype); ! 293: rewind(inFile); ! 294: } ! 295: else ! 296: fprintf (outFile, "-----BEGIN PGP MESSAGE, PART %02d/%02d-----\n", ! 297: 1, noSections); ! 298: fprintf (outFile, "Version: %s\n",rel_version); ! 299: fprintf (outFile, "\n"); ! 300: ! 301: init_crc(); ! 302: crc = CRCINIT; ! 303: ! 304: while((bytesRead = fread(buffer,1,LINE_LEN,inFile)) > 0) ! 305: { /* Munge up LINE_LEN characters */ ! 306: if (bytesRead < LINE_LEN) ! 307: fill0 (buffer+bytesRead, LINE_LEN-bytesRead); ! 308: ! 309: for (i=0; i<bytesRead-2; i+=3) { ! 310: crc = crcupdate(buffer[i],crc); ! 311: crc = crcupdate(buffer[i+1],crc); ! 312: crc = crcupdate(buffer[i+2],crc); ! 313: outdec(buffer+i,outFile,3); ! 314: } ! 315: ! 316: if (i<bytesRead) { ! 317: outdec(buffer+i,outFile,bytesRead-i); ! 318: while (i<bytesRead) ! 319: crc = crcupdate(buffer[i++],crc); ! 320: } ! 321: putc('\n',outFile); ! 322: ! 323: if (++lines == pem_lines && !filter_mode && currentSection < noSections) ! 324: { lines = 0; ! 325: outcrc (crc, outFile); ! 326: fprintf(outFile,"-----END PGP MESSAGE, PART %02d/%02d-----\n\n", ! 327: currentSection, noSections); ! 328: fclose (outFile); ! 329: outFile = fopen (numFilename (outfilename, ++currentSection), "w"); ! 330: fprintf(outFile,"-----BEGIN PGP MESSAGE, PART %02d/%02d-----\n", ! 331: currentSection, noSections); ! 332: fprintf(outFile,"\n"); ! 333: crc = CRCINIT; ! 334: } ! 335: } ! 336: outcrc (crc, outFile); ! 337: ! 338: if (noSections == 1) ! 339: fprintf (outFile, "-----END PGP %s-----\n\n",blocktype); ! 340: else ! 341: fprintf(outFile,"-----END PGP MESSAGE, PART %02d/%02d-----\n\n", ! 342: noSections, noSections); ! 343: ! 344: /* Done */ ! 345: if (ferror(outFile) || fclose(outFile)) ! 346: return(-1); ! 347: fclose(inFile); ! 348: ! 349: if (filter_mode) ! 350: return(0); ! 351: ! 352: if (noSections == 1) ! 353: fprintf (pgpout, PSTR("\nTransport armor file: %s\n"), outfilename); ! 354: else ! 355: { int i; ! 356: fprintf (pgpout, PSTR("\nTransport armor files: ")); ! 357: for (i=1; i<=noSections; ++i) ! 358: fprintf (pgpout, "%s%s", numFilename(outfilename,i), ! 359: i==noSections?"\n":", "); ! 360: } ! 361: return(0); ! 362: } /* pem_file */ ! 363: ! 364: ! 365: ! 366: ! 367: ! 368: /* End PEM encode routines. */ ! 369: ! 370: /* PEM decode routines. ! 371: */ ! 372: ! 373: #define MAX_RETRY_LINES 100 ! 374: ! 375: /* Strip trailing spaces and CR characters */ ! 376: void ! 377: strip_trailing (char *buf) ! 378: { ! 379: char *bp = buf; ! 380: while (*bp++ != '\n') /* Find end of line */ ! 381: ; ! 382: --bp; --bp; /* And back up... */ ! 383: /* Back up over spaces & CR */ ! 384: while (bp >= buf && (*bp == ' ' || *bp == '\r')) ! 385: --bp; ! 386: bp[1] = '\n'; /* Terminate line cleanly */ ! 387: bp[2] = '\0'; ! 388: } ! 389: ! 390: ! 391: int dpem_buffer(char *inbuf, char *outbuf, int *outlength) ! 392: { ! 393: unsigned char *bp; ! 394: int length; ! 395: unsigned int c1,c2,c3,c4; ! 396: register int j; ! 397: ! 398: length = 0; ! 399: bp = (unsigned char *)inbuf; ! 400: ! 401: /* FOUR input characters go into each THREE output charcters */ ! 402: ! 403: while (*bp!='\0' && *bp!='\n' && *bp!='\r') ! 404: { if (*bp&0x80 || (c1=asctobin[*bp])&0x80) ! 405: return -1; ! 406: ++bp; ! 407: if (*bp&0x80 || (c2=asctobin[*bp])&0x80) ! 408: return -1; ! 409: if (*++bp == PAD) ! 410: { c3 = c4 = 0; ! 411: length += 1; ! 412: if (*++bp != PAD) ! 413: return -1; ! 414: } ! 415: else if (*bp&0x80 || (c3=asctobin[*bp])&0x80) ! 416: return -1; ! 417: else ! 418: { if (*++bp == PAD) ! 419: { c4 = 0; ! 420: length += 2; ! 421: } ! 422: else if (*bp&0x80 || (c4=asctobin[*bp])&0x80) ! 423: return -1; ! 424: else ! 425: length += 3; ! 426: } ! 427: ++bp; ! 428: j = (c1 << 2) | (c2 >> 4); ! 429: *outbuf++=j; ! 430: j = (c2 << 4) | (c3 >> 2); ! 431: *outbuf++=j; ! 432: j = (c3 << 6) | c4; ! 433: *outbuf++=j; ! 434: } ! 435: ! 436: *outlength = length; ! 437: return(0); /* normal return */ ! 438: ! 439: } /* dpem_buffer */ ! 440: ! 441: static char pemfilename[MAX_PATH]; ! 442: /* ! 443: * try to open the next file of a multi-part armored file ! 444: * the sequence number is expected at the end of the file name ! 445: */ ! 446: static FILE * ! 447: open_next() ! 448: { ! 449: char *p, *s, c; ! 450: FILE *fp; ! 451: ! 452: p = pemfilename + strlen(pemfilename); ! 453: while (--p >= pemfilename && isdigit(*p)) ! 454: { ! 455: if (*p != '9') ! 456: { ! 457: ++*p; ! 458: return(fopen(pemfilename, "r")); ! 459: } ! 460: *p = '0'; ! 461: } ! 462: ! 463: /* need an extra digit */ ! 464: if (p >= pemfilename) ! 465: { /* try replacing character ( .as0 -> .a10 ) */ ! 466: c = *p; ! 467: *p = '1'; ! 468: if ((fp = fopen(pemfilename, "r")) != NULL) ! 469: return(fp); ! 470: *p = c; /* restore original character */ ! 471: } ! 472: ++p; ! 473: for (s = p + strlen(p); s >= p; --s) ! 474: s[1] = *s; ! 475: *p = '1'; /* insert digit ( fn0 -> fn10 ) */ ! 476: ! 477: return(fopen(pemfilename, "r")); ! 478: } ! 479: ! 480: /* ! 481: * Copy from in to out, decoding as you go, with handling for multiple ! 482: * 500-line blocks of encoded data. ! 483: */ ! 484: int pemdecode(FILE *in, FILE *out) ! 485: { ! 486: char inbuf[96]; ! 487: char outbuf[64]; ! 488: ! 489: int i, n, status; ! 490: int line; ! 491: int lineCount = 0; ! 492: int section, currentSection = 1; ! 493: int noSections = 0; ! 494: int gotcrc = 0; ! 495: long crc=CRCINIT, chkcrc; ! 496: char crcbuf[4]; ! 497: ! 498: init_crc(); ! 499: ! 500: for (line = 1; ; line++) /* for each input line */ ! 501: { ! 502: if (fgets(inbuf, sizeof(inbuf), in) == NULL) ! 503: { ! 504: fprintf(pgpout,PSTR("ERROR: ASCII armor decode input ended unexpectedly!\n")); ! 505: return(18); ! 506: } ! 507: ++infile_line; ! 508: ! 509: if (currentSection!=noSections && ! 510: strncmp(inbuf,"-----END PGP MESSAGE,", 21) == 0) ! 511: { /* End of this section */ ! 512: if (gotcrc) ! 513: { if (chkcrc != crc) ! 514: { fprintf(pgpout,PSTR("ERROR: Bad ASCII armor checksum in section %d.\n"), currentSection); ! 515: return -1; ! 516: } ! 517: } ! 518: gotcrc = 0; ! 519: crc = CRCINIT; ! 520: lineCount = 0; ! 521: section = 0; ! 522: ! 523: /* Try and find start of next section */ ! 524: do ! 525: { if (fgets(inbuf,sizeof(inbuf),in) == NULL || ++lineCount == MAX_RETRY_LINES) ! 526: { FILE *nextf; ! 527: if ((nextf = open_next()) != NULL) ! 528: { ! 529: fclose(in); ! 530: in = nextf; ! 531: lineCount = 0; ! 532: continue; ! 533: } ! 534: fprintf(pgpout,PSTR("Can't find section %d.\n"),currentSection + 1); ! 535: return(-1); ! 536: } ! 537: ++infile_line; ! 538: } ! 539: while (strncmp(inbuf,"-----BEGIN PGP MESSAGE",22)); ! 540: ! 541: /* Make sure this section is the correct one */ ! 542: lineCount = 0; ! 543: if (2 != sscanf(inbuf,"-----BEGIN PGP MESSAGE, PART %d/%d", ! 544: §ion,&noSections)) ! 545: { fprintf(pgpout,PSTR("Badly formed section header, part %d.\n"), ! 546: currentSection+1); ! 547: return(-1); ! 548: } ! 549: if (section != ++currentSection) ! 550: { fprintf(pgpout,PSTR("Sections out of order, expected part %d"),currentSection); ! 551: if (section) ! 552: fprintf(pgpout,PSTR(", got part %d\n"),section); ! 553: else ! 554: fputc('\n',pgpout); ! 555: return(-1); ! 556: } ! 557: ! 558: /* Skip header after BEGIN line */ ! 559: do { ! 560: ++infile_line; ! 561: if (fgets(inbuf, sizeof inbuf, in) == NULL) ! 562: { ! 563: fprintf(pgpout,PSTR("ERROR: Hit EOF in header of section %d.\n"), ! 564: currentSection); ! 565: return(-1); ! 566: } ! 567: } while (inbuf[0] != '\n' && inbuf[0] != '\r'); ! 568: ! 569: /* Continue decoding */ ! 570: continue; ! 571: } ! 572: ! 573: /* Quit when hit the -----END PGP MESSAGE----- line or a blank, ! 574: or handle checksum */ ! 575: if (inbuf[0] == PAD) /* Checksum lines start with PAD char */ ! 576: { status = dpem_buffer (inbuf+1,crcbuf,&n); ! 577: if (status==-1 || n!=3) ! 578: { fprintf(pgpout,PSTR("ERROR: Badly formed ASCII armor checksum, line %d.\n"),line); ! 579: return -1; ! 580: } ! 581: chkcrc = (((long)crcbuf[0]<<16)&0xff0000L) + ! 582: ((crcbuf[1]<<8)&0xff00L) + (crcbuf[2]&0xffL); ! 583: gotcrc = 1; ! 584: continue; ! 585: } ! 586: if (inbuf[0] == '\n' || inbuf[0] == '\r') ! 587: { fprintf(pgpout,PSTR("WARNING: No ASCII armor `END' line.\n")); ! 588: break; ! 589: } ! 590: if (strncmp(inbuf, "-----END PGP ", 13) == 0) ! 591: break; ! 592: ! 593: status = dpem_buffer(inbuf,outbuf,&n); ! 594: ! 595: if (status == -1) ! 596: { fprintf(pgpout,PSTR("ERROR: Bad ASCII armor character, line %d.\n"), line); ! 597: return -1; ! 598: } ! 599: ! 600: if (n > sizeof outbuf) ! 601: { fprintf(pgpout,PSTR("ERROR: Bad ASCII armor line length %d on line %d.\n"), ! 602: n, line); ! 603: return -1; ! 604: } ! 605: ! 606: for (i=0; i<n; ++i) ! 607: crc = crcupdate(outbuf[i],crc); ! 608: fwrite(outbuf,1,n,out); ! 609: ! 610: } /* line */ ! 611: ! 612: if (gotcrc) ! 613: { if (chkcrc != crc) ! 614: { fprintf(pgpout,PSTR("ERROR: Bad ASCII armor checksum")); ! 615: if (noSections > 0) ! 616: fprintf(pgpout,PSTR(" in section %d"), noSections); ! 617: fputc('\n',pgpout); ! 618: return -1; ! 619: } ! 620: } ! 621: else ! 622: fprintf(pgpout,PSTR("Warning: Transport armor lacks a checksum.\n")); ! 623: ! 624: return(0); /* normal return */ ! 625: } /* pemdecode */ ! 626: ! 627: ! 628: boolean is_pemfile(char *infile) ! 629: { ! 630: FILE *in; ! 631: char inbuf[80]; ! 632: char outbuf[80]; ! 633: int i, n, status; ! 634: long il; ! 635: ! 636: if ((in = fopen(infile, "r")) == NULL) ! 637: { /* can't open file */ ! 638: return(FALSE); ! 639: } ! 640: ! 641: /* Read to infile_line before we begin looking */ ! 642: for (il=0; il<infile_line; ++il) ! 643: { ! 644: if (fgets(inbuf, sizeof inbuf, in) == NULL) ! 645: return(FALSE); ! 646: } ! 647: ! 648: /* search file for header line */ ! 649: for (i=0; i<200; i++) /* give up after 200 lines of garbage */ ! 650: { ! 651: if (fgets(inbuf, sizeof inbuf, in) == NULL) ! 652: break; ! 653: else ! 654: { ! 655: if (strncmp(inbuf, "-----BEGIN PGP ", 15) == 0) ! 656: { ! 657: do { ! 658: if (fgets(inbuf, sizeof inbuf, in) == NULL) ! 659: break; ! 660: #ifndef STRICT_PEM ! 661: if (dpem_buffer(inbuf,outbuf,&n) == 0 && n == 48) ! 662: { fclose(in); ! 663: return(TRUE); ! 664: } ! 665: #endif ! 666: strip_trailing(inbuf); ! 667: } while (inbuf[0] != '\n'); ! 668: if (fgets(inbuf, sizeof inbuf, in) == NULL) ! 669: break; ! 670: status = dpem_buffer(inbuf,outbuf,&n); ! 671: if (status < 0) ! 672: break; ! 673: fclose(in); ! 674: return(TRUE); ! 675: } ! 676: } ! 677: } ! 678: ! 679: fclose(in); ! 680: return(FALSE); ! 681: ! 682: } /* is_pemfile */ ! 683: ! 684: ! 685: int dpem_file(char *infile, char *outfile, boolean *newname) ! 686: { ! 687: FILE *in, *out; ! 688: char buf[80]; ! 689: char outbuf[80]; ! 690: int status, n; ! 691: long il, fpos; ! 692: ! 693: /* open PEM decode file as text */ ! 694: if ((in = fopen(infile, "r")) == NULL) ! 695: { ! 696: fprintf(pgpout,PSTR("ERROR: Can't find file %s\n"), infile); ! 697: return(10); ! 698: } ! 699: strcpy(pemfilename, infile); /* store filename for multi-parts */ ! 700: ! 701: /* Skip to infile_line */ ! 702: for (il=0; il<infile_line; ++il) ! 703: { ! 704: if (fgets(buf, sizeof buf, in) == NULL) ! 705: return(FALSE); ! 706: } ! 707: ! 708: /* Loop through file, searching for header. Decode anything with a ! 709: header, complain if there were no headers. */ ! 710: ! 711: /* search file for header line */ ! 712: for (;;) ! 713: { ! 714: ++infile_line; ! 715: if (fgets(buf, sizeof buf, in) == NULL) ! 716: { ! 717: fprintf(pgpout,PSTR("ERROR: No ASCII armor `BEGIN' line!\n")); ! 718: fclose(in); ! 719: return(12); ! 720: } ! 721: if (strncmp(buf, "-----BEGIN PGP ", 15) == 0) ! 722: break; ! 723: } ! 724: /* Skip header after BEGIN line */ ! 725: do { ! 726: ++infile_line; ! 727: fpos = ftell(in); ! 728: if (fgets(buf, sizeof buf, in) == NULL) ! 729: { ! 730: fprintf(pgpout,PSTR("ERROR: Hit EOF in header.\n")); ! 731: fclose(in); ! 732: return(13); ! 733: } ! 734: #ifndef STRICT_PEM ! 735: if (dpem_buffer(buf,outbuf,&n) == 0 && n == 48) ! 736: { fseek(in, fpos, SEEK_SET); ! 737: break; ! 738: } ! 739: #endif ! 740: strip_trailing(buf); ! 741: } while (buf[0] != '\n'); ! 742: ! 743: /* create output file as binary */ ! 744: out = stdout; /* !NULL */ ! 745: while (file_exists(outfile) || ((out = fopen(outfile, "wb")) == NULL)) ! 746: { if (out != NULL) ! 747: { fprintf(pgpout,PSTR("\n\007Ciphertext output file '%s' already exists. Overwrite (y/N)? "), outfile); ! 748: if (getyesno('n')) ! 749: { if ((out = fopen(outfile, "wb")) == NULL) ! 750: fprintf(pgpout,PSTR("\n\007Unable to write ciphertext output file '%s'.\n")); ! 751: else ! 752: break; ! 753: } ! 754: } ! 755: else ! 756: fprintf(pgpout,PSTR("\n\007Unable to write ciphertext output file '%s'.\n")); ! 757: fprintf(pgpout, PSTR("Enter new name for ciphertext output file: ")); ! 758: getstring( outfile, 255, TRUE ); ! 759: if (*outfile == '\0') ! 760: return(-1); ! 761: *newname = TRUE; ! 762: out = stdout; /* !NULL */ ! 763: } ! 764: ! 765: status = pemdecode(in, out); ! 766: ! 767: fflush(out); ! 768: if (ferror(out)) ! 769: status = -1; ! 770: fclose(out); ! 771: fclose(in); ! 772: return(status); ! 773: } /* dpem_file */ ! 774: ! 775: /* Entry points for generic interface names */ ! 776: int ! 777: armor_file (char *infile, char *outfile, char *filename) ! 778: { ! 779: return pem_file (infile, outfile); ! 780: } ! 781: ! 782: int ! 783: de_armor_file(char *infile, char *outfile, boolean *newname) ! 784: { ! 785: *newname = FALSE; ! 786: return dpem_file (infile, outfile, newname); ! 787: } ! 788: ! 789: boolean ! 790: is_armor_file (char *infile) ! 791: { ! 792: return is_pemfile (infile); ! 793: } ! 794:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.