├── .docker
    └── Dockerfile
├── .gitignore
├── README-br.md
├── composer.json
├── composer.lock
├── docker-compose.yml
├── kool.yml
├── phpunit.xml
├── src
    ├── Buffer.php
    ├── Metadata.php
    ├── ObjectParser.php
    ├── PDFObject.php
    ├── PageInfo.php
    ├── PdfDocument.php
    ├── PdfValue
    │   ├── PDFValue.php
    │   ├── PDFValueHexString.php
    │   ├── PDFValueList.php
    │   ├── PDFValueObject.php
    │   ├── PDFValueReference.php
    │   ├── PDFValueSimple.php
    │   ├── PDFValueString.php
    │   └── PDFValueType.php
    ├── Signature.php
    ├── SignatureAppearance.php
    ├── SignatureObject.php
    ├── Signer.php
    ├── StreamReader.php
    ├── Struct.php
    ├── Trailer.php
    ├── Utils
    │   ├── ContentGeneration.php
    │   ├── Date.php
    │   ├── Img.php
    │   ├── Mime.php
    │   ├── Str.php
    │   └── helpers.php
    └── Xref
    │   ├── XRef14.php
    │   ├── XRef15.php
    │   └── Xref.php
└── tests
    ├── Feature
        └── ExampleTest.php
    ├── Pest.php
    ├── TestCase.php
    └── Unit
        └── ExampleTest.php


/.docker/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM kooldev/php:8.2
2 | 
3 | RUN sed -i '/^default = default_sect/a legacy = legacy_sect' /etc/ssl/openssl.cnf
4 | RUN sed -i '/^\[default_sect\]/a activate = 1' /etc/ssl/openssl.cnf
5 | RUN printf "[legacy_sect]\nactivate = 1" >> /etc/ssl/openssl.cnf
6 | 
7 | CMD [ "php-fpm" ]


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | vendor/
2 | .idea/
3 | file-tests/
4 | 


--------------------------------------------------------------------------------
/README-br.md:
--------------------------------------------------------------------------------
 1 | # PHP-SIGNER
 2 | 
 3 | Esse é um pacote escrito inteiramente em PHP para assinar PDF's com suporte a multiplas assinaturas.
 4 | 
 5 | ## INSTALAÇÃO:
 6 | ```bash
 7 | composer require jeidison/pdf-signer
 8 | ```
 9 | 
10 | ## EXEMPLOS:
11 | 
12 | Assinando documentos:
13 | ```php
14 | $pathFileCertificate = 'path_do_seu_arquivo.pfx';
15 | $passwordCertificate = 'senha do seu pfx';
16 | $fileContent = file_get_contents('path_do_seu_certificado.pdf');
17 | 
18 | $fileContentSigned = Signer::new()
19 |         ->withCertificate($pathFileCertificate, $passwordCertificate)
20 |         ->withContent($fileContent)
21 |         ->sign();
22 | 
23 | file_put_contents('path_onde_vc_quer_salvar_o_seu_pdf.pdf', $fileContentSigned);
24 | ```
25 | 
26 | Assinando documentos com metadados(Razão, Nome, Local, Informações de contato):
27 | ```php
28 | $pathFileCertificate = 'path_do_seu_arquivo.pfx';
29 | $passwordCertificate = 'senha do seu pfx';
30 | $fileContent = file_get_contents('path_do_seu_certificado.pdf');
31 | 
32 | $fileContentSigned = Signer::new()
33 |         ->withCertificate($pathFileCertificate, $passwordCertificate)
34 |         ->withContent($fileContent)
35 |         ->withMetadata(
36 |             Metadata::new()
37 |                 ->withReason('ASSINATURA DE DOCUMENTOS PARA TESTES.')
38 |                 ->withName('JEIDISON SANTOS FARIAS')
39 |                 ->withLocation('Araras/SP')
40 |                 ->withContactInfo('Jeidison Farias <jeidison.farias@gmail.com>')
41 |         )
42 |         ->sign();
43 | 
44 | file_put_contents('path_onde_vc_quer_salvar_o_seu_pdf.pdf', $fileContentSigned);
45 | ```
46 | 
47 | Assinando documentos com assinatura visível:
48 | ```php
49 | $pathFileCertificate = 'path_do_seu_arquivo.pfx';
50 | $passwordCertificate = 'senha do seu pfx';
51 | $fileContent = file_get_contents('path_do_seu_certificado.pdf');
52 | 
53 | $fileContentSigned = Signer::new()
54 |         ->withCertificate($pathFileCertificate, $passwordCertificate)
55 |         ->withContent($fileContent)
56 |         ->withSignatureAppearance(
57 |             SignatureAppearance::new()
58 |                 ->withImage('/path_do_seu_icone.png')
59 |                 ->withRect([350, 770, 400, 820])
60 |         )
61 |         ->sign();
62 | 
63 | file_put_contents('path_onde_vc_quer_salvar_o_seu_pdf.pdf', $fileContentSigned);
64 | ```
65 | 
66 | Adicionando carimbo de tempo na assinatura:
67 | ```php
68 | // Ainda não implementado.
69 | ```
70 | 
71 | ## Credits
72 | - [Jeidison Farias](https://github.com/jeidison)
73 | - [All Contributors](../../contributors)


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "jeidison/pdf-signer",
 3 |     "description": "Project to add digital signature in pdf files",
 4 |     "type": "library",
 5 |     "require": {
 6 |         "php": "^8.1",
 7 |         "ext-openssl": "*",
 8 |         "ext-zlib": "*",
 9 |         "ext-fileinfo": "*",
10 |         "ramsey/uuid": "^4.7"
11 |     },
12 |     "require-dev": {
13 |         "pestphp/pest": "v2.20.0",
14 |         "laravel/pint": "v1.13.2",
15 |         "symfony/var-dumper": "^6.4.2"
16 |     },
17 |     "license": "MIT",
18 |     "autoload": {
19 |         "psr-4": {
20 |             "Jeidison\\PdfSigner\\": "src/"
21 |         },
22 |         "files": [
23 |             "src/Utils/helpers.php"
24 |         ]
25 |     },
26 |     "autoload-dev": {
27 |         "psr-4": {
28 |             "Tests\\": "tests/"
29 |         }
30 |     },
31 |     "authors": [
32 |         {
33 |             "name": "Jeidison Farias"
34 |         }
35 |     ],
36 |     "minimum-stability": "dev",
37 |     "config": {
38 |         "allow-plugins": {
39 |             "pestphp/pest-plugin": true
40 |         }
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/docker-compose.yml:
--------------------------------------------------------------------------------
 1 | version: "3.8"
 2 | #
 3 | # Services definitions
 4 | #
 5 | services:
 6 |   app:
 7 |     build: .docker
 8 |     ports:
 9 |       - "${KOOL_APP_PORT:-80}:80"
10 |       - "9003:9003"
11 |     environment:
12 |       ASUSER: "${KOOL_ASUSER:-0}"
13 |       UID: "${UID:-0}"
14 |       ENABLE_XDEBUG: "true"
15 |       XDEBUG_MODE: "debug,develop,coverage"
16 |       XDEBUG_CONFIG: "client_host=host.docker.internal"
17 |     volumes:
18 |       - .:/app:delegated
19 |     networks:
20 |       - kool_local
21 |       - kool_global
22 | #
23 | # Networks definitions
24 | #
25 | networks:
26 |   kool_local:
27 |   kool_global:
28 |     external: true
29 |     name: "${KOOL_GLOBAL_NETWORK:-kool_global}"
30 | 


--------------------------------------------------------------------------------
/kool.yml:
--------------------------------------------------------------------------------
 1 | # Here you can define shortcuts and aliases to common tasks (commands)
 2 | # you will run in your local environment or CI or deploy.
 3 | #  Use the scripts defined below with:
 4 | #    $ kool run <script>
 5 | # Learn more at: https://kool.dev/docs/getting-started/how-it-works#koolyml
 6 | scripts:
 7 |   php: kool exec app php
 8 |   composer: kool exec app composer
 9 |   pest: kool exec app php ./vendor/bin/pest
10 |   pint: kool exec app php ./vendor/bin/pint
11 |   rector: kool exec app php vendor/bin/rector
12 |   bash: docker compose exec app bash
13 |   setup:
14 |     - kool start
15 |     # - add more setup commands
16 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 |          xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.3/phpunit.xsd"
 4 |          bootstrap="vendor/autoload.php"
 5 |          colors="true"
 6 | >
 7 |     <testsuites>
 8 |         <testsuite name="Test Suite">
 9 |             <directory suffix="Test.php">./tests</directory>
10 |         </testsuite>
11 |     </testsuites>
12 |     <source>
13 |         <include>
14 |             <directory suffix=".php">./app</directory>
15 |             <directory suffix=".php">./src</directory>
16 |         </include>
17 |     </source>
18 | </phpunit>
19 | 


--------------------------------------------------------------------------------
/src/Buffer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Jeidison\PdfSigner;
 4 | 
 5 | use Stringable;
 6 | 
 7 | /**
 8 |  * @author Jeidison Farias <jeidison.farias@gmail.com>
 9 |  **/
10 | class Buffer implements Stringable
11 | {
12 |     protected string $buffer;
13 | 
14 |     protected int $bufferLen = 0;
15 | 
16 |     public function __construct(string $string = null)
17 |     {
18 |         if ($string === null) {
19 |             $string = '';
20 |         }
21 | 
22 |         $this->buffer = $string;
23 |         $this->bufferLen = strlen($string);
24 |     }
25 | 
26 |     public function data(...$datas): void
27 |     {
28 |         foreach ($datas as $data) {
29 |             $this->bufferLen += strlen($data);
30 |             $this->buffer .= $data;
31 |         }
32 |     }
33 | 
34 |     public function size(): int
35 |     {
36 |         return $this->bufferLen;
37 |     }
38 | 
39 |     public function raw(): ?string
40 |     {
41 |         return $this->buffer;
42 |     }
43 | 
44 |     public function append(Buffer $b): static
45 |     {
46 |         $this->buffer .= $b->raw();
47 |         $this->bufferLen = strlen($this->buffer);
48 | 
49 |         return $this;
50 |     }
51 | 
52 |     public function add(...$bs): Buffer
53 |     {
54 |         $buffer = new Buffer($this->buffer);
55 |         foreach ($bs as $b) {
56 |             $buffer->append($b);
57 |         }
58 | 
59 |         return $buffer;
60 |     }
61 | 
62 |     public function __toString(): string
63 |     {
64 |         return $this->buffer;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Metadata.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Jeidison\PdfSigner;
 4 | 
 5 | /**
 6 |  * @author Jeidison Farias <jeidison.farias@gmail.com>
 7 |  **/
 8 | class Metadata
 9 | {
10 |     private ?string $name = null;
11 | 
12 |     private ?string $location = null;
13 | 
14 |     private ?string $contactInfo = null;
15 | 
16 |     private ?string $reason = null;
17 | 
18 |     public static function new(): self
19 |     {
20 |         return new self();
21 |     }
22 | 
23 |     public function withName(?string $name): self
24 |     {
25 |         if ($name) {
26 |             $this->name = $name;
27 |         }
28 | 
29 |         return $this;
30 |     }
31 | 
32 |     public function withReason(?string $reason): self
33 |     {
34 |         if ($reason) {
35 |             $this->reason = $reason;
36 |         }
37 | 
38 |         return $this;
39 |     }
40 | 
41 |     public function withLocation(?string $location): self
42 |     {
43 |         if ($location) {
44 |             $this->location = $location;
45 |         }
46 | 
47 |         return $this;
48 |     }
49 | 
50 |     public function withContactInfo(?string $contact): self
51 |     {
52 |         if ($contact) {
53 |             $this->contactInfo = $contact;
54 |         }
55 | 
56 |         return $this;
57 |     }
58 | 
59 |     public function getName(): ?string
60 |     {
61 |         return $this->name;
62 |     }
63 | 
64 |     public function getLocation(): ?string
65 |     {
66 |         return $this->location;
67 |     }
68 | 
69 |     public function getContactInfo(): ?string
70 |     {
71 |         return $this->contactInfo;
72 |     }
73 | 
74 |     public function getReason(): ?string
75 |     {
76 |         return $this->reason;
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/src/ObjectParser.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner;
  4 | 
  5 | use Exception;
  6 | use Jeidison\PdfSigner\PdfValue\PDFValueHexString;
  7 | use Jeidison\PdfSigner\PdfValue\PDFValueList;
  8 | use Jeidison\PdfSigner\PdfValue\PDFValueObject;
  9 | use Jeidison\PdfSigner\PdfValue\PDFValueSimple;
 10 | use Jeidison\PdfSigner\PdfValue\PDFValueString;
 11 | use Jeidison\PdfSigner\PdfValue\PDFValueType;
 12 | use Stringable;
 13 | 
 14 | class ObjectParser implements Stringable
 15 | {
 16 |     // Possible tokens in a PDF document
 17 |     final public const T_NOTOKEN = 0;
 18 | 
 19 |     final public const T_LIST_START = 1;
 20 | 
 21 |     final public const T_LIST_END = 2;
 22 | 
 23 |     final public const T_FIELD = 3;
 24 | 
 25 |     final public const T_STRING = 4;
 26 | 
 27 |     final public const T_HEX_STRING = 12;
 28 | 
 29 |     final public const T_SIMPLE = 5;
 30 | 
 31 |     final public const T_DICT_START = 6;
 32 | 
 33 |     final public const T_DICT_END = 7;
 34 | 
 35 |     final public const T_OBJECT_BEGIN = 8;
 36 | 
 37 |     final public const T_OBJECT_END = 9;
 38 | 
 39 |     final public const T_STREAM_BEGIN = 10;
 40 | 
 41 |     final public const T_STREAM_END = 11;
 42 | 
 43 |     final public const T_COMMENT = 13;
 44 | 
 45 |     final public const T_NAMES = [
 46 |         self::T_NOTOKEN => 'no token',
 47 |         self::T_LIST_START => 'list start',
 48 |         self::T_LIST_END => 'list end',
 49 |         self::T_FIELD => 'field',
 50 |         self::T_STRING => 'string',
 51 |         self::T_HEX_STRING => 'hex string',
 52 |         self::T_SIMPLE => 'simple',
 53 |         self::T_DICT_START => 'dict start',
 54 |         self::T_DICT_END => 'dict end',
 55 |         self::T_OBJECT_BEGIN => 'object begin',
 56 |         self::T_OBJECT_END => 'object end',
 57 |         self::T_STREAM_BEGIN => 'stream begin',
 58 |         self::T_STREAM_END => 'stream end',
 59 |         self::T_COMMENT => 'comment',
 60 |     ];
 61 | 
 62 |     final public const T_SIMPLE_OBJECTS = [
 63 |         self::T_SIMPLE,
 64 |         self::T_OBJECT_BEGIN,
 65 |         self::T_OBJECT_END,
 66 |         self::T_STREAM_BEGIN,
 67 |         self::T_STREAM_END,
 68 |         self::T_COMMENT,
 69 |     ];
 70 | 
 71 |     protected ?StreamReader $_buffer = null;
 72 | 
 73 |     protected $_c = false;
 74 | 
 75 |     protected $_n = false;
 76 | 
 77 |     protected $_t = false;
 78 | 
 79 |     protected $_tt = self::T_NOTOKEN;
 80 | 
 81 |     /**
 82 |      * Retrieves the current token type (one of T_* constants)
 83 |      *
 84 |      * @return token the current token
 85 |      */
 86 |     public function currentToken()
 87 |     {
 88 |         return $this->_tt;
 89 |     }
 90 | 
 91 |     /**
 92 |      * Obtains the next char and prepares the variable $this->_c and $this->_n to contain the current char and the next char
 93 |      *  - if EOF, _c will be false
 94 |      *  - if the last char before EOF, _n will be false
 95 |      *
 96 |      * @return char the next char
 97 |      */
 98 |     protected function nextchar()
 99 |     {
100 |         $this->_c = $this->_n;
101 |         $this->_n = $this->_buffer->nextchar();
102 | 
103 |         return $this->_c;
104 |     }
105 | 
106 |     /**
107 |      * Prepares the parser to analythe the text (i.e. prepares the parsing variables)
108 |      */
109 |     protected function start($buffer)
110 |     {
111 |         $this->_buffer = $buffer;
112 |         $this->_c = false;
113 |         $this->_n = false;
114 |         $this->_t = false;
115 |         $this->_tt = self::T_NOTOKEN;
116 | 
117 |         if ($this->_buffer->size() === 0) {
118 |             return false;
119 |         }
120 | 
121 |         $this->_n = $this->_buffer->currentchar();
122 |         $this->nextchar();
123 |     }
124 | 
125 |     /**
126 |      * Parses the document
127 |      */
128 |     public function parse($stream)
129 |     {
130 |         $this->start($stream);
131 |         $this->nexttoken();
132 | 
133 |         return $this->_parse_value();
134 |     }
135 | 
136 |     public function parsestr($str, $offset = 0)
137 |     {
138 |         $stream = new StreamReader($str);
139 |         $stream->goto($offset);
140 | 
141 |         return $this->parse($stream);
142 |     }
143 | 
144 |     public function __toString(): string
145 |     {
146 |         return 'pos: '.$this->_buffer->getPosition().sprintf(', c: %s, n: %s, t: %s, tt: ', $this->_c, $this->_n, $this->_t).
147 |         self::T_NAMES[$this->_tt].', b: '.$this->_buffer->substratpos(50).
148 |         "\n";
149 |     }
150 | 
151 |     /**
152 |      * Obtains the next token and returns it
153 |      */
154 |     public function nexttoken()
155 |     {
156 |         [$this->_t, $this->_tt] = $this->token();
157 | 
158 |         return $this->_t;
159 |     }
160 | 
161 |     /**
162 |      * Function that returns wether the current char is a separator or not
163 |      */
164 |     protected function _c_is_separator()
165 |     {
166 |         $DSEPS = ['<<', '>>'];
167 | 
168 |         return ($this->_c === false) || (str_contains("%<>()[]{}/ \n\r\t", (string) $this->_c)) || (in_array($this->_c.$this->_n, $DSEPS));
169 |     }
170 | 
171 |     /**
172 |      * This function assumes that the next content is an hex string, so it should be called after "<" is detected; it skips the trailing ">"
173 |      *
174 |      *  @return string the hex string
175 |      */
176 |     protected function _parse_hex_string()
177 |     {
178 |         $token = '';
179 | 
180 |         if ($this->_c !== '<') {
181 |             throw new Exception('Invalid hex string');
182 |         }
183 | 
184 |         $this->nextchar();  // This char is "<"
185 |         while (($this->_c !== '>') && (str_contains("0123456789abcdefABCDEF \t\r\n\f", $this->_c))) {
186 |             $token .= $this->_c;
187 |             if ($this->nextchar() === false) {
188 |                 break;
189 |             }
190 |         }
191 | 
192 |         if (($this->_c !== false) && (! str_contains(">0123456789abcdefABCDEF \t\r\n\f", $this->_c))) {
193 |             throw new Exception('invalid hex string');
194 |         }
195 | 
196 |         // The only way to get to here is that char is ">"
197 |         if ($this->_c !== '>') {
198 |             throw new Exception('Invalid hex string');
199 |         }
200 | 
201 |         $this->nextchar();
202 | 
203 |         return $token;
204 |     }
205 | 
206 |     protected function _parse_string()
207 |     {
208 |         $token = '';
209 |         if ($this->_c !== '(') {
210 |             throw new Exception('Invalid string');
211 |         }
212 | 
213 |         $nParenthesis = 1;
214 |         while ($this->_c !== false) {
215 |             $this->nextchar();
216 |             if (($this->_c === ')') && (! strlen($token) || ($token[strlen($token) - 1] !== '\\'))) {
217 |                 $nParenthesis--;
218 |                 if ($nParenthesis == 0) {
219 |                     break;
220 |                 }
221 |             } else {
222 |                 if (($this->_c === '(') && (! strlen($token) || ($token[strlen($token) - 1] !== '\\'))) {
223 |                     $nParenthesis++;
224 |                 }
225 | 
226 |                 $token .= $this->_c;
227 |             }
228 |         }
229 | 
230 |         if ($this->_c !== ')') {
231 |             throw new Exception('Invalid string');
232 |         }
233 | 
234 |         $this->nextchar();
235 | 
236 |         return $token;
237 |     }
238 | 
239 |     protected function token()
240 |     {
241 |         if ($this->_c === false) {
242 |             return [false, false];
243 |         }
244 | 
245 |         $token = false;
246 | 
247 |         while ($this->_c !== false) {
248 |             // Skip the spaces
249 |             while ((str_contains("\t\n\r ", (string) $this->_c)) && ($this->nextchar() !== false));
250 | 
251 |             $tokenType = self::T_NOTOKEN;
252 | 
253 |             // TODO: also the special characters are not "strictly" considered, according to section 7.3.4.2: \n \r \t \b \f \( \) \\ are valid; the other not; but also \bbb should be considered; all of them are "sufficiently" treated, but other unknown caracters such as \u are also accepted
254 |             switch ($this->_c) {
255 |                 case '%':
256 |                     $this->nextchar();
257 |                     $token = '';
258 |                     while (! str_contains("\n\r", (string) $this->_c)) {
259 |                         $token .= $this->_c;
260 |                         $this->nextchar();
261 |                     }
262 | 
263 |                     $tokenType = self::T_COMMENT;
264 |                     break;
265 |                 case '<':
266 |                     if ($this->_n === '<') {
267 |                         $this->nextchar();
268 |                         $this->nextchar();
269 |                         $token = '<<';
270 |                         $tokenType = self::T_DICT_START;
271 |                     } else {
272 |                         $token = $this->_parse_hex_string();
273 |                         $tokenType = self::T_HEX_STRING;
274 |                     }
275 | 
276 |                     break;
277 |                 case '(':
278 |                     $token = $this->_parse_string();
279 |                     $tokenType = self::T_STRING;
280 |                     break;
281 |                 case '>':
282 |                     if ($this->_n === '>') {
283 |                         $this->nextchar();
284 |                         $this->nextchar();
285 |                         $token = '>>';
286 |                         $tokenType = self::T_DICT_END;
287 |                     }
288 | 
289 |                     break;
290 |                 case '[':
291 |                     $token = $this->_c;
292 |                     $this->nextchar();
293 |                     $tokenType = self::T_LIST_START;
294 |                     break;
295 |                 case ']':
296 |                     $token = $this->_c;
297 |                     $this->nextchar();
298 |                     $tokenType = self::T_LIST_END;
299 |                     break;
300 |                 case '/':
301 |                     // Skip the field idenifyer
302 |                     $this->nextchar();
303 | 
304 |                     // We are assuming any char (i.e. /MY+difficult_id is valid)
305 |                     while (! $this->_c_is_separator()) {
306 |                         $token .= $this->_c;
307 |                         if ($this->nextchar() === false) {
308 |                             break;
309 |                         }
310 |                     }
311 | 
312 |                     $tokenType = self::T_FIELD;
313 |                     break;
314 |             }
315 | 
316 |             if ($token === false) {
317 |                 $token = '';
318 | 
319 |                 while (! $this->_c_is_separator()) {
320 |                     $token .= $this->_c;
321 |                     if ($this->nextchar() === false) {
322 |                         break;
323 |                     }
324 |                 }
325 | 
326 |                 $tokenType = match ($token) {
327 |                     'obj' => self::T_OBJECT_BEGIN,
328 |                     'endobj' => self::T_OBJECT_END,
329 |                     'stream' => self::T_STREAM_BEGIN,
330 |                     'endstream' => self::T_STREAM_END,
331 |                     default => self::T_SIMPLE,
332 |                 };
333 | 
334 |             }
335 | 
336 |             return [$token, $tokenType];
337 |         }
338 |     }
339 | 
340 |     protected function _parse_obj()
341 |     {
342 |         if ($this->_tt !== self::T_DICT_START) {
343 |             throw new Exception('Invalid object definition');
344 |         }
345 | 
346 |         $this->nexttoken();
347 |         $object = [];
348 |         while ($this->_t !== false) {
349 |             switch ($this->_tt) {
350 |                 case self::T_FIELD:
351 |                     $field = $this->_t;
352 |                     $this->nexttoken();
353 |                     $object[$field] = $this->_parse_value();
354 |                     break;
355 |                 case self::T_DICT_END:
356 |                     $this->nexttoken();
357 | 
358 |                     return new PDFValueObject($object);
359 |                 default:
360 |                     throw new Exception('Invalid token: '.$this);
361 |             }
362 |         }
363 | 
364 |         return false;
365 |     }
366 | 
367 |     protected function _parse_list()
368 |     {
369 |         if ($this->_tt !== self::T_LIST_START) {
370 |             throw new Exception('Invalid list definition');
371 |         }
372 | 
373 |         $this->nexttoken();
374 |         $list = [];
375 |         while ($this->_t !== false) {
376 |             switch ($this->_tt) {
377 |                 case self::T_LIST_END:
378 |                     $this->nexttoken();
379 | 
380 |                     return new PDFValueList($list);
381 | 
382 |                 case self::T_OBJECT_BEGIN:
383 |                 case self::T_OBJECT_END:
384 |                 case self::T_STREAM_BEGIN:
385 |                 case self::T_STREAM_END:
386 |                     throw new Exception('Invalid list definition');
387 |                 default:
388 |                     $value = $this->_parse_value();
389 |                     if ($value !== false) {
390 |                         $list[] = $value;
391 |                     }
392 | 
393 |                     break;
394 |             }
395 |         }
396 | 
397 |         return new PDFValueList($list);
398 |     }
399 | 
400 |     protected function _parse_value()
401 |     {
402 |         while ($this->_t !== false) {
403 |             switch ($this->_tt) {
404 |                 case self::T_DICT_START:
405 |                     return $this->_parse_obj();
406 |                 case self::T_LIST_START:
407 |                     return $this->_parse_list();
408 |                 case self::T_STRING:
409 |                     $string = new PDFValueString($this->_t);
410 |                     $this->nexttoken();
411 | 
412 |                     return $string;
413 |                 case self::T_HEX_STRING:
414 |                     $string = new PDFValueHexString($this->_t);
415 |                     $this->nexttoken();
416 | 
417 |                     return $string;
418 |                 case self::T_FIELD:
419 |                     $field = new PDFValueType($this->_t);
420 |                     $this->nexttoken();
421 | 
422 |                     return $field;
423 |                 case self::T_OBJECT_BEGIN:
424 |                 case self::T_STREAM_END:
425 |                     throw new Exception('invalid keyword');
426 |                 case self::T_OBJECT_END:
427 |                 case self::T_STREAM_BEGIN:
428 |                     return null;
429 |                 case self::T_COMMENT:
430 |                     $this->nexttoken();
431 |                     break;
432 |                 case self::T_SIMPLE:
433 |                     $simpleValue = $this->_t;
434 |                     $this->nexttoken();
435 | 
436 |                     while (($this->_t !== false) && ($this->_tt == self::T_SIMPLE)) {
437 |                         $simpleValue .= ' '.$this->_t;
438 |                         $this->nexttoken();
439 |                     }
440 | 
441 |                     return new PDFValueSimple($simpleValue);
442 |                 default:
443 |                     throw new Exception('Invalid token: '.$this);
444 |             }
445 |         }
446 | 
447 |         return false;
448 |     }
449 | }
450 | 


--------------------------------------------------------------------------------
/src/PDFObject.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner;
  4 | 
  5 | use ArrayAccess;
  6 | use Exception;
  7 | use Jeidison\PdfSigner\PdfValue\PDFValue;
  8 | use Jeidison\PdfSigner\PdfValue\PDFValueObject;
  9 | use Jeidison\PdfSigner\PdfValue\PDFValueSimple;
 10 | use Stringable;
 11 | 
 12 | class PDFObject implements ArrayAccess, Stringable
 13 | {
 14 |     protected mixed $stream = null;
 15 | 
 16 |     protected null|array|PDFValue $value = null;
 17 | 
 18 |     protected int $generation;
 19 | 
 20 |     public function __construct(protected $oid, array|PDFValue $value = null, $generation = 0)
 21 |     {
 22 |         if ($value === null) {
 23 |             $value = new PDFValueObject();
 24 |         }
 25 | 
 26 |         if (is_array($value)) {
 27 |             $obj = new PDFValueObject();
 28 |             foreach ($value as $field => $v) {
 29 |                 $obj[$field] = $v;
 30 |             }
 31 | 
 32 |             $value = $obj;
 33 |         }
 34 | 
 35 |         $this->value = $value;
 36 |         $this->generation = $generation;
 37 |     }
 38 | 
 39 |     public function getKeys(): array
 40 |     {
 41 |         return $this->value->getKeys();
 42 |     }
 43 | 
 44 |     public function setOid($oid): void
 45 |     {
 46 |         $this->oid = $oid;
 47 |     }
 48 | 
 49 |     public function getGeneration(): int
 50 |     {
 51 |         return $this->generation;
 52 |     }
 53 | 
 54 |     public function __toString(): string
 55 |     {
 56 |         return $this->oid.' 0 obj
 57 | '.
 58 |             ($this->value.PHP_EOL).
 59 |             ($this->stream === null ? '' :
 60 |                 'stream
 61 | ...
 62 | endstream
 63 | '
 64 |             ).
 65 |             "endobj\n";
 66 |     }
 67 | 
 68 |     public function toPdfEntry(): string
 69 |     {
 70 |         return $this->oid.' 0 obj'.PHP_EOL.
 71 |                 $this->value.PHP_EOL.
 72 |                 ($this->stream === null ? '' :
 73 |                     "stream\r\n".
 74 |                     $this->stream.
 75 |                     PHP_EOL.'endstream'.PHP_EOL
 76 |                 ).
 77 |                 'endobj'.PHP_EOL;
 78 |     }
 79 | 
 80 |     public function getOid()
 81 |     {
 82 |         return $this->oid;
 83 |     }
 84 | 
 85 |     public function getValue()
 86 |     {
 87 |         return $this->value;
 88 |     }
 89 | 
 90 |     protected static function flateDecode($stream, $params): ?string
 91 |     {
 92 |         switch ($params['Predictor']->get_int()) {
 93 |             case 1:
 94 |                 return $stream;
 95 |             case 10:
 96 |             case 11:
 97 |             case 12:
 98 |             case 13:
 99 |             case 14:
100 |             case 15:
101 |                 break;
102 |             default:
103 |                 throw new Exception('other predictor than PNG is not supported in this version');
104 |         }
105 | 
106 |         switch ($params['Colors']->get_int()) {
107 |             case 1:
108 |                 break;
109 |             default:
110 |                 throw new Exception('other color count than 1 is not supported in this version');
111 |         }
112 | 
113 |         switch ($params['BitsPerComponent']->get_int()) {
114 |             case 8:
115 |                 break;
116 |             default:
117 |                 throw new Exception('other bit count than 8 is not supported in this version');
118 |         }
119 | 
120 |         $decoded = new Buffer();
121 |         $columns = $params['Columns']->get_int();
122 |         $streamLen = strlen((string) $stream);
123 | 
124 |         $dataPrev = str_pad('', $columns, chr(0));
125 |         $posI = 0;
126 |         while ($posI < $streamLen) {
127 |             $filterByte = ord($stream[$posI++]);
128 |             $data = substr((string) $stream, $posI, $columns);
129 |             $posI += strlen($data);
130 |             $data = str_pad($data, $columns, chr(0));
131 | 
132 |             switch ($filterByte) {
133 |                 case 0:
134 |                     break;
135 |                 case 1:
136 |                     for ($i = 1; $i < $columns; $i++) {
137 |                         $data[$i] = ($data[$i] + $data[$i - 1]) % 256;
138 |                     }
139 | 
140 |                     break;
141 |                 case 2:
142 |                     for ($i = 0; $i < $columns; $i++) {
143 |                         $data[$i] = chr((ord($data[$i]) + ord($dataPrev[$i])) % 256);
144 |                     }
145 | 
146 |                     break;
147 |                 default:
148 |                     throw new Exception('Unsupported stream');
149 |             }
150 | 
151 |             $decoded->data($data);
152 |             $dataPrev = $data;
153 |         }
154 | 
155 |         return $decoded->raw();
156 |     }
157 | 
158 |     public function getStream($raw = true): string
159 |     {
160 |         if ($raw === true) {
161 |             return $this->stream;
162 |         }
163 | 
164 |         if (isset($this->value['Filter'])) {
165 |             switch ($this->value['Filter']) {
166 |                 case '/FlateDecode':
167 |                     $DecodeParams = $this->value['DecodeParms'] ?? [];
168 |                     $params = [
169 |                         'Columns' => $DecodeParams['Columns'] ?? new PDFValueSimple(0),
170 |                         'Predictor' => $DecodeParams['Predictor'] ?? new PDFValueSimple(1),
171 |                         'BitsPerComponent' => $DecodeParams['BitsPerComponent'] ?? new PDFValueSimple(8),
172 |                         'Colors' => $DecodeParams['Colors'] ?? new PDFValueSimple(1),
173 |                     ];
174 | 
175 |                     return self::flateDecode(gzuncompress($this->stream), $params);
176 |                 default:
177 |                     throw new Exception('Unknown compression method '.$this->value['Filter']);
178 |             }
179 |         }
180 | 
181 |         return $this->stream;
182 |     }
183 | 
184 |     public function setStream($stream, $raw = true): void
185 |     {
186 |         if ($raw === true) {
187 |             $this->stream = $stream;
188 | 
189 |             return;
190 |         }
191 | 
192 |         if (isset($this->value['Filter'])) {
193 |             if ($this->value['Filter'] == '/FlateDecode') {
194 |                 $stream = gzcompress((string) $stream);
195 |             }
196 |         }
197 | 
198 |         $this->value['Length'] = strlen((string) $stream);
199 |         $this->stream = $stream;
200 |     }
201 | 
202 |     public function offsetSet($field, $value): void
203 |     {
204 |         $this->value[$field] = $value;
205 |     }
206 | 
207 |     public function offsetExists($field): bool
208 |     {
209 |         return $this->value->offsetExists($field);
210 |     }
211 | 
212 |     #[\ReturnTypeWillChange]
213 |     public function offsetGet($field)
214 |     {
215 |         return $this->value[$field];
216 |     }
217 | 
218 |     public function offsetUnset($field): void
219 |     {
220 |         $this->value->offsetUnset($field);
221 |     }
222 | 
223 |     public function push($v)
224 |     {
225 |         return $this->value->push($v);
226 |     }
227 | }
228 | 


--------------------------------------------------------------------------------
/src/PageInfo.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner;
  4 | 
  5 | use Exception;
  6 | 
  7 | class PageInfo
  8 | {
  9 |     private PdfDocument $pdfDocument;
 10 | 
 11 |     protected array $pagesInfo = [];
 12 | 
 13 |     public static function new(): self
 14 |     {
 15 |         return new self();
 16 |     }
 17 | 
 18 |     public function withPdfDocument(PdfDocument $pdfDocument): self
 19 |     {
 20 |         $this->pdfDocument = $pdfDocument;
 21 | 
 22 |         return $this;
 23 |     }
 24 | 
 25 |     public function acquirePagesInfo(): self
 26 |     {
 27 |         $root = $this->pdfDocument->getTrailerObject()['Root'];
 28 |         if (($root === false) || (($root = $root->getObjectReferenced()) === false)) {
 29 |             throw new Exception('could not find the root object from the trailer');
 30 |         }
 31 | 
 32 |         $root = $this->pdfDocument->getObject($root);
 33 |         if ($root !== false) {
 34 |             $pages = $root['Pages'];
 35 |             if (($pages === false) || (($pages = $pages->getObjectReferenced()) === false)) {
 36 |                 throw new Exception('could not find the pages for the document');
 37 |             }
 38 | 
 39 |             $this->pagesInfo = $this->getPageInfo($pages);
 40 |         }
 41 | 
 42 |         return $this;
 43 |     }
 44 | 
 45 |     protected function getPageInfo(int $oid, array $info = []): array|false
 46 |     {
 47 |         $object = $this->pdfDocument->getObject($oid);
 48 |         if ($object === false) {
 49 |             throw new Exception('could not get information about the page');
 50 |         }
 51 | 
 52 |         $pageIds = [];
 53 | 
 54 |         switch ($object['Type']->val()) {
 55 |             case 'Pages':
 56 |                 $kids = $object['Kids'];
 57 |                 $kids = $kids->getObjectReferenced();
 58 |                 if ($kids !== false) {
 59 |                     if (isset($object['MediaBox'])) {
 60 |                         $info['size'] = $object['MediaBox']->val();
 61 |                     }
 62 | 
 63 |                     foreach ($kids as $kid) {
 64 |                         $ids = $this->getPageInfo($kid, $info);
 65 |                         if ($ids === false) {
 66 |                             return false;
 67 |                         }
 68 | 
 69 |                         array_push($pageIds, ...$ids);
 70 |                     }
 71 |                 } else {
 72 |                     throw new Exception('Could not get the pages');
 73 |                 }
 74 | 
 75 |                 break;
 76 |             case 'Page':
 77 |                 if (isset($object['MediaBox'])) {
 78 |                     $info['size'] = $object['MediaBox']->val();
 79 |                 }
 80 | 
 81 |                 return [['id' => $oid, 'info' => $info]];
 82 |             default:
 83 |                 return false;
 84 |         }
 85 | 
 86 |         return $pageIds;
 87 |     }
 88 | 
 89 |     public function getPageSize($i): ?array
 90 |     {
 91 |         if (is_int($i)) {
 92 |             if ($i < 0) {
 93 |                 return null;
 94 |             }
 95 | 
 96 |             if ($i > count($this->pagesInfo)) {
 97 |                 return null;
 98 |             }
 99 | 
100 |             $pageInfo = $this->pagesInfo[$i]['info'];
101 |         } else {
102 |             foreach ($this->pagesInfo as $info) {
103 |                 if ($info['oid'] === $i->get_oid()) {
104 |                     $pageInfo = $info['info'];
105 |                     break;
106 |                 }
107 |             }
108 |         }
109 | 
110 |         return $pageInfo['size'] ?? null;
111 |     }
112 | 
113 |     public function getPage(int $i): ?PDFObject
114 |     {
115 |         if ($i < 0) {
116 |             return null;
117 |         }
118 | 
119 |         if ($i >= count($this->pagesInfo)) {
120 |             return null;
121 |         }
122 | 
123 |         return $this->pdfDocument->getObject($this->pagesInfo[$i]['id']);
124 |     }
125 | }
126 | 


--------------------------------------------------------------------------------
/src/PdfDocument.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner;
  4 | 
  5 | use DateTime;
  6 | use Exception;
  7 | use Jeidison\PdfSigner\PdfValue\PDFValue;
  8 | use Jeidison\PdfSigner\PdfValue\PDFValueString;
  9 | use Jeidison\PdfSigner\Utils\Date;
 10 | use Ramsey\Uuid\Uuid;
 11 | 
 12 | /**
 13 |  * @author Jeidison Farias <jeidison.farias@gmail.com>
 14 |  **/
 15 | class PdfDocument
 16 | {
 17 |     /** @var array<PDFObject> */
 18 |     protected array $pdfObjects = [];
 19 | 
 20 |     protected string $pdfVersion;
 21 | 
 22 |     protected PDFValue $trailerObject;
 23 | 
 24 |     protected int $xrefPosition;
 25 | 
 26 |     protected array $xrefTable;
 27 | 
 28 |     protected string $xrefTableVersion;
 29 | 
 30 |     protected array $revisions;
 31 | 
 32 |     protected Buffer $buffer;
 33 | 
 34 |     protected int $maxOid = 0;
 35 | 
 36 |     protected PageInfo $pageInfo;
 37 | 
 38 |     public function getPdfVersion(): string
 39 |     {
 40 |         return $this->pdfVersion;
 41 |     }
 42 | 
 43 |     public function setPdfVersion(string $pdfVersion): void
 44 |     {
 45 |         $this->pdfVersion = $pdfVersion;
 46 |     }
 47 | 
 48 |     public function getTrailerObject(): PDFValue
 49 |     {
 50 |         return $this->trailerObject;
 51 |     }
 52 | 
 53 |     public function setTrailerObject(PDFValue $trailerObject): void
 54 |     {
 55 |         $this->trailerObject = $trailerObject;
 56 |     }
 57 | 
 58 |     public function getXrefPosition(): int
 59 |     {
 60 |         return $this->xrefPosition;
 61 |     }
 62 | 
 63 |     public function setXrefPosition(int $xrefPosition): void
 64 |     {
 65 |         $this->xrefPosition = $xrefPosition;
 66 |     }
 67 | 
 68 |     public function getXrefTable(): array
 69 |     {
 70 |         return $this->xrefTable;
 71 |     }
 72 | 
 73 |     public function setXrefTable(array $xrefTable): void
 74 |     {
 75 |         $this->xrefTable = $xrefTable;
 76 |     }
 77 | 
 78 |     public function getXrefTableVersion(): string
 79 |     {
 80 |         return $this->xrefTableVersion;
 81 |     }
 82 | 
 83 |     public function setXrefTableVersion(string $xrefTableVersion): void
 84 |     {
 85 |         $this->xrefTableVersion = $xrefTableVersion;
 86 |     }
 87 | 
 88 |     public function getRevisions(): array
 89 |     {
 90 |         return $this->revisions;
 91 |     }
 92 | 
 93 |     public function setRevisions(array $revisions): void
 94 |     {
 95 |         $this->revisions = $revisions;
 96 |     }
 97 | 
 98 |     public function getBuffer(): Buffer
 99 |     {
100 |         return $this->buffer;
101 |     }
102 | 
103 |     public function setBufferFromString(string $buffer): void
104 |     {
105 |         $this->buffer = new Buffer($buffer);
106 |     }
107 | 
108 |     public function getPdfObjects(): array
109 |     {
110 |         return $this->pdfObjects;
111 |     }
112 | 
113 |     public function setPdfObjects(array $pdfObjects): void
114 |     {
115 |         $this->pdfObjects = $pdfObjects;
116 |     }
117 | 
118 |     public function getMaxOid(): int
119 |     {
120 |         return $this->maxOid;
121 |     }
122 | 
123 |     public function setMaxOid(int $maxOid): void
124 |     {
125 |         $this->maxOid = $maxOid;
126 |     }
127 | 
128 |     protected function getNewOid(): int
129 |     {
130 |         $this->maxOid++;
131 | 
132 |         return $this->maxOid;
133 |     }
134 | 
135 |     public function createObject($value = [], $class = PDFObject::class, $autoAdd = true): PDFObject
136 |     {
137 |         $classPdfObject = new $class($this->getNewOid(), $value);
138 |         if ($autoAdd === true) {
139 |             $this->addObject($classPdfObject);
140 |         }
141 | 
142 |         return $classPdfObject;
143 |     }
144 | 
145 |     public function addObject(PDFObject $pdfObject): bool
146 |     {
147 |         $oid = $pdfObject->getOid();
148 | 
149 |         if (isset($this->pdfObjects[$oid]) && $this->pdfObjects[$oid]->getGeneration() > $pdfObject->getGeneration()) {
150 |             return false;
151 |         }
152 | 
153 |         $this->pdfObjects[$oid] = $pdfObject;
154 | 
155 |         if ($oid > $this->maxOid) {
156 |             $this->maxOid = $oid;
157 |         }
158 | 
159 |         return true;
160 |     }
161 | 
162 |     public function getObject($oid, $originalVersion = false): ?PDFObject
163 |     {
164 |         if ($originalVersion === true) {
165 |             // Prioritizing the original version
166 |             $object = $this->findObject($oid);
167 |             if ($object == null) {
168 |                 $object = $this->pdfObjects[$oid] ?? false;
169 |             }
170 | 
171 |         } else {
172 |             // Prioritizing the new versions
173 |             $object = $this->pdfObjects[$oid] ?? false;
174 |             if ($object == null) {
175 |                 $object = $this->findObject($oid);
176 |             }
177 |         }
178 | 
179 |         return $object;
180 |     }
181 | 
182 |     public function findObject(int $oid): ?PDFObject
183 |     {
184 |         if ($oid === 0) {
185 |             return null;
186 |         }
187 | 
188 |         if (! isset($this->xrefTable[$oid])) {
189 |             return null;
190 |         }
191 | 
192 |         $objectOffset = $this->xrefTable[$oid];
193 | 
194 |         if (! is_array($objectOffset)) {
195 |             return $this->findObjectAtPos($oid, $objectOffset);
196 |         }
197 | 
198 |         return $this->findObjectInObjStm($objectOffset['stmoid'], $objectOffset['pos'], $oid);
199 |     }
200 | 
201 |     public function findObjectInObjStm($objstmOid, $objpos, $oid): PDFObject
202 |     {
203 |         $objstm = $this->findObject($objstmOid);
204 |         if ($objstm === false) {
205 |             throw new Exception('could not get object stream '.$objstmOid);
206 |         }
207 | 
208 |         if (($objstm['Extends'] ?? false !== false)) {
209 |             throw new Exception('not supporting extended object streams at this time');
210 |         }
211 | 
212 |         $First = $objstm['First'] ?? false;
213 |         $N = $objstm['N'] ?? false;
214 |         $Type = $objstm['Type'] ?? false;
215 | 
216 |         if (($First === false) || ($N === false) || ($Type === false)) {
217 |             throw new Exception('invalid object stream '.$objstmOid);
218 |         }
219 | 
220 |         if ($Type->val() !== 'ObjStm') {
221 |             throw new Exception(sprintf('object %s is not an object stream', $objstmOid));
222 |         }
223 | 
224 |         $First = $First->get_int();
225 | 
226 |         $stream = $objstm->getStream(false);
227 |         $index = substr((string) $stream, 0, $First);
228 |         $index = explode(' ', trim($index));
229 | 
230 |         $stream = substr((string) $stream, $First);
231 | 
232 |         if (count($index) % 2 !== 0) {
233 |             throw new Exception('invalid index for object stream '.$objstmOid);
234 |         }
235 | 
236 |         $objpos *= 2;
237 |         if ($objpos > count($index)) {
238 |             throw new Exception(sprintf('object %s not found in object stream %s', $oid, $objstmOid));
239 |         }
240 | 
241 |         $offset = (int) $index[$objpos + 1];
242 |         $offsets = [];
243 |         $counter = count($index);
244 |         for ($i = 1; ($i < $counter); $i += 2) {
245 |             $offsets[] = (int) $index[$i];
246 |         }
247 | 
248 |         $offsets[] = strlen($stream);
249 |         sort($offsets);
250 | 
251 |         $next = $offsets[$i];
252 |         $objectDefStr = $oid.' 0 obj '.substr($stream, $offset, $next - $offset).' endobj';
253 | 
254 |         return $this->objectFromString($objectDefStr, $oid);
255 |     }
256 | 
257 |     public function findObjectAtPos($oid, $objectOffset): PDFObject
258 |     {
259 |         $object = $this->objectFromString($oid, $objectOffset, $offsetEnd);
260 | 
261 |         $streamPending = false;
262 |         if (substr($this->buffer, $offsetEnd - 7, 7) === "stream\n") {
263 |             $streamPending = $offsetEnd;
264 |         }
265 | 
266 |         if (substr($this->buffer, $offsetEnd - 7, 8) === "stream\r\n") {
267 |             $streamPending = $offsetEnd + 1;
268 |         }
269 | 
270 |         if ($streamPending !== false) {
271 |             $length = $object['Length']->getInt();
272 |             if ($length === false) {
273 |                 $lengthObjectId = $object['Length']->getObjectReferenced();
274 |                 if ($lengthObjectId === false) {
275 |                     throw new Exception('could not get stream for object ');
276 |                 }
277 | 
278 |                 $lengthObject = $this->findObject($lengthObjectId);
279 |                 if ($lengthObject === false) {
280 |                     throw new Exception('could not get object '.$oid);
281 |                 }
282 | 
283 |                 $length = $lengthObject->getValue()->getInt();
284 |             }
285 | 
286 |             if ($length === false) {
287 |                 throw new Exception('could not get stream length for object ');
288 |             }
289 | 
290 |             $object->setStream(substr((string) $this->buffer, $streamPending, $length));
291 |         }
292 | 
293 |         return $object;
294 |     }
295 | 
296 |     public function objectFromString($expectedObjId, $offset = 0, &$offsetEnd = 0): PDFObject
297 |     {
298 |         if (preg_match('/(\d+)\s+(\d+)\s+obj/ms', $this->buffer, $matches, 0, $offset) !== 1) {
299 |             throw new Exception('Object is not valid: '.$expectedObjId);
300 |         }
301 | 
302 |         $foundObjHeader = $matches[0];
303 |         $foundObjId = (int) $matches[1];
304 |         $foundObjGeneration = (int) $matches[2];
305 | 
306 |         if ($expectedObjId === null) {
307 |             $expectedObjId = $foundObjId;
308 |         }
309 | 
310 |         if ($foundObjId !== $expectedObjId) {
311 |             throw new Exception(sprintf('Pdf structure is corrupt: found obj %d while searching for obj %s (at %s)', $foundObjId, $expectedObjId, $offset));
312 |         }
313 | 
314 |         $offset += strlen($foundObjHeader);
315 | 
316 |         $parser = new ObjectParser();
317 |         $stream = new StreamReader($this->buffer, $offset);
318 | 
319 |         $objParsed = $parser->parse($stream);
320 |         if ($objParsed === false) {
321 |             throw new Exception(sprintf('Object %d could not be parsed', $expectedObjId));
322 |         }
323 | 
324 |         switch ($parser->currentToken()) {
325 |             case ObjectParser::T_STREAM_BEGIN:
326 |             case ObjectParser::T_OBJECT_END:
327 |                 break;
328 |             default:
329 |                 throw new Exception('Malformed object');
330 |         }
331 | 
332 |         $offsetEnd = $stream->getPosition();
333 | 
334 |         return new PDFObject($foundObjId, $objParsed, $foundObjGeneration);
335 |     }
336 | 
337 |     public function updateModifyDate(DateTime $date = null): bool
338 |     {
339 |         $root = $this->trailerObject['Root'];
340 |         if (($root === false) || (($root = $root->getObjectReferenced()) === false)) {
341 |             throw new Exception('Could not find the root object from the trailer');
342 |         }
343 | 
344 |         $rootObj = $this->getObject($root);
345 |         if ($rootObj === false) {
346 |             throw new Exception('Invalid root object');
347 |         }
348 | 
349 |         $date ??= new DateTime();
350 | 
351 |         if (isset($rootObj['Metadata'])) {
352 |             $metadata = $rootObj['Metadata'];
353 |             if ((($referenced = $metadata->get_object_referenced()) !== false) && (! is_array($referenced))) {
354 |                 $metadata = $this->getObject($referenced);
355 |                 $metaStream = $metadata->getStream();
356 |                 $metaStream = preg_replace('/<xmp:ModifyDate>([^<]*)<\/xmp:ModifyDate>/', '<xmp:ModifyDate>'.$date->format('c').'</xmp:ModifyDate>', $metaStream);
357 |                 $metaStream = preg_replace('/<xmp:MetadataDate>([^<]*)<\/xmp:MetadataDate>/', '<xmp:MetadataDate>'.$date->format('c').'</xmp:MetadataDate>', $metaStream);
358 |                 $metaStream = preg_replace('/<xmpMM:InstanceID>([^<]*)<\/xmpMM:InstanceID>/', '<xmpMM:InstanceID>uuid:'.Uuid::uuid4()->toString().'</xmpMM:InstanceID>', $metaStream);
359 |                 $metadata->setStream($metaStream, false);
360 |                 $this->addObject($metadata);
361 |             }
362 |         }
363 | 
364 |         $info = $this->trailerObject['Info'];
365 |         if (($info === false) || (($info = $info->getObjectReferenced()) === false)) {
366 |             throw new Exception('Could not find the info object from the trailer');
367 |         }
368 | 
369 |         $infoObj = $this->getObject($info);
370 |         if ($infoObj === false) {
371 |             throw new Exception('Invalid info object');
372 |         }
373 | 
374 |         $infoObj['ModDate'] = new PDFValueString(Date::toPdfDateString($date));
375 |         $infoObj['Producer'] = 'Modifier with PHP Signer';
376 |         $this->addObject($infoObj);
377 | 
378 |         return true;
379 |     }
380 | 
381 |     public function acquirePagesInfo(): void
382 |     {
383 |         $this->pageInfo = PageInfo::new()
384 |             ->withPdfDocument($this)
385 |             ->acquirePagesInfo();
386 |     }
387 | 
388 |     public function getPageInfo(): PageInfo
389 |     {
390 |         return $this->pageInfo;
391 |     }
392 | }
393 | 


--------------------------------------------------------------------------------
/src/PdfValue/PDFValue.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner\PdfValue;
  4 | 
  5 | use ArrayAccess;
  6 | use Exception;
  7 | use Stringable;
  8 | 
  9 | abstract class PDFValue implements ArrayAccess, Stringable
 10 | {
 11 |     public function __construct(protected mixed $value)
 12 |     {
 13 |     }
 14 | 
 15 |     public function val(): mixed
 16 |     {
 17 |         return $this->value;
 18 |     }
 19 | 
 20 |     public function __toString(): string
 21 |     {
 22 |         return ''.$this->value;
 23 |     }
 24 | 
 25 |     public function offsetExists($offset): bool
 26 |     {
 27 |         if (! is_array($this->value)) {
 28 |             return false;
 29 |         }
 30 | 
 31 |         return isset($this->value[$offset]);
 32 |     }
 33 | 
 34 |     public function offsetGet($offset): mixed
 35 |     {
 36 |         if (! is_array($this->value)) {
 37 |             return null;
 38 |         }
 39 | 
 40 |         if (! isset($this->value[$offset])) {
 41 |             return null;
 42 |         }
 43 | 
 44 |         return $this->value[$offset];
 45 |     }
 46 | 
 47 |     public function offsetSet($offset, $value): void
 48 |     {
 49 |         if (! is_array($this->value)) {
 50 |             return;
 51 |         }
 52 | 
 53 |         $this->value[$offset] = $value;
 54 |     }
 55 | 
 56 |     public function offsetUnset($offset): void
 57 |     {
 58 |         if ((! is_array($this->value)) || (! isset($this->value[$offset]))) {
 59 |             throw new Exception('Invalid offset');
 60 |         }
 61 | 
 62 |         unset($this->value[$offset]);
 63 |     }
 64 | 
 65 |     public function push(mixed $value): bool
 66 |     {
 67 |         return false;
 68 |     }
 69 | 
 70 |     public function getInt(): bool
 71 |     {
 72 |         return false;
 73 |     }
 74 | 
 75 |     public function getObjectReferenced(): mixed
 76 |     {
 77 |         return false;
 78 |     }
 79 | 
 80 |     public function getKeys()
 81 |     {
 82 |         return null;
 83 |     }
 84 | 
 85 |     protected static function convert(mixed $value): PDFValue
 86 |     {
 87 |         switch (gettype($value)) {
 88 |             case 'integer':
 89 |             case 'double':
 90 |                 return new PDFValueSimple($value);
 91 |             case 'string':
 92 |                 if ($value[0] === '/') {
 93 |                     return new PDFValueType(substr($value, 1));
 94 |                 } elseif (preg_match("/\s/ms", $value) === 1) {
 95 |                     return new PDFValueString($value);
 96 |                 }
 97 | 
 98 |                 return new PDFValueSimple($value);
 99 |             case 'array':
100 |                 if ($value === []) {
101 |                     return new PDFValueList();
102 |                 }
103 | 
104 |                 $obj = PDFValueObject::fromArray($value);
105 |                 if ($obj != null) {
106 |                     return $obj;
107 |                 }
108 | 
109 |                 $list = [];
110 |                 foreach ($value as $v) {
111 |                     $list[] = self::convert($v);
112 |                 }
113 | 
114 |                 return new PDFValueList($list);
115 |         }
116 | 
117 |         return $value;
118 |     }
119 | }
120 | 


--------------------------------------------------------------------------------
/src/PdfValue/PDFValueHexString.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Jeidison\PdfSigner\PdfValue;
 4 | 
 5 | class PDFValueHexString extends PDFValueString
 6 | {
 7 |     public function __toString(): string
 8 |     {
 9 |         return '<'.trim((string) $this->value).'>';
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/PdfValue/PDFValueList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Jeidison\PdfSigner\PdfValue;
 4 | 
 5 | class PDFValueList extends PDFValue
 6 | {
 7 |     public function __construct($value = [])
 8 |     {
 9 |         parent::__construct($value);
10 |     }
11 | 
12 |     public function __toString(): string
13 |     {
14 |         return '['.implode(' ', $this->value).']';
15 |     }
16 | 
17 |     public function val($list = false): array
18 |     {
19 |         if ($list === true) {
20 |             $result = [];
21 |             foreach ($this->value as $v) {
22 |                 $v = is_a($v, PDFValueSimple::class) ? explode(' ', (string) $v->val()) : [$v->val()];
23 |                 array_push($result, ...$v);
24 |             }
25 | 
26 |             return $result;
27 |         } else {
28 |             return parent::val();
29 |         }
30 |     }
31 | 
32 |     public function getObjectReferenced(): array|false
33 |     {
34 |         $ids = [];
35 |         $plainTextVal = implode(' ', $this->value);
36 |         if (trim($plainTextVal) == '') {
37 |             return $ids;
38 |         }
39 | 
40 |         $countFound = preg_match_all('/(([0-9]+)\s+[0-9]+\s+R)[^0-9]*/m', $plainTextVal, $matches);
41 |         if ($countFound <= 0) {
42 |             return false;
43 |         }
44 | 
45 |         $rebuilt = implode(' ', $matches[0]);
46 |         $rebuilt = preg_replace('/\s+/m', ' ', $rebuilt);
47 | 
48 |         $plainTextVal = preg_replace('/\s+/m', ' ', $plainTextVal);
49 |         if ($plainTextVal === $rebuilt) {
50 |             foreach ($matches[2] as $id) {
51 |                 $ids[] = (int) $id;
52 |             }
53 |         }
54 | 
55 |         return $ids;
56 |     }
57 | 
58 |     public function push(mixed $value): bool
59 |     {
60 |         if (is_object($value) && ($value::class === static::class)) {
61 |             $value = $value->val();
62 |         }
63 | 
64 |         if (! is_array($value)) {
65 |             $value = [$value];
66 |         }
67 | 
68 |         foreach ($value as $e) {
69 |             $e = self::convert($e);
70 |             $this->value[] = $e;
71 |         }
72 | 
73 |         return true;
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/src/PdfValue/PDFValueObject.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner\PdfValue;
  4 | 
  5 | class PDFValueObject extends PDFValue
  6 | {
  7 |     public function __construct(array $value = [])
  8 |     {
  9 |         $result = [];
 10 |         foreach ($value as $k => $v) {
 11 |             $result[$k] = self::convert($v);
 12 |         }
 13 | 
 14 |         parent::__construct($result);
 15 |     }
 16 | 
 17 |     public static function fromArray($parts): ?PDFValueObject
 18 |     {
 19 |         $k = array_keys($parts);
 20 |         $intkeys = false;
 21 |         $result = [];
 22 |         foreach ($k as $ck) {
 23 |             if (is_int($ck)) {
 24 |                 $intkeys = true;
 25 |                 break;
 26 |             }
 27 |         }
 28 | 
 29 |         if ($intkeys) {
 30 |             return null;
 31 |         }
 32 | 
 33 |         foreach ($parts as $k => $v) {
 34 |             $result[$k] = self::convert($v);
 35 |         }
 36 | 
 37 |         return new PDFValueObject($result);
 38 |     }
 39 | 
 40 |     public static function fromString($str): ?PDFValueObject
 41 |     {
 42 |         $result = [];
 43 |         $field = null;
 44 |         $parts = explode(' ', (string) $str);
 45 |         $counter = count($parts);
 46 |         for ($i = 0; $i < $counter; $i++) {
 47 | 
 48 |             if ($field === null) {
 49 |                 $field = $parts[$i];
 50 |                 if ($field === '') {
 51 |                     return null;
 52 |                 }
 53 | 
 54 |                 if ($field[0] !== '/') {
 55 |                     return null;
 56 |                 }
 57 | 
 58 |                 $field = substr($field, 1);
 59 |                 if ($field === '') {
 60 |                     return null;
 61 |                 }
 62 | 
 63 |                 continue;
 64 |             }
 65 | 
 66 |             $value = $parts[$i];
 67 |             $result[$field] = $value;
 68 |             $field = null;
 69 |         }
 70 | 
 71 |         if ($field !== null) {
 72 |             return null;
 73 |         }
 74 | 
 75 |         return new PDFValueObject($result);
 76 |     }
 77 | 
 78 |     public function getKeys(): array
 79 |     {
 80 |         return array_keys($this->value);
 81 |     }
 82 | 
 83 |     public function offsetSet($offset, $value): void
 84 |     {
 85 |         if ($value === null) {
 86 |             if (isset($this->value[$offset])) {
 87 |                 unset($this->value[$offset]);
 88 |             }
 89 |         }
 90 | 
 91 |         $this->value[$offset] = self::convert($value);
 92 |     }
 93 | 
 94 |     public function offsetExists($offset): bool
 95 |     {
 96 |         return isset($this->value[$offset]);
 97 |     }
 98 | 
 99 |     public function __toString(): string
100 |     {
101 |         $result = [];
102 |         foreach ($this->value as $k => $v) {
103 |             $v = ''.$v;
104 |             if ($v === '') {
105 |                 $result[] = '/'.$k;
106 | 
107 |                 continue;
108 |             }
109 | 
110 |             match ($v[0]) {
111 |                 '/', '[', '(', '<' => array_push($result, sprintf('/%s%s', $k, $v)),
112 |                 default => array_push($result, sprintf('/%s %s', $k, $v)),
113 |             };
114 |         }
115 | 
116 |         return '<<'.implode('', $result).'>>';
117 |     }
118 | }
119 | 


--------------------------------------------------------------------------------
/src/PdfValue/PDFValueReference.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Jeidison\PdfSigner\PdfValue;
 4 | 
 5 | class PDFValueReference extends PDFValueSimple
 6 | {
 7 |     public function __construct($oid)
 8 |     {
 9 |         parent::__construct(sprintf('%d 0 R', $oid));
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/PdfValue/PDFValueSimple.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Jeidison\PdfSigner\PdfValue;
 4 | 
 5 | class PDFValueSimple extends PDFValue
 6 | {
 7 |     public function push($value): bool
 8 |     {
 9 |         if ($value::class === static::class) {
10 |             $this->value = $this->value.' '.$value->val();
11 | 
12 |             return true;
13 |         }
14 | 
15 |         return false;
16 |     }
17 | 
18 |     public function getObjectReferenced(): mixed
19 |     {
20 |         if (! preg_match('/^\s*([0-9]+)\s+([0-9]+)\s+R\s*$/ms', (string) $this->value, $matches)) {
21 |             return false;
22 |         }
23 | 
24 |         return (int) $matches[1];
25 |     }
26 | 
27 |     public function getInt(): bool
28 |     {
29 |         if (! is_numeric($this->value)) {
30 |             return false;
31 |         }
32 | 
33 |         return (int) $this->value;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/PdfValue/PDFValueString.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Jeidison\PdfSigner\PdfValue;
 4 | 
 5 | class PDFValueString extends PDFValue
 6 | {
 7 |     public function __toString(): string
 8 |     {
 9 |         return '('.trim($this->value).')';
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/PdfValue/PDFValueType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Jeidison\PdfSigner\PdfValue;
 4 | 
 5 | class PDFValueType extends PDFValue
 6 | {
 7 |     public function __toString(): string
 8 |     {
 9 |         return '/'.trim((string) $this->value);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Signature.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner;
  4 | 
  5 | use Exception;
  6 | use Jeidison\PdfSigner\PdfValue\PDFValueList;
  7 | use Jeidison\PdfSigner\PdfValue\PDFValueObject;
  8 | use Jeidison\PdfSigner\PdfValue\PDFValueReference;
  9 | use Jeidison\PdfSigner\PdfValue\PDFValueSimple;
 10 | use Jeidison\PdfSigner\PdfValue\PDFValueString;
 11 | use Jeidison\PdfSigner\Utils\Str;
 12 | 
 13 | class Signature
 14 | {
 15 |     const SIGNATURE_MAX_LENGTH = 11742;
 16 | 
 17 |     private array $certificate = [
 18 |         'cert' => '',
 19 |         'pkey' => '',
 20 |         'extracerts' => '',
 21 |     ];
 22 | 
 23 |     private Metadata $metadata;
 24 | 
 25 |     private SignatureAppearance $appearance;
 26 | 
 27 |     private PdfDocument $pdfDocument;
 28 | 
 29 |     public function __construct()
 30 |     {
 31 |         $this->appearance = SignatureAppearance::new();
 32 |     }
 33 | 
 34 |     public static function new(): self
 35 |     {
 36 |         return new self();
 37 |     }
 38 | 
 39 |     public function withCertificate(array $certificate): self
 40 |     {
 41 |         $this->certificate = $certificate;
 42 | 
 43 |         return $this;
 44 |     }
 45 | 
 46 |     public function withAppearance(SignatureAppearance $appearance): self
 47 |     {
 48 |         $this->appearance = $appearance;
 49 | 
 50 |         return $this;
 51 |     }
 52 | 
 53 |     public function withoutAppearance(): self
 54 |     {
 55 |         $this->appearance->withImage(null);
 56 | 
 57 |         return $this;
 58 |     }
 59 | 
 60 |     public function withPdfDocument(PdfDocument $pdfDocument): self
 61 |     {
 62 |         $this->pdfDocument = $pdfDocument;
 63 | 
 64 |         return $this;
 65 |     }
 66 | 
 67 |     public function withMetadata(Metadata $metadata): self
 68 |     {
 69 |         $this->metadata = $metadata;
 70 | 
 71 |         return $this;
 72 |     }
 73 | 
 74 |     public function hasCertificate(): bool
 75 |     {
 76 |         return ! empty($this->certificate['cert']);
 77 |     }
 78 | 
 79 |     public function generateSignatureInDocument(): SignatureObject
 80 |     {
 81 |         $rectToAppear = $this->appearance->getReact();
 82 |         $pageToAppear = $this->appearance->getPageToAppear();
 83 | 
 84 |         $trailerObject = $this->pdfDocument->getTrailerObject();
 85 |         $root = $trailerObject['Root'];
 86 | 
 87 |         if (($root === false) || (($root = $root->getObjectReferenced()) === false)) {
 88 |             throw new Exception('Could not find the root object from the trailer');
 89 |         }
 90 | 
 91 |         $rootObj = $this->pdfDocument->getObject($root);
 92 |         if ($rootObj == null) {
 93 |             throw new Exception('Invalid root object');
 94 |         }
 95 | 
 96 |         $pageObj = $this->pdfDocument->getPageInfo()->getPage($pageToAppear);
 97 |         if ($pageObj == null) {
 98 |             throw new Exception('Invalid page');
 99 |         }
100 | 
101 |         $updatedObjects = [];
102 |         if (! isset($pageObj['Annots'])) {
103 |             $pageObj['Annots'] = new PDFValueList();
104 |         }
105 | 
106 |         $annots = $pageObj['Annots'];
107 | 
108 |         if ((($referenced = $annots->getObjectReferenced()) !== false) && (! is_array($referenced))) {
109 |             $newAnnots = $this->pdfDocument->createObject(
110 |                 $this->pdfDocument->getObject($referenced)->getValue()
111 |             );
112 |         } else {
113 |             $newAnnots = $this->pdfDocument->createObject(new PDFValueList());
114 |             $newAnnots->push($annots);
115 |         }
116 | 
117 |         $annotationObject = $this->pdfDocument->createObject([
118 |             'Type' => '/Annot',
119 |             'Subtype' => '/Widget',
120 |             'FT' => '/Sig',
121 |             'V' => new PDFValueString(''),
122 |             'T' => new PDFValueString('Signature'.Str::random()),
123 |             'P' => new PDFValueReference($pageObj->getOid()),
124 |             'Rect' => $rectToAppear,
125 |             'F' => 132,
126 |         ]);
127 | 
128 |         $signature = $this->pdfDocument->createObject([], SignatureObject::class, false);
129 |         $annotationObject['V'] = new PDFValueReference($signature->getOid());
130 | 
131 |         if ($this->appearance->getImage() != null) {
132 |             $pageRotation = $pageObj['Rotate'] ?? new PDFValueSimple(0);
133 | 
134 |             $annotationObject = $this->appearance
135 |                 ->withPageRotate($pageRotation)
136 |                 ->withAnnotationObject($annotationObject)
137 |                 ->withPdfDocument($this->pdfDocument)
138 |                 ->generate();
139 |         }
140 | 
141 |         if (! $newAnnots->push(new PDFValueReference($annotationObject->getOid()))) {
142 |             throw new Exception('Could not update the page where the signature has to appear');
143 |         }
144 | 
145 |         $pageObj['Annots'] = new PDFValueReference($newAnnots->getOid());
146 |         $updatedObjects[] = $pageObj;
147 | 
148 |         if (! isset($rootObj['AcroForm'])) {
149 |             $rootObj['AcroForm'] = new PDFValueObject();
150 |         }
151 | 
152 |         $acroForm = $rootObj['AcroForm'];
153 |         if ((($referenced = $acroForm->getObjectReferenced()) !== false) && (! is_array($referenced))) {
154 |             $updatedObjects[] = $acroForm = $this->pdfDocument->getObject($referenced);
155 |         } else {
156 |             $updatedObjects[] = $rootObj;
157 |         }
158 | 
159 |         $acroForm['SigFlags'] = 3;
160 |         if (! isset($acroForm['Fields'])) {
161 |             $acroForm['Fields'] = new PDFValueList();
162 |         }
163 | 
164 |         if (! $acroForm['Fields']->push(new PDFValueReference($annotationObject->getOid()))) {
165 |             throw new Exception('Could not create the signature field');
166 |         }
167 | 
168 |         foreach ($updatedObjects as $object) {
169 |             $this->pdfDocument->addObject($object);
170 |         }
171 | 
172 |         /** @var SignatureObject $signature */
173 |         return $signature->withName($this->metadata->getName())
174 |             ->withLocation($this->metadata->getLocation())
175 |             ->withReason($this->metadata->getReason())
176 |             ->withContactInfo($this->metadata->getContactInfo());
177 |     }
178 | 
179 |     public function calculatePkcs7Signature($fileNameToSign, $tmpFolder = '/tmp'): string
180 |     {
181 |         $filesizeOriginal = filesize($fileNameToSign);
182 |         if ($filesizeOriginal === false) {
183 |             throw new Exception('Could not open file '.$fileNameToSign);
184 |         }
185 | 
186 |         $tempFilename = tempnam($tmpFolder, 'pdfsign');
187 |         if ($tempFilename === false) {
188 |             throw new Exception('Could not create a temporary filename');
189 |         }
190 | 
191 |         if (! openssl_pkcs7_sign($fileNameToSign, $tempFilename, $this->certificate['cert'], $this->certificate['pkey'], [], PKCS7_BINARY | PKCS7_DETACHED)) {
192 |             unlink($tempFilename);
193 | 
194 |             throw new Exception('Failed to sign file '.$fileNameToSign);
195 |         }
196 | 
197 |         $signature = file_get_contents($tempFilename);
198 |         $signature = substr($signature, $filesizeOriginal);
199 |         $signature = substr($signature, (strpos($signature, "%%EOF\n\n------") + 13));
200 | 
201 |         $tmpArr = explode("\n\n", $signature);
202 |         $signature = $tmpArr[1];
203 | 
204 |         $signature = base64_decode(trim($signature));
205 |         $signature = current(unpack('H*', $signature));
206 | 
207 |         return str_pad($signature, self::SIGNATURE_MAX_LENGTH, '0');
208 |     }
209 | }
210 | 


--------------------------------------------------------------------------------
/src/SignatureAppearance.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner;
  4 | 
  5 | use Jeidison\PdfSigner\PdfValue\PDFValue;
  6 | use Jeidison\PdfSigner\PdfValue\PDFValueObject;
  7 | use Jeidison\PdfSigner\PdfValue\PDFValueReference;
  8 | use Jeidison\PdfSigner\PdfValue\PDFValueSimple;
  9 | use Jeidison\PdfSigner\Utils\Img;
 10 | 
 11 | class SignatureAppearance
 12 | {
 13 |     private ?string $imageFileName = null;
 14 | 
 15 |     private array $rectToAppear = [0, 0, 0, 0];
 16 | 
 17 |     private int $pageToAppear = 0;
 18 | 
 19 |     private PdfDocument $pdfDocument;
 20 | 
 21 |     private PDFObject $annotationObject;
 22 | 
 23 |     private PDFValue $pageRotation;
 24 | 
 25 |     public static function new(): self
 26 |     {
 27 |         return new self();
 28 |     }
 29 | 
 30 |     public function getReact(): array
 31 |     {
 32 |         return $this->rectToAppear;
 33 |     }
 34 | 
 35 |     public function getPageToAppear(): int
 36 |     {
 37 |         return $this->pageToAppear;
 38 |     }
 39 | 
 40 |     public function getImage(): ?string
 41 |     {
 42 |         return $this->imageFileName;
 43 |     }
 44 | 
 45 |     public function addSignAppearanceInPage(int $pageToAppear): self
 46 |     {
 47 |         $this->pageToAppear = $pageToAppear;
 48 | 
 49 |         return $this;
 50 |     }
 51 | 
 52 |     public function withRect(array $rect): self
 53 |     {
 54 |         $this->rectToAppear = $rect;
 55 | 
 56 |         return $this;
 57 |     }
 58 | 
 59 |     public function withImage(?string $imageFileName): self
 60 |     {
 61 |         $this->imageFileName = $imageFileName;
 62 | 
 63 |         return $this;
 64 |     }
 65 | 
 66 |     public function withPdfDocument(PdfDocument $pdfDocument): self
 67 |     {
 68 |         $this->pdfDocument = $pdfDocument;
 69 | 
 70 |         return $this;
 71 |     }
 72 | 
 73 |     public function withAnnotationObject(PDFObject $annotationObject): self
 74 |     {
 75 |         $this->annotationObject = $annotationObject;
 76 | 
 77 |         return $this;
 78 |     }
 79 | 
 80 |     public function withPageRotate(PDFValue $pageRotation): self
 81 |     {
 82 |         $this->pageRotation = $pageRotation;
 83 | 
 84 |         return $this;
 85 |     }
 86 | 
 87 |     public function generate(): PDFObject
 88 |     {
 89 |         $pageSize = $this->pdfDocument->getPageInfo()->getPageSize($this->pageToAppear);
 90 |         $pageSize = explode(' ', (string) $pageSize[0]->val());
 91 |         $pageSizeH = (float) ($pageSize[3]) - (float) ($pageSize[1]);
 92 | 
 93 |         $bbox = [0, 0, $this->rectToAppear[2] - $this->rectToAppear[0], $this->rectToAppear[3] - $this->rectToAppear[1]];
 94 |         $formObject = $this->pdfDocument->createObject([
 95 |             'BBox' => $bbox,
 96 |             'Subtype' => '/Form',
 97 |             'Type' => '/XObject',
 98 |             'Group' => [
 99 |                 'Type' => '/Group',
100 |                 'S' => '/Transparency',
101 |                 'CS' => '/DeviceRGB',
102 |             ],
103 |         ]);
104 | 
105 |         $containerFormObject = $this->pdfDocument->createObject([
106 |             'BBox' => $bbox,
107 |             'Subtype' => '/Form',
108 |             'Type' => '/XObject',
109 |             'Resources' => ['XObject' => [
110 |                 'n0' => new PDFValueSimple(''),
111 |                 'n2' => new PDFValueSimple(''),
112 |             ]],
113 |         ]);
114 |         $containerFormObject->setStream("q 1 0 0 1 0 0 cm /n0 Do Q\nq 1 0 0 1 0 0 cm /n2 Do Q\n", false);
115 | 
116 |         $layerN0 = $this->pdfDocument->createObject([
117 |             'BBox' => [0.0, 0.0, 100.0, 100.0],
118 |             'Subtype' => '/Form',
119 |             'Type' => '/XObject',
120 |             'Resources' => new PDFValueObject(),
121 |         ]);
122 | 
123 |         $layerN0->setStream('% DSBlank'.PHP_EOL, false);
124 | 
125 |         $layerN2 = $this->pdfDocument->createObject([
126 |             'BBox' => $bbox,
127 |             'Subtype' => '/Form',
128 |             'Type' => '/XObject',
129 |             'Resources' => new PDFValueObject(),
130 |         ]);
131 | 
132 |         $result = Img::addImage(
133 |             $this->pdfDocument->createObject(...),
134 |             $this->imageFileName,
135 |             $bbox[0],
136 |             $bbox[1],
137 |             $bbox[2],
138 |             $bbox[3],
139 |             $this->pageRotation->val()
140 |         );
141 | 
142 |         $layerN2['Resources'] = $result['resources'];
143 |         $layerN2->setStream($result['command'], false);
144 | 
145 |         $containerFormObject['Resources']['XObject']['n0'] = new PDFValueReference($layerN0->getOid());
146 |         $containerFormObject['Resources']['XObject']['n2'] = new PDFValueReference($layerN2->getOid());
147 | 
148 |         $formObject['Resources'] = new PDFValueObject([
149 |             'XObject' => [
150 |                 'FRM' => new PDFValueReference($containerFormObject->getOid()),
151 |             ],
152 |         ]);
153 |         $formObject->setStream('/FRM Do', false);
154 | 
155 |         $this->annotationObject['AP'] = ['N' => new PDFValueReference($formObject->getOid())];
156 |         $this->annotationObject['Rect'] = [
157 |             $this->rectToAppear[0],
158 |             $pageSizeH - $this->rectToAppear[1],
159 |             $this->rectToAppear[2],
160 |             $pageSizeH - $this->rectToAppear[3],
161 |         ];
162 | 
163 |         return $this->annotationObject;
164 |     }
165 | }
166 | 


--------------------------------------------------------------------------------
/src/SignatureObject.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner;
  4 | 
  5 | use Jeidison\PdfSigner\PdfValue\PDFValueSimple;
  6 | use Jeidison\PdfSigner\PdfValue\PDFValueString;
  7 | use Jeidison\PdfSigner\Utils\Date;
  8 | 
  9 | class SignatureObject extends PDFObject
 10 | {
 11 |     const BYTE_RANGE_SIZE = 68;
 12 | 
 13 |     protected int $prevContentSize = 0;
 14 | 
 15 |     protected ?int $postContentSize = null;
 16 | 
 17 |     public function __construct($oid)
 18 |     {
 19 |         parent::__construct($oid, [
 20 |             'Filter' => '/Adobe.PPKLite',
 21 |             'Type' => '/Sig',
 22 |             'SubFilter' => '/adbe.pkcs7.detached',
 23 |             'ByteRange' => new PDFValueSimple(str_repeat(' ', self::BYTE_RANGE_SIZE)),
 24 |             'Contents' => '<'.str_repeat('0', Signature::SIGNATURE_MAX_LENGTH).'>',
 25 |             'M' => new PDFValueString(Date::toPdfDateString()),
 26 |         ]);
 27 |     }
 28 | 
 29 |     public function withName(?string $name): self
 30 |     {
 31 |         if ($name) {
 32 |             $this->value['Name'] = "$name ";
 33 |         }
 34 | 
 35 |         return $this;
 36 |     }
 37 | 
 38 |     public function withReason(?string $reason): self
 39 |     {
 40 |         if ($reason) {
 41 |             $this->value['Reason'] = "$reason ";
 42 |         }
 43 | 
 44 |         return $this;
 45 |     }
 46 | 
 47 |     public function withLocation(?string $location): self
 48 |     {
 49 |         if ($location) {
 50 |             $this->value['Location'] = "$location ";
 51 |         }
 52 | 
 53 |         return $this;
 54 |     }
 55 | 
 56 |     public function withContactInfo(?string $contact): self
 57 |     {
 58 |         if ($contact) {
 59 |             $this->value['ContactInfo'] = "$contact ";
 60 |         }
 61 | 
 62 |         return $this;
 63 |     }
 64 | 
 65 |     public function withSizes($prevContentSize, int $postContentSize = null): self
 66 |     {
 67 |         $this->prevContentSize = $prevContentSize;
 68 |         $this->postContentSize = $postContentSize;
 69 | 
 70 |         return $this;
 71 |     }
 72 | 
 73 |     public function getSignatureMarkerOffset(): int
 74 |     {
 75 |         $tmpOutput = parent::toPdfEntry();
 76 |         $marker = '/Contents';
 77 |         $position = strpos($tmpOutput, $marker);
 78 | 
 79 |         return $position + strlen($marker);
 80 |     }
 81 | 
 82 |     public function toPdfEntry(): string
 83 |     {
 84 |         $signatureSize = strlen(parent::toPdfEntry());
 85 |         $offset = $this->getSignatureMarkerOffset();
 86 |         $startingSecondPart = $this->prevContentSize + $offset + Signature::SIGNATURE_MAX_LENGTH + 2;
 87 | 
 88 |         $contentsSize = strlen(''.$this->value['Contents']);
 89 | 
 90 |         $byteRangeStr = '[ 0 '.
 91 |             ($this->prevContentSize + $offset).' '.
 92 |             ($startingSecondPart).' '.
 93 |             ($this->postContentSize !== null ? $this->postContentSize + ($signatureSize - $contentsSize - $offset) : 0).' ]';
 94 | 
 95 |         $this->value['ByteRange'] = new PDFValueSimple($byteRangeStr.str_repeat(' ', self::BYTE_RANGE_SIZE - strlen($byteRangeStr) + 1));
 96 | 
 97 |         return parent::toPdfEntry();
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/Signer.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner;
  4 | 
  5 | use DateTime;
  6 | use Exception;
  7 | use Jeidison\PdfSigner\PdfValue\PDFValueHexString;
  8 | use Jeidison\PdfSigner\PdfValue\PDFValueSimple;
  9 | use Jeidison\PdfSigner\Xref\Xref;
 10 | 
 11 | /**
 12 |  * @author Jeidison Farias <jeidison.farias@gmail.com>
 13 |  **/
 14 | class Signer
 15 | {
 16 |     private ?Signature $signature;
 17 | 
 18 |     private PdfDocument $pdfDocument;
 19 | 
 20 |     public function __construct()
 21 |     {
 22 |         $this->signature = Signature::new();
 23 |     }
 24 | 
 25 |     public static function new(): static
 26 |     {
 27 |         return new static();
 28 |     }
 29 | 
 30 |     public function withContent(string $pdfContent): self
 31 |     {
 32 |         $pdfDocument = new PdfDocument();
 33 |         $pdfDocument->setBufferFromString($pdfContent);
 34 | 
 35 |         return $this->withPdfDocument($pdfDocument);
 36 |     }
 37 | 
 38 |     private function withPdfDocument(PdfDocument $pdfDocument): self
 39 |     {
 40 |         $this->pdfDocument = $pdfDocument;
 41 | 
 42 |         return $this;
 43 |     }
 44 | 
 45 |     public function withMetadata(Metadata $metadata): self
 46 |     {
 47 |         $this->signature->withMetadata($metadata);
 48 | 
 49 |         return $this;
 50 |     }
 51 | 
 52 |     public function withSignatureAppearance(SignatureAppearance $appearance): self
 53 |     {
 54 |         $this->signature->withAppearance($appearance);
 55 | 
 56 |         return $this;
 57 |     }
 58 | 
 59 |     private function prepareDocumentToSign(): void
 60 |     {
 61 |         $structure = Struct::new()
 62 |             ->withPdfDocument($this->pdfDocument)
 63 |             ->structure();
 64 | 
 65 |         $trailer = $structure['trailer'];
 66 |         $version = $structure['version'];
 67 |         $xrefTable = $structure['xref'];
 68 |         $xrefPosition = $structure['xrefposition'];
 69 |         $revisions = $structure['revisions'];
 70 | 
 71 |         $pdfDocument = $this->pdfDocument;
 72 |         $pdfDocument->setPdfVersion($version);
 73 |         $pdfDocument->setTrailerObject($trailer);
 74 |         $pdfDocument->setXrefPosition($xrefPosition);
 75 |         $pdfDocument->setXrefTable($xrefTable);
 76 |         $pdfDocument->setXrefTableVersion($structure['xrefversion']);
 77 |         $pdfDocument->setRevisions($revisions);
 78 | 
 79 |         $oids = array_keys($xrefTable);
 80 |         sort($oids);
 81 |         $pdfDocument->setMaxOid(array_pop($oids));
 82 |         $pdfDocument->acquirePagesInfo();
 83 | 
 84 |         $this->signature->withPdfDocument($pdfDocument);
 85 |     }
 86 | 
 87 |     public function withCertificate(string $pathCertificate, string $password): self
 88 |     {
 89 |         $certFileContent = file_get_contents($pathCertificate);
 90 |         if ($certFileContent === false) {
 91 |             throw new Exception('Could not read file '.$pathCertificate);
 92 |         }
 93 | 
 94 |         if (openssl_pkcs12_read($certFileContent, $certificate, $password) === false) {
 95 |             throw new Exception('Could not get the certificates from file '.openssl_error_string());
 96 |         }
 97 | 
 98 |         $certInfo = openssl_x509_parse($certificate['cert']);
 99 |         $expirationDate = $certInfo['validTo_time_t'];
100 | 
101 |         if ($expirationDate < time()) {
102 |             throw new Exception('Certificate has expired.');
103 |         }
104 | 
105 |         $this->signature->withCertificate($certificate);
106 | 
107 |         return $this;
108 |     }
109 | 
110 |     public function sign(): string
111 |     {
112 |         $this->prepareDocumentToSign();
113 | 
114 |         return $this->toBuffer();
115 |     }
116 | 
117 |     private function toBuffer(): Buffer
118 |     {
119 |         if (! $this->signature->hasCertificate()) {
120 |             return $this->pdfDocument->getBuffer();
121 |         }
122 | 
123 |         $this->pdfDocument->updateModifyDate();
124 |         $signature = $this->signature->generateSignatureInDocument();
125 | 
126 |         [$docToXref, $objOffSets] = Xref::new()
127 |             ->withPdfDocument($this->pdfDocument)
128 |             ->generateContentToXref();
129 | 
130 |         $xrefOffset = $docToXref->size();
131 | 
132 |         $objOffSets[$signature->getOid()] = $docToXref->size();
133 |         $xrefOffset += strlen($signature->toPdfEntry());
134 | 
135 |         $docVersionString = str_replace('PDF-', '', $this->pdfDocument->getPdfVersion());
136 | 
137 |         $targetVersion = $this->pdfDocument->getXrefTableVersion();
138 |         if ($this->pdfDocument->getXrefTableVersion() >= '1.5') {
139 |             if ($docVersionString > $targetVersion) {
140 |                 $targetVersion = $docVersionString;
141 |             }
142 |         } elseif ($docVersionString < $targetVersion) {
143 |             $targetVersion = $docVersionString;
144 |         }
145 | 
146 |         if ($targetVersion >= '1.5') {
147 |             $trailer = $this->pdfDocument->createObject(clone $this->pdfDocument->getTrailerObject());
148 | 
149 |             $objOffSets[$trailer->getOid()] = $xrefOffset;
150 | 
151 |             $xref = Xref::new()->buildXref15($objOffSets);
152 | 
153 |             $trailer['Index'] = explode(' ', (string) $xref['Index']);
154 |             $trailer['W'] = $xref['W'];
155 |             $trailer['Size'] = $this->pdfDocument->getMaxOid() + 1;
156 |             $trailer['Type'] = '/XRef';
157 | 
158 |             $ID2 = md5(''.(new DateTime())->getTimestamp().'-'.$this->pdfDocument->getXrefPosition().$this->pdfDocument->getTrailerObject());
159 |             $trailer['ID'] = [$trailer['ID'][0], new PDFValueHexString(strtoupper($ID2))];
160 | 
161 |             if (isset($trailer['DecodeParms'])) {
162 |                 unset($trailer['DecodeParms']);
163 |             }
164 | 
165 |             if (isset($trailer['Filter'])) {
166 |                 unset($trailer['Filter']);
167 |             }
168 | 
169 |             $trailer->setStream($xref['stream'], false);
170 |             $trailer['Prev'] = $this->pdfDocument->getXrefPosition();
171 | 
172 |             $docFromXref = new Buffer($trailer->toPdfEntry());
173 |             $docFromXref->data('startxref'.PHP_EOL.$xrefOffset.PHP_EOL.'%%EOF'.PHP_EOL);
174 |         } else {
175 |             $xrefContent = Xref::new()->buildXref($objOffSets);
176 | 
177 |             $this->pdfDocument->getTrailerObject()['Size'] = $this->pdfDocument->getMaxOid() + 1;
178 |             $this->pdfDocument->getTrailerObject()['Prev'] = $this->pdfDocument->getXrefPosition();
179 | 
180 |             $docFromXref = new Buffer($xrefContent);
181 |             $docFromXref->data("trailer\n".$this->pdfDocument->getTrailerObject());
182 |             $docFromXref->data("\nstartxref\n{$xrefOffset}\n%%EOF\n");
183 |         }
184 | 
185 |         $signature->withSizes($docToXref->size(), $docFromXref->size());
186 |         $signature['Contents'] = new PDFValueSimple('');
187 | 
188 |         $signableDocument = new Buffer($docToXref->raw().$signature->toPdfEntry().$docFromXref->raw());
189 | 
190 |         $tmpFolder = sys_get_temp_dir();
191 |         $tempFilename = tempnam($tmpFolder, 'pdfsign');
192 |         $tempFile = fopen($tempFilename, 'wb');
193 |         fwrite($tempFile, $signableDocument->raw());
194 |         fclose($tempFile);
195 | 
196 |         $signatureContents = $this->signature->calculatePkcs7Signature($tempFilename, $tmpFolder);
197 |         unlink($tempFilename);
198 | 
199 |         $signature['Contents'] = new PDFValueHexString($signatureContents);
200 | 
201 |         $docToXref->data($signature->toPdfEntry());
202 | 
203 |         return new Buffer($docToXref->raw().$docFromXref->raw());
204 |     }
205 | }
206 | 


--------------------------------------------------------------------------------
/src/StreamReader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Jeidison\PdfSigner;
 4 | 
 5 | /**
 6 |  * @author Jeidison Farias <jeidison.farias@gmail.com>
 7 |  **/
 8 | class StreamReader
 9 | {
10 |     protected string $buffer;
11 | 
12 |     protected int $bufferLen = 0;
13 | 
14 |     protected int $position = 0;
15 | 
16 |     public function __construct(string $string = null, $offset = 0)
17 |     {
18 |         $this->buffer = $string;
19 |         $this->bufferLen = strlen($string);
20 |         $this->goto($offset);
21 |     }
22 | 
23 |     public function nextChar(): false|string
24 |     {
25 |         $this->position = min($this->position + 1, $this->bufferLen);
26 | 
27 |         return $this->currentChar();
28 |     }
29 | 
30 |     public function nextChars(int $n): string
31 |     {
32 |         $n = min($n, $this->bufferLen - $this->position);
33 |         $retval = substr((string) $this->buffer, $this->position, $n);
34 |         $this->position += $n;
35 | 
36 |         return $retval;
37 |     }
38 | 
39 |     public function currentChar()
40 |     {
41 |         if ($this->position >= $this->bufferLen) {
42 |             return false;
43 |         }
44 | 
45 |         return $this->buffer[$this->position];
46 |     }
47 | 
48 |     public function eos(): bool
49 |     {
50 |         return $this->position >= $this->bufferLen;
51 |     }
52 | 
53 |     public function goto($pos = 0): void
54 |     {
55 |         $this->position = min(max(0, $pos), $this->bufferLen);
56 |     }
57 | 
58 |     public function subStrAtPos($length = 0): string
59 |     {
60 |         if ($length > 0) {
61 |             return substr($this->buffer, $this->position, $length);
62 |         } else {
63 |             return substr($this->buffer, $this->position);
64 |         }
65 |     }
66 | 
67 |     public function getPosition(): int
68 |     {
69 |         return $this->position;
70 |     }
71 | 
72 |     public function size(): int
73 |     {
74 |         return $this->bufferLen;
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/Struct.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Jeidison\PdfSigner;
 4 | 
 5 | use Exception;
 6 | use Jeidison\PdfSigner\Xref\Xref;
 7 | 
 8 | /**
 9 |  * @author Jeidison Farias <jeidison.farias@gmail.com>
10 |  **/
11 | class Struct
12 | {
13 |     private PdfDocument $pdfDocument;
14 | 
15 |     private string $separator = "\r\n";
16 | 
17 |     private const REGEX_PDF_VERSION = '/^%PDF-\d+\.\d+$/';
18 | 
19 |     public static function new(): static
20 |     {
21 |         return new static();
22 |     }
23 | 
24 |     public function withPdfDocument(PdfDocument $pdfDocument): self
25 |     {
26 |         $this->pdfDocument = $pdfDocument;
27 | 
28 |         return $this;
29 |     }
30 | 
31 |     public function structure(): array
32 |     {
33 |         $pdfVersion = strtok($this->pdfDocument->getBuffer()->raw(), $this->separator);
34 |         if ($pdfVersion === false) {
35 |             throw new Exception('Failed to get PDF version');
36 |         }
37 | 
38 |         if (preg_match(self::REGEX_PDF_VERSION, $pdfVersion, $matches) !== 1) {
39 |             throw new Exception('PDF version not found');
40 |         }
41 | 
42 |         if (preg_match_all('/startxref\s*([0-9]+)\s*%%EOF($|[\r\n])/ms', $this->pdfDocument->getBuffer()->raw(), $matches, PREG_SET_ORDER | PREG_OFFSET_CAPTURE) === false) {
43 |             throw new Exception('Failed to get structure');
44 |         }
45 | 
46 |         $versions = [];
47 |         foreach ($matches as $match) {
48 |             $versions[] = intval($match[2][1]) + strlen($match[2][0]);
49 |         }
50 | 
51 |         $startXRefPos = strrpos($this->pdfDocument->getBuffer()->raw(), 'startxref');
52 |         if ($startXRefPos === false) {
53 |             throw new Exception('startxref not found');
54 |         }
55 | 
56 |         if (preg_match('/startxref\s*([0-9]+)\s*%%EOF\s*$/ms', $this->pdfDocument->getBuffer()->raw(), $matches, 0, $startXRefPos) !== 1) {
57 |             throw new Exception('startxref and %%EOF not found');
58 |         }
59 | 
60 |         $xrefPos = intval($matches[1]);
61 | 
62 |         if ($xrefPos === 0) {
63 |             return [
64 |                 'trailer' => null,
65 |                 'version' => substr($pdfVersion, 1),
66 |                 'xref' => [],
67 |                 'xrefposition' => 0,
68 |                 'xrefversion' => substr($pdfVersion, 1),
69 |                 'revisions' => $versions,
70 |             ];
71 |         }
72 | 
73 |         [$xrefTable, $trailerObject, $minPdfVersion] = Xref::new()
74 |             ->withXRefPos($xrefPos)
75 |             ->withPdfDocument($this->pdfDocument)
76 |             ->getXref();
77 | 
78 |         if ($xrefTable === false) {
79 |             throw new Exception('Could not find the xref table');
80 |         }
81 | 
82 |         if ($trailerObject === false) {
83 |             throw new Exception('Could not find the trailer object');
84 |         }
85 | 
86 |         return [
87 |             'trailer' => $trailerObject,
88 |             'version' => substr($pdfVersion, 1),
89 |             'xref' => $xrefTable,
90 |             'xrefposition' => $xrefPos,
91 |             'xrefversion' => $minPdfVersion,
92 |             'revisions' => $versions,
93 |         ];
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/src/Trailer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Jeidison\PdfSigner;
 4 | 
 5 | use Exception;
 6 | 
 7 | /**
 8 |  * @author Jeidison Farias <jeidison.farias@gmail.com>
 9 |  **/
10 | class Trailer
11 | {
12 |     private string $buffer;
13 | 
14 |     private int $trailerPos;
15 | 
16 |     public static function new(): static
17 |     {
18 |         return new static();
19 |     }
20 | 
21 |     public function withBuffer(string $buffer): self
22 |     {
23 |         $this->buffer = $buffer;
24 | 
25 |         return $this;
26 |     }
27 | 
28 |     public function withTrailerPosition(int $trailerPos): self
29 |     {
30 |         $this->trailerPos = $trailerPos;
31 | 
32 |         return $this;
33 |     }
34 | 
35 |     public function getTrailer()
36 |     {
37 |         if (preg_match('/trailer\s*(.*)\s*startxref/ms', $this->buffer, $matches, 0, $this->trailerPos) !== 1) {
38 |             throw new Exception('Trailer not found.');
39 |         }
40 | 
41 |         $trailerStr = $matches[1];
42 |         try {
43 |             $parser = new ObjectParser();
44 | 
45 |             return $parser->parseStr($trailerStr);
46 |         } catch (Exception $e) {
47 |             throw new Exception('Trailer is not valid.', previous: $e);
48 |         }
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Utils/ContentGeneration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Jeidison\PdfSigner\Utils;
 4 | 
 5 | final class ContentGeneration
 6 | {
 7 |     public static function tx($x, $y): string
 8 |     {
 9 |         return sprintf(' 1 0 0 1 %.2F %.2F cm', $x, $y);
10 |     }
11 | 
12 |     public static function sx($w, $h): string
13 |     {
14 |         return sprintf(' %.2F 0 0 %.2F 0 0 cm', $w, $h);
15 |     }
16 | 
17 |     public static function deg2rad($angle): float|int
18 |     {
19 |         return $angle * pi() / 180;
20 |     }
21 | 
22 |     public static function rx($angle): string
23 |     {
24 |         $angle = deg2rad($angle);
25 | 
26 |         return sprintf(' %.2F %.2F %.2F %.2F 0 0 cm', cos($angle), sin($angle), -sin($angle), cos($angle));
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Utils/Date.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Jeidison\PdfSigner\Utils;
 4 | 
 5 | use DateTime;
 6 | 
 7 | final class Date
 8 | {
 9 |     public static function toPdfDateString(DateTime $date = null): string
10 |     {
11 |         $date ??= new DateTime();
12 |         $timestamp = $date->getTimestamp();
13 |         $formatted = substr_replace(date('YmdHisO', $timestamp), "'", (0 - 2), 0)."'";
14 | 
15 |         return 'D:'.$formatted;
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Utils/Img.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner\Utils;
  4 | 
  5 | use Exception;
  6 | use finfo;
  7 | use Jeidison\PdfSigner\PDFObject;
  8 | use Jeidison\PdfSigner\PdfValue\PDFValueList;
  9 | use Jeidison\PdfSigner\PdfValue\PDFValueObject;
 10 | use Jeidison\PdfSigner\PdfValue\PDFValueReference;
 11 | use Jeidison\PdfSigner\PdfValue\PDFValueType;
 12 | 
 13 | final class Img
 14 | {
 15 |     public static function create_image_objects($info, $objectFactory)
 16 |     {
 17 |         $objects = [];
 18 | 
 19 |         $image = call_user_func($objectFactory,
 20 |             [
 21 |                 'Type' => '/XObject',
 22 |                 'Subtype' => '/Image',
 23 |                 'Width' => $info['w'],
 24 |                 'Height' => $info['h'],
 25 |                 'ColorSpace' => [],
 26 |                 'BitsPerComponent' => $info['bpc'],
 27 |                 'Length' => strlen((string) $info['data']),
 28 |             ]
 29 |         );
 30 | 
 31 |         switch ($info['cs']) {
 32 |             case 'Indexed':
 33 |                 $data = gzcompress((string) $info['pal']);
 34 |                 $streamobject = call_user_func($objectFactory, [
 35 |                     'Filter' => '/FlateDecode',
 36 |                     'Length' => strlen($data),
 37 |                 ]);
 38 |                 $streamobject->set_stream($data);
 39 | 
 40 |                 $image['ColorSpace']->push([
 41 |                     '/Indexed', '/DeviceRGB', (strlen((string) $info['pal']) / 3) - 1, new PDFValueReference($streamobject->get_oid()),
 42 |                 ]);
 43 |                 $objects[] = $streamobject;
 44 |                 break;
 45 |             case 'DeviceCMYK':
 46 |                 $image['Decode'] = new PDFValueList([1, 0, 1, 0, 1, 0, 1, 0]);
 47 |             default:
 48 |                 $image['ColorSpace'] = new PDFValueType($info['cs']);
 49 |                 break;
 50 |         }
 51 | 
 52 |         if (isset($info['f'])) {
 53 |             $image['Filter'] = new PDFValueType($info['f']);
 54 |         }
 55 | 
 56 |         if (isset($info['dp'])) {
 57 |             $image['DecodeParms'] = PDFValueObject::fromString($info['dp']);
 58 |         }
 59 | 
 60 |         if (isset($info['trns']) && is_array($info['trns'])) {
 61 |             $image['Mask'] = new PDFValueList($info['trns']);
 62 |         }
 63 | 
 64 |         if (isset($info['smask'])) {
 65 |             $smaskinfo = [
 66 |                 'w' => $info['w'],
 67 |                 'h' => $info['h'],
 68 |                 'cs' => 'DeviceGray',
 69 |                 'bpc' => 8,
 70 |                 'f' => $info['f'],
 71 |                 'dp' => '/Predictor 15 /Colors 1 /BitsPerComponent 8 /Columns '.$info['w'],
 72 |                 'data' => $info['smask'],
 73 |             ];
 74 | 
 75 |             // In principle, it may return multiple objects
 76 |             $smasks = self::create_image_objects($smaskinfo, $objectFactory);
 77 |             foreach ($smasks as $smask) {
 78 |                 $objects[] = $smask;
 79 |             }
 80 | 
 81 |             /** @var PDFObject $smask */
 82 |             $image['SMask'] = new PDFValueReference($smask->getOid());
 83 |         }
 84 | 
 85 |         $image->setStream($info['data']);
 86 |         array_unshift($objects, $image);
 87 | 
 88 |         return $objects;
 89 |     }
 90 | 
 91 |     public static function addImage(callable $objectFactory, $filename, $x = 0, $y = 0, $w = 0, $h = 0, $angle = 0, $keepProportions = true)
 92 |     {
 93 |         if (empty($filename)) {
 94 |             throw new Exception('invalid image name or stream');
 95 |         }
 96 | 
 97 |         if ($filename[0] === '@') {
 98 |             $filecontent = substr((string) $filename, 1);
 99 |         } elseif (Str::isBase64($filename)) {
100 |             $filecontent = base64_decode((string) $filename);
101 |         } else {
102 |             $filecontent = @file_get_contents($filename);
103 | 
104 |             if ($filecontent === false) {
105 |                 throw new Exception('failed to get the image');
106 |             }
107 |         }
108 | 
109 |         $finfo = new finfo();
110 |         $contentType = $finfo->buffer($filecontent, FILEINFO_MIME_TYPE);
111 | 
112 |         $ext = Mime::mimeToExt($contentType);
113 | 
114 |         // TODO: support more image types than jpg
115 |         $addAlpha = false;
116 |         switch ($ext) {
117 |             case 'jpg':
118 |             case 'jpeg':
119 |                 $info = parseJpg($filecontent);
120 |                 break;
121 |             case 'png':
122 |                 $addAlpha = true;
123 |                 $info = parsePng($filecontent);
124 |                 break;
125 |             default:
126 |                 throw new Exception('unsupported mime type');
127 |         }
128 | 
129 |         // Generate a new identifier for the image
130 |         $info['i'] = 'Im'.Str::random(4);
131 | 
132 |         if ($w === null) {
133 |             $w = -96;
134 |         }
135 | 
136 |         if ($h === null) {
137 |             $h = -96;
138 |         }
139 | 
140 |         if ($w < 0) {
141 |             $w = -$info['w'] * 72 / $w;
142 |         }
143 | 
144 |         if ($h < 0) {
145 |             $h = -$info['h'] * 72 / $h;
146 |         }
147 | 
148 |         if ($w == 0) {
149 |             $w = $h * $info['w'] / $info['h'];
150 |         }
151 | 
152 |         if ($h == 0) {
153 |             $h = $w * $info['h'] / $info['w'];
154 |         }
155 | 
156 |         /** @var PDFObject $imagesObjects */
157 |         $imagesObjects = self::create_image_objects($info, $objectFactory);
158 | 
159 |         // Generate the command to translate and scale the image
160 |         if ($keepProportions) {
161 |             $angleRads = deg2rad($angle);
162 |             $W = abs($w * cos($angleRads) + $h * sin($angleRads));
163 |             $H = abs($w * sin($angleRads) + $h * cos($angleRads));
164 | 
165 |             $rW = $w == 0 ? 0 : $W / $w;
166 |             $rH = $h == 0 ? 0 : $H / $h;
167 |             $r = min($rW, $rH);
168 |             $w = $W * $r;
169 |             $h = $H * $r;
170 |         }
171 | 
172 |         $data = 'q';
173 |         $data .= ContentGeneration::tx($x, $y);
174 |         $data .= ContentGeneration::sx($w, $h);
175 |         if ($angle != 0) {
176 |             $data .= ContentGeneration::tx(0.5, 0.5);
177 |             $data .= ContentGeneration::rx($angle);
178 |             $data .= ContentGeneration::tx(-0.5, -0.5);
179 |         }
180 | 
181 |         $data .= sprintf(' /%s Do Q', $info['i']);
182 | 
183 |         $resources = new PDFValueObject([
184 |             'ProcSet' => ['/PDF', '/Text', '/ImageB', '/ImageC', '/ImageI'],
185 |             'XObject' => new PDFValueObject([
186 |                 $info['i'] => new PDFValueReference($imagesObjects[0]->getOid()),
187 |             ]),
188 |         ]);
189 | 
190 |         return ['image' => $imagesObjects[0], 'command' => $data, 'resources' => $resources, 'alpha' => $addAlpha];
191 |     }
192 | }
193 | 


--------------------------------------------------------------------------------
/src/Utils/Mime.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner\Utils;
  4 | 
  5 | final class Mime
  6 | {
  7 |     public static function mimeToExt(string $mime): ?string
  8 |     {
  9 |         return [
 10 |             'video/3gpp2' => '3g2',
 11 |             'video/3gp' => '3gp',
 12 |             'video/3gpp' => '3gp',
 13 |             'application/x-compressed' => '7zip',
 14 |             'audio/x-acc' => 'aac',
 15 |             'audio/ac3' => 'ac3',
 16 |             'application/postscript' => 'ai',
 17 |             'audio/x-aiff' => 'aif',
 18 |             'audio/aiff' => 'aif',
 19 |             'audio/x-au' => 'au',
 20 |             'video/x-msvideo' => 'avi',
 21 |             'video/msvideo' => 'avi',
 22 |             'video/avi' => 'avi',
 23 |             'application/x-troff-msvideo' => 'avi',
 24 |             'application/macbinary' => 'bin',
 25 |             'application/mac-binary' => 'bin',
 26 |             'application/x-binary' => 'bin',
 27 |             'application/x-macbinary' => 'bin',
 28 |             'image/bmp' => 'bmp',
 29 |             'image/x-bmp' => 'bmp',
 30 |             'image/x-bitmap' => 'bmp',
 31 |             'image/x-xbitmap' => 'bmp',
 32 |             'image/x-win-bitmap' => 'bmp',
 33 |             'image/x-windows-bmp' => 'bmp',
 34 |             'image/ms-bmp' => 'bmp',
 35 |             'image/x-ms-bmp' => 'bmp',
 36 |             'application/bmp' => 'bmp',
 37 |             'application/x-bmp' => 'bmp',
 38 |             'application/x-win-bitmap' => 'bmp',
 39 |             'application/cdr' => 'cdr',
 40 |             'application/coreldraw' => 'cdr',
 41 |             'application/x-cdr' => 'cdr',
 42 |             'application/x-coreldraw' => 'cdr',
 43 |             'image/cdr' => 'cdr',
 44 |             'image/x-cdr' => 'cdr',
 45 |             'zz-application/zz-winassoc-cdr' => 'cdr',
 46 |             'application/mac-compactpro' => 'cpt',
 47 |             'application/pkix-crl' => 'crl',
 48 |             'application/pkcs-crl' => 'crl',
 49 |             'application/x-x509-ca-cert' => 'crt',
 50 |             'application/pkix-cert' => 'crt',
 51 |             'text/css' => 'css',
 52 |             'text/x-comma-separated-values' => 'csv',
 53 |             'text/comma-separated-values' => 'csv',
 54 |             'application/vnd.msexcel' => 'csv',
 55 |             'application/x-director' => 'dcr',
 56 |             'application/vnd.openxmlformats-officedocument.wordprocessingml.document' => 'docx',
 57 |             'application/x-dvi' => 'dvi',
 58 |             'message/rfc822' => 'eml',
 59 |             'application/x-msdownload' => 'exe',
 60 |             'video/x-f4v' => 'f4v',
 61 |             'audio/x-flac' => 'flac',
 62 |             'video/x-flv' => 'flv',
 63 |             'image/gif' => 'gif',
 64 |             'application/gpg-keys' => 'gpg',
 65 |             'application/x-gtar' => 'gtar',
 66 |             'application/x-gzip' => 'gzip',
 67 |             'application/mac-binhex40' => 'hqx',
 68 |             'application/mac-binhex' => 'hqx',
 69 |             'application/x-binhex40' => 'hqx',
 70 |             'application/x-mac-binhex40' => 'hqx',
 71 |             'text/html' => 'html',
 72 |             'image/x-icon' => 'ico',
 73 |             'image/x-ico' => 'ico',
 74 |             'image/vnd.microsoft.icon' => 'ico',
 75 |             'text/calendar' => 'ics',
 76 |             'application/java-archive' => 'jar',
 77 |             'application/x-java-application' => 'jar',
 78 |             'application/x-jar' => 'jar',
 79 |             'image/jp2' => 'jp2',
 80 |             'video/mj2' => 'jp2',
 81 |             'image/jpx' => 'jp2',
 82 |             'image/jpm' => 'jp2',
 83 |             'image/jpeg' => 'jpg',
 84 |             'image/pjpeg' => 'jpg',
 85 |             'application/x-javascript' => 'js',
 86 |             'application/json' => 'json',
 87 |             'text/json' => 'json',
 88 |             'application/vnd.google-earth.kml+xml' => 'kml',
 89 |             'application/vnd.google-earth.kmz' => 'kmz',
 90 |             'text/x-log' => 'log',
 91 |             'audio/x-m4a' => 'm4a',
 92 |             'audio/mp4' => 'm4a',
 93 |             'application/vnd.mpegurl' => 'm4u',
 94 |             'audio/midi' => 'mid',
 95 |             'application/vnd.mif' => 'mif',
 96 |             'video/quicktime' => 'mov',
 97 |             'video/x-sgi-movie' => 'movie',
 98 |             'audio/mpeg' => 'mp3',
 99 |             'audio/mpg' => 'mp3',
100 |             'audio/mpeg3' => 'mp3',
101 |             'audio/mp3' => 'mp3',
102 |             'video/mp4' => 'mp4',
103 |             'video/mpeg' => 'mpeg',
104 |             'application/oda' => 'oda',
105 |             'audio/ogg' => 'ogg',
106 |             'video/ogg' => 'ogg',
107 |             'application/ogg' => 'ogg',
108 |             'application/x-pkcs10' => 'p10',
109 |             'application/pkcs10' => 'p10',
110 |             'application/x-pkcs12' => 'p12',
111 |             'application/x-pkcs7-signature' => 'p7a',
112 |             'application/pkcs7-mime' => 'p7c',
113 |             'application/x-pkcs7-mime' => 'p7c',
114 |             'application/x-pkcs7-certreqresp' => 'p7r',
115 |             'application/pkcs7-signature' => 'p7s',
116 |             'application/pdf' => 'pdf',
117 |             'application/octet-stream' => 'pdf',
118 |             'application/x-x509-user-cert' => 'pem',
119 |             'application/x-pem-file' => 'pem',
120 |             'application/pgp' => 'pgp',
121 |             'application/x-httpd-php' => 'php',
122 |             'application/php' => 'php',
123 |             'application/x-php' => 'php',
124 |             'text/php' => 'php',
125 |             'text/x-php' => 'php',
126 |             'application/x-httpd-php-source' => 'php',
127 |             'image/png' => 'png',
128 |             'image/x-png' => 'png',
129 |             'application/powerpoint' => 'ppt',
130 |             'application/vnd.ms-powerpoint' => 'ppt',
131 |             'application/vnd.ms-office' => 'ppt',
132 |             'application/msword' => 'ppt',
133 |             'application/vnd.openxmlformats-officedocument.presentationml.presentation' => 'pptx',
134 |             'application/x-photoshop' => 'psd',
135 |             'image/vnd.adobe.photoshop' => 'psd',
136 |             'audio/x-realaudio' => 'ra',
137 |             'audio/x-pn-realaudio' => 'ram',
138 |             'application/x-rar' => 'rar',
139 |             'application/rar' => 'rar',
140 |             'application/x-rar-compressed' => 'rar',
141 |             'audio/x-pn-realaudio-plugin' => 'rpm',
142 |             'application/x-pkcs7' => 'rsa',
143 |             'text/rtf' => 'rtf',
144 |             'text/richtext' => 'rtx',
145 |             'video/vnd.rn-realvideo' => 'rv',
146 |             'application/x-stuffit' => 'sit',
147 |             'application/smil' => 'smil',
148 |             'text/srt' => 'srt',
149 |             'image/svg+xml' => 'svg',
150 |             'application/x-shockwave-flash' => 'swf',
151 |             'application/x-tar' => 'tar',
152 |             'application/x-gzip-compressed' => 'tgz',
153 |             'image/tiff' => 'tiff',
154 |             'text/plain' => 'txt',
155 |             'text/x-vcard' => 'vcf',
156 |             'application/videolan' => 'vlc',
157 |             'text/vtt' => 'vtt',
158 |             'audio/x-wav' => 'wav',
159 |             'audio/wave' => 'wav',
160 |             'audio/wav' => 'wav',
161 |             'application/wbxml' => 'wbxml',
162 |             'video/webm' => 'webm',
163 |             'audio/x-ms-wma' => 'wma',
164 |             'application/wmlc' => 'wmlc',
165 |             'video/x-ms-wmv' => 'wmv',
166 |             'video/x-ms-asf' => 'wmv',
167 |             'application/xhtml+xml' => 'xhtml',
168 |             'application/excel' => 'xl',
169 |             'application/msexcel' => 'xls',
170 |             'application/x-msexcel' => 'xls',
171 |             'application/x-ms-excel' => 'xls',
172 |             'application/x-excel' => 'xls',
173 |             'application/x-dos_ms_excel' => 'xls',
174 |             'application/xls' => 'xls',
175 |             'application/x-xls' => 'xls',
176 |             'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' => 'xlsx',
177 |             'application/vnd.ms-excel' => 'xlsx',
178 |             'application/xml' => 'xml',
179 |             'text/xml' => 'xml',
180 |             'text/xsl' => 'xsl',
181 |             'application/xspf+xml' => 'xspf',
182 |             'application/x-compress' => 'z',
183 |             'application/x-zip' => 'zip',
184 |             'application/zip' => 'zip',
185 |             'application/x-zip-compressed' => 'zip',
186 |             'application/s-compressed' => 'zip',
187 |             'multipart/x-zip' => 'zip',
188 |             'text/x-scriptzsh' => 'zsh',
189 |         ][$mime] ?? null;
190 |     }
191 | }
192 | 


--------------------------------------------------------------------------------
/src/Utils/Str.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Jeidison\PdfSigner\Utils;
 4 | 
 5 | final class Str
 6 | {
 7 |     public static function isBase64($string): bool
 8 |     {
 9 |         if (! preg_match('/^[a-zA-Z0-9\/\r\n+]*={0,2}$/', (string) $string)) {
10 |             return false;
11 |         }
12 | 
13 |         $decoded = base64_decode((string) $string, true);
14 |         if ($decoded === false) {
15 |             return false;
16 |         }
17 | 
18 |         if (base64_encode($decoded) != $string) {
19 |             return false;
20 |         }
21 | 
22 |         return true;
23 |     }
24 | 
25 |     public static function random($length = 8, $extended = false, $hard = false): string
26 |     {
27 |         $token = '';
28 |         $codeAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
29 |         if ($extended === true) {
30 |             $codeAlphabet .= "!\"#$%&'()*+,-./:;<=>?@[\\]_{}";
31 |         }
32 | 
33 |         if ($hard === true) {
34 |             $codeAlphabet .= '^`|~';
35 |         }
36 | 
37 |         $max = strlen($codeAlphabet);
38 |         for ($i = 0; $i < $length; $i++) {
39 |             $token .= $codeAlphabet[random_int(0, $max - 1)];
40 |         }
41 | 
42 |         return $token;
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Utils/helpers.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use Jeidison\PdfSigner\StreamReader;
  4 | 
  5 | function parseJpg($filecontent)
  6 | {
  7 |     // Extract info from a JPEG file
  8 |     $a = getimagesizefromstring($filecontent);
  9 |     if (! $a) {
 10 |         throw new Exception('Missing or incorrect image');
 11 |     }
 12 | 
 13 |     if ($a[2] != 2) {
 14 |         throw new Exception('Not a JPEG image');
 15 |     }
 16 | 
 17 |     if (! isset($a['channels']) || $a['channels'] == 3) {
 18 |         $colspace = 'DeviceRGB';
 19 |     } elseif ($a['channels'] == 4) {
 20 |         $colspace = 'DeviceCMYK';
 21 |     } else {
 22 |         $colspace = 'DeviceGray';
 23 |     }
 24 | 
 25 |     $bpc = $a['bits'] ?? 8;
 26 |     $data = $filecontent;
 27 | 
 28 |     return ['w' => $a[0], 'h' => $a[1], 'cs' => $colspace, 'bpc' => $bpc, 'f' => 'DCTDecode', 'data' => $data];
 29 | }
 30 | 
 31 | function parsePng(string $fileContent)
 32 | {
 33 |     $f = new StreamReader($fileContent);
 34 | 
 35 |     return parsePngStream($f);
 36 | }
 37 | 
 38 | function parsePngStream(&$f)
 39 | {
 40 |     // Check signature
 41 |     if (($res = readStream($f, 8)) != chr(137).'PNG'.chr(13).chr(10).chr(26).chr(10)) {
 42 |         throw new Exception('Not a PNG image '.$res);
 43 |     }
 44 | 
 45 |     // Read header chunk
 46 |     readStream($f, 4);
 47 |     if (readStream($f, 4) != 'IHDR') {
 48 |         throw new Exception('Incorrect PNG image');
 49 |     }
 50 | 
 51 |     $w = readInt($f);
 52 |     $h = readInt($f);
 53 |     $bpc = ord(readStream($f, 1));
 54 |     if ($bpc > 8) {
 55 |         throw new Exception('16-bit depth not supported');
 56 |     }
 57 | 
 58 |     $ct = ord(readStream($f, 1));
 59 |     if ($ct == 0 || $ct == 4) {
 60 |         $colspace = 'DeviceGray';
 61 |     } elseif ($ct == 2 || $ct == 6) {
 62 |         $colspace = 'DeviceRGB';
 63 |     } elseif ($ct == 3) {
 64 |         $colspace = 'Indexed';
 65 |     } else {
 66 |         throw new Exception('Unknown color type');
 67 |     }
 68 | 
 69 |     if (ord(readStream($f, 1)) != 0) {
 70 |         throw new Exception('Unknown compression method');
 71 |     }
 72 | 
 73 |     if (ord(readStream($f, 1)) !== 0) {
 74 |         throw new Exception('Unknown filter method');
 75 |     }
 76 | 
 77 |     if (ord(readStream($f, 1)) !== 0) {
 78 |         throw new Exception('Interlacing not supported');
 79 |     }
 80 | 
 81 |     readStream($f, 4);
 82 |     $dp = '/Predictor 15 /Colors '.($colspace == 'DeviceRGB' ? 3 : 1).' /BitsPerComponent '.$bpc.' /Columns '.$w;
 83 | 
 84 |     // Scan chunks looking for palette, transparency and image data
 85 |     $pal = '';
 86 |     $trns = '';
 87 |     $data = '';
 88 |     do {
 89 |         $n = readInt($f);
 90 |         $type = readStream($f, 4);
 91 |         if ($type == 'PLTE') {
 92 |             // Read palette
 93 |             $pal = readStream($f, $n);
 94 |             readStream($f, 4);
 95 |         } elseif ($type == 'tRNS') {
 96 |             // Read transparency info
 97 |             $t = readStream($f, $n);
 98 |             if ($ct == 0) {
 99 |                 $trns = [ord(substr((string) $t, 1, 1))];
100 |             } elseif ($ct == 2) {
101 |                 $trns = [ord(substr((string) $t, 1, 1)), ord(substr((string) $t, 3, 1)), ord(substr((string) $t, 5, 1))];
102 |             } else {
103 |                 $pos = strpos((string) $t, chr(0));
104 |                 if ($pos !== false) {
105 |                     $trns = [$pos];
106 |                 }
107 |             }
108 | 
109 |             readStream($f, 4);
110 |         } elseif ($type == 'IDAT') {
111 |             // Read image data block
112 |             $data .= readStream($f, $n);
113 |             readStream($f, 4);
114 |         } elseif ($type == 'IEND') {
115 |             break;
116 |         } else {
117 |             readStream($f, $n + 4);
118 |         }
119 |     } while ($n);
120 | 
121 |     if ($colspace == 'Indexed' && empty($pal)) {
122 |         throw new Exception('Missing palette in image');
123 |     }
124 | 
125 |     $info = ['w' => $w, 'h' => $h, 'cs' => $colspace, 'bpc' => $bpc, 'f' => 'FlateDecode', 'dp' => $dp, 'pal' => $pal, 'trns' => $trns];
126 |     if ($ct >= 4) {
127 |         // Extract alpha channel
128 |         $data = gzuncompress($data);
129 |         if ($data === false) {
130 |             throw new Exception('failed to uncompress the image');
131 |         }
132 | 
133 |         $color = '';
134 |         $alpha = '';
135 |         if ($ct == 4) {
136 |             // Gray image
137 |             $len = 2 * $w;
138 |             for ($i = 0; $i < $h; $i++) {
139 |                 $pos = (1 + $len) * $i;
140 |                 $color .= $data[$pos];
141 |                 $alpha .= $data[$pos];
142 |                 $line = substr($data, $pos + 1, $len);
143 |                 $color .= preg_replace('/(.)./s', '$1', $line);
144 |                 $alpha .= preg_replace('/.(.)/s', '$1', $line);
145 |             }
146 |         } else {
147 |             // RGB image
148 |             $len = 4 * $w;
149 |             for ($i = 0; $i < $h; $i++) {
150 |                 $pos = (1 + $len) * $i;
151 |                 $color .= $data[$pos];
152 |                 $alpha .= $data[$pos];
153 |                 $line = substr($data, $pos + 1, $len);
154 |                 $color .= preg_replace('/(.{3})./s', '$1', $line);
155 |                 $alpha .= preg_replace('/.{3}(.)/s', '$1', $line);
156 |             }
157 |         }
158 | 
159 |         unset($data);
160 |         $data = gzcompress($color);
161 |         $info['smask'] = gzcompress($alpha);
162 |     }
163 | 
164 |     $info['data'] = $data;
165 | 
166 |     return $info;
167 | }
168 | 
169 | function readStream($f, $n): string
170 | {
171 |     $res = '';
172 | 
173 |     while ($n > 0 && ! $f->eos()) {
174 |         $s = $f->nextchars($n);
175 |         if ($s === false) {
176 |             throw new Exception('Error while reading the stream');
177 |         }
178 | 
179 |         $n -= strlen((string) $s);
180 |         $res .= $s;
181 |     }
182 | 
183 |     if ($n > 0) {
184 |         throw new Exception('Unexpected end of stream');
185 |     }
186 | 
187 |     return $res;
188 | }
189 | 
190 | function readInt($f): int
191 | {
192 |     // Read a 4-byte integer from stream
193 |     $a = unpack('Ni', readStream($f, 4));
194 | 
195 |     return $a['i'];
196 | }
197 | 


--------------------------------------------------------------------------------
/src/Xref/XRef14.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner\Xref;
  4 | 
  5 | use Exception;
  6 | use Jeidison\PdfSigner\PdfValue\PDFValue;
  7 | use Jeidison\PdfSigner\Trailer;
  8 | 
  9 | /**
 10 |  * @author Jeidison Farias <jeidison.farias@gmail.com>
 11 |  **/
 12 | class XRef14
 13 | {
 14 |     private string $buffer;
 15 | 
 16 |     private int $xrefPosition;
 17 | 
 18 |     public static function new(): static
 19 |     {
 20 |         return new static();
 21 |     }
 22 | 
 23 |     public function withBuffer(string $buffer): self
 24 |     {
 25 |         $this->buffer = $buffer;
 26 | 
 27 |         return $this;
 28 |     }
 29 | 
 30 |     public function withXRefPos(?int $xrefPos): self
 31 |     {
 32 |         $this->xrefPosition = $xrefPos;
 33 | 
 34 |         return $this;
 35 |     }
 36 | 
 37 |     public function getXref()
 38 |     {
 39 |         $trailerPos = strpos($this->buffer, 'trailer', $this->xrefPosition);
 40 |         $minPdfVersion = '1.4';
 41 | 
 42 |         $xrefSubstr = substr($this->buffer, $this->xrefPosition, $trailerPos - $this->xrefPosition);
 43 | 
 44 |         $separator = "\r\n";
 45 |         $xrefLine = strtok($xrefSubstr, $separator);
 46 |         if ($xrefLine !== 'xref') {
 47 |             throw new Exception('Xref tag not found at position '.$this->xrefPosition);
 48 |         }
 49 | 
 50 |         $objId = false;
 51 |         $objCount = 0;
 52 |         $xrefTable = [];
 53 | 
 54 |         while (($xrefLine = strtok($separator)) !== false) {
 55 | 
 56 |             if (preg_match('/(\d+) (\d+)$/', $xrefLine, $matches) === 1) {
 57 |                 if ($objCount > 0) {
 58 |                     throw new Exception('Malformed xref at position '.$this->xrefPosition);
 59 |                 }
 60 | 
 61 |                 $objId = (int) $matches[1];
 62 |                 $objCount = (int) $matches[2];
 63 | 
 64 |                 continue;
 65 |             }
 66 | 
 67 |             $qtd = preg_match('/^(\d+) (\d+) (.)\s*/', $xrefLine, $matches);
 68 |             if ($qtd !== 1) {
 69 |                 continue;
 70 |             }
 71 | 
 72 |             if ($objCount === 0) {
 73 |                 throw new Exception('Unexpected entry for xref: '.$xrefLine);
 74 |             }
 75 | 
 76 |             $objOffset = (int) $matches[1];
 77 |             $objGeneration = (int) $matches[2];
 78 |             $objOperation = $matches[3];
 79 | 
 80 |             if ($objOffset !== 0) {
 81 |                 switch ($objOperation) {
 82 |                     case 'f':
 83 |                         $xrefTable[$objId] = null;
 84 |                         break;
 85 |                     case 'n':
 86 |                         $xrefTable[$objId] = $objOffset;
 87 |                         if ($objGeneration != 0) {
 88 |                             throw new Exception('Objects of non-zero generation are not fully checked... please double check your document.');
 89 |                         }
 90 |                         break;
 91 |                 }
 92 |             }
 93 | 
 94 |             $objCount--;
 95 |             $objId++;
 96 |         }
 97 | 
 98 |         $trailerObj = Trailer::new()
 99 |             ->withBuffer($this->buffer)
100 |             ->withTrailerPosition($trailerPos)
101 |             ->getTrailer();
102 | 
103 |         if (isset($trailerObj['Prev'])) {
104 |             $xrefTable = $this->getPreviousXref($trailerObj, $minPdfVersion, $xrefTable);
105 |         }
106 | 
107 |         return [$xrefTable, $trailerObj, $minPdfVersion];
108 |     }
109 | 
110 |     private function getPreviousXref(PDFValue $trailerObj, string $minPdfVersion, array $xrefTable): array
111 |     {
112 |         $xrefPrevPos = $trailerObj['Prev']->val();
113 |         if (! is_numeric($xrefPrevPos)) {
114 |             throw new Exception('Invalid trailer');
115 |         }
116 | 
117 |         $xrefPrevPos = (int) $xrefPrevPos;
118 |         [$prevTable, , $prevMinPdfVersion] = XRef14::new()
119 |             ->withBuffer($this->buffer)
120 |             ->withXRefPos($xrefPrevPos)
121 |             ->getXref();
122 | 
123 |         if ($prevMinPdfVersion !== $minPdfVersion) {
124 |             throw new Exception('Mixed type of xref tables are not supported');
125 |         }
126 | 
127 |         if ($prevTable !== false) {
128 |             foreach ($prevTable as $objId => $objOffset) {
129 |                 if (! isset($xrefTable[$objId])) {
130 |                     $xrefTable[$objId] = $objOffset;
131 |                 }
132 |             }
133 |         }
134 | 
135 |         return $xrefTable;
136 |     }
137 | }
138 | 


--------------------------------------------------------------------------------
/src/Xref/XRef15.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner\Xref;
  4 | 
  5 | use Exception;
  6 | use Jeidison\PdfSigner\PdfDocument;
  7 | use Jeidison\PdfSigner\StreamReader;
  8 | 
  9 | /**
 10 |  * @author Jeidison Farias <jeidison.farias@gmail.com>
 11 |  **/
 12 | class XRef15
 13 | {
 14 |     private PdfDocument $pdfDocument;
 15 | 
 16 |     private int $xrefPosition;
 17 | 
 18 |     public static function new(): static
 19 |     {
 20 |         return new static();
 21 |     }
 22 | 
 23 |     public function withPdfDocument(PdfDocument $pdfDocument): self
 24 |     {
 25 |         $this->pdfDocument = $pdfDocument;
 26 | 
 27 |         return $this;
 28 |     }
 29 | 
 30 |     public function withXRefPos(?int $xrefPos): self
 31 |     {
 32 |         $this->xrefPosition = $xrefPos;
 33 | 
 34 |         return $this;
 35 |     }
 36 | 
 37 |     public function getXref()
 38 |     {
 39 |         $xrefO = $this->pdfDocument->findObjectAtPos($this->xrefPosition, []);
 40 |         if ($xrefO === false) {
 41 |             throw new Exception('Cross reference object not found when parsing xref at position '.$this->xrefPosition);
 42 |         }
 43 | 
 44 |         if (! (isset($xrefO['Type'])) || ($xrefO['Type']->val() !== 'XRef')) {
 45 |             throw new Exception('Invalid xref table');
 46 |         }
 47 | 
 48 |         $stream = $xrefO->getStream(false);
 49 |         if ($stream === null) {
 50 |             throw new Exception('Cross reference stream not found when parsing xref at position '.$this->xrefPosition);
 51 |         }
 52 | 
 53 |         $W = $xrefO['W']->val(true);
 54 |         if (count($W) !== 3) {
 55 |             throw new Exception('Invalid cross reference object');
 56 |         }
 57 | 
 58 |         $W[0] = (int) $W[0];
 59 |         $W[1] = (int) $W[1];
 60 |         $W[2] = (int) $W[2];
 61 | 
 62 |         $Size = $xrefO['Size']->get_int();
 63 |         if ($Size === false) {
 64 |             throw new Exception('Could not get the size of the xref table');
 65 |         }
 66 | 
 67 |         $Index = [0, $Size];
 68 |         if (isset($xrefO['Index'])) {
 69 |             $Index = $xrefO['Index']->val(true);
 70 |         }
 71 | 
 72 |         if (count($Index) % 2 !== 0) {
 73 |             throw new Exception('Invalid indexes of xref table');
 74 |         }
 75 | 
 76 |         $xrefTable = [];
 77 |         if (isset($xrefO['Prev'])) {
 78 |             $Prev = $xrefO['Prev'];
 79 |             $Prev = $Prev->get_int();
 80 |             if ($Prev === false) {
 81 |                 throw new Exception('Invalid reference to a previous xref table');
 82 |             }
 83 | 
 84 |             [$xrefTable] = XRef15::new()
 85 |                 ->withPdfDocument($this->pdfDocument)
 86 |                 ->withXRefPos($Prev)
 87 |                 ->getXref();
 88 |         }
 89 | 
 90 |         $streamV = new StreamReader($stream);
 91 | 
 92 |         $getFmtFunction = function ($f) {
 93 |             if ($f === false) {
 94 |                 return false;
 95 |             }
 96 | 
 97 |             return match ($f) {
 98 |                 0 => static fn ($v) => 0,
 99 |                 1 => static fn ($v) => unpack('C', str_pad($v, 1, chr(0), STR_PAD_LEFT))[1],
100 |                 2 => static fn ($v) => unpack('n', str_pad($v, 2, chr(0), STR_PAD_LEFT))[1],
101 |                 3, 4 => static fn ($v) => unpack('N', str_pad($v, 4, chr(0), STR_PAD_LEFT))[1],
102 |                 5, 6, 7, 8 => static fn ($v) => unpack('J', str_pad($v, 8, chr(0), STR_PAD_LEFT))[1],
103 |                 default => false,
104 |             };
105 |         };
106 | 
107 |         $fmtFunction = [
108 |             $getFmtFunction($W[0]),
109 |             $getFmtFunction($W[1]),
110 |             $getFmtFunction($W[2]),
111 |         ];
112 | 
113 |         $indexI = 0;
114 |         while ($indexI < count($Index)) {
115 |             $objectI = $Index[$indexI++];
116 |             $objectCount = $Index[$indexI++];
117 | 
118 |             while (($streamV->currentChar() !== false) && ($objectCount > 0)) {
119 |                 $f1 = $W[0] != 0 ? ($fmtFunction[0]($streamV->nextChars($W[0]))) : 1;
120 |                 $f2 = $fmtFunction[1]($streamV->nextChars($W[1]));
121 |                 $f3 = $fmtFunction[2]($streamV->nextChars($W[2]));
122 | 
123 |                 if (($f1 === false) || ($f2 === false) || ($f3 === false)) {
124 |                     throw new Exception('Invalid stream for xref table');
125 |                 }
126 | 
127 |                 switch ($f1) {
128 |                     case 0:
129 |                         $xrefTable[$objectI] = null;
130 |                         break;
131 |                     case 1:
132 |                         $xrefTable[$objectI] = $f2;
133 |                         if ($f3 !== 0) {
134 |                             throw new Exception('Objects of non-zero generation are not fully checked... please double check your document.');
135 |                         }
136 | 
137 |                         break;
138 |                     case 2:
139 |                         $xrefTable[$objectI] = ['stmoid' => $f2, 'pos' => $f3];
140 |                         break;
141 |                 }
142 | 
143 |                 $objectI++;
144 |                 $objectCount--;
145 |             }
146 |         }
147 | 
148 |         return [$xrefTable, $xrefO->getValue(), '1.5'];
149 |     }
150 | }
151 | 


--------------------------------------------------------------------------------
/src/Xref/Xref.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Jeidison\PdfSigner\Xref;
  4 | 
  5 | use Jeidison\PdfSigner\Buffer;
  6 | use Jeidison\PdfSigner\PdfDocument;
  7 | 
  8 | /**
  9 |  * @author Jeidison Farias <jeidison.farias@gmail.com>
 10 |  **/
 11 | class Xref
 12 | {
 13 |     private PdfDocument $pdfDocument;
 14 | 
 15 |     private int $xrefPosition;
 16 | 
 17 |     public static function new(): static
 18 |     {
 19 |         return new static();
 20 |     }
 21 | 
 22 |     public function withPdfDocument(PdfDocument $pdfDocument): self
 23 |     {
 24 |         $this->pdfDocument = $pdfDocument;
 25 | 
 26 |         return $this;
 27 |     }
 28 | 
 29 |     public function withXRefPos(?int $xrefPos): self
 30 |     {
 31 |         $this->xrefPosition = $xrefPos;
 32 | 
 33 |         return $this;
 34 |     }
 35 | 
 36 |     public function getXref(): array
 37 |     {
 38 |         $trailerPos = strpos($this->pdfDocument->getBuffer()->raw(), 'trailer', $this->xrefPosition);
 39 |         if ($trailerPos === false) {
 40 |             return XRef15::new()
 41 |                 ->withPdfDocument($this->pdfDocument)
 42 |                 ->withXRefPos($this->xrefPosition)
 43 |                 ->getXref();
 44 |         }
 45 | 
 46 |         return XRef14::new()
 47 |             ->withBuffer($this->pdfDocument->getBuffer()->raw())
 48 |             ->withXRefPos($this->xrefPosition)
 49 |             ->getXref();
 50 |     }
 51 | 
 52 |     public function buildXref15(array $offsets): array
 53 |     {
 54 |         if (isset($offsets[0])) {
 55 |             unset($offsets[0]);
 56 |         }
 57 | 
 58 |         $k = array_keys($offsets);
 59 |         sort($k);
 60 | 
 61 |         $indexes = [];
 62 |         $iK = 0;
 63 |         $cK = 0;
 64 |         $count = 1;
 65 |         $result = '';
 66 |         $counter = count($k);
 67 |         for ($i = 0; $i < $counter; $i++) {
 68 |             if ($cK === 0) {
 69 |                 $cK = $k[$i] - 1;
 70 |                 $iK = $k[$i];
 71 |                 $count = 0;
 72 |             }
 73 | 
 74 |             if ($k[$i] === $cK + 1) {
 75 |                 $count++;
 76 |             } else {
 77 |                 $indexes[] = sprintf('%s %d', $iK, $count);
 78 |                 $count = 1;
 79 |                 $iK = $k[$i];
 80 |             }
 81 | 
 82 |             $cOffset = $offsets[$k[$i]];
 83 | 
 84 |             if (is_array($cOffset)) {
 85 |                 $result .= pack('C', 2);
 86 |                 $result .= pack('N', $cOffset['stmoid']);
 87 |                 $result .= pack('C', $cOffset['pos']);
 88 |             } elseif ($cOffset === null) {
 89 |                 $result .= pack('C', 0);
 90 |                 $result .= pack('N', $cOffset);
 91 |                 $result .= pack('C', 0);
 92 |             } else {
 93 |                 $result .= pack('C', 1);
 94 |                 $result .= pack('N', $cOffset);
 95 |                 $result .= pack('C', 0);
 96 |             }
 97 | 
 98 |             $cK = $k[$i];
 99 |         }
100 | 
101 |         $indexes[] = sprintf('%s %d', $iK, $count);
102 |         $indexes = implode(' ', $indexes);
103 | 
104 |         return [
105 |             'W' => [1, 4, 1],
106 |             'Index' => $indexes,
107 |             'stream' => $result,
108 |         ];
109 |     }
110 | 
111 |     public function buildXref(array $offsets): string
112 |     {
113 |         $k = array_keys($offsets);
114 |         sort($k);
115 | 
116 |         $iK = 0;
117 |         $cK = 0;
118 |         $count = 1;
119 |         $result = '';
120 |         $references = "0000000000 65535 f \n";
121 |         $counter = count($k);
122 |         for ($i = 0; $i < $counter; $i++) {
123 |             if ($k[$i] === 0) {
124 |                 continue;
125 |             }
126 | 
127 |             if ($k[$i] === $cK + 1) {
128 |                 $count++;
129 |             } else {
130 |                 $result .= sprintf('%s %d%s%s', $iK, $count, PHP_EOL, $references);
131 |                 $count = 1;
132 |                 $iK = $k[$i];
133 |                 $references = '';
134 |             }
135 | 
136 |             $references .= sprintf("%010d 00000 n \n", $offsets[$k[$i]]);
137 |             $cK = $k[$i];
138 |         }
139 | 
140 |         $result .= sprintf('%s %d%s%s', $iK, $count, PHP_EOL, $references);
141 | 
142 |         return "xref\n".$result;
143 |     }
144 | 
145 |     public function generateContentToXref(): array
146 |     {
147 |         $result = new Buffer($this->pdfDocument->getBuffer()->raw());
148 |         $offsets = [];
149 |         $offsets[0] = 0;
150 | 
151 |         $offset = $result->size();
152 |         foreach ($this->pdfDocument->getPdfObjects() as $objId => $object) {
153 |             $result->data($object->toPdfEntry());
154 |             $offsets[$objId] = $offset;
155 |             $offset = $result->size();
156 |         }
157 | 
158 |         return [$result, $offsets];
159 |     }
160 | }
161 | 


--------------------------------------------------------------------------------
/tests/Feature/ExampleTest.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | test('example', function () {
4 |     expect(true)->toBeTrue();
5 | });
6 | 


--------------------------------------------------------------------------------
/tests/Pest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 | |--------------------------------------------------------------------------
 5 | | Test Case
 6 | |--------------------------------------------------------------------------
 7 | |
 8 | | The closure you provide to your test functions is always bound to a specific PHPUnit test
 9 | | case class. By default, that class is "PHPUnit\Framework\TestCase". Of course, you may
10 | | need to change it using the "uses()" function to bind a different classes or traits.
11 | |
12 | */
13 | 
14 | // uses(Tests\TestCase::class)->in('Feature');
15 | 
16 | /*
17 | |--------------------------------------------------------------------------
18 | | Expectations
19 | |--------------------------------------------------------------------------
20 | |
21 | | When you're writing tests, you often need to check that values meet certain conditions. The
22 | | "expect()" function gives you access to a set of "expectations" methods that you can use
23 | | to assert different things. Of course, you may extend the Expectation API at any time.
24 | |
25 | */
26 | 
27 | expect()->extend('toBeOne', fn () => $this->toBe(1));
28 | 
29 | /*
30 | |--------------------------------------------------------------------------
31 | | Functions
32 | |--------------------------------------------------------------------------
33 | |
34 | | While Pest is very powerful out-of-the-box, you may have some testing code specific to your
35 | | project that you don't want to repeat in every file. Here you can also expose helpers as
36 | | global functions to help you to reduce the number of lines of code in your test files.
37 | |
38 | */
39 | 
40 | function something()
41 | {
42 |     // ..
43 | }
44 | 


--------------------------------------------------------------------------------
/tests/TestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests;
 4 | 
 5 | use PHPUnit\Framework\TestCase as BaseTestCase;
 6 | 
 7 | abstract class TestCase extends BaseTestCase
 8 | {
 9 |     //
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/Unit/ExampleTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Jeidison\PdfSigner\Metadata;
 4 | use Jeidison\PdfSigner\Signer;
 5 | 
 6 | test('example2', function () {
 7 |     $certs = [
 8 |         ['path' => __DIR__.'/../../file-tests/9812.pfx', 'password' => '9812'],
 9 |         ['path' => __DIR__.'/../../file-tests/jeidison1809.pfx', 'password' => 'jeidison1809'],
10 |         ['path' => __DIR__.'/../../file-tests/msvppsvtsd1234.pfx', 'password' => 'msvppsvtsd1234'],
11 |         ['path' => __DIR__.'/../../file-tests/certificado-1234.pfx', 'password' => '1234'],
12 |         //        ['path' => __DIR__ . '/../../file-tests/expirado-123456.pfx', 'password' => '123456'],
13 |     ];
14 | 
15 |     $fileContent = file_get_contents(__DIR__.'/../../file-tests/FOR-52 Comunicado de Homologação.pdf');
16 |     foreach ($certs as $cert) {
17 |         $fileContent = Signer::new()
18 |             ->withCertificate($cert['path'], $cert['password'])
19 |             ->withContent($fileContent)
20 |             ->withMetadata(
21 |                 Metadata::new()
22 |                     ->withReason('ASSINATURA DE DOCUMENTOS PARA TESTES.')
23 |                     ->withName('JEIDISON SANTOS FARIAS')
24 |                     ->withLocation('Araras/SP')
25 |                     ->withContactInfo('Jeidison Farias <jeidison.farias@gmail.com>')
26 |             )
27 |             ->sign();
28 |     }
29 | 
30 |     file_put_contents(__DIR__.'/../../file-tests/signed-1.pdf', $fileContent);
31 |     expect(true)->toBeTrue();
32 | });
33 | 


--------------------------------------------------------------------------------