基于无监督学习的Web日志异常检测系统

1
import pandas as pd
2
import urllib.parse
3
from datetime import datetime
4
import re
5

6
def parse_url(raw_url):
7
    """
8
    解析 Apache 日志中的 URL 字段，提取 HTTP 方法、路径、查询字符串。
9
    输入：raw_url (str) 如 "GET /index.php?id=1 HTTP/1.1"
10
    输出：pd.Series([Method, Path, Query])
11
    """
12
    raw_url = raw_url.strip()
13
    # 尝试正则匹配：方法 + 空格 + 路径 + 可能 ? + 查询字符串
14
    match = re.match(r'(\w+)\s+([^\s?]+)(?:\?([^\s]*))?', raw_url)
15
    if match:
16
        method = match.group(1)
17
        path = match.group(2)
18
        query = match.group(3) if match.group(3) else ''
19
        return pd.Series([method, path.lower(), query.lower()])
20
    else:
21
        # 如果正则不匹配，按空格分割作为后备方案
22
        parts = raw_url.split()
23
        if len(parts) >= 2:
24
            method = parts[0]
25
            url_part = parts[1]
26
            if '?' in url_part:
27
                path, query = url_part.split('?', 1)
28
            else:
29
                path, query = url_part, ''
30
            return pd.Series([method, path.lower(), query.lower()])
31
        else:
32
            return pd.Series(['', raw_url.lower(), ''])
33

34
def standardize_time(timestr):
35
    """
36
    将 Apache 时间格式转换为 datetime 对象。
37
    输入示例："[03/Nov/2021:15:32:01 +0600]"
38
    输出：datetime 对象，若失败则返回 NaT
39
    """
40
    timestr = timestr.strip('[]')  # 去掉方括号
41
    try:
42
        return datetime.strptime(timestr, '%d/%b/%Y:%H:%M:%S %z')
43
    except:
44
        try:
45
            # 尝试无时区格式
46
            return datetime.strptime(timestr, '%d/%b/%Y:%H:%M:%S')
47
        except:
48
            return pd.NaT
49

50
# ----------------------- 主流程 -----------------------
51
df = pd.read_csv('weblog.csv')
52

53
# 统一列名，处理原数据中可能的拼写错误 "Staus" -> "Status"
54
df.rename(columns={'Staus': 'Status'}, inplace=True)
55

56
# 保存前1000行作为原始样本，供报告使用
57
df.head(1000).to_csv('raw_sample.csv', index=False)
58

59
# 去重，删除完全相同的日志行
60
df = df.drop_duplicates()
61
print(f"去重后条数: {len(df)}")
62

63
# 解析 URL，新增 Method、Path、Query 三列
64
df[['Method', 'Path', 'Query']] = df['URL'].apply(parse_url)
65

66
# URL 解码，将 %20 等转义字符还原
67
df['Path'] = df['Path'].apply(urllib.parse.unquote)
68
df['Query'] = df['Query'].apply(urllib.parse.unquote)
69

70
# 时间标准化，新增 Timestamp、Hour、Weekday 列
71
df['Timestamp'] = df['Time'].apply(standardize_time)
72
df = df.dropna(subset=['Timestamp'])               # 删除无法解析时间的行
73
df['Hour'] = df['Timestamp'].dt.hour               # 提取小时
74
df['Weekday'] = df['Timestamp'].dt.weekday         # 提取星期几（0=周一,6=周日）
75

76
# 选取最终需要的列，保存清洗后数据
77
cleaned = df[['IP', 'Timestamp', 'Hour', 'Weekday', 'Method', 'Path', 'Query', 'Status']]
78
cleaned.to_csv('cleaned.csv', index=False)
79
print(f"清洗完成，最终条数: {len(cleaned)}，字段数: {len(cleaned.columns)}")

1
import pandas as pd
2
import numpy as np
3
import re
4
import os
5
from drain3 import TemplateMiner
6
from drain3.file_persistence import FilePersistence
7
from sklearn.ensemble import IsolationForest
8
import matplotlib.pyplot as plt
9
import json
10
import warnings
11

12
warnings.filterwarnings('ignore')
13

14
# ----- 自动生成 drain3 配置文件（若不存在），避免警告 -----
15
if not os.path.exists('drain3.ini'):
16
    with open('drain3.ini', 'w') as f:
17
        f.write('[DRAIN]\n')
18
        f.write('sim_th = 0.4\n')   # 模板相似度阈值
19
        f.write('depth = 4\n')      # 解析树深度
20

21
def normalize_log_message(raw_msg):
22
    """
23
    日志归一化：将动态部分（数字、参数值）替换为占位符，便于模板聚类。
24
    输入：原始日志消息字符串
25
    输出：归一化后的字符串
26
    """
27
    # 路径中独立数字段替换为 <NUM>，例如 /abc/123/ -> /abc/<NUM>/
28
    msg = re.sub(r'/\d+(?=/|$|\s)', '/<NUM>', raw_msg)
29
    # 查询参数值替换为 <*>，例如 id=5 -> id=<*>
30
    msg = re.sub(r'=\w+', '=<*>', msg)
31
    # 剩余数字全部替换为 <NUM>
32
    msg = re.sub(r'\d+', '<NUM>', msg)
33
    return msg
34

35
# ---------- Drain 初始化 ----------
36
persistence = FilePersistence('drain_state.bin')   # 用于持久化模板
37
template_miner = TemplateMiner(persistence)
38

39
def extract_template(log_message):
40
    """
41
    提取单条日志的模板 ID。
42
    输入：原始日志消息（未归一化）
43
    输出：整数模板 ID
44
    """
45
    normalized = normalize_log_message(log_message)
46
    result = template_miner.add_log_message(normalized)
47
    return result['cluster_id']
48

49
def main():
50
    # 1. 读取清洗后的数据
51
    df = pd.read_csv('cleaned.csv')
52

53
    # 2. 构造完整的日志消息（方法 + 路径 + 查询字符串）
54
    df['log_message'] = df.apply(
55
        lambda row: f"{row['Method']} {row['Path']}" + (f"?{row['Query']}" if row['Query'] else ""),
56
        axis=1
57
    )
58

59
    # 3. 使用 Drain 提取模板，每个日志获得一个 template_id
60
    print("开始Drain模板提取...")
61
    df['template_id'] = df['log_message'].apply(extract_template)
62
    print(f"共提取 {df['template_id'].nunique()} 个不同模板")
63

64
    # 4. 保存模板映射到 JSON 文件（模板ID -> 模板文本、大小）
65
    clusters_dict = {}
66
    for cluster in template_miner.drain.clusters:
67
        cid = getattr(cluster, 'cluster_id', None)
68
        if cid is None:
69
            cid = id(cluster)   # 若找不到 cluster_id 属性，用内存地址作后备
70
        clusters_dict[cid] = {
71
            "template": cluster.get_template(),
72
            "size": cluster.size
73
        }
74
    with open('template_map.json', 'w') as f:
75
        json.dump(clusters_dict, f, indent=2)
76

77
    # 5. 特征工程：基于时间窗口构造统计特征
78
    print("构造时间窗口特征...")
79
    window_size = 5
80
    features = []
81
    n = len(df)
82
    for i in range(n):
83
        # 以当前行为中心取窗口
84
        start = max(0, i - window_size // 2)
85
        end = min(n, i + window_size // 2 + 1)
86
        window = df.iloc[start:end]
87

88
        # 窗口内模板出现次数统计
89
        template_counts = window['template_id'].value_counts().to_dict()
90
        cur_id = df.iloc[i]['template_id']
91
        cur_count = template_counts.get(cur_id, 0)      # 当前模板在窗口内的频次
92
        unique_templates = len(template_counts)         # 窗口内不同模板数量
93
        is_post = 1 if df.iloc[i]['Method'] == 'POST' else 0   # 是否POST
94
        status_code = int(df.iloc[i]['Status'])
95
        is_error = 1 if status_code >= 400 else 0       # 是否为错误状态码（4xx/5xx）
96

97
        features.append([cur_count, unique_templates, is_post, is_error])
98

99
    X = np.array(features)
100

101
    # 6. 训练 Isolation Forest 模型
102
    print("训练Isolation Forest...")
103
    iso = IsolationForest(n_estimators=100, contamination=0.05, random_state=42)
104
    preds = iso.fit_predict(X)          # -1 异常, 1 正常
105
    df['anomaly_score'] = iso.score_samples(X)   # 异常分数（越小越异常）
106
    df['is_anomaly'] = (preds == -1)            # 布尔标记
107

108
    # 7. 结果排序并保存
109
    df_sorted = df.sort_values('anomaly_score')
110
    output_cols = ['IP', 'Timestamp', 'log_message', 'Status', 'template_id', 'anomaly_score', 'is_anomaly']
111
    df_sorted[output_cols].to_csv('results.csv', index=False)
112
    print("结果已保存至 results.csv")
113

114
    # ---------- 8. 可视化 ----------
115
    os.makedirs('charts', exist_ok=True)
116

117
    plt.rcParams['font.sans-serif'] = ['SimHei']   # 中文显示
118
    plt.rcParams['axes.unicode_minus'] = False     # 负号正常显示
119

120
    # 图1：异常分数分布直方图
121
    plt.figure(figsize=(10, 5))
122
    plt.hist(df['anomaly_score'], bins=50, color='steelblue', edgecolor='black')
123
    threshold = np.percentile(df['anomaly_score'], 5)
124
    plt.axvline(x=threshold, color='red', linestyle='--', label=f'5% 阈值 ({threshold:.2f})')
125
    plt.xlabel('异常分数')
126
    plt.ylabel('频数')
127
    plt.title('异常分数分布')
128
    plt.legend()
129
    plt.savefig('charts/异常分数分布直方图.png')
130
    plt.close()
131

132
    # 图2：预测异常占比饼图
133
    anom_counts = df['is_anomaly'].value_counts()
134
    labels = ['正常', '异常']
135
    if anom_counts.index[0] == True:   # 确保“正常”在前
136
        anom_counts = anom_counts[::-1]
137
    plt.figure(figsize=(6, 6))
138
    plt.pie(anom_counts, labels=labels, autopct='%1.1f%%', startangle=90)
139
    plt.title('预测异常占比')
140
    plt.savefig('charts/预测异常占比饼图.png')
141
    plt.close()
142

143
    # 图3：各小时异常请求数量柱状图
144
    if 'Hour' not in df.columns:
145
        df['Hour'] = pd.to_datetime(df['Timestamp']).dt.hour
146
    anomaly_by_hour = df[df['is_anomaly']].groupby('Hour').size()
147
    all_hours = pd.Series(0, index=range(24))
148
    anomaly_by_hour = all_hours.add(anomaly_by_hour, fill_value=0)
149

150
    plt.figure(figsize=(10, 5))
151
    plt.bar(anomaly_by_hour.index, anomaly_by_hour.values, color='coral', edgecolor='black')
152
    plt.xlabel('小时')
153
    plt.ylabel('异常请求数量')
154
    plt.title('各小时异常请求分布')
155
    plt.xticks(range(0, 24, 2))
156
    plt.grid(axis='y', alpha=0.5)
157
    plt.savefig('charts/各小时异常请求数量柱状图.png')
158
    plt.close()
159

160
    print("可视化图表已保存至 charts/ 文件夹")
161

162
if __name__ == '__main__':
163
    main()

1
preprocess.py运行结果：
2
D:\miniconda3\python.exe C:\Users\Mudrock\Desktop\日志审计\综合实验\preprocess.py
3
去重后条数: 13437
4
清洗完成，最终条数: 13413，字段数: 8
5

6
进程已结束，退出代码为 0
7

8

9
algo.py运行结果
10
D:\miniconda3\python.exe C:\Users\Mudrock\Desktop\日志审计\综合实验\algo.py
11
开始Drain模板提取...
12
共提取 16 个不同模板
13
构造时间窗口特征...
14
训练Isolation Forest...
15
结果已保存至 results.csv
16
可视化图表已保存至 charts/ 文件夹
17

18
进程已结束，退出代码为 0

1
{
2
  "1": { "template": "GET <*>", "size": 12106 },
3
  "2": { "template": "POST <*>", "size": 632 },
4
  "3": { "template": "GET <*> oj <*> testing contest", "size": 581 },
5
  "4": { "template": "GET /contestproblem.php?name=<*> contest <NUM>", "size": 1 },
6
  "5": { "template": "GET /contestproblem.php?name=<*> <NUM>", "size": 4 },
7
  "6": { "template": "GET /description.php?name=<*> <*>", "size": 4 },
8
  "7": { "template": "GET /description.php?name=<*> a little makes a mickle", "size": 3 },
9
  "8": { "template": "GET <*> rahaman", "size": 4 },
10
  "9": { "template": "GET /details.php?name=<*> <*>", "size": 39 },
11
  "10": { "template": "GET /details.php?name=<*> for my valentine &cod=<*>", "size": 4 },
12
  "11": { "template": "GET /contestproblem.php?name=<*> <*> <*> <*>", "size": 9 },
13
  "12": { "template": "GET <*> multiplication <*>", "size": 7 },
14
  "13": { "template": "GET /description.php?name=<*> for my valentine", "size": 1 },
15
  "14": { "template": "GET /contestproblem.php?name=<*> oj testing contest <NUM>", "size": 7 },
16
  "15": { "template": "GET /description.php?name=<*> feeling lucky.", "size": 2 },
17
  "16": { "template": "HEAD <*>", "size": 9 }
18
}