Bonjour,
Je sollicite votre aide pour optimiser mon code. J'ai réaliser un petit programme de cryptage/décryptage RSA à l'aide de divers algo trouvé sur le net. Le souci, c'est que lorsque je génère des clés trop grandes, le programme plante lors du décryptage (nombres trop grands)
Voici le code

# encoding: utf-8 
import time
import sys
from random import randrange

###################################################fonction améliorée qui retourne le plus grand commun diviseur###################################################

def pgcd_ameliore(N,D):
	x=0; y=1;
	u=1; v=0;
	a=N; b=D;
	while (0 != a):
		q = int(b/a);
		r = b%a;
		m = x - u*q;
		n = y - v*q;
		b=a; a=r; x=u; y=v; u=m; v=n;
	return b == 1 and ((x+D)%D) or None



def pgcd(a,b):
    while a != b:
        if a > b:
            a = a - b
        else:
            b = b - a
    return a;


###################################################Algorithme de Miller Rabin pour vérifier si un nombre est premier###############################################

def temoin(a,n):
	m=n-1
	y=1
	while m!=0:
		if m%2==1:
			y=(a*y)%n
			m=m-1
		else:
			b=a	
			a=(a*a)%n
			if a==1 and b!=1 and b!=n-1:
				return True
			m=m/2
	if y!=1:
		return True
	else:
		return False

def Miller_Rabin(n,t):
	for i in range(t):
		a = randrange(2,n-1)
		if temoin(a,n):
			return True
	return False

####################################################générer des nombres premiers###################################################################################

def generer_nombre_premier (e,p,a=1) :
	pre=1<<e
	pre2=pre>>a
	pre2+=1
	r1=True
	while r1 : #on essais jusqu'à ce que ca marche !
		t=randrange(pre2,pre,2)
		r1=Miller_Rabin(t,p) #chance d'erreur : 2**-80
	return t

###################################################génération des clés RSA#########################################################################################

def generer_cle(lengh=512,nombredetest=44,marge=1): #generation de la clef
	p,q=generer_nombre_premier(lengh/8,nombredetest,marge),generer_nombre_premier(lengh/8,nombredetest,marge)
	n=p*q
	phiden=(p-1)*(q-1)
	e=1
	while 1 :
		e+=1
		if pgcd(phiden,e) == 1: #utilise le pgdc pour verifier si le totient et e sont coprimes
			break
	d=pgcd_ameliore(e,phiden)
	return ((n,e),(n,d))#renvoie les couples de clef privée et clef publique :

cle=generer_cle(64,72,1024)

####################################################Partie cryptage################################################################################################

print "Vous allez crypter votre phrase"
cle_publique={}
cle_publique['n']=cle[0][0]
cle_publique['e']=cle[0][1]
print "Voici votre clé publique: ",cle_publique
e=cle_publique['e']
n=cle_publique['n']
mot=raw_input("Entrez ce que vous voulez crypter:\n")
print "Cryptage en cours, cela peut prendre du temps ..."
taille_mot=len(mot)
compteur=0
print "Mot crypté: "
while compteur<taille_mot:
	lettre_ascii=ord(mot[compteur])
	lettre_crypte=pow(lettre_ascii,e)%n
	if lettre_ascii>n:
		print "Erreur de calcul, veuillez générer de nouvelles clés"
	print lettre_crypte,
	compteur=compteur+1

print "\n" 

#####################################################Partie decryptage#############################################################################################

print "Decryptage de la phrase"
cle_privee={}
cle_privee['n']=cle[1][0]
cle_privee['d']=cle[1][1]
print "Voici votre clé privée: ",cle_privee
n=cle_privee['n']
d=cle_privee['d']	
 #On récupère le nombre de lettre crypté (soit des bloc de un caractère)
i = raw_input("entrez votre phrase cryptée (block séparé par un espace) :")
compteur=0
while compteur < len(i):
	a=i.split(' ')
	compteur = compteur + 1

str = ""
for z in range(len(a)):
	nombre=int(a[z])

	ascii = (pow(nombre,d)%n)
   	# Avec la fonction chr(ASCII), on trouve le caractère correspondant
	for i in chr(ascii).split(' ') :
		str += i
	
print str	
	

raw_input('\n\nFin\n\n')

Si qqun veut bien m'aider, je suis partant