mirror of
https://github.com/unidoc/unipdf.git
synced 2025-04-26 13:48:55 +08:00
1578 lines
39 KiB
Go
1578 lines
39 KiB
Go
/*
|
|
* This file is subject to the terms and conditions defined in
|
|
* file 'LICENSE.md', which is part of this source code package.
|
|
*/
|
|
|
|
package model_test
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/rsa"
|
|
"errors"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
"golang.org/x/crypto/pkcs12"
|
|
|
|
"github.com/unidoc/unipdf/v3/common"
|
|
"github.com/unidoc/unipdf/v3/annotator"
|
|
"github.com/unidoc/unipdf/v3/core"
|
|
"github.com/unidoc/unipdf/v3/model"
|
|
"github.com/unidoc/unipdf/v3/model/sighandler"
|
|
)
|
|
|
|
// This test file contains multiple tests to generate PDFs from existing Pdf files. The outputs are written
|
|
// into TMPDIR as files. The files themselves need to be observed to check for correctness as we don't have
|
|
// a good way to automatically check if every detail is correct.
|
|
|
|
func init() {
|
|
common.SetLogger(common.NewConsoleLogger(common.LogLevelDebug))
|
|
}
|
|
|
|
const testPdfFile1 = "./testdata/minimal.pdf"
|
|
const testPdfLoremIpsumFile = "./testdata/lorem.pdf"
|
|
const testPdf3pages = "./testdata/pages3.pdf"
|
|
|
|
const imgPdfFile1 = "./testdata/img1-1.pdf"
|
|
const imgPdfFile2 = "./testdata/img1-2.pdf"
|
|
|
|
// source http://foersom.com/net/HowTo/data/OoPdfFormExample.pdf
|
|
const testPdfAcroFormFile1 = "./testdata/OoPdfFormExample.pdf"
|
|
|
|
const testPdfSignedPDFDocument = "./testdata/SampleSignedPDFDocument.pdf"
|
|
|
|
const testPKS12Key = "./testdata/certificate.p12"
|
|
const testPKS12KeyPassword = "password"
|
|
|
|
func tempFile(name string) string {
|
|
return filepath.Join(os.TempDir(), name)
|
|
}
|
|
|
|
// Appender with no data added should output an equivalent file.
|
|
func TestAppenderNoop(t *testing.T) {
|
|
f, err := os.Open("./testdata/minimal.pdf")
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
|
|
appender, err := model.NewPdfAppender(reader)
|
|
require.NoError(t, err)
|
|
|
|
model.SetPdfProducer("UniPDF")
|
|
model.SetPdfCreator("UniDoc UniPDF")
|
|
err = appender.WriteToFile(tempFile("appender_noop.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// The first part of the appended file should be same as in the original.
|
|
minimal, err := ioutil.ReadFile("./testdata/minimal.pdf")
|
|
require.NoError(t, err)
|
|
out, err := ioutil.ReadFile(tempFile("appender_noop.pdf"))
|
|
require.NoError(t, err)
|
|
require.Equal(t, minimal, out[0:len(minimal)])
|
|
|
|
origReader := reader
|
|
origObjNums := origReader.GetObjectNums()
|
|
require.Equal(t, []int{1, 2, 3, 4}, origObjNums)
|
|
|
|
// Check cross references table of original.
|
|
page, err := origReader.GetPage(1)
|
|
require.NoError(t, err)
|
|
origParser := page.GetPageAsIndirectObject().GetParser()
|
|
origXref := origParser.GetXrefTable()
|
|
expected := map[int]core.XrefObject{
|
|
1: core.XrefObject{ObjectNumber: 1, XType: 0, Offset: 18},
|
|
2: core.XrefObject{ObjectNumber: 2, XType: 0, Offset: 77},
|
|
3: core.XrefObject{ObjectNumber: 3, XType: 0, Offset: 178},
|
|
4: core.XrefObject{ObjectNumber: 4, XType: 0, Offset: 457},
|
|
}
|
|
require.Equal(t, expected, origXref.ObjectMap)
|
|
|
|
// Check the output.
|
|
{
|
|
f, err := os.Open(tempFile("appender_noop.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
|
|
objNums := reader.GetObjectNums()
|
|
|
|
// Number of objects should be equal.
|
|
// The appended version should only add 2 objects (new Info and Catalog).
|
|
require.Equal(t, len(origObjNums)+2, len(objNums))
|
|
require.Equal(t, []int{1, 2, 3, 4, 5, 6}, objNums)
|
|
|
|
// Check cross references table of appended version.
|
|
page, err := reader.GetPage(1)
|
|
require.NoError(t, err)
|
|
parser := page.GetPageAsIndirectObject().GetParser()
|
|
xrefs := parser.GetXrefTable()
|
|
expected := map[int]core.XrefObject{
|
|
1: core.XrefObject{ObjectNumber: 1, XType: 0, Offset: 18},
|
|
2: core.XrefObject{ObjectNumber: 2, XType: 0, Offset: 77},
|
|
3: core.XrefObject{ObjectNumber: 3, XType: 0, Offset: 178},
|
|
4: core.XrefObject{ObjectNumber: 4, XType: 0, Offset: 457},
|
|
5: core.XrefObject{ObjectNumber: 5, XType: 0, Offset: 740},
|
|
6: core.XrefObject{ObjectNumber: 6, XType: 0, Offset: 802},
|
|
}
|
|
require.Equal(t, expected, xrefs.ObjectMap)
|
|
}
|
|
}
|
|
|
|
func TestAppenderRemovePage(t *testing.T) {
|
|
f, err := os.Open(testPdf3pages)
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
|
|
appender, err := model.NewPdfAppender(reader)
|
|
require.NoError(t, err)
|
|
|
|
appender.RemovePage(1)
|
|
appender.RemovePage(2)
|
|
|
|
err = appender.WriteToFile(tempFile("appender_remove_page_1.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
origReader := reader
|
|
origObjNums := origReader.GetObjectNums()
|
|
|
|
// Check the output.
|
|
{
|
|
f, err := os.Open(tempFile("appender_remove_page_1.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
|
|
objNums := reader.GetObjectNums()
|
|
|
|
// Number of objects should be equal.
|
|
// The appended version should only add 2 objects (new Info and Catalog).
|
|
require.Equal(t, len(origObjNums)+2, len(objNums))
|
|
|
|
obj2, err := reader.GetIndirectObjectByNumber(2)
|
|
require.NoError(t, err)
|
|
|
|
pagesDict, ok := core.GetDict(obj2)
|
|
require.True(t, ok)
|
|
|
|
kidsArr, ok := core.GetArray(pagesDict.Get("Kids"))
|
|
require.True(t, ok)
|
|
require.Len(t, kidsArr.Elements(), 1)
|
|
}
|
|
}
|
|
|
|
func TestAppenderReplacePage(t *testing.T) {
|
|
f1, err := os.Open(testPdf3pages)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f1.Close()
|
|
pdf1, err := model.NewPdfReader(f1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
f2, err := os.Open(testPdfFile1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f2.Close()
|
|
pdf2, err := model.NewPdfReader(f2)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
appender, err := model.NewPdfAppender(pdf1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// if the page is already in the same file, expect that the Pages object is only updated
|
|
appender.ReplacePage(1, pdf1.PageList[1])
|
|
appender.ReplacePage(3, pdf2.PageList[0])
|
|
|
|
err = appender.WriteToFile(tempFile("appender_replace_page_1.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
origReader := pdf1
|
|
origObjNums := origReader.GetObjectNums()
|
|
|
|
// Check the output.
|
|
{
|
|
f, err := os.Open(tempFile("appender_replace_page_1.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
|
|
objNums := reader.GetObjectNums()
|
|
|
|
// Number of objects should be equal.
|
|
// The appended version adds 8 new objects: Related to the new page and new Info, Catalog, Pages.
|
|
// As well as updating some previous objects.
|
|
// TODO: Check specifically the xrefs table regarding updates, new objects etc.
|
|
require.Equal(t, len(origObjNums)+9, len(objNums))
|
|
|
|
obj2, err := reader.GetIndirectObjectByNumber(2)
|
|
require.NoError(t, err)
|
|
|
|
pagesDict, ok := core.GetDict(obj2)
|
|
require.True(t, ok)
|
|
|
|
kidsArr, ok := core.GetArray(pagesDict.Get("Kids"))
|
|
require.True(t, ok)
|
|
require.Len(t, kidsArr.Elements(), 3)
|
|
|
|
// The first page is a copy of the second one. And the third one is from another file.
|
|
// All new objects.
|
|
require.Equal(t, "[IObject:39, IObject:21, IObject:42]", kidsArr.String())
|
|
}
|
|
}
|
|
|
|
func TestAppenderAddAnnotation(t *testing.T) {
|
|
f1, err := os.Open(testPdf3pages)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f1.Close()
|
|
pdf1, err := model.NewPdfReader(f1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
appender, err := model.NewPdfAppender(pdf1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
page := pdf1.PageList[0]
|
|
annotation := model.NewPdfAnnotationSquare()
|
|
rect := model.PdfRectangle{Ury: 250.0, Urx: 150.0, Lly: 50.0, Llx: 50.0}
|
|
annotation.Rect = rect.ToPdfObject()
|
|
annotation.IC = core.MakeArrayFromFloats([]float64{4.0, 0.0, 0.3})
|
|
annotation.CA = core.MakeFloat(0.5)
|
|
|
|
page.AddAnnotation(annotation.PdfAnnotation)
|
|
|
|
//appender.ReplacePage(1, page)
|
|
appender.UpdatePage(page)
|
|
|
|
err = appender.WriteToFile(tempFile("appender_add_annotation_1.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// Check the output.
|
|
{
|
|
f, err := os.Open(tempFile("appender_add_annotation_1.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, reader)
|
|
require.Nil(t, reader.AcroForm)
|
|
|
|
page, err := reader.GetPage(1)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, page.Annots)
|
|
|
|
annots, err := page.GetAnnotations()
|
|
require.NoError(t, err)
|
|
require.NotNil(t, annots)
|
|
require.Len(t, annots, 1)
|
|
}
|
|
}
|
|
|
|
// Append annotation to page which already has annotations.
|
|
func TestAppenderAddAnnotation2(t *testing.T) {
|
|
f1, err := os.Open("testdata/OoPdfFormExample.pdf")
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f1.Close()
|
|
pdf1, err := model.NewPdfReader(f1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
appender, err := model.NewPdfAppender(pdf1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
page := pdf1.PageList[0]
|
|
annotation := model.NewPdfAnnotationSquare()
|
|
rect := model.PdfRectangle{Ury: 250.0, Urx: 150.0, Lly: 50.0, Llx: 50.0}
|
|
annotation.Rect = rect.ToPdfObject()
|
|
annotation.IC = core.MakeArrayFromFloats([]float64{4.0, 0.0, 0.3})
|
|
annotation.CA = core.MakeFloat(0.5)
|
|
|
|
page.AddAnnotation(annotation.PdfAnnotation)
|
|
|
|
appender.UpdatePage(page)
|
|
|
|
err = appender.WriteToFile(tempFile("appender_add_annotation_2.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// Check the output.
|
|
{
|
|
f, err := os.Open(tempFile("appender_add_annotation_2.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, reader)
|
|
require.NotNil(t, reader.AcroForm)
|
|
|
|
require.Len(t, reader.AcroForm.AllFields(), 17)
|
|
}
|
|
}
|
|
|
|
// Implements example H.7 Updating example (PDF32000_2008).
|
|
// The original file is the minimal pdf file (H.2). The updates are in 4 stages with the file saved after
|
|
// each stage:
|
|
// a) Four text annotations are added.
|
|
// b) The text of one of the annotations is altered.
|
|
// c) Two of the text annotations are deleted.
|
|
// d) Three text annotations are added.
|
|
func TestAppenderUpdatingExample(t *testing.T) {
|
|
stage1 := func() {
|
|
t.Logf("------- Stage 1")
|
|
f, err := os.Open("./testdata/minimal.pdf")
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
|
|
appender, err := model.NewPdfAppender(reader)
|
|
require.NoError(t, err)
|
|
|
|
// Stage 1: Add four text annotations.
|
|
annot1 := model.NewPdfAnnotationText()
|
|
annot1.Rect = core.MakeArrayFromIntegers([]int{44, 616, 162, 735})
|
|
annot1.Contents = core.MakeString("Text #1")
|
|
annot1.Open = core.MakeBool(true)
|
|
|
|
annot2 := model.NewPdfAnnotationText()
|
|
annot2.Rect = core.MakeArrayFromIntegers([]int{224, 668, 457, 735})
|
|
annot2.Contents = core.MakeString("Text #2")
|
|
annot2.Open = core.MakeBool(false)
|
|
|
|
annot3 := model.NewPdfAnnotationText()
|
|
annot3.Rect = core.MakeArrayFromIntegers([]int{293, 393, 328, 622})
|
|
annot3.Contents = core.MakeString("Text #3")
|
|
annot3.Open = core.MakeBool(true)
|
|
|
|
annot4 := model.NewPdfAnnotationText()
|
|
annot4.Rect = core.MakeArrayFromIntegers([]int{34, 398, 225, 575})
|
|
annot4.Contents = core.MakeString("Text #4")
|
|
annot4.Open = core.MakeBool(false)
|
|
|
|
page, err := reader.GetPage(1)
|
|
require.NoError(t, err)
|
|
|
|
page.AddAnnotation(annot1.PdfAnnotation)
|
|
page.AddAnnotation(annot2.PdfAnnotation)
|
|
page.AddAnnotation(annot3.PdfAnnotation)
|
|
page.AddAnnotation(annot4.PdfAnnotation)
|
|
|
|
appender.UpdatePage(page)
|
|
|
|
err = appender.WriteToFile(tempFile("appender_h7_stage1.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
}
|
|
stage1()
|
|
|
|
// Check the output of stage 1.
|
|
func() {
|
|
f, err := os.Open("./testdata/minimal.pdf")
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
origReader, err := model.NewPdfReader(f)
|
|
origObjNums := origReader.GetObjectNums()
|
|
|
|
f, err = os.Open(tempFile("appender_h7_stage1.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
|
|
objNums := reader.GetObjectNums()
|
|
|
|
// The new revision should contain:
|
|
// - Updated Page
|
|
// - 4 New annotation objects
|
|
// - New Info object (refrenced from the trailer).
|
|
// - New Catalog
|
|
require.Equal(t, len(origObjNums)+6, len(objNums))
|
|
|
|
// Check that the Pages object number is unchanged.
|
|
obj2, err := reader.GetIndirectObjectByNumber(2)
|
|
require.NoError(t, err)
|
|
|
|
pagesDict, ok := core.GetDict(obj2)
|
|
require.True(t, ok)
|
|
|
|
kidsArr, ok := core.GetArray(pagesDict.Get("Kids"))
|
|
require.True(t, ok)
|
|
require.Len(t, kidsArr.Elements(), 1)
|
|
require.Equal(t, "[IObject:3]", kidsArr.String())
|
|
}()
|
|
|
|
stage2 := func() {
|
|
t.Logf("------- Stage 2")
|
|
f, err := os.Open(tempFile("appender_h7_stage1.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
|
|
appender, err := model.NewPdfAppender(reader)
|
|
require.NoError(t, err)
|
|
|
|
page, err := reader.GetPage(1)
|
|
require.NoError(t, err)
|
|
|
|
annots, err := page.GetAnnotations()
|
|
require.NoError(t, err)
|
|
require.Len(t, annots, 4)
|
|
|
|
annot3 := annots[2]
|
|
annot3.Contents = core.MakeString("Modified Text #3")
|
|
|
|
appender.UpdateObject(annot3.GetContext().ToPdfObject())
|
|
|
|
err = appender.WriteToFile(tempFile("appender_h7_stage2.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
}
|
|
stage2()
|
|
// Check the output of stage 2.
|
|
func() {
|
|
f, err := os.Open(tempFile("appender_h7_stage1.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
origReader, err := model.NewPdfReader(f)
|
|
origObjNums := origReader.GetObjectNums()
|
|
|
|
f, err = os.Open(tempFile("appender_h7_stage2.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
|
|
objNums := reader.GetObjectNums()
|
|
|
|
// The new revision should contain:
|
|
// - Updated Annots object.
|
|
// - New Info
|
|
// - New Catalog
|
|
// - Updated Pages
|
|
// - No other changes
|
|
require.Equal(t, len(origObjNums)+2, len(objNums))
|
|
|
|
// Check that the Pages object number is unchanged.
|
|
obj2, err := reader.GetIndirectObjectByNumber(2)
|
|
require.NoError(t, err)
|
|
|
|
pagesDict, ok := core.GetDict(obj2)
|
|
require.True(t, ok)
|
|
|
|
kidsArr, ok := core.GetArray(pagesDict.Get("Kids"))
|
|
require.True(t, ok)
|
|
require.Len(t, kidsArr.Elements(), 1)
|
|
require.Equal(t, "[IObject:3]", kidsArr.String())
|
|
|
|
annots, err := reader.PageList[0].GetAnnotations()
|
|
require.NoError(t, err)
|
|
str, ok := core.GetString(annots[2].Contents)
|
|
require.True(t, ok)
|
|
require.Equal(t, "Modified Text #3", str.String())
|
|
textAnnot, ok := annots[2].GetContext().(*model.PdfAnnotationText)
|
|
require.True(t, ok)
|
|
open, ok := core.GetBool(textAnnot.Open)
|
|
require.True(t, ok)
|
|
require.Equal(t, "true", open.String())
|
|
}()
|
|
|
|
stage3 := func() {
|
|
t.Logf("------- Stage 3")
|
|
f, err := os.Open(tempFile("appender_h7_stage2.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
|
|
appender, err := model.NewPdfAppender(reader)
|
|
require.NoError(t, err)
|
|
|
|
page, err := reader.GetPage(1)
|
|
require.NoError(t, err)
|
|
|
|
annots, err := page.GetAnnotations()
|
|
require.NoError(t, err)
|
|
require.Len(t, annots, 4)
|
|
|
|
// Remove two annotations.
|
|
annots = annots[2:]
|
|
page.SetAnnotations(annots)
|
|
|
|
appender.UpdatePage(page)
|
|
|
|
err = appender.WriteToFile(tempFile("appender_h7_stage3.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
}
|
|
stage3()
|
|
// Check output of stage 3. Expected is just new Annots array + xrefs.
|
|
func() {
|
|
f, err := os.Open(tempFile("appender_h7_stage2.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
origReader, err := model.NewPdfReader(f)
|
|
origObjNums := origReader.GetObjectNums()
|
|
|
|
f, err = os.Open(tempFile("appender_h7_stage3.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
|
|
objNums := reader.GetObjectNums()
|
|
|
|
// The new revision should contain:
|
|
// - Updated Page object (including the Annots).
|
|
// - New Info
|
|
// - New Catalog
|
|
// - No other changes
|
|
require.Equal(t, len(origObjNums)+2, len(objNums))
|
|
|
|
// Check that the Pages object number is unchanged.
|
|
obj2, err := reader.GetIndirectObjectByNumber(2)
|
|
require.NoError(t, err)
|
|
|
|
pagesDict, ok := core.GetDict(obj2)
|
|
require.True(t, ok)
|
|
|
|
kidsArr, ok := core.GetArray(pagesDict.Get("Kids"))
|
|
require.True(t, ok)
|
|
require.Len(t, kidsArr.Elements(), 1)
|
|
require.Equal(t, "[IObject:3]", kidsArr.String())
|
|
|
|
annots, err := reader.PageList[0].GetAnnotations()
|
|
require.NoError(t, err)
|
|
require.Len(t, annots, 2)
|
|
}()
|
|
|
|
stage4 := func() {
|
|
t.Logf("------- Stage 4")
|
|
f, err := os.Open(tempFile("appender_h7_stage3.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
|
|
appender, err := model.NewPdfAppender(reader)
|
|
require.NoError(t, err)
|
|
|
|
// Stage 4: Add 3 new annotations.
|
|
newAnnot1 := model.NewPdfAnnotationText()
|
|
newAnnot1.Rect = core.MakeArrayFromIntegers([]int{58, 657, 172, 742})
|
|
newAnnot1.Contents = core.MakeString("New Text #1")
|
|
newAnnot1.Open = core.MakeBool(true)
|
|
|
|
newAnnot2 := model.NewPdfAnnotationText()
|
|
newAnnot2.Rect = core.MakeArrayFromIntegers([]int{389, 459, 570, 537})
|
|
newAnnot2.Contents = core.MakeString("New Text #2")
|
|
newAnnot2.Open = core.MakeBool(false)
|
|
|
|
newAnnot3 := model.NewPdfAnnotationText()
|
|
newAnnot3.Rect = core.MakeArrayFromIntegers([]int{44, 253, 473, 337})
|
|
newAnnot3.Contents = core.MakeString("New Text #3")
|
|
newAnnot3.Open = core.MakeBool(true)
|
|
|
|
page, err := reader.GetPage(1)
|
|
require.NoError(t, err)
|
|
|
|
page.AddAnnotation(newAnnot1.PdfAnnotation)
|
|
page.AddAnnotation(newAnnot2.PdfAnnotation)
|
|
page.AddAnnotation(newAnnot3.PdfAnnotation)
|
|
|
|
appender.UpdatePage(page)
|
|
|
|
err = appender.WriteToFile(tempFile("appender_h7_stage4.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
}
|
|
stage4()
|
|
|
|
// Check output of stage 4.
|
|
func() {
|
|
f, err := os.Open(tempFile("appender_h7_stage3.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
origReader, err := model.NewPdfReader(f)
|
|
origObjNums := origReader.GetObjectNums()
|
|
|
|
f, err = os.Open(tempFile("appender_h7_stage4.pdf"))
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
reader, err := model.NewPdfReader(f)
|
|
require.NoError(t, err)
|
|
|
|
objNums := reader.GetObjectNums()
|
|
|
|
// The new revision should contain:
|
|
// - Updated Page object (including the Annots).
|
|
// - New Info
|
|
// - New Catalog
|
|
// - 3 New Annots
|
|
// - No other changes
|
|
require.Equal(t, len(origObjNums)+5, len(objNums))
|
|
|
|
annots, err := reader.PageList[0].GetAnnotations()
|
|
require.NoError(t, err)
|
|
require.Len(t, annots, 5)
|
|
}()
|
|
}
|
|
|
|
func TestAppenderAddPage(t *testing.T) {
|
|
f1, err := os.Open(testPdfLoremIpsumFile)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f1.Close()
|
|
pdf1, err := model.NewPdfReader(f1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
f2, err := os.Open(testPdfFile1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f2.Close()
|
|
pdf2, err := model.NewPdfReader(f2)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
appender, err := model.NewPdfAppender(pdf1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
appender.AddPages(pdf1.PageList...)
|
|
|
|
appender.AddPages(pdf2.PageList...)
|
|
appender.AddPages(pdf2.PageList...)
|
|
|
|
err = appender.WriteToFile(tempFile("appender_add_page_1.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestAppenderAddPage2(t *testing.T) {
|
|
f1, err := os.Open(testPdfLoremIpsumFile)
|
|
require.NoError(t, err)
|
|
defer f1.Close()
|
|
|
|
pdf1, err := model.NewPdfReader(f1)
|
|
require.NoError(t, err)
|
|
|
|
f2, err := os.Open(testPdfAcroFormFile1)
|
|
require.NoError(t, err)
|
|
defer f2.Close()
|
|
|
|
pdf2, err := model.NewPdfReader(f2)
|
|
defer f2.Close()
|
|
|
|
appender, err := model.NewPdfAppender(pdf1)
|
|
defer f2.Close()
|
|
|
|
appender.AddPages(pdf2.PageList...)
|
|
|
|
// AcroForm from a different file.
|
|
appender.ReplaceAcroForm(pdf2.AcroForm)
|
|
|
|
err = appender.WriteToFile(tempFile("appender_add_page_2.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// TODO: Check outputs.
|
|
}
|
|
|
|
func TestAppenderMergePage(t *testing.T) {
|
|
f1, err := os.Open(testPdf3pages)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f1.Close()
|
|
pdf1, err := model.NewPdfReader(f1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
f2, err := os.Open(testPdfFile1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f2.Close()
|
|
pdf2, err := model.NewPdfReader(f2)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
appender, err := model.NewPdfAppender(pdf1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
err = appender.MergePageWith(1, pdf2.PageList[0])
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
err = appender.WriteToFile(tempFile("appender_merge_page_1.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestAppenderMergePage2(t *testing.T) {
|
|
f1, err := os.Open(imgPdfFile1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f1.Close()
|
|
|
|
pdf1, err := model.NewPdfReader(f1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
f2, err := os.Open(imgPdfFile2)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f2.Close()
|
|
|
|
pdf2, err := model.NewPdfReader(f2)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
appender, err := model.NewPdfAppender(pdf1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
err = appender.MergePageWith(1, pdf2.PageList[0])
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
appender.AddPages(pdf2.PageList...)
|
|
|
|
err = appender.WriteToFile(tempFile("appender_merge_page_2.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestAppenderMergePage3(t *testing.T) {
|
|
f1, err := os.Open(testPdfFile1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f1.Close()
|
|
pdf1, err := model.NewPdfReader(f1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
f2, err := os.Open(testPdfLoremIpsumFile)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f2.Close()
|
|
|
|
pdf2, err := model.NewPdfReader(f2)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
appender, err := model.NewPdfAppender(pdf1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
err = appender.MergePageWith(1, pdf2.PageList[0])
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
err = appender.WriteToFile(tempFile("appender_merge_page_3.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
func validateFile(t *testing.T, fileName string) {
|
|
t.Logf("Validating %s", fileName)
|
|
data, err := ioutil.ReadFile(fileName)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
reader, err := model.NewPdfReader(bytes.NewReader(data))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
handler, _ := sighandler.NewAdobeX509RSASHA1(nil, nil)
|
|
handler2, _ := sighandler.NewAdobePKCS7Detached(nil, nil)
|
|
handlers := []model.SignatureHandler{handler, handler2}
|
|
|
|
res, err := reader.ValidateSignatures(handlers)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
if len(res) == 0 {
|
|
t.Errorf("Fail: signature fields not found")
|
|
return
|
|
}
|
|
|
|
if !res[0].IsSigned || !res[0].IsVerified {
|
|
t.Errorf("Fail: validation failed")
|
|
return
|
|
}
|
|
|
|
for i, item := range res {
|
|
t.Logf("== Signature %d", i+1)
|
|
t.Logf("%s", item.String())
|
|
}
|
|
}
|
|
|
|
func parseByteRange(byteRange *core.PdfObjectArray) ([]int64, error) {
|
|
if byteRange == nil {
|
|
return nil, errors.New("byte range cannot be nil")
|
|
}
|
|
if byteRange.Len() != 4 {
|
|
return nil, errors.New("invalid byte range length")
|
|
}
|
|
|
|
s1, err := core.GetNumberAsInt64(byteRange.Get(0))
|
|
if err != nil {
|
|
return nil, errors.New("invalid byte range value")
|
|
}
|
|
l1, err := core.GetNumberAsInt64(byteRange.Get(1))
|
|
if err != nil {
|
|
return nil, errors.New("invalid byte range value")
|
|
}
|
|
|
|
s2, err := core.GetNumberAsInt64(byteRange.Get(2))
|
|
if err != nil {
|
|
return nil, errors.New("invalid byte range value")
|
|
}
|
|
l2, err := core.GetNumberAsInt64(byteRange.Get(3))
|
|
if err != nil {
|
|
return nil, errors.New("invalid byte range value")
|
|
}
|
|
|
|
return []int64{s1, s1 + l1, s2, s2 + l2}, nil
|
|
}
|
|
|
|
func TestAppenderSignPage4(t *testing.T) {
|
|
// TODO move to reader_test.go
|
|
validateFile(t, testPdfSignedPDFDocument)
|
|
|
|
f1, err := os.Open(testPdfFile1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f1.Close()
|
|
pdf1, err := model.NewPdfReader(f1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
appender, err := model.NewPdfAppender(pdf1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
f, _ := ioutil.ReadFile(testPKS12Key)
|
|
privateKey, cert, err := pkcs12.Decode(f, testPKS12KeyPassword)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
handler, err := sighandler.NewAdobePKCS7Detached(privateKey.(*rsa.PrivateKey), cert)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// Create signature field and appearance.
|
|
signature := model.NewPdfSignature(handler)
|
|
signature.SetName("Test Appender")
|
|
signature.SetReason("TestAppenderSignPage4")
|
|
signature.SetDate(time.Now(), "")
|
|
|
|
if err := signature.Initialize(); err != nil {
|
|
return
|
|
}
|
|
|
|
sigField := model.NewPdfFieldSignature(signature)
|
|
sigField.T = core.MakeString("Signature1")
|
|
sigField.Rect = core.MakeArray(
|
|
core.MakeInteger(0),
|
|
core.MakeInteger(0),
|
|
core.MakeInteger(0),
|
|
core.MakeInteger(0),
|
|
)
|
|
|
|
if err = appender.Sign(1, sigField); err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
err = appender.WriteToFile(tempFile("appender_sign_page_4.pdf"))
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
validateFile(t, tempFile("appender_sign_page_4.pdf"))
|
|
}
|
|
|
|
// Multiple revisions of signing.
|
|
func TestAppenderSignMultiple(t *testing.T) {
|
|
inputPath := "./testdata/minimal.pdf"
|
|
|
|
for i := 0; i < 3; i++ {
|
|
t.Logf("======================================")
|
|
t.Logf("--> Signature revision %d", i+1)
|
|
t.Logf("Input %s", inputPath)
|
|
f, err := os.Open(inputPath)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
pdfReader, err := model.NewPdfReader(f)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
f.Close()
|
|
return
|
|
}
|
|
|
|
t.Logf("Fields: %d", len(pdfReader.AcroForm.AllFields()))
|
|
if len(pdfReader.AcroForm.AllFields()) != i {
|
|
t.Fatalf("fields != %d (got %d)", i, len(pdfReader.AcroForm.AllFields()))
|
|
}
|
|
|
|
annotations, err := pdfReader.PageList[0].GetAnnotations()
|
|
require.NoError(t, err)
|
|
t.Logf("Annotations: %d", len(annotations))
|
|
if len(annotations) != i {
|
|
t.Fatalf("page annotations != %d (got %d)", i, len(annotations))
|
|
}
|
|
for j, annot := range annotations {
|
|
t.Logf("i=%d Annots page object equal? %v == %v?", j, pdfReader.PageList[0].GetContainingPdfObject(), annot.P)
|
|
require.Equal(t, pdfReader.PageList[0].GetContainingPdfObject(), annot.P)
|
|
}
|
|
|
|
appender, err := model.NewPdfAppender(pdfReader)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
f.Close()
|
|
return
|
|
}
|
|
|
|
pfxData, _ := ioutil.ReadFile("./testdata/JohnSmith.pfx")
|
|
privateKey, cert, err := pkcs12.Decode(pfxData, "password")
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
f.Close()
|
|
return
|
|
}
|
|
|
|
handler, err := sighandler.NewAdobePKCS7Detached(privateKey.(*rsa.PrivateKey), cert)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
f.Close()
|
|
return
|
|
}
|
|
|
|
// Create signature field and appearance.
|
|
signature := model.NewPdfSignature(handler)
|
|
signature.SetName(fmt.Sprintf("Test Appender - Round %d", i+1))
|
|
signature.SetReason(fmt.Sprintf("Test Appender - Round %d", i+1))
|
|
signature.SetDate(time.Now(), "")
|
|
|
|
if err := signature.Initialize(); err != nil {
|
|
return
|
|
}
|
|
|
|
sigField := model.NewPdfFieldSignature(signature)
|
|
sigField.T = core.MakeString(fmt.Sprintf("Signature %d", i+1))
|
|
sigField.Rect = core.MakeArray(
|
|
core.MakeInteger(0),
|
|
core.MakeInteger(0),
|
|
core.MakeInteger(0),
|
|
core.MakeInteger(0),
|
|
)
|
|
|
|
if err = appender.Sign(1, sigField); err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
f.Close()
|
|
return
|
|
}
|
|
|
|
outPath := tempFile(fmt.Sprintf("appender_sign_multiple_%d.pdf", i+1))
|
|
t.Logf("Signing to %s", outPath)
|
|
|
|
err = appender.WriteToFile(outPath)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
f.Close()
|
|
return
|
|
}
|
|
|
|
validateFile(t, outPath)
|
|
inputPath = outPath
|
|
|
|
f.Close()
|
|
}
|
|
}
|
|
|
|
func TestSignatureAppearance(t *testing.T) {
|
|
f, err := os.Open(testPdf3pages)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f.Close()
|
|
|
|
pdfReader, err := model.NewPdfReader(f)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
t.Logf("Fields: %d", len(pdfReader.AcroForm.AllFields()))
|
|
|
|
appender, err := model.NewPdfAppender(pdfReader)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
pfxData, _ := ioutil.ReadFile(testPKS12Key)
|
|
privateKey, cert, err := pkcs12.Decode(pfxData, testPKS12KeyPassword)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
handler, err := sighandler.NewAdobePKCS7Detached(privateKey.(*rsa.PrivateKey), cert)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// Create signature.
|
|
signature := model.NewPdfSignature(handler)
|
|
signature.SetName("Test Signature Appearance Name")
|
|
signature.SetReason("TestSignatureAppearance Reason")
|
|
signature.SetDate(time.Now(), "")
|
|
|
|
if err := signature.Initialize(); err != nil {
|
|
return
|
|
}
|
|
|
|
numPages, err := pdfReader.GetNumPages()
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
for i := 0; i < numPages; i++ {
|
|
pageNum := i + 1
|
|
|
|
// Annot1
|
|
opts := annotator.NewSignatureFieldOpts()
|
|
opts.FontSize = 10
|
|
opts.Rect = []float64{10, 25, 75, 60}
|
|
|
|
sigField, err := annotator.NewSignatureField(
|
|
signature,
|
|
[]*annotator.SignatureLine{
|
|
annotator.NewSignatureLine("Name", "Jane Doe"),
|
|
annotator.NewSignatureLine("Date", "2019.01.03"),
|
|
annotator.NewSignatureLine("Reason", "Some reason"),
|
|
annotator.NewSignatureLine("Location", "New York"),
|
|
annotator.NewSignatureLine("DN", "authority1:name1"),
|
|
},
|
|
opts,
|
|
)
|
|
sigField.T = core.MakeString(fmt.Sprintf("Signature %d", pageNum))
|
|
|
|
if err = appender.Sign(pageNum, sigField); err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// Annot2
|
|
opts = annotator.NewSignatureFieldOpts()
|
|
opts.FontSize = 8
|
|
opts.Rect = []float64{250, 25, 325, 70}
|
|
opts.TextColor = model.NewPdfColorDeviceRGB(255, 0, 0)
|
|
|
|
sigField, err = annotator.NewSignatureField(
|
|
signature,
|
|
[]*annotator.SignatureLine{
|
|
annotator.NewSignatureLine("Name", "John Doe"),
|
|
annotator.NewSignatureLine("Date", "2019.03.14"),
|
|
annotator.NewSignatureLine("Reason", "No reason"),
|
|
annotator.NewSignatureLine("Location", "London"),
|
|
annotator.NewSignatureLine("DN", "authority2:name2"),
|
|
},
|
|
opts,
|
|
)
|
|
sigField.T = core.MakeString(fmt.Sprintf("Signature2 %d", pageNum))
|
|
|
|
if err = appender.Sign(pageNum, sigField); err != nil {
|
|
log.Fatalf("Fail: %v\n", err)
|
|
}
|
|
|
|
// Annot3
|
|
opts = annotator.NewSignatureFieldOpts()
|
|
opts.BorderSize = 1
|
|
opts.FontSize = 10
|
|
opts.Rect = []float64{475, 25, 590, 80}
|
|
opts.FillColor = model.NewPdfColorDeviceRGB(255, 255, 0)
|
|
opts.TextColor = model.NewPdfColorDeviceRGB(0, 0, 200)
|
|
|
|
sigField, err = annotator.NewSignatureField(
|
|
signature,
|
|
[]*annotator.SignatureLine{
|
|
annotator.NewSignatureLine("Name", "John Smith"),
|
|
annotator.NewSignatureLine("Date", "2019.02.19"),
|
|
annotator.NewSignatureLine("Reason", "Another reason"),
|
|
annotator.NewSignatureLine("Location", "Paris"),
|
|
annotator.NewSignatureLine("DN", "authority3:name3"),
|
|
},
|
|
opts,
|
|
)
|
|
sigField.T = core.MakeString(fmt.Sprintf("Signature3 %d", pageNum))
|
|
|
|
if err = appender.Sign(pageNum, sigField); err != nil {
|
|
log.Fatalf("Fail: %v\n", err)
|
|
}
|
|
}
|
|
|
|
outPath := tempFile("appender_signature_appearance.pdf")
|
|
if err = appender.WriteToFile(outPath); err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
validateFile(t, outPath)
|
|
}
|
|
|
|
// Multiple revisions of signing with appearances.
|
|
func TestAppenderSignMultipleAppearances(t *testing.T) {
|
|
inputPath := testPdf3pages
|
|
|
|
for i := 0; i < 3; i++ {
|
|
t.Logf("======================================")
|
|
t.Logf("--> Signature revision %d", i+1)
|
|
t.Logf("Input %s", inputPath)
|
|
f, err := os.Open(inputPath)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
pdfReader, err := model.NewPdfReader(f)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
f.Close()
|
|
return
|
|
}
|
|
|
|
numPages, err := pdfReader.GetNumPages()
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
t.Logf("Fields: %d", len(pdfReader.AcroForm.AllFields()))
|
|
if len(pdfReader.AcroForm.AllFields()) != i*numPages {
|
|
t.Fatalf("fields != %d (got %d)", i*numPages, len(pdfReader.AcroForm.AllFields()))
|
|
}
|
|
|
|
annotations, err := pdfReader.PageList[0].GetAnnotations()
|
|
require.NoError(t, err)
|
|
t.Logf("Annotations: %d", len(annotations))
|
|
if len(annotations) != i {
|
|
t.Fatalf("page annotations != %d (got %d)", i, len(annotations))
|
|
}
|
|
for j, annot := range annotations {
|
|
t.Logf("i=%d Annots page object equal? %v == %v?", j, pdfReader.PageList[0].GetContainingPdfObject(), annot.P)
|
|
require.Equal(t, pdfReader.PageList[0].GetContainingPdfObject(), annot.P)
|
|
}
|
|
|
|
appender, err := model.NewPdfAppender(pdfReader)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
f.Close()
|
|
return
|
|
}
|
|
|
|
pfxData, _ := ioutil.ReadFile("./testdata/JohnSmith.pfx")
|
|
privateKey, cert, err := pkcs12.Decode(pfxData, "password")
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
f.Close()
|
|
return
|
|
}
|
|
|
|
handler, err := sighandler.NewAdobePKCS7Detached(privateKey.(*rsa.PrivateKey), cert)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
f.Close()
|
|
return
|
|
}
|
|
|
|
// Create signature field and appearance.
|
|
signature := model.NewPdfSignature(handler)
|
|
signature.SetName(fmt.Sprintf("Test Appender - Round %d", i+1))
|
|
signature.SetReason(fmt.Sprintf("Test Appender - Round %d", i+1))
|
|
signature.SetDate(time.Now(), "")
|
|
|
|
if err := signature.Initialize(); err != nil {
|
|
return
|
|
}
|
|
|
|
for j := 0; j < numPages; j++ {
|
|
pageNum := j + 1
|
|
|
|
opts := annotator.NewSignatureFieldOpts()
|
|
opts.BorderSize = 1
|
|
opts.FontSize = 10
|
|
opts.Rect = []float64{float64(200*i) + 50, 25, float64(200*i) + 150, 80}
|
|
opts.FillColor = model.NewPdfColorDeviceRGB(255, 255, 0)
|
|
opts.TextColor = model.NewPdfColorDeviceRGB(0, 0, 200)
|
|
|
|
sigField, err := annotator.NewSignatureField(
|
|
signature,
|
|
[]*annotator.SignatureLine{
|
|
annotator.NewSignatureLine("Name", fmt.Sprintf("John Smith %d", i+1)),
|
|
annotator.NewSignatureLine("Date", fmt.Sprintf("2019.0%d.%d", i+1, i+1)),
|
|
annotator.NewSignatureLine("Reason", fmt.Sprintf("Reason %d", i+1)),
|
|
annotator.NewSignatureLine("Location", "New York"),
|
|
annotator.NewSignatureLine("DN", fmt.Sprintf("authority%d:name%d", i+1, i+1)),
|
|
},
|
|
opts,
|
|
)
|
|
sigField.T = core.MakeString(fmt.Sprintf("Signature %d-%d", i+1, j+1))
|
|
|
|
if err = appender.Sign(pageNum, sigField); err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
f.Close()
|
|
return
|
|
}
|
|
}
|
|
|
|
outPath := tempFile(fmt.Sprintf("appender_sign_multiple_appearances_%d.pdf", i+1))
|
|
t.Logf("Signing to %s", outPath)
|
|
|
|
if err = appender.WriteToFile(outPath); err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
f.Close()
|
|
return
|
|
}
|
|
|
|
//validateFile(t, outPath)
|
|
inputPath = outPath
|
|
|
|
f.Close()
|
|
}
|
|
}
|
|
|
|
func TestAppenderExternalSignature(t *testing.T) {
|
|
validateFile(t, testPdfSignedPDFDocument)
|
|
|
|
// Function to generate signed PDF using the specified signature handler.
|
|
generateSignedFile := func(handler model.SignatureHandler) ([]byte, *model.PdfSignature, error) {
|
|
file, err := os.Open(testPdfFile1)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
defer file.Close()
|
|
|
|
reader, err := model.NewPdfReader(file)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
appender, err := model.NewPdfAppender(reader)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
// Create signature.
|
|
signature := model.NewPdfSignature(handler)
|
|
signature.SetName("Test External Signature")
|
|
signature.SetReason("TestAppenderExternalSignature")
|
|
signature.SetDate(time.Date(2019, 3, 24, 7, 30, 24, 0, time.UTC), "")
|
|
|
|
if err := signature.Initialize(); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
// Create signature field and appearance.
|
|
opts := annotator.NewSignatureFieldOpts()
|
|
opts.FontSize = 10
|
|
opts.Rect = []float64{10, 25, 75, 60}
|
|
|
|
field, err := annotator.NewSignatureField(
|
|
signature,
|
|
[]*annotator.SignatureLine{
|
|
annotator.NewSignatureLine("Name", "John Doe"),
|
|
annotator.NewSignatureLine("Date", "2019.15.03"),
|
|
annotator.NewSignatureLine("Reason", "External signature test"),
|
|
},
|
|
opts,
|
|
)
|
|
field.T = core.MakeString("External signature")
|
|
|
|
if err = appender.Sign(1, field); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
// Write PDF file to buffer.
|
|
pdfBuf := bytes.NewBuffer(nil)
|
|
if err = appender.Write(pdfBuf); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
return pdfBuf.Bytes(), signature, nil
|
|
}
|
|
|
|
// Function which signs PDF and returns the signature data.
|
|
getExternalSignature := func() ([]byte, error) {
|
|
certFile, err := ioutil.ReadFile(testPKS12Key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
privateKey, cert, err := pkcs12.Decode(certFile, testPKS12KeyPassword)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
handler, err := sighandler.NewAdobePKCS7Detached(privateKey.(*rsa.PrivateKey), cert)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Get external signature data.
|
|
_, signature, err := generateSignedFile(handler)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return signature.Contents.Bytes(), nil
|
|
}
|
|
|
|
// Generate PDF file signed with empty signature.
|
|
handler, err := sighandler.NewEmptyAdobePKCS7Detached(8192)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
pdfData, signature, err := generateSignedFile(handler)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// Parse signature byte range.
|
|
byteRange, err := parseByteRange(signature.ByteRange)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// This would be the time to send the PDF buffer to a signing device or
|
|
// signing web service and get back the signature. We will simulate this by
|
|
// signing the PDF using UniDoc and returning the signature data.
|
|
signatureData, err := getExternalSignature()
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// Apply external signature to the PDF data buffer.
|
|
sigBytes := make([]byte, 8192)
|
|
copy(sigBytes, signatureData)
|
|
|
|
sig := core.MakeHexString(string(sigBytes)).WriteString()
|
|
copy(pdfData[byteRange[1]:byteRange[2]], []byte(sig))
|
|
|
|
// Write output file.
|
|
outputPath := tempFile("appender_sign_external_signature.pdf")
|
|
if err := ioutil.WriteFile(outputPath, pdfData, os.ModePerm); err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// Validate output file.
|
|
validateFile(t, outputPath)
|
|
}
|
|
|
|
// Each Appender can only be written out once, further invokations of Write should result in an error.
|
|
func TestAppenderAttemptMultiWrite(t *testing.T) {
|
|
f1, err := os.Open(testPdfLoremIpsumFile)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f1.Close()
|
|
pdf1, err := model.NewPdfReader(f1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
f2, err := os.Open(testPdfFile1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
defer f2.Close()
|
|
pdf2, err := model.NewPdfReader(f2)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
appender, err := model.NewPdfAppender(pdf1)
|
|
if err != nil {
|
|
t.Errorf("Fail: %v\n", err)
|
|
return
|
|
}
|
|
|
|
appender.AddPages(pdf1.PageList...)
|
|
appender.AddPages(pdf2.PageList...)
|
|
appender.AddPages(pdf2.PageList...)
|
|
|
|
// Write twice to buffer and compare results.
|
|
var buf1, buf2 bytes.Buffer
|
|
err = appender.Write(&buf1)
|
|
if err != nil {
|
|
t.Fatalf("Error: %v", err)
|
|
}
|
|
err = appender.Write(&buf2)
|
|
if err == nil {
|
|
t.Fatalf("Second invokation of appender.Write should yield an error")
|
|
}
|
|
}
|