Vigolium - Scanner de vulnérabilités haute fidélité combinant IA agentique avec vitesse native, modularité et précision

Vigolium propose deux modes de scan complémentaires :

Scan natif (vigolium scan) : Rapide, puissant et flexible. Analyse déterministe en plusieurs phases avec 317 modules couvrant la découverte de contenu, le spidering navigateur/SPA, et l'audit actif/passif, couvrant les classes de vulnérabilités d'injection, de contrôle d'accès, de fichiers/chemins, d'API/protocole, spécifiques aux frameworks, cloud/infra, et hors bande (OAST).
Scan agentique (vigolium agent) : Audite en profondeur votre codebase. Analyse pilotée par l'IA qui planifie les attaques de manière autonome, sélectionne les modules, génère des extensions personnalisées et trie les résultats, en combinant audit de code source approfondi avec une analyse de vulnérabilités autonome et ciblée.

Installation

Installation rapide (recommandée)```bash

curl -fsSL https://vigolium.com/install.sh | bash

### [npm](https://www.npmjs.com/package/@vigolium/vigolium)```bash
npm install -g @vigolium/vigolium

Autre méthode, comme Docker ou la compilation depuis les sources

Docker```bash

docker pull j3ssie/vigolium:latest docker run --rm j3ssie/vigolium:latest scan -h

### Compiler à partir des sources```bash
git clone https://github.com/vigolium/vigolium.git
cd vigolium
make build         # build and install to $GOPATH/bin

Nécessite Go 1.26+ et bun 1.3.11+. Voir HACKING.md pour les prérequis et les détails de compilation.

Tableau de bord UI	Tableau de bord du trafic

Rapports statiques	Rapports statiques

Analyse native	Analyse agentique

Fonctionnalités clés

Analyse native

323 modules de scanner : 207 actifs (fuzzing) + 116 passifs (correspondance de motifs), couvrant l'OWASP Top 10 et au-delà
Tests hors bande (OAST) : XSS/SSRF/injection de commande aveugles via les rappels interactsh avec corrélation automatique des payloads
Mutation sensible à la valeur : classe les paramètres par type sémantique (entier, UUID, JWT, e-mail) et mute selon l'intention
Pipeline multi-phase : collecte externe, découverte de contenu (Deparos), exploration navigateur/SPA (Spitolas) et audit, contrôlés par des préréglages de stratégie et des profils d'analyse
Entrées flexibles : URLs, OpenAPI/Swagger, Postman, Burp Suite, cURL, Nuclei JSONL
Authentification multi-session : sessions en ligne, fichiers de session ou configurations d'authentification complètes avec flux de connexion, extraction de jetons et tests IDOR/BOLA
Extensions JavaScript : modules et hooks personnalisés via un moteur JS intégré avec des API HTTP tenant compte de la session
Évolutif et rapportable : pool de workers concurrent avec limitation de débit par hôte, file hybride mémoire/disque/Redis et rapports HTML autonomes

Analyse agentique

Runtime olium intégré au processus : chaque mode d'agent s'exécute sur le moteur natif Go pkg/olium : boucle au tour par tour, registre d'outils intégré, prise en charge des compétences et pilotes de fournisseur enfichables (pas de pools SDK en sous-processus)
Autopilote : l'agent découvre les points de terminaison de manière autonome, exécute des analyses et trie les résultats, avec un pipeline multi-spécialiste et une reprise de session en option
Essaim : l'agent maître sélectionne les modules, génère des extensions d'attaque JS personnalisées, exécute l'audit de code + SAST, lance les analyses et trie les résultats ; ciblé ou en portée complète (--discover), avec --diff/--last-commits pour les exécutions centrées sur les modifications
Pilotes d'audit source : audit, piolium et le répartiteur unifié audit exécutent des audits de code source au premier plan partageant un même schéma de constatations et un balisage en base de données
Mode requête : invites à usage unique pour la revue de code, la découverte de points de terminaison et la détection de secrets
Fournisseurs enfichables : openai-compatible (par défaut), openai-codex-oauth, openai-api-key, openai-responses, anthropic-api-key, anthropic-oauth, anthropic-cli, anthropic-compatible, anthropic-vertex, google-vertex. Les mêmes modes sont exposés via l'API REST avec streaming SSE et un endpoint de chat compatible OpenAI

Démarrage rapide : Analyse native```bash

Scan a single target (default: balanced strategy)

vigolium scan -t https://example.com

Scan with a strategy preset

vigolium scan -t https://example.com --strategy deep

Scan specific modules only

vigolium scan -t https://example.com -m xss-reflected,sqli-error

Scan from an OpenAPI spec

vigolium scan -T openapi.yaml -I openapi

Pipe URLs from stdin

cat urls.txt | vigolium scan

Run a single phase directly

vigolium run discovery -t https://example.com

Generate an HTML report

vigolium scan -t https://example.com --only discovery --format html -o report.html

Voir la [vue d'ensemble de l'architecture](https://docs.vigolium.com/architecture/overview) pour le pipeline complet et le [guide des stratégies](https://docs.vigolium.com/native-scan/strategies) pour les stratégies, les profils et la configuration du rythme. Pour une référence rapide des commandes, voir [docs.vigolium.com/getting-started/cheat-sheet](https://docs.vigolium.com/getting-started/cheat-sheet).

## Mode Serveur```bash
# Start API server with authentication
vigolium server -k my-secret-key

# Enable transparent HTTP proxy for traffic recording
vigolium server -k my-key --ingest-proxy-port 9003

# Auto-scan ingested traffic
vigolium server -k my-key --scan-on-receive

I'm ready to translate the chunk, but the INPUT section appears to be empty. No Markdown content was provided to translate. Please supply the actual chunk text, and I'll translate it into French while preserving all formatting and code exactly as-is.```bash

Ingest traffic to a running server

cat urls.txt | vigolium ingest -s http://localhost:9002

Ingest an OpenAPI spec

vigolium ingest -s http://localhost:9002 -i api.yaml -I openapi

Voir [exécution du serveur](https://docs.vigolium.com/server-mode/running-the-server) pour la configuration du serveur, [ingestion](https://docs.vigolium.com/server-mode/ingestion) pour les flux d'ingestion, et la [vue d'ensemble de l'API](https://docs.vigolium.com/api-overview) pour la référence complète de l'API REST.

> **Intégration Burp Suite** : transmettez le trafic Burp Suite en direct vers un serveur Vigolium en cours d'exécution avec l'extension [burp-vigolium](https://github.com/vigolium/burp-vigolium).

## Analyse authentifiée

Vigolium prend en charge l'analyse authentifiée multi-session pour les tests IDOR/BOLA et les vérifications d'élévation de privilèges :```bash
# Inline session via CLI flag (name:Header:value)
vigolium scan -t https://example.com \
  --auth "admin:Cookie:session_id=abc123" \
  --auth "user:Cookie:session_id=xyz789"

# Load session(s) from a YAML/JSON file
vigolium scan -t https://example.com --auth-file ./admin-session.yaml

# Auth file with an automated login flow (token extraction, etc.)
vigolium scan -t https://example.com --auth-file ./login-flow.yaml

# Add custom headers (works with sessions)
vigolium scan -t https://example.com -H "Authorization: Bearer token123"

Les fichiers d'authentification prennent en charge les en-têtes statiques, les jetons bearer et les flux de connexion automatisés avec extraction de jetons à partir des cookies, des réponses JSON ou des en-têtes. Des exemples prédéfinis sont disponibles dans public/presets/sessions/. Consultez le guide d'authentification pour le guide complet.

Les drapeaux --auth / --auth-file s'appelaient auparavant --session / --session-file. Les anciens noms fonctionnent toujours comme alias obsolètes.

Scan agentique

Une analyse pilotée par l'IA où des agents planifient, exécutent et priorisent de manière autonome les évaluations de vulnérabilités avec le moteur de scan natif en arrière-plan :```bash

Autopilot: autonomous AI-driven scanning (in-process olium engine)

vigolium agent autopilot -t https://example.com vigolium agent autopilot -t https://example.com --source ./src --prompt "focus on auth bypass" vigolium agent autopilot -t https://example.com --diff main...feature/auth # diff-focused vigolium agent autopilot -t https://example.com --intensity deep # preset bundle

Swarm: AI-guided targeted or full-scope vulnerability scanning

vigolium agent swarm -t https://example.com/api/users --vuln-type sqli vigolium agent swarm -t https://example.com --discover # full-scope vigolium agent swarm -t https://example.com --source ./src --discover # source-aware full-scope vigolium agent swarm --input "curl -X POST https://example.com/api/login -d '{"user":"admin"}'"

Source-audit drivers (separate harness, do not route through olium)

vigolium agent audit --source ./src # default: auto (audit, fall back to piolium) vigolium agent audit --source ./src --driver audit --mode deep # vigolium-audit only (claude/codex) vigolium agent audit --source ./src --driver piolium --mode balanced # Pi-native (pi extension) only vigolium agent audit --source ./src --driver both # audit then piolium, back-to-back vigolium agent audit --source ./src --modes deep,confirm # chain modes (same as --intensity deep) vigolium agent audit --source ./src -S --output-dir ./audit-out # throwaway DB + bundled HTML report vigolium audit --source ./src # top-level alias

Direct olium access (TUI or headless)

vigolium ol # launch the olium TUI vigolium ol --prompt "..." # one-shot prompt (-p implies headless)

Modes de scan agentiques :
- **Autopilot** : scan autonome. La CLI appelle `pkg/olium/autopilot.Run` directement ; le serveur ajoute la préparation vigolium-audit, la configuration d'authentification et un ensemble de contexte figé autour de la même boucle
- **Swarm** : scan de vulnérabilités guidé par IA prenant en charge la requête unique ciblée et le périmètre complet (`--discover`). L'agent maître analyse les entrées, sélectionne les modules, génère des extensions JS personnalisées, exécute l'audit de code et la SAST, lance les scans et trie les résultats
- **Audit** : audit de code source via `vigolium agent audit` — un répartiteur unifié qui exécute les harnais intégrés **vigolium-audit** (claude/codex) et/ou **piolium** (natif Pi), sélectionnés avec `--driver {auto|both|audit|piolium}` (par défaut `auto` : exécute l'audit, ne bascule vers piolium que si l'audit échoue). Harnais séparés ; **ne pas** router via olium. Lignes enfants par pilote sous un parent AgenticScan unique avec déduplication des résultats après passage. Il n'existe pas de sous-commande `agent piolium` autonome — piolium s'exécute via `--driver=piolium`

> **CLI d'audit autonomes** : l'audit de sécurité agentique est également fourni sous forme de CLI autonomes que vous pouvez exécuter indépendamment de Vigolium : [vigolium-audit](https://github.com/vigolium/vigolium-audit) (le harnais derrière `vigolium agent audit`) et [piolium](https://github.com/vigolium/piolium) (le pilote natif Pi derrière `vigolium agent audit --driver=piolium`).

Consultez le [guide du mode agent](https://docs.vigolium.com/agentic-scan/agent-mode) pour le guide complet.

## ⚡ Vigolium Cloud Console

Une solution cloud pour les équipes qui veulent la puissance de Vigolium sans gérer d'infrastructure. La Console est la version **améliorée et complète de Vigolium** : scan géré, rapports centralisés, collaboration d'équipe et fonctionnalités supplémentaires superposées au cœur open source, afin que vous puissiez vous concentrer sur la correction des vulnérabilités plutôt que sur la maintenance des outils.

> Découvrez la Cloud Console sur [console.vigolium.com](https://console.vigolium.com/).

## Couches de scan natif

Le pipeline de scan natif est composé de couches modulaires, chacune documentée séparément :

| Couche | Description | Docs |
|-------|-------------|------|
| **Découverte de contenu (Deparos)** | Énumération adaptative de répertoires/fichiers avec détection de soft-404 basée sur les empreintes | [docs.vigolium.com/native-scan/phases/discovery](https://docs.vigolium.com/native-scan/phases/discovery) |
| **Spider navigateur (Spitolas)** | Crawler à machine à états piloté par Chromium avec capture du trafic CDP | [docs.vigolium.com/native-scan/phases/spidering](https://docs.vigolium.com/native-scan/phases/spidering) |
| **Audit** | Scan de vulnérabilités actif/passif avec extraction des points d'insertion et framework DiffScan | [docs.vigolium.com/native-scan/phases/audit](https://docs.vigolium.com/native-scan/phases/audit) |
| **Modules de scan** | 207 modules actifs et 116 modules passifs couvrant l'OWASP Top 10 et au-delà | [docs.vigolium.com/native-scan/modules-reference](https://docs.vigolium.com/native-scan/modules-reference) |

## Documentation

La documentation complète se trouve sur [docs.vigolium.com](https://docs.vigolium.com/). Les notes de version et l'historique des versions sont dans le [CHANGELOG](https://github.com/vigolium/vigolium/blob/HEAD/CHANGELOG.md). Liens rapides :

| Sujet | Lien |
|-------|------|
| Configurer les agents | [docs.vigolium.com/getting-started/setup-agent](https://docs.vigolium.com/getting-started/setup-agent) |
| Démarrer un scan natif | [docs.vigolium.com/getting-started/native-scan](https://docs.vigolium.com/getting-started/native-scan) |
| Démarrer un scan agentique | [docs.vigolium.com/getting-started/agentic-scan](https://docs.vigolium.com/getting-started/agentic-scan) |
| Démarrer un audit agentique | [docs.vigolium.com/getting-started/agentic-security-audit](https://docs.vigolium.com/getting-started/agentic-security-audit) |
| Démarrage rapide | [docs.vigolium.com/getting-started/quickstart](https://docs.vigolium.com/getting-started/quickstart) |
| Aide-mémoire | [docs.vigolium.com/getting-started/cheat-sheet](https://docs.vigolium.com/getting-started/cheat-sheet) |
| Serveur et ingestion | [docs.vigolium.com/getting-started/server-and-ingestion](https://docs.vigolium.com/getting-started/server-and-ingestion) |
| Écrire des extensions | [docs.vigolium.com/customization/writing-extensions](https://docs.vigolium.com/customization/writing-extensions) |

## Moteur JavaScript

Exécutez du code JavaScript/TypeScript directement ou écrivez des modules de scan et des hooks personnalisés sans recompilation :```bash
# Execute inline JavaScript
vigolium js --code 'let r = vigolium.http.get(TARGET); console.log(r.status)' -t https://example.com

# Run a JS file with timeout
vigolium js --code-file ./my-script.js -t https://example.com --timeout 60s

# Manage extensions
vigolium ext ls                # list loaded extensions
vigolium ext docs --example    # browse API with code examples
vigolium ext preset            # install starter scripts

Le moteur JS expose des API HTTP tenant compte de la session pour les tests authentifiés :```javascript // Create a persistent session with shared cookie jar. // post() takes a string body — serialize objects yourself. let session = vigolium.http.session(); session.post( "https://app.example.com/login", JSON.stringify({ user: "admin", pass: "secret" }), { headers: { "Content-Type": "application/json" } } ); session.get("https://app.example.com/dashboard"); // cookies auto-sent

// Automated login flow with token extraction let authed = vigolium.http.login({ url: "https://app.example.com/api/auth", method: "POST", body: JSON.stringify({ username: "admin", password: "pass" }), extract: [{ source: "json", path: "$.token", apply_as: "Authorization: Bearer {value}" }] });

// IDOR/BOLA testing across multiple sessions let results = vigolium.http.authTest({ sessions: { admin: adminSession, user: userSession }, requests: [{ method: "GET", url: "https://app.example.com/api/users/1" }] });

// Multi-step authentication sequences let result = vigolium.http.sequence([ { url: "/csrf", extract: [{ source: "cookie", name: "csrf_token", as: "token" }] }, { url: "/login", method: "POST", body: "csrf={token}&user=admin" } ]);

// Parallel request batching (race conditions, IDOR) let responses = vigolium.http.batch([req1, req2, req3], { concurrency: 10 });

// CSRF token extraction let csrf = vigolium.http.csrf("https://app.example.com/form");

// HTTP request replay with variations let varied = vigolium.http.replay(rawRequest, [ { headers: { "Authorization": "Bearer admin_token" } }, { headers: { "Authorization": "Bearer user_token" } } ]);

Consultez le [guide de création d'extensions](https://docs.vigolium.com/customization/writing-extensions) et `pkg/jsext/vigolium.d.ts` pour les définitions complètes de l'API TypeScript.

## Référence CLI

<details>
<summary>Déployez la référence complète des commandes et options</summary>

### Commandes```
Scanning:
  vigolium scan                Run a native scan (deterministic multi-phase vulnerability scanning)
  vigolium run <phase>         Run a single native scan phase (alias for scan --only <phase>)
  vigolium scan-url <url>      Quick native scan of a single URL
  vigolium scan-request        Native scan from a raw HTTP request

Agentic scan (in-process olium engine):
  vigolium agent autopilot     Autonomous AI-driven vulnerability scanning
  vigolium agent swarm         AI-guided targeted or full-scope vulnerability scanning
  vigolium agent query         Single-shot prompt (code review, endpoint discovery)
  vigolium agent olium         Direct olium TUI (or one-shot non-interactive via -p)
  vigolium agent audit         Unified driver dispatcher (vigolium-audit and/or piolium, --driver=auto|both|audit|piolium)
  vigolium agent session       Browse/replay agent session artifacts
  vigolium olium | vigolium ol Top-level alias for `vigolium agent olium`

Server & ingestion:
  vigolium server              Start the API server with traffic ingestion
  vigolium ingest              Ingest traffic to a running server
  vigolium storage             Interact with cloud object storage (uploads, downloads)

Data & projects:
  vigolium db                  Database operations (list, stats, export, clean, seed)
  vigolium finding             Browse and manage findings (load, tui)
  vigolium traffic             Browse and replay HTTP records (tui, replay)
  vigolium replay              Mutate a stored/supplied HTTP request and diff baseline vs replay
  vigolium project             Manage projects (create, list, use, config)
  vigolium scope               Manage scope rules
  vigolium import              Import findings/data from external sources
  vigolium export              Export scan results

Extensions & auth:
  vigolium js                  Execute JavaScript/TypeScript code
  vigolium ext                 Manage JavaScript extensions (eval, lint)
  vigolium auth                Manage authentication sessions (list, load, lint, totp)

Setup & introspection:
  vigolium init                Initialize a Vigolium workspace
  vigolium config              Manage configuration (ls, set, path, clean)
  vigolium strategy            Inspect scanning strategies and phases
  vigolium module              Inspect/enable scanner modules
  vigolium doctor              Diagnose environment & dependencies
  vigolium version             Show version info

Options```

Native Scan (vigolium scan / run): -t, --target Target URL -T, --target-file File containing target URLs -i, --input Input file path (- for stdin) -I, --input-mode Input format: urls, openapi, swagger, burp, curl, nuclei, har -m, --modules Modules to run (comma-separated or 'all') --strategy Strategy preset: lite, balanced, deep --scanning-profile Scanning profile name or YAML path --only Phases to run (comma-separated): ingestion, discovery (deparos), external-harvest, spidering (spitolas), known-issue-scan, dynamic-assessment, extension --skip Phases to skip (repeatable, same names as --only) -S, --stateless Use a throwaway temp database, discarded after the scan --fail-on Exit non-zero when a finding at/above this severity is present

Authentication: --auth Inline session definition (name:Header:value, repeatable) --auth-file Session YAML/JSON file path, supports login flows (repeatable) -H, --header Custom HTTP header (repeatable)

Performance: -c, --concurrency Concurrent workers (default: 50) -r, --rate-limit Max requests/sec (default: 0 = unlimited) --max-per-host Per-host concurrency cap (default: 2) --proxy HTTP/SOCKS5 proxy URL --timeout HTTP request timeout (default: 15s)

Agentic Scan (vigolium agent autopilot / swarm / query): --source Path to source code for source-aware scanning --files Specific files to include relative to --source --source-label Label for source code ingestion --provider Olium provider: openai-compatible (default), openai-codex-oauth, openai-api-key, openai-responses, anthropic-api-key, anthropic-oauth, anthropic-cli, anthropic-compatible, anthropic-claude-sdk-bridge, anthropic-vertex, google-vertex --model Model ID override --oauth-token OAuth bearer token (anthropic-oauth) --oauth-cred OAuth/SA file path (openai-codex-oauth, anthropic-vertex, google-vertex) --llm-api-key API key (anthropic-api-key, openai-api-key) --vuln-type Vulnerability type focus (sqli, xss, ssrf, ...) --prompt Free-text task guidance (same as the positional [prompt]) --plan-file Plan file mixing guidance + raw seed HTTP request(s) --knowledge-base File/dir describing the app; prose is distilled, traffic exports (HAR/Burp/curl/OpenAPI/Postman) are ingested --prior-context Front-load existing project traffic/findings: auto, summary, off --intensity Preset bundle: quick, balanced, deep --diff Diff range / PR URL / HEAD~~N for change-focused scans --last-commits Shorthand for --diff HEAD~~N --code-audit Enable AI code audit (default: on with --source) --discover Run discovery+spidering before planning (swarm) --audit vigolium-audit mode: lite, balanced, deep, mock, off --piolium Piolium audit mode (empty = auto-pick) --resume Resume a durable-autopilot run by agentic-scan UUID --session-dir Pin the session dir for this run's debug artifacts --transcript Copy transcript.jsonl out after the run --max-iterations Max triage-rescan iterations --max-commands Cap on agent tool calls --token-budget Cap on aggregate tokens --max-duration Max agent wall-clock time (0 = no limit) --only / --skip / --start-from Phase control (swarm)

Source audit (vigolium agent audit / vigolium audit): --driver auto (default), both, audit, piolium --intensity Preset: quick, balanced, deep (deep = modes deep,confirm) --mode Mode override: lite, balanced, deep, revisit, confirm, merge, ... --modes Chain modes back-to-back (e.g. deep,confirm) --list-modes Print the audit mode graph and exit --agent Coding agent for the audit leg: claude or codex --keep-raw Keep raw output under /vigolium-results/ (on by default) --clean-raw Remove the source-tree raw copy after the run -S, --stateless Run into a throwaway DB and auto-render an HTML report --output-dir Bundle the HTML report + raw results into one folder (needs -S) --no-dedup Skip the post-pass project-wide findings dedup --no-preflight Skip the pre-audit auth/model roundtrip checks -i, --interactive Drive the audit yourself in the coding agent (audit driver only)

JavaScript: --code Inline JavaScript to execute --code-file Path to JS/TS file to execute --timeout Execution timeout (default: 30s)

Output: -j, --json Compact, token-aware JSON output (read/query commands) --format Output format (comma-separated for multiple): console, jsonl, html, sqlite (needs -S), fs (flat traffic/finding tree) -o, --output Output file path --silent Suppress all output except findings -v, --verbose Verbose logging

</details>

## Structure du dépôt

Le répertoire `platform/` contient l'outillage externe et le tableau de bord UI, et ne fait pas partie du scanner principal. Aucune modification ne doit y être apportée.

## Bancs d'essai

Vigolium est continuellement évalué contre des applications volontairement vulnérables et également testé intensivement contre des cibles réelles via des programmes de bug bounty et de divulgation responsable.

- **Auto-hébergé (Docker) :** [DVWA](https://github.com/digininja/DVWA), [OWASP Juice Shop](https://github.com/juice-shop/juice-shop), [VAmPI](https://github.com/erev0s/VAmPI), [crAPI](https://github.com/OWASP/crAPI), [Vulnerable Java App](https://github.com/DataDog/vulnerable-java-application), [Vulnerable Nginx](https://github.com/detectify/vulnerable-nginx), [OopsSec Store](https://github.com/kOaDT/oss-oopssec-store) (application Next.js personnalisée)
- **Externe (hébergé) :** [Acunetix TestPHP](http://testphp.vulnweb.com), [Gin & Juice Shop](https://ginandjuice.shop), [Testfire](http://demo.testfire.net)
- **XSS et multi-vuln :** [BruteLogic XSS](https://github.com/vigolium/vigolium/blob/HEAD/test/benchmark/xss_scanner/), [XBOW](https://github.com/vigolium/vigolium/blob/HEAD/test/benchmark/definitions/xbow/) (XSS, SQLi, SSTI, LFI, SSRF, XXE, injection de commandes)

Exécutez les bancs d'essai avec `make test-canary` (applications Docker) ou `make test-integration` (XSS).

## Développement```bash
make build          # build and install
make test           # run all tests (auto-installs gotestsum)
make test-unit      # fast unit tests (-short, no external deps)
make test-e2e       # E2E tests (requires Docker)
make lint           # run linter
make fmt            # format code

Consultez HACKING.md pour le guide de build complet, la cartographie de la base de code et le guide de développement des modules.

Sécurité

Vigolium est un outil de sécurité offensive, et deux de ses parties sont intentionnellement permissives : le mode agent s'exécute sans sandbox (le LLM dispose d'un accès complet au shell, aux fichiers et au réseau sur l'hôte) et les extensions peuvent exécuter des commandes arbitraires. Exécutez le mode agent dans un conteneur/VM jetable dédié à l'engagement, et traitez les extensions non fiables comme du code non fiable. Consultez SECURITY.md avant de commencer, et signalez les vulnérabilités de Vigolium lui-même en privé à [email protected].

Licence

Vigolium est publié sous la GNU Affero General Public License v3.0. Les œuvres dérivées doivent rester ouvertes sous les mêmes conditions.

Conçu avec ♥ par @j3ssie, avec @theblackturtle comme principal contributeur initial.

Lire plus

vigolium v0.3.10

Catégories