# Python Crypto.Util.number.size() Examples

The following are 30 code examples of Crypto.Util.number.size(). You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may also want to check out all available functions/classes of the module , or try the search function .
Example #1
```def _div_gf2(a, b):
"""
Compute division of polynomials over GF(2).
Given a and b, it finds two polynomials q and r such that:

a = b*q + r with deg(r)<deg(b)
"""

if (a < b):
return 0, a

deg = number.size
q = 0
r = a
d = deg(b)
while deg(r) >= d:
s = 1 << (deg(r) - d)
q ^= s
r ^= _mult_gf2(b, s)
return (q, r) ```
Example #2
```def _check_private_key(self, dsaObj):
# Check capabilities
self.assertEqual(1, dsaObj.has_private())
self.assertEqual(1, dsaObj.can_sign())
self.assertEqual(0, dsaObj.can_encrypt())
self.assertEqual(0, dsaObj.can_blind())

# Check dsaObj.[ygpqx] -> dsaObj.key.[ygpqx] mapping
self.assertEqual(dsaObj.y, dsaObj.key.y)
self.assertEqual(dsaObj.g, dsaObj.key.g)
self.assertEqual(dsaObj.p, dsaObj.key.p)
self.assertEqual(dsaObj.q, dsaObj.key.q)
self.assertEqual(dsaObj.x, dsaObj.key.x)

# Sanity check key data
self.assertEqual(1, dsaObj.p > dsaObj.q)            # p > q
self.assertEqual(160, size(dsaObj.q))               # size(q) == 160 bits
self.assertEqual(0, (dsaObj.p - 1) % dsaObj.q)      # q is a divisor of p-1
self.assertEqual(dsaObj.y, pow(dsaObj.g, dsaObj.x, dsaObj.p))     # y == g**x mod p
self.assertEqual(1, 0 < dsaObj.x < dsaObj.q)       # 0 < x < q ```
Example #3
 Source File: test_DSA.py    From Safejumper-for-Desktop with GNU General Public License v2.0 6 votes
```def _check_private_key(self, dsaObj):
# Check capabilities
self.assertEqual(1, dsaObj.has_private())
self.assertEqual(1, dsaObj.can_sign())
self.assertEqual(0, dsaObj.can_encrypt())
self.assertEqual(0, dsaObj.can_blind())

# Check dsaObj.[ygpqx] -> dsaObj.key.[ygpqx] mapping
self.assertEqual(dsaObj.y, dsaObj.key.y)
self.assertEqual(dsaObj.g, dsaObj.key.g)
self.assertEqual(dsaObj.p, dsaObj.key.p)
self.assertEqual(dsaObj.q, dsaObj.key.q)
self.assertEqual(dsaObj.x, dsaObj.key.x)

# Sanity check key data
self.assertEqual(1, dsaObj.p > dsaObj.q)            # p > q
self.assertEqual(160, size(dsaObj.q))               # size(q) == 160 bits
self.assertEqual(0, (dsaObj.p - 1) % dsaObj.q)      # q is a divisor of p-1
self.assertEqual(dsaObj.y, pow(dsaObj.g, dsaObj.x, dsaObj.p))     # y == g**x mod p
self.assertEqual(1, 0 < dsaObj.x < dsaObj.q)       # 0 < x < q ```
Example #4
 Source File: SecretSharing.py    From FODI with GNU General Public License v3.0 6 votes
```def _div_gf2(a, b):
"""
Compute division of polynomials over GF(2).
Given a and b, it finds two polynomials q and r such that:

a = b*q + r with deg(r)<deg(b)
"""

if (a < b):
return 0, a

deg = number.size
q = 0
r = a
d = deg(b)
while deg(r) >= d:
s = 1 << (deg(r) - d)
q ^= s
r ^= _mult_gf2(b, s)
return (q, r) ```
Example #5
```def size(self):
"Return the maximum number of bits that can be handled by this key."
return number.size(self.p) - 1 ```
Example #6
```def generate_c(bits, randfunc, progress_func = None):
# Generate the prime factors of n
if progress_func:
progress_func('p,q\n')

p = q = 1
while number.size(p*q) < bits:
p = pubkey.getPrime(bits/2, randfunc)
q = pubkey.getPrime(bits/2, randfunc)

# p shall be smaller than q (for calc of u)
if p > q:
(p, q)=(q, p)
if progress_func:
progress_func('u\n')
u=pubkey.inverse(p, q)
n=p*q

e = 65537
if progress_func:
progress_func('d\n')
d=pubkey.inverse(e, (p-1)*(q-1))
key = _fastmath.rsa_construct(n,e,d,p,q,u)
obj = RSAobj_c(key)

##    print p
##    print q
##    print number.size(p), number.size(q), number.size(q*p),
##    print obj.size(), bits
assert bits <= 1+obj.size(), "Generated key is too small"
return obj ```
Example #7
```def size(self):
return self.key.size() ```
Example #8
```def generate(bits, randfunc, progress_func=None):
"""generate(bits:int, randfunc:callable, progress_func:callable)

Generate an RSA key of length 'bits', using 'randfunc' to get
random data and 'progress_func', if present, to display
the progress of the key generation.
"""
obj=RSAobj()

# Generate the prime factors of n
if progress_func:
progress_func('p,q\n')
p = q = 1L
while number.size(p*q) < bits:
p = pubkey.getPrime(bits/2, randfunc)
q = pubkey.getPrime(bits/2, randfunc)

# p shall be smaller than q (for calc of u)
if p > q:
(p, q)=(q, p)
obj.p = p
obj.q = q

if progress_func:
progress_func('u\n')
obj.u = pubkey.inverse(obj.p, obj.q)
obj.n = obj.p*obj.q

obj.e = 65537L
if progress_func:
progress_func('d\n')
obj.d=pubkey.inverse(obj.e, (obj.p-1)*(obj.q-1))

assert bits <= 1+obj.size(), "Generated key is too small"

return obj ```
Example #9
```def size(self):
"""size() : int
Return the maximum number of bits that can be handled by this key.
"""
return number.size(self.n) - 1 ```
Example #10
```def size(self):
return self.key.size() ```
Example #11
```def generate_c(bits, randfunc, progress_func = None):
# Generate the prime factors of n
if progress_func:
progress_func('p,q\n')

p = q = 1L
while number.size(p*q) < bits:
p = pubkey.getPrime(bits/2, randfunc)
q = pubkey.getPrime(bits/2, randfunc)

# p shall be smaller than q (for calc of u)
if p > q:
(p, q)=(q, p)
if progress_func:
progress_func('u\n')
u=pubkey.inverse(p, q)
n=p*q

e = 65537L
if progress_func:
progress_func('d\n')
d=pubkey.inverse(e, (p-1)*(q-1))
key = _fastmath.rsa_construct(n,e,d,p,q,u)
obj = RSAobj_c(key)

##    print p
##    print q
##    print number.size(p), number.size(q), number.size(q*p),
##    print obj.size(), bits
assert bits <= 1+obj.size(), "Generated key is too small"
return obj ```
Example #12
```def size(self):
"Return the maximum number of bits that can be handled by this key."
return number.size(self.p) - 1 ```
Example #13
```def size(self):
"Return the maximum number of bits that can be handled by this key."
return number.size(self.p) - 1 ```
Example #14
```def generate(bits, randfunc, progress_func=None):
"""generate(bits:int, randfunc:callable, progress_func:callable)

Generate an RSA key of length 'bits', using 'randfunc' to get
random data and 'progress_func', if present, to display
the progress of the key generation.
"""
obj=RSAobj()

# Generate the prime factors of n
if progress_func:
progress_func('p,q\n')
p = q = 1L
while number.size(p*q) < bits:
p = pubkey.getPrime(bits/2, randfunc)
q = pubkey.getPrime(bits/2, randfunc)

# p shall be smaller than q (for calc of u)
if p > q:
(p, q)=(q, p)
obj.p = p
obj.q = q

if progress_func:
progress_func('u\n')
obj.u = pubkey.inverse(obj.p, obj.q)
obj.n = obj.p*obj.q

obj.e = 65537L
if progress_func:
progress_func('d\n')
obj.d=pubkey.inverse(obj.e, (obj.p-1)*(obj.q-1))

assert bits <= 1+obj.size(), "Generated key is too small"

return obj ```
Example #15
```def size(self):
"""size() : int
Return the maximum number of bits that can be handled by this key.
"""
return number.size(self.n) - 1 ```
Example #16
```def size(self):
return self.key.size() ```
Example #17
 Source File: test_SecretSharing.py    From FODI with GNU General Public License v3.0 5 votes
```def test_div_gf2(self):
from Crypto.Util.number import size as deg

x, y = _div_gf2(567, 7)
self.failUnless(deg(y) < deg(7))

w = _mult_gf2(x, 7) ^ y
self.assertEqual(567, w)

x, y = _div_gf2(7, 567)
self.assertEqual(x, 0)
self.assertEqual(y, 7) ```
Example #18
 Source File: test_number.py    From FODI with GNU General Public License v3.0 5 votes
```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)
Example #19
 Source File: test_DSA.py    From FODI with GNU General Public License v3.0 5 votes
```def setUp(self):
global DSA, Random, bytes_to_long, size
from Crypto.PublicKey import DSA
from Crypto import Random
from Crypto.Util.number import bytes_to_long, inverse, size

self.dsa = DSA ```
Example #20
 Source File: test_DSA.py    From FODI with GNU General Public License v3.0 5 votes
```def _check_private_key(self, dsaObj):
# Check capabilities
self.assertEqual(1, dsaObj.has_private())
self.assertEqual(1, dsaObj.can_sign())
self.assertEqual(0, dsaObj.can_encrypt())

# Sanity check key data
self.assertEqual(1, dsaObj.p > dsaObj.q)            # p > q
self.assertEqual(160, size(dsaObj.q))               # size(q) == 160 bits
self.assertEqual(0, (dsaObj.p - 1) % dsaObj.q)      # q is a divisor of p-1
self.assertEqual(dsaObj.y, pow(dsaObj.g, dsaObj.x, dsaObj.p))     # y == g**x mod p
self.assertEqual(1, 0 < dsaObj.x < dsaObj.q)       # 0 < x < q ```
Example #21
 Source File: random.py    From FODI with GNU General Public License v3.0 5 votes
```def randrange(self, *args):
"""randrange([start,] stop[, step]):
Return a randomly-selected element from range(start, stop, step)."""
if len(args) == 3:
(start, stop, step) = args
elif len(args) == 2:
(start, stop) = args
step = 1
elif len(args) == 1:
(stop,) = args
start = 0
step = 1
else:
raise TypeError("randrange expected at most 3 arguments, got %d" % (len(args),))
if (not is_native_int(start) or not is_native_int(stop) or not
is_native_int(step)):
raise TypeError("randrange requires integer arguments")
if step == 0:
raise ValueError("randrange step argument must not be zero")

num_choices = ceil_div(stop - start, step)
if num_choices < 0:
num_choices = 0
if num_choices < 1:
raise ValueError("empty range for randrange(%r, %r, %r)" % (start, stop, step))

# Pick a random number in the range of possible numbers
r = num_choices
while r >= num_choices:
r = self.getrandbits(size(num_choices))

return start + (step * r) ```
Example #22
```def test_div_gf2(self):
from Crypto.Util.number import size as deg

x, y = _div_gf2(567, 7)
self.failUnless(deg(y) < deg(7))

w = _mult_gf2(x, 7) ^ y
self.assertEqual(567, w)

x, y = _div_gf2(7, 567)
self.assertEqual(x, 0)
self.assertEqual(y, 7) ```
Example #23
```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)
Example #24
```def setUp(self):
global DSA, Random, bytes_to_long, size
from Crypto.PublicKey import DSA
from Crypto import Random
from Crypto.Util.number import bytes_to_long, inverse, size

self.dsa = DSA ```
Example #25
```def _check_private_key(self, dsaObj):
# Check capabilities
self.assertEqual(1, dsaObj.has_private())
self.assertEqual(1, dsaObj.can_sign())
self.assertEqual(0, dsaObj.can_encrypt())

# Sanity check key data
self.assertEqual(1, dsaObj.p > dsaObj.q)            # p > q
self.assertEqual(160, size(dsaObj.q))               # size(q) == 160 bits
self.assertEqual(0, (dsaObj.p - 1) % dsaObj.q)      # q is a divisor of p-1
self.assertEqual(dsaObj.y, pow(dsaObj.g, dsaObj.x, dsaObj.p))     # y == g**x mod p
self.assertEqual(1, 0 < dsaObj.x < dsaObj.q)       # 0 < x < q ```
Example #26
```def randrange(self, *args):
"""randrange([start,] stop[, step]):
Return a randomly-selected element from range(start, stop, step)."""
if len(args) == 3:
(start, stop, step) = args
elif len(args) == 2:
(start, stop) = args
step = 1
elif len(args) == 1:
(stop,) = args
start = 0
step = 1
else:
raise TypeError("randrange expected at most 3 arguments, got %d" % (len(args),))
if (not is_native_int(start) or not is_native_int(stop) or not
is_native_int(step)):
raise TypeError("randrange requires integer arguments")
if step == 0:
raise ValueError("randrange step argument must not be zero")

num_choices = ceil_div(stop - start, step)
if num_choices < 0:
num_choices = 0
if num_choices < 1:
raise ValueError("empty range for randrange(%r, %r, %r)" % (start, stop, step))

# Pick a random number in the range of possible numbers
r = num_choices
while r >= num_choices:
r = self.getrandbits(size(num_choices))

return start + (step * r) ```
Example #27
 Source File: _slowmath.py    From Safejumper-for-Desktop with GNU General Public License v2.0 5 votes
```def size(self):
"""Return the maximum number of bits that can be encrypted"""
return size(self.n) - 1 ```
Example #28
```def size(self):
"""size() : int
Return the maximum number of bits that can be handled by this key.
"""
return number.size(self.n) - 1 ```
Example #29
```def sign(self, M, K):
"""Sign a piece of data with ElGamal.

:Parameter M: The piece of data to sign with ElGamal. It may
not be longer in bit size than *p-1*.
:Type M: byte string or long

:Parameter K: A secret number, chosen randomly in the closed
range *[1,p-2]* and such that *gcd(k,p-1)=1*.
:Type K: long (recommended) or byte string (not recommended)

:attention: selection of *K* is crucial for security. Generating a
random number larger than *p-1* and taking the modulus by *p-1* is
**not** secure, since smaller values will occur more frequently.
Generating a random number systematically smaller than *p-1*
(e.g. *floor((p-1)/8)* random bytes) is also **not** secure.
In general, it shall not be possible for an attacker to know
the value of any bit of K.

:attention: The number *K* shall not be reused for any other
operation and shall be discarded immediately.

:attention: M must be be a cryptographic hash, otherwise an
attacker may mount an existential forgery attack.

:Return: A tuple with 2 longs.
"""
return pubkey.sign(self, M, K) ```
Example #30
```def size(self):