def envoie_dernier_bloc(login, bloc):
"""
Fonction permettant d'envoyer un bloc (X[0...n]) pour vérification
login : login de l'utilisateur
bloc : bloc envoyé pour vérification (une chaîne de caractères, contenant des octets hexadécimaux)
"""
server = Server(BASE_URL)
msg_a_envoyer = {'value' : bloc}
print(server.query(TP2_URL + login + "/" + SEED_STR, msg_a_envoyer))
def demande_informations(self, message, IV):
"""
Méthode permettant d'envoyer une requête à l'oracle.
Prend en paramètre un message chiffré (en hexadécimal).
"""
server = Server(self.base_url)
#Le message à envoyer sera contenu dans le paramètre 'cyphertext'
msg_a_envoyer = {'ciphertext' : message, 'IV' : IV}
#print("Envoie de la requête à l'oracle...")
return server.query(self.url + self.login, msg_a_envoyer)
def envoie_octet_intermediaire(login, i, byte):
"""
Fonction permettant d'envoyer un octet pour vérification, à la position i (en partant de la fin) d'un bloc X_n du message à déchiffrer
login : login de l'utilisateur)
i : position (en partant de la fin) de l'octet 'byte'
byte : octet envoyé pour vérification (en hexadécimal)
"""
server = Server(BASE_URL)
msg_a_envoyer = {'value' : byte}
print(server.query(TP1_URL + login + "/" + SEED_STR + "/" + str(i), msg_a_envoyer))
def envoie_dernier_octet(login, last_byte):
"""
Fonction permettant d'envoyer le dernier octet trouvé du dernier bloc du message à déchiffrer
login : login de l'utilisateur
last_byte : l'octet trouvé (en hexadécimal)
"""
server = Server(BASE_URL)
#Le message à envoyer sera contenu dans le paramètre 'cyphertext'
msg_a_envoyer = {'value' : last_byte}
print(server.query(TP1_URL + login + "/" + SEED_STR, msg_a_envoyer))
Nécessite en paramètre le login de l'utilisateur
"""
#Login du user
login = sys.argv[1]
#Graine -> nombre aléatoire entier
seed = randint(1, 1000)
server = Server(BASE_URL)
#Développement de l'URL pour CHALLENGE
url_challenge = "{0}{1}/{2}".format(URL_CHALLENGE, login, seed)
#Demande au serveur à l'URL de CHALLENGE
reponse_challenge = server.query(url_challenge)
#On récupère le champ A -> normalement en UTF-8, il faut décoder l'hexadécimal en bytes, puis de bytes en unicode
AxorM = reponse_challenge['A']
#On récupère le champ B -> normalement en ASCII, il faut décoder l'hexadécimal en bytes, puis de bytes en ascii
BxorM = reponse_challenge['B']
#Transformation en bytes pour A et B
AxorM_decode = base64.b16decode(AxorM, casefold=True)
BxorM_decode = base64.b16decode(BxorM, casefold=True)
#Calcul du XOR entre A et B (en bytes) -> élimination du masque M
AxorB = xor(AxorM_decode, BxorM_decode)
length_AxorB = len(AxorB)
Fonction permettant de s'assurer que a est premier avec q
"""
x, _, _ = XGCD(a, b)
return x
if __name__ == "__main__":
#Récupération du login
login = sys.argv[1]
#Récupération des éléments
client = Server(BASE_URL + TP_ACTUEL)
reponse = client.query(GET_PK + login)
p = reponse['p']
q = (p - 1)
g = reponse['g']
h = reponse['h']
#Choix de b et c de façon arbitraire - choix pouvant aller de 1 à q
b = random.randint(1, q)
tmp = 0
"""
Fonction utilisée dans pollard_rho, afin de donner le nouveau résultat concernant x et y
"""
return ((pow(x, 2) + 1) % n)
if __name__ == "__main__":
login = sys.argv[1]
level_spe = sys.argv[2]
class_spe = sys.argv[3]
server = Server(BASE_URL + TP_ACTUEL)
reponse = server.query(GET_PARAM + level_spe + "/" + class_spe)
id = reponse['id']
n = reponse['n']
print("n: {0}".format(n))
fact_tab = []
stack = [n]
while len(stack) != 0:
x = stack.pop(-1)
if isprime(x):
fact_tab.append(x)
b = r
tmp = (u[0] - q*v[0], u[1] - q*v[1])
u = v
v = tmp
return a, u[0], u[1]
def modinv(a, b):
g, x, y = XGCD(a,b)
return x
if __name__ == "__main__" :
print("Programme Elgamal Forgery ...")
server = Server("http://pac.bouillaguet.info/TP4/ElGamal-forgery/")
challenge = server.query("PK/verkyndt")
p = challenge['p']
g = challenge['g']
h = challenge['h']
q = p-1
c = random.randrange(1,p-1)
b = random.randrange(1,p-1)
#c ne doit pas avoir de diviseur commun avec q autre que 1
while(XGCD(c,q)[0]!=1):
print("while")
c = random.randrange(1,p-1)
r = (pow(g,b,p) * pow(h,c,p)) % p
if ("-debug" in sys.argv):
debug_mode = True
else:
debug_mode = False
progressBar = ProgressBar.ProgressBar(100,100,"Progression...")
#Implémentation du serveur
server = Server(BASE_URL)
#Récupération de la PK
if (debug_mode):
print("Récupération de la public key...")
else:
progressBar.update(20)
PK = server.query(GET_PK + login)
p = PK['p']
g = PK['g']
h = PK['h']
q = p - 1
m0 = random.randint(1, 100)
m1 = random.randint(1, 100)
#Récupération de m0
mc0 = server.query(TO_SIGN + login, {'m' : m0})
r, s0 = mc0['signature'][0], mc0['signature'][1]
#Récupération de m1
mc1 = server.query(TO_SIGN + login, {'m' : m1})
_, s1 = mc1['signature'][0], mc1['signature'][1]
Main du programme rand
"""
login = sys.argv[1]
if "-debug" in sys.argv:
debug_mode = True
else:
debug_mode = False
server = Server("http://pac.bouillaguet.info/TP3/rand/")
rand_nbr = Random()
inverse_modulaire = mod_inv(1103515245, 2**32)
IV = server.query('/challenge/' + login)
if debug_mode:
print("IV[0] : {0}".format(IV["IV"][0]))
print("IV[1] : {0}".format(IV["IV"][1]))
#1er envoi
k3_possibles = calculer_next(IV["IV"][0], IV["IV"][1])
if debug_mode:
print("Liste des k3 possibles: ", end = "")
print("{0}".format(k3_possibles))
#Liste des valeurs possibles pour la seed
liste_des_possibles = []
# -*- coding:utf-8 -*-
"""
TP5 PAC - signature de Rabin
"""
from rsa import *
from client import Server
NAME = 'monbailly'
URL = 'http://pac.bouillaguet.info/TP5/Rabin-signature/'
server = Server(URL)
rsa = RSA()
rsa.keyGen()
# ----------------------------------------------------------------------------
# Récupération du challenge
# -------------------------
dic = {'n': rsa.n}
response = server.query('challenge/' + NAME, dic)
print(response)
if __name__ == "__main__":
"""
Programme permettant de valider la partie 'ElGamal' du TP3 de PAC
"""
#Récupération du login de l'utilisateur
login = sys.argv[1]
progressBar = ProgressBar.ProgressBar(100,100,"Progression...")
#Implémentation de l'URL
server = Server(BASE_URL + TP_ACTUEL)
#Récupération d'un dictionnaire contenant 'p' et 'q'
#'p' est un nombre premier, tandis que 'q' est un générateur
reponse_server = server.query(GET_PARAM + login)
progressBar.update(20)
p = reponse_server['p']
g = reponse_server['g']
#Génération d'un nombre aléatoire compris entre 1 et (p-1)
x = random.randint(1, p-1)
#Calcul de la clef publique en calculant g^x
public_key = pow(g, x, p)
challenge_a_envoyer = {'h' : public_key}
reponse_server = server.query(GET_CHALLENGE + login, challenge_a_envoyer)
