from PIL import Image

def create_image_from_rgb_file(file_path, width, height):
    with open(file_path, 'r') as file:
        lines = file.readlines()

    rgb_values = [tuple(map(int, line.strip().split(','))) for line in lines]

    image = Image.new('RGB', (width, height))

    pixels = []
    for i in range(height):
        for j in range(width):
            index = i * width + j
            if index < len(rgb_values):
                pixels.append(rgb_values[index])
            else:
                pixels.append((0, 0, 0))

    image.putdata(pixels)

    image.save('output.png')
    print("图像已保存为 output.png")

if __name__ == "__main__":
    width = int(input("请输入图像边长1: "))
    height = int(input("请输入图像边长2: "))

    with open('1.txt', 'r') as file:
        line_count = sum(1 for _ in file)

    create_image_from_rgb_file('1.txt', width, height)

flags = ['11111111010111101111', '11111011111110111111', '00001100101010110001', '01001010010000001101', '11010011011101010111', '10011011011010110110', '00111001101101111101'] # 按顺序存到列表里

for i in range(0, 20):
    flag = ''
    for j in range(0, 7):
        flag += flags[j][i] # 提取每一列的二进制位，将其组合成一个新的二进制字符串
    print(chr(int(flag, 2)), end='') # 将该二进制字符串转换为对应的 ASCII 字符并输出

import os
from PIL import Image

def find_duplicate_images(template_image_name, directory):
    duplicates = []
    template_path = os.path.join(directory, f'{template_image_name}.png')
    with Image.open(template_path) as template_img:
        template_hash = hash(template_img.tobytes())
        
        for filename in sorted(os.listdir(directory)):
            if filename.endswith('.png'):
                try:
                    file_num = int(filename.rsplit('.', 1)[0])
                    if 0 <= file_num < 1168: # 有1168张图片
                        file_path = os.path.join(directory, filename)
                        with Image.open(file_path) as img:
                            if hash(img.tobytes()) == template_hash:
                                duplicates.append(file_num)
                except ValueError:
                    continue
    return duplicates

def delete_images(image_numbers, directory):
    for image_num in image_numbers:
        image_name = f"{image_num}.png"
        image_path = os.path.join(directory, image_name)
        try:
            os.remove(image_path)
        except Exception as e:
            print(f"Failed to delete {image_name}: {e}")

def create_traffic_light_string(red_lights, yellow_lights, green_lights):
    traffic_dict = {}
    for num in red_lights:
        traffic_dict[num] = '1'
    for num in yellow_lights:
        traffic_dict[num] = '/'
    for num in green_lights:
        traffic_dict[num] = '0'

    result = ''.join([traffic_dict.get(num, '') for num in sorted(traffic_dict)])
    return result

if __name__ == "__main__":
    gif_frame_directory = '/path/gifframe' # 图片所在文件夹路径

    # # 删除灰色的图片
    # delete_images(find_duplicate_images('1', gif_frame_directory), gif_frame_directory)
    # delete_images(find_duplicate_images('3', gif_frame_directory), gif_frame_directory)
    # delete_images(find_duplicate_images('17', gif_frame_directory), gif_frame_directory)

    # 检测红灯
    red_lights = find_duplicate_images('2', gif_frame_directory)
    red_lights.sort()

    # 检测黄灯
    yellow_lights = find_duplicate_images('16', gif_frame_directory)
    yellow_lights.sort()

    # 检测绿灯
    green_lights = find_duplicate_images('18', gif_frame_directory)
    green_lights.sort()

    # 创建并打印交通灯字符串
    traffic_light_str = create_traffic_light_string(red_lights, yellow_lights, green_lights)
    print(traffic_light_str)

flag = '01100110/01101100/01100001/01100111/01111011/01010000/01101100/00110011/00110100/01110011/00110011/01011111/01110000/00110100/01111001/01011111/00110100/01110100/01110100/00110011/01101110/01110100/00110001/00110000/01101110/01011111/01110100/00110000/01011111/01110100/01110010/00110100/01100110/01100110/00110001/01100011/01011111/01110011/00110100/01100110/00110011/01110100/01111001/01011111/01110111/01101000/00110011/01101110/01011111/01111001/00110000/01110101/01011111/00110100/01110010/00110011/01011111/00110000/01110101/01110100/01110011/00110001/01100100/00110011/01111101'
print(''.join([chr(int(i, 2)) for i in flag.split('/')]))

passwords = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z','A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']

with open('dict.txt', 'w') as dictionary:
    for i in range(len(passwords)):
        dictionary.write(f"{passwords[i]*50}\n")

import re
import os
import filetype # pip install filetype
from lsb import extract # 把github上下载的lsb.py放到当前目录下

path = '/path' # 文件存放目录
dict_path = f'{path}/darkweb2017-top1000.txt'
filename=f'{path}/小猪佩奇.png'

# 反转字典
with open(dict_path, "r", encoding='utf-8') as file:
    lines = file.readlines()
lines.reverse()
with open(dict_path, "w", encoding='utf-8') as file:
    file.writelines(lines)

# 读取字典
with open(f'{path}/darkweb2017-top1000.txt','r+') as file:
    file = file.readlines()

# 提取
for i in file:
    i=i.replace('\n','')
    if len(i)==7 and re.search('[0-9!?]',i)==None:
        out_file= f'{path}/output/{i}'
        extract(filename,out_file,i)

# 当前路径下所有子文件
def get_files_names(file_dir):
    for _, _, files in os.walk(file_dir):
        return files

files_names = get_files_names(f'{path}/output/')

# 判断文件类型并输出
for i in range(0, len(files_names)):
    try:
        kind = filetype.guess(f'{path}/output/{files_names[i]}')
        if kind is None:
            pass
        else:
            print(f"File: {files_names[i]}, MIME Type: {kind.mime}")
    except Exception as e:
        print(f"Error processing file {files_names[i]}: {e}")

# uncompyle6 version 3.9.2
# Python bytecode version base 3.6 (3379)
# Decompiled from: Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)]
# Embedded file name: QAQ.py
# Compiled at: 2018-08-15 14:38:31
# Size of source mod 2**32: 620 bytes


def encryt(key, plain):
    cipher = ""
    for i in range(len(plain)):
        cipher += chr(ord(key[i % len(key)]) ^ ord(plain[i]))

    return cipher


def getPlainText():
    plain = ""
    with open("plain.txt") as f:
        while True:
            line = f.readline()
            if line:
                plain += line
            else:
                break

    return plain


def main():
    key = "LordCasser"
    plain = getPlainText()
    cipher = encryt(key, plain)
    with open("cipher.txt", "w") as f:
        f.write(cipher.encode("base_64"))


if __name__ == "__main__":
    main()

# okay decompiling QAQ.pyc

import base64
def decrypt(key, cipher):
    plain = ""
    for i in range(len(cipher)):
        plain += chr(ord(key[i % len(key)]) ^ ord(cipher[i]))
    return plain

key = "LordCasser"
cipher = base64.b64decode("FSAnRAIzNlMjPQMjNyBJNTs6NlIFPFIqDDVTJy0zGE8rKxZBJDIrJkYoPUQML1M3MDYJZTElFyI7 UzE6DTtSNxckNDw2Mxk9Jzc=").decode()
plain = decrypt(key, cipher)
with open("plain.txt", "w") as f:
    f.write(plain)

def letter_to_index(letter):
    if 'A' <= letter <= 'Z':
        return ord(letter) - ord('A')
    elif 'a' <= letter <= 'z':
        return ord(letter) - ord('a')
    else:
        return None

def index_to_letter(index, is_upper):
    if is_upper:
        return chr(index + ord('A'))
    else:
        return chr(index + ord('a'))

def prepare_keyword(keyword, length):
    return (keyword * (length // len(keyword) + 1))[:length]

def vigenere_decrypt(ciphertext, keyword):
    decrypted_text = []
    keyword = keyword.upper()
    extended_keyword = prepare_keyword(keyword, len(ciphertext))
    keyword_index = 0

    for char in ciphertext:
        if 'A' <= char <= 'Z' or 'a' <= char <= 'z':
            is_upper = char.isupper()
            char_index = letter_to_index(char)
            key_index = letter_to_index(extended_keyword[keyword_index])
            dec_idx = (char_index - key_index) % 26
            decrypted_text.append(index_to_letter(dec_idx, is_upper))
            keyword_index += 1
        else:
            decrypted_text.append(char)

    return ''.join(decrypted_text)

def read_file(file_path):
    with open(file_path, 'r', encoding='utf-8') as file:
        return file.read()

def read_keywords(file_path):
    with open(file_path, 'r', encoding='utf-8') as file:
        return [line.strip() for line in file]

def main():
    path = "/path" # 密文和密钥所在目录
    ciphertext = read_file(f'{path}/ciphertext.txt') # 密文
    keywords = read_keywords(f'{path}/keys.txt') # 密钥

    for keyword in keywords:
        plaintext = vigenere_decrypt(ciphertext, keyword)
        if 'password' in plaintext.lower(): # password也可以是别的词，猜出来的
            print(plaintext)

if __name__ == "__main__":
    main()

# 不完整密码: *7*5-*4*3?
# 不完整sha-1: 619c20c*a4de755*9be9a8b*b7cbfa5*e8b4365*

import string
import hashlib
import itertools


# 1.先定义几个字符集到时候使用
str_digits = string.digits
str_upper = string.ascii_uppercase
str_lower = string.ascii_lowercase
str_printable = string.printable

password = "%s7%s5-%s4%s3?"
for chrs in itertools.product(str_printable, repeat=4):
    pwd = password % chrs
    if (hash_str := hashlib.sha1(pwd.encode()).hexdigest()).startswith("619c20c"):
        print(pwd, hash_str)

import sympy
import libnum
from Crypto.PublicKey import RSA


# 1.read flag.enc
with open("flag.enc", "rb") as f:
    flag = f.read()
    c = libnum.s2n(flag)

# 2.read pub_key
with open("rsa_public_key.pem") as f:
    pub_key = RSA.import_key(f.read())

n = pub_key.n
e = pub_key.e

# 3.使用factordb查询的
p = 15991846970993213322072626901560749932686325766403404864023341810735319249066370916090640926219079368845510444031400322229147771682961132420481897362843199
q = 28805791771260259486856902729020438686670354441296247148207862836064657849735343618207098163901787287368569768472521344635567334299356760080507454640207003

phi_n = (p - 1) * (q - 1)
d = sympy.mod_inverse(e, phi_n)

m = pow(c, d, n)
m = int(m) # 将 gmpy2.mpz 类型转换为 int 类型
print(libnum.n2s(m))

def decode_string(encoded_str, shift=4):
    decoded_str = ""
    for char in encoded_str:
        # Shift the ASCII value of each character backwards by 'shift'
        new_ascii = ord(char) - shift
        # Append the shifted character to the result string
        decoded_str += chr(new_ascii)
    return decoded_str

# Given encoded string
encoded_str = "e6Z9i~]8R~U~QHE{RnY{QXg~QnQ{^XVlRXlp^XI5Q6Q6SKY8jUAA"
# Decode the string
decoded_str = decode_string(encoded_str)
print("Decoded string:", decoded_str)

decoded_provided_string = base64.b64decode(decoded_str).decode('utf-8')
print("Decoded Provided String:", decoded_provided_string)

import base64
from html import unescape
import urllib.parse as urlparse

def decode_data(encoded_string):
    # Step 1: Base64 decode
    base64_decoded = base64.b64decode(encoded_string).decode('utf-8')

    # Step 2: Split by backslash and convert octal to characters
    octal_parts = base64_decoded.split('\\')
    del octal_parts[0]  # Remove the first element if it's empty or not an octal sequence
    oct_to_text = ''.join(chr(int(part, 8)) for part in octal_parts if part)  # Convert octal to char

    # Step 3: Split by '\x' and convert hex to characters
    hex_parts = oct_to_text.split('\\x')
    del hex_parts[0]  # Remove the first element if it's empty or not a hex sequence
    hex_to_text = ''.join(chr(int(part, 16)) for part in hex_parts if part)  # Convert hex to char

    # Step 4: Decode unicode escape sequences
    unicode_decoded = hex_to_text.encode().decode('unicode-escape')

    # Step 5: Split by comma and replace first and last elements
    decimal_parts = unicode_decoded.split(',')
    if len(decimal_parts) > 1:  # Ensure there are enough elements to modify
        decimal_parts[0] = '38'
        decimal_parts[-1] = '59'
    dec_to_text = ''.join(chr(int(part)) for part in decimal_parts if part.isdigit())  # Convert decimal to char

    # Step 6 & 7: HTML entity decode twice
    html_decoded_first_pass = unescape(dec_to_text)
    html_decoded_second_pass = unescape(html_decoded_first_pass)

    # Step 8: URL decode
    url_decoded = urlparse.unquote(html_decoded_second_pass)

    return url_decoded

encoded_string = "" #这里填入密文
print(decode_data(encoded_string))

# 定义圆盘和密钥
disks = [
    "ZWAXJGDLUBVIQHKYPNTCRMOSFE",
    "KPBELNACZDTRXMJQOYHGVSFUWI",
    "BDMAIZVRNSJUWFHTEQGYXPLOCK",
    "RPLNDVHGFCUKTEBSXQYIZMJWAO",
    "IHFRLABEUOTSGJVDKCPMNZQWXY",
    "AMKGHIWPNYCJBFZDRUSLOQXVET",
    "GWTHSPYBXIZULVKMRAFDCEONJQ",
    "NOZUTWDCVRJLXKISEFAPMYGHBQ",
    "QWATDSRFHENYVUBMCOIKZGJXPL",
    "WABMCXPLTDSRJQZGOIKFHENYVU",
    "XPLTDAOIKFZGHENYSRUBMCQWVJ",
    "TDSWAYXPLVUBOIKZGJRFHENMCQ",
    "BMCSRFHLTDENQWAOXPYVUIKZGJ",
    "XPHKZGJTDSENYVUBMLAOIRFCQW"
]

key = [2, 5, 1, 3, 6, 4, 9, 7, 8, 14, 10, 13, 11, 12]
ciphertext = "HCBTSXWCRQGLES"

# 根据密钥重新排序圆盘
ordered_disks = [disks[i-1] for i in key]

# 找到每个密文字符在对应圆盘上的位置，并构建所有可能的解码结果
positions = []
for i, char in enumerate(ciphertext):
    pos = ordered_disks[i].index(char)
    positions.append(pos)

# 输出所有可能的解码结果（即每一列）
for i in range(len(disks[0])):
    plaintext = ''
    for j, disk in enumerate(ordered_disks):
        plaintext += disk[(i + positions[j]) % len(disk)]
    print(plaintext)