diff -r 50606131a987 Lib/gzip.py
--- a/Lib/gzip.py	Sun Jan 13 22:24:27 2013 +0200
+++ b/Lib/gzip.py	Mon Jan 14 20:53:39 2013 +0200
@@ -65,9 +65,6 @@
     # or unsigned.
     output.write(struct.pack("<L", value))
 
-def read32(input):
-    return struct.unpack("<I", input.read(4))[0]
-
 class _PaddedFile:
     """Minimal read-only file object that prepends a string to the contents
     of an actual file. Shouldn't be used outside of gzip.py, as it lacks
@@ -282,26 +279,23 @@
         self.size = 0
 
     def _read_gzip_header(self):
+        # This function raises struct.error on incompleted header.
         magic = self.fileobj.read(2)
         if magic == b'':
-            raise EOFError("Reached EOF")
+            return False
 
         if magic != b'\037\213':
             raise OSError('Not a gzipped file')
-        method = ord( self.fileobj.read(1) )
+
+        method, flag, self.mtime = struct.unpack("<BBIxx", self.fileobj.read(8))
         if method != 8:
             raise OSError('Unknown compression method')
-        flag = ord( self.fileobj.read(1) )
-        self.mtime = read32(self.fileobj)
-        # extraflag = self.fileobj.read(1)
-        # os = self.fileobj.read(1)
-        self.fileobj.read(2)
 
         if flag & FEXTRA:
             # Read & discard the extra field, if present
-            xlen = ord(self.fileobj.read(1))
-            xlen = xlen + 256*ord(self.fileobj.read(1))
-            self.fileobj.read(xlen)
+            xlen = struct.unpack("<H", self.fileobj.read(2))
+            if len(self.fileobj.read(xlen)) < xlen:
+                raise struct.error()
         if flag & FNAME:
             # Read and discard a null-terminated string containing the filename
             while True:
@@ -315,12 +309,14 @@
                 if not s or s==b'\000':
                     break
         if flag & FHCRC:
-            self.fileobj.read(2)     # Read & discard the 16-bit header CRC
+            # Read & discard the 16-bit header CRC
+            struct.unpack("<H", self.fileobj.read(2))
 
         unused = self.fileobj.unused()
         if unused:
             uncompress = self.decompress.decompress(unused)
             self._add_read_data(uncompress)
+        return True
 
     def write(self,data):
         self._check_closed()
@@ -354,20 +350,15 @@
 
         readsize = 1024
         if size < 0:        # get the whole thing
-            try:
-                while True:
-                    self._read(readsize)
-                    readsize = min(self.max_read_chunk, readsize * 2)
-            except EOFError:
-                size = self.extrasize
+            while self._read(readsize):
+                readsize = min(self.max_read_chunk, readsize * 2)
+            size = self.extrasize
         else:               # just get some more of it
-            try:
-                while size > self.extrasize:
-                    self._read(readsize)
-                    readsize = min(self.max_read_chunk, readsize * 2)
-            except EOFError:
-                if size > self.extrasize:
+            while size > self.extrasize:
+                if not self._read(readsize):
                     size = self.extrasize
+                    break
+                readsize = min(self.max_read_chunk, readsize * 2)
 
         offset = self.offset - self.extrastart
         chunk = self.extrabuf[offset: offset + size]
@@ -385,12 +376,9 @@
         if self.extrasize <= 0 and self.fileobj is None:
             return b''
 
-        try:
-            # For certain input data, a single call to _read() may not return
-            # any data. In this case, retry until we get some data or reach EOF.
-            while self.extrasize <= 0:
-                self._read()
-        except EOFError:
+        # For certain input data, a single call to _read() may not return
+        # any data. In this case, retry until we get some data or reach EOF.
+        while self.extrasize <= 0 and self._read():
             pass
         if size < 0 or size > self.extrasize:
             size = self.extrasize
@@ -413,12 +401,9 @@
         if self.extrasize == 0:
             if self.fileobj is None:
                 return b''
-            try:
-                # Ensure that we don't return b"" if we haven't reached EOF.
-                while self.extrasize == 0:
-                    # 1024 is the same buffering heuristic used in read()
-                    self._read(max(n, 1024))
-            except EOFError:
+            # Ensure that we don't return b"" if we haven't reached EOF.
+            # 1024 is the same buffering heuristic used in read()
+            while self.extrasize == 0 and self._read(max(n, 1024)):
                 pass
         offset = self.offset - self.extrastart
         remaining = self.extrasize
@@ -431,45 +416,52 @@
 
     def _read(self, size=1024):
         if self.fileobj is None:
-            raise EOFError("Reached EOF")
+            return False
 
-        if self._new_member:
-            # If the _new_member flag is set, we have to
-            # jump to the next member, if there is one.
-            self._init_read()
-            self._read_gzip_header()
-            self.decompress = zlib.decompressobj(-zlib.MAX_WBITS)
-            self._new_member = False
+        try:
+            if self._new_member:
+                # If the _new_member flag is set, we have to
+                # jump to the next member, if there is one.
+                self._init_read()
+                if not self._read_gzip_header():
+                    return False
+                self.decompress = zlib.decompressobj(-zlib.MAX_WBITS)
+                self._new_member = False
 
-        # Read a chunk of data from the file
-        buf = self.fileobj.read(size)
+            # Read a chunk of data from the file
+            buf = self.fileobj.read(size)
 
-        # If the EOF has been reached, flush the decompression object
-        # and mark this object as finished.
+            # If the EOF has been reached, flush the decompression object
+            # and mark this object as finished.
 
-        if buf == b"":
-            uncompress = self.decompress.flush()
-            # Prepend the already read bytes to the fileobj to they can be
-            # seen by _read_eof()
-            self.fileobj.prepend(self.decompress.unused_data, True)
-            self._read_eof()
+            if buf == b"":
+                uncompress = self.decompress.flush()
+                # Prepend the already read bytes to the fileobj to they can be
+                # seen by _read_eof()
+                self.fileobj.prepend(self.decompress.unused_data, True)
+                self._read_eof()
+                self._add_read_data( uncompress )
+                return False
+
+            uncompress = self.decompress.decompress(buf)
             self._add_read_data( uncompress )
-            raise EOFError('Reached EOF')
 
-        uncompress = self.decompress.decompress(buf)
-        self._add_read_data( uncompress )
-
-        if self.decompress.unused_data != b"":
-            # Ending case: we've come to the end of a member in the file,
-            # so seek back to the start of the unused data, finish up
-            # this member, and read a new gzip header.
-            # Prepend the already read bytes to the fileobj to they can be
-            # seen by _read_eof() and _read_gzip_header()
-            self.fileobj.prepend(self.decompress.unused_data, True)
-            # Check the CRC and file size, and set the flag so we read
-            # a new member on the next call
-            self._read_eof()
-            self._new_member = True
+            if self.decompress.unused_data != b"":
+                # Ending case: we've come to the end of a member in the file,
+                # so seek back to the start of the unused data, finish up
+                # this member, and read a new gzip header.
+                # Prepend the already read bytes to the fileobj to they can be
+                # seen by _read_eof() and _read_gzip_header()
+                self.fileobj.prepend(self.decompress.unused_data, True)
+                # Check the CRC and file size, and set the flag so we read
+                # a new member on the next call
+                self._read_eof()
+                self._new_member = True
+        except struct.error:
+            # _read_gzip_header() and _read_eof() raise struct.error on EOF
+            raise EOFError("Compressed file ended before the "
+                           "end-of-stream marker was reached")
+        return True
 
     def _add_read_data(self, data):
         self.crc = zlib.crc32(data, self.crc) & 0xffffffff
@@ -484,8 +476,8 @@
         # We check the that the computed CRC and size of the
         # uncompressed data matches the stored values.  Note that the size
         # stored is the true file size mod 2**32.
-        crc32 = read32(self.fileobj)
-        isize = read32(self.fileobj)  # may exceed 2GB
+        # This function raises struct.error on incompleted footer.
+        crc32, isize = struct.unpack("<II", self.fileobj.read(8))
         if crc32 != self.crc:
             raise OSError("CRC check failed %s != %s" % (hex(crc32),
                                                          hex(self.crc)))
diff -r 50606131a987 Lib/test/test_bz2.py
--- a/Lib/test/test_bz2.py	Sun Jan 13 22:24:27 2013 +0200
+++ b/Lib/test/test_bz2.py	Mon Jan 14 20:53:39 2013 +0200
@@ -569,6 +569,20 @@
                 bz2f.seek(-150, 1)
                 self.assertEqual(bz2f.read(), self.TEXT[500-150:])
 
+    def test_read_truncated(self):
+        # drop the 48-bit eos_magic and the 32-bit crc
+        truncated = self.DATA[:-10]
+        with BZ2File(BytesIO(truncated)) as f:
+            self.assertRaises(EOFError, f.read)
+        with BZ2File(BytesIO(truncated)) as f:
+            self.assertEqual(f.read(len(self.TEXT)), self.TEXT)
+            self.assertRaises(EOFError, f.read, 1)
+        # incompleted 4-bytes file header and at least 146-bit long
+        # block header
+        for i in range(22):
+            with BZ2File(BytesIO(truncated[:i])) as f:
+                self.assertRaises(EOFError, f.read, 1)
+
 
 class BZ2CompressorTest(BaseTest):
     def testCompress(self):
diff -r 50606131a987 Lib/test/test_gzip.py
--- a/Lib/test/test_gzip.py	Sun Jan 13 22:24:27 2013 +0200
+++ b/Lib/test/test_gzip.py	Mon Jan 14 20:53:39 2013 +0200
@@ -389,6 +389,20 @@
             datac = gzip.compress(data)
             self.assertEqual(gzip.decompress(datac), data)
 
+    def test_read_truncated(self):
+        data = data1*50
+        # drop the 32-bit crc and the 32-bit file size
+        truncated = gzip.compress(data)[:-8]
+        with gzip.GzipFile(fileobj=io.BytesIO(truncated)) as f:
+            self.assertRaises(EOFError, f.read)
+        with gzip.GzipFile(fileobj=io.BytesIO(truncated)) as f:
+            self.assertEqual(f.read(len(data)), data)
+            self.assertRaises(EOFError, f.read, 1)
+        # incompleted 10-bytes header
+        for i in range(2, 10):
+            with gzip.GzipFile(fileobj=io.BytesIO(truncated[:i])) as f:
+                self.assertRaises(EOFError, f.read, 1)
+
 
 class TestOpen(BaseTest):
     def test_binary_modes(self):
diff -r 50606131a987 Lib/test/test_lzma.py
--- a/Lib/test/test_lzma.py	Sun Jan 13 22:24:27 2013 +0200
+++ b/Lib/test/test_lzma.py	Mon Jan 14 20:53:39 2013 +0200
@@ -669,6 +669,20 @@
         with LZMAFile(BytesIO(COMPRESSED_XZ[:128])) as f:
             self.assertRaises(EOFError, f.read)
 
+    def test_read_truncated(self):
+        # drop stream footer: the 32-bit crc, the 32-bit index size,
+        # the 16-bit flags, and the 16-bit magic
+        truncated = COMPRESSED_XZ[:-12]
+        with LZMAFile(BytesIO(truncated)) as f:
+            self.assertRaises(EOFError, f.read)
+        with LZMAFile(BytesIO(truncated)) as f:
+            self.assertEqual(f.read(len(INPUT)), INPUT)
+            self.assertRaises(EOFError, f.read, 1)
+        # incompleted 12-bytes header
+        for i in range(12):
+            with LZMAFile(BytesIO(truncated[:i])) as f:
+                self.assertRaises(EOFError, f.read, 1)
+
     def test_read_bad_args(self):
         f = LZMAFile(BytesIO(COMPRESSED_XZ))
         f.close()