Root Me : plateforme d'apprentissage dédiée au Hacking et à la Sécurité de l'Information

NTRU | Multiple Transmission

Vozec — 2024-12-13T15:00:39Z

Vous mettez la main sur un téléphone portable et vous êtes sûr que l'un des contacts a un secret bien gardé.
Le problème est qu'il chiffre ses messages, qu'il considère comme importants. Demandez-lui le drapeau et déchiffrez le, il semblerait qu'il ait fait une erreur d'implémentation...

Sources à télécharger : https://static.root-me.org/cryptanalyse/ch72/ch72.zip

Paramètres de connexion au challenge

Hôte	challenge01.root-me.org
Protocole	TCP
Port	0

- Cryptanalyse

NTRU | Weak Parameter

Vozec — 2024-12-13T15:00:32Z

Une fois de plus, vous accédez à un service de messagerie sécurisé, et l'un des contacts a un secret à vous confier, à vous de lui demander ! Les messages importants sont chiffrés, mais il semble que les paramètres du cryptosystème aient été ... mal choisis.
Exploitez cette mis-configuration pour déchiffrer le secret.

Sources à télécharger : https://static.root-me.org/cryptanalyse/ch71/ch71.zip

Paramètres de connexion au challenge

Hôte	challenge01.root-me.org
Protocole	TCP
Port	0

- Cryptanalyse

Goldreich Goldwasser Halevi | Weak Parameter

Vozec — 2024-12-13T15:00:24Z

On vous fait l'éloge d'un chiffrement qui va révolutionner la cryptographie. Votre collègue vous parle même d'une résistance aux ordinateurs quantiques !
Montrez lui que derrière ces mots savants, subsistent encore des défauts dans sa mise en place.

- Cryptanalyse

ElGamal - Attaque par fautes (Introduction)

Vozec — 2024-12-13T15:00:18Z

Vous faites face à un crypto-système ElGamal avec une possibilité de simuler une injection de faute dans le processus de déchiffrement.
Exploitez cette vulnérabilité pour retrouver les 256 bits de la clé privée.
Vous disposez :
– D'un oracle de chiffrement
– D'un oracle de déchiffrement (avec ou sans faute)

Voici un extrait du code source :

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# File name : challenge.py
# Author : Vozec
# Date created : 4 Avril 2023
from sage.rings.finite_rings.integer_mod import square_root_mod_prime
from random import randint, randrange
from Crypto.Util.number import long_to_bytes,bytes_to_long
import os
flag = os.getenv('flag', 'RM{fakeflag}')
curve = {
'Name':'secp256k1',
'A':0,
'B':7,
'Prime':2^256 - 2^32 - 2^9 - 2^8 - 2^7 - 2^6 - 2^4 - 1,
}
class ElGamal_ECC():
def __init__(self,bits=256):
self.A = curve['A']
self.B = curve['B']
self.p = Zmod(curve['Prime'])
self.E = EllipticCurve(self.p,[self.A,self.B])
self.P = self.E.gens()[0]
self.a = randrange(self.P.additive_order())
self.Q = self.a * self.P
def check_point(self,x,y):
return (self.p(y)^2) == (self.p(x)^3 + self.A*self.p(x) + self.B)
def msg_to_point(self,m):
def compute_y(x):
alpha = self.p(x)^3 + self.A*self.p(x) + self.B
return square_root_mod_prime(self.p(alpha))
m = len(m).to_bytes(1, byteorder="big") + m
while True:
x = int.from_bytes(m, "big")
y = compute_y(x)
if self.check_point(x,y):
return self.E(x,y)
m += os.urandom(1)
def point_to_msg(self,M):
def int_length_in_byte(n: int):
assert n >= 0
length = 0
while n:
n >>= 8
length += 1
return length
try:
x = int(M[0])
byte_len = int_length_in_byte(x)
l = (x >> ((byte_len - 1) * 8)) & 0xff
pt = ((x >> ((byte_len - l - 1) * 8))
& (int.from_bytes(b"\xff" * l, "big")))
return pt.to_bytes(l, byteorder="big")
except:
return b'Fail to recover message from provided point'
def encrypt(self,M):
k = randint(0,curve['Prime'] - 1)
c1 = k * self.P
c2 = k * self.Q + M
return [c1,c2]
def decrypt(self,pair,fault=False):
def inject_fault(a):
# Inject a single bit fault in a random position
return a ^^ (1 << randint(0, int(a).bit_length() - 1))
c1,c2 = pair
a = inject_fault(self.a) if fault else self.a
M = c2 - a * c1
return M
class challenge:
def __init__(self):
print(('''
______ _ _ ______ _ _____ _
| ____| | | | | ____| |/ ____| | |
| |__ __ _ _ _| | |_ _ _ | |__ | | | __ __ _ _ __ ___ __ _| |
| __/ _` | | | | | __| | | | | __| | | | |_ |/ _` | '_ ` _ \\ / _` | |
| | | (_| | |_| | | |_| |_| | | |____| | |__| | (_| | | | | | | (_| | |
|_| \\__,_|\\__,_|_|\\__|\\__, | |______|_|\\_____|\\__,_|_| |_| |_|\\__,_|_|
__/ |
|___/
'''[1:-1]))
print('[+] Initialisation , please wait ...')
self.ECC = ElGamal_ECC()
def menu(self):
print(('''
[+] Menu:
(1) Encrypt message
(2) Decrypt message
(3) Decrypt message with a random single bit fault
(4) Check the secret key
(5) Exit
'''[:-1]))
while 1:
c = input(" $> ")
if c in ['1','2','3','4','5']:
return int(c)
def check(self):
key = input(' Key (int): ').strip()
if not key.isdigit():
print('\n[-] Invalid Key format ')
elif int(key) == self.ECC.a:
print(f'\n[+] Here is your flag: {flag}')
else:
print('\n[-] Invalid Key')
print('[*] Quitting ...')
exit()
def print_curve(self):
print(f'''
Curve Informations:
Name : {curve['Name']}
Prime: {curve['Prime']}
(A,B): ({curve['A']},{curve['B']})
Curve: {self.ECC.E}
''')
def ask_input(self):
try:
ct = input(' Ciphertext [(x1,y1);(x2,y2)]: ')
enc = [tuple([int(_.strip()) for _ in point[1:-1].split(',')])
for point in ct.strip()[1:-1].split(';')]
return enc
except:
print('[-] Invalid Input')
return None
def main(self):
new = True
self.print_curve()
while 1:
choice = self.menu()
# (1) Encrypt point
if choice == 1:
if new:
pt = bytes(input(' Plaintext : '),'utf-8')
M = self.ECC.msg_to_point(pt)
C1,C2 = self.ECC.encrypt(M)
print(' Associed Point: \n\tX=%s\n\tY=%s'%(int(M[0]),int(M[1])))
print(' Encrypted: \n\tC1=%s\n\tC2=%s'%(C1[:2],C2[:2]))
new = False
else:
print('[-] You have already encrypted message')
# (2) Decrypt point
# (3) Decrypt point with a random fault
elif choice in [2,3]:
enc = self.ask_input()
if not enc: break
fault = True if choice == 3 else False
if not self.ECC.check_point(enc[0][0],enc[0][1]):
print(' Invalid Ciphertext ! Point(s) not on the curve.')
break
if not self.ECC.check_point(enc[1][0],enc[1][1]):
print(' Invalid Ciphertext ! Point(s) not on the curve.')
break
dec = self.ECC.decrypt([
self.ECC.E(enc[0][0],enc[0][1]),
self.ECC.E(enc[1][0],enc[1][1]),
],fault=fault)
print(' Associed Point: \n\tX=%s\n\tY=%s'%(int(dec[0]),int(dec[1])))
print(' Decrypted: %s'%(self.ECC.point_to_msg(dec)))
# (4) Check the secret key
elif choice == 4:
self.check()
# (5) Exit
else:
exit()
def test():
ECC = ElGamal_ECC()
m = b'HelloThere :)'
M = ECC.msg_to_point(m)
c1,c2 = ECC.encrypt(M)
assert ECC.check_point(c1.xy()[0], c1.xy()[1])
assert ECC.check_point(c2.xy()[0], c2.xy()[1])
dec = ECC.decrypt([
ECC.E(c1.xy()[0], c1.xy()[1]),
ECC.E(c2.xy()[0], c2.xy()[1]),
],fault=False)
m_dec = ECC.point_to_msg(dec)
assert m == m_dec
if __name__ == '__main__':
# test()
challenge().main()

Télécharger

Paramètres de connexion au challenge

Hôte	challenge01.root-me.org
Protocole	TCP
Port	0

- Cryptanalyse

DSA - Erreur d'implémentation

Vozec — 2024-12-13T15:00:10Z

Vous êtes engagé pour tester la sécurité cryptographique d'une implémentation du célèbre système DSA.
A vous de jouer !

from Crypto.Util.number import isPrime, getPrime
from os import getenv
from hashlib import sha1
from random import randint
# https://fr.wikipedia.org/wiki/Digital_Signature_Algorithm
class DSA:
def __init__(self, L=1024, N=256):
self.L = L
self.N = N
self.p, self.q, self.g = self.gen_params()
self.x = randint(1, self.q)
self.y = pow(self.g, self.x, self.p)
def gen_params(self):
q = getPrime(self.L)
while 1:
p = q*2*randint(1, 2**self.N) + 1
if isPrime(p):
break
while 1:
h = randint(1, p-1)
g = pow(h, (p-1)//q, p)
if g > 1:
break
return (p, q, g)
def H(self, message):
return int.from_bytes(sha1(message.encode()).digest(), 'big')
def sign(self, message):
Hm = self.H(message)
while True:
s = randint(1, self.q - 1)
s1 = pow(self.g, s, self.p) % self.q
if s1 == 0:
continue
s_inv = modinv(s, self.q)
s2 = ((Hm + s1 * self.x) * s_inv) % self.q
if s2 == 0:
continue
break
return f'{s1}:{s2}'
def verify(self, message, signature):
try:
s1, s2 = map(int,signature.split(':'))
Hm = self.H(message)
if not (0 < s1 < self.q or 0 < s2 < self.q):
return False
w = modinv(s2, self.q)
u1 = (Hm * w) % self.q
u2 = (s1 * w) % self.q
v = (pow(self.g, u1, self.p) * pow(self.y, u2, self.p) % self.p) % self.q
return v == s1
except:
return False
def egcd(a, b):
if a == 0:
return (b, 0, 1)
g, y, x = egcd(b%a,a)
return (g, x - (b//a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
print('Modular inverse does not exist')
return False
return x%m
def main():
dsa = DSA()
target = 'Can I have The Flag please'
flag = getenv('FLAG', "RM{REDACTED}")
print("Here is the public key:")
print(f"\t- p = {dsa.p}")
print(f"\t- q = {dsa.q}")
print(f"\t- g = {dsa.g}")
print(f"\t- y = {dsa.y}")
while True:
print("\nMenu:")
print("1. Sign a message")
print("2. Verify a message")
print("3. Get the flag")
print("4. Quit")
choice = input("Choose an option: ")
if choice == "1":
message = input("Enter the message to sign: ").strip()
if message == target:
print('Forbidden message !')
continue
print(f"sig = {dsa.sign(message)}")
elif choice == "2":
message = input("Enter the message to verify: ")
signature = input("Enter the signature associed: ")
if dsa.verify(message, signature):
print("The signature is valid.")
else:
print("The signature is invalid.")
elif choice == "3":
signature = input("Enter the secret signature: ")
if dsa.verify(target, signature):
print(f"Well played, here is the flag: {flag}")
else:
print("The signature is invalid, get out !")
break
elif choice == "4":
print("Quitting the program.")
break
else:
print("Invalid choice. Please select a valid option.")
if __name__ == "__main__":
main()

Télécharger

Paramètres de connexion au challenge

Hôte	challenge01.root-me.org
Protocole	TCP
Port	0

- Cryptanalyse

Fichier - PKZIP 2

kevin.mille — 2024-11-08T11:00:11Z

Mon ami m'a envoyé sa collection de photos de chats, mais a oublié de me transmettre le mot de passe de l'archive ZIP.
Récupérez les photos malgré tout, et vous obtiendrez le flag en récompense.

- Cryptanalyse

AES - ECB - Copy Paste

Vozec — 2024-02-05T11:33:20Z

Ce panel de connexion utilise le chiffrement AES en mode ECB pour générer ses tokens d'authentifications. A vous de découvrir comment contourner ce login et accéder au secret de l'utilisateur admin

Extrait du code

def login(self):
token = input('Token:\n> ').strip().encode()
try:
data = json.loads(unpad(self.aes.decrypt(unhexlify(token)),16).decode())
if data['username'] not in users:
return '[-] Unknow user'
if data['username'] == "admin" and data["isAdmin"]:
return '[+] Hello admin , here is your secret : %s'%flag
return "[+] Hello %s , you don't have any secret in our database"%data['username']
except:
return '[-] Invalid token !'
def register(self):
user = input('Username:\n> ').strip()
if user in users:
return '[-] User already exists'
data = b'{"username": "%s", "isAdmin": false}' %(user.encode())
token = hexlify(self.aes.encrypt(pad(data, 16))).decode()
users.append(user)
return '[+] You can use this token to access your account : %s' %token

Télécharger

Paramètres de connexion au challenge

Hôte	challenge01.root-me.org
Protocole	TCP
Port	0

- Cryptanalyse

Shamir Secret Sharing - Introduction

Vozec — 2024-02-05T11:33:12Z

Vous vous retrouvez en possession de paires de nombres et votre collègue, d'un coup d'œil, vous assure que vous avez tout ce qu'il faut pour déchiffrer le message.

- Cryptanalyse

Shamir Secret Sharing - Irreductible ?

Mr7F — 2024-02-05T11:33:04Z

Il semblerait que cette fois-ci le système ait été renforcé. Et votre ami est encore absent.

Code source

import os
import random
from Crypto.Util.number import bytes_to_long, getPrime
DEGREE = 10
BITSIZE = 64
SECRET = None
def get_coeff(p):
while True:
# os.urandom is safer than random.randint, nothing fishy here
coeff = bytes_to_long(os.urandom(BITSIZE // 16).hex().upper().encode())
if BITSIZE - 1 <= coeff.bit_length() and coeff < p:
# if the coefficients are not small LLL won't work, I'm sure
return coeff
def generate_points(modulus = 0):
global SECRET
coefficients = [get_coeff(modulus) for _ in range(DEGREE + 1)]
SECRET = coefficients[0]
def _eval(x):
return x, sum(c * x ** d for d, c in enumerate(coefficients)) % modulus
return [_eval(random.randint(0, modulus - 1)) for _ in range(DEGREE + 1)]
p = getPrime(BITSIZE)
points = generate_points(modulus=p)
points = points[1:]
print("One of our friends is gone, is our secret lost ?")
print("p = ", p)
print("points = ", points)
assert int(input("What's our secret ? ")) == SECRET, "We lost it"
with open(".passwd") as file:
print(file.read())

Télécharger

Paramètres de connexion au challenge

Hôte	challenge01.root-me.org
Protocole	TCP
Port	0

- Cryptanalyse

Shamir Secret Sharing - Reduction

Vozec — 2024-02-05T11:32:55Z

Deux amis ont disparu et vous n'arrivez pas à déchiffrer le message secret ! Utilisez vos compétences en mathématiques pour trouver le message !

- Cryptanalyse