origamindee 3.0.0

data/test/test_pdf_parse.rb

@@ -0,0 +1,134 @@
+require 'minitest/autorun'
+
+class TestPDFParser < Minitest::Test
+    def setup
+        @files =
+            %w{
+              dataset/empty.pdf
+              dataset/calc.pdf
+              dataset/crypto.pdf
+              }
+    end
+
+    def test_parse_pdf
+        @files.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("<</Ref 2 0 R/N null/Pi 3.14 /D <<>>>>")
+
+        assert_instance_of Dictionary, dict
+        assert_instance_of Dictionary, dict[:D]
+        assert_instance_of Null, dict[:N]
+        assert_instance_of Reference, dict[:Ref]
+        assert_equal dict.size, 4
+        assert_raises(InvalidReferenceError) { dict[:Ref].solve }
+        assert dict[:Pi] == 3.14
+    end
+
+    def test_parse_array
+        array = Origami::Array.parse("[/Test (abc) .2 \n 799 [<<>>]]")
+
+        assert array.all?{|e| e.is_a?(Origami::Object)}
+        assert_equal array.length, 5
+        assert_raises(InvalidArrayObjectError) { Origami::Array.parse("[1 ") }
+        assert_raises(InvalidArrayObjectError) { Origami::Array.parse("") }
+    end
+
+    def test_parse_string
+        str = LiteralString.parse("(\\122\\125by\\n)")
+        assert_instance_of LiteralString, str
+        assert_equal str.value, "RUby\n"
+
+        assert_raises(InvalidLiteralStringObjectError) { LiteralString.parse("") }
+        assert_raises(InvalidLiteralStringObjectError) { LiteralString.parse("(test") }
+        assert_equal "((O))", LiteralString.parse("(((O)))").value
+        assert_equal LiteralString.parse("(ABC\\\nDEF\\\r\nGHI)").value, "ABCDEFGHI"
+        assert_equal LiteralString.parse('(\r\n\b\t\f\\(\\)\\x\\\\)').value, "\r\n\b\t\f()x\\"
+        assert_equal LiteralString.parse('(\r\n\b\t\f\\\\\\(\\))').to_s, '(\r\n\b\t\f\\\\\\(\\))'
+
+        str = HexaString.parse("<52  55  62 79 0A>")
+        assert_instance_of HexaString, str
+        assert_equal str.value, "RUby\n"
+
+        assert_equal HexaString.parse("<4>").value, 0x40.chr
+
+        assert_raises(InvalidHexaStringObjectError) { HexaString.parse("") }
+        assert_raises(InvalidHexaStringObjectError) { HexaString.parse("<12") }
+        assert_raises(InvalidHexaStringObjectError) { HexaString.parse("<12X>") }
+    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?
+        refute b_true.false?
+
+        assert_raises(InvalidBooleanObjectError) { Boolean.parse("") }
+        assert_raises(InvalidBooleanObjectError) { Boolean.parse("tru") }
+    end
+
+    def test_parse_real
+        real = Real.parse("-3.141592653")
+        assert_instance_of Real, real
+        assert_equal real, -3.141592653
+
+        real = Real.parse("+.00200")
+        assert_instance_of Real, real
+        assert_equal real, 0.002
+
+        assert_raises(InvalidRealObjectError) { Real.parse("") }
+        assert_raises(InvalidRealObjectError) { Real.parse(".") }
+        assert_raises(InvalidRealObjectError) { Real.parse("+0x1") }
+    end
+
+    def test_parse_int
+        int = Origami::Integer.parse("02000000000000")
+        assert_instance_of Origami::Integer, int
+        assert_equal int, 2000000000000
+
+        int = Origami::Integer.parse("-98")
+        assert_instance_of Origami::Integer, int
+        assert_equal int, -98
+
+        assert_raises(Origami::InvalidIntegerObjectError) { Origami::Integer.parse("") }
+        assert_raises(Origami::InvalidIntegerObjectError) { Origami::Integer.parse("+-1") }
+        assert_raises(Origami::InvalidIntegerObjectError) { Origami::Integer.parse("ABC") }
+    end
+
+    def test_parse_name
+        name = Name.parse("/#52#55#62#79#0A")
+        assert_instance_of Name, name
+        assert_equal name.value, :"RUby\n"
+
+        name = Name.parse("/")
+        assert_instance_of Name, name
+        assert_equal :"", name.value
+
+        assert_raises(Origami::InvalidNameObjectError) { Name.parse("") }
+        assert_raises(Origami::InvalidNameObjectError) { Name.parse("test") }
+    end
+
+    def test_parse_reference
+        ref = Reference.parse("199 1 R")
+        assert_instance_of Reference, ref
+
+        assert_equal [199, 1], ref.to_a
+        assert_raises(InvalidReferenceError) { ref.solve }
+        assert_raises(InvalidReferenceError) { Reference.parse("-2 0 R") }
+        assert_raises(InvalidReferenceError) { Reference.parse("0 R") }
+        assert_raises(InvalidReferenceError) { Reference.parse("") }
+    end
+end

data/test/test_pdf_parse_lazy.rb

@@ -0,0 +1,69 @@
+require 'minitest/autorun'
+require 'stringio'
+
+class TestPDFLazyParser < Minitest::Test
+
+    def setup
+        @files = 
+            %w{
+              dataset/empty.pdf
+              dataset/calc.pdf
+              dataset/crypto.pdf
+              }
+
+    end
+
+    def test_parse_pdf_lazy
+        @files.each do |file|
+            pdf = PDF.read(File.join(__dir__, file), 
+                           ignore_errors: false,
+                           lazy: true,
+                           verbosity: Parser::VERBOSE_QUIET)
+
+            assert_instance_of PDF, pdf
+
+            pdf.each_object do |object|
+                assert_kind_of Origami::Object, object
+            end
+
+            assert_instance_of Catalog, pdf.Catalog
+
+            pdf.each_page do |page|
+                assert_kind_of Page, page
+            end
+        end
+    end
+
+    def test_save_pdf_lazy
+        @files.each do |file|
+            pdf = PDF.read(File.join(__dir__, file), 
+                           ignore_errors: false,
+                           lazy: true,
+                           verbosity: Parser::VERBOSE_QUIET)
+
+            pdf.save(StringIO.new)
+        end
+    end
+
+    def test_random_access
+        io = StringIO.new
+        stream = Stream.new("abc")
+
+        PDF.create(io) do |pdf|
+            pdf.insert(stream)
+        end
+
+        io = io.reopen(io.string, 'r')
+
+        pdf = PDF.read(io, ignore_errors: false,
+                           lazy: true,
+                           verbosity: Parser::VERBOSE_QUIET)
+
+        non_existent = pdf[42]
+        existent = pdf[stream.reference]
+
+        assert_nil non_existent
+        assert_instance_of Stream, existent
+        assert_equal stream.data, existent.data
+    end
+end

data/test/test_pdf_sign.rb

@@ -0,0 +1,97 @@
+require 'minitest/autorun'
+require 'stringio'
+require 'openssl'
+
+class TestSign < Minitest::Test
+
+    def create_self_signed_ca_certificate(key_size, expires)
+        key = OpenSSL::PKey::RSA.new key_size
+
+        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 + expires
+
+        cert.public_key = key.public_key
+        cert.subject = name
+
+        extension_factory = OpenSSL::X509::ExtensionFactory.new
+        extension_factory.issuer_certificate = cert
+        extension_factory.subject_certificate = cert
+
+        cert.add_extension extension_factory.create_extension('basicConstraints', 'CA:TRUE', true)
+        cert.add_extension extension_factory.create_extension('keyUsage', 'digitalSignature,keyCertSign')
+        cert.add_extension extension_factory.create_extension('subjectKeyIdentifier', 'hash')
+
+        cert.issuer = name
+        cert.sign key, OpenSSL::Digest::SHA256.new
+
+        [ cert, key ]
+    end
+
+    def setup
+        @cert, @key = create_self_signed_ca_certificate(1024, 3600)
+        @other_cert, @other_key = create_self_signed_ca_certificate(1024, 3600)
+    end
+
+    def setup_document_with_annotation
+        document = PDF.read(File.join(__dir__, "dataset/calc.pdf"),
+                           ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+
+        annotation = Annotation::Widget::Signature.new.set_indirect(true)
+        annotation.Rect = Rectangle[llx: 89.0, lly: 386.0, urx: 190.0, ury: 353.0]
+
+        document.append_page do |page|
+            page.add_annotation(annotation)
+        end
+
+        [ document, annotation ]
+    end
+
+    def sign_document_with_method(method)
+        document, annotation = setup_document_with_annotation
+
+        document.sign(@cert, @key,
+            method: method,
+            annotation: annotation,
+            issuer: "Guillaume Delugré",
+            location: "France",
+            contact: "origami@localhost",
+            reason: "Example"
+        )
+
+        assert document.frozen?
+        assert document.signed?
+
+        output = StringIO.new
+        document.save(output)
+
+        document = PDF.read(output.reopen(output.string,'r'), verbosity: Parser::VERBOSE_QUIET)
+
+        refute document.verify
+        assert document.verify(allow_self_signed: true)
+        assert document.verify(trusted_certs: [@cert])
+        refute document.verify(trusted_certs: [@other_cert])
+
+        result = document.verify do |ctx|
+            ctx.error == OpenSSL::X509::V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT and ctx.current_cert.to_pem == @cert.to_pem
+        end
+
+        assert result
+    end
+
+    def test_sign_pkcs7_sha1
+        sign_document_with_method(Signature::PKCS7_SHA1)
+    end
+
+    def test_sign_pkcs7_detached
+        sign_document_with_method(Signature::PKCS7_DETACHED)
+    end
+
+    def test_sign_x509_sha1
+        sign_document_with_method(Signature::PKCS1_RSA_SHA1)
+    end
+end

data/test/test_streams.rb

@@ -0,0 +1,184 @@
+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
+
+        assert_equal Filter::Flate.decode(Filter::Flate.encode("")), ""
+    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(Filter::ASCIIHex.encode("")), ""
+    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(Filter::ASCII85.encode("")), ""
+    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(Filter::RunLength.encode("")), ""
+    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(Filter::LZW.encode("")), ""
+    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(Filter::CCITTFax.encode("")), ""
+    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?(XRefToCompressedObject) }
+
+        pdf.each_object(compressed: true) do |object|
+            xref = xrefstm.find(object.no)
+
+            if object.parent.is_a?(ObjectStream)
+                assert_instance_of XRefToCompressedObject, 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