origami 1.2.7 → 2.0.0

data/test/test_pdf_encrypt.rb

@@ -0,0 +1,95 @@
+require 'minitest/autorun'
+require 'stringio'
+
+class TestEncryption < Minitest::Test
+    def setup
+        @target = PDF.read(File.join(__dir__, "dataset/calc.pdf"),
+                           ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+        @output = StringIO.new
+    end
+
+    def test_encrypt_rc4_40b
+        @output.string = ""
+        @target.encrypt(cipher: 'rc4', key_size: 40).save(@output)
+    end
+
+    def test_encrypt_rc4_128b
+        @output.string = ""
+        @target.encrypt(cipher: 'rc4').save(@output)
+    end
+
+    def test_encrypt_aes_128b
+        @output.string = ""
+        @target.encrypt(cipher: 'aes').save(@output)
+    end
+
+    def test_decrypt_rc4_40b
+        @output.string = ""
+
+        pdf = PDF.new.encrypt(cipher: 'rc4', key_size: 40)
+        pdf.Catalog[:Test] = "test"
+        pdf.save(@output)
+
+        refute_equal pdf.Catalog[:Test], "test"
+
+        @output = @output.reopen(@output.string, "r")
+        pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+
+        assert_equal pdf.Catalog[:Test], "test"
+    end
+
+    def test_decrypt_rc4_128b
+        @output.string = ""
+        pdf = PDF.new.encrypt(cipher: 'rc4')
+        pdf.Catalog[:Test] = "test"
+        pdf.save(@output)
+
+        refute_equal pdf.Catalog[:Test], "test"
+
+        @output.reopen(@output.string, "r")
+        pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+
+        assert_equal pdf.Catalog[:Test], "test"
+    end
+
+    def test_decrypt_aes_128b
+        @output.string = ""
+        pdf = PDF.new.encrypt(cipher: 'aes')
+        pdf.Catalog[:Test] = "test"
+        pdf.save(@output)
+
+        refute_equal pdf.Catalog[:Test], "test"
+
+        @output = @output.reopen(@output.string, "r")
+        pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+
+        assert_equal pdf.Catalog[:Test], "test"
+    end
+
+    def test_decrypt_aes_256b
+        @output.string = ""
+        pdf = PDF.new.encrypt(cipher: 'aes', key_size: 256)
+        pdf.Catalog[:Test] = "test"
+        pdf.save(@output)
+
+        refute_equal pdf.Catalog[:Test], "test"
+
+        @output = @output.reopen(@output.string, "r")
+        pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+
+        assert_equal pdf.Catalog[:Test], "test"
+    end
+
+    def test_crypt_filter
+        @output.string = ""
+        pdf = PDF.new.encrypt(cipher: 'aes', key_size: 128)
+
+        pdf.Catalog[:S1] = Stream.new("test", :Filter => :Crypt)
+        pdf.Catalog[:S2] = Stream.new("test")
+
+        pdf.save(@output)
+
+        assert_equal pdf.Catalog.S1.encoded_data, "test"
+        refute_equal pdf.Catalog.S2.encoded_data, "test"
+    end
+end

data/test/test_pdf_parse.rb

@@ -0,0 +1,96 @@
+require 'minitest/autorun'
+
+class TestPDFParser < Minitest::Test
+    def setup
+        @data =
+            %w{
+              dataset/empty.pdf
+              dataset/calc.pdf
+              dataset/crypto.pdf
+              }
+
+        @dict = StringScanner.new "<</Ref 2 0 R/N null/Pi 3.14 /D <<>>>>"
+
+        @literalstring = StringScanner.new "(\\122\\125by\\n)"
+        @hexastring = StringScanner.new "<52  55  62 79 0A>"
+        @true = StringScanner.new "true"
+        @false = StringScanner.new "false"
+        @real = StringScanner.new "-3.141592653"
+        @int = StringScanner.new "00000000002000000000000"
+        @name = StringScanner.new "/#52#55#62#79#0A"
+        @ref = StringScanner.new "199 1 R"
+    end
+
+    def test_parse_pdf
+        @data.each do |file|
+            pdf = PDF.read(File.join(__dir__, file), ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+
+            assert_instance_of PDF, pdf
+
+            pdf.each_object do |object|
+                assert_kind_of Origami::Object, object
+            end
+        end
+    end
+
+    def test_parse_dictionary
+        dict = Dictionary.parse(@dict)
+
+        assert_instance_of Dictionary, dict
+        assert_instance_of Dictionary, dict[:D]
+        assert_instance_of Null, dict[:N]
+        assert_instance_of Reference, dict[:Ref]
+        assert_raises(InvalidReferenceError) { dict[:Ref].solve }
+        assert dict[:Pi] == 3.14
+    end
+
+    def test_parse_string
+        str = LiteralString.parse(@literalstring)
+        assert_instance_of LiteralString, str
+        assert_equal str.value, "RUby\n"
+
+        str = HexaString.parse(@hexastring)
+        assert_instance_of HexaString, str
+        assert_equal str.value, "RUby\n"
+    end
+
+    def test_parse_bool
+        b_true = Boolean.parse(@true)
+        b_false = Boolean.parse(@false)
+
+        assert_instance_of Boolean, b_true
+        assert_instance_of Boolean, b_false
+
+        assert b_false.false?
+        assert (not b_true.false?)
+    end
+
+    def test_parse_real
+        real = Real.parse(@real)
+        assert_instance_of Real, real
+
+        assert_equal real, -3.141592653
+    end
+
+    def test_parse_int
+        int = Origami::Integer.parse(@int)
+        assert_instance_of Origami::Integer, int
+
+        assert_equal int, 2000000000000
+    end
+
+    def test_parse_name
+        name = Name.parse(@name)
+        assert_instance_of Name, name
+
+        assert_equal name.value, :"RUby\n"
+    end
+
+    def test_parse_reference
+        ref = Reference.parse(@ref)
+        assert_instance_of Reference, ref
+
+        assert_equal [199, 1], ref.to_a
+        assert_raises(InvalidReferenceError) { ref.solve }
+    end
+end

data/test/test_pdf_sign.rb

@@ -0,0 +1,58 @@
+require 'minitest/autorun'
+require 'stringio'
+require 'openssl'
+
+class TestSign < Minitest::Test
+
+    def setup
+        @target = PDF.read(File.join(__dir__, "dataset/calc.pdf"),
+                           ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+        @output = StringIO.new
+
+        @key = OpenSSL::PKey::RSA.new 2048
+
+        name = OpenSSL::X509::Name.parse 'CN=origami/DC=example'
+
+        @cert = OpenSSL::X509::Certificate.new
+        @cert.version = 2
+        @cert.serial = 0
+        @cert.not_before = Time.now
+        @cert.not_after = Time.now + 3600
+
+        @cert.public_key = @key.public_key
+        @cert.subject = name
+
+        extension_factory = OpenSSL::X509::ExtensionFactory.new nil, @cert
+
+        @cert.add_extension extension_factory.create_extension('basicConstraints', 'CA:TRUE', true)
+        @cert.add_extension extension_factory.create_extension('keyUsage', 'digitalSignature')
+        @cert.add_extension extension_factory.create_extension('subjectKeyIdentifier', 'hash')
+
+        @cert.issuer = name
+        @cert.sign @key, OpenSSL::Digest::SHA256.new
+    end
+
+    def test_sign
+        sig_annot = Annotation::Widget::Signature.new.set_indirect(true)
+        sig_annot.Rect = Rectangle[llx: 89.0, lly: 386.0, urx: 190.0, ury: 353.0]
+
+        @target.append_page do |page|
+            page.add_annotation(sig_annot)
+        end
+
+        @target.sign(@cert, @key,
+            annotation: sig_annot,
+            issuer: "Guillaume Delugré",
+            location: "France",
+            contact: "origami@localhost",
+            reason: "Example"
+        )
+
+        assert @target.frozen?
+        assert @target.signed?
+
+        @target.save(@output)
+
+        assert PDF.read(@output.reopen(@output.string,'r'), verbosity: Parser::VERBOSE_QUIET).verify
+    end
+end

data/test/test_streams.rb

@@ -0,0 +1,182 @@
+require 'minitest/autorun'
+require 'stringio'
+
+class TestStreams < Minitest::Test
+    def setup
+        @target = PDF.new
+        @output = StringIO.new
+        @data = "0123456789" * 1024
+    end
+
+    def test_predictors
+        stm = Stream.new(@data, :Filter => :FlateDecode)
+        stm.set_predictor(Filter::Predictor::TIFF)
+        raw = stm.encoded_data
+        stm.data = nil
+        stm.encoded_data = raw
+
+        assert_equal @data, stm.data
+
+        stm = Stream.new(@data, :Filter => :FlateDecode)
+        stm.set_predictor(Filter::Predictor::PNG_SUB)
+        raw = stm.encoded_data
+        stm.data = nil
+        stm.encoded_data = raw
+
+        assert_equal @data, stm.data
+
+        stm = Stream.new(@data, :Filter => :FlateDecode)
+        stm.set_predictor(Filter::Predictor::PNG_UP)
+        raw = stm.encoded_data
+        stm.data = nil
+        stm.encoded_data = raw
+
+        assert_equal stm.data, @data
+
+        stm = Stream.new(@data, :Filter => :FlateDecode)
+        stm.set_predictor(Filter::Predictor::PNG_AVERAGE)
+        raw = stm.encoded_data
+        stm.data = nil
+        stm.encoded_data = raw
+
+        assert_equal stm.data, @data
+
+        stm = Stream.new(@data, :Filter => :FlateDecode)
+        stm.set_predictor(Filter::Predictor::PNG_PAETH)
+        raw = stm.encoded_data
+        stm.data = nil
+        stm.encoded_data = raw
+
+        assert_equal stm.data, @data
+    end
+
+    def test_filter_flate
+        stm = Stream.new(@data, :Filter => :FlateDecode)
+        raw = stm.encoded_data
+        stm.data = nil
+        stm.encoded_data = raw
+
+        assert_equal stm.data, @data
+    end
+
+    def test_filter_asciihex
+        stm = Stream.new(@data, :Filter => :ASCIIHexDecode)
+        raw = stm.encoded_data
+        stm.data = nil
+        stm.encoded_data = raw
+
+        assert_equal stm.data, @data
+
+        assert_raises(Filter::InvalidASCIIHexStringError) do
+            Filter::ASCIIHex.decode("123456789ABCDEFGHIJKL")
+        end
+
+        assert_equal Filter::ASCIIHex.decode(""), ""
+    end
+
+    def test_filter_ascii85
+        stm = Stream.new(@data, :Filter => :ASCII85Decode)
+        raw = stm.encoded_data
+        stm.data = nil
+        stm.encoded_data = raw
+
+        assert_equal stm.data, @data
+
+        assert_raises(Filter::InvalidASCII85StringError) do
+            Filter::ASCII85.decode("ABCD\x01")
+        end
+
+        assert_equal Filter::ASCII85.decode(""), ""
+    end
+
+    def test_filter_rle
+        stm = Stream.new(@data, :Filter => :RunLengthDecode)
+        raw = stm.encoded_data
+        stm.data = nil
+        stm.encoded_data = raw
+
+        assert_equal stm.data, @data
+
+        assert_raises(Filter::InvalidRunLengthDataError) do
+            Filter::RunLength.decode("\x7f")
+        end
+
+        assert_equal Filter::RunLength.decode(""), ""
+    end
+
+    def test_filter_lzw
+        stm = Stream.new(@data, :Filter => :LZWDecode)
+        raw = stm.encoded_data
+        stm.data = nil
+        stm.encoded_data = raw
+
+        assert_equal stm.data, @data
+
+        assert_raises(Filter::InvalidLZWDataError) do
+            Filter::LZW.decode("abcd")
+        end
+
+        assert_equal Filter::LZW.decode(""), ""
+    end
+
+    def test_filter_ccittfax
+        stm = Stream.new(@data[0, 216], :Filter => :CCITTFaxDecode)
+
+        raw = stm.encoded_data
+        stm.data = nil
+        stm.encoded_data = raw
+
+        assert_equal stm.data, @data[0, 216]
+
+        assert_raises(Filter::InvalidCCITTFaxDataError) do
+            Filter::CCITTFax.decode("abcd")
+        end
+
+        assert_equal Filter::CCITTFax.decode(""), ""
+    end
+
+    def test_stream
+        chain = %i[FlateDecode LZWDecode ASCIIHexDecode]
+
+        stm = Stream.new(@data, Filter: chain)
+        @target << stm
+        @target.save(@output)
+
+        assert stm.Length == stm.encoded_data.length
+        assert_equal stm.filters, chain
+        assert_equal stm.data, @data
+    end
+
+    def test_object_stream
+        objstm = ObjectStream.new
+        objstm.Filter = %i[FlateDecode ASCIIHexDecode RunLengthDecode]
+
+        @target << objstm
+
+        assert_raises(InvalidObjectError) do
+            objstm.insert Stream.new
+        end
+
+        3.times do
+            objstm.insert HexaString.new(@data)
+        end
+
+        assert_equal objstm.objects.size, 3
+
+        objstm.each_object do |object|
+            assert_instance_of HexaString, object
+            assert_equal object.parent, objstm
+            assert objstm.include?(object.no)
+            assert_equal objstm.extract(object.no), object
+            assert_equal objstm.extract_by_index(objstm.index(object.no)), object
+        end
+
+        objstm.delete(objstm.objects.first.no)
+        assert_equal objstm.objects.size, 2
+
+        @target.save(@output)
+
+        assert_instance_of Origami::Integer, objstm.N
+        assert_equal objstm.N, objstm.objects.size
+    end
+end

data/test/test_xrefs.rb

@@ -0,0 +1,67 @@
+require 'minitest/autorun'
+require 'stringio'
+require 'strscan'
+
+class TestXrefs < MiniTest::Test
+
+    def setup
+        @target = PDF.new
+    end
+
+    def test_xreftable
+        output = StringIO.new
+
+        @target.save(output)
+        output.reopen(output.string, 'r')
+
+        pdf = PDF.read(output, verbosity: Parser::VERBOSE_QUIET, ignore_errors: false)
+
+        xreftable = pdf.revisions.last.xreftable
+        assert_instance_of XRef::Section, xreftable
+
+        pdf.root_objects.each do |object|
+            xref = xreftable.find(object.no)
+
+            assert_instance_of XRef, xref
+            assert xref.used?
+
+            assert_equal xref.offset, object.file_offset
+        end
+    end
+
+    def test_xrefstream
+        output = StringIO.new
+        objstm = ObjectStream.new
+        objstm.Filter = :FlateDecode
+
+        @target.insert objstm
+
+        3.times do
+            objstm.insert Null.new
+        end
+
+        @target.save(output)
+        output = output.reopen(output.string, 'r')
+
+        pdf = PDF.read(output, verbosity: Parser::VERBOSE_QUIET, ignore_errors: false)
+        xrefstm = pdf.revisions.last.xrefstm
+
+        assert_instance_of XRefStream, xrefstm
+        assert xrefstm.entries.all?{ |xref| xref.is_a?(XRef) or xref.is_a?(XRefToCompressedObj) }
+
+        pdf.each_object(compressed: true) do |object|
+            xref = xrefstm.find(object.no)
+
+            if object.parent.is_a?(ObjectStream)
+                assert_instance_of XRefToCompressedObj, xref
+                assert_equal xref.objstmno, object.parent.no
+                assert_equal xref.index, object.parent.index(object.no)
+            else
+                assert_instance_of XRef, xref
+                assert_equal xref.offset, object.file_offset
+            end
+        end
+
+        assert_instance_of Catalog, xrefstm.Root
+    end
+end