Multi-Source Cybersecurity Logs: An ATT&CK-Labeled Dataset and SLM Evaluation
This paper introduces a novel multi-source cybersecurity dataset comprising 870 sessions with system, network, and browser logs labeled with granular MITRE ATT&CK techniques, and demonstrates that fine-tuning Small Language Models on this data significantly enhances their ability to classify malicious events and identify attack techniques.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine you are trying to solve a mystery in a busy office building. To catch a thief, you can't just look at the security cameras (network logs); you also need to check the employee badge swipes (system logs) and the receipts from the coffee shop or online store (browser logs). If you only look at one source, the thief can easily hide.
This paper is about building a super-detailed training manual for computer detectives and testing if a new type of "smart assistant" (called a Small Language Model) can learn to spot the thief using that manual.
Here is the breakdown of what they did, using simple analogies:
1. The Problem: The "Blind Detective"
Currently, most computer security datasets are like giving a detective a map of only the parking lot. They miss what happened inside the building (system logs) or what the person was looking at on their computer screen (browser logs).
- The Gap: Existing data either misses the browser activity, misses the system activity, or just says "Bad Guy" or "Good Guy" without explaining how the bad guy did it (like which specific lock-picking technique they used).
- The Goal: The authors wanted to create a dataset that captures everything happening at the same time (System + Network + Browser) and labels every bad move with a specific "technique name" from a famous security playbook called MITRE ATT&CK.
2. The Solution: Building the "Mystery Simulator"
The authors didn't just guess what attacks look like; they built a realistic simulation lab.
- The Setup: They set up a safe, isolated digital room (a lab) where they could run real malware without hurting anyone.
- The Actors: They ran 870 sessions (simulations).
- 800 sessions were "Good Guys" just doing normal work (browsing, writing emails, coding).
- 70 sessions were "Bad Guys" using real hacking tools (like Remote Access Trojans and ransomware) to steal data or lock up computers.
- The Result: They collected about 2.3 million events (like footprints, door openings, and phone calls) and labeled them. They covered 53 different hacking techniques across 12 different attack goals.
- The "Chunk": To make it easy for the computer to read, they grouped the data into small bundles called "chunks." Imagine a chunk is a 7-second video clip of the attack. The computer has to look at this 7-step sequence to decide: "Is this a normal day, or is a robbery happening?"
3. The Test: Training the "Smart Assistants"
They took three small, efficient AI models (called SLMs—think of them as smart but compact assistants, not the massive, heavy super-computers) and tried to teach them using their new dataset.
- The Models: They used three different "brains": Qwen, Llama, and Phi.
- The Method: They used a technique called LoRA. Imagine this as giving the AI a specialized cheat sheet or a set of sticky notes with the rules of the game, rather than rewriting the AI's entire brain. This is fast and cheap.
4. The Results: From "Clueless" to "Expert"
The results were dramatic, like turning a blindfolded person into a sharp-eyed detective overnight.
Before Training (The "Base" Models):
- The AI was terrible. It got about 8% of the answers right.
- The Big Flaw: The AI was a "cry wolf" machine. It was so paranoid that it labeled almost every single normal session as an attack. It was like a security guard who thinks everyone walking into the office is a thief. It was useless in real life because it would create too many false alarms.
After Training (The "Fine-Tuned" Models):
- The AI became excellent. Accuracy jumped to between 90% and 97%.
- It finally learned to tell the difference between a normal user browsing the web and a hacker stealing data.
- The Winner: The Phi-4-Mini model was the best, catching 97% of the attacks. The others were good, but one (Llama) missed more than half the attacks.
The "Technique" Challenge:
- While the AI got very good at saying "This is an attack," it was still a bit shaky when asked to name the exact specific technique used (e.g., "They used T1059.001").
- The best model only got the exact name right 42% of the time. However, it was very good at getting the general idea right (partial matches), meaning it understood the logic even if it couldn't spell the technical term perfectly.
5. The Takeaway
The paper proves two main things:
- The Dataset Works: You can create a high-quality, multi-source dataset using real attack simulations, and it contains clear patterns that computers can learn.
- Training is Essential: You cannot just take a generic AI and expect it to catch hackers. It needs to be "fine-tuned" on specific security data. Without this training, the AI is too paranoid to be useful. With training, it becomes a powerful tool for security teams to triage (sort out) alerts quickly.
In short: They built a realistic "hacking simulator," taught three small AI assistants how to spot the bad guys, and proved that with the right training, these small assistants can become very effective security guards.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.