rex 1.0.2 → 2.0.2

data/lib/rex/zip.rb

@@ -0,0 +1,96 @@
+# -*- coding: binary -*-
+#
+# Zip library
+#
+# Written by Joshua J. Drake <jduck [at] metasploit.com>
+#
+# Based on code contributed by bannedit, and the following SPEC:
+# Reference: http://www.pkware.com/documents/casestudies/APPNOTE.TXT
+#
+
+require 'zlib'
+
+module Rex
+module Zip
+
+ZIP_VERSION = 0x14
+
+# general purpose bit flag values
+#
+# bit 0
+GPBF_ENCRYPTED      = 0x0001
+# bits 1 & 2
+# implode only
+GPBF_IMP_8KDICT     = 0x0002
+GPBF_IMP_3SFT       = 0x0004
+# deflate only
+GPBF_DEF_MAX        = 0x0002
+GPBF_DEF_FAST       = 0x0004
+GPBF_DEF_SUPERFAST  = 0x0006
+# lzma only
+GPBF_LZMA_EOSUSED   = 0x0002
+# bit 3
+GPBF_USE_DATADESC   = 0x0008
+# bit 4
+GPBF_DEF_ENHANCED   = 0x0010
+# bit 5
+GPBF_COMP_PATHCED   = 0x0020
+# bit 6
+GPBF_STRONG_ENC     = 0x0040
+# bit 7-10 unused
+# bit 11
+GPBF_STRS_UTF8      = 0x0800
+# bit 12 (reserved)
+# bit 13
+GPBF_DIR_ENCRYPTED  = 0x2000
+# bit 14,15 (reserved)
+
+
+# compression methods
+CM_STORE            = 0
+CM_SHRINK           = 1
+CM_REDUCE1          = 2
+CM_REDUCE2          = 3
+CM_REDUCE3          = 4
+CM_REDUCE4          = 5
+CM_IMPLODE          = 6
+CM_TOKENIZE         = 7
+CM_DEFLATE          = 8
+CM_DEFLATE64        = 9
+CM_PKWARE_IMPLODE   = 10
+# 11 - reserved
+CM_BZIP2            = 12
+# 13 - reserved
+CM_LZMA_EFS         = 14
+# 15-17 reserved
+CM_IBM_TERSE        = 18
+CM_IBM_LZ77         = 19
+# 20-96 reserved
+CM_WAVPACK          = 97
+CM_PPMD_V1R1        = 98
+
+
+# internal file attributes
+IFA_ASCII           = 0x0001
+# bits 2 & 3 are reserved
+IFA_MAINFRAME_MODE  = 0x0002 # ??
+
+
+# external file attributes
+EFA_ISDIR           = 0x0001
+
+
+# various parts of the structure
+require 'rex/zip/blocks'
+
+# an entry in a zip file
+require 'rex/zip/entry'
+
+# the archive class
+require 'rex/zip/archive'
+
+# a child of Archive, implements Java ARchives for creating java applications
+require 'rex/zip/jar'
+
+end
+end

data/lib/rex/zip/archive.rb

@@ -0,0 +1,130 @@
+# -*- coding: binary -*-
+
+module Rex
+module Zip
+
+#
+# This represents an entire archive.
+#
+class Archive
+
+  # An array of the Entry objects stored in this Archive.
+  attr_reader :entries
+
+
+  def initialize(compmeth=CM_DEFLATE)
+    @compmeth = compmeth
+    @entries = []
+  end
+
+  #
+  # Recursively adds a directory of files into the archive.
+  #
+  def add_r(dir)
+    path = File.dirname(dir)
+    Dir[File.join(dir, "**", "**")].each do |file|
+      relative = file.sub(/^#{path.chomp('/')}\//, '')
+      if File.directory?(file)
+        @entries << Entry.new(relative.chomp('/') + '/', '', @compmeth, nil, EFA_ISDIR, nil, nil)
+      else
+        contents = File.read(file, :mode => 'rb')
+        @entries << Entry.new(relative, contents, @compmeth, nil, nil, nil, nil)
+      end
+    end
+  end
+
+  #
+  # Create a new Entry and add it to the archive.
+  #
+  # If fdata is set, the file is populated with that data
+  # from the calling method. If fdata is nil, then the
+  # fs is checked for the file. If central_dir_name is set
+  # it will be used to spoof the name at the Central Directory
+  # at packing time.
+  #
+  def add_file(fname, fdata=nil, xtra=nil, comment=nil, central_dir_name=nil)
+    if (not fdata)
+      begin
+        st = File.stat(fname)
+      rescue
+        return nil
+      end
+
+      ts = st.mtime
+      if (st.directory?)
+        attrs = EFA_ISDIR
+        fdata = ''
+        unless fname[-1,1] == '/'
+          fname += '/'
+        end
+      else
+        f = File.open(fname, 'rb')
+        fdata = f.read(f.stat.size)
+        f.close
+      end
+    end
+
+    @entries << Entry.new(fname, fdata, @compmeth, ts, attrs, xtra, comment, central_dir_name)
+  end
+
+
+  def set_comment(comment)
+    @comment = comment
+  end
+
+
+  #
+  # Write the compressed file to +fname+.
+  #
+  def save_to(fname)
+    f = File.open(fname, 'wb')
+    f.write(pack)
+    f.close
+  end
+
+
+  #
+  # Compress this archive and return the resulting zip file as a String.
+  #
+  def pack
+    ret = ''
+
+    # save the offests
+    offsets = []
+
+    # file 1 .. file n
+    @entries.each { |ent|
+      offsets << ret.length
+      ret << ent.pack
+    }
+
+    # archive decryption header (unsupported)
+    # archive extra data record (unsupported)
+
+    # central directory
+    cfd_offset = ret.length
+    idx = 0
+    @entries.each { |ent|
+      cfd = CentralDir.new(ent, offsets[idx])
+      ret << cfd.pack
+      idx += 1
+    }
+
+    # zip64 end of central dir record (unsupported)
+    # zip64 end of central dir locator (unsupported)
+
+    # end of central directory record
+    cur_offset = ret.length - cfd_offset
+    ret << CentralDirEnd.new(@entries.length, cur_offset, cfd_offset, @comment).pack
+
+    ret
+  end
+
+  def inspect
+    "#<#{self.class} entries = [#{@entries.map{|e| e.name}.join(",")}]>"
+  end
+
+end
+
+end
+end

data/lib/rex/zip/blocks.rb

@@ -0,0 +1,184 @@
+# -*- coding: binary -*-
+
+module Rex
+module Zip
+
+
+#
+# This structure holds the following data pertaining to a Zip entry's data.
+#
+# data crc
+# compressed size
+# uncompressed size
+#
+class CompInfo
+
+  def initialize(crc, compsz, uncompsz)
+    @crc, @compsz, @uncompsz = crc, compsz, uncompsz
+  end
+
+  def pack
+    [ @crc, @compsz, @uncompsz ].pack('VVV')
+  end
+
+end
+
+
+#
+# This structure holds the following data pertaining to a Zip entry.
+#
+# general purpose bit flag
+# compression method
+# modification time
+# modification date
+#
+class CompFlags
+
+  attr_accessor :compmeth
+
+  def initialize(gpbf, compmeth, timestamp)
+    @gpbf = gpbf
+    @compmeth = compmeth
+    @mod_time = ((timestamp.hour << 11) | (timestamp.min << 5) | (timestamp.sec))
+    @mod_date = (((timestamp.year - 1980) << 9) | (timestamp.mon << 5) | (timestamp.day))
+  end
+
+  def pack
+    [ @gpbf, @compmeth, @mod_time, @mod_date ].pack('vvvv')
+  end
+
+end
+
+
+
+#
+# This structure is sometimes stored after the file data and used
+# instead of the fields within the Local File Header.
+#
+class DataDesc
+
+  SIGNATURE = 0x8074b50
+
+  def initialize(compinfo)
+    @compinfo = compinfo
+  end
+
+  def pack
+    ret = [ SIGNATURE ].pack('V')
+    ret << @compinfo.pack
+    ret
+  end
+
+end
+
+
+#
+# This structure records the compression data and flags about
+# a Zip entry to a file.
+#
+class LocalFileHdr
+
+  SIGNATURE = 0x4034b50
+
+  def initialize(entry)
+    @entry = entry
+  end
+
+  def pack
+    path = @entry.relative_path
+
+    ret = [ SIGNATURE, ZIP_VERSION ].pack('Vv')
+    ret << @entry.flags.pack
+    ret << @entry.info.pack
+    ret << [ path.length, @entry.xtra.length ].pack('vv')
+    ret << path
+    ret << @entry.xtra
+    ret
+  end
+
+end
+
+
+#
+# This structure holds all of the information about a particular Zip Entry
+# as it is contained within the central directory.
+#
+class CentralDir
+
+  SIGNATURE = 0x2014b50
+
+  def initialize(entry, offset)
+    @entry = entry
+    @disknum_start = 0
+    @attr_int = 0
+    @attr_ext = 0x20
+    @hdr_offset = offset
+  end
+
+  def pack
+    if @entry.central_dir_name.blank?
+      path = @entry.relative_path
+    else
+      path = @entry.central_dir_path
+    end
+
+    ret = [ SIGNATURE, ZIP_VERSION ].pack('Vv')
+    ret << [ ZIP_VERSION ].pack('v')
+    ret << @entry.flags.pack
+    ret << @entry.info.pack
+    arr = []
+    arr << path.length
+    arr << @entry.xtra.length
+    arr << @entry.comment.length
+    arr << @disknum_start
+    arr << @attr_int
+    arr << @entry.attrs
+    arr << @hdr_offset
+    ret << arr.pack('vvvvvVV')
+    ret << path
+    ret << @entry.xtra
+    ret << @entry.comment
+    # digital signature not supported
+    ret
+  end
+
+end
+
+
+#
+# This structure is written after the per-entry central directory records to
+# provide information about the archive as a whole.
+#
+class CentralDirEnd
+
+  SIGNATURE = 0x6054b50
+
+  def initialize(ncfd, cfdsz, offset, comment=nil)
+    @disk_no = 0
+    @disk_dir_start = 0
+    @ncfd_this_disk = ncfd
+    @ncfd_total = ncfd
+    @cfd_size = cfdsz
+    @start_offset = offset
+    @comment = comment
+    @comment ||= ''
+  end
+
+
+  def pack
+    arr = []
+    arr << SIGNATURE
+    arr << @disk_no
+    arr << @disk_dir_start
+    arr << @ncfd_this_disk
+    arr << @ncfd_total
+    arr << @cfd_size
+    arr << @start_offset
+    arr << @comment.length
+    (arr.pack('VvvvvVVv') + @comment)
+  end
+
+end
+
+end
+end

data/lib/rex/zip/entry.rb

@@ -0,0 +1,122 @@
+# -*- coding: binary -*-
+
+module Rex
+module Zip
+
+#
+# An Entry represents a logical file or directory to be stored in an Archive
+#
+class Entry
+
+  attr_accessor :name, :flags, :info, :xtra, :comment, :attrs, :central_dir_name
+  attr_reader :data
+
+  def initialize(fname, data, compmeth, timestamp=nil, attrs=nil, xtra=nil, comment=nil, central_dir_name=nil)
+    @name = fname.unpack("C*").pack("C*")
+    @central_dir_name = (central_dir_name ? central_dir_name.unpack("C*").pack("C*") : nil)
+    @data = data.unpack("C*").pack("C*")
+    @xtra = xtra
+    @xtra ||= ''
+    @comment = comment
+    @comment ||= ''
+    @attrs = attrs
+    @attrs ||= 0
+
+    # XXX: sanitize timestmap (assume now)
+    timestamp ||= Time.now
+    @flags = CompFlags.new(0, compmeth, timestamp)
+
+    if (@data)
+      compress
+    else
+      @data = ''
+      @info = CompInfo.new(0, 0, 0)
+    end
+    @compdata ||= ''
+  end
+
+  def data=(val)
+    @data = val.unpack("C*").pack("C*")
+    compress
+  end
+
+  #
+  # Compress the #data and store it for later use.  If this entry's compression method
+  # produces a larger blob than the original data, the method is changed to CM_STORE.
+  #
+  def compress
+    @crc = Zlib.crc32(@data, 0)
+    case @flags.compmeth
+
+    when CM_STORE
+      @compdata = @data
+
+    when CM_DEFLATE
+      z = Zlib::Deflate.new(Zlib::BEST_COMPRESSION)
+      @compdata = z.deflate(@data, Zlib::FINISH)
+      z.close
+      @compdata = @compdata[2, @compdata.length-6]
+
+    else
+      raise 'Unsupported compression method: %u' % @flags.compmeth
+    end
+
+    # if compressing doesn't help, just store it
+    if (@compdata.length > @data.length)
+      @compdata = @data
+      @flags.compmeth = CM_STORE
+    end
+
+    @info = CompInfo.new(@crc, @compdata.length, @data.length)
+  end
+
+
+  def relative_path
+    get_relative_path(@name)
+  end
+
+  def central_dir_path
+    return nil if @central_dir_name.blank?
+    get_relative_path(@central_dir_name)
+  end
+
+
+  #
+  # Return the compressed data in a format suitable for adding to an Archive
+  #
+  def pack
+    #  - lfh 1
+    lfh = LocalFileHdr.new(self)
+    ret = lfh.pack
+
+    #  - data 1
+    if (@compdata)
+      ret << @compdata
+    end
+
+    if (@gpbf & GPBF_USE_DATADESC)
+      #  - data desc 1
+      dd = DataDesc.new(@info)
+      ret << dd.pack
+    end
+
+    ret
+  end
+
+  def inspect
+    "#<#{self.class} name:#{name}, data:#{@data.length} bytes>"
+  end
+
+  private
+
+  def get_relative_path(path)
+    if (path[0,1] == '/')
+      return path[1, path.length]
+    end
+    path
+  end
+
+end
+
+end
+end