zsteg 0.0.0

data/lib/zsteg/checker/wbstego.rb

@@ -0,0 +1,98 @@
+module ZSteg
+  class Checker
+    module WBStego
+
+      class Result < IOStruct.new "a3a3a*", :size, :ext, :data, :even
+        def initialize *args
+          super
+          if self.size.is_a?(String)
+            self.size = (self.size[0,3] + "\x00").unpack('V')[0]
+          end
+          self.even = false if self.even.nil?
+        end
+
+        def to_s
+          inspect.sub("#<struct #{self.class.to_s}", "<wbStego").red
+        end
+      end
+
+      class << self
+        def used_colors
+          raise "TODO"
+        end
+
+        # from wbStego4open sources
+        def calc_avail_size image
+         space = 0
+         biHeader = image.hdr
+         if biHeader.biCompression == 0
+           case biHeader.biBitCount
+           when 4
+             space = 2*image.imagedata_size if used_colors < 9
+           when 8
+             space = image.imagedata_size if used_colors < 129
+           when 24
+             space = image.imagedata_size
+           end
+         else
+           raise "TODO"
+#           if biHeader.biBitCount=4 then begin
+#             if UsedColors<9 then space:=GetAvailSizeRLE else space:=0;
+#           end;
+#           if biHeader.biBitCount=8 then begin
+#             if UsedColors<129 then space:=GetAvailSizeRLE else space:=0;
+#           end;
+         end
+         space/8
+        end
+
+        def check data, params = {}
+          return if data.size < 4
+          return if params[:bit_order] != :lsb
+          if params[:image].format == :bmp
+            return if params[:order] !~ /b/i
+          end
+
+          size1 = (data[0,3] + "\x00").unpack('V')[0]
+          avail_size =
+            if params[:image].format == :bmp
+              calc_avail_size(params[:image])
+            else
+              params[:max_hidden_size]
+            end
+          return if size1 == 0 || size1 > avail_size
+          size2 = (data[3,3] + "\x00").unpack('V')[0]
+#          p [size1, size2, avail_size]
+          if size2 < avail_size
+            spacing = 1.0*avail_size/(size2+5) - 1
+#            puts "[d] spacing=#{spacing}"
+            if spacing > 0
+              error = 0
+              r = ''
+              6.upto(data.size-1) do |idx|
+                if error < 1
+                  r << data[idx]
+                  error += spacing
+                else
+                  error -= 1
+                end
+              end
+#              puts "[d] r=#{r.inspect} (#{r.size})"
+              ext = r[0,3]
+              return unless valid_ext?(ext)
+              return Result.new(size2, ext, r[3..-1], true)
+            end
+          end
+          # no even distribution
+          return unless valid_ext?(data[3,3])
+          return Result.read(data)
+        end
+
+        # XXX require that file extension be 7-bit ASCII
+        def valid_ext? ext
+          ext =~ /\A[\x20-\x7e]+\Z/
+        end
+      end
+    end
+  end
+end

data/lib/zsteg/cli.rb

@@ -0,0 +1,132 @@
+require 'optparse'
+require 'awesome_print'
+
+module ZSteg
+  class CLI
+    DEFAULT_ACTIONS = %w'check'
+    DEFAULT_LIMIT   = 256
+    DEFAULT_ORDER   = 'auto'
+
+    def initialize argv = ARGV
+      @argv = argv
+    end
+
+    def run
+      @actions = []
+      @options = {
+        :verbose => 0,
+        :limit => DEFAULT_LIMIT,
+        :bits  => [1,2,3,4],
+        :order => DEFAULT_ORDER
+      }
+      optparser = OptionParser.new do |opts|
+        opts.banner = "Usage: zsteg [options] filename.png"
+        opts.separator ""
+
+        opts.on("-c", "--channels X", /[rgba,]+/,
+                "channels (R/G/B/A) or any combination, comma separated",
+                "valid values: r,g,b,a,rg,rgb,bgr,rgba,..."
+        ){ |x| @options[:channels] = x.split(',') }
+
+        opts.on("-l", "--limit N", Integer,
+                "limit bytes checked, 0 = no limit (default: #{DEFAULT_LIMIT})"
+        ){ |n| @options[:limit] = n }
+
+        opts.on("-b", "--bits N", /[\d,-]+/,
+                "number of bits (1..8), single value or '1,3,5' or '1-8'") do |n|
+          if n['-']
+            @options[:bits] = Range.new(*n.split('-').map(&:to_i)).to_a
+          else
+            @options[:bits] = n.split(',').map(&:to_i)
+          end
+        end
+
+        opts.on "--lsb", "least significant BIT comes first" do
+          @options[:bit_order] = :lsb
+        end
+        opts.on "--msb", "most significant BIT comes first" do
+          @options[:bit_order] = :msb
+        end
+
+        opts.on("-o", "--order X", /all|auto|[bxy,]+/i,
+                "pixel iteration order (default: '#{DEFAULT_ORDER}')",
+                "valid values: ALL,xy,yx,XY,YX,xY,Xy,bY,...",
+        ){ |x| @options[:order] = x.split(',') }
+
+        opts.on "-E", "--extract NAME", "extract specified payload, NAME is like '1b,rgb,lsb'" do |x|
+          @actions << [:extract, x]
+        end
+
+        opts.separator ""
+        opts.on "-v", "--verbose", "Run verbosely (can be used multiple times)" do |v|
+          @options[:verbose] += 1
+        end
+        opts.on "-q", "--quiet", "Silent any warnings (can be used multiple times)" do |v|
+          @options[:verbose] -= 1
+        end
+      end
+
+      if (argv = optparser.parse(@argv)).empty?
+        puts optparser.help
+        return
+      end
+
+      @actions = DEFAULT_ACTIONS if @actions.empty?
+
+      argv.each_with_index do |fname,idx|
+        if argv.size > 1 && @options[:verbose] >= 0
+          puts if idx > 0
+          puts "[.] #{fname}".green
+        end
+        @fname = fname
+
+        @actions.each do |action|
+          if action.is_a?(Array)
+            self.send(*action) if self.respond_to?(action.first)
+          else
+            self.send(action) if self.respond_to?(action)
+          end
+        end
+      end
+    rescue Errno::EPIPE
+      # output interrupt, f.ex. when piping output to a 'head' command
+      # prevents a 'Broken pipe - <STDOUT> (Errno::EPIPE)' message
+    end
+
+    ###########################################################################
+    # actions
+
+    def check
+      Checker.new(@fname, @options).check
+    end
+
+    def extract name
+      if ['extradata', 'data after IEND'].include?(name)
+        img = ZPNG::Image.load(@fname)
+        print img.extradata
+        return
+      end
+
+      h = {}
+      name.split(',').each do |x|
+        case x
+        when 'lsb'
+          h[:bit_order] = :lsb
+        when 'msb'
+          h[:bit_order] = :msb
+        when /(\d)b/
+          h[:bits] = $1.to_i
+        when /\A[rgba]+\Z/
+          h[:channels] = x.split('')
+        when /\Axy|yx\Z/i
+          h[:order] = x
+        else
+          raise "uknown param #{x.inspect}"
+        end
+      end
+      h[:limit] = @options[:limit] if @options[:limit] != DEFAULT_LIMIT
+      print Extractor.new(@fname, @options).extract(h)
+    end
+
+  end
+end

data/lib/zsteg/extractor.rb

@@ -0,0 +1,21 @@
+module ZSteg
+  class Extractor
+
+    include ByteExtractor
+    include ColorExtractor
+
+    # image can be either filename or ZPNG::Image
+    def initialize image, params = {}
+      @image = image.is_a?(ZPNG::Image) ? image : ZPNG::Image.load(image)
+      @verbose = params[:verbose]
+    end
+
+    def extract params = {}
+      if params[:order] =~ /b/i
+        byte_extract params
+      else
+        color_extract params
+      end
+    end
+  end
+end

data/lib/zsteg/extractor/byte_extractor.rb

@@ -0,0 +1,94 @@
+module ZSteg
+  class Extractor
+    # ByteExtractor extracts bits from each scanline bytes
+    # actual for BMP+wbStego combination
+    module ByteExtractor
+
+      def byte_extract params = {}
+        limit = params[:limit].to_i
+        limit = 2**32 if limit <= 0
+
+        bits = params[:bits]
+        raise "invalid bits value #{bits.inspect}" unless (1..8).include?(bits)
+        mask = 2**bits - 1
+
+
+        data = ''.force_encoding('binary')
+        a = []
+        byte_iterator(params[:order]) do |x,y|
+          sl = @image.scanlines[y]
+
+          value = sl.decoded_bytes[x].ord
+          bits.times do |bidx|
+            a << ((value & (1<<(bits-bidx-1))) == 0 ? 0 : 1)
+          end
+
+          if a.size >= 8
+            byte = 0
+            if params[:bit_order] == :msb
+              8.times{ |i| byte |= (a.shift<<i)}
+            else
+              8.times{ |i| byte |= (a.shift<<(7-i))}
+            end
+            #printf "[d] %02x %08b\n", byte, byte
+            data << byte.chr
+            if data.size >= limit
+              print "[limit #{params[:limit]}]".gray if @verbose > 1
+              break
+            end
+          end
+        end
+        if params[:strip_tail_zeroes] != false && data[-1,1] == "\x00"
+          oldsz = data.size
+          data.sub!(/\x00+\Z/,'')
+          print "[zerotail #{oldsz-data.size}]".gray if @verbose > 1
+        end
+        data
+      end
+
+      # 'xy': b=0,y=0; b=1,y=0; b=2,y=0; ...
+      # 'yx': b=0,y=0; b=0,y=1; b=0,y=2; ...
+      # ...
+      # 'xY': b=0,  y=MAX; b=1,    y=MAX; b=2,    y=MAX; ...
+      # 'XY': b=MAX,y=MAX; b=MAX-1,y=MAX; b=MAX-2,y=MAX; ...
+      def byte_iterator type = nil
+        if type.nil? || type == 'auto'
+          type = @image.format == :bmp ? 'bY' : 'by'
+        end
+        raise "invalid iterator type #{type}" unless type =~ /\A(by|yb)\Z/i
+
+        sl0 = @image.scanlines.first
+
+        x0,x1,xstep =
+          if type.index('b')
+            [0, sl0.decoded_bytes.size-1, 1]
+          else
+            [sl0.decoded_bytes.size-1, 0, -1]
+          end
+
+        y0,y1,ystep =
+          if type.index('y')
+            [0, @image.height-1, 1]
+          else
+            [@image.height-1, 0, -1]
+          end
+
+        if type[0,1].downcase == 'b'
+          # ROW iterator
+          y0.step(y1,ystep) do |y|
+            x0.step(x1,xstep) do |x|
+              yield x,y
+            end
+          end
+        else
+          # COLUMN iterator
+          x0.step(x1,xstep) do |x|
+            y0.step(y1,ystep) do |y|
+              yield x,y
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zsteg/extractor/color_extractor.rb

@@ -0,0 +1,95 @@
+module ZSteg
+  class Extractor
+    # ColorExtractor extracts bits from each pixel's color
+    module ColorExtractor
+
+      def color_extract params = {}
+        channels = (Array(params[:channels]) + Array(params[:channel])).compact
+
+        limit = params[:limit].to_i
+        limit = 2**32 if limit <= 0
+
+        bits = params[:bits]
+        raise "invalid bits value #{bits.inspect}" unless (1..8).include?(bits)
+        mask = 2**bits - 1
+
+
+        data = ''.force_encoding('binary')
+        a = []
+        coord_iterator(params[:order]) do |x,y|
+          color = @image[x,y]
+
+          channels.each do |c|
+            value = color.send(c)
+            bits.times do |bidx|
+              a << ((value & (1<<(bits-bidx-1))) == 0 ? 0 : 1)
+            end
+          end
+
+          if a.size >= 8
+            byte = 0
+            if params[:bit_order] == :msb
+              8.times{ |i| byte |= (a.shift<<i)}
+            else
+              8.times{ |i| byte |= (a.shift<<(7-i))}
+            end
+            #printf "[d] %02x %08b\n", byte, byte
+            data << byte.chr
+            if data.size >= limit
+              print "[limit #{params[:limit]}]".gray if @verbose > 1
+              break
+            end
+          end
+        end
+        if params[:strip_tail_zeroes] != false && data[-1,1] == "\x00"
+          oldsz = data.size
+          data.sub!(/\x00+\Z/,'')
+          print "[zerotail #{oldsz-data.size}]".gray if @verbose > 1
+        end
+        data
+      end
+
+      # 'xy': x=0,y=0; x=1,y=0; x=2,y=0; ...
+      # 'yx': x=0,y=0; x=0,y=1; x=0,y=2; ...
+      # ...
+      # 'xY': x=0,  y=MAX; x=1,    y=MAX; x=2,    y=MAX; ...
+      # 'XY': x=MAX,y=MAX; x=MAX-1,y=MAX; x=MAX-2,y=MAX; ...
+      def coord_iterator type = nil
+        if type.nil? || type == 'auto'
+          type = @image.format == :bmp ? 'xY' : 'xy'
+        end
+        raise "invalid iterator type #{type}" unless type =~ /\A(xy|yx)\Z/i
+
+        x0,x1,xstep =
+          if type.index('x')
+            [0, @image.width-1, 1]
+          else
+            [@image.width-1, 0, -1]
+          end
+
+        y0,y1,ystep =
+          if type.index('y')
+            [0, @image.height-1, 1]
+          else
+            [@image.height-1, 0, -1]
+          end
+
+        if type[0,1].downcase == 'x'
+          # ROW iterator
+          y0.step(y1,ystep) do |y|
+            x0.step(x1,xstep) do |x|
+              yield x,y
+            end
+          end
+        else
+          # COLUMN iterator
+          x0.step(x1,xstep) do |x|
+            y0.step(y1,ystep) do |y|
+              yield x,y
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zsteg/file_cmd.rb

@@ -0,0 +1,63 @@
+require 'open3'
+require 'tempfile'
+
+module ZSteg
+  class FileCmd
+
+    IGNORES = [
+      'data',
+      'empty',
+      'Sendmail frozen configuration',
+      'DOS executable',
+      'Dyalog APL',
+      '8086 relocatable',
+      'SysEx File',
+      'COM executable',
+      'Non-ISO extended-ASCII text',
+      'ISO-8859 text',
+      'very short file',
+      'International EBCDIC text',
+      'lif file',
+      'AmigaOS bitmap font'
+    ]
+
+    def start!
+      @stdin, @stdout, @stderr, @wait_thr = Open3.popen3("file -n -b -f -")
+    end
+
+    def check_file fname
+      @stdin.puts fname
+      r = @stdout.gets.force_encoding('binary').strip
+      IGNORES.any?{ |x| r.index(x) == 0 } ? nil : r
+    end
+
+    def check_data data
+      @tempfile ||= Tempfile.new('zsteg', :encoding => 'binary')
+      @tempfile.rewind
+      @tempfile.write data
+      @tempfile.flush
+      check_file @tempfile.path
+    end
+
+    def stop!
+      @stdin.close
+      @stdout.close
+      @stderr.close
+    ensure
+      if @tempfile
+        @tempfile.close
+        @tempfile.unlink
+        @tempfile = nil
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  filecmd = ZSteg::FileCmd.new
+  ARGV.each do |fname|
+    p filecmd.check_file fname
+    p filecmd.check_data File.binread(fname)
+  end
+  filecmd.stop!
+end