git.sur5r.net Git - openldap/blob - servers/slapd/saslauthz.c

   1 /*
   2  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
   3  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   4  */
   5 /*
   6  * Copyright (c) 2000, Mark Adamson, Carnegie Mellon.  All rights reserved.
   7  * This software is not subject to any license of Carnegie Mellon University.
   8  *
   9  * Redistribution and use in source and binary forms are permitted without
  10  * restriction or fee of any kind as long as this notice is preserved.
  11  *
  12  * The name "Carnegie Mellon" must not be used to endorse or promote
  13  * products derived from this software without prior written permission.
  14  *
  15  */
  16
  17 #include "portable.h"
  18
  19 #include <stdio.h>
  20
  21 #include <ac/stdlib.h>
  22 #include <ac/string.h>
  23
  24 #include "slap.h"
  25
  26 #include <limits.h>
  27
  28 #include <ldap_pvt.h>
  29
  30 #define SASLREGEX_REPLACE 10
  31
  32 typedef struct sasl_regexp {
  33   char *sr_match;                                                       /* regexp match pattern */
  34   char *sr_replace;                                             /* regexp replace pattern */
  35   regex_t sr_workspace;                                         /* workspace for regexp engine */
  36   regmatch_t sr_strings[SASLREGEX_REPLACE];     /* strings matching $1,$2 ... */
  37   int sr_offset[SASLREGEX_REPLACE+2];           /* offsets of $1,$2... in *replace */
  38 } SaslRegexp_t;
  39
  40 static int nSaslRegexp = 0;
  41 static SaslRegexp_t *SaslRegexp = NULL;
  42
  43 /* What SASL proxy authorization policies are allowed? */
  44 #define SASL_AUTHZ_NONE 0
  45 #define SASL_AUTHZ_FROM 1
  46 #define SASL_AUTHZ_TO   2
  47
  48 static int authz_policy = SASL_AUTHZ_NONE;
  49
  50 int slap_sasl_setpolicy( const char *arg )
  51 {
  52         int rc = LDAP_SUCCESS;
  53
  54         if ( strcasecmp( arg, "none" ) == 0 ) {
  55                 authz_policy = SASL_AUTHZ_NONE;
  56         } else if ( strcasecmp( arg, "from" ) == 0 ) {
  57                 authz_policy = SASL_AUTHZ_FROM;
  58         } else if ( strcasecmp( arg, "to" ) == 0 ) {
  59                 authz_policy = SASL_AUTHZ_TO;
  60         } else if ( strcasecmp( arg, "both" ) == 0 ) {
  61                 authz_policy = SASL_AUTHZ_FROM | SASL_AUTHZ_TO;
  62         } else {
  63                 rc = LDAP_OTHER;
  64         }
  65         return rc;
  66 }
  67
  68 /* URI format: ldap://<host>/<base>[?[<attrs>][?[<scope>][?[<filter>]]]] */
  69
  70 static int slap_parseURI( struct berval *uri,
  71         struct berval *searchbase, int *scope, Filter **filter )
  72 {
  73         struct berval bv;
  74         int rc;
  75         LDAPURLDesc *ludp;
  76
  77         assert( uri != NULL && uri->bv_val != NULL );
  78         searchbase->bv_val = NULL;
  79         searchbase->bv_len = 0;
  80         *scope = -1;
  81         *filter = NULL;
  82
  83 #ifdef NEW_LOGGING
  84         LDAP_LOG( TRANSPORT, ENTRY,
  85                 "slap_parseURI: parsing %s\n", uri->bv_val, 0, 0 );
  86 #else
  87         Debug( LDAP_DEBUG_TRACE, "slap_parseURI: parsing %s\n", uri->bv_val, 0, 0 );
  88 #endif
  89
  90         /* If it does not look like a URI, assume it is a DN */
  91         if( !strncasecmp( uri->bv_val, "dn:", sizeof("dn:")-1 ) ) {
  92                 bv.bv_val = uri->bv_val + sizeof("dn:")-1;
  93                 bv.bv_val += strspn( bv.bv_val, " " );
  94
  95 is_dn:  bv.bv_len = uri->bv_len - (bv.bv_val - uri->bv_val);
  96
  97                 rc = dnNormalize2( NULL, &bv, searchbase );
  98                 if( rc == LDAP_SUCCESS ) {
  99                         *scope = LDAP_SCOPE_BASE;
 100                 }
 101                 return( rc );
 102         }
 103
 104         rc = ldap_url_parse( uri->bv_val, &ludp );
 105         if ( rc == LDAP_URL_ERR_BADSCHEME ) {
 106                 bv.bv_val = uri->bv_val;
 107                 goto is_dn;
 108         }
 109
 110         if ( rc != LDAP_URL_SUCCESS ) {
 111                 return LDAP_PROTOCOL_ERROR;
 112         }
 113
 114         if (( ludp->lud_host && *ludp->lud_host )
 115                 || ludp->lud_attrs || ludp->lud_exts )
 116         {
 117                 /* host part should be empty */
 118                 /* attrs and extensions parts should be empty */
 119                 return LDAP_PROTOCOL_ERROR;
 120         }
 121
 122         /* Grab the scope */
 123         *scope = ludp->lud_scope;
 124
 125         /* Grab the filter */
 126         if ( ludp->lud_filter ) {
 127                 *filter = str2filter( ludp->lud_filter );
 128                 if ( *filter == NULL ) {
 129                         rc = LDAP_PROTOCOL_ERROR;
 130                         goto done;
 131                 }
 132         }
 133
 134         /* Grab the searchbase */
 135         bv.bv_val = ludp->lud_dn;
 136         bv.bv_len = strlen( bv.bv_val );
 137         rc = dnNormalize2( NULL, &bv, searchbase );
 138
 139 done:
 140         if( rc != LDAP_SUCCESS ) {
 141                 if( *filter ) filter_free( *filter );
 142         }
 143
 144         ldap_free_urldesc( ludp );
 145         return( rc );
 146 }
 147
 148 static int slap_sasl_rx_off(char *rep, int *off)
 149 {
 150         const char *c;
 151         int n;
 152
 153         /* Precompile replace pattern. Find the $<n> placeholders */
 154         off[0] = -2;
 155         n = 1;
 156         for ( c = rep;   *c;  c++ ) {
 157                 if ( *c == '\\' && c[1] ) {
 158                         c++;
 159                         continue;
 160                 }
 161                 if ( *c == '$' ) {
 162                         if ( n == SASLREGEX_REPLACE ) {
 163 #ifdef NEW_LOGGING
 164                                 LDAP_LOG( TRANSPORT, ERR,
 165                                         "slap_sasl_rx_off: \"%s\" has too many $n "
 166                                         "placeholders (max %d)\n", rep, SASLREGEX_REPLACE, 0  );
 167 #else
 168                                 Debug( LDAP_DEBUG_ANY,
 169                                         "SASL replace pattern %s has too many $n "
 170                                                 "placeholders (max %d)\n",
 171                                         rep, SASLREGEX_REPLACE, 0 );
 172 #endif
 173
 174                                 return( LDAP_OTHER );
 175                         }
 176                         off[n] = c - rep;
 177                         n++;
 178                 }
 179         }
 180
 181         /* Final placeholder, after the last $n */
 182         off[n] = c - rep;
 183         n++;
 184         off[n] = -1;
 185         return( LDAP_SUCCESS );
 186 }
 187
 188 int slap_sasl_regexp_config( const char *match, const char *replace )
 189 {
 190         int rc;
 191         SaslRegexp_t *reg;
 192
 193         SaslRegexp = (SaslRegexp_t *) ch_realloc( (char *) SaslRegexp,
 194           (nSaslRegexp + 1) * sizeof(SaslRegexp_t) );
 195
 196         reg = &SaslRegexp[nSaslRegexp];
 197
 198         reg->sr_match = ch_strdup( match );
 199         reg->sr_replace = ch_strdup( replace );
 200
 201         /* Precompile matching pattern */
 202         rc = regcomp( &reg->sr_workspace, reg->sr_match, REG_EXTENDED|REG_ICASE );
 203         if ( rc ) {
 204 #ifdef NEW_LOGGING
 205                 LDAP_LOG( TRANSPORT, ERR,
 206                         "slap_sasl_regexp_config: \"%s\" could not be compiled.\n",
 207                         reg->sr_match, 0, 0 );
 208 #else
 209                 Debug( LDAP_DEBUG_ANY,
 210                 "SASL match pattern %s could not be compiled by regexp engine\n",
 211                 reg->sr_match, 0, 0 );
 212 #endif
 213
 214                 return( LDAP_OTHER );
 215         }
 216
 217         rc = slap_sasl_rx_off( reg->sr_replace, reg->sr_offset );
 218         if ( rc != LDAP_SUCCESS ) return rc;
 219
 220         nSaslRegexp++;
 221         return( LDAP_SUCCESS );
 222 }
 223
 224
 225 /* Perform replacement on regexp matches */
 226 static void slap_sasl_rx_exp(
 227         const char *rep,
 228         const int *off,
 229         regmatch_t *str,
 230         const char *saslname,
 231         struct berval *out )
 232 {
 233         int i, n, len, insert;
 234
 235         /* Get the total length of the final URI */
 236
 237         n=1;
 238         len = 0;
 239         while( off[n] >= 0 ) {
 240                 /* Len of next section from replacement string (x,y,z above) */
 241                 len += off[n] - off[n-1] - 2;
 242                 if( off[n+1] < 0)
 243                         break;
 244
 245                 /* Len of string from saslname that matched next $i  (b,d above) */
 246                 i = rep[ off[n] + 1 ]   - '0';
 247                 len += str[i].rm_eo - str[i].rm_so;
 248                 n++;
 249         }
 250         out->bv_val = ch_malloc( len + 1 );
 251         out->bv_len = len;
 252
 253         /* Fill in URI with replace string, replacing $i as we go */
 254         n=1;
 255         insert = 0;
 256         while( off[n] >= 0) {
 257                 /* Paste in next section from replacement string (x,y,z above) */
 258                 len = off[n] - off[n-1] - 2;
 259                 strncpy( out->bv_val+insert, rep + off[n-1] + 2, len);
 260                 insert += len;
 261                 if( off[n+1] < 0)
 262                         break;
 263
 264                 /* Paste in string from saslname that matched next $i  (b,d above) */
 265                 i = rep[ off[n] + 1 ]   - '0';
 266                 len = str[i].rm_eo - str[i].rm_so;
 267                 strncpy( out->bv_val+insert, saslname + str[i].rm_so, len );
 268                 insert += len;
 269
 270                 n++;
 271         }
 272
 273         out->bv_val[insert] = '\0';
 274 }
 275
 276 /* Take the passed in SASL name and attempt to convert it into an
 277    LDAP URI to find the matching LDAP entry, using the pattern matching
 278    strings given in the saslregexp config file directive(s) */
 279
 280 static int slap_sasl_regexp( struct berval *in, struct berval *out )
 281 {
 282         char *saslname = in->bv_val;
 283         SaslRegexp_t *reg;
 284         int i;
 285
 286         memset( out, 0, sizeof( *out ) );
 287
 288 #ifdef NEW_LOGGING
 289         LDAP_LOG( TRANSPORT, ENTRY,
 290                 "slap_sasl_regexp: converting SASL name %s\n", saslname, 0, 0 );
 291 #else
 292         Debug( LDAP_DEBUG_TRACE, "slap_sasl_regexp: converting SASL name %s\n",
 293            saslname, 0, 0 );
 294 #endif
 295
 296         if (( saslname == NULL ) || ( nSaslRegexp == 0 )) {
 297                 return( 0 );
 298         }
 299
 300         /* Match the normalized SASL name to the saslregexp patterns */
 301         for( reg = SaslRegexp,i=0;  i<nSaslRegexp;  i++,reg++ ) {
 302                 if ( regexec( &reg->sr_workspace, saslname, SASLREGEX_REPLACE,
 303                   reg->sr_strings, 0)  == 0 )
 304                         break;
 305         }
 306
 307         if( i >= nSaslRegexp ) return( 0 );
 308
 309         /*
 310          * The match pattern may have been of the form "a(b.*)c(d.*)e" and the
 311          * replace pattern of the form "x$1y$2z". The returned string needs
 312          * to replace the $1,$2 with the strings that matched (b.*) and (d.*)
 313          */
 314         slap_sasl_rx_exp( reg->sr_replace, reg->sr_offset,
 315                 reg->sr_strings, saslname, out );
 316
 317 #ifdef NEW_LOGGING
 318         LDAP_LOG( TRANSPORT, ENTRY,
 319                 "slap_sasl_regexp: converted SASL name to %s\n",
 320                 out->bv_len ? out->bv_val : "", 0, 0 );
 321 #else
 322         Debug( LDAP_DEBUG_TRACE,
 323                 "slap_sasl_regexp: converted SASL name to %s\n",
 324                 out->bv_len ? out->bv_val : "", 0, 0 );
 325 #endif
 326
 327         return( 1 );
 328 }
 329
 330 /* This callback actually does some work...*/
 331 static int sasl_sc_sasl2dn( Operation *o, SlapReply *rs )
 332 {
 333         struct berval *ndn = o->o_callback->sc_private;
 334
 335         if (rs->sr_type != REP_SEARCH) return 0;
 336
 337         /* We only want to be called once */
 338         if( ndn->bv_val ) {
 339                 free(ndn->bv_val);
 340                 ndn->bv_val = NULL;
 341
 342 #ifdef NEW_LOGGING
 343                 LDAP_LOG( TRANSPORT, DETAIL1,
 344                         "slap_sasl2dn: search DN returned more than 1 entry\n", 0, 0, 0 );
 345 #else
 346                 Debug( LDAP_DEBUG_TRACE,
 347                         "slap_sasl2dn: search DN returned more than 1 entry\n", 0,0,0 );
 348 #endif
 349                 return -1;
 350         }
 351
 352         ber_dupbv(ndn, &rs->sr_entry->e_nname);
 353         return 0;
 354 }
 355
 356
 357 typedef struct smatch_info {
 358         struct berval *dn;
 359         int match;
 360 } smatch_info;
 361
 362 static int sasl_sc_smatch( Operation *o, SlapReply *rs )
 363 {
 364         smatch_info *sm = o->o_callback->sc_private;
 365
 366         if (rs->sr_type != REP_SEARCH) return 0;
 367
 368         if (dn_match(sm->dn, &rs->sr_entry->e_nname)) {
 369                 sm->match = 1;
 370                 return -1;      /* short-circuit the search */
 371         }
 372
 373         return 1;
 374 }
 375
 376 /*
 377  * Map a SASL regexp rule to a DN. If the rule is just a DN or a scope=base
 378  * URI, just strcmp the rule (or its searchbase) to the *assertDN. Otherwise,
 379  * the rule must be used as an internal search for entries. If that search
 380  * returns the *assertDN entry, the match is successful.
 381  *
 382  * The assertDN should not have the dn: prefix
 383  */
 384
 385 static
 386 int slap_sasl_match(Connection *conn, struct berval *rule, struct berval *assertDN, struct berval *authc )
 387 {
 388         int rc;
 389         regex_t reg;
 390         smatch_info sm;
 391         slap_callback cb = { sasl_sc_smatch };
 392         Operation op = {0};
 393         SlapReply rs = {REP_RESULT};
 394
 395 #ifdef NEW_LOGGING
 396         LDAP_LOG( TRANSPORT, ENTRY,
 397                 "slap_sasl_match: comparing DN %s to rule %s\n",
 398                 assertDN->bv_val, rule->bv_val,0 );
 399 #else
 400         Debug( LDAP_DEBUG_TRACE,
 401            "===>slap_sasl_match: comparing DN %s to rule %s\n",
 402                 assertDN->bv_val, rule->bv_val, 0 );
 403 #endif
 404
 405         rc = slap_parseURI( rule, &op.o_req_ndn, &op.oq_search.rs_scope, &op.oq_search.rs_filter );
 406         if( rc != LDAP_SUCCESS ) goto CONCLUDED;
 407
 408         /* Massive shortcut: search scope == base */
 409         if( op.oq_search.rs_scope == LDAP_SCOPE_BASE ) {
 410                 rc = regcomp(&reg, op.o_req_ndn.bv_val,
 411                         REG_EXTENDED|REG_ICASE|REG_NOSUB);
 412                 if ( rc == 0 ) {
 413                         rc = regexec(&reg, assertDN->bv_val, 0, NULL, 0);
 414                         regfree( &reg );
 415                 }
 416                 if ( rc == 0 ) {
 417                         rc = LDAP_SUCCESS;
 418                 } else {
 419                         rc = LDAP_INAPPROPRIATE_AUTH;
 420                 }
 421                 goto CONCLUDED;
 422         }
 423
 424         /* Must run an internal search. */
 425
 426 #ifdef NEW_LOGGING
 427         LDAP_LOG( TRANSPORT, DETAIL1,
 428                 "slap_sasl_match: performing internal search (base=%s, scope=%d)\n",
 429                 op.o_req_ndn.bv_val, op.oq_search.rs_scope, 0 );
 430 #else
 431         Debug( LDAP_DEBUG_TRACE,
 432            "slap_sasl_match: performing internal search (base=%s, scope=%d)\n",
 433            op.o_req_ndn.bv_val, op.oq_search.rs_scope, 0 );
 434 #endif
 435
 436         op.o_bd = select_backend( &op.o_req_ndn, 0, 1 );
 437         if(( op.o_bd == NULL ) || ( op.o_bd->be_search == NULL)) {
 438                 rc = LDAP_INAPPROPRIATE_AUTH;
 439                 goto CONCLUDED;
 440         }
 441
 442         sm.dn = assertDN;
 443         sm.match = 0;
 444         cb.sc_private = &sm;
 445
 446         op.o_tag = LDAP_REQ_SEARCH;
 447         op.o_protocol = LDAP_VERSION3;
 448         op.o_ndn = *authc;
 449         op.o_callback = &cb;
 450         op.o_time = slap_get_time();
 451         op.o_do_not_cache = 1;
 452         op.o_is_auth_check = 1;
 453         op.o_threadctx = conn->c_sasl_bindop->o_threadctx;
 454         op.o_conn = conn;
 455         op.o_connid = conn->c_connid;
 456
 457         op.o_bd->be_search( &op, &rs );
 458
 459         if (sm.match) {
 460                 rc = LDAP_SUCCESS;
 461         } else {
 462                 rc = LDAP_INAPPROPRIATE_AUTH;
 463         }
 464
 465 CONCLUDED:
 466         if( op.o_req_ndn.bv_len ) ch_free( op.o_req_ndn.bv_val );
 467         if( op.oq_search.rs_filter ) filter_free( op.oq_search.rs_filter );
 468
 469 #ifdef NEW_LOGGING
 470         LDAP_LOG( TRANSPORT, ENTRY,
 471                 "slap_sasl_match: comparison returned %d\n", rc, 0, 0 );
 472 #else
 473         Debug( LDAP_DEBUG_TRACE,
 474            "<===slap_sasl_match: comparison returned %d\n", rc, 0, 0);
 475 #endif
 476
 477         return( rc );
 478 }
 479
 480
 481 /*
 482  * This function answers the question, "Can this ID authorize to that ID?",
 483  * based on authorization rules. The rules are stored in the *searchDN, in the
 484  * attribute named by *attr. If any of those rules map to the *assertDN, the
 485  * authorization is approved.
 486  *
 487  * The DNs should not have the dn: prefix
 488  */
 489 static int
 490 slap_sasl_check_authz( Connection *conn,
 491         struct berval *searchDN,
 492         struct berval *assertDN,
 493         AttributeDescription *ad,
 494         struct berval *authc )
 495 {
 496         int i, rc;
 497         BerVarray vals=NULL;
 498
 499 #ifdef NEW_LOGGING
 500         LDAP_LOG( TRANSPORT, ENTRY,
 501                 "slap_sasl_check_authz: does %s match %s rule in %s?\n",
 502             assertDN->bv_val, ad->ad_cname.bv_val, searchDN->bv_val);
 503 #else
 504         Debug( LDAP_DEBUG_TRACE,
 505            "==>slap_sasl_check_authz: does %s match %s rule in %s?\n",
 506            assertDN->bv_val, ad->ad_cname.bv_val, searchDN->bv_val);
 507 #endif
 508
 509         rc = backend_attribute( conn->c_sasl_bindop, NULL,
 510                 searchDN, ad, &vals );
 511         if( rc != LDAP_SUCCESS ) goto COMPLETE;
 512
 513         /* Check if the *assertDN matches any **vals */
 514         for( i=0; vals[i].bv_val != NULL; i++ ) {
 515                 rc = slap_sasl_match( conn, &vals[i], assertDN, authc );
 516                 if ( rc == LDAP_SUCCESS ) goto COMPLETE;
 517         }
 518         rc = LDAP_INAPPROPRIATE_AUTH;
 519
 520 COMPLETE:
 521         if( vals ) ber_bvarray_free( vals );
 522
 523 #ifdef NEW_LOGGING
 524         LDAP_LOG( TRANSPORT, RESULTS,
 525                 "slap_sasl_check_authz: %s check returning %s\n",
 526                 ad->ad_cname.bv_val, rc, 0 );
 527 #else
 528         Debug( LDAP_DEBUG_TRACE,
 529            "<==slap_sasl_check_authz: %s check returning %d\n",
 530                 ad->ad_cname.bv_val, rc, 0);
 531 #endif
 532
 533         return( rc );
 534 }
 535
 536 /*
 537  * Given a SASL name (e.g. "UID=name,cn=REALM,cn=MECH,cn=AUTH")
 538  * return the LDAP DN to which it matches. The SASL regexp rules in the config
 539  * file turn the SASL name into an LDAP URI. If the URI is just a DN (or a
 540  * search with scope=base), just return the URI (or its searchbase). Otherwise
 541  * an internal search must be done, and if that search returns exactly one
 542  * entry, return the DN of that one entry.
 543  */
 544 void slap_sasl2dn( Connection *conn,
 545         struct berval *saslname, struct berval *sasldn )
 546 {
 547         int rc;
 548         slap_callback cb = { sasl_sc_sasl2dn };
 549         Operation op = {0};
 550         SlapReply rs = {REP_RESULT};
 551         struct berval regout = { 0, NULL };
 552
 553 #ifdef NEW_LOGGING
 554         LDAP_LOG( TRANSPORT, ENTRY,
 555                 "slap_sasl2dn: converting SASL name %s to DN.\n",
 556                 saslname->bv_val, 0, 0 );
 557 #else
 558         Debug( LDAP_DEBUG_TRACE, "==>slap_sasl2dn: "
 559                 "converting SASL name %s to a DN\n",
 560                 saslname->bv_val, 0,0 );
 561 #endif
 562
 563         sasldn->bv_val = NULL;
 564         sasldn->bv_len = 0;
 565         cb.sc_private = sasldn;
 566
 567         /* Convert the SASL name into a minimal URI */
 568         if( !slap_sasl_regexp( saslname, &regout ) ) {
 569                 goto FINISHED;
 570         }
 571
 572         rc = slap_parseURI( &regout, &op.o_req_ndn, &op.oq_search.rs_scope, &op.oq_search.rs_filter );
 573         if( regout.bv_val ) ch_free( regout.bv_val );
 574         if( rc != LDAP_SUCCESS ) {
 575                 goto FINISHED;
 576         }
 577
 578         /* Must do an internal search */
 579         op.o_bd = select_backend( &op.o_req_ndn, 0, 1 );
 580
 581         /* Massive shortcut: search scope == base */
 582         if( op.oq_search.rs_scope == LDAP_SCOPE_BASE ) {
 583                 *sasldn = op.o_req_ndn;
 584                 op.o_req_ndn.bv_len = 0;
 585                 op.o_req_ndn.bv_val = NULL;
 586                 goto FINISHED;
 587         }
 588
 589 #ifdef NEW_LOGGING
 590         LDAP_LOG( TRANSPORT, DETAIL1,
 591                 "slap_sasl2dn: performing internal search (base=%s, scope=%d)\n",
 592                 op.o_req_ndn.bv_val, op.oq_search.rs_scope, 0 );
 593 #else
 594         Debug( LDAP_DEBUG_TRACE,
 595                 "slap_sasl2dn: performing internal search (base=%s, scope=%d)\n",
 596                 op.o_req_ndn.bv_val, op.oq_search.rs_scope, 0 );
 597 #endif
 598
 599         if(( op.o_bd == NULL ) || ( op.o_bd->be_search == NULL)) {
 600                 goto FINISHED;
 601         }
 602
 603         op.o_conn = conn;
 604         op.o_connid = conn->c_connid;
 605         op.o_tag = LDAP_REQ_SEARCH;
 606         op.o_protocol = LDAP_VERSION3;
 607         op.o_ndn = conn->c_ndn;
 608         op.o_callback = &cb;
 609         op.o_time = slap_get_time();
 610         op.o_do_not_cache = 1;
 611         op.o_is_auth_check = 1;
 612         op.o_threadctx = conn->c_sasl_bindop ? conn->c_sasl_bindop->o_threadctx:
 613                 ldap_pvt_thread_pool_context( &connection_pool );
 614         op.oq_search.rs_deref = LDAP_DEREF_NEVER;
 615         op.oq_search.rs_slimit = 1;
 616         op.oq_search.rs_attrsonly = 1;
 617
 618         op.o_bd->be_search( &op, &rs );
 619
 620 FINISHED:
 621         if( sasldn->bv_len ) {
 622                 conn->c_authz_backend = op.o_bd;
 623         }
 624         if( op.o_req_ndn.bv_len ) ch_free( op.o_req_ndn.bv_val );
 625         if( op.oq_search.rs_filter ) filter_free( op.oq_search.rs_filter );
 626
 627 #ifdef NEW_LOGGING
 628         LDAP_LOG( TRANSPORT, ENTRY,
 629                 "slap_sasl2dn: Converted SASL name to %s\n",
 630                 sasldn->bv_len ? sasldn->bv_val : "<nothing>", 0, 0 );
 631 #else
 632         Debug( LDAP_DEBUG_TRACE, "<==slap_sasl2dn: Converted SASL name to %s\n",
 633                 sasldn->bv_len ? sasldn->bv_val : "<nothing>", 0, 0 );
 634 #endif
 635
 636         return;
 637 }
 638
 639
 640 /* Check if a bind can SASL authorize to another identity.
 641  * The DNs should not have the dn: prefix
 642  */
 643
 644 int slap_sasl_authorized( Connection *conn,
 645         struct berval *authcDN, struct berval *authzDN )
 646 {
 647         int rc = LDAP_INAPPROPRIATE_AUTH;
 648
 649         /* User binding as anonymous */
 650         if ( authzDN == NULL ) {
 651                 rc = LDAP_SUCCESS;
 652                 goto DONE;
 653         }
 654
 655 #ifdef NEW_LOGGING
 656         LDAP_LOG( TRANSPORT, ENTRY,
 657                 "slap_sasl_authorized: can %s become %s?\n",
 658                 authcDN->bv_val, authzDN->bv_val, 0 );
 659 #else
 660         Debug( LDAP_DEBUG_TRACE,
 661            "==>slap_sasl_authorized: can %s become %s?\n",
 662                 authcDN->bv_val, authzDN->bv_val, 0 );
 663 #endif
 664
 665         /* If person is authorizing to self, succeed */
 666         if ( dn_match( authcDN, authzDN ) ) {
 667                 rc = LDAP_SUCCESS;
 668                 goto DONE;
 669         }
 670
 671         /* Allow the manager to authorize as any DN. */
 672         if( conn->c_authz_backend && be_isroot( conn->c_authz_backend, authcDN )) {
 673                 rc = LDAP_SUCCESS;
 674                 goto DONE;
 675         }
 676
 677         /* Check source rules */
 678         if( authz_policy & SASL_AUTHZ_TO ) {
 679                 rc = slap_sasl_check_authz( conn, authcDN, authzDN,
 680                         slap_schema.si_ad_saslAuthzTo, authcDN );
 681                 if( rc == LDAP_SUCCESS ) {
 682                         goto DONE;
 683                 }
 684         }
 685
 686         /* Check destination rules */
 687         if( authz_policy & SASL_AUTHZ_FROM ) {
 688                 rc = slap_sasl_check_authz( conn, authzDN, authcDN,
 689                         slap_schema.si_ad_saslAuthzFrom, authcDN );
 690                 if( rc == LDAP_SUCCESS ) {
 691                         goto DONE;
 692                 }
 693         }
 694
 695         rc = LDAP_INAPPROPRIATE_AUTH;
 696
 697 DONE:
 698
 699 #ifdef NEW_LOGGING
 700         LDAP_LOG( TRANSPORT, RESULTS, "slap_sasl_authorized: return %d\n", rc,0,0 );
 701 #else
 702         Debug( LDAP_DEBUG_TRACE,
 703                 "<== slap_sasl_authorized: return %d\n", rc, 0, 0 );
 704 #endif
 705
 706         return( rc );
 707 }