Skip to main content

What are YARA rules?

YARA rules describe malware families as text or byte patterns plus a condition, so analysts can scan files and memory for matches.

Glossary
Updated 2 min read

Definition

YARA rules

Also called YARA, YARA rule

YARA rules are pattern-matching descriptions of malware or other files, made of text, hexadecimal, or regular expression strings plus a Boolean condition, that the open-source YARA tool uses to identify and classify matching files.

How it works

YARA's project page describes it as a tool aimed at helping malware researchers identify and classify malware samples by creating descriptions of malware families based on textual or binary patterns. Each description, or rule, consists of a set of strings and a Boolean expression that determines its logic.

The documentation describes the syntax as resembling C. A rule starts with the keyword rule and an identifier. It has an optional strings section, where each string gets a $ identifier and is defined as text, hex bytes, or a regular expression, and a required condition section that combines them with operators such as and, or, any of, and file-size checks. YARA runs on Windows, Linux, and macOS, from the command line or from Python through yara-python.

Example

A rule that flags files containing both a distinctive string and a byte sequence from a loader, but only if the file is small:

rule Example_Loader
{
    meta:
        description = "Illustrative loader detection"
    strings:
        $text = "UVODFRYSIHLNWPEJXQZAKCBGMT"
        $bytes = { 6A 40 68 00 30 00 00 6A 14 8D 91 }
    condition:
        $text and $bytes and filesize < 500KB
}

Why it matters for a SOC

YARA is the standard way to turn malware analysis into something scannable. Threat intelligence reports often ship YARA rules alongside indicators of compromise, and responders run them across endpoints, file shares, email attachments, and memory images during an investigation to answer "where else is this?" Because a good rule keys on structural patterns rather than a single hash, it survives recompiles that would defeat hash matching. Rules still need testing against clean files: overly broad strings are a common source of false positives, which is why tools such as YARA-CI exist to test rules continuously.

Rule quality also affects speed, which matters when scanning file shares or many endpoints. The community YARA performance guidelines on GitHub explain that YARA first extracts short substrings called atoms, of at most 4 bytes, from each string to drive a fast multi-pattern search, then verifies full matches and evaluates conditions. The practical advice follows: avoid strings shorter than 4 bytes, keep a long concrete segment in hex strings with wildcards, use regular expressions sparingly and anchor them, and put cheap checks like filesize first in the condition.

Go deeper

FAQ

What is the difference between YARA and Sigma?
YARA matches patterns inside files and memory. Sigma matches events in log data. The Sigma project describes itself as doing for log files what YARA does for files, and teams commonly use both.

Sources

  1. Writing YARA rules | YARA documentation · accessed November 16, 2026
  2. Neo23x0/YARA-Performance-Guidelines (GitHub) · accessed November 16, 2026
  3. YARA - The pattern matching swiss knife for malware researchers · accessed November 16, 2026

Attackers are scaling with tokens

Cotool helps defenders operate at machine speed. See how security teams are scaling Detection & Response.

Book a demo