Security (Sécurité)¶

Gestion des callbacks trou noir¶

Si une action est restreinte par le component Security, elle devient un trou noir, comme une requête invalide qui aboutira à une erreur 404 par défaut. Vous pouvez configurer ce comportement, en définissant la propriété $this->Security->blackHoleCallback par une fonction de rappel (callback) dans le controller.

SecurityComponent::blackHole(object $controller, string $error)¶

Met en « trou noir » (black-hole) une requête invalide, avec une erreur 404 ou un callback personnalisé. Sans callback, la requête sera abandonnée. Si un callback de controller est défini pour SecurityComponent::blackHoleCallback, il sera appelé et passera toute information sur l’erreur.

property SecurityComponent::$blackHoleCallback¶

La fonction de rappel (callback) du controller qui va gérer et requéter ce qui doit être mis dans un trou noir (blackholed). La fonction de rappel de mise en trou noir (blackhole callback) peut être n’importe quelle méthode publique d’un controller. La fonction de rappel doit s’attendre a un paramètre indiquant le type d’erreur:

public function beforeFilter() {
    $this->Security->blackHoleCallback = 'blackhole';
}

public function blackhole($type) {
    // gestions des erreurs.
}

Le paramètre $type peut avoir les valeurs suivantes:

• “auth” Indique une erreur de validation de formulaire, ou une incohérence controller/action.

• “csrf” Indique une erreur CSRF.

• “get” Indique un problème sur la méthode de restriction HTTP.

• “post” Indique un problème sur la méthode de restriction HTTP.

• “put” Indique un problème sur la méthode de restriction HTTP.

• “delete” Indique un problème sur la méthode de restriction HTTP.

• “secure” Indique un problème sur la méthode de restriction SSL.

Restreindre les méthodes HTTP¶

SecurityComponent::requirePost()¶

Définit les actions qui nécessitent une requête POST. Prend un nombre indéfini de paramètres. Peut être appelé sans argument, pour forcer toutes les actions à requérir un POST.

SecurityComponent::requireGet()¶

Définit les actions qui nécessitent une requête GET. Prend un nombre indéfini de paramètres. Peut-être appelé sans argument, pour forcer toutes les actions à requérir un GET.

SecurityComponent::requirePut()¶

Définit les actions qui nécessitent une requête PUT. Prend un nombre indéfini de paramètres. Peut-être appelé sans argument, pour forcer toutes les actions à requérir un PUT.

SecurityComponent::requireDelete()¶

Définit les actions qui nécessitent une requête DELETE. Prend un nombre indéfini de paramètres. Peut-être appelé sans argument, pour forcer toutes les actions à requérir un DELETE.

Restreindre les actions à SSL¶

SecurityComponent::requireSecure()¶

Définit les actions qui nécessitent une requête SSL-securisée. Prend un nombre indéfini de paramètres. Peut-être appelé sans argument, pour forcer toutes les actions à requérir une SSL-securisée.

SecurityComponent::requireAuth()¶

Définit les actions qui nécessitent un jeton valide généré par le component Security. Prend un nombre indéfini de paramètres. Peut-être appelé sans argument, pour forcer toutes les actions à requérir une authentification valide.

Restreindre les demandes croisées de controller¶

property SecurityComponent::$allowedControllers¶

Une liste de controllers qui peuvent envoyer des requêtes vers ce controller. Ceci peut être utilisé pour contrôler les demandes croisées de controller.

property SecurityComponent::$allowedActions¶

Une liste des actions qui peuvent envoyer des requêtes vers les actions de ce controller. Ceci peut être utilisé pour contrôler les demandes croisées de controller.

Prévention de la falsification de formulaire¶

Par défaut le component Security SecurityComponent prévient les utilisateurs de la falsification de formulaire dans certains cas. SecurityComponent va éviter les choses suivantes:

avec le Helper Form et en traquant quels champs sont dans un formulaire. il assure le suivi des éléments d’entrée cachés. Toutes ces données sont combinées et hachées. Quand un formulaire est soumis, le component de sécurité utilisera les données POSTé pour construire la même structure et comparer le hachage.

• Les champs inconnus ne peuvent être ajoutés au formulaire.

• Les champs ne peuvent être retirés du formulaire.

• Les valeurs dans les inputs cachés ne peuvent être modifiées.

La prévention de ces types de falsification est faite de concert avec FormHelper, en recherchant les champs qui sont dans un formulaire. Les valeurs pour les champs cachés sont aussi utilisées. Toutes ces données sont combinées et il en ressort un hash. Quand un formulaire est soumis, SecurityComponent va utiliser les données POSTées pour construire la même structure et comparer le hash.

property SecurityComponent::$unlockedFields¶

Définit une liste de champs de formulaire à exclure de la validation POST. Les champs peuvent être déverrouillés dans le component ou avec FormHelper::unlockField(). Les champs qui ont été déverrouillés ne sont pas requis faisant parti du POST et les champs cachés déverrouillés n’ont pas leur valeur vérifiée.

property SecurityComponent::$validatePost¶

Mis à false pour complètement éviter la validation des requêtes POST, essentiellement éteindre la validation de formulaire.

configuration CSRF (Cross site request forgery)¶

property SecurityComponent::$csrfCheck¶

Si vous utilisez les formulaires de protection CSRF. Définit à false pour désactiver la protection CSRF sur les formulaires.

property SecurityComponent::$csrfExpires¶

La durée avant expiration d’un jeton CSRF. Chaque requête formulaire/page va générer un nouveau jeton qui ne pourra être soumis qu’une seule fois avant son expiration. Peut être une valeur compatible avec strtotime(). Par défaut 30 minutes.

property SecurityComponent::$csrfUseOnce¶

Contrôle si oui ou non les jetons CSRF sont utilisés et brûlés. Définit à false pour ne pas générer de nouveau jetons sur chaque requête. Un jeton pourra être réutilisé jusqu’à ce qu’il expire. Ceci réduit les chances des utilisateurs d’avoir des requêtes invalides en raison de la consommation de jeton. Cela à pour effet de rendre CSRF moins sécurisé, et les jetons réutilisables.

Utilisation¶

Le component Security est généralement utilisé dans la méthode beforeFilter() de votre controller. Vous pouvez spécifier les restrictions de sécurité que vous voulez et le component Security les forcera au démarrage:

class WidgetController extends AppController {

    public $components = array('Security');

    public function beforeFilter() {
        $this->Security->requirePost('delete');
    }
}

Dans cette exemple, l’action delete peut être effectuée avec succès si celui ci reçoit une requête POST:

class WidgetController extends AppController {

    public $components = array('Security');

    public function beforeFilter() {
        if (isset($this->request->params['admin'])) {
            $this->Security->requireSecure();
        }
    }
}

Cette exemple forcera toutes les actions qui proviennent de la « route » Admin à être effectuées via des requêtes sécurisées SSL:

class WidgetController extends AppController {

    public $components = array('Security');

    public function beforeFilter() {
        if (isset($this->params['admin'])) {
            $this->Security->blackHoleCallback = 'forceSSL';
            $this->Security->requireSecure();
        }
    }

    public function forceSSL() {
        $this->redirect('https://' . env('SERVER_NAME') . $this->here);
    }
}

Cet exemple forcera toutes les actions qui proviennent de la « route » admin à requérir des requêtes sécurisés SSL. Quand la requête est placée dans un trou noir, elle appellera le callback forceSSL() qui redirigera les requêtes non sécurisées vers les requêtes sécurisées automatiquement.

protection CSRF¶

CSRF ou Cross Site Request Forgery est une vulnérabilité courante pour les applications Web. Cela permet à un attaquant de capturer et de rejouer une requête, et parfois de soumettre des demandes de données en utilisant les balises images ou des ressources sur d’autres domaines.

Les doubles soumissions et les attaques replay sont gérées par les fonctionnalités CSRF du component Security. Elles fonctionnent en ajoutant un jeton spécial pour chaque requête de formulaire. Ce jeton utilisé qu’une fois ne peut pas être utilisé à nouveau. Si une tentative est faîte pour ré-utiliser un jeton expiré la requête sera mise dans le trou noir (blackholed)

public $components = array(
    'Security' => array(
        'csrfExpires' => '+1 hour'
    )
);

public function beforeFilter() {
    $this->Security->csrfExpires = '+1 hour';
    // ...
}

public $components = array(
    'Security' => array(
        'csrfUseOnce' => false
    )
);

Désactiver CSRF et la Validation des Données Post pour des Actions Spécifiques¶

Il peut arriver que vous souhaitiez désactiver toutes les vérifications de sécurité pour une action (ex. ajax request). Vous pouvez « délocker » ces actions en les listant dans $this->Security->unlockedActions dans votre beforeFilter. La propriété unlockedActions ne va pas avoir d’effets sur les autres fonctionnalités de SecurityComponent.