• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# This file is dual licensed under the terms of the Apache License, Version
2# 2.0, and the BSD License. See the LICENSE file in the root of this repository
3# for complete details.
4
5"""
6Test using the NIST Test Vectors
7"""
8
9from __future__ import absolute_import, division, print_function
10
11import binascii
12import os
13
14import pytest
15
16from cryptography.hazmat.backends.interfaces import CipherBackend
17from cryptography.hazmat.primitives.ciphers import algorithms, modes
18
19from .utils import generate_encrypt_test
20from ...utils import load_nist_vectors
21
22
23@pytest.mark.supported(
24    only_if=lambda backend: backend.cipher_supported(
25        algorithms.TripleDES(b"\x00" * 8), modes.CBC(b"\x00" * 8)
26    ),
27    skip_message="Does not support TripleDES CBC",
28)
29@pytest.mark.requires_backend_interface(interface=CipherBackend)
30class TestTripleDESModeCBC(object):
31    test_kat = generate_encrypt_test(
32        load_nist_vectors,
33        os.path.join("ciphers", "3DES", "CBC"),
34        [
35            "TCBCinvperm.rsp",
36            "TCBCpermop.rsp",
37            "TCBCsubtab.rsp",
38            "TCBCvarkey.rsp",
39            "TCBCvartext.rsp",
40        ],
41        lambda keys, **kwargs: algorithms.TripleDES(binascii.unhexlify(keys)),
42        lambda iv, **kwargs: modes.CBC(binascii.unhexlify(iv)),
43    )
44
45    test_mmt = generate_encrypt_test(
46        load_nist_vectors,
47        os.path.join("ciphers", "3DES", "CBC"),
48        ["TCBCMMT1.rsp", "TCBCMMT2.rsp", "TCBCMMT3.rsp"],
49        lambda key1, key2, key3, **kwargs: algorithms.TripleDES(
50            binascii.unhexlify(key1 + key2 + key3)
51        ),
52        lambda iv, **kwargs: modes.CBC(binascii.unhexlify(iv)),
53    )
54
55
56@pytest.mark.supported(
57    only_if=lambda backend: backend.cipher_supported(
58        algorithms.TripleDES(b"\x00" * 8), modes.OFB(b"\x00" * 8)
59    ),
60    skip_message="Does not support TripleDES OFB",
61)
62@pytest.mark.requires_backend_interface(interface=CipherBackend)
63class TestTripleDESModeOFB(object):
64    test_kat = generate_encrypt_test(
65        load_nist_vectors,
66        os.path.join("ciphers", "3DES", "OFB"),
67        [
68            "TOFBpermop.rsp",
69            "TOFBsubtab.rsp",
70            "TOFBvarkey.rsp",
71            "TOFBvartext.rsp",
72            "TOFBinvperm.rsp",
73        ],
74        lambda keys, **kwargs: algorithms.TripleDES(binascii.unhexlify(keys)),
75        lambda iv, **kwargs: modes.OFB(binascii.unhexlify(iv)),
76    )
77
78    test_mmt = generate_encrypt_test(
79        load_nist_vectors,
80        os.path.join("ciphers", "3DES", "OFB"),
81        ["TOFBMMT1.rsp", "TOFBMMT2.rsp", "TOFBMMT3.rsp"],
82        lambda key1, key2, key3, **kwargs: algorithms.TripleDES(
83            binascii.unhexlify(key1 + key2 + key3)
84        ),
85        lambda iv, **kwargs: modes.OFB(binascii.unhexlify(iv)),
86    )
87
88
89@pytest.mark.supported(
90    only_if=lambda backend: backend.cipher_supported(
91        algorithms.TripleDES(b"\x00" * 8), modes.CFB(b"\x00" * 8)
92    ),
93    skip_message="Does not support TripleDES CFB",
94)
95@pytest.mark.requires_backend_interface(interface=CipherBackend)
96class TestTripleDESModeCFB(object):
97    test_kat = generate_encrypt_test(
98        load_nist_vectors,
99        os.path.join("ciphers", "3DES", "CFB"),
100        [
101            "TCFB64invperm.rsp",
102            "TCFB64permop.rsp",
103            "TCFB64subtab.rsp",
104            "TCFB64varkey.rsp",
105            "TCFB64vartext.rsp",
106        ],
107        lambda keys, **kwargs: algorithms.TripleDES(binascii.unhexlify(keys)),
108        lambda iv, **kwargs: modes.CFB(binascii.unhexlify(iv)),
109    )
110
111    test_mmt = generate_encrypt_test(
112        load_nist_vectors,
113        os.path.join("ciphers", "3DES", "CFB"),
114        ["TCFB64MMT1.rsp", "TCFB64MMT2.rsp", "TCFB64MMT3.rsp"],
115        lambda key1, key2, key3, **kwargs: algorithms.TripleDES(
116            binascii.unhexlify(key1 + key2 + key3)
117        ),
118        lambda iv, **kwargs: modes.CFB(binascii.unhexlify(iv)),
119    )
120
121
122@pytest.mark.supported(
123    only_if=lambda backend: backend.cipher_supported(
124        algorithms.TripleDES(b"\x00" * 8), modes.CFB8(b"\x00" * 8)
125    ),
126    skip_message="Does not support TripleDES CFB8",
127)
128@pytest.mark.requires_backend_interface(interface=CipherBackend)
129class TestTripleDESModeCFB8(object):
130    test_kat = generate_encrypt_test(
131        load_nist_vectors,
132        os.path.join("ciphers", "3DES", "CFB"),
133        [
134            "TCFB8invperm.rsp",
135            "TCFB8permop.rsp",
136            "TCFB8subtab.rsp",
137            "TCFB8varkey.rsp",
138            "TCFB8vartext.rsp",
139        ],
140        lambda keys, **kwargs: algorithms.TripleDES(binascii.unhexlify(keys)),
141        lambda iv, **kwargs: modes.CFB8(binascii.unhexlify(iv)),
142    )
143
144    test_mmt = generate_encrypt_test(
145        load_nist_vectors,
146        os.path.join("ciphers", "3DES", "CFB"),
147        ["TCFB8MMT1.rsp", "TCFB8MMT2.rsp", "TCFB8MMT3.rsp"],
148        lambda key1, key2, key3, **kwargs: algorithms.TripleDES(
149            binascii.unhexlify(key1 + key2 + key3)
150        ),
151        lambda iv, **kwargs: modes.CFB8(binascii.unhexlify(iv)),
152    )
153
154
155@pytest.mark.supported(
156    only_if=lambda backend: backend.cipher_supported(
157        algorithms.TripleDES(b"\x00" * 8), modes.ECB()
158    ),
159    skip_message="Does not support TripleDES ECB",
160)
161@pytest.mark.requires_backend_interface(interface=CipherBackend)
162class TestTripleDESModeECB(object):
163    test_kat = generate_encrypt_test(
164        load_nist_vectors,
165        os.path.join("ciphers", "3DES", "ECB"),
166        [
167            "TECBinvperm.rsp",
168            "TECBpermop.rsp",
169            "TECBsubtab.rsp",
170            "TECBvarkey.rsp",
171            "TECBvartext.rsp",
172        ],
173        lambda keys, **kwargs: algorithms.TripleDES(binascii.unhexlify(keys)),
174        lambda **kwargs: modes.ECB(),
175    )
176
177    test_mmt = generate_encrypt_test(
178        load_nist_vectors,
179        os.path.join("ciphers", "3DES", "ECB"),
180        ["TECBMMT1.rsp", "TECBMMT2.rsp", "TECBMMT3.rsp"],
181        lambda key1, key2, key3, **kwargs: algorithms.TripleDES(
182            binascii.unhexlify(key1 + key2 + key3)
183        ),
184        lambda **kwargs: modes.ECB(),
185    )
186