FM / rsa

/usr/lib/python2.6/site-packages/rsa

Name	Size	Mode	Actions
asn1.py	1781	0644	edit dl rm
asn1.pyc	1653	0644	edit dl rm
asn1.pyo	1653	0644	edit dl rm
bigfile.py	5185	0644	edit dl rm
bigfile.pyc	4786	0644	edit dl rm
bigfile.pyo	4786	0644	edit dl rm
cli.py	12185	0644	edit dl rm
cli.pyc	13319	0644	edit dl rm
cli.pyo	13319	0644	edit dl rm
common.py	4640	0644	edit dl rm
common.pyc	4235	0644	edit dl rm
common.pyo	4235	0644	edit dl rm
core.py	1656	0644	edit dl rm
core.pyc	1485	0644	edit dl rm
core.pyo	1485	0644	edit dl rm
key.py	22867	0644	edit dl rm
key.pyc	23986	0644	edit dl rm
key.pyo	23986	0644	edit dl rm
parallel.py	2299	0644	edit dl rm
parallel.pyc	2098	0644	edit dl rm
parallel.pyo	2098	0644	edit dl rm
pem.py	3537	0644	edit dl rm
pem.pyc	2843	0644	edit dl rm
pem.pyo	2843	0644	edit dl rm
pkcs1.py	12230	0644	edit dl rm
pkcs1.pyc	11173	0644	edit dl rm
pkcs1.pyo	11126	0644	edit dl rm
prime.py	4560	0644	edit dl rm
prime.pyc	3664	0644	edit dl rm
prime.pyo	3618	0644	edit dl rm
randnum.py	2643	0644	edit dl rm
randnum.pyc	2074	0644	edit dl rm
randnum.pyo	2074	0644	edit dl rm
transform.py	6892	0644	edit dl rm
transform.pyc	5856	0644	edit dl rm
transform.pyo	5856	0644	edit dl rm
util.py	3059	0644	edit dl rm
util.pyc	2520	0644	edit dl rm
util.pyo	2449	0644	edit dl rm
varblock.py	5406	0644	edit dl rm
varblock.pyc	4856	0644	edit dl rm
varblock.pyo	4856	0644	edit dl rm
_compat.py	3890	0644	edit dl rm
_compat.pyc	3655	0644	edit dl rm
_compat.pyo	3655	0644	edit dl rm
_version133.py	11764	0644	edit dl rm
_version133.pyc	13639	0644	edit dl rm
_version133.pyo	13639	0644	edit dl rm
_version200.py	15123	0644	edit dl rm
_version200.pyc	15264	0644	edit dl rm
_version200.pyo	15264	0644	edit dl rm
__init__.py	1476	0644	edit dl rm
__init__.pyc	1112	0644	edit dl rm
__init__.pyo	1112	0644	edit dl rm

Edit: /usr/lib/python2.6/site-packages/rsa/_version200.py (15123B)

# -*- coding: utf-8 -*-
#
#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      https://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.

"""Deprecated version of the RSA module

.. deprecated:: 3.0

This submodule is deprecated and will be completely removed as of version 4.0.

"""

__author__ = "Sybren Stuvel, Marloes de Boer, Ivo Tamboer, and Barry Mead"
__date__ = "2010-02-08"
__version__ = '2.0'

import math
import os
import random
import sys
import types
from rsa._compat import byte

# Display a warning that this insecure version is imported.
import warnings
warnings.warn('Insecure version of the RSA module is imported as %s' % __name__)
warnings.warn('This submodule is deprecated and will be completely removed as of version 4.0.',
              DeprecationWarning)

def bit_size(number):
    """Returns the number of bits required to hold a specific long number"""

return int(math.ceil(math.log(number,2)))

def gcd(p, q):
    """Returns the greatest common divisor of p and q
    >>> gcd(48, 180)
    12
    """
    # Iterateive Version is faster and uses much less stack space
    while q != 0:
        if p < q: (p,q) = (q,p)
        (p,q) = (q, p % q)
    return p

def bytes2int(bytes):
    r"""Converts a list of bytes or a string to an integer
    """

if not (type(bytes) is types.ListType or type(bytes) is types.StringType):
        raise TypeError("You must pass a string or a list")

# Convert byte stream to integer
    integer = 0
    for byte in bytes:
        integer *= 256
        if type(byte) is types.StringType: byte = ord(byte)
        integer += byte

return integer

def int2bytes(number):
    """
    Converts a number to a string of bytes
    """

if not (type(number) is types.LongType or type(number) is types.IntType):
        raise TypeError("You must pass a long or an int")

string = ""

while number > 0:
        string = "%s%s" % (byte(number & 0xFF), string)
        number /= 256
    
    return string

def to64(number):
    """Converts a number in the range of 0 to 63 into base 64 digit
    character in the range of '0'-'9', 'A'-'Z', 'a'-'z','-','_'.
    """

if not (type(number) is types.LongType or type(number) is types.IntType):
        raise TypeError("You must pass a long or an int")

if 0 <= number <= 9:            #00-09 translates to '0' - '9'
        return byte(number + 48)

if 10 <= number <= 35:
        return byte(number + 55)     #10-35 translates to 'A' - 'Z'

if 36 <= number <= 61:
        return byte(number + 61)     #36-61 translates to 'a' - 'z'

if number == 62:                # 62   translates to '-' (minus)
        return byte(45)

if number == 63:                # 63   translates to '_' (underscore)
        return byte(95)

raise ValueError('Invalid Base64 value: %i' % number)

def from64(number):
    """Converts an ordinal character value in the range of
    0-9,A-Z,a-z,-,_ to a number in the range of 0-63.
    """

if not (type(number) is types.LongType or type(number) is types.IntType):
        raise TypeError("You must pass a long or an int")

if 48 <= number <= 57:         #ord('0') - ord('9') translates to 0-9
        return(number - 48)

if 65 <= number <= 90:         #ord('A') - ord('Z') translates to 10-35
        return(number - 55)

if 97 <= number <= 122:        #ord('a') - ord('z') translates to 36-61
        return(number - 61)

if number == 45:               #ord('-') translates to 62
        return(62)

if number == 95:               #ord('_') translates to 63
        return(63)

raise ValueError('Invalid Base64 value: %i' % number)

def int2str64(number):
    """Converts a number to a string of base64 encoded characters in
    the range of '0'-'9','A'-'Z,'a'-'z','-','_'.
    """

if not (type(number) is types.LongType or type(number) is types.IntType):
        raise TypeError("You must pass a long or an int")

string = ""

while number > 0:
        string = "%s%s" % (to64(number & 0x3F), string)
        number /= 64

return string

def str642int(string):
    """Converts a base64 encoded string into an integer.
    The chars of this string in in the range '0'-'9','A'-'Z','a'-'z','-','_'
    """

if not (type(string) is types.ListType or type(string) is types.StringType):
        raise TypeError("You must pass a string or a list")

integer = 0
    for byte in string:
        integer *= 64
        if type(byte) is types.StringType: byte = ord(byte)
        integer += from64(byte)

return integer

def read_random_int(nbits):
    """Reads a random integer of approximately nbits bits rounded up
    to whole bytes"""

nbytes = int(math.ceil(nbits/8.))
    randomdata = os.urandom(nbytes)
    return bytes2int(randomdata)

def randint(minvalue, maxvalue):
    """Returns a random integer x with minvalue <= x <= maxvalue"""

# Safety - get a lot of random data even if the range is fairly
    # small
    min_nbits = 32

# The range of the random numbers we need to generate
    range = (maxvalue - minvalue) + 1

# Which is this number of bytes
    rangebytes = ((bit_size(range) + 7) / 8)

# Convert to bits, but make sure it's always at least min_nbits*2
    rangebits = max(rangebytes * 8, min_nbits * 2)
    
    # Take a random number of bits between min_nbits and rangebits
    nbits = random.randint(min_nbits, rangebits)
    
    return (read_random_int(nbits) % range) + minvalue

def jacobi(a, b):
    """Calculates the value of the Jacobi symbol (a/b)
    where both a and b are positive integers, and b is odd
    """

if a == 0: return 0
    result = 1
    while a > 1:
        if a & 1:
            if ((a-1)*(b-1) >> 2) & 1:
                result = -result
            a, b = b % a, a
        else:
            if (((b * b) - 1) >> 3) & 1:
                result = -result
            a >>= 1
    if a == 0: return 0
    return result

def jacobi_witness(x, n):
    """Returns False if n is an Euler pseudo-prime with base x, and
    True otherwise.
    """

j = jacobi(x, n) % n
    f = pow(x, (n-1)/2, n)

if j == f: return False
    return True

def randomized_primality_testing(n, k):
    """Calculates whether n is composite (which is always correct) or
    prime (which is incorrect with error probability 2**-k)

Returns False if the number is composite, and True if it's
    probably prime.
    """

# 50% of Jacobi-witnesses can report compositness of non-prime numbers

for i in range(k):
        x = randint(1, n-1)
        if jacobi_witness(x, n): return False
    
    return True

def is_prime(number):
    """Returns True if the number is prime, and False otherwise.
    """

if randomized_primality_testing(number, 6):
        # Prime, according to Jacobi
        return True
    
    # Not prime
    return False

def getprime(nbits):
    """Returns a prime number of max. 'math.ceil(nbits/8)*8' bits. In
    other words: nbits is rounded up to whole bytes.
    """

while True:
        integer = read_random_int(nbits)

# Make sure it's odd
        integer |= 1

# Test for primeness
        if is_prime(integer): break

# Retry if not prime

return integer

def are_relatively_prime(a, b):
    """Returns True if a and b are relatively prime, and False if they
    are not.

>>> are_relatively_prime(2, 3)
    1
    >>> are_relatively_prime(2, 4)
    0
    """

d = gcd(a, b)
    return (d == 1)

def find_p_q(nbits):
    """Returns a tuple of two different primes of nbits bits"""
    pbits = nbits + (nbits/16)  #Make sure that p and q aren't too close
    qbits = nbits - (nbits/16)  #or the factoring programs can factor n
    p = getprime(pbits)
    while True:
        q = getprime(qbits)
        #Make sure p and q are different.
        if not q == p: break
    return (p, q)

def extended_gcd(a, b):
    """Returns a tuple (r, i, j) such that r = gcd(a, b) = ia + jb
    """
    # r = gcd(a,b) i = multiplicitive inverse of a mod b
    #      or      j = multiplicitive inverse of b mod a
    # Neg return values for i or j are made positive mod b or a respectively
    # Iterateive Version is faster and uses much less stack space
    x = 0
    y = 1
    lx = 1
    ly = 0
    oa = a                             #Remember original a/b to remove 
    ob = b                             #negative values from return results
    while b != 0:
        q = long(a/b)
        (a, b)  = (b, a % b)
        (x, lx) = ((lx - (q * x)),x)
        (y, ly) = ((ly - (q * y)),y)
    if (lx < 0): lx += ob              #If neg wrap modulo orignal b
    if (ly < 0): ly += oa              #If neg wrap modulo orignal a
    return (a, lx, ly)                 #Return only positive values

# Main function: calculate encryption and decryption keys
def calculate_keys(p, q, nbits):
    """Calculates an encryption and a decryption key for p and q, and
    returns them as a tuple (e, d)"""

n = p * q
    phi_n = (p-1) * (q-1)

while True:
        # Make sure e has enough bits so we ensure "wrapping" through
        # modulo n
        e = max(65537,getprime(nbits/4))
        if are_relatively_prime(e, n) and are_relatively_prime(e, phi_n): break

(d, i, j) = extended_gcd(e, phi_n)

if not d == 1:
        raise Exception("e (%d) and phi_n (%d) are not relatively prime" % (e, phi_n))
    if (i < 0):
        raise Exception("New extended_gcd shouldn't return negative values")
    if not (e * i) % phi_n == 1:
        raise Exception("e (%d) and i (%d) are not mult. inv. modulo phi_n (%d)" % (e, i, phi_n))

return (e, i)

def gen_keys(nbits):
    """Generate RSA keys of nbits bits. Returns (p, q, e, d).

Note: this can take a long time, depending on the key size.
    """

(p, q) = find_p_q(nbits)
    (e, d) = calculate_keys(p, q, nbits)

return (p, q, e, d)

def newkeys(nbits):
    """Generates public and private keys, and returns them as (pub,
    priv).

The public key consists of a dict {e: ..., , n: ....). The private
    key consists of a dict {d: ...., p: ...., q: ....).
    """
    nbits = max(9,nbits)           # Don't let nbits go below 9 bits
    (p, q, e, d) = gen_keys(nbits)

return ( {'e': e, 'n': p*q}, {'d': d, 'p': p, 'q': q} )

def encrypt_int(message, ekey, n):
    """Encrypts a message using encryption key 'ekey', working modulo n"""

if type(message) is types.IntType:
        message = long(message)

if not type(message) is types.LongType:
        raise TypeError("You must pass a long or int")

if message < 0 or message > n:
        raise OverflowError("The message is too long")

#Note: Bit exponents start at zero (bit counts start at 1) this is correct
    safebit = bit_size(n) - 2                   #compute safe bit (MSB - 1)
    message += (1 << safebit)                   #add safebit to ensure folding

return pow(message, ekey, n)

def decrypt_int(cyphertext, dkey, n):
    """Decrypts a cypher text using the decryption key 'dkey', working
    modulo n"""

message = pow(cyphertext, dkey, n)

safebit = bit_size(n) - 2                   #compute safe bit (MSB - 1)
    message -= (1 << safebit)                   #remove safebit before decode

return message

def encode64chops(chops):
    """base64encodes chops and combines them into a ',' delimited string"""

chips = []                              #chips are character chops

for value in chops:
        chips.append(int2str64(value))

#delimit chops with comma
    encoded = ','.join(chips)

return encoded

def decode64chops(string):
    """base64decodes and makes a ',' delimited string into chops"""

chips = string.split(',')               #split chops at commas

chops = []

for string in chips:                    #make char chops (chips) into chops
        chops.append(str642int(string))

return chops

def chopstring(message, key, n, funcref):
    """Chops the 'message' into integers that fit into n,
    leaving room for a safebit to be added to ensure that all
    messages fold during exponentiation.  The MSB of the number n
    is not independant modulo n (setting it could cause overflow), so
    use the next lower bit for the safebit.  Therefore reserve 2-bits
    in the number n for non-data bits.  Calls specified encryption
    function for each chop.

Used by 'encrypt' and 'sign'.
    """

msglen = len(message)
    mbits = msglen * 8
    #Set aside 2-bits so setting of safebit won't overflow modulo n.
    nbits = bit_size(n) - 2             # leave room for safebit
    nbytes = nbits / 8
    blocks = msglen / nbytes

if msglen % nbytes > 0:
        blocks += 1

cypher = []
    
    for bindex in range(blocks):
        offset = bindex * nbytes
        block = message[offset:offset+nbytes]
        value = bytes2int(block)
        cypher.append(funcref(value, key, n))

return encode64chops(cypher)   #Encode encrypted ints to base64 strings

def gluechops(string, key, n, funcref):
    """Glues chops back together into a string.  calls
    funcref(integer, key, n) for each chop.

Used by 'decrypt' and 'verify'.
    """
    message = ""

chops = decode64chops(string)  #Decode base64 strings into integer chops
    
    for cpart in chops:
        mpart = funcref(cpart, key, n) #Decrypt each chop
        message += int2bytes(mpart)    #Combine decrypted strings into a msg
    
    return message

def encrypt(message, key):
    """Encrypts a string 'message' with the public key 'key'"""
    if 'n' not in key:
        raise Exception("You must use the public key with encrypt")

return chopstring(message, key['e'], key['n'], encrypt_int)

def sign(message, key):
    """Signs a string 'message' with the private key 'key'"""
    if 'p' not in key:
        raise Exception("You must use the private key with sign")

return chopstring(message, key['d'], key['p']*key['q'], encrypt_int)

def decrypt(cypher, key):
    """Decrypts a string 'cypher' with the private key 'key'"""
    if 'p' not in key:
        raise Exception("You must use the private key with decrypt")

return gluechops(cypher, key['d'], key['p']*key['q'], decrypt_int)

def verify(cypher, key):
    """Verifies a string 'cypher' with the public key 'key'"""
    if 'n' not in key:
        raise Exception("You must use the public key with verify")

return gluechops(cypher, key['e'], key['n'], decrypt_int)

# Do doctest if we're not imported
if __name__ == "__main__":
    import doctest
    doctest.testmod()

__all__ = ["newkeys", "encrypt", "decrypt", "sign", "verify"]

cmd: