update windows build to Python 3.7
This commit is contained in:
parent
73105fa71e
commit
ddc59ab92d
5761 changed files with 750298 additions and 213405 deletions
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -1,165 +1,165 @@
|
|||
# -*- 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"""
|
||||
|
||||
__revision__ = "$Id$"
|
||||
|
||||
import sys
|
||||
if sys.version_info[0] == 2 and sys.version_info[1] == 1:
|
||||
from Crypto.Util.py21compat import *
|
||||
from Crypto.Util.py3compat import *
|
||||
|
||||
import unittest
|
||||
|
||||
class CounterTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
global Counter
|
||||
from Crypto.Util import Counter
|
||||
|
||||
def test_BE_shortcut(self):
|
||||
"""Big endian, shortcut enabled"""
|
||||
c = Counter.new(128)
|
||||
self.assertEqual(c.__PCT_CTR_SHORTCUT__,True) # assert_
|
||||
c = Counter.new(128, little_endian=False)
|
||||
self.assertEqual(c.__PCT_CTR_SHORTCUT__,True) # assert_
|
||||
c = Counter.new(128, disable_shortcut=False)
|
||||
self.assertEqual(c.__PCT_CTR_SHORTCUT__,True) # assert_
|
||||
c = Counter.new(128, little_endian=False, disable_shortcut=False)
|
||||
self.assertEqual(c.__PCT_CTR_SHORTCUT__,True) # assert_
|
||||
|
||||
def test_LE_shortcut(self):
|
||||
"""Little endian, shortcut enabled"""
|
||||
c = Counter.new(128, little_endian=True)
|
||||
self.assertEqual(c.__PCT_CTR_SHORTCUT__,True) # assert_
|
||||
c = Counter.new(128, little_endian=True, disable_shortcut=False)
|
||||
self.assertEqual(c.__PCT_CTR_SHORTCUT__,True) # assert_
|
||||
|
||||
def test_BE_no_shortcut(self):
|
||||
"""Big endian, shortcut disabled"""
|
||||
c = Counter.new(128, disable_shortcut=True)
|
||||
self.assertRaises(AttributeError, getattr, c, '__PCT_CTR_SHORTCUT__')
|
||||
c = Counter.new(128, little_endian=False, disable_shortcut=True)
|
||||
self.assertRaises(AttributeError, getattr, c, '__PCT_CTR_SHORTCUT__')
|
||||
|
||||
def test_LE_no_shortcut(self):
|
||||
"""Little endian, shortcut disabled"""
|
||||
c = Counter.new(128, little_endian=True, disable_shortcut=True)
|
||||
self.assertRaises(AttributeError, getattr, c, '__PCT_CTR_SHORTCUT__')
|
||||
|
||||
def test_BE_defaults(self):
|
||||
"""128-bit, Big endian, defaults"""
|
||||
c = Counter.new(128)
|
||||
self.assertEqual(1, c.next_value())
|
||||
self.assertEqual(b("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01"), c())
|
||||
self.assertEqual(2, c.next_value())
|
||||
self.assertEqual(b("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02"), c())
|
||||
for i in range(3, 256):
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(b("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")+bchr(i), c())
|
||||
self.assertEqual(256, c.next_value())
|
||||
self.assertEqual(b("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00"), c())
|
||||
|
||||
def test_LE_defaults(self):
|
||||
"""128-bit, Little endian, defaults"""
|
||||
c = Counter.new(128, little_endian=True)
|
||||
self.assertEqual(1, c.next_value())
|
||||
self.assertEqual(b("\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), c())
|
||||
self.assertEqual(2, c.next_value())
|
||||
self.assertEqual(b("\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), c())
|
||||
for i in range(3, 256):
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(bchr(i)+b("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), c())
|
||||
self.assertEqual(256, c.next_value())
|
||||
self.assertEqual(b("\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), c())
|
||||
|
||||
def test_BE8_wraparound(self):
|
||||
"""8-bit, Big endian, wraparound"""
|
||||
c = Counter.new(8)
|
||||
for i in range(1, 256):
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(bchr(i), c())
|
||||
self.assertRaises(OverflowError, c.next_value)
|
||||
self.assertRaises(OverflowError, c)
|
||||
self.assertRaises(OverflowError, c.next_value)
|
||||
self.assertRaises(OverflowError, c)
|
||||
|
||||
def test_LE8_wraparound(self):
|
||||
"""8-bit, Little endian, wraparound"""
|
||||
c = Counter.new(8, little_endian=True)
|
||||
for i in range(1, 256):
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(bchr(i), c())
|
||||
self.assertRaises(OverflowError, c.next_value)
|
||||
self.assertRaises(OverflowError, c)
|
||||
self.assertRaises(OverflowError, c.next_value)
|
||||
self.assertRaises(OverflowError, c)
|
||||
|
||||
def test_BE8_wraparound_allowed(self):
|
||||
"""8-bit, Big endian, wraparound with allow_wraparound=True"""
|
||||
c = Counter.new(8, allow_wraparound=True)
|
||||
for i in range(1, 256):
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(bchr(i), c())
|
||||
self.assertEqual(0, c.next_value())
|
||||
self.assertEqual(b("\x00"), c())
|
||||
self.assertEqual(1, c.next_value())
|
||||
|
||||
def test_LE8_wraparound_allowed(self):
|
||||
"""8-bit, Little endian, wraparound with allow_wraparound=True"""
|
||||
c = Counter.new(8, little_endian=True, allow_wraparound=True)
|
||||
for i in range(1, 256):
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(bchr(i), c())
|
||||
self.assertEqual(0, c.next_value())
|
||||
self.assertEqual(b("\x00"), c())
|
||||
self.assertEqual(1, c.next_value())
|
||||
|
||||
def test_BE8_carry(self):
|
||||
"""8-bit, Big endian, carry attribute"""
|
||||
c = Counter.new(8)
|
||||
for i in range(1, 256):
|
||||
self.assertEqual(0, c.carry)
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(bchr(i), c())
|
||||
self.assertEqual(1, c.carry)
|
||||
|
||||
def test_LE8_carry(self):
|
||||
"""8-bit, Little endian, carry attribute"""
|
||||
c = Counter.new(8, little_endian=True)
|
||||
for i in range(1, 256):
|
||||
self.assertEqual(0, c.carry)
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(bchr(i), c())
|
||||
self.assertEqual(1, c.carry)
|
||||
|
||||
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:
|
||||
# -*- 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"""
|
||||
|
||||
__revision__ = "$Id$"
|
||||
|
||||
import sys
|
||||
if sys.version_info[0] == 2 and sys.version_info[1] == 1:
|
||||
from Crypto.Util.py21compat import *
|
||||
from Crypto.Util.py3compat import *
|
||||
|
||||
import unittest
|
||||
|
||||
class CounterTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
global Counter
|
||||
from Crypto.Util import Counter
|
||||
|
||||
def test_BE_shortcut(self):
|
||||
"""Big endian, shortcut enabled"""
|
||||
c = Counter.new(128)
|
||||
self.assertEqual(c.__PCT_CTR_SHORTCUT__,True) # assert_
|
||||
c = Counter.new(128, little_endian=False)
|
||||
self.assertEqual(c.__PCT_CTR_SHORTCUT__,True) # assert_
|
||||
c = Counter.new(128, disable_shortcut=False)
|
||||
self.assertEqual(c.__PCT_CTR_SHORTCUT__,True) # assert_
|
||||
c = Counter.new(128, little_endian=False, disable_shortcut=False)
|
||||
self.assertEqual(c.__PCT_CTR_SHORTCUT__,True) # assert_
|
||||
|
||||
def test_LE_shortcut(self):
|
||||
"""Little endian, shortcut enabled"""
|
||||
c = Counter.new(128, little_endian=True)
|
||||
self.assertEqual(c.__PCT_CTR_SHORTCUT__,True) # assert_
|
||||
c = Counter.new(128, little_endian=True, disable_shortcut=False)
|
||||
self.assertEqual(c.__PCT_CTR_SHORTCUT__,True) # assert_
|
||||
|
||||
def test_BE_no_shortcut(self):
|
||||
"""Big endian, shortcut disabled"""
|
||||
c = Counter.new(128, disable_shortcut=True)
|
||||
self.assertRaises(AttributeError, getattr, c, '__PCT_CTR_SHORTCUT__')
|
||||
c = Counter.new(128, little_endian=False, disable_shortcut=True)
|
||||
self.assertRaises(AttributeError, getattr, c, '__PCT_CTR_SHORTCUT__')
|
||||
|
||||
def test_LE_no_shortcut(self):
|
||||
"""Little endian, shortcut disabled"""
|
||||
c = Counter.new(128, little_endian=True, disable_shortcut=True)
|
||||
self.assertRaises(AttributeError, getattr, c, '__PCT_CTR_SHORTCUT__')
|
||||
|
||||
def test_BE_defaults(self):
|
||||
"""128-bit, Big endian, defaults"""
|
||||
c = Counter.new(128)
|
||||
self.assertEqual(1, c.next_value())
|
||||
self.assertEqual(b("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01"), c())
|
||||
self.assertEqual(2, c.next_value())
|
||||
self.assertEqual(b("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02"), c())
|
||||
for i in range(3, 256):
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(b("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")+bchr(i), c())
|
||||
self.assertEqual(256, c.next_value())
|
||||
self.assertEqual(b("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00"), c())
|
||||
|
||||
def test_LE_defaults(self):
|
||||
"""128-bit, Little endian, defaults"""
|
||||
c = Counter.new(128, little_endian=True)
|
||||
self.assertEqual(1, c.next_value())
|
||||
self.assertEqual(b("\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), c())
|
||||
self.assertEqual(2, c.next_value())
|
||||
self.assertEqual(b("\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), c())
|
||||
for i in range(3, 256):
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(bchr(i)+b("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), c())
|
||||
self.assertEqual(256, c.next_value())
|
||||
self.assertEqual(b("\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), c())
|
||||
|
||||
def test_BE8_wraparound(self):
|
||||
"""8-bit, Big endian, wraparound"""
|
||||
c = Counter.new(8)
|
||||
for i in range(1, 256):
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(bchr(i), c())
|
||||
self.assertRaises(OverflowError, c.next_value)
|
||||
self.assertRaises(OverflowError, c)
|
||||
self.assertRaises(OverflowError, c.next_value)
|
||||
self.assertRaises(OverflowError, c)
|
||||
|
||||
def test_LE8_wraparound(self):
|
||||
"""8-bit, Little endian, wraparound"""
|
||||
c = Counter.new(8, little_endian=True)
|
||||
for i in range(1, 256):
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(bchr(i), c())
|
||||
self.assertRaises(OverflowError, c.next_value)
|
||||
self.assertRaises(OverflowError, c)
|
||||
self.assertRaises(OverflowError, c.next_value)
|
||||
self.assertRaises(OverflowError, c)
|
||||
|
||||
def test_BE8_wraparound_allowed(self):
|
||||
"""8-bit, Big endian, wraparound with allow_wraparound=True"""
|
||||
c = Counter.new(8, allow_wraparound=True)
|
||||
for i in range(1, 256):
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(bchr(i), c())
|
||||
self.assertEqual(0, c.next_value())
|
||||
self.assertEqual(b("\x00"), c())
|
||||
self.assertEqual(1, c.next_value())
|
||||
|
||||
def test_LE8_wraparound_allowed(self):
|
||||
"""8-bit, Little endian, wraparound with allow_wraparound=True"""
|
||||
c = Counter.new(8, little_endian=True, allow_wraparound=True)
|
||||
for i in range(1, 256):
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(bchr(i), c())
|
||||
self.assertEqual(0, c.next_value())
|
||||
self.assertEqual(b("\x00"), c())
|
||||
self.assertEqual(1, c.next_value())
|
||||
|
||||
def test_BE8_carry(self):
|
||||
"""8-bit, Big endian, carry attribute"""
|
||||
c = Counter.new(8)
|
||||
for i in range(1, 256):
|
||||
self.assertEqual(0, c.carry)
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(bchr(i), c())
|
||||
self.assertEqual(1, c.carry)
|
||||
|
||||
def test_LE8_carry(self):
|
||||
"""8-bit, Little endian, carry attribute"""
|
||||
c = Counter.new(8, little_endian=True)
|
||||
for i in range(1, 256):
|
||||
self.assertEqual(0, c.carry)
|
||||
self.assertEqual(i, c.next_value())
|
||||
self.assertEqual(bchr(i), c())
|
||||
self.assertEqual(1, c.carry)
|
||||
|
||||
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:
|
||||
|
|
|
|||
|
|
@ -1,293 +1,293 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# SelfTest/Util/test_asn.py: Self-test for the Crypto.Util.asn1 module
|
||||
#
|
||||
# ===================================================================
|
||||
# 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.asn1"""
|
||||
|
||||
__revision__ = "$Id$"
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
|
||||
from Crypto.Util.py3compat import *
|
||||
from Crypto.Util.asn1 import DerSequence, DerObject
|
||||
|
||||
class DerObjectTests(unittest.TestCase):
|
||||
|
||||
def testObjEncode1(self):
|
||||
# No payload
|
||||
der = DerObject(b('\x33'))
|
||||
self.assertEqual(der.encode(), b('\x33\x00'))
|
||||
# Small payload
|
||||
der.payload = b('\x45')
|
||||
self.assertEqual(der.encode(), b('\x33\x01\x45'))
|
||||
# Invariant
|
||||
self.assertEqual(der.encode(), b('\x33\x01\x45'))
|
||||
# Initialize with numerical tag
|
||||
der = DerObject(b(0x33))
|
||||
der.payload = b('\x45')
|
||||
self.assertEqual(der.encode(), b('\x33\x01\x45'))
|
||||
|
||||
def testObjEncode2(self):
|
||||
# Known types
|
||||
der = DerObject('SEQUENCE')
|
||||
self.assertEqual(der.encode(), b('\x30\x00'))
|
||||
der = DerObject('BIT STRING')
|
||||
self.assertEqual(der.encode(), b('\x03\x00'))
|
||||
|
||||
def testObjEncode3(self):
|
||||
# Long payload
|
||||
der = DerObject(b('\x34'))
|
||||
der.payload = b("0")*128
|
||||
self.assertEqual(der.encode(), b('\x34\x81\x80' + "0"*128))
|
||||
|
||||
def testObjDecode1(self):
|
||||
# Decode short payload
|
||||
der = DerObject()
|
||||
der.decode(b('\x20\x02\x01\x02'))
|
||||
self.assertEqual(der.payload, b("\x01\x02"))
|
||||
self.assertEqual(der.typeTag, 0x20)
|
||||
|
||||
def testObjDecode2(self):
|
||||
# Decode short payload
|
||||
der = DerObject()
|
||||
der.decode(b('\x22\x81\x80' + "1"*128))
|
||||
self.assertEqual(der.payload, b("1")*128)
|
||||
self.assertEqual(der.typeTag, 0x22)
|
||||
|
||||
class DerSequenceTests(unittest.TestCase):
|
||||
|
||||
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.assertTrue(der.hasOnlyInts())
|
||||
# Invariant
|
||||
self.assertEqual(der.encode(), b('0\x03\x02\x01\x00'))
|
||||
|
||||
def testEncode2(self):
|
||||
# One single-byte integer (non-zero)
|
||||
der = DerSequence()
|
||||
der.append(127)
|
||||
self.assertEqual(der.encode(), b('0\x03\x02\x01\x7f'))
|
||||
# Indexing
|
||||
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):
|
||||
# One single-byte integer (looks negative)
|
||||
der = DerSequence()
|
||||
der.append(0xFF)
|
||||
self.assertEqual(der.encode(), b('0\x04\x02\x02\x00\xff'))
|
||||
|
||||
def testEncode6(self):
|
||||
# Two 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())
|
||||
#
|
||||
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\x0A\x02\x02\x01\x80\x02\x01\x09\x02\x01\x08'))
|
||||
|
||||
def testEncode6(self):
|
||||
# One integer and another type (no matter what it is)
|
||||
der = DerSequence()
|
||||
der.append(0x180)
|
||||
der.append(b('\x00\x02\x00\x00'))
|
||||
self.assertEqual(der.encode(), b('0\x08\x02\x02\x01\x80\x00\x02\x00\x00'))
|
||||
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 testDecode3(self):
|
||||
# One multi-byte integer (non-zero)
|
||||
der = DerSequence()
|
||||
der.decode(b('0\x04\x02\x02\x01\x80'))
|
||||
self.assertEqual(len(der),1)
|
||||
self.assertEqual(der[0],0x180)
|
||||
|
||||
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 testDecode5(self):
|
||||
# One single-byte integer (looks negative)
|
||||
der = DerSequence()
|
||||
der.decode(b('0\x04\x02\x02\x00\xff'))
|
||||
self.assertEqual(len(der),1)
|
||||
self.assertEqual(der[0],0xFF)
|
||||
|
||||
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'))
|
||||
|
||||
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):
|
||||
# Wrong payload type
|
||||
der = DerSequence()
|
||||
self.assertRaises(ValueError, der.decode, b('\x30\x00\x00'), True)
|
||||
|
||||
def testErrDecode3(self):
|
||||
# Wrong length format
|
||||
der = DerSequence()
|
||||
self.assertRaises(ValueError, der.decode, b('\x30\x04\x02\x01\x01\x00'))
|
||||
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 testErrDecode4(self):
|
||||
# Wrong integer format
|
||||
der = DerSequence()
|
||||
# Multi-byte encoding for zero
|
||||
#self.assertRaises(ValueError, der.decode, '\x30\x04\x02\x02\x00\x00')
|
||||
# Negative integer
|
||||
self.assertRaises(ValueError, der.decode, b('\x30\x04\x02\x01\xFF'))
|
||||
|
||||
def get_tests(config={}):
|
||||
from Crypto.SelfTest.st_common import list_test_cases
|
||||
listTests = []
|
||||
listTests += list_test_cases(DerObjectTests)
|
||||
listTests += list_test_cases(DerSequenceTests)
|
||||
return listTests
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = lambda: unittest.TestSuite(get_tests())
|
||||
unittest.main(defaultTest='suite')
|
||||
|
||||
# vim:set ts=4 sw=4 sts=4 expandtab:
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# SelfTest/Util/test_asn.py: Self-test for the Crypto.Util.asn1 module
|
||||
#
|
||||
# ===================================================================
|
||||
# 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.asn1"""
|
||||
|
||||
__revision__ = "$Id$"
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
|
||||
from Crypto.Util.py3compat import *
|
||||
from Crypto.Util.asn1 import DerSequence, DerObject
|
||||
|
||||
class DerObjectTests(unittest.TestCase):
|
||||
|
||||
def testObjEncode1(self):
|
||||
# No payload
|
||||
der = DerObject(b('\x33'))
|
||||
self.assertEqual(der.encode(), b('\x33\x00'))
|
||||
# Small payload
|
||||
der.payload = b('\x45')
|
||||
self.assertEqual(der.encode(), b('\x33\x01\x45'))
|
||||
# Invariant
|
||||
self.assertEqual(der.encode(), b('\x33\x01\x45'))
|
||||
# Initialize with numerical tag
|
||||
der = DerObject(b(0x33))
|
||||
der.payload = b('\x45')
|
||||
self.assertEqual(der.encode(), b('\x33\x01\x45'))
|
||||
|
||||
def testObjEncode2(self):
|
||||
# Known types
|
||||
der = DerObject('SEQUENCE')
|
||||
self.assertEqual(der.encode(), b('\x30\x00'))
|
||||
der = DerObject('BIT STRING')
|
||||
self.assertEqual(der.encode(), b('\x03\x00'))
|
||||
|
||||
def testObjEncode3(self):
|
||||
# Long payload
|
||||
der = DerObject(b('\x34'))
|
||||
der.payload = b("0")*128
|
||||
self.assertEqual(der.encode(), b('\x34\x81\x80' + "0"*128))
|
||||
|
||||
def testObjDecode1(self):
|
||||
# Decode short payload
|
||||
der = DerObject()
|
||||
der.decode(b('\x20\x02\x01\x02'))
|
||||
self.assertEqual(der.payload, b("\x01\x02"))
|
||||
self.assertEqual(der.typeTag, 0x20)
|
||||
|
||||
def testObjDecode2(self):
|
||||
# Decode short payload
|
||||
der = DerObject()
|
||||
der.decode(b('\x22\x81\x80' + "1"*128))
|
||||
self.assertEqual(der.payload, b("1")*128)
|
||||
self.assertEqual(der.typeTag, 0x22)
|
||||
|
||||
class DerSequenceTests(unittest.TestCase):
|
||||
|
||||
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.assertTrue(der.hasOnlyInts())
|
||||
# Invariant
|
||||
self.assertEqual(der.encode(), b('0\x03\x02\x01\x00'))
|
||||
|
||||
def testEncode2(self):
|
||||
# One single-byte integer (non-zero)
|
||||
der = DerSequence()
|
||||
der.append(127)
|
||||
self.assertEqual(der.encode(), b('0\x03\x02\x01\x7f'))
|
||||
# Indexing
|
||||
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):
|
||||
# One single-byte integer (looks negative)
|
||||
der = DerSequence()
|
||||
der.append(0xFF)
|
||||
self.assertEqual(der.encode(), b('0\x04\x02\x02\x00\xff'))
|
||||
|
||||
def testEncode6(self):
|
||||
# Two 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())
|
||||
#
|
||||
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\x0A\x02\x02\x01\x80\x02\x01\x09\x02\x01\x08'))
|
||||
|
||||
def testEncode6(self):
|
||||
# One integer and another type (no matter what it is)
|
||||
der = DerSequence()
|
||||
der.append(0x180)
|
||||
der.append(b('\x00\x02\x00\x00'))
|
||||
self.assertEqual(der.encode(), b('0\x08\x02\x02\x01\x80\x00\x02\x00\x00'))
|
||||
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 testDecode3(self):
|
||||
# One multi-byte integer (non-zero)
|
||||
der = DerSequence()
|
||||
der.decode(b('0\x04\x02\x02\x01\x80'))
|
||||
self.assertEqual(len(der),1)
|
||||
self.assertEqual(der[0],0x180)
|
||||
|
||||
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 testDecode5(self):
|
||||
# One single-byte integer (looks negative)
|
||||
der = DerSequence()
|
||||
der.decode(b('0\x04\x02\x02\x00\xff'))
|
||||
self.assertEqual(len(der),1)
|
||||
self.assertEqual(der[0],0xFF)
|
||||
|
||||
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'))
|
||||
|
||||
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):
|
||||
# Wrong payload type
|
||||
der = DerSequence()
|
||||
self.assertRaises(ValueError, der.decode, b('\x30\x00\x00'), True)
|
||||
|
||||
def testErrDecode3(self):
|
||||
# Wrong length format
|
||||
der = DerSequence()
|
||||
self.assertRaises(ValueError, der.decode, b('\x30\x04\x02\x01\x01\x00'))
|
||||
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 testErrDecode4(self):
|
||||
# Wrong integer format
|
||||
der = DerSequence()
|
||||
# Multi-byte encoding for zero
|
||||
#self.assertRaises(ValueError, der.decode, '\x30\x04\x02\x02\x00\x00')
|
||||
# Negative integer
|
||||
self.assertRaises(ValueError, der.decode, b('\x30\x04\x02\x01\xFF'))
|
||||
|
||||
def get_tests(config={}):
|
||||
from Crypto.SelfTest.st_common import list_test_cases
|
||||
listTests = []
|
||||
listTests += list_test_cases(DerObjectTests)
|
||||
listTests += list_test_cases(DerSequenceTests)
|
||||
return listTests
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = lambda: unittest.TestSuite(get_tests())
|
||||
unittest.main(defaultTest='suite')
|
||||
|
||||
# vim:set ts=4 sw=4 sts=4 expandtab:
|
||||
|
|
|
|||
|
|
@ -1,295 +1,295 @@
|
|||
# -*- 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"""
|
||||
|
||||
__revision__ = "$Id$"
|
||||
|
||||
import sys
|
||||
if sys.version_info[0] == 2 and sys.version_info[1] == 1:
|
||||
from Crypto.Util.py21compat import *
|
||||
|
||||
import unittest
|
||||
|
||||
# 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 test_negative_number_roundtrip_mpzToLongObj_longObjToMPZ(self):
|
||||
"""Test that mpzToLongObj and longObjToMPZ (internal functions) roundtrip negative numbers correctly."""
|
||||
n = -100000000000000000000000000000000000
|
||||
e = 2
|
||||
k = number._fastmath.rsa_construct(n, e)
|
||||
self.assertEqual(n, k.n)
|
||||
self.assertEqual(e, k.e)
|
||||
|
||||
def get_tests(config={}):
|
||||
from Crypto.SelfTest.st_common import list_test_cases
|
||||
return list_test_cases(MiscTests)
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = lambda: unittest.TestSuite(get_tests())
|
||||
unittest.main(defaultTest='suite')
|
||||
|
||||
# vim:set ts=4 sw=4 sts=4 expandtab:
|
||||
# -*- 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"""
|
||||
|
||||
__revision__ = "$Id$"
|
||||
|
||||
import sys
|
||||
if sys.version_info[0] == 2 and sys.version_info[1] == 1:
|
||||
from Crypto.Util.py21compat import *
|
||||
|
||||
import unittest
|
||||
|
||||
# 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 test_negative_number_roundtrip_mpzToLongObj_longObjToMPZ(self):
|
||||
"""Test that mpzToLongObj and longObjToMPZ (internal functions) roundtrip negative numbers correctly."""
|
||||
n = -100000000000000000000000000000000000
|
||||
e = 2
|
||||
k = number._fastmath.rsa_construct(n, e)
|
||||
self.assertEqual(n, k.n)
|
||||
self.assertEqual(e, k.e)
|
||||
|
||||
def get_tests(config={}):
|
||||
from Crypto.SelfTest.st_common import list_test_cases
|
||||
return list_test_cases(MiscTests)
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = lambda: unittest.TestSuite(get_tests())
|
||||
unittest.main(defaultTest='suite')
|
||||
|
||||
# vim:set ts=4 sw=4 sts=4 expandtab:
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue