origami 1.0.2

data/origami/name.rb

@@ -0,0 +1,170 @@
+=begin
+
+= File
+	name.rb
+
+= Info
+	This file is part of Origami, PDF manipulation framework for Ruby
+	Copyright (C) 2010	Guillaume Delugré <guillaume@security-labs.org>
+	All right reserved.
+	
+  Origami 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 3 of the License, or
+  (at your option) any later version.
+
+  Origami is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+
+=end
+
+if RUBY_VERSION < '1.9'
+  class EmptySymbol
+    def ==(sym)
+      sym.is_a?(EmptySymbol)
+    end
+
+    def id2name
+      ""
+    end
+    alias to_s id2name
+
+    def to_sym
+      self
+    end
+
+    def to_o
+      Name.new("")
+    end
+
+    def inspect
+      ":"
+    end
+  end
+end
+
+module Origami
+
+  REGULARCHARS = "([^ \\t\\r\\n\\0\\[\\]<>()%\\/]|#[a-fA-F0-9][a-fA-F0-9])*" #:nodoc:
+
+  class InvalidNameObjectError < InvalidObjectError #:nodoc:
+  end
+
+  #
+  # Class representing a Name Object.
+  # Name objects are strings which identify some PDF file inner structures.
+  #
+  class Name #< DelegateClass(Symbol)
+    
+    include Origami::Object
+    
+    TOKENS = %w{ / } #:nodoc:
+    
+    @@regexp = Regexp.new(WHITESPACES + TOKENS.first + "(" + REGULARCHARS + ")" + WHITESPACES) #:nodoc
+    
+    #
+    # Creates a new Name.
+    # _name_:: A symbol representing the new Name value.
+    #
+    def initialize(name = "")
+      unless name.is_a?(Symbol) or name.is_a?(::String)
+        raise TypeError, "Expected type Symbol or String, received #{name.class}."
+      end
+      
+      @value = name.to_s
+      
+      super()
+    end
+
+    if RUBY_VERSION < '1.9'
+      def value   
+        ( @value.empty? ) ? EmptySymbol.new : @value.to_sym
+      end
+    else
+      def value   
+        @value.to_sym
+      end
+    end
+
+    def ==(object) #:nodoc:
+      @value.to_sym == object
+    end
+    
+    def eql?(object) #:nodoc:
+      object.is_a?(Name) and self.to_s == object.to_s
+    end
+    
+    def hash #:nodoc:
+      @value.hash
+    end
+    
+    def to_s #:nodoc:
+      super(TOKENS.first + Name.expand(@value))
+    end
+    
+    def self.parse(stream) #:nodoc:
+
+      offset = stream.pos
+      
+      name = 
+        if stream.scan(@@regexp).nil?
+          raise InvalidNameObjectError, "Bad name format"
+        else
+          value = stream[2]
+          
+          Name.new(value.include?('#') ? contract(value) : value)
+        end
+
+      name.file_offset = offset
+
+      name
+    end
+    
+    def self.contract(name) #:nodoc:
+     
+      i = 0
+      while i < name.length
+
+        if name[i,1] == "#"
+          digits = name[i+1, 2]
+          
+          unless /^[A-Za-z0-9]{2}$/ === digits
+            raise InvalidNameObjectError, "Irregular use of # token"
+          end
+          
+          char = digits.hex.chr
+          
+          if char == "\0"
+            raise InvalidNameObjectError, "Null byte forbidden inside name definition"
+          end
+          
+          name[i, 3] = char
+        end
+          
+        i = i + 1
+      end
+
+      name
+    end
+    
+    def self.expand(name) #:nodoc:
+      
+      forbiddenchars = /[ #\t\r\n\0\[\]<>()%\/]/
+      
+      name.gsub!(forbiddenchars) do |c|
+        "#" + c[0].ord.to_s(16).rjust(2,"0")
+      end
+      
+      name
+    end
+    
+    def real_type ; Name end
+
+  end
+
+end

data/origami/null.rb

@@ -0,0 +1,75 @@
+=begin
+
+= File
+	null.rb
+
+= Info
+	This file is part of Origami, PDF manipulation framework for Ruby
+	Copyright (C) 2010	Guillaume Delugr� <guillaume@security-labs.org>
+	All right reserved.
+	
+  Origami 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 3 of the License, or
+  (at your option) any later version.
+
+  Origami is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+
+=end
+
+module Origami
+
+  class InvalidNullObjectError < InvalidObjectError #:nodoc:
+  end
+  
+  #
+  # Class representing  Null Object.
+  #
+  class Null
+    
+    include Origami::Object
+    
+    TOKENS = %w{ null } #:nodoc:
+    
+    @@regexp = Regexp.new(WHITESPACES + TOKENS.first)
+    
+    def initialize
+      super
+    end
+    
+    def self.parse(stream) #:nodoc:
+
+      offset = stream.pos
+      
+      if stream.skip(@@regexp).nil?
+        raise InvalidNullObjectError
+      end
+      
+      null = Null.new
+      null.file_offset = offset
+
+      null
+    end
+    
+    #
+    # Returns *nil*.
+    #
+    def value
+      nil
+    end
+    
+    def to_s #:nodoc:
+      super(TOKENS.first)
+    end
+
+    def real_type ; Null end
+    
+  end
+  
+end

data/origami/numeric.rb

@@ -0,0 +1,188 @@
+=begin
+
+= File
+	numeric.rb
+
+= Info
+	Origami 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 3 of the License, or
+  (at your option) any later version.
+
+  Origami is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+
+=end
+
+require 'delegate'
+
+module Origami
+
+  class InvalidIntegerObjectError < InvalidObjectError #:nodoc:
+  end
+
+  #
+  # Class representing a PDF number (Integer, or Real).
+  #
+  module Number
+    include Origami::Object
+    
+    def ~
+      self.class.new(~self.to_i)
+    end
+    
+    def |(val)
+      self.class.new(self.to_i | val)
+    end
+    
+    def &(val)
+      self.class.new(self.to_i & val)
+    end
+    
+    def ^(val)
+      self.class.new(self.to_i ^ val)
+    end
+    
+    def <<(val)
+      self.class.new(self.to_i << val)
+    end
+    
+    def >>(val)
+      self.class.new(self.to_i >> val)
+    end
+    
+    def +(val)
+      self.class.new(self.to_i + val)
+    end
+    
+    def -(val)
+      self.class.new(self.to_i - val)
+    end
+    
+    def -@
+      self.class.new(-self.to_i)
+    end
+    
+    def *(val)
+      self.class.new(self.to_i * val)
+    end
+    
+    def /(val)
+      self.class.new(self.to_i / val)
+    end
+    
+    def abs
+      self.class.new(self.to_i.abs)
+    end
+    
+    def **(val)
+      self.class.new(self.to_i ** val)
+    end
+    
+    def to_s
+      super(value.to_s)
+    end
+    
+    def real_type ; Number end
+  end
+  
+  #
+  # Class representing an Integer Object.
+  #
+  class Integer < DelegateClass(Bignum)
+    
+    include Number
+    
+    TOKENS = [ "(\\+|-)?[\\d]+[^.]?" ] #:nodoc:
+
+    REGEXP_TOKEN = Regexp.new(TOKENS.first)
+
+    @@regexp = Regexp.new(WHITESPACES + "((\\+|-)?[\\d]+)")
+
+    #
+    # Creates a new Integer from  a Ruby Fixnum / Bignum.
+    # _i_:: The Integer value.
+    #
+    def initialize(i = 0)
+      
+      unless i.is_a?(::Integer)
+        raise TypeError, "Expected type Fixnum or Bignum, received #{i.class}."
+      end
+
+      super(i)
+    end
+      
+    def self.parse(stream) #:nodoc:
+
+      offset = stream.pos
+
+      if not stream.scan(@@regexp)
+        raise InvalidIntegerObjectError, "Invalid integer format"
+      end
+
+      value = stream[2].to_i
+      int = Integer.new(value)
+      int.file_offset = offset
+
+      int
+    end
+    
+    alias value to_i
+    
+  end
+  
+  class InvalidRealObjectError < InvalidObjectError #:nodoc:
+  end
+
+  #
+  # Class representing a Real number Object.
+  # PDF real numbers are arbitrary precision numbers, depending on architectures.
+  #
+  class Real < DelegateClass(Float)
+    
+    include Number
+    
+    TOKENS = [ "(\\+|-)?([\\d]*\\.[\\d]+|[\\d]+\\.[\\d]*)([eE](\\+|-)?[\\d]+)?" ] #:nodoc:
+
+    REGEXP_TOKEN = Regexp.new(TOKENS.first)
+    
+    @@regexp = Regexp.new(WHITESPACES + "(" + TOKENS.first + ")")
+    
+    #
+    # Creates a new Real from a Ruby Float.
+    # _f_:: The new Real value.
+    #
+    def initialize(f = 0)
+      
+      unless f.is_a?(Float)
+        raise TypeError, "Expected type Float, received #{f.class}."
+      end
+      
+      super(f)
+    end
+  
+    def self.parse(stream) #:nodoc:
+
+      offset = stream.pos
+      
+      if not stream.scan(@@regexp)
+        raise InvalidRealObjectError, "Invalid real number format"
+      end
+       
+      value = stream[2].to_f
+      real = Real.new(value)
+      real.file_offset = offset
+
+      real
+    end
+    
+    alias value to_f
+    
+  end
+
+end

data/origami/obfuscation.rb

@@ -0,0 +1,233 @@
+module Origami
+
+  module Obfuscator
+
+    WHITECHARS = [ " ", "\t", "\r", "\n", "\0" ] 
+    OBJECTS = [ Array, Boolean, Dictionary, Integer, Name, Null, Stream, String, Real, Reference ]
+    MAX_INT = 0xFFFFFFFF
+    PRINTABLE = ("!".."9").to_a + (':'..'Z').to_a + ('['..'z').to_a + ('{'..'~').to_a
+    FILTERS = [ :FlateDecode, :RunLengthDecode, :LZWDecode, :ASCIIHexDecode, :ASCII85Decode ]
+
+    def self.junk_spaces(max_size = 3)
+      length = rand(max_size) + 1
+
+      ::Array.new(length) { WHITECHARS[rand(WHITECHARS.size)] }.join
+    end
+
+    def self.junk_comment(max_size = 15)
+      length = rand(max_size) + 1
+
+      junk_comment = ::Array.new(length) { 
+        byte = rand(256).chr until (not byte.nil? and byte != "\n" and byte != "\r"); byte 
+      }.join
+      
+      "%#{junk_comment}#{EOL}"
+    end
+
+    def self.junk_object(type = nil)
+
+      if type.nil?
+        type = OBJECTS[rand(OBJECTS.size)]
+      end
+
+      unless type.include?(Origami::Object)
+        raise TypeError, "Not a valid object type"
+      end
+
+      Obfuscator.send("junk_#{type.to_s.split('::').last.downcase}")
+    end
+
+    def self.junk_array(max_size = 5)
+      length = rand(max_size) + 1
+
+      ::Array.new(length) {
+        obj = Obfuscator.junk_object until (not obj.nil? and not obj.is_a?(Stream)) ; obj
+      }.to_o 
+    end
+
+    def self.junk_boolean
+      Boolean.new(rand(2).zero?)
+    end
+
+    def self.junk_dictionary(max_size = 5)
+      length = rand(max_size) + 1
+
+      hash = Hash.new
+      length.times do 
+        obj = Obfuscator.junk_object
+        hash[Obfuscator.junk_name] = obj unless obj.is_a?(Stream)
+      end
+      
+      hash.to_o
+    end
+
+    def self.junk_integer(max = MAX_INT)
+      Integer.new(rand(max + 1))
+    end
+
+    def self.junk_name(max_size = 8)
+      length = rand(max_size) + 1
+
+      Name.new(::Array.new(length) { PRINTABLE[rand(PRINTABLE.size)] }.join)
+    end
+
+    def self.junk_null
+      Null.new
+    end
+
+    def self.junk_stream(max_data_size = 200)
+      
+      chainlen = rand(2) + 1
+      chain = ::Array.new(chainlen) { FILTERS[rand(FILTERS.size)] }
+
+      length = rand(max_data_size) + 1
+      junk_data = ::Array.new(length) { rand(256).chr }.join
+
+      stm = Stream.new
+      stm.dictionary = Obfuscator.junk_dictionary(5)
+      stm.setFilter(chain)
+      stm.data = junk_data
+
+      stm
+    end
+
+    def self.junk_string(max_size = 10)
+      length = rand(max_size) + 1
+
+      strtype = (rand(2).zero?) ? ByteString : HexaString
+
+      strtype.new(::Array.new(length) { PRINTABLE[rand(PRINTABLE.size)] }.join)
+    end
+
+    def self.junk_real
+      Real.new(rand * rand(MAX_INT + 1))
+    end
+
+    def self.junk_reference(max_no = 300, max_gen = 1)
+      no = rand(max_no) + 1
+      gen = rand(max_gen)
+
+      Reference.new(no, gen)
+    end
+
+  end
+
+  class Dictionary
+    
+    def to_obfuscated_str
+      content = TOKENS.first + Obfuscator.junk_spaces
+      self.each_pair { |key, value|
+        content << Obfuscator.junk_spaces + 
+          key.to_obfuscated_str + Obfuscator.junk_spaces + 
+          value.to_obfuscated_str + Obfuscator.junk_spaces
+      }
+
+      content << TOKENS.last
+      super(content)
+    end
+
+  end
+
+  module Object
+    alias :to_obfuscated_str :to_s
+  end
+
+  class Array
+    def to_obfuscated_str
+      content = TOKENS.first + Obfuscator.junk_spaces
+      self.each { |entry|
+        content << entry.to_o.to_obfuscated_str + Obfuscator.junk_spaces
+      }
+
+      content << TOKENS.last
+
+      super(content)
+    end
+  end
+
+  class Null
+    alias :to_obfuscated_str :to_s
+  end
+
+  class Boolean
+    alias :to_obfuscated_str :to_s
+  end
+
+  class Integer
+    alias :to_obfuscated_str :to_s
+  end
+
+  class Real
+    alias :to_obfuscated_str :to_s
+  end
+
+  class Reference
+    def to_obfuscated_str
+      refstr = refno.to_s + Obfuscator.junk_spaces + refgen.to_s + Obfuscator.junk_spaces + "R"
+
+      super(refstr)
+    end
+  end
+
+  class ByteString
+    def to_obfuscated_str
+      to_s
+    end
+  end
+
+  class HexaString
+    def to_obfuscated_str
+      to_s
+    end
+  end
+
+  class Name
+    def to_obfuscated_str(prop = 2)
+      name = @value.dup
+      
+      forbiddenchars = [ " ","#","\t","\r","\n","\0","[","]","<",">","(",")","%","/","\\" ]
+
+      name.gsub!(/./) do |c|
+        if rand(prop) == 0 or forbiddenchars.include?(c)
+          hexchar = c[0].to_s(base=16)
+          hexchar = "0" + hexchar if hexchar.length < 2
+          
+          '#' + hexchar
+        else
+          c
+        end
+      end
+
+      super(TOKENS.first + name)
+    end
+  end
+
+  class Stream
+    def to_obfuscated_str
+      content = ""
+      
+      content << @dictionary.to_obfuscated_str
+      content << "stream" + EOL
+      content << self.rawdata
+      content << EOL << TOKENS.last
+      
+      super(content)
+    end
+  end
+
+  class Trailer
+
+    def to_obfuscated_str
+      content = ""
+      if self.has_dictionary?
+        content << TOKENS.first << EOL << @dictionary.to_obfuscated_str << EOL
+      end
+
+      content << XREF_TOKEN << EOL << @startxref.to_s << EOL << TOKENS.last << EOL
+
+      content
+    end
+
+  end
+
+end