omnizip 0.3.1

data/lib/omnizip/checksum_registry.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+module Omnizip
+  # Registry for managing available checksum algorithms.
+  #
+  # This class maintains a central registry of all checksum implementations
+  # available in Omnizip, providing a consistent interface for algorithm
+  # discovery and instantiation.
+  #
+  # The registry pattern ensures that checksum algorithms are defined in
+  # one place and can be easily extended with new implementations without
+  # modifying existing code.
+  #
+  # @example Register a new checksum algorithm
+  #   ChecksumRegistry.register(:crc32, Omnizip::Checksums::Crc32)
+  #
+  # @example Get a checksum class
+  #   crc_class = ChecksumRegistry.get(:crc32)
+  #   checksum = crc_class.calculate("data")
+  #
+  # @example List available checksums
+  #   ChecksumRegistry.available
+  #   # => [:crc32, :crc64]
+  class ChecksumRegistry
+    @checksums = {}
+
+    class << self
+      # Register a checksum algorithm.
+      #
+      # Adds a new checksum implementation to the registry, making it
+      # available for use throughout the application.
+      #
+      # @param name [Symbol] unique identifier for the checksum
+      # @param checksum_class [Class] class implementing the checksum
+      # @return [void]
+      # @raise [ArgumentError] if name is already registered
+      def register(name, checksum_class)
+        name = name.to_sym
+        if @checksums.key?(name)
+          raise ArgumentError,
+                "Checksum '#{name}' is already registered"
+        end
+
+        @checksums[name] = checksum_class
+      end
+
+      # Retrieve a checksum class by name.
+      #
+      # Returns the checksum class registered under the given name,
+      # allowing for instantiation and use.
+      #
+      # @param name [Symbol] identifier of the checksum to retrieve
+      # @return [Class] the checksum class
+      # @raise [UnknownAlgorithmError] if checksum not found
+      def get(name)
+        name = name.to_sym
+        checksum_class = @checksums[name]
+
+        unless checksum_class
+          raise UnknownAlgorithmError,
+                "Unknown checksum: '#{name}'. Available: " \
+                "#{available.join(', ')}"
+        end
+
+        checksum_class
+      end
+
+      # List all available checksum algorithms.
+      #
+      # Returns an array of registered checksum names, useful for
+      # displaying options to users or validating input.
+      #
+      # @return [Array<Symbol>] array of registered checksum names
+      def available
+        @checksums.keys.sort
+      end
+
+      # Check if a checksum is registered.
+      #
+      # @param name [Symbol] identifier of the checksum to check
+      # @return [Boolean] true if registered, false otherwise
+      def registered?(name)
+        @checksums.key?(name.to_sym)
+      end
+
+      # Clear all registered checksums.
+      #
+      # This method is primarily for testing purposes and should not
+      # be used in production code.
+      #
+      # @return [void]
+      # @api private
+      def clear
+        @checksums.clear
+      end
+    end
+  end
+end

data/lib/omnizip/checksums/crc32.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+require_relative "crc_base"
+
+module Omnizip
+  module Checksums
+    # CRC32 checksum implementation using IEEE 802.3 polynomial.
+    #
+    # This implementation uses the standard CRC32 polynomial (0xEDB88320)
+    # as used in 7-Zip, ZIP archives, PNG files, and Ethernet frames.
+    #
+    # The algorithm uses a 256-entry pre-computed lookup table for
+    # efficient O(1) per-byte processing, making it suitable for
+    # high-performance checksum calculation.
+    #
+    # Polynomial: 0xEDB88320 (reversed IEEE 802.3)
+    # Initial value: 0xFFFFFFFF
+    # Final XOR: 0xFFFFFFFF
+    # Bit width: 32
+    #
+    # @example One-shot calculation
+    #   checksum = Omnizip::Checksums::Crc32.calculate("abc")
+    #   # => 0x352441C2
+    #
+    # @example Incremental calculation
+    #   crc = Omnizip::Checksums::Crc32.new
+    #   crc.update("Hello, ")
+    #   crc.update("world!")
+    #   result = crc.finalize
+    class Crc32 < CrcBase
+      # IEEE 802.3 polynomial (reversed representation)
+      # This is the standard polynomial used in 7-Zip and ZIP files
+      POLYNOMIAL = 0xEDB88320
+
+      # 32-bit mask for truncating values
+      MASK_32 = 0xFFFFFFFF
+
+      # Pre-computed lookup table for CRC32 calculation
+      # Generated using the IEEE 802.3 polynomial
+      # This table is computed once at class load time for performance
+      TABLE = generate_table(POLYNOMIAL, 32).freeze
+
+      # Process a single byte through the CRC32 algorithm.
+      #
+      # Uses the lookup table for efficient computation:
+      # new_crc = (old_crc >> 8) ^ table[(old_crc ^ byte) & 0xFF]
+      #
+      # @param crc [Integer] current CRC value
+      # @param byte [Integer] byte to process (0-255)
+      # @return [Integer] updated CRC value
+      def process_byte(crc, byte)
+        index = (crc ^ byte) & 0xFF
+        (crc >> 8) ^ TABLE[index]
+      end
+
+      # Get the initial CRC32 value.
+      #
+      # CRC32 starts with all bits set to 1, which helps detect
+      # leading zeros in the data stream.
+      #
+      # @return [Integer] 0xFFFFFFFF
+      def initial_value
+        MASK_32
+      end
+
+      # Get the final XOR value for CRC32.
+      #
+      # The final result is XORed with all 1s to invert the bits,
+      # which is part of the CRC32 standard.
+      #
+      # @return [Integer] 0xFFFFFFFF
+      def final_xor
+        MASK_32
+      end
+
+      # Get the lookup table for CRC32.
+      #
+      # @return [Array<Integer>] 256-entry lookup table
+      def self.lookup_table
+        TABLE
+      end
+    end
+  end
+end

data/lib/omnizip/checksums/crc64.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+require_relative "crc_base"
+
+module Omnizip
+  module Checksums
+    # CRC64 checksum implementation using ECMA-182 polynomial.
+    #
+    # This implementation uses the ECMA-182 polynomial for CRC64 calculation
+    # as used in the XZ file format and 7-Zip archives. This is the standard
+    # 64-bit CRC polynomial for data integrity verification in compressed
+    # archives.
+    #
+    # The algorithm uses a 256-entry pre-computed lookup table with 64-bit
+    # values for efficient O(1) per-byte processing.
+    #
+    # Polynomial: 0xC96C5795D7870F42 (ECMA-182)
+    # Initial value: 0xFFFFFFFFFFFFFFFF
+    # Final XOR: 0xFFFFFFFFFFFFFFFF
+    # Bit width: 64
+    #
+    # @example One-shot calculation
+    #   checksum = Omnizip::Checksums::Crc64.calculate("123456789")
+    #   # => 0x995DC9BBDF1939FA
+    #
+    # @example Incremental calculation
+    #   crc = Omnizip::Checksums::Crc64.new
+    #   crc.update("Hello, ")
+    #   crc.update("world!")
+    #   result = crc.finalize
+    class Crc64 < CrcBase
+      # ECMA-182 polynomial (reversed representation)
+      # This is the standard polynomial used in XZ format
+      POLYNOMIAL = 0xC96C5795D7870F42
+
+      # 64-bit mask for truncating values
+      MASK_64 = 0xFFFFFFFFFFFFFFFF
+
+      # Pre-computed lookup table for CRC64 calculation
+      # Generated using the ECMA-182 polynomial
+      # This table is computed once at class load time for performance
+      TABLE = generate_table(POLYNOMIAL, 64).freeze
+
+      # Process a single byte through the CRC64 algorithm.
+      #
+      # Uses the lookup table for efficient computation:
+      # new_crc = (old_crc >> 8) ^ table[(old_crc ^ byte) & 0xFF]
+      #
+      # @param crc [Integer] current CRC value
+      # @param byte [Integer] byte to process (0-255)
+      # @return [Integer] updated CRC value
+      def process_byte(crc, byte)
+        index = (crc ^ byte) & 0xFF
+        (crc >> 8) ^ TABLE[index]
+      end
+
+      # Get the initial CRC64 value.
+      #
+      # CRC64 starts with all bits set to 1, which helps detect
+      # leading zeros in the data stream.
+      #
+      # @return [Integer] 0xFFFFFFFFFFFFFFFF
+      def initial_value
+        MASK_64
+      end
+
+      # Get the final XOR value for CRC64.
+      #
+      # The final result is XORed with all 1s to invert the bits,
+      # which is part of the CRC64 standard.
+      #
+      # @return [Integer] 0xFFFFFFFFFFFFFFFF
+      def final_xor
+        MASK_64
+      end
+
+      # Get the lookup table for CRC64.
+      #
+      # @return [Array<Integer>] 256-entry lookup table
+      def self.lookup_table
+        TABLE
+      end
+    end
+  end
+end

data/lib/omnizip/checksums/crc_base.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+module Omnizip
+  module Checksums
+    # Abstract base class for CRC (Cyclic Redundancy Check) algorithms.
+    #
+    # This class provides the common framework for implementing CRC
+    # checksums using lookup tables for efficient computation. Subclasses
+    # must define their specific polynomial and bit width.
+    #
+    # The lookup table approach provides O(1) per-byte processing time,
+    # making it significantly faster than bit-by-bit calculation.
+    #
+    # Architecture:
+    # - Pre-computed lookup tables stored as class constants
+    # - Incremental computation support via update method
+    # - Initial and final XOR values for standard CRC variants
+    #
+    # @abstract Subclass and override polynomial-specific methods
+    class CrcBase
+      # @return [Integer] current CRC value
+      attr_reader :value
+
+      # Initialize a new CRC calculator with default initial value.
+      #
+      # The initial value is typically all 1s (inverted 0) to detect
+      # leading zeros in the input data.
+      def initialize
+        @value = initial_value
+      end
+
+      # Update the CRC value with new data.
+      #
+      # This method processes the input data byte-by-byte using the
+      # lookup table, allowing incremental CRC calculation.
+      #
+      # @param data [String] binary string to process
+      # @return [self] for method chaining
+      def update(data)
+        data.each_byte do |byte|
+          @value = process_byte(@value, byte)
+        end
+        self
+      end
+
+      # Reset the CRC calculator to initial state.
+      #
+      # @return [self] for method chaining
+      def reset
+        @value = initial_value
+        self
+      end
+
+      # Get the finalized CRC value.
+      #
+      # Applies the final XOR operation required by most CRC standards
+      # to produce the final checksum value.
+      #
+      # @return [Integer] final CRC checksum
+      def finalize
+        @value ^ final_xor
+      end
+
+      # Calculate CRC for data in one operation.
+      #
+      # This is a convenience method that combines initialize, update,
+      # and finalize into a single call.
+      #
+      # @param data [String] binary string to checksum
+      # @return [Integer] final CRC checksum
+      def self.calculate(data)
+        new.update(data).finalize
+      end
+
+      protected
+
+      # Process a single byte through the CRC algorithm.
+      #
+      # This method must be implemented by subclasses to perform the
+      # actual CRC calculation using the lookup table.
+      #
+      # @param crc [Integer] current CRC value
+      # @param byte [Integer] byte to process (0-255)
+      # @return [Integer] updated CRC value
+      # @abstract
+      def process_byte(crc, byte)
+        raise NotImplementedError,
+              "#{self.class} must implement #process_byte"
+      end
+
+      # Get the initial CRC value.
+      #
+      # @return [Integer] initial value (typically all 1s)
+      # @abstract
+      def initial_value
+        raise NotImplementedError,
+              "#{self.class} must implement #initial_value"
+      end
+
+      # Get the final XOR value.
+      #
+      # @return [Integer] value to XOR with final result
+      # @abstract
+      def final_xor
+        raise NotImplementedError,
+              "#{self.class} must implement #final_xor"
+      end
+
+      # Get the lookup table for this CRC variant.
+      #
+      # @return [Array<Integer>] 256-entry lookup table
+      # @abstract
+      def self.lookup_table
+        raise NotImplementedError,
+              "#{self} must implement .lookup_table"
+      end
+
+      # Generate a CRC lookup table for given polynomial.
+      #
+      # This method pre-computes all possible CRC values for single-byte
+      # inputs, enabling efficient O(1) per-byte processing.
+      #
+      # @param polynomial [Integer] CRC polynomial
+      # @param bits [Integer] bit width (32 or 64)
+      # @return [Array<Integer>] 256-entry lookup table
+      def self.generate_table(polynomial, bits)
+        mask = (1 << bits) - 1
+        (0..255).map do |i|
+          crc = i
+          8.times do
+            if crc.anybits?(1)
+              crc = (crc >> 1) ^ polynomial
+            else
+              crc >>= 1
+            end
+          end
+          crc & mask
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/checksums/verifier.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require "zlib"
+require "digest"
+require_relative "crc64"
+
+module Omnizip
+  module Checksums
+    # Checksum verification utilities for XZ format
+    #
+    # XZ supports multiple check types:
+    # - 0: None (no checksum)
+    # - 1: CRC32 (4 bytes)
+    # - 4: CRC64 (8 bytes)
+    # - 10: SHA256 (32 bytes)
+    class Verifier
+      # Check type constants (from XZ spec)
+      CHECK_NONE = 0
+      CHECK_CRC32 = 1
+      CHECK_CRC64 = 4
+      CHECK_SHA256 = 10
+
+      # Check sizes in bytes
+      CHECK_SIZES = {
+        CHECK_NONE => 0,
+        CHECK_CRC32 => 4,
+        CHECK_CRC64 => 8,
+        CHECK_SHA256 => 32,
+      }.freeze
+
+      # Verify CRC32 checksum
+      #
+      # @param data [String] Data to verify
+      # @param expected [Integer] Expected CRC32 value
+      # @return [Boolean] True if checksum matches
+      def self.verify_crc32(data, expected)
+        Zlib.crc32(data) == expected
+      end
+
+      # Verify CRC64 checksum
+      #
+      # @param data [String] Data to verify
+      # @param expected [Integer] Expected CRC64 value
+      # @return [Boolean] True if checksum matches
+      def self.verify_crc64(data, expected)
+        Crc64.calculate(data) == expected
+      end
+
+      # Verify SHA256 checksum
+      #
+      # @param data [String] Data to verify
+      # @param expected [String] Expected SHA256 digest (binary, 32 bytes)
+      # @return [Boolean] True if checksum matches
+      def self.verify_sha256(data, expected)
+        Digest::SHA256.digest(data) == expected
+      end
+
+      # Generic verify based on check type
+      #
+      # @param data [String] Data to verify
+      # @param expected [String] Expected checksum (binary format)
+      # @param check_type [Integer] Check type (0=None, 1=CRC32, 4=CRC64, 10=SHA256)
+      # @return [Boolean] True if checksum matches or check type is None
+      # @raise [ArgumentError] If check type is unknown
+      def self.verify(data, expected, check_type)
+        case check_type
+        when CHECK_NONE
+          true # No checksum to verify
+        when CHECK_CRC32
+          expected_crc = expected.unpack1("V")
+          verify_crc32(data, expected_crc)
+        when CHECK_CRC64
+          expected_crc = expected.unpack1("Q<")
+          verify_crc64(data, expected_crc)
+        when CHECK_SHA256
+          verify_sha256(data, expected)
+        else
+          raise "Unknown check type: #{check_type}"
+        end
+      end
+
+      # Get check size in bytes
+      #
+      # @param check_type [Integer] Check type
+      # @return [Integer] Size of checksum in bytes
+      def self.check_size(check_type)
+        CHECK_SIZES.fetch(check_type, 0)
+      end
+
+      # Calculate checksum for data based on check type
+      #
+      # @param data [String] Data to checksum
+      # @param check_type [Integer] Check type
+      # @return [String] Checksum in binary format
+      def self.calculate(data, check_type)
+        case check_type
+        when CHECK_NONE
+          ""
+        when CHECK_CRC32
+          [Zlib.crc32(data)].pack("V")
+        when CHECK_CRC64
+          [Crc64.calculate(data)].pack("Q<")
+        when CHECK_SHA256
+          Digest::SHA256.digest(data)
+        else
+          raise "Unknown check type: #{check_type}"
+        end
+      end
+    end
+  end
+end