X-Git-Url: https://asedeno.scripts.mit.edu/gitweb/?a=blobdiff_plain;f=sshzlib.c;h=60447fdf60766b23b923e80df7fcb7db2dcd6ac8;hb=24c9cfc800c5e81819d80fd3eda953f950e263d6;hp=91f5537f3b99226503eaba39cdd7875502518542;hpb=d02ea52abcbff2cf1bbd03344e710ffa15371f99;p=PuTTY.git diff --git a/sshzlib.c b/sshzlib.c index 91f5537f..60447fdf 100644 --- a/sshzlib.c +++ b/sshzlib.c @@ -38,9 +38,28 @@ */ #include +#include #include +#ifdef ZLIB_STANDALONE + +/* + * This module also makes a handy zlib decoding tool for when + * you're picking apart Zip files or PDFs or PNGs. If you compile + * it with ZLIB_STANDALONE defined, it builds on its own and + * becomes a command-line utility. + * + * Therefore, here I provide a self-contained implementation of the + * macros required from the rest of the PuTTY sources. + */ +#define snew(type) ( (type *) malloc(sizeof(type)) ) +#define snewn(n, type) ( (type *) malloc((n) * sizeof(type)) ) +#define sresize(x, n, type) ( (type *) realloc((x), (n) * sizeof(type)) ) +#define sfree(x) ( free((x)) ) + +#else #include "ssh.h" +#endif #ifndef FALSE #define FALSE 0 @@ -182,13 +201,20 @@ static void lz77_compress(struct LZ77Context *ctx, unsigned char *data, int len, int compress) { struct LZ77InternalContext *st = ctx->ictx; - int i, hash, distance, off, nmatch, matchlen, advance; + int i, distance, off, nmatch, matchlen, advance; struct Match defermatch, matches[MAXMATCH]; int deferchr; + assert(st->npending <= HASHCHARS); + /* * Add any pending characters from last time to the window. (We * might not be able to.) + * + * This leaves st->pending empty in the usual case (when len >= + * HASHCHARS); otherwise it leaves st->pending empty enough that + * adding all the remaining 'len' characters will not push it past + * HASHCHARS in size. */ for (i = 0; i < st->npending; i++) { unsigned char foo[HASHCHARS]; @@ -206,6 +232,7 @@ static void lz77_compress(struct LZ77Context *ctx, } st->npending -= i; + defermatch.distance = 0; /* appease compiler */ defermatch.len = 0; deferchr = '\0'; while (len > 0) { @@ -215,7 +242,7 @@ static void lz77_compress(struct LZ77Context *ctx, /* * Hash the next few characters. */ - hash = lz77_hash(data); + int hash = lz77_hash(data); /* * Look the hash up in the corresponding hash chain and see @@ -240,7 +267,6 @@ static void lz77_compress(struct LZ77Context *ctx, } } else { nmatch = 0; - hash = INVALID; } if (nmatch > 0) { @@ -314,6 +340,7 @@ static void lz77_compress(struct LZ77Context *ctx, if (len >= HASHCHARS) { lz77_advance(st, *data, lz77_hash(data)); } else { + assert(st->npending < HASHCHARS); st->pending[st->npending++] = *data; } data++; @@ -602,6 +629,8 @@ void zlib_compress_cleanup(void *handle) { struct LZ77Context *ectx = (struct LZ77Context *)handle; sfree(ectx->userdata); + sfree(ectx->ictx); + sfree(ectx); } /* @@ -678,9 +707,9 @@ int zlib_compress_block(void *handle, unsigned char *block, int len, /* * Start a Deflate (RFC1951) uncompressed block. We - * transmit a zero bit (BFINAL=0), followed by a zero - * bit and a one bit (BTYPE=00). Of course these are in - * the wrong order (00 0). + * transmit a zero bit (BFINAL=0), followed by two more + * zero bits (BTYPE=00). Of course these are in the + * wrong order (00 0), not that it matters. */ outbits(out, 0, 3); @@ -963,13 +992,15 @@ void *zlib_decompress_init(void) void zlib_decompress_cleanup(void *handle) { struct zlib_decompress_ctx *dctx = (struct zlib_decompress_ctx *)handle; - + if (dctx->currlentable && dctx->currlentable != dctx->staticlentable) zlib_freetable(&dctx->currlentable); if (dctx->currdisttable && dctx->currdisttable != dctx->staticdisttable) zlib_freetable(&dctx->currdisttable); if (dctx->lenlentable) zlib_freetable(&dctx->lenlentable); + zlib_freetable(&dctx->staticlentable); + zlib_freetable(&dctx->staticdisttable); sfree(dctx); } @@ -1023,13 +1054,14 @@ int zlib_decompress_block(void *handle, unsigned char *block, int len, { struct zlib_decompress_ctx *dctx = (struct zlib_decompress_ctx *)handle; const coderecord *rec; - int code, blktype, rep, dist, nlen; + int code, blktype, rep, dist, nlen, header; static const unsigned char lenlenmap[] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }; - dctx->outblk = NULL; - dctx->outsize = dctx->outlen = 0; + dctx->outblk = snewn(256, unsigned char); + dctx->outsize = 256; + dctx->outlen = 0; while (len > 0 || dctx->nbits > 0) { while (dctx->nbits < 24 && len > 0) { @@ -1039,10 +1071,35 @@ int zlib_decompress_block(void *handle, unsigned char *block, int len, } switch (dctx->state) { case START: - /* Expect 16-bit zlib header, which we'll dishonourably ignore. */ + /* Expect 16-bit zlib header. */ if (dctx->nbits < 16) goto finished; /* done all we can */ - EATBITS(16); + + /* + * The header is stored as a big-endian 16-bit integer, + * in contrast to the general little-endian policy in + * the rest of the format :-( + */ + header = (((dctx->bits & 0xFF00) >> 8) | + ((dctx->bits & 0x00FF) << 8)); + EATBITS(16); + + /* + * Check the header: + * + * - bits 8-11 should be 1000 (Deflate/RFC1951) + * - bits 12-15 should be at most 0111 (window size) + * - bit 5 should be zero (no dictionary present) + * - we don't care about bits 6-7 (compression rate) + * - bits 0-4 should be set up to make the whole thing + * a multiple of 31 (checksum). + */ + if ((header & 0x0F00) != 0x0800 || + (header & 0xF000) > 0x7000 || + (header & 0x0020) != 0x0000 || + (header % 31) != 0) + goto decode_error; + dctx->state = OUTSIDEBLK; break; case OUTSIDEBLK: @@ -1176,6 +1233,8 @@ int zlib_decompress_block(void *handle, unsigned char *block, int len, goto finished; if (code == -2) goto decode_error; + if (code >= 30) /* dist symbols 30 and 31 are invalid */ + goto decode_error; dctx->state = GOTDISTSYM; dctx->sym = code; break; @@ -1210,6 +1269,8 @@ int zlib_decompress_block(void *handle, unsigned char *block, int len, goto finished; nlen = dctx->bits & 0xFFFF; EATBITS(16); + if (dctx->uncomplen != (nlen ^ 0xFFFF)) + goto decode_error; if (dctx->uncomplen == 0) dctx->state = OUTSIDEBLK; /* block is empty */ else @@ -1238,8 +1299,90 @@ int zlib_decompress_block(void *handle, unsigned char *block, int len, return 0; } +#ifdef ZLIB_STANDALONE + +#include +#include + +int main(int argc, char **argv) +{ + unsigned char buf[16], *outbuf; + int ret, outlen; + void *handle; + int noheader = FALSE, opts = TRUE; + char *filename = NULL; + FILE *fp; + + while (--argc) { + char *p = *++argv; + + if (p[0] == '-' && opts) { + if (!strcmp(p, "-d")) + noheader = TRUE; + else if (!strcmp(p, "--")) + opts = FALSE; /* next thing is filename */ + else { + fprintf(stderr, "unknown command line option '%s'\n", p); + return 1; + } + } else if (!filename) { + filename = p; + } else { + fprintf(stderr, "can only handle one filename\n"); + return 1; + } + } + + handle = zlib_decompress_init(); + + if (noheader) { + /* + * Provide missing zlib header if -d was specified. + */ + zlib_decompress_block(handle, "\x78\x9C", 2, &outbuf, &outlen); + assert(outlen == 0); + } + + if (filename) + fp = fopen(filename, "rb"); + else + fp = stdin; + + if (!fp) { + assert(filename); + fprintf(stderr, "unable to open '%s'\n", filename); + return 1; + } + + while (1) { + ret = fread(buf, 1, sizeof(buf), fp); + if (ret <= 0) + break; + zlib_decompress_block(handle, buf, ret, &outbuf, &outlen); + if (outbuf) { + if (outlen) + fwrite(outbuf, 1, outlen, stdout); + sfree(outbuf); + } else { + fprintf(stderr, "decoding error\n"); + fclose(fp); + return 1; + } + } + + zlib_decompress_cleanup(handle); + + if (filename) + fclose(fp); + + return 0; +} + +#else + const struct ssh_compress ssh_zlib = { "zlib", + "zlib@openssh.com", /* delayed version */ zlib_compress_init, zlib_compress_cleanup, zlib_compress_block, @@ -1249,3 +1392,5 @@ const struct ssh_compress ssh_zlib = { zlib_disable_compression, "zlib (RFC1950)" }; + +#endif