Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
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.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitLabGitLab/cognitive-functors/c4-meta-system
Autenticazione e AutorizzazioneStrumenti DifensiviMachine LearningRed TeamingSicurezza dell'IARilevamento di AnomalieAttacco Avversario
GitLabcognitive-functors/c4-meta-system

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

c4-meta-system

Difesa AI in produzione con protezione a 7 livelli: vincoli matematici, accesso object-capability, consenso O2 distribuito, etica SVETILO. Prima difesa open-source contro ThoughtVirus. BSL 1.1.

Vedi Repository
61 mese faNon ancora revisionato

C4-META System v1.0.0 (prototipo di ricerca)

Prototipo di ricerca per la difesa AI multi-livello: spiegabilità C4, classificatori ensemble, deoffuscamento, motore di sicurezza O₂, difesa ThoughtVirus e allineamento valoriale SVETILO. Grado alpha — validato internamente, audit esterno in sospeso.

License: BSL 1.1 Docker ThoughtVirus SVETILO Site AoC

Versione: 1.0.0-alpha | Stato: Prototipo di ricerca | Licenza: BSL 1.1 (gratuita fuori produzione; produzione → commerciale)

Autore: I.G. Selyutin. Co-autore del modello C4-META: N.I. Kovalev.
Identità del prodotto (2026-08): prototipo di ricerca BSL / profondità commerciale di uno stack di difesa C4 multi-livello più pesante (ensemble, scaffolding O₂, laboratorio red-team) basato su Apache-2.0 c4protocol.
Non è un secondo protocollo aperto. Non è una difesa AGI di produzione certificata. Non è “v8 FINAL”.
Audit di onestà: docs/AUDIT-c4-meta-system-2026-08.md.
Percorso di promozione: docs/PROMOTE-FROM-PROTOCOL.md (consumare/fissare c4protocol; nessun dump dell'ensemble nell'SDK sottile).
GitLab Pages = public/ (EN + public/ru/). Ricevuta per il runtime aperto: make conformance in c4protocol.

🎯 Panoramica

Il Sistema C4-META è un prototipo di ricerca per la difesa AI multi-livello che implementa:

Architettura di difesa a 4 livelli

root@kitploit:~
Input Sanitization → Semantic Analysis → Behavioral Analysis → Meta-Observer (O₂)
  • Livello 1 — Sanificazione dell'input: pipeline di deoffuscamento (leet speak, 90+ omoglifi Unicode, caratteri a larghezza zero, override RTL, Base64/ROT13)
  • Livello 2 — Analisi semantica: voto ensemble a 4 classificatori (ONNX BERT + RuleBased + Heuristic + LLM Semantic)
  • Livello 3 — Analisi comportamentale: moduli di difesa AoC, pattern matching, rilevamento di anomalie di traiettoria
  • Livello 4 — Meta-Osservatore (O₂): entropia di trasferimento, consenso BFT, entanglement semantico, analisi di grafi causali

Funzionalità principali

  • Voto ensemble a 4 classificatori — ONNX BERT + RuleBased (80+ pattern) + Heuristic (32 parole pericolose) + LLM Semantic (Ollama/DeepSeek)
  • Logica OR a doppio classificatore: BERT semantico + classificatore a parole chiave RuleBased con fallback OR — nessun singolo punto di guasto
  • 16 moduli di difesa AoC — 11 classici + 5 estesi (euristici/laboratorio; non è una pretesa di “tutti i guasti multi-agente risolti”)
  • Difesa ThoughtVirus — difesa a due livelli (rilevamento di pattern regex + analisi della traiettoria C4). Ispirata da arXiv:2603.00131 (Multi-Agent Security Initiative; non Microsoft)(https://arxiv.org/abs/2603.00131)
  • SVETILO — 7 sigilli euristici tramite value_verification.py (non un modello etico addestrato)
  • Spiegabilità C4 (T,S,A) — analisi delle coordinate cognitive tramite modello ONNX quantizzato (737KB, ~50ms)
  • Scaffolding O₂ — moduli di ricerca; il percorso BFT è simulazione consultiva, non FT bizantino di produzione
  • Deoffuscamento — leet speak, 90+ omoglifi Unicode, caratteri a larghezza zero, override RTL, Base64/ROT13
  • Laboratorio Red Team — progettazione scientifica controllo/trattamento, test esatto di Fisher, d di Cohen, CI bootstrap
  • Scanner di contenuti subliminali — rileva le mappature token→concetto
  • Rilevamento jailbreak multi-turno — tracciamento dell'escalation basato su sessione
  • Distribuzione Docker/K8s — distribuzione multi-nodo containerizzata

🏗 Architettura

root@kitploit:~
┌──────────────────────────────────────────────┐
│  LAYER 1: Input Sanitization                 │
│  Deobfuscation (homoglyphs, leetspeak, etc.) │
├──────────────────────────────────────────────┤
│  LAYER 2: Semantic Analysis                  │
│  4-Classifier Ensemble: ONNX_BERT (~50ms)    │
│  + RuleBased + Heuristic + LLM_SEMANTIC      │
│  Dual classifier OR-logic (BERT+RuleBased)   │
├──────────────────────────────────────────────┤
│  LAYER 3: Behavioral Analysis                │
│  16 AoC Defense Modules (11 original + 5     │
│  extended), Pattern matching, Trajectory     │
│  anomaly detection, ThoughtVirus defense     │
├──────────────────────────────────────────────┤
│  LAYER 4: Meta-Observer (O₂)                 │
│  Transfer entropy, BFT consensus,            │
│  semantic entanglement, causal graphs,       │
│  Kill-Switch, SVETILO value verification     │
├──────────────────────────────────────────────┤
│  C4 Core Engine (Z₃³)                        │
│  pipeline_orchestrator.py, event_bus.py      │
│  c4_meta_monitor.py — self-awareness deque  │
├──────────────────────────────────────────────┤
│  Defenses: Anti-Deadlock, Anti-Emergence,    │
│  Anti-Hijack, Circuit Breaker, O₂ Kill-Switch│
├──────────────────────────────────────────────┤
│  Red Team Lab: AOC scenarios, experiment     │
│  runner, LLM client, adapters                │
├──────────────────────────────────────────────┤
│  Routing: Smart Router, Quarantine,          │
│  Antifragile Scoring (capped growth)         │
└──────────────────────────────────────────────┘

Voto dei 4 classificatori:

  • ONNX_BERT: coordinate cognitive C4 (T,S,A) tramite modello quantizzato (737KB, ~50ms)
  • RuleBased: 80+ pattern regex che coprono injection, jailbreak, role-play, bypass dell'autorità
  • Heuristic: 32 parole pericolose + analisi degli assi C4 + metrica di densità semantica
  • LLM_SEMANTIC: Ollama/DeepSeek — classificazione semantica degli attacchi (~300ms)

Logica OR a doppio classificatore: BERT + RuleBased operano come gate primario con fallback OR — se uno dei due segnala l'input, questo procede ai livelli di difesa. Nessun singolo classificatore è un collo di bottiglia.

📁 Struttura del progetto

root@kitploit:~
c4-meta-system/
├── v4_1/
│   ├── core/
│   │   ├── pipeline.py                  # Main entry points (re-exports)
│   │   ├── __main__.py                  # HTTP server entrypoint for Docker
│   │   ├── pipeline_stages.py           # Individual processing stages
│   │   ├── pipeline_orchestrator.py      # Main orchestration (thread-safe)
│   │   ├── result_factory.py             # Standardized C4v4Result factory
│   │   ├── event_bus.py                  # Organic event bus (atexit cleanup)
│   │   └── c4_meta_monitor.py            # Z³ self-awareness (deque bounded)
│   ├── security/
│   │   ├── o2_engine.py                  # O₂ defense (kill-switch self-DoS fixed)
│   │   ├── explainable_o2.py             # O₂ explainability (sampling inverted)
│   │   ├── o2_shared.py                  # Window structures (@mention comms)
│   │   ├── semantic_detector.py          # Concept graphs (normalized entanglement)
│   │   ├── secure_debug_endpoints.py     # Debug endpoints (UTC + rate limits)
│   │   ├── hardening.py                  # Model signing / admin token verification
│   │   ├── behavioral_profiler.py        # Drift detection (thread-safe singleton)
│   │   ├── distributed_o2.py             # SQLite/Redis backend (BEGIN IMMEDIATE)
│   │   ├── swarm_orchestrator.py         # Anti-virus swarm
│   │   └── ...
│   ├── defenses/
│   │   ├── anti_deadlock.py              # Resource deadlock prevention
│   │   ├── anti_emergence.py             # State convergence (async release fixed)
│   │   └── ...
│   ├── redteam/
│   │   ├── orchestrator.py              # Main orchestrator (target_callback parsing)
│   │   ├── scenario_manager.py           # AOC scenarios management
│   │   ├── adapters/                     # LLM backend adapters
│   │   ├── experiment_executor.py        # Async execution (FPR logic fixed)
│   │   ├── experiment_services.py       # Service locator
│   │   ├── experiment_runner.py         # Web UI + REST API
│   │   ├── llm_client.py                 # Async-safe LLM client (empty choices guarded)
│   │   └── ...
│   ├── classifiers/                      # 4-classifier ensemble
│   ├── config/                           # Configuration management
│   ├── access/                           # Access control
│   ├── explainability/                   # C4 explainability
│   ├── learning/                         # Learning loop
│   ├── plugins/                          # Plugin system
│   ├── quarantine/                       # Quarantine management
│   ├── router/                           # Smart routing
│   ├── scoring/                          # Antifragile scoring
│   └── tests/                            # 240 tests (19 test files)
├── formal/                               # TLA+ specifications
├── models/                               # ONNX model + tokenizer
├── archive/Dockerfile.prepared          # Multi-stage production build (archived)
├── Dockerfile.distroless                # Distroless-ready builder pattern
├── archive/docker-compose.yml.prepared  # Full stack (Ollama + UI + Monitoring) (archived)
├── .dockerignore                        # Security-hardened exclusion list
├── infra/k8s/                           # Kubernetes manifests (hardened)
└── README.md                            # This file

🐳 Distribuzione Docker

Il sistema è completamente predisposto per la containerizzazione con configurazione sensibile all'ambiente.

Opzioni di distribuzione:

root@kitploit:~
# Full stack (C4-META + Ollama + UI)
docker compose --profile experiment up -d

# Build image
docker build -t c4-meta-system -f archive/Dockerfile.prepared .

# Run with local Ollama
OLLAMA_BASE_URL=http://host.docker.internal:11434 docker run -p 8080:8080 c4-meta-system

# Red Team runner
docker build -t c4-redteam -f redteam/Dockerfile.redteam.prepared .
docker run -p 8081:8081 c4-redteam

Endpoint di salute

  • Container core: GET /health sulla porta 8080
  • Runner Red Team: GET /health sulla porta 8081

🚀 Avvio rapido

Installazione

root@kitploit:~
pip install -r requirements.txt
# Optional Docker deps
pip install -r requirements-docker.txt

Esegui il server Core

root@kitploit:~
python -m v4_1.core
# or explicitly
python -m v4_1.core.__main__

Esegui la dashboard Red Team

root@kitploit:~
python -m v4_1.redteam.experiment_runner --web --port 8080

🏗️ Cronologia delle correzioni di bug

Correzioni di bug principali (60 risolti nei cicli di audit)

  1. Self-DoS del Kill-Switch — o2_engine.py non blocca più tutto il traffico quando O2 è disabilitato.
  2. Contesa di lock BFT — il consenso BFT viene eseguito fuori dalla sezione critica, prevenendo il blocco head-of-line.
  3. Perdite dell'event bus — ThreadPoolExecutor ora esegue la pulizia tramite atexit; i callback asincroni usano run_coroutine_threadsafe().
  4. Inversione del campionamento O2 — explainable_o2.py ora campiona correttamente la frazione sample_rate invece di 1 - sample_rate.
  5. Mesh di comunicazione falso — o2_shared.py registra solo le menzioni esplicite @agent invece di una cricca completamente connessa.
  6. Falsi positivi di entanglement — semantic_detector.py normalizza i conteggi dei concetti prima del confronto con la soglia.
  7. Logica del callback di destinazione — l'orchestratore e l'esecutore Redteam ora analizzano correttamente / dalle risposte di difesa invece di assumere che successo = bloccato.

📊 Risultati dei benchmark

Risultati completi dei benchmark su 4 dataset e 2000 varianti avversarie della pipeline di difesa C4.

Vedi c4protocol/BENCHMARK_RESULTS.md per il report completo.

Nota: O₂ distribuito richiede un cluster Redis per la produzione. La modalità a nodo singolo è disponibile per lo sviluppo (vedi guida alla distribuzione).

📊 Stato

Sfida Red Team

Le difese di C4-META sono robuste — ma nessun sistema è perfetto. Se trovi un prompt che aggira il classificatore ensemble, i moduli di difesa AoC o il motore O₂, vogliamo saperlo.

Segnala i bypass:

  • GitLab Issues: https://gitlab.com/cognitive-functors/c4-meta-system/-/issues
  • Email: [email protected]

Cosa ci serve: il prompt che aggira, la risposta attesa e quale livello di difesa ha fallito. Riconosciamo tutti i segnalatori nella nostra hall of fame della sicurezza.

C4-META v1.0.0-alpha — Prototipo di ricerca per la difesa AI multi-livello. Validazione interna completata. Audit esterno in sospeso.

Scarica lo strumento
blocked
quarantined
  • Indurimento degli endpoint di debug — sessioni limitate per IP, timestamp in UTC, pulizia con base temporale coerente.
  • Unificazione dell'hash del token admin — sia access/capabilities.py che security/hardening.py supportano bcrypt e SHA256.
  • Firma del modello fail-closed — ModelIntegrityVerifier solleva RuntimeError se C4_MODEL_SIGNING_KEY non è impostata.
  • Correzione di regressione del Round 5 — eliminato il deadlock in explainable_o2.py (non blocca più il thread dell'event loop).
  • Validazione URL Redis — corretta la regex in distributed_o2.py per imporre davvero URL Redis solo localhost.
  • Consegna dell'executor dell'event bus — cattura il riferimento al loop principale all'init/publish così i callback asincroni vengono consegnati correttamente dal thread pool.
  • Data race O₂ — la lettura di _active_threat in process_message() ora è protetta da lock.
  • Limiti del rilevatore subliminale — le cache di token/contesto/co-occorrenza ora hanno dimensioni massime configurabili per prevenire una crescita illimitata della memoria.
  • Sicurezza dei percorsi del registro prompt — save_to_file / load_from_file ora risolvono rispetto a una directory base sicura invece di un controllo del prefisso non funzionante.
  • Confronto a tempo costante — phase3.py ora esegue sempre l'hash di entrambi gli operandi, eliminando il canale laterale temporale dal ramo di lunghezza.
  • Persistenza atomica — tutte le scritture JSON/JSONL/testo in experiment_reporter, decision_logger, orchestrator, experiment_runner e hardening.py usano file temporaneo + rename atomico.
  • Fissaggio UID Docker — archive/Dockerfile.prepared ora crea esplicitamente utente/gruppo con UID/GID 1000, in linea con runAsUser di K8s.
  • Gestione dei Secret K8s — deployment.yaml fa riferimento al Secret c4-meta-api-keys per l'iniezione delle chiavi API; aggiunto un manifest di esempio in secrets.yaml.
  • Jitter del circuit breaker — il tempo di recupero ora usa un vero jitter ±50% invece di estendersi soltanto.
  • Autenticazione del circuit breaker — disable() e reenable() richiedono l'hash di CIRCUIT_BREAKER_AUTH_TOKEN.
  • Autenticazione debug dell'ensemble — vote_debug() verifica C4_ADMIN_TOKEN_HASH con confronto a tempo costante.
  • Correzioni degli estrattori di feature — SentimentExtractor non deduplica più le parole; ComplexityExtractor limita a [0, 1].
  • Stub dell'avversario adattivo — le strategie di mutazione con offuscamento Unicode, omoglifi e larghezza zero ora hanno implementazioni reali.
  • Pulizia anti-hijack — rimosso _goal_history inutilizzato; OmegaPrioritizer usa deque(maxlen=1000) per l'espulsione O(1).
  • Ordine dei lock del monitor di convergenza — eliminato il locking annidato tra ConvergenceMonitor e PhiAttractorCalculator.
  • Consapevolezza del fuso orario — o2_shared.py usa datetime.now(timezone.utc) invece di datetime naif.
  • Codice morto nello smart router — rimosso il metodo privato _regenerate_session inutilizzato.
  • Stub dell'experiment runner — i runner delle categorie AOC ora si rivolgono a implementazioni di attacco reali invece di {"status": "simulated"}.
  • Azzeramento della minaccia attiva O₂ — _active_threat viene ora azzerata quando l'analisi della finestra è sicura; non è più permanentemente appiccicosa dopo il primo rilevamento.
  • Gestione delle richieste pericolose nella pipeline — vote_result.is_dangerous=True ora restituisce un risultato di blocco invece di cadere su ALLOW.
  • Isolamento delle sessioni anonime — ogni sessione non valida riceve un ID anonimo univoco; niente più inquinamento dello stato tra utenti tramite anon_anonymous condiviso.
  • Singleton del controller di accesso — get_access_controller() ora usa il double-checked locking per prevenire condizioni di gara all'inizializzazione.
  • Singleton del learning loop — get_learning_loop() ora usa il double-checked locking per prevenire condizioni di gara all'inizializzazione.
  • Thread safety della regola delle due persone — pending_operations e approved_operations protetti da threading.Lock.
  • Thread safety dell'esecuzione ritardata — il dict pending protetto da threading.Lock.
  • URL di fallback Ollama — corretto a /v1/chat/completions invece del semplice /chat/completions.
  • Latenza monotonica — tutti i calcoli di latenza usano time.monotonic() invece di time.time() per prevenire latenze negative durante gli aggiustamenti NTP.
  • API deprecata dell'event bus — rimosso il fallback alla deprecata asyncio.get_event_loop().
  • Data race dell'ultimo risultato O₂ — la scrittura di _last_result in _analyze_window() ora è protetta da lock.
  • Pattern personalizzati del filtro di sicurezza — _compile_*_regex() ora usa il parametro patterns passato invece di ignorarlo.
  • Doppia chiamata del filtro di sicurezza — filter_attack_prompt() ora effettua una singola chiamata di filtro invece di contare due volte le statistiche.
  • Lock del singleton del client LLM — _get_lock() usa un threading lock per prevenire la gara nella creazione di asyncio.Lock.
  • Immutabilità dello snapshot cognitivo — snapshot_cognition() memorizza una copia di C4Coordinate invece di un riferimento mutabile.
  • Immutabilità della transizione di stato — transition_to() copia il C4Coordinate in arrivo invece di mantenerne un riferimento.
  • Correzione del path traversal — _save_results() controlla il traversal PRIMA di risolvere e garantisce che il percorso rimanga all'interno della directory base.
  • Correzione della proprietà della sessione — create_session() verifica la proprietà dell'utente prima di restituire un ID di sessione esistente.
  • Eccezioni di retry — il default retryable_exceptions è cambiato da (Exception,) a (ConnectionError, TimeoutError, OSError).
  • Log di audit del validatore di token — _audit_log ora usa deque(maxlen=10000) per prevenire una crescita illimitata.
  • Deadlock del validatore di token — revoke_all_for_subject() usa un ordinamento coerente dei lock (revocati → usati).
  • Token admin monouso — verify_admin_token() passa consume_single_use=False per evitare di consumare token in fase di verifica.
  • Lock del consenso BFT — reach_consensus() ora è protetto da threading.Lock.
  • RNG per fuzzing — generate_random_string() usa secrets.SystemRandom() invece di random.
  • KeyError del decision logger — _describe_z_state() gestisce correttamente T=-1.
  • Query del decision logger — il filtro per intervallo di tempo viene ora applicato sui risultati già filtrati invece di scartare i filtri precedenti.
  • Reset del kill switch O₂ — reset_threat_state() ora azzera davvero manual_quarantine e lo stato di emergenza.
  • Audit del kill switch O₂ — unquarantine_agent() registra l'audit solo quando l'agente era effettivamente in quarantena.
  • Guardia dell'experiment reporter — build_report() protegge treatment_metrics vuoti con lo stesso pattern di control_metrics.
  • Limite di crescita antifragile — antifragile_growth limitato a 1.000.000,0 per prevenire una crescita illimitata dei float.
    • MetricaValore
    Tasso di rilevamento avversario80.3%
    Punteggio di robustezza1.25
    Rilevamento pulito (AoC)70.9%
    Tasso di falsi positivi14.6%
    Tasso di blocco C4 LLM96.7%
    Riduzione ASR GPT-4o-mini10.7% → 0.7% (93.2%)
    Riduzione ASR Mistral 7B22.5% → 0.5% (97.6%)
    MetricaValore
    Versione1.0.0 FINAL
    StatoPrototipo di ricerca (validazione interna completata)
    Test240 test (19 file di test)
    Classificatori4 (ONNX_BERT, RuleBased, Heuristic, LLM_SEMANTIC)
    Livelli di difesa4 (Sanificazione input → Semantico → Comportamentale → Meta-Osservatore)
    Difese AoC16 (11 originali + 5 estese)
    ThoughtVirusdifesa a 2 livelli (regex + traiettoria C4)
    SVETILO7 sigilli integrati
    Correzioni di bug60+ risolti nei cicli di audit
    Build DockerSuperata (multi-stage, pronta per distroless)
    Manifest K8sPronti (induriti con secretKeyRef)
    LicenzaBSL 1.1