Implementazione in PHP di un motore PBAC con regole dinamiche e sicure usando symfony/expression-language per un controllo accessi flessibile e configurabile.
<?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;
}
?>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).