<-
Apache > Serveur HTTP > Documentation > Version 2.4 > Modules

Module Apache mod_authnz_fcgi

Langues Disponibles:  en  |  fr 

Description:Permet à une application d'autorisation FastCGI de gérer l'authentification et l'autorisation httpd.
Statut:Extension
Identificateur de Module:authnz_fcgi_module
Fichier Source:mod_authnz_fcgi.c
Compatibilité:Disponible à partir de la version 2.4.10 du serveur HTTP Apache

Sommaire

Ce module permet aux applications d'autorisation FastCGI d'authentifier les utilisateurs et de contrôler leur accès aux ressources. Il supporte les systèmes d'autorisation FastCGI génériques qui participent en une seule phase à l'authentification et à l'autorisation, ainsi que les processus d'authentification et d'autorisation spécifiques à Apache httpd qui interviennent en une ou plusieurs phases.

Les processus d'autorisation FastCGI peuvent authentifier un utilisateur via son identificateur et son mot de passe comme dans le processus d'authentification basique, ou via un mécanisme arbitraire.

Support Apache!

Sujets

Directives

Traitement des bugs

Voir aussi

top

Modes d'invocation

Les modes d'invocation des processus d'autorisation FastCGI que ce module supporte se distinguent par deux caractéristiques : le type et le mécanisme d'authentification.

Le Type est simplement authn pour l'authentification, authz pour l'autorisation et authnz l'authentification et l'autorisation.

Le mécanisme d'authentification fait référence aux mécanismes d'authentification et aux phases de traitement de la configuration de Apache httpd, et peut être AuthBasicProvider, Require, ou check_user_id. Les deux premiers mécanismes correspondent aux directives utilisées pour participer aux phases de traitement appropriées.

Description de chaque mode:

Type authn, mechanism AuthBasicProvider
Dans ce mode, la variable FCGI_ROLE est définie à AUTHORIZER, et la variable FCGI_APACHE_ROLE à AUTHENTICATOR. L'application doit être spécifiée en tant que fournisseur de type authn via la directive AuthnzFcgiDefineProvider, et activée via la directive AuthBasicProvider. Lorsqu'elle est invoquée, l'application est censée authentifier le client à l'aide de l'identifiant et du mot de passe de l'utilisateur. Exemple d'application :
#!/usr/bin/perl
use FCGI;
my $request = FCGI::Request();
while ($request->Accept() >= 0) {
    die if $ENV{'FCGI_APACHE_ROLE'} ne "AUTHENTICATOR";
    die if $ENV{'FCGI_ROLE'}        ne "AUTHORIZER";
    die if !$ENV{'REMOTE_PASSWD'};
    die if !$ENV{'REMOTE_USER'};

    print STDERR "This text is written to the web server error log.\n";

    if ( ($ENV{'REMOTE_USER' } eq "foo" || $ENV{'REMOTE_USER'} eq "foo1") &&
        $ENV{'REMOTE_PASSWD'} eq "bar" ) {
        print "Status: 200\n";
        print "Variable-AUTHN_1: authn_01\n";
        print "Variable-AUTHN_2: authn_02\n";
        print "\n";
    }
    else {
        print "Status: 401\n\n";
    }
}
Exemple de configuration httpd :
AuthnzFcgiDefineProvider authn FooAuthn fcgi://localhost:10102/
<Location "/protected/">
  AuthType Basic
  AuthName "Restricted"
  AuthBasicProvider FooAuthn
  Require ...
</Location>
Type authz, mechanism Require
Dans ce mode, la variable FCGI_ROLE est définie à AUTHORIZER et FCGI_APACHE_ROLE à AUTHORIZER. L'application doit être spécifiée en tant que fournisseur de type authz via la directive AuthnzFcgiDefineProvider. Lorsqu'elle est invoquée, l'application est censée contrôler les accès du client à l'aide de l'identifiant utilisateur et d'autres données contenues dans la requête. Exemple d'application :
#!/usr/bin/perl
use FCGI;
my $request = FCGI::Request();
while ($request->Accept() >= 0) {
    die if $ENV{'FCGI_APACHE_ROLE'} ne "AUTHORIZER";
    die if $ENV{'FCGI_ROLE'}        ne "AUTHORIZER";
    die if $ENV{'REMOTE_PASSWD'};

    print STDERR "This text is written to the web server error log.\n";

    if ($ENV{'REMOTE_USER'} eq "foo1") {
        print "Status: 200\n";
        print "Variable-AUTHZ_1: authz_01\n";
        print "Variable-AUTHZ_2: authz_02\n";
        print "\n";
    }
    else {
        print "Status: 403\n\n";
    }
}
Exemple de configuration httpd :
AuthnzFcgiDefineProvider authz FooAuthz fcgi://localhost:10103/
<Location "/protected/">
  AuthType ...
  AuthName ...
  AuthBasicProvider ...
  Require FooAuthz
</Location>
Type authnz, mechanism AuthBasicProvider + Require
Dans ce mode qui supporte le protocole d'autorisation web server-agnostic FastCGI, la variable FCGI_ROLE est définie à AUTHORIZER et FCGI_APACHE_ROLE n'est pas définie. L'application doit être spécifiée en tant que fournisseur de type authnz via la directive AuthnzFcgiDefineProvider. L'application est censée assurer l'authentification et l'autorisation au cours d'une même invocation à l'aide de l'identifiant et du mot de passe de l'utilisateur et d'autres données contenues dans la requête. L'invocation de l'application intervient au cours de la phase d'authentification de l'API Apache httpd. Si l'application renvoie le code 200, et si le même fournisseur est invoqué au cours de la phase d'autorisation (via une directive Require), mod_authnz_fcgi renverra un code de type success pour la phase d'autorisation sans invoquer l'application. Exemple d'application :
#!/usr/bin/perl
use FCGI;
my $request = FCGI::Request();
while ($request->Accept() >= 0) {
    die if $ENV{'FCGI_APACHE_ROLE'};
    die if $ENV{'FCGI_ROLE'} ne "AUTHORIZER";
    die if !$ENV{'REMOTE_PASSWD'};
    die if !$ENV{'REMOTE_USER'};

    print STDERR "This text is written to the web server error log.\n";

    if ( ($ENV{'REMOTE_USER' } eq "foo" || $ENV{'REMOTE_USER'} eq "foo1") &&
        $ENV{'REMOTE_PASSWD'} eq "bar" &&
        $ENV{'REQUEST_URI'} =~ m%/bar/.*%) {
        print "Status: 200\n";
        print "Variable-AUTHNZ_1: authnz_01\n";
        print "Variable-AUTHNZ_2: authnz_02\n";
        print "\n";
    }
    else {
        print "Status: 401\n\n";
    }
}
Exemple de configuration httpd :
AuthnzFcgiDefineProvider authnz FooAuthnz fcgi://localhost:10103/
<Location "/protected/">
  AuthType Basic
  AuthName "Restricted"
  AuthBasicProvider FooAuthnz
  Require FooAuthnz
</Location>
Type authn, mechanism check_user_id
Dans ce mode, la variable FCGI_ROLE est définie à AUTHORIZER et FCGI_APACHE_ROLE à AUTHENTICATOR. L'application doit être spécifiée en tant que fournisseur de type authn via une directive AuthnzFcgiDefineProvider. La directive AuthnzFcgiCheckAuthnProvider permet de l'invoquer. Exemple d'application :
#!/usr/bin/perl
use FCGI;
my $request = FCGI::Request();
while ($request->Accept() >= 0) {
    die if $ENV{'FCGI_APACHE_ROLE'} ne "AUTHENTICATOR";
    die if $ENV{'FCGI_ROLE'} ne "AUTHORIZER";

    # This authorizer assumes that the RequireBasicAuth option of 
    # AuthnzFcgiCheckAuthnProvider is On:
    die if !$ENV{'REMOTE_PASSWD'};
    die if !$ENV{'REMOTE_USER'};

    print STDERR "This text is written to the web server error log.\n";

    if ( ($ENV{'REMOTE_USER' } eq "foo" || $ENV{'REMOTE_USER'} eq "foo1") &&
        $ENV{'REMOTE_PASSWD'} eq "bar" ) {
        print "Status: 200\n";
        print "Variable-AUTHNZ_1: authnz_01\n";
        print "Variable-AUTHNZ_2: authnz_02\n";
        print "\n";
    }
    else {
        print "Status: 401\n\n";
        # If a response body is written here, it will be returned to
        # the client.
    }
}
Exemple de configuration httpd :
AuthnzFcgiDefineProvider authn FooAuthn fcgi://localhost:10103/
<Location "/protected/">
  AuthType ...
  AuthName ...
  AuthnzFcgiCheckAuthnProvider FooAuthn \
                               Authoritative On \
                               RequireBasicAuth Off \
                               UserExpr "%{reqenv:REMOTE_USER}"
  Require ...
</Location>
top

Exemples supplémentaires

  1. Si votre application supporte séparément les rôles d'authentification et d'autorisation (AUTHENTICATOR et AUTHORIZER), vous pouvez définir des fournisseurs séparés comme suit, même s'ils correspondent à la même application :
    AuthnzFcgiDefineProvider authn  FooAuthn  fcgi://localhost:10102/
    AuthnzFcgiDefineProvider authz  FooAuthz  fcgi://localhost:10102/
    Spécifie le fournisseur authn via la directive AuthBasicProvider et le fournisseur authz via la directive Require:
    AuthType Basic
    AuthName "Restricted"
    AuthBasicProvider FooAuthn
    Require FooAuthz
  2. Si votre application supporte le rôle générique AUTHORIZER (authentification et autorisation en une seule invocation), vous pouvez définir un fournisseur unique comme suit :
    AuthnzFcgiDefineProvider authnz FooAuthnz fcgi://localhost:10103/
    Spécifie le fournisseur authnz via les directives AuthBasicProvider et Require :
    AuthType Basic
    AuthName "Restricted"
    AuthBasicProvider FooAuthnz
    Require FooAuthnz
top

Limitations

Les fonctionnalités suivantes ne sont pas encore implémentées :

Vérificateur d'accès d'Apache httpd
La phase access check de l'API Apache httpd est distincte des phases d'authentification et d'autorisation. Certaines autres implémentations de FastCGI supportent cette phase et lorsque c'est le cas, la variable FCGI_APACHE_ROLE est définie à ACCESS_CHECKER.
Redirections (pipes) ou sockets locaux (Unix)
Seuls les sockets TCP sont actuellement supportés.
Support de mod_authn_socache
Le support de l'interaction avec mod_authn_socache pour les applications qui interviennent dans le processus d'authentification d'Apache httpd serait souhaitable.
Support de l'authentification de type digest à l'aide de AuthDigestProvider
Cette limitation ne sera probablement jamais franchie car il n'existe aucun flux de données d'autorisation capable de lire dans un condensé de type hash.
Gestion des processus applicatifs
Cette fonctionnalité restera probablement hors de portée de ce module. Il faudra donc gérer les processus applicatifs d'une autre manière ; par exemple, fcgistarter permet de les démarrer.
AP_AUTH_INTERNAL_PER_URI
Tous les fournisseurs sont actuellement enregistrés en tant que AP_AUTH_INTERNAL_PER_CONF, ce qui signifie que les vérifications ne sont pas effectuées pour les sous-requêtes internes avec la même configuration de contrôle d'accès que la requête initiale.
Conversion du jeu de caractères des données de protocole
Si mod_authnz_fcgi s'exécute dans un environnement de compilation EBCDIC, toutes les données de protocole FastCGI sont écrites en EBCDIC et doivent être disponibles en EBCDIC.
Plusieurs requêtes pour une connexion
Actuellement, la connexion au fournisseur d'autorisation FastCGI est fermée après chaque phase de traitement. Par exemple, si le fournisseur d'autorisation gère séparément les phases authn et authz, deux connexions seront nécessaires.
Redirection de certains URIs
Les URIs en provenance des clients ne peuvent pas être redirigés selon une table de redirection, comme avec la directive ProxyPass utilisée avec les répondeurs FastCGI.
top

Journalisation

  1. Les erreurs de traitement sont journalisées à un niveau error ou supérieur.
  2. Les messages envoyés par l'application sont journalisés au niveau warn.
  3. Les messages de deboguage à caractère général sont journalisés au niveau debug.
  4. Les variables d'environnement transmises à l'application sont journalisées au niveau trace2. La valeur de la variable REMOTE_PASSWD sera occultée, mais toute autre donnée sensible sera visible dans le journal.
  5. Toutes les entrées/sorties entre le module et l'application FastCGI, y compris les variables d'environnement, seront journalisées au format imprimable et hexadécimal au niveau trace5. Toutes les données sensibles seront visibles dans le journal.

La directive LogLevel permet de configurer un niveau de journalisation spécifique à mod_authnz_fcgi. Par exemple :

LogLevel info authnz_fcgi:trace8
top

Directive AuthnzFcgiCheckAuthnProvider

Description:Permet à une application FastCGI de gérer l'accroche d'authentification check_authn.
Syntaxe:AuthnzFcgiCheckAuthnProvider provider-name|None option ...
Défaut:none
Contexte:répertoire
Statut:Extension
Module:mod_authnz_fcgi

Cette directive permet de confier à une application FastCGI la gestion d'une phase spécifique du processus d'authentification ou d'autorisation.

Certaines fonctionnalités des fournisseurs d'autorisation FastCGI nécessitent cette directive en lieu et place de AuthBasicProvider pour pouvoir être activées :

provider-name
C'est le nom du fournisseur défini au préalable via la directive AuthnzFcgiDefineProvider.
None
Spécifiez None pour désactiver un fournisseur activé avec cette même directive dans une autre portée, par exemple dans un répertoire parent.
option
Les options suivantes sont supportées :
Authoritative On|Off (par défaut On)
Cette option permet de définir si l'appel à d'autres modules est autorisé lorsqu'un fournisseur d'autorisation FastCGI a été configuré et si la requête échoue.
DefaultUser id utilisateur
Lorsque le fournisseur d'autorisation donne son accord, et si UserExpr est défini et correspond à une chaîne vide, (par exemple, si le fournisseur d'autorisation ne renvoie aucune variable), c'est cette valeur qui sera utilisée comme id utilisateur par défaut. Cela se produit souvent lorsqu'on se trouve dans un contexte d'invité, ou d'utilisateur non authentifié ; les utilisateurs et invités se voient alors attribué un id utilisateur spécifique qui permettra de se connecter et d'accéder à certaines ressources.
RequireBasicAuth On|Off (par défaut Off)
Cette option permet de définir si l'authentification basique est requise avant de transmettre la requête au fournisseur d'autorisation. Dans l'affirmative, le fournisseur d'autorisation ne sera invoqué qu'en présence d'un id utilisateur et d'un mot de passe ; si ces deux éléments ne sont pas présents, un code d'erreur 401 sera renvoyé
UserExpr expr (pas de valeur par défaut)
Lorsque le client ne fournit pas l'authentification basique et si le fournisseur d'autorisation détermine l'id utilisateur, cette expression, évaluée après l'appel au fournisseur d'autorisation, permet de déterminer l'id utilisateur. Cette expression se conforme à la syntaxe ap_expr et doit correspondre à une chaîne de caractères. Une utilisation courante consiste à référencer la définition d'une Variable-XXX renvoyée par le fournisseur d'autorisation via une option du style UserExpr "%{reqenv:XXX}". Si cette option est spécifiée, et si l'id utilisateur ne peut pas être définie via l'expression après une authentification réussie, la requête sera rejetée avec un code d'erreur 500.
top

Directive AuthnzFcgiDefineProvider

Description:Définit une application FastCGI en tant que fournisseur d'authentification et/ou autorisation
Syntaxe:AuthnzFcgiDefineProvider type provider-name backend-address
Défaut:none
Contexte:configuration globale
Statut:Extension
Module:mod_authnz_fcgi

Cette directive permet de définir une application FastCGI en tant que fournisseur pour une phase particulière d'authentification ou d'autorisation.

type
Les valeurs de ce paramètre sont authn pour l'authentification, authz pour l'autorisation, ou authnz pour un fournisseur d'autorisation générique FastCGI qui effectue les deux vérifications.
provider-name
Ce paramètre permet d'associer un nom au fournisseur ; ce nom pourra être utilisé dans des directives comme AuthBasicProvider et Require.
backend-address
Ce paramètre permet de spécifier l'adresse de l'application sous la forme fcgi://hostname:port/. Le ou les processus de l'application doivent être gérés indépendamment comme avec fcgistarter.

Langues Disponibles:  en  |  fr 

top

Commentaires

Notice:
This is not a Q&A section. Comments placed here should be pointed towards suggestions on improving the documentation or server, and may be removed again by our moderators if they are either implemented or considered invalid/off-topic. Questions on how to manage the Apache HTTP Server should be directed at either our IRC channel, #httpd, on Freenode, or sent to our mailing lists.
Comments are disabled for this page at the moment.