6kittylog

#include <iostream>
#include <random>

using namespace std;

int main() {
    
    unsigned char target[63] = { 0x33, 0x84, 0x3d, 0x3f, 0x2a, 0x93, 0x7b, 0x82, 0x1a, 0xac, 0x8e,
                      0xf4, 0xb1, 0xcb, 0x8d, 0x21, 0x0e, 0xb7, 0x67, 0x96, 0x2c,
                      0x81, 0xd3, 0xbc, 0x29, 0x6c, 0x4b, 0x0d, 0x00, 0xed, 0xfd,
                      0xee, 0x56, 0x40, 0x52, 0xd5, 0x05, 0x6d, 0x90, 0x3e, 0x7a, 0x1b,
                      0x69, 0x23, 0x1f, 0xb6, 0x1d, 0xbc, 0x98, 0xd1, 0xa6, 0x83,
                      0xe9, 0xeb, 0x13, 0x21, 0x3d, 0xf8, 0x2b, 0x79, 0x53, 0x4f, 0xa1 };

    unsigned long long seedst = 0;
    unsigned long long seeden = 256;
    bool found = true;
    unsigned long long seed;
    char s[64] = { 0, };

    for (unsigned long long i = seedst; i <= seeden; ++i) {
        seed = i;
        srand(i);

        for (int j = 0; j < 63; ++j) {
            int randd = rand() % 256;
            s[j] = randd ^ target[j];

            if (s[j] < 32 || s[j] > 126) {
                found = false;
                break;
            }
        }
    }
    if (found) {
        cout << "seed:" << seed << ", string:" << s;
    }
    else
        cout << "NOT FOUND";

    return 0;
}

#예제에서 쓰인 블록 암호 모드는 ECB, 해당 부분 설명으로 아래서... 
import string
import random
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad

#암호화 
def aes_encrypt(key, plaintext):
    cipher = AES.new(key, AES.MODE_ECB)
    ciphertext = cipher.encrypt(pad(plaintext.encode('utf-8'), AES.block_size)) #AES 사이즈 지정 
    return ciphertext

#복호화 
def aes_decrypt(key, ciphertext):
    cipher = AES.new(key, AES.MODE_ECB) #이때 key는 대칭키 
    decrypted_data = unpad(cipher.decrypt(ciphertext), AES.block_size)
    return decrypted_data.decode('utf-8')

from Crypto.Cipher import DES
from Crypto.Hash import SHA256 as SHA

class myDES():

    # DES 초기화
    def __init__(self, keytext, ivtext):
        hash = SHA.new()
        hash.update(keytext.encode('utf-8'))
        # keytext를 해시화했을 때 첫 8byte를 key로 함
        key = hash.digest()
        self.key = key[:8]

        hash.update(ivtext.encode('utf-8'))
        iv = hash.digest()
        # ivtext를 해시화했을때 첫 8byte를 iv로 함
        # iv는 CBC 모드 운영을 위한 초기화벡터를 말함 
        self.iv = iv[:8]

    # ECB 모드로 암호화
    def encrypt_ECB(self, plaintext):
        # 항상 8byte 단위로 끊어서 암호화하기 때문에 평문이 8byte로 끊기지 않는다면 
        # padding값을 추가해 8byte로 만들어줌
        while(len(plaintext) % 8 != 0):
            plaintext += ' '
        des = DES.new(self.key, DES.MODE_ECB)
        encryptMsg = des.encrypt(plaintext.encode())
        return encryptMsg

    # ECB 모드로 암호화된 암호문을 복호화
    def decrypt_ECB(self, ciphertext):
        des = DES.new(self.key, DES.MODE_ECB)
        descryptMsg = des.decrypt(ciphertext)
        return descryptMsg

    # CBC 모드로 암호화
    def encrypt_CBC(self, plaintext):
        while(len(plaintext) % 8 != 0):
            plaintext += ' '

        # CBC 모드에서는 iv(초기화 벡터) 값이 필요
        des = DES.new(self.key, DES.MODE_CBC, self.iv)
        encryptMsg = des.encrypt(plaintext.encode())
        return encryptMsg

    # CBC 모드로 암호화된 암호문을 복호화
    def decrypt_CBC(self, ciphertext):
        des = DES.new(self.key, DES.MODE_CBC, self.iv)
        descryptMsg = des.decrypt(ciphertext)
        return descryptMsg

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP

def generate_keys():
    key = RSA.generate(2048)
    # 개인키 생성 
    private_key = key.export_key()
    # 공개키 생성, 이때 서로 소수 
    public_key = key.publickey().export_key()
    return private_key, public_key

# 암호화 
def encrypt_message(public_key, message):
    rsa_key = RSA.import_key(public_key)
    # OAEP는 RSA와 함께 사용되는 Padding 
    cipher = PKCS1_OAEP.new(rsa_key)
    encrypted_message = cipher.encrypt(message.encode())
    return encrypted_message

# 복호화 
def decrypt_message(private_key, encrypted_message):
    # key import(개인키) 
    rsa_key = RSA.import_key(private_key)
    cipher = PKCS1_OAEP.new(rsa_key)
    decrypted_message = cipher.decrypt(encrypted_message).decode()
    return decrypted_message

import hashlib #이전 암호 라이브러리와 다르다 

# SHA-256 해시 객체 생성
hash_object = hashlib.sha256()

# 데이터 업데이트
hash_object.update(data.encode())

# 해시 값 추출
hash_value = hash_object.hexdigest()

import hashlib

result = hashlib.md5(data.encode()).hexdigest()

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad

KEY = ?
FLAG = ?

@chal.route('/ecb_oracle/encrypt/<plaintext>/')
def encrypt(plaintext):
    plaintext = bytes.fromhex(plaintext)

    padded = pad(plaintext + FLAG.encode(), 16)
    cipher = AES.new(KEY, AES.MODE_ECB)
    try:
        encrypted = cipher.encrypt(padded)
    except ValueError as e:
        return {"error": str(e)}

    return {"ciphertext": encrypted.hex()}

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
import time
import requests

#ciphertext를 받아온다. 
def get_cipher(plaintext):
    chellenge_site = 'https://aes.cryptohack.org/ecb_oracle/encrypt/' + plaintext.hex() + '/'
    r = requests.get(chellenge_site)
    ciphertext = r.json()
    return bytes.fromhex(ciphertext['ciphertext'])

flag=b''

#range 범위 설정에 대해서는 후술... 
for i in range(0, 32):
    plaintext = b'\x61' * (31 - i)  #\x61을 31-i만큼 채운다 
    ciphertext = get_cipher(plaintext)[:32]  #보내고 ascii 하나씩 대입해서 비교 
    plaintext += flag  #찾아둔 flag들 더해야 함 
    print("try %d" % (i+1))
    
    #ascii 브루트포스 for문 
    for j in range(33, 127):
        plaintext = plaintext[:31]
        plaintext += j.to_bytes(1, byteorder='big')

        wr_ci = get_cipher(plaintext)[:32]
        #같다면 
        if (wr_ci == ciphertext):
            flag += j.to_bytes(1, byteorder='big')
            print(flag)
            break
        time.sleep(1)