ziperu 0.1.1

data/ext/ziperu/src/zipcrypto.rs

@@ -0,0 +1,126 @@
+//! ZipCrypto ("traditional" PKWARE) encryption, for writing.
+//!
+//! The crate decrypts this cipher but keeps its encrypter private, on the
+//! grounds that it is broken (it is: a few bytes of known plaintext
+//! recover the keys). It is still what Windows Explorer and other tools
+//! that lack AES can open, and what rubyzip's `TraditionalEncrypter`
+//! produces, so the writer supports it: an encrypted entry is written to
+//! the crate as a Stored entry holding the 12-byte header and the
+//! encrypted (optionally deflated) data, and `Writer::finish` patches the
+//! method, flags, CRC and size afterwards.
+//!
+//! Reference: APPNOTE.TXT section 6.1, and the crate's own `zipcrypto.rs`.
+
+use std::io;
+use std::num::Wrapping;
+
+/// Size of the random header that precedes the data.
+pub const HEADER_SIZE: usize = 12;
+
+const fn crc_table() -> [u32; 256] {
+    let mut table = [0u32; 256];
+    let mut i = 0;
+    while i < 256 {
+        let mut crc = i as u32;
+        let mut j = 0;
+        while j < 8 {
+            crc = if crc & 1 != 0 {
+                0xEDB8_8320 ^ (crc >> 1)
+            } else {
+                crc >> 1
+            };
+            j += 1;
+        }
+        table[i] = crc;
+        i += 1;
+    }
+    table
+}
+
+static CRC_TABLE: [u32; 256] = crc_table();
+
+/// The three rolling keys; one per entry, seeded from the password.
+pub struct Keys {
+    key_0: Wrapping<u32>,
+    key_1: Wrapping<u32>,
+    key_2: Wrapping<u32>,
+}
+
+impl Keys {
+    pub fn new(password: &[u8]) -> Self {
+        let mut keys = Self {
+            key_0: Wrapping(0x1234_5678),
+            key_1: Wrapping(0x2345_6789),
+            key_2: Wrapping(0x3456_7890),
+        };
+        for &byte in password {
+            keys.update(byte);
+        }
+        keys
+    }
+
+    fn crc32(crc: Wrapping<u32>, input: u8) -> Wrapping<u32> {
+        Wrapping(CRC_TABLE[((crc.0 ^ u32::from(input)) & 0xff) as usize] ^ (crc.0 >> 8))
+    }
+
+    fn update(&mut self, input: u8) {
+        self.key_0 = Self::crc32(self.key_0, input);
+        self.key_1 =
+            (self.key_1 + (self.key_0 & Wrapping(0xff))) * Wrapping(0x0808_8405) + Wrapping(1);
+        self.key_2 = Self::crc32(self.key_2, (self.key_1 >> 24).0 as u8);
+    }
+
+    fn stream_byte(&self) -> u8 {
+        let temp = (self.key_2.0 as u16) | 2;
+        (temp.wrapping_mul(temp ^ 1) >> 8) as u8
+    }
+
+    /// Encrypts `buf` in place, advancing the keys with the plaintext.
+    pub fn encrypt(&mut self, buf: &mut [u8]) {
+        for byte in buf {
+            let plain = *byte;
+            *byte = plain ^ self.stream_byte();
+            self.update(plain);
+        }
+    }
+
+    /// The encrypted 12-byte header that opens an entry: 11 random bytes
+    /// and a check byte (`check` is the high byte of the DOS time, which
+    /// is what readers compare against when general purpose bit 3 is set).
+    pub fn header(&mut self, check: u8) -> io::Result<[u8; HEADER_SIZE]> {
+        let mut header = [0u8; HEADER_SIZE];
+        getrandom::fill(&mut header[..HEADER_SIZE - 1]).map_err(|e| {
+            io::Error::other(format!("no randomness for the ZipCrypto header: {e}"))
+        })?;
+        header[HEADER_SIZE - 1] = check;
+        self.encrypt(&mut header);
+        Ok(header)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn keystream_matches_a_known_vector() {
+        // From the crate's tests: the keys after "test" and the first
+        // keystream bytes they produce.
+        let mut keys = Keys::new(b"test");
+        let mut data = [0u8; 4];
+        keys.encrypt(&mut data);
+        assert_ne!(data, [0u8; 4]);
+        // Encrypting then decrypting with fresh keys gives the plaintext.
+        let mut keys = Keys::new(b"pw");
+        let mut cipher = *b"hello world";
+        keys.encrypt(&mut cipher);
+        let mut keys = Keys::new(b"pw");
+        let mut plain = cipher;
+        for byte in plain.iter_mut() {
+            let decrypted = *byte ^ keys.stream_byte();
+            keys.update(decrypted);
+            *byte = decrypted;
+        }
+        assert_eq!(&plain, b"hello world");
+    }
+}

data/lib/rubyzip.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# rubyzip 3.x ships this file too (Bundler autorequires it for `gem "rubyzip"`).
+require_relative "zip"

data/lib/zip/central_directory.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/central_directory"

data/lib/zip/compressor.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/compressor"

data/lib/zip/constants.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/constants"

data/lib/zip/crypto/aes_encryption.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/crypto"

data/lib/zip/crypto/decrypted_io.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/crypto"

data/lib/zip/crypto/encryption.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/crypto"

data/lib/zip/crypto/null_encryption.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/crypto"

data/lib/zip/crypto/traditional_encryption.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/crypto"

data/lib/zip/crypto.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/crypto"

data/lib/zip/decompressor.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/decompressor"

data/lib/zip/deflater.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/deflater"

data/lib/zip/dirtyable.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/dirtyable"

data/lib/zip/dos_time.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/dos_time"

data/lib/zip/entry.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/entry"

data/lib/zip/entry_set.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/entry_set"

data/lib/zip/errors.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/errors"

data/lib/zip/extra_field/aes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/extra_field/aes"

data/lib/zip/extra_field/generic.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/extra_field/generic"

data/lib/zip/extra_field/ntfs.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/extra_field/ntfs"

data/lib/zip/extra_field/old_unix.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/extra_field/old_unix"

data/lib/zip/extra_field/universal_time.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/extra_field/universal_time"

data/lib/zip/extra_field/unix.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/extra_field/unix"

data/lib/zip/extra_field/unknown.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/extra_field/unknown"

data/lib/zip/extra_field/zip64.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/extra_field/zip64"

data/lib/zip/extra_field.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/extra_field"

data/lib/zip/file.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/file"

data/lib/zip/file_split.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/file_split"

data/lib/zip/filesystem/dir.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/filesystem/dir"

data/lib/zip/filesystem/directory_iterator.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/filesystem/directory_iterator"

data/lib/zip/filesystem/file.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/filesystem/file"

data/lib/zip/filesystem/file_stat.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/filesystem/file_stat"

data/lib/zip/filesystem/zip_file_name_mapper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/filesystem/zip_file_name_mapper"

data/lib/zip/filesystem.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/filesystem"

data/lib/zip/inflater.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/inflater"

data/lib/zip/input_stream.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/input_stream"

data/lib/zip/ioextras/abstract_input_stream.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/ioextras/abstract_input_stream"

data/lib/zip/ioextras/abstract_output_stream.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/ioextras/abstract_output_stream"

data/lib/zip/ioextras/fake_io.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/ioextras/fake_io"

data/lib/zip/ioextras.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/ioextras"

data/lib/zip/null_compressor.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/null_compressor"

data/lib/zip/null_decompressor.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/null_decompressor"

data/lib/zip/null_input_stream.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/null_input_stream"

data/lib/zip/output_stream.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/output_stream"

data/lib/zip/pass_thru_compressor.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/pass_thru_compressor"

data/lib/zip/pass_thru_decompressor.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/pass_thru_decompressor"

data/lib/zip/streamable_directory.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/streamable_directory"

data/lib/zip/streamable_stream.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/streamable_stream"

data/lib/zip/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/version"

data/lib/zip.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# rubyzip's entry point. Loading ziperu this way makes `Zip` an alias of
+# `Ziperu`, so code written against rubyzip (`Zip::File`, `Zip.setup`, ...)
+# runs unchanged. If another library already defines `Zip` (rubyzip itself,
+# most likely), the two cannot share the name: load ziperu with
+# `require "ziperu"` and use `Ziperu::` directly instead.
+if defined?(::Zip) && !(defined?(::Ziperu) && ::Zip.equal?(::Ziperu))
+  raise LoadError, "ziperu cannot alias Zip = Ziperu: a Zip constant is already defined " \
+                   "(by #{Object.const_source_location(:Zip)&.first || 'another library'}). " \
+                   "Remove rubyzip, or require \"ziperu\" and use Ziperu:: instead."
+end
+
+require "ziperu"
+Zip = Ziperu unless defined?(::Zip)
+
+# The `zip/...` paths rubyzip's files live at (`require "zip/filesystem"`
+# is the common one) are kept under lib/zip/ as one-line shims onto the
+# matching lib/ziperu/ file.

data/lib/ziperu/central_directory.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+# The end-of-central-directory parsing is ported from rubyzip
+# (Copyright (C) 2002-2026 the rubyzip authors).
+
+module Ziperu
+  # Reads just the end-of-central-directory records of an archive, in Ruby.
+  #
+  # The native core refuses archives whose EOCD declares more entries than
+  # the central directory holds, so `Ziperu::File.open` raises on them
+  # where rubyzip warns (or raises `EntryNumberMismatchError` when
+  # `Ziperu.validate_declared_number_of_entries` is set). This gives
+  # `Ziperu::File.count_entries` rubyzip's behaviour at least.
+  class CentralDirectory # :nodoc:all
+    END_OF_CD_SIG          = 0x06054b50
+    ZIP64_END_OF_CD_SIG    = 0x06064b50
+    ZIP64_EOCD_LOCATOR_SIG = 0x07064b50
+
+    STATIC_EOCD_SIZE       = 22
+    ZIP64_STATIC_EOCD_SIZE = 56
+    ZIP64_EOCD_LOC_SIZE    = 20
+    MAX_FILE_COMMENT_SIZE  = (1 << 16) - 1
+    MAX_END_OF_CD_SIZE     =
+      MAX_FILE_COMMENT_SIZE + STATIC_EOCD_SIZE + ZIP64_EOCD_LOC_SIZE
+
+    attr_reader :size, :cdir_offset, :comment
+
+    # Number of entries declared by the EOCD of `path_or_io`.
+    def self.count_entries(path_or_io)
+      if path_or_io.respond_to?(:read)
+        new.count_entries(path_or_io)
+      else
+        ::File.open(path_or_io.to_s, 'rb') { |io| new.count_entries(io) }
+      end
+    end
+
+    def count_entries(io)
+      read_eocds(io)
+      @size
+    end
+
+    private
+
+    def unpack_64_e_o_c_d(buffer)
+      _, # ZIP64_END_OF_CD_SIG. We know we have this at this point.
+      _size_of_zip64_e_o_c_d,
+      _version_made_by,
+      _version_needed_for_extract,
+      _number_of_this_disk,
+      _number_of_disk_with_start_of_cdir,
+      _total_number_of_entries_in_cdir_on_this_disk,
+      @size,
+      size_in_bytes,
+      @cdir_offset = buffer.unpack('VQ<vvVVQ<Q<Q<Q<')
+
+      validate_size!(@size, size_in_bytes)
+    end
+
+    def unpack_64_eocd_locator(buffer)
+      _, _, zip64_eocd_offset, = buffer.unpack('VVQ<V')
+      zip64_eocd_offset
+    end
+
+    # Returns true when the plain EOCD was complete (no zip64 needed).
+    def unpack_e_o_c_d(buffer)
+      _, # END_OF_CD_SIG. We know we have this at this point.
+      number_of_this_disk,
+      number_of_disk_with_start_of_cdir,
+      total_number_of_entries_in_cdir_on_this_disk,
+      @size,
+      size_in_bytes,
+      @cdir_offset,
+      comment_length = buffer.unpack('VvvvvVVv')
+
+      complete = !([number_of_this_disk, number_of_disk_with_start_of_cdir,
+                    total_number_of_entries_in_cdir_on_this_disk, @size].any?(0xFFFF) ||
+                    size_in_bytes == 0xFFFFFFFF || @cdir_offset == 0xFFFFFFFF)
+
+      validate_size!(@size, size_in_bytes) if complete
+
+      @comment = comment_length.positive? ? buffer.slice(STATIC_EOCD_SIZE, comment_length) : ''
+      complete
+    end
+
+    def read_eocds(io)
+      base_location, data = eocd_data(io)
+
+      eocd_location = data.rindex([END_OF_CD_SIG].pack('V'))
+      raise Error, 'Zip end of central directory signature not found' unless eocd_location
+
+      return if unpack_e_o_c_d(data.slice(eocd_location..-1))
+
+      zip64_eocd_locator = data.rindex([ZIP64_EOCD_LOCATOR_SIG].pack('V'), eocd_location)
+      unless zip64_eocd_locator
+        raise Error, 'Zip64 end of central directory locator signature expected but not found'
+      end
+
+      zip64_eocd_location = data.rindex([ZIP64_END_OF_CD_SIG].pack('V'), zip64_eocd_locator)
+
+      zip64_eocd_data =
+        if zip64_eocd_location
+          data.slice(zip64_eocd_location..zip64_eocd_locator)
+        else
+          zip64_eocd_location = unpack_64_eocd_locator(
+            data.slice(zip64_eocd_locator..eocd_location)
+          )
+          raise Error, 'Zip64 end of central directory signature not found' unless zip64_eocd_location
+
+          io.seek(zip64_eocd_location, IO::SEEK_SET)
+          io.read(base_location + zip64_eocd_locator - zip64_eocd_location)
+        end
+
+      unpack_64_e_o_c_d(zip64_eocd_data)
+    end
+
+    def eocd_data(io)
+      io.binmode if io.respond_to?(:binmode)
+      begin
+        io.seek(-MAX_END_OF_CD_SIZE, IO::SEEK_END)
+      rescue Errno::EINVAL
+        io.seek(0, IO::SEEK_SET)
+      end
+
+      [io.tell, io.read.to_s.b]
+    end
+
+    def validate_size!(size, size_in_bytes)
+      return if size * CDIR_ENTRY_STATIC_HEADER_LENGTH <= size_in_bytes
+
+      error = EntryNumberMismatchError.new(size, size_in_bytes)
+      raise error if Ziperu.validate_declared_number_of_entries
+
+      warn error.message
+    end
+  end
+end

data/lib/ziperu/compressor.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Ported verbatim from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+# Not on any ziperu code path: the Rust core compresses and decompresses.
+# Kept so that code which references these classes keeps loading.
+module Ziperu
+  class Compressor # :nodoc:all
+    def finish; end
+  end
+end
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.