Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
yaraast — Una potente libreria Python e strumento CLI per analizzare, esaminare e manipolare regole YARA tramite rappresentazione ad Albero Sintattico Astratto (AST). | Kitploit
Strumenti/GitHubGitHub/seifreed/yaraast
Analisi StaticaAnalisi delle VulnerabilitàAnalisi del CodiceScripting e AutomazioneAnalisi MalwareUtilità e Framework
GitHubseifreed/yaraast

yaraast

Una potente libreria Python e strumento CLI per analizzare, esaminare e manipolare regole YARA tramite rappresentazione ad Albero Sintattico Astratto (AST).

Vedi Repository
54514310 giorni faRevisionato da Kitploit
Condividi
<p align="center">
  <img src="https://img.shields.io/badge/YARAAST-YARA%20Parser%20&amp;%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&amp;style=flat-square&amp;logo=github&amp;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&amp;logo=python&amp;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&amp;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&amp;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&amp;logo=readthedocs&amp;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>
Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Nessun dato di popolarità ancora.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →