# TimisoaraCTF Finals 2018 Crypto Write ups

## Write-up for tasks Recap(250p) and Recess(400p)

This was a 2 in one problem. We were given a copy of the code that was running on a server in which the flags were in some files flag1, respectively flag2:

```
import signal
import sys
import os
import binascii
import random
os.chdir(os.path.dirname(os.path.abspath(__file__)))
MAGIC_NUMBER = 11
MSG_LENGTH = 119
CERT_CNT = MAGIC_NUMBER
coeffs = [random.randint(0, MAGIC_NUMBER**128) for i in range(MAGIC_NUMBER)]
def enc_func(msg):
global coeffs
msg = msg * 0x100 + 0xFF
acc = 0
cur = 1
for coeff in coeffs:
acc = (acc + coeff * cur) % (MAGIC_NUMBER**128)
cur = (cur * msg) % (MAGIC_NUMBER**128)
return acc % (MAGIC_NUMBER**128)
def get_hex_msg():
try:
msg = raw_input()
msg = int(msg,16)
return msg % (MAGIC_NUMBER ** (128) )
except:
print "Bad input"
exit()
def encryption():
print 'Input your message:'
msg = get_hex_msg()
ct = enc_func( msg )
print "Encryption >>>> %#x" % ct
def challenge1():
for i in range(CERT_CNT):
msg = random.randint(0, MAGIC_NUMBER**(MSG_LENGTH) )
ct = enc_func( msg )
print 'Encrypt this: %#x' % msg
ct2 = get_hex_msg()
if ct != ct2:
print "Your input %#x should have been %#x" % (ct2, ct)
exit()
print "You win challenge 1"
print open("flag1").read()
def challenge2():
for i in range(CERT_CNT):
msg = random.randint(0, MAGIC_NUMBER**(MSG_LENGTH))
ct = enc_func( msg )
print 'Decrypt this: %#x' % (ct)
msg2 = get_hex_msg()
if enc_func(msg) != enc_func(msg2):
print "Your input %#x should have been %#x" % (msg2, msg)
exit()
print "You win challenge 2"
print open("flag2").read()
def input_int(prompt):
sys.stdout.write(prompt)
try:
n = int(raw_input())
return n
except ValueError:
return 0
except:
exit()
def menu():
while True:
print "Horrible Crypto"
print "1. Arbitrary Encryption"
print "2. Encryption Challenge"
print "3. Decryption Challenge"
print "4. Exit"
choice = input_int("Command: ")
{
1: encryption,
2: challenge1,
3: challenge2,
4: exit,
}.get(choice, lambda *args:1)()
if __name__ == "__main__":
signal.alarm(15)
a menu()
```

Ok, so let’s analyse what we are given and what we have to do:

Running the code we can see a menu:

Horrible Crypto

- Arbitrary Encryption
- Encryption Challenge
- Decryption Challenge
- Exit

So, we are given an encryption oracle and two challanges, encryption (**task recap**) and decryption (**task recess**)

### Understanding the encryption

Let’s start with the encryption:

```
def enc_func(msg):
global coeffs
msg = msg * 0x100 + 0xFF
acc = 0
cur = 1
for coeff in coeffs:
acc = (acc + coeff * cur) % (MAGIC_NUMBER**128)
cur = (cur * msg) % (MAGIC_NUMBER**128)
return acc % (MAGIC_NUMBER**128)
def get_hex_msg():
try:
msg = raw_input()
msg = int(msg,16)
return msg % (MAGIC_NUMBER ** (128) )
except:
print "Bad input"
exit()
def encryption():
print 'Input your message:'
msg = get_hex_msg()
ct = enc_func( msg )
print "Encryption >>>> %#x" % ct
```

Inside `encryption()`

the input is a hex number which gets decoded to an int and then actually encrypted in `enc_func(msg)`

.

Now, let’s focus on how the encryption works:

It takes the message, it multiplies it by 256, adds 255 `msg = msg * 0x100 + 0xFF`

and then computes the polynomial `coeffs(msg)`

modulo 11^{128} (`MAGIC_NUMBER = 11`

is a constant), and that’s our ciphertext.

### Task Recap

Recap was the first challenge. The adversary is given 11 messages to encrypt. By successfully encrypting the messages, the flag is given to the adversary.

```
def challenge1():
for i in range(CERT_CNT):
msg = random.randint(0, MAGIC_NUMBER**(MSG_LENGTH) )
ct = enc_func( msg )
print 'Encrypt this: %#x' % msg
ct2 = get_hex_msg()
if ct != ct2:
print "Your input %#x should have been %#x" % (ct2, ct)
exit()
print "You win challenge 1"
print open("flag1").read()
```

So basically we need to find the coefficients of the polynomial **coeffs** in order to be able to encrypt. Note that we have an encryption oracle so practically we can find any coefficient of the polynomial **coeffs** right? Well, that’s great because we can recreate the original polynomial by creating a **Lagrange polynomial** of degree equal to the degree of the polynomial **coeffs**.

You can read more about it on Wikipedia, the math is pretty simple, and there’s an image that visually describes very well the algorithm.
**NOTE**: since the contest’s servers don’t work anymore you will have to run the challange code locally.

### Task Recess

Now, the second task was the **real deal**. The adversary has to decrypt 11 messages. I didn’t solve this task during the contest (I solved it about 4 hours after the contest ended, but I still got goosebumbs when I got the flag). About 3 hours before the end of the contest a hint was added (sadly, i don’t remember the exact form of the hint), and eventually I found an article on Wikipedia and a bit of code on GitHub. After a good 30 minutes of reading I implemented the solution, practically for a message **msg** we had to find a root of the polynomial `f(x)=coeffs(x)-msg`

. The mistake I made was that I didn’t realize what this line of code was doing:

```
msg = msg * 0x100 + 0xFF
```

This makes it so that the encription is a bit more complicated, encription isn’t just **coeffs(msg)**, it’s **coeffs(g(msg))**, where **g** is another ploynomial: `g(x) = 256*x+255`

. That means that Hensel’s lemma had to be applied to the polynomial **coeffs(g(x))**. So I wrote a funtion that composes two polynomials.

### The code

Here’s my solution to both problems:

```
from pwn import *
from Crypto.Util.number import inverse
MOD=11**128
def transform(x):
return (x*256+255)%MOD
#Polynomial part
class Polynomial(list):
def __init__(self,coeffs):
self.coeffs = coeffs
def evaluate(self,x,mod):
val = 0
for i in range(len(self.coeffs)):
val = (val + x**i * self.coeffs[i]) % mod
return val
def raise_degree(self,x):
coeffs=[]
for i in range(x):
coeffs.append(0)
for i in range(len(self.coeffs)):
coeffs.append(self.coeffs[i])
self.coeffs=coeffs
def add_to_degree(self,x,y):
while(len(self.coeffs)<=x):
self.coeffs.append(0)
self.coeffs[x]=(self.coeffs[x]+y)%MOD
def add_poly(self,x):
while(len(self.coeffs)<len(x.coeffs)):
self.coeffs.append(0)
for i in range(len(x.coeffs)):
self.coeffs[i]=(self.coeffs[i]+x.coeffs[i])%MOD
def multiply(self,x):
for i in range(len(self.coeffs)):
self.coeffs[i]=(self.coeffs[i] * x)%MOD
def multiply_with_poly(self,p):
coeffs=Polynomial([])
for i in range(len(self.coeffs)):
q=Polynomial(p.coeffs)
q.raise_degree(i)
q.multiply(self.coeffs[i])
coeffs.add_poly(q)
self.coeffs=coeffs.coeffs
def calculate_derivative(self):
p=Polynomial([])
for i in range(1,len(self.coeffs)):
p.coeffs.append((self.coeffs[i]*i)%MOD)
return p
def compose(self,p):
P=Polynomial([])
q=Polynomial([1])
for i in range(len(self.coeffs)):
q2=Polynomial(q.coeffs)
q2.multiply(self.coeffs[i])
P.add_poly(q2)
q.multiply_with_poly(p)
self.coeffs=P.coeffs
def print_poly(self):
return self.coeffs
#Lagrange Interpolation part
def Lagrange_Basis_Polynomial(xlist,index):
l=Polynomial([1])
for i in range(len(xlist)):
if(i==index):
continue
p=Polynomial([(MOD-xlist[i])%MOD,1])
p.multiply(inverse((MOD+xlist[index]-xlist[i])%MOD,MOD))
l.multiply_with_poly(p)
return l
def Lagrange_Polynomial(xylist):
xlist=[]
ylist=[]
L=Polynomial([])
for a in xylist:
xlist.append(a[0])
ylist.append(a[1])
for i in range(len(ylist)):
l=Lagrange_Basis_Polynomial(xlist,i)
l.multiply(ylist[i])
L.add_poly(l)
return L
#Hensel's Lemma part
def Hensel(f,d,p,k):
if k==1:
r=[]
for i in range(p):
if(f.evaluate(i,p)==0):
r.append(i)
return r
r=Hensel(f,d,p,k-1)
new=[]
for i,n in enumerate(r):
dr=d.evaluate(n,p)
fr=f.evaluate(n,p**k)
if dr!=0:
for t in range(p):
if(f.evaluate(r[i]+t*p**(k-1),p**k)==0):
new.append(r[i]+t*p**(k-1))
break
if dr==0:
if fr%p**k==0:
for t in range(p):
new.append(r[i]+t*p**(k-1))
return new
#Main part
xylist=[]
s=remote('localhost',1337)
for i in range(11):
s.recvuntil('Command: ')
s.sendline('1')
s.recvuntil('Input your message:')
s.sendline(hex(i)[2:])
s.recvline()
x=s.recvline()[18:][:-1]
x=int(x,16)
xylist.append((transform(i),x))
print "Values of the polynomial:"
for x in xylist:
print 'f('+str(x[0])+') = '+str(x[1])
coeffs=Lagrange_Polynomial(xylist)
print "\nReconstructed polynomial"
for i,x in zip([i for i in range(11)],coeffs.print_poly()):
print str(i)+':',x
print '\nStarting challenge 1!'
s.recvuntil('Command: ')
s.sendline('2')
for i in range(11):
s.recvuntil('Encrypt this: ')
x=int(s.recvline()[2:],16)
s.sendline(str(hex(coeffs.evaluate(transform(x),MOD))[2:]))
print 'step',i+1,'done'
print '\n'+s.recvline()
print s.recvline()
print '\nComposed polynomial'
f=Polynomial(coeffs.coeffs)
g=Polynomial([255,256])
f.compose(g)
for i,x in zip([i for i in range(11)],coeffs.print_poly()):
print str(i)+':',x
print '\nStarting challenge 2!'
s.recvuntil('Command: ')
s.sendline('3')
for i in range(11):
s.recvuntil('Decrypt this: ')
x=int(s.recvline()[2:],16)
print x
f=Polynomial(coeffs.coeffs)
g=Polynomial([255,256])
f.compose(g)
h=Polynomial(f.coeffs)
h.add_to_degree(0,-x)
d=f.calculate_derivative()
out=Hensel(h,d,11,128)
print coeffs.evaluate(transform(out[0]),MOD)
s.sendline(hex(out[0])[2:])
print 'step',i+1,'done'
print '\n'+s.recvline()
print s.recvline()
```