quale pacchetto python per algoritmo RSA

Question

cercando di fare la crittografia RSA su una breve stringa in Python. Questo è un pezzo di dati utente che voglio negozio senza personale (compreso il sottoscritto) di essere in grado di vederlo. La chiave privata sarà su pen drive nella mia cassetta di sicurezza per quando otteniamo citato in giudizio.

la mia domanda: c'è un pacchetto python 'probabilmente corretto' per RSA asimmetrica-chiave? Sarò più sicuro utilizzare una libreria C (in tal caso quale).

Answer 1

La crittografia di brevi stringhe con RSA può essere problematico. Ci sono alcune parti dei dati è possibile cifrare con RSA che rivelano dettagli sulla propria chiave privata. Nel tuo caso probabilmente sarà bene perché sarà sufficiente oscura il personale non capirlo. Ma nel caso generale, con un avversario esperto e / o ben finanziato, non si desidera utilizzare RSA per cifrare i dati direttamente, se si desidera che i dati siano tenuti segreti.

mi sento di raccomandare semplicemente utilizzando GnuPG invece . E 'risolto tutti questi problemi per voi.

Answer 2

pycrypto

Answer 3

pycryptopp

Answer 4

def gcd (a, b):
    "Compute GCD of two numbers"

    if b == 0: return a
    else: return gcd(b, a % b)

def multiplicative_inverse(a, b):
    """ Find multiplicative inverse of a modulo b (a > b)
        using Extended Euclidean Algorithm """

    origA = a
    X = 0
    prevX = 1
    Y = 1
    prevY = 0

    while b != 0:

        temp = b
        quotient = a/b
        b = a % b
        a = temp

        temp = X
        a = prevX - quotient * X
        prevX = temp

        temp = Y
        Y = prevY - quotient * Y
        prevY = temp

    return origA + prevY

def generateRSAKeys(p, q):
    "Generate RSA Public and Private Keys from prime numbers p & q"

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

    # Generate a number e so that gcd(n, e) = 1, start with e = 3
    e = 3

    while 1:

        if gcd(m, e) == 1: break
        else: e = e + 2

    d = multiplicative_inverse(m, e)   

    # Return a tuple of public and private keys 
    return ((n,e), (n,d))           

if __name__ == "__main__":

    print "RSA Encryption algorithm...."
    p = long(raw_input("Enter the value of p (prime number):"))
    q = long(raw_input("Enter the value of q (prime number):"))

    print "Generating public and private keys...."
    (publickey, privatekey) = generateRSAKeys(p, q)

    print "Public Key (n, e) =", publickey
    print "Private Key (n, d) =", privatekey

    n, e = publickey
    n, d = privatekey

    input_num = long(raw_input("Enter a number to be encrypted:"))
    encrypted_num = (input_num ** e) % n
    print "Encrypted number using public key =", encrypted_num
    decrypted_num = encrypted_num ** d % n
    print "Decrypted (Original) number using private key =", decrypted_num