origami 2.0.4 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67f206ada90cab96c6551107f6e1b7c882608a9c
-  data.tar.gz: c64e6272dd9512390470c9e5c56454f569162913
+  metadata.gz: e32cc8725108ee820a1b79b293f0f22357816d7f
+  data.tar.gz: 329075b872aff363e86f995ef67bc2744f383539
 SHA512:
-  metadata.gz: a5335917cb27a2fba1c7e36cd805b924d225d436b62be76411d43c51102c651eb5cbdc931cf12bfd4de206e93a421afcf01edae11b20816a4d6815d06b7aba3f
-  data.tar.gz: aa3eaf290b1c5ece1b06630dcb1440e81403865d753355dbccac57ba7f395486eb2bd3b14ba0a96baa8b15c2d4666072d37dead6a54de7c44a40d212ebb67bb8
+  metadata.gz: bba9faff66109e12ce8212f7c048e3c58e61ffce8012dbb797250545bced380a40ff02546a7bf15d73e0dba2f67782de12987816659656e4397a7411fd43662e
+  data.tar.gz: eea468b0212056341542b6bddae44e9194da88b0b546850b91e6ca5aa5a05161263bbbe303e2b67b12c72a4cdeb2a7a6c2af9aba3a0dce53784a8f30093bab53

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+2.1.0
+-----
+* Moved pdfwalker to a separate gem
+
 2.0.0
 -----
 * Code reindented to 4 spaces.

data/README.md

@@ -28,10 +28,8 @@ As of version 2, the minimal version required to run Origami is Ruby 2.1.
 
 Some optional features require additional gems:
 
-* [Gtk2][ruby-gtk2] for running the GUI interface
 * [therubyracer][the-ruby-racer] for JavaScript emulation of PDF scripts
 
-[ruby-gtk2]: https://rubygems.org/gems/gtk2
 [the-ruby-racer]: https://rubygems.org/gems/therubyracer
 
 Quick start
@@ -102,12 +100,15 @@ Origami comes with a set of tools to manipulate PDF documents from the command l
 * [pdfmetadata](bin/pdfmetadata): Displays the metadata contained in a document.
 * [pdf2ruby](bin/pdf2ruby): Converts a PDF into an Origami script rebuilding an equivalent document (experimental).
 * [pdfsh](bin/pdfsh): An IRB shell running inside the Origami namespace.
-* [pdfwalker](bin/pdfwalker): A graphical interface to dig into the contents of a PDF document.
 
+**Note**: Since version 2.1, [pdfwalker][pdfwalker-gem] has been moved to a [separate repository][pdfwalker-repo].
+
+[pdfwalker-gem]: https://rubygems.org/gems/pdfwalker
+[pdfwalker-repo]: https://github.com/gdelugre/pdfwalker
 
 License
 -------
 
-Origami is distributed under the [LGPL](COPYING.LESSER) license, except for the graphical interface which is distributed under the [GPL](bin/gui/COPYING) license.
+Origami is distributed under the [LGPL](COPYING.LESSER) license.
 
-Copyright © 2016 Guillaume Delugré.
+Copyright © 2017 Guillaume Delugré.

data/bin/pdf2pdfa

@@ -83,5 +83,5 @@ begin
     PDF.read(target, params).save(@options[:output], intent: 'PDF/A', noindent: true)
 
 rescue
-    abort"#{$!.class}: #{$!.message}"
+    abort "#{$!.class}: #{$!.message}"
 end

data/bin/pdfcop

@@ -142,12 +142,12 @@ def reject(cause)
 end
 
 def quarantine(file, quarantine_folder)
-    digest = Digest::SHA256.file(TARGET)
-    ext = File.extname(TARGET)
-    dest_name = "#{File.basename(TARGET, ext)}_#{digest}#{ext}"
-    dest_path = File.join(@options[:move_dir], dest_name)
+    digest = Digest::SHA256.file(file)
+    ext = File.extname(file)
+    dest_name = "#{File.basename(file, ext)}_#{digest}#{ext}"
+    dest_path = File.join(quarantine_folder, dest_name)
 
-    FileUtils.move(TARGET, dest_path)
+    FileUtils.move(file, dest_path)
 end
 
 def check_rights(*required_rights)

data/bin/pdfsh

@@ -7,6 +7,6 @@ rescue LoadError
 end
 
 $:.unshift File.join(__dir__, 'shell')
-ENV["IRBRC"] = File.join(__dir__, "shell", ".irbrc")
+ENV["IRBRC"] = File.join(__dir__, "shell", "irbrc")
 
 IRB.start

data/lib/origami/array.rb

@@ -145,13 +145,22 @@ module Origami
         end
         alias push <<
 
-        def []=(key,val)
+        def []=(key, val)
             key, val = key.to_o, val.to_o
             super(key.to_o, val.to_o)
 
-            val.parent = self unless val.indirect? or val.parent.equal?(self)
+            val.parent = self unless val.indirect?
+        end
+
+        def concat(*arys)
+            arys.each do |ary|
+                ary.each do |e|
+                    val = e.to_o
+                    val.parent = self unless val.indirect?
 
-            val
+                    self.push(val)
+                end
+            end
         end
 
         def copy

data/lib/origami/dictionary.rb

@@ -159,8 +159,6 @@ module Origami
 
             key.parent = self
             val.parent = self unless val.indirect? or val.parent.equal?(self)
-
-            val
         end
 
         def [](key)

data/lib/origami/encryption.rb

@@ -58,48 +58,6 @@ module Origami
                 raise EncryptionNotSupportedError, "Unknown security handler : '#{handler.Filter}'"
             end
 
-            crypt_filters = {
-                Identity: Encryption::Identity
-            }
-
-            case handler.V.to_i
-            when 1,2
-                crypt_filters = Hash.new(Encryption::RC4)
-                string_filter = stream_filter = nil
-            when 4,5
-                crypt_filters = {
-                    Identity: Encryption::Identity
-                }
-
-                if handler[:CF].is_a?(Dictionary)
-                    handler[:CF].each_pair do |name, cf|
-                        next unless cf.is_a?(Dictionary)
-
-                        crypt_filters[name.value] =
-                            if cf[:CFM] == :V2 then Encryption::RC4
-                            elsif cf[:CFM] == :AESV2 then Encryption::AES
-                            elsif cf[:CFM] == :None then Encryption::Identity
-                            elsif cf[:CFM] == :AESV3 and handler.V.to_i == 5 then Encryption::AES
-                            else
-                                raise EncryptionNotSupportedError, "Unsupported encryption version : #{handler.V}"
-                            end
-                    end
-                end
-
-                string_filter = handler.StrF.is_a?(Name) ? handler.StrF.value : :Identity
-                stream_filter = handler.StmF.is_a?(Name) ? handler.StmF.value : :Identity
-
-                unless crypt_filters.key?(string_filter)
-                    raise EncryptionError, "Invalid StrF value in encryption dictionary"
-                end
-
-                unless crypt_filters.key?(stream_filter)
-                    raise EncryptionError, "Invalid StmF value in encryption dictionary"
-                end
-            else
-                raise EncryptionNotSupportedError, "Unsupported encryption version : #{handler.V}"
-            end
-
             doc_id = trailer_key(:ID)
             unless doc_id.is_a?(Array)
                 raise EncryptionError, "Document ID was not found or is invalid" unless handler.V.to_i == 5
@@ -107,24 +65,11 @@ module Origami
                 doc_id = doc_id.first
             end
 
-            if handler.is_user_password?(passwd, doc_id)
-                encryption_key = handler.compute_user_encryption_key(passwd, doc_id)
-            elsif handler.is_owner_password?(passwd, doc_id)
-                if handler.V.to_i < 5
-                    user_passwd = handler.retrieve_user_password(passwd)
-                    encryption_key = handler.compute_user_encryption_key(user_passwd, doc_id)
-                else
-                    encryption_key = handler.compute_owner_encryption_key(passwd)
-                end
-            else
-                raise EncryptionInvalidPasswordError
-            end
+            encryption_key = handler.derive_encryption_key(passwd, doc_id)
 
             self.extend(Encryption::EncryptedDocument)
             self.encryption_handler = handler
-            self.crypt_filters = crypt_filters
             self.encryption_key = encryption_key
-            self.stm_filter, self.str_filter = stream_filter, string_filter
 
             decrypt_objects
 
@@ -156,7 +101,7 @@ module Origami
             }.update(options)
 
             # Get the cryptographic parameters.
-            version, revision, crypt_filters = crypto_revision_from_options(params)
+            version, revision = crypto_revision_from_options(params)
 
             # Create the security handler.
             handler, encryption_key = create_security_handler(version, revision, params)
@@ -165,8 +110,6 @@ module Origami
             self.extend(Encryption::EncryptedDocument)
             self.encryption_handler = handler
             self.encryption_key = encryption_key
-            self.crypt_filters = crypt_filters
-            self.stm_filter = self.str_filter = :StdCF
 
             self
         end
@@ -228,23 +171,12 @@ module Origami
         def crypto_revision_from_options(params)
             case params[:cipher].upcase
             when 'RC4'
-                algorithm = Encryption::RC4
-                version, revision = crypto_revision_from_rc4_key(params[:key_size])
-                crypt_filters = Hash.new(algorithm)
-
+                crypto_revision_from_rc4_key(params[:key_size])
             when 'AES'
-                algorithm = Encryption::AES
-                version, revision = crypto_revision_from_aes_key(params[:key_size], params[:hardened])
-
-                crypt_filters = {
-                    Identity: Encryption::Identity,
-                    StdCF: algorithm
-                }
+                crypto_revision_from_aes_key(params[:key_size], params[:hardened])
             else
                 raise EncryptionNotSupportedError, "Cipher not supported : #{params[:cipher]}"
             end
-
-            [ version, revision, crypt_filters ]
         end
 
         #
@@ -312,22 +244,20 @@ module Origami
         module EncryptedDocument
             attr_accessor :encryption_key
             attr_accessor :encryption_handler
-            attr_accessor :str_filter, :stm_filter
-            attr_accessor :crypt_filters
 
             # Get the encryption cipher from the crypt filter name.
             def encryption_cipher(name)
-                @crypt_filters[name]
+                @encryption_handler.encryption_cipher(name)
             end
 
             # Get the default string encryption cipher.
             def string_encryption_cipher
-                encryption_cipher @str_filter
+                @encryption_handler.string_encryption_cipher
             end
 
             # Get the default stream encryption cipher.
             def stream_encryption_cipher
-                encryption_cipher @stm_filter
+                @encryption_handler.stream_encryption_cipher
             end
 
             private
@@ -736,6 +666,57 @@ module Origami
             field   :StmF,          :Type => Name, :Default => :Identity, :Version => "1.5"
             field   :StrF,          :Type => Name, :Default => :Identity, :Version => "1.5"
             field   :EFF,           :Type => Name, :Version => "1.6"
+
+            #
+            # Returns the default string encryption cipher.
+            #
+            def string_encryption_cipher
+                encryption_cipher(self.StrF || :Identity)
+            end
+
+            #
+            # Returns the default stream encryption cipher.
+            #
+            def stream_encryption_cipher
+                encryption_cipher(self.StmF || :Identity)
+            end
+
+            #
+            # Returns the encryption cipher corresponding to a crypt filter name.
+            #
+            def encryption_cipher(name)
+                case self.V.to_i
+                when 1, 2
+                    Encryption::RC4
+                when 4, 5
+                    return Encryption::Identity if name == :Identity
+                    raise EncryptionError, "Broken CF entry" unless self.CF.is_a?(Dictionary)
+
+                    self.CF.select { |key, dict| key == name and dict.is_a?(Dictionary) }
+                           .map { |_, dict| cipher_from_crypt_filter_method(dict[:CFM] || :None) }
+                           .first
+                else
+                    raise EncryptionNotSupportedError, "Unsupported encryption version: #{handler.V}"
+                end
+            end
+
+            private
+
+            #
+            # Converts a crypt filter method identifier to its cipher class.
+            #
+            def cipher_from_crypt_filter_method(name)
+                case name.to_sym
+                when :None then Encryption::Identity
+                when :V2 then Encryption::RC4
+                when :AESV2 then Encryption::AES
+                when :AESV3
+                    raise EncryptionNotSupportedError, "AESV3 requires a version 5 handler" if self.V.to_i != 5
+                    Encryption::AES
+                else
+                     raise EncryptionNotSupportedError, "Unsupported crypt filter method: #{name}"
+                end
+            end
         end
 
         #
@@ -785,6 +766,25 @@ module Origami
                     end
                 end
 
+                #
+                # Checks the given password and derives the document encryption key.
+                # Raises EncryptionInvalidPasswordError on invalid password.
+                #
+                def derive_encryption_key(passwd, doc_id)
+                    if is_user_password?(passwd, doc_id)
+                        compute_user_encryption_key(passwd, doc_id)
+                    elsif is_owner_password?(passwd, doc_id)
+                        if self.V.to_i < 5
+                            user_passwd = retrieve_user_password(passwd)
+                            compute_user_encryption_key(user_passwd, doc_id)
+                        else
+                            compute_owner_encryption_key(passwd)
+                        end
+                    else
+                        raise EncryptionInvalidPasswordError
+                    end
+                end
+
                 #
                 # Computes the key that will be used to encrypt/decrypt the document contents with user password.
                 # Called at all revisions.

data/lib/origami/filters.rb

@@ -214,8 +214,6 @@ module Origami
                     pbyte = bits >> 3
                     pbit = bits - (pbyte << 3)
                     @ptr_byte, @ptr_bit = pbyte, pbit
-
-                    bits
                 end
 
                 #

data/lib/origami/filters/ccitt.rb

@@ -63,44 +63,50 @@ module Origami
             # Encodes data using CCITT-facsimile compression method.
             #
             def encode(stream)
-                mode = @params.has_key?(:K) ? @params.K.value : 0
+                mode = @params.key?(:K) ? @params.K.value : 0
+                colors = (@params.BlackIs1 == true) ? [0,1] : [1,0]
+                use_eob = (@params.EndOfBlock.nil? or @params.EndOfBlock == true)
+                use_eol = (@params.EndOfLine == true)
+                white, _black = colors
+
+                bitr = Utils::BitReader.new(stream)
+                bitw = Utils::BitWriter.new
 
                 unless mode.is_a?(::Integer) and mode <= 0
                     raise NotImplementedError.new("CCITT encoding scheme not supported", input_data: stream)
                 end
 
-                columns = @params.has_key?(:Columns) ? @params.Columns.value : (stream.size << 3)
-                unless columns.is_a?(::Integer) and columns > 0 #and columns % 8 == 0
+                # Use a single row if no width has been set.
+                @params[:Columns] ||= stream.size * 8
+                columns = @params.Columns.value
+
+                unless columns.is_a?(::Integer) and columns >= 0
                     raise CCITTFaxFilterError.new("Invalid value for parameter `Columns'", input_data: stream)
                 end
 
-                if stream.size % (columns >> 3) != 0
-                    raise CCITTFaxFilterError.new("Data size is not a multiple of image width", input_data: stream)
-                end
+                if columns > 0
+                    # Group 4 requires an imaginary white line
+                    if mode < 0
+                        prev_line = Utils::BitWriter.new
+                        write_bit_range(prev_line, white, columns)
+                        prev_line = Utils::BitReader.new(prev_line.final.to_s)
+                    end
 
-                colors = (@params.BlackIs1 == true) ? [0,1] : [1,0]
-                white, _black = colors
-                bitr = Utils::BitReader.new(stream)
-                bitw = Utils::BitWriter.new
+                    until bitr.eod?
+                        # Emit line synchronization code.
+                        bitw.write(*EOL) if use_eol
 
-                # Group 4 requires an imaginary white line
-                if mode < 0
-                    prev_line = Utils::BitWriter.new
-                    write_bit_range(prev_line, white, columns)
-                    prev_line = Utils::BitReader.new(prev_line.final.to_s)
-                end
-
-                until bitr.eod?
-                    case
-                    when mode == 0
-                        encode_one_dimensional_line(bitr, bitw, columns, colors)
-                    when mode < 0
-                        encode_two_dimensional_line(bitr, bitw, columns, colors, prev_line)
+                        case
+                        when mode == 0
+                            encode_one_dimensional_line(bitr, bitw, columns, colors)
+                        when mode < 0
+                            encode_two_dimensional_line(bitr, bitw, columns, colors, prev_line)
+                        end
                     end
                 end
 
-                # Emit return-to-control code
-                bitw.write(*RTC)
+                # Emit return-to-control code.
+                bitw.write(*RTC) if use_eob
 
                 bitw.final.to_s
             end
@@ -109,14 +115,14 @@ module Origami
             # Decodes data using CCITT-facsimile compression method.
             #
             def decode(stream)
-                mode = @params.has_key?(:K) ? @params.K.value : 0
+                mode = @params.key?(:K) ? @params.K.value : 0
 
                 unless mode.is_a?(::Integer) and mode <= 0
                     raise NotImplementedError.new("CCITT encoding scheme not supported", input_data: stream)
                 end
 
                 columns = @params.has_key?(:Columns) ? @params.Columns.value : 1728
-                unless columns.is_a?(::Integer) and columns > 0 #and columns % 8 == 0
+                unless columns.is_a?(::Integer) and columns >= 0
                     raise CCITTFaxFilterError.new("Invalid value for parameter `Columns'", input_data: stream)
                 end
 
@@ -130,18 +136,18 @@ module Origami
                 }
 
                 unless params[:has_eob?]
-                    unless @params.has_key?(:Rows) and @params.Rows.is_a?(::Integer) and @params.Rows.value > 0
+                    rows = @params.key?(:Rows) ? @params.Rows.value : 0
+
+                    unless rows.is_a?(::Integer) and rows >= 0
                         raise CCITTFaxFilterError.new("Invalid value for parameter `Rows'", input_data: stream)
                     end
-
-                    rows = @params.Rows.to_i
                 end
 
                 bitr = Utils::BitReader.new(stream)
                 bitw = Utils::BitWriter.new
 
                 # Group 4 requires an imaginary white line
-                if mode < 0
+                if columns > 0 and mode < 0
                     prev_line = Utils::BitWriter.new
                     write_bit_range(prev_line, white, columns)
                     prev_line = Utils::BitReader.new(prev_line.final.to_s)
@@ -159,6 +165,8 @@ module Origami
                         break
                     end
 
+                    break if columns == 0
+
                     # checking for the presence of EOL
                     if bitr.peek(EOL[1]) != EOL[0]
                         raise InvalidCCITTFaxDataError.new(
@@ -184,7 +192,6 @@ module Origami
                         raise error
                     end
 
-
                     rows -= 1 unless params[:has_eob?]
                 end
 
@@ -194,11 +201,12 @@ module Origami
             private
 
             def encode_one_dimensional_line(input, output, columns, colors) #:nodoc:
-                output.write(*EOL)
                 scan_len = 0
                 white, _black = colors
                 current_color = white
 
+                return if columns == 0
+
                 # Process each bit in line.
                 begin
                     if input.read(1) == current_color