NSSCTF_RE（二）暑期

news2024/11/13 23:12:49

[CISCN 2021初赛]babybc

在这里插入图片描述
LLVM是那个控制流平坦化混淆，bc是IR指令文件
在这里插入图片描述
在这里插入图片描述
得到64位elf文件
然后就慢慢分析，感觉太妙了我靠
一个数独游戏，用二个二维数组添加约束，一个二维数组作地图，慢慢看
最后用 z3 来解数独，也是 vary nice
在这里插入图片描述

from z3 import *

from hashlib import md5

# 限制条件

rowss = [[0x00, 0x00, 0x00, 0x01],

         [0x01, 0x00, 0x00, 0x00],

         [0x02, 0x00, 0x00, 0x01],

         [0x00, 0x00, 0x00, 0x00],

         [0x01, 0x00, 0x01, 0x00]]

# 限制条件

colnms = [[0x00, 0x00, 0x02, 0x00, 0x02],

          [0x00, 0x00, 0x00, 0x00, 0x00],

          [0x00, 0x00, 0x00, 0x01, 0x00],

          [0x00, 0x01, 0x00, 0x00, 0x01]]

s = Solver()

# 初始化题目

map = [[None] * 5,

       [None] * 5,

       [None] * 5,

       [None] * 5,

       [None] * 5]

for i in range(5):

    for j in range(5):
        map[i][j] = Int("x%d%d" % (i, j))  # 先初始化设置未知数

s.add(map[2][2] == 4)

s.add(map[3][3] == 3)  # 添加条件: 有两个位置已知

# 设置限制条件

for i in range(5):

    for j in range(5):
        s.add(map[i][j] >= 1)

        s.add(map[i][j] <= 5)  # 添加条件: 填的数字为1-5

for i in range(5):

    for j in range(5):

        for k in range(j):
            s.add(map[i][j] != map[i][k])  # 添加条件: 一行中不能有相同

for j in range(5):

    for i in range(5):

        for k in range(i):
            s.add(map[i][j] != map[k][j])  # 添加条件: 一列中不能有相同

for i in range(5):

    for j in range(4):

        if rowss[i][j] == 1:

            s.add(map[i][j] > map[i][j + 1])

        elif rowss[i][j] == 2:

            s.add(map[i][j] < map[i][j + 1])  # 根据题目分析添加条件

for i in range(4):

    for j in range(5):

        if colnms[i][j] == 2:

            s.add(map[i][j] > map[i + 1][j])

        elif colnms[i][j] == 1:

            s.add(map[i][j] < map[i + 1][j])  # 根据题目分析添加条件

answer = s.check()

if answer == sat:

    print(s.model())

    m = s.model()

    flag = []

    for i in map:

        for j in i:
            flag.append(m[j].as_long())

    print(flag)

    for i in range(len(flag)):
        flag[i] += 48

    flag[12] = 48

    flag[18] = 48

    flag = bytes(flag)

    print("CISCN{%s}" % md5(flag).hexdigest())

# Flag=CISCN{8a04b4597ad08b83211d3adfa1f61431}

[HNCTF 2022 WEEK4]ez_maze

uncompyle6不能反编译pyc
pycdc打开，就是一个简单的31*31的maze，不过需要注意的是只能走0
学着写了一个 DFS 解密脚本

from hashlib import md5
map1 = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
        [1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1],
        [1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1],
        [1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1],
        [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1],
        [1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1],
        [1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1],
        [1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1],
        [1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1],
        [1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1],
        [1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1],
        [1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1],
        [1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1],
        [1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1],
        [1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
        [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1],
        [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1],
        [1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1],
        [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1],
        [1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1],
        [1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
        [1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
        [1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
        [1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
        [1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1],
        [1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1],
        [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1],
        [1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1],
        [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
        ]
# record go track
map2=[[0 for _ in range(len(map1))] for _ in range(len(map1))]
flag=""

def DFS(row,col):
    global flag
    go=0
    if row==29 and col==29: # finally
        print(flag)
        res=flag
        return res
    # first check next row whether can go and be noticed
    if map1[row+1][col]==go and map2[row+1][col]==0:
        # if can,go and notice and 递归
        map2[row][col]=1
        flag+='s'
        DFS(row+1,col)
        # 回溯操作
        flag=flag[:-1]
        map2[row][col]=0
    if map1[row-1][col]==go and map2[row-1][col]==0:
        map2[row][col]=1
        flag+='w'
        DFS(row-1,col)
        flag=flag[:-1]
        map2[row][col]=0
    if map1[row][col-1]==go and map2[row][col-1]==0:
        map2[row][col]=1
        flag+='a'
        DFS(row,col-1)
        flag=flag[:-1]
        map2[row][col]=0
    if map1[row][col+1]==go and map2[row][col+1]==0:
        map2[row][col]=1
        flag+='d'
        DFS(row,col+1)
        flag=flag[:-1]
        map2[row][col]=0

if __name__ == '__main__':
    start_row=1
    start_col=1
    DFS(start_row,start_col)
    enc='ssssddssaassddddwwwwddwwddddddwwddddddssddwwddddddddssssaawwaassaassaassddssaassaawwwwwwaaaaaaaassaassddddwwddssddssssaassddssssaaaaaawwddwwaawwwwaassssssssssssddddssddssddddddddwwaaaaaawwwwddssddwwwwwwwwddssddssssssssddddss'
    enc=enc.encode()
    print(md5(enc).hexdigest())

[GDOUCTF 2023]L！s！

在这里插入图片描述
两个 64位的elf文件
一个应该是 patch 了
两个程序的main好像差不多都是一千多行代码，前面有很多case语句
结合文件的名字，这两个文件可能只有一点细微的差异，其他内容都是一样的

识别二进制文件中的差异，可以使用 IDA 的 BinDiff 插件
工具下的有点问题，烦 jdk 0.0
算了，反正来学一下解密
厨子的使用
感觉自己很多都不会用啊，学学
在这里插入图片描述
在这里插入图片描述
记一下：

def little_endian(num, width_num):  # 将小端序转换为正序  
    global buffer  
    hex_str = hex(num)  # 将int数据转换为十六进制的字符串  
    while len(hex_str) != width_num + 2:  
        hex_str = "0x" + "0" * (width_num - len(hex_str[2:])) + hex_str[2:]  # 位数不足width的用0凑齐  
    index = width_num  
    while index >= 2:  
        tmp = int((hex_str[index: index + 2]), 16)  # 每两位string转换为十六进制int型数据  
        buffer.append(tmp)  # 将int型作为char存入buffer  
        index -= 2  
    return buffer  
  
  
buffer = []  # 存放结果的列表  
  
lmao1 = 0x7D2E370A180F1604  
lmao2 = 0x3F7D132A2A252822  
lmao3 = 0x392A7F3F39132D13  
lmao4 = 0x31207C7C381320  
  
little_endian(lmao1, 16)  
little_endian(lmao2, 16)  
little_endian(lmao3, 16)  
little_endian(lmao4, 14)  
  
print(buffer)  
# [4, 22, 15, 24, 10, 55, 46, 125, 34, 40, 37, 42, 42, 19, 125, 63, 19, 45, 19, 57, 63, 127, 42, 57, 32, 19, 56, 124, 124, 32, 49]  
  
for key in range(256):  # 直接爆破key  
    flag = ""  
    print("key = ", key)  
    for k in range(len(buffer)):  
        tmp = buffer[k] ^ key  # 逐个与key异或  
        flag += chr(tmp)  # 对应的字符存入flag  
    print(flag)  
    if 'HZCTF' in flag or 'NSSCTF' in flag:  # 只输出包含'HZCTF'或'NSSCTF'的结果  
        break

注意学习了那个端序的处理
也还有一种，不过不太好记

import struct  
  
stack_bytes = [  
    0x7d2e370a180f1604,  
    0x3f7d132a2a252822,  
    0x392a7f3f39132d13,  
    0x31207c7c381320  
]  
  
# 将stack_bytes中的数据按照小端字节序打包为二进制数据  
xored_bytes = struct.pack("<4Q", *stack_bytes)  
# 其中，< 表示小端序，Q代表一个无符号长整型  
# 每个无符号长整型整数占8个字节，所以总共打包出来的字符串长度为32个字节  
# b'\x04\x16\x0f\x18\n7.}"(%**\x13}?\x13-\x139?\x7f*9 \x138|| 1\x00'  
  
for xorkey in range(256):  
    output = bytes(byte ^ xorkey for byte in xored_bytes)  
    if b"HZCTF{" in output:  
        print(output)  
  
# b'HZCTF{b1ndiff_1s_a_us3ful_t00l}L'  
# （因为在lmao4的高位补了一个0，所以多输出了一个L）

Art

在这里插入图片描述
在这里插入图片描述
angr 跑了半天没出来
只能爆破了
在这里插入图片描述

flag=[0]*27+[125]
enc=[2,  24,  15, 248,  25,   4,  39, 216, 235,   0,
   53,  72,  77,  42,  69, 107,  89,  46,  67,   1,
   24,  92,9, 9, 9, 9, 181, 125]
# for i in range(1,len(enc),1):
#     Str1[i - 1] ^= (Str1[i - 1] % 17 + Str1[i]) ^ 25
#     str[i-1]=sre[i-1]^25^(str[i-1]%17+str[i])
#     str[26]=str[26]^25^(str[26]%17+str[27])
def dfs(index):
    if index ==0:
        for j in flag:
            print(chr(j),end='')
        print()
    else:
        for i in range(32,128,1):
            if (i^25)^(i%17+flag[index])==enc[index-1]:
                flag[index-1]=i
                dfs(index-1)
dfs(27)
# (i^25)^(i%17+flag[27])==enc[26]

对于逆向来说，算法还是很重要的

不可大意

在这里插入图片描述
要注意顺序

z3使用

from z3 import *
s=Solver()
charArray=[BitVec(f"charArray[{i}]",8) for i in range(9)]
s.add((charArray[0] * 4778) + (charArray[1] * 3659) + (charArray[2] * 9011) + (charArray[3] * 5734) + (charArray[4] * 4076) + (charArray[5] * 6812) + (charArray[6] * 8341) + (charArray[7] * 6765) + (charArray[8] * 7435) == 5711942)
s.add((charArray[0] * 4449) + (charArray[1] * 5454) + (charArray[2] * 4459) + (charArray[3] * 5800) + (charArray[4] * 6685) + (charArray[5] * 6120) + (charArray[6] * 7357) + (charArray[7] * 3561) + (charArray[8] * 5199) == 4885863 )
s.add((charArray[0] * 3188) + (charArray[1] * 6278) + (charArray[2] * 9411) + (charArray[3] * 5760) + (charArray[4] * 9909) + (charArray[5] * 7618) + (charArray[6] * 7184) + (charArray[7] * 4791) + (charArray[8] * 8686) == 6387690)
s.add( (charArray[0] * 8827) + (charArray[1] * 7419) + (charArray[2] * 7033) + (charArray[3] * 9306) + (charArray[4] * 7300) + (charArray[5] * 5774) + (charArray[6] * 6588) + (charArray[7] * 5541) + (charArray[8] * 4628) == 6077067)
s.add( (charArray[0] * 5707) + (charArray[1] * 5793) + (charArray[2] * 4589) + (charArray[3] * 6679) + (charArray[4] * 3972) + (charArray[5] * 5876) + (charArray[6] * 6668) + (charArray[7] * 5951) + (charArray[8] * 9569) == 5492294)
s.add((charArray[0] * 9685) + (charArray[1] * 7370) + (charArray[2] * 4648) + (charArray[3] * 7230) + (charArray[4] * 9614) + (charArray[5] * 9979) + (charArray[6] * 8309) + (charArray[7] * 9631) + (charArray[8] * 9272) == 7562511)
s.add( (charArray[0] * 6955) + (charArray[1] * 8567) + (charArray[2] * 7949) + (charArray[3] * 8699) + (charArray[4] * 3284) + (charArray[5] * 6647) + (charArray[6] * 3175) + (charArray[7] * 8506) + (charArray[8] * 6552) == 5970432)
s.add( (charArray[0] * 4323) + (charArray[1] * 4706) + (charArray[2] * 8081) + (charArray[3] * 7900) + (charArray[4] * 4862) + (charArray[5] * 9544) + (charArray[6] * 5211) + (charArray[7] * 7443) + (charArray[8] * 5676) == 5834523)
s.add((charArray[0] * 3022) + (charArray[1] * 8999) + (charArray[2] * 5058) + (charArray[3] * 4529) + (charArray[4] * 3940) + (charArray[5] * 4279) + (charArray[6] * 4606) + (charArray[7] * 3428) + (charArray[8] * 8889) == 4681110)

if s.check()==sat:
    m=s.model()
    print(m)
    print(len(m))
    data=[]
    for i in range(9):
        data.append((m[charArray[i]].as_long()))
    for i in range(9):
        print(chr(data[i]),end='')

TEA_Apk

在这里插入图片描述
还有一个 base64

最外面函数
在这里插入图片描述
在这里插入图片描述

看的太头疼了

中间函数
在这里插入图片描述
也是大致清楚了，就是将 byte 转 int

barr.length & 3 (11) == 0

相当于 / 4 ，算出 int 的长度
然后根据 z 来 new int 数组空间，如果 true ，长度加一，最后元素为原计算长度
，false 就是原长度

( bArr[i] & 255) << ( ( i & 3) << 3 ) | iArr[i2]

byte - int 关键， &255 确保在 0-255 之间， ( ( i & 3) << 3 ) 算偏移

>>> 无符号右移

里面
在这里插入图片描述
这个应该只是检查长度是否是16
wp 看了一下，原来一整个是 XXTEA 加密，工具直接可以解，不过还是分析了一下，确实很难逆
翻半天，就只有一个大佬的脚本

import base64
from ctypes import c_uint32

import libnum

DELTA = 0x9E3779B9


def decrypt(v, n, k):
    rounds = 6 + int(52 / n)
    sum = c_uint32(rounds * DELTA)
    y = v[0].value
    while rounds > 0:
        e = (sum.value >> 2) & 3
        p = n - 1
        while p > 0:
            z = v[p - 1].value
            v[p].value -= (((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4)) ^ ((sum.value ^ y) + (k[(p & 3) ^ e] ^ z)))
            y = v[p].value
            p -= 1
        z = v[n - 1].value
        v[0].value -= (((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4)) ^ ((sum.value ^ y) + (k[(p & 3) ^ e] ^ z)))
        y = v[0].value
        sum.value -= DELTA
        rounds -= 1


enc = "vlgg9nNjUcYuWzBSSOwKxbMD2rhFgf4zuiyMpLxpNkM="
key = "ABvWW7hqwNvHUhfP"
enc = base64.b64decode(enc.encode())
print(enc)
e = list(map(lambda i: c_uint32(int(enc[i:i + len(enc) // 8][::-1].hex(), 16)), range(0, len(enc), len(enc) // 8)))
print(e)
k = list(map(lambda i: int(key[i:i + len(key) // 4].encode()[::-1].hex(), 16), range(0, len(key), len(key) // 4)))
print(k)
decrypt(e, len(e), k)
print(b''.join(map(lambda x: libnum.n2s(x.value)[::-1], e)))

研究一下

[长城杯 2021 院校组]Just_cmp-re

估计是 hook strcmp 了吧
在这里插入图片描述
运行到 call 报错了
在这里插入图片描述
翻到了这个函数
额，就很逆向

data=[  0x00, 0x00, 0x00, 0x00, 0x00, 0x37, 0x07, 0x0A, 0x37, 0x0A,
  0x08, 0x0A, 0x06, 0x06, 0x0B, 0x38, 0x07, 0x0A, 0x3B, 0x08,
  0x38, 0x0E, 0x0F, 0x3B, 0x3A, 0x0A, 0x0B, 0x06, 0x09, 0x07,
  0x3B, 0x37, 0x0D, 0x0F, 0x07, 0x38, 0x0F, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
enc='flag{********************************}'
flag=''
for i in range(len(enc)):
    flag+=chr(ord(enc[i])+data[i])
print(flag)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1926502.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

k8s快速部署一个网站

k8s快速部署一个网站

1&#xff09;使用Deployment控制器部署镜像&#xff1a; kubectl create deployment web-demo --imagelizhenliang/web-demo:v1 kubectl get deployment,pods[rootk8s-matser ~]# kubectl get pods NAME READY STATUS RESTARTS A…
阅读更多...
25届平安产险校招测评IQ新16PF攻略：全面解析与应试策略

25届平安产险校招测评IQ新16PF攻略：全面解析与应试策略

尊敬的读者&#xff0c;您好。随着平安产险校招季的到来&#xff0c;许多应届毕业生正积极准备着各项测评。本文旨在提供一份详尽的测评攻略&#xff0c;帮助您更好地理解平安产险的校招测评流程&#xff0c;以及如何有效应对。 25届平安产险平安IQ&#xff08;新&#xff09;测…
阅读更多...
Java 设计模式系列：外观模式

Java 设计模式系列：外观模式

简介 外观模式&#xff08;Facade Pattern&#xff09;是一种设计模式&#xff0c;又名门面模式&#xff0c;是一种通过为多个复杂的子系统提供一个一致的接口&#xff0c;而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口&#xff0c;外部应用程序不用关心内部…
阅读更多...
2024-07-14 Unity插件 Odin Inspector2 —— Essential Attributes

2024-07-14 Unity插件 Odin Inspector2 —— Essential Attributes

文章目录 1 说明2 重要特性2.1 AssetsOnly / SceneObjectsOnly2.2 CustomValueDrawer2.3 OnValueChanged2.4 DetailedInfoBox2.5 EnableGUI2.6 GUIColor2.7 HideLabel2.8 PropertyOrder2.9 PropertySpace2.10 ReadOnly2.11 Required2.12 RequiredIn&#xff08;*&#xff09;2.…
阅读更多...
基于Python thinker GUI界面的股票评论数据及投资者情绪分析设计与实现

基于Python thinker GUI界面的股票评论数据及投资者情绪分析设计与实现

1.绪论 1.1背景介绍 Python 的 Tkinter 库提供了创建用户界面的工具&#xff0c;可以用来构建股票评论数据及投资者情绪分析的图形用户界面&#xff08;GUI&#xff09;。通过该界面&#xff0c;用户可以输入股票评论数据&#xff0c;然后通过情感分析等技术对评论进行情绪分析…
阅读更多...
昇思25天学习打卡营第14天 | ShuffleNet图像分类

昇思25天学习打卡营第14天 | ShuffleNet图像分类

昇思25天学习打卡营第14天 | ShuffleNet图像分类 文章目录 昇思25天学习打卡营第14天 | ShuffleNet图像分类ShuffleNetPointwise Group ConvolutionChannel ShuffleShuffleNet模块网络构建 模型训练与评估数据集训练模型评估模型预测 总结打卡 ShuffleNet ShuffleNetV1是旷世科…
阅读更多...
大模型系列3--pytorch dataloader的原理

大模型系列3--pytorch dataloader的原理

pytorch dataloader运行原理 1. 背景2. 环境搭建2.1. 安装WSL & vscode2.2. 安装conda & pytorch_gpu环境 & pytorch 2.112.3 命令行验证python环境2.4. vscode启用pytorch_cpu虚拟环境 3. 调试工具3.1. vscode 断点调试3.2. py-spy代码栈探测3.3. gdb attach3.4. …
阅读更多...
基于锚框的物体检测过程

基于锚框的物体检测过程

说明&#xff1a;基于锚框的物体检测过程&#xff1a;分为单阶段和两阶段 整体步骤&#xff1a; 提供目标候选区域&#xff1a; 锚框提供了一组预定义的候选区域&#xff0c;这些区域可以覆盖各种尺度和长宽比的目标。通过这些锚框&#xff0c;可以在不同的位置和不同的尺度上…
阅读更多...
02-Charles的安装与配置

02-Charles的安装与配置

一、Charles的安装 Charles的下载地址&#xff1a;https://www.charlesproxy.com/。 下载之后&#xff0c;傻瓜式安装即可。 二、Charles组件介绍 主导航栏介绍&#xff1a; 请求导航栏介绍&#xff1a; 请求数据栏介绍&#xff1a; 三、Charles代理设置 四、客户端-windows代理…
阅读更多...
【Linux】多线程_6

【Linux】多线程_6

文章目录 九、多线程7. 生产者消费者模型生产者消费者模型的简单代码结果演示 未完待续 九、多线程 7. 生产者消费者模型 生产者消费者模型的简单代码 Makefile&#xff1a; cp:Main.ccg -o $ $^ -stdc11 -lpthread .PHONY:clean clean:rm -f cpThread.hpp&#xff1a; #i…
阅读更多...
React学习笔记02-----

React学习笔记02-----

一、React简介 想实现页面的局部刷新&#xff0c;而不是整个网页的刷新。AJAXDOM可以实现局部刷新 1.特点 &#xff08;1&#xff09;虚拟DOM 开发者通过React来操作原生DOM&#xff0c;从而构建页面。 React通过虚拟DOM来实现&#xff0c;可以解决DOM的兼容性问题&#x…
阅读更多...
NSSCTF_RE（一）暑期

NSSCTF_RE（一）暑期

[SWPUCTF 2021 新生赛]简单的逻辑 nss上附件都不对 没看明白怎么玩的 dnspy分析有三个 AchievePoint , game.Player.Bet - 22m; for (int i 0; i < Program.memory.Length; i) { byte[] array Program.memory; int num i; array[num] ^ 34; } Environment.SetEnvironment…
阅读更多...
【CICID】GitHub-Actions-SpringBoot项目部署

【CICID】GitHub-Actions-SpringBoot项目部署

[TOC] 【CICID】GitHub-Actions-SpringBoot项目部署 0 流程图 1 创建SprinBoot项目 ​ IDEA创建本地项目&#xff0c;然后推送到 Github 1.1 项目结构 1.2 Dockerfile文件 根据自身项目&#xff0c;修改 CMD ["java","-jar","/app/target/Spri…
阅读更多...
Scrapy框架实现数据采集的详细步骤

Scrapy框架实现数据采集的详细步骤

需求描述&#xff1a; 本项目目标是使用Scrapy框架从宁波大学经济学院网站&#xff08;nbufe.edu.cn&#xff09;爬取新闻或公告详情页的内容。具体需求如下&#xff1a; 1、通过遍历多个页面&#xff08;共55页&#xff09;构建翻页URL。 2、使用scrapy自带的xpath从每页的…
阅读更多...
STM32智能机器人避障系统教程

STM32智能机器人避障系统教程

目录 引言环境准备智能机器人避障系统基础代码实现&#xff1a;实现智能机器人避障系统 4.1 数据采集模块 4.2 数据处理与控制模块 4.3 通信与网络系统实现 4.4 用户界面与数据可视化应用场景&#xff1a;机器人导航与避障问题解决方案与优化收尾与总结 1. 引言 智能机器人避…
阅读更多...
Android ImageDecoder把瘦高/扁平大图相当于fitCenter模式decode成目标小尺寸Bitmap，Kotlin

Android ImageDecoder把瘦高/扁平大图相当于fitCenter模式decode成目标小尺寸Bitmap，Kotlin

Android ImageDecoder把瘦高/扁平大图相当于fitCenter模式decode成目标小尺寸Bitmap&#xff0c;Kotlin val sz Size(MainActivity.SIZE, MainActivity.SIZE)val src ImageDecoder.createSource(mContext?.contentResolver!!, uri)val bitmap ImageDecoder.decodeBitmap(sr…
阅读更多...
iPhone数据恢复篇：在 iPhone 上恢复找回短信的 5 种方法

iPhone数据恢复篇：在 iPhone 上恢复找回短信的 5 种方法

方法 1&#xff1a;检查最近删除的文件夹 iOS 允许您在 30 天内恢复已删除的短信。您需要先从“设置”菜单启用“过滤器”。让我们来实际检查一下。 步骤 1&#xff1a;打开“设置” > “信息”。 步骤 2&#xff1a;选择“未知和垃圾邮件”&#xff0c;然后切换到“过滤…
阅读更多...
全开源批量SEO外链工具html源码

全开源批量SEO外链工具html源码

全开源批量SEO外链工具html源码&#xff0c;已更新增加大量高质量外链 若需要增加修改其他外链请打开txt文件 修复优化页面端代码&#xff0c;界面布局 源码为自适应端&#xff0c;手机和电脑端都适配 源码下载&#xff1a;https://download.csdn.net/download/m0_66047725…
阅读更多...
Redis作为缓存，如何保证MySQL数据库与Redis缓存一致性（双写一致性）？

Redis作为缓存，如何保证MySQL数据库与Redis缓存一致性（双写一致性）？

双写一致性&#xff1a;当修改了数据库的数据也要同时更新缓存的数据&#xff0c;缓存和数据库的数据要保持一致。 强一致性&#xff1a;如果项目要求数据库与Redis保持高度一致&#xff0c;可以采用读写锁保证强一致性。采用redisson实现的读写锁&#xff0c;在读的时候添加共…
阅读更多...
基于单片机的停车场车位管理系统设计

基于单片机的停车场车位管理系统设计

1.简介 停车场车位管理系统是日常中随处可见的一种智能化车位管理技术&#xff0c;使用该技术可以提高车位管理效率&#xff0c;从而减轻人员车位管理工作负荷。本系统集成车牌识别、自动放行、自助缴费等技术&#xff0c;并且具备车位占用状态实时监测与车位数量实时统计、查询…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023