
Una potente libreria Python e strumento CLI per analizzare, esaminare e manipolare regole YARA tramite rappresentazione ad Albero Sintattico Astratto (AST).
<p align="center">
<img src="https://img.shields.io/badge/YARAAST-YARA%20Parser%20&%20AST-blue?style=for-the-badge" alt="YARAAST">
</p>
<h1 align="center">yaraast</h1>
<p align="center">
<strong>Analizza, analizza e trasforma regole YARA con un toolkit AST in Python</strong>
</p>
<p align="center">
<a href="https://github.com/seifreed/yaraast/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/seifreed/yaraast/ci.yml?branch=main&style=flat-square&logo=github&label=CI" alt="CI"></a>
<a href="https://github.com/seifreed/yaraast/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="License: MIT"></a>
<img src="https://img.shields.io/badge/python-3.11--3.14-blue?style=flat-square&logo=python&logoColor=white" alt="Python 3.11-3.14">
</p>
<p align="center">
<a href="https://github.com/seifreed/yaraast/stargazers"><img src="https://img.shields.io/github/stars/seifreed/yaraast?style=flat-square&logo=github" alt="GitHub Stars"></a>
<a href="https://github.com/seifreed/yaraast/issues"><img src="https://img.shields.io/github/issues/seifreed/yaraast?style=flat-square&logo=github" alt="GitHub Issues"></a>
<a href="https://github.com/seifreed/yaraast/tree/main/docs"><img src="https://img.shields.io/badge/docs-GitHub-blue?style=flat-square&logo=readthedocs&logoColor=white" alt="Docs"></a>
</p>
---
## Panoramica
**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.
### Caratteristiche Principali
| 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 |
### Ecosistema di Regole Supportato
```text
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à](https://github.com/seifreed/yaraast/blob/main/docs/compatibility.md) per i motori e le
funzionalità esatti testati dalla CI.
---
## Installazione
### Da PyPI (Consigliato)
```bash
pip install yaraast
```
### Dal Codice Sorgente
```bash
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 .
```
---
## Avvio Rapido
```python
import yaraast
yara_code = """
rule example {
strings:
$a = "malware" nocase
condition:
$a
}
"""
document = yaraast.parse(yara_code)
print(document.ast.rules[0].name)
```
---
## Utilizzo
### Interfaccia a Riga di Comando
```bash
# 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
```
### Comandi CLI Principali
| 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 |
---
## Libreria Python
### Parsing Unificato
```python
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.
### Parser Diretto + Visitor
```python
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)
```
---
## Dipendenze Opzionali
```bash
# 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]
```
## Documentazione Runtime
- Compatibilità dialetti: [docs/compatibility.md](https://github.com/seifreed/yaraast/blob/main/docs/compatibility.md)
- Interni runtime LSP: [docs/lsp-runtime.md](https://github.com/seifreed/yaraast/blob/main/docs/lsp-runtime.md)
- Report parità LSP: [docs/lsp-parity-report.md](https://github.com/seifreed/yaraast/blob/main/docs/lsp-parity-report.md)
- Ultimo artefatto benchmark runtime: [docs/benchmarks/lsp-runtime-latest.json](https://github.com/seifreed/yaraast/blob/main/docs/benchmarks/lsp-runtime-latest.json)
---
## Requisiti
- Python 3.11, 3.12, 3.13 o 3.14
- Consulta [pyproject.toml](https://github.com/seifreed/yaraast/blob/main/pyproject.toml) per l'elenco completo di dipendenze ed extra
---
## Contributi
I contributi sono benvenuti. Consulta [CONTRIBUTING.md](https://github.com/seifreed/yaraast/blob/main/CONTRIBUTING.md) per configurazione, controlli di qualità e linee guida sul flusso di lavoro.
1. Fai il fork del repository
2. Crea un branch (`git checkout -b feature/your-change`)
3. Committa le modifiche (`git commit -m "Add your change"`)
4. Esegui il push (`git push origin feature/your-change`)
5. Apri una Pull Request
La politica del progetto è documentata in [SECURITY.md](https://github.com/seifreed/yaraast/blob/main/SECURITY.md),
[CODE_OF_CONDUCT.md](https://github.com/seifreed/yaraast/blob/main/CODE_OF_CONDUCT.md), [CHANGELOG.md](https://github.com/seifreed/yaraast/blob/main/CHANGELOG.md) e
[MIGRATING.md](https://github.com/seifreed/yaraast/blob/main/MIGRATING.md).
---
## Licenza
Questo progetto è concesso in licenza sotto la MIT License - consulta [LICENSE](https://github.com/seifreed/yaraast/blob/main/LICENSE).
**Autore**
- Marc Rivero ([[email protected]](mailto:[email protected]))
- Repository: [github.com/seifreed/yaraast](https://github.com/seifreed/yaraast)
---
<p align="center">
<sub>Costruito per flussi di lavoro di analisi malware e ingegneria del rilevamento</sub>
</p>Scopri gli strumenti più utilizzati dalla nostra community.
Nessun dato di popolarità ancora.