流量分析

流量分析附件

数据包中包含明文 flag 直接拿取即可

流量分析2

题目

小明通过webshell获取网站的流量，你能帮他分析分析吗？

流量分析2附件

按照第一个题目中的方法去尝试检索 flag

并未发现任何明文 flag 文字出现

简单浏览基本上都是简单的 GET 请求，但是其中包含一些文件上传的 HTTP 请求，那就将这些 HTTP 请求全部过滤出来

http.request

其中包含 GET 请求，而 GET 请求用于文件的获取更多，所以将 POST 请求过滤出来

http.request.method == "POST"

其中发现有获取 config.php 的异常请求，于是对其中进行的分析

这样类似的请求一般是用于登录，其中不会包含 flag

出现文件痕迹，进行追踪流

并未出现 flag 痕迹，继续查看

再次出现文件痕迹

追踪流后发现 flag 痕迹

fl4g{ftop_Is_Waiting_4_y}

流量分析3

题目

某集团服务器遭受了大量的恶意攻击，你作为一名安全工程师，请你分析出攻击者的IP。提交格式：flag{127.0.0.1}

流量分析3附件

随便找一个流进行追踪，发现乱码

eyJtc2ciOiJOVEV1TVRrNExqRTNOUzR6TFNBdElGc3dPQzlLWVc0dk1qQXlOVG94T0RveE16b3hNQ0FyTURBd01GMGdJa2RGVkNBdmMyVmhjbU5vTDNObFlYSmphQzV3YUhBZ1NGUlVVQzh4TGpFaUlESXdNQ0EwT1RJd0lDSXRJaUFpVFc5NmFXeHNZUzgxTGpBZ0tHbFFhRzl1WlRzZ1ExQlZJR2xRYUc5dVpTQlBVeUF4TjE4eFh6RWdiR2xyWlNCTllXTWdUMU1nV0NrZ1FYQndiR1ZYWldKTGFYUXZOVE0wTGpFZ0tFdElWRTFNTENCc2FXdGxJRWRsWTJ0dktTQkdlR2xQVXk4eE5pNDNiRFU1TURZdU1DQk5iMkpwYkdVdk5qRk5PVEV3SUZOaFptRnlhUzgxTXpRdU1TSUsiLCJ0eXBlIjoiTG9nLURhdGEifQ==

其中包含 A–Z a–z 0–9 + / 以及末尾是 == ，所以可以判断是 base64 编码格式

解码查看内容

{
  "msg": "NTEuMTk4LzQzMS40MzEuMjQxLjEuMQ==",
  "type": "Log-Data"
}

发现 msg 还是 base64 加密编码，解密查看

51.198/431.431.241.1.1

原文则是

{
  "msg": "51.198/431.431.241.1.1",
  "type": "Log-Data"
}

让 AI 写一个脚本进行解密

#!/usr/bin/env python3
"""
批量从 pcap 文件中提取 hex 数据 → 深度解码 base64。
数据格式: hex → bytes → base64 JSON(含msg字段) → base64 msg → 文本
用法:
    python batch_base64_decode.py <pcap_file> [output_dir]
"""

import base64
import binascii
import json
import os
import re
import subprocess
import sys
from collections import Counter
from pathlib import Path

TSHARK = r"C:\Program Files\Wireshark\tshark.exe"


def decode_b64_safe(s: str) -> bytes | None:
    """安全的 base64 解码"""
    missing = len(s) % 4
    if missing:
        s += "=" * (4 - missing)
    try:
        return base64.b64decode(s, validate=True)
    except Exception:
        return None


def hex_to_json(hex_str: str) -> dict | None:
    """hex → bytes → base64 → JSON"""
    try:
        raw = bytes.fromhex(hex_str)
    except ValueError:
        return None

    try:
        b64_str = raw.decode("ascii")
    except UnicodeDecodeError:
        return None

    decoded = decode_b64_safe(b64_str)
    if decoded is None:
        return None

    try:
        return json.loads(decoded)
    except (json.JSONDecodeError, UnicodeDecodeError):
        return None


def main():
    if len(sys.argv) < 2:
        print(__doc__)
        sys.exit(1)

    pcap_path = Path(sys.argv[1]).resolve()
    output_dir = Path(sys.argv[2]) if len(sys.argv) > 2 else Path("./decoded_output")
    output_dir = output_dir.resolve()
    output_dir.mkdir(parents=True, exist_ok=True)

    print(f"[*] 源文件: {pcap_path}")
    print(f"[*] 输出目录: {output_dir}")

    # Step 1: tshark 提取 hex
    print("[*] 正在用 tshark 提取数据...")
    result = subprocess.run(
        [TSHARK, "-r", str(pcap_path), "-Y", "data", "-T", "fields", "-e", "data"],
        capture_output=True,
        text=True,
        timeout=120,
    )

    lines = [l.strip() for l in result.stdout.strip().split("\n") if l.strip()]
    print(f"[*] 提取到 {len(lines)} 行 hex 数据")

    # 去重（保持顺序）
    unique = list(dict.fromkeys(lines))
    print(f"[*] 唯一 hex 值: {len(unique)}")

    # Step 2: 第一层解码 hex → JSON
    print("[*] 第一层解码: hex → JSON ...")
    json_objects = []
    json_counter = Counter()
    decode_failures = 0

    for hex_str in unique:
        obj = hex_to_json(hex_str)
        if obj:
            json_objects.append((hex_str, obj))
            json_counter["total"] += 1
            json_counter[obj.get("type", "unknown")] += 1
        else:
            decode_failures += 1

    print(f"[*] JSON 解码成功: {len(json_objects)}, 失败: {decode_failures}")
    print(f"[*] 类型分布: {dict(json_counter)}")

    # Step 3: 第二层解码 msg 字段
    print("[*] 第二层解码: msg (base64) → 明文 ...")
    decoded_msgs = []
    suspicious = []

    for hex_str, obj in json_objects:
        msg_b64 = obj.get("msg", "")
        if not msg_b64:
            continue

        decoded_bytes = decode_b64_safe(msg_b64)
        if decoded_bytes is None:
            continue

        try:
            msg_text = decoded_bytes.decode("utf-8")
        except UnicodeDecodeError:
            msg_text = repr(decoded_bytes)

        decoded_msgs.append((hex_str, obj, msg_text))

        # 检测异常：不是标准日志格式的
        if not re.match(r"^\d+\.\d+\.\d+\.\d+-", msg_text):
            suspicious.append((hex_str, obj, msg_text))
        # 检测可能包含 flag 的
        if re.search(r"flag|ctf\{|CTF\{|FLAG\{", msg_text, re.IGNORECASE):
            suspicious.append((hex_str, obj, msg_text))

    print(f"[*] msg 解码成功: {len(decoded_msgs)}")
    print(f"[*] 可疑/异常条目: {len(suspicious)}")

    # Step 4: 输出报告
    report_path = output_dir / "decoded_report.txt"
    with open(report_path, "w", encoding="utf-8") as f:
        f.write("=" * 70 + "\n")
        f.write(" Base64 深度解码报告\n")
        f.write(f" 源文件: {pcap_path}\n")
        f.write(f" 提取行数: {len(lines)}\n")
        f.write(f" 唯一 hex: {len(unique)}\n")
        f.write(f" JSON 解码: {len(json_objects)}\n")
        f.write(f" msg 解码: {len(decoded_msgs)}\n")
        f.write(f" 类型分布: {dict(json_counter)}\n")
        f.write("=" * 70 + "\n\n")

        # 先列出所有可疑条目
        if suspicious:
            f.write("=" * 70 + "\n")
            f.write(f" 🚨 可疑/异常条目 ({len(suspicious)} 条)\n")
            f.write("=" * 70 + "\n\n")
            for hex_str, obj, msg in suspicious:
                f.write(f"  msg: {msg}\n")
                f.write(f"  原始 JSON: {json.dumps(obj, ensure_ascii=False)}\n")
                f.write("-" * 70 + "\n")
        else:
            f.write("(未发现明显异常条目)\n\n")

        # 全部解码后的日志
        f.write("\n" + "=" * 70 + "\n")
        f.write(" 全部已解码 msg 字段\n")
        f.write("=" * 70 + "\n\n")

        # 按日志时间排序（如果能解析）
        for idx, (hex_str, obj, msg) in enumerate(decoded_msgs, 1):
            f.write(f"[#{idx:06d}] {msg}\n")

    print(f"[*] 报告已保存: {report_path}")

    # 纯文本日志输出
    log_path = output_dir / "access_log.txt"
    with open(log_path, "w", encoding="utf-8") as f:
        for hex_str, obj, msg in decoded_msgs:
            f.write(msg + "\n")

    print(f"[*] 纯文本日志: {log_path}")

    # 只输出可疑条目
    if suspicious:
        susp_path = output_dir / "suspicious.txt"
        with open(susp_path, "w", encoding="utf-8") as f:
            for hex_str, obj, msg in suspicious:
                f.write(msg + "\n")
                f.write(f"  JSON: {json.dumps(obj, ensure_ascii=False)}\n")
                f.write("-" * 70 + "\n")
        print(f"[*] 可疑条目: {susp_path}")

    # 控制台摘要
    print(f"\n[*] === 解码摘要 ===")
    print(f"    总 hex 行: {len(lines)}")
    print(f"    唯一 hex: {len(unique)}")
    print(f"    JSON 成功: {len(json_objects)}")
    print(f"    msg 成功: {len(decoded_msgs)}")
    print(f"    可疑/异常: {len(suspicious)}")

    if suspicious:
        print(f"\n[!] 🚨 发现可疑条目:")
        for hex_str, obj, msg in suspicious[:10]:
            print(f"    {msg[:200]}")


if __name__ == "__main__":
    main()

在 output 目录中找到 suspicious.txt 文件，将文件第一行进行提交即可

flag{35.127.46.111}

HTTP 数据分析

HTTP 数据分析附件

题目

请你根据附件中的流量数据进行统计汇总，提取出现攻击次数最多的useragent。在提取出useragent后，使用MD5算法对其进行加密，并将加密后的32位十六进制字符串作为flag进行提交。 【提交格式】 例如，如果得出的useragent为: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.1.1 Safari/605.1.15 则需要将其进行MD5加密，然后按照以下格式提交：flag{md5(useragent)}，其中md5(useragent)代表加密后的32位MD5字符串。 示例：假设MD5加密后的字符串为 e1f1c2b0f33a4c2b0ff7c7c5a46a7e5e，则提交的格式应为：flag{e1f1c2b0f33a4c2b0ff7c7c5a46a7e5e}。 【评测标准】本题按结果给分。

根据题目中要求，我们需要将所有 user agent 进行清洗，将清洗后的 user agent 进行排名，取第一名的进行 MD5 加密，最后拼接 flag 字符串输出

写出以下 Python 脚本

import hashlib
import re
from collections import Counter

log_file = r"C:\Users\Ivo\Documents\Code\ctf\Http数据分析\http.log.txt"

with open(log_file, "r", encoding="utf-8") as f:
    content = f.read()

# 每条请求和响应之间用 ==== 分隔，每个块内可能包含 User-Agent
blocks = content.split("======================================================")

ua_counter = Counter()

for block in blocks:
    # 提取 User-Agent 行
    ua_match = re.search(r"User-Agent:\s*(.+)", block)
    if ua_match:
        ua = ua_match.group(1).strip()
        ua_counter[ua] += 1

most_common_ua = ua_counter.most_common(1)[0][0]
count = ua_counter.most_common(1)[0][1]

print(f"共有 {sum(ua_counter.values())} 条 User-Agent，{len(ua_counter)} 种")
print(f"\n出现次数最多的 User-Agent (出现 {count} 次)：")
print(most_common_ua)

md5_hex = hashlib.md5(most_common_ua.encode()).hexdigest()
print(f"\nMD5: {md5_hex}")
print(f"flag{{{md5_hex}}}")

输出最终结果

flag{488f54ddd342ab5253e726d9d61aa250}