import json
import requests
from Crypto.Cipher import AES

BLOCK_SIZE = 16

def ECBorCBC(text):
    text = str(text)[2:-1]
    for _ in range(len(text)):
        if text.count(text[int(len(text)/2) : int(len(text)/2) + BLOCK_SIZE]) > 1:
            return 'ECB'
        else:
            return 'CBC'

def get(url):
    return requests.get(url, headers={'Content-Type': 'application/json', 'charset': 'utf-8'})

def post(url, text):
    return requests.post(url, data = json.dumps(text), headers = {'Content-Type': 'application/json', 'charset':'utf-8'})

def get_data(data, number):
    return b64decode(post(URL + str(number) + '/noentropy', str(b64encode(data))[2:-1]))

def get_random_padding(encr_data, encr_data_2):
    for i in range(len(encr_data)):
        if encr_data[i] != encr_data_2[i]:
            return i

def get_addition(number, padding):
    initial_addition = 256
    control_addition = 256
    size = padding + BLOCK_SIZE
    for i in range(BLOCK_SIZE + 2):
        encr_data = get_data(b'\x00'*(BLOCK_SIZE + i), number)
        if initial_addition != encr_data[size]:
            initial_addition = encr_data[size]
            control_addition = encr_data[size + 1]
        else:
            if control_addition != encr_data[size + 1]:
                control_addition = encr_data[size + 1]
            else:
                return i - 1
    return 0

from base64 import b64encode, b64decode

CHALLENGES_ID = 15
COUNT_BYTES = 2048
VALUES_SIZE = 256
URL = 'http://192.168.56.103/api/EcbDecryption/Chumak/'

for number in range(1, CHALLENGES_ID + 1):



    encr_data = get_data(b'\x00' * COUNT_BYTES, number)
    encr_data_2 = get_data(b'\x01' * COUNT_BYTES, number)

    if ECBorCBC(encr_data) == 'ECB':
        verify_data = get(URL + str(number) + '/verify')
        random_padding = get_random_padding(encr_data, encr_data_2)
        addition = get_addition(number, random_padding)

        target_data = b''
        target_data_len = len(encr_data) - (random_padding + COUNT_BYTES)
        sent_data = b'\x00' * (2 * BLOCK_SIZE + target_data_len + addition)

        for ind in range(target_data_len):
            encr_data = get_data(sent_data[:-ind-1], number)
            sent_data = sent_data[1:len(sent_data)] + bytes([0])
            for v in range(0, VALUES_SIZE):
                sent_data = sent_data[0:len(sent_data)-1] + bytes([v])
                encr_data_2 = get_data(sent_data, number)
                size = random_padding + len(sent_data) + BLOCK_SIZE - addition

                if encr_data[:size] == encr_data_2[:size]:
                    target_data += bytes([v])
                    break

            if len(target_data)%10 == 0:
                print('Addition: ', addition)
                print('Target data: ', target_data)
                target_data = b64decode(verify_data.text)
                print('The first bytes of verify data: ', target_data[:BLOCK_SIZE])
                break
    else:
        print('There is not ECB chiper')