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

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6 /*
   7  * Copyright (c) 2000, Mark Adamson, Carnegie Mellon.  All rights reserved.
   8  * This software is not subject to any license of Carnegie Mellon University.
   9  *
  10  * Redistribution and use in source and binary forms are permitted without
  11  * restriction or fee of any kind as long as this notice is preserved.
  12  *
  13  * The name "Carnegie Mellon" must not be used to endorse or promote
  14  * products derived from this software without prior written permission.
  15  *
  16  */
  17
  18 #include "portable.h"
  19
  20 #include <stdio.h>
  21
  22 #include <ac/stdlib.h>
  23 #include <ac/string.h>
  24
  25 #include "slap.h"
  26
  27 #include <limits.h>
  28
  29 #include <ldap_pvt.h>
  30
  31 #define SASLREGEX_REPLACE 10
  32
  33 typedef struct sasl_regexp {
  34   char *sr_match;                                                       /* regexp match pattern */
  35   char *sr_replace;                                             /* regexp replace pattern */
  36   regex_t sr_workspace;                                         /* workspace for regexp engine */
  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( Operation *op, 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 = dnNormalize( 0, NULL, NULL, &bv, searchbase, op->o_tmpmemctx );
  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_x( op, 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 = dnNormalize( 0, NULL, NULL, &bv, searchbase, op->o_tmpmemctx );
 138
 139 done:
 140         if( rc != LDAP_SUCCESS ) {
 141                 if( *filter ) filter_free_x( op, *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         void *ctx )
 233 {
 234         int i, n, len, insert;
 235
 236         /* Get the total length of the final URI */
 237
 238         n=1;
 239         len = 0;
 240         while( off[n] >= 0 ) {
 241                 /* Len of next section from replacement string (x,y,z above) */
 242                 len += off[n] - off[n-1] - 2;
 243                 if( off[n+1] < 0)
 244                         break;
 245
 246                 /* Len of string from saslname that matched next $i  (b,d above) */
 247                 i = rep[ off[n] + 1 ]   - '0';
 248                 len += str[i].rm_eo - str[i].rm_so;
 249                 n++;
 250         }
 251         out->bv_val = sl_malloc( len + 1, ctx );
 252         out->bv_len = len;
 253
 254         /* Fill in URI with replace string, replacing $i as we go */
 255         n=1;
 256         insert = 0;
 257         while( off[n] >= 0) {
 258                 /* Paste in next section from replacement string (x,y,z above) */
 259                 len = off[n] - off[n-1] - 2;
 260                 strncpy( out->bv_val+insert, rep + off[n-1] + 2, len);
 261                 insert += len;
 262                 if( off[n+1] < 0)
 263                         break;
 264
 265                 /* Paste in string from saslname that matched next $i  (b,d above) */
 266                 i = rep[ off[n] + 1 ]   - '0';
 267                 len = str[i].rm_eo - str[i].rm_so;
 268                 strncpy( out->bv_val+insert, saslname + str[i].rm_so, len );
 269                 insert += len;
 270
 271                 n++;
 272         }
 273
 274         out->bv_val[insert] = '\0';
 275 }
 276
 277 /* Take the passed in SASL name and attempt to convert it into an
 278    LDAP URI to find the matching LDAP entry, using the pattern matching
 279    strings given in the saslregexp config file directive(s) */
 280
 281 static int slap_sasl_regexp( struct berval *in, struct berval *out, void *ctx )
 282 {
 283         char *saslname = in->bv_val;
 284         SaslRegexp_t *reg;
 285         regmatch_t sr_strings[SASLREGEX_REPLACE];       /* strings matching $1,$2 ... */
 286         int i;
 287
 288         memset( out, 0, sizeof( *out ) );
 289
 290 #ifdef NEW_LOGGING
 291         LDAP_LOG( TRANSPORT, ENTRY,
 292                 "slap_sasl_regexp: converting SASL name %s\n", saslname, 0, 0 );
 293 #else
 294         Debug( LDAP_DEBUG_TRACE, "slap_sasl_regexp: converting SASL name %s\n",
 295            saslname, 0, 0 );
 296 #endif
 297
 298         if (( saslname == NULL ) || ( nSaslRegexp == 0 )) {
 299                 return( 0 );
 300         }
 301
 302         /* Match the normalized SASL name to the saslregexp patterns */
 303         for( reg = SaslRegexp,i=0;  i<nSaslRegexp;  i++,reg++ ) {
 304                 if ( regexec( &reg->sr_workspace, saslname, SASLREGEX_REPLACE,
 305                   sr_strings, 0)  == 0 )
 306                         break;
 307         }
 308
 309         if( i >= nSaslRegexp ) return( 0 );
 310
 311         /*
 312          * The match pattern may have been of the form "a(b.*)c(d.*)e" and the
 313          * replace pattern of the form "x$1y$2z". The returned string needs
 314          * to replace the $1,$2 with the strings that matched (b.*) and (d.*)
 315          */
 316         slap_sasl_rx_exp( reg->sr_replace, reg->sr_offset,
 317                 sr_strings, saslname, out, ctx );
 318
 319 #ifdef NEW_LOGGING
 320         LDAP_LOG( TRANSPORT, ENTRY,
 321                 "slap_sasl_regexp: converted SASL name to %s\n",
 322                 out->bv_len ? out->bv_val : "", 0, 0 );
 323 #else
 324         Debug( LDAP_DEBUG_TRACE,
 325                 "slap_sasl_regexp: converted SASL name to %s\n",
 326                 out->bv_len ? out->bv_val : "", 0, 0 );
 327 #endif
 328
 329         return( 1 );
 330 }
 331
 332 /* This callback actually does some work...*/
 333 static int sasl_sc_sasl2dn( Operation *o, SlapReply *rs )
 334 {
 335         struct berval *ndn = o->o_callback->sc_private;
 336
 337         if (rs->sr_type != REP_SEARCH) return 0;
 338
 339         /* We only want to be called once */
 340         if( ndn->bv_val ) {
 341                 o->o_tmpfree(ndn->bv_val, o->o_tmpmemctx);
 342                 ndn->bv_val = NULL;
 343
 344 #ifdef NEW_LOGGING
 345                 LDAP_LOG( TRANSPORT, DETAIL1,
 346                         "slap_sasl2dn: search DN returned more than 1 entry\n", 0, 0, 0 );
 347 #else
 348                 Debug( LDAP_DEBUG_TRACE,
 349                         "slap_sasl2dn: search DN returned more than 1 entry\n", 0,0,0 );
 350 #endif
 351                 return -1;
 352         }
 353
 354         ber_dupbv_x(ndn, &rs->sr_entry->e_nname, o->o_tmpmemctx);
 355         return 0;
 356 }
 357
 358
 359 typedef struct smatch_info {
 360         struct berval *dn;
 361         int match;
 362 } smatch_info;
 363
 364 static int sasl_sc_smatch( Operation *o, SlapReply *rs )
 365 {
 366         smatch_info *sm = o->o_callback->sc_private;
 367
 368         if (rs->sr_type != REP_SEARCH) return 0;
 369
 370         if (dn_match(sm->dn, &rs->sr_entry->e_nname)) {
 371                 sm->match = 1;
 372                 return -1;      /* short-circuit the search */
 373         }
 374
 375         return 1;
 376 }
 377
 378 /*
 379  * Map a SASL regexp rule to a DN. If the rule is just a DN or a scope=base
 380  * URI, just strcmp the rule (or its searchbase) to the *assertDN. Otherwise,
 381  * the rule must be used as an internal search for entries. If that search
 382  * returns the *assertDN entry, the match is successful.
 383  *
 384  * The assertDN should not have the dn: prefix
 385  */
 386
 387 static
 388 int slap_sasl_match(Operation *opx, struct berval *rule, struct berval *assertDN, struct berval *authc )
 389 {
 390         int rc;
 391         regex_t reg;
 392         smatch_info sm;
 393         slap_callback cb = { sasl_sc_smatch, NULL };
 394         Operation op = {0};
 395         SlapReply rs = {REP_RESULT};
 396
 397 #ifdef NEW_LOGGING
 398         LDAP_LOG( TRANSPORT, ENTRY,
 399                 "slap_sasl_match: comparing DN %s to rule %s\n",
 400                 assertDN->bv_val, rule->bv_val,0 );
 401 #else
 402         Debug( LDAP_DEBUG_TRACE,
 403            "===>slap_sasl_match: comparing DN %s to rule %s\n",
 404                 assertDN->bv_val, rule->bv_val, 0 );
 405 #endif
 406
 407         rc = slap_parseURI( opx, rule, &op.o_req_ndn, &op.oq_search.rs_scope, &op.oq_search.rs_filter );
 408         if( rc != LDAP_SUCCESS ) goto CONCLUDED;
 409
 410         /* Massive shortcut: search scope == base */
 411         if( op.oq_search.rs_scope == LDAP_SCOPE_BASE ) {
 412                 rc = regcomp(&reg, op.o_req_ndn.bv_val,
 413                         REG_EXTENDED|REG_ICASE|REG_NOSUB);
 414                 if ( rc == 0 ) {
 415                         rc = regexec(&reg, assertDN->bv_val, 0, NULL, 0);
 416                         regfree( &reg );
 417                 }
 418                 if ( rc == 0 ) {
 419                         rc = LDAP_SUCCESS;
 420                 } else {
 421                         rc = LDAP_INAPPROPRIATE_AUTH;
 422                 }
 423                 goto CONCLUDED;
 424         }
 425
 426         /* Must run an internal search. */
 427
 428 #ifdef NEW_LOGGING
 429         LDAP_LOG( TRANSPORT, DETAIL1,
 430                 "slap_sasl_match: performing internal search (base=%s, scope=%d)\n",
 431                 op.o_req_ndn.bv_val, op.oq_search.rs_scope, 0 );
 432 #else
 433         Debug( LDAP_DEBUG_TRACE,
 434            "slap_sasl_match: performing internal search (base=%s, scope=%d)\n",
 435            op.o_req_ndn.bv_val, op.oq_search.rs_scope, 0 );
 436 #endif
 437
 438         op.o_bd = select_backend( &op.o_req_ndn, 0, 1 );
 439         if(( op.o_bd == NULL ) || ( op.o_bd->be_search == NULL)) {
 440                 rc = LDAP_INAPPROPRIATE_AUTH;
 441                 goto CONCLUDED;
 442         }
 443
 444         sm.dn = assertDN;
 445         sm.match = 0;
 446         cb.sc_private = &sm;
 447
 448         op.o_tag = LDAP_REQ_SEARCH;
 449         op.o_protocol = LDAP_VERSION3;
 450         op.o_ndn = *authc;
 451         op.o_callback = &cb;
 452         op.o_time = slap_get_time();
 453         op.o_do_not_cache = 1;
 454         op.o_is_auth_check = 1;
 455         op.o_threadctx = opx->o_threadctx;
 456         op.o_tmpmemctx = opx->o_tmpmemctx;
 457         op.o_tmpmfuncs = opx->o_tmpmfuncs;
 458         op.o_conn = opx->o_conn;
 459         op.o_connid = opx->o_connid;
 460
 461         op.o_bd->be_search( &op, &rs );
 462
 463         if (sm.match) {
 464                 rc = LDAP_SUCCESS;
 465         } else {
 466                 rc = LDAP_INAPPROPRIATE_AUTH;
 467         }
 468
 469 CONCLUDED:
 470         if( op.o_req_ndn.bv_len ) sl_free( op.o_req_ndn.bv_val, opx->o_tmpmemctx );
 471         if( op.oq_search.rs_filter ) filter_free_x( opx, op.oq_search.rs_filter );
 472
 473 #ifdef NEW_LOGGING
 474         LDAP_LOG( TRANSPORT, ENTRY,
 475                 "slap_sasl_match: comparison returned %d\n", rc, 0, 0 );
 476 #else
 477         Debug( LDAP_DEBUG_TRACE,
 478            "<===slap_sasl_match: comparison returned %d\n", rc, 0, 0);
 479 #endif
 480
 481         return( rc );
 482 }
 483
 484
 485 /*
 486  * This function answers the question, "Can this ID authorize to that ID?",
 487  * based on authorization rules. The rules are stored in the *searchDN, in the
 488  * attribute named by *attr. If any of those rules map to the *assertDN, the
 489  * authorization is approved.
 490  *
 491  * The DNs should not have the dn: prefix
 492  */
 493 static int
 494 slap_sasl_check_authz( Operation *op,
 495         struct berval *searchDN,
 496         struct berval *assertDN,
 497         AttributeDescription *ad,
 498         struct berval *authc )
 499 {
 500         int i, rc;
 501         BerVarray vals=NULL;
 502
 503 #ifdef NEW_LOGGING
 504         LDAP_LOG( TRANSPORT, ENTRY,
 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 #else
 508         Debug( LDAP_DEBUG_TRACE,
 509            "==>slap_sasl_check_authz: does %s match %s rule in %s?\n",
 510            assertDN->bv_val, ad->ad_cname.bv_val, searchDN->bv_val);
 511 #endif
 512
 513         rc = backend_attribute( op, NULL,
 514                 searchDN, ad, &vals );
 515         if( rc != LDAP_SUCCESS ) goto COMPLETE;
 516
 517         /* Check if the *assertDN matches any **vals */
 518         for( i=0; vals[i].bv_val != NULL; i++ ) {
 519                 rc = slap_sasl_match( op, &vals[i], assertDN, authc );
 520                 if ( rc == LDAP_SUCCESS ) goto COMPLETE;
 521         }
 522         rc = LDAP_INAPPROPRIATE_AUTH;
 523
 524 COMPLETE:
 525         if( vals ) ber_bvarray_free_x( vals, op->o_tmpmemctx );
 526
 527 #ifdef NEW_LOGGING
 528         LDAP_LOG( TRANSPORT, RESULTS,
 529                 "slap_sasl_check_authz: %s check returning %s\n",
 530                 ad->ad_cname.bv_val, rc, 0 );
 531 #else
 532         Debug( LDAP_DEBUG_TRACE,
 533            "<==slap_sasl_check_authz: %s check returning %d\n",
 534                 ad->ad_cname.bv_val, rc, 0);
 535 #endif
 536
 537         return( rc );
 538 }
 539
 540 /*
 541  * Given a SASL name (e.g. "UID=name,cn=REALM,cn=MECH,cn=AUTH")
 542  * return the LDAP DN to which it matches. The SASL regexp rules in the config
 543  * file turn the SASL name into an LDAP URI. If the URI is just a DN (or a
 544  * search with scope=base), just return the URI (or its searchbase). Otherwise
 545  * an internal search must be done, and if that search returns exactly one
 546  * entry, return the DN of that one entry.
 547  */
 548 void slap_sasl2dn( Operation *opx,
 549         struct berval *saslname, struct berval *sasldn )
 550 {
 551         int rc;
 552         slap_callback cb = { sasl_sc_sasl2dn, NULL };
 553         Operation op = {0};
 554         SlapReply rs = {REP_RESULT};
 555         struct berval regout = { 0, NULL };
 556
 557 #ifdef NEW_LOGGING
 558         LDAP_LOG( TRANSPORT, ENTRY,
 559                 "slap_sasl2dn: converting SASL name %s to DN.\n",
 560                 saslname->bv_val, 0, 0 );
 561 #else
 562         Debug( LDAP_DEBUG_TRACE, "==>slap_sasl2dn: "
 563                 "converting SASL name %s to a DN\n",
 564                 saslname->bv_val, 0,0 );
 565 #endif
 566
 567         sasldn->bv_val = NULL;
 568         sasldn->bv_len = 0;
 569         cb.sc_private = sasldn;
 570
 571         /* Convert the SASL name into a minimal URI */
 572         if( !slap_sasl_regexp( saslname, &regout, opx->o_tmpmemctx ) ) {
 573                 goto FINISHED;
 574         }
 575
 576         rc = slap_parseURI( opx, &regout, &op.o_req_ndn, &op.oq_search.rs_scope, &op.oq_search.rs_filter );
 577         if( regout.bv_val ) sl_free( regout.bv_val, opx->o_tmpmemctx );
 578         if( rc != LDAP_SUCCESS ) {
 579                 goto FINISHED;
 580         }
 581
 582         /* Must do an internal search */
 583         op.o_bd = select_backend( &op.o_req_ndn, 0, 1 );
 584
 585         /* Massive shortcut: search scope == base */
 586         if( op.oq_search.rs_scope == LDAP_SCOPE_BASE ) {
 587                 *sasldn = op.o_req_ndn;
 588                 op.o_req_ndn.bv_len = 0;
 589                 op.o_req_ndn.bv_val = NULL;
 590                 goto FINISHED;
 591         }
 592
 593 #ifdef NEW_LOGGING
 594         LDAP_LOG( TRANSPORT, DETAIL1,
 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 #else
 598         Debug( LDAP_DEBUG_TRACE,
 599                 "slap_sasl2dn: performing internal search (base=%s, scope=%d)\n",
 600                 op.o_req_ndn.bv_val, op.oq_search.rs_scope, 0 );
 601 #endif
 602
 603         if(( op.o_bd == NULL ) || ( op.o_bd->be_search == NULL)) {
 604                 goto FINISHED;
 605         }
 606
 607         op.o_conn = opx->o_conn;
 608         op.o_connid = opx->o_connid;
 609         op.o_tag = LDAP_REQ_SEARCH;
 610         op.o_protocol = LDAP_VERSION3;
 611         op.o_ndn = opx->o_conn->c_ndn;
 612         op.o_callback = &cb;
 613         op.o_time = slap_get_time();
 614         op.o_do_not_cache = 1;
 615         op.o_is_auth_check = 1;
 616         op.o_threadctx = opx->o_threadctx;
 617         op.o_tmpmemctx = opx->o_tmpmemctx;
 618         op.o_tmpmfuncs = opx->o_tmpmfuncs;
 619         op.oq_search.rs_deref = LDAP_DEREF_NEVER;
 620         op.oq_search.rs_slimit = 1;
 621         op.oq_search.rs_attrsonly = 1;
 622
 623         op.o_bd->be_search( &op, &rs );
 624
 625 FINISHED:
 626         if( sasldn->bv_len ) {
 627                 opx->o_conn->c_authz_backend = op.o_bd;
 628         }
 629         if( op.o_req_ndn.bv_len ) ch_free( op.o_req_ndn.bv_val );
 630         if( op.oq_search.rs_filter ) filter_free_x( opx, op.oq_search.rs_filter );
 631
 632 #ifdef NEW_LOGGING
 633         LDAP_LOG( TRANSPORT, ENTRY,
 634                 "slap_sasl2dn: Converted SASL name to %s\n",
 635                 sasldn->bv_len ? sasldn->bv_val : "<nothing>", 0, 0 );
 636 #else
 637         Debug( LDAP_DEBUG_TRACE, "<==slap_sasl2dn: Converted SASL name to %s\n",
 638                 sasldn->bv_len ? sasldn->bv_val : "<nothing>", 0, 0 );
 639 #endif
 640
 641         return;
 642 }
 643
 644
 645 /* Check if a bind can SASL authorize to another identity.
 646  * The DNs should not have the dn: prefix
 647  */
 648
 649 int slap_sasl_authorized( Operation *op,
 650         struct berval *authcDN, struct berval *authzDN )
 651 {
 652         int rc = LDAP_INAPPROPRIATE_AUTH;
 653
 654         /* User binding as anonymous */
 655         if ( authzDN == NULL ) {
 656                 rc = LDAP_SUCCESS;
 657                 goto DONE;
 658         }
 659
 660 #ifdef NEW_LOGGING
 661         LDAP_LOG( TRANSPORT, ENTRY,
 662                 "slap_sasl_authorized: can %s become %s?\n",
 663                 authcDN->bv_val, authzDN->bv_val, 0 );
 664 #else
 665         Debug( LDAP_DEBUG_TRACE,
 666            "==>slap_sasl_authorized: can %s become %s?\n",
 667                 authcDN->bv_val, authzDN->bv_val, 0 );
 668 #endif
 669
 670         /* If person is authorizing to self, succeed */
 671         if ( dn_match( authcDN, authzDN ) ) {
 672                 rc = LDAP_SUCCESS;
 673                 goto DONE;
 674         }
 675
 676         /* Allow the manager to authorize as any DN. */
 677         if( op->o_conn->c_authz_backend && be_isroot( op->o_conn->c_authz_backend, authcDN )) {
 678                 rc = LDAP_SUCCESS;
 679                 goto DONE;
 680         }
 681
 682         /* Check source rules */
 683         if( authz_policy & SASL_AUTHZ_TO ) {
 684                 rc = slap_sasl_check_authz( op, authcDN, authzDN,
 685                         slap_schema.si_ad_saslAuthzTo, authcDN );
 686                 if( rc == LDAP_SUCCESS ) {
 687                         goto DONE;
 688                 }
 689         }
 690
 691         /* Check destination rules */
 692         if( authz_policy & SASL_AUTHZ_FROM ) {
 693                 rc = slap_sasl_check_authz( op, authzDN, authcDN,
 694                         slap_schema.si_ad_saslAuthzFrom, authcDN );
 695                 if( rc == LDAP_SUCCESS ) {
 696                         goto DONE;
 697                 }
 698         }
 699
 700         rc = LDAP_INAPPROPRIATE_AUTH;
 701
 702 DONE:
 703
 704 #ifdef NEW_LOGGING
 705         LDAP_LOG( TRANSPORT, RESULTS, "slap_sasl_authorized: return %d\n", rc,0,0 );
 706 #else
 707         Debug( LDAP_DEBUG_TRACE,
 708                 "<== slap_sasl_authorized: return %d\n", rc, 0, 0 );
 709 #endif
 710
 711         return( rc );
 712 }