seifreed/yaraastUna potente libreria Python e strumento CLI per analizzare, esaminare e manipolare regole YARA tramite rappresentazione ad Albero Sintattico Astratto (AST).
Analizza, analizza e trasforma regole YARA con un toolkit AST in Python
yaraast è una libreria Python per analizzare e manipolare regole della famiglia YARA utilizzando Alberi Sintattici Astratti (AST). Supporta i flussi di lavoro classici YARA, YARA-L e YARA-X con rilevamento automatico del dialetto e strumenti CLI.
| Caratteristica | Descrizione |
|---|---|
| Parsing Multi-dialetto | Analizza YARA, YARA-L e YARA-X da file o stringhe |
| Rilevamento Automatico del Dialetto | Parser unificato che rileva automaticamente i dialetti delle regole |
| Strumenti AST | Costruisci, trasforma, confronta e serializza AST |
| Formattazione e Validazione | Comandi CLI per flussi di lavoro parse/format/validate |
| Supporto Streaming | Analizza file molto grandi con modalità streaming |
| Integrazioni Ecosistema | Funzionalità opzionali LSP e relative a libyara |
Dialetti YARA, YARA-L, YARA-X
Parser Parser standard, parser unificato, parser streaming
Output YARA, JSON, YAML, viste ad albero AST
Strumenti CLI, visitor, builder, serializzazione, controlli semantici
I livelli di supporto variano in base al dialetto. YARA classico è stabile, YARA-X è in beta, YARA-L è sperimentale e il rilevamento automatico del dialetto è best effort. Consulta la matrice di compatibilità per i motori e le funzionalità esatti testati dalla CI.
pip install yaraast
git clone https://github.com/seifreed/yaraast.git
cd yaraast
python3 -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activate
pip install -e .
import yaraast
yara_code = """
rule example {
strings:
$a = "malware" nocase
condition:
$a
}
"""
document = yaraast.parse(yara_code)
print(document.ast.rules[0].name)
# Analizza e stampa YARA normalizzato
yaraast parse rules.yar
# Analizza in JSON
yaraast parse rules.yar --format json
# Analizza con dialetto esplicito
yaraast parse rules.yar --dialect yara-x
# Valida file (controlli sintassi + parsing)
yaraast validate rules.yar
# Formatta file in-place (formattatore basato su AST)
yaraast fmt rules.yar
# Controlla la formattazione senza modificare il file
yaraast fmt rules.yar --check
| Comando | Descrizione |
|---|---|
parse | Analizza un file di regole e genera output YARA/JSON/YAML/albero |
validate | Valida le regole ed esegue sottocomandi di validazione |
fmt | Formattatore basato su AST (con --check e --diff) |
format | Formatta l'input in un file di output di destinazione |
validate-syntax | Punto di ingresso per la validazione focalizzata sulla sintassi |
lsp | Avvia le funzionalità del Language Server Protocol |
from pathlib import Path
import yaraast
source = "rule example { condition: true }"
# Rilevamento automatico del dialetto
document = yaraast.parse(source)
# Forza un dialetto specifico
document = yaraast.parse(source, dialect="yara")
# Analizza file, genera nuovo sorgente e formatta in modo canonico
Path("rules.yar").write_text(source, encoding="utf-8")
file_document = yaraast.parse_file("rules.yar")
generated = yaraast.generate(file_document)
formatted = yaraast.format_canonical(source, dialect="yara")
# Preserva ogni byte al di fuori di una modifica esplicita UTF-8
offset = source.encode("utf-8").index(b"true")
rewritten = yaraast.rewrite_lossless(
source,
[yaraast.SourceEdit(offset, offset + 4, "false")],
)
# I parser pubblici applicano limiti predefiniti. Sovrascrivili per operazione quando necessario.
limits = yaraast.ResourceLimits(max_input_bytes=1024 * 1024, parse_deadline=5.0)
document = yaraast.parse(source, resource_limits=limits)
cancel = yaraast.CancellationToken()
cancel.cancel()
# yaraast.parse(source, cancellation_token=cancel) solleva ParseCancelledError
ResourceLimits() disabilita esplicitamente tutti i limiti. Il parsing CLI utilizza i
predefiniti pubblici; il parsing LSP utilizza limiti più restrittivi per input, token, annidamento, pattern e scadenza
e non memorizza mai nella cache un risultato parziale dopo una cancellazione o un fallimento del limite.
from pathlib import Path
from yaraast.parser import Parser
from yaraast.visitor import BaseVisitor
class RuleCollector(BaseVisitor):
def __init__(self):
self.rules = []
def visit_rule(self, node):
self.rules.append(node.name)
super().visit_rule(node)
ast = Parser(Path("rules.yar").read_text(encoding="utf-8")).parse()
collector = RuleCollector()
collector.visit(ast)
print(collector.rules)
# Supporto LSP
pip install yaraast[lsp]
# Integrazione libyara
pip install yaraast[libyara]
# Strumenti di performance
pip install yaraast[performance]
# Supporto visualizzazione
pip install yaraast[visualization]
# Pacchetto di supporto runtime
pip install yaraast[all]
# Strumenti runtime e di sviluppo
pip install yaraast[dev-all]
I contributi sono benvenuti. Consulta CONTRIBUTING.md per configurazione, controlli di qualità e linee guida sul flusso di lavoro.
git checkout -b feature/your-change)git commit -m "Add your change")git push origin feature/your-change)La politica del progetto è documentata in SECURITY.md, CODE_OF_CONDUCT.md, CHANGELOG.md e MIGRATING.md.
Questo progetto è concesso in licenza sotto la MIT License - consulta LICENSE.
Autore
Costruito per flussi di lavoro di analisi malware e ingegneria del rilevamento