UmVfX1BvaW50's Blog
0%

Script

分类于
  • Script

Reverse

python字节码：dis — Python 字节码反汇编器 — Python 3.8.17 文档

ctypes

1
2
3
4
5
6
7
import ctypes

# 加载DLL
my_dll = ctypes.CDLL('path/to/your/dll_file.dll')

# 调用DLL中的函数
result = my_dll.my_function(arg1, arg2)

发送Msg

1
2
3
4
5
6
7
8
9
10
11
12
13
#include<Windows.h>
#include<stdio.h>
int main()
{
  HWND h = FindWindowA(NULL, "Flag就在控件里");
  if (h)
  {
    SendMessage(h, 0x0464, 0, 0);
    printf("success");
  }
  else printf("failure");
}

IDA

IDC爬数据

1
2
3
4
5
6
7
auto addr = 0x0000000100008000;
auto i = 0;
for(i; i < 10; i = i+1)
{
	Message("%x",Byte(addr+i));
	//PatchByte(addr+i,Byte());
}

dump数据

1
2
3
4
5
6
7
auto i,fp;

fp = fopen("D:\\dump2","wb");

for(i=0x7F28238C1000;i<0x7F28238C2A80;i++)
    fputc(Byte(i),fp);
print(1);

常用函数

  • idc

    1
    2
    //获取寄存器的值
    auto eax = GetRegValue("EAX")

  • python

    1
    2
    3
    4
    5
    6
    7
    8
    # 导入头文件
    from idaapi import *
    # 获取寄存器的值
    espval = get_reg_val('esp')
    # 获取字节值ida_bytes.get_word()
    value = ida_bytes.get_word(address)
    # 获取16字节长度的数据
    ida_bytes.get_bytes(ea, 16)

C++板子

1
2
3
4
5
6
#include <bits/stdc++.h>
using namespace std;
int main()
{
    return 0;
}

数字前后bit替换

1
2
3
4
5
def swap_bit(num):
    temp = bin(num)[2:]
    temp = str(temp).zfill(8)
    temp = temp[3:] + temp[:3]
    return int(temp,2)

爆破程序输入

1
2
3
4
5
6
7
8
9
10
11
12
from pwn import *
for i in range(20):
    io = process('./a.out')
    io.recvuntil(b'input:\n')
    i = str(i)
    io.sendline(i.encode())
    res=io.recvline()
    print(res)
    if b'Yes' in res:
        print(i)
    else:
        io.close()

angr docker

启动

1
2
3
4
docker pull angr/angr  
docker run -itd -v /home/kali/Desktop/angr:/angr  angr/angr
docker exec -it f31ffdb5083062a25a5ba77feec15ece5ae0964f7e34a424e2dfc52a313c90ef bash 
cd /angr

脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import angr
import claripy

p=angr.Project('./attachment',load_options={"auto_load_libs": False})
f=p.factory
state = f.entry_state(addr=0x400605)#设置state开始运行时的地址
flag = claripy.BVS('flag',8*32)#要求的内容有32个，用BVS转成二进制给flag变量
state.memory.store(0x603055+0x300+5,flag)#因为程序没有输入，所以直接把字符串设置到内存
state.regs.rdx=0x603055+0x300
state.regs.rdi=0x603055+0x300+5#然后设置两个寄存器

sm = p.factory.simulation_manager(state)#准备从state开始遍历路径


print("ready")

sm.explore(find=0x401DAE)#遍历到成功的地址

if sm.found:
    print("sucess")
    x=sm.found[0].solver.eval(flag,cast_to=bytes)
    print(x)
else:
    print('error')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import angr
import sys
 
def main(argv):
    p = angr.Project('')
    initial_state = p.factory.entry_state()
    sm = p.factory.simgr(initial_state)
    good_addr = 
    bad_addr = 
    sm.explore(find=good_addr, avoid=bad_addr) 
    if sm.found:
        flag = sm.found[0]
        print(flag.posix.dumps(sys.stdin.fileno()))
    else:
        raise Exception('Cannot find')
if __name__ == '__main__':
        main(sys.argv)

参数注入

  • hackgame2022 flag自动机
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <windows.h>
#include <stdio.h>

int main(void){
    HWND target = NULL;

    // 获取窗口句柄
    target = FindWindowW(L"flag 自动机", L"flag 自动机");
    if (target == NULL){
        printf("error!");
        return -1;
    }
    printf("0x%x", target);

    // 发送消息
    PostMessageW(target, 0x111, 3, 114514);
    return 0;
}

CRC32解密

  • RoarCTF2019 polyre
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
secret = [0xBC8FF26D43536296, 0x520100780530EE16, 0x4DC0B5EA935F08EC,
          0x342B90AFD853F450, 0x8B250EBCAA2C3681, 0x55759F81A2C68AE4]
key = 0xB0004B7679FA26B3

flag = ""

# 产生CRC32查表法所用的表
for s in secret:
    for i in range(64):
        sign = s & 1                   #判断首位正负
        if sign == 1:
            s ^= key
        s //= 2
        if sign == 1:
            s |= 0x8000000000000000    # 防止负值除2，溢出为正值
    print(hex(s))                      # 输出表
    # 计算CRC64
    j = 0
    while j < 8:
        flag += chr(s&0xFF)
        s >>= 8
        j += 1
print(flag)

Crypto

获取全符号表

1
2
alphabet = (string.ascii_letters + string.digits + string.punctuation).encode()
string.printable

字符串转端序32位hex

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import ctypes
def string_to_uint32_bytes(string):
    # 将字符串转换为字节序列
    bytes_data = string.encode('utf-8')

    # 将字节序列转换为大端序的c_uint32类型数据
    uint32_data = []
    for i in range(0, 40, 4):
        value = int.from_bytes(bytes_data[i:i + 4], 'little')
        print(value,end=',')
        #uint32_data.append(ctypes.c_uint32(value))

    return uint32_data
print(string_to_uint32_bytes('NSSCTF{8c844a60262f9d280a4da5ebcf78726b}'))

Z3约束求解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import z3
s = z3.Solver()
# Generate an empty list with the same length as the flag
flag = [z3.Int(x) for x in range(23)]
# add constraint condition
s.add()


# Solve
r = s.check()
if repr(r) == 'sat':
    result = s.model()
# result = [k!15 = 95,k!0 = 112,...]
# Replace flag with corresponding subscripts and values
    for k in result:
        index = int(str(k).replace('k!', ''))
        flag[index] = result[k].as_long()
    print(flag)
# Generate chr()flag
    #print(''.join([chr(x) for x in flag]))

因数分解pollard_rho

(34条消息) pollard_rho算法_DeepStarSky的博客-CSDN博客

sha1加密

1
2
3
4
import hashlib
origin = input()
temp = hashlib.sha1(origin.encode())
print(temp.hexdigest())

IDCT变换

1
2
3
4
5
6
7
8
9
10
11
import numpy as np
import cv2                 # install opencv-python 

x = np.array([], dtype=np.float64)
x = cv2.idct(x)
x = x.ravel()
flag=''

for i in range(len(x)):
    flag+=chr(round(x[i]))
print(flag)

RSA已知p高位攻击

  • 生成模式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    from Crypto.Util.number import *
    from gmpy2 import *
    from secret import flag
    import random
    e=
    c=
    m=bytes_to_long(flag)
    p=getprime(512)
    q=getprime(512)
    n=p*q
    c=pow(m,e,n)
    print("n={}".format(n))
    print("c={}".format(c))
    tmp=random.randint(100,300)
    print("p>>tmp={}".format(p>>tmp))
    #c=6423951485971717307108570552094997465421668596714747882611104648100280293836248438862138501051894952826415798421772671979484920170142688929362334687355938148152419374972520025565722001651499172379146648678015238649772132040797315727334900549828142714418998609658177831830859143752082569051539601438562078140 

    #n=102089505560145732952560057865678579074090718982870849595040014068558983876754569662426938164259194050988665149701199828937293560615459891835879217321525050181965009152805251750575379985145711513607266950522285677715896102978770698240713690402491267904700928211276700602995935839857781256403655222855599880553

    #p>>200=8183408885924573625481737168030555426876736448015512229437332241283388177166503450163622041857

  • sage脚本求p

    1
    2
    3
    4
    5
    6
    7
    8
    n = 
    p = 
    p = p << bits				//bits为求解位数，比如已知312位p2，p为512位，bits = 200
    PR. = PolynomialRing(Zmod(n))
    f = x + p
    roots = f.small_roots(X=2 ^ bits,beta = 0.4)
    print(roots)
    print(p)

RSA已知明文m高位攻击

  • 生成模式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    from Crypto.Util.number import *
    from secret import flag
    import libnum
    flag="UNCTF{*************************}" 
    m=libnum.s2n(flag)
    p=libnum.generate_prime(1024)
    q=libnum.generate_prime(1024)
    n=p*q
    e=6
    c=pow(m,e,n)
    M=((m>>60)<<60)
    print("n=",n)
    print("c=",c)
    print("((m>>60)<<60)=",M)

  • sage求解m

    1
    2
    3
    4
    5
    6
    7
    n = 
    c = 
    high_m = 
    R.<x> = PolynomialRing(Zmod(n), implementation='NTL')
    m = high_m + x
    M = m((m^6 - c).small_roots()[0])
    print(hex(int(M))[2:])

  • python还原m

    1
    2
    3
    import libnum
    M =
    print(libnum.n2s(M))

Base64变表解密

1
2
3
4
5
6
7
8
9
10
11
12
import base64
# 原表
origin = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
# 变表
base = 'yzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/abcdefghijklmnopqrstuvwx'
# 密文
c = '1ovhXETgZUDgXFS='
# 映射表
table = str.maketrans(base,origin)
# 明文
m = str(base64.b64decode(c.translate(table)),encoding=('utf-8'))
print(m)

SM4解密

  • 题目部分解密源码
1
2
3
4
5
6
from libnum import s2n, n2s
from pysm4 import decrypt
cipher = 119384314703134531538573762305905297230
print(cipher)
sm4_key = s2n(b"where_are_u_now?")
print(n2s(decrypt(cipher, sm4_key)).decode())

MD5加密

1
2
3
4
5
6
7
8
9
10
11
import hashlib

# 待加密信息
str = 'this is a md5 test.'

# 创建md5对象
hl = hashlib.md5()
hl.update(str.encode(encoding='utf-8'))

print('MD5加密前为 ：' + str)
print('MD5加密后为 ：' + hl.hexdigest())

RC4加密

  • 密钥长度可变，加解密同一套代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#include <stdio.h>
#include <string.h>

typedef unsigned longULONG;
 
/*初始化函数*/
void rc4_init(unsigned char *s, unsigned char *key, unsigned long len)
{
    int i = 0, j = 0;
    char k[256] = {0};
    unsigned char tmp;
    for (i = 0; i < 256; i++){
        s[i] = i;
        k[i] = key[i % len];
    }
    for (i = 0; i < 256; i++){
        j = (j + s[i] + k[i]) % 256;
        tmp = s[i];
        s[i] = s[j];
        s[j] = tmp;
    }
}
 
/*加解密*/
void rc4_crypt(unsigned char *s, unsigned char *Data, unsigned long len)
{
    int i = 0, j = 0, t = 0;
    unsigned long k = 0;
    unsigned char tmp;
    for (k = 0; k < len; k++){
        i = (i + 1) % 256;
        j = (j + s[i]) % 256;
        tmp = s[i];
        s[i] = s[j];
        s[j] = tmp;
        t = (s[i] + s[j]) % 256;
        Data[k] ^= s[t];
    }
}
 
int main()
{
    unsigned char s[256] = { 0 };//S-box
    char key[256] = {"justfortest"};		
    //密文十六进制形式
    int pata[512] = {0x10,0xa8,0x1,0x36,0xa0,0x48,0x6a,0xb6,0xdb,0xf1,0x64,0xad,0x84,0x59,0x2,0x9d,0x8a,0x54,0x9e,0xc2,0x4d,0x27};
    //转换为字符串形式
    char pData[512] = {0};
    for(int i = 0; pata[i]; i++){
    	pData[i] = (char)pata[i];
    }

    rc4_init(s, (unsigned char*)key, strlen(key));//已经完成了初始化
    rc4_crypt(s, (unsigned char*)pData, strlen(pData));//crypt
    //out
    for(int i = 0; pData[i]; i++){
    	printf("0x%02x,",pData[i]);
    }
    printf("字符串格式为：\n%s",pData);
    return 0;
}

ChaCha20

  • 本质上就是逐字节异或
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from Crypto.Cipher import ChaCha20
from Crypto.Random import get_random_bytes

def encrypt(key, nonce, plaintext):
    chacha = ChaCha20.new(key=key, nonce=nonce)
    return chacha.encrypt(plaintext)

def decrypt(key, nonce, ciphertext):
    decipher = ChaCha20.new(key=key, nonce=nonce)
    return decipher.decrypt(ciphertext)

# 生成一个随机的256位密钥和96位初始向量[这个长度是固定的]
key = get_random_bytes(32)
nonce = get_random_bytes(12)

plaintext = b"Hello, World!"
# 加密消息
ciphertext = encrypt(key, nonce, plaintext)
# 解密消息
decrypted = decrypt(key, nonce, ciphertext)

print("Plaintext:", plaintext)
print("Ciphertext:", ciphertext)
print("Decrypted:", decrypted)

LLL

  • 题目
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
from gmpy2 import *
from Crypto.Util.number import *

def get_key():
    p = getPrime(1400)
    f = getRandomNBitInteger(1024)
    while True:
        q = getPrime(512)
        if gcd(f, q) != 1:
            continue
        else:
            break
    h = (invert(f, p) * q) % p
    return p, h

def encrypt2(msg, p, h):
    s = getRandomNBitInteger(512)
    c = (s * h + msg) % p
    return c

p, h = get_key()
c = encrypt2(flag, p, h)
print("p =", p)
print("h =", h)
print("c =", c)

# p = 25886434964719448194352673440525701654705794467884891063997131230558866479588298264578120588832128279435501897537203249743883076992668855905005985050222145380285378634993563571078034923112985724204131887907198503097115380966366598622251191576354831935118147880783949022370177789175320661630501595157946150891275992785113199863734714343650596491139321990230671901990010723398037081693145723605154355325074739107535905777351
# h = 2332673914418001018316159191702497430320194762477685969994411366563846498561222483921873160125818295447435796015251682805613716554577537183122368080760105458908517619529332931042168173262127728892648742025494771751133664547888267249802368767396121189473647263861691578834674578112521646941677994097088669110583465311980605508259404858000937372665500663077299603396786862387710064061811000146453852819607311367850587534711
# c = 20329058681057003355767546524327270876901063126285410163862577312957425318547938475645814390088863577141554443432653658287774537679738768993301095388221262144278253212238975358868925761055407920504398004143126310247822585095611305912801250788531962681592054588938446210412897150782558115114462054815460318533279921722893020563472010279486838372516063331845966834180751724227249589463408168677246991839581459878242111459287

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
from Crypto.Util.number import *

def decrypt(c,f,g,h,p):
    a = (f*c)%p
    m = (a*inverse(f,g))%g
    return m

p = 25886434964719448194352673440525701654705794467884891063997131230558866479588298264578120588832128279435501897537203249743883076992668855905005985050222145380285378634993563571078034923112985724204131887907198503097115380966366598622251191576354831935118147880783949022370177789175320661630501595157946150891275992785113199863734714343650596491139321990230671901990010723398037081693145723605154355325074739107535905777351
h = 2332673914418001018316159191702497430320194762477685969994411366563846498561222483921873160125818295447435796015251682805613716554577537183122368080760105458908517619529332931042168173262127728892648742025494771751133664547888267249802368767396121189473647263861691578834674578112521646941677994097088669110583465311980605508259404858000937372665500663077299603396786862387710064061811000146453852819607311367850587534711
c = 20329058681057003355767546524327270876901063126285410163862577312957425318547938475645814390088863577141554443432653658287774537679738768993301095388221262144278253212238975358868925761055407920504398004143126310247822585095611305912801250788531962681592054588938446210412897150782558115114462054815460318533279921722893020563472010279486838372516063331845966834180751724227249589463408168677246991839581459878242111459287



m = Matrix(
    [
        [h, p],
        [1, 0]
    ]
)

mm = m.T
mmlll = mm.LLL()

for LLres in list(mmlll):
    g, f = LLres
    if g < 0 and f < 0:
        g = -g
        f = -f
        mmmm = decrypt(c,f,g,h,p)
        print(mmmm)

# S3 = 10700695166096094995375972320865971168959897437299342068124161538902514000691034236758289037664275323635047529647532200693311709347984126070052011571264606

LCG

1
2
3
4
5
6
7
8
9
10
11
12
13
def crack_unknown_increment(states, modulus, multiplier):
    increment = (states[1] - states[0]*multiplier) % modulus
    print('lcg_c =',increment)
def crack_unknown_multiplier(states, modulus):
    multiplier = (states[2] - states[1]) * gmpy2.invert(states[1] - states[0], modulus) % modulus # 注意这里求逆元
    print('lcg_m =', multiplier)
    return crack_unknown_increment(states, modulus, multiplier)
def crack_unknown_modulus(states):
    diffs = [s1 - s0 for s0, s1 in zip(states, states[1:])]
    zeroes = [t2*t0 - t1*t1 for t0, t1, t2 in zip(diffs, diffs[1:], diffs[2:])]
    modulus = abs(reduce(gcd, zeroes))
    print('lcg_n =',modulus)
    return crack_unknown_multiplier(states, modulus)

已知p*q & p^q 求解p和q

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def solve(muln,xorn,bitn):
    x_list, y_list = [0], [0]

    for i in range(bitn):
        cur_mod = 2**(i+1)
        next_x_list, next_y_list = [], []
        for x_l, y_l in zip(x_list, y_list):
            for x_h, y_h in [(0,0), (0,1), (1,0), (1,1)]:
                x = x_h*(2**i) + x_l
                y = y_h*(2**i) + y_l
                if ((x * y % cur_mod == muln % cur_mod) and ((x ^ y) == xorn % cur_mod)):
                    next_x_list.append(x)
                    next_y_list.append(y)

        x_list, y_list = next_x_list, next_y_list

    for x, y in zip(x_list, y_list):
        if x * y == muln and x*y-muln == 0 and (x^y)-xorn == 0:
            break

    print(x)
    print(y)
    return x,y
p = 20810298530643139779725379335557687960281905096107101411585220918672653323875234344540342801651123667553812866458790076971583539529404583369246005781146655852295475940942005806084842620601383912513102861245275690036363402134681262533947475193408594967684453091957401932685922178406769578067946779033282889429596341714417295489842047781388337010440309434639274398589029236213499110100040841426995862849012466514170374143655264739023758914247116354182164550612494432327931655944868705959874670536031052370968354394583880324756639698871918124498442308334232127034553164826483441746719644515097123067550594588348951855987
q = 66138689143868607947630785415331461127626263390302506173955100963855136134289233949354345883327245336547595357625259526618623795152771487180400409991587378085305813144661971099363267511657121911410275002816755637490837422852032755234403225128695875574749525003296342076268760708900752562579555935703659615570
solve(p,q,1024)

已知p+q和p*q求解p和q

1
2
3
4
5
6
7
8
9
from z3 import *
mul = 
add = 
x = Real('x')
y = Real('y')
s = Solver()
s.add(x*y==mul,x+y==add)
print(s.check())
print(s.model())

randcrack

1
2
3
4
5
6
7
8
9
10
11
from randcrack import RandCrack
 
with open(r'output.txt', 'r') as f:
    l = f.readlines()
l = [int(i.strip()) for i in l]

rc = RandCrack()
for i in l:
    rc.submit(i)

print(rc.predict_getrandbits(32))

sha2560爆破

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from pwnlib.util.iters import mbruteforce
from hashlib import sha256
import string
import sys


"""
$ ncat -v [HOST] [PORT]
sha256("KOcNc"+"?") starts with 26bits of zero:
usage: $ python3 solve.py KOcNc
"""

prefixes = sys.argv[1]
def brute(cur):

    content = prefixes + str(cur)
    s = sha256(content.encode())
    if s.hexdigest().startswith("000000") and int(s.hexdigest()[6:8], 16) < 0x40:
        return True
    return False

import pwn
res =  mbruteforce(brute, string.ascii_lowercase + string.digits, method = 'upto', length=6,  threads = 20)
print(res)

Go爆破sha256前4位

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
package main

import (
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"math"
	"strings"
	"time"
)

func sha(str string) string {
	h := sha256.New()
	h.Write([]byte(str))
	a := h.Sum(nil)
	hashCode2 := hex.EncodeToString(a[:]) //将数组转换成切片，转换成16进制，返回字符串
	return hashCode2
}

var ans = make(chan string)
var count, sum int = 0, 0
var flag int = 0

func f(s string, com string, cnt int) {
	cnt--
	for i := 33; i <= 126; i++ {
		temp_s := strings.Replace(s, "?", fmt.Sprintf("%c", i), 1)
		if cnt == 0 {
			count++
			str := sha(temp_s)
			if str == com {
				flag = 1
				ans <- temp_s
				return
			}
		} else {
			go f(temp_s, com, cnt)
		}
	}
}
func main() {
	s := "????" + "teilcm0NyiScbzKQ"
	com := "71cee1525a232a1b6e828d85fa14d089d323b6af6a64d5454a12192382258aab"
	num := int(0)
	for i := 0; i < len(s); i++ {
		if s[i] == '?' {
			num++
		}
	}
	sum = int(math.Pow((126 - 33 + 1), float64(num)))
	go f(s, com, num)
	var sec int = 0
	for flag != 1 {
		sec++
		fmt.Println(count, "/", sum, ":", flag)
		time.Sleep(1 * time.Second)
	}
	fmt.Println(count, "/", sum, ":", <-ans)
	fmt.Print("Time:", sec, 's')
}

Base8

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def to8bArr(baguaStr):
    code = {'乾': '0',  #
            '兑': '1',  # 兑
            '离': '2',  # 离
            '震': '3',  # 震
            '巽': '4',  #
            '坎': '5',  #
            '艮': '6',  #
            '坤': '7',  # 坤
            }

    bArr = []

    temp = []
    # 把八卦符转为8进制数字
    for s in baguaStr:
        temp.append(code[s])
    print(temp)
    tempStr = ''
    # 数字3个一组 组合回八进制
    for i in range(len(temp)):
        tempStr += temp[i]
        if i % 3 == 2:
            bArr.append('0o' + tempStr)
            tempStr = ''
    for i in bArr:
        print(chr(int(i, base=8)),end='')

Blowfish

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
import Crypto.Util.number
import copy

p_box = [
    0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344,
    0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89,
    0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C,
    0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917,
    0x9216D5D9, 0x8979FB1B]

s_box = [
    [0xD1310BA6, 0x98DFB5AC, 0x2FFD72DB, 0xD01ADFB7,
     0xB8E1AFED, 0x6A267E96, 0xBA7C9045, 0xF12C7F99,
     0x24A19947, 0xB3916CF7, 0x0801F2E2, 0x858EFC16,
     0x636920D8, 0x71574E69, 0xA458FEA3, 0xF4933D7E,
     0x0D95748F, 0x728EB658, 0x718BCD58, 0x82154AEE,
     0x7B54A41D, 0xC25A59B5, 0x9C30D539, 0x2AF26013,
     0xC5D1B023, 0x286085F0, 0xCA417918, 0xB8DB38EF,
     0x8E79DCB0, 0x603A180E, 0x6C9E0E8B, 0xB01E8A3E,
     0xD71577C1, 0xBD314B27, 0x78AF2FDA, 0x55605C60,
     0xE65525F3, 0xAA55AB94, 0x57489862, 0x63E81440,
     0x55CA396A, 0x2AAB10B6, 0xB4CC5C34, 0x1141E8CE,
     0xA15486AF, 0x7C72E993, 0xB3EE1411, 0x636FBC2A,
     0x2BA9C55D, 0x741831F6, 0xCE5C3E16, 0x9B87931E,
     0xAFD6BA33, 0x6C24CF5C, 0x7A325381, 0x28958677,
     0x3B8F4898, 0x6B4BB9AF, 0xC4BFE81B, 0x66282193,
     0x61D809CC, 0xFB21A991, 0x487CAC60, 0x5DEC8032,
     0xEF845D5D, 0xE98575B1, 0xDC262302, 0xEB651B88,
     0x23893E81, 0xD396ACC5, 0x0F6D6FF3, 0x83F44239,
     0x2E0B4482, 0xA4842004, 0x69C8F04A, 0x9E1F9B5E,
     0x21C66842, 0xF6E96C9A, 0x670C9C61, 0xABD388F0,
     0x6A51A0D2, 0xD8542F68, 0x960FA728, 0xAB5133A3,
     0x6EEF0B6C, 0x137A3BE4, 0xBA3BF050, 0x7EFB2A98,
     0xA1F1651D, 0x39AF0176, 0x66CA593E, 0x82430E88,
     0x8CEE8619, 0x456F9FB4, 0x7D84A5C3, 0x3B8B5EBE,
     0xE06F75D8, 0x85C12073, 0x401A449F, 0x56C16AA6,
     0x4ED3AA62, 0x363F7706, 0x1BFEDF72, 0x429B023D,
     0x37D0D724, 0xD00A1248, 0xDB0FEAD3, 0x49F1C09B,
     0x075372C9, 0x80991B7B, 0x25D479D8, 0xF6E8DEF7,
     0xE3FE501A, 0xB6794C3B, 0x976CE0BD, 0x04C006BA,
     0xC1A94FB6, 0x409F60C4, 0x5E5C9EC2, 0x196A2463,
     0x68FB6FAF, 0x3E6C53B5, 0x1339B2EB, 0x3B52EC6F,
     0x6DFC511F, 0x9B30952C, 0xCC814544, 0xAF5EBD09,
     0xBEE3D004, 0xDE334AFD, 0x660F2807, 0x192E4BB3,
     0xC0CBA857, 0x45C8740F, 0xD20B5F39, 0xB9D3FBDB,
     0x5579C0BD, 0x1A60320A, 0xD6A100C6, 0x402C7279,
     0x679F25FE, 0xFB1FA3CC, 0x8EA5E9F8, 0xDB3222F8,
     0x3C7516DF, 0xFD616B15, 0x2F501EC8, 0xAD0552AB,
     0x323DB5FA, 0xFD238760, 0x53317B48, 0x3E00DF82,
     0x9E5C57BB, 0xCA6F8CA0, 0x1A87562E, 0xDF1769DB,
     0xD542A8F6, 0x287EFFC3, 0xAC6732C6, 0x8C4F5573,
     0x695B27B0, 0xBBCA58C8, 0xE1FFA35D, 0xB8F011A0,
     0x10FA3D98, 0xFD2183B8, 0x4AFCB56C, 0x2DD1D35B,
     0x9A53E479, 0xB6F84565, 0xD28E49BC, 0x4BFB9790,
     0xE1DDF2DA, 0xA4CB7E33, 0x62FB1341, 0xCEE4C6E8,
     0xEF20CADA, 0x36774C01, 0xD07E9EFE, 0x2BF11FB4,
     0x95DBDA4D, 0xAE909198, 0xEAAD8E71, 0x6B93D5A0,
     0xD08ED1D0, 0xAFC725E0, 0x8E3C5B2F, 0x8E7594B7,
     0x8FF6E2FB, 0xF2122B64, 0x8888B812, 0x900DF01C,
     0x4FAD5EA0, 0x688FC31C, 0xD1CFF191, 0xB3A8C1AD,
     0x2F2F2218, 0xBE0E1777, 0xEA752DFE, 0x8B021FA1,
     0xE5A0CC0F, 0xB56F74E8, 0x18ACF3D6, 0xCE89E299,
     0xB4A84FE0, 0xFD13E0B7, 0x7CC43B81, 0xD2ADA8D9,
     0x165FA266, 0x80957705, 0x93CC7314, 0x211A1477,
     0xE6AD2065, 0x77B5FA86, 0xC75442F5, 0xFB9D35CF,
     0xEBCDAF0C, 0x7B3E89A0, 0xD6411BD3, 0xAE1E7E49,
     0x00250E2D, 0x2071B35E, 0x226800BB, 0x57B8E0AF,
     0x2464369B, 0xF009B91E, 0x5563911D, 0x59DFA6AA,
     0x78C14389, 0xD95A537F, 0x207D5BA2, 0x02E5B9C5,
     0x83260376, 0x6295CFA9, 0x11C81968, 0x4E734A41,
     0xB3472DCA, 0x7B14A94A, 0x1B510052, 0x9A532915,
     0xD60F573F, 0xBC9BC6E4, 0x2B60A476, 0x81E67400,
     0x08BA6FB5, 0x571BE91F, 0xF296EC6B, 0x2A0DD915,
     0xB6636521, 0xE7B9F9B6, 0xFF34052E, 0xC5855664,
     0x53B02D5D, 0xA99F8FA1, 0x08BA4799, 0x6E85076A],
    [0x4B7A70E9, 0xB5B32944, 0xDB75092E, 0xC4192623,
     0xAD6EA6B0, 0x49A7DF7D, 0x9CEE60B8, 0x8FEDB266,
     0xECAA8C71, 0x699A17FF, 0x5664526C, 0xC2B19EE1,
     0x193602A5, 0x75094C29, 0xA0591340, 0xE4183A3E,
     0x3F54989A, 0x5B429D65, 0x6B8FE4D6, 0x99F73FD6,
     0xA1D29C07, 0xEFE830F5, 0x4D2D38E6, 0xF0255DC1,
     0x4CDD2086, 0x8470EB26, 0x6382E9C6, 0x021ECC5E,
     0x09686B3F, 0x3EBAEFC9, 0x3C971814, 0x6B6A70A1,
     0x687F3584, 0x52A0E286, 0xB79C5305, 0xAA500737,
     0x3E07841C, 0x7FDEAE5C, 0x8E7D44EC, 0x5716F2B8,
     0xB03ADA37, 0xF0500C0D, 0xF01C1F04, 0x0200B3FF,
     0xAE0CF51A, 0x3CB574B2, 0x25837A58, 0xDC0921BD,
     0xD19113F9, 0x7CA92FF6, 0x94324773, 0x22F54701,
     0x3AE5E581, 0x37C2DADC, 0xC8B57634, 0x9AF3DDA7,
     0xA9446146, 0x0FD0030E, 0xECC8C73E, 0xA4751E41,
     0xE238CD99, 0x3BEA0E2F, 0x3280BBA1, 0x183EB331,
     0x4E548B38, 0x4F6DB908, 0x6F420D03, 0xF60A04BF,
     0x2CB81290, 0x24977C79, 0x5679B072, 0xBCAF89AF,
     0xDE9A771F, 0xD9930810, 0xB38BAE12, 0xDCCF3F2E,
     0x5512721F, 0x2E6B7124, 0x501ADDE6, 0x9F84CD87,
     0x7A584718, 0x7408DA17, 0xBC9F9ABC, 0xE94B7D8C,
     0xEC7AEC3A, 0xDB851DFA, 0x63094366, 0xC464C3D2,
     0xEF1C1847, 0x3215D908, 0xDD433B37, 0x24C2BA16,
     0x12A14D43, 0x2A65C451, 0x50940002, 0x133AE4DD,
     0x71DFF89E, 0x10314E55, 0x81AC77D6, 0x5F11199B,
     0x043556F1, 0xD7A3C76B, 0x3C11183B, 0x5924A509,
     0xF28FE6ED, 0x97F1FBFA, 0x9EBABF2C, 0x1E153C6E,
     0x86E34570, 0xEAE96FB1, 0x860E5E0A, 0x5A3E2AB3,
     0x771FE71C, 0x4E3D06FA, 0x2965DCB9, 0x99E71D0F,
     0x803E89D6, 0x5266C825, 0x2E4CC978, 0x9C10B36A,
     0xC6150EBA, 0x94E2EA78, 0xA5FC3C53, 0x1E0A2DF4,
     0xF2F74EA7, 0x361D2B3D, 0x1939260F, 0x19C27960,
     0x5223A708, 0xF71312B6, 0xEBADFE6E, 0xEAC31F66,
     0xE3BC4595, 0xA67BC883, 0xB17F37D1, 0x018CFF28,
     0xC332DDEF, 0xBE6C5AA5, 0x65582185, 0x68AB9802,
     0xEECEA50F, 0xDB2F953B, 0x2AEF7DAD, 0x5B6E2F84,
     0x1521B628, 0x29076170, 0xECDD4775, 0x619F1510,
     0x13CCA830, 0xEB61BD96, 0x0334FE1E, 0xAA0363CF,
     0xB5735C90, 0x4C70A239, 0xD59E9E0B, 0xCBAADE14,
     0xEECC86BC, 0x60622CA7, 0x9CAB5CAB, 0xB2F3846E,
     0x648B1EAF, 0x19BDF0CA, 0xA02369B9, 0x655ABB50,
     0x40685A32, 0x3C2AB4B3, 0x319EE9D5, 0xC021B8F7,
     0x9B540B19, 0x875FA099, 0x95F7997E, 0x623D7DA8,
     0xF837889A, 0x97E32D77, 0x11ED935F, 0x16681281,
     0x0E358829, 0xC7E61FD6, 0x96DEDFA1, 0x7858BA99,
     0x57F584A5, 0x1B227263, 0x9B83C3FF, 0x1AC24696,
     0xCDB30AEB, 0x532E3054, 0x8FD948E4, 0x6DBC3128,
     0x58EBF2EF, 0x34C6FFEA, 0xFE28ED61, 0xEE7C3C73,
     0x5D4A14D9, 0xE864B7E3, 0x42105D14, 0x203E13E0,
     0x45EEE2B6, 0xA3AAABEA, 0xDB6C4F15, 0xFACB4FD0,
     0xC742F442, 0xEF6ABBB5, 0x654F3B1D, 0x41CD2105,
     0xD81E799E, 0x86854DC7, 0xE44B476A, 0x3D816250,
     0xCF62A1F2, 0x5B8D2646, 0xFC8883A0, 0xC1C7B6A3,
     0x7F1524C3, 0x69CB7492, 0x47848A0B, 0x5692B285,
     0x095BBF00, 0xAD19489D, 0x1462B174, 0x23820E00,
     0x58428D2A, 0x0C55F5EA, 0x1DADF43E, 0x233F7061,
     0x3372F092, 0x8D937E41, 0xD65FECF1, 0x6C223BDB,
     0x7CDE3759, 0xCBEE7460, 0x4085F2A7, 0xCE77326E,
     0xA6078084, 0x19F8509E, 0xE8EFD855, 0x61D99735,
     0xA969A7AA, 0xC50C06C2, 0x5A04ABFC, 0x800BCADC,
     0x9E447A2E, 0xC3453484, 0xFDD56705, 0x0E1E9EC9,
     0xDB73DBD3, 0x105588CD, 0x675FDA79, 0xE3674340,
     0xC5C43465, 0x713E38D8, 0x3D28F89E, 0xF16DFF20,
     0x153E21E7, 0x8FB03D4A, 0xE6E39F2B, 0xDB83ADF7],
    [0xE93D5A68, 0x948140F7, 0xF64C261C, 0x94692934,
     0x411520F7, 0x7602D4F7, 0xBCF46B2E, 0xD4A20068,
     0xD4082471, 0x3320F46A, 0x43B7D4B7, 0x500061AF,
     0x1E39F62E, 0x97244546, 0x14214F74, 0xBF8B8840,
     0x4D95FC1D, 0x96B591AF, 0x70F4DDD3, 0x66A02F45,
     0xBFBC09EC, 0x03BD9785, 0x7FAC6DD0, 0x31CB8504,
     0x96EB27B3, 0x55FD3941, 0xDA2547E6, 0xABCA0A9A,
     0x28507825, 0x530429F4, 0x0A2C86DA, 0xE9B66DFB,
     0x68DC1462, 0xD7486900, 0x680EC0A4, 0x27A18DEE,
     0x4F3FFEA2, 0xE887AD8C, 0xB58CE006, 0x7AF4D6B6,
     0xAACE1E7C, 0xD3375FEC, 0xCE78A399, 0x406B2A42,
     0x20FE9E35, 0xD9F385B9, 0xEE39D7AB, 0x3B124E8B,
     0x1DC9FAF7, 0x4B6D1856, 0x26A36631, 0xEAE397B2,
     0x3A6EFA74, 0xDD5B4332, 0x6841E7F7, 0xCA7820FB,
     0xFB0AF54E, 0xD8FEB397, 0x454056AC, 0xBA489527,
     0x55533A3A, 0x20838D87, 0xFE6BA9B7, 0xD096954B,
     0x55A867BC, 0xA1159A58, 0xCCA92963, 0x99E1DB33,
     0xA62A4A56, 0x3F3125F9, 0x5EF47E1C, 0x9029317C,
     0xFDF8E802, 0x04272F70, 0x80BB155C, 0x05282CE3,
     0x95C11548, 0xE4C66D22, 0x48C1133F, 0xC70F86DC,
     0x07F9C9EE, 0x41041F0F, 0x404779A4, 0x5D886E17,
     0x325F51EB, 0xD59BC0D1, 0xF2BCC18F, 0x41113564,
     0x257B7834, 0x602A9C60, 0xDFF8E8A3, 0x1F636C1B,
     0x0E12B4C2, 0x02E1329E, 0xAF664FD1, 0xCAD18115,
     0x6B2395E0, 0x333E92E1, 0x3B240B62, 0xEEBEB922,
     0x85B2A20E, 0xE6BA0D99, 0xDE720C8C, 0x2DA2F728,
     0xD0127845, 0x95B794FD, 0x647D0862, 0xE7CCF5F0,
     0x5449A36F, 0x877D48FA, 0xC39DFD27, 0xF33E8D1E,
     0x0A476341, 0x992EFF74, 0x3A6F6EAB, 0xF4F8FD37,
     0xA812DC60, 0xA1EBDDF8, 0x991BE14C, 0xDB6E6B0D,
     0xC67B5510, 0x6D672C37, 0x2765D43B, 0xDCD0E804,
     0xF1290DC7, 0xCC00FFA3, 0xB5390F92, 0x690FED0B,
     0x667B9FFB, 0xCEDB7D9C, 0xA091CF0B, 0xD9155EA3,
     0xBB132F88, 0x515BAD24, 0x7B9479BF, 0x763BD6EB,
     0x37392EB3, 0xCC115979, 0x8026E297, 0xF42E312D,
     0x6842ADA7, 0xC66A2B3B, 0x12754CCC, 0x782EF11C,
     0x6A124237, 0xB79251E7, 0x06A1BBE6, 0x4BFB6350,
     0x1A6B1018, 0x11CAEDFA, 0x3D25BDD8, 0xE2E1C3C9,
     0x44421659, 0x0A121386, 0xD90CEC6E, 0xD5ABEA2A,
     0x64AF674E, 0xDA86A85F, 0xBEBFE988, 0x64E4C3FE,
     0x9DBC8057, 0xF0F7C086, 0x60787BF8, 0x6003604D,
     0xD1FD8346, 0xF6381FB0, 0x7745AE04, 0xD736FCCC,
     0x83426B33, 0xF01EAB71, 0xB0804187, 0x3C005E5F,
     0x77A057BE, 0xBDE8AE24, 0x55464299, 0xBF582E61,
     0x4E58F48F, 0xF2DDFDA2, 0xF474EF38, 0x8789BDC2,
     0x5366F9C3, 0xC8B38E74, 0xB475F255, 0x46FCD9B9,
     0x7AEB2661, 0x8B1DDF84, 0x846A0E79, 0x915F95E2,
     0x466E598E, 0x20B45770, 0x8CD55591, 0xC902DE4C,
     0xB90BACE1, 0xBB8205D0, 0x11A86248, 0x7574A99E,
     0xB77F19B6, 0xE0A9DC09, 0x662D09A1, 0xC4324633,
     0xE85A1F02, 0x09F0BE8C, 0x4A99A025, 0x1D6EFE10,
     0x1AB93D1D, 0x0BA5A4DF, 0xA186F20F, 0x2868F169,
     0xDCB7DA83, 0x573906FE, 0xA1E2CE9B, 0x4FCD7F52,
     0x50115E01, 0xA70683FA, 0xA002B5C4, 0x0DE6D027,
     0x9AF88C27, 0x773F8641, 0xC3604C06, 0x61A806B5,
     0xF0177A28, 0xC0F586E0, 0x006058AA, 0x30DC7D62,
     0x11E69ED7, 0x2338EA63, 0x53C2DD94, 0xC2C21634,
     0xBBCBEE56, 0x90BCB6DE, 0xEBFC7DA1, 0xCE591D76,
     0x6F05E409, 0x4B7C0188, 0x39720A3D, 0x7C927C24,
     0x86E3725F, 0x724D9DB9, 0x1AC15BB4, 0xD39EB8FC,
     0xED545578, 0x08FCA5B5, 0xD83D7CD3, 0x4DAD0FC4,
     0x1E50EF5E, 0xB161E6F8, 0xA28514D9, 0x6C51133C,
     0x6FD5C7E7, 0x56E14EC4, 0x362ABFCE, 0xDDC6C837,
     0xD79A3234, 0x92638212, 0x670EFA8E, 0x406000E0],
    [0x3A39CE37, 0xD3FAF5CF, 0xABC27737, 0x5AC52D1B,
     0x5CB0679E, 0x4FA33742, 0xD3822740, 0x99BC9BBE,
     0xD5118E9D, 0xBF0F7315, 0xD62D1C7E, 0xC700C47B,
     0xB78C1B6B, 0x21A19045, 0xB26EB1BE, 0x6A366EB4,
     0x5748AB2F, 0xBC946E79, 0xC6A376D2, 0x6549C2C8,
     0x530FF8EE, 0x468DDE7D, 0xD5730A1D, 0x4CD04DC6,
     0x2939BBDB, 0xA9BA4650, 0xAC9526E8, 0xBE5EE304,
     0xA1FAD5F0, 0x6A2D519A, 0x63EF8CE2, 0x9A86EE22,
     0xC089C2B8, 0x43242EF6, 0xA51E03AA, 0x9CF2D0A4,
     0x83C061BA, 0x9BE96A4D, 0x8FE51550, 0xBA645BD6,
     0x2826A2F9, 0xA73A3AE1, 0x4BA99586, 0xEF5562E9,
     0xC72FEFD3, 0xF752F7DA, 0x3F046F69, 0x77FA0A59,
     0x80E4A915, 0x87B08601, 0x9B09E6AD, 0x3B3EE593,
     0xE990FD5A, 0x9E34D797, 0x2CF0B7D9, 0x022B8B51,
     0x96D5AC3A, 0x017DA67D, 0xD1CF3ED6, 0x7C7D2D28,
     0x1F9F25CF, 0xADF2B89B, 0x5AD6B472, 0x5A88F54C,
     0xE029AC71, 0xE019A5E6, 0x47B0ACFD, 0xED93FA9B,
     0xE8D3C48D, 0x283B57CC, 0xF8D56629, 0x79132E28,
     0x785F0191, 0xED756055, 0xF7960E44, 0xE3D35E8C,
     0x15056DD4, 0x88F46DBA, 0x03A16125, 0x0564F0BD,
     0xC3EB9E15, 0x3C9057A2, 0x97271AEC, 0xA93A072A,
     0x1B3F6D9B, 0x1E6321F5, 0xF59C66FB, 0x26DCF319,
     0x7533D928, 0xB155FDF5, 0x03563482, 0x8ABA3CBB,
     0x28517711, 0xC20AD9F8, 0xABCC5167, 0xCCAD925F,
     0x4DE81751, 0x3830DC8E, 0x379D5862, 0x9320F991,
     0xEA7A90C2, 0xFB3E7BCE, 0x5121CE64, 0x774FBE32,
     0xA8B6E37E, 0xC3293D46, 0x48DE5369, 0x6413E680,
     0xA2AE0810, 0xDD6DB224, 0x69852DFD, 0x09072166,
     0xB39A460A, 0x6445C0DD, 0x586CDECF, 0x1C20C8AE,
     0x5BBEF7DD, 0x1B588D40, 0xCCD2017F, 0x6BB4E3BB,
     0xDDA26A7E, 0x3A59FF45, 0x3E350A44, 0xBCB4CDD5,
     0x72EACEA8, 0xFA6484BB, 0x8D6612AE, 0xBF3C6F47,
     0xD29BE463, 0x542F5D9E, 0xAEC2771B, 0xF64E6370,
     0x740E0D8D, 0xE75B1357, 0xF8721671, 0xAF537D5D,
     0x4040CB08, 0x4EB4E2CC, 0x34D2466A, 0x0115AF84,
     0xE1B00428, 0x95983A1D, 0x06B89FB4, 0xCE6EA048,
     0x6F3F3B82, 0x3520AB82, 0x011A1D4B, 0x277227F8,
     0x611560B1, 0xE7933FDC, 0xBB3A792B, 0x344525BD,
     0xA08839E1, 0x51CE794B, 0x2F32C9B7, 0xA01FBAC9,
     0xE01CC87E, 0xBCC7D1F6, 0xCF0111C3, 0xA1E8AAC7,
     0x1A908749, 0xD44FBD9A, 0xD0DADECB, 0xD50ADA38,
     0x0339C32A, 0xC6913667, 0x8DF9317C, 0xE0B12B4F,
     0xF79E59B7, 0x43F5BB3A, 0xF2D519FF, 0x27D9459C,
     0xBF97222C, 0x15E6FC2A, 0x0F91FC71, 0x9B941525,
     0xFAE59361, 0xCEB69CEB, 0xC2A86459, 0x12BAA8D1,
     0xB6C1075E, 0xE3056A0C, 0x10D25065, 0xCB03A442,
     0xE0EC6E0E, 0x1698DB3B, 0x4C98A0BE, 0x3278E964,
     0x9F1F9532, 0xE0D392DF, 0xD3A0342B, 0x8971F21E,
     0x1B0A7441, 0x4BA3348C, 0xC5BE7120, 0xC37632D8,
     0xDF359F8D, 0x9B992F2E, 0xE60B6F47, 0x0FE3F11D,
     0xE54CDA54, 0x1EDAD891, 0xCE6279CF, 0xCD3E7E6F,
     0x1618B166, 0xFD2C1D05, 0x848FD2C5, 0xF6FB2299,
     0xF523F357, 0xA6327623, 0x93A83531, 0x56CCCD02,
     0xACF08162, 0x5A75EBB5, 0x6E163697, 0x88D273CC,
     0xDE966292, 0x81B949D0, 0x4C50901B, 0x71C65614,
     0xE6C6C7BD, 0x327A140A, 0x45E1D006, 0xC3F27B9A,
     0xC9AA53FD, 0x62A80F00, 0xBB25BFE2, 0x35BDD2F6,
     0x71126905, 0xB2040222, 0xB6CBCF7C, 0xCD769C2B,
     0x53113EC0, 0x1640E3D3, 0x38ABBD60, 0x2547ADF0,
     0xBA38209C, 0xF746CE76, 0x77AFA1C5, 0x20756060,
     0x85CBFE4E, 0x8AE88DD8, 0x7AAAF9B0, 0x4CF9AA7E,
     0x1948C25C, 0x02FB8A8C, 0x01C36AE4, 0xD6EBE1F9,
     0x90D4F869, 0xA65CDEA0, 0x3F09252D, 0xC208E69F,
     0xB74E6132, 0xCE77E25B, 0x578FDFE3, 0x3AC372E6]]


key_pbox = [0 for i in range(18)]
Encrypt = []


def init_key_pbox(_key):
    index = 0
    for i in range(18):
        for j in range(4):
            key_pbox[i] = ord(_key[index]) | (key_pbox[i] << 8)
            index += 1
            if index >= len(_key):
                index = 0

    for i in range(18):
        p_box[i] ^= key_pbox[i]


def Fn(Left):
    a = (Left & 0xff000000) >> 24
    b = (Left & 0x00ff0000) >> 16
    c = (Left & 0x0000ff00) >> 8
    d = Left & 0x000000ff

    Sa = s_box[0][a]
    Sb = s_box[1][b]
    Sc = s_box[2][c]
    Sd = s_box[3][d]

    return (((Sa + Sb) ^ Sc) + Sd) & 0xffffffff


def Blow_Main_Encrypt(Left, Right):
    for i in range(16):
        Left ^= p_box[i]
        Right ^= Fn(Left)
        Temp = Left
        Left = Right
        Right = Temp

    Temp = Left
    Left = Right ^ p_box[17]
    Right = Temp ^ p_box[16]
    return Left, Right


def Blow_Main_Decrypt(Left, Right):
    for i in range(17, 1, -1):
        Left ^= p_box[i]
        Right ^= Fn(Left)

        Temp = Left
        Left = Right
        Right = Temp

    Temp = Left
    Left = Right ^ p_box[0]
    Right = Temp ^ p_box[1]
    return Left , Right


def Change_Box():
    Left = 0
    Right = 0
    for i in range(0, 18, 2):
        Left, Right = Blow_Main_Encrypt(Left, Right)
        p_box[i] = Left
        p_box[i + 1] = Right

    for i in range(4):
        for j in range(0, 256, 2):
            Left, Right = Blow_Main_Encrypt(Left, Right)
            s_box[i][j] = Left
            s_box[i][j + 1] = Right


def BlowFish_Encrypt(data):
    while len(data) % 8:
        data += '0'
    cipher = ''
    for i in range(0, len(data), 8):
        Left = (ord(data[i]) << 24) | (ord(data[i + 1]) << 16) | (ord(data[i + 2]) << 8) | (ord(data[i + 3]))
        Right = (ord(data[i + 4]) << 24) | (ord(data[i + 5]) << 16) | (ord(data[i + 6]) << 8) | (ord(data[i + 7]))
        Left, Right = Blow_Main_Encrypt(Left, Right)
        cipher += hex(Left)[2:]
        cipher += hex(Right)[2:]
    global Encrypt
    Encrypt = []
    print(cipher)


def BlowFish_Decrypt(cipher):
    plain = ''
    for i in range(0, len(cipher), 16):
        Left = cipher[i:i + 8]
        Right = cipher[i + 8:i + 16]
        Left = int(Left, base=16)
        Right = int(Right, base=16)

        Left, Right = Blow_Main_Decrypt(Left, Right)
        plain += hex(Left)[2:]
        plain += hex(Right)[2:]

    plain = int(plain, base=16)
    print(Crypto.Util.number.long_to_bytes(plain))
    global Encrypt
    Encrypt = []


if __name__ == '__main__':
    key = 'secrettt'
    data = '11111111'
    cipher = 'f25e08ada7fe4eeb'
    init_key_pbox(key)
    Change_Box()

    BlowFish_Encrypt(data)

    BlowFish_Decrypt(cipher)

Misc

获取图片rbg

1
2
3
4
5
6
7
8
9
10
11
from PIL import Image
# open file
filename = 
image = Image.open(filename)
# select format
image = image.convert("RGB")
# Select coordinates
x = 
y = 
rgb = image.getpixel((x, y))
print(rgb)

01矩阵生成二维码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import qrcode
from PIL import Image

# 读取33*33的01矩阵
with open('matrix.txt', 'r') as f:
    matrix = [[int(x) for x in line.strip().split()] for line in f.readlines()]

# 根据01矩阵生成二维码图片
img = Image.new('RGB', (33, 33), color='white')
pixels = img.load()
for y in range(33):
    for x in range(33):
        if matrix[y][x] == 1:
            pixels[x, y] = (0, 0, 0)  # 黑色像素

# 保存二维码图片
img.save('qrcode.png')

Base64隐写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def base64_stego(lines):
    alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
    flag = ''
    temp = 0
    bit = 0
    for i in lines:
        if i[-1] != '=':			# 无等号
            continue
        elif i[-2] != '=':			# 单等号，取出倒数第二个字符的后两位
            bit += 2				
            temp = (temp << 2) + (alphabet.find(i[-2]) & 0x3)
        else:						# 双等号，取出倒数第三个字符的后四位
            bit += 4				
            temp = (temp << 4) + (alphabet.find(i[-3]) & 0xf)
        if bit == 8:				# 所取bit够一个字节，转为chr
            bit = 0
            flag += chr(temp)
            temp = 0
        elif bit > 8:				# 4+2+4，取8位，保存多余两位
            bit = 2
            flag += chr(temp >> 2)
            temp = temp & 0x3
    return flag

CRC32图片宽高爆破

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import struct
import zlib

def hexStr2bytes(s):
    b = b""
    for i in range(0,len(s),2):
        temp = s[i:i+2]
        b +=struct.pack("B",int(temp,16))
    return b

str1="49484452"			# IHDR
str2="0806000000"
bytes1=hexStr2bytes(str1)
bytes2=hexStr2bytes(str2)
wid,hei = 1918,864		# W & h

crc32 = "0x7dc73f7f"	# CRC32

for w in range(wid,wid+2000):
    for h in range(hei,hei+2000):
        width = hex(w)[2:].rjust(8,'0')
        height = hex(h)[2:].rjust(8,'0')
        bytes_temp=hexStr2bytes(width+height)
        if eval(hex(zlib.crc32(bytes1+bytes_temp+bytes2))) == eval(crc32):
            print(hex(w),hex(h))

对比文件差异

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def compare_files(file1, file2):
    with open(file1, 'rb') as f1, open(file2, 'rb') as f2:
        bytes1 = f1.read()
        bytes2 = f2.read()

    if bytes1 == bytes2:
        print("文件内容完全相同！")
    else:
        if len(bytes1) != len(bytes2):
            print("文件大小不同！")

        diff_bytes = []
        for i, (b1, b2) in enumerate(zip(bytes1, bytes2)):
            if b1 != b2:
                diff_bytes.append((i, b1, b2))

        if diff_bytes:
            print("文件存在差异：")
            for offset, byte1, byte2 in diff_bytes:
                print(f"偏移量: {offset}, 文件1字节: 0x{byte1:02X}, 文件2字节: 0x{byte2:02X}")
        else:
            print("文件内容相同！")


# 用法示例
file1_path = 'License-decrypted.bin'
file2_path = 'temp23'
compare_files(file1_path, file2_path)

图片低位提取

1
2
3
4
5
6
7
8
9
10
11
# 提取低位
import cv2
import numpy as np

img = cv2.imread("turing.png", cv2.IMREAD_UNCHANGED) 

img2 = img & 0xFF   
img2 = img2.astype(np.uint8)

cv2.imwrite("turing1.png", img2)

Logistic混沌变换加密

基于混沌Logistic加密算法的图片加密与还原（python） - HOr7z - 博客园 (cnblogs.com)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import cv2
import numpy as np
from PIL import Image

def logistic(Img, x, u,times):
    M = Img.shape[0]
    N = Img.shape[1]
    for i in range(1, times):
        x = u * x * (1 - x)
    array = np.zeros(M * N)
    array[1] = x
    for i in range(1, M * N - 1):
        array[i + 1] = u * array[i] * (1 - array[i])
    array = np.array(array * 255, dtype='uint8')
    code = np.reshape(array, (M, N))
    xor = Img ^ code
    v = xor
    return v

x = 0.114514
u = 3.1415
times = 500

Img = cv2.imread('turing1.png')
Img = Img[:, :, [2, 1, 0]]
(r, g, b) = cv2.split(Img)
R = logistic(r, x, u, times)
G = logistic(g, x, u, times)
B = logistic(b, x, u, times)
merged = np.ones(Img.shape, dtype=np.uint8)
merged[:, :, 2] = B
merged[:, :, 1] = G
merged[:, :, 0] = R

Img = Image.fromarray(merged)
Img.save('turing1_logistic.png')

爬取edu的名字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import requests,time
from lxml import etree

def edu_list(page0,page1):
    for page in range(page0,page1+1):
        try:
            url='https://src.sjtu.edu.cn/rank/firm/0/?page='+str(page)
            data=requests.get(url).content
            soup = etree.HTML(data.decode('utf-8'))
            result = soup.xpath('//td[@class="am-text-center"]/a/text()')
            results = ' '.join(result)
            print(results)
            resultss=results.split()
            for edu in resultss:
                with open(r'src.txt', 'a+',encoding='utf-8') as f:
                    f.write(edu+'\n')
                    f.close()
        except Exception as e:
            time.sleep(0.5)
            pass

if __name__ == '__main__':
    edu_list(1,100)

用必应搜索获取edu的网址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import requests
from urllib.parse import quote
from bs4 import BeautifulSoup


schools = []
with open('src.txt', 'r', encoding='utf-8') as f:
    lines = f.readlines()
for line in lines:
    schools.append(line.strip())


for school in schools:
    temp = school
    try:
        school = quote(school)
        school = str(school)
        # 构造搜索URL
        search_url = f'https://cn.bing.com/search?q={school}'
        # 发送请求
        response = requests.get(search_url)

        # 使用BeautifulSoup解析HTML
        soup = BeautifulSoup(response.text, 'html.parser')
        # 查找第一个搜索结果的链接
        link = soup.find('cite').text
        with open(r'list.txt', 'a+', encoding='utf-8') as f:
            f.write(link+'\n')
            f.close()
        print(link)
    except:
        print(f'无法获取 {temp} 的官方网站')
        continue

读取csv文件的某一列

1
2
3
4
5
6
7
import csv
with open('huanqiu.com.csv') as csv_file:
    csv_reader = csv.reader(csv_file)     # 创建 CSV 读取器
    first_column = []                     # 创建空列表
    for row in csv_reader:
        first_column.append(row[0])       # 将每行的第一列添加到列表中
print(first_column)                       # 打印列表

调用浏览器打开列表中的网站

1
2
3
4
5
6
import webbrowser
import time
def open_urls_with_edge(st,en,url_list):
    for i in range(st,en):
        webbrowser.open(url_list[i], new=2)  # new=2 在新的浏览器页签中打开 url
        time.sleep(2)

像素提取

1
2
3
4
5
6
7
8
9
10
11
from PIL import Image
# open file
filename = 
image = Image.open(filename)
# select format
image = image.convert("RGB")
# Select coordinates
x = 
y = 
rgb = image.getpixel((x, y))
print(rgb)

绘制散点图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import matplotlib.pyplot as plt

x_coords = []
y_coords = []

# 绘制
plt.scatter(x_coords, y_coords)
# 设置标题
plt.title("Scatter Plot")
# 设置xy轴标签
plt.xlabel("X-axis")
plt.ylabel("Y-axis")

plt.show()