granicus.if.org Git - apache/blob - modules/aaa/mod_access_compat.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * Security options etc.
  19  *
  20  * Module derived from code originally written by Rob McCool
  21  *
  22  */
  23
  24 #include "apr_strings.h"
  25 #include "apr_network_io.h"
  26 #include "apr_md5.h"
  27
  28 #define APR_WANT_STRFUNC
  29 #define APR_WANT_BYTEFUNC
  30 #include "apr_want.h"
  31
  32 #include "ap_config.h"
  33 #include "httpd.h"
  34 #include "http_core.h"
  35 #include "http_config.h"
  36 #include "http_log.h"
  37 #include "http_protocol.h"
  38 #include "http_request.h"
  39
  40 #include "mod_auth.h"
  41
  42 #if APR_HAVE_NETINET_IN_H
  43 #include <netinet/in.h>
  44 #endif
  45
  46 enum allowdeny_type {
  47     T_ENV,
  48     T_ALL,
  49     T_IP,
  50     T_HOST,
  51     T_FAIL
  52 };
  53
  54 typedef struct {
  55     apr_int64_t limited;
  56     union {
  57         char *from;
  58         apr_ipsubnet_t *ip;
  59     } x;
  60     enum allowdeny_type type;
  61 } allowdeny;
  62
  63 /* things in the 'order' array */
  64 #define DENY_THEN_ALLOW 0
  65 #define ALLOW_THEN_DENY 1
  66 #define MUTUAL_FAILURE 2
  67
  68 typedef struct {
  69     int order[METHODS];
  70     apr_array_header_t *allows;
  71     apr_array_header_t *denys;
  72     int *satisfy; /* for every method one */
  73 } access_compat_dir_conf;
  74
  75 module AP_MODULE_DECLARE_DATA access_compat_module;
  76
  77 static void *create_access_compat_dir_config(apr_pool_t *p, char *dummy)
  78 {
  79     int i;
  80     access_compat_dir_conf *conf =
  81         (access_compat_dir_conf *)apr_pcalloc(p, sizeof(access_compat_dir_conf));
  82
  83     for (i = 0; i < METHODS; ++i) {
  84         conf->order[i] = DENY_THEN_ALLOW;
  85     }
  86     conf->allows = apr_array_make(p, 1, sizeof(allowdeny));
  87     conf->denys = apr_array_make(p, 1, sizeof(allowdeny));
  88     conf->satisfy = apr_palloc(p, sizeof(*conf->satisfy) * METHODS);
  89     for (i = 0; i < METHODS; ++i) {
  90         conf->satisfy[i] = SATISFY_NOSPEC;
  91     }
  92
  93     return (void *)conf;
  94 }
  95
  96 static const char *order(cmd_parms *cmd, void *dv, const char *arg)
  97 {
  98     access_compat_dir_conf *d = (access_compat_dir_conf *) dv;
  99     int i, o;
 100
 101     ap_log_error(APLOG_MARK, APLOG_INFO, 0, cmd->server,
 102                   "The 'Order' directive has been deprecated. "
 103                   "Consider using '<SatisfyAll><SatisfyOne>' directives.");
 104
 105     if (!strcasecmp(arg, "allow,deny"))
 106         o = ALLOW_THEN_DENY;
 107     else if (!strcasecmp(arg, "deny,allow"))
 108         o = DENY_THEN_ALLOW;
 109     else if (!strcasecmp(arg, "mutual-failure"))
 110         o = MUTUAL_FAILURE;
 111     else
 112         return "unknown order";
 113
 114     for (i = 0; i < METHODS; ++i)
 115         if (cmd->limited & (AP_METHOD_BIT << i))
 116             d->order[i] = o;
 117
 118     return NULL;
 119 }
 120
 121 static const char *satisfy(cmd_parms *cmd, void *dv, const char *arg)
 122 {
 123     access_compat_dir_conf *d = (access_compat_dir_conf *) dv;
 124     int satisfy = SATISFY_NOSPEC;
 125     int i;
 126
 127     ap_log_error(APLOG_MARK, APLOG_INFO, 0, cmd->server,
 128                   "The 'Satisfy' directive has been deprecated. "
 129                   "Consider using '<SatisfyAll><SatisfyOne>' directives.");
 130
 131     if (!strcasecmp(arg, "all")) {
 132         satisfy = SATISFY_ALL;
 133     }
 134     else if (!strcasecmp(arg, "any")) {
 135         satisfy = SATISFY_ANY;
 136     }
 137     else {
 138         return "Satisfy either 'any' or 'all'.";
 139     }
 140
 141     for (i = 0; i < METHODS; ++i) {
 142         if (cmd->limited & (AP_METHOD_BIT << i)) {
 143             d->satisfy[i] = satisfy;
 144         }
 145     }
 146
 147     return NULL;
 148 }
 149
 150 static const char *allow_cmd(cmd_parms *cmd, void *dv, const char *from,
 151                              const char *where_c)
 152 {
 153     access_compat_dir_conf *d = (access_compat_dir_conf *) dv;
 154     allowdeny *a;
 155     char *where = apr_pstrdup(cmd->pool, where_c);
 156     char *s;
 157     char msgbuf[120];
 158     apr_status_t rv;
 159
 160     ap_log_error(APLOG_MARK, APLOG_INFO, 0, cmd->server,
 161                   "The 'Allow/Deny' directives have been deprecated. "
 162                   "Consider using one of the host providers in mod_authz_host.");
 163
 164     if (strcasecmp(from, "from"))
 165         return "allow and deny must be followed by 'from'";
 166
 167     a = (allowdeny *) apr_array_push(cmd->info ? d->allows : d->denys);
 168     a->x.from = where;
 169     a->limited = cmd->limited;
 170
 171     if (!strncasecmp(where, "env=", 4)) {
 172         a->type = T_ENV;
 173         a->x.from += 4;
 174
 175     }
 176     else if (!strcasecmp(where, "all")) {
 177         a->type = T_ALL;
 178     }
 179     else if ((s = ap_strchr(where, '/'))) {
 180         *s++ = '\0';
 181         rv = apr_ipsubnet_create(&a->x.ip, where, s, cmd->pool);
 182         if(APR_STATUS_IS_EINVAL(rv)) {
 183             /* looked nothing like an IP address */
 184             return "An IP address was expected";
 185         }
 186         else if (rv != APR_SUCCESS) {
 187             apr_strerror(rv, msgbuf, sizeof msgbuf);
 188             return apr_pstrdup(cmd->pool, msgbuf);
 189         }
 190         a->type = T_IP;
 191     }
 192     else if (!APR_STATUS_IS_EINVAL(rv = apr_ipsubnet_create(&a->x.ip, where,
 193                                                             NULL, cmd->pool))) {
 194         if (rv != APR_SUCCESS) {
 195             apr_strerror(rv, msgbuf, sizeof msgbuf);
 196             return apr_pstrdup(cmd->pool, msgbuf);
 197         }
 198         a->type = T_IP;
 199     }
 200     else { /* no slash, didn't look like an IP address => must be a host */
 201         a->type = T_HOST;
 202     }
 203
 204     return NULL;
 205 }
 206
 207 static char its_an_allow;
 208
 209 static const command_rec access_compat_cmds[] =
 210 {
 211     AP_INIT_TAKE1("order", order, NULL, OR_LIMIT,
 212                   "'allow,deny', 'deny,allow', or 'mutual-failure'"),
 213     AP_INIT_ITERATE2("allow", allow_cmd, &its_an_allow, OR_LIMIT,
 214                      "'from' followed by hostnames or IP-address wildcards"),
 215     AP_INIT_ITERATE2("deny", allow_cmd, NULL, OR_LIMIT,
 216                      "'from' followed by hostnames or IP-address wildcards"),
 217     AP_INIT_TAKE1("Satisfy", satisfy, NULL, OR_AUTHCFG,
 218                   "access policy if both allow and require used ('all' or 'any')"),
 219     {NULL}
 220 };
 221
 222 static int in_domain(const char *domain, const char *what)
 223 {
 224     int dl = strlen(domain);
 225     int wl = strlen(what);
 226
 227     if ((wl - dl) >= 0) {
 228         if (strcasecmp(domain, &what[wl - dl]) != 0) {
 229             return 0;
 230         }
 231
 232         /* Make sure we matched an *entire* subdomain --- if the user
 233          * said 'allow from good.com', we don't want people from nogood.com
 234          * to be able to get in.
 235          */
 236
 237         if (wl == dl) {
 238             return 1;                /* matched whole thing */
 239         }
 240         else {
 241             return (domain[0] == '.' || what[wl - dl - 1] == '.');
 242         }
 243     }
 244     else {
 245         return 0;
 246     }
 247 }
 248
 249 static int find_allowdeny(request_rec *r, apr_array_header_t *a, int method)
 250 {
 251
 252     allowdeny *ap = (allowdeny *) a->elts;
 253     apr_int64_t mmask = (AP_METHOD_BIT << method);
 254     int i;
 255     int gothost = 0;
 256     const char *remotehost = NULL;
 257
 258     for (i = 0; i < a->nelts; ++i) {
 259         if (!(mmask & ap[i].limited)) {
 260             continue;
 261         }
 262
 263         switch (ap[i].type) {
 264         case T_ENV:
 265             if (apr_table_get(r->subprocess_env, ap[i].x.from)) {
 266                 return 1;
 267             }
 268             break;
 269
 270         case T_ALL:
 271             return 1;
 272
 273         case T_IP:
 274             if (apr_ipsubnet_test(ap[i].x.ip, r->connection->remote_addr)) {
 275                 return 1;
 276             }
 277             break;
 278
 279         case T_HOST:
 280             if (!gothost) {
 281                 int remotehost_is_ip;
 282
 283                 remotehost = ap_get_remote_host(r->connection,
 284                                                 r->per_dir_config,
 285                                                 REMOTE_DOUBLE_REV,
 286                                                 &remotehost_is_ip);
 287
 288                 if ((remotehost == NULL) || remotehost_is_ip) {
 289                     gothost = 1;
 290                 }
 291                 else {
 292                     gothost = 2;
 293                 }
 294             }
 295
 296             if ((gothost == 2) && in_domain(ap[i].x.from, remotehost)) {
 297                 return 1;
 298             }
 299             break;
 300
 301         case T_FAIL:
 302             /* do nothing? */
 303             break;
 304         }
 305     }
 306
 307     return 0;
 308 }
 309
 310 static int ap_satisfies(request_rec *r)
 311 {
 312     access_compat_dir_conf *conf = (access_compat_dir_conf *)
 313         ap_get_module_config(r->per_dir_config, &access_compat_module);
 314
 315     return conf->satisfy[r->method_number];
 316 }
 317
 318 static int check_dir_access(request_rec *r)
 319 {
 320     int method = r->method_number;
 321     int ret = OK;
 322     access_compat_dir_conf *a = (access_compat_dir_conf *)
 323         ap_get_module_config(r->per_dir_config, &access_compat_module);
 324
 325     if (a->order[method] == ALLOW_THEN_DENY) {
 326         ret = HTTP_FORBIDDEN;
 327         if (find_allowdeny(r, a->allows, method)) {
 328             ret = OK;
 329         }
 330         if (find_allowdeny(r, a->denys, method)) {
 331             ret = HTTP_FORBIDDEN;
 332         }
 333     }
 334     else if (a->order[method] == DENY_THEN_ALLOW) {
 335         if (find_allowdeny(r, a->denys, method)) {
 336             ret = HTTP_FORBIDDEN;
 337         }
 338         if (find_allowdeny(r, a->allows, method)) {
 339             ret = OK;
 340         }
 341     }
 342     else {
 343         if (find_allowdeny(r, a->allows, method)
 344             && !find_allowdeny(r, a->denys, method)) {
 345             ret = OK;
 346         }
 347         else {
 348             ret = HTTP_FORBIDDEN;
 349         }
 350     }
 351
 352     if (ret == OK) {
 353         apr_table_setn(r->notes, AUTHZ_ACCESS_PASSED_NOTE, "Y");
 354     }
 355     else {
 356         apr_table_setn(r->notes, AUTHZ_ACCESS_PASSED_NOTE, "N");
 357         /* If Satisfy is Any and authorization is required, then
 358            defer to the authorization stage */
 359         if ((ap_satisfies(r) == SATISFY_ANY) && ap_some_auth_required(r)) {
 360             ret = OK;
 361         }
 362     }
 363
 364     if (ret == HTTP_FORBIDDEN) {
 365         ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 366                       "client denied by server configuration: %s%s",
 367                       r->filename ? "" : "uri ",
 368                       r->filename ? r->filename : r->uri);
 369     }
 370
 371     return ret;
 372 }
 373
 374 static void register_hooks(apr_pool_t *p)
 375 {
 376     APR_REGISTER_OPTIONAL_FN(ap_satisfies);
 377
 378     /* This can be access checker since we don't require r->user to be set. */
 379     ap_hook_access_checker(check_dir_access,NULL,NULL,APR_HOOK_MIDDLE);
 380 }
 381
 382 module AP_MODULE_DECLARE_DATA access_compat_module =
 383 {
 384     STANDARD20_MODULE_STUFF,
 385     create_access_compat_dir_config,   /* dir config creater */
 386     NULL,                           /* dir merger --- default is to override */
 387     NULL,                           /* server config */
 388     NULL,                           /* merge server config */
 389     access_compat_cmds,
 390     register_hooks                  /* register hooks */
 391 };