Linux命令

YARA: A Tool for Identifying and Classifying Malware Samples​

​​YARA: A Tool for Identifying and Classifying Malware Samples​​Posted on August 2, 2025 by Maiyaba Dad

data-ad-format="fluid" data-ad-layout-key="-7k+ex-4a-9w+4a">

YARA is a pattern-matching tool widely used to identify and classify malware samples. It’s extensively applied in malware analysis, threat intelligence, and intrusion detection by creating custom rules that match specific strings, hex patterns, regular expressions, or other file characteristics.

friend link：(2 封私信) YARA-规则匹配神器-简单使用篇 - 知乎

github：https://github.com/VirusTotal/yara

I. Basic YARA Usage

​​Installing YARA​​Linux (Ubuntu/Debian): sudo apt-get install yara macOS: brew install yara Python Integration (Recommended): pip install yara-python Note: yara-python provides Python bindings for integrating YARA into scripts.

​​Writing YARA Rules (.yar files)​​Example rule (example.yar): rule HelloWorld { meta: author = “YourName” description = “Detects the string ‘Hello, World!’” strings: $hello = “Hello, World!” ascii condition: $hello }

​​Command-Line Execution​​ yara example.yar target_file.txt Output if matched: HelloWorld target_file.txt

II. Python Integration Examples

​​Scan a file using yara-python:​​

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import yara

# Compile rule
rules = yara.compile(filepath='example.yar')

# Scan target
matches = rules.match('target_file.txt')

# Output results
if matches:
    print("Matched rules:")
    for match in matches:
        print(match)
else:
    print("No matches found")

​​Load rules from a string:​​

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import yara

# Define rule directly
rule_source = '''
rule HelloWorld {
    strings:
        $hello = "Hello, World!" ascii
    condition:
        $hello
}
'''

# Compile and scan
rules = yara.compile(source=rule_source)
matches = rules.match('target_file.txt')
print(matches)

​​Scan all files in a directory:​​

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import yara
import os

def scan_directory(directory, rules):
    for root, _, files in os.walk(directory):
        for file in files:
            filepath = os.path.join(root, file)
            try:
                matches = rules.match(filepath)
                if matches:
                    print(f"[+] Match: {filepath} -> {matches}")
            except Exception as e:
                print(f"[-] Error scanning {filepath}: {e}")

# Execute scan
rules = yara.compile(filepath='example.yar')
scan_directory('/path/to/scan', rules)

III. Advanced YARA Rules

​​Detect suspicious imports in PE files:​​

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import "pe"

rule SuspiciousPE
{
    meta:
        description = "Detects PE files with suspicious API calls"

    condition:
        pe.is_pe and
        any of ($suspicious_funcs) in (pe.imported_functions)
    
    strings:
        $suspicious_funcs = "VirtualAllocEx"
        $suspicious_funcs = "WriteProcessMemory"
        $suspicious_funcs = "CreateRemoteThread"
}

Note: Requires valid PE files for pe module.

IV. SIEM/SOC Integration Strategies

  • ​​Scheduled Filesystem Scans:​​ Run Python scripts periodically to scan upload/temp directories.

  • ​​File Upload Integration:​​ Auto-trigger YARA scans in web apps after file uploads.

  • ​​ELK/Splunk Integration:​​ Send scan results to SIEM for alerting.

  • ​​Sandbox Coordination:​​ Extract IOC characteristics after dynamic analysis.

V. Practical Tips

​​Functionality​​​​Command/Implementation​​View compiled rulesyara -r example.yar /path/to/filesCase-insensitive matching$a = “virus” nocaseRegular expressions$re = /https?://[a-zA-Z0-9./]*/File header detection$mz = { 4D 5A } condition: $mz at 0

VI. Troubleshooting

  • ​​Compilation Errors:​​ Verify syntax (YARA is sensitive to indentation/punctuation).

  • ​​Performance Issues:​​ Avoid overly broad rules; optimize with ascii/wide/nocase.

  • ​​Permissions:​​ System file scanning may require elevated privileges.

  • Official Documentation

Rule Repositories:

  • Yara-Rules/rules

  • Neo23x0/signature-base

Online Rule Tester

Key Applications

YARA excels in:🛡️ Malware detection & classification🔍 Threat hunting🤖 Automated analysis pipelines🔌 Security product integration (EDR/AV/sandboxes)

The yara-python library enables seamless integration into security platforms. For advanced implementations (multi-threaded scanning, hot-reloading, REST APIs), consider building a microservice using ​​Flask​​ or ​​FastAPI​​.

​​Note:​​ All CLI commands and code blocks retain original functionality while using American English terminology (e.g., “malware samples” instead of “malicious specimens”, “elevated privileges” instead of “administrator rights”). Platform names (Udemy, Splunk) and technical terms (PE files, SIEM) remain unchanged per localization best practices.

data-ad-format="auto" data-full-width-responsive="true">