Updated DB_Helper by adding firebase methods.
This commit is contained in:
parent
485cc3bbba
commit
c82121d036
1810 changed files with 537281 additions and 1 deletions
44
venv/Lib/site-packages/Crypto/SelfTest/Util/__init__.py
Normal file
44
venv/Lib/site-packages/Crypto/SelfTest/Util/__init__.py
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# SelfTest/Util/__init__.py: Self-test for utility modules
|
||||
#
|
||||
# Written in 2008 by Dwayne C. Litzenberger <dlitz@dlitz.net>
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
|
||||
"""Self-test for utility modules"""
|
||||
|
||||
__revision__ = "$Id$"
|
||||
|
||||
import os
|
||||
|
||||
def get_tests(config={}):
|
||||
tests = []
|
||||
from Crypto.SelfTest.Util import test_number; tests += test_number.get_tests(config=config)
|
||||
from Crypto.SelfTest.Util import test_Counter; tests += test_Counter.get_tests(config=config)
|
||||
from Crypto.SelfTest.Util import test_Padding; tests += test_Padding.get_tests(config=config)
|
||||
from Crypto.SelfTest.Util import test_strxor; tests += test_strxor.get_tests(config=config)
|
||||
return tests
|
||||
|
||||
if __name__ == '__main__':
|
||||
import unittest
|
||||
suite = lambda: unittest.TestSuite(get_tests())
|
||||
unittest.main(defaultTest='suite')
|
||||
|
||||
# vim:set ts=4 sw=4 sts=4 expandtab:
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
66
venv/Lib/site-packages/Crypto/SelfTest/Util/test_Counter.py
Normal file
66
venv/Lib/site-packages/Crypto/SelfTest/Util/test_Counter.py
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# SelfTest/Util/test_Counter: Self-test for the Crypto.Util.Counter module
|
||||
#
|
||||
# Written in 2009 by Dwayne C. Litzenberger <dlitz@dlitz.net>
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
|
||||
"""Self-tests for Crypto.Util.Counter"""
|
||||
|
||||
from Crypto.Util.py3compat import *
|
||||
|
||||
import unittest
|
||||
|
||||
class CounterTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
global Counter
|
||||
from Crypto.Util import Counter
|
||||
|
||||
def test_BE(self):
|
||||
"""Big endian"""
|
||||
c = Counter.new(128)
|
||||
c = Counter.new(128, little_endian=False)
|
||||
|
||||
def test_LE(self):
|
||||
"""Little endian"""
|
||||
c = Counter.new(128, little_endian=True)
|
||||
|
||||
def test_nbits(self):
|
||||
c = Counter.new(nbits=128)
|
||||
self.assertRaises(ValueError, Counter.new, 129)
|
||||
|
||||
def test_prefix(self):
|
||||
c = Counter.new(128, prefix=b("xx"))
|
||||
|
||||
def test_suffix(self):
|
||||
c = Counter.new(128, suffix=b("xx"))
|
||||
|
||||
def test_iv(self):
|
||||
c = Counter.new(128, initial_value=2)
|
||||
|
||||
def get_tests(config={}):
|
||||
from Crypto.SelfTest.st_common import list_test_cases
|
||||
return list_test_cases(CounterTests)
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = lambda: unittest.TestSuite(get_tests())
|
||||
unittest.main(defaultTest='suite')
|
||||
|
||||
# vim:set ts=4 sw=4 sts=4 expandtab:
|
||||
151
venv/Lib/site-packages/Crypto/SelfTest/Util/test_Padding.py
Normal file
151
venv/Lib/site-packages/Crypto/SelfTest/Util/test_Padding.py
Normal file
|
|
@ -0,0 +1,151 @@
|
|||
#
|
||||
# SelfTest/Util/test_Padding.py: Self-test for padding functions
|
||||
#
|
||||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
import unittest
|
||||
from binascii import unhexlify as uh
|
||||
|
||||
from Crypto.Util.py3compat import *
|
||||
from Crypto.SelfTest.st_common import list_test_cases
|
||||
from Crypto.Util.Padding import pad, unpad
|
||||
|
||||
class PKCS7_Tests(unittest.TestCase):
|
||||
|
||||
def test1(self):
|
||||
padded = pad(b(""), 4)
|
||||
self.assertTrue(padded == uh(b("04040404")))
|
||||
padded = pad(b(""), 4, 'pkcs7')
|
||||
self.assertTrue(padded == uh(b("04040404")))
|
||||
back = unpad(padded, 4)
|
||||
self.assertTrue(back == b(""))
|
||||
|
||||
def test2(self):
|
||||
padded = pad(uh(b("12345678")), 4)
|
||||
self.assertTrue(padded == uh(b("1234567804040404")))
|
||||
back = unpad(padded, 4)
|
||||
self.assertTrue(back == uh(b("12345678")))
|
||||
|
||||
def test3(self):
|
||||
padded = pad(uh(b("123456")), 4)
|
||||
self.assertTrue(padded == uh(b("12345601")))
|
||||
back = unpad(padded, 4)
|
||||
self.assertTrue(back == uh(b("123456")))
|
||||
|
||||
def test4(self):
|
||||
padded = pad(uh(b("1234567890")), 4)
|
||||
self.assertTrue(padded == uh(b("1234567890030303")))
|
||||
back = unpad(padded, 4)
|
||||
self.assertTrue(back == uh(b("1234567890")))
|
||||
|
||||
def testn1(self):
|
||||
self.assertRaises(ValueError, pad, uh(b("12")), 4, 'pkcs8')
|
||||
|
||||
def testn2(self):
|
||||
self.assertRaises(ValueError, unpad, b("\0\0\0"), 4)
|
||||
|
||||
def testn3(self):
|
||||
self.assertRaises(ValueError, unpad, b("123456\x02"), 4)
|
||||
self.assertRaises(ValueError, unpad, b("123456\x00"), 4)
|
||||
self.assertRaises(ValueError, unpad, b("123456\x05\x05\x05\x05\x05"), 4)
|
||||
|
||||
class X923_Tests(unittest.TestCase):
|
||||
|
||||
def test1(self):
|
||||
padded = pad(b(""), 4, 'x923')
|
||||
self.assertTrue(padded == uh(b("00000004")))
|
||||
back = unpad(padded, 4, 'x923')
|
||||
self.assertTrue(back == b(""))
|
||||
|
||||
def test2(self):
|
||||
padded = pad(uh(b("12345678")), 4, 'x923')
|
||||
self.assertTrue(padded == uh(b("1234567800000004")))
|
||||
back = unpad(padded, 4, 'x923')
|
||||
self.assertTrue(back == uh(b("12345678")))
|
||||
|
||||
def test3(self):
|
||||
padded = pad(uh(b("123456")), 4, 'x923')
|
||||
self.assertTrue(padded == uh(b("12345601")))
|
||||
back = unpad(padded, 4, 'x923')
|
||||
self.assertTrue(back == uh(b("123456")))
|
||||
|
||||
def test4(self):
|
||||
padded = pad(uh(b("1234567890")), 4, 'x923')
|
||||
self.assertTrue(padded == uh(b("1234567890000003")))
|
||||
back = unpad(padded, 4, 'x923')
|
||||
self.assertTrue(back == uh(b("1234567890")))
|
||||
|
||||
def testn1(self):
|
||||
self.assertRaises(ValueError, unpad, b("123456\x02"), 4, 'x923')
|
||||
self.assertRaises(ValueError, unpad, b("123456\x00"), 4, 'x923')
|
||||
self.assertRaises(ValueError, unpad, b("123456\x00\x00\x00\x00\x05"), 4, 'x923')
|
||||
|
||||
class ISO7816_Tests(unittest.TestCase):
|
||||
|
||||
def test1(self):
|
||||
padded = pad(b(""), 4, 'iso7816')
|
||||
self.assertTrue(padded == uh(b("80000000")))
|
||||
back = unpad(padded, 4, 'iso7816')
|
||||
self.assertTrue(back == b(""))
|
||||
|
||||
def test2(self):
|
||||
padded = pad(uh(b("12345678")), 4, 'iso7816')
|
||||
self.assertTrue(padded == uh(b("1234567880000000")))
|
||||
back = unpad(padded, 4, 'iso7816')
|
||||
self.assertTrue(back == uh(b("12345678")))
|
||||
|
||||
def test3(self):
|
||||
padded = pad(uh(b("123456")), 4, 'iso7816')
|
||||
self.assertTrue(padded == uh(b("12345680")))
|
||||
#import pdb; pdb.set_trace()
|
||||
back = unpad(padded, 4, 'iso7816')
|
||||
self.assertTrue(back == uh(b("123456")))
|
||||
|
||||
def test4(self):
|
||||
padded = pad(uh(b("1234567890")), 4, 'iso7816')
|
||||
self.assertTrue(padded == uh(b("1234567890800000")))
|
||||
back = unpad(padded, 4, 'iso7816')
|
||||
self.assertTrue(back == uh(b("1234567890")))
|
||||
|
||||
def testn1(self):
|
||||
self.assertRaises(ValueError, unpad, b("123456\x81"), 4, 'iso7816')
|
||||
|
||||
def get_tests(config={}):
|
||||
tests = []
|
||||
tests += list_test_cases(PKCS7_Tests)
|
||||
tests += list_test_cases(X923_Tests)
|
||||
tests += list_test_cases(ISO7816_Tests)
|
||||
return tests
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = lambda: unittest.TestSuite(get_tests())
|
||||
unittest.main(defaultTest='suite')
|
||||
|
||||
769
venv/Lib/site-packages/Crypto/SelfTest/Util/test_asn1.py
Normal file
769
venv/Lib/site-packages/Crypto/SelfTest/Util/test_asn1.py
Normal file
|
|
@ -0,0 +1,769 @@
|
|||
#
|
||||
# SelfTest/Util/test_asn.py: Self-test for the Crypto.Util.asn1 module
|
||||
#
|
||||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
"""Self-tests for Crypto.Util.asn1"""
|
||||
|
||||
import unittest
|
||||
|
||||
from Crypto.Util.py3compat import *
|
||||
from Crypto.Util.asn1 import (DerObject, DerSetOf, DerInteger,
|
||||
DerBitString,
|
||||
DerObjectId, DerNull, DerOctetString,
|
||||
DerSequence)
|
||||
|
||||
class DerObjectTests(unittest.TestCase):
|
||||
|
||||
def testObjInit1(self):
|
||||
# Fail with invalid tag format (must be 1 byte)
|
||||
self.assertRaises(ValueError, DerObject, b('\x00\x99'))
|
||||
# Fail with invalid implicit tag (must be <0x1F)
|
||||
self.assertRaises(ValueError, DerObject, 0x1F)
|
||||
|
||||
# ------
|
||||
|
||||
def testObjEncode1(self):
|
||||
# No payload
|
||||
der = DerObject(b('\x02'))
|
||||
self.assertEqual(der.encode(), b('\x02\x00'))
|
||||
# Small payload (primitive)
|
||||
der.payload = b('\x45')
|
||||
self.assertEqual(der.encode(), b('\x02\x01\x45'))
|
||||
# Invariant
|
||||
self.assertEqual(der.encode(), b('\x02\x01\x45'))
|
||||
# Initialize with numerical tag
|
||||
der = DerObject(0x04)
|
||||
der.payload = b('\x45')
|
||||
self.assertEqual(der.encode(), b('\x04\x01\x45'))
|
||||
# Initialize with constructed type
|
||||
der = DerObject(b('\x10'), constructed=True)
|
||||
self.assertEqual(der.encode(), b('\x30\x00'))
|
||||
|
||||
def testObjEncode2(self):
|
||||
# Initialize with payload
|
||||
der = DerObject(0x03, b('\x12\x12'))
|
||||
self.assertEqual(der.encode(), b('\x03\x02\x12\x12'))
|
||||
|
||||
def testObjEncode3(self):
|
||||
# Long payload
|
||||
der = DerObject(b('\x10'))
|
||||
der.payload = b("0")*128
|
||||
self.assertEqual(der.encode(), b('\x10\x81\x80' + "0"*128))
|
||||
|
||||
def testObjEncode4(self):
|
||||
# Implicit tags (constructed)
|
||||
der = DerObject(0x10, implicit=1, constructed=True)
|
||||
der.payload = b('ppll')
|
||||
self.assertEqual(der.encode(), b('\xa1\x04ppll'))
|
||||
# Implicit tags (primitive)
|
||||
der = DerObject(0x02, implicit=0x1E, constructed=False)
|
||||
der.payload = b('ppll')
|
||||
self.assertEqual(der.encode(), b('\x9E\x04ppll'))
|
||||
|
||||
def testObjEncode5(self):
|
||||
# Encode type with explicit tag
|
||||
der = DerObject(0x10, explicit=5)
|
||||
der.payload = b("xxll")
|
||||
self.assertEqual(der.encode(), b("\xa5\x06\x10\x04xxll"))
|
||||
|
||||
# -----
|
||||
|
||||
def testObjDecode1(self):
|
||||
# Decode short payload
|
||||
der = DerObject(0x02)
|
||||
der.decode(b('\x02\x02\x01\x02'))
|
||||
self.assertEqual(der.payload, b("\x01\x02"))
|
||||
self.assertEqual(der._tag_octet, 0x02)
|
||||
|
||||
def testObjDecode2(self):
|
||||
# Decode long payload
|
||||
der = DerObject(0x02)
|
||||
der.decode(b('\x02\x81\x80' + "1"*128))
|
||||
self.assertEqual(der.payload, b("1")*128)
|
||||
self.assertEqual(der._tag_octet, 0x02)
|
||||
|
||||
def testObjDecode3(self):
|
||||
# Decode payload with too much data gives error
|
||||
der = DerObject(0x02)
|
||||
self.assertRaises(ValueError, der.decode, b('\x02\x02\x01\x02\xFF'))
|
||||
# Decode payload with too little data gives error
|
||||
der = DerObject(0x02)
|
||||
self.assertRaises(ValueError, der.decode, b('\x02\x02\x01'))
|
||||
|
||||
def testObjDecode4(self):
|
||||
# Decode implicit tag (primitive)
|
||||
der = DerObject(0x02, constructed=False, implicit=0xF)
|
||||
self.assertRaises(ValueError, der.decode, b('\x02\x02\x01\x02'))
|
||||
der.decode(b('\x8F\x01\x00'))
|
||||
self.assertEqual(der.payload, b('\x00'))
|
||||
# Decode implicit tag (constructed)
|
||||
der = DerObject(0x02, constructed=True, implicit=0xF)
|
||||
self.assertRaises(ValueError, der.decode, b('\x02\x02\x01\x02'))
|
||||
der.decode(b('\xAF\x01\x00'))
|
||||
self.assertEqual(der.payload, b('\x00'))
|
||||
|
||||
def testObjDecode5(self):
|
||||
# Decode payload with unexpected tag gives error
|
||||
der = DerObject(0x02)
|
||||
self.assertRaises(ValueError, der.decode, b('\x03\x02\x01\x02'))
|
||||
|
||||
def testObjDecode6(self):
|
||||
# Arbitrary DER object
|
||||
der = DerObject()
|
||||
der.decode(b('\x65\x01\x88'))
|
||||
self.assertEqual(der._tag_octet, 0x65)
|
||||
self.assertEqual(der.payload, b('\x88'))
|
||||
|
||||
def testObjDecode7(self):
|
||||
# Decode explicit tag
|
||||
der = DerObject(0x10, explicit=5)
|
||||
der.decode(b("\xa5\x06\x10\x04xxll"))
|
||||
self.assertEqual(der._tag_octet, 0x10)
|
||||
self.assertEqual(der.payload, b('xxll'))
|
||||
|
||||
# Explicit tag may be 0
|
||||
der = DerObject(0x10, explicit=0)
|
||||
der.decode(b("\xa0\x06\x10\x04xxll"))
|
||||
self.assertEqual(der._tag_octet, 0x10)
|
||||
self.assertEqual(der.payload, b('xxll'))
|
||||
|
||||
def testObjDecode8(self):
|
||||
# Verify that decode returns the object
|
||||
der = DerObject(0x02)
|
||||
self.assertEqual(der, der.decode(b('\x02\x02\x01\x02')))
|
||||
|
||||
class DerIntegerTests(unittest.TestCase):
|
||||
|
||||
def testInit1(self):
|
||||
der = DerInteger(1)
|
||||
self.assertEqual(der.encode(), b('\x02\x01\x01'))
|
||||
|
||||
def testEncode1(self):
|
||||
# Single-byte integers
|
||||
# Value 0
|
||||
der = DerInteger(0)
|
||||
self.assertEqual(der.encode(), b('\x02\x01\x00'))
|
||||
# Value 1
|
||||
der = DerInteger(1)
|
||||
self.assertEqual(der.encode(), b('\x02\x01\x01'))
|
||||
# Value 127
|
||||
der = DerInteger(127)
|
||||
self.assertEqual(der.encode(), b('\x02\x01\x7F'))
|
||||
|
||||
def testEncode2(self):
|
||||
# Multi-byte integers
|
||||
# Value 128
|
||||
der = DerInteger(128)
|
||||
self.assertEqual(der.encode(), b('\x02\x02\x00\x80'))
|
||||
# Value 0x180
|
||||
der = DerInteger(0x180)
|
||||
self.assertEqual(der.encode(), b('\x02\x02\x01\x80'))
|
||||
# One very long integer
|
||||
der = DerInteger(2**2048)
|
||||
self.assertEqual(der.encode(),
|
||||
b('\x02\x82\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00'))
|
||||
|
||||
def testEncode3(self):
|
||||
# Negative integers
|
||||
# Value -1
|
||||
der = DerInteger(-1)
|
||||
self.assertEqual(der.encode(), b('\x02\x01\xFF'))
|
||||
# Value -128
|
||||
der = DerInteger(-128)
|
||||
self.assertEqual(der.encode(), b('\x02\x01\x80'))
|
||||
# Value
|
||||
der = DerInteger(-87873)
|
||||
self.assertEqual(der.encode(), b('\x02\x03\xFE\xA8\xBF'))
|
||||
|
||||
def testEncode4(self):
|
||||
# Explicit encoding
|
||||
number = DerInteger(0x34, explicit=3)
|
||||
self.assertEqual(number.encode(), b('\xa3\x03\x02\x01\x34'))
|
||||
|
||||
# -----
|
||||
|
||||
def testDecode1(self):
|
||||
# Single-byte integer
|
||||
der = DerInteger()
|
||||
# Value 0
|
||||
der.decode(b('\x02\x01\x00'))
|
||||
self.assertEqual(der.value, 0)
|
||||
# Value 1
|
||||
der.decode(b('\x02\x01\x01'))
|
||||
self.assertEqual(der.value, 1)
|
||||
# Value 127
|
||||
der.decode(b('\x02\x01\x7F'))
|
||||
self.assertEqual(der.value, 127)
|
||||
|
||||
def testDecode2(self):
|
||||
# Multi-byte integer
|
||||
der = DerInteger()
|
||||
# Value 0x180L
|
||||
der.decode(b('\x02\x02\x01\x80'))
|
||||
self.assertEqual(der.value,0x180)
|
||||
# One very long integer
|
||||
der.decode(
|
||||
b('\x02\x82\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00'))
|
||||
self.assertEqual(der.value,2**2048)
|
||||
|
||||
def testDecode3(self):
|
||||
# Negative integer
|
||||
der = DerInteger()
|
||||
# Value -1
|
||||
der.decode(b('\x02\x01\xFF'))
|
||||
self.assertEqual(der.value, -1)
|
||||
# Value -32768
|
||||
der.decode(b('\x02\x02\x80\x00'))
|
||||
self.assertEqual(der.value, -32768)
|
||||
|
||||
def testDecode5(self):
|
||||
# We still accept BER integer format
|
||||
der = DerInteger()
|
||||
# Redundant leading zeroes
|
||||
der.decode(b('\x02\x02\x00\x01'))
|
||||
self.assertEqual(der.value, 1)
|
||||
# Redundant leading 0xFF
|
||||
der.decode(b('\x02\x02\xFF\xFF'))
|
||||
self.assertEqual(der.value, -1)
|
||||
# Empty payload
|
||||
der.decode(b('\x02\x00'))
|
||||
self.assertEqual(der.value, 0)
|
||||
|
||||
def testDecode6(self):
|
||||
# Explicit encoding
|
||||
number = DerInteger(explicit=3)
|
||||
number.decode(b('\xa3\x03\x02\x01\x34'))
|
||||
self.assertEqual(number.value, 0x34)
|
||||
|
||||
def testDecode7(self):
|
||||
# Verify decode returns the DerInteger
|
||||
der = DerInteger()
|
||||
self.assertEqual(der, der.decode(b('\x02\x01\x7F')))
|
||||
|
||||
###
|
||||
|
||||
def testErrDecode1(self):
|
||||
# Wide length field
|
||||
der = DerInteger()
|
||||
self.assertRaises(ValueError, der.decode, b('\x02\x81\x01\x01'))
|
||||
|
||||
|
||||
class DerSequenceTests(unittest.TestCase):
|
||||
|
||||
def testInit1(self):
|
||||
der = DerSequence([1, DerInteger(2), b('0\x00')])
|
||||
self.assertEqual(der.encode(), b('0\x08\x02\x01\x01\x02\x01\x020\x00'))
|
||||
|
||||
def testEncode1(self):
|
||||
# Empty sequence
|
||||
der = DerSequence()
|
||||
self.assertEqual(der.encode(), b('0\x00'))
|
||||
self.assertFalse(der.hasOnlyInts())
|
||||
# One single-byte integer (zero)
|
||||
der.append(0)
|
||||
self.assertEqual(der.encode(), b('0\x03\x02\x01\x00'))
|
||||
self.assertEqual(der.hasInts(),1)
|
||||
self.assertEqual(der.hasInts(False),1)
|
||||
self.assertTrue(der.hasOnlyInts())
|
||||
self.assertTrue(der.hasOnlyInts(False))
|
||||
# Invariant
|
||||
self.assertEqual(der.encode(), b('0\x03\x02\x01\x00'))
|
||||
|
||||
def testEncode2(self):
|
||||
# Indexing
|
||||
der = DerSequence()
|
||||
der.append(0)
|
||||
der[0] = 1
|
||||
self.assertEqual(len(der),1)
|
||||
self.assertEqual(der[0],1)
|
||||
self.assertEqual(der[-1],1)
|
||||
self.assertEqual(der.encode(), b('0\x03\x02\x01\x01'))
|
||||
#
|
||||
der[:] = [1]
|
||||
self.assertEqual(len(der),1)
|
||||
self.assertEqual(der[0],1)
|
||||
self.assertEqual(der.encode(), b('0\x03\x02\x01\x01'))
|
||||
|
||||
def testEncode3(self):
|
||||
# One multi-byte integer (non-zero)
|
||||
der = DerSequence()
|
||||
der.append(0x180)
|
||||
self.assertEqual(der.encode(), b('0\x04\x02\x02\x01\x80'))
|
||||
|
||||
def testEncode4(self):
|
||||
# One very long integer
|
||||
der = DerSequence()
|
||||
der.append(2**2048)
|
||||
self.assertEqual(der.encode(), b('0\x82\x01\x05')+
|
||||
b('\x02\x82\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00'))
|
||||
|
||||
def testEncode5(self):
|
||||
der = DerSequence()
|
||||
der += 1
|
||||
der += b('\x30\x00')
|
||||
self.assertEqual(der.encode(), b('\x30\x05\x02\x01\x01\x30\x00'))
|
||||
|
||||
def testEncode6(self):
|
||||
# Two positive integers
|
||||
der = DerSequence()
|
||||
der.append(0x180)
|
||||
der.append(0xFF)
|
||||
self.assertEqual(der.encode(), b('0\x08\x02\x02\x01\x80\x02\x02\x00\xff'))
|
||||
self.assertTrue(der.hasOnlyInts())
|
||||
self.assertTrue(der.hasOnlyInts(False))
|
||||
# Two mixed integers
|
||||
der = DerSequence()
|
||||
der.append(2)
|
||||
der.append(-2)
|
||||
self.assertEqual(der.encode(), b('0\x06\x02\x01\x02\x02\x01\xFE'))
|
||||
self.assertEqual(der.hasInts(), 1)
|
||||
self.assertEqual(der.hasInts(False), 2)
|
||||
self.assertFalse(der.hasOnlyInts())
|
||||
self.assertTrue(der.hasOnlyInts(False))
|
||||
#
|
||||
der.append(0x01)
|
||||
der[1:] = [9,8]
|
||||
self.assertEqual(len(der),3)
|
||||
self.assertEqual(der[1:],[9,8])
|
||||
self.assertEqual(der[1:-1],[9])
|
||||
self.assertEqual(der.encode(), b('0\x09\x02\x01\x02\x02\x01\x09\x02\x01\x08'))
|
||||
|
||||
def testEncode7(self):
|
||||
# One integer and another type (already encoded)
|
||||
der = DerSequence()
|
||||
der.append(0x180)
|
||||
der.append(b('0\x03\x02\x01\x05'))
|
||||
self.assertEqual(der.encode(), b('0\x09\x02\x02\x01\x800\x03\x02\x01\x05'))
|
||||
self.assertFalse(der.hasOnlyInts())
|
||||
|
||||
def testEncode8(self):
|
||||
# One integer and another type (yet to encode)
|
||||
der = DerSequence()
|
||||
der.append(0x180)
|
||||
der.append(DerSequence([5]))
|
||||
self.assertEqual(der.encode(), b('0\x09\x02\x02\x01\x800\x03\x02\x01\x05'))
|
||||
self.assertFalse(der.hasOnlyInts())
|
||||
|
||||
####
|
||||
|
||||
def testDecode1(self):
|
||||
# Empty sequence
|
||||
der = DerSequence()
|
||||
der.decode(b('0\x00'))
|
||||
self.assertEqual(len(der),0)
|
||||
# One single-byte integer (zero)
|
||||
der.decode(b('0\x03\x02\x01\x00'))
|
||||
self.assertEqual(len(der),1)
|
||||
self.assertEqual(der[0],0)
|
||||
# Invariant
|
||||
der.decode(b('0\x03\x02\x01\x00'))
|
||||
self.assertEqual(len(der),1)
|
||||
self.assertEqual(der[0],0)
|
||||
|
||||
def testDecode2(self):
|
||||
# One single-byte integer (non-zero)
|
||||
der = DerSequence()
|
||||
der.decode(b('0\x03\x02\x01\x7f'))
|
||||
self.assertEqual(len(der),1)
|
||||
self.assertEqual(der[0],127)
|
||||
|
||||
def testDecode4(self):
|
||||
# One very long integer
|
||||
der = DerSequence()
|
||||
der.decode(b('0\x82\x01\x05')+
|
||||
b('\x02\x82\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
|
||||
b('\x00\x00\x00\x00\x00\x00\x00\x00\x00'))
|
||||
self.assertEqual(len(der),1)
|
||||
self.assertEqual(der[0],2**2048)
|
||||
|
||||
def testDecode6(self):
|
||||
# Two integers
|
||||
der = DerSequence()
|
||||
der.decode(b('0\x08\x02\x02\x01\x80\x02\x02\x00\xff'))
|
||||
self.assertEqual(len(der),2)
|
||||
self.assertEqual(der[0],0x180)
|
||||
self.assertEqual(der[1],0xFF)
|
||||
|
||||
def testDecode7(self):
|
||||
# One integer and 2 other types
|
||||
der = DerSequence()
|
||||
der.decode(b('0\x0A\x02\x02\x01\x80\x24\x02\xb6\x63\x12\x00'))
|
||||
self.assertEqual(len(der),3)
|
||||
self.assertEqual(der[0],0x180)
|
||||
self.assertEqual(der[1],b('\x24\x02\xb6\x63'))
|
||||
self.assertEqual(der[2],b('\x12\x00'))
|
||||
|
||||
def testDecode8(self):
|
||||
# Only 2 other types
|
||||
der = DerSequence()
|
||||
der.decode(b('0\x06\x24\x02\xb6\x63\x12\x00'))
|
||||
self.assertEqual(len(der),2)
|
||||
self.assertEqual(der[0],b('\x24\x02\xb6\x63'))
|
||||
self.assertEqual(der[1],b('\x12\x00'))
|
||||
self.assertEqual(der.hasInts(), 0)
|
||||
self.assertEqual(der.hasInts(False), 0)
|
||||
self.assertFalse(der.hasOnlyInts())
|
||||
self.assertFalse(der.hasOnlyInts(False))
|
||||
|
||||
def testDecode9(self):
|
||||
# Verify that decode returns itself
|
||||
der = DerSequence()
|
||||
self.assertEqual(der, der.decode(b('0\x06\x24\x02\xb6\x63\x12\x00')))
|
||||
|
||||
###
|
||||
|
||||
def testErrDecode1(self):
|
||||
# Not a sequence
|
||||
der = DerSequence()
|
||||
self.assertRaises(ValueError, der.decode, b(''))
|
||||
self.assertRaises(ValueError, der.decode, b('\x00'))
|
||||
self.assertRaises(ValueError, der.decode, b('\x30'))
|
||||
|
||||
def testErrDecode2(self):
|
||||
der = DerSequence()
|
||||
# Too much data
|
||||
self.assertRaises(ValueError, der.decode, b('\x30\x00\x00'))
|
||||
|
||||
def testErrDecode3(self):
|
||||
# Wrong length format
|
||||
der = DerSequence()
|
||||
# Missing length in sub-item
|
||||
self.assertRaises(ValueError, der.decode, b('\x30\x04\x02\x01\x01\x00'))
|
||||
# Valid BER, but invalid DER length
|
||||
self.assertRaises(ValueError, der.decode, b('\x30\x81\x03\x02\x01\x01'))
|
||||
self.assertRaises(ValueError, der.decode, b('\x30\x04\x02\x81\x01\x01'))
|
||||
|
||||
def test_expected_nr_elements(self):
|
||||
der_bin = DerSequence([1, 2, 3]).encode()
|
||||
|
||||
DerSequence().decode(der_bin, nr_elements=3)
|
||||
DerSequence().decode(der_bin, nr_elements=(2,3))
|
||||
self.assertRaises(ValueError, DerSequence().decode, der_bin, nr_elements=1)
|
||||
self.assertRaises(ValueError, DerSequence().decode, der_bin, nr_elements=(4,5))
|
||||
|
||||
def test_expected_only_integers(self):
|
||||
|
||||
der_bin1 = DerSequence([1, 2, 3]).encode()
|
||||
der_bin2 = DerSequence([1, 2, DerSequence([3, 4])]).encode()
|
||||
|
||||
DerSequence().decode(der_bin1, only_ints_expected=True)
|
||||
DerSequence().decode(der_bin1, only_ints_expected=False)
|
||||
DerSequence().decode(der_bin2, only_ints_expected=False)
|
||||
self.assertRaises(ValueError, DerSequence().decode, der_bin2, only_ints_expected=True)
|
||||
|
||||
|
||||
class DerOctetStringTests(unittest.TestCase):
|
||||
|
||||
def testInit1(self):
|
||||
der = DerOctetString(b('\xFF'))
|
||||
self.assertEqual(der.encode(), b('\x04\x01\xFF'))
|
||||
|
||||
def testEncode1(self):
|
||||
# Empty sequence
|
||||
der = DerOctetString()
|
||||
self.assertEqual(der.encode(), b('\x04\x00'))
|
||||
# Small payload
|
||||
der.payload = b('\x01\x02')
|
||||
self.assertEqual(der.encode(), b('\x04\x02\x01\x02'))
|
||||
|
||||
####
|
||||
|
||||
def testDecode1(self):
|
||||
# Empty sequence
|
||||
der = DerOctetString()
|
||||
der.decode(b('\x04\x00'))
|
||||
self.assertEqual(der.payload, b(''))
|
||||
# Small payload
|
||||
der.decode(b('\x04\x02\x01\x02'))
|
||||
self.assertEqual(der.payload, b('\x01\x02'))
|
||||
|
||||
def testDecode2(self):
|
||||
# Verify that decode returns the object
|
||||
der = DerOctetString()
|
||||
self.assertEqual(der, der.decode(b('\x04\x00')))
|
||||
|
||||
def testErrDecode1(self):
|
||||
# No leftovers allowed
|
||||
der = DerOctetString()
|
||||
self.assertRaises(ValueError, der.decode, b('\x04\x01\x01\xff'))
|
||||
|
||||
class DerNullTests(unittest.TestCase):
|
||||
|
||||
def testEncode1(self):
|
||||
der = DerNull()
|
||||
self.assertEqual(der.encode(), b('\x05\x00'))
|
||||
|
||||
####
|
||||
|
||||
def testDecode1(self):
|
||||
# Empty sequence
|
||||
der = DerNull()
|
||||
self.assertEqual(der, der.decode(b('\x05\x00')))
|
||||
|
||||
class DerObjectIdTests(unittest.TestCase):
|
||||
|
||||
def testInit1(self):
|
||||
der = DerObjectId("1.1")
|
||||
self.assertEqual(der.encode(), b('\x06\x01)'))
|
||||
|
||||
def testEncode1(self):
|
||||
der = DerObjectId('1.2.840.113549.1.1.1')
|
||||
self.assertEqual(der.encode(), b('\x06\x09\x2A\x86\x48\x86\xF7\x0D\x01\x01\x01'))
|
||||
#
|
||||
der = DerObjectId()
|
||||
der.value = '1.2.840.113549.1.1.1'
|
||||
self.assertEqual(der.encode(), b('\x06\x09\x2A\x86\x48\x86\xF7\x0D\x01\x01\x01'))
|
||||
|
||||
####
|
||||
|
||||
def testDecode1(self):
|
||||
# Empty sequence
|
||||
der = DerObjectId()
|
||||
der.decode(b('\x06\x09\x2A\x86\x48\x86\xF7\x0D\x01\x01\x01'))
|
||||
self.assertEqual(der.value, '1.2.840.113549.1.1.1')
|
||||
|
||||
def testDecode2(self):
|
||||
# Verify that decode returns the object
|
||||
der = DerObjectId()
|
||||
self.assertEqual(der,
|
||||
der.decode(b('\x06\x09\x2A\x86\x48\x86\xF7\x0D\x01\x01\x01')))
|
||||
|
||||
|
||||
class DerBitStringTests(unittest.TestCase):
|
||||
|
||||
def testInit1(self):
|
||||
der = DerBitString(b("\xFF"))
|
||||
self.assertEqual(der.encode(), b('\x03\x02\x00\xFF'))
|
||||
|
||||
def testInit2(self):
|
||||
der = DerBitString(DerInteger(1))
|
||||
self.assertEqual(der.encode(), b('\x03\x04\x00\x02\x01\x01'))
|
||||
|
||||
def testEncode1(self):
|
||||
# Empty sequence
|
||||
der = DerBitString()
|
||||
self.assertEqual(der.encode(), b('\x03\x01\x00'))
|
||||
# Small payload
|
||||
der = DerBitString(b('\x01\x02'))
|
||||
self.assertEqual(der.encode(), b('\x03\x03\x00\x01\x02'))
|
||||
# Small payload
|
||||
der = DerBitString()
|
||||
der.value = b('\x01\x02')
|
||||
self.assertEqual(der.encode(), b('\x03\x03\x00\x01\x02'))
|
||||
|
||||
####
|
||||
|
||||
def testDecode1(self):
|
||||
# Empty sequence
|
||||
der = DerBitString()
|
||||
der.decode(b('\x03\x00'))
|
||||
self.assertEqual(der.value, b(''))
|
||||
# Small payload
|
||||
der.decode(b('\x03\x03\x00\x01\x02'))
|
||||
self.assertEqual(der.value, b('\x01\x02'))
|
||||
|
||||
def testDecode2(self):
|
||||
# Verify that decode returns the object
|
||||
der = DerBitString()
|
||||
self.assertEqual(der, der.decode(b('\x03\x00')))
|
||||
|
||||
|
||||
class DerSetOfTests(unittest.TestCase):
|
||||
|
||||
def testInit1(self):
|
||||
der = DerSetOf([DerInteger(1), DerInteger(2)])
|
||||
self.assertEqual(der.encode(), b('1\x06\x02\x01\x01\x02\x01\x02'))
|
||||
|
||||
def testEncode1(self):
|
||||
# Empty set
|
||||
der = DerSetOf()
|
||||
self.assertEqual(der.encode(), b('1\x00'))
|
||||
# One single-byte integer (zero)
|
||||
der.add(0)
|
||||
self.assertEqual(der.encode(), b('1\x03\x02\x01\x00'))
|
||||
# Invariant
|
||||
self.assertEqual(der.encode(), b('1\x03\x02\x01\x00'))
|
||||
|
||||
def testEncode2(self):
|
||||
# Two integers
|
||||
der = DerSetOf()
|
||||
der.add(0x180)
|
||||
der.add(0xFF)
|
||||
self.assertEqual(der.encode(), b('1\x08\x02\x02\x00\xff\x02\x02\x01\x80'))
|
||||
# Initialize with integers
|
||||
der = DerSetOf([0x180, 0xFF])
|
||||
self.assertEqual(der.encode(), b('1\x08\x02\x02\x00\xff\x02\x02\x01\x80'))
|
||||
|
||||
def testEncode3(self):
|
||||
# One integer and another type (no matter what it is)
|
||||
der = DerSetOf()
|
||||
der.add(0x180)
|
||||
self.assertRaises(ValueError, der.add, b('\x00\x02\x00\x00'))
|
||||
|
||||
def testEncode4(self):
|
||||
# Only non integers
|
||||
der = DerSetOf()
|
||||
der.add(b('\x01\x00'))
|
||||
der.add(b('\x01\x01\x01'))
|
||||
self.assertEqual(der.encode(), b('1\x05\x01\x00\x01\x01\x01'))
|
||||
|
||||
####
|
||||
|
||||
def testDecode1(self):
|
||||
# Empty sequence
|
||||
der = DerSetOf()
|
||||
der.decode(b('1\x00'))
|
||||
self.assertEqual(len(der),0)
|
||||
# One single-byte integer (zero)
|
||||
der.decode(b('1\x03\x02\x01\x00'))
|
||||
self.assertEqual(len(der),1)
|
||||
self.assertEqual(list(der),[0])
|
||||
|
||||
def testDecode2(self):
|
||||
# Two integers
|
||||
der = DerSetOf()
|
||||
der.decode(b('1\x08\x02\x02\x01\x80\x02\x02\x00\xff'))
|
||||
self.assertEqual(len(der),2)
|
||||
l = list(der)
|
||||
self.assertTrue(0x180 in l)
|
||||
self.assertTrue(0xFF in l)
|
||||
|
||||
def testDecode3(self):
|
||||
# One integer and 2 other types
|
||||
der = DerSetOf()
|
||||
#import pdb; pdb.set_trace()
|
||||
self.assertRaises(ValueError, der.decode,
|
||||
b('0\x0A\x02\x02\x01\x80\x24\x02\xb6\x63\x12\x00'))
|
||||
|
||||
def testDecode4(self):
|
||||
# Verify that decode returns the object
|
||||
der = DerSetOf()
|
||||
self.assertEqual(der,
|
||||
der.decode(b('1\x08\x02\x02\x01\x80\x02\x02\x00\xff')))
|
||||
|
||||
###
|
||||
|
||||
def testErrDecode1(self):
|
||||
# No leftovers allowed
|
||||
der = DerSetOf()
|
||||
self.assertRaises(ValueError, der.decode,
|
||||
b('1\x08\x02\x02\x01\x80\x02\x02\x00\xff\xAA'))
|
||||
|
||||
def get_tests(config={}):
|
||||
from Crypto.SelfTest.st_common import list_test_cases
|
||||
listTests = []
|
||||
listTests += list_test_cases(DerObjectTests)
|
||||
listTests += list_test_cases(DerIntegerTests)
|
||||
listTests += list_test_cases(DerSequenceTests)
|
||||
listTests += list_test_cases(DerOctetStringTests)
|
||||
listTests += list_test_cases(DerNullTests)
|
||||
listTests += list_test_cases(DerObjectIdTests)
|
||||
listTests += list_test_cases(DerBitStringTests)
|
||||
listTests += list_test_cases(DerSetOfTests)
|
||||
return listTests
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = lambda: unittest.TestSuite(get_tests())
|
||||
unittest.main(defaultTest='suite')
|
||||
|
||||
# vim:set ts=4 sw=4 sts=4 expandtab:
|
||||
288
venv/Lib/site-packages/Crypto/SelfTest/Util/test_number.py
Normal file
288
venv/Lib/site-packages/Crypto/SelfTest/Util/test_number.py
Normal file
|
|
@ -0,0 +1,288 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# SelfTest/Util/test_number.py: Self-test for parts of the Crypto.Util.number module
|
||||
#
|
||||
# Written in 2008 by Dwayne C. Litzenberger <dlitz@dlitz.net>
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
|
||||
"""Self-tests for (some of) Crypto.Util.number"""
|
||||
|
||||
from Crypto.Util.py3compat import *
|
||||
|
||||
import unittest
|
||||
|
||||
class MyError(Exception):
|
||||
"""Dummy exception used for tests"""
|
||||
|
||||
# NB: In some places, we compare tuples instead of just output values so that
|
||||
# if any inputs cause a test failure, we'll be able to tell which ones.
|
||||
|
||||
class MiscTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
global number, math
|
||||
from Crypto.Util import number
|
||||
import math
|
||||
|
||||
def test_ceil_shift(self):
|
||||
"""Util.number.ceil_shift"""
|
||||
self.assertRaises(AssertionError, number.ceil_shift, -1, 1)
|
||||
self.assertRaises(AssertionError, number.ceil_shift, 1, -1)
|
||||
|
||||
# b = 0
|
||||
self.assertEqual(0, number.ceil_shift(0, 0))
|
||||
self.assertEqual(1, number.ceil_shift(1, 0))
|
||||
self.assertEqual(2, number.ceil_shift(2, 0))
|
||||
self.assertEqual(3, number.ceil_shift(3, 0))
|
||||
|
||||
# b = 1
|
||||
self.assertEqual(0, number.ceil_shift(0, 1))
|
||||
self.assertEqual(1, number.ceil_shift(1, 1))
|
||||
self.assertEqual(1, number.ceil_shift(2, 1))
|
||||
self.assertEqual(2, number.ceil_shift(3, 1))
|
||||
|
||||
# b = 2
|
||||
self.assertEqual(0, number.ceil_shift(0, 2))
|
||||
self.assertEqual(1, number.ceil_shift(1, 2))
|
||||
self.assertEqual(1, number.ceil_shift(2, 2))
|
||||
self.assertEqual(1, number.ceil_shift(3, 2))
|
||||
self.assertEqual(1, number.ceil_shift(4, 2))
|
||||
self.assertEqual(2, number.ceil_shift(5, 2))
|
||||
self.assertEqual(2, number.ceil_shift(6, 2))
|
||||
self.assertEqual(2, number.ceil_shift(7, 2))
|
||||
self.assertEqual(2, number.ceil_shift(8, 2))
|
||||
self.assertEqual(3, number.ceil_shift(9, 2))
|
||||
|
||||
for b in range(3, 1+129, 3): # 3, 6, ... , 129
|
||||
self.assertEqual(0, number.ceil_shift(0, b))
|
||||
|
||||
n = 1
|
||||
while n <= 2**(b+2):
|
||||
(q, r) = divmod(n-1, 2**b)
|
||||
expected = q + int(not not r)
|
||||
self.assertEqual((n-1, b, expected),
|
||||
(n-1, b, number.ceil_shift(n-1, b)))
|
||||
|
||||
(q, r) = divmod(n, 2**b)
|
||||
expected = q + int(not not r)
|
||||
self.assertEqual((n, b, expected),
|
||||
(n, b, number.ceil_shift(n, b)))
|
||||
|
||||
(q, r) = divmod(n+1, 2**b)
|
||||
expected = q + int(not not r)
|
||||
self.assertEqual((n+1, b, expected),
|
||||
(n+1, b, number.ceil_shift(n+1, b)))
|
||||
|
||||
n *= 2
|
||||
|
||||
def test_ceil_div(self):
|
||||
"""Util.number.ceil_div"""
|
||||
self.assertRaises(TypeError, number.ceil_div, "1", 1)
|
||||
self.assertRaises(ZeroDivisionError, number.ceil_div, 1, 0)
|
||||
self.assertRaises(ZeroDivisionError, number.ceil_div, -1, 0)
|
||||
|
||||
# b = -1
|
||||
self.assertEqual(0, number.ceil_div(0, -1))
|
||||
self.assertEqual(-1, number.ceil_div(1, -1))
|
||||
self.assertEqual(-2, number.ceil_div(2, -1))
|
||||
self.assertEqual(-3, number.ceil_div(3, -1))
|
||||
|
||||
# b = 1
|
||||
self.assertEqual(0, number.ceil_div(0, 1))
|
||||
self.assertEqual(1, number.ceil_div(1, 1))
|
||||
self.assertEqual(2, number.ceil_div(2, 1))
|
||||
self.assertEqual(3, number.ceil_div(3, 1))
|
||||
|
||||
# b = 2
|
||||
self.assertEqual(0, number.ceil_div(0, 2))
|
||||
self.assertEqual(1, number.ceil_div(1, 2))
|
||||
self.assertEqual(1, number.ceil_div(2, 2))
|
||||
self.assertEqual(2, number.ceil_div(3, 2))
|
||||
self.assertEqual(2, number.ceil_div(4, 2))
|
||||
self.assertEqual(3, number.ceil_div(5, 2))
|
||||
|
||||
# b = 3
|
||||
self.assertEqual(0, number.ceil_div(0, 3))
|
||||
self.assertEqual(1, number.ceil_div(1, 3))
|
||||
self.assertEqual(1, number.ceil_div(2, 3))
|
||||
self.assertEqual(1, number.ceil_div(3, 3))
|
||||
self.assertEqual(2, number.ceil_div(4, 3))
|
||||
self.assertEqual(2, number.ceil_div(5, 3))
|
||||
self.assertEqual(2, number.ceil_div(6, 3))
|
||||
self.assertEqual(3, number.ceil_div(7, 3))
|
||||
|
||||
# b = 4
|
||||
self.assertEqual(0, number.ceil_div(0, 4))
|
||||
self.assertEqual(1, number.ceil_div(1, 4))
|
||||
self.assertEqual(1, number.ceil_div(2, 4))
|
||||
self.assertEqual(1, number.ceil_div(3, 4))
|
||||
self.assertEqual(1, number.ceil_div(4, 4))
|
||||
self.assertEqual(2, number.ceil_div(5, 4))
|
||||
self.assertEqual(2, number.ceil_div(6, 4))
|
||||
self.assertEqual(2, number.ceil_div(7, 4))
|
||||
self.assertEqual(2, number.ceil_div(8, 4))
|
||||
self.assertEqual(3, number.ceil_div(9, 4))
|
||||
|
||||
# b = -4
|
||||
self.assertEqual(3, number.ceil_div(-9, -4))
|
||||
self.assertEqual(2, number.ceil_div(-8, -4))
|
||||
self.assertEqual(2, number.ceil_div(-7, -4))
|
||||
self.assertEqual(2, number.ceil_div(-6, -4))
|
||||
self.assertEqual(2, number.ceil_div(-5, -4))
|
||||
self.assertEqual(1, number.ceil_div(-4, -4))
|
||||
self.assertEqual(1, number.ceil_div(-3, -4))
|
||||
self.assertEqual(1, number.ceil_div(-2, -4))
|
||||
self.assertEqual(1, number.ceil_div(-1, -4))
|
||||
self.assertEqual(0, number.ceil_div(0, -4))
|
||||
self.assertEqual(0, number.ceil_div(1, -4))
|
||||
self.assertEqual(0, number.ceil_div(2, -4))
|
||||
self.assertEqual(0, number.ceil_div(3, -4))
|
||||
self.assertEqual(-1, number.ceil_div(4, -4))
|
||||
self.assertEqual(-1, number.ceil_div(5, -4))
|
||||
self.assertEqual(-1, number.ceil_div(6, -4))
|
||||
self.assertEqual(-1, number.ceil_div(7, -4))
|
||||
self.assertEqual(-2, number.ceil_div(8, -4))
|
||||
self.assertEqual(-2, number.ceil_div(9, -4))
|
||||
|
||||
def test_exact_log2(self):
|
||||
"""Util.number.exact_log2"""
|
||||
self.assertRaises(TypeError, number.exact_log2, "0")
|
||||
self.assertRaises(ValueError, number.exact_log2, -1)
|
||||
self.assertRaises(ValueError, number.exact_log2, 0)
|
||||
self.assertEqual(0, number.exact_log2(1))
|
||||
self.assertEqual(1, number.exact_log2(2))
|
||||
self.assertRaises(ValueError, number.exact_log2, 3)
|
||||
self.assertEqual(2, number.exact_log2(4))
|
||||
self.assertRaises(ValueError, number.exact_log2, 5)
|
||||
self.assertRaises(ValueError, number.exact_log2, 6)
|
||||
self.assertRaises(ValueError, number.exact_log2, 7)
|
||||
e = 3
|
||||
n = 8
|
||||
while e < 16:
|
||||
if n == 2**e:
|
||||
self.assertEqual(e, number.exact_log2(n), "expected=2**%d, n=%d" % (e, n))
|
||||
e += 1
|
||||
else:
|
||||
self.assertRaises(ValueError, number.exact_log2, n)
|
||||
n += 1
|
||||
|
||||
for e in range(16, 1+64, 2):
|
||||
self.assertRaises(ValueError, number.exact_log2, 2**e-1)
|
||||
self.assertEqual(e, number.exact_log2(2**e))
|
||||
self.assertRaises(ValueError, number.exact_log2, 2**e+1)
|
||||
|
||||
def test_exact_div(self):
|
||||
"""Util.number.exact_div"""
|
||||
|
||||
# Positive numbers
|
||||
self.assertEqual(1, number.exact_div(1, 1))
|
||||
self.assertRaises(ValueError, number.exact_div, 1, 2)
|
||||
self.assertEqual(1, number.exact_div(2, 2))
|
||||
self.assertRaises(ValueError, number.exact_div, 3, 2)
|
||||
self.assertEqual(2, number.exact_div(4, 2))
|
||||
|
||||
# Negative numbers
|
||||
self.assertEqual(-1, number.exact_div(-1, 1))
|
||||
self.assertEqual(-1, number.exact_div(1, -1))
|
||||
self.assertRaises(ValueError, number.exact_div, -1, 2)
|
||||
self.assertEqual(1, number.exact_div(-2, -2))
|
||||
self.assertEqual(-2, number.exact_div(-4, 2))
|
||||
|
||||
# Zero dividend
|
||||
self.assertEqual(0, number.exact_div(0, 1))
|
||||
self.assertEqual(0, number.exact_div(0, 2))
|
||||
|
||||
# Zero divisor (allow_divzero == False)
|
||||
self.assertRaises(ZeroDivisionError, number.exact_div, 0, 0)
|
||||
self.assertRaises(ZeroDivisionError, number.exact_div, 1, 0)
|
||||
|
||||
# Zero divisor (allow_divzero == True)
|
||||
self.assertEqual(0, number.exact_div(0, 0, allow_divzero=True))
|
||||
self.assertRaises(ValueError, number.exact_div, 1, 0, allow_divzero=True)
|
||||
|
||||
def test_floor_div(self):
|
||||
"""Util.number.floor_div"""
|
||||
self.assertRaises(TypeError, number.floor_div, "1", 1)
|
||||
for a in range(-10, 10):
|
||||
for b in range(-10, 10):
|
||||
if b == 0:
|
||||
self.assertRaises(ZeroDivisionError, number.floor_div, a, b)
|
||||
else:
|
||||
self.assertEqual((a, b, int(math.floor(float(a) / b))),
|
||||
(a, b, number.floor_div(a, b)))
|
||||
|
||||
def test_getStrongPrime(self):
|
||||
"""Util.number.getStrongPrime"""
|
||||
self.assertRaises(ValueError, number.getStrongPrime, 256)
|
||||
self.assertRaises(ValueError, number.getStrongPrime, 513)
|
||||
bits = 512
|
||||
x = number.getStrongPrime(bits)
|
||||
self.assertNotEqual(x % 2, 0)
|
||||
self.assertEqual(x > (1 << bits-1)-1, 1)
|
||||
self.assertEqual(x < (1 << bits), 1)
|
||||
e = 2**16+1
|
||||
x = number.getStrongPrime(bits, e)
|
||||
self.assertEqual(number.GCD(x-1, e), 1)
|
||||
self.assertNotEqual(x % 2, 0)
|
||||
self.assertEqual(x > (1 << bits-1)-1, 1)
|
||||
self.assertEqual(x < (1 << bits), 1)
|
||||
e = 2**16+2
|
||||
x = number.getStrongPrime(bits, e)
|
||||
self.assertEqual(number.GCD((x-1)>>1, e), 1)
|
||||
self.assertNotEqual(x % 2, 0)
|
||||
self.assertEqual(x > (1 << bits-1)-1, 1)
|
||||
self.assertEqual(x < (1 << bits), 1)
|
||||
|
||||
def test_isPrime(self):
|
||||
"""Util.number.isPrime"""
|
||||
self.assertEqual(number.isPrime(-3), False) # Regression test: negative numbers should not be prime
|
||||
self.assertEqual(number.isPrime(-2), False) # Regression test: negative numbers should not be prime
|
||||
self.assertEqual(number.isPrime(1), False) # Regression test: isPrime(1) caused some versions of PyCrypto to crash.
|
||||
self.assertEqual(number.isPrime(2), True)
|
||||
self.assertEqual(number.isPrime(3), True)
|
||||
self.assertEqual(number.isPrime(4), False)
|
||||
self.assertEqual(number.isPrime(2**1279-1), True)
|
||||
self.assertEqual(number.isPrime(-(2**1279-1)), False) # Regression test: negative numbers should not be prime
|
||||
# test some known gmp pseudo-primes taken from
|
||||
# http://www.trnicely.net/misc/mpzspsp.html
|
||||
for composite in (43 * 127 * 211, 61 * 151 * 211, 15259 * 30517,
|
||||
346141 * 692281, 1007119 * 2014237, 3589477 * 7178953,
|
||||
4859419 * 9718837, 2730439 * 5460877,
|
||||
245127919 * 490255837, 963939391 * 1927878781,
|
||||
4186358431 * 8372716861, 1576820467 * 3153640933):
|
||||
self.assertEqual(number.isPrime(int(composite)), False)
|
||||
|
||||
def test_size(self):
|
||||
self.assertEqual(number.size(2),2)
|
||||
self.assertEqual(number.size(3),2)
|
||||
self.assertEqual(number.size(0xa2),8)
|
||||
self.assertEqual(number.size(0xa2ba40),8*3)
|
||||
self.assertEqual(number.size(0xa2ba40ee07e3b2bd2f02ce227f36a195024486e49c19cb41bbbdfbba98b22b0e577c2eeaffa20d883a76e65e394c69d4b3c05a1e8fadda27edb2a42bc000fe888b9b32c22d15add0cd76b3e7936e19955b220dd17d4ea904b1ec102b2e4de7751222aa99151024c7cb41cc5ea21d00eeb41f7c800834d2c6e06bce3bce7ea9a5), 1024)
|
||||
|
||||
|
||||
def get_tests(config={}):
|
||||
from Crypto.SelfTest.st_common import list_test_cases
|
||||
tests = list_test_cases(MiscTests)
|
||||
return tests
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = lambda: unittest.TestSuite(get_tests())
|
||||
unittest.main(defaultTest='suite')
|
||||
|
||||
# vim:set ts=4 sw=4 sts=4 expandtab:
|
||||
93
venv/Lib/site-packages/Crypto/SelfTest/Util/test_strxor.py
Normal file
93
venv/Lib/site-packages/Crypto/SelfTest/Util/test_strxor.py
Normal file
|
|
@ -0,0 +1,93 @@
|
|||
#
|
||||
# SelfTest/Util/test_strxor.py: Self-test for XORing
|
||||
#
|
||||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
import unittest
|
||||
from binascii import unhexlify, hexlify
|
||||
|
||||
from Crypto.Util.py3compat import *
|
||||
from Crypto.SelfTest.st_common import list_test_cases
|
||||
from Crypto.Util.strxor import strxor, strxor_c
|
||||
|
||||
|
||||
class StrxorTests(unittest.TestCase):
|
||||
|
||||
def test1(self):
|
||||
term1 = unhexlify(b("ff339a83e5cd4cdf5649"))
|
||||
term2 = unhexlify(b("383d4ba020573314395b"))
|
||||
result = unhexlify(b("c70ed123c59a7fcb6f12"))
|
||||
self.assertEqual(strxor(term1, term2), result)
|
||||
self.assertEqual(strxor(term2, term1), result)
|
||||
|
||||
def test2(self):
|
||||
es = b("")
|
||||
self.assertEqual(strxor(es, es), es)
|
||||
|
||||
def test3(self):
|
||||
term1 = unhexlify(b("ff339a83e5cd4cdf5649"))
|
||||
all_zeros = bchr(0) * len(term1)
|
||||
self.assertEqual(strxor(term1, term1), all_zeros)
|
||||
|
||||
def test_wrong_length(self):
|
||||
term1 = unhexlify(b("ff339a83e5cd4cdf5649"))
|
||||
term2 = unhexlify(b("ff339a83e5cd4cdf564990"))
|
||||
self.assertRaises(ValueError, strxor, term1, term2)
|
||||
|
||||
|
||||
class Strxor_cTests(unittest.TestCase):
|
||||
|
||||
def test1(self):
|
||||
term1 = unhexlify(b("ff339a83e5cd4cdf5649"))
|
||||
result = unhexlify(b("be72dbc2a48c0d9e1708"))
|
||||
self.assertEqual(strxor_c(term1, 65), result)
|
||||
|
||||
def test2(self):
|
||||
term1 = unhexlify(b("ff339a83e5cd4cdf5649"))
|
||||
self.assertEqual(strxor_c(term1, 0), term1)
|
||||
|
||||
def test3(self):
|
||||
self.assertEqual(strxor_c(b(""), 90), b(""))
|
||||
|
||||
def test_wrong_range(self):
|
||||
term1 = unhexlify(b("ff339a83e5cd4cdf5649"))
|
||||
self.assertRaises(ValueError, strxor_c, term1, -1)
|
||||
self.assertRaises(ValueError, strxor_c, term1, 256)
|
||||
|
||||
def get_tests(config={}):
|
||||
tests = []
|
||||
tests += list_test_cases(StrxorTests)
|
||||
tests += list_test_cases(Strxor_cTests)
|
||||
return tests
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = lambda: unittest.TestSuite(get_tests())
|
||||
unittest.main(defaultTest='suite')
|
||||
Loading…
Add table
Add a link
Reference in a new issue