|
0
|
1 <?php
|
|
|
2
|
|
|
3 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
|
|
|
4
|
|
|
5 /**
|
|
|
6 * Encrypt and sign tests for the Crypt_GPG package.
|
|
|
7 *
|
|
|
8 * These tests require the PHPUnit 3.6 or greater package to be installed.
|
|
|
9 * PHPUnit is installable using PEAR. See the
|
|
|
10 * {@link http://www.phpunit.de/manual/3.6/en/installation.html manual}
|
|
|
11 * for detailed installation instructions.
|
|
|
12 *
|
|
|
13 * To run these tests, use:
|
|
|
14 * <code>
|
|
|
15 * $ phpunit EncryptSignTestCase
|
|
|
16 * </code>
|
|
|
17 *
|
|
|
18 * LICENSE:
|
|
|
19 *
|
|
|
20 * This library is free software; you can redistribute it and/or modify
|
|
|
21 * it under the terms of the GNU Lesser General Public License as
|
|
|
22 * published by the Free Software Foundation; either version 2.1 of the
|
|
|
23 * License, or (at your option) any later version.
|
|
|
24 *
|
|
|
25 * This library is distributed in the hope that it will be useful,
|
|
|
26 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
28 * Lesser General Public License for more details.
|
|
|
29 *
|
|
|
30 * You should have received a copy of the GNU Lesser General Public
|
|
|
31 * License along with this library; if not, see
|
|
|
32 * <http://www.gnu.org/licenses/>
|
|
|
33 *
|
|
|
34 * @category Encryption
|
|
|
35 * @package Crypt_GPG
|
|
|
36 * @author Michael Gauthier <mike@silverorange.com>
|
|
|
37 * @copyright 2005-2009 silverorange
|
|
|
38 * @license http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
|
|
|
39 * @version $Id$
|
|
|
40 * @link http://pear.php.net/package/Crypt_GPG
|
|
|
41 */
|
|
|
42
|
|
|
43 /**
|
|
|
44 * Base test case.
|
|
|
45 */
|
|
|
46 require_once 'TestCase.php';
|
|
|
47
|
|
|
48 /**
|
|
|
49 * Tests encrypt and sign abilities of Crypt_GPG.
|
|
|
50 *
|
|
|
51 * @category Encryption
|
|
|
52 * @package Crypt_GPG
|
|
|
53 * @author Michael Gauthier <mike@silverorange.com>
|
|
|
54 * @copyright 2005-2009 silverorange
|
|
|
55 * @license http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
|
|
|
56 * @link http://pear.php.net/package/Crypt_GPG
|
|
|
57 */
|
|
|
58 class EncryptAndSignTestCase extends Crypt_GPG_TestCase
|
|
|
59 {
|
|
|
60 // string
|
|
|
61 // {{{ testEncryptAndSignKeyNotFoundException_invalid_sign_key()
|
|
|
62
|
|
|
63 /**
|
|
|
64 * @expectedException Crypt_GPG_KeyNotFoundException
|
|
|
65 *
|
|
|
66 * @group string
|
|
|
67 */
|
|
|
68 public function testEncryptAndSignKeyNotFoundException_invalid_sign_key()
|
|
|
69 {
|
|
|
70 $data = 'Hello, Alice! Goodbye, Bob!';
|
|
|
71 $this->gpg->addSignKey('non-existent-key@example.com');
|
|
|
72 $this->gpg->addEncryptKey('first-keypair@example.com');
|
|
|
73 $this->gpg->encryptAndSign($data);
|
|
|
74 }
|
|
|
75
|
|
|
76 // }}}
|
|
|
77 // {{{ testEncryptAndSignKeyNotFoundException_no_sign_key()
|
|
|
78
|
|
|
79 /**
|
|
|
80 * @expectedException Crypt_GPG_KeyNotFoundException
|
|
|
81 *
|
|
|
82 * @group string
|
|
|
83 */
|
|
|
84 public function testEncryptAndSignKeyNotFoundException_no_sign_key()
|
|
|
85 {
|
|
|
86 $data = 'Hello, Alice! Goodbye, Bob!';
|
|
|
87 $this->gpg->addEncryptKey('first-keypair@example.com');
|
|
|
88 $this->gpg->encryptAndSign($data);
|
|
|
89 }
|
|
|
90
|
|
|
91 // }}}
|
|
|
92 // {{{ testEncryptAndSignKeyNotFoundException_invalid_encrypt_key()
|
|
|
93
|
|
|
94 /**
|
|
|
95 * @expectedException Crypt_GPG_KeyNotFoundException
|
|
|
96 *
|
|
|
97 * @group string
|
|
|
98 */
|
|
|
99 public function testEncryptAndSignKeyNotFoundException_invalid_encrypt_key()
|
|
|
100 {
|
|
|
101 $data = 'Hello, Alice! Goodbye, Bob!';
|
|
|
102 $this->gpg->addSignKey('first-keypair@example.com', 'test1');
|
|
|
103 $this->gpg->addEncryptKey('non-existent-key@example.com');
|
|
|
104 $this->gpg->encryptAndSign($data);
|
|
|
105 }
|
|
|
106
|
|
|
107 // }}}
|
|
|
108 // {{{ testEncryptAndSignKeyNotFoundException_no_encrypt_key()
|
|
|
109
|
|
|
110 /**
|
|
|
111 * @expectedException Crypt_GPG_KeyNotFoundException
|
|
|
112 *
|
|
|
113 * @group string
|
|
|
114 */
|
|
|
115 public function testEncryptAndSignKeyNotFoundException_no_encrypt_key()
|
|
|
116 {
|
|
|
117 $data = 'Hello, Alice! Goodbye, Bob!';
|
|
|
118 $this->gpg->addSignKey('first-keypair@example.com', 'test1');
|
|
|
119 $this->gpg->encryptAndSign($data);
|
|
|
120 }
|
|
|
121
|
|
|
122 // }}}
|
|
|
123 // {{{ testEncryptAndSignBadPassphraseException_missing_sign_key()
|
|
|
124
|
|
|
125 /**
|
|
|
126 * @expectedException Crypt_GPG_BadPassphraseException
|
|
|
127 *
|
|
|
128 * @group string
|
|
|
129 */
|
|
|
130 public function testEncryptAndSignBadPassphraseException_missing_sign_key()
|
|
|
131 {
|
|
|
132 $data = 'Hello, Alice! Goodbye, Bob!';
|
|
|
133 $this->gpg->addSignKey('first-keypair@example.com');
|
|
|
134 $this->gpg->addEncryptKey('first-keypair@example.com');
|
|
|
135 $this->gpg->encryptAndSign($data);
|
|
|
136 }
|
|
|
137
|
|
|
138 // }}}
|
|
|
139 // {{{ testEncryptAndSignBadPassphraseException_bad_sign_key()
|
|
|
140
|
|
|
141 /**
|
|
|
142 * @expectedException Crypt_GPG_BadPassphraseException
|
|
|
143 *
|
|
|
144 * @group string
|
|
|
145 */
|
|
|
146 public function testEncryptAndSignBadPassphraseException_bad_sign_key()
|
|
|
147 {
|
|
|
148 $data = 'Hello, Alice! Goodbye, Bob!';
|
|
|
149 $this->gpg->addSignKey('first-keypair@example.com', 'incorrect');
|
|
|
150 $this->gpg->addEncryptKey('first-keypair@example.com');
|
|
|
151 $this->gpg->encryptAndSign($data);
|
|
|
152 }
|
|
|
153
|
|
|
154 // }}}
|
|
|
155 // {{{ testEncryptAndSignNoPassphrase()
|
|
|
156
|
|
|
157 /**
|
|
|
158 * @group string
|
|
|
159 */
|
|
|
160 public function testEncryptAndSignNoPassphrase()
|
|
|
161 {
|
|
|
162 $data = 'Hello, Alice! Goodbye, Bob!';
|
|
|
163
|
|
|
164 $signKey = 'no-passphrase@example.com';
|
|
|
165 $encryptKey = 'first-keypair@example.com';
|
|
|
166 $decryptPassphrase = 'test1';
|
|
|
167
|
|
|
168 $this->gpg->addSignKey($signKey);
|
|
|
169 $this->gpg->addEncryptKey($encryptKey);
|
|
|
170 $encryptedSignedData = $this->gpg->encryptAndSign($data);
|
|
|
171
|
|
|
172 $this->gpg->addDecryptKey($encryptKey, $decryptPassphrase);
|
|
|
173 $results = $this->gpg->decryptAndVerify($encryptedSignedData);
|
|
|
174
|
|
|
175 $this->assertEquals($data, $results['data']);
|
|
|
176 $this->assertEquals(1, count($results['signatures']));
|
|
|
177 foreach ($results['signatures'] as $signature) {
|
|
|
178 $this->assertTrue($signature->isValid());
|
|
|
179 }
|
|
|
180 }
|
|
|
181
|
|
|
182 // }}}
|
|
|
183 // {{{ testEncryptAndSign()
|
|
|
184
|
|
|
185 /**
|
|
|
186 * @group string
|
|
|
187 */
|
|
|
188 public function testEncryptAndSign()
|
|
|
189 {
|
|
|
190 $data = 'Hello, Alice! Goodbye, Bob!';
|
|
|
191
|
|
|
192 $signKey = 'first-keypair@example.com';
|
|
|
193 $signPassphrase = 'test1';
|
|
|
194 $encryptKey = 'first-keypair@example.com';
|
|
|
195 $decryptPassphrase = 'test1';
|
|
|
196
|
|
|
197 $this->gpg->addSignKey($signKey, $signPassphrase);
|
|
|
198 $this->gpg->addEncryptKey($encryptKey);
|
|
|
199 $encryptedSignedData = $this->gpg->encryptAndSign($data);
|
|
|
200
|
|
|
201 $this->gpg->addDecryptKey($encryptKey, $decryptPassphrase);
|
|
|
202 $results = $this->gpg->decryptAndVerify($encryptedSignedData);
|
|
|
203
|
|
|
204 $this->assertEquals($data, $results['data']);
|
|
|
205 $this->assertEquals(1, count($results['signatures']));
|
|
|
206 foreach ($results['signatures'] as $signature) {
|
|
|
207 $this->assertTrue($signature->isValid());
|
|
|
208 }
|
|
|
209 }
|
|
|
210
|
|
|
211 // }}}
|
|
|
212 // {{{ testEncryptAndSignDualOnePassphrase()
|
|
|
213
|
|
|
214 /**
|
|
|
215 * @group string
|
|
|
216 */
|
|
|
217 public function testEncryptAndSignDualOnePassphrase()
|
|
|
218 {
|
|
|
219 $data = 'Hello, Alice! Goodbye, Bob!';
|
|
|
220
|
|
|
221 $signKey1 = 'first-keypair@example.com';
|
|
|
222 $signPassphrase1 = 'test1';
|
|
|
223 $signKey2 = 'no-passphrase@example.com';
|
|
|
224 $encryptKey = 'first-keypair@example.com';
|
|
|
225 $decryptPassphrase = 'test1';
|
|
|
226
|
|
|
227 $this->gpg->addSignKey($signKey1, $signPassphrase1);
|
|
|
228 $this->gpg->addSignKey($signKey2);
|
|
|
229 $this->gpg->addEncryptKey($encryptKey);
|
|
|
230 $encryptedSignedData = $this->gpg->encryptAndSign($data);
|
|
|
231
|
|
|
232 $this->gpg->addDecryptKey($encryptKey, $decryptPassphrase);
|
|
|
233 $results = $this->gpg->decryptAndVerify($encryptedSignedData);
|
|
|
234
|
|
|
235 $this->assertEquals($data, $results['data']);
|
|
|
236 $this->assertEquals(2, count($results['signatures']));
|
|
|
237 foreach ($results['signatures'] as $signature) {
|
|
|
238 $this->assertTrue($signature->isValid());
|
|
|
239 }
|
|
|
240 }
|
|
|
241
|
|
|
242 // }}}
|
|
|
243 // {{{ testEncryptAndSignDual()
|
|
|
244
|
|
|
245 /**
|
|
|
246 * @group string
|
|
|
247 */
|
|
|
248 public function testEncryptAndSignDual()
|
|
|
249 {
|
|
|
250 $data = 'Hello, Alice! Goodbye, Bob!';
|
|
|
251
|
|
|
252 $signKey1 = 'first-keypair@example.com';
|
|
|
253 $signPassphrase1 = 'test1';
|
|
|
254 $signKey2 = 'second-keypair@example.com';
|
|
|
255 $signPassphrase2 = 'test2';
|
|
|
256 $encryptKey = 'first-keypair@example.com';
|
|
|
257 $decryptPassphrase = 'test1';
|
|
|
258
|
|
|
259 $this->gpg->addSignKey($signKey1, $signPassphrase1);
|
|
|
260 $this->gpg->addSignKey($signKey2, $signPassphrase2);
|
|
|
261 $this->gpg->addEncryptKey($encryptKey);
|
|
|
262 $encryptedSignedData = $this->gpg->encryptAndSign($data);
|
|
|
263
|
|
|
264 $this->gpg->addDecryptKey($encryptKey, $decryptPassphrase);
|
|
|
265 $results = $this->gpg->decryptAndVerify($encryptedSignedData);
|
|
|
266
|
|
|
267 $this->assertEquals($data, $results['data']);
|
|
|
268 $this->assertEquals(2, count($results['signatures']));
|
|
|
269 foreach ($results['signatures'] as $signature) {
|
|
|
270 $this->assertTrue($signature->isValid());
|
|
|
271 }
|
|
|
272 }
|
|
|
273
|
|
|
274 // }}}
|
|
|
275 // {{{ testEncryptAndSignEmpty()
|
|
|
276
|
|
|
277 /**
|
|
|
278 * @group string
|
|
|
279 */
|
|
|
280 public function testEncryptAndSignEmpty()
|
|
|
281 {
|
|
|
282 $data = '';
|
|
|
283
|
|
|
284 $this->gpg->addSignKey('first-keypair@example.com', 'test1');
|
|
|
285 $this->gpg->addEncryptKey('first-keypair@example.com');
|
|
|
286 $encryptedSignedData = $this->gpg->encryptAndSign($data);
|
|
|
287
|
|
|
288 $this->gpg->addDecryptKey('first-keypair@example.com', 'test1');
|
|
|
289 $results = $this->gpg->decryptAndVerify($encryptedSignedData);
|
|
|
290
|
|
|
291 $this->assertEquals('', $results['data']);
|
|
|
292 $this->assertEquals(1, count($results['signatures']));
|
|
|
293 foreach ($results['signatures'] as $signature) {
|
|
|
294 $this->assertTrue($signature->isValid());
|
|
|
295 }
|
|
|
296 }
|
|
|
297
|
|
|
298 // }}}
|
|
|
299 // {{{ testEncryptAndSignFileNoPassphrase()
|
|
|
300
|
|
|
301 /**
|
|
|
302 * @group file
|
|
|
303 */
|
|
|
304 public function testEncryptAndSignFileNoPassphrase()
|
|
|
305 {
|
|
|
306 $expectedMd5Sum = 'f96267d87551ee09bfcac16921e351c1';
|
|
|
307 $originalFilename = $this->getDataFilename('testFileMedium.plain');
|
|
|
308 $encryptedFilename =
|
|
|
309 $this->getTempFilename('testEncryptAndSignFileNoPassphrase.asc');
|
|
|
310
|
|
|
311 $decryptedFilename =
|
|
|
312 $this->getTempFilename('testEncryptAndSignFileNoPassphrase.plain');
|
|
|
313
|
|
|
314 $this->gpg->addSignKey('no-passphrase@example.com');
|
|
|
315 $this->gpg->addEncryptKey('first-keypair@example.com');
|
|
|
316 $this->gpg->encryptAndSignFile($originalFilename, $encryptedFilename);
|
|
|
317
|
|
|
318 $this->gpg->addDecryptKey('first-keypair@example.com', 'test1');
|
|
|
319 $results = $this->gpg->decryptAndVerifyFile($encryptedFilename,
|
|
|
320 $decryptedFilename);
|
|
|
321
|
|
|
322 $md5Sum = $this->getMd5Sum($decryptedFilename);
|
|
|
323 $this->assertEquals($expectedMd5Sum, $md5Sum);
|
|
|
324
|
|
|
325 $this->assertEquals(1, count($results['signatures']));
|
|
|
326 foreach ($results['signatures'] as $signature) {
|
|
|
327 $this->assertTrue($signature->isValid());
|
|
|
328 }
|
|
|
329 }
|
|
|
330
|
|
|
331 // }}}
|
|
|
332 // {{{ testEncryptAndSignFile()
|
|
|
333
|
|
|
334 /**
|
|
|
335 * @group file
|
|
|
336 */
|
|
|
337 public function testEncryptAndSignFile()
|
|
|
338 {
|
|
|
339 $expectedMd5Sum = 'f96267d87551ee09bfcac16921e351c1';
|
|
|
340 $originalFilename = $this->getDataFilename('testFileMedium.plain');
|
|
|
341 $encryptedFilename =
|
|
|
342 $this->getTempFilename('testEncryptAndSignFileNoPassphrase.asc');
|
|
|
343
|
|
|
344 $decryptedFilename =
|
|
|
345 $this->getTempFilename('testEncryptAndSignFileNoPassphrase.plain');
|
|
|
346
|
|
|
347 $this->gpg->addSignKey('first-keypair@example.com', 'test1');
|
|
|
348 $this->gpg->addEncryptKey('first-keypair@example.com');
|
|
|
349 $this->gpg->encryptAndSignFile($originalFilename, $encryptedFilename);
|
|
|
350
|
|
|
351 $this->gpg->addDecryptKey('first-keypair@example.com', 'test1');
|
|
|
352 $results = $this->gpg->decryptAndVerifyFile($encryptedFilename,
|
|
|
353 $decryptedFilename);
|
|
|
354
|
|
|
355 $md5Sum = $this->getMd5Sum($decryptedFilename);
|
|
|
356 $this->assertEquals($expectedMd5Sum, $md5Sum);
|
|
|
357
|
|
|
358 $this->assertEquals(1, count($results['signatures']));
|
|
|
359 foreach ($results['signatures'] as $signature) {
|
|
|
360 $this->assertTrue($signature->isValid());
|
|
|
361 }
|
|
|
362 }
|
|
|
363
|
|
|
364 // }}}
|
|
|
365 // {{{ testEncryptAndSignFileDualOnePassphrase()
|
|
|
366
|
|
|
367 /**
|
|
|
368 * @group file
|
|
|
369 */
|
|
|
370 public function testEncryptAndSignFileDualOnePassphrase()
|
|
|
371 {
|
|
|
372 $expectedMd5Sum = 'f96267d87551ee09bfcac16921e351c1';
|
|
|
373 $originalFilename = $this->getDataFilename('testFileMedium.plain');
|
|
|
374 $encryptedFilename =
|
|
|
375 $this->getTempFilename('testEncryptAndSignFileNoPassphrase.asc');
|
|
|
376
|
|
|
377 $decryptedFilename =
|
|
|
378 $this->getTempFilename('testEncryptAndSignFileNoPassphrase.plain');
|
|
|
379
|
|
|
380 $this->gpg->addSignKey('first-keypair@example.com', 'test1');
|
|
|
381 $this->gpg->addSignKey('no-passphrase@example.com');
|
|
|
382 $this->gpg->addEncryptKey('first-keypair@example.com');
|
|
|
383 $this->gpg->encryptAndSignFile($originalFilename, $encryptedFilename);
|
|
|
384
|
|
|
385 $this->gpg->addDecryptKey('first-keypair@example.com', 'test1');
|
|
|
386 $results = $this->gpg->decryptAndVerifyFile($encryptedFilename,
|
|
|
387 $decryptedFilename);
|
|
|
388
|
|
|
389 $md5Sum = $this->getMd5Sum($decryptedFilename);
|
|
|
390 $this->assertEquals($expectedMd5Sum, $md5Sum);
|
|
|
391
|
|
|
392 $this->assertEquals(2, count($results['signatures']));
|
|
|
393 foreach ($results['signatures'] as $signature) {
|
|
|
394 $this->assertTrue($signature->isValid());
|
|
|
395 }
|
|
|
396 }
|
|
|
397
|
|
|
398 // }}}
|
|
|
399 // {{{ testEncryptAndSignFileDual()
|
|
|
400
|
|
|
401 /**
|
|
|
402 * @group file
|
|
|
403 */
|
|
|
404 public function testEncryptAndSignFileDual()
|
|
|
405 {
|
|
|
406 $expectedMd5Sum = 'f96267d87551ee09bfcac16921e351c1';
|
|
|
407 $originalFilename = $this->getDataFilename('testFileMedium.plain');
|
|
|
408 $encryptedFilename =
|
|
|
409 $this->getTempFilename('testEncryptAndSignFileNoPassphrase.asc');
|
|
|
410
|
|
|
411 $decryptedFilename =
|
|
|
412 $this->getTempFilename('testEncryptAndSignFileNoPassphrase.plain');
|
|
|
413
|
|
|
414 $this->gpg->addSignKey('first-keypair@example.com', 'test1');
|
|
|
415 $this->gpg->addSignKey('second-keypair@example.com', 'test2');
|
|
|
416 $this->gpg->addEncryptKey('first-keypair@example.com');
|
|
|
417 $this->gpg->encryptAndSignFile($originalFilename, $encryptedFilename);
|
|
|
418
|
|
|
419 $this->gpg->addDecryptKey('first-keypair@example.com', 'test1');
|
|
|
420 $results = $this->gpg->decryptAndVerifyFile($encryptedFilename,
|
|
|
421 $decryptedFilename);
|
|
|
422
|
|
|
423 $md5Sum = $this->getMd5Sum($decryptedFilename);
|
|
|
424 $this->assertEquals($expectedMd5Sum, $md5Sum);
|
|
|
425
|
|
|
426 $this->assertEquals(2, count($results['signatures']));
|
|
|
427 foreach ($results['signatures'] as $signature) {
|
|
|
428 $this->assertTrue($signature->isValid());
|
|
|
429 }
|
|
|
430 }
|
|
|
431
|
|
|
432 // }}}
|
|
|
433 // {{{ testEncryptAndSignFileFileException_input()
|
|
|
434
|
|
|
435 /**
|
|
|
436 * @expectedException Crypt_GPG_FileException
|
|
|
437 *
|
|
|
438 * @group file
|
|
|
439 */
|
|
|
440 public function testEncryptAndSignFileFileException_input()
|
|
|
441 {
|
|
|
442 // input file does not exist
|
|
|
443 $inputFilename = $this->getDataFilename(
|
|
|
444 'testEncryptAndSignFileFileFileException_input.plain');
|
|
|
445
|
|
|
446 $this->gpg->addSignKey('first-keypair@example.com', 'test1');
|
|
|
447 $this->gpg->addEncryptKey('first-keypair@example.com');
|
|
|
448 $this->gpg->encryptAndSignFile($inputFilename);
|
|
|
449 }
|
|
|
450
|
|
|
451 // }}}
|
|
|
452 // {{{ testEncryptAndSignFileFileException_output()
|
|
|
453
|
|
|
454 /**
|
|
|
455 * @expectedException Crypt_GPG_FileException
|
|
|
456 *
|
|
|
457 * @group file
|
|
|
458 */
|
|
|
459 public function testEncryptAndSignFileFileException_output()
|
|
|
460 {
|
|
|
461 // input file is plaintext
|
|
|
462 // output file does not exist
|
|
|
463 $inputFilename = $this->getDataFilename('testFileMedium.plain');
|
|
|
464 $outputFilename = './non-existent' .
|
|
|
465 '/testEncryptAndSignFileFileException_output.plain';
|
|
|
466
|
|
|
467 $this->gpg->addSignKey('first-keypair@example.com', 'test1');
|
|
|
468 $this->gpg->addEncryptKey('first-keypair@example.com');
|
|
|
469 $this->gpg->encryptAndSignFile($inputFilename, $outputFilename);
|
|
|
470 }
|
|
|
471
|
|
|
472 // }}}
|
|
|
473 // {{{ testEncryptAndSignFileEmpty()
|
|
|
474
|
|
|
475 /**
|
|
|
476 * @group file
|
|
|
477 */
|
|
|
478 public function testEncryptAndSignFileEmpty()
|
|
|
479 {
|
|
|
480 $originalFilename = $this->getDataFilename('testFileEmpty.plain');
|
|
|
481 $encryptedFilename =
|
|
|
482 $this->getTempFilename('testEncryptAndSignFileEmpty.asc');
|
|
|
483
|
|
|
484 $this->gpg->addSignKey('first-keypair@example.com', 'test1');
|
|
|
485 $this->gpg->addEncryptKey('first-keypair@example.com');
|
|
|
486 $this->gpg->encryptAndSignFile($originalFilename, $encryptedFilename);
|
|
|
487
|
|
|
488 $this->gpg->addDecryptKey('first-keypair@example.com', 'test1');
|
|
|
489 $results = $this->gpg->decryptAndVerifyFile($encryptedFilename);
|
|
|
490
|
|
|
491 $this->assertEquals('', $results['data']);
|
|
|
492
|
|
|
493 $this->assertEquals(1, count($results['signatures']));
|
|
|
494 foreach ($results['signatures'] as $signature) {
|
|
|
495 $this->assertTrue($signature->isValid());
|
|
|
496 }
|
|
|
497 }
|
|
|
498
|
|
|
499 // }}}
|
|
|
500 }
|
|
|
501
|
|
|
502 ?>
|
