ISITDTU CTF - AES_CNV

AES_CNV.py

from hashlib import md5
from base64 import b64decode
from base64 import b64encode
from Crypto.Cipher import AES
from time import ctime
from Secret import __SECRET__
import os

BLOCK_SIZE = 16

pad = lambda s: s + (BLOCK_SIZE - len(s) % BLOCK_SIZE) * \
                chr(BLOCK_SIZE - len(s) % BLOCK_SIZE)
unpad = lambda s: s[:-ord(s[len(s) - 1:])]

def toblock(s):
    rs = []
    for i in range(0, len(s), BLOCK_SIZE):
        rs.append(s[i:i+BLOCK_SIZE])
    return rs

def tostr(src):
    s = ''.join(x for x in src)
    return s
    
def xor(dest, src):
    if len(dest) == 0:
        return src
    elif len(src) == 0:
        return dest
    elif len(dest) >= len(src):
        return ''.join(chr(ord(dest[i])^ord(src[i])) for i in range(len(src)))
    else:
        return ''.join(chr(ord(dest[i])^ord(src[i])) for i in range(len(dest)))


class AES_CNV():
    """
    AES CNV created by chung96vn of AceBear Team
    """
    def __init__(self, key):
        """
        Init object
        """
        assert len(key) == BLOCK_SIZE * 2
        self.key = key

    def encrypt(self, plain_text, iv):
        """
        Encrypt plaint text
        """
        assert len(iv) == 16
        plain_text = pad(plain_text)
        assert len(plain_text)%BLOCK_SIZE == 0
        cipher_text = ''
        aes = AES.new(self.key, AES.MODE_ECB)
        h = iv
        for i in range(len(plain_text)//BLOCK_SIZE):
            block = plain_text[i*16:i*16+16]
            block = xor(block, h)
            cipher_block = aes.encrypt(block)
            cipher_text += cipher_block
            h = md5(cipher_block).digest()
        return b64encode(iv+cipher_text)
        
    def decrypt(self, cipher_text):
        """
        Decrypt cipher text
        """
        cipher_text = b64decode(cipher_text)
        assert len(cipher_text)%BLOCK_SIZE == 0
        iv = cipher_text[:16]
        cipher_text = cipher_text[16:]
        aes = AES.new(self.key, AES.MODE_ECB)
        h = iv
        plain_text = ''
        for i in range(len(cipher_text)//BLOCK_SIZE):
            block = cipher_text[i*16:i*16+16]
            plain_block = aes.decrypt(block)
            plain_block = xor(plain_block, h)
            plain_text += plain_block
            h = md5(block).digest()
        return unpad(plain_text)

        
class Game():
    """
    Game for player
    """
    def __init__(self):
        self.key = os.urandom(BLOCK_SIZE*2)
        self.aes = AES_CNV(self.key)
        self.secret = toblock(pad(__SECRET__))
        
    def encode(self, m):
        m_ar = toblock(pad(m))
        p_ar = []
        for i in range(len(m_ar)):
            p_ar.append(xor(m_ar[i], self.secret[i%len(self.secret)]))
        p = tostr(p_ar)
        return self.aes.encrypt(p, os.urandom(BLOCK_SIZE))
        
    def decode(self, c):
        p = self.aes.decrypt(c)
        p_ar = toblock(p)
        m_ar = []
        for i in range(len(p_ar)):
            m_ar.append(xor(p_ar[i], self.secret[i%len(self.secret)]))
        m = tostr(m_ar)
        return unpad(m)
        

challenge.py

import os
import socket
import threading
import time
import SocketServer
from AES_CNV import Game
from Crypto import Random
from Secret import __FLAG__

host, port = '0.0.0.0', 13337
BUFF_SIZE = 1024

class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    allow_reuse_address = True

class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        self.request.settimeout(10)
        self.game = Game()
        self.request.sendall("******************************************************************\n")
        self.request.sendall("* Challenge created by chung96vn                                 *\n")
        self.request.sendall("* My blog: https://chung96vn.blogspot.com                        *\n")
        self.request.sendall("* From: AceBear Team                                             *\n")
        self.request.sendall("******************************************************************\n\n\n")
        self.request.sendall("Give me content of your request you want to encrypt: ")
        try:
            req = self.request.recv(BUFF_SIZE).strip()
        except:
            self.request.sendall("Error!\n")
            exit()
        if req.startswith("Give me the flag"):
            self.request.sendall("Sorry! We don't support it!\n")
            exit()
        self.request.sendall("Your encypted: ")
        self.request.sendall(self.game.encode(req)+"\n")
        self.request.sendall("Give me encrypted of your request: ")
        enc = self.request.recv(BUFF_SIZE).strip()
        try:
            dec = self.game.decode(enc)
        except:
            self.request.sendall("Error!\n")
            exit()
        self.request.sendall("Your request: %s\n" %dec)
        if dec.startswith("Give me the flag"):
            self.request.sendall("This is flag: %s\n" %__FLAG__)
        self.request.sendall("Bye~~")
                
def main():       
    server = ThreadedTCPServer((host, port), ThreadedTCPRequestHandler)
    server_thread = threading.Thread(target=server.serve_forever)
    server_thread.daemon = True
    server_thread.start()
    print "Server loop running in thread:", server_thread.name
    server_thread.join()

if __name__ == '__main__':
    main()

solve_idiot.py

import socket
from base64 import b64encode, b64decode

input_game = "Give me the fla0"
desire_game = "Give me the flag"

def xor(dest, src):
    if len(dest) == 0:
        return src
    elif len(src) == 0:
        return dest
    elif len(dest) >= len(src):
        return ''.join(chr(ord(dest[i])^ord(src[i])) for i in range(len(src)))
    else:
        return ''.join(chr(ord(dest[i])^ord(src[i])) for i in range(len(dest)))

host = '35.185.111.53'
port = 13337
soc = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
soc.connect((host,port))

soc.recv(1024)
soc.recv(1024)
soc.send(input_game + '\n')
soc.recv(1024)
rep = soc.recv(1024)
cookie = rep.split()[0]

print 'cookie1\t\t', cookie
cookie = b64decode(cookie)
iv = cookie[:16]
iv = xor(iv, input_game)
iv = xor(iv, desire_game)
attack_cookie = iv + cookie[16:]
print 'attack_cookie\t', b64encode(attack_cookie)

soc.send(b64encode(attack_cookie) + '\n')
soc.recv(1024)
rep = soc.recv(1024)
print rep

soc.close()