DDCTF2020官方Write Up——MISC 篇

import cv2

import numpy as np

import os

from match import d_score

import pickle

path = 'picture'

dirs = os.listdir(path)

sort_imgs=[]

original_img_len=2160

imgs=[]

match_list=[]

original_img=cv2.imread("demo.jpg")



print(original_img.shape)



for file in dirs:

    img=cv2.imread('picture/'+file)

    imgs.append(img)



print("ok")

leng = 27

high = 51



current_len=0

current_high=0

imgg=img = np.zeros((27,51,3), np.uint8)

for kkk in range(len(imgs)):

    match_list.clear()

    for i in range(len(imgs)):

        img = imgs[i]

        img2=original_img[current_len:current_len+leng,current_high:current_high+high]

        rate=d_score(img,img2)

        match_list.append(rate)



    current_len = current_len + leng

    if (current_len == original_img_len):

        current_len = 0

        current_high = current_high + 51



    max=0

    max_id=0

    for i in range(len(match_list)):

        if (match_list[i]>=max):

            max=match_list[i]

            max_id=i

    print(dirs[max_id],max,len(match_list))

    sort_imgs.append(dirs[max_id])

    del imgs[max_id]

    del dirs[max_id]


print(sort_imgs)

obj=open("list","wb")

pickle.dump(sort_imgs,obj)

import cv2

import numpy as np

from PIL import Image

from io import BytesIO

import matplotlib


matplotlib.use('TkAgg')

import matplotlib.pyplot as plt


def aHash(img):

    # 均值哈希算法

    # 缩放为8*8

    img = cv2.resize(img, (8, 8))

    # 转换为灰度图

    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # s为像素和初值为0，hash_str为hash值初值为''

    s = 0

    hash_str = ''

    # 遍历累加求像素和

    for i in range(8):

        for j in range(8):

            s = s + gray[i, j]

    # 求平均灰度

    avg = s / 64

    # 灰度大于平均值为1相反为0生成图片的hash值

    for i in range(8):

        for j in range(8):

            if gray[i, j] > avg:

                hash_str = hash_str + '1'

            else:

                hash_str = hash_str + '0'

    return hash_str

def dHash(img):

    # 差值哈希算法

    # 缩放8*8

    img = cv2.resize(img, (9, 8))

    # 转换灰度图

    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    hash_str = ''

    # 每行前一个像素大于后一个像素为1，相反为0，生成哈希

    for i in range(8):

        for j in range(8):

            if gray[i, j] > gray[i, j + 1]:

                hash_str = hash_str + '1'

            else:

                hash_str = hash_str + '0'

    return hash_str

def pHash(img):

    # 感知哈希算法

    # 缩放32*32

    img = cv2.resize(img, (32, 32))  # , interpolation=cv2.INTER_CUBIC



    # 转换为灰度图

    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # 将灰度图转为浮点型，再进行dct变换

    dct = cv2.dct(np.float32(gray))

    # opencv实现的掩码操作

    dct_roi = dct[0:8, 0:8]



    hash = []

    avreage = np.mean(dct_roi)

    for i in range(dct_roi.shape[0]):

        for j in range(dct_roi.shape[1]):

            if dct_roi[i, j] > avreage:

                hash.append(1)

            else:

                hash.append(0)

    return hash


def calculate(image1, image2):

    # 灰度直方图算法

    # 计算单通道的直方图的相似值

    hist1 = cv2.calcHist([image1], [0], None, [256], [0.0, 255.0])

    hist2 = cv2.calcHist([image2], [0], None, [256], [0.0, 255.0])

    # 计算直方图的重合度

    degree = 0

    for i in range(len(hist1)):

        if hist1[i] != hist2[i]:

            degree = degree + 

                     (1 - abs(hist1[i] - hist2[i]) / max(hist1[i], hist2[i]))

        else:

            degree = degree + 1

    degree = degree / len(hist1)

    return degree


def classify_hist_with_split(image1, image2, size=(256, 256)):

    # RGB每个通道的直方图相似度

    # 将图像resize后，分离为RGB三个通道，再计算每个通道的相似值

    image1 = cv2.resize(image1, size)

    image2 = cv2.resize(image2, size)

    sub_image1 = cv2.split(image1)

    sub_image2 = cv2.split(image2)

    sub_data = 0

    for im1, im2 in zip(sub_image1, sub_image2):

        sub_data += calculate(im1, im2)

    sub_data = sub_data / 3

    return sub_data


def cmpHash(hash1, hash2):

    # Hash值对比

    # 算法中1和0顺序组合起来的即是图片的指纹hash。顺序不固定，但是比较的时候必须是相同的顺序。

    # 对比两幅图的指纹，计算汉明距离，即两个64位的hash值有多少是不一样的，不同的位数越小，图片越相似

    # 汉明距离：一组二进制数据变成另一组数据所需要的步骤，可以衡量两图的差异，汉明距离越小，则相似度越高。汉明距离为0，即两张图片完全一样

    n = 0

    # hash长度不同则返回-1代表传参出错

    if len(hash1) != len(hash2):

        return -1

    # 遍历判断

    for i in range(len(hash1)):

        # 不相等则n计数+1，n最终为相似度

        if hash1[i] != hash2[i]:

            n = n + 1

    return n


def getImageByUrl(url):

    # 根据图片url 获取图片对象

    html = requests.get(url, verify=False)

    image = Image.open(BytesIO(html.content))

    return image


def PILImageToCV():

    # PIL Image转换成OpenCV格式

    path = "/Users/waldenz/Documents/Work/doc/TestImages/t3.png"

    img = Image.open(path)

    plt.subplot(121)

    plt.imshow(img)

    print(isinstance(img, np.ndarray))

    img = cv2.cvtColor(np.asarray(img), cv2.COLOR_RGB2BGR)

    print(isinstance(img, np.ndarray))

    plt.subplot(122)

    plt.imshow(img)

    plt.show()


def CVImageToPIL():

    # OpenCV图片转换为PIL image

    path = "/Users/waldenz/Documents/Work/doc/TestImages/t3.png"

    img = cv2.imread(path)

    # cv2.imshow("OpenCV",img)

    plt.subplot(121)

    plt.imshow(img)



    img2 = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))

    plt.subplot(122)

    plt.imshow(img2)

    plt.show()


def bytes_to_cvimage(filebytes):

    # 图片字节流转换为cv image

    image = Image.open(filebytes)

    img = cv2.cvtColor(np.asarray(image), cv2.COLOR_RGB2BGR)

    return img



def hammingDist(s1, s2):

    assert len(s1) == len(s2)

    return sum([ch1 != ch2 for ch1, ch2 in zip(s1, s2)])



def d_score(img1,img2):

    dhash_str1 = dHash(img1)

    dhash_str2 = dHash(img2)

    d_scores = 1 - hammingDist(dhash_str1, dhash_str2) * 1. / (32 * 32 / 4)

    return d_scores



def runAllImageSimilaryFun(img1, img2):

    n4 = classify_hist_with_split(img1, img2)

    print('三直方图算法相似度：', n4)

NUM_BITS = 12

BLOCK_SIZE_BITS = 48

BLOCK_SIZE = BLOCK_SIZE_BITS // 8

MAX_VALUE = (2 << (NUM_BITS - 1))

BIT_MASK = MAX_VALUE - 1



class Cipher(object):

    def __init__(self, k0, k1, k2, k3, k4):

        self.k0 = k0

        self.k1 = k1

        self.k2 = k2

        self.k3 = k3

        self.k4 = k4



        self._rand_start = 0

        self.sbox0, self.rsbox0 = self.generate_boxes(106)

        self.sbox1, self.rsbox1 = self.generate_boxes(81)


    def my_srand(self, seed):

        self._rand_start = seed


    def my_rand(self):

        if self._rand_start == 0:

            self._rand_start = 123459876

        hi = self._rand_start // 127773

        lo = self._rand_start % 127773

        x = 16807 * lo - 2836 * hi

        if x < 0:

            x += 0x7fffffff

        self._rand_start = (x % (0x7fffffff + 1))

        return self._rand_start



    def generate_boxes(self, seed):

        self.my_srand(seed)

        sbox = list(range(MAX_VALUE))

        rsbox = list(range(MAX_VALUE))


        for i in range(MAX_VALUE):

            r = self.my_rand() % MAX_VALUE

            temp = sbox[i]

            sbox[i] = sbox[r]

            sbox[r] = temp


        for i in range(MAX_VALUE):

            rsbox[sbox[i]] = i


        return sbox, rsbox


    def ror7(self, b):

        return ((((b) & BIT_MASK) >> 7) | (((b) << (NUM_BITS - 7)) & BIT_MASK))


    def rol7(self, b):

        return ((((b) << 7) & BIT_MASK) | (((b) & BIT_MASK) >> (NUM_BITS - 7)))



    def pad_string(self, s):

        num_blocks = len(s) // BLOCK_SIZE

        num_remainder = len(s) % BLOCK_SIZE



        pad = (BLOCK_SIZE - num_remainder) % BLOCK_SIZE

        s += bytes([pad]*(BLOCK_SIZE - num_remainder))

        return s


    def unpad_string(self, s):

        pad = s[-1] & 0xff

        if pad == 0 or pad > BLOCK_SIZE:

            pad = BLOCK_SIZE

        return s[:-pad]


    def string_to_bits_list(self, s):

        input_chars = s

        num_blocks = len(s) // BLOCK_SIZE



        bits_list = []

        for i in range(num_blocks):

            block = 0

            for j in range(BLOCK_SIZE):

                block = block << 8

                block = block | input_chars[i * BLOCK_SIZE + j]

            for j in range(BLOCK_SIZE_BITS, 0, -NUM_BITS):

                bits_list.append((block >> (j - NUM_BITS)) & BIT_MASK)

        return bits_list



    def bits_list_to_string(self, input_bits):

        num_input_bits_per_block = BLOCK_SIZE_BITS // NUM_BITS;

        output_chars = []

        for i in range(0, len(input_bits), num_input_bits_per_block):

            block = 0

            for j in range(num_input_bits_per_block):

                block = block << NUM_BITS

                block = block | (input_bits[i+j])

            for j in range(BLOCK_SIZE, 0, -1):

                output_chars.append((block >> ((j-1) * 8)) & 0xff)

        return bytes(output_chars)



    def encrypt_bits(self, b):

        boxed = self.sbox0[self.sbox1[self.sbox0[(b & BIT_MASK) ^ self.k0] ^ self.k1] ^ self.k2] ^ self.k3

        return (self.ror7(boxed) ^ self.k4) & BIT_MASK;



    def decrypt_bits(self, b):

        unboxed = self.rol7((b & BIT_MASK) ^ self.k4) ^ self.k3

        return (self.rsbox0[self.rsbox1[self.rsbox0[unboxed] ^ self.k2] ^ self.k1] ^ self.k0);



    def encrypt(self, s):

        pad_s = self.pad_string(s)

        bits = self.string_to_bits_list(pad_s)

        return self.bits_list_to_string([(self.encrypt_bits(b)) for b in bits])



    def decrypt(self, s):

        bits = self.string_to_bits_list(s)

        dec = [self.decrypt_bits(b) for b in bits]

        return self.unpad_string(self.bits_list_to_string(dec))



#find the right SECRET_KEYS

SECRET_KEYS = [0,0,0,0,0]

cipher = Cipher(*SECRET_KEYS)

test_text = b"Cryptanalysis has coevolved together with cryptography"

test_text=cipher.string_to_bits_list(test_text)

ciphertext = bytes.fromhex("2371697013e9bdcb50133102f2c8c08a69b93e1878ac7939ac70498ddd5dee019f4be4ec8dd3a612c8708a1169701d5d3de3169c7b1d146146146146")

ciphertext=cipher.string_to_bits_list(ciphertext)



import tqdm



"""

rol7(b ^ k4) ^ k3 = rol7(b) ^ rol7(k4) ^ k3 = rol7(b) ^ k3k4

"""

k0_k1_dict={}

i=0

t=tqdm.tqdm(total=MAX_VALUE**2,ascii=True)

for k0 in range(MAX_VALUE):

    for k1 in range(MAX_VALUE):

        ts=[]

        for b in test_text[:12]:

            ts.append(cipher.sbox1[cipher.sbox0[b ^ k0] ^ k1])

        k0_k1_dict[cipher.bits_list_to_string(ts)]=i

        t.update()

        i+=1

t.close()



k2_k3k4_dict={}

i=0

t=tqdm.tqdm(total=MAX_VALUE**2,ascii=True)

for k2 in range(MAX_VALUE):

    for k3k4 in range(MAX_VALUE):

        ts=[]

        for b in ciphertext[:12]:

            ts.append(cipher.rsbox0[cipher.rol7(b) ^ k3k4] ^ k2)

        k2_k3k4_dict[cipher.bits_list_to_string(ts)]=i

        t.update()

        i+=1

t.close()



for key in k0_k1_dict.keys():

    if key in k2_k3k4_dict:

        i=k0_k1_dict[key]

        j=k2_k3k4_dict[key]

        k0=i//MAX_VALUE

        k1=i%MAX_VALUE

        k2=j//MAX_VALUE

        k3k4=j%MAX_VALUE

        break



message=[]

enc=bytes.fromhex("8ed251b18692697c0f57513c697f09ae4425eacd92a7982edcf9581fa8019e6dcb5753e96972fdf01dcf")

for c in cipher.string_to_bits_list(enc):

    message.append(cipher.rsbox0[cipher.rsbox1[cipher.rsbox0[cipher.rol7(c) ^ k3k4] ^ k2] ^ k1] ^ k0)

flag=cipher.unpad_string(cipher.bits_list_to_string(message)).decode()

print(flag)

FLAG值：

DDCTF{69f15862699b70d7c1084eca5f214a60}