diff -urpN john-1.7.8-jumbo-6a/src/pkzip_fmt_plug.c john-1.7.8-jumbo-6b/src/pkzip_fmt_plug.c
--- john-1.7.8-jumbo-6a/src/pkzip_fmt_plug.c	2011-09-12 14:19:35.281250000 +0000
+++ john-1.7.8-jumbo-6b/src/pkzip_fmt_plug.c	2011-09-12 18:04:50.437500000 +0000
@@ -20,7 +20,7 @@
 #include "arch.h"
 #include "misc.h"
 #include "formats.h"
-//#define USE_PKZIP_MAGIC 1
+#define USE_PKZIP_MAGIC 1
 #include "pkzip.h"
 
 #include "zlib.h"
@@ -349,11 +349,15 @@ static const char *ValidateZipContents(F
 
 	/* Even if we 'miss', we keep walking back. We 'can' miss if the CRC of file, or some other       */
 	/* binary data happens to have the 0x04034b50 signature, thus giving us a false local header hit. */
-	if (_crc == crc && _len == complen && 0x14 == version && (flags & 1) && (method == 8 || method == 0) && offex==30+namelen+exlen)
+	if (_crc == crc && _len == complen &&  (0x14 == version || 0xA == version) && (flags & 1) && (method == 8 || method == 0) && offex==30+namelen+exlen)
 		return "";
 	return "We could NOT find the internal zip data in this ZIP file";
 }
-
+static u8 *buf_copy (char *p, int len) {
+	u8 *op = mem_alloc_tiny(len, MEM_ALIGN_NONE);
+	memcpy(op, p, len);
+	return op;
+}
 static void init(struct fmt_main *pFmt)
 {
 	unsigned short n=0;
@@ -595,6 +599,32 @@ static void *get_salt(char *ciphertext)
 
 	MEM_FREE(cpalloc);
 
+	// Ok, we want to add some 'logic' to remove the magic testing, except for specific cases.
+	//  If the only file blobs we have are stored, and long blobs, then we want magic (3 file, 2 byte checksum does not need magic).
+	//  A single 1 byte file, even if deflated, we want to keep magic. (possibly).
+	j = 0;
+	for (i = 0; i < salt->cnt; ++i) {
+		if (salt->H[i].compType == 8) {
+			if (salt->cnt == 1 && salt->chk_bytes == 1)
+				j += 10;
+			else
+				break;
+		}
+		j += 1;
+	}
+	// ok, if j == 1, then we 'might' want to use magic. Otherwise, we want to 'clear' all magic values.
+	if (j >= 20) 
+		j = 0;
+	if (j && salt->chk_bytes == 2 && salt->cnt > 1)
+		j = 0;  // we do not need to use magic, on 2 or 3 stored 2 byte checksum files.  We already have 2^32 or 2^48 in the checksum checking
+	if (j && salt->chk_bytes == 1 && salt->cnt == 3)
+		j = 0;  // we do not need to use magic, on 3 stored 2 byte checksum files.  We already have 2^32 or 2^48 in the checksum checking
+	if (!j) {
+		for (i = 0; i < salt->cnt; ++i)
+			salt->H[i].magic = 0;	// remove any 'magic' logic from this hash.
+	}
+
+
 	return salt_p;
 }
 
@@ -697,16 +727,6 @@ static int cmp_exact_loadfile(int index)
 		return 1;
 	}
 
-    /* allocate inflate state */
-    strm.zalloc = Z_NULL;
-    strm.zfree = Z_NULL;
-    strm.opaque = Z_NULL;
-    strm.avail_in = 0;
-    strm.next_in = Z_NULL;
-    ret = inflateInit2(&strm, -15);
-	if (ret != Z_OK) /* if zlib is hosed, then likely there is no reason at all to continue.  Better to exit, and let the user 'fix' the system */
-		perror("Error, initializing the libz inflateInit2() system\n");
-
 	/* 'seed' the decryption with the IV. We do NOT use these bytes, they simply seed us. */
 	key0.u = K12[index*3], key1.u = K12[index*3+1], key2.u = K12[index*3+2];
 	k=12;
@@ -730,6 +750,30 @@ static int cmp_exact_loadfile(int index)
 	/* to get the data to inflate, and crc check                                                                 */
 	inp_used = 12;
 
+	if (salt->H[salt->full_zip_idx].compType == 0) {
+		// handle a stored blob (we do not have to decrypt it.
+		int avail_in;
+		crc = 0xFFFFFFFF;
+        avail_in = get_next_decrypted_block(in, CHUNK, fp, &inp_used, &key0, &key1, &key2);
+		while (avail_in) {
+			for (k = 0; k < avail_in; ++k)
+				crc = pkzip_crc32(crc,in[k]);
+			avail_in = get_next_decrypted_block(in, CHUNK, fp, &inp_used, &key0, &key1, &key2);
+		}
+		fclose(fp);
+		return ~crc == salt->crc32;
+	}
+
+    /* allocate inflate state */
+    strm.zalloc = Z_NULL;
+    strm.zfree = Z_NULL;
+    strm.opaque = Z_NULL;
+    strm.avail_in = 0;
+    strm.next_in = Z_NULL;
+    ret = inflateInit2(&strm, -15);
+	if (ret != Z_OK) /* if zlib is hosed, then likely there is no reason at all to continue.  Better to exit, and let the user 'fix' the system */
+		perror("Error, initializing the libz inflateInit2() system\n");
+
     /* decompress until deflate stream ends or end of file */
     do {
         strm.avail_in = get_next_decrypted_block(in, CHUNK, fp, &inp_used, &key0, &key1, &key2);
@@ -795,7 +839,7 @@ static int cmp_exact(char *source, int i
 	if (salt->fname == NULL) {
 		/* we have the whole zip blob in memory, simply allocate a decrypt buffer, decrypt
 		 * in one step, crc and be done with it. This is the 'trivial' type. */
-		decompBuf = mem_alloc(salt->deCompLen);
+
 		decrBuf = mem_alloc(salt->compLen-12);
 
 		key0.u = K12[index*3], key1.u = K12[index*3+1], key2.u = K12[index*3+2];
@@ -819,18 +863,28 @@ static int cmp_exact(char *source, int i
 			key2.u = pkzip_crc32 (key2.u, key1.c[KB2]);
 		} while (--k);
 
+		if (salt->H[salt->full_zip_idx].compType == 0) {
+			// handle a stored blob (we do not have to decrypt it.
+			crc = 0xFFFFFFFF;
+			for (k = 0; k < salt->compLen-12; ++k)
+				crc = pkzip_crc32(crc,decrBuf[k]);
+			MEM_FREE(decrBuf);
+			return ~crc == salt->crc32;
+		}
+
 		strm.zalloc = Z_NULL; strm.zfree = Z_NULL; strm.opaque = Z_NULL; strm.next_in = Z_NULL; strm.avail_in = 0;
 
 		ret = inflateInit2(&strm, -15); /* 'raw', since we do not have gzip header, or gzip crc. .ZIP files are 'raw' implode data. */
 		if (ret != Z_OK)
 		   perror("Error, initializing the libz inflateInit2() system\n");
 
+		decompBuf = mem_alloc(salt->deCompLen);
+
 		strm.next_in = decrBuf;
 		strm.avail_in = salt->compLen-12;
 		strm.avail_out = salt->deCompLen;
 		strm.next_out = decompBuf;
 
-
 		ret = inflate(&strm, Z_SYNC_FLUSH);
 		inflateEnd(&strm);
 		if (ret != Z_STREAM_END || strm.total_out != salt->deCompLen) {
@@ -890,11 +944,6 @@ static int isLegalUTF8_char(const u8 *so
     if (*source > 0xF4) return -1;
     return len+1;
 }
-static u8 *buf_copy (char *p, int len) {
-	u8 *op = mem_alloc_tiny(len, MEM_ALIGN_NONE);
-	memcpy(op, p, len);
-	return op;
-}
 static int validate_ascii(const u8 *out, int inplen) {
 	int i;
 	int unicode=0, utf8=0;
@@ -1310,10 +1359,40 @@ SkipKeyLoadInit:;
 			if ( (C & 6) == 6)
 				goto Failed_Bailout;
 			SigChecked = 0;
+			if ( salt->H[cur_hash_idx].compType == 0) {
+				// handle a stored file.
+				// We can ONLY deal with these IF we are handling 'magic' testing.
+
+#if USE_PKZIP_MAGIC
+				// Ok, if we have a signature, check it here, WITHOUT having to call zLib's inflate.
+				if (salt->H[cur_hash_idx].pSig->max_len) {
+					int len = salt->H[cur_hash_idx].pSig->max_len;
+					if (len > salt->H[cur_hash_idx].datlen-12)
+						len = salt->H[cur_hash_idx].datlen-12;
+					SigChecked = 1;
+					curDecryBuf[0] = C;
+					for (; e < len;) {
+						key0.u = pkzip_crc32 (key0.u, curDecryBuf[e]);
+						key1.u = (key1.u + key0.c[KB1]) * 134775813 + 1;
+						key2.u = pkzip_crc32 (key2.u, key1.c[KB2]);
+						curDecryBuf[++e] = PKZ_MULT(*b++,key2);
+					}
+
+					if (salt->H[cur_hash_idx].magic == 255) {
+						if (!validate_ascii(&curDecryBuf[5], len-5))
+							goto Failed_Bailout;
+					} else {
+						if (!CheckSigs(curDecryBuf, len, salt->H[cur_hash_idx].pSig))
+							goto Failed_Bailout;
+					}
+				}
+#endif
+				continue;
+			}
 			if ( (C & 6) == 0) {
 				// Check that checksum2 is 0 or 1.  If not, I 'think' we can be done
-				//if (C > 1)
-					//goto Failed_Bailout;
+				if (C > 1)
+					goto Failed_Bailout;
 				// now get 4 bytes.  This is the length.  It is made up of 2 16 bit values.
 				// these 2 values are checksumed, so it is easy to tell if the data is WRONG.
 				// correct data is u16_1 == (u16_2^0xFFFF)
@@ -1326,8 +1405,8 @@ SkipKeyLoadInit:;
 				}
 				v1 = curDecryBuf[1] | (((u16)curDecryBuf[2])<<8);
 				v2 = curDecryBuf[3] | (((u16)curDecryBuf[4])<<8);
-				//if (v1 != (v2^0xFFFF))
-					//goto Failed_Bailout;
+				if (v1 != (v2^0xFFFF))
+					goto Failed_Bailout;
 #if USE_PKZIP_MAGIC
 				// Ok, if we have a signature, check it here, WITHOUT having to call zLib's inflate.
 				if (salt->H[cur_hash_idx].pSig->max_len) {
diff -urpN john-1.7.8-jumbo-6a/src/zip2john.c john-1.7.8-jumbo-6b/src/zip2john.c
--- john-1.7.8-jumbo-6a/src/zip2john.c	2011-09-12 14:16:42.359375000 +0000
+++ john-1.7.8-jumbo-6b/src/zip2john.c	2011-09-12 18:19:51.609375000 +0000
@@ -68,7 +68,7 @@
 #include "misc.h"
 #include "formats.h"
 
-static int ascii_mode=0, checksum_only=0;
+static int ascii_mode=0, checksum_only=0, use_magic=1;
 static char *ascii_fname;
 
 static char *MagicTypes[]= { "", "DOC", "XLS", "DOT", "XLT", "EXE", "DLL", "ZIP", "BMP", "DIB", "GIF", "PDF", "GZ", "TGZ", "BZ2", "TZ2", "FLV", "SWF", "MP3", NULL };
@@ -247,6 +247,8 @@ static int magic_type(const char *filena
 	char *Buf = str_alloc_copy((char*)filename), *cp;
 	int i;
 
+	if (!use_magic) return 0;
+
 	strupr(Buf);
 	if (ascii_fname && !strcasecmp(Buf, ascii_fname)) 
 		return 255;
@@ -490,9 +492,15 @@ int usage() {
 	fprintf(stderr, "\t  -co This will create a 'checksum only' hash.  If there are many encrypted\n");
 	fprintf(stderr, "\t      files in the .zip file, then this may be an option, and there will be\n");
 	fprintf(stderr, "\t      enough data that false possitives will not be seen.  If the .zip is 2\n");
-	fprintf(stderr, "\t      byte checksums, and there are 8 of them, then only 1 out of 2^128 chance\n");
-	fprintf(stderr, "\t      that a bad password could sneak through.  If there are 8 1-byte hashes,\n");
-	fprintf(stderr, "\t      there is only 1 in 2^64 chance of a false positive.\n");
+	fprintf(stderr, "\t      byte checksums, and there are 3 or more of them, then we have 48 bits\n");
+	fprintf(stderr, "\t      knowledge, which 'may' be enough to crack the password, without having\n");
+	fprintf(stderr, "\t      to force the user to have the .zip file present\n");
+	fprintf(stderr, "\t  -nm DO not look for any magic file types in this zip.  If you know that\n");
+	fprintf(stderr, "\t      are files with one of the 'magic' extensions, but they are not the right\n");
+	fprintf(stderr, "\t      type files (some *.doc files that ARE NOT M$Office word documents), then\n");
+	fprintf(stderr, "\t      this switch will keep them from being detected this way.  NOTE, that\n");
+	fprintf(stderr, "\t      the 'magic' logic will only be used in john, under certain situations.\n");
+	fprintf(stderr, "\t      Most of these situations are when there are only 'stored' files in the zip\n");
 	return 0;
 }
 int zip2john(int argc, char **argv)
@@ -514,30 +522,16 @@ int zip2john(int argc, char **argv)
 			fprintf(stderr, "Using file %s as an 'ASCII' quick check file\n", ascii_fname);
 			++i;
 		}
-		if (strstr(argv[i], "-m=")) {
-			if (!strncmp(argv[i], "-m=", 3))
-				ascii_fname = &argv[i][3];
-			else if (!strncmp(argv[i], "--m=", 4))
-				ascii_fname = &argv[i][4];
-			else
-				break;
-			magic_mode = FindMagic(ascii_fname);
-			ascii_mode = 1;
-			fprintf(stderr, "Using file %s as an 'MAGIC' quick check file. Type is: %s\n", ascii_fname, MagicTypes[magic_mode]);
-			++i;
-		}
-		if (strstr(argv[i], "-M=")) {
-			magic_mode = 0xFF;
-			LoadMagicDataFName(argv[i]);
-			ascii_mode = 1;
-			fprintf(stderr, "Using file %s as an 'MAGIC' quick check file. The 'given' data is:  %s\n", ascii_fname, ToHexStr(MagicData));
-			++i;
-		}
 		else if (!strcmp(argv[i], "-co") || !strcmp(argv[i], "--co")) {
 			checksum_only = 1;
 			++i;
 			fprintf(stderr, "Outputing hashes that are 'checksum ONLY' hashes\n");
 		}
+		else if (!strcmp(argv[i], "-nm") || !strcmp(argv[i], "--nm")) {
+			use_magic = 0;
+			++i;
+			fprintf(stderr, "Ignoring any checking of file 'magic' signatures\n");
+		}
 		else if (!strncmp(argv[i], "-h", 2) || !strncmp(argv[i], "--h", 3))
 			return usage();
 		else
