ZipDirectoryReader.php

Go to the documentation of this file.

<?php
namespace Wikimedia\Mime;
 
use StatusValue;
use UnexpectedValueException;
 
class ZipDirectoryReader {
    public static function read( $fileName, $callback, $options = [] ) {
        $file = fopen( $fileName, 'r' );
        $zdr = new self( $file, $callback, $options );
        return $zdr->execute();
    }
 
    public static function readHandle( $file, $callback, $options = [] ) {
        $zdr = new self( $file, $callback, $options );
        return $zdr->execute();
    }
 
    protected $file;
 
    protected $fileLength;
 
    protected $buffer;
 
    protected $callback;
 
    protected $zip64 = false;
 
    protected $eocdr;
    protected $eocdr64;
    protected $eocdr64Locator;
 
    private const ZIP64_EXTRA_HEADER = 0x0001;
 
    private const SEGSIZE = 16384;
 
    private const GENERAL_UTF8 = 11;
 
    private const GENERAL_CD_ENCRYPTED = 13;
 
    protected function __construct( $file, $callback, $options ) {
        $this->file = $file;
        $this->callback = $callback;
 
        if ( isset( $options['zip64'] ) ) {
            $this->zip64 = $options['zip64'];
        }
    }
 
    private function execute() {
        if ( !$this->file ) {
            return StatusValue::newFatal( 'zip-file-open-error' );
        }
 
        $status = StatusValue::newGood();
        try {
            $this->readEndOfCentralDirectoryRecord();
            if ( $this->zip64 ) {
                [ $offset, $size ] = $this->findZip64CentralDirectory();
                $this->readCentralDirectory( $offset, $size );
            } else {
                if ( $this->eocdr['CD size'] == 0xffffffff
                    || $this->eocdr['CD offset'] == 0xffffffff
                    || $this->eocdr['CD entries total'] == 0xffff
                ) {
                    $this->error( 'zip-unsupported', 'Central directory header indicates ZIP64, ' .
                        'but we are in legacy mode. Rejecting this upload is necessary to avoid ' .
                        'opening vulnerabilities on clients using OpenJDK 7 or later.' );
                }
 
                [ $offset, $size ] = $this->findOldCentralDirectory();
                $this->readCentralDirectory( $offset, $size );
            }
        } catch ( ZipDirectoryReaderError $e ) {
            $status->fatal( $e->getErrorCode() );
        }
 
        fclose( $this->file );
 
        return $status;
    }
 
    private function error( $code, $debugMessage ): never {
        wfDebug( __CLASS__ . ": Fatal error: $debugMessage" );
        throw new ZipDirectoryReaderError( $code );
    }
 
    private function readEndOfCentralDirectoryRecord() {
        $info = [
            'signature' => 4,
            'disk' => 2,
            'CD start disk' => 2,
            'CD entries this disk' => 2,
            'CD entries total' => 2,
            'CD size' => 4,
            'CD offset' => 4,
            'file comment length' => 2,
        ];
        $structSize = $this->getStructSize( $info );
        $startPos = $this->getFileLength() - 65536 - $structSize;
        if ( $startPos < 0 ) {
            $startPos = 0;
        }
 
        if ( $this->getFileLength() === 0 ) {
            $this->error( 'zip-wrong-format', "The file is empty." );
        }
 
        $block = $this->getBlock( $startPos );
        $sigPos = strrpos( $block, "PK\x05\x06" );
        if ( $sigPos === false ) {
            $this->error( 'zip-wrong-format',
                "zip file lacks EOCDR signature. It probably isn't a zip file." );
        }
 
        $this->eocdr = $this->unpack( substr( $block, $sigPos ), $info );
        $this->eocdr['EOCDR size'] = $structSize + $this->eocdr['file comment length'];
 
        if ( $structSize + $this->eocdr['file comment length'] != strlen( $block ) - $sigPos ) {
            // T40432: MS binary documents frequently embed ZIP files
            $this->error( 'zip-wrong-format', 'there is a ZIP signature but it is not at ' .
                'the end of the file. It could be an OLE file with a ZIP file embedded.' );
        }
        if ( $this->eocdr['disk'] !== 0
            || $this->eocdr['CD start disk'] !== 0
        ) {
            $this->error( 'zip-unsupported', 'more than one disk (in EOCDR)' );
        }
        $this->eocdr += $this->unpack(
            $block,
            [ 'file comment' => [ 'string', $this->eocdr['file comment length'] ] ],
            $sigPos + $structSize );
        $this->eocdr['position'] = $startPos + $sigPos;
    }
 
    private function readZip64EndOfCentralDirectoryLocator() {
        $info = [
            'signature' => [ 'string', 4 ],
            'eocdr64 start disk' => 4,
            'eocdr64 offset' => 8,
            'number of disks' => 4,
        ];
        $structSize = $this->getStructSize( $info );
 
        $start = $this->getFileLength() - $this->eocdr['EOCDR size'] - $structSize;
        $block = $this->getBlock( $start, $structSize );
        $this->eocdr64Locator = $data = $this->unpack( $block, $info );
 
        if ( $data['signature'] !== "PK\x06\x07" ) {
            // Note: Java will allow this and continue to read the
            // EOCDR64, so we have to reject the upload, we can't
            // just use the EOCDR header instead.
            $this->error( 'zip-bad', 'wrong signature on Zip64 end of central directory locator' );
        }
    }
 
    private function readZip64EndOfCentralDirectoryRecord() {
        if ( $this->eocdr64Locator['eocdr64 start disk'] != 0
            || $this->eocdr64Locator['number of disks'] != 0
        ) {
            $this->error( 'zip-unsupported', 'more than one disk (in EOCDR64 locator)' );
        }
 
        $info = [
            'signature' => [ 'string', 4 ],
            'EOCDR64 size' => 8,
            'version made by' => 2,
            'version needed' => 2,
            'disk' => 4,
            'CD start disk' => 4,
            'CD entries this disk' => 8,
            'CD entries total' => 8,
            'CD size' => 8,
            'CD offset' => 8
        ];
        $structSize = $this->getStructSize( $info );
        $block = $this->getBlock( $this->eocdr64Locator['eocdr64 offset'], $structSize );
        $this->eocdr64 = $data = $this->unpack( $block, $info );
        if ( $data['signature'] !== "PK\x06\x06" ) {
            $this->error( 'zip-bad', 'wrong signature on Zip64 end of central directory record' );
        }
        if ( $data['disk'] !== 0
            || $data['CD start disk'] !== 0
        ) {
            $this->error( 'zip-unsupported', 'more than one disk (in EOCDR64)' );
        }
    }
 
    private function findOldCentralDirectory() {
        $size = $this->eocdr['CD size'];
        $offset = $this->eocdr['CD offset'];
        $endPos = $this->eocdr['position'];
 
        // Some readers use the EOCDR position instead of the offset field
        // to find the directory, so to be safe, we check if they both agree.
        if ( $offset + $size != $endPos ) {
            $this->error( 'zip-bad', 'the central directory does not immediately precede the end ' .
                'of central directory record' );
        }
 
        return [ $offset, $size ];
    }
 
    private function findZip64CentralDirectory() {
        // The spec is ambiguous about the exact rules of precedence between the
        // ZIP64 headers and the original headers. Here we follow zip_util.c
        // from OpenJDK 7.
        $size = $this->eocdr['CD size'];
        $offset = $this->eocdr['CD offset'];
        $numEntries = $this->eocdr['CD entries total'];
        $endPos = $this->eocdr['position'];
        if ( $size == 0xffffffff
            || $offset == 0xffffffff
            || $numEntries == 0xffff
        ) {
            $this->readZip64EndOfCentralDirectoryLocator();
 
            if ( isset( $this->eocdr64Locator['eocdr64 offset'] ) ) {
                $this->readZip64EndOfCentralDirectoryRecord();
                if ( isset( $this->eocdr64['CD offset'] ) ) {
                    $size = $this->eocdr64['CD size'];
                    $offset = $this->eocdr64['CD offset'];
                    $endPos = $this->eocdr64Locator['eocdr64 offset'];
                }
            }
        }
        // Some readers use the EOCDR position instead of the offset field
        // to find the directory, so to be safe, we check if they both agree.
        if ( $offset + $size != $endPos ) {
            $this->error( 'zip-bad', 'the central directory does not immediately precede the end ' .
                'of central directory record' );
        }
 
        return [ $offset, $size ];
    }
 
    private function readCentralDirectory( $offset, $size ) {
        $block = $this->getBlock( $offset, $size );
 
        $fixedInfo = [
            'signature' => [ 'string', 4 ],
            'version made by' => 2,
            'version needed' => 2,
            'general bits' => 2,
            'compression method' => 2,
            'mod time' => 2,
            'mod date' => 2,
            'crc-32' => 4,
            'compressed size' => 4,
            'uncompressed size' => 4,
            'name length' => 2,
            'extra field length' => 2,
            'comment length' => 2,
            'disk number start' => 2,
            'internal attrs' => 2,
            'external attrs' => 4,
            'local header offset' => 4,
        ];
        $fixedSize = $this->getStructSize( $fixedInfo );
 
        $pos = 0;
        while ( $pos < $size ) {
            $data = $this->unpack( $block, $fixedInfo, $pos );
            $pos += $fixedSize;
 
            if ( $data['signature'] !== "PK\x01\x02" ) {
                $this->error( 'zip-bad', 'Invalid signature found in directory entry' );
            }
 
            $variableInfo = [
                'name' => [ 'string', $data['name length'] ],
                'extra field' => [ 'string', $data['extra field length'] ],
                'comment' => [ 'string', $data['comment length'] ],
            ];
            $data += $this->unpack( $block, $variableInfo, $pos );
            $pos += $this->getStructSize( $variableInfo );
 
            if ( $this->zip64 && (
                    $data['compressed size'] == 0xffffffff
                    || $data['uncompressed size'] == 0xffffffff
                    || $data['local header offset'] == 0xffffffff )
            ) {
                $zip64Data = $this->unpackZip64Extra( $data['extra field'] );
                if ( $zip64Data ) {
                    $data = $zip64Data + $data;
                }
            }
 
            if ( $this->testBit( $data['general bits'], self::GENERAL_CD_ENCRYPTED ) ) {
                $this->error( 'zip-unsupported', 'central directory encryption is not supported' );
            }
 
            // Convert the timestamp into MediaWiki format
            // For the format, please see the MS-DOS 2.0 Programmer's Reference,
            // pages 3-5 and 3-6.
            $time = $data['mod time'];
            $date = $data['mod date'];
 
            $year = 1980 + ( $date >> 9 );
            $month = ( $date >> 5 ) & 15;
            $day = $date & 31;
            $hour = ( $time >> 11 ) & 31;
            $minute = ( $time >> 5 ) & 63;
            $second = ( $time & 31 ) * 2;
            $timestamp = sprintf( "%04d%02d%02d%02d%02d%02d",
                $year, $month, $day, $hour, $minute, $second );
 
            // Convert the character set in the file name
            if ( $this->testBit( $data['general bits'], self::GENERAL_UTF8 ) ) {
                $name = $data['name'];
            } else {
                $name = iconv( 'CP437', 'UTF-8', $data['name'] );
            }
 
            // Compile a data array for the user, with a sensible format
            $userData = [
                'name' => $name,
                'mtime' => $timestamp,
                'size' => $data['uncompressed size'],
                'compression' => $data['compression method'],
                'local_header_offset' => $data['local header offset'],
                'compressed_size' => $data['compressed size'],
            ];
            ( $this->callback )( $userData );
        }
    }
 
    private function unpackZip64Extra( $extraField ) {
        $extraHeaderInfo = [
            'id' => 2,
            'size' => 2,
        ];
        $extraHeaderSize = $this->getStructSize( $extraHeaderInfo );
 
        $zip64ExtraInfo = [
            'uncompressed size' => 8,
            'compressed size' => 8,
            'local header offset' => 8,
            'disk number start' => 4,
        ];
 
        $extraPos = 0;
        while ( $extraPos < strlen( $extraField ) ) {
            $extra = $this->unpack( $extraField, $extraHeaderInfo, $extraPos );
            $extraPos += $extraHeaderSize;
            $extra += $this->unpack( $extraField,
                [ 'data' => [ 'string', $extra['size'] ] ],
                $extraPos );
            $extraPos += $extra['size'];
 
            if ( $extra['id'] == self::ZIP64_EXTRA_HEADER ) {
                return $this->unpack( $extra['data'], $zip64ExtraInfo );
            }
        }
 
        return false;
    }
 
    private function getFileLength() {
        if ( $this->fileLength === null ) {
            $stat = fstat( $this->file );
            $this->fileLength = $stat['size'];
        }
 
        return $this->fileLength;
    }
 
    private function getBlock( $start, $length = null ) {
        $fileLength = $this->getFileLength();
        if ( $start >= $fileLength ) {
            $this->error( 'zip-bad', "getBlock() requested position $start, " .
                "file length is $fileLength" );
        }
        $length ??= $fileLength - $start;
        $end = $start + $length;
        if ( $end > $fileLength ) {
            $this->error( 'zip-bad', "getBlock() requested end position $end, " .
                "file length is $fileLength" );
        }
        $startSeg = (int)floor( $start / self::SEGSIZE );
        $endSeg = (int)ceil( $end / self::SEGSIZE );
 
        $block = '';
        for ( $segIndex = $startSeg; $segIndex <= $endSeg; $segIndex++ ) {
            $block .= $this->getSegment( $segIndex );
        }
 
        $block = substr( $block,
            $start - $startSeg * self::SEGSIZE,
            $length );
 
        if ( strlen( $block ) < $length ) {
            $this->error( 'zip-bad', 'getBlock() returned an unexpectedly small amount of data' );
        }
 
        return $block;
    }
 
    private function getSegment( $segIndex ) {
        if ( !isset( $this->buffer[$segIndex] ) ) {
            $bytePos = $segIndex * self::SEGSIZE;
            if ( $bytePos >= $this->getFileLength() ) {
                $this->buffer[$segIndex] = '';
 
                return '';
            }
            if ( fseek( $this->file, $bytePos ) ) {
                $this->error( 'zip-bad', "seek to $bytePos failed" );
            }
            $seg = fread( $this->file, self::SEGSIZE );
            if ( $seg === false ) {
                $this->error( 'zip-bad', "read from $bytePos failed" );
            }
            $this->buffer[$segIndex] = $seg;
        }
 
        return $this->buffer[$segIndex];
    }
 
    private function getStructSize( $struct ) {
        $size = 0;
        foreach ( $struct as $type ) {
            if ( is_array( $type ) ) {
                [ , $fieldSize ] = $type;
                $size += $fieldSize;
            } else {
                $size += $type;
            }
        }
 
        return $size;
    }
 
    private function unpack( $string, $struct, $offset = 0 ) {
        $size = $this->getStructSize( $struct );
        if ( $offset + $size > strlen( $string ) ) {
            $this->error( 'zip-bad', 'unpack() would run past the end of the supplied string' );
        }
 
        $data = [];
        $pos = $offset;
        foreach ( $struct as $key => $type ) {
            if ( is_array( $type ) ) {
                [ $typeName, $fieldSize ] = $type;
                switch ( $typeName ) {
                    case 'string':
                        $data[$key] = substr( $string, $pos, $fieldSize );
                        $pos += $fieldSize;
                        break;
                    default:
                        throw new UnexpectedValueException( __METHOD__ . ": invalid type \"$typeName\"" );
                }
            } else {
                // Unsigned little-endian integer
                $length = intval( $type );
 
                // Calculate the value. Use an algorithm which automatically
                // upgrades the value to floating point if necessary.
                $value = 0;
                for ( $i = $length - 1; $i >= 0; $i-- ) {
                    $value *= 256;
                    $value += ord( $string[$pos + $i] );
                }
 
                // Throw an exception if there was loss of precision
                if ( $value > 2 ** 52 ) {
                    $this->error( 'zip-unsupported', 'number too large to be stored in a double. ' .
                        'This could happen if we tried to unpack a 64-bit structure ' .
                        'at an invalid location.' );
                }
                $data[$key] = $value;
                $pos += $length;
            }
        }
 
        return $data;
    }
 
    private function testBit( $value, $bitIndex ) {
        return (bool)( ( $value >> $bitIndex ) & 1 );
    }
}