summaryrefslogtreecommitdiffstats
path: root/docs/manual/mod/mod_authnz_fcgi.xml.fr
blob: ed264c0c84861d6db327cb82adfa5902b8eb8a23 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE modulesynopsis SYSTEM "../style/modulesynopsis.dtd">
<?xml-stylesheet type="text/xsl" href="../style/manual.fr.xsl"?>
<!-- English Revision : 1793934 -->
<!-- French translation : Lucien GENTIS -->
<!-- Reviewed by : Vincent Deffontaines -->

<!--
 Licensed to the Apache Software Foundation (ASF) under one or more
 contributor license agreements.  See the NOTICE file distributed with
 this work for additional information regarding copyright ownership.
 The ASF licenses this file to You under the Apache License, Version 2.0
 (the "License"); you may not use this file except in compliance with
 the License.  You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
-->

<modulesynopsis metafile="mod_authnz_fcgi.xml.meta">

<name>mod_authnz_fcgi</name>
<description>Permet &agrave; une application d'autorisation FastCGI de g&eacute;rer
l'authentification et l'autorisation httpd.</description>
<status>Extension</status>
<sourcefile>mod_authnz_fcgi.c</sourcefile>
<identifier>authnz_fcgi_module</identifier>
<compatibility>Disponible &agrave; partir de la version 2.4.10 du serveur HTTP
Apache</compatibility>

<summary>
    <p>Ce module permet aux applications d'autorisation FastCGI
    d'authentifier les utilisateurs et de contr&ocirc;ler leur acc&egrave;s aux
    ressources. Il supporte les syst&egrave;mes d'autorisation FastCGI
    g&eacute;n&eacute;riques qui participent en une seule phase &agrave; l'authentification
    et &agrave; l'autorisation, ainsi que les processus d'authentification et
    d'autorisation sp&eacute;cifiques &agrave; Apache httpd qui interviennent en une
    ou plusieurs phases.</p>

    <p>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&eacute;canisme
    arbitraire.</p>
</summary>

<seealso><a href="../howto/auth.html">Authentification, autorisation et
contr&ocirc;le d'acc&egrave;s</a></seealso>
<seealso><module>mod_auth_basic</module></seealso>
<seealso><program>fcgistarter</program></seealso>
<seealso><module>mod_proxy_fcgi</module></seealso>

<section id="invocations"><title>Modes d'invocation</title>

    <p>Les modes d'invocation des processus d'autorisation FastCGI que
    ce module supporte se distinguent par deux caract&eacute;ristiques : le
    <em>type</em> et le <em>m&eacute;canisme</em> d'authentification.</p>

    <p>Le <em>Type</em> est simplement <code>authn</code> pour
    l'authentification, <code>authz</code> pour l'autorisation et
    <code>authnz</code> l'authentification et l'autorisation.</p>

    <p>Le <em>m&eacute;canisme</em> d'authentification fait r&eacute;f&eacute;rence aux
    m&eacute;canismes d'authentification et aux phases de traitement de la
    configuration de Apache httpd, et peut &ecirc;tre
    <code>AuthBasicProvider</code>, <code>Require</code>, ou
    <code>check_user_id</code>. Les deux premiers m&eacute;canismes
    correspondent aux directives utilis&eacute;es pour participer aux phases de
    traitement appropri&eacute;es.</p>

    <p>Description de chaque mode:</p>

    <dl>
      <dt><em>Type</em> <code>authn</code>, <em>mechanism</em>
      <code>AuthBasicProvider</code></dt>

      <dd>Dans ce mode, la variable <code>FCGI_ROLE</code> est d&eacute;finie &agrave;
      <code>AUTHORIZER</code>, et la variable
      <code>FCGI_APACHE_ROLE</code> &agrave; <code>AUTHENTICATOR</code>.
      L'application doit &ecirc;tre sp&eacute;cifi&eacute;e en tant que fournisseur de type
      <em>authn</em> via la directive <directive
      module="mod_authnz_fcgi">AuthnzFcgiDefineProvider</directive>, et
      activ&eacute;e via la directive <directive
      module="mod_auth_basic">AuthBasicProvider</directive>. Lorsqu'elle
      est invoqu&eacute;e, l'application est cens&eacute;e authentifier le client &agrave;
      l'aide de l'identifiant et du mot de passe de l'utilisateur.
      Exemple d'application :

<highlight language="perl">
#!/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") &amp;&amp;
        $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";
    }
}
</highlight>

      Exemple de configuration httpd :
<highlight language="config">
AuthnzFcgiDefineProvider authn FooAuthn fcgi://localhost:10102/
&lt;Location "/protected/"&gt;
  AuthType Basic
  AuthName "Restricted"
  AuthBasicProvider FooAuthn
  Require ...
&lt;/Location&gt;
</highlight>
      </dd>

      <dt><em>Type</em> <code>authz</code>, <em>mechanism</em>
      <code>Require</code></dt>
      <dd>Dans ce mode, la variable <code>FCGI_ROLE</code> est d&eacute;finie &agrave;
      <code>AUTHORIZER</code> et <code>FCGI_APACHE_ROLE</code> &agrave;
      <code>AUTHORIZER</code>. L'application doit &ecirc;tre sp&eacute;cifi&eacute;e en tant
      que fournisseur de type <em>authz</em> via la directive <directive
      module="mod_authnz_fcgi">AuthnzFcgiDefineProvider</directive>.
      Lorsqu'elle est invoqu&eacute;e, l'application est cens&eacute;e contr&ocirc;ler les
      acc&egrave;s du client &agrave; l'aide de l'identifiant utilisateur et d'autres
      donn&eacute;es contenues dans la requ&ecirc;te. Exemple d'application :
<highlight language="perl">
#!/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";
    }
}
</highlight>

      Exemple de configuration httpd :
<highlight language="config">
AuthnzFcgiDefineProvider authz FooAuthz fcgi://localhost:10103/
&lt;Location "/protected/"&gt;
  AuthType ...
  AuthName ...
  AuthBasicProvider ...
  Require FooAuthz
&lt;/Location&gt;
</highlight>
      </dd>

      <dt><em>Type</em> <code>authnz</code>, <em>mechanism</em>
      <code>AuthBasicProvider</code> <em>+</em> <code>Require</code></dt>

      <dd>Dans ce mode qui supporte le protocole d'autorisation web
      server-agnostic FastCGI, la variable <code>FCGI_ROLE</code> est
      d&eacute;finie &agrave; <code>AUTHORIZER</code> et <code>FCGI_APACHE_ROLE</code>
      n'est pas d&eacute;finie. L'application doit &ecirc;tre sp&eacute;cifi&eacute;e en tant que
      fournisseur de type <em>authnz</em> via la directive <directive
      module="mod_authnz_fcgi">AuthnzFcgiDefineProvider</directive>.
      L'application est cens&eacute;e assurer l'authentification et
      l'autorisation au cours d'une m&ecirc;me invocation &agrave; l'aide de
      l'identifiant et du mot de passe de l'utilisateur et d'autres
      donn&eacute;es contenues dans la requ&ecirc;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&ecirc;me
      fournisseur est invoqu&eacute; au cours de la phase d'autorisation (via
      une directive <directive>Require</directive>), mod_authnz_fcgi
      renverra un code de type success pour la phase d'autorisation sans
      invoquer l'application. Exemple d'application :
<highlight language="perl">
#!/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") &amp;&amp;
        $ENV{'REMOTE_PASSWD'} eq "bar" &amp;&amp;
        $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";
    }
}
</highlight>

      Exemple de configuration httpd :
<highlight language="config">
AuthnzFcgiDefineProvider authnz FooAuthnz fcgi://localhost:10103/
&lt;Location "/protected/"&gt;
  AuthType Basic
  AuthName "Restricted"
  AuthBasicProvider FooAuthnz
  Require FooAuthnz
&lt;/Location&gt;
</highlight>
      </dd>

      <dt><em>Type</em> <code>authn</code>, <em>mechanism</em>
      <code>check_user_id</code></dt>

      <dd>Dans ce mode, la variable <code>FCGI_ROLE</code> est d&eacute;finie &agrave;
      <code>AUTHORIZER</code> et <code>FCGI_APACHE_ROLE</code> &agrave;
      <code>AUTHENTICATOR</code>. L'application doit &ecirc;tre sp&eacute;cifi&eacute;e en
      tant que fournisseur de type <em>authn</em> via une directive
      <directive
      module="mod_authnz_fcgi">AuthnzFcgiDefineProvider</directive>. La
      directive <directive
      module="mod_authnz_fcgi">AuthnzFcgiCheckAuthnProvider</directive>
      permet de l'invoquer. Exemple d'application :
<highlight language="perl">
#!/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") &amp;&amp;
        $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.
    }
}
</highlight>

      Exemple de configuration httpd :
<highlight language="config">
AuthnzFcgiDefineProvider authn FooAuthn fcgi://localhost:10103/
&lt;Location "/protected/"&gt;
  AuthType ...
  AuthName ...
  AuthnzFcgiCheckAuthnProvider FooAuthn \
                               Authoritative On \
                               RequireBasicAuth Off \
                               UserExpr "%{reqenv:REMOTE_USER}"
  Require ...
&lt;/Location&gt;
</highlight>
      </dd>

    </dl>

</section>

<section id="examples"><title>Exemples suppl&eacute;mentaires</title>

  <ol>
    <li>Si votre application supporte s&eacute;par&eacute;ment les r&ocirc;les
    d'authentification et d'autorisation (<code>AUTHENTICATOR</code> et
    <code>AUTHORIZER</code>), vous pouvez d&eacute;finir des fournisseurs
    s&eacute;par&eacute;s comme suit, m&ecirc;me s'ils correspondent &agrave; la m&ecirc;me application :

<highlight language="config">
AuthnzFcgiDefineProvider authn  FooAuthn  fcgi://localhost:10102/
AuthnzFcgiDefineProvider authz  FooAuthz  fcgi://localhost:10102/
</highlight>

    Sp&eacute;cifie le fournisseur authn via la directive
    <directive module="mod_auth_basic">AuthBasicProvider</directive>
    et le fournisseur authz via la directive
    <directive module="mod_authz_core">Require</directive>:

<highlight language="config">
AuthType Basic
AuthName "Restricted"
AuthBasicProvider FooAuthn
Require FooAuthz
</highlight>
    </li>

    <li>Si votre application supporte le r&ocirc;le g&eacute;n&eacute;rique
    <code>AUTHORIZER</code> (authentification et autorisation en une
    seule invocation), vous pouvez d&eacute;finir un fournisseur unique comme
    suit :

<highlight language="config">
AuthnzFcgiDefineProvider authnz FooAuthnz fcgi://localhost:10103/
</highlight>

    Sp&eacute;cifie le fournisseur authnz via les directives
    <directive>AuthBasicProvider</directive> et
    <directive>Require</directive> :

<highlight language="config">
AuthType Basic
AuthName "Restricted"
AuthBasicProvider FooAuthnz
Require FooAuthnz
</highlight>
    </li>
</ol>
</section>

<section id="limitations"><title>Limitations</title>

    <p>Les fonctionnalit&eacute;s suivantes ne sont pas encore impl&eacute;ment&eacute;es :</p>

    <dl>
      <dt>V&eacute;rificateur d'acc&egrave;s d'Apache httpd</dt>
      <dd>La phase <em>access check</em> de l'API Apache httpd est
      distincte des phases d'authentification et d'autorisation.
      Certaines autres impl&eacute;mentations de FastCGI supportent cette phase
      et lorsque c'est le cas, la variable <code>FCGI_APACHE_ROLE</code>
      est d&eacute;finie &agrave; <code>ACCESS_CHECKER</code>.</dd>

      <dt>Redirections (pipes) ou sockets locaux (Unix)</dt>
      <dd>Seuls les sockets TCP sont actuellement support&eacute;s.</dd>

      <dt>Support de mod_authn_socache</dt>
      <dd>Le support de l'interaction avec mod_authn_socache pour les
      applications qui interviennent dans le processus
      d'authentification d'Apache httpd serait souhaitable.</dd>

      <dt>Support de l'authentification de type digest &agrave; l'aide de AuthDigestProvider</dt>
      <dd>Cette limitation ne sera probablement jamais franchie car il
      n'existe aucun flux de donn&eacute;es d'autorisation capable de lire dans
      un condens&eacute; de type hash.</dd>

      <dt>Gestion des processus applicatifs</dt>
      <dd>Cette fonctionnalit&eacute; restera probablement hors de port&eacute;e de ce
      module. Il faudra donc g&eacute;rer les processus applicatifs d'une autre
      mani&egrave;re ; par exemple, <program>fcgistarter</program> permet de
      les d&eacute;marrer.</dd>

      <dt>AP_AUTH_INTERNAL_PER_URI</dt>
      <dd>Tous les fournisseurs sont actuellement enregistr&eacute;s en tant
      que AP_AUTH_INTERNAL_PER_CONF, ce qui signifie que les
      v&eacute;rifications ne sont pas effectu&eacute;es pour les
      sous-requ&ecirc;tes internes avec la m&ecirc;me configuration de contr&ocirc;le
      d'acc&egrave;s que la requ&ecirc;te initiale.</dd>

      <dt>Conversion du jeu de caract&egrave;res des donn&eacute;es de protocole</dt>
      <dd>Si mod_authnz_fcgi s'ex&eacute;cute dans un environnement de
      compilation EBCDIC, toutes les donn&eacute;es de protocole FastCGI sont
      &eacute;crites en EBCDIC et doivent &ecirc;tre disponibles en EBCDIC.</dd>

      <dt>Plusieurs requ&ecirc;tes pour une connexion</dt>
      <dd>Actuellement, la connexion au fournisseur d'autorisation
      FastCGI est ferm&eacute;e apr&egrave;s chaque phase de traitement. Par exemple,
      si le fournisseur d'autorisation g&egrave;re s&eacute;par&eacute;ment les phases
      <em>authn</em> et <em>authz</em>, deux connexions seront
      n&eacute;cessaires.</dd>

      <dt>Redirection de certains URIs</dt>
      <dd>Les URIs en provenance des clients ne peuvent pas &ecirc;tre
      redirig&eacute;s selon une table de redirection, comme avec la directive
      <directive>ProxyPass</directive> utilis&eacute;e avec les r&eacute;pondeurs
      FastCGI.</dd>

    </dl>

</section>

<section id="logging"><title>Journalisation</title>

    <ol>
        <li>Les erreurs de traitement sont journalis&eacute;es &agrave; un niveau
	<code>error</code> ou sup&eacute;rieur.</li>
        <li>Les messages envoy&eacute;s par l'application sont journalis&eacute;s au
	niveau <code>warn</code>.</li>
        <li>Les messages de deboguage &agrave; caract&egrave;re g&eacute;n&eacute;ral sont
	journalis&eacute;s au niveau <code>debug</code>.</li>
        <li>Les variables d'environnement transmises &agrave; l'application
	sont journalis&eacute;es au niveau <code>trace2</code>. La valeur de la
	variable <code>REMOTE_PASSWD</code> sera occult&eacute;e, mais
	<strong>toute autre donn&eacute;e sensible sera visible dans le
	journal</strong>.</li>
        <li>Toutes les entr&eacute;es/sorties entre le module et l'application
	FastCGI, y compris les variables d'environnement, seront
	journalis&eacute;es au format imprimable et hexad&eacute;cimal au niveau
	<code>trace5</code>. <strong>Toutes les donn&eacute;es sensibles seront
	visibles dans le journal.</strong></li>
    </ol>

    <p>La directive <directive module="core">LogLevel</directive> permet
    de configurer un niveau de journalisation sp&eacute;cifique &agrave;
    mod_authnz_fcgi. Par exemple :</p>

<highlight language="config">
LogLevel info authnz_fcgi:trace8
</highlight>

</section>

<directivesynopsis>
<name>AuthnzFcgiDefineProvider</name>
<description>D&eacute;finit une application FastCGI en tant que fournisseur
d'authentification et/ou autorisation</description>
<syntax>AuthnzFcgiDefineProvider <em>type</em> <em>provider-name</em>
<em>backend-address</em></syntax>
<default>none</default>
<contextlist><context>server config</context></contextlist>
<usage>
    <p>Cette directive permet de d&eacute;finir une application FastCGI en tant
    que fournisseur pour une phase particuli&egrave;re d'authentification ou
    d'autorisation.</p>

    <dl>
      <dt><em>type</em></dt>
      <dd>Les valeurs de ce param&egrave;tre sont <em>authn</em> pour
      l'authentification, <em>authz</em> pour l'autorisation, ou
      <em>authnz</em> pour un fournisseur d'autorisation g&eacute;n&eacute;rique
      FastCGI qui effectue les deux v&eacute;rifications.</dd>

      <dt><em>provider-name</em></dt>
      <dd>Ce param&egrave;tre permet d'associer un nom au fournisseur ; ce nom
      pourra &ecirc;tre utilis&eacute; dans des directives comme <directive
      module="mod_auth_basic">AuthBasicProvider</directive> et
      <directive module="mod_authz_core">Require</directive>.</dd>

      <dt><em>backend-address</em></dt>
      <dd>Ce param&egrave;tre permet de sp&eacute;cifier l'adresse de l'application
      sous la forme <em>fcgi://hostname:port/</em>. Le ou les processus
      de l'application doivent &ecirc;tre g&eacute;r&eacute;s ind&eacute;pendamment comme avec
      <program>fcgistarter</program>.</dd>
    </dl>
</usage>
</directivesynopsis>

<directivesynopsis>
<name>AuthnzFcgiCheckAuthnProvider</name>
<description>Permet &agrave; une application FastCGI de g&eacute;rer l'accroche
d'authentification check_authn.</description>
<syntax>AuthnzFcgiCheckAuthnProvider <em>provider-name</em>|<code>None</code>
<em>option</em> ...</syntax>
<default>none</default>
<contextlist><context>directory</context></contextlist>
<override>FileInfo</override>
<usage>
    <p>Cette directive permet de confier &agrave; une application FastCGI la
    gestion d'une phase sp&eacute;cifique du processus d'authentification ou
    d'autorisation.</p>

    <p>Certaines fonctionnalit&eacute;s des fournisseurs d'autorisation FastCGI
    n&eacute;cessitent cette directive en lieu et place de
    <directive>AuthBasicProvider</directive> pour pouvoir &ecirc;tre activ&eacute;es :</p>

    <ul>
      <li>L'authentification de type autre que basique ; en g&eacute;n&eacute;ral,
      d&eacute;termination de l'identifiant utilisateur et renvoi de sa valeur
      depuis le fournisseur d'autorisation ; voir l'option
      <code>UserExpr</code> ci-dessous</li>
      <li>S&eacute;lection d'un code de r&eacute;ponse personnalis&eacute; ; en cas de
      code de r&eacute;ponse autre que 200 en provenance du fournisseur
      d'autorisation, c'est ce code qui sera utilis&eacute; comme code d'&eacute;tat
      de la r&eacute;ponse</li>
      <li>D&eacute;finition du corps d'une r&eacute;ponse autre que 200 ; si le
      fournisseur d'autorisation renvoie un corps de r&eacute;ponse avec un
      code autre que 200, c'est ce corps de r&eacute;ponse qui sera renvoy&eacute; au
      client ; la longueur du texte est limit&eacute;e &agrave; 8192 octets</li>
    </ul>

    <dl>
      <dt><em>provider-name</em></dt>
      <dd>C'est le nom du fournisseur d&eacute;fini au pr&eacute;alable via la
      directive <directive>AuthnzFcgiDefineProvider</directive>.</dd>

      <dt><code>None</code></dt>
      <dd>Sp&eacute;cifiez <code>None</code> pour d&eacute;sactiver un fournisseur
      activ&eacute; avec cette m&ecirc;me directive dans une autre port&eacute;e, par
      exemple dans un r&eacute;pertoire parent.</dd>

      <dt><em>option</em></dt>
      <dd>Les options suivantes sont support&eacute;es :

      <dl>
         <dt>Authoritative On|Off (par d&eacute;faut On)</dt>
         <dd>Cette option permet de d&eacute;finir si l'appel &agrave; d'autres
	 modules est autoris&eacute; lorsqu'un fournisseur d'autorisation FastCGI a
	 &eacute;t&eacute; configur&eacute; et si la requ&ecirc;te &eacute;choue.</dd>

         <dt>DefaultUser <em>id utilisateur</em></dt>
         <dd>Lorsque le fournisseur d'autorisation donne son accord, et
	 si <code>UserExpr</code> est d&eacute;fini et correspond &agrave; une cha&icirc;ne
	 vide, (par exemple, si le fournisseur d'autorisation ne renvoie
	 aucune variable), c'est cette valeur qui sera utilis&eacute;e comme id
	 utilisateur par d&eacute;faut. Cela se produit souvent lorsqu'on se trouve dans
	 un contexte d'invit&eacute;, ou d'utilisateur non authentifi&eacute; ;
	 les utilisateurs et invit&eacute;s se voient alors attribu&eacute; un id
	 utilisateur sp&eacute;cifique qui permettra de se connecter et
	 d'acc&eacute;der &agrave; certaines ressources.</dd>

         <dt>RequireBasicAuth On|Off (par d&eacute;faut Off)</dt>
         <dd>Cette option permet de d&eacute;finir si l'authentification
	 basique est requise avant de transmettre la requ&ecirc;te au
	 fournisseur d'autorisation. Dans l'affirmative, le fournisseur
	 d'autorisation ne sera invoqu&eacute; qu'en pr&eacute;sence d'un id
	 utilisateur et d'un mot de passe ; si ces deux &eacute;l&eacute;ments ne sont
	 pas pr&eacute;sents, un code d'erreur 401 sera renvoy&eacute;</dd>

         <dt>UserExpr <em>expr</em> (pas de valeur par d&eacute;faut)</dt>
         <dd>Lorsque le client ne fournit pas l'authentification basique
	 et si le fournisseur d'autorisation d&eacute;termine l'id utilisateur,
	 cette expression, &eacute;valu&eacute;e apr&egrave;s l'appel au fournisseur
	 d'autorisation, permet de d&eacute;terminer l'id utilisateur. Cette
	 expression se conforme &agrave; la <a href="../expr.html">syntaxe
	 ap_expr</a> et doit correspondre &agrave; une cha&icirc;ne de caract&egrave;res.
	 Une utilisation courante consiste &agrave; r&eacute;f&eacute;rencer la d&eacute;finition
	 d'une <code>Variable-<em>XXX</em></code> renvoy&eacute;e par le
	 fournisseur d'autorisation via une option du style
	 <code>UserExpr "%{reqenv:<em>XXX</em>}"</code>. Si cette option
	 est sp&eacute;cifi&eacute;e, et si l'id utilisateur ne peut pas &ecirc;tre d&eacute;finie
	 via l'expression apr&egrave;s une authentification r&eacute;ussie, la requ&ecirc;te
	 sera rejet&eacute;e avec un code d'erreur 500.</dd>

       </dl>
      </dd>
     </dl>
</usage>
</directivesynopsis>

</modulesynopsis>