origamindee 3.0.0

data/bin/pdfencrypt

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+
+=begin
+
+= Info
+    Encrypts a PDF document.
+
+= License
+    Copyright (C) 2016  Guillaume Delugré.
+
+    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
+
+begin
+    require 'origami'
+rescue LoadError
+    $: << File.join(__dir__, '../lib')
+    require 'origami'
+end
+include Origami
+
+require 'optparse'
+
+class OptParser
+    BANNER = <<USAGE
+Usage: #{$0} [<PDF-file>] [-p <password>] [-c <cipher>] [-s <key-size>] [--hardened] [-o <output-file>]
+Encrypts a PDF document. Supports RC4 40 to 128 bits, AES128, AES256.
+Bug reports or feature requests at: http://github.com/gdelugre/origami
+
+Options:
+USAGE
+
+    def self.parser(options)
+        OptionParser.new do |opts|
+            opts.banner = BANNER
+
+            opts.on("-o", "--output FILE", "Output PDF file (stdout by default)") do |o|
+                options[:output] = o
+            end
+
+            opts.on("-p", "--password PASSWORD", "Password of the document") do |p|
+                options[:password] = p
+            end
+
+            opts.on("-c", "--cipher CIPHER", "Cipher used to encrypt the document (Default: AES)") do |c|
+                options[:cipher] = c
+            end
+
+            opts.on("-s", "--key-size KEYSIZE", "Key size in bits (Default: 256)") do |s|
+                options[:key_size] = s.to_i
+            end
+
+            opts.on("--hardened", "Use stronger key validation scheme (only AES-256)") do
+                options[:hardened] = true
+            end
+
+            opts.on_tail("-h", "--help", "Show this message") do
+                puts opts
+                exit
+            end
+        end
+    end
+
+    def self.parse(args)
+        options =
+        {
+            output: STDOUT,
+            password: '',
+            cipher: 'aes',
+            key_size: 256,
+            hardened: false
+        }
+
+        self.parser(options).parse!(args)
+
+        options
+    end
+end
+
+begin
+    @options = OptParser.parse(ARGV)
+
+    target = (ARGV.empty?) ? STDIN : ARGV.shift
+    params =
+    {
+        verbosity: Parser::VERBOSE_QUIET,
+    }
+
+    pdf = PDF.read(target, params)
+    pdf.encrypt(
+        user_passwd:    @options[:password],
+        owner_passwd:   @options[:password],
+        cipher:         @options[:cipher],
+        key_size:       @options[:key_size],
+        hardened:       @options[:hardened]
+    )
+    pdf.save(@options[:output], noindent: true)
+
+rescue
+    abort "#{$!.class}: #{$!.message}"
+end

data/bin/pdfexplode

@@ -0,0 +1,223 @@
+#!/usr/bin/env ruby
+
+=begin
+
+= Info
+    Explodes a PDF into separate documents.
+
+= License
+    Copyright (C) 2016  Guillaume Delugré.
+
+    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
+
+begin
+    require 'origami'
+rescue LoadError
+    $: << File.join(__dir__, '../lib')
+    require 'origami'
+end
+include Origami
+
+require 'optparse'
+require 'rexml/document'
+
+class OptParser
+    BANNER = <<USAGE
+Usage: #{$0} <PDF-file> [-r <range>] [-t pages|rsrc] [-d <output-directory>]
+Explodes a document into separate documents.
+Bug reports or feature requests at: http://github.com/gdelugre/origami
+
+Options:
+USAGE
+
+    def self.parser(options)
+        OptionParser.new do |opts|
+            opts.banner = BANNER
+
+            opts.on("-d", "--output-dir DIR", "Output directory.") do |d|
+                options[:output_dir] = d
+            end
+
+            opts.on("-r", "--range PAGES", "Page range (e.g: 2-, 1-3, 5). Default to '-'.") do |r|
+                range =
+                    if r.index('-').nil?
+                        page = r.to_i
+                        Range.new(page-1, page-1)
+                    else
+                        from, to = r.split('-').map{|bound| bound.to_i}
+                        from ||= 1
+                        to ||= 0
+                        Range.new(from-1, to-1)
+                    end
+                options[:page_range] = range
+            end
+
+            opts.on("-t", "--type TYPE", "Split by type. Can be 'pages' or 'rsrc'. Default to 'pages'.") do |t|
+                options[:split_by] = t
+            end
+
+            opts.on_tail("-h", "--help", "Show this message.") do
+                puts opts
+                exit
+            end
+        end
+    end
+
+    def self.parse(args)
+        options =
+        {
+            page_range: (0..-1),
+            split_by: 'pages'
+        }
+
+        self.parser(options).parse!(args)
+
+        options
+    end
+end
+
+begin
+    @options = OptParser.parse(ARGV)
+
+    if ARGV.empty?
+        abort "Error: No filename was specified. #{$0} --help for details."
+    else
+        target = ARGV.shift
+    end
+
+    if @options[:output_dir].nil?
+        @options[:output_dir] = "#{File.join(File.dirname(target), File.basename(target,'.pdf'))}.explode"
+    end
+
+    Origami::OPTIONS[:ignore_bad_references] = true
+    OUTPUT_DIR = @options[:output_dir]
+    Dir::mkdir(OUTPUT_DIR) unless File.directory?(OUTPUT_DIR)
+
+    def split_by_rsrc(n, page, type)
+        all_rsrc = page.resources
+        type_rsrc = page.resources(type)
+        other_rsrc = all_rsrc.keys - type_rsrc.keys
+
+        return unless type_rsrc.empty?
+
+        # Keep only specified resource type.
+        output_file = File.join(OUTPUT_DIR, "page_#{n}_keeponly_#{type}.pdf")
+        PDF.write(output_file) do |pdf|
+            reduced = page.copy
+            # New resource dictionary with only matching resources.
+            reduced.Resources = Resources.new(type => type_rsrc)
+            # Remove mention of other resources.
+            reduced.each_content_stream do |stream|
+                stream.data = stream.data.lines.
+                    delete_if {|line| other_rsrc.any?{|res| line =~ /#{res}/}}.join
+            end
+
+            STDERR.puts "Creating #{output_file}..."
+            pdf.append_page(reduced)
+        end
+
+        # Remove all specified resource type.
+        output_file = File.join(OUTPUT_DIR, "page_#{n}_excluded_#{type}.pdf")
+        PDF.write(output_file) do |pdf|
+            reduced = page.copy
+            # New resource dictionary with no resource of specified type.
+            reduced.Resources = reduced.Resources.copy
+            reduced.Resources.delete(type)
+            # Remove mention this resource type.
+            reduced.each_content_stream do |stream|
+                stream.data = stream.data.lines.
+                    delete_if {|line| type_rsrc.keys.any?{|res| line =~ /#{res}/}}.join
+            end
+
+            STDERR.puts "Creating #{output_file}..."
+            pdf.append_page(reduced)
+        end
+
+        # Now treating each resource object separately.
+        type_rsrc.each_pair do |name, rsrc|
+            anyother_rsrc = all_rsrc.keys - [ name ]
+            # Keey only specified resource object.
+            output_file = File.join(OUTPUT_DIR, "page_#{n}_keeponly_#{type}_#{name}.pdf")
+            PDF.write(output_file) do |pdf|
+                reduced = page.copy
+                # New resource dictionary with only specified resource object.
+                reduced.Resources = Resources.new(type => {name => rsrc})
+                # Remove mention of all other resources.
+                reduced.each_content_stream do |stream|
+                    stream.data = stream.data.lines.
+                        delete_if {|line| anyother_rsrc.any?{|res| line =~ /#{res}/}}.join
+                end
+
+                STDERR.puts "Creating #{output_file}..."
+                pdf.append_page(reduced)
+            end
+
+            # Remove only specified resource object.
+            output_file = File.join(OUTPUT_DIR, "page_#{n}_excluded_#{type}_#{name}.pdf")
+            PDF.write(output_file) do |pdf|
+                reduced = page.copy
+                # New resource dictionary with only specified resource object.
+                reduced.Resources = reduced.Resources.copy
+                reduced.Resources[type] = reduced.Resources.send(type).copy
+                reduced.Resources[type].delete(name)
+                # Remove mention of this resource only.
+                reduced.each_content_stream do |stream|
+                    stream.data = stream.data.lines.
+                        delete_if {|line| line =~ /#{name}/}.join
+                end
+
+                STDERR.puts "Creating #{output_file}..."
+                pdf.append_page(reduced)
+            end
+        end
+    end
+
+    params =
+    {
+        verbosity: Parser::VERBOSE_QUIET,
+    }
+    pdf = PDF.read(target, params)
+
+    i = @options[:page_range].first + 1
+    pdf.pages[@options[:page_range]].each do |page|
+        case @options[:split_by]
+        when 'pages'
+            output_file = File.join(OUTPUT_DIR, "page_#{i}.pdf")
+            PDF.write(output_file) do |doc|
+                STDERR.puts "Creating #{output_file}..."
+                doc.append_page(page)
+            end
+
+        when 'rsrc'
+            [ Resources::EXTGSTATE,
+              Resources::COLORSPACE,
+              Resources::PATTERN,
+              Resources::SHADING,
+              Resources::XOBJECT,
+              Resources::FONT,
+              Resources::PROPERTIES
+            ].each { |type| split_by_rsrc(i, page, type) }
+
+        else
+            raise ArgumentError, "Unknown split option: #{@options[:split_by]}"
+        end
+
+        i += 1
+    end
+
+rescue
+    abort "#{$!.class}: #{$!.message} #{$!.backtrace.join($/)}"
+end

data/bin/pdfextract

@@ -0,0 +1,277 @@
+#!/usr/bin/env ruby
+
+=begin
+
+= Info
+    Extracts valuable data from a PDF document. Can extract:
+     - decoded streams
+     - JavaScript
+     - file attachments
+
+= License
+    Copyright (C) 2016  Guillaume Delugré.
+
+    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
+
+begin
+    require 'origami'
+rescue LoadError
+    $: << File.join(__dir__, '../lib')
+    require 'origami'
+end
+include Origami
+
+require 'optparse'
+require 'rexml/document'
+
+class OptParser
+    BANNER = <<USAGE
+Usage: #{$0} <PDF-file> [-afjms] [-d <output-directory>]
+Extracts various data out of a document (streams, scripts, images, fonts, metadata, attachments).
+Bug reports or feature requests at: http://github.com/gdelugre/origami
+
+Options:
+USAGE
+
+    def self.parser(options)
+        OptionParser.new do |opts|
+            opts.banner = BANNER
+
+            opts.on("-d", "--output-dir DIR", "Output directory") do |d|
+                options[:output_dir] = d
+            end
+
+            opts.on("-s", "--streams", "Extracts all decoded streams") do
+                options[:streams] = true
+            end
+
+            opts.on("-a", "--attachments", "Extracts file attachments") do
+                options[:attachments] = true
+            end
+
+            opts.on("-f", "--fonts", "Extracts embedded font files") do
+                options[:fonts] = true
+            end
+
+            opts.on("-j", "--js", "Extracts JavaScript scripts") do
+                options[:javascript] = true
+            end
+
+            opts.on("-m", "--metadata", "Extracts metadata streams") do
+                options[:metadata] = true
+            end
+
+            opts.on("-i", "--images", "Extracts embedded images") do
+                options[:images] = true
+            end
+
+            opts.on_tail("-h", "--help", "Show this message") do
+                puts opts
+                exit
+            end
+        end
+    end
+
+    def self.parse(args)
+        options = {}
+
+        self.parser(options).parse!(args)
+
+        options
+    end
+end
+
+begin
+    @options = OptParser.parse(ARGV)
+
+    if ARGV.empty?
+        abort "Error: No filename was specified. #{$0} --help for details."
+    else
+        target = ARGV.shift
+    end
+
+    unless %i[streams javascript attachments fonts metadata images].any? {|opt| @options[opt]}
+        @options[:streams] =
+        @options[:javascript] =
+        @options[:fonts] =
+        @options[:attachments] =
+        @options[:images] = true
+    end
+
+    if @options[:output_dir].nil?
+        @options[:output_dir] = "#{File.basename(target, '.pdf')}.dump"
+    end
+
+    # Force data extraction, even for invalid FlateDecode streams.
+    Origami::OPTIONS[:ignore_zlib_errors] = true
+    Origami::OPTIONS[:ignore_png_errors] = true
+
+    OUTPUT_DIR = @options[:output_dir]
+    Dir::mkdir(OUTPUT_DIR) unless File.directory?(OUTPUT_DIR)
+
+    params =
+    {
+        verbosity: Parser::VERBOSE_QUIET,
+    }
+    pdf = PDF.read(target, params)
+
+    if @options[:streams]
+        nstreams = 0
+        stream_dir = File.join(OUTPUT_DIR, "streams")
+        Dir::mkdir(stream_dir) unless File.directory?(stream_dir)
+
+        pdf.each_object.select {|obj| obj.is_a?(Stream)}.each do |stream|
+            stream_file = File.join(stream_dir, "stream_#{stream.reference.refno}.dmp")
+            begin
+                File.binwrite(stream_file, stream.data)
+            rescue
+                STDERR.puts "Cannot decode stream #{stream.reference}: #{$!.message}"
+                next
+            end
+
+            nstreams += 1
+        end
+
+        puts "Extracted #{nstreams} PDF streams to '#{stream_dir}'."
+    end
+
+    if @options[:javascript]
+        nscripts = 0
+        js_dir = File.join(OUTPUT_DIR, "scripts")
+        Dir::mkdir(js_dir) unless File.directory?(js_dir)
+
+        pdf.ls(/^JS$/).each do |script|
+            script_file = File.join(js_dir, "script_#{script.hash}.js")
+            script_data =
+                case script
+                when Stream then script.data
+                else script.value
+                end
+
+            File.binwrite(script_file, script_data)
+            nscripts += 1
+        end
+
+        # Also checking for presence of JavaScript in XML forms.
+        if pdf.form? and pdf.Catalog.AcroForm.has_key?(:XFA)
+            xfa = pdf.Catalog.AcroForm.XFA
+
+            case xfa
+            when Array then
+                xml = ""
+                i = 0
+                xfa.each do |packet|
+                    if i % 2 == 1
+                        xml << packet.solve.data
+                    end
+
+                    i = i + 1
+                end
+            when Stream then
+                xml = xfa.data
+            else
+                reject("Malformed XFA dictionary")
+            end
+
+            xfadoc = REXML::Document.new(xml)
+            REXML::XPath.match(xfadoc, "//script").each do |script|
+                script_file = File.join(js_dir, "script_#{script.hash}.js")
+                File.binwrite(script_file, script.text)
+                nscripts += 1
+            end
+        end
+
+        puts "Extracted #{nscripts} scripts to '#{js_dir}'."
+    end
+
+    if @options[:attachments]
+        nattach = 0
+        attachments_dir = File.join(OUTPUT_DIR, "attachments")
+        Dir::mkdir(attachments_dir) unless File.directory?(attachments_dir)
+
+        pdf.each_attachment do |name, attachment|
+            name = name.to_utf8.tr("\/\x00", "_")
+            attached_file = File.join(attachments_dir, "attached_#{File.basename(name)}")
+
+            if attachment and attachment.EF and attachment.EF.F.is_a?(Stream)
+                File.binwrite(attached_file, attachment.EF.F.data)
+                nattach += 1
+            end
+        end
+
+        puts "Extracted #{nattach} attachments to '#{attachments_dir}'."
+    end
+
+    if @options[:fonts]
+        nfonts = 0
+        fonts_dir = File.join(OUTPUT_DIR, "fonts")
+        Dir::mkdir(fonts_dir) unless File.directory?(fonts_dir)
+
+        pdf.each_object.select {|obj| obj.is_a?(Stream)}.each do |stream|
+            font = stream.xrefs.find{|obj| obj.is_a?(FontDescriptor)}
+            if font
+                font_file = File.join(fonts_dir, File.basename(font.FontName.value.to_s))
+                File.binwrite(font_file, stream.data)
+                nfonts += 1
+            end
+        end
+
+        puts "Extracted #{nfonts} fonts to '#{fonts_dir}'."
+    end
+
+    if @options[:metadata]
+        nmeta = 0
+        metadata_dir = File.join(OUTPUT_DIR, "metadata")
+        Dir::mkdir(metadata_dir) unless File.directory?(metadata_dir)
+
+        pdf.each_object.select {|obj| obj.is_a?(MetadataStream)}.each do |stream|
+            metadata_file = File.join(metadata_dir, "metadata_#{stream.reference.refno}.xml")
+            File.binwrite(metadata_file, stream.data)
+            nmeta += 1
+        end
+
+        puts "Extracted #{nmeta} metadata streams to '#{metadata_dir}'."
+    end
+
+    if @options[:images]
+        nimages = 0
+        image_dir = File.join(OUTPUT_DIR, "images")
+        Dir::mkdir(image_dir) unless File.directory?(image_dir)
+
+        pdf.each_object.select {|obj| obj.is_a?(Graphics::ImageXObject)}.each do |stream|
+            begin
+                ext, image_data = stream.to_image_file
+                image_file = File.join(image_dir, "image_#{stream.reference.refno}.#{ext}")
+
+                if ext != 'png' and stream.ColorSpace == Graphics::Color::Space::DEVICE_CMYK
+                    STDERR.puts "Warning: file '#{image_file}' is intended to be viewed in CMYK color space."
+                end
+
+                File.binwrite(image_file, image_data)
+                nimages += 1
+            rescue
+                STDERR.puts "Unable to decode image (stream #{stream.reference.refno}). #{$!.message}"
+                STDERR.puts $!.backtrace.join($/)
+            end
+        end
+
+        puts "Extracted #{nimages} images to '#{image_dir}'."
+    end
+
+rescue
+    STDERR.puts $!.backtrace.join($/)
+    abort "#{$!.class}: #{$!.message}"
+end