Implementazione di un motore di policy-based access control (PBAC) in PHP con regole dinamiche

Implementazione in PHP di un motore PBAC con regole dinamiche e sicure usando symfony/expression-language per un controllo accessi flessibile e configurabile.

Breve Introduzione

Implementazione di un motore di policy-based access control (PBAC) in PHP con regole dinamiche (php)
DESCRIZIONE:
Questo esempio mostra come implementare un motore di controllo degli accessi basato su policy (PBAC) in PHP, capace di valutare regole dinamiche definite come espressioni logiche. Il sistema consente di definire policy articolate, con condizioni su attributi dell'utente, risorsa e ambiente, e di valutarle in modo sicuro e flessibile.

NOTE AGGIUNTIVE:
L'uso di symfony/expression-language permette di valutare espressioni condizionali in modo sicuro evitando l'uso di eval(). Le policy sono altamente configurabili e possono essere caricate da database o file esterni. Questo esempio è pronto per essere esteso in sistemi reali di controllo accessi, integrandosi con sistemi di autenticazione e gestione utenti.

SPIEGAZIONI:
- La classe Policy rappresenta una singola regola di accesso, con attributi come azione (read, write, delete), effetto (allow, deny) e una condizione espressa in linguaggio espressione.
- PolicyEngine carica un array di policy e valuta ciascuna in ordine, fermandosi alla prima che corrisponde e restituisce l'effetto associato.
- Le condizioni sono espresse in un linguaggio simile a PHP ma sicuro, che può accedere agli attributi passati (es. user.role, resource.type).
- L'esempio mostra come definire policy dinamiche e come eseguire una valutazione di accesso con attributi di esempio.
- Il logging interno aiuta a capire quale policy ha deciso l'accesso e perché.

Codice Esempio: php

<?php

require __DIR__ . '/vendor/autoload.php';

use Symfony\Component\ExpressionLanguage\ExpressionLanguage;

/**
 * Classe che rappresenta una singola policy di accesso.
 */
class Policy
{
    public string $id;            // Identificativo univoco della policy
    public string $action;        // Azione a cui si applica (es. 'read', 'write')
    public string $effect;        // 'allow' o 'deny'
    public string $condition;     // Condizione espressa come espressione logica

    /**
     * Costruttore
     * @param string $id
     * @param string $action
     * @param string $effect
     * @param string $condition
     */
    public function __construct(string $id, string $action, string $effect, string $condition)
    {
        $this->id = $id;
        $this->action = $action;
        $this->effect = strtolower($effect) === 'allow' ? 'allow' : 'deny';
        $this->condition = $condition;
    }
}

/**
 * Motore di valutazione delle policy PBAC.
 */
class PolicyEngine
{
    /** @var Policy[] */
    private array $policies = [];
    private ExpressionLanguage $expressionLanguage;
    private array $log = [];

    public function __construct()
    {
        $this->expressionLanguage = new ExpressionLanguage();
    }

    /**
     * Aggiunge una policy al motore
     * @param Policy $policy
     * @return void
     */
    public function addPolicy(Policy $policy): void
    {
        $this->policies[] = $policy;
    }

    /**
     * Valuta se l'accesso è consentito
     * @param string $action Azione richiesta
     * @param array $context Attributi disponibili per la valutazione (user, resource, environment)
     * @return bool true se consentito, false se negato
     */
    public function evaluate(string $action, array $context): bool
    {
        $this->log = [];

        foreach ($this->policies as $policy) {
            // Controlla se la policy riguarda l'azione richiesta
            if ($policy->action !== $action) {
                continue;
            }

            // Valuta la condizione della policy
            try {
                $result = $this->expressionLanguage->evaluate($policy->condition, $context);
            } catch (Exception $e) {
                // In caso di errore nella valutazione, consideriamo la policy non applicabile
                $this->log[] = "Policy {$policy->id} - errore valutazione condizione: " . $e->getMessage();
                continue;
            }

            if ($result) {
                // La policy si applica, ritorniamo l'effetto
                $this->log[] = "Policy {$policy->id} applicata con effetto: {$policy->effect}";
                return $policy->effect === 'allow';
            } else {
                $this->log[] = "Policy {$policy->id} non applicata (condizione falsa)";
            }
        }

        // Se nessuna policy si applica, default deny
        $this->log[] = "Nessuna policy applicabile trovata. Accesso negato di default.";
        return false;
    }

    /**
     * Restituisce il log dell'ultima valutazione
     * @return array
     */
    public function getLog(): array
    {
        return $this->log;
    }
}

// Esempio di configurazione policy
$policies = [
    new Policy(
        'policy1',
        'read',
        'allow',
        'user.role == "admin" or (user.role == "user" and resource.ownerId == user.id)'
    ),
    new Policy(
        'policy2',
        'write',
        'allow',
        'user.role == "admin"'
    ),
    new Policy(
        'policy3',
        'delete',
        'deny',
        'true' // Negare sempre la cancellazione
    ),
    new Policy(
        'policy4',
        'read',
        'deny',
        'environment.time < 8 or environment.time > 18' // Negare lettura fuori orario 8-18
    ),
];

// Creazione motore e caricamento policy
$engine = new PolicyEngine();
foreach ($policies as $policy) {
    $engine->addPolicy($policy);
}

// Contesto di esempio
$context = [
    'user' => [
        'id' => 42,
        'role' => 'user'
    ],
    'resource' => [
        'ownerId' => 42,
        'type' => 'document'
    ],
    'environment' => [
        'time' => (int)date('G') // ora in formato 24h senza zeri iniziali
    ]
];

// Valutazione accesso
$action = 'read';
$allowed = $engine->evaluate($action, $context);

// Output risultato
echo "Accesso all'azione '{$action}': " . ($allowed ? "CONSENTITO" : "NEGATO") . PHP_EOL;

// Output log dettagliato
foreach ($engine->getLog() as $logEntry) {
    echo "- {$logEntry}" . PHP_EOL;
}

?>
×
×
×
Vuoi rigenerare la risposta?
×
Esporta chat
Scegli il formato di esportazione
Generazione PDF in corso…
Allegati
×
Stai per chiudere la chat e passare al generatore immagini, se non sei loggato perderai la nostra chat, confermi?
Stai visualizzando una chat condivisa in modalità temporanea. Non verrà salvata.
×
Prompt salvati
×
Nota privata
×
Etichetta
×
Cerca in tutte le chat
×
I tuoi insight
Analisi in corso…
×
Preferenze IA
Nome assistente 30
Lunghezza risposte
Modello IA
Risposte strutturate
Includi esempi
Usa emoji
Guidami, non risolvere Indizi e domande invece della soluzione pronta
Configura di più →
×
Condividi questa chat
Chi apre questo link potrà visualizzare la chat oppure aggiungerla al proprio profilo come chat personale.
Attenzione: verranno condivisi anche gli allegati della chat. Chi la aggiungerà riceverà una copia dei file nella propria cartella.
Chat condivisa
Qualcuno ha condiviso una chat con te. Vuoi solo visualizzarla o aggiungerla alle tue chat?
Attenzione: verranno condivisi anche gli allegati della chat. Chi la aggiungerà riceverà una copia dei file nella propria cartella.
×

Messaggi salvati

Caricamento in corso...

×

Cronologia Chat

programmi-esempio · CRONOLOGIA CHAT

Caricamento in corso...

Preferenze IA

×
  • BaseRisposte rapide ed essenziali per studio
  • MedioQualità superiore per studio e programmazione
  • AvanzatoRagionamento complesso e analisi dettagliate
Spiega Passaggi

Cosa serve?

PHP 8.0+ come linguaggio di programmazione per sfruttare tipizzazione e funzionalità moderne.

Composer per la gestione delle dipendenze.

Dipendenza: symfony/expression-language per la valutazione sicura di espressioni logiche dinamiche.

Classe PolicyEngine: motore centrale che carica, gestisce e valuta le policy.

Classe Policy: rappresenta una singola policy con attributi, azione, effetto e condizione espressa come stringa.

Array di attributi contestuali (utente, risorsa, ambiente) passati al motore per la valutazione.

Configurazione di policy in formato array PHP o JSON, facilmente estendibile e modificabile a runtime.

Sistema di logging semplice per tracciare decisioni e motivazioni.

Nessun hardware specifico richiesto (esempio software puro).

Argomenti Simili

Mini pagina di login fittizia in PHP che controlla username e password statici
Pagina PHP semplice con form di login che verifica username e password statici senza database, ideale per comprendere la gestione base di login in PHP.
Mini sistema di prenotazione appuntamenti giornalieri con controllo di sovrapposizioni
Sistema PHP semplice per gestire prenotazioni giornaliere con controllo automatico di sovrapposizioni temporali e interfaccia minimale funzionale.
Sistema di prenotazione sale riunioni in PHP con controllo di conflitti e salvataggio su file
Sistema di prenotazione sale riunioni in PHP con controllo conflitti e salvataggio su file JSON per gestire facilmente le prenotazioni senza database.
Sistema di sondaggi in PHP con creazione, voto e visualizzazione risultati (file-based)
Sistema di sondaggi in PHP con creazione, voto e visualizzazione risultati tramite file JSON e sessione per evitare voti multipli, semplice e modulare.
Gestione di un piccolo inventario IT in PHP (PC, stampanti, accessori) con stato e assegnazione
Applicazione PHP per gestire un inventario IT di PC, stampanti e accessori con stato, assegnazione utenti e salvataggio dati in file JSON semplice e funzionale.
Pannello di amministrazione in PHP per gestione utenti e ruoli con controllo ACL
Pannello di amministrazione PHP per gestire utenti, ruoli e permessi con controllo ACL, autenticazione sicura e protezione tramite token CSRF.
Implementazione di un sistema di notifiche in-app in PHP con coda di messaggi su database
Guida completa per implementare un sistema di notifiche in-app in PHP con database MySQL, gestione sicura tramite PDO e API REST scalabili.
Motore di ricerca interno in PHP con indicizzazione full-text e suggerimenti di ricerca
Motore di ricerca interno in PHP con indicizzazione full-text su MySQL, suggerimenti ortografici e completamento automatico per ricerche efficienti.