zlib: reject local/central ZIP header mismatch

The reader treats the central directory as authoritative for a member's
method, sizes, CRC, and name, but read the local header only for its
signature. An archive whose local file header disagrees with the
central directory therefore extracts different bytes here than in a
reader that uses the local header (e.g. Info-ZIP unzip), and its
encrypted bit was read from the local header while its identity came
from the central directory - a parser-confusion split that defeats
inspect-then-consume pipelines and can slip an encrypted member past a
central-directory scanner.
Cross-check the local header against the central entry when a member is
read: method, CRC, and both sizes (exempting a data-descriptor entry,
whose local crc/sizes are legitimately zero), plus the encryption flag.
Reject a mismatch with ERR_ZIP_INVALID_ARCHIVE, consistent with the
reject-rather-than-silently-choose stance already taken for ambiguous
archive ends.
The existing hardening/coverage tests that forged a decode-time size,
CRC, or Zip64 lie in the central header alone now trip this earlier
check; update them to patch both headers consistently so they still
exercise the decode-time guards they target.
Signed-off-by: Philipp Dunkel <pip@pipobscure.com>
PR-URL: #65016
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>

Author: pipobscure

lib/internal/zip/entry.js

@@ -76,6 +76,7 @@ const {
 const{
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
 }=require('internal/zip/headers');
 const{
@@ -399,6 +400,9 @@ class ZipEntry {
 awaitreadFdFully(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -419,6 +423,9 @@ class ZipEntry {
 readFdFullySync(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -930,6 +937,7 @@ function* readArchiveEntries(buf, end) {
 }
 constlocalOffset=central.localFileHeaderOffset+end.prefix;
 constlocal=newLocalFileHeader(buf,localOffset);
+assertConsistentLocalHeader(local,central);
 constdataStart=localOffset+local.byteLength;
 constlength=central.compressedSize;
 validateArchiveRange(buf,dataStart,length,'entry data');

lib/internal/zip/headers.js

@@ -25,6 +25,8 @@ const {
 SIG_ZIP64_EOCD_LOCATOR,
 SIG_EOCD,
 MADE_BY_UNIX,
+FLAG_ENCRYPTED,
+FLAG_DATA_DESCRIPTOR,
 SENTINEL16,
 SENTINEL32,
 TAIL_LENGTH,
@@ -267,6 +269,7 @@ class CentralFileHeader {
 classLocalFileHeader{
  #buffer;
  #offset;
+ #zip64 =null;
 constructor(buffer,offset=0){
 validateArchiveRange(buffer,offset,30,'local file header');
 if(buffer.readUInt32LE(offset)!==SIG_LOCAL_FILE_HEADER){
@@ -280,9 +283,31 @@ class LocalFileHeader {
 }
 getbyteLength(){return30+this.fileNameLength+this.extraFieldLength;}
 getflags(){returnthis.#buffer.readUInt16LE(this.#offset +6);}
-// Spec field (sec. 4.4.5); the central directory's method is authoritative,
-// so the local copy is not consumed today.
-// get compressionMethod() { return this.#buffer.readUInt16LE(this.#offset + 8); }
+// The central directory is authoritative, but these local fields are read to
+// reject an archive whose local header contradicts it (assertConsistentLocalHeader).
+getcompressionMethod(){returnthis.#buffer.readUInt16LE(this.#offset +8);}
+getcrc32(){returnthis.#buffer.readUInt32LE(this.#offset +14);}
+// The Zip64 extra supplies the true 64-bit sizes for whichever classic size
+// field holds an overflow sentinel; a local header has no offset/disk field.
+ #resolveZip64(){
+if(this.#zip64 ===null){
+this.#zip64 =parseZip64Extra(this.extraField,{
+uncompressedSize: this.#buffer.readUInt32LE(this.#offset +22)===SENTINEL32,
+compressedSize: this.#buffer.readUInt32LE(this.#offset +18)===SENTINEL32,
+localFileHeaderOffset: false,
+diskNumber: false,
+});
+}
+returnthis.#zip64;
+}
+getcompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +18);
+returnvalue===SENTINEL32 ? this.#resolveZip64().compressedSize : value;
+}
+getuncompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +22);
+returnvalue===SENTINEL32 ? this.#resolveZip64().uncompressedSize : value;
+}
 getfileNameLength(){returnthis.#buffer.readUInt16LE(this.#offset +26);}
 getextraFieldLength(){returnthis.#buffer.readUInt16LE(this.#offset +28);}
 getextraField(){
@@ -311,6 +336,35 @@ class LocalFileHeader {
 }
 }
 
+// Reject an archive whose local file header contradicts the central directory
+// on a field that decides which bytes a member yields. This reader treats the
+// central directory as authoritative, but a divergent local header lets a
+// local-header-based extractor (Info-ZIP unzip, and others) read a different
+// member, method, or size from the same archive - a parser-confusion split that
+// defeats inspect-then-consume pipelines. Reject rather than silently diverge.
+functionassertConsistentLocalHeader(local,central){
+if(local.compressionMethod!==central.compressionMethod){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central compression methods disagree');
+}
+if((local.flags&FLAG_ENCRYPTED)!==(central.flags&FLAG_ENCRYPTED)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central encryption flags disagree');
+}
+// A streamed entry (data-descriptor bit) writes zero crc and sizes in the
+// local header, deferring the true values to the central directory; only then
+// is a difference on those three fields expected.
+constdeferred=(local.flags&FLAG_DATA_DESCRIPTOR)!==0&&
+local.crc32===0&&local.compressedSize===0&&local.uncompressedSize===0;
+if(!deferred&&
+(local.crc32!==central.crc32||
+local.compressedSize!==central.compressedSize||
+local.uncompressedSize!==central.uncompressedSize)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central header crc-32 or sizes disagree');
+}
+}
+
 // Returns whether an EOCD-looking record could describe an archive this
 // implementation supports. This is deliberately only a cheap preflight: the
 // selected record still receives the complete Zip64 and central-directory
@@ -563,6 +617,7 @@ function readCentralDirectory(buffer, count) {
 module.exports={
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
  readCentralDirectory,
 };

test/parallel/test-zlib-zip-coverage.js

@@ -288,8 +288,9 @@ test('a Zip64 extra field value beyond Number.MAX_SAFE_INTEGER is rejected', asy
 uncompressedSize: 0xffffffffffffffffn,
 });
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+// The header cross-check resolves the sizes as the archive is read, so a
+// malformed Zip64 value is rejected at read time rather than at .size access.
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /exceedsthesafeintegerrange/,
 });
@@ -325,8 +326,7 @@ test('a Zip64 extra-field TLV whose declared size overflows the extra field is r
 tlv.writeUInt16LE(100,2);// claims 100 bytes of data, but none follow
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /extrafieldismalformed/,
 });
@@ -345,8 +345,7 @@ test('a Zip64 extra-field TLV too short for the field it claims to carry is reje
 tlv.writeUInt32LE(123,4);
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /Zip64extendedinformationextrafieldistruncated/,
 });
@@ -500,7 +499,8 @@ test('contentIterator() enforces the same guards as content() and contentSync()'
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
 }
@@ -593,7 +593,8 @@ test('ZipFile getSync().contentSync() enforces the same guards via decodeMemberS
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 constfilePath=awaitwriteTempArchive(tampered,'size-mismatch');
 constzf=zlib.ZipFile.openSync(filePath);
 assert.throws(()=>zf.getSync('f.txt').contentSync(),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
@@ -607,7 +608,8 @@ test('contentIterator() rejects an entry that inflates to less than its declared
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hi'.length;
-tampered.writeUInt32LE(1000,centralStart+24);// Declared size grown beyond reality
+tampered.writeUInt32LE(1000,22);// Local declared size
+tampered.writeUInt32LE(1000,centralStart+24);// Central declared size grown beyond reality
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{
 code: 'ERR_ZIP_ENTRY_CORRUPT',

test/parallel/test-zlib-zip-hardening.js

@@ -118,13 +118,14 @@ test('a declared-size mismatch is rejected as corrupt', async () => {
 constentry=awaitzlib.ZipEntry.create('f.txt',Buffer.from('hello world'),{method: 'store'});
 constarchive=awaitbuildArchive([entry]);
 
-// Shrink the *declared* uncompressed size in the central directory record
-// without touching the stored bytes themselves, so the amount of data
-// produced no longer matches what the header promised.
+// Shrink the *declared* uncompressed size in both the local and central
+// headers (kept consistent so the header cross-check passes) without touching
+// the stored bytes, so the produced amount no longer matches the headers'
+// promise and the decode-time size check fires.
 consttampered=Buffer.from(archive);
 constcentralHeaderStart=30+'f.txt'.length+'hello world'.length;
-constuncompressedSizeOffset=centralHeaderStart+24;
-tampered.writeUInt32LE(1,uncompressedSizeOffset);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralHeaderStart+24);// Central uncompressed size
 
 const[tamperedEntry]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(tamperedEntry.size,1);
@@ -165,7 +166,10 @@ test('a forged small header whose content inflates past its declared size is rej
 consttampered=Buffer.from(archive);
 consteocd=tampered.length-22;// No comment, so EOCD is the last 22 bytes
 constcdOffset=tampered.readUInt32LE(eocd+16);
-tampered.writeUInt32LE(50,cdOffset+24);// Forge declared uncompressedSize
+// Forge the declared uncompressedSize in both headers (kept consistent so
+// the header cross-check passes; the decompressor still catches the lie).
+tampered.writeUInt32LE(50,22);// Local uncompressedSize
+tampered.writeUInt32LE(50,cdOffset+24);// Central uncompressedSize
 
 const[e]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(e.size,50);// 50 <= maxSize 100 clears the up-front check
@@ -413,9 +417,11 @@ test('a member whose data crosses into the central directory is rejected', async
 constarchive=Buffer.from(awaitbuildArchive(
 [awaitzlib.ZipEntry.create(name,content,{method: 'store'})]));
 constcentralHeaderStart=30+name.length+content.length;
-// Lie about the compressed size so the member's data range reaches into
-// the central directory (while staying inside the buffer).
-archive.writeUInt32LE(content.length+40,centralHeaderStart+20);
+// Lie about the compressed size in both headers (kept consistent so the
+// header cross-check passes) so the member's data range reaches into the
+// central directory (while staying inside the buffer).
+archive.writeUInt32LE(content.length+40,18);// Local compressed size
+archive.writeUInt32LE(content.length+40,centralHeaderStart+20);// Central
 assert.throws(()=>[...zlib.ZipEntry.read(archive)],
 {code: 'ERR_ZIP_INVALID_ARCHIVE',message: /possiblezipbomb/});
 });

lib/internal/zip/entry.js

@@ -76,6 +76,7 @@ const {
 const{
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
 }=require('internal/zip/headers');
 const{
@@ -399,6 +400,9 @@ class ZipEntry {
 awaitreadFdFully(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -419,6 +423,9 @@ class ZipEntry {
 readFdFullySync(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -930,6 +937,7 @@ function* readArchiveEntries(buf, end) {
 }
 constlocalOffset=central.localFileHeaderOffset+end.prefix;
 constlocal=newLocalFileHeader(buf,localOffset);
+assertConsistentLocalHeader(local,central);
 constdataStart=localOffset+local.byteLength;
 constlength=central.compressedSize;
 validateArchiveRange(buf,dataStart,length,'entry data');

lib/internal/zip/headers.js

@@ -25,6 +25,8 @@ const {
 SIG_ZIP64_EOCD_LOCATOR,
 SIG_EOCD,
 MADE_BY_UNIX,
+FLAG_ENCRYPTED,
+FLAG_DATA_DESCRIPTOR,
 SENTINEL16,
 SENTINEL32,
 TAIL_LENGTH,
@@ -267,6 +269,7 @@ class CentralFileHeader {
 classLocalFileHeader{
  #buffer;
  #offset;
+ #zip64 =null;
 constructor(buffer,offset=0){
 validateArchiveRange(buffer,offset,30,'local file header');
 if(buffer.readUInt32LE(offset)!==SIG_LOCAL_FILE_HEADER){
@@ -280,9 +283,31 @@ class LocalFileHeader {
 }
 getbyteLength(){return30+this.fileNameLength+this.extraFieldLength;}
 getflags(){returnthis.#buffer.readUInt16LE(this.#offset +6);}
-// Spec field (sec. 4.4.5); the central directory's method is authoritative,
-// so the local copy is not consumed today.
-// get compressionMethod() { return this.#buffer.readUInt16LE(this.#offset + 8); }
+// The central directory is authoritative, but these local fields are read to
+// reject an archive whose local header contradicts it (assertConsistentLocalHeader).
+getcompressionMethod(){returnthis.#buffer.readUInt16LE(this.#offset +8);}
+getcrc32(){returnthis.#buffer.readUInt32LE(this.#offset +14);}
+// The Zip64 extra supplies the true 64-bit sizes for whichever classic size
+// field holds an overflow sentinel; a local header has no offset/disk field.
+ #resolveZip64(){
+if(this.#zip64 ===null){
+this.#zip64 =parseZip64Extra(this.extraField,{
+uncompressedSize: this.#buffer.readUInt32LE(this.#offset +22)===SENTINEL32,
+compressedSize: this.#buffer.readUInt32LE(this.#offset +18)===SENTINEL32,
+localFileHeaderOffset: false,
+diskNumber: false,
+});
+}
+returnthis.#zip64;
+}
+getcompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +18);
+returnvalue===SENTINEL32 ? this.#resolveZip64().compressedSize : value;
+}
+getuncompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +22);
+returnvalue===SENTINEL32 ? this.#resolveZip64().uncompressedSize : value;
+}
 getfileNameLength(){returnthis.#buffer.readUInt16LE(this.#offset +26);}
 getextraFieldLength(){returnthis.#buffer.readUInt16LE(this.#offset +28);}
 getextraField(){
@@ -311,6 +336,35 @@ class LocalFileHeader {
 }
 }
 
+// Reject an archive whose local file header contradicts the central directory
+// on a field that decides which bytes a member yields. This reader treats the
+// central directory as authoritative, but a divergent local header lets a
+// local-header-based extractor (Info-ZIP unzip, and others) read a different
+// member, method, or size from the same archive - a parser-confusion split that
+// defeats inspect-then-consume pipelines. Reject rather than silently diverge.
+functionassertConsistentLocalHeader(local,central){
+if(local.compressionMethod!==central.compressionMethod){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central compression methods disagree');
+}
+if((local.flags&FLAG_ENCRYPTED)!==(central.flags&FLAG_ENCRYPTED)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central encryption flags disagree');
+}
+// A streamed entry (data-descriptor bit) writes zero crc and sizes in the
+// local header, deferring the true values to the central directory; only then
+// is a difference on those three fields expected.
+constdeferred=(local.flags&FLAG_DATA_DESCRIPTOR)!==0&&
+local.crc32===0&&local.compressedSize===0&&local.uncompressedSize===0;
+if(!deferred&&
+(local.crc32!==central.crc32||
+local.compressedSize!==central.compressedSize||
+local.uncompressedSize!==central.uncompressedSize)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central header crc-32 or sizes disagree');
+}
+}
+
 // Returns whether an EOCD-looking record could describe an archive this
 // implementation supports. This is deliberately only a cheap preflight: the
 // selected record still receives the complete Zip64 and central-directory
@@ -563,6 +617,7 @@ function readCentralDirectory(buffer, count) {
 module.exports={
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
  readCentralDirectory,
 };

test/parallel/test-zlib-zip-coverage.js

@@ -288,8 +288,9 @@ test('a Zip64 extra field value beyond Number.MAX_SAFE_INTEGER is rejected', asy
 uncompressedSize: 0xffffffffffffffffn,
 });
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+// The header cross-check resolves the sizes as the archive is read, so a
+// malformed Zip64 value is rejected at read time rather than at .size access.
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /exceedsthesafeintegerrange/,
 });
@@ -325,8 +326,7 @@ test('a Zip64 extra-field TLV whose declared size overflows the extra field is r
 tlv.writeUInt16LE(100,2);// claims 100 bytes of data, but none follow
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /extrafieldismalformed/,
 });
@@ -345,8 +345,7 @@ test('a Zip64 extra-field TLV too short for the field it claims to carry is reje
 tlv.writeUInt32LE(123,4);
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /Zip64extendedinformationextrafieldistruncated/,
 });
@@ -500,7 +499,8 @@ test('contentIterator() enforces the same guards as content() and contentSync()'
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
 }
@@ -593,7 +593,8 @@ test('ZipFile getSync().contentSync() enforces the same guards via decodeMemberS
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 constfilePath=awaitwriteTempArchive(tampered,'size-mismatch');
 constzf=zlib.ZipFile.openSync(filePath);
 assert.throws(()=>zf.getSync('f.txt').contentSync(),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
@@ -607,7 +608,8 @@ test('contentIterator() rejects an entry that inflates to less than its declared
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hi'.length;
-tampered.writeUInt32LE(1000,centralStart+24);// Declared size grown beyond reality
+tampered.writeUInt32LE(1000,22);// Local declared size
+tampered.writeUInt32LE(1000,centralStart+24);// Central declared size grown beyond reality
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{
 code: 'ERR_ZIP_ENTRY_CORRUPT',

test/parallel/test-zlib-zip-hardening.js

@@ -118,13 +118,14 @@ test('a declared-size mismatch is rejected as corrupt', async () => {
 constentry=awaitzlib.ZipEntry.create('f.txt',Buffer.from('hello world'),{method: 'store'});
 constarchive=awaitbuildArchive([entry]);
 
-// Shrink the *declared* uncompressed size in the central directory record
-// without touching the stored bytes themselves, so the amount of data
-// produced no longer matches what the header promised.
+// Shrink the *declared* uncompressed size in both the local and central
+// headers (kept consistent so the header cross-check passes) without touching
+// the stored bytes, so the produced amount no longer matches the headers'
+// promise and the decode-time size check fires.
 consttampered=Buffer.from(archive);
 constcentralHeaderStart=30+'f.txt'.length+'hello world'.length;
-constuncompressedSizeOffset=centralHeaderStart+24;
-tampered.writeUInt32LE(1,uncompressedSizeOffset);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralHeaderStart+24);// Central uncompressed size
 
 const[tamperedEntry]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(tamperedEntry.size,1);
@@ -165,7 +166,10 @@ test('a forged small header whose content inflates past its declared size is rej
 consttampered=Buffer.from(archive);
 consteocd=tampered.length-22;// No comment, so EOCD is the last 22 bytes
 constcdOffset=tampered.readUInt32LE(eocd+16);
-tampered.writeUInt32LE(50,cdOffset+24);// Forge declared uncompressedSize
+// Forge the declared uncompressedSize in both headers (kept consistent so
+// the header cross-check passes; the decompressor still catches the lie).
+tampered.writeUInt32LE(50,22);// Local uncompressedSize
+tampered.writeUInt32LE(50,cdOffset+24);// Central uncompressedSize
 
 const[e]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(e.size,50);// 50 <= maxSize 100 clears the up-front check
@@ -413,9 +417,11 @@ test('a member whose data crosses into the central directory is rejected', async
 constarchive=Buffer.from(awaitbuildArchive(
 [awaitzlib.ZipEntry.create(name,content,{method: 'store'})]));
 constcentralHeaderStart=30+name.length+content.length;
-// Lie about the compressed size so the member's data range reaches into
-// the central directory (while staying inside the buffer).
-archive.writeUInt32LE(content.length+40,centralHeaderStart+20);
+// Lie about the compressed size in both headers (kept consistent so the
+// header cross-check passes) so the member's data range reaches into the
+// central directory (while staying inside the buffer).
+archive.writeUInt32LE(content.length+40,18);// Local compressed size
+archive.writeUInt32LE(content.length+40,centralHeaderStart+20);// Central
 assert.throws(()=>[...zlib.ZipEntry.read(archive)],
 {code: 'ERR_ZIP_INVALID_ARCHIVE',message: /possiblezipbomb/});
 });

lib/internal/zip/entry.js

@@ -76,6 +76,7 @@ const {
 const{
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
 }=require('internal/zip/headers');
 const{
@@ -399,6 +400,9 @@ class ZipEntry {
 awaitreadFdFully(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -419,6 +423,9 @@ class ZipEntry {
 readFdFullySync(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -930,6 +937,7 @@ function* readArchiveEntries(buf, end) {
 }
 constlocalOffset=central.localFileHeaderOffset+end.prefix;
 constlocal=newLocalFileHeader(buf,localOffset);
+assertConsistentLocalHeader(local,central);
 constdataStart=localOffset+local.byteLength;
 constlength=central.compressedSize;
 validateArchiveRange(buf,dataStart,length,'entry data');

lib/internal/zip/headers.js

@@ -25,6 +25,8 @@ const {
 SIG_ZIP64_EOCD_LOCATOR,
 SIG_EOCD,
 MADE_BY_UNIX,
+FLAG_ENCRYPTED,
+FLAG_DATA_DESCRIPTOR,
 SENTINEL16,
 SENTINEL32,
 TAIL_LENGTH,
@@ -267,6 +269,7 @@ class CentralFileHeader {
 classLocalFileHeader{
  #buffer;
  #offset;
+ #zip64 =null;
 constructor(buffer,offset=0){
 validateArchiveRange(buffer,offset,30,'local file header');
 if(buffer.readUInt32LE(offset)!==SIG_LOCAL_FILE_HEADER){
@@ -280,9 +283,31 @@ class LocalFileHeader {
 }
 getbyteLength(){return30+this.fileNameLength+this.extraFieldLength;}
 getflags(){returnthis.#buffer.readUInt16LE(this.#offset +6);}
-// Spec field (sec. 4.4.5); the central directory's method is authoritative,
-// so the local copy is not consumed today.
-// get compressionMethod() { return this.#buffer.readUInt16LE(this.#offset + 8); }
+// The central directory is authoritative, but these local fields are read to
+// reject an archive whose local header contradicts it (assertConsistentLocalHeader).
+getcompressionMethod(){returnthis.#buffer.readUInt16LE(this.#offset +8);}
+getcrc32(){returnthis.#buffer.readUInt32LE(this.#offset +14);}
+// The Zip64 extra supplies the true 64-bit sizes for whichever classic size
+// field holds an overflow sentinel; a local header has no offset/disk field.
+ #resolveZip64(){
+if(this.#zip64 ===null){
+this.#zip64 =parseZip64Extra(this.extraField,{
+uncompressedSize: this.#buffer.readUInt32LE(this.#offset +22)===SENTINEL32,
+compressedSize: this.#buffer.readUInt32LE(this.#offset +18)===SENTINEL32,
+localFileHeaderOffset: false,
+diskNumber: false,
+});
+}
+returnthis.#zip64;
+}
+getcompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +18);
+returnvalue===SENTINEL32 ? this.#resolveZip64().compressedSize : value;
+}
+getuncompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +22);
+returnvalue===SENTINEL32 ? this.#resolveZip64().uncompressedSize : value;
+}
 getfileNameLength(){returnthis.#buffer.readUInt16LE(this.#offset +26);}
 getextraFieldLength(){returnthis.#buffer.readUInt16LE(this.#offset +28);}
 getextraField(){
@@ -311,6 +336,35 @@ class LocalFileHeader {
 }
 }
 
+// Reject an archive whose local file header contradicts the central directory
+// on a field that decides which bytes a member yields. This reader treats the
+// central directory as authoritative, but a divergent local header lets a
+// local-header-based extractor (Info-ZIP unzip, and others) read a different
+// member, method, or size from the same archive - a parser-confusion split that
+// defeats inspect-then-consume pipelines. Reject rather than silently diverge.
+functionassertConsistentLocalHeader(local,central){
+if(local.compressionMethod!==central.compressionMethod){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central compression methods disagree');
+}
+if((local.flags&FLAG_ENCRYPTED)!==(central.flags&FLAG_ENCRYPTED)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central encryption flags disagree');
+}
+// A streamed entry (data-descriptor bit) writes zero crc and sizes in the
+// local header, deferring the true values to the central directory; only then
+// is a difference on those three fields expected.
+constdeferred=(local.flags&FLAG_DATA_DESCRIPTOR)!==0&&
+local.crc32===0&&local.compressedSize===0&&local.uncompressedSize===0;
+if(!deferred&&
+(local.crc32!==central.crc32||
+local.compressedSize!==central.compressedSize||
+local.uncompressedSize!==central.uncompressedSize)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central header crc-32 or sizes disagree');
+}
+}
+
 // Returns whether an EOCD-looking record could describe an archive this
 // implementation supports. This is deliberately only a cheap preflight: the
 // selected record still receives the complete Zip64 and central-directory
@@ -563,6 +617,7 @@ function readCentralDirectory(buffer, count) {
 module.exports={
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
  readCentralDirectory,
 };

test/parallel/test-zlib-zip-coverage.js

@@ -288,8 +288,9 @@ test('a Zip64 extra field value beyond Number.MAX_SAFE_INTEGER is rejected', asy
 uncompressedSize: 0xffffffffffffffffn,
 });
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+// The header cross-check resolves the sizes as the archive is read, so a
+// malformed Zip64 value is rejected at read time rather than at .size access.
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /exceedsthesafeintegerrange/,
 });
@@ -325,8 +326,7 @@ test('a Zip64 extra-field TLV whose declared size overflows the extra field is r
 tlv.writeUInt16LE(100,2);// claims 100 bytes of data, but none follow
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /extrafieldismalformed/,
 });
@@ -345,8 +345,7 @@ test('a Zip64 extra-field TLV too short for the field it claims to carry is reje
 tlv.writeUInt32LE(123,4);
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /Zip64extendedinformationextrafieldistruncated/,
 });
@@ -500,7 +499,8 @@ test('contentIterator() enforces the same guards as content() and contentSync()'
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
 }
@@ -593,7 +593,8 @@ test('ZipFile getSync().contentSync() enforces the same guards via decodeMemberS
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 constfilePath=awaitwriteTempArchive(tampered,'size-mismatch');
 constzf=zlib.ZipFile.openSync(filePath);
 assert.throws(()=>zf.getSync('f.txt').contentSync(),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
@@ -607,7 +608,8 @@ test('contentIterator() rejects an entry that inflates to less than its declared
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hi'.length;
-tampered.writeUInt32LE(1000,centralStart+24);// Declared size grown beyond reality
+tampered.writeUInt32LE(1000,22);// Local declared size
+tampered.writeUInt32LE(1000,centralStart+24);// Central declared size grown beyond reality
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{
 code: 'ERR_ZIP_ENTRY_CORRUPT',

test/parallel/test-zlib-zip-hardening.js

@@ -118,13 +118,14 @@ test('a declared-size mismatch is rejected as corrupt', async () => {
 constentry=awaitzlib.ZipEntry.create('f.txt',Buffer.from('hello world'),{method: 'store'});
 constarchive=awaitbuildArchive([entry]);
 
-// Shrink the *declared* uncompressed size in the central directory record
-// without touching the stored bytes themselves, so the amount of data
-// produced no longer matches what the header promised.
+// Shrink the *declared* uncompressed size in both the local and central
+// headers (kept consistent so the header cross-check passes) without touching
+// the stored bytes, so the produced amount no longer matches the headers'
+// promise and the decode-time size check fires.
 consttampered=Buffer.from(archive);
 constcentralHeaderStart=30+'f.txt'.length+'hello world'.length;
-constuncompressedSizeOffset=centralHeaderStart+24;
-tampered.writeUInt32LE(1,uncompressedSizeOffset);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralHeaderStart+24);// Central uncompressed size
 
 const[tamperedEntry]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(tamperedEntry.size,1);
@@ -165,7 +166,10 @@ test('a forged small header whose content inflates past its declared size is rej
 consttampered=Buffer.from(archive);
 consteocd=tampered.length-22;// No comment, so EOCD is the last 22 bytes
 constcdOffset=tampered.readUInt32LE(eocd+16);
-tampered.writeUInt32LE(50,cdOffset+24);// Forge declared uncompressedSize
+// Forge the declared uncompressedSize in both headers (kept consistent so
+// the header cross-check passes; the decompressor still catches the lie).
+tampered.writeUInt32LE(50,22);// Local uncompressedSize
+tampered.writeUInt32LE(50,cdOffset+24);// Central uncompressedSize
 
 const[e]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(e.size,50);// 50 <= maxSize 100 clears the up-front check
@@ -413,9 +417,11 @@ test('a member whose data crosses into the central directory is rejected', async
 constarchive=Buffer.from(awaitbuildArchive(
 [awaitzlib.ZipEntry.create(name,content,{method: 'store'})]));
 constcentralHeaderStart=30+name.length+content.length;
-// Lie about the compressed size so the member's data range reaches into
-// the central directory (while staying inside the buffer).
-archive.writeUInt32LE(content.length+40,centralHeaderStart+20);
+// Lie about the compressed size in both headers (kept consistent so the
+// header cross-check passes) so the member's data range reaches into the
+// central directory (while staying inside the buffer).
+archive.writeUInt32LE(content.length+40,18);// Local compressed size
+archive.writeUInt32LE(content.length+40,centralHeaderStart+20);// Central
 assert.throws(()=>[...zlib.ZipEntry.read(archive)],
 {code: 'ERR_ZIP_INVALID_ARCHIVE',message: /possiblezipbomb/});
 });

lib/internal/zip/entry.js

@@ -76,6 +76,7 @@ const {
 const{
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
 }=require('internal/zip/headers');
 const{
@@ -399,6 +400,9 @@ class ZipEntry {
 awaitreadFdFully(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -419,6 +423,9 @@ class ZipEntry {
 readFdFullySync(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -930,6 +937,7 @@ function* readArchiveEntries(buf, end) {
 }
 constlocalOffset=central.localFileHeaderOffset+end.prefix;
 constlocal=newLocalFileHeader(buf,localOffset);
+assertConsistentLocalHeader(local,central);
 constdataStart=localOffset+local.byteLength;
 constlength=central.compressedSize;
 validateArchiveRange(buf,dataStart,length,'entry data');

lib/internal/zip/headers.js

@@ -25,6 +25,8 @@ const {
 SIG_ZIP64_EOCD_LOCATOR,
 SIG_EOCD,
 MADE_BY_UNIX,
+FLAG_ENCRYPTED,
+FLAG_DATA_DESCRIPTOR,
 SENTINEL16,
 SENTINEL32,
 TAIL_LENGTH,
@@ -267,6 +269,7 @@ class CentralFileHeader {
 classLocalFileHeader{
  #buffer;
  #offset;
+ #zip64 =null;
 constructor(buffer,offset=0){
 validateArchiveRange(buffer,offset,30,'local file header');
 if(buffer.readUInt32LE(offset)!==SIG_LOCAL_FILE_HEADER){
@@ -280,9 +283,31 @@ class LocalFileHeader {
 }
 getbyteLength(){return30+this.fileNameLength+this.extraFieldLength;}
 getflags(){returnthis.#buffer.readUInt16LE(this.#offset +6);}
-// Spec field (sec. 4.4.5); the central directory's method is authoritative,
-// so the local copy is not consumed today.
-// get compressionMethod() { return this.#buffer.readUInt16LE(this.#offset + 8); }
+// The central directory is authoritative, but these local fields are read to
+// reject an archive whose local header contradicts it (assertConsistentLocalHeader).
+getcompressionMethod(){returnthis.#buffer.readUInt16LE(this.#offset +8);}
+getcrc32(){returnthis.#buffer.readUInt32LE(this.#offset +14);}
+// The Zip64 extra supplies the true 64-bit sizes for whichever classic size
+// field holds an overflow sentinel; a local header has no offset/disk field.
+ #resolveZip64(){
+if(this.#zip64 ===null){
+this.#zip64 =parseZip64Extra(this.extraField,{
+uncompressedSize: this.#buffer.readUInt32LE(this.#offset +22)===SENTINEL32,
+compressedSize: this.#buffer.readUInt32LE(this.#offset +18)===SENTINEL32,
+localFileHeaderOffset: false,
+diskNumber: false,
+});
+}
+returnthis.#zip64;
+}
+getcompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +18);
+returnvalue===SENTINEL32 ? this.#resolveZip64().compressedSize : value;
+}
+getuncompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +22);
+returnvalue===SENTINEL32 ? this.#resolveZip64().uncompressedSize : value;
+}
 getfileNameLength(){returnthis.#buffer.readUInt16LE(this.#offset +26);}
 getextraFieldLength(){returnthis.#buffer.readUInt16LE(this.#offset +28);}
 getextraField(){
@@ -311,6 +336,35 @@ class LocalFileHeader {
 }
 }
 
+// Reject an archive whose local file header contradicts the central directory
+// on a field that decides which bytes a member yields. This reader treats the
+// central directory as authoritative, but a divergent local header lets a
+// local-header-based extractor (Info-ZIP unzip, and others) read a different
+// member, method, or size from the same archive - a parser-confusion split that
+// defeats inspect-then-consume pipelines. Reject rather than silently diverge.
+functionassertConsistentLocalHeader(local,central){
+if(local.compressionMethod!==central.compressionMethod){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central compression methods disagree');
+}
+if((local.flags&FLAG_ENCRYPTED)!==(central.flags&FLAG_ENCRYPTED)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central encryption flags disagree');
+}
+// A streamed entry (data-descriptor bit) writes zero crc and sizes in the
+// local header, deferring the true values to the central directory; only then
+// is a difference on those three fields expected.
+constdeferred=(local.flags&FLAG_DATA_DESCRIPTOR)!==0&&
+local.crc32===0&&local.compressedSize===0&&local.uncompressedSize===0;
+if(!deferred&&
+(local.crc32!==central.crc32||
+local.compressedSize!==central.compressedSize||
+local.uncompressedSize!==central.uncompressedSize)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central header crc-32 or sizes disagree');
+}
+}
+
 // Returns whether an EOCD-looking record could describe an archive this
 // implementation supports. This is deliberately only a cheap preflight: the
 // selected record still receives the complete Zip64 and central-directory
@@ -563,6 +617,7 @@ function readCentralDirectory(buffer, count) {
 module.exports={
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
  readCentralDirectory,
 };

test/parallel/test-zlib-zip-coverage.js

@@ -288,8 +288,9 @@ test('a Zip64 extra field value beyond Number.MAX_SAFE_INTEGER is rejected', asy
 uncompressedSize: 0xffffffffffffffffn,
 });
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+// The header cross-check resolves the sizes as the archive is read, so a
+// malformed Zip64 value is rejected at read time rather than at .size access.
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /exceedsthesafeintegerrange/,
 });
@@ -325,8 +326,7 @@ test('a Zip64 extra-field TLV whose declared size overflows the extra field is r
 tlv.writeUInt16LE(100,2);// claims 100 bytes of data, but none follow
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /extrafieldismalformed/,
 });
@@ -345,8 +345,7 @@ test('a Zip64 extra-field TLV too short for the field it claims to carry is reje
 tlv.writeUInt32LE(123,4);
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /Zip64extendedinformationextrafieldistruncated/,
 });
@@ -500,7 +499,8 @@ test('contentIterator() enforces the same guards as content() and contentSync()'
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
 }
@@ -593,7 +593,8 @@ test('ZipFile getSync().contentSync() enforces the same guards via decodeMemberS
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 constfilePath=awaitwriteTempArchive(tampered,'size-mismatch');
 constzf=zlib.ZipFile.openSync(filePath);
 assert.throws(()=>zf.getSync('f.txt').contentSync(),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
@@ -607,7 +608,8 @@ test('contentIterator() rejects an entry that inflates to less than its declared
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hi'.length;
-tampered.writeUInt32LE(1000,centralStart+24);// Declared size grown beyond reality
+tampered.writeUInt32LE(1000,22);// Local declared size
+tampered.writeUInt32LE(1000,centralStart+24);// Central declared size grown beyond reality
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{
 code: 'ERR_ZIP_ENTRY_CORRUPT',

test/parallel/test-zlib-zip-hardening.js

@@ -118,13 +118,14 @@ test('a declared-size mismatch is rejected as corrupt', async () => {
 constentry=awaitzlib.ZipEntry.create('f.txt',Buffer.from('hello world'),{method: 'store'});
 constarchive=awaitbuildArchive([entry]);
 
-// Shrink the *declared* uncompressed size in the central directory record
-// without touching the stored bytes themselves, so the amount of data
-// produced no longer matches what the header promised.
+// Shrink the *declared* uncompressed size in both the local and central
+// headers (kept consistent so the header cross-check passes) without touching
+// the stored bytes, so the produced amount no longer matches the headers'
+// promise and the decode-time size check fires.
 consttampered=Buffer.from(archive);
 constcentralHeaderStart=30+'f.txt'.length+'hello world'.length;
-constuncompressedSizeOffset=centralHeaderStart+24;
-tampered.writeUInt32LE(1,uncompressedSizeOffset);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralHeaderStart+24);// Central uncompressed size
 
 const[tamperedEntry]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(tamperedEntry.size,1);
@@ -165,7 +166,10 @@ test('a forged small header whose content inflates past its declared size is rej
 consttampered=Buffer.from(archive);
 consteocd=tampered.length-22;// No comment, so EOCD is the last 22 bytes
 constcdOffset=tampered.readUInt32LE(eocd+16);
-tampered.writeUInt32LE(50,cdOffset+24);// Forge declared uncompressedSize
+// Forge the declared uncompressedSize in both headers (kept consistent so
+// the header cross-check passes; the decompressor still catches the lie).
+tampered.writeUInt32LE(50,22);// Local uncompressedSize
+tampered.writeUInt32LE(50,cdOffset+24);// Central uncompressedSize
 
 const[e]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(e.size,50);// 50 <= maxSize 100 clears the up-front check
@@ -413,9 +417,11 @@ test('a member whose data crosses into the central directory is rejected', async
 constarchive=Buffer.from(awaitbuildArchive(
 [awaitzlib.ZipEntry.create(name,content,{method: 'store'})]));
 constcentralHeaderStart=30+name.length+content.length;
-// Lie about the compressed size so the member's data range reaches into
-// the central directory (while staying inside the buffer).
-archive.writeUInt32LE(content.length+40,centralHeaderStart+20);
+// Lie about the compressed size in both headers (kept consistent so the
+// header cross-check passes) so the member's data range reaches into the
+// central directory (while staying inside the buffer).
+archive.writeUInt32LE(content.length+40,18);// Local compressed size
+archive.writeUInt32LE(content.length+40,centralHeaderStart+20);// Central
 assert.throws(()=>[...zlib.ZipEntry.read(archive)],
 {code: 'ERR_ZIP_INVALID_ARCHIVE',message: /possiblezipbomb/});
 });

lib/internal/zip/entry.js

@@ -76,6 +76,7 @@ const {
 const{
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
 }=require('internal/zip/headers');
 const{
@@ -399,6 +400,9 @@ class ZipEntry {
 awaitreadFdFully(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -419,6 +423,9 @@ class ZipEntry {
 readFdFullySync(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -930,6 +937,7 @@ function* readArchiveEntries(buf, end) {
 }
 constlocalOffset=central.localFileHeaderOffset+end.prefix;
 constlocal=newLocalFileHeader(buf,localOffset);
+assertConsistentLocalHeader(local,central);
 constdataStart=localOffset+local.byteLength;
 constlength=central.compressedSize;
 validateArchiveRange(buf,dataStart,length,'entry data');

lib/internal/zip/headers.js

@@ -25,6 +25,8 @@ const {
 SIG_ZIP64_EOCD_LOCATOR,
 SIG_EOCD,
 MADE_BY_UNIX,
+FLAG_ENCRYPTED,
+FLAG_DATA_DESCRIPTOR,
 SENTINEL16,
 SENTINEL32,
 TAIL_LENGTH,
@@ -267,6 +269,7 @@ class CentralFileHeader {
 classLocalFileHeader{
  #buffer;
  #offset;
+ #zip64 =null;
 constructor(buffer,offset=0){
 validateArchiveRange(buffer,offset,30,'local file header');
 if(buffer.readUInt32LE(offset)!==SIG_LOCAL_FILE_HEADER){
@@ -280,9 +283,31 @@ class LocalFileHeader {
 }
 getbyteLength(){return30+this.fileNameLength+this.extraFieldLength;}
 getflags(){returnthis.#buffer.readUInt16LE(this.#offset +6);}
-// Spec field (sec. 4.4.5); the central directory's method is authoritative,
-// so the local copy is not consumed today.
-// get compressionMethod() { return this.#buffer.readUInt16LE(this.#offset + 8); }
+// The central directory is authoritative, but these local fields are read to
+// reject an archive whose local header contradicts it (assertConsistentLocalHeader).
+getcompressionMethod(){returnthis.#buffer.readUInt16LE(this.#offset +8);}
+getcrc32(){returnthis.#buffer.readUInt32LE(this.#offset +14);}
+// The Zip64 extra supplies the true 64-bit sizes for whichever classic size
+// field holds an overflow sentinel; a local header has no offset/disk field.
+ #resolveZip64(){
+if(this.#zip64 ===null){
+this.#zip64 =parseZip64Extra(this.extraField,{
+uncompressedSize: this.#buffer.readUInt32LE(this.#offset +22)===SENTINEL32,
+compressedSize: this.#buffer.readUInt32LE(this.#offset +18)===SENTINEL32,
+localFileHeaderOffset: false,
+diskNumber: false,
+});
+}
+returnthis.#zip64;
+}
+getcompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +18);
+returnvalue===SENTINEL32 ? this.#resolveZip64().compressedSize : value;
+}
+getuncompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +22);
+returnvalue===SENTINEL32 ? this.#resolveZip64().uncompressedSize : value;
+}
 getfileNameLength(){returnthis.#buffer.readUInt16LE(this.#offset +26);}
 getextraFieldLength(){returnthis.#buffer.readUInt16LE(this.#offset +28);}
 getextraField(){
@@ -311,6 +336,35 @@ class LocalFileHeader {
 }
 }
 
+// Reject an archive whose local file header contradicts the central directory
+// on a field that decides which bytes a member yields. This reader treats the
+// central directory as authoritative, but a divergent local header lets a
+// local-header-based extractor (Info-ZIP unzip, and others) read a different
+// member, method, or size from the same archive - a parser-confusion split that
+// defeats inspect-then-consume pipelines. Reject rather than silently diverge.
+functionassertConsistentLocalHeader(local,central){
+if(local.compressionMethod!==central.compressionMethod){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central compression methods disagree');
+}
+if((local.flags&FLAG_ENCRYPTED)!==(central.flags&FLAG_ENCRYPTED)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central encryption flags disagree');
+}
+// A streamed entry (data-descriptor bit) writes zero crc and sizes in the
+// local header, deferring the true values to the central directory; only then
+// is a difference on those three fields expected.
+constdeferred=(local.flags&FLAG_DATA_DESCRIPTOR)!==0&&
+local.crc32===0&&local.compressedSize===0&&local.uncompressedSize===0;
+if(!deferred&&
+(local.crc32!==central.crc32||
+local.compressedSize!==central.compressedSize||
+local.uncompressedSize!==central.uncompressedSize)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central header crc-32 or sizes disagree');
+}
+}
+
 // Returns whether an EOCD-looking record could describe an archive this
 // implementation supports. This is deliberately only a cheap preflight: the
 // selected record still receives the complete Zip64 and central-directory
@@ -563,6 +617,7 @@ function readCentralDirectory(buffer, count) {
 module.exports={
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
  readCentralDirectory,
 };

test/parallel/test-zlib-zip-coverage.js

@@ -288,8 +288,9 @@ test('a Zip64 extra field value beyond Number.MAX_SAFE_INTEGER is rejected', asy
 uncompressedSize: 0xffffffffffffffffn,
 });
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+// The header cross-check resolves the sizes as the archive is read, so a
+// malformed Zip64 value is rejected at read time rather than at .size access.
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /exceedsthesafeintegerrange/,
 });
@@ -325,8 +326,7 @@ test('a Zip64 extra-field TLV whose declared size overflows the extra field is r
 tlv.writeUInt16LE(100,2);// claims 100 bytes of data, but none follow
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /extrafieldismalformed/,
 });
@@ -345,8 +345,7 @@ test('a Zip64 extra-field TLV too short for the field it claims to carry is reje
 tlv.writeUInt32LE(123,4);
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /Zip64extendedinformationextrafieldistruncated/,
 });
@@ -500,7 +499,8 @@ test('contentIterator() enforces the same guards as content() and contentSync()'
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
 }
@@ -593,7 +593,8 @@ test('ZipFile getSync().contentSync() enforces the same guards via decodeMemberS
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 constfilePath=awaitwriteTempArchive(tampered,'size-mismatch');
 constzf=zlib.ZipFile.openSync(filePath);
 assert.throws(()=>zf.getSync('f.txt').contentSync(),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
@@ -607,7 +608,8 @@ test('contentIterator() rejects an entry that inflates to less than its declared
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hi'.length;
-tampered.writeUInt32LE(1000,centralStart+24);// Declared size grown beyond reality
+tampered.writeUInt32LE(1000,22);// Local declared size
+tampered.writeUInt32LE(1000,centralStart+24);// Central declared size grown beyond reality
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{
 code: 'ERR_ZIP_ENTRY_CORRUPT',

test/parallel/test-zlib-zip-hardening.js

@@ -118,13 +118,14 @@ test('a declared-size mismatch is rejected as corrupt', async () => {
 constentry=awaitzlib.ZipEntry.create('f.txt',Buffer.from('hello world'),{method: 'store'});
 constarchive=awaitbuildArchive([entry]);
 
-// Shrink the *declared* uncompressed size in the central directory record
-// without touching the stored bytes themselves, so the amount of data
-// produced no longer matches what the header promised.
+// Shrink the *declared* uncompressed size in both the local and central
+// headers (kept consistent so the header cross-check passes) without touching
+// the stored bytes, so the produced amount no longer matches the headers'
+// promise and the decode-time size check fires.
 consttampered=Buffer.from(archive);
 constcentralHeaderStart=30+'f.txt'.length+'hello world'.length;
-constuncompressedSizeOffset=centralHeaderStart+24;
-tampered.writeUInt32LE(1,uncompressedSizeOffset);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralHeaderStart+24);// Central uncompressed size
 
 const[tamperedEntry]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(tamperedEntry.size,1);
@@ -165,7 +166,10 @@ test('a forged small header whose content inflates past its declared size is rej
 consttampered=Buffer.from(archive);
 consteocd=tampered.length-22;// No comment, so EOCD is the last 22 bytes
 constcdOffset=tampered.readUInt32LE(eocd+16);
-tampered.writeUInt32LE(50,cdOffset+24);// Forge declared uncompressedSize
+// Forge the declared uncompressedSize in both headers (kept consistent so
+// the header cross-check passes; the decompressor still catches the lie).
+tampered.writeUInt32LE(50,22);// Local uncompressedSize
+tampered.writeUInt32LE(50,cdOffset+24);// Central uncompressedSize
 
 const[e]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(e.size,50);// 50 <= maxSize 100 clears the up-front check
@@ -413,9 +417,11 @@ test('a member whose data crosses into the central directory is rejected', async
 constarchive=Buffer.from(awaitbuildArchive(
 [awaitzlib.ZipEntry.create(name,content,{method: 'store'})]));
 constcentralHeaderStart=30+name.length+content.length;
-// Lie about the compressed size so the member's data range reaches into
-// the central directory (while staying inside the buffer).
-archive.writeUInt32LE(content.length+40,centralHeaderStart+20);
+// Lie about the compressed size in both headers (kept consistent so the
+// header cross-check passes) so the member's data range reaches into the
+// central directory (while staying inside the buffer).
+archive.writeUInt32LE(content.length+40,18);// Local compressed size
+archive.writeUInt32LE(content.length+40,centralHeaderStart+20);// Central
 assert.throws(()=>[...zlib.ZipEntry.read(archive)],
 {code: 'ERR_ZIP_INVALID_ARCHIVE',message: /possiblezipbomb/});
 });

lib/internal/zip/entry.js

@@ -76,6 +76,7 @@ const {
 const{
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
 }=require('internal/zip/headers');
 const{
@@ -399,6 +400,9 @@ class ZipEntry {
 awaitreadFdFully(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -419,6 +423,9 @@ class ZipEntry {
 readFdFullySync(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -930,6 +937,7 @@ function* readArchiveEntries(buf, end) {
 }
 constlocalOffset=central.localFileHeaderOffset+end.prefix;
 constlocal=newLocalFileHeader(buf,localOffset);
+assertConsistentLocalHeader(local,central);
 constdataStart=localOffset+local.byteLength;
 constlength=central.compressedSize;
 validateArchiveRange(buf,dataStart,length,'entry data');

lib/internal/zip/headers.js

@@ -25,6 +25,8 @@ const {
 SIG_ZIP64_EOCD_LOCATOR,
 SIG_EOCD,
 MADE_BY_UNIX,
+FLAG_ENCRYPTED,
+FLAG_DATA_DESCRIPTOR,
 SENTINEL16,
 SENTINEL32,
 TAIL_LENGTH,
@@ -267,6 +269,7 @@ class CentralFileHeader {
 classLocalFileHeader{
  #buffer;
  #offset;
+ #zip64 =null;
 constructor(buffer,offset=0){
 validateArchiveRange(buffer,offset,30,'local file header');
 if(buffer.readUInt32LE(offset)!==SIG_LOCAL_FILE_HEADER){
@@ -280,9 +283,31 @@ class LocalFileHeader {
 }
 getbyteLength(){return30+this.fileNameLength+this.extraFieldLength;}
 getflags(){returnthis.#buffer.readUInt16LE(this.#offset +6);}
-// Spec field (sec. 4.4.5); the central directory's method is authoritative,
-// so the local copy is not consumed today.
-// get compressionMethod() { return this.#buffer.readUInt16LE(this.#offset + 8); }
+// The central directory is authoritative, but these local fields are read to
+// reject an archive whose local header contradicts it (assertConsistentLocalHeader).
+getcompressionMethod(){returnthis.#buffer.readUInt16LE(this.#offset +8);}
+getcrc32(){returnthis.#buffer.readUInt32LE(this.#offset +14);}
+// The Zip64 extra supplies the true 64-bit sizes for whichever classic size
+// field holds an overflow sentinel; a local header has no offset/disk field.
+ #resolveZip64(){
+if(this.#zip64 ===null){
+this.#zip64 =parseZip64Extra(this.extraField,{
+uncompressedSize: this.#buffer.readUInt32LE(this.#offset +22)===SENTINEL32,
+compressedSize: this.#buffer.readUInt32LE(this.#offset +18)===SENTINEL32,
+localFileHeaderOffset: false,
+diskNumber: false,
+});
+}
+returnthis.#zip64;
+}
+getcompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +18);
+returnvalue===SENTINEL32 ? this.#resolveZip64().compressedSize : value;
+}
+getuncompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +22);
+returnvalue===SENTINEL32 ? this.#resolveZip64().uncompressedSize : value;
+}
 getfileNameLength(){returnthis.#buffer.readUInt16LE(this.#offset +26);}
 getextraFieldLength(){returnthis.#buffer.readUInt16LE(this.#offset +28);}
 getextraField(){
@@ -311,6 +336,35 @@ class LocalFileHeader {
 }
 }
 
+// Reject an archive whose local file header contradicts the central directory
+// on a field that decides which bytes a member yields. This reader treats the
+// central directory as authoritative, but a divergent local header lets a
+// local-header-based extractor (Info-ZIP unzip, and others) read a different
+// member, method, or size from the same archive - a parser-confusion split that
+// defeats inspect-then-consume pipelines. Reject rather than silently diverge.
+functionassertConsistentLocalHeader(local,central){
+if(local.compressionMethod!==central.compressionMethod){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central compression methods disagree');
+}
+if((local.flags&FLAG_ENCRYPTED)!==(central.flags&FLAG_ENCRYPTED)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central encryption flags disagree');
+}
+// A streamed entry (data-descriptor bit) writes zero crc and sizes in the
+// local header, deferring the true values to the central directory; only then
+// is a difference on those three fields expected.
+constdeferred=(local.flags&FLAG_DATA_DESCRIPTOR)!==0&&
+local.crc32===0&&local.compressedSize===0&&local.uncompressedSize===0;
+if(!deferred&&
+(local.crc32!==central.crc32||
+local.compressedSize!==central.compressedSize||
+local.uncompressedSize!==central.uncompressedSize)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central header crc-32 or sizes disagree');
+}
+}
+
 // Returns whether an EOCD-looking record could describe an archive this
 // implementation supports. This is deliberately only a cheap preflight: the
 // selected record still receives the complete Zip64 and central-directory
@@ -563,6 +617,7 @@ function readCentralDirectory(buffer, count) {
 module.exports={
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
  readCentralDirectory,
 };

test/parallel/test-zlib-zip-coverage.js

@@ -288,8 +288,9 @@ test('a Zip64 extra field value beyond Number.MAX_SAFE_INTEGER is rejected', asy
 uncompressedSize: 0xffffffffffffffffn,
 });
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+// The header cross-check resolves the sizes as the archive is read, so a
+// malformed Zip64 value is rejected at read time rather than at .size access.
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /exceedsthesafeintegerrange/,
 });
@@ -325,8 +326,7 @@ test('a Zip64 extra-field TLV whose declared size overflows the extra field is r
 tlv.writeUInt16LE(100,2);// claims 100 bytes of data, but none follow
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /extrafieldismalformed/,
 });
@@ -345,8 +345,7 @@ test('a Zip64 extra-field TLV too short for the field it claims to carry is reje
 tlv.writeUInt32LE(123,4);
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /Zip64extendedinformationextrafieldistruncated/,
 });
@@ -500,7 +499,8 @@ test('contentIterator() enforces the same guards as content() and contentSync()'
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
 }
@@ -593,7 +593,8 @@ test('ZipFile getSync().contentSync() enforces the same guards via decodeMemberS
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 constfilePath=awaitwriteTempArchive(tampered,'size-mismatch');
 constzf=zlib.ZipFile.openSync(filePath);
 assert.throws(()=>zf.getSync('f.txt').contentSync(),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
@@ -607,7 +608,8 @@ test('contentIterator() rejects an entry that inflates to less than its declared
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hi'.length;
-tampered.writeUInt32LE(1000,centralStart+24);// Declared size grown beyond reality
+tampered.writeUInt32LE(1000,22);// Local declared size
+tampered.writeUInt32LE(1000,centralStart+24);// Central declared size grown beyond reality
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{
 code: 'ERR_ZIP_ENTRY_CORRUPT',

test/parallel/test-zlib-zip-hardening.js

@@ -118,13 +118,14 @@ test('a declared-size mismatch is rejected as corrupt', async () => {
 constentry=awaitzlib.ZipEntry.create('f.txt',Buffer.from('hello world'),{method: 'store'});
 constarchive=awaitbuildArchive([entry]);
 
-// Shrink the *declared* uncompressed size in the central directory record
-// without touching the stored bytes themselves, so the amount of data
-// produced no longer matches what the header promised.
+// Shrink the *declared* uncompressed size in both the local and central
+// headers (kept consistent so the header cross-check passes) without touching
+// the stored bytes, so the produced amount no longer matches the headers'
+// promise and the decode-time size check fires.
 consttampered=Buffer.from(archive);
 constcentralHeaderStart=30+'f.txt'.length+'hello world'.length;
-constuncompressedSizeOffset=centralHeaderStart+24;
-tampered.writeUInt32LE(1,uncompressedSizeOffset);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralHeaderStart+24);// Central uncompressed size
 
 const[tamperedEntry]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(tamperedEntry.size,1);
@@ -165,7 +166,10 @@ test('a forged small header whose content inflates past its declared size is rej
 consttampered=Buffer.from(archive);
 consteocd=tampered.length-22;// No comment, so EOCD is the last 22 bytes
 constcdOffset=tampered.readUInt32LE(eocd+16);
-tampered.writeUInt32LE(50,cdOffset+24);// Forge declared uncompressedSize
+// Forge the declared uncompressedSize in both headers (kept consistent so
+// the header cross-check passes; the decompressor still catches the lie).
+tampered.writeUInt32LE(50,22);// Local uncompressedSize
+tampered.writeUInt32LE(50,cdOffset+24);// Central uncompressedSize
 
 const[e]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(e.size,50);// 50 <= maxSize 100 clears the up-front check
@@ -413,9 +417,11 @@ test('a member whose data crosses into the central directory is rejected', async
 constarchive=Buffer.from(awaitbuildArchive(
 [awaitzlib.ZipEntry.create(name,content,{method: 'store'})]));
 constcentralHeaderStart=30+name.length+content.length;
-// Lie about the compressed size so the member's data range reaches into
-// the central directory (while staying inside the buffer).
-archive.writeUInt32LE(content.length+40,centralHeaderStart+20);
+// Lie about the compressed size in both headers (kept consistent so the
+// header cross-check passes) so the member's data range reaches into the
+// central directory (while staying inside the buffer).
+archive.writeUInt32LE(content.length+40,18);// Local compressed size
+archive.writeUInt32LE(content.length+40,centralHeaderStart+20);// Central
 assert.throws(()=>[...zlib.ZipEntry.read(archive)],
 {code: 'ERR_ZIP_INVALID_ARCHIVE',message: /possiblezipbomb/});
 });

lib/internal/zip/entry.js

@@ -76,6 +76,7 @@ const {
 const{
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
 }=require('internal/zip/headers');
 const{
@@ -399,6 +400,9 @@ class ZipEntry {
 awaitreadFdFully(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -419,6 +423,9 @@ class ZipEntry {
 readFdFullySync(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -930,6 +937,7 @@ function* readArchiveEntries(buf, end) {
 }
 constlocalOffset=central.localFileHeaderOffset+end.prefix;
 constlocal=newLocalFileHeader(buf,localOffset);
+assertConsistentLocalHeader(local,central);
 constdataStart=localOffset+local.byteLength;
 constlength=central.compressedSize;
 validateArchiveRange(buf,dataStart,length,'entry data');

lib/internal/zip/headers.js

@@ -25,6 +25,8 @@ const {
 SIG_ZIP64_EOCD_LOCATOR,
 SIG_EOCD,
 MADE_BY_UNIX,
+FLAG_ENCRYPTED,
+FLAG_DATA_DESCRIPTOR,
 SENTINEL16,
 SENTINEL32,
 TAIL_LENGTH,
@@ -267,6 +269,7 @@ class CentralFileHeader {
 classLocalFileHeader{
  #buffer;
  #offset;
+ #zip64 =null;
 constructor(buffer,offset=0){
 validateArchiveRange(buffer,offset,30,'local file header');
 if(buffer.readUInt32LE(offset)!==SIG_LOCAL_FILE_HEADER){
@@ -280,9 +283,31 @@ class LocalFileHeader {
 }
 getbyteLength(){return30+this.fileNameLength+this.extraFieldLength;}
 getflags(){returnthis.#buffer.readUInt16LE(this.#offset +6);}
-// Spec field (sec. 4.4.5); the central directory's method is authoritative,
-// so the local copy is not consumed today.
-// get compressionMethod() { return this.#buffer.readUInt16LE(this.#offset + 8); }
+// The central directory is authoritative, but these local fields are read to
+// reject an archive whose local header contradicts it (assertConsistentLocalHeader).
+getcompressionMethod(){returnthis.#buffer.readUInt16LE(this.#offset +8);}
+getcrc32(){returnthis.#buffer.readUInt32LE(this.#offset +14);}
+// The Zip64 extra supplies the true 64-bit sizes for whichever classic size
+// field holds an overflow sentinel; a local header has no offset/disk field.
+ #resolveZip64(){
+if(this.#zip64 ===null){
+this.#zip64 =parseZip64Extra(this.extraField,{
+uncompressedSize: this.#buffer.readUInt32LE(this.#offset +22)===SENTINEL32,
+compressedSize: this.#buffer.readUInt32LE(this.#offset +18)===SENTINEL32,
+localFileHeaderOffset: false,
+diskNumber: false,
+});
+}
+returnthis.#zip64;
+}
+getcompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +18);
+returnvalue===SENTINEL32 ? this.#resolveZip64().compressedSize : value;
+}
+getuncompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +22);
+returnvalue===SENTINEL32 ? this.#resolveZip64().uncompressedSize : value;
+}
 getfileNameLength(){returnthis.#buffer.readUInt16LE(this.#offset +26);}
 getextraFieldLength(){returnthis.#buffer.readUInt16LE(this.#offset +28);}
 getextraField(){
@@ -311,6 +336,35 @@ class LocalFileHeader {
 }
 }
 
+// Reject an archive whose local file header contradicts the central directory
+// on a field that decides which bytes a member yields. This reader treats the
+// central directory as authoritative, but a divergent local header lets a
+// local-header-based extractor (Info-ZIP unzip, and others) read a different
+// member, method, or size from the same archive - a parser-confusion split that
+// defeats inspect-then-consume pipelines. Reject rather than silently diverge.
+functionassertConsistentLocalHeader(local,central){
+if(local.compressionMethod!==central.compressionMethod){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central compression methods disagree');
+}
+if((local.flags&FLAG_ENCRYPTED)!==(central.flags&FLAG_ENCRYPTED)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central encryption flags disagree');
+}
+// A streamed entry (data-descriptor bit) writes zero crc and sizes in the
+// local header, deferring the true values to the central directory; only then
+// is a difference on those three fields expected.
+constdeferred=(local.flags&FLAG_DATA_DESCRIPTOR)!==0&&
+local.crc32===0&&local.compressedSize===0&&local.uncompressedSize===0;
+if(!deferred&&
+(local.crc32!==central.crc32||
+local.compressedSize!==central.compressedSize||
+local.uncompressedSize!==central.uncompressedSize)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central header crc-32 or sizes disagree');
+}
+}
+
 // Returns whether an EOCD-looking record could describe an archive this
 // implementation supports. This is deliberately only a cheap preflight: the
 // selected record still receives the complete Zip64 and central-directory
@@ -563,6 +617,7 @@ function readCentralDirectory(buffer, count) {
 module.exports={
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
  readCentralDirectory,
 };

test/parallel/test-zlib-zip-coverage.js

@@ -288,8 +288,9 @@ test('a Zip64 extra field value beyond Number.MAX_SAFE_INTEGER is rejected', asy
 uncompressedSize: 0xffffffffffffffffn,
 });
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+// The header cross-check resolves the sizes as the archive is read, so a
+// malformed Zip64 value is rejected at read time rather than at .size access.
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /exceedsthesafeintegerrange/,
 });
@@ -325,8 +326,7 @@ test('a Zip64 extra-field TLV whose declared size overflows the extra field is r
 tlv.writeUInt16LE(100,2);// claims 100 bytes of data, but none follow
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /extrafieldismalformed/,
 });
@@ -345,8 +345,7 @@ test('a Zip64 extra-field TLV too short for the field it claims to carry is reje
 tlv.writeUInt32LE(123,4);
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /Zip64extendedinformationextrafieldistruncated/,
 });
@@ -500,7 +499,8 @@ test('contentIterator() enforces the same guards as content() and contentSync()'
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
 }
@@ -593,7 +593,8 @@ test('ZipFile getSync().contentSync() enforces the same guards via decodeMemberS
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 constfilePath=awaitwriteTempArchive(tampered,'size-mismatch');
 constzf=zlib.ZipFile.openSync(filePath);
 assert.throws(()=>zf.getSync('f.txt').contentSync(),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
@@ -607,7 +608,8 @@ test('contentIterator() rejects an entry that inflates to less than its declared
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hi'.length;
-tampered.writeUInt32LE(1000,centralStart+24);// Declared size grown beyond reality
+tampered.writeUInt32LE(1000,22);// Local declared size
+tampered.writeUInt32LE(1000,centralStart+24);// Central declared size grown beyond reality
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{
 code: 'ERR_ZIP_ENTRY_CORRUPT',

test/parallel/test-zlib-zip-hardening.js

@@ -118,13 +118,14 @@ test('a declared-size mismatch is rejected as corrupt', async () => {
 constentry=awaitzlib.ZipEntry.create('f.txt',Buffer.from('hello world'),{method: 'store'});
 constarchive=awaitbuildArchive([entry]);
 
-// Shrink the *declared* uncompressed size in the central directory record
-// without touching the stored bytes themselves, so the amount of data
-// produced no longer matches what the header promised.
+// Shrink the *declared* uncompressed size in both the local and central
+// headers (kept consistent so the header cross-check passes) without touching
+// the stored bytes, so the produced amount no longer matches the headers'
+// promise and the decode-time size check fires.
 consttampered=Buffer.from(archive);
 constcentralHeaderStart=30+'f.txt'.length+'hello world'.length;
-constuncompressedSizeOffset=centralHeaderStart+24;
-tampered.writeUInt32LE(1,uncompressedSizeOffset);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralHeaderStart+24);// Central uncompressed size
 
 const[tamperedEntry]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(tamperedEntry.size,1);
@@ -165,7 +166,10 @@ test('a forged small header whose content inflates past its declared size is rej
 consttampered=Buffer.from(archive);
 consteocd=tampered.length-22;// No comment, so EOCD is the last 22 bytes
 constcdOffset=tampered.readUInt32LE(eocd+16);
-tampered.writeUInt32LE(50,cdOffset+24);// Forge declared uncompressedSize
+// Forge the declared uncompressedSize in both headers (kept consistent so
+// the header cross-check passes; the decompressor still catches the lie).
+tampered.writeUInt32LE(50,22);// Local uncompressedSize
+tampered.writeUInt32LE(50,cdOffset+24);// Central uncompressedSize
 
 const[e]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(e.size,50);// 50 <= maxSize 100 clears the up-front check
@@ -413,9 +417,11 @@ test('a member whose data crosses into the central directory is rejected', async
 constarchive=Buffer.from(awaitbuildArchive(
 [awaitzlib.ZipEntry.create(name,content,{method: 'store'})]));
 constcentralHeaderStart=30+name.length+content.length;
-// Lie about the compressed size so the member's data range reaches into
-// the central directory (while staying inside the buffer).
-archive.writeUInt32LE(content.length+40,centralHeaderStart+20);
+// Lie about the compressed size in both headers (kept consistent so the
+// header cross-check passes) so the member's data range reaches into the
+// central directory (while staying inside the buffer).
+archive.writeUInt32LE(content.length+40,18);// Local compressed size
+archive.writeUInt32LE(content.length+40,centralHeaderStart+20);// Central
 assert.throws(()=>[...zlib.ZipEntry.read(archive)],
 {code: 'ERR_ZIP_INVALID_ARCHIVE',message: /possiblezipbomb/});
 });

lib/internal/zip/entry.js

@@ -76,6 +76,7 @@ const {
 const{
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
 }=require('internal/zip/headers');
 const{
@@ -399,6 +400,9 @@ class ZipEntry {
 awaitreadFdFully(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -419,6 +423,9 @@ class ZipEntry {
 readFdFullySync(fd,full.subarray(30),this.#localOffset +30);
 }
 this.#local =newLocalFileHeader(full,0);
+if(this.#central !==null){
+assertConsistentLocalHeader(this.#local,this.#central);
+}
 this.#contentOffset =this.#localOffset +length;
 returnthis.#local;
 }
@@ -930,6 +937,7 @@ function* readArchiveEntries(buf, end) {
 }
 constlocalOffset=central.localFileHeaderOffset+end.prefix;
 constlocal=newLocalFileHeader(buf,localOffset);
+assertConsistentLocalHeader(local,central);
 constdataStart=localOffset+local.byteLength;
 constlength=central.compressedSize;
 validateArchiveRange(buf,dataStart,length,'entry data');

lib/internal/zip/headers.js

@@ -25,6 +25,8 @@ const {
 SIG_ZIP64_EOCD_LOCATOR,
 SIG_EOCD,
 MADE_BY_UNIX,
+FLAG_ENCRYPTED,
+FLAG_DATA_DESCRIPTOR,
 SENTINEL16,
 SENTINEL32,
 TAIL_LENGTH,
@@ -267,6 +269,7 @@ class CentralFileHeader {
 classLocalFileHeader{
  #buffer;
  #offset;
+ #zip64 =null;
 constructor(buffer,offset=0){
 validateArchiveRange(buffer,offset,30,'local file header');
 if(buffer.readUInt32LE(offset)!==SIG_LOCAL_FILE_HEADER){
@@ -280,9 +283,31 @@ class LocalFileHeader {
 }
 getbyteLength(){return30+this.fileNameLength+this.extraFieldLength;}
 getflags(){returnthis.#buffer.readUInt16LE(this.#offset +6);}
-// Spec field (sec. 4.4.5); the central directory's method is authoritative,
-// so the local copy is not consumed today.
-// get compressionMethod() { return this.#buffer.readUInt16LE(this.#offset + 8); }
+// The central directory is authoritative, but these local fields are read to
+// reject an archive whose local header contradicts it (assertConsistentLocalHeader).
+getcompressionMethod(){returnthis.#buffer.readUInt16LE(this.#offset +8);}
+getcrc32(){returnthis.#buffer.readUInt32LE(this.#offset +14);}
+// The Zip64 extra supplies the true 64-bit sizes for whichever classic size
+// field holds an overflow sentinel; a local header has no offset/disk field.
+ #resolveZip64(){
+if(this.#zip64 ===null){
+this.#zip64 =parseZip64Extra(this.extraField,{
+uncompressedSize: this.#buffer.readUInt32LE(this.#offset +22)===SENTINEL32,
+compressedSize: this.#buffer.readUInt32LE(this.#offset +18)===SENTINEL32,
+localFileHeaderOffset: false,
+diskNumber: false,
+});
+}
+returnthis.#zip64;
+}
+getcompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +18);
+returnvalue===SENTINEL32 ? this.#resolveZip64().compressedSize : value;
+}
+getuncompressedSize(){
+constvalue=this.#buffer.readUInt32LE(this.#offset +22);
+returnvalue===SENTINEL32 ? this.#resolveZip64().uncompressedSize : value;
+}
 getfileNameLength(){returnthis.#buffer.readUInt16LE(this.#offset +26);}
 getextraFieldLength(){returnthis.#buffer.readUInt16LE(this.#offset +28);}
 getextraField(){
@@ -311,6 +336,35 @@ class LocalFileHeader {
 }
 }
 
+// Reject an archive whose local file header contradicts the central directory
+// on a field that decides which bytes a member yields. This reader treats the
+// central directory as authoritative, but a divergent local header lets a
+// local-header-based extractor (Info-ZIP unzip, and others) read a different
+// member, method, or size from the same archive - a parser-confusion split that
+// defeats inspect-then-consume pipelines. Reject rather than silently diverge.
+functionassertConsistentLocalHeader(local,central){
+if(local.compressionMethod!==central.compressionMethod){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central compression methods disagree');
+}
+if((local.flags&FLAG_ENCRYPTED)!==(central.flags&FLAG_ENCRYPTED)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central encryption flags disagree');
+}
+// A streamed entry (data-descriptor bit) writes zero crc and sizes in the
+// local header, deferring the true values to the central directory; only then
+// is a difference on those three fields expected.
+constdeferred=(local.flags&FLAG_DATA_DESCRIPTOR)!==0&&
+local.crc32===0&&local.compressedSize===0&&local.uncompressedSize===0;
+if(!deferred&&
+(local.crc32!==central.crc32||
+local.compressedSize!==central.compressedSize||
+local.uncompressedSize!==central.uncompressedSize)){
+thrownewERR_ZIP_INVALID_ARCHIVE(
+'local and central header crc-32 or sizes disagree');
+}
+}
+
 // Returns whether an EOCD-looking record could describe an archive this
 // implementation supports. This is deliberately only a cheap preflight: the
 // selected record still receives the complete Zip64 and central-directory
@@ -563,6 +617,7 @@ function readCentralDirectory(buffer, count) {
 module.exports={
  CentralFileHeader,
  LocalFileHeader,
+ assertConsistentLocalHeader,
  findArchiveEnd,
  readCentralDirectory,
 };

test/parallel/test-zlib-zip-coverage.js

@@ -288,8 +288,9 @@ test('a Zip64 extra field value beyond Number.MAX_SAFE_INTEGER is rejected', asy
 uncompressedSize: 0xffffffffffffffffn,
 });
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+// The header cross-check resolves the sizes as the archive is read, so a
+// malformed Zip64 value is rejected at read time rather than at .size access.
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /exceedsthesafeintegerrange/,
 });
@@ -325,8 +326,7 @@ test('a Zip64 extra-field TLV whose declared size overflows the extra field is r
 tlv.writeUInt16LE(100,2);// claims 100 bytes of data, but none follow
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /extrafieldismalformed/,
 });
@@ -345,8 +345,7 @@ test('a Zip64 extra-field TLV too short for the field it claims to carry is reje
 tlv.writeUInt32LE(123,4);
 constpatched=injectRawZip64Extra(archive,name,content.length,tlv);
 
-const[read]=zlib.ZipEntry.read(patched);
-assert.throws(()=>read.size,{
+assert.throws(()=>[...zlib.ZipEntry.read(patched)],{
 code: 'ERR_ZIP_INVALID_ARCHIVE',
 message: /Zip64extendedinformationextrafieldistruncated/,
 });
@@ -500,7 +499,8 @@ test('contentIterator() enforces the same guards as content() and contentSync()'
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
 }
@@ -593,7 +593,8 @@ test('ZipFile getSync().contentSync() enforces the same guards via decodeMemberS
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hello world'.length;
-tampered.writeUInt32LE(1,centralStart+24);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralStart+24);// Central uncompressed size
 constfilePath=awaitwriteTempArchive(tampered,'size-mismatch');
 constzf=zlib.ZipFile.openSync(filePath);
 assert.throws(()=>zf.getSync('f.txt').contentSync(),{code: 'ERR_ZIP_ENTRY_CORRUPT'});
@@ -607,7 +608,8 @@ test('contentIterator() rejects an entry that inflates to less than its declared
 constarchive=awaitbuildArchive([entry]);
 consttampered=Buffer.from(archive);
 constcentralStart=30+'f.txt'.length+'hi'.length;
-tampered.writeUInt32LE(1000,centralStart+24);// Declared size grown beyond reality
+tampered.writeUInt32LE(1000,22);// Local declared size
+tampered.writeUInt32LE(1000,centralStart+24);// Central declared size grown beyond reality
 const[read]=zlib.ZipEntry.read(tampered);
 awaitassert.rejects(drain(read.contentIterator()),{
 code: 'ERR_ZIP_ENTRY_CORRUPT',

test/parallel/test-zlib-zip-hardening.js

@@ -118,13 +118,14 @@ test('a declared-size mismatch is rejected as corrupt', async () => {
 constentry=awaitzlib.ZipEntry.create('f.txt',Buffer.from('hello world'),{method: 'store'});
 constarchive=awaitbuildArchive([entry]);
 
-// Shrink the *declared* uncompressed size in the central directory record
-// without touching the stored bytes themselves, so the amount of data
-// produced no longer matches what the header promised.
+// Shrink the *declared* uncompressed size in both the local and central
+// headers (kept consistent so the header cross-check passes) without touching
+// the stored bytes, so the produced amount no longer matches the headers'
+// promise and the decode-time size check fires.
 consttampered=Buffer.from(archive);
 constcentralHeaderStart=30+'f.txt'.length+'hello world'.length;
-constuncompressedSizeOffset=centralHeaderStart+24;
-tampered.writeUInt32LE(1,uncompressedSizeOffset);
+tampered.writeUInt32LE(1,22);// Local uncompressed size
+tampered.writeUInt32LE(1,centralHeaderStart+24);// Central uncompressed size
 
 const[tamperedEntry]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(tamperedEntry.size,1);
@@ -165,7 +166,10 @@ test('a forged small header whose content inflates past its declared size is rej
 consttampered=Buffer.from(archive);
 consteocd=tampered.length-22;// No comment, so EOCD is the last 22 bytes
 constcdOffset=tampered.readUInt32LE(eocd+16);
-tampered.writeUInt32LE(50,cdOffset+24);// Forge declared uncompressedSize
+// Forge the declared uncompressedSize in both headers (kept consistent so
+// the header cross-check passes; the decompressor still catches the lie).
+tampered.writeUInt32LE(50,22);// Local uncompressedSize
+tampered.writeUInt32LE(50,cdOffset+24);// Central uncompressedSize
 
 const[e]=zlib.ZipEntry.read(tampered);
 assert.strictEqual(e.size,50);// 50 <= maxSize 100 clears the up-front check
@@ -413,9 +417,11 @@ test('a member whose data crosses into the central directory is rejected', async
 constarchive=Buffer.from(awaitbuildArchive(
 [awaitzlib.ZipEntry.create(name,content,{method: 'store'})]));
 constcentralHeaderStart=30+name.length+content.length;
-// Lie about the compressed size so the member's data range reaches into
-// the central directory (while staying inside the buffer).
-archive.writeUInt32LE(content.length+40,centralHeaderStart+20);
+// Lie about the compressed size in both headers (kept consistent so the
+// header cross-check passes) so the member's data range reaches into the
+// central directory (while staying inside the buffer).
+archive.writeUInt32LE(content.length+40,18);// Local compressed size
+archive.writeUInt32LE(content.length+40,centralHeaderStart+20);// Central
 assert.throws(()=>[...zlib.ZipEntry.read(archive)],
 {code: 'ERR_ZIP_INVALID_ARCHIVE',message: /possiblezipbomb/});
 });