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))
ENCODING_UTF8 = "utf-8"
ENCODING_ASCII = "ascii"
if __name__ == "__main__":
"""
Programme permettant de résoudre le problème two-time-pad
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)
def get_tmp(a, b):
"""
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)
def g(x, n):
"""
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)
def handle_response(self, server: Server) -> bool: # whether or not it was handled
# switch command
cmd = self.command
try:
cmd_num = int(cmd)
CommandResponse.handle_response(CommandResponse(cmd_num), self, server)
return True
except ValueError:
pass
for c in Command.COMMANDS:
if c.call_safe(self, server): return True
if cmd == 'ping':
server.send_command('PONG')
server.info("pong'd")
elif cmd == 'notice':
server.info('NOTICE: ' + self.content)
elif cmd == 'cap':
server.info('haha cap')
server.send_str('no')
elif cmd == 'privmsg':
server.info(self.content) # todo: parse sources!
else:
server.info('unable to parse %s or command %s'%(self, self.command))
return False
def handle_response(self, response: 'ResponseHandler', server: Server) -> None:
# https://tools.ietf.org/html/rfc2812#section-5
server.info('response gotten: %s'%str(response))
if self.number == 432: # bad nickname
server.info('bad nick!')
elif self.number == 1: # welcome
server.info(response.content)
elif self.number == 2: # another welcome message?
server.info(response.content)
elif self.number == 352: # a general message to be logged
user: str = response.parameters[1]
channel: str = response.parameters[0]
server.info('%s > %s' % (user, response.content))
else:
server.info(response.content)
q,r = divmod(a, b)
a = b
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)
"""
(_,x,_) = XGCD(a,b)
return x
if __name__ == "__main__":
login = sys.argv[1]
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)
tab_to_return.append(t)
return tab_to_return
if __name__ == "__main__":
"""
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:
# -*- 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)
""" (_,x,_) = XGCD(a,b) return x 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)
