archive-zip 0.3.0 → 0.4.0

data/lib/archive/zip/codec/null_encryption.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require 'archive/support/io-like'
 require 'archive/zip/codec'
 
@@ -36,6 +38,10 @@ module Archive; class Zip; module Codec
       # assumption that _io_ is already buffered.
       def initialize(io)
         @io = io
+
+        # Keep track of the total number of bytes written.
+        @total_bytes_in = 0
+
         # Assume that the delegate IO object is already buffered.
         self.flush_size = 0
       end
@@ -50,9 +56,34 @@ module Archive; class Zip; module Codec
 
       private
 
+      # Allows resetting this object and the delegate object back to the
+      # beginning of the stream or reporting the current position in the stream.
+      #
+      # Raises Errno::EINVAL unless _offset_ is <tt>0</tt> and _whence_ is
+      # either IO::SEEK_SET or IO::SEEK_CUR.  Raises Errno::EINVAL if _whence_
+      # is IO::SEEK_SEK and the delegate object does not respond to the _rewind_
+      # method.
+      def unbuffered_seek(offset, whence = IO::SEEK_SET)
+        unless offset == 0 &&
+               ((whence == IO::SEEK_SET && @io.respond_to?(:rewind)) ||
+                whence == IO::SEEK_CUR) then
+          raise Errno::EINVAL
+        end
+
+        case whence
+        when IO::SEEK_SET
+          @io.rewind
+          @total_bytes_in = 0
+        when IO::SEEK_CUR
+          @total_bytes_in
+        end
+      end
+
       # Writes _string_ to the delegate IO object and returns the result.
       def unbuffered_write(string)
-        @io.write(string)
+        bytes_written = @io.write(string)
+        @total_bytes_in += bytes_written
+        bytes_written
       end
     end
 
@@ -80,21 +111,41 @@ module Archive; class Zip; module Codec
       end
 
       # Creates a new instance of this class using _io_ as a data source.  _io_
-      # must be readable and provide a read method as IO does or errors will be
-      # raised when performing read operations.  If _io_ provides a rewind
-      # method, this class' rewind method will be enabled.
+      # must be readable and provide a _read_ method as an IO instance would or
+      # errors will be raised when performing read operations.
+      #
+      # This class has extremely limited seek capabilities.  It is possible to
+      # seek with an offset of <tt>0</tt> and a whence of <tt>IO::SEEK_CUR</tt>.
+      # As a result, the _pos_ and _tell_ methods also work as expected.
+      #
+      # Due to certain optimizations within IO::Like#seek and if there is data
+      # in the read buffer, the _seek_ method can be used to seek forward from
+      # the current stream position up to the end of the buffer.  Unless it is
+      # known definitively how much data is in the buffer, it is best to avoid
+      # relying on this behavior.
+      #
+      # If _io_ also responds to _rewind_, then the _rewind_ method of this
+      # class can be used to reset the whole stream back to the beginning. Using
+      # _seek_ of this class to seek directly to offset <tt>0</tt> using
+      # <tt>IO::SEEK_SET</tt> for whence will also work in this case.
+      #
+      # Any other seeking attempts, will raise Errno::EINVAL exceptions.
       #
       # The _fill_size_ attribute is set to <tt>0</tt> by default under the
       # assumption that _io_ is already buffered.
       def initialize(io)
         @io = io
+
+        # Keep track of the total number of bytes read.
+        @total_bytes_out = 0
+
         # Assume that the delegate IO object is already buffered.
         self.fill_size = 0
       end
 
       # Closes this object so that further write operations will fail.  If
-      # _close_delegate_ is +true+, the delegate object used as a data sink will
-      # also be closed using its close method.
+      # _close_delegate_ is +true+, the delegate object used as a data source
+      # will also be closed using its close method.
       def close(close_delegate = true)
         super()
         @io.close if close_delegate
@@ -108,22 +159,32 @@ module Archive; class Zip; module Codec
       def unbuffered_read(length)
         buffer = @io.read(length)
         raise EOFError, 'end of file reached' if buffer.nil?
+        @total_bytes_out += buffer.length
 
         buffer
       end
 
       # Allows resetting this object and the delegate object back to the
-      # beginning of the stream.  _offset_ must be <tt>0</tt> and _whence_ must
-      # be IO::SEEK_SET or an error will be raised.  The delegate object must
-      # respond to the _rewind_ method or an error will be raised.
+      # beginning of the stream or reporting the current position in the stream.
+      #
+      # Raises Errno::EINVAL unless _offset_ is <tt>0</tt> and _whence_ is
+      # either IO::SEEK_SET or IO::SEEK_CUR.  Raises Errno::EINVAL if _whence_
+      # is IO::SEEK_SEK and the delegate object does not respond to the _rewind_
+      # method.
       def unbuffered_seek(offset, whence = IO::SEEK_SET)
-        unless offset == 0 && whence == IO::SEEK_SET then
-          raise Errno::EINVAL, 'Invalid argument'
+        unless offset == 0 &&
+               ((whence == IO::SEEK_SET && @io.respond_to?(:rewind)) ||
+                whence == IO::SEEK_CUR) then
+          raise Errno::EINVAL
         end
-        unless @io.respond_to?(:rewind) then
-          raise Errno::ESPIPE, 'Illegal seek'
+
+        case whence
+        when IO::SEEK_SET
+          @io.rewind
+          @total_bytes_out = 0
+        when IO::SEEK_CUR
+          @total_bytes_out
         end
-        @io.rewind
       end
     end
 

data/lib/archive/zip/codec/store.rb

@@ -1,4 +1,7 @@
+# encoding: UTF-8
+
 require 'archive/support/io-like'
+require 'archive/support/zlib'
 require 'archive/zip/codec'
 require 'archive/zip/data_descriptor'
 
@@ -58,12 +61,12 @@ module Archive; class Zip; module Codec
         nil
       end
 
-      # Returns an instance of Archive::Zip::Entry::DataDescriptor with
-      # information regarding the data which has passed through this object to
-      # the delegate object.  The close or flush methods should be called before
-      # using this method in order to ensure that any possibly buffered data is
-      # flushed to the delegate object; otherwise, the contents of the data
-      # descriptor may be inaccurate.
+      # Returns an instance of Archive::Zip::DataDescriptor with information
+      # regarding the data which has passed through this object to the delegate
+      # object.  The close or flush methods should be called before using this
+      # method in order to ensure that any possibly buffered data is flushed to
+      # the delegate object; otherwise, the contents of the data descriptor may
+      # be inaccurate.
       def data_descriptor
         DataDescriptor.new(
           @crc32,
@@ -74,6 +77,30 @@ module Archive; class Zip; module Codec
 
       private
 
+      # Allows resetting this object and the delegate object back to the
+      # beginning of the stream or reporting the current position in the stream.
+      #
+      # Raises Errno::EINVAL unless _offset_ is <tt>0</tt> and _whence_ is
+      # either IO::SEEK_SET or IO::SEEK_CUR.  Raises Errno::EINVAL if _whence_
+      # is IO::SEEK_SEK and the delegate object does not respond to the _rewind_
+      # method.
+      def unbuffered_seek(offset, whence = IO::SEEK_SET)
+        unless offset == 0 &&
+               ((whence == IO::SEEK_SET && @io.respond_to?(:rewind)) ||
+                whence == IO::SEEK_CUR) then
+          raise Errno::EINVAL
+        end
+
+        case whence
+        when IO::SEEK_SET
+          @io.rewind
+          @crc32 = 0
+          @uncompressed_size = 0
+        when IO::SEEK_CUR
+          @uncompressed_size
+        end
+      end
+
       # Writes _string_ to the delegate object and returns the number of bytes
       # actually written.  Updates the uncompressed_size and crc32 attributes as
       # a side effect.
@@ -115,9 +142,25 @@ module Archive; class Zip; module Codec
       end
 
       # Creates a new instance of this class using _io_ as a data source.  _io_
-      # must be readable and provide a read method as IO does or errors will be
-      # raised when performing read operations.  If _io_ provides a rewind
-      # method, this class' rewind method will be enabled.
+      # must be readable and provide a _read_ method as an IO instance would or
+      # errors will be raised when performing read operations.
+      #
+      # This class has extremely limited seek capabilities.  It is possible to
+      # seek with an offset of <tt>0</tt> and a whence of <tt>IO::SEEK_CUR</tt>.
+      # As a result, the _pos_ and _tell_ methods also work as expected.
+      #
+      # Due to certain optimizations within IO::Like#seek and if there is data
+      # in the read buffer, the _seek_ method can be used to seek forward from
+      # the current stream position up to the end of the buffer.  Unless it is
+      # known definitively how much data is in the buffer, it is best to avoid
+      # relying on this behavior.
+      #
+      # If _io_ also responds to _rewind_, then the _rewind_ method of this
+      # class can be used to reset the whole stream back to the beginning. Using
+      # _seek_ of this class to seek directly to offset <tt>0</tt> using
+      # <tt>IO::SEEK_SET</tt> for whence will also work in this case.
+      #
+      # Any other seeking attempts, will raise Errno::EINVAL exceptions.
       #
       # The _fill_size_ attribute is set to <tt>0</tt> by default under the
       # assumption that _io_ is already buffered.
@@ -138,11 +181,11 @@ module Archive; class Zip; module Codec
         nil
       end
 
-      # Returns an instance of Archive::Zip::Entry::DataDescriptor with
-      # information regarding the data which has passed through this object
-      # from the delegate object.  It is recommended to call the close method
-      # before calling this in order to ensure that no further read operations
-      # change the state of this object.
+      # Returns an instance of Archive::Zip::DataDescriptor with information
+      # regarding the data which has passed through this object from the
+      # delegate object.  It is recommended to call the close method before
+      # calling this in order to ensure that no further read operations change
+      # the state of this object.
       def data_descriptor
         DataDescriptor.new(
           @crc32,
@@ -165,21 +208,27 @@ module Archive; class Zip; module Codec
       end
 
       # Allows resetting this object and the delegate object back to the
-      # beginning of the stream.  _offset_ must be <tt>0</tt> and _whence_ must
-      # be IO::SEEK_SET or an error will be raised.  The delegate object must
-      # respond to the _rewind_ method or an error will be raised.  The
-      # uncompressed_size and crc32 attributes are reinitialized as a side
-      # effect.
+      # beginning of the stream or reporting the current position in the stream.
+      #
+      # Raises Errno::EINVAL unless _offset_ is <tt>0</tt> and _whence_ is
+      # either IO::SEEK_SET or IO::SEEK_CUR.  Raises Errno::EINVAL if _whence_
+      # is IO::SEEK_SEK and the delegate object does not respond to the _rewind_
+      # method.
       def unbuffered_seek(offset, whence = IO::SEEK_SET)
-        unless offset == 0 && whence == IO::SEEK_SET then
-          raise Errno::EINVAL, 'Invalid argument'
+        unless offset == 0 &&
+               ((whence == IO::SEEK_SET && @io.respond_to?(:rewind)) ||
+                whence == IO::SEEK_CUR) then
+          raise Errno::EINVAL
         end
-        unless @io.respond_to?(:rewind) then
-          raise Errno::ESPIPE, 'Illegal seek'
+
+        case whence
+        when IO::SEEK_SET
+          @io.rewind
+          @crc32 = 0
+          @uncompressed_size = 0
+        when IO::SEEK_CUR
+          @uncompressed_size
         end
-        @io.rewind
-        @crc32 = 0
-        @uncompressed_size = 0
       end
     end
 

data/lib/archive/zip/codec/traditional_encryption.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+
+require 'archive/support/integer'
 require 'archive/support/io-like'
 require 'archive/support/time'
 require 'archive/support/zlib'
@@ -108,18 +111,40 @@ module Archive; class Zip; module Codec
       # The _flush_size_ attribute is set to <tt>0</tt> by default under the
       # assumption that _io_ is already buffered.
       def initialize(io, password, mtime)
+        # Keep track of the total number of bytes written.
+        # Set this here so that the call to #initialize_keys caused by the call
+        # to super below does not cause errors in #unbuffered_write due to this
+        # attribute being uninitialized.
+        @total_bytes_in = 0
+
+        # This buffer is used to hold the encrypted version of the string most
+        # recently sent to #unbuffered_write.
+        @encrypt_buffer = ''
+
         super(io, password, mtime)
 
         # Assume that the delegate IO object is already buffered.
         self.flush_size = 0
       end
 
-      # Closes this object so that further write operations will fail.  If
-      # _close_delegate_ is +true+, the delegate object used as a data sink will
-      # also be closed using its close method.
+      # Closes the stream after flushing the encryption buffer to the delegate.
+      # If _close_delegate_ is +true+, the delegate object used as a data sink
+      # will also be closed using its close method.
+      #
+      # Raises IOError if called more than once.
       def close(close_delegate = true)
+        flush()
+        begin
+          until @encrypt_buffer.empty? do
+            @encrypt_buffer.slice!(0, io.write(@encrypt_buffer))
+          end
+        rescue Errno::EAGAIN, Errno::EINTR
+          retry if write_ready?
+        end
+
         super()
         io.close if close_delegate
+        nil
       end
 
       private
@@ -131,31 +156,74 @@ module Archive; class Zip; module Codec
         super
 
         # Create and encrypt a 12 byte header to protect the encrypted file data
-        # from attack.  The first 10 bytes are random, and the lat 2 bytes are
+        # from attack.  The first 10 bytes are random, and the last 2 bytes are
         # the low order word of the last modified time of the entry in DOS
         # format.
+        header = ''
         10.times do
-          unbuffered_write(rand(256).chr)
+          header << rand(256).chr
         end
         time = mtime.to_dos_time.to_i
-        unbuffered_write((time & 0xff).chr)
-        unbuffered_write(((time >> 8) & 0xff).chr)
+        header << (time & 0xff).chr << ((time >> 8) & 0xff).chr
+
+        # Take care to ensure that all bytes in the header are written.
+        while header.size > 0 do
+          begin
+            header.slice!(0, unbuffered_write(header))
+          rescue Errno::EAGAIN, Errno::EINTR
+            sleep(1)
+          end
+        end
+
+        # Reset the total bytes written in order to disregard the header.
+        @total_bytes_in = 0
+
         nil
       end
 
+      # Allows resetting this object and the delegate object back to the
+      # beginning of the stream or reporting the current position in the stream.
+      #
+      # Raises Errno::EINVAL unless _offset_ is <tt>0</tt> and _whence_ is
+      # either IO::SEEK_SET or IO::SEEK_CUR.  Raises Errno::EINVAL if _whence_
+      # is IO::SEEK_SEK and the delegate object does not respond to the _rewind_
+      # method.
+      def unbuffered_seek(offset, whence = IO::SEEK_SET)
+        unless offset == 0 &&
+               ((whence == IO::SEEK_SET && @io.respond_to?(:rewind)) ||
+                whence == IO::SEEK_CUR) then
+          raise Errno::EINVAL
+        end
+
+        case whence
+        when IO::SEEK_SET
+          io.rewind
+          @encrypt_buffer = ''
+          initialize_keys
+          @total_bytes_in = 0
+        when IO::SEEK_CUR
+          @total_bytes_in
+        end
+      end
+
       # Encrypts and writes _string_ to the delegate IO object.  Returns the
-      # number of bytes of _string_ written.  If _string_ is not a String, it is
-      # converted into one using its _to_s_ method.
+      # number of bytes of _string_ written.
       def unbuffered_write(string)
-        string = string.to_s
-        bytes_written = 0
+        # First try to write out the contents of the encrypt buffer because if
+        # that raises a failure we can let that pass up the call stack without
+        # having polluted the encryption state.
+        until @encrypt_buffer.empty? do
+          @encrypt_buffer.slice!(0, io.write(@encrypt_buffer))
+        end
+        # At this point we can encrypt the given string into a new buffer and
+        # behave as if it was written.
         string.each_byte do |byte|
           temp = decrypt_byte
-          break unless io.write((byte ^ temp).chr) > 0
-          bytes_written += 1
+          @encrypt_buffer << (byte ^ temp).chr
           update_keys(byte.chr)
         end
-        bytes_written
+        @total_bytes_in += string.length
+        string.length
       end
     end
 
@@ -187,15 +255,37 @@ module Archive; class Zip; module Codec
       end
 
       # Creates a new instance of this class using _io_ as a data source.  _io_
-      # must be readable and provide a read method as IO does or errors will be
-      # raised when performing read operations.  If _io_ provides a rewind
-      # method, this class' rewind method will be enabled.  _password_ should be
-      # the encryption key.  _mtime_ must be the last modified time of the entry
-      # to be encrypted/decrypted.
+      # must be readable and provide a _read_ method as an IO instance would or
+      # errors will be raised when performing read operations.  _password_
+      # should be the encryption key.  _mtime_ must be the last modified time of
+      # the entry to be encrypted/decrypted.
+      #
+      # This class has extremely limited seek capabilities.  It is possible to
+      # seek with an offset of <tt>0</tt> and a whence of <tt>IO::SEEK_CUR</tt>.
+      # As a result, the _pos_ and _tell_ methods also work as expected.
+      #
+      # Due to certain optimizations within IO::Like#seek and if there is data
+      # in the read buffer, the _seek_ method can be used to seek forward from
+      # the current stream position up to the end of the buffer.  Unless it is
+      # known definitively how much data is in the buffer, it is best to avoid
+      # relying on this behavior.
+      #
+      # If _io_ also responds to _rewind_, then the _rewind_ method of this
+      # class can be used to reset the whole stream back to the beginning. Using
+      # _seek_ of this class to seek directly to offset <tt>0</tt> using
+      # <tt>IO::SEEK_SET</tt> for whence will also work in this case.
+      #
+      # Any other seeking attempts, will raise Errno::EINVAL exceptions.
       #
       # The _fill_size_ attribute is set to <tt>0</tt> by default under the
       # assumption that _io_ is already buffered.
       def initialize(io, password, mtime)
+        # Keep track of the total number of bytes read.
+        # Set this here so that the call to #initialize_keys caused by the call
+        # to super below does not cause errors in #unbuffered_read due to this
+        # attribute being uninitialized.
+        @total_bytes_out = 0
+
         super(io, password, mtime)
 
         # Assume that the delegate IO object is already buffered.
@@ -203,8 +293,8 @@ module Archive; class Zip; module Codec
       end
 
       # Closes this object so that further write operations will fail.  If
-      # _close_delegate_ is +true+, the delegate object used as a data sink will
-      # also be closed using its close method.
+      # _close_delegate_ is +true+, the delegate object used as a data source
+      # will also be closed using its close method.
       def close(close_delegate = true)
         super()
         io.close if close_delegate
@@ -218,8 +308,20 @@ module Archive; class Zip; module Codec
       def initialize_keys
         super
 
-        # Decrypt the 12 byte header.
-        unbuffered_read(12)
+        # Load the 12 byte header taking care to ensure that all bytes are read.
+        bytes_needed = 12
+        while bytes_needed > 0 do
+          begin
+            bytes_read = unbuffered_read(bytes_needed)
+            bytes_needed -= bytes_read.size
+          rescue Errno::EAGAIN, Errno::EINTR
+            sleep(1)
+          end
+        end
+
+        # Reset the total bytes read in order to disregard the header.
+        @total_bytes_out = 0
+
         nil
       end
 
@@ -230,28 +332,37 @@ module Archive; class Zip; module Codec
       def unbuffered_read(length)
         buffer = io.read(length)
         raise EOFError, 'end of file reached' if buffer.nil?
+        @total_bytes_out += buffer.length
 
-        (0 ... buffer.size).each do |i|
-          buffer[i] = (buffer[i] ^ decrypt_byte)
+        0.upto(buffer.length - 1) do |i|
+          buffer[i] = (buffer[i].ord ^ decrypt_byte).chr
           update_keys(buffer[i].chr)
         end
         buffer
       end
 
       # Allows resetting this object and the delegate object back to the
-      # beginning of the stream.  _offset_ must be <tt>0</tt> and _whence_ must
-      # be IO::SEEK_SET or an error will be raised.  The delegate object must
-      # respond to the _rewind_ method or an error will be raised.
+      # beginning of the stream or reporting the current position in the stream.
+      #
+      # Raises Errno::EINVAL unless _offset_ is <tt>0</tt> and _whence_ is
+      # either IO::SEEK_SET or IO::SEEK_CUR.  Raises Errno::EINVAL if _whence_
+      # is IO::SEEK_SEK and the delegate object does not respond to the _rewind_
+      # method.
       def unbuffered_seek(offset, whence = IO::SEEK_SET)
-        unless offset == 0 && whence == IO::SEEK_SET then
-          raise Errno::EINVAL, 'Invalid argument'
+        unless offset == 0 &&
+               ((whence == IO::SEEK_SET && @io.respond_to?(:rewind)) ||
+                whence == IO::SEEK_CUR) then
+          raise Errno::EINVAL
         end
-        unless io.respond_to?(:rewind) then
-          raise Errno::ESPIPE, 'Illegal seek'
+
+        case whence
+        when IO::SEEK_SET
+          io.rewind
+          initialize_keys
+          @total_bytes_out = 0
+        when IO::SEEK_CUR
+          @total_bytes_out
         end
-        io.rewind
-        initialize_keys
-        0
       end
     end