数据安全及数据安全CTF题目解题方法的总结
在安全领域中,“数据安全”通常不是一个抽象的概念,而是一系列需要你通过黑客技术去发现、利用或修复的具体漏洞和挑战。它主要聚焦于“攻击视角”下的数据安全,即数据是如何因为不安全的实践而泄露或被篡改的。
数据安全
在安全领域中,“数据安全”通常不是一个抽象的概念,而是一系列需要你通过黑客技术去发现、利用或修复的具体漏洞和挑战。它主要聚焦于 “攻击视角” 下的数据安全,即数据是如何因为不安全的实践而泄露或被篡改的。
一般有数据识别与审计,数据清洗,数据删除与恢复,数据脱敏等
基础知识掌握
常见数据特征
个人身份与标识类
1.手机号:11位数字且第一位数字是1
( 第二位和第三位数字代表了不同的运营商和归属地,目前已经开放到 3-9)
2.身份证号 :
- 格式:18位(15位已基本淘汰)。
- 规则:前6位为地址码,中间8位为出生日期,后4位为顺序码和校验码。
- 正则示例:
\d{17}[\dXx]
3.姓名:
- 格式:通常为2-4个汉字。
- 注意:也有少数民族或特殊情况包含间隔点
·。 - 正则示例:
[\u4e00-\u9fa5]{2,4}或[\u4e00-\u9fa5·]{2,5}
3.用户名/账号:
- 格式:通常为数字、字母、下划线的组合,长度在4-20位之间。
- 正则示例:
[a-zA-Z0-9_]{4,20}
网络与通信类
1.IP地址:
- IPv4:
192.168.1.1,四个0-255的数字用点分隔。^(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$ - IPv6:
2001:0db8::ff00:0042:8329,更复杂,由冒号分隔的十六进制块组成。\b(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}\b
2.Mac地址:
XX:XX:XX:XX:XX:XX
- 长度固定: 48位(6个字节)的二进制数,通常用12个十六进制字符表示。
- 格式: 最常见的表示方法是用分隔符(冒号
:或连字符-)将12个字符每两个一组分开,形成XX:XX:XX:XX:XX:XX的格式。 - 字符范围: 十六进制数字,即
0-9和A-F(不区分大小写)。
3.邮箱地址:
- 格式:
用户名@域名.顶级域名。 - 规则:用户名部分通常允许数字、字母、点、下划线等;域名部分遵循主机名规则。
- 正则示例:
[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}
4.URL:
- 格式:包含协议、域名、路径、参数等。
- 正则示例:
https?://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(/\S*)?
时间与日期类
1.日期:
- 常见格式:
YYYY-MM-DD,YYYY/MM/DD,YYYY年MM月DD日。 - 正则示例 (YYYY-MM-DD):
\d{4}-\d{1,2}-\d{1,2}
2.时间:
- 常见格式:
HH:MM:SS或HH:MM。 - 正则示例:
\d{1,2}:\d{2}(:\d{2})?
地理与位置类
1.邮政编码:
- 中国:6位数字。
- 正则示例:
\d{6}
2.车牌号:
- 中国:汉字(省份) + 字母(城市) + 数字和字母混合。
- 正则示例 (简化):
[\u4e00-\u9fa5][A-Z][A-Z0-9]{4,5}
代码与序列类
- MD5哈希值
- 格式:32个十六进制字符。
- 正则示例:
[a-fA-F0-9]{32}
- SHA1哈希值
- 格式:40个十六进制字符。
- 正则示例:
[a-fA-F0-9]{40}
- Base64编码
- 格式:由大小写字母、数字、
+、/和=组成。 - 正则示例:
[A-Za-z0-9+/]{20,}={0,2}
正则表达式
正则表达式是一种用于匹配和处理文本的强大工具。它使用一种特殊的字符序列来描述、检查一个字符串是否满足某种复杂的模式。
简单来说,它就是一套“文本匹配规则”,在数据安全里面常用于数据提取方面
正则表达式及示例:
1.手机号
^1[3-9]\d{9}$^:匹配字符串的开始。1:第一位必须是1。[3-9]:第二位必须是3-9之间的一个数字。\d{9}:后面跟着任意9个数字。$:匹配字符串的结束。
2.mac地址
^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$^:匹配字符串的开始。([0-9A-Fa-f]{2}[:-]){5}:匹配一个“两个十六进制字符 + 一个冒号或连字符”的单元,并重复5次。([0-9A-Fa-f]{2}):匹配最后两个十六进制字符。$:匹配字符串的结束。
正则表达式在数据安全中的应用**
1. 数据识别与提取
这是最常见的用途。当你从内存镜像、网络流量或日志文件中拿到一大段杂乱无章的文本时,可以用正则表达式快速定位关键信息。
- 查找Flag:
flag{[^}]+}或CTF{[^}]+}
- 解释:匹配以
flag{开头,后面跟着一个或多个}以外的字符[^}]+,直到遇到}为止。
- 查找邮箱:
\w+@\w+\.\w+
- 解释:匹配
单词字符@单词字符.单词字符。
- 查找IP地址:
\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3} - 查找SQL注入痕迹: 在日志中搜索
UNION.*SELECT,OR.1=1等模式。
2. Web应用防火墙规则
WAF经常使用正则表达式来检测和拦截恶意流量。
- 规则
/(union.*select)/i可以拦截大多数简单的UNION SELECT注入攻击。 - 规则
/<script.*?>/i可以用于检测反射型XSS攻击的初步特征。
正则表达基础代码
import re
# 基本元字符
pattern = r"正则表达式"
# 常用模式
r"\d+" # 一个或多个数字
r"\w+" # 字母、数字、下划线
r"[a-zA-Z]+" # 英文字母
r".*" # 任意字符(贪婪)
r".*?" # 任意字符(非贪婪)
r"(\d{4})-(\d{2})" # 分组捕获一些常见文件特性
1. PDF文件 - XSS和代码注入
常见攻击向量:
// PDF中的JavaScript执行
/JavaScript <</JS (app.alert('XSS'))>>
// 利用PDF表单漏洞
/AA <</O <</JS (app.alert(1))>>>
// URI动作注入
/A << /S /URI /URI (javascript:alert('XSS')) >>检测方法:
def detect_pdf_xss(pdf_content):
patterns = [
r"/JavaScript.*?<<.*?JS.*?\(.*?alert",
r"javascript:",
r"app\.alert",
r"/AA.*?<<.*?JS"
]
for pattern in patterns:
if re.search(pattern, pdf_content, re.IGNORECASE | re.DOTALL):
return True
return False例子:
打开出现弹窗
2. PNG文件 - CRC校验攻击
PNG文件结构:
PNG签名 (89 50 4E 47 0D 0A 1A 0A)
└── IHDR块 (图像头信息)
├── 长度 (4字节)
├── 类型 (4字节: "IHDR")
├── 数据 (13字节)
└── CRC (4字节: 校验前面数据)例子:
发现png最后一个块错误,在末尾发现恶意代码
3. 压缩文件 - 重复数据压缩
原理:
- 重复数据:
00 00 00 00...压缩后很小 - 实际案例:42.zip (42KB → 解压后4.5PB)
- 利用DEFLATE算法:重复模式高效压缩
4. JPEG - 注释和EXIF注入
# JPEG文件结构利用
FF FE - 注释段
- 可插入恶意脚本
- EXIF数据注入
# 检测代码
def check_jpeg_comments(jpeg_data):
markers = [b'\xFF\xFE', b'EXIF', b'Comment']
return any(marker in jpeg_data for marker in markers)数据识别与审计
数据识别与审计是数据安全的第一道防线,旨在系统性地发现、分类和评估组织内的敏感数据。在攻击视角下,这也是攻击者进行信息收集和敏感数据定位的关键阶段。
这一块主要运用的是对数据的熟悉程度和技巧
例如常见文件头文件尾,编码和正则表达式,为此给出两个例题进行讲解和拓展
文件格式题
例题1:2025轩辕杯数据安全(改编自2025数字中国[数据安全])
题目给了pdf,txt,png,wav四种文件类型,让找出信息泄露或者隐藏恶意代码的文件(每一个五个)
pdf根据之前讲的,可以注入代码,写个识别的就行
import os
import re
import csv
def contains_script(text):
return b'alert' in text
def process_directory(directory, output_csv):
"""遍历目录中的所有pdf文件"""
with open(output_csv, mode='w', newline='', encoding='utf-8') as csvfile:
csvwriter = csv.writer(csvfile)
# 写入CSV文件的表头
csvwriter.writerow(['Filename', 'Content'])
for root, dirs, files in os.walk(directory):
for file in files:
if file.endswith('.pdf'):
file_path = os.path.join(root, file)
with open(file_path, mode='rb') as f:
content = f.read()
# 检查文件内容是否包含数字
if contains_script(content):
csvwriter.writerow([file])
if __name__ == "__main__":
directory_to_search = 'pdf' # 替换为你要搜索的目录路径
output_csv_file = 'outputpdf.csv' # 输出CSV文件的名称
process_directory(directory_to_search, output_csv_file)对于png:
png尾部插入了一句话木马(这里是这样,通常也只能改尾部,改其他地方图片会损坏)
import os
def has_extra_data(file_path):
with open(file_path, 'rb') as f:
content = f.read()
# PNG 文件的尾部应该是 IEND 部分,长度为 12 字节
end_pos = len(content) - 8
if content[end_pos:end_pos + 8] == b'IEND\xaeB`\x82':
return None
else:
return content[end_pos-40:end_pos + 8]
def process_directory(directory):
for root, dirs, files in os.walk(directory):
for file in files:
if file.lower().endswith('.png'):
file_path = os.path.join(root, file)
extra_data = has_extra_data(file_path)
if extra_data:
# print(f"文件: {file_path}, 尾部额外数据: {extra_data}")
print(f"{file}")
if __name__ == "__main__":
directory_to_search = 'png' # 替换为你要搜索的目录路径
process_directory(directory_to_search)而对于txt,可以看到大部分都是文字评论,根据我们知道的敏感信息,基本上都是带数字字母的,写个脚本先筛一下这些,筛出来就是答案
import os
import re
import csv
def contains_digit(text):
"""检查文本是否包含数字"""
return bool(re.search(r'\d', text))
def contains_zimu(text):
return bool(re.search(r'[a-zA-Z]', text))
def process_directory(directory, output_csv):
"""遍历目录中的所有txt文件,并将包含数字或字母的文件名和内容写入CSV文件"""
with open(output_csv, mode='w', newline='', encoding='utf-8') as csvfile:
csvwriter = csv.writer(csvfile)
# 写入CSV文件的表头
csvwriter.writerow(['Filename', 'Content'])
for root, dirs, files in os.walk(directory):
for file in files:
if file.endswith('.txt'):
file_path = os.path.join(root, file)
with open(file_path, mode='r', encoding='utf-8') as f:
content = f.read()
# 检查文件内容是否包含数字
if contains_digit(content):
csvwriter.writerow([file, content])
elif contains_zimu(content):
csvwriter.writerow([file, content])
if __name__ == "__main__":
directory_to_search = 'txt' # 替换为你要搜索的目录路径
output_csv_file = 'output.csv' # 输出CSV文件的名称
process_directory(directory_to_search, output_csv_file)wav部分
1.用openai的whisper功能读取
import os
import whisper
from tqdm import tqdm # 用于显示进度条
def transcribe_wav_files(folder_path, model_size="base", output_file="transcriptions.txt"):
"""
使用Whisper转录文件夹中的所有WAV文件
参数:
folder_path (str): 包含WAV文件的文件夹路径
model_size (str): Whisper模型大小 (tiny, base, small, medium, large)
output_file (str): 保存转录结果的文本文件路径
"""
# 加载Whisper模型
print(f"Loading Whisper {model_size} model...")
model = whisper.load_model(model_size)
# 获取文件夹中的所有WAV文件
wav_files = [f for f in os.listdir(folder_path) if f.lower().endswith('.wav')]
if not wav_files:
print("No WAV files found in the specified folder.")
return
print(f"Found {len(wav_files)} WAV files to process.")
# 打开输出文件准备写入
with open(output_file, 'w', encoding='utf-8') as f_out:
# 处理每个WAV文件
for wav_file in tqdm(wav_files, desc="Processing WAV files"):
file_path = os.path.join(folder_path, wav_file)
try:
# 使用Whisper进行转录
result = model.transcribe(file_path)
# 写入结果到文件
f_out.write(f"File: {wav_file}\n")
f_out.write(f"Transcription: {result['text']}\n\n")
except Exception as e:
print(f"\nError processing {wav_file}: {str(e)}")
f_out.write(f"File: {wav_file}\n")
f_out.write(f"Error: {str(e)}\n\n")
print(f"\nTranscription complete. Results saved to {output_file}")
if __name__ == "__main__":
# 使用示例
folder_path = input("Enter the path to the folder containing WAV files: ")
# 可选:让用户选择模型大小
model_size = input("Choose model size (tiny/base/small/medium/large, default=base): ").strip().lower()
if model_size not in ['tiny', 'base', 'small', 'medium', 'large']:
model_size = "base"
transcribe_wav_files(folder_path, model_size)法二
发现大部分音频是空音频(00 00 00 00....)
zip里面查看
按压缩后大小排序,前五个就是答案,可以去听一下验证
这道题就是典型的识别文件格式的数据识别题目,写这种题,对文件的特性要熟悉
例题2:数字中国2025 模型环境安全题目1
题目: 根据公司内部的规定,在使用AI时,员工必须严格遵守不上传涉及公司敏感信息的要求。这些敏感信息 可能包括但不限于:用户的个人资料、财务报表、员工的个人信息、研发中的技术⽅案、内部通讯记 录、合同文件、商业机密、市场营销策略等任何可能对公司造成不利影响的机密数据。管理员在服务器 当中搭建了本地AI模型来帮助其办公,但在某次操作时违反了公司规定,管理员想要利用AI批量对包含 了用户隐私信息的图片进行批量格式转换。请选手访问文件服务器。获取""upload.zip""文件,分析 附件还原上传的数据、统计用户的隐私数据数量,将隐私数据数量,作为标准答案提交。 文件服务器账号密码:ftpuser/ftpuser 他是模型安全里面的数据安全,正常解法应该是OCR识别,但这个可以用他的特性
题目给的是upload文件
使用foremost-e提取,得到若干png图片,即为敏感信息
观察发现同样行数的png高度相同,所以可以统计png高度对应的图片数,和图片上的表项数,相乘即可算出答案
import os
from PIL import Image
def count_pngs_by_height(directory):
"""Count PNG files grouped by their height in pixels."""
height_count = {}
for root, dirs, files in os.walk(directory):
for file in files:
if file.lower().endswith('.png'):
file_path = os.path.join(root, file)
try:
with Image.open(file_path) as img:
height = img.height
height_count[height] = height_count.get(height, 0) + 1
except Exception as e:
print(f"无法打开文件 {file_path}: {e}")
return height_count
def calculate_expression(height_counts):
"""Calculate the expression based on height counts."""
# Create a mapping from height to multiplier
height_multiplier = {
672: 10,
733: 11,
794: 12,
855: 13,
916: 14,
977: 15,
1038: 16,
1099: 17,
1160: 18,
1221: 19,
1282: 20
}
total = 0
calculation_parts = []
for height, count in sorted(height_counts.items()):
if height in height_multiplier:
product = count * height_multiplier[height]
total += product
calculation_parts.append(f"{count} × {height_multiplier[height]}")
calculation_str = " + ".join(calculation_parts) + f" = {total}"
return total, calculation_str
def main():
directory_path = 'foremost_output/png'
# Count PNGs by height
height_counts = count_pngs_by_height(directory_path)
# Print height counts
print("PNG图片高度统计:")
for height, count in sorted(height_counts.items()):
print(f"像素高度 {height}: {count} 张图片")
# Calculate and print the expression
total, calculation = calculate_expression(height_counts)
print("\n计算结果:")
print(calculation)
if __name__ == "__main__":
main()
#像素高度 672: 48 张图片
#像素高度 733: 39 张图片
#像素高度 794: 50 张图片
#像素高度 855: 53 张图片
#像素高度 916: 51 张图片
#像素高度 977: 60 张图片
#像素高度 1038: 51 张图片
#像素高度 1099: 38 张图片
#像素高度 1160: 33 张图片
#像素高度 1221: 34 张图片
#像素高度 1282: 43 张图片
# 表达式为 43 × 20 + 34 × 19 + 33 × 18 + 38 × 17 + 51 × 16 + 60 × 15 + 51 × 14 + 53 × 13 + 50 × 12 + 39 × 11 + 48 × 10 = 7,374数据提取题
对于数据提取,之前提到过,是需要利用好正则表达式和一些便捷工具的,这类题目是可以靠积累来提升解题速度的,下面按常见文件的格式进行例题讲解
txt格式
例题:2025陇剑杯线下数据安全3
题目描述:
敏感数据识别,小明发现了一段乱序文本中混杂了PhoneNo,IMEI,IPv4,email四种数据类型。请你对其进行数据清洗。按照从上往下,从左往右的顺序分别提取PhoneNo,IMEI,IPv4,email四种数据类型,并分别拼接为字符串。将其分别md5后的值进行再次拼接后进行md5,作为flag提交。
例子:
PhoneNo:18500000000,18523130201
IMEI:535209652769093 535209652761243
IPv4:1.1.1.1 8.8.8.8
Email:1111@qq.com 2222@qq.com
分别进行拼接
PhoneNo-->md5(1850000000018523130201)-->6d2c199df697d35bc656c951dfcd4a33
IMEI-->md5(535209652769093535209652761243)-->b398caf154d248f56996fac704bd2a32
IPv4-->md5(1.1.1.18.8.8.8)-->be11df755d003e1401f5831a5d1440ad
Email-->md5(1111@qq.com2222@qq.com)10dfd7f442eedc5b33cb26f5927b7ce3
最终拼接
flag-->md5(6d2c199df697d35bc656c951dfcd4a33b398caf154d248f56996fac704bd2a32be11df755d003e1401f5831a5d1440ad10dfd7f442eedc5b33cb26f5927b7ce3)--->320e15d80e1944424a109312f2aefb13
flag{320e15d80e1944424a109312f2aefb13}也就是提取这四种类型的数据
这里是对txt进行提取,txt最佳方法就是正则匹配
这里也就是之前讲的
1.手机号
^1[3-9]\d{9}$2..邮箱地址:
[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}3.IMEI(国际移动设备识别码)
^\d{15}$4.IPv4
^(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$这里只给出提取数据的代码:
import re
# 读取文件内容
with open("mixed_sensitive_data.txt", "r", encoding="utf-8") as f:
text = f.read()
# 正则定义
phone_pattern = re.compile(r'\b1[3-9]\d{9}\b')
imei_pattern = re.compile(r'\b\d{15}\b')
ipv4_pattern = re.compile(r'\b(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}\b')
email_pattern = re.compile(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}')
# 提取匹配项
phones = phone_pattern.findall(text)
imeis = imei_pattern.findall(text)
ipv4s = ipv4_pattern.findall(text)
emails = email_pattern.findall(text)
# 拼接字符串
phone_str = ''.join(phones)
imei_str = ''.join(imeis)
ipv4_str = ''.join(ipv4s)
email_str = ''.join(emails)
# 输出检查
print(f"PhoneNo: {phones}")
print(f"IMEI: {imeis}")
print(f"IPv4: {ipv4s}")
print(f"Email: {emails}")csv/xlsx格式
数据分析流程
- 数据读取:使用pandas读取Excel/CSV
- 数据提取:从复杂字段中提取关键信息
例题:2025数证杯 数据分析赛道 04
通过对检材“04-涉诈案件信息表“分析,统计每个分局2024-2025年每月被骗总额环比大于30%的月份个数(环比定义:(这个月的数据-上个月的数据)/上个月数据。特殊情况,例如某分局2025年1月被骗金额总和为100,若该分局2024年12月没有被骗金额,则该分局2025年1月也符合题目要求,应增加一个月份。2024年1月不需要计算与上个月的环比情况),请写出环比大于30%的月份个数最多的分局ID名称为?(答案格式:按照实际情况填写)( )提取的精妙之处:
def extract_imsi(suyuan_text):
match = re.search(r'=\[(\d+)->', str(suyuan_text))
if match:
return match.group(1)
return None正则表达式 r'=\[(\d+)->' 的精妙之处:
=\[→ 匹配"=["这个固定前缀(\d+)→ 捕获一个或多个数字(这就是我们要的IMSI)->→ 匹配"->"这个固定后缀
故完整解题脚本:
import pandas as pd
import re
from collections import Counter
# 读取Excel文件
df = pd.read_excel('/mnt/user-data/uploads/1761969765214_03-案件卡串号数据.xlsx')
# 提取真实卡串号的函数
def extract_imsi(suyuan_text):
# 匹配格式: =[卡串号->
# 使用正则表达式提取
match = re.search(r'=\[(\d+)->', str(suyuan_text))
if match:
return match.group(1)
return None
# 提取所有真实卡串号
df['真实卡串号'] = df['溯源'].apply(extract_imsi)
# 查看提取结果
print("提取的真实卡串号示例:")
print(df[['溯源', '真实卡串号']].head(10))
print("\n"+"="*80+"\n")
# 统计每个卡串号出现的次数
imsi_counts = df['真实卡串号'].value_counts()
print("所有卡串号出现次数统计:")
print(imsi_counts)
print("\n"+"="*80+"\n")
# 找出出现次数最多的卡串号
most_common_imsi = imsi_counts.idxmax()
most_common_count = imsi_counts.max()
print(f"出现次数最多的真实卡串号是: {most_common_imsi}")
print(f"出现次数: {most_common_count}")pcap/pcapng/json文件
对于流量包,一般都是有http文件上传导出成可读文本(txt/json)等
一些是ftp,这些都是流量包内部知识,提取方法wireshark/tshark都可
然后进行分析,有时用的是scapy
这里用几个例题讲解
例题1:数字中国数据识别赛题2
题目说明:
给了对应的session和流量包
大体思路:通过wireshark 导出所有http报文)编写脚本匹配那些id被多个session访问,然后在从session文件中看看访问的用户是不是管理员即可
第一步过滤http.request.method == "POST"
第二步导出json
第三步理解数据结构
import json
with open("output.json", "r", encoding="utf-8") as f:
data = json.load(f)
# 您的数据是列表,包含1301个数据包
print(f"数据包数量: {len(data)}") # 1301
# 每个数据包的结构
first_packet = data[0]
print("第一包键:", first_packet.keys())
# 输出: ['_source', ...]
print("layers键:", first_packet['_source']['layers'].keys())
# 输出: ['frame', 'eth', 'ip', 'tcp', 'http', 'json', ...]
# Session数据路径:
session = data[i]['_source']['layers']['http']['http.cookie']
# 请求体数据路径:
request_data = data[i]['_source']['layers']['http']['http.file_data']第四步提取具体数值
results = []
for packet in data:
layers = packet['_source']['layers']
# 提取session
session = ""
if 'http' in layers and 'http.cookie' in layers['http']:
session = layers['http']['http.cookie'] # "PHPSESSID=abc123"
# 提取请求体(十六进制格式)
hex_data = ""
if 'http' in layers and 'http.file_data' in layers['http']:
hex_data = layers['http']['http.file_data'] # "6a:30:49:54:70..."
if session and hex_data:
results.append({'session': session, 'hex_data': hex_data})第五步数据处理和后续转换
完整解题代码:
import json
import base64
with open("output.json", "r", encoding="utf-8") as f:
data = json.load(f)
print("数据包数量:", len(data))
print("\n第一个数据包的详细结构:")
# 详细分析第一个数据包的结构
first_packet = data[0]['_source']['layers']
print("http层中的键:", first_packet['http'].keys())
# 检查cookie信息
print("\n检查cookie:")
if 'http.cookie' in first_packet['http']:
print("http.cookie:", first_packet['http']['http.cookie'])
else:
print("没有找到http.cookie,http层包含:")
for key in first_packet['http']:
if 'cookie' in key.lower():
print(f" {key}: {first_packet['http'][key]}")
# 检查请求体数据
print("\n检查请求体:")
if 'http.file_data' in first_packet['http']:
hex_data = first_packet['http']['http.file_data']
print(f"http.file_data长度: {len(hex_data)}")
print(f"http.file_data前100字符: {hex_data[:100]}")
# 尝试解码
try:
# 去除冒号和换行,转换为字节
clean_hex = hex_data.replace(':', '').replace('\n', '')
raw_data = bytes.fromhex(clean_hex)
print(f"原始数据长度: {len(raw_data)} bytes")
# 尝试直接显示可打印字符
printable = ''.join(chr(b) if 32 <= b <= 126 else '.' for b in raw_data[:200])
print(f"可打印字符: {printable}")
# 检查是否包含search_id
if b'search_id' in raw_data:
print("找到 'search_id' 在请求体中!")
# 提取search_id值
import re
text = raw_data.decode('utf-8', errors='ignore')
matches = re.findall(r'"search_id"\s*:\s*"(\d+)"', text)
if matches:
print(f"找到search_id: {matches}")
except Exception as e:
print(f"解码错误: {e}")
# 检查其他可能包含数据的字段
print("\n检查其他字段:")
for layer in ['json', 'data-text-lines']:
if layer in first_packet:
print(f"{layer}: {first_packet[layer]}")
# 现在重新尝试提取所有数据
print("\n" + "="*50)
print("开始提取所有数据...")
res = []
for i, packet in enumerate(data):
layers = packet['_source']['layers']
# 提取session (多种可能的位置)
ses = ""
if 'http' in layers:
http_layer = layers['http']
# 尝试不同的cookie键名
for key in http_layer:
if 'cookie' in key.lower():
ses = http_layer[key]
break
# 提取search_id
search_id = ''
if 'http' in layers and 'http.file_data' in layers['http']:
hex_data = layers['http']['http.file_data']
try:
clean_hex = hex_data.replace(':', '').replace('\n', '')
raw_data = bytes.fromhex(clean_hex)
# 尝试作为文本解析
text = raw_data.decode('utf-8', errors='ignore')
import re
matches = re.findall(r'"search_id"\s*:\s*"(\d+)"', text)
if matches:
search_id = matches[0]
else:
# 尝试其他格式
matches = re.findall(r'search_id=(\d+)', text)
if matches:
search_id = matches[0]
except Exception as e:
pass
if ses and search_id:
res.append([search_id, ses])
if len(res) <= 5: # 显示前5个成功提取的
print(f"成功提取: search_id={search_id}, session={ses}")
print(f"\n总共提取到 {len(res)} 条数据")
if res:
# 统计可疑访问
from collections import defaultdict
id_sessions = defaultdict(set)
for search_id, session in res:
id_sessions[search_id].add(session)
print("\nID访问统计:")
for search_id, sessions in id_sessions.items():
if len(sessions) > 1:
print(f"可疑: ID {search_id} 被 {len(sessions)} 个不同session访问: {sessions}")
# 检查越权
print("\n开始检查越权...")
for search_id, sessions in id_sessions.items():
if len(sessions) > 1:
for session in sessions:
phpsessid = session.replace('PHPSESSID=', '')
filename = f'session_{phpsessid}'
try:
with open(filename, 'r', encoding="utf-8") as f:
content = f.read().strip()
print(f"Session {phpsessid} 内容: {content}")
# 解析session
if '"login_id";i:' in content and '"is_admin";b:' in content:
login_id = content.split('"login_id";i:')[1].split(';')[0]
is_admin = content.split('"is_admin";b:')[1].split('}')[0]
if login_id != search_id and is_admin == '0':
print(f"*** 越权发现! 用户 {login_id} 查询了用户 {search_id} ***")
except FileNotFoundError:
print(f"找不到session文件: {filename}")
except Exception as e:
print(f"解析session文件错误: {e}")例题2 绿盟CTF 内部赛数据安全赛道
请参赛选手对于给定的网络流量数据包,利用适当的工具和技术,准确获取数据接口查询的内容。该网络流
量数据包将记录多个API接口的访问记录,API形如:
http://www.test.com/api/search/name/?page=1
http://www.test.com/api/search/name/?page=2
http://www.test.com/api/search/name/?page=3
http://www.test.com/api/search/phone/?page=1
调用APl后将获取相关数据,其中前三条api均为获取name数据,为同一api。根据该调用数据的原理,请获取可查询到的
数据量最多的api接口,和该api获取到的数据量作为答案提交。最终答案格式为md5(信息量最多的api_该ap获取到的数
据量)。
正确答案示例:http://www.test.com/api/search/name/共保存数据量10000条,为数据量最多的api
提交结果示例:flag{md5(http://www.test.com/api/search/name/_10000)}题目给了流量包pcap
导出http上传的文件
这些都是敏感信息数据(json格式)
有bank,phone,等四种
写个脚本写题即可(导出文件我这里放到了ggg文件夹)
import os
import ast
from collections import defaultdict
folder = "ggg"
api_data_count = defaultdict(int)
def detect_api_type(data_list):
if not data_list:
return None
first_item = str(data_list[0])
# 邮箱特征
if '@' in first_item and ('.com' in first_item or '.net' in first_item or '.org' in first_item):
return "email"
# 身份证号特征:18位,数字或最后一位为X
if len(first_item) == 18:
if first_item[:-1].isdigit() and (first_item[-1].isdigit() or first_item[-1].upper() == 'X'):
return "id"
# 数字类型
if first_item.isdigit():
length = len(first_item)
if length == 11: # 手机号
return "phone"
elif 15 <= length <= 19: # 银行卡号或其他长数字
return "bank"
for filename in os.listdir(folder):
filepath = os.path.join(folder, filename)
with open(filepath, "r", encoding="utf-8") as f:
content = f.read().strip()
try:
data_list = ast.literal_eval(content)
except:
continue
api_type = detect_api_type(data_list)
api_data_count[api_type] += len(data_list)
print("各接口数据量统计:", dict(api_data_count))
# 找出数据量最多的接口
if api_data_count:
max_api = max(api_data_count, key=api_data_count.get)
max_count = api_data_count[max_api]
# 构造 URL
url = f"http://192.168.21.138:8081/api/search/{max_api}/"
answer_str = f"{url}_{max_count}"
import hashlib
md5_hash = hashlib.md5(answer_str.encode()).hexdigest()
print("最多的接口:", max_api)
print("总数据量:", max_count)
print("答案字符串:", answer_str)
print("MD5:", md5_hash)
else:
print("没有数据")对于数据提取我给大家分享个我自己写的工具
https://github.com/rlyhtpzzu/DataExtractorGUI
数据清洗
一、什么是数据清洗
数据清洗(Data Cleaning,又称 Data Cleansing 或 Data Scrubbing)是数据预处理中的核心环节。它的目标是识别并修正数据中的错误、不一致或缺失部分,以提高数据质量,从而为后续的数据分析、建模和机器学习提供可靠基础。
在真实场景中,原始数据往往存在以下问题:
- 缺失值:例如某些用户没有填写邮箱或年龄。
- 异常值:某条记录的年龄为 200 岁,或工资为负数。
- 重复数据:同一用户被录入多次。
- 不一致数据:如性别字段中同时出现 M、male、男。
- 格式问题:日期格式混乱,如 2025/08/18 与 18-08-2025 混用。
如果不进行清洗,分析结果可能会严重偏差。
二、数据清洗的常见步骤
- 缺失值处理
缺失值是最常见问题。处理方式包括:
- 删除法:直接删除包含缺失值的行或列(适合缺失率高的情况)
- 填充法:用均值、中位数、众数或插值方法补全
- 模型预测:使用机器学习算法预测缺失值
方法对比表
方法 | 说明 | 适用场景 | 优缺点 |
删除法 | 直接删除包含缺失值的行或列 | 当缺失值比例较高,且该行/列对整体分析影响不大时 | ✅ 简单快速;❌ 可能丢失有用信息 |
填充法 | 用均值、中位数、众数或插值方法补全 | 当缺失值比例较小,且数据分布规律明显时 | ✅ 保留更多数据;❌ 可能引入偏差 |
模型预测 | 使用机器学习模型(如 KNN、回归)预测缺失值(将其他完整的列作为特征,缺失值的列作为标签,进行训练预测) | 当数据复杂、缺失值对结果影响较大时 | ✅ 填充值更合理;❌ 计算复杂度高,需额外建模 |
示例(Pandas):
import pandas as pd
import numpy as np
# 构造样例数据
df = pd.DataFrame({
"姓名": ["张三", "李四", "王五", "赵六"],
"年龄": [25, np.nan, 30, 28],
"工资": [5000, 6000, None, 8000]
})
# 缺失值填充
df["年龄"].fillna(df["年龄"].mean(), inplace=True) # 用均值填充
df["工资"].fillna(df["工资"].median(), inplace=True) # 用中位数填充fillna() 函数详解
函数作用:在 Pandas 中,fillna() 用于填充缺失值 (NaN)。常见于 DataFrame 或 Series 对象,用来替换空值,使数据更加完整。
基本语法:
DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)参数解析:
参数 | 说明 |
| 用于替换缺失值的值,可以是标量、字典或 Series。例如 |
| 采用插值法填充: |
| 填充方向: |
| 是否在原对象上直接修改: |
| 限制填充的次数。例如 |
| 尝试将填充值转换为合适的更小的数据类型,比如从 float64 转成 int32。 |
- 异常值检测与处理
异常值会严重影响模型。常见方法:
- 箱线图法(IQR):利用四分位距检测异常值
- Z-Score 方法:根据数据分布的标准差判断
- 逻辑规则:如年龄不能小于 0,工资不可能为负数
示例(Z-Score):
from scipy import stats
# 检测工资异常值
z_scores = stats.zscore(df["工资"])
df = df[(abs(z_scores) < 3)] # 保留 |Z|<3 的数据- 重复数据处理
重复记录会影响统计和建模,常用方法:
# 删除重复行
df = df.drop_duplicates()- 数据标准化与一致化
实际数据可能存在不同的表示方法:
- 性别字段:M/F、男/女、1/0
- 日期字段:2025-08-18、2025/8/18
处理方式:
# 性别字段统一
df["性别"] = df["性别"].replace({"男": "M", "女": "F"})- 数据格式规范化
确保数据类型正确:
# 转换日期字段
df["日期"] = pd.to_datetime(df["日期"], errors="coerce")
# 转换数值字段
df["工资"] = pd.to_numeric(df["工资"], errors="coerce")三、数据清洗在项目中的意义
- 提升数据质量:减少噪声和偏差
- 增强模型性能:机器学习模型对"脏数据"很敏感
- 节省分析成本:避免在错误数据上浪费计算和决策
- 确保结果可靠:让分析结论更符合业务逻辑
四、案例:员工数据清洗
假设我们有一份员工数据,部分字段存在缺失、重复、异常情况。
import pandas as pd
import numpy as np
data = {
"姓名": ["张三", "李四", "王五", "李四"],
"性别": ["男", "女", "M", "male"],
"年龄": [25, 200, 30, 29],
"工资": [5000, 6000, None, -1000],
"入职日期": ["2022-01-05", "20220110", "2022/01/15", "2022-01-20"]
}
df = pd.DataFrame(data)
print("数据清洗前:\n", df)
# 1. 缺失值处理
df["工资"].fillna(df["工资"].median(), inplace=True)
# 2. 异常值处理(逻辑规则)
df.loc[df["年龄"] > 100, "年龄"] = df["年龄"].median()
df.loc[df["工资"] < 0, "工资"] = df["工资"].median()
# 3. 重复数据去重
df = df.drop_duplicates()
# 4. 一致化
df["性别"] = df["性别"].replace({"男": "M", "女": "F", "male": "M"})
# 5. 日期规范化
df["入职日期"] = pd.to_datetime(df["入职日期"], errors="coerce")
print("数据清洗后:\n", df)清洗后,数据更干净,适合后续分析。
五、总结
数据清洗是数据科学和机器学习流程中至关重要的一步。主要目标是去除噪声、修正错误、统一格式、处理缺失与异常。
在数据安全比赛中,可以结合 Pandas、NumPy、正则表达式、机器学习算法等工具,构建自动化的数据清洗流程。
补充:数据质量评估指标
在开始清洗前,建议先评估数据质量:
def assess_data_quality(df):
print("数据质量报告:")
print(f"总记录数: {len(df)}")
print(f"总列数: {len(df.columns)}")
print("\n缺失值统计:")
missing_stats = df.isnull().sum()
print(missing_stats[missing_stats > 0])
print(f"\n重复记录数: {df.duplicated().sum()}")
print(f"\n数据类型:\n{df.dtypes}")
# 使用示例
assess_data_quality(df)数据删除与恢复
取证
以数字中国2025的一道题讲解
题目: 管理员利用AI模型设计了一个结合redis和mysql的交易数据查询系统,但是未对代码的安全性进行充 分验证,导致mysql中的用户虽然被删除但仍可以利用redis中的JWT信息,登录交易数据查询系统。请 选手下载平台提供的附件(用户表.xlsx),根据用户表(其中1个用户为管理员测试账号,可进行数据库 管理)及数据库中存在的用户,判断哪些用户在被删除后仍可以利用JWT进行登录,将用户名按照用户表 中的先后排序,并使用“_”拼接后,通过md5处理后进行提交对给出的账号密码尝试逐一登录,发现大部分无法登录,直接跳转首页;有些账号能正常登录(绿色标记);有些账号登录后功能异常( 黄色标记 )
猜测异常但能登陆的账号即为删除但仍缓存的用户
import hashlib
# 要计算 MD5 的字符串或数据
data = "wangguizhi_ningxiurong_zhanglihua_mengpeng_gantingting"
# 创建一个 md5 哈希对象
md5_hash = hashlib.md5()
# 更新哈希对象的摘要信息
md5_hash.update(data.encode('utf-8'))
# 获取十六进制表示的 MD5 值
md5_hex_digest = md5_hash.hexdigest()
print("MD5:", md5_hex_digest)
# MD5: 8429e825242b4e9063862b78da1e46dd同时发现管理员账号:
数据脱敏
讲解一些脱敏算法,数据脱敏算法可以分为两大类别:不可逆脱敏和可逆脱敏。在大多数涉及隐私保护的场景下,我们主要使用不可逆脱敏。
一、不可逆脱敏
一旦处理,原始数据无法恢复。适用于数据分析、测试、共享等无需追溯源值的场景。
1. 替换
用伪造的、但格式一致的数据替换真实数据。
- 随机替换:从一个符合规则的字典中随机选取值替换。
- 基于规则的替换:如根据姓氏和性别生成符合文化习惯的假名。
示例(Python):
import pandas as pd
import random
from faker import Faker
fake = Faker('zh_CN')
df = pd.DataFrame({
'真实姓名': ['张三', '李四', '王五'],
'真实手机号': ['13900123000', '15812345678', '13711112222']
})
# 使用Faker库进行替换脱敏
df['脱敏姓名'] = [fake.name() for _ in range(len(df))]
df['脱敏手机号'] = [fake.phone_number() for _ in range(len(df))]
print(df)输出:
真实姓名 真实手机号 脱敏姓名 脱敏手机号
0 张三 13900123000 刘伟 162-7894-1234
1 李四 15812345678 赵强 145-1234-5678
2 王五 13711112222 陈静 158-9876-54322. 遮蔽/打码
保留部分信息,隐藏敏感部分。这是一种非常常见且直观的方法。
- 保留前后,遮蔽中间:常用于姓名、身份证号、信用卡号。
张三->张*110101199001011234->110101********123413900123000->139****3000
示例(Python):
def mask_name(name):
if len(name) <= 1:
return name
return name[0] + '*' * (len(name) - 1)
def mask_id_number(id_number, visible_front=6, visible_back=4):
if len(id_number) < (visible_front + visible_back):
return id_number # 或者处理错误
front = id_number[:visible_front]
back = id_number[-visible_back:]
stars = '*' * (len(id_number) - visible_front - visible_back)
return front + stars + back
df['遮蔽姓名'] = df['真实姓名'].apply(mask_name)
df['遮蔽身份证'] = '110101199001011234'
df['遮蔽身份证'] = df['遮蔽身份证'].apply(lambda x: mask_id_number(x))
print(df[['真实姓名', '遮蔽姓名', '遮蔽身份证']])输出:
真实姓名 遮蔽姓名 遮蔽身份证
0 张三 张* 110101********1234
1 李四 李* 110101********1234
2 王五 王* 110101********12343. 泛化
将精确值转换为一个范围或一个更粗的粒度,降低数据的辨识度。
- 年龄:
28->20-30 - 工资:
12500->10000-15000 - 日期:
2023-08-18->2023-Q3 - 地区:
北京市海淀区中关村街道->北京市
示例(Python):
import math
def generalize_age(age):
# 按10岁为一个区间进行泛化
lower = (age // 10) * 10
upper = lower + 9
return f"{lower}-{upper}"
def generalize_salary(salary):
# 按5000为一个区间进行泛化
bin_width = 5000
lower = math.floor(salary / bin_width) * bin_width
upper = lower + bin_width - 1
return f"{lower}-{upper}"
df['年龄'] = [28, 35, 42]
df['工资'] = [12500, 8300, 21000]
df['泛化年龄'] = df['年龄'].apply(generalize_age)
df['泛化工资'] = df['工资'].apply(generalize_salary)
print(df[['年龄', '泛化年龄', '工资', '泛化工资']])输出:
年龄 泛化年龄 工资 泛化工资
0 28 20-29 12500 10000-14999
1 35 30-39 8300 8000-12999
2 42 40-49 21000 20000-249994. 置乱
对某一列的数据进行随机排序,从而打破该列数据与其他列的关联性。注意:这会破坏数据行内的业务逻辑,需谨慎使用。
示例(Python):
df = pd.DataFrame({
'姓名': ['张三', '李四', '王五'],
'部门': ['技术部', '销售部', '市场部'],
'工资': [20000, 15000, 18000]
})
print("置乱前:")
print(df)
# 对“工资”列进行置乱
df['置乱工资'] = df['工资'].sample(frac=1, random_state=42).reset_index(drop=True)
print("\n置乱后:")
print(df)输出:
置乱前:
姓名 部门 工资
0 张三 技术部 20000
1 李四 销售部 15000
2 王五 市场部 18000
置乱后:
姓名 部门 工资 置乱工资
0 张三 技术部 20000 18000
1 李四 销售部 15000 20000
2 王五 市场部 18000 15000可以看到,张三的工资不再是20000,而是被置乱成了18000。
5. 加噪
对数值型数据加入一个随机噪声,使数据近似真实但并非原值。常用于保护统计特征的同时隐藏个体精确值。
- 加法噪声:
新值 = 原值 + 随机噪声 - 乘法噪声:
新值 = 原值 * (1 + 随机噪声)
示例(Python):
import numpy as np
np.random.seed(42) # 保证结果可重现
df = pd.DataFrame({'真实工资': [20000, 15000, 18000]})
# 添加±10%的乘法噪声
noise = np.random.uniform(-0.1, 0.1, size=len(df))
df['加噪工资'] = df['真实工资'] * (1 + noise)
df['加噪工资'] = df['加噪工资'].round(2)
print(df)输出:
真实工资 加噪工资
0 20000 21405.48
1 15000 13801.50
2 18000 19204.38二、可逆脱敏
处理后数据可通过特定密钥或方法恢复为原始数据。适用于系统间安全传输或受控环境下的数据处理。
1. 加密算法
使用对称加密(如AES)或非对称加密(如RSA)对数据进行加密。拥有密钥才能解密。
示例(使用cryptography库):
# 注意:这是一个简化示例,生产环境需要安全地管理密钥
from cryptography.fernet import Fernet
# 生成密钥
key = Fernet.generate_key()
cipher_suite = Fernet(key)
df = pd.DataFrame({'信用卡号': ['1234567890123456', '9876543210987654']})
# 加密
df['加密卡号'] = df['信用卡号'].apply(lambda x: cipher_suite.encrypt(x.encode()).decode())
# 解密 (仅用于演示)
df['解密卡号'] = df['加密卡号'].apply(lambda x: cipher_suite.decrypt(x.encode()).decode())
print(df[['信用卡号', '加密卡号']])
print(f"\n密钥 (请妥善保管): {key.decode()}")输出:
信用卡号 加密卡号
0 1234567890123456 gAAAAABmY...(很长一串密文)
1 9876543210987654 gAAAAABmY...(另一串很长密文)2. 令牌化
用一个无意义的随机令牌(Token)替换敏感数据。原始数据被安全地存储在独立的“令牌库”中,只有授权系统才能通过令牌查询到原始值。
- 场景:支付系统。商家存储的是令牌而非你的真实信用卡号,当需要扣款时,支付网关通过令牌从令牌库中换取真实卡号。
三、如何选择脱敏算法?
算法 | 适用场景 | 优点 | 缺点 |
替换 | 测试环境、UI展示 | 数据看起来真实,保持格式 | 需要维护数据字典,可能碰撞 |
遮蔽 | 日志记录、内部报表 | 实现简单,直观,部分信息可用 | 信息有损失,不适合分析 |
泛化 | 数据分析、统计、BI报表 | 保留数据分布和统计特性 | 失去精确性 |
置乱 | 破坏关联性的测试数据 | 保留列的总体分布 | 完全破坏行内业务逻辑 |
加噪 | 保护个体精确值的数值分析 | 保留统计特征(如均值、方差) | 引入微小误差 |
加密 | 安全数据传输、受控环境 | 安全,可逆 | 计算开销大,需要管理密钥 |
令牌化 | 支付系统、核心系统交互 | 高性能,高安全性 | 架构复杂,需要维护令牌库 |
核心原则:
- 目的决定手段:先明确数据用途(开发测试?数据分析?),再选择最合适的算法。
- 最小化原则:只对必要的敏感字段进行脱敏,并使用刚好满足安全需求的算法。
- 保持关联性:确保脱敏后,不同表、不同字段间的关联关系不被破坏(例如,用户ID脱敏后要保持一致)。
- 保留业务逻辑:确保脱敏后的数据在业务上是合理的(例如,年龄不能出现负数,城市名必须是真实存在的)。
例如下面这张图片中数据脱敏的例子
从xlsx中读取数据并实现脱敏
import pandas as pd
import hashlib
def desensitize_name(name):
length = len(name)
if length == 2:
return name[0] + '*'
elif length == 3:
return name[0] + '*' + name[2]
elif length == 4:
return name[0] + '**' + name[3]
else:
return name # 对于非2-4字姓名,原样返回(可根据需求修改)
def desensitize_phone(phone):
if len(phone) == 11:
return phone[:3] + '*****' + phone[8:]
return phone # 对于非11位手机号,原样返回
def desensitize_id(id_num):
if len(id_num) >= 6:
return id_num[:6] + '*' * (len(id_num) - 6)
return id_num # 对于不足6位的身份证号,原样返回
def desensitize_bank_card(card):
card_str = str(card).strip() # 转换为字符串并去除空白
length = len(card_str)
if length < 14:
return '*' * length
else:
# 计算需要保留的中间部分
keep_length = max(0, length - 14) # 总长度-14=中间保留位数
middle = card_str[4:4+keep_length] if keep_length > 0 else ''
return '****' + middle + '*' * 10
def desensitize_email(email):
parts = email.split('@')
if len(parts) == 2:
local_part = parts[0]
# 找到最后一个.的位置
last_dot = local_part.rfind('.')
if last_dot != -1:
# 保留.及其前面的字符
to_keep = local_part[:last_dot+1]
to_mask = local_part[last_dot+1:]
else:
to_keep = ''
to_mask = local_part
masked = to_keep + '*' * len(to_mask)
return masked + '@' + parts[1]
return email # 对于不包含@的email,原样返回
def desensitize_gender(gender):
return '未知'
def desensitize_wechat(wechat):
if wechat:
return '*' * len(wechat)
return wechat
def concatenate_and_hash(file_path):
# 读取Excel文件
df = pd.read_excel(file_path)
# 移除标题行(第一行)
data_rows = df.iloc[1:] if len(df) > 1 else df
# 按照先行后列的顺序拼接所有单元格内容
concatenated_str = ''
for _, row in data_rows.iterrows():
for value in row:
concatenated_str += str(value) if pd.notna(value) else ''
# 计算MD5哈希值
md5_hash = hashlib.md5(concatenated_str.encode('utf-8')).hexdigest()
return md5_hash
if __name__ == "__main__":
# 读取Excel文件
df = pd.read_excel('data.xlsx')
# 应用脱敏函数
df['姓名'] = df['姓名'].apply(desensitize_name)
df['手机号'] = df['手机号'].astype(str).apply(desensitize_phone)
df['身份证号'] = df['身份证号'].astype(str).apply(desensitize_id)
df['银行卡号'] = df['银行卡号'].astype(str).apply(desensitize_bank_card)
df['Email'] = df['Email'].apply(desensitize_email)
df['性别'] = df['性别'].apply(desensitize_gender)
df['微信号'] = df['微信号'].apply(desensitize_wechat)
# 保存脱敏后的数据到新文件
df.to_excel('desensitized_data.xlsx', index=False)
print("[+] 数据脱敏完成,结果已保存到 desensitized_data.xlsx")
file_path = 'desensitized_data.xlsx' # 替换为你的Excel文件路径
result = concatenate_and_hash(file_path)
print(f"[+] 拼接后的字符串的MD5值为: {result}")从csv中读取数据并实现脱敏
import csv
import hashlib
import base64
data_list = []
res_list = []
def basedecode(line):
try:
if line[-1] == "Base32":
for i in range(1,6):
line[i] = base64.b32decode(line[i]).decode()
elif line[-1] == "Base64":
for i in range(1,6):
line[i] = base64.b64decode(line[i]).decode()
elif line[-1] == "Base85":
for i in range(1,6):
line[i] = base64.b85decode(line[i]).decode()
except:
pass
def username_solve(username):
res = ''
if len(username) == 2:
res = username[0] + '*'
else:
res = username[0] + "*"*(len(username)-2)+username[-1]
return res
def password_solve(pwd):
md5_hash = hashlib.md5()
md5_hash.update(pwd.encode('utf-8'))
res = md5_hash.hexdigest()
return res
def name_solve(name):
sha1_hash = hashlib.sha1()
sha1_hash.update(name.encode('utf-8'))
res = sha1_hash.hexdigest()
return res
def id_solve(id):
res = "*"*6 + id[6:10] + "*"*8
return res
def phone_solve(phone):
res = phone[:3] + "*"*4 + phone[7:]
return res
if __name__ == "__main__":
with open("data.csv", "r", encoding='utf-8') as f:
reader = csv.reader(f)
for row in reader:
data_list.append(row)
data_list[0].remove(data_list[0][6])
res_list.append(data_list[0])
for line in data_list[1:]:
basedecode(line)
line[1] = username_solve(line[1])
line[2] = password_solve(line[2])
line[3] = name_solve(line[3])
line[4] = id_solve(line[4])
line[5] = phone_solve(line[5])
line.remove(line[6])
res_list.append(line)
with open('out.csv',"w",newline='',encoding='utf-8') as f:
writer = csv.writer(f)
writer.writerows(res_list)从json中读取数据并实现脱敏
import json
from scapy.all import *
# 解析JSON文件,建立IP到域名的映射
ip_domain = {}
with open('国外敏感域名清单.json', 'r') as f:
data = json.load(f)
for category in data['categories'].values():
domains = category['domains']
for domain, ip in domains.items():
ip_domain[ip] = domain
# 解析PCAP文件,统计目标IP访问次数
ip_count = {}
packets = rdpcap('某流量审计平台导出的镜像流量.pcap')
for pkt in packets:
if IP in pkt:
dst_ip = pkt[IP].dst
if dst_ip in ip_domain:
ip_count[dst_ip] = ip_count.get(dst_ip, 0) + 1
# 找出访问次数最多的IP
max_ip = None
max_count = 0
for ip, count in ip_count.items():
if count > max_count:
max_count = count
max_ip = ip
# 生成结果
if max_ip:
domain = ip_domain[max_ip]
print(f"{domain}:{max_ip}:{max_count}")
else:
print("无访问记录")文章探讨数据安全中敏感信息的识别、提取及脱敏方法,涵盖正则表达式应用、文件格式分析、流量审计与常见脱敏算法。
由 AI 根据全文自动生成,仅供参考,以原文为准
