1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
# Copyright (C) 2017 Jan Jancar
#
# This file is a part of the Mailman PGP plugin.
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
# more details.
#
# You should have received a copy of the GNU General Public License along with
# this program. If not, see <http://www.gnu.org/licenses/>.
""""""
import os
from email import message_from_bytes
from unittest import TestCase
from mailman.email.message import Message
from pgpy import PGPKey
from pkg_resources import resource_string
def load_message(path):
data = resource_string('mailman_pgp.pgp.tests',
os.path.join('data', 'messages', path))
return message_from_bytes(data, Message)
def load_key(path):
key, _ = PGPKey.from_blob(
resource_string('mailman_pgp.pgp.tests',
os.path.join('data', 'keys', path)))
return key
class WrapperTestCase(TestCase):
wrapper = None
def is_signed(self, message, signed):
wrapped = self.wrapper(message)
self.assertEqual(wrapped.is_signed(), signed)
def sign(self, message, key):
wrapped = self.wrapper(message)
signed = wrapped.sign(key)
signed_wrapped = self.wrapper(signed)
self.assertTrue(signed_wrapped.is_signed())
def sign_verify(self, message, priv, pub):
wrapped = self.wrapper(message)
signed = wrapped.sign(priv)
signed_wrapped = self.wrapper(signed)
for signature in signed_wrapped.verify(pub):
self.assertTrue(bool(signature))
def verify(self, message, key, valid):
wrapped = self.wrapper(message)
for signature in wrapped.verify(key):
self.assertEqual(bool(signature), valid)
def is_encrypted(self, message, encrypted):
wrapped = self.wrapper(message)
self.assertEqual(wrapped.is_encrypted(), encrypted)
def encrypt(self, message, *keys, **kwargs):
wrapped = self.wrapper(message)
encrypted = wrapped.encrypt(*keys, **kwargs)
encrypted_wrapped = self.wrapper(encrypted)
self.assertTrue(encrypted_wrapped.is_encrypted())
def encrypt_decrypt(self, message, pub, priv):
wrapped = self.wrapper(message)
encrypted = wrapped.encrypt(pub)
encrypted_wrapped = self.wrapper(encrypted)
decrypted = encrypted_wrapped.decrypt(priv)
decrypted_wrapped = self.wrapper(decrypted)
self.assertFalse(decrypted_wrapped.is_encrypted())
self.assertEqual(decrypted.get_payload(), message.get_payload())
def decrypt(self, message, key, clear):
wrapped = self.wrapper(message)
decrypted = wrapped.decrypt(key)
decrypted_wrapped = self.wrapper(decrypted)
self.assertFalse(decrypted_wrapped.is_encrypted())
self.assertEqual(decrypted.get_payload(), clear)
def has_keys(self, message, has_keys):
wrapped = self.wrapper(message)
self.assertEqual(wrapped.has_keys(), has_keys)
def keys(self, message, keys):
wrapped = self.wrapper(message)
loaded = list(wrapped.keys())
self.assertEqual(len(loaded), len(keys))
loaded_fingerprints = list(map(lambda key: key.fingerprint, loaded))
fingerprints = list(map(lambda key: key.fingerprint, keys))
self.assertListEqual(loaded_fingerprints, fingerprints)
def sign_encrypt_decrypt_verify(self, message, sign_key, encrypt_key):
wrapped = self.wrapper(message)
encrypted = wrapped.sign_encrypt(sign_key, encrypt_key.pubkey)
encrypted_wrapped = self.wrapper(encrypted)
self.assertTrue(encrypted_wrapped.is_encrypted())
decrypted = encrypted_wrapped.decrypt(encrypt_key)
decrypted_wrapped = self.wrapper(decrypted)
self.assertTrue(decrypted_wrapped.is_signed())
self.assertFalse(decrypted_wrapped.is_encrypted())
verification = decrypted_wrapped.verify(sign_key.pubkey)
for sig in verification:
self.assertTrue(bool(sig))
self.assertListEqual(list(decrypted_wrapped.get_signed()),
list(wrapped.get_payload()))
|
