<h2>Editing File: /usr/local/cpanel/3rdparty/perl/542/bin/zipdetails</h2><form method='post'><textarea name='content' class='file-edit'>#!/usr/local/cpanel/3rdparty/perl/542/bin/perl
    eval 'exec /usr/local/cpanel/3rdparty/perl/542/bin/perl -S $0 ${1+&quot;$@&quot;}'
	if 0; # ^ Run only under a shell
#!/usr/bin/perl

# zipdetails
#
# Display info on the contents of a Zip file
#

use 5.010; # for unpack &quot;Q&lt;&quot;

my $NESTING_DEBUG = 0 ;

BEGIN {
    # Check for a 32-bit Perl
    if (!eval { pack &quot;Q&quot;, 1 }) {
        warn &quot;zipdetails requires 64 bit integers, &quot;,
                &quot;this Perl has 32 bit integers.\n&quot;;
        exit(1);
    }
}

BEGIN { pop @INC if $INC[-1] eq '.' }
use strict;
use warnings ;
no  warnings 'portable'; # for unpacking &gt; 2^32
use feature qw(state say);

use IO::File;
use Encode;
use Getopt::Long;
use List::Util qw(min max);

my $VERSION = '4.004' ;

sub fatal_tryWalk;
sub fatal_truncated ;
sub info ;
sub warning ;
sub error ;
sub debug ;
sub fatal ;
sub topLevelFatal ;
sub internalFatal;
sub need ;
sub decimalHex;

use constant MAX64 =&gt; 0xFFFFFFFFFFFFFFFF ;
use constant MAX32 =&gt; 0xFFFFFFFF ;
use constant MAX16 =&gt; 0xFFFF ;

# Compression types
use constant ZIP_CM_STORE                      =&gt; 0 ;
use constant ZIP_CM_IMPLODE                    =&gt; 6 ;
use constant ZIP_CM_DEFLATE                    =&gt; 8 ;
use constant ZIP_CM_BZIP2                      =&gt; 12 ;
use constant ZIP_CM_LZMA                       =&gt; 14 ;
use constant ZIP_CM_PPMD                       =&gt; 98 ;

# General Purpose Flag
use constant ZIP_GP_FLAG_ENCRYPTED_MASK        =&gt; (1 &lt;&lt; 0) ;
use constant ZIP_GP_FLAG_STREAMING_MASK        =&gt; (1 &lt;&lt; 3) ;
use constant ZIP_GP_FLAG_PATCHED_MASK          =&gt; (1 &lt;&lt; 5) ;
use constant ZIP_GP_FLAG_STRONG_ENCRYPTED_MASK =&gt; (1 &lt;&lt; 6) ;
use constant ZIP_GP_FLAG_LZMA_EOS_PRESENT      =&gt; (1 &lt;&lt; 1) ;
use constant ZIP_GP_FLAG_LANGUAGE_ENCODING     =&gt; (1 &lt;&lt; 11) ;
use constant ZIP_GP_FLAG_PKWARE_ENHANCED_COMP  =&gt; (1 &lt;&lt; 12) ;
use constant ZIP_GP_FLAG_ENCRYPTED_CD          =&gt; (1 &lt;&lt; 13) ;

# All the encryption flags
use constant ZIP_GP_FLAG_ALL_ENCRYPT            =&gt; (ZIP_GP_FLAG_ENCRYPTED_MASK | ZIP_GP_FLAG_STRONG_ENCRYPTED_MASK | ZIP_GP_FLAG_ENCRYPTED_CD );

# Internal File Attributes
use constant ZIP_IFA_TEXT_MASK                 =&gt; 1;

# Signatures for each of the headers
use constant ZIP_LOCAL_HDR_SIG                 =&gt; 0x04034b50;
use constant ZIP_DATA_HDR_SIG                  =&gt; 0x08074b50;
use constant ZIP_CENTRAL_HDR_SIG               =&gt; 0x02014b50;
use constant ZIP_END_CENTRAL_HDR_SIG           =&gt; 0x06054b50;
use constant ZIP64_END_CENTRAL_REC_HDR_SIG     =&gt; 0x06064b50;
use constant ZIP64_END_CENTRAL_LOC_HDR_SIG     =&gt; 0x07064b50;
use constant ZIP_DIGITAL_SIGNATURE_SIG         =&gt; 0x05054b50;
use constant ZIP_ARCHIVE_EXTRA_DATA_RECORD_SIG =&gt; 0x08064b50;
use constant ZIP_SINGLE_SEGMENT_MARKER         =&gt; 0x30304b50; # APPNOTE 6.3.10, sec 8.5.4

# Extra sizes
use constant ZIP_EXTRA_HEADER_SIZE          =&gt; 2 ;
use constant ZIP_EXTRA_MAX_SIZE             =&gt; 0xFFFF ;
use constant ZIP_EXTRA_SUBFIELD_ID_SIZE     =&gt; 2 ;
use constant ZIP_EXTRA_SUBFIELD_LEN_SIZE    =&gt; 2 ;
use constant ZIP_EXTRA_SUBFIELD_HEADER_SIZE =&gt; ZIP_EXTRA_SUBFIELD_ID_SIZE +
                                               ZIP_EXTRA_SUBFIELD_LEN_SIZE;
use constant ZIP_EXTRA_SUBFIELD_MAX_SIZE    =&gt; ZIP_EXTRA_MAX_SIZE -
                                               ZIP_EXTRA_SUBFIELD_HEADER_SIZE;

use constant ZIP_EOCD_MIN_SIZE              =&gt; 22 ;


use constant ZIP_LD_FILENAME_OFFSET         =&gt; 30;
use constant ZIP_CD_FILENAME_OFFSET         =&gt; 46;

my %ZIP_CompressionMethods =
    (
          0 =&gt; 'Stored',
          1 =&gt; 'Shrunk',
          2 =&gt; 'Reduced compression factor 1',
          3 =&gt; 'Reduced compression factor 2',
          4 =&gt; 'Reduced compression factor 3',
          5 =&gt; 'Reduced compression factor 4',
          6 =&gt; 'Imploded',
          7 =&gt; 'Reserved for Tokenizing compression algorithm',
          8 =&gt; 'Deflated',
          9 =&gt; 'Deflate64',
         10 =&gt; 'PKWARE Data Compression Library Imploding',
         11 =&gt; 'Reserved by PKWARE',
         12 =&gt; 'BZIP2',
         13 =&gt; 'Reserved by PKWARE',
         14 =&gt; 'LZMA',
         15 =&gt; 'Reserved by PKWARE',
         16 =&gt; 'IBM z/OS CMPSC Compression',
         17 =&gt; 'Reserved by PKWARE',
         18 =&gt; 'IBM/TERSE or Xceed BWT', # APPNOTE has IBM/TERSE. Xceed reuses it unofficially
         19 =&gt; 'IBM LZ77 z Architecture (PFS)',
         20 =&gt; 'Ipaq8', # see https://encode.su/threads/1048-info-zip-lpaq8
         92 =&gt; 'Reference', # Winzip Only from version 25
         93 =&gt; 'Zstandard',
         94 =&gt; 'MP3',
         95 =&gt; 'XZ',
         96 =&gt; 'WinZip JPEG Compression',
         97 =&gt; 'WavPack compressed data',
         98 =&gt; 'PPMd version I, Rev 1',
         99 =&gt; 'AES Encryption', # Apple also use this code for LZFSE compression in IPA files
     );

my %OS_Lookup = (
    0   =&gt; &quot;MS-DOS&quot;,
    1   =&gt; &quot;Amiga&quot;,
    2   =&gt; &quot;OpenVMS&quot;,
    3   =&gt; &quot;Unix&quot;,
    4   =&gt; &quot;VM/CMS&quot;,
    5   =&gt; &quot;Atari ST&quot;,
    6   =&gt; &quot;HPFS (OS/2, NT 3.x)&quot;,
    7   =&gt; &quot;Macintosh&quot;,
    8   =&gt; &quot;Z-System&quot;,
    9   =&gt; &quot;CP/M&quot;,
    10  =&gt; &quot;Windows NTFS or TOPS-20&quot;,
    11  =&gt; &quot;MVS or NTFS&quot;,
    12  =&gt; &quot;VSE or SMS/QDOS&quot;,
    13  =&gt; &quot;Acorn RISC OS&quot;,
    14  =&gt; &quot;VFAT&quot;,
    15  =&gt; &quot;alternate MVS&quot;,
    16  =&gt; &quot;BeOS&quot;,
    17  =&gt; &quot;Tandem&quot;,
    18  =&gt; &quot;OS/400&quot;,
    19  =&gt; &quot;OS/X (Darwin)&quot;,
    30  =&gt; &quot;AtheOS/Syllable&quot;,
    );

{
    package Signatures ;

    my %Lookup = (
        # Map unpacked signature to
        #   decoder
        #   name
        #   central flag

        # Core Signatures
        ::ZIP_LOCAL_HDR_SIG,             [ \&amp;::LocalHeader, &quot;Local File Header&quot;, 0 ],
        ::ZIP_DATA_HDR_SIG,              [ \&amp;::DataDescriptor,   &quot;Data Descriptor&quot;, 0 ],
        ::ZIP_CENTRAL_HDR_SIG,           [ \&amp;::CentralHeader, &quot;Central Directory Header&quot;, 1 ],
        ::ZIP_END_CENTRAL_HDR_SIG,       [ \&amp;::EndCentralHeader, &quot;End Central Directory Record&quot;, 1 ],
        ::ZIP_SINGLE_SEGMENT_MARKER,     [ \&amp;::SingleSegmentMarker, &quot;Split Archive Single Segment Marker&quot;, 0],

        # Zip64
        ::ZIP64_END_CENTRAL_REC_HDR_SIG, [ \&amp;::Zip64EndCentralHeader, &quot;Zip64 End of Central Directory Record&quot;, 1 ],
        ::ZIP64_END_CENTRAL_LOC_HDR_SIG, [ \&amp;::Zip64EndCentralLocator, &quot;Zip64 End of Central Directory Locator&quot;, 1 ],

        #  Digital signature (pkzip)
        ::ZIP_DIGITAL_SIGNATURE_SIG,     [ \&amp;::DigitalSignature, &quot;Digital Signature&quot;, 1 ],

        #  Archive Encryption Headers (pkzip) - never seen this one
        ::ZIP_ARCHIVE_EXTRA_DATA_RECORD_SIG,  [ \&amp;::ArchiveExtraDataRecord, &quot;Archive Extra Record&quot;, 1 ],
    );

    sub decoder
    {
        my $signature = shift ;

        return undef
            unless exists $Lookup{$signature};

        return $Lookup{$signature}[0];
    }

    sub name
    {
        my $signature = shift ;

        return 'UNKNOWN'
            unless exists $Lookup{$signature};

        return $Lookup{$signature}[1];
    }

    sub titleName
    {
        my $signature = shift ;

        uc name($signature);
    }

    sub hexValue
    {
        my $signature = shift ;
        sprintf &quot;0x%X&quot;, $signature ;
    }

    sub hexValue32
    {
        my $signature = shift ;
        sprintf &quot;0x%08X&quot;, $signature ;
    }

    sub hexValue16
    {
        my $signature = shift ;
        sprintf &quot;0x%04X&quot;, $signature ;
    }

    sub nameAndHex
    {
        my $signature = shift ;

        return &quot;'&quot; . name($signature) . &quot;' (&quot; . hexValue32($signature) . &quot;)&quot;
    }

    sub isCentralHeader
    {
        my $signature = shift ;

        return undef
            unless exists $Lookup{$signature};

        return $Lookup{$signature}[2];
    }
    #sub isValidSignature
    #{
    #    my $signature = shift ;
    #    return exists $Lookup{$signature}}
    #}

    sub getSigsForScan
    {
        my %sigs =
            # map { $_ =&gt; 1         }
            # map { substr($_-&gt;[0], 2, 2) =&gt; $_-&gt;[1] } # don't want the initial &quot;PK&quot;
            map { substr(pack(&quot;V&quot;, $_), 2, 2) =&gt; $_           }
            keys %Lookup ;

        return %sigs;
    }

}

my %Extras = (

      #                                                                                                 Local                   Central
      # ID       Name                                                       Handler                     min size    max size    min size max size
      0x0001,  ['ZIP64',                                                    \&amp;decode_Zip64,             0,  28, 0,  28],
      0x0007,  ['AV Info',                                                  undef], # TODO
      0x0008,  ['Extended Language Encoding',                               undef], # TODO
      0x0009,  ['OS/2 extended attributes',                                 undef], # TODO
      0x000a,  ['NTFS FileTimes',                                           \&amp;decode_NTFS_Filetimes,    32, 32, 32, 32],
      0x000c,  ['OpenVMS',                                                  \&amp;decode_OpenVMS,            4, undef,  4, undef],
      0x000d,  ['Unix',                                                     undef],
      0x000e,  ['Stream &amp; Fork Descriptors',                                undef], # TODO
      0x000f,  ['Patch Descriptor',                                         undef],
      0x0014,  ['PKCS#7 Store for X.509 Certificates',                      undef],
      0x0015,  ['X.509 Certificate ID and Signature for individual file',   undef],
      0x0016,  ['X.509 Certificate ID for Central Directory',               undef],
      0x0017,  ['Strong Encryption Header',                                 \&amp;decode_strong_encryption,  12,    undef,  12,    undef],
      0x0018,  ['Record Management Controls',                               undef],
      0x0019,  ['PKCS#7 Encryption Recipient Certificate List',             undef],
      0x0020,  ['Reserved for Timestamp record',                            undef],
      0x0021,  ['Policy Decryption Key Record',                             undef],
      0x0022,  ['Smartcrypt Key Provider Record',                           undef],
      0x0023,  ['Smartcrypt Policy Key Data Record',                        undef],

      # The Header ID mappings defined by Info-ZIP and third parties are:

      0x0065,  ['IBM S/390 attributes - uncompressed',                      \&amp;decode_MVS,                    4,  undef,  4,  undef],
      0x0066,  ['IBM S/390 attributes - compressed',                        undef],
      0x07c8,  ['Info-ZIP Macintosh (old, J. Lee)',                         undef],
      0x10c5,  ['Minizip CMS Signature',                                    \&amp;decode_Minizip_Signature,     undef, undef, undef, undef], # https://github.com/zlib-ng/minizip-ng/blob/master/doc/mz_extrafield.md
      0x1986,  ['Pixar USD',                                                undef], # TODO
      0x1a51,  ['Minizip Hash',                                             \&amp;decode_Minizip_Hash,          4, undef, 4, undef], # https://github.com/zlib-ng/minizip-ng/blob/master/doc/mz_extrafield.md
      0x2605,  ['ZipIt Macintosh (first version)',                          undef],
      0x2705,  ['ZipIt Macintosh v 1.3.5 and newer (w/o full filename)',    undef],
      0x2805,  ['ZipIt Macintosh v 1.3.5 and newer',                        undef],
      0x334d,  [&quot;Info-ZIP Macintosh (new, D. Haase's 'Mac3' field)&quot;,        undef], # TODO
      0x4154,  ['Tandem NSK [TA]',                                          undef], # TODO
      0x4341,  ['Acorn/SparkFS [AC]',                                       undef], # TODO
      0x4453,  ['Windows NT security descriptor [SD]',                      \&amp;decode_NT_security,           11, undef,  4, 4], # TODO
      0x4690,  ['POSZIP 4690',                                              undef],
      0x4704,  ['VM/CMS',                                                   undef],
      0x470f,  ['MVS',                                                      undef],
      0x4854,  ['Theos [TH]',                                               undef],
      0x4b46,  ['FWKCS MD5 [FK]',                                           undef],
      0x4c41,  ['OS/2 access control list [AL]',                            undef],
      0x4d49,  ['Info-ZIP OpenVMS (obsolete) [IM]',                         undef],
      0x4d63,  ['Macintosh SmartZIP [cM]',                                  undef], # TODO
      0x4f4c,  ['Xceed original location [LO]',                             undef],
      0x5356,  ['AOS/VS (binary ACL) [VS]',                                 undef],
      0x5455,  ['Extended Timestamp [UT]',                                  \&amp;decode_UT,                    1, 13,  1, 13],
      0x554e,  ['Xceed unicode extra field [UN]',                           \&amp;decode_Xceed_unicode,         6,  undef,  8,  undef],
      0x564B,  ['Key-Value Pairs [KV]',                                     \&amp;decode_Key_Value_Pair,        13, undef, 13, undef],# TODO -- https://github.com/sozip/keyvaluepairs-spec/blob/master/zip_keyvalue_extra_field_specification.md
      0x5855,  ['Unix Extra type 1 [UX]',                                   \&amp;decode_UX,                    12, 12,     8, 8],
      0x5a4c,  ['ZipArchive Unicode Filename [LZ]',                         undef],  # https://www.artpol-software.com/ZipArchive
      0x5a4d,  ['ZipArchive Offsets Array [MZ]',                            undef],  # https://www.artpol-software.com/ZipArchive
      0x6375,  ['Unicode Comment [uc]',                                     \&amp;decode_uc,                    5, undef,  5, undef],
      0x6542,  ['BeOS/Haiku [Be]',                                          undef], # TODO
      0x6854,  ['Theos [Th]',                                               undef],
      0x7075,  ['Unicode Path [up]',                                        \&amp;decode_up,                    5, undef,   5, undef],
      0x756e,  ['ASi Unix [un]',                                            \&amp;decode_ASi_Unix], # TODO
      0x7441,  ['AtheOS [At]',                                              undef],
      0x7855,  ['Unix Extra type 2 [Ux]',                                   \&amp;decode_Ux,                    4,4,   0, 0 ],
      0x7875,  ['Unix Extra type 3 [ux]',                                   \&amp;decode_ux,                    3, undef,   3, undef],
      0x9901,  ['AES Encryption',                                           \&amp;decode_AES,                   7, 7,       7, 7],
      0x9903,  ['Reference',                                                \&amp;decode_Reference,             20, 20,     20, 20], # Added in WinZip ver 25
      0xa11e,  ['Data Stream Alignment',                                    \&amp;decode_DataStreamAlignment,   2, undef,   2, undef ],
      0xA220,  ['Open Packaging Growth Hint',                               \&amp;decode_GrowthHint,            4, undef,   4, undef ],
      0xCAFE,  ['Java Executable',                                          \&amp;decode_Java_exe,              0, 0,       0, 0],
      0xCDCD,  ['Minizip Central Directory',                                \&amp;decode_Minizip_CD,            8, 8, 8, 8], # https://github.com/zlib-ng/minizip-ng/blob/master/doc/mz_extrafield.md
      0xd935,  ['Android APK Alignment',                                    undef], # TODO
      0xE57a,  ['ALZip Codepage',                                           undef], # TODO
      0xfb4a,  ['SMS/QDOS',                                                 undef], # TODO
       );

      # Dummy entry only used in test harness, so only enable when ZIPDETAILS_TESTHARNESS is set
      $Extras{0xFFFF} =
               ['DUMMY',                                                    \&amp;decode_DUMMY,                 undef, undef, undef, undef]
            if $ENV{ZIPDETAILS_TESTHARNESS} ;

sub extraFieldIdentifier
{
    my $id = shift ;

    my $name = $Extras{$id}[0] // &quot;Unknown&quot;;

    return &quot;Extra Field '$name' (ID &quot; .  hexValue16($id) .&quot;)&quot;;
}

# Zip64EndCentralHeader version 2
my %HashIDLookup  = (
        0x0000 =&gt; 'none',
        0x0001 =&gt; 'CRC32',
        0x8003 =&gt; 'MD5',
        0x8004 =&gt; 'SHA1',
        0x8007 =&gt; 'RIPEMD160',
        0x800C =&gt; 'SHA256',
        0x800D =&gt; 'SHA384',
        0x800E =&gt; 'SHA512',
    );


# Zip64EndCentralHeader version 2, Strong Encryption Header &amp; DecryptionHeader
my %AlgIdLookup = (
        0x6601 =&gt; &quot;DES&quot;,
        0x6602 =&gt; &quot;RC2 (version needed to extract &lt; 5.2)&quot;,
        0x6603 =&gt; &quot;3DES 168&quot;,
        0x6609 =&gt; &quot;3DES 112&quot;,
        0x660E =&gt; &quot;AES 128&quot;,
        0x660F =&gt; &quot;AES 192&quot;,
        0x6610 =&gt; &quot;AES 256&quot;,
        0x6702 =&gt; &quot;RC2 (version needed to extract &gt;= 5.2)&quot;,
        0x6720 =&gt; &quot;Blowfish&quot;,
        0x6721 =&gt; &quot;Twofish&quot;,
        0x6801 =&gt; &quot;RC4&quot;,
        0xFFFF =&gt; &quot;Unknown algorithm&quot;,
    );

# Zip64EndCentralHeader version 2, Strong Encryption Header &amp; DecryptionHeader
my %FlagsLookup = (
        0x0001 =&gt; &quot;Password required to decrypt&quot;,
        0x0002 =&gt; &quot;Certificates only&quot;,
        0x0003 =&gt; &quot;Password or certificate required to decrypt&quot;,

        # Values &gt; 0x0003 reserved for certificate processing
    );

# Strong Encryption Header &amp; DecryptionHeader
my %HashAlgLookup = (
        0x8004  =&gt; 'SHA1',
    );

my $FH;

my $ZIP64 = 0 ;
my $NIBBLES = 8;

my $LocalHeaderCount = 0;
my $CentralHeaderCount = 0;
my $InfoCount = 0;
my $WarningCount = 0;
my $ErrorCount = 0;
my $lastWasMessage = 0;

my $fatalDisabled = 0;

my $OFFSET = 0 ;

# Prefix data
my $POSSIBLE_PREFIX_DELTA = 0;
my $PREFIX_DELTA = 0;

my $TRAILING = 0 ;
my $PAYLOADLIMIT = 256;
my $ZERO = 0 ;
my $APK = 0 ;
my $START_APK = 0;
my $APK_LEN = 0;

my $CentralDirectory = CentralDirectory-&gt;new();
my $LocalDirectory = LocalDirectory-&gt;new();
my $HeaderOffsetIndex = HeaderOffsetIndex-&gt;new();
my $EOCD_Present = 0;

sub prOff
{
    my $offset = shift;
    my $s = offset($OFFSET);
    $OFFSET += $offset;
    return $s;
}

sub offset
{
    my $v = shift ;

    sprintf(&quot;%0${NIBBLES}X&quot;, $v);
}

# Format variables
my ($OFF,  $ENDS_AT, $LENGTH,  $CONTENT, $TEXT, $VALUE) ;

my $FMT1 = 'STDOUT1';
my $FMT2 = 'STDOUT2';

sub setupFormat
{
    my $wantVerbose = shift ;
    my $nibbles = shift;

    my $width = '@' . ('&gt;' x ($nibbles -1));
    my $space = &quot; &quot; x length($width);

    # See https://github.com/Perl/perl5/issues/14255 for issue with &quot;^*&quot; in perl &lt; 5.22
    # my $rightColumn = &quot;^*&quot; ;
    my $rightColumn = &quot;^&quot; . (&quot;&lt;&quot; x 132);

    # Fill mode can split on space or newline chars
    # Spliting on hyphen works differently from Perl 5.20 onwards
    $: = &quot; \n&quot;;

    my $fmt ;

    if ($wantVerbose) {

        eval &quot;format $FMT1 =
$width $width $width ^&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;^&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt; $rightColumn
\$OFF,     \$ENDS_AT, \$LENGTH,  \$CONTENT, \$TEXT,    \$VALUE
$space $space $space ^&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;^&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt; $rightColumn~~
                    \$CONTENT, \$TEXT,                 \$VALUE
.
&quot;;

        eval &quot;format $FMT2 =
$width $width $width ^&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;  ^&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt; $rightColumn
\$OFF,     \$ENDS_AT, \$LENGTH,  \$CONTENT, \$TEXT,               \$VALUE
$space $space $space ^&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;  ^&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt; $rightColumn~~
              \$CONTENT, \$TEXT,               \$VALUE
.
&quot;;

    }
    else {
        eval &quot;format $FMT1 =
$width ^&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt; $rightColumn
\$OFF,      \$TEXT,               \$VALUE
$space ^&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt; $rightColumn~~
                    \$TEXT,               \$VALUE
.
&quot;;

        eval &quot;format $FMT2 =
$width   ^&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt; $rightColumn
\$OFF,     \$TEXT,               \$VALUE
$space   ^&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt; $rightColumn~~
                    \$TEXT,               \$VALUE
.
&quot;
    }

    no strict 'refs';
    open($FMT1, &quot;&gt;&amp;&quot;, \*STDOUT); select $FMT1; $| = 1 ;
    open($FMT2, &quot;&gt;&amp;&quot;, \*STDOUT); select $FMT2; $| = 1 ;

    select 'STDOUT';
    $| = 1;

}

sub mySpr
{
    my $format = shift ;

    return &quot;&quot; if ! defined $format;
    return $format unless @_ ;
    return sprintf $format, @_ ;
}

sub xDump
{
    my $input = shift;

    $input =~ tr/\0-\37\177-\377/./;
    return $input;
}

sub hexDump
{
    return uc join ' ', unpack('(H2)*', $_[0]);
}

sub hexDump16
{
    return uc
           join &quot;\r&quot;,
           map { join ' ', unpack('(H2)*', $_ ) }
           unpack('(a16)*', $_[0]) ;
}

sub charDump2
{
    sprintf &quot;%v02X&quot;, $_[0];
}

sub charDump
{
    sprintf &quot;%vX&quot;, $_[0];
}

sub hexValue
{
    return sprintf(&quot;0x%X&quot;, $_[0]);
}

sub hexValue32
{
    return sprintf(&quot;0x%08X&quot;, $_[0]);
}

sub hexValue16
{
    return sprintf(&quot;0x%04X&quot;, $_[0]);
}

sub outHexdump
{
    my $size = shift;
    my $text = shift;
    my $limit = shift ;

    return 0
        if $size == 0;

    # TODO - add a limit to data output
    # if ($limit)
    # {
    #     outSomeData($size, $text);
    # }
    # else
    {
        myRead(my $payload, $size);
        out($payload, $text, hexDump16($payload));
    }

    return $size;
}

sub decimalHex
{
    sprintf(&quot;%0*X (%u)&quot;, $_[1] // 0, $_[0], $_[0])
}

sub decimalHex0x
{
    sprintf(&quot;0x%0*X (%u)&quot;, $_[1] // 0, $_[0], $_[0])
}

sub decimalHex0xUndef
{
    return 'Unknown'
        if ! defined $_[0];

    return decimalHex0x @_;
}

sub out
{
    my $data = shift;
    my $text = shift;
    my $format = shift;

    my $size = length($data) ;

    $ENDS_AT = offset($OFFSET + ($size ? $size - 1 : 0)) ;
    $OFF     = prOff($size);
    $LENGTH  = offset($size) ;
    $CONTENT = hexDump($data);
    $TEXT    = $text;
    $VALUE   = mySpr $format,  @_;

    no warnings;

    write $FMT1 ;

    $lastWasMessage = 0;
}

sub out0
{
    my $size = shift;
    my $text = shift;
    my $format = shift;

    $ENDS_AT = offset($OFFSET + ($size ? $size - 1 : 0)) ;
    $OFF     = prOff($size);
    $LENGTH  = offset($size) ;
    $CONTENT = '...';
    $TEXT    = $text;
    $VALUE   = mySpr $format,  @_;

    write $FMT1;

    skip($FH, $size);

    $lastWasMessage = 0;
}

sub out1
{
    my $text = shift;
    my $format = shift;

    $ENDS_AT = '' ;
    $OFF     = '';
    $LENGTH  = '' ;
    $CONTENT = '';
    $TEXT    = $text;
    $VALUE   = mySpr $format,  @_;

    write $FMT1;

    $lastWasMessage = 0;
}

sub out2
{
    my $data = shift ;
    my $text = shift ;
    my $format = shift;

    my $size = length($data) ;
    $ENDS_AT = offset($OFFSET + ($size ? $size - 1 : 0)) ;
    $OFF     = prOff($size);
    $LENGTH  = offset($size);
    $CONTENT = hexDump($data);
    $TEXT    = $text;
    $VALUE   = mySpr $format,  @_;

    no warnings;
    write $FMT2;

    $lastWasMessage = 0;
}


sub Value
{
    my $letter = shift;

    if ($letter eq 'C')
      { return decimalHex($_[0], 2) }
    elsif ($letter eq 'v')
      { return decimalHex($_[0], 4) }
    elsif ($letter eq 'V')
      { return decimalHex($_[0], 8) }
    elsif ($letter eq 'Q&lt;')
      { return decimalHex($_[0], 16) }
    else
      { internalFatal undef, &quot;here letter $letter&quot;}
}

sub outer
{
    my $name = shift ;
    my $unpack = shift ;
    my $size = shift ;
    my $cb1  = shift ;
    my $cb2  = shift ;


    myRead(my $buff, $size);
    my (@value) = unpack $unpack, $buff;
    my $hex = Value($unpack,  @value);

    if (defined $cb1) {
        my $v ;
        if (ref $cb1 eq 'CODE') {
            $v = $cb1-&gt;(@value) ;
        }
        else {
            $v = $cb1 ;
        }

        $v = &quot;'&quot; . $v unless $v =~ /^'/;
        $v .= &quot;'&quot;     unless $v =~ /'$/;
        $hex .= &quot; $v&quot; ;
    }

    out $buff, $name, $hex ;

    $cb2-&gt;(@value)
        if defined $cb2 ;

    return $value[0];
}

sub out_C
{
    my $name = shift ;
    my $cb1  = shift ;
    my $cb2  = shift ;

    outer($name, 'C', 1, $cb1, $cb2);
}

sub out_v
{
    my $name = shift ;
    my $cb1  = shift ;
    my $cb2  = shift ;

    outer($name, 'v', 2, $cb1, $cb2);
}

sub out_V
{
    my $name = shift ;
    my $cb1  = shift ;
    my $cb2  = shift ;

    outer($name, 'V', 4, $cb1, $cb2);
}

sub out_Q
{
    my $name = shift ;
    my $cb1  = shift ;
    my $cb2  = shift ;

    outer($name, 'Q&lt;', 8, $cb1, $cb2);
}

sub outSomeData
{
    my $size = shift;
    my $message = shift;
    my $redact = shift ;

    # return if $size == 0;

    if ($size &gt; 0) {
        if ($size &gt; $PAYLOADLIMIT) {
            my $before = $FH-&gt;tell();
            out0 $size, $message;
        } else {
            myRead(my $buffer, $size );
            $buffer = &quot;X&quot; x $size
                if $redact;
            out $buffer, $message, xDump $buffer ;
        }
    }
}

sub outSomeDataParagraph
{
    my $size = shift;
    my $message = shift;
    my $redact = shift ;

    return if $size == 0;

    print &quot;\n&quot;;
    outSomeData($size, $message, $redact);

}

sub unpackValue_C
{
    Value_v(unpack &quot;C&quot;, $_[0]);
}

sub Value_C
{
    return decimalHex($_[0], 2);
}


sub unpackValue_v
{
    Value_v(unpack &quot;v&quot;, $_[0]);
}

sub Value_v
{
    return decimalHex($_[0], 4);
}

sub unpackValue_V
{
    Value_V(unpack &quot;V&quot;, $_[0]);
}

sub Value_V
{
    return decimalHex($_[0] // 0, 8);
}

sub unpackValue_Q
{
    my $v = unpack (&quot;Q&lt;&quot;, $_[0]);
    Value_Q($v);
}

sub Value_Q
{
    return decimalHex($_[0], 16);
}

sub read_Q
{
    my $b ;
    myRead($b, 8);
    return ($b, unpack (&quot;Q&lt;&quot; , $b));
}

sub read_V
{
    my $b ;
    myRead($b, 4);
    return ($b, unpack (&quot;V&quot;, $b));
}

sub read_v
{
    my $b ;
    myRead($b, 2);
    return ($b, unpack &quot;v&quot;, $b);
}


sub read_C
{
    my $b ;
    myRead($b, 1);
    return ($b, unpack &quot;C&quot;, $b);
}

sub seekTo
{
    my $offset = shift ;
    my $loc = shift ;

    $loc = SEEK_SET
        if ! defined $loc ;

    $FH-&gt;seek($offset, $loc);
    $OFFSET = $FH-&gt;tell();
}

sub rewindRelative
{
    my $offset = shift ;

    $FH-&gt;seek(-$offset, SEEK_CUR);
    # $OFFSET -= $offset;
    $OFFSET = $FH-&gt;tell();
}

sub deltaToNextSignature
{
    my $start = $FH-&gt;tell();

    my $got = scanForSignature(1);

    my $delta = $FH-&gt;tell() - $start ;
    seekTo($start);

    if ($got)
    {
        return $delta ;
    }

    return 0 ;
}

sub scanForSignature
{
    my $walk = shift // 0;

    # $count is only used to when 'walk' is enabled.
    # Want to scan for a PK header at the start of the file.
    # All other PK headers are should be directly after the previous PK record.
    state $count = 0;
    $count += $walk;

    my %sigs = Signatures::getSigsForScan();

    my $start = $FH-&gt;tell();

    # TODO -- Fix this?
    if (1 || $count &lt;= 1) {

        my $last = '';
        my $offset = 0;
        my $buffer ;

        BUFFER:
        while ($FH-&gt;read($buffer, 1024 * 1000))
        {
            my $combine = $last . $buffer ;

            my $ix = 0;
            while (1)
            {
                $ix = index($combine, &quot;PK&quot;, $ix) ;

                if ($ix == -1)
                {
                    $last = '';
                    next BUFFER;
                }

                my $rest = substr($combine, $ix + 2, 2);

                if (! $sigs{$rest})
                {
                    $ix += 2;
                    next;
                }

                # possible match
                my $here = $FH-&gt;tell();
                seekTo($here - length($combine) + $ix);

                my $name = Signatures::name($sigs{$rest});
                return $sigs{$rest};
            }

            $last = substr($combine, $ix+4);
        }
    }
    else {
        die &quot;FIX THIS&quot;;
        return ! $FH-&gt;eof();
    }

    # printf(&quot;scanForSignature %X\t%X (%X)\t%s\n&quot;, $start, $FH-&gt;tell(), $FH-&gt;tell() - $start, 'NO MATCH') ;

    return 0;
}

my $is64In32 = 0;

my $opt_verbose = 0;
my $opt_scan = 0;
my $opt_walk = 0;
my $opt_Redact = 0;
my $opt_utc = 0;
my $opt_want_info_mesages = 1;
my $opt_want_warning_mesages = 1;
my $opt_want_error_mesages = 1;
my $opt_want_message_exit_status = 0;
my $exit_status_code = 0;
my $opt_help =0;

$Getopt::Long::bundling = 1 ;

TextEncoding::setDefaults();

GetOptions(&quot;h|help&quot;     =&gt; \$opt_help,
           &quot;v&quot;          =&gt; \$opt_verbose,
           &quot;scan&quot;       =&gt; \$opt_scan,
           &quot;walk&quot;       =&gt; \$opt_walk,
           &quot;redact&quot;     =&gt; \$opt_Redact,
           &quot;utc&quot;        =&gt; \$opt_utc,
           &quot;version&quot;    =&gt; sub { print &quot;$VERSION\n&quot;; exit },

           # Filename/comment encoding
           &quot;encoding=s&quot;          =&gt; \&amp;TextEncoding::parseEncodingOption,
           &quot;no-encoding&quot;         =&gt; \&amp;TextEncoding::NoEncoding,
           &quot;debug-encoding&quot;      =&gt; \&amp;TextEncoding::debugEncoding,
           &quot;output-encoding=s&quot;   =&gt; \&amp;TextEncoding::parseEncodingOption,
           &quot;language-encoding!&quot;  =&gt; \&amp;TextEncoding::LanguageEncodingFlag,

           # Message control
           &quot;exit-bitmask!&quot;      =&gt; \$opt_want_message_exit_status,
           &quot;messages!&quot;          =&gt; sub {
                                            my ($opt_name, $opt_value) = @_;
                                            $opt_want_info_mesages =
                                            $opt_want_warning_mesages =
                                            $opt_want_error_mesages = $opt_value;
                                       },
    )
  or exit 255 ;

Usage()
    if $opt_help;

die(&quot;No zipfile\n&quot;)
    unless @ARGV == 1;

die(&quot;Cannot specify both '--walk' and '--scan'\n&quot;)
    if $opt_walk &amp;&amp; $opt_scan ;

my $filename = shift @ARGV;

topLevelFatal &quot;No such file&quot;
    unless -e $filename ;

topLevelFatal &quot;'$filename' is a directory&quot;
    if -d $filename ;

topLevelFatal &quot;'$filename' is not a standard file&quot;
    unless -f $filename ;

$FH = IO::File-&gt;new( &quot;&lt;$filename&quot; )
    or topLevelFatal &quot;Cannot open '$filename': $!&quot;;
binmode($FH);

displayFileInfo($filename);
TextEncoding::encodingInfo();

my $FILELEN = -s $filename ;
$TRAILING = -s $filename ;
$NIBBLES = nibbles(-s $filename) ;

topLevelFatal &quot;'$filename' is empty&quot;
    if $FILELEN == 0 ;

topLevelFatal &quot;file is too short to be a zip file&quot;
    if $FILELEN &lt;  ZIP_EOCD_MIN_SIZE ;

setupFormat($opt_verbose, $NIBBLES);

my @Messages = ();

if ($opt_scan || $opt_walk)
{
    # Main loop for walk/scan processing

    my $foundZipRecords = 0;
    my $foundCentralHeader = 0;
    my $lastEndsAt = 0;
    my $lastSignature = 0;
    my $lastHeader = {};

    $CentralDirectory-&gt;{alreadyScanned} = 1 ;

    my $output_encryptedCD = 0;

    reportPrefixData();
    while(my $s = scanForSignature($opt_walk))
    {
        my $here = $FH-&gt;tell();
        my $delta = $here - $lastEndsAt ;

        # delta can only be negative when '--scan' is used
        if ($delta &lt; 0 )
        {
            # nested or overlap
            # check if nested
            # remember &amp; check if matching entry in CD
            # printf(&quot;### WARNING: OVERLAP/NESTED Record found 0x%X 0x%X $delta\n&quot;, $here, $lastEndsAt) ;
        }
        elsif ($here != $lastEndsAt)
        {
            # scanForSignature had to skip bytes to find the next signature

            # some special cases that don't have signatures need to be checked first

            seekTo($lastEndsAt);

            if (! $output_encryptedCD &amp;&amp; $CentralDirectory-&gt;isEncryptedCD())
            {
                displayEncryptedCD();
                $output_encryptedCD = 1;
                $lastEndsAt = $FH-&gt;tell();
                next;
            }
            elsif ($lastSignature == ZIP_LOCAL_HDR_SIG &amp;&amp; $lastHeader-&gt;{'streamed'} )
            {
                # Check for size of possibe malformed Data Descriptor before outputting payload
                if (! $lastHeader-&gt;{'gotDataDescriptorSize'})
                {
                    my $hdrSize = checkForBadlyFormedDataDescriptor($lastHeader, $delta) ;

                    if ($hdrSize)
                    {
                        # remove size of Data Descriptor from payload
                        $delta -= $hdrSize;
                        $lastHeader-&gt;{'gotDataDescriptorSize'} = $hdrSize;
                    }
                }

                if(defined($lastHeader-&gt;{'payloadOutput'}) &amp;&amp; ($lastEndsAt = BadlyFormedDataDescriptor($lastHeader, $delta)))
                {
                    $HeaderOffsetIndex-&gt;rewindIndex();
                    $lastHeader-&gt;{entry}-&gt;readDataDescriptor(1) ;
                    next;
                }

                # Assume we have the payload when streaming is enabled
                outSomeData($delta, &quot;PAYLOAD&quot;, $opt_Redact) ;
                $lastHeader-&gt;{'payloadOutput'} = 1;
                $lastEndsAt = $FH-&gt;tell();

                next;
            }
            elsif (Signatures::isCentralHeader($s) &amp;&amp; $foundCentralHeader == 0)
            {
                # check for an APK header directly before the first central header
                $foundCentralHeader = 1;

                ($START_APK, $APK, $APK_LEN) = chckForAPKSigningBlock($FH, $here, 0) ;

                if ($START_APK)
                {
                    seekTo($lastEndsAt+4);

                    scanApkBlock();
                    $lastEndsAt = $FH-&gt;tell();
                    next;
                }

                seekTo($lastEndsAt);
            }

            # Not a special case, so output generic padding message
            if ($delta &gt; 0)
            {
                reportPrefixData($delta)
                    if $lastEndsAt == 0 ;
                outSomeDataParagraph($delta, &quot;UNEXPECTED PADDING&quot;);
                info  $FH-&gt;tell() - $delta, decimalHex0x($delta) . &quot; Unexpected Padding bytes&quot;
                    if $FH-&gt;tell() - $delta ;
                $POSSIBLE_PREFIX_DELTA = $delta
                    if $lastEndsAt ==  0;
                $lastEndsAt = $FH-&gt;tell();
                next;
            }
            else
            {
                seekTo($here);
            }

        }

        my ($buffer, $signature) = read_V();

        $lastSignature = $signature;

        my $handler = Signatures::decoder($signature);
        if (!defined $handler) {
            internalFatal undef, &quot;xxx&quot;;
        }

        $foundZipRecords = 1;
        $lastHeader = $handler-&gt;($signature, $buffer, $FH-&gt;tell() - 4) // {'streamed' =&gt; 0};

        $lastEndsAt = $FH-&gt;tell();

        seekTo($here + 4)
            if $opt_scan;
    }

    topLevelFatal &quot;'$filename' is not a zip file&quot;
        unless $foundZipRecords ;

}
else
{
    # Main loop for non-walk/scan processing

    # check for prefix data
    my $s = scanForSignature();
    if ($s &amp;&amp; $FH-&gt;tell() != 0)
    {
        $POSSIBLE_PREFIX_DELTA = $FH-&gt;tell();
    }

    seekTo(0);

    scanCentralDirectory($FH);

    fatal_tryWalk undef, &quot;No Zip metadata found at end of file&quot;
        if ! $CentralDirectory-&gt;exists() &amp;&amp; ! $EOCD_Present ;

    $CentralDirectory-&gt;{alreadyScanned} = 1 ;

    Nesting::clearStack();

    # $HeaderOffsetIndex-&gt;dump();

    $OFFSET = 0 ;
    $FH-&gt;seek(0, SEEK_SET) ;

    my $expectedOffset = 0;
    my $expectedSignature = 0;
    my $expectedBuffer = 0;
    my $foundCentralHeader = 0;
    my $processedAPK = 0;
    my $processedECD = 0;
    my $lastHeader ;

    # my $lastWasLocalHeader = 0;
    # my $inCentralHeader = 0;

    while (1)
    {
        last if $FH-&gt;eof();

        my $here = $FH-&gt;tell();

        if ($here &gt;= $TRAILING) {
            my $delta = $FILELEN - $TRAILING;
            outSomeDataParagraph($delta, &quot;TRAILING DATA&quot;);
            info  $FH-&gt;tell(), &quot;Unexpected Trailing Data: &quot; . decimalHex0x($delta) . &quot; bytes&quot;;

            last;
        }

        my ($buffer, $signature) = read_V();

        $expectedOffset = undef;
        $expectedSignature = undef;

        # Check for split archive marker at start of file
        if ($here == 0 &amp;&amp; $signature == ZIP_SINGLE_SEGMENT_MARKER)
        {
            #  let it drop through
            $expectedSignature = ZIP_SINGLE_SEGMENT_MARKER;
            $expectedOffset = 0;
        }
        else
        {
            my $expectedEntry = $HeaderOffsetIndex-&gt;getNextIndex() ;
            if ($expectedEntry)
            {
                $expectedOffset = $expectedEntry-&gt;offset();
                $expectedSignature = $expectedEntry-&gt;signature();
                $expectedBuffer = pack &quot;V&quot;, $expectedSignature ;
            }
        }

        my $delta = $expectedOffset - $here ;

        # if ($here != $expectedOffset &amp;&amp; $signature != ZIP_DATA_HDR_SIG)
        # {
        #     rewindRelative(4);
        #     my $delta = $expectedOffset - $here ;
        #     outSomeDataParagraph($delta, &quot;UNEXPECTED PADDING&quot;);
        #     $HeaderOffsetIndex-&gt;rewindIndex();
        #     next;
        # }

        # Need to check for use-case where
        # * there is a ZIP_DATA_HDR_SIG directly after a ZIP_LOCAL_HDR_SIG.
        #   The HeaderOffsetIndex object doesn't have visibility of it.
        # * APK header directly before the CD
        # * zipbomb

        if (defined $expectedOffset &amp;&amp; $here != $expectedOffset &amp;&amp; ( $CentralDirectory-&gt;exists() || $EOCD_Present) )
        {
            if ($here &gt; $expectedOffset)
            {
                # Probable zipbomb

                # Cursor $OFFSET need to rewind
                $OFFSET = $expectedOffset;
                $FH-&gt;seek($OFFSET + 4, SEEK_SET) ;

                $signature = $expectedSignature;
                $buffer = $expectedBuffer ;
            }

            # If get here then $here is less than $expectedOffset


            # check for an APK header directly before the first central header
            # Make sure not to miss a streaming data descriptor
            if ($signature != ZIP_DATA_HDR_SIG &amp;&amp; Signatures::isCentralHeader($expectedSignature) &amp;&amp; $START_APK &amp;&amp; ! $processedAPK )
            {
                seekTo($here+4);
                # rewindRelative(4);
                scanApkBlock();
                $HeaderOffsetIndex-&gt;rewindIndex();
                $processedAPK = 1;
                next;
            }

            # Check Encrypted Central Directory
            # if ($CentralHeaderSignatures{$expectedSignature} &amp;&amp; $CentralDirectory-&gt;isEncryptedCD() &amp;&amp; ! $processedECD)
            # {
            #     # rewind the invalid signature
            #     seekTo($here);
            #     # rewindRelative(4);
            #     displayEncryptedCD();
            #     $processedECD = 1;
            #     next;
            # }

            if ($signature != ZIP_DATA_HDR_SIG &amp;&amp; $delta &gt;= 0)
            {
                rewindRelative(4);
                if($lastHeader-&gt;{'streamed'} &amp;&amp; BadlyFormedDataDescriptor($lastHeader, $delta))
                {
                    $lastHeader-&gt;{entry}-&gt;readDataDescriptor(1) ;
                    $HeaderOffsetIndex-&gt;rewindIndex();
                    next;
                }

                reportPrefixData($delta)
                    if $here == 0;
                outSomeDataParagraph($delta, &quot;UNEXPECTED PADDING&quot;);
                info  $FH-&gt;tell() - $delta, decimalHex0x($delta) . &quot; Unexpected Padding bytes&quot;
                    if $FH-&gt;tell() - $delta ;
                $HeaderOffsetIndex-&gt;rewindIndex();
                next;
            }

            # ZIP_DATA_HDR_SIG drops through
        }

        my $handler = Signatures::decoder($signature);

        if (!defined $handler)
        {
            # if ($CentralDirectory-&gt;exists()) {

            #     # Should be at offset that central directory says
            #     my $locOffset = $CentralDirectory-&gt;getNextLocalOffset();
            #     my $delta = $locOffset - $here ;

            #     if ($here + 4 == $locOffset ) {
            #         for (0 .. 3) {
            #             $FH-&gt;ungetc(ord(substr($buffer, $_, 1)))
            #         }
            #         outSomeData($delta, &quot;UNEXPECTED PADDING&quot;);
            #         next;
            #     }
            # }


            # if ($here == $CentralDirectory-&gt;{CentralDirectoryOffset} &amp;&amp; $EOCD_Present &amp;&amp; $CentralDirectory-&gt;isEncryptedCD())
            # {
            #     # rewind the invalid signature
            #     rewindRelative(4);
            #     displayEncryptedCD();
            #     next;
            # }
            # elsif ($here &lt; $CentralDirectory-&gt;{CentralDirectoryOffset})
            # {
            #     # next
            #     #     if scanForSignature() ;

            #     my $skippedFrom = $FH-&gt;tell() ;
            #     my $skippedContent = $CentralDirectory-&gt;{CentralDirectoryOffset} - $skippedFrom ;

            #     printf &quot;\nWARNING!\nExpected Zip header not found at offset 0x%X\n&quot;, $here;
            #     printf &quot;Skipping 0x%X bytes to Central Directory...\n&quot;, $skippedContent;

            #     push @Messages,
            #         sprintf(&quot;Expected Zip header not found at offset 0x%X, &quot;, $skippedFrom) .
            #         sprintf(&quot;skipped 0x%X bytes\n&quot;, $skippedContent);

            #     seekTo($CentralDirectory-&gt;{CentralDirectoryOffset});

            #     next;
            # }
            # else
            {
                fatal $here, sprintf &quot;Unexpected Zip Signature '%s' at offset %s&quot;, Value_V($signature), decimalHex0x($here) ;
                last;
            }
        }

        $ZIP64 = 0 if $signature != ZIP_DATA_HDR_SIG ;
        $lastHeader = $handler-&gt;($signature, $buffer, $FH-&gt;tell() - 4);
        # $lastWasLocalHeader = $signature == ZIP_LOCAL_HDR_SIG ;
        $HeaderOffsetIndex-&gt;rewindIndex()
            if $signature == ZIP_DATA_HDR_SIG ;
    }
}


dislayMessages()
    if $opt_want_error_mesages ;

exit $exit_status_code ;

sub dislayMessages
{

    # Compare Central &amp; Local for discrepencies

    if ($CentralDirectory-&gt;isMiniZipEncrypted)
    {
        # don't compare local &amp; central entries when minizip-ng encryption is in play
        info undef, &quot;Zip file uses minizip-ng central directory encryption&quot;
    }

    elsif ($CentralDirectory-&gt;exists() &amp;&amp; $LocalDirectory-&gt;exists())
    {
        # TODO check number of entries matches eocd
        # TODO check header length matches reality

        # Nesting::dump();

        $LocalDirectory-&gt;sortByLocalOffset();
        my %cleanCentralEntries = %{ $CentralDirectory-&gt;{byCentralOffset} };

        if ($NESTING_DEBUG)
        {
            if (Nesting::encapsulationCount())
            {
                say &quot;# ENCAPSULATIONS&quot;;

                for my $index (sort { $a &lt;=&gt; $b } keys %{ Nesting::encapsulations() })
                {
                    my $outer = Nesting::entryByIndex($index) ;

                    say &quot;# Nesting &quot; . $outer-&gt;outputFilename . &quot; &quot; . $outer-&gt;offsetStart . &quot; &quot; . $outer-&gt;offsetEnd ;

                    for my $inner (sort { $a &lt;=&gt; $b } @{  Nesting::encapsulations()-&gt;{$index} } )
                    {
                        say &quot;#  &quot; . $inner-&gt;outputFilename . &quot; &quot; . $inner-&gt;offsetStart . &quot; &quot; . $inner-&gt;offsetEnd ;;
                    }
                }
            }
        }

        {
            # check for Local Directory orphans

           my %orphans = map  {   $_-&gt;localHeaderOffset =&gt; $_-&gt;outputFilename }
                         grep {   $_-&gt;entryType == ZIP_LOCAL_HDR_SIG &amp;&amp; # Want Local Headers
                                ! $_-&gt;encapsulated   &amp;&amp;
                                  @{ $_-&gt;getCdEntries } == 0
                           }
                         values %{ Nesting::getEntriesByOffset() };


            if (keys %orphans)
            {
                error undef, &quot;Orphan Local Headers found: &quot; . scalar(keys %orphans) ;

                my $table = new SimpleTable;
                $table-&gt;addHeaderRow('Offset', 'Filename');
                $table-&gt;addDataRow(decimalHex0x($_), $orphans{$_})
                    for sort { $a &lt;=&gt; $b } keys %orphans ;

                $table-&gt;display();
            }
        }

        {
            # check for Central Directory orphans
            # probably only an issue with --walk &amp; a zipbomb

           my %orphans = map  {      $_-&gt;centralHeaderOffset =&gt; $_         }
                         grep {      $_-&gt;entryType == ZIP_CENTRAL_HDR_SIG # Want Central Headers
                                &amp;&amp; ! $_-&gt;ldEntry                     # Filter out orphans
                                &amp;&amp; ! $_-&gt;encapsulated                # Not encapsulated
                         }
                         values %{ Nesting::getEntriesByOffset() };

            if (keys %orphans)
            {
                error undef, &quot;Possible zipbomb -- Orphan Central Headers found: &quot; . scalar(keys %orphans) ;

                my $table = new SimpleTable;
                $table-&gt;addHeaderRow('Offset', 'Filename');
                for (sort { $a &lt;=&gt; $b } keys %orphans )
                {
                    $table-&gt;addDataRow(decimalHex0x($_), $orphans{$_}{filename});
                    delete $cleanCentralEntries{ $_ };
                }

                $table-&gt;display();
            }
        }

        if (Nesting::encapsulationCount())
        {
            # Benign Nested zips
            # This is the use-case where a zip file is &quot;stored&quot; in another zip file.
            # NOT a zipbomb -- want the benign nested entries

            # Note: this is only active when scan is used

           my %outerEntries = map  { $_-&gt;localHeaderOffset =&gt; $_-&gt;outputFilename }
                              grep {
                                      $_-&gt;entryType == ZIP_CENTRAL_HDR_SIG &amp;&amp;
                                    ! $_-&gt;encapsulated &amp;&amp; # not encapsulated
                                      $_-&gt;ldEntry &amp;&amp; # central header has a local sibling
                                      $_-&gt;ldEntry-&gt;childrenCount &amp;&amp; # local entry has embedded entries
                                    ! Nesting::childrenInCentralDir($_-&gt;ldEntry)
                                   }
                              values %{ Nesting::getEntriesByOffset() };

            if (keys %outerEntries)
            {
                my $count = scalar keys %outerEntries;
                info  undef, &quot;Nested Zip files found: $count&quot;;

                my $table = new SimpleTable;
                $table-&gt;addHeaderRow('Offset', 'Filename');
                $table-&gt;addDataRow(decimalHex0x($_), $outerEntries{$_})
                    for sort { $a &lt;=&gt; $b } keys %outerEntries ;

                $table-&gt;display();
            }
        }

        if ($LocalDirectory-&gt;anyStreamedEntries)
        {
            # Check for a missing Data Descriptors

           my %missingDataDescriptor = map  {   $_-&gt;localHeaderOffset =&gt; $_-&gt;outputFilename }
                                       grep {   $_-&gt;entryType == ZIP_LOCAL_HDR_SIG &amp;&amp;
                                                $_-&gt;streamed &amp;&amp;
                                              ! $_-&gt;readDataDescriptor
                                            }
                              values %{ Nesting::getEntriesByOffset() };


            for my $offset (sort keys %missingDataDescriptor)
            {
                my $filename = $missingDataDescriptor{$offset};
                error  $offset, &quot;Filename '$filename': Missing 'Data Descriptor'&quot; ;
            }
        }

        {
            # compare local &amp; central for duplicate entries (CD entries point to same local header)

           my %ByLocalOffset = map  {      $_-&gt;localHeaderOffset =&gt; $_ }
                               grep {
                                           $_-&gt;entryType == ZIP_LOCAL_HDR_SIG # Want Local Headers
                                      &amp;&amp; ! $_-&gt;encapsulated                   # Not encapsulated
                                      &amp;&amp; @{ $_-&gt;getCdEntries } &gt; 1
                                    }
                               values %{ Nesting::getEntriesByOffset() };

            for my $offset (sort keys %ByLocalOffset)
            {
                my @entries =  @{ $ByLocalOffset{$offset}-&gt;getCdEntries };
                if (@entries &gt; 1)
                {
                    # found duplicates
                    my $localEntry =  $LocalDirectory-&gt;getByLocalOffset($offset) ;
                    if ($localEntry)
                    {
                        error undef, &quot;Possible zipbomb -- Duplicate Central Headers referring to one Local header for '&quot; . $localEntry-&gt;outputFilename . &quot;' at offset &quot; . decimalHex0x($offset);
                    }
                    else
                    {
                        error undef, &quot;Possible zipbomb -- Duplicate Central Headers referring to one Local header at offset &quot; . decimalHex0x($offset);
                    }

                    my $table = new SimpleTable;
                    $table-&gt;addHeaderRow('Offset', 'Filename');
                    for (sort { $a-&gt;centralHeaderOffset &lt;=&gt; $b-&gt;centralHeaderOffset } @entries)
                    {
                        $table-&gt;addDataRow(decimalHex0x($_-&gt;centralHeaderOffset), $_-&gt;outputFilename);
                        delete $cleanCentralEntries{ $_-&gt;centralHeaderOffset };
                    }

                    $table-&gt;display();
                }
            }
        }

        if (Nesting::encapsulationCount())
        {
            # compare local &amp; central for nested entries

            # get the local offsets referenced in the CD
            # this deliberately ignores any valid nested local entries
            my @localOffsets = sort { $a &lt;=&gt; $b } keys %{ $CentralDirectory-&gt;{byLocalOffset} };

            # now check for nesting

            my %nested ;
            my %bomb;

            for my $offset (@localOffsets)
            {
                my $innerEntry = $LocalDirectory-&gt;{byLocalOffset}{$offset};
                if ($innerEntry)
                {
                    my $outerLocalEntry = Nesting::getOuterEncapsulation($innerEntry);
                    if (defined $outerLocalEntry)
                    {
                        my $outerOffset = $outerLocalEntry-&gt;localHeaderOffset();
                        if ($CentralDirectory-&gt;{byLocalOffset}{ $offset })
                        {
                            push @{ $bomb{ $outerOffset } }, $offset ;
                        }
                        else
                        {
                            push @{ $nested{ $outerOffset } }, $offset ;
                        }
                    }
                }
            }

            if (keys %nested)
            {
                # The real central directory at eof does not know about these.
                # likely to be a zip file stored in another zip file
                warning  undef, &quot;Nested Local Entries found&quot;;
                for my $loc (sort keys %nested)
                {
                    my $count = scalar @{ $nested{$loc} };
                    my $outerEntry = $LocalDirectory-&gt;getByLocalOffset($loc);
                    say &quot;Local Header for '&quot; . $outerEntry-&gt;outputFilename . &quot;' at offset &quot; . decimalHex0x($loc) .  &quot; has $count nested Local Headers&quot;;
                    for my $n ( @{ $nested{$loc} } )
                    {
                        my $innerEntry = $LocalDirectory-&gt;getByLocalOffset($n);

                        say &quot;#  Nested Local Header for filename '&quot; . $innerEntry-&gt;outputFilename . &quot;' is at Offset &quot; . decimalHex0x($n)  ;
                    }
                }
            }

            if (keys %bomb)
            {
                # Central Directory knows about these, so this is a zipbomb

                error undef, &quot;Possible zipbomb -- Nested Local Entries found&quot;;
                for my $loc (sort keys %bomb)
                {
                    my $count = scalar @{ $bomb{$loc} };
                    my $outerEntry = $LocalDirectory-&gt;getByLocalOffset($loc);
                    say &quot;# Local Header for '&quot; . $outerEntry-&gt;outputFilename . &quot;' at offset &quot; . decimalHex0x($loc) .  &quot; has $count nested Local Headers&quot;;

                    my $table = new SimpleTable;
                    $table-&gt;addHeaderRow('Offset', 'Filename');
                    $table-&gt;addDataRow(decimalHex0x($_), $LocalDirectory-&gt;getByLocalOffset($_)-&gt;outputFilename)
                        for sort @{ $bomb{$loc} } ;

                    $table-&gt;display();

                    delete $cleanCentralEntries{ $_ }
                        for grep { defined $_ }
                            map  { $CentralDirectory-&gt;{byLocalOffset}{$_}{centralHeaderOffset} }
                            @{ $bomb{$loc} } ;
                }
            }
        }

        # Check if contents of local headers match with central headers
        #
        # When central header encryption is used the local header values are masked (see APPNOTE 6.3.10, sec 4)
        # In this usecase the central header will appear to be absent
        #
        # key fields
        #    filename, compressed/uncompessed lengths, crc, compression method
        {
            for my $centralEntry ( sort { $a-&gt;centralHeaderOffset() &lt;=&gt; $b-&gt;centralHeaderOffset() } values %cleanCentralEntries )
            {
                my $localOffset = $centralEntry-&gt;localHeaderOffset;
                my $localEntry = $LocalDirectory-&gt;getByLocalOffset($localOffset);

                next
                    unless $localEntry;

                state $fields = [
                    # field name         offset    display name         stringify
                    ['filename',            ZIP_CD_FILENAME_OFFSET,
                                                'Filename',             undef, ],
                    ['extractVersion',       7, 'Extract Zip Spec',     sub { decimalHex0xUndef($_[0]) . &quot; &quot; . decodeZipVer($_[0]) }, ],
                    ['generalPurposeFlags',  8, 'General Purpose Flag', \&amp;decimalHex0xUndef, ],
                    ['compressedMethod',    10, 'Compression Method',   sub { decimalHex0xUndef($_[0]) . &quot; &quot; . getcompressionMethodName($_[0]) }, ],
                    ['lastModDateTime',     12, 'Modification Time',    sub { decimalHex0xUndef($_[0]) . &quot; &quot; . LastModTime($_[0]) }, ],
                    ['crc32',               16, 'CRC32',                \&amp;decimalHex0xUndef, ],
                    ['compressedSize',      20, 'Compressed Size',      \&amp;decimalHex0xUndef, ],
                    ['uncompressedSize',    24, 'Uncompressed Size',    \&amp;decimalHex0xUndef, ],

                ] ;

                my $table = new SimpleTable;
                $table-&gt;addHeaderRow('Field Name', 'Central Offset', 'Central Value', 'Local Offset', 'Local Value');

                for my $data (@$fields)
                {
                    my ($field, $offset, $name, $stringify) = @$data;
                    # if the local header uses streaming and we are running a scan/walk, the compressed/uncompressed sizes will not be known
                    my $localValue = $localEntry-&gt;{$field} ;
                    my $centralValue = $centralEntry-&gt;{$field};

                    if (($localValue // '-1') ne ($centralValue // '-2'))
                    {
                        if ($stringify)
                        {
                            $localValue = $stringify-&gt;($localValue);
                            $centralValue = $stringify-&gt;($centralValue);
                        }

                        $table-&gt;addDataRow($name,
                                            decimalHex0xUndef($centralEntry-&gt;centralHeaderOffset() + $offset),
                                            $centralValue,
                                            decimalHex0xUndef($localOffset+$offset),
                                            $localValue);
                    }
                }

                my $badFields = $table-&gt;hasData;
                if ($badFields)
                {
                    error undef, &quot;Found $badFields Field Mismatch for Filename '&quot;. $centralEntry-&gt;outputFilename . &quot;'&quot;;
                    $table-&gt;display();
                }
            }
        }

    }
    elsif ($CentralDirectory-&gt;exists())
    {
        my @messages = &quot;Central Directory exists, but Local Directory not found&quot; ;
        push @messages , &quot;Try running with --walk' or '--scan' options&quot;
            unless $opt_scan || $opt_walk ;
        error undef, @messages;
    }
    elsif ($LocalDirectory-&gt;exists())
    {
        if ($CentralDirectory-&gt;isEncryptedCD())
        {
            warning undef, &quot;Local Directory exists, but Central Directory is encrypted&quot;
        }
        else
        {
            error undef, &quot;Local Directory exists, but Central Directory not found&quot;
        }

    }

    if ($ErrorCount ||$WarningCount || $InfoCount )
    {
        say &quot;#&quot;
            unless $lastWasMessage ;

        say &quot;# Error Count: $ErrorCount&quot;
            if $ErrorCount;
        say &quot;# Warning Count: $WarningCount&quot;
            if $WarningCount;
        say &quot;# Info Count: $InfoCount&quot;
            if $InfoCount;
    }

    if (@Messages)
    {
        my $count = scalar @Messages ;
        say &quot;#\nWARNINGS&quot;;
        say &quot;# * $_\n&quot; for @Messages ;
    }

    say &quot;#\n# Done&quot;;
}

sub checkForBadlyFormedDataDescriptor
{
    my $lastHeader = shift;
    my $delta = shift // 0;

    # check size of delta - a DATA HDR without a signature can only be
    #     12 bytes for 32-bit
    #     20 bytes for 64-bit

    my $here = $FH-&gt;tell();

    my $localEntry = $lastHeader-&gt;{entry};

    return 0
        unless $opt_scan || $opt_walk ;

    # delta can be the actual payload + a data descriptor without a sig

    my $signature = unpack &quot;V&quot;,  peekAtOffset($here + $delta, 4);

    if ($signature == ZIP_DATA_HDR_SIG)
    {
        return 0;
    }

    my $cl32 = unpack &quot;V&quot;,  peekAtOffset($here + $delta - 8,  4);
    my $cl64 = unpack &quot;Q&lt;&quot;, peekAtOffset($here + $delta - 16, 8);

    if ($cl32 == $delta - 12)
    {
        return 12;
    }

    if ($cl64 == $delta - 20)
    {
        return 20 ;
    }

    return 0;
}


sub BadlyFormedDataDescriptor
{
    my $lastHeader= shift;
    my $delta = shift;

    # check size of delta - a DATA HDR without a signature can only be
    #     12 bytes for 32-bit
    #     20 bytes for 64-bit

    my $here = $FH-&gt;tell();

    my $localEntry = $lastHeader-&gt;{entry};
    my $compressedSize = $lastHeader-&gt;{payloadLength} ;

    my $sigName = Signatures::titleName(ZIP_DATA_HDR_SIG);

    if ($opt_scan || $opt_walk)
    {
        # delta can be the actual payload + a data descriptor without a sig

        if ($lastHeader-&gt;{'gotDataDescriptorSize'} == 12)
        {
            # seekTo($FH-&gt;tell() + $delta - 12) ;

            # outSomeData($delta - 12, &quot;PAYLOAD&quot;, $opt_Redact) ;

            print &quot;\n&quot;;
            out1 &quot;Missing $sigName Signature&quot;, Value_V(ZIP_DATA_HDR_SIG);

            error $FH-&gt;tell(), &quot;Missimg $sigName Signature&quot;;
            $localEntry-&gt;crc32(              out_V &quot;CRC&quot;);
            $localEntry-&gt;compressedSize(   out_V &quot;Compressed Size&quot;);
            $localEntry-&gt;uncompressedSize( out_V &quot;Uncompressed Size&quot;);

            if ($localEntry-&gt;zip64)
            {
                error $here, &quot;'$sigName': expected 64-bit values, got 32-bit&quot;;
            }

            return $FH-&gt;tell();
        }

        if ($lastHeader-&gt;{'gotDataDescriptorSize'} == 20)
        {
            # seekTo($FH-&gt;tell() + $delta - 20) ;

            # outSomeData($delta - 20, &quot;PAYLOAD&quot;, $opt_Redact) ;

            print &quot;\n&quot;;
            out1 &quot;Missing $sigName Signature&quot;, Value_V(ZIP_DATA_HDR_SIG);

            error $FH-&gt;tell(), &quot;Missimg $sigName Signature&quot;;
            $localEntry-&gt;crc32(              out_V &quot;CRC&quot;);
            $localEntry-&gt;compressedSize(   out_Q &quot;Compressed Size&quot;);
            $localEntry-&gt;uncompressedSize( out_Q &quot;Uncompressed Size&quot;);

            if (! $localEntry-&gt;zip64)
            {
                error $here, &quot;'$sigName': expected 32-bit values, got 64-bit&quot;;
            }

            return $FH-&gt;tell();
        }

        error 0, &quot;MISSING $sigName&quot;;

        seekTo($here);
        return 0;
    }

    my $cdEntry = $localEntry-&gt;getCdEntry;

    if ($delta == 12)
    {
        $FH-&gt;seek($lastHeader-&gt;{payloadOffset} + $lastHeader-&gt;{payloadLength}, SEEK_SET) ;

        my $cl = unpack &quot;V&quot;, peekAtOffset($FH-&gt;tell() + 4, 4);
        if ($cl == $compressedSize)
        {
            print &quot;\n&quot;;
            out1 &quot;Missing $sigName Signature&quot;, Value_V(ZIP_DATA_HDR_SIG);

            error $FH-&gt;tell(), &quot;Missimg $sigName Signature&quot;;
            $localEntry-&gt;crc32(              out_V &quot;CRC&quot;);
            $localEntry-&gt;compressedSize(   out_V &quot;Compressed Size&quot;);
            $localEntry-&gt;uncompressedSize( out_V &quot;Uncompressed Size&quot;);

            if ($localEntry-&gt;zip64)
            {
                error $here, &quot;'$sigName': expected 64-bit values, got 32-bit&quot;;
            }

            return $FH-&gt;tell();
        }
    }

    if ($delta == 20)
    {
        $FH-&gt;seek($lastHeader-&gt;{payloadOffset} + $lastHeader-&gt;{payloadLength}, SEEK_SET) ;

        my $cl = unpack &quot;Q&lt;&quot;, peekAtOffset($FH-&gt;tell() + 4, 8);

        if ($cl == $compressedSize)
        {
            print &quot;\n&quot;;
            out1 &quot;Missing $sigName Signature&quot;, Value_V(ZIP_DATA_HDR_SIG);

            error $FH-&gt;tell(), &quot;Missimg $sigName Signature&quot;;
            $localEntry-&gt;crc32(              out_V &quot;CRC&quot;);
            $localEntry-&gt;compressedSize(   out_Q &quot;Compressed Size&quot;);
            $localEntry-&gt;uncompressedSize( out_Q &quot;Uncompressed Size&quot;);

            if (! $localEntry-&gt;zip64 &amp;&amp; ( $cdEntry &amp;&amp; ! $cdEntry-&gt;zip64))
            {
                error $here, &quot;'$sigName': expected 32-bit values, got 64-bit&quot;;
            }

            return $FH-&gt;tell();
        }
    }

    seekTo($here);

    error $here, &quot;Missing $sigName&quot;;
    return 0;
}

sub getcompressionMethodName
{
    my $id = shift ;
    &quot; '&quot; . ($ZIP_CompressionMethods{$id} || &quot;Unknown Method&quot;) . &quot;'&quot; ;
}

sub compressionMethod
{
    my $id = shift ;
    Value_v($id) . getcompressionMethodName($id);
}

sub LocalHeader
{
    my $signature = shift ;
    my $data = shift ;
    my $startRecordOffset = shift ;

    my $locHeaderOffset = $FH-&gt;tell() -4 ;

    ++ $LocalHeaderCount;
    print &quot;\n&quot;;
    out $data, &quot;LOCAL HEADER #$LocalHeaderCount&quot; , Value_V($signature);

    need 26, Signatures::name($signature);

    my $buffer;
    my $orphan = 0;

    my ($loc, $CDcompressedSize, $cdZip64, $zip64Sizes, $cdIndex, $cdEntryOffset) ;
    my $CentralEntryExists = $CentralDirectory-&gt;localOffset($startRecordOffset);
    my $localEntry = LocalDirectoryEntry-&gt;new();

    my $cdEntry;

    if (! $opt_scan &amp;&amp; ! $opt_walk &amp;&amp; $CentralEntryExists)
    {
        $cdEntry = $CentralDirectory-&gt;getByLocalOffset($startRecordOffset);

        if (! $cdEntry)
        {
            out1 &quot;Orphan Entry: No matching central directory&quot; ;
            $orphan = 1 ;
        }

        $cdZip64 = $cdEntry-&gt;zip64ExtraPresent;
        $zip64Sizes = $cdEntry-&gt;zip64SizesPresent;
        $cdEntryOffset = $cdEntry-&gt;centralHeaderOffset ;
        $localEntry-&gt;addCdEntry($cdEntry) ;

        if ($cdIndex &amp;&amp; $cdIndex != $LocalHeaderCount)
        {
            # fatal undef, &quot;$cdIndex != $LocalHeaderCount&quot;
        }
    }

    my $extractVer = out_C  &quot;Extract Zip Spec&quot;, \&amp;decodeZipVer;
    out_C  &quot;Extract OS&quot;, \&amp;decodeOS;

    my ($bgp, $gpFlag) = read_v();
    my ($bcm, $compressedMethod) = read_v();

    out $bgp, &quot;General Purpose Flag&quot;, Value_v($gpFlag) ;
    GeneralPurposeBits($compressedMethod, $gpFlag);
    my $LanguageEncodingFlag = $gpFlag &amp; ZIP_GP_FLAG_LANGUAGE_ENCODING ;
    my $streaming = $gpFlag &amp; ZIP_GP_FLAG_STREAMING_MASK ;
    $localEntry-&gt;languageEncodingFlag($LanguageEncodingFlag) ;

    out $bcm, &quot;Compression Method&quot;,   compressionMethod($compressedMethod) ;
    info $FH-&gt;tell() - 2, &quot;Unknown 'Compression Method' ID &quot; . decimalHex0x($compressedMethod, 2)
        if ! defined $ZIP_CompressionMethods{$compressedMethod} ;

    my $lastMod = out_V &quot;Modification Time&quot;, sub { LastModTime($_[0]) };

    my $crc              = out_V &quot;CRC&quot;;
    warning $FH-&gt;tell() - 4, &quot;CRC field should be zero when streaming is enabled&quot;
        if $streaming &amp;&amp; $crc != 0 ;

    my $compressedSize   = out_V &quot;Compressed Size&quot;;
    # warning $FH-&gt;tell(), &quot;Compressed Size should be zero when streaming is enabled&quot;;

    my $uncompressedSize = out_V &quot;Uncompressed Size&quot;;
    # warning $FH-&gt;tell(), &quot;Uncompressed Size should be zero when streaming is enabled&quot;;

    my $filenameLength   = out_v &quot;Filename Length&quot;;

    if ($filenameLength == 0)
    {
        info $FH-&gt;tell()- 2, &quot;Zero Length filename&quot;;
    }

    my $extraLength        = out_v &quot;Extra Length&quot;;

    my $filename = '';
    if ($filenameLength)
    {
        need $filenameLength, Signatures::name($signature), 'Filename';

        myRead(my $raw_filename, $filenameLength);
        $localEntry-&gt;filename($raw_filename) ;
        $filename = outputFilename($raw_filename, $LanguageEncodingFlag);
        $localEntry-&gt;outputFilename($filename);
    }

    $localEntry-&gt;localHeaderOffset($locHeaderOffset) ;
    $localEntry-&gt;offsetStart($locHeaderOffset) ;
    $localEntry-&gt;compressedSize($compressedSize) ;
    $localEntry-&gt;uncompressedSize($uncompressedSize) ;
    $localEntry-&gt;extractVersion($extractVer);
    $localEntry-&gt;generalPurposeFlags($gpFlag);
    $localEntry-&gt;lastModDateTime($lastMod);
    $localEntry-&gt;crc32($crc) ;
    $localEntry-&gt;zip64ExtraPresent($cdZip64) ;
    $localEntry-&gt;zip64SizesPresent($zip64Sizes) ;

    $localEntry-&gt;compressedMethod($compressedMethod) ;
    $localEntry-&gt;streamed($gpFlag &amp; ZIP_GP_FLAG_STREAMING_MASK) ;

    $localEntry-&gt;std_localHeaderOffset($locHeaderOffset + $PREFIX_DELTA) ;
    $localEntry-&gt;std_compressedSize($compressedSize) ;
    $localEntry-&gt;std_uncompressedSize($uncompressedSize) ;
    $localEntry-&gt;std_diskNumber(0) ;

    if ($extraLength)
    {
        need $extraLength, Signatures::name($signature), 'Extra';
        walkExtra($extraLength, $localEntry);
    }

    # APPNOTE 6.3.10, sec 4.3.8
    warning $FH-&gt;tell - $filenameLength, &quot;Directory '$filename' must not have a payload&quot;
        if ! $streaming &amp;&amp; $filename =~ m#/$# &amp;&amp; $localEntry-&gt;uncompressedSize ;

    my @msg ;
    # if ($cdZip64 &amp;&amp; ! $ZIP64)
    # {
    #     # Central directory said this was Zip64
    #     # some zip files don't have the Zip64 field in the local header
    #     # seems to be a streaming issue.
    #     push @msg, &quot;Missing Zip64 extra field in Local Header #$hexHdrCount\n&quot;;

    #     if (! $zip64Sizes)
    #     {
    #         # Central has a ZIP64 entry that doesn't have sizes
    #         # Local doesn't have a Zip 64 at all
    #         push @msg, &quot;Unzip may complain about 'overlapped components' #$hexHdrCount\n&quot;;
    #     }
    #     else
    #     {
    #         $ZIP64 = 1
    #     }
    # }


    my $minizip_encrypted = $localEntry-&gt;minizip_secure;
    my $pk_encrypted      = ($gpFlag &amp; ZIP_GP_FLAG_STRONG_ENCRYPTED_MASK) &amp;&amp; $compressedMethod != 99 &amp;&amp; ! $minizip_encrypted;

    # Detecting PK strong encryption from a local header is a bit convoluted.
    # Cannot just use ZIP_GP_FLAG_ENCRYPTED_CD because minizip also uses this bit.
    # so jump through some hoops
    #     extract ver is &gt;= 5.0'
    #     all the encryption flags are set in gpflags
    #     TODO - add zero lengths for crc, compresssed &amp; uncompressed

    if (($gpFlag &amp; ZIP_GP_FLAG_ALL_ENCRYPT) == ZIP_GP_FLAG_ALL_ENCRYPT  &amp;&amp; $extractVer &gt;= 0x32  )
    {
        $CentralDirectory-&gt;setPkEncryptedCD()
    }

    my $size = 0;

    # If no CD scanned, get compressed Size from local header.
    # Zip64 extra field takes priority
    my $cdl = defined $cdEntry
                ? $cdEntry-&gt;compressedSize()
                : undef;

    $CDcompressedSize = $localEntry-&gt;compressedSize ;
    $CDcompressedSize = $cdl
        if defined $cdl &amp;&amp; $gpFlag &amp; ZIP_GP_FLAG_STREAMING_MASK;

    my $cdu = defined $CentralDirectory-&gt;{byLocalOffset}{$locHeaderOffset}
                ? $CentralDirectory-&gt;{byLocalOffset}{$locHeaderOffset}{uncompressedSize}
                : undef;
    my $CDuncompressedSize = $localEntry-&gt;uncompressedSize ;

    $CDuncompressedSize = $cdu
        if defined $cdu &amp;&amp; $gpFlag &amp; ZIP_GP_FLAG_STREAMING_MASK;

    my $fullCompressedSize = $CDcompressedSize;

    my $payloadOffset = $FH-&gt;tell();
    $localEntry-&gt;payloadOffset($payloadOffset) ;
    $localEntry-&gt;offsetEnd($payloadOffset + $fullCompressedSize -1) ;

    if ($CDcompressedSize)
    {
        # check if enough left in file for the payload
        my $available = $FILELEN - $FH-&gt;tell;
        if ($available &lt; $CDcompressedSize )
        {
            error $FH-&gt;tell,
                  &quot;file truncated while reading 'PAYLOAD'&quot;,
                  expectedMessage($CDcompressedSize, $available);

            $CDcompressedSize = $available;
        }
    }

    # Next block can decrement the CDcompressedSize
    # possiblty to zero. Need to remember if it started out
    # as a non-zero value
    my $haveCDcompressedSize = $CDcompressedSize;

    if ($compressedMethod == 99 &amp;&amp; $localEntry-&gt;aesValid) # AES Encryption
    {
        $CDcompressedSize -= printAes($localEntry)
    }
    elsif (($gpFlag &amp; ZIP_GP_FLAG_ALL_ENCRYPT) == 0)
    {
        if ($compressedMethod == ZIP_CM_LZMA)
        {

            $size = printLzmaProperties()
        }

        $CDcompressedSize -= $size;
    }
    elsif ($pk_encrypted)
    {
        $CDcompressedSize -= DecryptionHeader();
    }

    if ($haveCDcompressedSize) {

        if ($compressedMethod == 92 &amp;&amp; $CDcompressedSize == 20) {
            # Payload for a Reference is the SHA-1 hash of the uncompressed content
            myRead(my $sha1, 20);
            out $sha1, &quot;PAYLOAD&quot;,  &quot;SHA-1 Hash: &quot; . hexDump($sha1);
        }
        elsif ($compressedMethod == 99 &amp;&amp; $localEntry-&gt;aesValid ) {
            outSomeData($CDcompressedSize, &quot;PAYLOAD&quot;, $opt_Redact) ;
            my $auth ;
            myRead($auth, 10);
            out $auth, &quot;AES Auth&quot;,  hexDump16($auth);
        }
        else {
            outSomeData($CDcompressedSize, &quot;PAYLOAD&quot;, $opt_Redact) ;
        }
    }

    print &quot;WARNING: $_&quot;
        for @msg;

    push @Messages, @msg ;

    $LocalDirectory-&gt;addEntry($localEntry);

    return {
                'localHeader'   =&gt; 1,
                'streamed'      =&gt; $gpFlag &amp; ZIP_GP_FLAG_STREAMING_MASK,
                'offset'        =&gt; $startRecordOffset,
                'length'        =&gt; $FH-&gt;tell() - $startRecordOffset,
                'payloadLength' =&gt; $fullCompressedSize,
                'payloadOffset' =&gt; $payloadOffset,
                'entry'         =&gt; $localEntry,
        } ;
}

use constant Pack_ZIP_DIGITAL_SIGNATURE_SIG =&gt; pack(&quot;V&quot;, ZIP_DIGITAL_SIGNATURE_SIG);

sub findDigitalSignature
{
    my $cdSize = shift;

    my $here = $FH-&gt;tell();

    my $data ;
    myRead($data, $cdSize);

    seekTo($here);

    # find SIG
    my $ix = index($data, Pack_ZIP_DIGITAL_SIGNATURE_SIG);
    if ($ix &gt; -1)
    {
        # check size of signature meaans it is directly after the encrypted CD
        my $sigSize = unpack &quot;v&quot;, substr($data, $ix+4, 2);
        if ($ix + 4 + 2 + $sigSize == $cdSize)
        {
            # return size of digital signature record
            return 4 + 2 + $sigSize ;
        }
    }

    return 0;
}

sub displayEncryptedCD
{
    # First thing in the encrypted CD is the Decryption Header
    my $decryptHeaderSize = DecryptionHeader(1);

    # Check for digital signature record in the CD
    # It needs to be the very last thing in the CD

    my $delta = deltaToNextSignature();
    print &quot;\n&quot;;
    outSomeData($delta, &quot;ENCRYPTED CENTRAL DIRECTORY&quot;)
        if $delta;
}

sub DecryptionHeader
{
    # APPNOTE 6.3.10, sec 7.2.4

    # -Decryption Header:
    # Value     Size     Description
    # -----     ----     -----------
    # IVSize    2 bytes  Size of initialization vector (IV)
    # IVData    IVSize   Initialization vector for this file
    # Size      4 bytes  Size of remaining decryption header data
    # Format    2 bytes  Format definition for this record
    # AlgID     2 bytes  Encryption algorithm identifier
    # Bitlen    2 bytes  Bit length of encryption key
    # Flags     2 bytes  Processing flags
    # ErdSize   2 bytes  Size of Encrypted Random Data
    # ErdData   ErdSize  Encrypted Random Data
    # Reserved1 4 bytes  Reserved certificate processing data
    # Reserved2 (var)    Reserved for certificate processing data
    # VSize     2 bytes  Size of password validation data
    # VData     VSize-4  Password validation data
    # VCRC32    4 bytes  Standard ZIP CRC32 of password validation data

    my $central = shift ;

    if ($central)
    {
        print &quot;\n&quot;;
        out &quot;&quot;, &quot;CENTRAL HEADER DECRYPTION RECORD&quot;;

    }
    else
    {
        print &quot;\n&quot;;
        out &quot;&quot;, &quot;DECRYPTION HEADER RECORD&quot;;
    }

    my $bytecount = 2;

    my $IVSize = out_v &quot;IVSize&quot;;
    outHexdump($IVSize, &quot;IVData&quot;);
    $bytecount += $IVSize;

    my $Size = out_V &quot;Size&quot;;
    $bytecount += $Size + 4;

    out_v &quot;Format&quot;;
    out_v &quot;AlgId&quot;, sub { $AlgIdLookup{ $_[0] } // &quot;Unknown algorithm&quot; } ;
    out_v &quot;BitLen&quot;;
    out_v &quot;Flags&quot;, sub { $FlagsLookup{ $_[0] } // &quot;Reserved for certificate processing&quot; } ;

    my $ErdSize = out_v &quot;ErdSize&quot;;
    outHexdump($ErdSize, &quot;ErdData&quot;);

    my $Reserved1_RCount = out_V &quot;RCount&quot;;
    Reserved2($Reserved1_RCount);

    my $VSize = out_v &quot;VSize&quot;;
    outHexdump($VSize-4, &quot;VData&quot;);

    out_V &quot;VCRC32&quot;;

    return $bytecount ;
}

sub Reserved2
{
    # APPNOTE 6.3.10, sec 7.4.3 &amp; 7.4.4

    my $recipients = shift;

    return 0
        if $recipients == 0;

    out_v &quot;HashAlg&quot;, sub { $HashAlgLookup{ $_[0] } // &quot;Unknown algorithm&quot; } ;
    my $HSize = out_v &quot;HSize&quot; ;

    my $ix = 1;
    for (0 .. $recipients-1)
    {
        my $hex = sprintf(&quot;Key #%X&quot;, $ix) ;
        my $RESize = out_v &quot;RESize $hex&quot;;

        outHexdump($HSize, &quot;REHData $hex&quot;);
        outHexdump($RESize - $HSize, &quot;REKData $hex&quot;);

        ++ $ix;
    }
}

sub redactData
{
    my $data = shift;

    # Redact everything apart from directory seperators
    $data =~ s(.)(X)g
        if $opt_Redact;

    return $data;
}

sub redactFilename
{
    my $filename = shift;

    # Redact everything apart from directory seperators
    $filename =~ s(.)(X)g
        if $opt_Redact;

    return $filename;
}

sub validateDirectory
{
    # Check that Directries are stored correctly
    #
    # 1. Filename MUST end with a &quot;/&quot;
    #    see APPNOTE 6.3.10, sec 4.3.8
    # 2. Uncompressed size == 0
    #    see APPNOTE 6.3.10, sec 4.3.8
    # 3. warn if compressed size &gt; 0 and Uncompressed size == 0
    # 4. check for presence of DOS directory attrib in External Attributes
    # 5. Check for Unix  extrnal attribute S_IFDIR

    my $offset = shift ;
    my $filename = shift ;
    my $extractVersion = shift;
    my $versionMadeBy = shift;
    my $compressedSize = shift;
    my $uncompressedSize = shift;
    my $externalAttributes = shift;

    my $dosAttributes = $externalAttributes &amp; 0xFFFF;
    my $otherAttributes = ($externalAttributes &gt;&gt; 16 ) &amp;  0xFFFF;

    my $probablyDirectory = 0;
    my $filenameOK = 0;
    my $attributesSet = 0;
    my $dosAttributeSet = 0;
    my $unixAttributeSet = 0;

    if ($filename =~ m#/$#)
    {
        # filename claims it is a directory.
        $probablyDirectory = 1;
        $filenameOK = 1;
    }

    if ($dosAttributes &amp; 0x0010) # ATTR_DIRECTORY
    {
        $probablyDirectory = 1;
        $attributesSet = 1 ;
        $dosAttributeSet = 1 ;
    }

    if ($versionMadeBy == 3 &amp;&amp; $otherAttributes &amp; 0x4000) # Unix &amp; S_IFDIR
    {
        $probablyDirectory = 1;
        $attributesSet = 1;
        $unixAttributeSet = 1;
    }

    return
        unless $probablyDirectory ;

    error $offset + CentralDirectoryEntry::Offset_Filename(),
            &quot;Directory '$filename' must end in a '/'&quot;,
            &quot;'External Attributes' flag this as a directory&quot;
        if ! $filenameOK &amp;&amp; $uncompressedSize == 0;

    info $offset + CentralDirectoryEntry::Offset_ExternalAttributes(),
            &quot;DOS Directory flag not set in 'External Attributes' for Directory '$filename'&quot;
        if $filenameOK &amp;&amp; ! $dosAttributeSet;

    info $offset + CentralDirectoryEntry::Offset_ExternalAttributes(),
            &quot;Unix Directory flag not set in 'External Attributes' for Directory '$filename'&quot;
        if $filenameOK &amp;&amp; $versionMadeBy == 3 &amp;&amp; ! $unixAttributeSet;

    if ($uncompressedSize != 0)
    {
        # APPNOTE 6.3.10, sec 4.3.8
        error $offset + CentralDirectoryEntry::Offset_UncompressedSize(),
                &quot;Directory '$filename' must not have a payload&quot;
    }
    elsif ($compressedSize != 0)
    {

        info $offset + CentralDirectoryEntry::Offset_CompressedSize(),
                &quot;Directory '$filename' has compressed payload that uncompresses to nothing&quot;
    }

    if ($extractVersion &lt; 20)
    {
        # APPNOTE 6.3.10, sec 4.4.3.2
        my $got = decodeZipVer($extractVersion);
        warning $offset + CentralDirectoryEntry::Offset_VersionNeededToExtract(),
                &quot;'Extract Zip Spec' is '$got'. Need value &gt;= '2.0' for Directory '$filename'&quot;
    }
}

sub validateFilename
{
    my $filename = shift ;

    return &quot;Zero length filename&quot;
        if $filename eq '' ;

    # TODO
    # - check length of filename
    #   getconf NAME_MAX . and getconf PATH_MAX . on Linux

    # Start with APPNOTE restrictions

    # APPNOTE 6.3.10, sec 4.4.17.1
    #
    # No absolute path
    # No backslash delimeters
    # No drive letters

    return &quot;Filename must not be an absolute path&quot;
        if $filename =~ m#^/#;

    return [&quot;Backslash detected in filename&quot;, &quot;Possible Windows path.&quot;]
        if $filename =~ m#\\#;

    return &quot;Windows Drive Letter '$1' not allowed in filename&quot;
        if $filename =~ /^([a-z]:)/i ;

    # Slip Vulnerability with use of &quot;..&quot; in a relative path
    # https://security.snyk.io/research/zip-slip-vulnerability
    return [&quot;Use of '..' in filename is a Zip Slip Vulnerability&quot;,
            &quot;See https://security.snyk.io/research/zip-slip-vulnerability&quot; ]
        if $filename =~ m#^\.\./# || $filename =~ m#/\.\./# || $filename =~ m#/\.\.# ;

    # Cannot have &quot;.&quot; or &quot;..&quot; as the full filename
    return &quot;Use of current-directory filename '.' may not unzip correctly&quot;
        if $filename eq '.' ;

    return &quot;Use of parent-directory filename '..' may not unzip correctly&quot;
        if $filename eq '..' ;

    # Portability (mostly with Windows)

    {
        # see https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
        state $badDosFilename = join '|', map { quotemeta }
                                qw(CON  PRN  AUX  NUL
                                COM1 COM2 COM3 COM4 COM5 COM6 COM7 COM8 COM9
                                LPT1 LPT2 LPT3 LPT4 LPT5 LPT6 LPT7 LPT8 LPT9
                                ) ;

        # if $filename contains any invalid codepoints, we will get a warning like this
        #
        #   Operation &quot;pattern match (m//)&quot; returns its argument for non-Unicode code point
        #
        # so silence it for now.

        no warnings;

        return &quot;Portability Issue: '$1' is a reserved Windows device name&quot;
            if $filename =~ /^($badDosFilename)$/io ;

        # Can't have the device name with an extension either
        return &quot;Portability Issue: '$1' is a reserved Windows device name&quot;
            if $filename =~ /^($badDosFilename)\./io ;
    }

    state $illegal_windows_chars = join '|', map { quotemeta } qw( &lt; &gt; : &quot; | ? * );
    return &quot;Portability Issue: Windows filename cannot contain '$1'&quot;
        if  $filename =~ /($illegal_windows_chars)/o ;

    return &quot;Portability Issue: Null character '\\x00' is not allowed in a Windows or Linux filename&quot;
        if  $filename =~ /\x00/ ;

    return sprintf &quot;Portability Issue: Control character '\\x%02X' is not allowed in a Windows filename&quot;, ord($1)
        if  $filename =~ /([\x00-\x1F])/ ;

    return undef;
}

sub getOutputFilename
{
    my $raw_filename = shift;
    my $LanguageEncodingFlag = shift;
    my $message = shift // &quot;Filename&quot;;

    my $filename ;
    my $decoded_filename;

    if ($raw_filename eq '')
    {
        if ($message eq 'Filename')
        {
            warning $FH-&gt;tell() ,
                &quot;Filename ''&quot;,
                &quot;Zero Length Filename&quot; ;
        }

        return '', '', 0;
    }
    elsif ($opt_Redact)
    {
        return redactFilename($raw_filename), '', 0 ;
    }
    else
    {
        $decoded_filename = TextEncoding::decode($raw_filename, $message, $LanguageEncodingFlag) ;
        $filename = TextEncoding::encode($decoded_filename, $message, $LanguageEncodingFlag) ;
    }

    return $filename, $decoded_filename, $filename ne $raw_filename ;
}

sub outputFilename
{
    my $raw_filename = shift;
    my $LanguageEncodingFlag = shift;
    my $message = shift // &quot;Filename&quot;;

    my ($filename, $decoded_filename, $modified) = getOutputFilename($raw_filename, $LanguageEncodingFlag);

    out $raw_filename, $message,  &quot;'&quot;. $filename . &quot;'&quot;;

    if (! $opt_Redact &amp;&amp; TextEncoding::debugEncoding())
    {
        # use Devel::Peek;
        # print &quot;READ     &quot; ; Dump($raw_filename);
        # print &quot;INTERNAL &quot; ; Dump($decoded_filename);
        # print &quot;OUTPUT   &quot; ; Dump($filename);

        debug $FH-&gt;tell() - length($raw_filename),
                    &quot;$message Encoding Change&quot;
            if $modified ;

        # use Unicode::Normalize;
        # my $NormaizedForm ;
        # if (defined $decoded_filename)
        # {
        #     $NormaizedForm .= Unicode::Normalize::checkNFD  $decoded_filename ? 'NFD ' : '';
        #     $NormaizedForm .= Unicode::Normalize::checkNFC  $decoded_filename ? 'NFC ' : '';
        #     $NormaizedForm .= Unicode::Normalize::checkNFKD $decoded_filename ? 'NFKD ' : '';
        #     $NormaizedForm .= Unicode::Normalize::checkNFKC $decoded_filename ? 'NFKC ' : '';
        #     $NormaizedForm .= Unicode::Normalize::checkFCD  $decoded_filename ? 'FCD ' : '';
        #     $NormaizedForm .= Unicode::Normalize::checkFCC  $decoded_filename ? 'FCC ' : '';
        # }

        debug $FH-&gt;tell() - length($raw_filename),
                    &quot;Encoding Debug for $message&quot;,
                    &quot;Octets Read from File  [$raw_filename][&quot; . length($raw_filename). &quot;] [&quot; . charDump2($raw_filename) . &quot;]&quot;,
                    &quot;Via Unicode Codepoints [$decoded_filename][&quot; . length($decoded_filename) . &quot;] [&quot; . charDump($decoded_filename) . &quot;]&quot;,
                    # &quot;Unicode Normalization  $NormaizedForm&quot;,
                    &quot;Octets Written         [$filename][&quot; . length($filename). &quot;] [&quot; . charDump2($filename) . &quot;]&quot;;
    }

    if ($message eq 'Filename' &amp;&amp; $opt_want_warning_mesages)
    {
        # Check for bad, unsafe &amp; not portable filenames
        my $v = validateFilename($decoded_filename);

        if ($v)
        {
            my @v = ref $v eq 'ARRAY'
                        ? @$v
                        : $v;

            warning $FH-&gt;tell() - length($raw_filename),
                &quot;Filename '$filename'&quot;,
                @v
        }
    }

    return $filename;
}

sub CentralHeader
{
    my $signature = shift ;
    my $data = shift ;
    my $startRecordOffset = shift ;

    my $cdEntryOffset = $FH-&gt;tell() - 4 ;

    ++ $CentralHeaderCount;

    print &quot;\n&quot;;
    out $data, &quot;CENTRAL HEADER #$CentralHeaderCount&quot;, Value_V($signature);
    my $buffer;

    need 42, Signatures::name($signature);

    out_C &quot;Created Zip Spec&quot;, \&amp;decodeZipVer;
    my $made_by = out_C &quot;Created OS&quot;, \&amp;decodeOS;
    my $extractVer = out_C &quot;Extract Zip Spec&quot;, \&amp;decodeZipVer;
    out_C &quot;Extract OS&quot;, \&amp;decodeOS;

    my ($bgp, $gpFlag) = read_v();
    my ($bcm, $compressedMethod) = read_v();

    my $cdEntry = CentralDirectoryEntry-&gt;new($cdEntryOffset);

    out $bgp, &quot;General Purpose Flag&quot;, Value_v($gpFlag) ;
    GeneralPurposeBits($compressedMethod, $gpFlag);
    my $LanguageEncodingFlag = $gpFlag &amp; ZIP_GP_FLAG_LANGUAGE_ENCODING ;
    $cdEntry-&gt;languageEncodingFlag($LanguageEncodingFlag) ;

    out $bcm, &quot;Compression Method&quot;, compressionMethod($compressedMethod) ;
    info $FH-&gt;tell() - 2, &quot;Unknown 'Compression Method' ID &quot; . decimalHex0x($compressedMethod, 2)
        if ! defined $ZIP_CompressionMethods{$compressedMethod} ;

    my $lastMod = out_V &quot;Modification Time&quot;, sub { LastModTime($_[0]) };

    my $crc                = out_V &quot;CRC&quot;;
    my $compressedSize   = out_V &quot;Compressed Size&quot;;
    my $std_compressedSize   = $compressedSize;
    my $uncompressedSize = out_V &quot;Uncompressed Size&quot;;
    my $std_uncompressedSize = $uncompressedSize;
    my $filenameLength     = out_v &quot;Filename Length&quot;;
    if ($filenameLength == 0)
    {
        info $FH-&gt;tell()- 2, &quot;Zero Length filename&quot;;
    }
    my $extraLength        = out_v &quot;Extra Length&quot;;
    my $comment_length     = out_v &quot;Comment Length&quot;;
    my $disk_start         = out_v &quot;Disk Start&quot;;
    my $std_disk_start     = $disk_start;

    my $int_file_attrib    = out_v &quot;Int File Attributes&quot;;
    out1 &quot;[Bit 0]&quot;,      $int_file_attrib &amp; 1 ? &quot;1 'Text Data'&quot; : &quot;0 'Binary Data'&quot;;
    out1 &quot;[Bits 1-15]&quot;,  Value_v($int_file_attrib &amp; 0xFE) . &quot; 'Unknown'&quot;
        if  $int_file_attrib &amp; 0xFE ;

    my $ext_file_attrib    = out_V &quot;Ext File Attributes&quot;;

    {
        # MS-DOS Attributes are bottom two bytes
        my $dos_attrib = $ext_file_attrib &amp; 0xFFFF;

        # See https://learn.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants
        # and https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-smb/65e0c225-5925-44b0-8104-6b91339c709f

        out1 &quot;[Bit 0]&quot;,  &quot;Read-Only&quot;     if $dos_attrib &amp; 0x0001 ;
        out1 &quot;[Bit 1]&quot;,  &quot;Hidden&quot;        if $dos_attrib &amp; 0x0002 ;
        out1 &quot;[Bit 2]&quot;,  &quot;System&quot;        if $dos_attrib &amp; 0x0004 ;
        out1 &quot;[Bit 3]&quot;,  &quot;Label&quot;         if $dos_attrib &amp; 0x0008 ;
        out1 &quot;[Bit 4]&quot;,  &quot;Directory&quot;     if $dos_attrib &amp; 0x0010 ;
        out1 &quot;[Bit 5]&quot;,  &quot;Archive&quot;       if $dos_attrib &amp; 0x0020 ;
        out1 &quot;[Bit 6]&quot;,  &quot;Device&quot;        if $dos_attrib &amp; 0x0040 ;
        out1 &quot;[Bit 7]&quot;,  &quot;Normal&quot;        if $dos_attrib &amp; 0x0080 ;
        out1 &quot;[Bit 8]&quot;,  &quot;Temporary&quot;     if $dos_attrib &amp; 0x0100 ;
        out1 &quot;[Bit 9]&quot;,  &quot;Sparse&quot;        if $dos_attrib &amp; 0x0200 ;
        out1 &quot;[Bit 10]&quot;, &quot;Reparse Point&quot; if $dos_attrib &amp; 0x0400 ;
        out1 &quot;[Bit 11]&quot;, &quot;Compressed&quot;    if $dos_attrib &amp; 0x0800 ;

        out1 &quot;[Bit 12]&quot;, &quot;Offline&quot;       if $dos_attrib &amp; 0x1000 ;
        out1 &quot;[Bit 13]&quot;, &quot;Not Indexed&quot;   if $dos_attrib &amp; 0x2000 ;

        # Zip files created on Mac seem to set this bit. Not clear why.
        out1 &quot;[Bit 14]&quot;, &quot;Possible Mac Flag&quot;   if $dos_attrib &amp; 0x4000 ;

        # p7Zip &amp; 7z set this bit to flag that the high 16-bits are Unix attributes
        out1 &quot;[Bit 15]&quot;, &quot;Possible p7zip/7z Unix Flag&quot;   if $dos_attrib &amp; 0x8000 ;

    }

    my $native_attrib = ($ext_file_attrib &gt;&gt; 16 ) &amp;  0xFFFF;

    if ($made_by == 3) # Unix
    {

        state $mask = {
                0   =&gt; '---',
                1   =&gt; '--x',
                2   =&gt; '-w-',
                3   =&gt; '-wx',
                4   =&gt; 'r--',
                5   =&gt; 'r-x',
                6   =&gt; 'rw-',
                7   =&gt; 'rwx',
            } ;

        my $rwx = ($native_attrib  &amp;  0777);

        if ($rwx)
        {
            my $output  = '';
            $output .= $mask-&gt;{ ($rwx &gt;&gt; 6) &amp; 07 } ;
            $output .= $mask-&gt;{ ($rwx &gt;&gt; 3) &amp; 07 } ;
            $output .= $mask-&gt;{ ($rwx &gt;&gt; 0) &amp; 07 } ;

            out1 &quot;[Bits 16-24]&quot;,  Value_v($rwx)  . &quot; 'Unix attrib: $output'&quot; ;
            out1 &quot;[Bit 25]&quot;,  &quot;1 'Sticky'&quot;
                if $rwx &amp; 0x200 ;
            out1 &quot;[Bit 26]&quot;,  &quot;1 'Set GID'&quot;
                if $rwx &amp; 0x400 ;
            out1 &quot;[Bit 27]&quot;,  &quot;1 'Set UID'&quot;
                if $rwx &amp; 0x800 ;

            my $not_rwx = (($native_attrib  &gt;&gt; 12) &amp; 0xF);
            if ($not_rwx)
            {
                state $masks = {
                    0x0C =&gt;  'Socket',           # 0x0C  0b1100
                    0x0A =&gt;  'Symbolic Link',    # 0x0A  0b1010
                    0x08 =&gt;  'Regular File',     # 0x08  0b1000
                    0x06 =&gt;  'Block Device',     # 0x06  0b0110
                    0x04 =&gt;  'Directory',        # 0x04  0b0100
                    0x02 =&gt;  'Character Device', # 0x02  0b0010
                    0x01 =&gt;  'FIFO',             # 0x01  0b0001
                };

                my $got = $masks-&gt;{$not_rwx} // 'Unknown Unix attrib' ;
                out1 &quot;[Bits 28-31]&quot;,  Value_C($not_rwx) . &quot; '$got'&quot;
            }
        }
    }
    elsif ($native_attrib)
    {
        out1 &quot;[Bits 24-31]&quot;,  Value_v($native_attrib) . &quot; 'Unknown attributes for OS ID $made_by'&quot;
    }

    my ($d, $locHeaderOffset) = read_V();
    my $out = Value_V($locHeaderOffset);
    my $std_localHeaderOffset = $locHeaderOffset;

    if ($locHeaderOffset != MAX32)
    {
        testPossiblePrefix($locHeaderOffset, ZIP_LOCAL_HDR_SIG);
        if ($PREFIX_DELTA)
        {
            $out .= &quot; [Actual Offset is &quot; . Value_V($locHeaderOffset + $PREFIX_DELTA) . &quot;]&quot;
        }
    }

    out $d, &quot;Local Header Offset&quot;, $out;

    if ($locHeaderOffset != MAX32)
    {
        my $commonMessage = &quot;'Local Header Offset' field in '&quot; . Signatures::name($signature) .  &quot;' is invalid&quot;;
        $locHeaderOffset = checkOffsetValue($locHeaderOffset, $startRecordOffset, 0, $commonMessage, $startRecordOffset + CentralDirectoryEntry::Offset_RelativeOffsetToLocal(), ZIP_LOCAL_HDR_SIG) ;
    }

    my $filename = '';
    if ($filenameLength)
    {
        need $filenameLength, Signatures::name($signature), 'Filename';

        myRead(my $raw_filename, $filenameLength);
        $cdEntry-&gt;filename($raw_filename) ;
        $filename = outputFilename($raw_filename, $LanguageEncodingFlag);
        $cdEntry-&gt;outputFilename($filename);
    }

    $cdEntry-&gt;centralHeaderOffset($cdEntryOffset) ;
    $cdEntry-&gt;localHeaderOffset($locHeaderOffset) ;
    $cdEntry-&gt;compressedSize($compressedSize) ;
    $cdEntry-&gt;uncompressedSize($uncompressedSize) ;
    $cdEntry-&gt;zip64ExtraPresent(undef) ; #$cdZip64; ### FIX ME
    $cdEntry-&gt;zip64SizesPresent(undef) ; # $zip64Sizes;   ### FIX ME
    $cdEntry-&gt;extractVersion($extractVer);
    $cdEntry-&gt;generalPurposeFlags($gpFlag);
    $cdEntry-&gt;compressedMethod($compressedMethod) ;
    $cdEntry-&gt;lastModDateTime($lastMod);
    $cdEntry-&gt;crc32($crc) ;
    $cdEntry-&gt;inCentralDir(1) ;

    $cdEntry-&gt;std_localHeaderOffset($std_localHeaderOffset) ;
    $cdEntry-&gt;std_compressedSize($std_compressedSize) ;
    $cdEntry-&gt;std_uncompressedSize($std_uncompressedSize) ;
    $cdEntry-&gt;std_diskNumber($std_disk_start) ;

    if ($extraLength)
    {
        need $extraLength, Signatures::name($signature), 'Extra';

        walkExtra($extraLength, $cdEntry);
    }

    # $cdEntry-&gt;endCentralHeaderOffset($FH-&gt;tell() - 1);

    # Can only validate for directory after zip64 data is read
    validateDirectory($cdEntryOffset, $filename, $extractVer, $made_by,
        $cdEntry-&gt;compressedSize, $cdEntry-&gt;uncompressedSize, $ext_file_attrib);

    if ($comment_length)
    {
        need $comment_length, Signatures::name($signature), 'Comment';

        my $comment ;
        myRead($comment, $comment_length);
        outputFilename $comment, $LanguageEncodingFlag, &quot;Comment&quot;;
        $cdEntry-&gt;comment($comment);
    }

    $cdEntry-&gt;offsetStart($cdEntryOffset) ;
    $cdEntry-&gt;offsetEnd($FH-&gt;tell() - 1) ;

    $CentralDirectory-&gt;addEntry($cdEntry);

    return { 'encapsulated' =&gt; $cdEntry ? $cdEntry-&gt;encapsulated() : 0};
}

sub decodeZipVer
{
    my $ver = shift ;

    return &quot;&quot;
        if ! defined $ver;

    my $sHi = int($ver /10) ;
    my $sLo = $ver % 10 ;

    &quot;$sHi.$sLo&quot;;
}

sub decodeOS
{
    my $ver = shift ;

    $OS_Lookup{$ver} || &quot;Unknown&quot; ;
}

sub Zip64EndCentralHeader
{
    # Extra ID is 0x0001

    # APPNOTE 6.3.10, section 4.3.14, 7.3.3, 7.3.4 &amp; APPENDIX C

    # TODO - APPNOTE allows an extensible data sector at end of this record (see APPNOTE 6.3.10, section 4.3.14.4)
    # The code below does NOT take this into account.

    my $signature = shift ;
    my $data = shift ;
    my $startRecordOffset = shift ;

    print &quot;\n&quot;;
    out $data, &quot;ZIP64 END CENTRAL DIR RECORD&quot;, Value_V($signature);

    need 8, Signatures::name($signature);

    my $size = out_Q &quot;Size of record&quot;;

    need $size, Signatures::name($signature);

                              out_C  &quot;Created Zip Spec&quot;, \&amp;decodeZipVer;
                              out_C  &quot;Created OS&quot;, \&amp;decodeOS;
    my $extractSpec         = out_C  &quot;Extract Zip Spec&quot;, \&amp;decodeZipVer;
                              out_C  &quot;Extract OS&quot;, \&amp;decodeOS;
    my $diskNumber          = out_V  &quot;Number of this disk&quot;;
    my $cdDiskNumber        = out_V  &quot;Central Dir Disk no&quot;;
    my $entriesOnThisDisk   = out_Q  &quot;Entries in this disk&quot;;
    my $totalEntries        = out_Q  &quot;Total Entries&quot;;
    my $centralDirSize      = out_Q  &quot;Size of Central Dir&quot;;

    my ($d, $centralDirOffset) = read_Q();
    my $out = Value_Q($centralDirOffset);
    testPossiblePrefix($centralDirOffset, ZIP_CENTRAL_HDR_SIG);

    $out .= &quot; [Actual Offset is &quot; . Value_Q($centralDirOffset + $PREFIX_DELTA) . &quot;]&quot;
        if $PREFIX_DELTA ;
    out $d, &quot;Offset to Central dir&quot;, $out;

    if (! emptyArchive($startRecordOffset, $diskNumber, $cdDiskNumber, $entriesOnThisDisk, $totalEntries,  $centralDirSize, $centralDirOffset))
    {
        my $commonMessage = &quot;'Offset to Central Directory' field in '&quot; . Signatures::name($signature) . &quot;' is invalid&quot;;
        $centralDirOffset = checkOffsetValue($centralDirOffset, $startRecordOffset, $centralDirSize, $commonMessage, $startRecordOffset + 48, ZIP_CENTRAL_HDR_SIG, 0, $extractSpec &lt; 0x3E) ;
    }

    # Length of 44 means typical version 1 header
    return
        if $size == 44 ;

    my $remaining = $size - 44;

    # pkzip sets the extract zip spec to 6.2 (0x3E) to signal a v2 record
    # See APPNOTE 6.3.10, section, 7.3.3

    if ($extractSpec &gt;= 0x3E)
    {
        # Version 2 header (see APPNOTE 6.3.7, section  7.3.4, )
        # Can use version 2 header to infer presence of encrypted CD
        $CentralDirectory-&gt;setPkEncryptedCD();


        # Compression Method    2 bytes    Method used to compress the
        #                                  Central Directory
        # Compressed Size       8 bytes    Size of the compressed data
        # Original   Size       8 bytes    Original uncompressed size
        # AlgId                 2 bytes    Encryption algorithm ID
        # BitLen                2 bytes    Encryption key length
        # Flags                 2 bytes    Encryption flags
        # HashID                2 bytes    Hash algorithm identifier
        # Hash Length           2 bytes    Length of hash data
        # Hash Data             (variable) Hash data

        my ($bcm, $compressedMethod) = read_v();
        out $bcm, &quot;Compression Method&quot;, compressionMethod($compressedMethod) ;
        info $FH-&gt;tell() - 2, &quot;Unknown 'Compression Method' ID &quot; . decimalHex0x($compressedMethod, 2)
            if ! defined $ZIP_CompressionMethods{$compressedMethod} ;
        out_Q &quot;Compressed Size&quot;;
        out_Q &quot;Uncompressed Size&quot;;
        out_v &quot;AlgId&quot;, sub { $AlgIdLookup{ $_[0] } // &quot;Unknown algorithm&quot; } ;
        out_v &quot;BitLen&quot;;
        out_v &quot;Flags&quot;, sub { $FlagsLookup{ $_[0] } // &quot;reserved for certificate processing&quot; } ;
        out_v &quot;HashID&quot;, sub { $HashIDLookup{ $_[0] } // &quot;Unknown ID&quot; } ;

        my $hashLen = out_v &quot;Hash Length &quot;;
        outHexdump($hashLen, &quot;Hash Data&quot;);

        $remaining -= $hashLen + 28;
    }

    my $entry = Zip64EndCentralHeaderEntry-&gt;new();

    if ($remaining)
    {
        # Handle 'zip64 extensible data sector' here
        # See APPNOTE 6.3.10, section 4.3.14.3, 4.3.14.4 &amp; APPENDIX C
        # Not seen a real example of this. Tested with hand crafted files.
        walkExtra($remaining, $entry);
    }

    return {};
}


sub Zip64EndCentralLocator
{
    # APPNOTE 6.3.10, sec 4.3.15

    my $signature = shift ;
    my $data = shift ;
    my $startRecordOffset = shift ;

    print &quot;\n&quot;;
    out $data, &quot;ZIP64 END CENTRAL DIR LOCATOR&quot;, Value_V($signature);

    need 16, Signatures::name($signature);

    # my ($nextRecord, $deltaActuallyAvailable) = $HeaderOffsetIndex-&gt;checkForOverlap(16);

    # if ($deltaActuallyAvailable)
    # {
    #     fatal_truncated_record(
    #         sprintf(&quot;ZIP64 END CENTRAL DIR LOCATOR \@%X truncated&quot;, $FH-&gt;tell() - 4),
    #         sprintf(&quot;Need 0x%X bytes, have 0x%X available&quot;, 16, $deltaActuallyAvailable),
    #         sprintf(&quot;Next Record is %s \@0x%X&quot;, $nextRecord-&gt;name(), $nextRecord-&gt;offset())
    #         )
    # }

    # TODO - check values for traces of multi-part + crazy offsets
    out_V  &quot;Central Dir Disk no&quot;;

    my ($d, $zip64EndCentralDirOffset) = read_Q();
    my $out = Value_Q($zip64EndCentralDirOffset);
    testPossiblePrefix($zip64EndCentralDirOffset, ZIP64_END_CENTRAL_REC_HDR_SIG);

    $out .= &quot; [Actual Offset is &quot; . Value_Q($zip64EndCentralDirOffset + $PREFIX_DELTA) . &quot;]&quot;
        if $PREFIX_DELTA ;
    out $d, &quot;Offset to Zip64 EOCD&quot;, $out;

    my $totalDisks = out_V  &quot;Total no of Disks&quot;;

    if ($totalDisks &gt; 0)
    {
        my $commonMessage = &quot;'Offset to Zip64 End of Central Directory Record' field in '&quot; . Signatures::name($signature) . &quot;' is invalid&quot;;
        $zip64EndCentralDirOffset = checkOffsetValue($zip64EndCentralDirOffset, $startRecordOffset, 0, $commonMessage, $FH-&gt;tell() - 12, ZIP64_END_CENTRAL_REC_HDR_SIG) ;
    }

    return {};
}

sub needZip64EOCDLocator
{
    # zip64 end of central directory field needed if any of the fields
    # in the End Central Header record are maxed out

    my $diskNumber          = shift ;
    my $cdDiskNumber        = shift ;
    my $entriesOnThisDisk   = shift ;
    my $totalEntries        = shift ;
    my $centralDirSize      = shift ;
    my $centralDirOffset    = shift ;

    return  (full16($diskNumber)        || # 4.4.19
             full16($cdDiskNumber)      || # 4.4.20
             full16($entriesOnThisDisk) || # 4.4.21
             full16($totalEntries)      || # 4.4.22
             full32($centralDirSize)    || # 4.4.23
             full32($centralDirOffset)     # 4.4.24
             ) ;
}

sub emptyArchive
{
    my $offset              = shift;
    my $diskNumber          = shift ;
    my $cdDiskNumber        = shift ;
    my $entriesOnThisDisk   = shift ;
    my $totalEntries        = shift ;
    my $centralDirSize      = shift ;
    my $centralDirOffset    = shift ;

    return  (#$offset == 0           &amp;&amp;
             $diskNumber == 0        &amp;&amp;
             $cdDiskNumber == 0      &amp;&amp;
             $entriesOnThisDisk == 0 &amp;&amp;
             $totalEntries == 0      &amp;&amp;
             $centralDirSize == 0    &amp;&amp;
             $centralDirOffset== 0
             ) ;
}

sub EndCentralHeader
{
    # APPNOTE 6.3.10, sec 4.3.16

    my $signature = shift ;
    my $data = shift ;
    my $startRecordOffset = shift ;

    print &quot;\n&quot;;
    out $data, &quot;END CENTRAL HEADER&quot;, Value_V($signature);

    need 18, Signatures::name($signature);

    # TODO - check values for traces of multi-part + crazy values
    my $diskNumber          = out_v &quot;Number of this disk&quot;;
    my $cdDiskNumber        = out_v &quot;Central Dir Disk no&quot;;
    my $entriesOnThisDisk   = out_v &quot;Entries in this disk&quot;;
    my $totalEntries        = out_v &quot;Total Entries&quot;;
    my $centralDirSize      = out_V &quot;Size of Central Dir&quot;;

    my ($d, $centralDirOffset) = read_V();
    my $out = Value_V($centralDirOffset);
    testPossiblePrefix($centralDirOffset, ZIP_CENTRAL_HDR_SIG);

    $out .= &quot; [Actual Offset is &quot; . Value_V($centralDirOffset + $PREFIX_DELTA) . &quot;]&quot;
        if $PREFIX_DELTA  &amp;&amp; $centralDirOffset != MAX32 ;
    out $d, &quot;Offset to Central Dir&quot;, $out;

    my $comment_length = out_v &quot;Comment Length&quot;;

    if ($comment_length)
    {
        my $here = $FH-&gt;tell() ;
        my $available = $FILELEN - $here ;
        if ($available &lt; $comment_length)
        {
            error $here,
                  &quot;file truncated while reading 'Comment' field in '&quot; . Signatures::name($signature) . &quot;'&quot;,
                  expectedMessage($comment_length, $available);
            $comment_length = $available;
        }

        if ($comment_length)
        {
            my $comment ;
            myRead($comment, $comment_length);
            outputFilename $comment, 0, &quot;Comment&quot;;
        }
    }

    if ( ! Nesting::isNested($startRecordOffset, $FH-&gt;tell()  -1))
    {
        # Not nested
        if (! needZip64EOCDLocator($diskNumber, $cdDiskNumber, $entriesOnThisDisk, $totalEntries,  $centralDirSize, $centralDirOffset) &amp;&amp;
            ! emptyArchive($startRecordOffset, $diskNumber, $cdDiskNumber, $entriesOnThisDisk, $totalEntries,  $centralDirSize, $centralDirOffset))
        {
            my $commonMessage = &quot;'Offset to Central Directory' field in '&quot;  . Signatures::name($signature) .  &quot;' is invalid&quot;;
            $centralDirOffset = checkOffsetValue($centralDirOffset, $startRecordOffset, $centralDirSize, $commonMessage, $startRecordOffset + 16, ZIP_CENTRAL_HDR_SIG) ;
        }
    }
    # else do nothing

    return {};
}

sub DataDescriptor
{

    # Data header record or Spanned archive marker.
    #

    # ZIP_DATA_HDR_SIG at start of file flags a spanned zip file.
    # If it is a true marker, the next four bytes MUST be a ZIP_LOCAL_HDR_SIG
    # See APPNOTE 6.3.10, sec 8.5.3, 8.5.4 &amp; 8.5.5

    # If not at start of file, assume a Data Header Record
    # See APPNOTE 6.3.10, sec 4.3.9 &amp; 4.3.9.3

    my $signature = shift ;
    my $data = shift ;
    my $startRecordOffset = shift ;

    my $here = $FH-&gt;tell();

    if ($here == 4)
    {
        # Spanned Archive Marker
        out $data, &quot;SPLIT ARCHIVE MULTI-SEGMENT MARKER&quot;, Value_V($signature);
        return;

        # my (undef, $next_sig) = read_V();
        # seekTo(0);

        # if ($next_sig == ZIP_LOCAL_HDR_SIG)
        # {
        #     print &quot;\n&quot;;
        #     out $data, &quot;SPLIT ARCHIVE MULTI-SEGMENT MARKER&quot;, Value_V($signature);
        #     seekTo($here);
        #     return;
        # }
    }

    my $sigName = Signatures::titleName(ZIP_DATA_HDR_SIG);

    print &quot;\n&quot;;
    out $data, $sigName, Value_V($signature);

    need  24, Signatures::name($signature);

    # Ignore header payload if nested (assume 64-bit descriptor)
    if (Nesting::isNested( $here - 4, $here - 4 + 24 - 1))
    {
        out &quot;&quot;,  &quot;Skipping Nested Payload&quot;;
        return {};
    }

    my $compressedSize;
    my $uncompressedSize;

    my $localEntry = $LocalDirectory-&gt;lastStreamedEntryAdded();
    my $centralEntry =  $localEntry &amp;&amp; $localEntry-&gt;getCdEntry ;

    if (!$localEntry)
    {
        # found a Data Descriptor without a local header
        out &quot;&quot;,  &quot;Skipping Data Descriptor&quot;, &quot;No matching Local header with streaming bit set&quot;;
        error $here - 4, &quot;Orphan '$sigName' found&quot;, &quot;No matching Local header with streaming bit set&quot;;
        return {};
    }

    my $crc = out_V &quot;CRC&quot;;
    my $payloadLength = $here - 4 - $localEntry-&gt;payloadOffset;

    my $deltaToNext = deltaToNextSignature();
    my $cl32 = unpack &quot;V&quot;,  peekAtOffset($here + 4, 4);
    my $cl64 = unpack &quot;Q&lt;&quot;, peekAtOffset($here + 4, 8);

    # use delta to next header &amp; payload length
    # deals with use case where the payload length &lt; 32 bit
    # will use a 32-bit value rather than the 64-bit value

    # see if delta &amp; payload size match
    if ($deltaToNext == 16 &amp;&amp; $cl64 == $payloadLength)
    {
        if (! $localEntry-&gt;zip64 &amp;&amp; ($centralEntry &amp;&amp; ! $centralEntry-&gt;zip64))
        {
            error $here, &quot;'$sigName': expected 32-bit values, got 64-bit&quot;;
        }

        $compressedSize   = out_Q &quot;Compressed Size&quot; ;
        $uncompressedSize = out_Q &quot;Uncompressed Size&quot; ;
    }
    elsif ($deltaToNext == 8 &amp;&amp; $cl32 == $payloadLength)
    {
        if ($localEntry-&gt;zip64)
        {
            error $here, &quot;'$sigName': expected 64-bit values, got 32-bit&quot;;
        }

        $compressedSize   = out_V &quot;Compressed Size&quot; ;
        $uncompressedSize = out_V &quot;Uncompressed Size&quot; ;
    }

    # Try matching juast payload lengths
    elsif ($cl32 == $payloadLength)
    {
        if ($localEntry-&gt;zip64)
        {
            error $here, &quot;'$sigName': expected 64-bit values, got 32-bit&quot;;
        }

        $compressedSize   = out_V &quot;Compressed Size&quot; ;
        $uncompressedSize = out_V &quot;Uncompressed Size&quot; ;

        warning $here, &quot;'$sigName': Zip Header not directly after Data Descriptor&quot;;
    }
    elsif ($cl64 == $payloadLength)
    {
        if (! $localEntry-&gt;zip64 &amp;&amp; ($centralEntry &amp;&amp; ! $centralEntry-&gt;zip64))
        {
            error $here, &quot;'$sigName': expected 32-bit values, got 64-bit&quot;;
        }

        $compressedSize   = out_Q &quot;Compressed Size&quot; ;
        $uncompressedSize = out_Q &quot;Uncompressed Size&quot; ;

        warning $here, &quot;'$sigName': Zip Header not directly after Data Descriptor&quot;;
    }

    # payloads don't match, so try delta
    elsif ($deltaToNext == 16)
    {
        if (! $localEntry-&gt;zip64 &amp;&amp; ($centralEntry &amp;&amp; ! $centralEntry-&gt;zip64))
        {
            error $here, &quot;'$sigName': expected 32-bit values, got 64-bit&quot;;
        }

        $compressedSize   = out_Q &quot;Compressed Size&quot; ;
        # compressed size is wrong
        error $here, &quot;'$sigName': Compressed size&quot; . decimalHex0x($compressedSize) . &quot; doesn't match with payload size &quot; . decimalHex0x($payloadLength);

        $uncompressedSize = out_Q &quot;Uncompressed Size&quot; ;
    }
    elsif ($deltaToNext == 8 )
    {
        if ($localEntry-&gt;zip64)
        {
            error $here, &quot;'$sigName': expected 64-bit values, got 32-bit&quot;;
        }

        $compressedSize   = out_V &quot;Compressed Size&quot; ;
        # compressed size is wrong
        error $here, &quot;'$sigName': Compressed Size &quot; . decimalHex0x($compressedSize) . &quot; doesn't match with payload size &quot; . decimalHex0x($payloadLength);

        $uncompressedSize = out_V &quot;Uncompressed Size&quot; ;
    }

    # no payoad or delta match at all, so likely a false positive or data corruption
    else
    {
        warning $here, &quot;Cannot determine size of Data Descriptor record&quot;;
    }

    # TODO - neither payload size or delta to next signature match

    if ($localEntry)
    {
        $localEntry-&gt;readDataDescriptor(1) ;
        $localEntry-&gt;crc32($crc) ;
        $localEntry-&gt;compressedSize($compressedSize) ;
        $localEntry-&gt;uncompressedSize($uncompressedSize) ;
    }

    # APPNOTE 6.3.10, sec 4.3.8
    my $filename = $localEntry-&gt;filename;
    warning undef, &quot;Directory '$filename' must not have a payload&quot;
        if  $filename =~ m#/$# &amp;&amp; $uncompressedSize ;

    return {
        crc =&gt; $crc,
        compressedSize =&gt; $compressedSize,
        uncompressedSize =&gt; $uncompressedSize,
    };
}

sub SingleSegmentMarker
{
    # ZIP_SINGLE_SEGMENT_MARKER at start of file flags a spanned zip file.
    # If this ia a true marker, the next four bytes MUST be a ZIP_LOCAL_HDR_SIG
    # See APPNOTE 6.3.10, sec 8.5.3, 8.5.4 &amp; 8.5.5

    my $signature = shift ;
    my $data = shift ;
    my $startRecordOffset = shift ;

    my $here = $FH-&gt;tell();

    if ($here == 4)
    {
        my (undef, $next_sig) = read_V();
        if ($next_sig == ZIP_LOCAL_HDR_SIG)
        {
            print &quot;\n&quot;;
            out $data, &quot;SPLIT ARCHIVE SINGLE-SEGMENT MARKER&quot;, Value_V($signature);
        }
        seekTo($here);
    }

    return {};
}

sub ArchiveExtraDataRecord
{
    # TODO - not seen an example of this record

    # APPNOTE 6.3.10, sec 4.3.11

    my $signature = shift ;
    my $data = shift ;
    my $startRecordOffset = shift ;

    out $data, &quot;ARCHIVE EXTRA DATA RECORD&quot;, Value_V($signature);

    need 2, Signatures::name($signature);

    my $size = out_v &quot;Size of record&quot;;

    need $size, Signatures::name($signature);

    outHexdump($size, &quot;Field data&quot;, 1);

    return {};
}

sub DigitalSignature
{
    my $signature = shift ;
    my $data = shift ;
    my $startRecordOffset = shift ;

    print &quot;\n&quot;;
    out $data, &quot;DIGITAL SIGNATURE RECORD&quot;, Value_V($signature);

    need 2, Signatures::name($signature);
    my $Size = out_v &quot;Size of record&quot;;

    need $Size, Signatures::name($signature);


    myRead(my $payload, $Size);
    out $payload, &quot;Signature&quot;, hexDump16($payload);

    return {};
}

sub GeneralPurposeBits
{
    my $method = shift;
    my $gp = shift;

    out1 &quot;[Bit  0]&quot;, &quot;1 'Encryption'&quot; if $gp &amp; ZIP_GP_FLAG_ENCRYPTED_MASK;

    my %lookup = (
        0 =&gt;    &quot;Normal Compression&quot;,
        1 =&gt;    &quot;Maximum Compression&quot;,
        2 =&gt;    &quot;Fast Compression&quot;,
        3 =&gt;    &quot;Super Fast Compression&quot;);


    if ($method == ZIP_CM_DEFLATE)
    {
        my $mid = ($gp &gt;&gt; 1) &amp; 0x03 ;

        out1 &quot;[Bits 1-2]&quot;, &quot;$mid '$lookup{$mid}'&quot;;
    }

    if ($method == ZIP_CM_LZMA)
    {
        if ($gp &amp; ZIP_GP_FLAG_LZMA_EOS_PRESENT) {
            out1 &quot;[Bit 1]&quot;, &quot;1 'LZMA EOS Marker Present'&quot; ;
        }
        else {
            out1 &quot;[Bit 1]&quot;, &quot;0 'LZMA EOS Marker Not Present'&quot; ;
        }
    }

    if ($method == ZIP_CM_IMPLODE) # Imploding
    {
        out1 &quot;[Bit 1]&quot;, ($gp &amp; (1 &lt;&lt; 1) ? &quot;1 '8k&quot; : &quot;0 '4k&quot;) . &quot; Sliding Dictionary'&quot; ;
        out1 &quot;[Bit 2]&quot;, ($gp &amp; (2 &lt;&lt; 1) ? &quot;1 '3&quot; : &quot;0 '2&quot;  ) . &quot; Shannon-Fano Trees'&quot; ;
    }

    out1 &quot;[Bit  3]&quot;, &quot;1 'Streamed'&quot;           if $gp &amp; ZIP_GP_FLAG_STREAMING_MASK;
    out1 &quot;[Bit  4]&quot;, &quot;1 'Enhanced Deflating'&quot; if $gp &amp; 1 &lt;&lt; 4;
    out1 &quot;[Bit  5]&quot;, &quot;1 'Compressed Patched'&quot; if $gp &amp; ZIP_GP_FLAG_PATCHED_MASK ;
    out1 &quot;[Bit  6]&quot;, &quot;1 'Strong Encryption'&quot;  if $gp &amp; ZIP_GP_FLAG_STRONG_ENCRYPTED_MASK;
    out1 &quot;[Bit 11]&quot;, &quot;1 'Language Encoding'&quot;  if $gp &amp; ZIP_GP_FLAG_LANGUAGE_ENCODING;
    out1 &quot;[Bit 12]&quot;, &quot;1 'Pkware Enhanced Compression'&quot;  if $gp &amp; ZIP_GP_FLAG_PKWARE_ENHANCED_COMP ;
    out1 &quot;[Bit 13]&quot;, &quot;1 'Encrypted Central Dir'&quot;  if $gp &amp; ZIP_GP_FLAG_ENCRYPTED_CD ;

    return ();
}


sub seekSet
{
    my $fh = $_[0] ;
    my $size = $_[1];

    use Fcntl qw(SEEK_SET);
    seek($fh, $size, SEEK_SET);

}

sub skip
{
    my $fh = $_[0] ;
    my $size = $_[1];

    use Fcntl qw(SEEK_CUR);
    seek($fh, $size, SEEK_CUR);

}


sub myRead
{
    my $got = \$_[0] ;
    my $size = $_[1];

    my $wantSize = $size;
    $$got = '';

    if ($size == 0)
    {
        return ;
    }

    if ($size &gt; 0)
    {
        my $buff ;
        my $status = $FH-&gt;read($buff, $size);
        return $status
            if $status &lt; 0;
        $$got .= $buff ;
    }

    my $len = length $$got;
    # fatal undef, &quot;Truncated file (got $len, wanted $wantSize): $!&quot;
    fatal undef, &quot;Unexpected zip file truncation&quot;,
                expectedMessage($wantSize, $len)
        if length $$got != $wantSize;
}

sub expectedMessage
{
    my $expected = shift;
    my $got = shift;
    return &quot;Expected &quot; . decimalHex0x($expected) . &quot; bytes, but only &quot; . decimalHex0x($got) . &quot; available&quot;
}

sub need
{
    my $byteCount = shift ;
    my $message = shift ;
    my $field = shift // '';

    # return $FILELEN - $FH-&gt;tell() &gt;= $byteCount;
    my $here = $FH-&gt;tell() ;
    my $available = $FILELEN - $here ;
    if ($available &lt; $byteCount)
    {
        my @message ;

        if ($field)
        {
            push @message, &quot;Unexpected zip file truncation while reading '$field' field in '$message'&quot;;
        }
        else
        {
            push @message, &quot;Unexpected zip file truncation while reading '$message'&quot;;
        }


        push @message, expectedMessage($byteCount, $available);
        # push @message, sprintf(&quot;Expected 0x%X bytes, but only 0x%X available&quot;, $byteCount, $available);
        push @message, &quot;Try running with --walk' or '--scan' options&quot;
            if ! $opt_scan &amp;&amp; ! $opt_walk ;

        fatal $here, @message;
    }
}

sub testPossiblePrefix
{
    my $offset = shift;
    my $expectedSignature = shift ;

    if (testPossiblePrefixNoPREFIX_DELTA($offset, $expectedSignature))
    {
        $PREFIX_DELTA = $POSSIBLE_PREFIX_DELTA;
        $POSSIBLE_PREFIX_DELTA = 0;

        reportPrefixData();

        return 1
    }

    return 0
}

sub testPossiblePrefixNoPREFIX_DELTA
{
    my $offset = shift;
    my $expectedSignature = shift ;

    return 0
        if $offset + 4 &gt; $FILELEN || ! $POSSIBLE_PREFIX_DELTA || $PREFIX_DELTA;

    my $currentOFFSET = $OFFSET;
    my $gotSig = readSignatureFromOffset($offset);

    if ($gotSig == $expectedSignature)
    {
        # do have possible prefix data, but the offset is correct
        $POSSIBLE_PREFIX_DELTA = $PREFIX_DELTA = 0;
        $OFFSET = $currentOFFSET;

        return 0;
    }

    $gotSig = readSignatureFromOffset($offset + $POSSIBLE_PREFIX_DELTA);

    $OFFSET = $currentOFFSET;

    return  ($gotSig == $expectedSignature) ;
}

sub offsetIsValid
{
    my $offset = shift;
    my $headerStart = shift;
    my $centralDirSize = shift;
    my $commonMessage = shift ;
    my $expectedSignature = shift ;
    my $dereferencePointer = shift;

    my $must_point_back = 1;

    my $delta = $offset - $FILELEN + 1 ;

    $offset += $PREFIX_DELTA
        if $PREFIX_DELTA ;

    return sprintf(&quot;value %s is %s bytes past EOF&quot;, decimalHex0x($offset), decimalHex0x($delta))
        if $delta &gt; 0 ;

    return sprintf &quot;value %s must be less that %s&quot;, decimalHex0x($offset), decimalHex0x($headerStart)
        if $must_point_back &amp;&amp; $offset &gt;= $headerStart;

    if ($dereferencePointer)
    {
        my $actual = $headerStart - $centralDirSize;
        my $cdSizeOK = ($actual == $offset);
        my $possibleDelta = $actual - $offset;

        if ($centralDirSize &amp;&amp; ! $cdSizeOK &amp;&amp; $possibleDelta &gt; 0 &amp;&amp; readSignatureFromOffset($possibleDelta) == ZIP_LOCAL_HDR_SIG)
        {
            # If testing end of central dir, check if the location of the first CD header
            # is consistent with the central dir size.
            # Common use case is a SFX zip file

            my $gotSig = readSignatureFromOffset($actual);
            my $v = hexValue32($gotSig);
            return 'value @ ' .  hexValue($actual) . &quot; should decode to signature for &quot; . Signatures::nameAndHex($expectedSignature) . &quot;. Got $v&quot; # . hexValue32($gotSig)
                if $gotSig != $expectedSignature ;

            $PREFIX_DELTA = $possibleDelta;
            reportPrefixData();

            return undef;
        }
        else
        {
            my $gotSig = readSignatureFromOffset($offset);
            my $v = hexValue32($gotSig);
            return 'value @ ' .  hexValue($offset) . &quot; should decode to signature for &quot; . Signatures::nameAndHex($expectedSignature) . &quot;. Got $v&quot; # . hexValue32($gotSig)
                if $gotSig != $expectedSignature ;
        }
    }

    return undef ;
}

sub checkOffsetValue
{
    my $offset = shift;
    my $headerStart = shift;
    my $centralDirSize = shift;
    my $commonMessage = shift ;
    my $messageOffset = shift;
    my $expectedSignature = shift ;
    my $fatal = shift // 0;
    my $dereferencePointer = shift // 1;

    my $keepOFFSET = $OFFSET ;

    my $message = offsetIsValid($offset, $headerStart, $centralDirSize, $commonMessage, $expectedSignature, $dereferencePointer);
    if ($message)
    {
        fatal_tryWalk($messageOffset, $commonMessage, $message)
            if $fatal;

        error $messageOffset, $commonMessage, $message
            if ! $fatal;
    }

    $OFFSET = $keepOFFSET;

    return $offset + $PREFIX_DELTA;

}

sub fatal_tryWalk
{
    my $offset   = shift ;
    my $message = shift;

    fatal($offset, $message, @_, &quot;Try running with --walk' or '--scan' options&quot;);
}

sub fatal
{
    my $offset   = shift ;
    my $message = shift;

    return if $fatalDisabled;

    if (defined $offset)
    {
        warn &quot;#\n# FATAL: Offset &quot; . hexValue($offset) . &quot;: $message\n&quot;;
    }
    else
    {
        warn &quot;#\n# FATAL: $message\n&quot;;
    }

    warn  &quot;#        $_ . \n&quot;
        for @_;
    warn &quot;#\n&quot; ;

    exit 1;
}

sub disableFatal
{
    $fatalDisabled = 1 ;
}

sub enableFatal
{
    $fatalDisabled = 0 ;
}

sub topLevelFatal
{
    my $message = shift ;

    no warnings 'utf8';

    warn &quot;FATAL: $message\n&quot;;

    warn  &quot;$_ . \n&quot;
        for @_;

    exit 1;
}

sub internalFatal
{
    my $offset   = shift ;
    my $message = shift;

    no warnings 'utf8';

    if (defined $offset)
    {
        warn &quot;# FATAL: Offset &quot; . hexValue($offset) . &quot;: Internal Error: $message\n&quot;;
    }
    else
    {
        warn &quot;# FATAL: Internal Error: $message\n&quot;;
    }

    warn &quot;#        $_ \n&quot;
        for @_;

    warn &quot;#        Please report error at https://github.com/pmqs/zipdetails/issues\n&quot;;
    exit 1;
}

sub warning
{
    my $offset   = shift ;
    my $message  = shift;

    no warnings 'utf8';

    return
        unless $opt_want_warning_mesages ;

    say &quot;#&quot;
        unless $lastWasMessage ++ ;

    if (defined $offset)
    {
        say &quot;# WARNING: Offset &quot; . hexValue($offset) . &quot;: $message&quot;;
    }
    else
    {
        say &quot;# WARNING: $message&quot;;
    }


    say &quot;#          $_&quot; for @_ ;
    say &quot;#&quot;;
    ++ $WarningCount ;

    $exit_status_code |= 2
        if $opt_want_message_exit_status ;
}

sub error
{
    my $offset   = shift ;
    my $message  = shift;

    no warnings 'utf8';

    return
        unless $opt_want_error_mesages ;

    say &quot;#&quot;
        unless $lastWasMessage ++ ;

    if (defined $offset)
    {
        say &quot;# ERROR: Offset &quot; . hexValue($offset) . &quot;: $message&quot;;
    }
    else
    {
        say &quot;# ERROR: $message&quot;;
    }


    say &quot;#        $_&quot; for @_ ;
    say &quot;#&quot;;

    ++ $ErrorCount ;

    $exit_status_code |= 4
        if $opt_want_message_exit_status ;
}

sub debug
{
    my $offset   = shift ;
    my $message  = shift;

    no warnings 'utf8';

    say &quot;#&quot;
        unless $lastWasMessage ++ ;

    if (defined $offset)
    {
        say &quot;# DEBUG: Offset &quot; . hexValue($offset) . &quot;: $message&quot;;
    }
    else
    {
        say &quot;# DEBUG: $message&quot;;
    }


    say &quot;#        $_&quot; for @_ ;
    say &quot;#&quot;;
}

sub internalError
{
    my $message  = shift;

    no warnings 'utf8';

    say &quot;#&quot;;
    say &quot;# ERROR: $message&quot;;
    say &quot;#        $_&quot; for @_ ;
    say &quot;#        Please report error at https://github.com/pmqs/zipdetails/issues&quot;;
    say &quot;#&quot;;

    ++ $ErrorCount ;
}

sub reportPrefixData
{
    my $delta = shift // $PREFIX_DELTA ;
    state $reported = 0;
    return if $reported || $delta == 0;

    info 0, &quot;found &quot; . decimalHex0x($delta) . &quot; bytes before beginning of zipfile&quot; ;
    $reported = 1;
}

sub info
{
    my $offset   = shift;
    my $message  = shift;

    no warnings 'utf8';

    return
        unless $opt_want_info_mesages ;

    say &quot;#&quot;
        unless $lastWasMessage ++ ;

    if (defined $offset)
    {
        say &quot;# INFO: Offset &quot; . hexValue($offset) . &quot;: $message&quot;;
    }
    else
    {
        say &quot;# INFO: $message&quot;;
    }

    say &quot;#       $_&quot; for @_ ;
    say &quot;#&quot;;

    ++ $InfoCount ;

    $exit_status_code |= 1
        if $opt_want_message_exit_status ;
}

sub walkExtra
{
    # APPNOTE 6.3.10, sec 4.4.11, 4.4.28, 4.5
    my $XLEN = shift;
    my $entry = shift;

    # Caller has determined that there are $XLEN bytes available to read

    my $buff ;
    my $offset = 0 ;

    my $id;
    my $subLen;
    my $payload ;

    my $count = 0 ;
    my $endExtraOffset = $FH-&gt;tell() + $XLEN ;

    while ($offset &lt; $XLEN) {

        ++ $count;

        # Detect if there is not enough data for an extra ID and length.
        # Android zipalign and zipflinger are prime candidates for these
        # non-standard extra sub-fields.
        my $remaining = $XLEN - $offset;
        if ($remaining &lt; ZIP_EXTRA_SUBFIELD_HEADER_SIZE) {
            # There is not enough left.
            # Consume whatever is there and return so parsing
            # can continue.

            myRead($payload, $remaining);
            my $data = hexDump($payload);

            if ($payload =~ /^\x00+$/)
            {
                # All nulls
                out $payload, &quot;Null Padding in Extra&quot;;
                info $FH-&gt;tell() - length($payload), decimalHex0x(length $payload) . &quot; Null Padding Bytes in Extra Field&quot; ;
            }
            else
            {
                out $payload, &quot;Extra Data&quot;, $data;
                error $FH-&gt;tell() - length($payload), &quot;'Extra Data' Malformed&quot;;
            }

            return undef;
        }

        myRead($id, ZIP_EXTRA_SUBFIELD_ID_SIZE);
        $offset += ZIP_EXTRA_SUBFIELD_ID_SIZE;
        my $lookID = unpack &quot;v&quot;, $id ;
        if ($lookID == 0)
        {
            # check for null padding at end of extra
            my $here = $FH-&gt;tell();
            my $rest;
            myRead($rest, $XLEN - $offset);
            if ($rest =~ /^\x00+$/)
            {
                my $len = length ($id . $rest) ;
                out $id . $rest, &quot;Null Padding in Extra&quot;;
                info $FH-&gt;tell() - $len, decimalHex0x($len) . &quot; Null Padding Bytes in Extra Field&quot;;
                return undef;
            }

            seekTo($here);
        }

        my ($who, $decoder, $local_min, $local_max, $central_min, $central_max) =  @{ $Extras{$lookID} // ['', undef, undef,  undef,  undef, undef ] };

        my $idString =  Value_v($lookID) ;
        $idString .=  &quot; '$who'&quot;
            if $who;

        out $id, &quot;Extra ID #$count&quot;, $idString ;
        info $FH-&gt;tell() - 2, &quot;Unknown Extra ID $idString&quot;
            if ! exists $Extras{$lookID} ;

        myRead($buff, ZIP_EXTRA_SUBFIELD_LEN_SIZE);
        $offset += ZIP_EXTRA_SUBFIELD_LEN_SIZE;

        $subLen =  unpack(&quot;v&quot;, $buff);
        out2 $buff, &quot;Length&quot;, Value_v($subLen) ;

        $remaining = $XLEN - $offset;
        if ($subLen &gt; $remaining )
        {
            error $FH-&gt;tell() -2,
                  extraFieldIdentifier($lookID) . &quot;: 'Length' field invalid&quot;,
                  sprintf(&quot;value %s &gt; %s bytes remaining&quot;, decimalHex0x($subLen), decimalHex0x($remaining));
            outSomeData $remaining, &quot;  Extra Payload&quot;;
            return undef;
        }

        if (! defined $decoder)
        {
            if ($subLen)
            {
                myRead($payload, $subLen);
                my $data = hexDump16($payload);

                out2 $payload, &quot;Extra Payload&quot;, $data;
            }
        }
        else
        {
            if (testExtraLimits($lookID, $subLen, $entry-&gt;inCentralDir))
            {
                my $endExtraOffset = $FH-&gt;tell() + $subLen;
                $decoder-&gt;($lookID, $subLen, $entry) ;

                # Belt &amp; Braces - should now be at $endExtraOffset
                # error here means issue in an extra handler
                # should noy happen, but just in case
                # TODO -- need tests for this
                my $here = $FH-&gt;tell() ;
                if ($here &gt; $endExtraOffset)
                {
                    # gone too far, so need to bomb out now
                    internalFatal $here, &quot;Overflow processing &quot; . extraFieldIdentifier($lookID) . &quot;.&quot;,
                                  sprintf(&quot;Should be at offset %s, actually at %s&quot;, decimalHex0x($endExtraOffset),  decimalHex0x($here));
                }
                elsif ($here &lt; $endExtraOffset)
                {
                    # not gone far enough, can recover
                    error $here,
                            sprintf(&quot;Expected to be at offset %s after processing %s, actually at %s&quot;, decimalHex0x($endExtraOffset),  extraFieldIdentifier($lookID), decimalHex0x($here)),
                            &quot;Skipping &quot; . decimalHex0x($endExtraOffset - $here) . &quot; bytes&quot;;
                    outSomeData $endExtraOffset - $here, &quot;  Extra Data&quot;;
                }
            }
        }

        $offset += $subLen ;
    }

    return undef ;
}

sub testExtraLimits
{
    my $lookID = shift;
    my $size = shift;
    my $inCentralDir = shift;

    my ($who, undef, $local_min, $local_max, $central_min, $central_max) =  @{ $Extras{$lookID} // ['', undef, undef,  undef,  undef, undef ] };

    my ($min, $max) = $inCentralDir
                        ? ($central_min, $central_max)
                        : ($local_min, $local_max) ;

    return 1
        if ! defined $min &amp;&amp; ! defined $max ;

    if (defined $min &amp;&amp; defined $max)
    {
        # both the same
        if ($min == $max)
        {
            if ($size != $min)
            {
                error $FH-&gt;tell() -2, sprintf &quot;%s: 'Length' field invalid: expected %s, got %s&quot;, extraFieldIdentifier($lookID), decimalHex0x($min),  decimalHex0x($size);
                outSomeData $size, &quot;  Extra Payload&quot; if $size;
                return 0;
            }
        }
        else # min != max
        {
            if ($size &lt; $min || $size &gt; $max)
            {
                error $FH-&gt;tell() -2, sprintf &quot;%s: 'Length' field invalid: value must be betweem %s and %s, got %s&quot;, extraFieldIdentifier($lookID), decimalHex0x($min), decimalHex0x($max), decimalHex0x($size);
                outSomeData $size, &quot;  Extra Payload&quot; if $size ;
                return 0;
            }
        }

    }
    else # must be defined $min &amp; undefined max
    {
        if ($size &lt; $min)
        {
            error $FH-&gt;tell() -2, sprintf &quot;%s: 'Length' field invalid: value must be at least %s, got %s&quot;, extraFieldIdentifier($lookID), decimalHex0x($min),  decimalHex0x($size);
            outSomeData $size, &quot;  Extra Payload&quot; if $size;
            return 0;
        }
    }

    return 1;

}

sub full32
{
    return ($_[0] // 0) == MAX32 ;
}

sub full16
{
    return ($_[0] // 0) == MAX16 ;
}

sub decode_Zip64
{
    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    myRead(my $payload, $len);
    if ($entry-&gt;inCentralDir() )
    {
        walk_Zip64_in_CD($extraID, $payload, $entry, 1) ;
    }
    else
    {
        walk_Zip64_in_LD($extraID, $payload, $entry, 1) ;

    }
}

sub walk_Zip64_in_LD
{
    my $extraID = shift ;
    my $zip64Extended = shift;
    my $entry = shift;
    my $display = shift // 1 ;

    my $fieldStart = $FH-&gt;tell() - length $zip64Extended;
    my $fieldOffset = $fieldStart ;

    $ZIP64 = 1;
    $entry-&gt;zip64(1);

    if (length $zip64Extended == 0)
    {
        info $fieldOffset, extraFieldIdentifier($extraID) .  &quot;: Length is Zero&quot;;
        return;
    }

    my $assumeLengthsPresent   = (length($zip64Extended) == 16) ;
    my $assumeAllFieldsPresent = (length($zip64Extended) == 28) ;

    if ($assumeLengthsPresent || $assumeAllFieldsPresent || full32 $entry-&gt;std_uncompressedSize )
    {
        # TODO defer a warning if in local header &amp; central/local don't have std_uncompressedSizeset to 0xffffffff
        if (length $zip64Extended &lt; 8)
        {
            my $message = extraFieldIdentifier($extraID) .  &quot;: Expected &quot; . decimalHex0x(8) . &quot; bytes for 'Uncompressed Size': only &quot; . decimalHex0x(length $zip64Extended)  . &quot; bytes present&quot;;
            error $fieldOffset, $message;
            out2 $zip64Extended, $message;
            return;
        }

        $fieldOffset += 8;
        my $data = substr($zip64Extended, 0, 8, &quot;&quot;) ;
        $entry-&gt;uncompressedSize(unpack &quot;Q&lt;&quot;, $data);
        out2 $data, &quot;Uncompressed Size&quot;, Value_Q($entry-&gt;uncompressedSize)
            if $display;
    }

    if ($assumeLengthsPresent || $assumeAllFieldsPresent || full32 $entry-&gt;std_compressedSize)
    {
        if (length $zip64Extended &lt; 8)
        {
            my $message = extraFieldIdentifier($extraID) .  &quot;: Expected &quot; . decimalHex0x(8) . &quot; bytes for 'Compressed Size': only &quot; . decimalHex0x(length $zip64Extended)  . &quot; bytes present&quot;;
            error $fieldOffset, $message;
            out2 $zip64Extended, $message;
            return;
        }

        $fieldOffset += 8;

        my $data = substr($zip64Extended, 0, 8, &quot;&quot;) ;
        $entry-&gt;compressedSize( unpack &quot;Q&lt;&quot;, $data);
        out2 $data, &quot;Compressed Size&quot;, Value_Q($entry-&gt;compressedSize)
            if $display;
    }

    # Zip64 in local header should not have localHeaderOffset or disk number
    # but some zip files do

    if ($assumeAllFieldsPresent)
    {
        $fieldOffset += 8;

        my $data = substr($zip64Extended, 0, 8, &quot;&quot;) ;
        my $localHeaderOffset = unpack &quot;Q&lt;&quot;, $data;
        out2 $data, &quot;Offset to Local Dir&quot;, Value_Q($localHeaderOffset)
            if $display;
    }

    if ($assumeAllFieldsPresent)
    {
        $fieldOffset += 4;

        my $data = substr($zip64Extended, 0, 4, &quot;&quot;) ;
        my $diskNumber = unpack &quot;v&quot;, $data;
        out2 $data, &quot;Disk Number&quot;, Value_V($diskNumber)
            if $display;
    }

    if (length $zip64Extended)
    {
        if ($display)
        {
            out2 $zip64Extended, &quot;Unexpected Data&quot;, hexDump16 $zip64Extended ;
            info $fieldOffset, extraFieldIdentifier($extraID) .  &quot;: Unexpected Data: &quot; . decimalHex0x(length $zip64Extended) . &quot; bytes&quot;;
        }
    }

}

sub walk_Zip64_in_CD
{
    my $extraID = shift ;
    my $zip64Extended = shift;
    my $entry = shift;
    my $display = shift // 1 ;

    my $fieldStart = $FH-&gt;tell() - length $zip64Extended;
    my $fieldOffset = $fieldStart ;

    $ZIP64 = 1;
    $entry-&gt;zip64(1);

    if (length $zip64Extended == 0)
    {
        info $fieldOffset, extraFieldIdentifier($extraID) .  &quot;: Length is Zero&quot;;
        return;
    }

    my $assumeAllFieldsPresent = (length($zip64Extended) == 28) ;

    if ($assumeAllFieldsPresent || full32 $entry-&gt;std_uncompressedSize )
    {
        if (length $zip64Extended &lt; 8)
        {
            my $message = extraFieldIdentifier($extraID) .  &quot;: Expected &quot; . decimalHex0x(8) . &quot; bytes for 'Uncompressed Size': only &quot; . decimalHex0x(length $zip64Extended)  . &quot; bytes present&quot;;
            error $fieldOffset, $message;
            out2 $zip64Extended, $message;
            return;
        }

        $fieldOffset += 8;
        my $data = substr($zip64Extended, 0, 8, &quot;&quot;) ;
        $entry-&gt;uncompressedSize(unpack &quot;Q&lt;&quot;, $data);
        out2 $data, &quot;Uncompressed Size&quot;, Value_Q($entry-&gt;uncompressedSize)
            if $display;
    }

    if ($assumeAllFieldsPresent || full32 $entry-&gt;std_compressedSize)
    {
        if (length $zip64Extended &lt; 8)
        {
            my $message = extraFieldIdentifier($extraID) .  &quot;: Expected &quot; . decimalHex0x(8) . &quot; bytes for 'Compressed Size': only &quot; . decimalHex0x(length $zip64Extended)  . &quot; bytes present&quot;;
            error $fieldOffset, $message;
            out2 $zip64Extended, $message;
            return;
        }

        $fieldOffset += 8;

        my $data = substr($zip64Extended, 0, 8, &quot;&quot;) ;
        $entry-&gt;compressedSize(unpack &quot;Q&lt;&quot;, $data);
        out2 $data, &quot;Compressed Size&quot;, Value_Q($entry-&gt;compressedSize)
            if $display;
    }

    if ($assumeAllFieldsPresent || full32 $entry-&gt;std_localHeaderOffset)
    {
        if (length $zip64Extended &lt; 8)
        {
            my $message = extraFieldIdentifier($extraID) .  &quot;: Expected &quot; . decimalHex0x(8) . &quot; bytes for 'Offset to Local Dir': only &quot; . decimalHex0x(length $zip64Extended)  . &quot; bytes present&quot;;
            error $fieldOffset, $message;
            out2 $zip64Extended, $message;
            return;
        }

        $fieldOffset += 8;

        my $here = $FH-&gt;tell();
        my $data = substr($zip64Extended, 0, 8, &quot;&quot;) ;
        $entry-&gt;localHeaderOffset(unpack &quot;Q&lt;&quot;, $data);
        out2 $data, &quot;Offset to Local Dir&quot;, Value_Q($entry-&gt;localHeaderOffset)
            if $display;

        my $commonMessage = &quot;'Offset to Local Dir' field in 'Zip64 Extra Field' is invalid&quot;;
        $entry-&gt;localHeaderOffset(checkOffsetValue($entry-&gt;localHeaderOffset, $fieldStart, 0, $commonMessage, $fieldStart, ZIP_LOCAL_HDR_SIG, 0) );
    }

    if ($assumeAllFieldsPresent || full16 $entry-&gt;std_diskNumber)
    {
        if (length $zip64Extended &lt; 4)
        {
            my $message = extraFieldIdentifier($extraID) .  &quot;: Expected &quot; . decimalHex0x(4) . &quot; bytes for 'Disk Number': only &quot; . decimalHex0x(length $zip64Extended)  . &quot; bytes present&quot;;
            error $fieldOffset, $message;
            out2 $zip64Extended, $message;
            return;
        }

        $fieldOffset += 4;

        my $here = $FH-&gt;tell();
        my $data = substr($zip64Extended, 0, 4, &quot;&quot;) ;
        $entry-&gt;diskNumber(unpack &quot;v&quot;, $data);
        out2 $data, &quot;Disk Number&quot;, Value_V($entry-&gt;diskNumber)
            if $display;
        $entry-&gt;zip64_diskNumberPresent(1);
    }

    if (length $zip64Extended)
    {
        if ($display)
        {
            out2 $zip64Extended, &quot;Unexpected Data&quot;, hexDump16 $zip64Extended ;
            info $fieldOffset, extraFieldIdentifier($extraID) .  &quot;: Unexpected Data: &quot; . decimalHex0x(length $zip64Extended) . &quot; bytes&quot;;
        }
    }
}

sub Ntfs2Unix
{
    my $m = shift;
    my $v = shift;

    # NTFS offset is 19DB1DED53E8000

    my $hex = Value_Q($v) ;

    # Treat empty value as special case
    # Could decode to 1 Jan 1601
    return &quot;$hex 'No Date/Time'&quot;
        if $v == 0;

    $v -= 0x19DB1DED53E8000 ;
    my $ns = ($v % 10000000) * 100;
    my $elapse = int ($v/10000000);
    return &quot;$hex '&quot; . getT($elapse) .
           &quot; &quot; . sprintf(&quot;%0dns'&quot;, $ns);
}

sub decode_NTFS_Filetimes
{
    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    out_V &quot;  Reserved&quot;;
    out_v &quot;  Tag1&quot;;
    out_v &quot;  Size1&quot; ;

    my ($m, $s1) = read_Q;
    out $m, &quot;  Mtime&quot;, Ntfs2Unix($m, $s1);

    my ($a, $s3) = read_Q;
    out $a, &quot;  Atime&quot;, Ntfs2Unix($a, $s3);

    my ($c, $s2) = read_Q;
    out $c, &quot;  Ctime&quot;, Ntfs2Unix($c, $s2);
}

sub OpenVMS_DateTime
{
    my $ix = shift;
    my $tag = shift;
    my $size = shift;

    # VMS epoch is 17 Nov 1858
    # Offset to Unix Epoch is -0x7C95674C3DA5C0 (-35067168005400000)

    my ($data, $value) = read_Q();

    my $datetime = &quot;No Date Time'&quot;;
    if ($value != 0)
    {
        my $v =  $value - 0x007C95674C3DA5C0 ;
        my $ns = ($v % 10000000) * 100 ;
        my $seconds = int($v / 10000000) ;
        $datetime = getT($seconds) .
           &quot; &quot; . sprintf(&quot;%0dns'&quot;, $ns);
    }

    out2 $data, &quot;  Attribute&quot;, Value_Q($value) . &quot; '$datetime&quot;;
}

sub OpenVMS_DumpBytes
{
    my $ix = shift;
    my $tag = shift;
    my $size = shift;

    myRead(my $data, $size);

    out($data, &quot;    Attribute&quot;, hexDump16($data));

}

sub OpenVMS_4ByteValue
{
    my $ix = shift;
    my $tag = shift;
    my $size = shift;

    my ($data, $value) = read_V();

    out2 $data, &quot;  Attribute&quot;, Value_V($value);
}

sub OpenVMS_UCHAR
{
    my $ix = shift;
    my $tag = shift;
    my $size = shift;

    state $FCH = {
        0     =&gt; 'FCH$M_WASCONTIG',
        1     =&gt; 'FCH$M_NOBACKUP',
        2     =&gt; 'FCH$M_WRITEBACK',
        3     =&gt; 'FCH$M_READCHECK',
        4     =&gt; 'FCH$M_WRITCHECK',
        5     =&gt; 'FCH$M_CONTIGB',
        6     =&gt; 'FCH$M_LOCKED',
        6     =&gt; 'FCH$M_CONTIG',
        11    =&gt; 'FCH$M_BADACL',
        12    =&gt; 'FCH$M_SPOOL',
        13    =&gt; 'FCH$M_DIRECTORY',
        14    =&gt; 'FCH$M_BADBLOCK',
        15    =&gt; 'FCH$M_MARKDEL',
        16    =&gt; 'FCH$M_NOCHARGE',
        17    =&gt; 'FCH$M_ERASE',
        18    =&gt; 'FCH$M_SHELVED',
        20    =&gt; 'FCH$M_SCRATCH',
        21    =&gt; 'FCH$M_NOMOVE',
        22    =&gt; 'FCH$M_NOSHELVABLE',
    } ;

    my ($data, $value) = read_V();

    out2 $data, &quot;  Attribute&quot;, Value_V($value);

    for my $bit ( sort { $a &lt;=&gt; $b } keys %{ $FCH } )
    {
        # print &quot;$bit\n&quot;;
        if ($value &amp; (1 &lt;&lt; $bit) )
        {
            out1 &quot;      [Bit $bit]&quot;, $FCH-&gt;{$bit} ;
        }
    }
}

sub OpenVMS_2ByteValue
{
    my $ix = shift;
    my $tag = shift;
    my $size = shift;

    my ($data, $value) = read_v();

    out2 $data, &quot;  Attribute&quot;, Value_v($value);
}

sub OpenVMS_revision
{
    my $ix = shift;
    my $tag = shift;
    my $size = shift;

    my ($data, $value) = read_v();

    out2 $data, &quot;  Attribute&quot;, Value_v($value) . &quot;'Revision Count &quot; . Value_v($value) . &quot;'&quot;;
}

sub decode_OpenVMS
{
    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    state $openVMS_tags = {
        0x04    =&gt; [ 'ATR$C_RECATTR',   \&amp;OpenVMS_DumpBytes  ],
        0x03    =&gt; [ 'ATR$C_UCHAR',     \&amp;OpenVMS_UCHAR      ],
        0x11    =&gt; [ 'ATR$C_CREDATE',   \&amp;OpenVMS_DateTime   ],
        0x12    =&gt; [ 'ATR$C_REVDATE',   \&amp;OpenVMS_DateTime   ],
        0x13    =&gt; [ 'ATR$C_EXPDATE',   \&amp;OpenVMS_DateTime   ],
        0x14    =&gt; [ 'ATR$C_BAKDATE',   \&amp;OpenVMS_DateTime   ],
        0x0D    =&gt; [ 'ATR$C_ASCDATES',  \&amp;OpenVMS_revision   ],
        0x15    =&gt; [ 'ATR$C_UIC',       \&amp;OpenVMS_4ByteValue ],
        0x16    =&gt; [ 'ATR$C_FPRO',      \&amp;OpenVMS_DumpBytes  ],
        0x17    =&gt; [ 'ATR$C_RPRO',      \&amp;OpenVMS_2ByteValue ],
        0x1D    =&gt; [ 'ATR$C_JOURNAL',   \&amp;OpenVMS_DumpBytes  ],
        0x1F    =&gt; [ 'ATR$C_ADDACLENT', \&amp;OpenVMS_DumpBytes  ],
    } ;

    out_V &quot;  CRC&quot;;
    $len -= 4;

    my $ix = 1;
    while ($len)
    {
        my ($data, $tag) = read_v();
        my $tagname = 'Unknown Tag';
        my $decoder = undef;

        if ($openVMS_tags-&gt;{$tag})
        {
            ($tagname, $decoder) = @{ $openVMS_tags-&gt;{$tag} } ;
        }

        out2 $data,  &quot;Tag #$ix&quot;, Value_v($tag) . &quot; '&quot; . $tagname . &quot;'&quot; ;
        my $size = out_v &quot;    Size&quot;;

        if (defined $decoder)
        {
            $decoder-&gt;($ix, $tag, $size) ;
        }
        else
        {
            outSomeData($size, &quot;    Attribute&quot;);
        }

        ++ $ix;
        $len -= $size + 2 + 2;
    }

}

sub getT
{
    my $time = shift ;

    if ($opt_utc)
     { return scalar gmtime($time) // 'Unknown'}
    else
     { return scalar localtime($time) // 'Unknown' }
}

sub getTime
{
    my $time = shift ;

    return &quot;'Invalid Date or Time'&quot;
        if ! defined $time;

    return &quot;'&quot; . getT($time) . &quot;'&quot;;
}

sub LastModTime
{
    my $value = shift ;

    return &quot;'No Date/Time'&quot;
        if $value == 0;

    return getTime(_dosToUnixTime($value))
}

sub _dosToUnixTime
{
    my $dt = shift;

    # Mozilla xpi files have empty datetime
    # This is not a valid Dos datetime value
    return 0 if $dt == 0 ;

    my $year = ( ( $dt &gt;&gt; 25 ) &amp; 0x7f ) + 80;
    my $mon  = ( ( $dt &gt;&gt; 21 ) &amp; 0x0f ) - 1;
    my $mday = ( ( $dt &gt;&gt; 16 ) &amp; 0x1f );

    my $hour = ( ( $dt &gt;&gt; 11 ) &amp; 0x1f );
    my $min  = ( ( $dt &gt;&gt; 5  ) &amp; 0x3f );
    my $sec  = ( ( $dt &lt;&lt; 1  ) &amp; 0x3e );

    use Time::Local ;
    my $time_t;
    eval
    {
        # Use eval to catch crazy dates
        $time_t = Time::Local::timegm( $sec, $min, $hour, $mday, $mon, $year);
    }
    or do
    {
        my $dosDecode = $year+1900 . sprintf &quot;-%02u-%02u %02u:%02u:%02u&quot;, $mon, $mday, $hour, $min, $sec;
        warning $FH-&gt;tell(), &quot;'Modification Time' value &quot; . decimalHex0x($dt, 4) .  &quot;  decodes to '$dosDecode': not a valid DOS date/time&quot; ;
        return undef
    };

    return $time_t;

}

sub decode_UT
{
    # 0x5455 'UT: Extended Timestamp'

    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    # Definition in IZ APPNOTE

    # NOTE: Although the IZ appnote says that the central directory
    #       doesn't store the Acces &amp; Creation times, there are
    #       some implementations that do poopulate the CD incorrectly.

    # Caller has determined that at least one byte is available

    # When $full is true assume all timestamps are present
    my $full = ($len == 13) ;

    my $remaining = $len;

    my ($data, $flags) = read_C();

    my $v = Value_C $flags;
    my @f ;
    push @f, &quot;Modification&quot;    if $flags &amp; 1;
    push @f, &quot;Access&quot; if $flags &amp; 2;
    push @f, &quot;Creation&quot; if $flags &amp; 4;
    $v .= &quot; '&quot; . join(' ', @f) . &quot;'&quot;
        if @f;

    out $data, &quot;  Flags&quot;, $v;

    info $FH-&gt;tell() - 1, extraFieldIdentifier($extraID) . &quot;: Reserved bits set in 'Flags' field&quot;
        if $flags &amp; ~0x7;

    -- $remaining;

    if ($flags &amp; 1 || $full)
    {
        if ($remaining == 0 )
        {
            # Central Dir only has Modification Time
            error $FH-&gt;tell(), extraFieldIdentifier($extraID) . &quot;: Missing field 'Modification Time'&quot; ;
            return;
        }
        else
        {
            info $FH-&gt;tell(), extraFieldIdentifier($extraID) .  &quot;: Unexpected 'Modification Time' present&quot;
                if ! ($flags &amp; 1)  ;

            if ($remaining &lt; 4)
            {
                outSomeData $remaining, &quot;  Extra Data&quot;;
                error $FH-&gt;tell() - $remaining,
                    extraFieldIdentifier($extraID) .  &quot;: Truncated reading 'Modification Time'&quot;,
                    expectedMessage(4, $remaining);
                return;
            }

            my ($data, $time) = read_V();

            out2 $data, &quot;Modification Time&quot;,    Value_V($time) . &quot; &quot; . getTime($time) ;

            $remaining -= 4 ;
        }
    }

    # The remaining sub-fields are only present in the Local Header

    if ($flags &amp; 2 || $full)
    {
        if ($remaining == 0 &amp;&amp; $entry-&gt;inCentralDir)
        {
            # Central Dir doesn't have access time
        }
        else
        {
            info $FH-&gt;tell(), extraFieldIdentifier($extraID) . &quot;: Unexpected 'Access Time' present&quot;
                if ! ($flags &amp; 2) || $entry-&gt;inCentralDir ;

            if ($remaining &lt; 4)
            {
                outSomeData $remaining, &quot;  Extra Data&quot;;
                error $FH-&gt;tell() - $remaining,
                    extraFieldIdentifier($extraID) . &quot;: Truncated reading 'Access Time'&quot; ,
                    expectedMessage(4, $remaining);

                return;
            }

            my ($data, $time) = read_V();

            out2 $data, &quot;Access Time&quot;,    Value_V($time) . &quot; &quot; . getTime($time) ;
            $remaining -= 4 ;
        }
    }

    if ($flags &amp; 4  || $full)
    {
        if ($remaining == 0 &amp;&amp; $entry-&gt;inCentralDir)
        {
            # Central Dir doesn't have creation time
        }
        else
        {
            info $FH-&gt;tell(), extraFieldIdentifier($extraID) . &quot;: Unexpected 'Creation Time' present&quot;
                if ! ($flags &amp; 4) || $entry-&gt;inCentralDir ;

            if ($remaining &lt; 4)
            {
                outSomeData $remaining, &quot;  Extra Data&quot;;

                error  $FH-&gt;tell() - $remaining,
                    extraFieldIdentifier($extraID) . &quot;: Truncated reading 'Creation Time'&quot; ,
                    expectedMessage(4, $remaining);

                return;
            }

            my ($data, $time) = read_V();

            out2 $data, &quot;Creation Time&quot;,    Value_V($time) . &quot; &quot; . getTime($time) ;
        }
    }
}


sub decode_Minizip_Signature
{
    # 0x10c5 Minizip CMS Signature

    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    # Definition in https://github.com/zlib-ng/minizip-ng/blob/master/doc/mz_extrafield.md#cms-signature-0x10c5

    $CentralDirectory-&gt;setMiniZipEncrypted();

    if ($len == 0)
    {
        info $FH-&gt;tell() - 2, extraFieldIdentifier($extraID) . &quot;: Zero length Signature&quot;;
        return;
    }

    outHexdump($len, &quot;  Signature&quot;);

}

sub decode_Minizip_Hash
{
    # 0x1a51 Minizip Hash
    # Definition in https://github.com/zlib-ng/minizip-ng/blob/master/doc/mz_extrafield.md#hash-0x1a51

    # caller ckecks there are at least 4 bytes available
    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    state $Algorithm = {
            10 =&gt; 'MD5',
            20 =&gt; 'SHA1',
            23 =&gt; 'SHA256',
    };

    my $remaining = $len;

    $CentralDirectory-&gt;setMiniZipEncrypted();

    my ($data, $alg) = read_v();
    my $algorithm = $Algorithm-&gt;{$alg} // &quot;Unknown&quot;;

    out $data, &quot;  Algorithm&quot;, Value_v($alg) . &quot; '$algorithm'&quot;;
    if (! exists $Algorithm-&gt;{$alg})
    {
        info $FH-&gt;tell() - 2, extraFieldIdentifier($extraID) . &quot;: Unknown algorithm ID &quot; .Value_v($alg);
    }

    my ($d, $digestSize) = read_v();
    out $d, &quot;  Digest Size&quot;, Value_v($digestSize);

    $remaining -= 4;

    if ($digestSize == 0)
    {
        info $FH-&gt;tell() - 2, extraFieldIdentifier($extraID) . &quot;: Zero length Digest&quot;;
    }
    elsif ($digestSize &gt; $remaining)
    {
        error $FH-&gt;tell() - 2, extraFieldIdentifier($extraID) . &quot;: Digest Size &quot; . decimalHex0x($digestSize) . &quot; &gt;  &quot; . decimalHex0x($remaining) . &quot; bytes remaining in extra field&quot; ;
        $digestSize = $remaining ;
    }

    outHexdump($digestSize, &quot;  Digest&quot;);

    $remaining -= $digestSize;

    if ($remaining)
    {
        outHexdump($remaining, &quot;  Unexpected Data&quot;);
        error $FH-&gt;tell() - $remaining, extraFieldIdentifier($extraID) . &quot;: &quot; . decimalHex0x($remaining) . &quot; unexpected trailing bytes&quot; ;
    }
}

sub decode_Minizip_CD
{
    # 0xcdcd Minizip Central Directory
    # Definition in https://github.com/zlib-ng/minizip-ng/blob/master/doc/mz_extrafield.md#central-directory-0xcdcd

    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    $entry-&gt;minizip_secure(1);
    $CentralDirectory-&gt;setMiniZipEncrypted();

    my $size = out_Q &quot;  Entries&quot;;

 }

sub decode_AES
{
    # ref https://www.winzip.com/en/support/aes-encryption/
    # Document version: 1.04
    # Last modified: January 30, 2009

    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    return if $len == 0 ;

    my $validAES = 1;

    state $lookup = { 1 =&gt; &quot;AE-1&quot;, 2 =&gt; &quot;AE-2&quot; };
    my $vendorVersion = out_v &quot;  Vendor Version&quot;, sub {  $lookup-&gt;{$_[0]} || &quot;Unknown&quot;  } ;
    if (! $lookup-&gt;{$vendorVersion})
    {
        $validAES = 0;
        warning $FH-&gt;tell() - 2, extraFieldIdentifier($extraID) . &quot;: Unknown 'Vendor Version' $vendorVersion. Valid values are 1,2&quot;
    }

    my $id ;
    myRead($id, 2);
    my $idValue = out $id, &quot;  Vendor ID&quot;, unpackValue_v($id) . &quot; '$id'&quot;;

    if ($id ne 'AE')
    {
        $validAES = 0;
        warning $FH-&gt;tell() - 2, extraFieldIdentifier($extraID) . &quot;: Unknown 'Vendor ID' '$idValue'. Valid value is 'AE'&quot;
    }

    state $strengths = {1 =&gt; &quot;128-bit encryption key&quot;,
                        2 =&gt; &quot;192-bit encryption key&quot;,
                        3 =&gt; &quot;256-bit encryption key&quot;,
                       };

    my $strength = out_C &quot;  Encryption Strength&quot;, sub {$strengths-&gt;{$_[0]} || &quot;Unknown&quot; } ;

    if (! $strengths-&gt;{$strength})
    {
        $validAES = 0;
        warning $FH-&gt;tell() - 1, extraFieldIdentifier($extraID) . &quot;: Unknown 'Encryption Strength' $strength. Valid values are 1,2,3&quot;
    }

    my ($bmethod, $method) = read_v();
    out $bmethod, &quot;  Compression Method&quot;, compressionMethod($method) ;
    if (! defined $ZIP_CompressionMethods{$method})
    {
        $validAES = 0;
        warning $FH-&gt;tell() - 2, extraFieldIdentifier($extraID) . &quot;: Unknown 'Compression Method' ID &quot; . decimalHex0x($method, 2)
    }

    $entry-&gt;aesStrength($strength) ;
    $entry-&gt;aesValid($validAES) ;
}

sub decode_Reference
{
    # ref https://www.winzip.com/en/support/compression-methods/

    my $len = shift;
    my $entry = shift;

    out_V &quot;  CRC&quot;;
    myRead(my $uuid, 16);
    # UUID is big endian
    out2 $uuid, &quot;UUID&quot;,
        unpack('H*', substr($uuid, 0, 4)) . '-' .
        unpack('H*', substr($uuid, 4, 2)) . '-' .
        unpack('H*', substr($uuid, 6, 2)) . '-' .
        unpack('H*', substr($uuid, 8, 2)) . '-' .
        unpack('H*', substr($uuid, 10, 6)) ;
}

sub decode_DUMMY
{
    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    out_V &quot;  Data&quot;;
}

sub decode_GrowthHint
{
    # APPNOTE 6.3.10, sec 4.6.10

    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    # caller has checked that 4 bytes are available,
    # so can output values without checking available space
    out_v &quot;  Signature&quot; ;
    out_v &quot;  Initial Value&quot;;

    my $padding;
    myRead($padding, $len - 4);

    out2 $padding, &quot;Padding&quot;, hexDump16($padding);

    if ($padding !~ /^\x00+$/)
    {
        info $FH-&gt;tell(), extraFieldIdentifier($extraID) . &quot;: 'Padding' is not all NULL bytes&quot;;
    }
}

sub decode_DataStreamAlignment
{
    # APPNOTE 6.3.10, sec 4.6.11

    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    my $inCentralHdr = $entry-&gt;inCentralDir ;

    return if $len == 0 ;

    my ($data, $alignment) = read_v();

    out $data, &quot;  Alignment&quot;, Value_v($alignment) ;

    my $recompress_value = $alignment &amp; 0x8000 ? 1 : 0;

    my $recompressing = $recompress_value ? &quot;True&quot; : &quot;False&quot;;
    $alignment &amp;= 0x7FFF ;
    my $hexAl =  sprintf(&quot;%X&quot;, $alignment);

    out1 &quot;  [Bit   15]&quot;,  &quot;$recompress_value    'Recompress $recompressing'&quot;;
    out1 &quot;  [Bits 0-14]&quot;, &quot;$hexAl 'Minimal Alignment $alignment'&quot;;

    if (! $inCentralHdr &amp;&amp; $len - 2 &gt; 0)
    {
        my $padding;
        myRead($padding, $len - 2);

        out2 $padding, &quot;Padding&quot;, hexDump16($padding);
    }
}


sub decode_UX
{
    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    my $inCentralHdr = $entry-&gt;inCentralDir ;

    return if $len == 0 ;

    my ($data, $time) = read_V();
    out2 $data, &quot;Access Time&quot;, Value_V($time) . &quot; &quot; . getTime($time) ;

    ($data, $time) = read_V();
    out2 $data, &quot;Modification Time&quot;, Value_V($time) . &quot; &quot; . getTime($time) ;

    if (! $inCentralHdr ) {
        out_v &quot;  UID&quot; ;
        out_v &quot;  GID&quot;;
    }
}

sub decode_Ux
{
    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    return if $len == 0 ;
    out_v &quot;  UID&quot; ;
    out_v &quot;  GID&quot;;
}

sub decodeLitteEndian
{
    my $value = shift ;

    if (length $value == 8)
    {
        return unpackValueQ ($value)
    }
    elsif (length $value == 4)
    {
        return unpackValue_V ($value)
    }
    elsif (length $value == 2)
    {
        return unpackValue_v ($value)
    }
    elsif (length $value == 1)
    {
        return unpackValue_C ($value)
    }
    else {
        # TODO - fix this
        internalFatal undef, &quot;unsupported decodeLitteEndian length '&quot; . length ($value) . &quot;'&quot;;
    }
}

sub decode_ux
{
    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    # caller has checked that 3 bytes are available

    return if $len == 0 ;

    my $version = out_C &quot;  Version&quot; ;
    info  $FH-&gt;tell() - 1, extraFieldIdentifier($extraID) . &quot;: 'Version' should be &quot; . decimalHex0x(1) . &quot;, got &quot; . decimalHex0x($version, 1)
        if $version != 1 ;

    my $available = $len - 1 ;

    my $uidSize = out_C &quot;  UID Size&quot;;
    $available -= 1;

    if ($uidSize)
    {
        if ($available &lt; $uidSize)
        {
            outSomeData($available, &quot;  Bad Extra Data&quot;);
            error $FH-&gt;tell() - $available,
                extraFieldIdentifier($extraID) . &quot;: truncated reading 'UID'&quot;,
                expectedMessage($uidSize, $available);
            return;
        }

        myRead(my $data, $uidSize);
        out2 $data, &quot;UID&quot;, decodeLitteEndian($data);
        $available -= $uidSize ;
    }

    if ($available &lt; 1)
    {
        error $FH-&gt;tell(),
                    extraFieldIdentifier($extraID) . &quot;: truncated reading 'GID Size'&quot;,
                    expectedMessage($uidSize, $available);
        return ;
    }

    my $gidSize = out_C &quot;  GID Size&quot;;
    $available -= 1 ;
    if ($gidSize)
    {
        if ($available &lt; $gidSize)
        {
            outSomeData($available, &quot;  Bad Extra Data&quot;);
            error $FH-&gt;tell() - $available,
                        extraFieldIdentifier($extraID) . &quot;: truncated reading 'GID'&quot;,
                        expectedMessage($gidSize, $available);
            return;
        }

        myRead(my $data, $gidSize);
        out2 $data, &quot;GID&quot;, decodeLitteEndian($data);
        $available -= $gidSize ;
    }

}

sub decode_Java_exe
{
    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

}

sub decode_up
{
    # APPNOTE 6.3.10, sec 4.6.9

    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    out_C &quot;  Version&quot;;
    out_V &quot;  NameCRC32&quot;;

    if ($len - 5 &gt; 0)
    {
        myRead(my $data, $len - 5);

        outputFilename($data, 1,  &quot;  UnicodeName&quot;);
    }
}

sub decode_ASi_Unix
{
    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    # https://stackoverflow.com/questions/76581811/why-does-unzip-ignore-my-zip64-end-of-central-directory-record

    out_V &quot;  CRC&quot;;
    my $native_attrib = out_v &quot;  Mode&quot;;

    # TODO - move to separate sub &amp; tidy
    if (1) # Unix
    {

        state $mask = {
                0   =&gt; '---',
                1   =&gt; '--x',
                2   =&gt; '-w-',
                3   =&gt; '-wx',
                4   =&gt; 'r--',
                5   =&gt; 'r-x',
                6   =&gt; 'rw-',
                7   =&gt; 'rwx',
            } ;

        my $rwx = ($native_attrib  &amp;  0777);

        if ($rwx)
        {
            my $output  = '';
            $output .= $mask-&gt;{ ($rwx &gt;&gt; 6) &amp; 07 } ;
            $output .= $mask-&gt;{ ($rwx &gt;&gt; 3) &amp; 07 } ;
            $output .= $mask-&gt;{ ($rwx &gt;&gt; 0) &amp; 07 } ;

            out1 &quot;  [Bits 0-8]&quot;,  Value_v($rwx)  . &quot; 'Unix attrib: $output'&quot; ;
            out1 &quot;  [Bit 9]&quot;,  &quot;1 'Sticky'&quot;
                if $rwx &amp; 0x200 ;
            out1 &quot;  [Bit 10]&quot;,  &quot;1 'Set GID'&quot;
                if $rwx &amp; 0x400 ;
            out1 &quot;  [Bit 11]&quot;,  &quot;1 'Set UID'&quot;
                if $rwx &amp; 0x800 ;

            my $not_rwx = (($native_attrib  &gt;&gt; 12) &amp; 0xF);
            if ($not_rwx)
            {
                state $masks = {
                    0x0C =&gt;  'Socket',           # 0x0C  0b1100
                    0x0A =&gt;  'Symbolic Link',    # 0x0A  0b1010
                    0x08 =&gt;  'Regular File',     # 0x08  0b1000
                    0x06 =&gt;  'Block Device',     # 0x06  0b0110
                    0x04 =&gt;  'Directory',        # 0x04  0b0100
                    0x02 =&gt;  'Character Device', # 0x02  0b0010
                    0x01 =&gt;  'FIFO',             # 0x01  0b0001
                };

                my $got = $masks-&gt;{$not_rwx} // 'Unknown Unix attrib' ;
                out1 &quot;  [Bits 12-15]&quot;,  Value_C($not_rwx) . &quot; '$got'&quot;
            }
        }
    }


    my $s = out_V &quot;  SizDev&quot;;
    out_v &quot;  UID&quot;;
    out_v &quot;  GID&quot;;

}

sub decode_uc
{
    # APPNOTE 6.3.10, sec 4.6.8

    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    out_C &quot;  Version&quot;;
    out_V &quot;  ComCRC32&quot;;

    if ($len - 5 &gt; 0)
    {
        myRead(my $data, $len - 5);

        outputFilename($data, 1, &quot;  UnicodeCom&quot;);
    }
}

sub decode_Xceed_unicode
{
    # 0x554e

    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    my $data ;
    my $remaining = $len;

    # No public definition available, so reverse engineer the content.

    # See https://github.com/pmqs/zipdetails/issues/13 for C# source that populates
    # this field.

    # Fiddler https://www.telerik.com/fiddler) creates this field.

    # Local Header only has UTF16LE filename
    #
    # Field definition
    #    4 bytes Signature                      always XCUN
    #    2 bytes Filename Length (divided by 2)
    #      Filename

    # Central has UTF16LE filename &amp; comment
    #
    # Field definition
    #    4 bytes Signature                      always XCUN
    #    2 bytes Filename Length (divided by 2)
    #    2 bytes Comment Length (divided by 2)
    #      Filename
    #      Comment

    # First 4 bytes appear to be little-endian &quot;XCUN&quot; all the time
    # Just double check
    my ($idb, $id) = read_V();
    $remaining -= 4;

    my $outid = decimalHex0x($id);
    $outid .= &quot; 'XCUN'&quot;
        if $idb eq 'NUCX';

    out $idb, &quot;  ID&quot;, $outid;

    # Next 2 bytes contains a count of the filename length divided by 2
    # Dividing by 2 gives the number of UTF-16 characters.
    my $filenameLength = out_v &quot;  Filename Length&quot;;
    $filenameLength *= 2; # Double to get number of bytes to read
    $remaining -= 2;

    my $commentLength = 0;

    if ($entry-&gt;inCentralDir)
    {
        # Comment length only in Central Directory
        # Again stored divided by 2.
        $commentLength = out_v &quot;  Comment Length&quot;;
        $commentLength *= 2; # Double to get number of bytes to read
        $remaining -= 2;
    }

    # next is a UTF16 encoded filename

    if ($filenameLength)
    {
        if ($filenameLength &gt; $remaining )
        {
            myRead($data, $remaining);
            out redactData($data), &quot;  UTF16LE Filename&quot;, &quot;'&quot; . redactFilename(decode(&quot;UTF16LE&quot;, $data)) . &quot;'&quot;;

            error $FH-&gt;tell() - $remaining,
                extraFieldIdentifier($extraID) .  &quot;: Truncated reading 'UTF16LE Filename'&quot;,
                expectedMessage($filenameLength, $remaining);
            return undef;
        }

        myRead($data, $filenameLength);
        out redactData($data), &quot;  UTF16LE Filename&quot;, &quot;'&quot; . redactFilename(decode(&quot;UTF16LE&quot;, $data)) . &quot;'&quot;;
        $remaining -= $filenameLength;
    }

    # next is a UTF16 encoded comment

    if ($commentLength)
    {
        if ($commentLength &gt; $remaining )
        {
            myRead($data, $remaining);
            out redactData($data), &quot;  UTF16LE Comment&quot;, &quot;'&quot; . redactFilename(decode(&quot;UTF16LE&quot;, $data)) . &quot;'&quot;;

            error $FH-&gt;tell() - $remaining,
                extraFieldIdentifier($extraID) .  &quot;: Truncated reading 'UTF16LE Comment'&quot;,
                expectedMessage($filenameLength, $remaining);
            return undef;
        }

        myRead($data, $commentLength);
        out redactData($data), &quot;  UTF16LE Comment&quot;, &quot;'&quot; . redactFilename(decode(&quot;UTF16LE&quot;, $data)) . &quot;'&quot;;
        $remaining -= $commentLength;
    }

    if ($remaining)
    {
        outHexdump($remaining, &quot;  Unexpected Data&quot;);
        error $FH-&gt;tell() - $remaining, extraFieldIdentifier($extraID) . &quot;: &quot; . decimalHex0x($remaining) . &quot; unexpected trailing bytes&quot; ;
    }
}

sub decode_Key_Value_Pair
{
    # 0x564B 'KV'
    # https://github.com/sozip/keyvaluepairs-spec/blob/master/zip_keyvalue_extra_field_specification.md

    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    my $remaining = $len;

    myRead(my $signature, 13);
    $remaining -= 13;

    if ($signature ne 'KeyValuePairs')
    {
        error $FH-&gt;tell() - 13, extraFieldIdentifier($extraID) . &quot;: 'Signature' field not 'KeyValuePairs'&quot; ;
        myRead(my $payload, $remaining);
        my $data = hexDump16($signature . $payload);

        out2 $signature . $payload, &quot;Extra Payload&quot;, $data;

        return ;
    }

    out $signature, '  Signature', &quot;'KeyValuePairs'&quot;;
    my $kvPairs = out_C &quot;  KV Count&quot;;
    $remaining -= 1;

    for my $index (1 .. $kvPairs)
    {
        my $key;
        my $klen = out_v &quot;  Key size #$index&quot;;
        $remaining -= 4;

        myRead($key, $klen);
        outputFilename $key, 1, &quot;  Key #$index&quot;;
        $remaining -= $klen;

        my $value;
        my $vlen = out_v &quot;  Value size #$index&quot;;
        $remaining -= 4;

        myRead($value, $vlen);
        outputFilename $value, 1, &quot;  Value #$index&quot;;
        $remaining -= $vlen;
    }

    # TODO check that
    # * count of kv pairs is accurate
    # * no truncation in middle of kv data
    # * no trailing data
}

sub decode_NT_security
{
    # IZ Appnote
    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    my $inCentralHdr = $entry-&gt;inCentralDir ;

    out_V &quot;  Uncompressed Size&quot; ;

    if (! $inCentralHdr) {

        out_C &quot;  Version&quot; ;

        out_v &quot;  CType&quot;, sub { &quot;'&quot; . ($ZIP_CompressionMethods{$_[0]} || &quot;Unknown Method&quot;) . &quot;'&quot; };

        out_V &quot;  CRC&quot; ;

        my $plen = $len - 4 - 1 - 2 - 4;
        outHexdump $plen, &quot;  Extra Payload&quot;;
    }
}

sub decode_MVS
{
    # APPNOTE 6.3.10, Appendix
    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    # data in Big-Endian
    myRead(my $data, $len);
    my $ID = unpack(&quot;N&quot;, $data);

    if ($ID == 0xE9F3F9F0) # EBCDIC for &quot;Z390&quot;
    {
        my $d = substr($data, 0, 4, '') ;
        out($d, &quot;  ID&quot;, &quot;'Z390'&quot;);
    }

    out($data, &quot;  Extra Payload&quot;, hexDump16($data));
}

sub decode_strong_encryption
{
    # APPNOTE 6.3.10, sec 4.5.12 &amp; 7.4.2

    my $extraID = shift ;
    my $len = shift;
    my $entry = shift;

    # TODO check for overflow is contents &gt; $len
    out_v &quot;  Format&quot;;
    out_v &quot;  AlgId&quot;, sub { $AlgIdLookup{ $_[0] } // &quot;Unknown algorithm&quot; } ;
    out_v &quot;  BitLen&quot;;
    out_v &quot;  Flags&quot;, sub { $FlagsLookup{ $_[0] } // &quot;reserved for certificate processing&quot; } ;

    # see APPNOTE 6.3.10, sec 7.4.2 for this part
    my $recipients = out_V &quot;  Recipients&quot;;

    my $available = $len - 12;

    if ($recipients)
    {
        if ($available &lt; 2)
        {
            outSomeData($available, &quot;  Badly formed extra data&quot;);
            # TODO - need warning
            return;
        }

        out_v &quot;  HashAlg&quot;, sub { $HashAlgLookup{ $_[0] } // &quot;Unknown algorithm&quot; } ;
        $available -= 2;

        if ($available &lt; 2)
        {
            outSomeData($available, &quot;  Badly formed extra data&quot;);
            # TODO - need warning
            return;
        }

        my $HSize = out_v &quot;  HSize&quot; ;
        $available -= 2;

        # should have $recipients * $HSize bytes available
        if ($recipients * $HSize != $available)
        {
            outSomeData($available, &quot;  Badly formed extra data&quot;);
            # TODO - need warning
            return;
        }

        my $ix = 1;
        for (0 .. $recipients-1)
        {
            myRead(my $payload, $HSize);
            my $data = hexDump16($payload);

            out2 $payload, sprintf(&quot;Key #%X&quot;, $ix), $data;
            ++ $ix;
        }
    }
}


sub printAes
{
    # ref https://www.winzip.com/en/support/aes-encryption/

    my $entry = shift;

    return 0
        if ! $entry-&gt;aesValid;

    my %saltSize = (
                        1 =&gt; 8,
                        2 =&gt; 12,
                        3 =&gt; 16,
                    );

    myRead(my $salt, $saltSize{$entry-&gt;aesStrength } // 0);
    out $salt, &quot;AES Salt&quot;, hexDump16($salt);
    myRead(my $pwv, 2);
    out $pwv, &quot;AES Pwd Ver&quot;, hexDump16($pwv);

    return  $saltSize{$entry-&gt;aesStrength} + 2 + 10;
}

sub printLzmaProperties
{
    my $len = 0;

    my $b1;
    my $b2;
    my $buffer;

    myRead($b1, 2);
    my ($verHi, $verLow) = unpack (&quot;CC&quot;, $b1);

    out $b1, &quot;LZMA Version&quot;, sprintf(&quot;%02X%02X&quot;, $verHi, $verLow) . &quot; '$verHi.$verLow'&quot;;
    my $LzmaPropertiesSize = out_v &quot;LZMA Properties Size&quot;;
    $len += 4;

    my $LzmaInfo = out_C &quot;LZMA Info&quot;,  sub { $_[0] == 93 ? &quot;(Default)&quot; : &quot;&quot;};

    my $PosStateBits = 0;
    my $LiteralPosStateBits = 0;
    my $LiteralContextBits = 0;
    $PosStateBits = int($LzmaInfo / (9 * 5));
	$LzmaInfo -= $PosStateBits * 9 * 5;
	$LiteralPosStateBits = int($LzmaInfo / 9);
	$LiteralContextBits = $LzmaInfo - $LiteralPosStateBits * 9;

    out1 &quot;  PosStateBits&quot;,        $PosStateBits;
    out1 &quot;  LiteralPosStateBits&quot;, $LiteralPosStateBits;
    out1 &quot;  LiteralContextBits&quot;,  $LiteralContextBits;

    out_V &quot;LZMA Dictionary Size&quot;;

    # TODO - assumption that this is 5
    $len += $LzmaPropertiesSize;

    skip($FH, $LzmaPropertiesSize - 5)
        if  $LzmaPropertiesSize != 5 ;

    return $len;
}

sub peekAtOffset
{
    # my $fh = shift;
    my $offset = shift;
    my $len = shift;

    my $here = $FH-&gt;tell();

    seekTo($offset) ;

    my $buffer;
    myRead($buffer, $len);
    seekTo($here);

    length $buffer == $len
        or return '';

    return $buffer;
}

sub readFromOffset
{
    # my $fh = shift;
    my $offset = shift;
    my $len = shift;

    seekTo($offset) ;

    my $buffer;
    myRead($buffer, $len);

    length $buffer == $len
        or return '';

    return $buffer;
}

sub readSignatureFromOffset
{
    my $offset = shift ;

    # catch use case where attempting to read past EOF
    # sub is expecting to return a 32-bit value so return 54-bit out-of-bound value
    return MAX64
        if $offset + 4 &gt; $FILELEN ;

    my $here = $FH-&gt;tell();
    my $buffer = readFromOffset($offset, 4);
    my $gotSig = unpack(&quot;V&quot;, $buffer) ;
    seekTo($here);

    return $gotSig;
}


sub chckForAPKSigningBlock
{
    my $fh = shift;
    my $cdOffset = shift;
    my $cdSize = shift;

    # APK Signing Block comes directy before the Central directory
    # See https://source.android.com/security/apksigning/v2

    # If offset available is less than 44, it isn't an APK signing block
    #
    #   len1     8
    #   id       4
    #   kv with zero len 8
    #   len1     8
    #   magic   16
    #   ----------
    #           44

    return (0, 0, '')
        if $cdOffset &lt; 44 || $FILELEN - $cdSize &lt; 44 ;

    # Step 1 - 16 bytes before CD is literal string &quot;APK Sig Block 42&quot;
    my $magicOffset = $cdOffset - 16;
    my $buffer = readFromOffset($magicOffset, 16);

    return (0, 0, '')
        if $buffer ne &quot;APK Sig Block 42&quot; ;

    # Step 2 - read the second length field
    #          and check that it looks ok
    $buffer = readFromOffset($cdOffset - 16 - 8, 8);
    my $len2 = unpack(&quot;Q&lt;&quot;, $buffer);

    return (0, 0, '')
        if $len2 == 0 || $len2 &gt; $FILELEN;

    # Step 3 - read the first length field.
    #          It should be identical to the second one.

    my $startApkOffset = $cdOffset -  8 - $len2 ;

    $buffer = readFromOffset($startApkOffset, 8);
    my $len1 = unpack(&quot;Q&lt;&quot;, $buffer);

    return (0, 0, '')
        if $len1 != $len2;

    return ($startApkOffset, $cdOffset - 16 - 8, $buffer);
}

sub scanApkBlock
{
    state $IDs = {
            0x7109871a  =&gt; &quot;APK Signature v2&quot;,
            0xf05368c0  =&gt; &quot;APK Signature v3&quot;,
            0x42726577  =&gt; &quot;Verity Padding Block&quot;, # from https://android.googlesource.com/platform/tools/apksig/+/master/src/main/java/com/android/apksig/internal/apk/ApkSigningBlockUtils.java
            0x6dff800d  =&gt; &quot;Source Stamp&quot;,
            0x504b4453  =&gt; &quot;Dependency Info&quot;,
            0x71777777  =&gt; &quot;APK Channel Block&quot;,
            0xff3b5998  =&gt; &quot;Zero Block&quot;,
            0x2146444e  =&gt; &quot;Play Metadata&quot;,
    } ;


    seekTo($FH-&gt;tell() - 4) ;
    print &quot;\n&quot;;
    out &quot;&quot;, &quot;APK SIGNING BLOCK&quot;;

    scanApkPadding();
    out_Q &quot;Block Length Copy #1&quot;;
    my $ix = 1;

    while ($FH-&gt;tell() &lt; $APK - 8)
    {
         my ($bytes, $id, $len);
        ($bytes, $len) = read_Q ;
        out $bytes, &quot;ID/Value Length #&quot; . sprintf(&quot;%X&quot;, $ix), Value_Q($len);

        ($bytes, $id) = read_V;

        out $bytes, &quot;  ID&quot;, Value_V($id) . &quot; '&quot; . ($IDs-&gt;{$id} // 'Unknown ID') . &quot;'&quot;;

        outSomeData($len-4, &quot;  Value&quot;);
        ++ $ix;
    }

    out_Q &quot;Block Length Copy #2&quot;;

    my $magic ;
    myRead($magic, 16);

    out $magic, &quot;Magic&quot;, qq['$magic'];
}

sub scanApkPadding
{
    my $here = $FH-&gt;tell();

    return
        if $here == $START_APK;

    # found some padding

    my $delta = $START_APK - $here;
    my $padding = peekAtOffset($here, $delta);

    if ($padding =~ /^\x00+$/)
    {
        outSomeData($delta, &quot;Null Padding&quot;);
    }
    else
    {
        outHexdump($delta, &quot;Unexpected Padding&quot;);
    }
}

sub scanCentralDirectory
{
    my $fh = shift;

    my $here = $fh-&gt;tell();

    # Use cases
    # 1 32-bit CD
    # 2 64-bit CD

    my ($offset, $size) = findCentralDirectoryOffset($fh);
    $CentralDirectory-&gt;{CentralDirectoryOffset} = $offset;
    $CentralDirectory-&gt;{CentralDirectorySize} = $size;

    return ()
        if ! defined $offset;

    $fh-&gt;seek($offset, SEEK_SET) ;

    # Now walk the Central Directory Records
    my $buffer ;
    my $cdIndex = 0;
    my $cdEntryOffset = 0;

    while ($fh-&gt;read($buffer, ZIP_CD_FILENAME_OFFSET) == ZIP_CD_FILENAME_OFFSET  &amp;&amp;
           unpack(&quot;V&quot;, $buffer) == ZIP_CENTRAL_HDR_SIG) {

        my $startHeader = $fh-&gt;tell() - ZIP_CD_FILENAME_OFFSET;

        my $cdEntryOffset = $fh-&gt;tell() - ZIP_CD_FILENAME_OFFSET;
        $HeaderOffsetIndex-&gt;addOffsetNoPrefix($cdEntryOffset, ZIP_CENTRAL_HDR_SIG) ;

        ++ $cdIndex ;

        my $extractVer         = unpack(&quot;v&quot;, substr($buffer,  6, 1));
        my $gpFlag             = unpack(&quot;v&quot;, substr($buffer,  8, 2));
        my $lastMod            = unpack(&quot;V&quot;, substr($buffer, 10, 4));
        my $crc                = unpack(&quot;V&quot;, substr($buffer, 16, 4));
        my $compressedSize   = unpack(&quot;V&quot;, substr($buffer, 20, 4));
        my $uncompressedSize = unpack(&quot;V&quot;, substr($buffer, 24, 4));
        my $filename_length    = unpack(&quot;v&quot;, substr($buffer, 28, 2));
        my $extra_length       = unpack(&quot;v&quot;, substr($buffer, 30, 2));
        my $comment_length     = unpack(&quot;v&quot;, substr($buffer, 32, 2));
        my $diskNumber         = unpack(&quot;v&quot;, substr($buffer, 34, 2));
        my $locHeaderOffset    = unpack(&quot;V&quot;, substr($buffer, 42, 4));

        my $cdZip64 = 0;
        my $zip64Sizes = 0;

        if (! full32 $locHeaderOffset)
        {
            # Check for corrupt offset
            # 1. ponting paset EOF
            # 2. offset points forward in the file
            # 3. value at offset is not a CD record signature

            my $commonMessage = &quot;'Local Header Offset' field in '&quot; . Signatures::name(ZIP_CENTRAL_HDR_SIG) . &quot;' is invalid&quot;;
            checkOffsetValue($locHeaderOffset, $startHeader, 0, $commonMessage,
                $startHeader + CentralDirectoryEntry::Offset_RelativeOffsetToLocal(),
                ZIP_LOCAL_HDR_SIG, 1) ;
        }

        $fh-&gt;read(my $filename, $filename_length) ;

        my $cdEntry = CentralDirectoryEntry-&gt;new();

        $cdEntry-&gt;centralHeaderOffset($startHeader) ;
        $cdEntry-&gt;localHeaderOffset($locHeaderOffset) ;
        $cdEntry-&gt;compressedSize($compressedSize) ;
        $cdEntry-&gt;uncompressedSize($uncompressedSize) ;
        $cdEntry-&gt;extractVersion($extractVer);
        $cdEntry-&gt;generalPurposeFlags($gpFlag);
        $cdEntry-&gt;filename($filename) ;
        $cdEntry-&gt;lastModDateTime($lastMod);
        $cdEntry-&gt;languageEncodingFlag($gpFlag &amp; ZIP_GP_FLAG_LANGUAGE_ENCODING) ;
        $cdEntry-&gt;diskNumber($diskNumber) ;
        $cdEntry-&gt;crc32($crc) ;
        $cdEntry-&gt;zip64ExtraPresent($cdZip64) ;

        $cdEntry-&gt;std_localHeaderOffset($locHeaderOffset) ;
        $cdEntry-&gt;std_compressedSize($compressedSize) ;
        $cdEntry-&gt;std_uncompressedSize($uncompressedSize) ;
        $cdEntry-&gt;std_diskNumber($diskNumber) ;


        if ($extra_length)
        {
            $fh-&gt;read(my $extraField, $extra_length) ;

            # Check for Zip64
            my $zip64Extended = findID(0x0001, $extraField);

            if ($zip64Extended)
            {
                $cdZip64 = 1;
                walk_Zip64_in_CD(1, $zip64Extended, $cdEntry, 0);
            }
        }

        $cdEntry-&gt;offsetStart($startHeader) ;
        $cdEntry-&gt;offsetEnd($FH-&gt;tell() - 1);

        # don't call addEntry until after the extra fields have been scanned
        # the localheader offset value may be updated in th ezip64 extra field.
        $CentralDirectory-&gt;addEntry($cdEntry);
        $HeaderOffsetIndex-&gt;addOffset($cdEntry-&gt;localHeaderOffset, ZIP_LOCAL_HDR_SIG) ;

        skip($fh, $comment_length ) ;
    }

    $FH-&gt;seek($fh-&gt;tell() - ZIP_CD_FILENAME_OFFSET, SEEK_SET);

    # Check for Digital Signature
    $HeaderOffsetIndex-&gt;addOffset($fh-&gt;tell() - 4, ZIP_DIGITAL_SIGNATURE_SIG)
        if $fh-&gt;read($buffer, 4) == 4  &amp;&amp;
            unpack(&quot;V&quot;, $buffer) == ZIP_DIGITAL_SIGNATURE_SIG ;

    $CentralDirectory-&gt;sortByLocalOffset();
    $HeaderOffsetIndex-&gt;sortOffsets();

    $fh-&gt;seek($here, SEEK_SET) ;

}

use constant ZIP64_END_CENTRAL_LOC_HDR_SIZE     =&gt; 20;
use constant ZIP64_END_CENTRAL_REC_HDR_MIN_SIZE =&gt; 56;

sub offsetFromZip64
{
    my $fh = shift ;
    my $here = shift;
    my $eocdSize = shift;

    #### Zip64 end of central directory locator

    # check enough bytes available for zip64 locator record
    fatal_tryWalk undef, &quot;Cannot find signature for &quot; .  Signatures::nameAndHex(ZIP64_END_CENTRAL_LOC_HDR_SIG), # 'Zip64 end of central directory locator': 0x07064b50&quot;
                         &quot;Possible truncated or corrupt zip file&quot;
        if $here &lt; ZIP64_END_CENTRAL_LOC_HDR_SIZE ;

    $fh-&gt;seek($here - ZIP64_END_CENTRAL_LOC_HDR_SIZE, SEEK_SET) ;
    $here = $FH-&gt;tell();

    my $buffer;
    my $got = 0;
    $fh-&gt;read($buffer, ZIP64_END_CENTRAL_LOC_HDR_SIZE);

    my $gotSig = unpack(&quot;V&quot;, $buffer);
    fatal_tryWalk $here - 4, sprintf(&quot;Expected signature for &quot; . Signatures::nameAndHex(ZIP64_END_CENTRAL_LOC_HDR_SIG) . &quot; not found, got 0x%X&quot;, $gotSig)
        if $gotSig != ZIP64_END_CENTRAL_LOC_HDR_SIG ;

    $HeaderOffsetIndex-&gt;addOffset($fh-&gt;tell() - ZIP64_END_CENTRAL_LOC_HDR_SIZE, ZIP64_END_CENTRAL_LOC_HDR_SIG) ;


    my $cd64 = unpack &quot;Q&lt;&quot;, substr($buffer,  8, 8);
    my $totalDisks = unpack &quot;V&quot;, substr($buffer,  16, 4);

    testPossiblePrefix($cd64, ZIP64_END_CENTRAL_REC_HDR_SIG);

    if ($totalDisks &gt; 0)
    {
        my $commonMessage = &quot;'Offset to Zip64 End of Central Directory Record' field in '&quot; . Signatures::name(ZIP64_END_CENTRAL_LOC_HDR_SIG) . &quot;' is invalid&quot;;
        $cd64 = checkOffsetValue($cd64, $here, 0, $commonMessage, $here + 8, ZIP64_END_CENTRAL_REC_HDR_SIG, 1) ;
    }

    my $delta = $here - $cd64;

    #### Zip64 end of central directory record

    my $zip64eocd_name = &quot;'&quot; . Signatures::name(ZIP64_END_CENTRAL_REC_HDR_SIG) . &quot;'&quot;;
    my $zip64eocd_name_value = Signatures::nameAndHex(ZIP64_END_CENTRAL_REC_HDR_SIG);
    my $zip64eocd_value = Signatures::hexValue(ZIP64_END_CENTRAL_REC_HDR_SIG);

    # check enough bytes available
    # fatal_tryWalk sprintf &quot;Size of 'Zip64 End of Central Directory Record' 0x%X too small&quot;, $cd64
    fatal_tryWalk undef, sprintf &quot;Size of $zip64eocd_name 0x%X too small&quot;, $cd64
        if $delta &lt; ZIP64_END_CENTRAL_REC_HDR_MIN_SIZE;

    # Seek to Zip64 End of Central Directory Record
    $fh-&gt;seek($cd64, SEEK_SET) ;
    $HeaderOffsetIndex-&gt;addOffsetNoPrefix($fh-&gt;tell(), ZIP64_END_CENTRAL_REC_HDR_SIG) ;

    $fh-&gt;read($buffer, ZIP64_END_CENTRAL_REC_HDR_MIN_SIZE) ;

    my $sig = unpack(&quot;V&quot;, substr($buffer, 0, 4)) ;
    fatal_tryWalk undef, sprintf &quot;Cannot find $zip64eocd_name: expected $zip64eocd_value but got 0x%X&quot;, $sig
        if $sig != ZIP64_END_CENTRAL_REC_HDR_SIG ;

    # pkzip sets the extract zip spec to 6.2 (0x3E) to signal a v2 record
    # See APPNOTE 6.3.10, section, 7.3.3

    # Version 1 header is 44 bytes (assuming no extensible data sector)
    # Version 2 header (see APPNOTE 6.3.7, section) is &gt; 44 bytes

    my $extractSpec         = unpack &quot;C&quot;,  substr($buffer, 14, 1);
    my $diskNumber          = unpack &quot;V&quot;,  substr($buffer, 16, 4);
    my $cdDiskNumber        = unpack &quot;V&quot;,  substr($buffer, 20, 4);
    my $entriesOnThisDisk   = unpack &quot;Q&lt;&quot;, substr($buffer, 24, 8);
    my $totalEntries        = unpack &quot;Q&lt;&quot;, substr($buffer, 32, 8);
    my $centralDirSize      = unpack &quot;Q&lt;&quot;, substr($buffer, 40, 8);
    my $centralDirOffset    = unpack &quot;Q&lt;&quot;, substr($buffer, 48, 8);

    if ($extractSpec &gt;= 0x3E)
    {
        $opt_walk = 1;
        $CentralDirectory-&gt;setPkEncryptedCD();
    }

    if (! emptyArchive($here, $diskNumber, $cdDiskNumber, $entriesOnThisDisk, $totalEntries,  $centralDirSize, $centralDirOffset))
    {
        my $commonMessage = &quot;'Offset to Central Directory' field in $zip64eocd_name is invalid&quot;;
        $centralDirOffset = checkOffsetValue($centralDirOffset, $here, 0, $commonMessage, $here + 48, ZIP_CENTRAL_HDR_SIG, 1, $extractSpec &lt; 0x3E) ;
    }

    # TODO - APPNOTE allows an extensible data sector here (see APPNOTE 6.3.10, section 4.3.14.2) -- need to take this into account

    return ($centralDirOffset, $centralDirSize) ;
}

use constant Pack_ZIP_END_CENTRAL_HDR_SIG =&gt; pack(&quot;V&quot;, ZIP_END_CENTRAL_HDR_SIG);

sub findCentralDirectoryOffset
{
    my $fh = shift ;

    # Most common use-case is where there is no comment, so
    # know exactly where the end of central directory record
    # should be.

    need ZIP_EOCD_MIN_SIZE, Signatures::name(ZIP_END_CENTRAL_HDR_SIG);

    $fh-&gt;seek(-ZIP_EOCD_MIN_SIZE(), SEEK_END) ;
    my $here = $fh-&gt;tell();

    my $is64bit = $here &gt; MAX32;
    my $over64bit = $here  &amp; (~ MAX32);

    my $buffer;
    $fh-&gt;read($buffer, ZIP_EOCD_MIN_SIZE);

    my $zip64 = 0;
    my $diskNumber ;
    my $cdDiskNumber ;
    my $entriesOnThisDisk ;
    my $totalEntries ;
    my $centralDirSize ;
    my $centralDirOffset ;
    my $commentLength = 0;
    my $trailingBytes = 0;

    if ( unpack(&quot;V&quot;, $buffer) == ZIP_END_CENTRAL_HDR_SIG ) {

        $HeaderOffsetIndex-&gt;addOffset($here + $PREFIX_DELTA, ZIP_END_CENTRAL_HDR_SIG) ;

        $diskNumber       = unpack(&quot;v&quot;, substr($buffer, 4,   2));
        $cdDiskNumber     = unpack(&quot;v&quot;, substr($buffer, 6,   2));
        $entriesOnThisDisk= unpack(&quot;v&quot;, substr($buffer, 8,   2));
        $totalEntries     = unpack(&quot;v&quot;, substr($buffer, 10,  2));
        $centralDirSize   = unpack(&quot;V&quot;, substr($buffer, 12,  4));
        $centralDirOffset = unpack(&quot;V&quot;, substr($buffer, 16,  4));
        $commentLength    = unpack(&quot;v&quot;, substr($buffer, 20,  2));
    }
    else {
        $fh-&gt;seek(0, SEEK_END) ;

        my $fileLen = $fh-&gt;tell();
        my $want = 0 ;

        while(1) {
            $want += 1024 * 32;
            my $seekTo = $fileLen - $want;
            if ($seekTo &lt; 0 ) {
                $seekTo = 0;
                $want = $fileLen ;
            }
            $fh-&gt;seek( $seekTo, SEEK_SET);
            $fh-&gt;read($buffer, $want) ;
            my $pos = rindex( $buffer, Pack_ZIP_END_CENTRAL_HDR_SIG);

            if ($pos &gt;= 0 &amp;&amp; $want - $pos &gt; ZIP_EOCD_MIN_SIZE) {
                $here = $seekTo + $pos ;
                $HeaderOffsetIndex-&gt;addOffset($here + $PREFIX_DELTA, ZIP_END_CENTRAL_HDR_SIG) ;

                $diskNumber       = unpack(&quot;v&quot;, substr($buffer, $pos + 4,   2));
                $cdDiskNumber     = unpack(&quot;v&quot;, substr($buffer, $pos + 6,   2));
                $entriesOnThisDisk= unpack(&quot;v&quot;, substr($buffer, $pos + 8,   2));
                $totalEntries     = unpack(&quot;v&quot;, substr($buffer, $pos + 10,  2));
                $centralDirSize   = unpack(&quot;V&quot;, substr($buffer, $pos + 12,  4));
                $centralDirOffset = unpack(&quot;V&quot;, substr($buffer, $pos + 16,  4));
                $commentLength    = unpack(&quot;v&quot;, substr($buffer, $pos + 20,  2)) // 0;

                my $expectedEof = $fileLen - $want + $pos + ZIP_EOCD_MIN_SIZE + $commentLength  ;
                # check for trailing data after end of zip
                if ($expectedEof &lt; $fileLen ) {
                    $TRAILING = $expectedEof ;
                    $trailingBytes = $FILELEN - $expectedEof ;
                }
                last ;
            }

            return undef
                if $want == $fileLen;

        }
    }

    $EOCD_Present = 1;

    # Empty zip file can just contain an EOCD record
    return (0, 0)
        if ZIP_EOCD_MIN_SIZE + $commentLength + $trailingBytes  == $FILELEN ;

    if (needZip64EOCDLocator($diskNumber, $cdDiskNumber, $entriesOnThisDisk, $totalEntries, $centralDirOffset, $centralDirSize) &amp;&amp;
        ! emptyArchive($here, $diskNumber, $cdDiskNumber, $entriesOnThisDisk, $totalEntries, $centralDirOffset, $centralDirSize))
    {
        ($centralDirOffset, $centralDirSize) = offsetFromZip64($fh, $here, ZIP_EOCD_MIN_SIZE + $commentLength + $trailingBytes)
    }
    elsif ($is64bit)
    {
        # use-case is where a 64-bit zip file doesn't use the 64-bit
        # extensions.
        # print &quot;EOCD not 64-bit $centralDirOffset ($here)\n&quot; ;

        fatal_tryWalk $here, &quot;Zip file &gt; 4Gig. Expected 'Offset to Central Dir' to be 0xFFFFFFFF, got &quot; . hexValue($centralDirOffset);

        $centralDirOffset += $over64bit;
        $is64In32 = 1;
    }
    else
    {
        if ($centralDirSize)
        {
            my $commonMessage = &quot;'Offset to Central Directory' field in '&quot; . Signatures::name(ZIP_END_CENTRAL_HDR_SIG) . &quot;' is invalid&quot;;
            $centralDirOffset = checkOffsetValue($centralDirOffset, $here, $centralDirSize, $commonMessage, $here + 16, ZIP_CENTRAL_HDR_SIG, 1) ;
        }
    }

    return (0, 0)
        if  $totalEntries == 0 &amp;&amp; $entriesOnThisDisk == 0;

    # APK Signing Block is directly before the first CD entry
    # Check if it is present
    ($START_APK, $APK, $APK_LEN) = chckForAPKSigningBlock($fh, $centralDirOffset, ZIP_EOCD_MIN_SIZE + $commentLength);

    return ($centralDirOffset, $centralDirSize) ;
}

sub findID
{
    my $id_want = shift ;
    my $data    = shift;

    my $XLEN = length $data ;

    my $offset = 0 ;
    while ($offset &lt; $XLEN) {

        return undef
            if $offset + ZIP_EXTRA_SUBFIELD_HEADER_SIZE  &gt; $XLEN ;

        my $id = substr($data, $offset, ZIP_EXTRA_SUBFIELD_ID_SIZE);
        $id = unpack(&quot;v&quot;, $id);
        $offset += ZIP_EXTRA_SUBFIELD_ID_SIZE;

        my $subLen =  unpack(&quot;v&quot;, substr($data, $offset,
                                            ZIP_EXTRA_SUBFIELD_LEN_SIZE));
        $offset += ZIP_EXTRA_SUBFIELD_LEN_SIZE ;

        return undef
            if $offset + $subLen &gt; $XLEN ;

        return substr($data, $offset, $subLen)
            if $id eq $id_want ;

        $offset += $subLen ;
    }

    return undef ;
}


sub nibbles
{
    my @nibbles = (
        [ 16 =&gt; 0x1000000000000000 ],
        [ 15 =&gt; 0x100000000000000 ],
        [ 14 =&gt; 0x10000000000000 ],
        [ 13 =&gt; 0x1000000000000 ],
        [ 12 =&gt; 0x100000000000 ],
        [ 11 =&gt; 0x10000000000 ],
        [ 10 =&gt; 0x1000000000 ],
        [  9 =&gt; 0x100000000 ],
        [  8 =&gt; 0x10000000 ],
        [  7 =&gt; 0x1000000 ],
        [  6 =&gt; 0x100000 ],
        [  5 =&gt; 0x10000 ],
        [  4 =&gt; 0x1000 ],
        [  4 =&gt; 0x100 ],
        [  4 =&gt; 0x10 ],
        [  4 =&gt; 0x1 ],
    );
    my $value = shift ;

    for my $pair (@nibbles)
    {
        my ($count, $limit) = @{ $pair };

        return $count
            if $value &gt;= $limit ;
    }
}

{
    package HeaderOffsetEntry;

    sub new
    {
        my $class = shift ;
        my $offset = shift ;
        my $signature = shift;

        bless [ $offset, $signature, Signatures::name($signature)] , $class;

    }

    sub offset
    {
        my $self = shift;
        return $self-&gt;[0];
    }

    sub signature
    {
        my $self = shift;
        return $self-&gt;[1];
    }

    sub name
    {
        my $self = shift;
        return $self-&gt;[2];
    }

}

{
    package HeaderOffsetIndex;

    # Store a list of header offsets recorded when scannning the central directory

    sub new
    {
        my $class = shift ;

        my %object = (
                        'offsetIndex'       =&gt; [],
                        'offset2Index'      =&gt; {},
                        'offset2Signature'  =&gt; {},
                        'currentIndex'      =&gt; -1,
                        'currentSignature'  =&gt; 0,
                        # 'sigNames'          =&gt; $sigNames,
                     ) ;

        bless \%object, $class;
    }

    sub sortOffsets
    {
        my $self = shift ;

        @{ $self-&gt;{offsetIndex} } = sort { $a-&gt;[0] &lt;=&gt; $b-&gt;[0] }
                                    @{ $self-&gt;{offsetIndex} };
        my $ix = 0;
        $self-&gt;{offset2Index}{$_} = $ix++
            for @{ $self-&gt;{offsetIndex} } ;
    }

    sub addOffset
    {
        my $self = shift ;
        my $offset = shift ;
        my $signature = shift ;

        $offset += $PREFIX_DELTA ;
        $self-&gt;addOffsetNoPrefix($offset, $signature);
    }

    sub addOffsetNoPrefix
    {
        my $self = shift ;
        my $offset = shift ;
        my $signature = shift ;

        my $name = Signatures::name($signature);

        if (! defined $self-&gt;{offset2Signature}{$offset})
        {
            push @{ $self-&gt;{offsetIndex} }, HeaderOffsetEntry-&gt;new($offset, $signature) ;
            $self-&gt;{offset2Signature}{$offset} = $signature;
        }
    }

    sub getNextIndex
    {
        my $self = shift ;
        my $offset = shift ;

        $self-&gt;{currentIndex} ++;

        return ${ $self-&gt;{offsetIndex} }[$self-&gt;{currentIndex}] // undef
    }

    sub rewindIndex
    {
        my $self = shift ;
        my $offset = shift ;

        $self-&gt;{currentIndex} --;
    }

    sub dump
    {
        my $self = shift;

        say &quot;### HeaderOffsetIndex&quot;;
        say &quot;###   Offset\tSignature&quot;;
        for my $x ( @{ $self-&gt;{offsetIndex} } )
        {
            my ($offset, $sig) = @$x;
            printf &quot;###   %X %d\t\t&quot; . $x-&gt;name() . &quot;\n&quot;, $x-&gt;offset(), $x-&gt;offset();
        }
    }

    sub checkForOverlap
    {
        my $self = shift ;
        my $need = shift;

        my $needOffset = $FH-&gt;tell() + $need;

        for my $hdrOffset (@{ $self-&gt;{offsetIndex} })
        {
            my $delta = $hdrOffset - $needOffset;
            return [$self-&gt;{offsetIndex}{$hdrOffset}, $needOffset - $hdrOffset]
                if $delta &lt;= 0 ;
        }

        return [undef, undef];
    }

}

{
    package FieldsAndAccessors;

    sub Add
    {
        use Data::Dumper ;

        my $classname = shift;
        my $object = shift;
        my $fields = shift ;
        my $no_handler = shift // {};

        state $done = {};


        while (my ($name, $value) =  each %$fields)
        {
            my $method = &quot;${classname}::$name&quot;;

            $object-&gt;{$name} = $value;

            # don't auto-create a handler
            next
                if $no_handler-&gt;{$name};

            no strict 'refs';

            # Don't use lvalue sub for now - vscode debugger breaks with it enabled.
            # https://github.com/richterger/Perl-LanguageServer/issues/194
            # *$method = sub : lvalue {
            #     $_[0]-&gt;{$name} ;
            # }
            # unless defined $done-&gt;{$method};

            # Auto-generate getter/setter
            *$method = sub  {
                $_[0]-&gt;{$name} = $_[1]
                    if @_ == 2;
                return $_[0]-&gt;{$name} ;
            }
            unless defined $done-&gt;{$method};

            ++ $done-&gt;{$method};


        }
    }
}

{
    package BaseEntry ;

    sub new
    {
        my $class = shift ;

        state $index = 0;

        my %fields = (
                        'index'                 =&gt; $index ++,
                        'zip64'                 =&gt; 0,
                        'offsetStart'           =&gt; 0,
                        'offsetEnd'             =&gt; 0,
                        'inCentralDir'          =&gt; 0,
                        'encapsulated'          =&gt; 0, # enclosed in outer zip
                        'childrenCount'         =&gt; 0, # this entry is a zip with enclosed children
                        'streamed'              =&gt; 0,
                        'languageEncodingFlag'  =&gt; 0,
                        'entryType'             =&gt; 0,
                     ) ;

        my $self = bless {}, $class;

        FieldsAndAccessors::Add($class, $self, \%fields) ;

        return $self;
    }

    sub increment_childrenCount
    {
        my $self = shift;
        $self-&gt;{childrenCount} ++;
    }
}

{
    package LocalCentralEntryBase ;

    use parent -norequire , 'BaseEntry' ;

    sub new
    {
        my $class = shift ;

        my $self = $class-&gt;SUPER::new();


        my %fields = (
                        # fields from the header
                        'centralHeaderOffset'   =&gt; 0,
                        'localHeaderOffset'     =&gt; 0,

                        'extractVersion'        =&gt; 0,
                        'generalPurposeFlags'   =&gt; 0,
                        'compressedMethod'      =&gt; 0,
                        'lastModDateTime'       =&gt; 0,
                        'crc32'                 =&gt; 0,
                        'compressedSize'        =&gt; 0,
                        'uncompressedSize'      =&gt; 0,
                        'filename'              =&gt; '',
                        'outputFilename'        =&gt; '',
                        # inferred data
                        # 'InCentralDir'          =&gt; 0,
                        # 'zip64'                 =&gt; 0,

                        'zip64ExtraPresent'     =&gt; 0,
                        'zip64SizesPresent'     =&gt; 0,
                        'payloadOffset'         =&gt; 0,

                        # zip64 extra
                        'zip64_compressedSize'    =&gt; undef,
                        'zip64_uncompressedSize'  =&gt; undef,
                        'zip64_localHeaderOffset' =&gt; undef,
                        'zip64_diskNumber'        =&gt; undef,
                        'zip64_diskNumberPresent' =&gt; 0,

                        # Values direct from the header before merging any Zip64 values
                        'std_compressedSize'    =&gt; undef,
                        'std_uncompressedSize'  =&gt; undef,
                        'std_localHeaderOffset' =&gt; undef,
                        'std_diskNumber'        =&gt; undef,

                        # AES
                        'aesStrength'             =&gt; 0,
                        'aesValid'                =&gt; 0,

                        # Minizip CD encryption
                        'minizip_secure'          =&gt; 0,

                     ) ;

        FieldsAndAccessors::Add($class, $self, \%fields) ;

        return $self;
    }
}

{
    package Zip64EndCentralHeaderEntry ;

    use parent -norequire , 'LocalCentralEntryBase' ;

    sub new
    {
        my $class = shift ;

        my $self = $class-&gt;SUPER::new();


        my %fields = (
                        'inCentralDir'          =&gt; 1,
                     ) ;

        FieldsAndAccessors::Add($class, $self, \%fields) ;

        return $self;
    }

}

{
    package CentralDirectoryEntry;

    use parent -norequire , 'LocalCentralEntryBase' ;

    use constant Offset_VersionMadeBy           =&gt; 4;
    use constant Offset_VersionNeededToExtract  =&gt; 6;
    use constant Offset_GeneralPurposeFlags     =&gt; 8;
    use constant Offset_CompressionMethod       =&gt; 10;
    use constant Offset_ModificationTime        =&gt; 12;
    use constant Offset_ModificationDate        =&gt; 14;
    use constant Offset_CRC32                   =&gt; 16;
    use constant Offset_CompressedSize          =&gt; 20;
    use constant Offset_UncompressedSize        =&gt; 24;
    use constant Offset_FilenameLength          =&gt; 28;
    use constant Offset_ExtraFieldLength        =&gt; 30;
    use constant Offset_FileCommentLength       =&gt; 32;
    use constant Offset_DiskNumber              =&gt; 34;
    use constant Offset_InternalAttributes      =&gt; 36;
    use constant Offset_ExternalAttributes      =&gt; 38;
    use constant Offset_RelativeOffsetToLocal   =&gt; 42;
    use constant Offset_Filename                =&gt; 46;

    sub new
    {
        my $class = shift ;
        my $offset = shift;

        # check for existing entry
        return $CentralDirectory-&gt;{byCentralOffset}{$offset}
            if defined $offset &amp;&amp; defined $CentralDirectory-&gt;{byCentralOffset}{$offset} ;

        my $self = $class-&gt;SUPER::new();

        my %fields = (
                        'diskNumber'                =&gt; 0,
                        'comment'                   =&gt; &quot;&quot;,
                        'ldEntry'                   =&gt; undef,
                     ) ;

        FieldsAndAccessors::Add($class, $self, \%fields) ;

        $self-&gt;inCentralDir(1) ;
        $self-&gt;entryType(::ZIP_CENTRAL_HDR_SIG) ;

        return $self;
    }
}

{
    package CentralDirectory;

    sub new
    {
        my $class = shift ;

        my %object = (
                        'entries'       =&gt; [],
                        'count'         =&gt; 0,
                        'byLocalOffset' =&gt; {},
                        'byCentralOffset' =&gt; {},
                        'byName'        =&gt; {},
                        'offset2Index' =&gt; {},
                        'normalized_filenames' =&gt; {},
                        'CentralDirectoryOffset'      =&gt; 0,
                        'CentralDirectorySize'      =&gt; 0,
                        'zip64'         =&gt; 0,
                        'encryptedCD'   =&gt; 0,
                        'minizip_secure' =&gt; 0,
                        'alreadyScanned' =&gt; 0,
                     ) ;

        bless \%object, $class;
    }

    sub addEntry
    {
        my $self = shift ;
        my $entry = shift ;

        my $localHeaderOffset = $entry-&gt;localHeaderOffset  ;
        my $CentralDirectoryOffset = $entry-&gt;centralHeaderOffset ;
        my $filename = $entry-&gt;filename ;

        Nesting::add($entry);

        # Create a reference from Central to Local header entries
        my $ldEntry = Nesting::getLdEntryByOffset($localHeaderOffset);
        if ($ldEntry)
        {
            $entry-&gt;ldEntry($ldEntry) ;

            # LD -&gt; CD
            # can have multiple LD entries point to same CD
            # so need to keep a list
            $ldEntry-&gt;addCdEntry($entry);
        }

        # only check for duplicate in real CD scan
        if ($self-&gt;{alreadyScanned} &amp;&amp; ! $entry-&gt;encapsulated )
        {
            my $existing = $self-&gt;{byName}{$filename} ;
            if ($existing &amp;&amp; $existing-&gt;centralHeaderOffset != $entry-&gt;centralHeaderOffset)
            {
                ::error $CentralDirectoryOffset,
                        &quot;Duplicate Central Directory entries for filename '$filename'&quot;,
                        &quot;Current Central Directory entry at offset &quot; . ::decimalHex0x($CentralDirectoryOffset),
                        &quot;Duplicate Central Directory entry at offset &quot; . ::decimalHex0x($self-&gt;{byName}{$filename}{centralHeaderOffset});

                # not strictly illegal to have duplicate filename, so save this one
            }
            else
            {
                my $existingNormalizedEntry = $self-&gt;normalize_filename($entry, $filename);
                if ($existingNormalizedEntry)
                {
                    ::warning $CentralDirectoryOffset,
                            &quot;Portability Issue: Found case-insensitive duplicate for filename '$filename'&quot;,
                            &quot;Current Central Directory entry at offset &quot; . ::decimalHex0x($CentralDirectoryOffset),
                            &quot;Duplicate Central Directory entry for filename '&quot; . $existingNormalizedEntry-&gt;outputFilename . &quot;' at offset &quot; . ::decimalHex0x($existingNormalizedEntry-&gt;centralHeaderOffset);
                }
            }
        }

        # CD can get processed twice, so return if already processed
        return
            if $self-&gt;{byCentralOffset}{$CentralDirectoryOffset} ;

        if (! $entry-&gt;encapsulated )
        {
            push @{ $self-&gt;{entries} }, $entry;

            $self-&gt;{byLocalOffset}{$localHeaderOffset} = $entry;
            $self-&gt;{byCentralOffset}{$CentralDirectoryOffset} = $entry;
            $self-&gt;{byName}{ $filename } = $entry;
            $self-&gt;{offset2Index} = $self-&gt;{count} ++;
        }

    }

    sub exists
    {
        my $self = shift ;

        return scalar @{ $self-&gt;{entries} };
    }

    sub sortByLocalOffset
    {
        my $self = shift ;

        @{ $self-&gt;{entries} } = sort { $a-&gt;localHeaderOffset() &lt;=&gt; $b-&gt;localHeaderOffset() }
                                @{ $self-&gt;{entries} };
    }

    sub getByLocalOffset
    {
        my $self = shift ;
        my $offset = shift ;

        # TODO - what happens if none exists?
        my $entry = $self-&gt;{byLocalOffset}{$offset - $PREFIX_DELTA} ;
        return $entry ;
    }

    sub localOffset
    {
        my $self = shift ;
        my $offset = shift ;

        # TODO - what happens if none exists?
        return $self-&gt;{byLocalOffset}{$offset - $PREFIX_DELTA} ;
    }

    sub getNextLocalOffset
    {
        my $self = shift ;
        my $offset = shift ;

        my $index = $self-&gt;{offset2Index} ;

        if ($index + 1 &gt;= $self-&gt;{count})
        {
            return 0;
        }

        return ${ $self-&gt;{entries} }[$index+1]-&gt;localHeaderOffset() ;
    }

    sub inCD
    {
        my $self = shift ;
        $FH-&gt;tell() &gt;= $self-&gt;{CentralDirectoryOffset};
    }

    sub setPkEncryptedCD
    {
        my $self = shift ;

        $self-&gt;{encryptedCD} = 1 ;

    }

    sub setMiniZipEncrypted
    {
        my $self = shift ;

        $self-&gt;{minizip_secure} = 1 ;
    }

    sub isMiniZipEncrypted
    {
        my $self = shift ;
        return $self-&gt;{minizip_secure};
    }

    sub isEncryptedCD
    {
        my $self = shift ;
        return $self-&gt;{encryptedCD} &amp;&amp; ! $self-&gt;{minizip_secure};
    }

    sub normalize_filename
    {
        # check if there is a filename that already exists
        # with the same name when normalized to lower case

        my $self = shift ;
        my $entry = shift;
        my $filename = shift;

        my $nFilename = lc $filename;

        my $lookup = $self-&gt;{normalized_filenames}{$nFilename};
        # if ($lookup &amp;&amp; $lookup ne $filename)
        if ($lookup)
        {
            return $lookup,
        }

        $self-&gt;{normalized_filenames}{$nFilename} = $entry;

        return undef;
    }
}

{
    package LocalDirectoryEntry;

    use parent -norequire , 'LocalCentralEntryBase' ;

    use constant Offset_VersionNeededToExtract  =&gt; 4;
    use constant Offset_GeneralPurposeFlags     =&gt; 6;
    use constant Offset_CompressionMethod       =&gt; 8;
    use constant Offset_ModificationTime        =&gt; 10;
    use constant Offset_ModificationDate        =&gt; 12;
    use constant Offset_CRC32                   =&gt; 14;
    use constant Offset_CompressedSize          =&gt; 18;
    use constant Offset_UncompressedSize        =&gt; 22;
    use constant Offset_FilenameLength          =&gt; 26;
    use constant Offset_ExtraFieldLength        =&gt; 27;
    use constant Offset_Filename                =&gt; 30;

    sub new
    {
        my $class = shift ;

        my $self = $class-&gt;SUPER::new();

        my %fields = (
                        'streamedMatch'         =&gt; 0,
                        'readDataDescriptor'    =&gt; 0,
                        'cdEntryIndex'          =&gt; {},
                        'cdEntryList'           =&gt; [],
                     ) ;

        FieldsAndAccessors::Add($class, $self, \%fields) ;

        $self-&gt;inCentralDir(0) ;
        $self-&gt;entryType(::ZIP_LOCAL_HDR_SIG) ;

        return $self;
    }

    sub addCdEntry
    {
        my $self = shift ;
        my $entry = shift;

        # don't want encapsulated entries
        # and protect against duplicates
        return
            if $entry-&gt;encapsulated ||
               $self-&gt;{cdEntryIndex}{$entry-&gt;index} ++ &gt;= 1;

        push @{ $self-&gt;{cdEntryList} }, $entry ;
    }

    sub getCdEntry
    {
        my $self = shift ;

        return []
            if ! $self-&gt;{cdEntryList} ;

        return $self-&gt;{cdEntryList}[0] ;
    }

    sub getCdEntries
    {
        my $self = shift ;
        return $self-&gt;{cdEntryList} ;
    }
}

{
    package LocalDirectory;

    sub new
    {
        my $class = shift ;

        my %object = (
                        'entries'       =&gt; [],
                        'count'         =&gt; 0,
                        'byLocalOffset' =&gt; {},
                        'byName'        =&gt; {},
                        'offset2Index' =&gt; {},
                        'normalized_filenames' =&gt; {},
                        'CentralDirectoryOffset'      =&gt; 0,
                        'CentralDirectorySize'      =&gt; 0,
                        'zip64'         =&gt; 0,
                        'encryptedCD'   =&gt; 0,
                        'streamedPresent' =&gt; 0,
                     ) ;

        bless \%object, $class;
    }

    sub isLocalEntryNested
    {
        my $self = shift ;
        my $localEntry = shift;

        return Nesting::getFirstEncapsulation($localEntry);

    }

    sub addEntry
    {
        my $self = shift ;
        my $localEntry = shift ;

        my $filename = $localEntry-&gt;filename ;
        my $localHeaderOffset = $localEntry-&gt;localHeaderOffset;
        my $payloadOffset = $localEntry-&gt;payloadOffset ;

        my $existingEntry = $self-&gt;{byName}{$filename} ;

        my $endSurfaceArea = $payloadOffset + ($localEntry-&gt;compressedSize // 0)  ;

        if ($existingEntry)
        {
            ::error $localHeaderOffset,
                    &quot;Duplicate Local Directory entry for filename '$filename'&quot;,
                    &quot;Current Local Directory entry at offset &quot; . ::decimalHex0x($localHeaderOffset),
                    &quot;Duplicate Local Directory entry at offset &quot; . ::decimalHex0x($existingEntry-&gt;localHeaderOffset),
        }
        else
        {

            my ($existing_filename, $offset) = $self-&gt;normalize_filename($filename);
            if ($existing_filename)
            {
                ::warning $localHeaderOffset,
                        &quot;Portability Issue: Found case-insensitive duplicate for filename '$filename'&quot;,
                        &quot;Current Local Directory entry at offset &quot; . ::decimalHex0x($localHeaderOffset),
                        &quot;Duplicate Local Directory entry for filename '$existing_filename' at offset &quot; . ::decimalHex0x($offset);
            }
        }

        # keep nested local entries for zipbomb deteection
        push @{ $self-&gt;{entries} }, $localEntry;

        $self-&gt;{byLocalOffset}{$localHeaderOffset} = $localEntry;
        $self-&gt;{byName}{ $filename } = $localEntry;

        $self-&gt;{streamedPresent} ++
            if $localEntry-&gt;streamed;

        Nesting::add($localEntry);
    }

    sub exists
    {
        my $self = shift ;

        return scalar @{ $self-&gt;{entries} };
    }

    sub sortByLocalOffset
    {
        my $self = shift ;

        @{ $self-&gt;{entries} } = sort { $a-&gt;localHeaderOffset() &lt;=&gt; $b-&gt;localHeaderOffset() }
                                @{ $self-&gt;{entries} };
    }

    sub localOffset
    {
        my $self = shift ;
        my $offset = shift ;

        return $self-&gt;{byLocalOffset}{$offset} ;
    }

    sub getByLocalOffset
    {
        my $self = shift ;
        my $offset = shift ;

        # TODO - what happens if none exists?
        my $entry = $self-&gt;{byLocalOffset}{$offset} ;
        return $entry ;
    }

    sub getNextLocalOffset
    {
        my $self = shift ;
        my $offset = shift ;

        my $index = $self-&gt;{offset2Index} ;

        if ($index + 1 &gt;= $self-&gt;{count})
        {
            return 0;
        }

        return ${ $self-&gt;{entries} }[$index+1]-&gt;localHeaderOffset ;
    }

    sub lastStreamedEntryAdded
    {
        my $self = shift ;
        my $offset = shift ;

        for my $entry ( reverse @{ $self-&gt;{entries} } )
        {
            if ($entry-&gt;streamed)# &amp;&amp; ! $entry-&gt;streamedMatch)
            {
                $entry-&gt;streamedMatch($entry-&gt;streamedMatch + 1) ;
                return $entry;
            }
        }

        return undef;
    }

    sub inCD
    {
        my $self = shift ;
        $FH-&gt;tell() &gt;= $self-&gt;{CentralDirectoryOffset};
    }

    sub setPkEncryptedCD
    {
        my $self = shift ;

        $self-&gt;{encryptedCD} = 1 ;

    }

    sub isEncryptedCD
    {
        my $self = shift ;
        return $self-&gt;{encryptedCD} ;
    }

    sub anyStreamedEntries
    {
        my $self = shift ;
        return $self-&gt;{streamedPresent} ;
    }

    sub normalize_filename
    {
        # check if there is a filename that already exists
        # with the same name when normalized to lower case

        my $self = shift ;
        my $filename = shift;

        my $nFilename = lc $filename;

        my $lookup = $self-&gt;{normalized_filenames}{$nFilename};
        if ($lookup &amp;&amp; $lookup ne $filename)
        {
            return $self-&gt;{byName}{$lookup}{outputFilename},
                   $self-&gt;{byName}{$lookup}{localHeaderOffset}
        }

        $self-&gt;{normalized_filenames}{$nFilename} = $filename;

        return undef, undef;
    }
}

{
    package Eocd ;

    sub new
    {
        my $class = shift ;

        my %object = (
                        'zip64'       =&gt; 0,
                     ) ;

        bless \%object, $class;
    }
}

sub displayFileInfo
{
    return;

    my $filename = shift;

    info undef,
        &quot;Filename       : '$filename'&quot;,
        &quot;Size           : &quot; . (-s $filename) . &quot; (&quot; . decimalHex0x(-s $filename) . &quot;)&quot;,
        # &quot;Native Encoding: '&quot; . TextEncoding::getNativeLocaleName() . &quot;'&quot;,
}

{
    package TextEncoding;

    my $nativeLocaleEncoding = getNativeLocale();
    my $opt_EncodingFrom = $nativeLocaleEncoding;
    my $opt_EncodingTo = $nativeLocaleEncoding ;
    my $opt_Encoding_Enabled;
    my $opt_Debug_Encoding;
    my $opt_use_LanguageEncodingFlag;

    sub setDefaults
    {
        $nativeLocaleEncoding = getNativeLocale();
        $opt_EncodingFrom = $nativeLocaleEncoding;
        $opt_EncodingTo = $nativeLocaleEncoding ;
        $opt_Encoding_Enabled = 1;
        $opt_Debug_Encoding = 0;
        $opt_use_LanguageEncodingFlag = 1;
    }

    sub getNativeLocale
    {
        state $enc;

        if (! defined $enc)
        {
            eval
            {
                require encoding ;
                my $encoding = encoding::_get_locale_encoding() ;
                if (! $encoding)
                {
                    # CP437 is the legacy default for zip files
                    $encoding = 'cp437';
                    # ::warning undef, &quot;Cannot determine system charset: defaulting to '$encoding'&quot;
                }
                $enc = Encode::find_encoding($encoding) ;
            } ;
        }

        return $enc;
    }

    sub getNativeLocaleName
    {
        state $name;

        return $name
            if defined $name ;

        if (! defined $name)
        {
            my $enc = getNativeLocale();
            if ($enc)
            {
                $name = $enc-&gt;name()
            }
            else
            {
                $name = 'unknown'
            }
        }

        return $name ;
    }

    sub parseEncodingOption
    {
        my $opt_name = shift;
        my $opt_value = shift;

        my $enc = Encode::find_encoding($opt_value) ;
        die &quot;Encoding '$opt_value' not found for option '$opt_name'\n&quot;
            unless ref $enc;

        if ($opt_name eq 'encoding')
        {
            $opt_EncodingFrom = $enc;
        }
        elsif ($opt_name eq 'output-encoding')
        {
            $opt_EncodingTo = $enc;
        }
        else
        {
            die &quot;Unknown option $opt_name\n&quot;
        }
    }

    sub NoEncoding
    {
        my $opt_name = shift;
        my $opt_value = shift;

        $opt_Encoding_Enabled = 0 ;
    }

    sub LanguageEncodingFlag
    {
        my $opt_name = shift;
        my $opt_value = shift;

        $opt_use_LanguageEncodingFlag = $opt_value ;
    }

    sub debugEncoding
    {
        if (@_)
        {
            $opt_Debug_Encoding = 1 ;
        }

        return $opt_Debug_Encoding ;
    }

    sub encodingInfo
    {
        return
            unless $opt_Encoding_Enabled &amp;&amp; $opt_Debug_Encoding ;

        my $enc  = TextEncoding::getNativeLocaleName();
        my $from = $opt_EncodingFrom-&gt;name();
        my $to   = $opt_EncodingTo-&gt;name();

        ::debug undef, &quot;Debug Encoding Enabled&quot;,
                      &quot;System Default Encoding:                  '$enc'&quot;,
                      &quot;Encoding used when reading from zip file: '$from'&quot;,
                      &quot;Encoding used for display output:         '$to'&quot;;
    }

    sub cleanEval
    {
        chomp $_[0] ;
        $_[0] =~ s/ at .+ line \d+\.$// ;
        return $_[0];
    }

    sub decode
    {
        my $name = shift ;
        my $type = shift ;
        my $LanguageEncodingFlag = shift ;

        return $name
            if ! $opt_Encoding_Enabled ;

        # TODO - check for badly formed content
        if ($LanguageEncodingFlag &amp;&amp; $opt_use_LanguageEncodingFlag)
        {
            # use &quot;utf-8-strict&quot; to catch invalid codepoints
            eval { $name = Encode::decode('utf-8-strict', $name, Encode::FB_CROAK ) } ;
            ::warning $FH-&gt;tell() - length $name, &quot;Could not decode 'UTF-8' $type: &quot; . cleanEval $@
                if $@ ;
        }
        else
        {
            eval { $name = $opt_EncodingFrom-&gt;decode($name, Encode::FB_CROAK ) } ;
            ::warning $FH-&gt;tell() - length $name, &quot;Could not decode '&quot; . $opt_EncodingFrom-&gt;name() . &quot;' $type: &quot; . cleanEval $@
                if $@;
        }

        # remove any BOM
        $name =~ s/^\x{FEFF}//;

        return $name ;
    }

    sub encode
    {
        my $name = shift ;
        my $type = shift ;
        my $LanguageEncodingFlag = shift ;

        return $name
            if ! $opt_Encoding_Enabled;

        if ($LanguageEncodingFlag &amp;&amp; $opt_use_LanguageEncodingFlag)
        {
            eval { $name = Encode::encode('utf8', $name, Encode::FB_CROAK ) } ;
            ::warning $FH-&gt;tell() - length $name, &quot;Could not encode 'utf8' $type: &quot; . cleanEval $@
                if $@ ;
        }
        else
        {
            eval { $name = $opt_EncodingTo-&gt;encode($name, Encode::FB_CROAK ) } ;
            ::warning $FH-&gt;tell() - length $name, &quot;Could not encode '&quot; . $opt_EncodingTo-&gt;name() . &quot;' $type: &quot; . cleanEval $@
                if $@;
        }

        return $name;
    }
}

{
    package Nesting;

    use Data::Dumper;

    my @nestingStack = ();
    my %encapsulations;
    my %inner2outer;
    my $encapsulationCount  = 0;
    my %index2entry ;
    my %offset2entry ;

    # my %localOffset2cdEntry;

    sub clearStack
    {
        @nestingStack = ();
        %encapsulations = ();
        %inner2outer = ();
        %index2entry = ();
        %offset2entry = ();
        $encapsulationCount = 0;
    }

    sub dump
    {
        my $indent = shift // 0;

        for my $offset (sort {$a &lt;=&gt; $b} keys %offset2entry)
        {
            my $leading = &quot; &quot; x $indent ;
            say $leading . &quot;\nOffset $offset&quot; ;
            say Dumper($offset2entry{$offset})
        }
    }

    sub add
    {
        my $entry = shift;

        getEnclosingEntry($entry);
        push @nestingStack, $entry;
        $index2entry{ $entry-&gt;index } = $entry;
        $offset2entry{ $entry-&gt;offsetStart } = $entry;
    }

    sub getEnclosingEntry
    {
        my $entry = shift;

        my $filename = $entry-&gt;filename;

        pop @nestingStack
            while @nestingStack &amp;&amp; $entry-&gt;offsetStart &gt; $nestingStack[-1]-&gt;offsetEnd ;

        my $match = undef;

        if (@nestingStack &amp;&amp;
            $entry-&gt;offsetStart &gt;= $nestingStack[-1]-&gt;offsetStart &amp;&amp;
            $entry-&gt;offsetEnd   &lt;= $nestingStack[-1]-&gt;offsetEnd &amp;&amp;
            $entry-&gt;index       != $nestingStack[-1]-&gt;index)
        {
            # Nested entry found
            $match = $nestingStack[-1];
            push @{ $encapsulations{ $match-&gt;index } }, $entry;
            $inner2outer{ $entry-&gt;index} = $match-&gt;index;
            ++ $encapsulationCount;

            $entry-&gt;encapsulated(1) ;
            $match-&gt;increment_childrenCount();

            if ($NESTING_DEBUG)
            {
                say &quot;#### nesting &quot; . (caller(1))[3] . &quot; index #&quot; . $entry-&gt;index . ' &quot;' .
                    $entry-&gt;outputFilename . '&quot; [' . $entry-&gt;offsetStart . &quot;-&gt;&quot; . $entry-&gt;offsetEnd . &quot;]&quot; .
                    &quot; in #&quot; . $match-&gt;index . ' &quot;' .
                    $match-&gt;outputFilename . '&quot; [' . $match-&gt;offsetStart . &quot;-&gt;&quot; . $match-&gt;offsetEnd . &quot;]&quot; ;
            }
        }

        return $match;
    }

    sub isNested
    {
        my $offsetStart = shift;
        my $offsetEnd = shift;

        if ($NESTING_DEBUG)
        {
            say &quot;### Want: offsetStart &quot; . ::decimalHex0x($offsetStart) . &quot; offsetEnd &quot; . ::decimalHex0x($offsetEnd);
            for my $entry (@nestingStack)
            {
                say &quot;### Have: offsetStart &quot; . ::decimalHex0x($entry-&gt;offsetStart) . &quot; offsetEnd &quot; . ::decimalHex0x($entry-&gt;offsetEnd);
            }
        }

        return 0
            unless @nestingStack ;

        my @copy = @nestingStack ;

        pop @copy
            while @copy &amp;&amp; $offsetStart &gt; $copy[-1]-&gt;offsetEnd ;

        return @copy &amp;&amp;
               $offsetStart &gt;= $copy[-1]-&gt;offsetStart &amp;&amp;
               $offsetEnd   &lt;= $copy[-1]-&gt;offsetEnd ;
    }

    sub getOuterEncapsulation
    {
        my $entry = shift;

        my $outerIndex =  $inner2outer{ $entry-&gt;index } ;

        return undef
            if ! defined $outerIndex ;

        return $index2entry{$outerIndex} // undef;
    }

    sub getEncapsulations
    {
        my $entry = shift;

        return $encapsulations{ $entry-&gt;index } ;
    }

    sub getFirstEncapsulation
    {
        my $entry = shift;

        my $got = $encapsulations{ $entry-&gt;index } ;

        return defined $got ? $$got[0] : undef;
    }

    sub encapsulations
    {
        return \%encapsulations;
    }

    sub encapsulationCount
    {
        return $encapsulationCount;
    }

    sub childrenInCentralDir
    {
        # find local header entries that have children that are not referenced in the CD
        # tis means it is likely a benign nextd zip file
        my $entry = shift;

        for my $child (@{ $encapsulations{$entry-&gt;index} } )
        {
            next
                unless $child-&gt;entryType == ::ZIP_LOCAL_HDR_SIG ;

            return 1
                if @{ $child-&gt;cdEntryList };
        }

        return 0;
    }

    sub entryByIndex
    {
        my $index = shift;
        return $index2entry{$index};
    }

    sub getEntryByOffset
    {
        my $offset  = shift;
        return $offset2entry{$offset};
    }

    sub getLdEntryByOffset
    {
        my $offset  = shift;
        my $entry = $offset2entry{$offset};

        return $entry
            if $entry &amp;&amp; $entry-&gt;entryType == ::ZIP_LOCAL_HDR_SIG;

        return undef;
    }

    sub getEntriesByOffset
    {
        return \%offset2entry ;
    }
}

{
    package SimpleTable ;

    use List::Util qw(max sum);

    sub new
    {
        my $class = shift;

        my %object = (
            header =&gt; [],
            data   =&gt; [],
            columns   =&gt; 0,
            prefix =&gt; '#  ',
        );
        bless \%object, $class;
    }

    sub addHeaderRow
    {
        my $self = shift;
        push @{ $self-&gt;{header} }, [ @_ ] ;
        $self-&gt;{columns} = max($self-&gt;{columns}, scalar @_ ) ;
    }

    sub addDataRow
    {
        my $self = shift;

        push @{ $self-&gt;{data} }, [ @_ ] ;
        $self-&gt;{columns} = max($self-&gt;{columns}, scalar @_ ) ;
    }

    sub hasData
    {
        my $self = shift;

        return scalar @{ $self-&gt;{data} } ;
    }

    sub display
    {
        my $self = shift;

        # work out the column widths
        my @colW = (0) x $self-&gt;{columns} ;
        for my $row (@{ $self-&gt;{data} }, @{ $self-&gt;{header} })
        {
            my @r = @$row;
            for my $ix (0 .. $self-&gt;{columns} -1)
            {
                $colW[$ix] = max($colW[$ix],
                                3 + length( $r[$ix] )
                                );
            }
        }

        my $width = sum(@colW) ; #+ @colW ;
        my @template ;
        for my $w (@colW)
        {
            push @template, ' ' x ($w - 3);
        }

        print $self-&gt;{prefix} . '-' x ($width + 1) . &quot;\n&quot;;

        for my $row (@{ $self-&gt;{header} })
        {
            my @outputRow = @template;

            print $self-&gt;{prefix} . '| ';
            for my $ix (0 .. $self-&gt;{columns} -1)
            {
                my $field = $template[$ix] ;
                substr($field, 0, length($row-&gt;[$ix]), $row-&gt;[$ix]);
                print $field . ' | ';
            }
            print &quot;\n&quot;;

        }

        print $self-&gt;{prefix} . '-' x ($width + 1) . &quot;\n&quot;;

        for my $row (@{ $self-&gt;{data} })
        {
            my @outputRow = @template;

            print $self-&gt;{prefix} . '| ';
            for my $ix (0 .. $self-&gt;{columns} -1)
            {
                my $field = $template[$ix] ;
                substr($field, 0, length($row-&gt;[$ix]), $row-&gt;[$ix]);
                print $field . ' | ';
            }
            print &quot;\n&quot;;
        }

        print $self-&gt;{prefix} . '-' x ($width + 1) . &quot;\n&quot;;
        print &quot;#\n&quot;;
    }
}

sub Usage
{
    my $enc = TextEncoding::getNativeLocaleName();

    my $message = &lt;&lt;EOM;
zipdetails [OPTIONS] file

Display details about the internal structure of a Zip file.

OPTIONS

  General Options
     -h, --help
            Display help
     --redact
            Hide filename and payload data in the output
     --scan
            Enable pessimistic scanning mode.
            Blindly scan the file looking for zip headers
            Expect false-positives.
     --utc
            Display date/time fields in UTC. Default is local time
     -v
            Enable verbose mode -- output more stuff
     --version
            Print zipdetails version number
            This is version $VERSION
     --walk
            Enable optimistic scanning mode.
            Blindly scan the file looking for zip headers
            Expect false-positives.

  Filename/Comment Encoding
    --encoding e
            Use encoding &quot;e&quot; when reading filename/comments from the zip file
            Uses system encoding ('$enc') by default
    --no-encoding
            Disable filename &amp; comment encoding. Default disabled.
    --output-encoding e
            Use encoding &quot;e&quot; when writing filename/comments to the display
            Uses system encoding ('$enc') by default
    --debug-encoding
            Display eatra info when a filename/comment encoding has changed
    --language-encoding, --no-language-encoding
            Enable/disable support for the zip file &quot;Language Encoding&quot; flag.
            When this flag is set in a zip file the filename/comment is assumed
            to be encoded in UTF8.
            Default is enabled

  Message Control
     --messages, --no-messages
            Enable/disable all info/warning/error messages. Default enabled.
     --exit-bitmask, --no-exit-bitmask
            Enable/disable exit status bitmask for messages. Default disabled.
            Bitmask values are
                Info    1
                Warning 2
                Error   4

Copyright (c) 2011-2024 Paul Marquess. All rights reserved.

This program is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
EOM

    if (@_)
    {
        warn &quot;$_\n&quot;
            for @_  ;
        warn &quot;\n&quot;;

        die $message ;
    }

    print $message ;
    exit 0;

}

1;

__END__

=head1 NAME

zipdetails - display the internal structure of zip files

=head1 SYNOPSIS

    zipdetails [options] zipfile.zip

=head1 DESCRIPTION

This program creates a detailed report on the internal structure of zip
files. For each item of metadata within a zip file the program will output

=over 5

=item the offset into the zip file where the item is located.

=item a textual representation for the item.

=item an optional hex dump of the item.

=back


The program assumes a prior understanding of the internal structure of Zip
files. You should have a copy of the zip file definition,
L&lt;APPNOTE.TXT|https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT&gt;,
at hand to help understand the output from this program.

=head2 Default Behaviour

By default the program expects to be given a well-formed zip file.  It will
navigate the zip file by first parsing the zip C&lt;Central Directory&gt; at the end
of the file.  If the C&lt;Central Directory&gt; is found, it will then walk
sequentally through the zip records starting at the beginning of the file.
See L&lt;Advanced Analysis&gt; for other processing options.

If the program finds any structural or portability issues with the zip file
it will print a message at the point it finds the issue and/or in a summary
at the end of the output report. Whilst the set of issues that can be
detected it exhaustive, don't assume that this program can find I&lt;all&gt; the
possible issues in a zip file - there are likely edge conditions that need
to be addressed.

If you have suggestions for use-cases where this could be enhanced please
consider creating an enhancement request (see L&lt;&quot;SUPPORT&quot;&gt;).

=head3 Date &amp; Time fields

Date/time fields found in zip files are displayed in local time. Use the
C&lt;--utc&gt; option to display these fields in Coordinated Universal Time (UTC).

=head3 Filenames &amp; Comments

Filenames and comments are decoded/encoded using the default system
encoding of the host running C&lt;zipdetails&gt;. When the sytem encoding cannot
be determined C&lt;cp437&gt; will be used.

The exceptions are

=over 5

=item *

when the C&lt;Language Encoding Flag&gt; is set in the zip file, the
filename/comment fields are assumed to be encoded in UTF-8.

=item *

the definition for the metadata field implies UTF-8 charset encoding

=back

See L&lt;&quot;Filename Encoding Issues&quot;&gt; and L&lt;Filename &amp; Comment Encoding
Options&gt; for ways to control the encoding of filename/comment fields.

=head2 OPTIONS

=head3 General Options

=over 5

=item C&lt;-h&gt;, C&lt;--help&gt;

Display help

=item C&lt;--redact&gt;

Obscure filenames and payload data in the output. Handy for the use case
where the zip files contains sensitive data that cannot be shared.

=item C&lt;--scan&gt;

Pessimistically scan the zip file loking for possible zip records. Can be
error-prone. For very large zip files this option is slow. Consider using
the C&lt;--walk&gt; option first. See L&lt;&quot;Advanced Analysis Options&quot;&gt;

=item C&lt;--utc&gt;

By default, date/time fields are displayed in local time. Use this option to
display them in in Coordinated Universal Time (UTC).

=item C&lt;-v&gt;

Enable Verbose mode. See L&lt;&quot;Verbose Output&quot;&gt;.

=item C&lt;--version&gt;

Display version number of the program and exit.

=item C&lt;--walk&gt;

Optimistically walk the zip file looking for possible zip records.
See L&lt;&quot;Advanced Analysis Options&quot;&gt;

=back

=head3 Filename &amp; Comment Encoding Options

See L&lt;&quot;Filename Encoding Issues&quot;&gt;

=over 5

=item C&lt;--encoding name&gt;

Use encoding &quot;name&quot; when reading filenames/comments from the zip file.

When this option is not specified the default the system encoding is used.

=item C&lt; --no-encoding&gt;

Disable all filename &amp; comment encoding/decoding. Filenames/comments are
processed as byte streams.

This option is not enabled by default.

=item C&lt;--output-encoding name&gt;

Use encoding &quot;name&quot; when writing filename/comments to the display.  By
default the system encoding will be used.

=item C&lt;--language-encoding&gt;, C&lt;--no-language-encoding&gt;

Modern zip files set a metadata entry in zip files, called the &quot;Language
encoding flag&quot;, when they write filenames/comments encoded in UTF-8.

Occasionally some applications set the C&lt;Language Encoding Flag&gt; but write
data that is not UTF-8 in the filename/comment fields of the zip file. This
will usually result in garbled text being output for the
filenames/comments.

To deal with this use-case, set the C&lt;--no-language-encoding&gt; option and,
if needed, set the C&lt;--encoding name&gt; option to encoding actually used.

Default is C&lt;--language-encoding&gt;.

=item C&lt;--debug-encoding&gt;

Display extra debugging info when a filename/comment encoding has changed.

=back

=head3 Message Control Options

=over 5

=item C&lt;--messages&gt;, C&lt;--no-messages&gt;

Enable/disable the output of all info/warning/error messages.

Disabling messages means that no checks are carried out to check that the
zip file is well-formed.

Default is enabled.

=item C&lt;--exit-bitmask&gt;, C&lt;--no-exit-bitmask&gt;

Enable/disable exit status bitmask for messages. Default disabled.
Bitmask values are: 1 for info, 2 for warning and 4 for error.

=back


=head2 Default Output

By default C&lt;zipdetails&gt; will output each metadata field from the zip file
in three columns.

=over 5

=item 1

The offset, in hex, to the start of the field relative to the beginning of
the file.

=item 2

The name of the field.

=item 3

Detailed information about the contents of the field. The format depends on
the type of data:

=over 5

=item * Numeric Values

If the field contains an 8-bit, 16-bit, 32-bit or 64-bit numeric value, it
will be displayed in both hex and decimal -- for example &quot;C&lt;002A (42)&gt;&quot;.

Note that Zip files store most numeric values in I&lt;little-endian&gt; encoding
(there area few rare instances where I&lt;big-endian&gt; is used). The value read
from the zip file will have the I&lt;endian&gt; encoding removed before being
displayed.

Next, is an optional description of what the numeric value means.

=item * String

If the field corresponds to a printable string, it will be output enclosed
in single quotes.

=item * Binary Data

The term I&lt;Binary Data&gt; is just a catch-all for all other metadata in the
zip file. This data is displayed as a series of ascii-hex byte values in
the same order they are stored in the zip file.

=back

=back

For example, assuming you have a zip file, C&lt;test,zip&gt;, with one entry

    $ unzip -l  test.zip
    Archive:  test.zip
    Length      Date    Time    Name
    ---------  ---------- -----   ----
        446  2023-03-22 20:03   lorem.txt
    ---------                     -------
        446                     1 file

Running C&lt;zipdetails&gt; will gives this output

    $ zipdetails test.zip

    0000 LOCAL HEADER #1       04034B50 (67324752)
    0004 Extract Zip Spec      14 (20) '2.0'
    0005 Extract OS            00 (0) 'MS-DOS'
    0006 General Purpose Flag  0000 (0)
         [Bits 1-2]            0 'Normal Compression'
    0008 Compression Method    0008 (8) 'Deflated'
    000A Modification Time     5676A072 (1450614898) 'Wed Mar 22 20:03:36 2023'
    000E CRC                   F90EE7FF (4178503679)
    0012 Compressed Size       0000010E (270)
    0016 Uncompressed Size     000001BE (446)
    001A Filename Length       0009 (9)
    001C Extra Length          0000 (0)
    001E Filename              'lorem.txt'
    0027 PAYLOAD

    0135 CENTRAL HEADER #1     02014B50 (33639248)
    0139 Created Zip Spec      1E (30) '3.0'
    013A Created OS            03 (3) 'Unix'
    013B Extract Zip Spec      14 (20) '2.0'
    013C Extract OS            00 (0) 'MS-DOS'
    013D General Purpose Flag  0000 (0)
         [Bits 1-2]            0 'Normal Compression'
    013F Compression Method    0008 (8) 'Deflated'
    0141 Modification Time     5676A072 (1450614898) 'Wed Mar 22 20:03:36 2023'
    0145 CRC                   F90EE7FF (4178503679)
    0149 Compressed Size       0000010E (270)
    014D Uncompressed Size     000001BE (446)
    0151 Filename Length       0009 (9)
    0153 Extra Length          0000 (0)
    0155 Comment Length        0000 (0)
    0157 Disk Start            0000 (0)
    0159 Int File Attributes   0001 (1)
         [Bit 0]               1 'Text Data'
    015B Ext File Attributes   81ED0000 (2179792896)
         [Bits 16-24]          01ED (493) 'Unix attrib: rwxr-xr-x'
         [Bits 28-31]          08 (8) 'Regular File'
    015F Local Header Offset   00000000 (0)
    0163 Filename              'lorem.txt'

    016C END CENTRAL HEADER    06054B50 (101010256)
    0170 Number of this disk   0000 (0)
    0172 Central Dir Disk no   0000 (0)
    0174 Entries in this disk  0001 (1)
    0176 Total Entries         0001 (1)
    0178 Size of Central Dir   00000037 (55)
    017C Offset to Central Dir 00000135 (309)
    0180 Comment Length        0000 (0)
    #
    # Done


=head2 Verbose Output

If the C&lt;-v&gt; option is present, the metadata output is split into the
following columns:

=over 5

=item 1

The offset, in hex, to the start of the field relative to the beginning of
the file.

=item 2

The offset, in hex, to the end of the field relative to the beginning of
the file.

=item 3

The length, in hex, of the field.

=item 4

A hex dump of the bytes in field in the order they are stored in the zip file.

=item 5

A textual description of the field.

=item 6

Information about the contents of the field. See the description in the
L&lt;Default Output&gt; for more details.

=back

Here is the same zip file, C&lt;test.zip&gt;, dumped using the C&lt;zipdetails&gt;
C&lt;-v&gt; option:

    $ zipdetails -v test.zip

    0000 0003 0004 50 4B 03 04 LOCAL HEADER #1       04034B50 (67324752)
    0004 0004 0001 14          Extract Zip Spec      14 (20) '2.0'
    0005 0005 0001 00          Extract OS            00 (0) 'MS-DOS'
    0006 0007 0002 00 00       General Purpose Flag  0000 (0)
                               [Bits 1-2]            0 'Normal Compression'
    0008 0009 0002 08 00       Compression Method    0008 (8) 'Deflated'
    000A 000D 0004 72 A0 76 56 Modification Time     5676A072 (1450614898) 'Wed Mar 22 20:03:36 2023'
    000E 0011 0004 FF E7 0E F9 CRC                   F90EE7FF (4178503679)
    0012 0015 0004 0E 01 00 00 Compressed Size       0000010E (270)
    0016 0019 0004 BE 01 00 00 Uncompressed Size     000001BE (446)
    001A 001B 0002 09 00       Filename Length       0009 (9)
    001C 001D 0002 00 00       Extra Length          0000 (0)
    001E 0026 0009 6C 6F 72 65 Filename              'lorem.txt'
                   6D 2E 74 78
                   74
    0027 0134 010E ...         PAYLOAD

    0135 0138 0004 50 4B 01 02 CENTRAL HEADER #1     02014B50 (33639248)
    0139 0139 0001 1E          Created Zip Spec      1E (30) '3.0'
    013A 013A 0001 03          Created OS            03 (3) 'Unix'
    013B 013B 0001 14          Extract Zip Spec      14 (20) '2.0'
    013C 013C 0001 00          Extract OS            00 (0) 'MS-DOS'
    013D 013E 0002 00 00       General Purpose Flag  0000 (0)
                               [Bits 1-2]            0 'Normal Compression'
    013F 0140 0002 08 00       Compression Method    0008 (8) 'Deflated'
    0141 0144 0004 72 A0 76 56 Modification Time     5676A072 (1450614898) 'Wed Mar 22 20:03:36 2023'
    0145 0148 0004 FF E7 0E F9 CRC                   F90EE7FF (4178503679)
    0149 014C 0004 0E 01 00 00 Compressed Size       0000010E (270)
    014D 0150 0004 BE 01 00 00 Uncompressed Size     000001BE (446)
    0151 0152 0002 09 00       Filename Length       0009 (9)
    0153 0154 0002 00 00       Extra Length          0000 (0)
    0155 0156 0002 00 00       Comment Length        0000 (0)
    0157 0158 0002 00 00       Disk Start            0000 (0)
    0159 015A 0002 01 00       Int File Attributes   0001 (1)
                               [Bit 0]               1 'Text Data'
    015B 015E 0004 00 00 ED 81 Ext File Attributes   81ED0000 (2179792896)
                               [Bits 16-24]          01ED (493) 'Unix attrib: rwxr-xr-x'
                               [Bits 28-31]          08 (8) 'Regular File'
    015F 0162 0004 00 00 00 00 Local Header Offset   00000000 (0)
    0163 016B 0009 6C 6F 72 65 Filename              'lorem.txt'
                   6D 2E 74 78
                   74

    016C 016F 0004 50 4B 05 06 END CENTRAL HEADER    06054B50 (101010256)
    0170 0171 0002 00 00       Number of this disk   0000 (0)
    0172 0173 0002 00 00       Central Dir Disk no   0000 (0)
    0174 0175 0002 01 00       Entries in this disk  0001 (1)
    0176 0177 0002 01 00       Total Entries         0001 (1)
    0178 017B 0004 37 00 00 00 Size of Central Dir   00000037 (55)
    017C 017F 0004 35 01 00 00 Offset to Central Dir 00000135 (309)
    0180 0181 0002 00 00       Comment Length        0000 (0)
    #
    # Done

=head2 Advanced Analysis

If you have a corrupt or non-standard zip file, particulatly one where the
C&lt;Central Directory&gt; metadata at the end of the file is absent/incomplete, you
can use either the C&lt;--walk&gt; option or the C&lt;--scan&gt; option to search for
any zip metadata that is still present in the file.

When either of these options is enabled, this program will bypass the
initial step of reading the C&lt;Central Directory&gt; at the end of the file and
simply scan the zip file sequentially from the start of the file looking
for zip metedata records. Although this can be error prone, for the most
part it will find any zip file metadata that is still present in the file.

The difference between the two options is how aggressive the sequential
scan is: C&lt;--walk&gt; is optimistic, while C&lt;--scan&gt; is pessimistic.

To understand the difference in more detail you need to know a bit about
how zip file metadata is structured. Under the hood, a zip file uses a
series of 4-byte signatures to flag the start of a each of the metadata
records it uses. When the C&lt;--walk&gt; or the C&lt;--scan&gt; option is enabled both
work identically by scanning the file from the beginning looking for any
the of these valid 4-byte metadata signatures. When a 4-byte signature is
found both options will blindly assume that it has found a vald metadata
record and display it.

=head3 C&lt;--walk&gt;

The C&lt;--walk&gt; option optimistically assumes that it has found a real zip
metatada record and so starts the scan for the next record directly after
the record it has just output.

=head3 C&lt;--scan&gt;

The C&lt;--scan&gt; option is pessimistic and assumes the 4-byte signature
sequence may have been a false-positive, so before starting the scan for
the next resord, it will rewind to the location in the file directly after
the 4-byte sequecce it just processed. This means it will rescan data that
has already been processed.  For very lage zip files the C&lt;--scan&gt; option
can be really realy slow, so trying the C&lt;--walk&gt; option first.

B&lt;Important Note&gt;: If the zip file being processed contains one or more
nested zip files, and the outer zip file uses the C&lt;STORE&gt; compression
method, the C&lt;--scan&gt; option will display the zip metadata for both the
outer &amp; inner zip files.

=head2 Filename Encoding Issues

Sometimes when displaying the contents of a zip file the filenames (or
comments) appear to be garbled. This section walks through the reasons and
mitigations that can be applied to work around these issues.

=head3 Background

When zip files were first created in the 1980's, there was no Unicode or
UTF-8. Issues around character set encoding interoperability were not a
major concern.

Initially, the only official encoding supported in zip files was IBM Code
Page 437 (AKA C&lt;CP437&gt;). As time went on users in locales where C&lt;CP437&gt;
wasn't appropriate stored filenames in the encoding native to their locale.
If you were running a system that matched the locale of the zip file, all
was well. If not, you had to post-process the filenames after unzipping the
zip file.

Fast forward to the introduction of Unicode and UTF-8 encoding. The
approach now used by all major zip implementations is to set the C&lt;Language
encoding flag&gt; (also known as C&lt;EFS&gt;) in the zip file metadata to signal
that a filename/comment is encoded in UTF-8.

To ensure maximum interoperability when sharing zip files store 7-bit
filenames as-is in the zip file. For anything else the C&lt;EFS&gt; bit needs to
be set and the filename is encoded in UTF-8. Although this rule is kept to
for the most part, there are exceptions out in the wild.

=head3 Dealing with Encoding Errors

The most common filename encoding issue is where the C&lt;EFS&gt; bit is not set and
the filename is stored in a character set that doesnt't match the system
encoding. This mostly impacts legacy zip files that predate the
introduction of Unicode.

To deal with this issue you first need to know what encoding was used in
the zip file. For example, if the filename is encoded in C&lt;ISO-8859-1&gt; you
can display the filenames using the C&lt;--encoding&gt; option

    zipdetails --encoding ISO-8859-1 myfile.zip

A less common variation of this is where the C&lt;EFS&gt; bit is set, signalling
that the filename will be encoded in UTF-8, but the filename is not encoded
in UTF-8. To deal with this scenarion, use the C&lt;--no-language-encoding&gt;
option along with the C&lt;--encoding&gt; option.


=head1 LIMITATIONS

The following zip file features are not supported by this program:

=over 5

=item *

Multi-part/Split/Spanned Zip Archives.

This program cannot give an overall report on the combined parts of a
multi-part zip file.

The best you can do is run with either the C&lt;--scan&gt; or C&lt;--walk&gt; options
against individual parts. Some will contains zipfile metadata which will be
detected and some will only contain compressed payload data.


=item *

Encrypted Central Directory

When pkzip I&lt;Strong Encryption&gt; is enabled in a zip file this program can
still parse most of the metadata in the zip file. The exception is when the
C&lt;Central Directory&gt; of a zip file is also encrypted. This program cannot
parse any metadata from an encrypted C&lt;Central Directory&gt;.

=item *

Corrupt Zip files

When C&lt;zipdetails&gt; encounters a corrupt zip file, it will do one or more of
the following

=over 5

=item *

Display details of the corruption and carry on

=item *

Display details of the corruption and terminate

=item *

Terminate with a generic message

=back

Which of the above is output is dependent in the severity of the
corruption.

=back

=head1 TODO

=head2 JSON/YML Output

Output some of the zip file metadata as a JSON or YML document.

=head2 Corrupt Zip files

Although the detection and reporting of most of the common corruption use-cases is
present in C&lt;zipdetails&gt;, there are likely to be other edge cases that need
to be supported.

If you have a corrupt Zip file that isn't being processed properly, please
report it (see  L&lt;&quot;SUPPORT&quot;&gt;).

=head1 SUPPORT

General feedback/questions/bug reports should be sent to
L&lt;https://github.com/pmqs/zipdetails/issues&gt;.

=head1 SEE ALSO


The primary reference for Zip files is
L&lt;APPNOTE.TXT|https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT&gt;.

An alternative reference is the Info-Zip appnote. This is available from
L&lt;ftp://ftp.info-zip.org/pub/infozip/doc/&gt;

For details of WinZip AES encryption see L&lt;AES Encryption Information:
Encryption Specification AE-1 and
AE-2|https://www.winzip.com/en/support/aes-encryption/&gt;.

The C&lt;zipinfo&gt; program that comes with the info-zip distribution
(L&lt;http://www.info-zip.org/&gt;) can also display details of the structure of a zip
file.


=head1 AUTHOR

Paul Marquess F&lt;pmqs@cpan.org&gt;.

=head1 COPYRIGHT

Copyright (c) 2011-2024 Paul Marquess. All rights reserved.

This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2F3rdparty%2Fperl%2F542%2Fbin'>Back to Directory</a>