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         if( vals != NULL ) {
 519                 for( i=0; vals[i].bv_val != NULL; i++ ) {
 520                         rc = slap_sasl_match( op, &vals[i], assertDN, authc );
 521                         if ( rc == LDAP_SUCCESS ) goto COMPLETE;
 522                 }
 523         }
 524         rc = LDAP_INAPPROPRIATE_AUTH;
 525
 526 COMPLETE:
 527         if( vals ) ber_bvarray_free_x( vals, op->o_tmpmemctx );
 528
 529 #ifdef NEW_LOGGING
 530         LDAP_LOG( TRANSPORT, RESULTS,
 531                 "slap_sasl_check_authz: %s check returning %s\n",
 532                 ad->ad_cname.bv_val, rc, 0 );
 533 #else
 534         Debug( LDAP_DEBUG_TRACE,
 535            "<==slap_sasl_check_authz: %s check returning %d\n",
 536                 ad->ad_cname.bv_val, rc, 0);
 537 #endif
 538
 539         return( rc );
 540 }
 541
 542 /*
 543  * Given a SASL name (e.g. "UID=name,cn=REALM,cn=MECH,cn=AUTH")
 544  * return the LDAP DN to which it matches. The SASL regexp rules in the config
 545  * file turn the SASL name into an LDAP URI. If the URI is just a DN (or a
 546  * search with scope=base), just return the URI (or its searchbase). Otherwise
 547  * an internal search must be done, and if that search returns exactly one
 548  * entry, return the DN of that one entry.
 549  */
 550 void slap_sasl2dn( Operation *opx,
 551         struct berval *saslname, struct berval *sasldn )
 552 {
 553         int rc;
 554         slap_callback cb = { sasl_sc_sasl2dn, NULL };
 555         Operation op = {0};
 556         SlapReply rs = {REP_RESULT};
 557         struct berval regout = { 0, NULL };
 558
 559 #ifdef NEW_LOGGING
 560         LDAP_LOG( TRANSPORT, ENTRY,
 561                 "slap_sasl2dn: converting SASL name %s to DN.\n",
 562                 saslname->bv_val, 0, 0 );
 563 #else
 564         Debug( LDAP_DEBUG_TRACE, "==>slap_sasl2dn: "
 565                 "converting SASL name %s to a DN\n",
 566                 saslname->bv_val, 0,0 );
 567 #endif
 568
 569         sasldn->bv_val = NULL;
 570         sasldn->bv_len = 0;
 571         cb.sc_private = sasldn;
 572
 573         /* Convert the SASL name into a minimal URI */
 574         if( !slap_sasl_regexp( saslname, &regout, opx->o_tmpmemctx ) ) {
 575                 goto FINISHED;
 576         }
 577
 578         rc = slap_parseURI( opx, &regout, &op.o_req_ndn, &op.oq_search.rs_scope, &op.oq_search.rs_filter );
 579         if( regout.bv_val ) sl_free( regout.bv_val, opx->o_tmpmemctx );
 580         if( rc != LDAP_SUCCESS ) {
 581                 goto FINISHED;
 582         }
 583
 584         /* Must do an internal search */
 585         op.o_bd = select_backend( &op.o_req_ndn, 0, 1 );
 586
 587         /* Massive shortcut: search scope == base */
 588         if( op.oq_search.rs_scope == LDAP_SCOPE_BASE ) {
 589                 *sasldn = op.o_req_ndn;
 590                 op.o_req_ndn.bv_len = 0;
 591                 op.o_req_ndn.bv_val = NULL;
 592                 goto FINISHED;
 593         }
 594
 595 #ifdef NEW_LOGGING
 596         LDAP_LOG( TRANSPORT, DETAIL1,
 597                 "slap_sasl2dn: performing internal search (base=%s, scope=%d)\n",
 598                 op.o_req_ndn.bv_val, op.oq_search.rs_scope, 0 );
 599 #else
 600         Debug( LDAP_DEBUG_TRACE,
 601                 "slap_sasl2dn: performing internal search (base=%s, scope=%d)\n",
 602                 op.o_req_ndn.bv_val, op.oq_search.rs_scope, 0 );
 603 #endif
 604
 605         if(( op.o_bd == NULL ) || ( op.o_bd->be_search == NULL)) {
 606                 goto FINISHED;
 607         }
 608
 609         op.o_conn = opx->o_conn;
 610         op.o_connid = opx->o_connid;
 611         op.o_tag = LDAP_REQ_SEARCH;
 612         op.o_protocol = LDAP_VERSION3;
 613         op.o_ndn = opx->o_conn->c_ndn;
 614         op.o_callback = &cb;
 615         op.o_time = slap_get_time();
 616         op.o_do_not_cache = 1;
 617         op.o_is_auth_check = 1;
 618         op.o_threadctx = opx->o_threadctx;
 619         op.o_tmpmemctx = opx->o_tmpmemctx;
 620         op.o_tmpmfuncs = opx->o_tmpmfuncs;
 621         op.oq_search.rs_deref = LDAP_DEREF_NEVER;
 622         op.oq_search.rs_slimit = 1;
 623         op.oq_search.rs_attrsonly = 1;
 624
 625         op.o_bd->be_search( &op, &rs );
 626
 627 FINISHED:
 628         if( sasldn->bv_len ) {
 629                 opx->o_conn->c_authz_backend = op.o_bd;
 630         }
 631         if( op.o_req_ndn.bv_len ) ch_free( op.o_req_ndn.bv_val );
 632         if( op.oq_search.rs_filter ) filter_free_x( opx, op.oq_search.rs_filter );
 633
 634 #ifdef NEW_LOGGING
 635         LDAP_LOG( TRANSPORT, ENTRY,
 636                 "slap_sasl2dn: Converted SASL name to %s\n",
 637                 sasldn->bv_len ? sasldn->bv_val : "<nothing>", 0, 0 );
 638 #else
 639         Debug( LDAP_DEBUG_TRACE, "<==slap_sasl2dn: Converted SASL name to %s\n",
 640                 sasldn->bv_len ? sasldn->bv_val : "<nothing>", 0, 0 );
 641 #endif
 642
 643         return;
 644 }
 645
 646
 647 /* Check if a bind can SASL authorize to another identity.
 648  * The DNs should not have the dn: prefix
 649  */
 650
 651 int slap_sasl_authorized( Operation *op,
 652         struct berval *authcDN, struct berval *authzDN )
 653 {
 654         int rc = LDAP_INAPPROPRIATE_AUTH;
 655
 656         /* User binding as anonymous */
 657         if ( authzDN == NULL ) {
 658                 rc = LDAP_SUCCESS;
 659                 goto DONE;
 660         }
 661
 662 #ifdef NEW_LOGGING
 663         LDAP_LOG( TRANSPORT, ENTRY,
 664                 "slap_sasl_authorized: can %s become %s?\n",
 665                 authcDN->bv_val, authzDN->bv_val, 0 );
 666 #else
 667         Debug( LDAP_DEBUG_TRACE,
 668            "==>slap_sasl_authorized: can %s become %s?\n",
 669                 authcDN->bv_val, authzDN->bv_val, 0 );
 670 #endif
 671
 672         /* If person is authorizing to self, succeed */
 673         if ( dn_match( authcDN, authzDN ) ) {
 674                 rc = LDAP_SUCCESS;
 675                 goto DONE;
 676         }
 677
 678         /* Allow the manager to authorize as any DN. */
 679         if( op->o_conn->c_authz_backend && be_isroot( op->o_conn->c_authz_backend, authcDN )) {
 680                 rc = LDAP_SUCCESS;
 681                 goto DONE;
 682         }
 683
 684         /* Check source rules */
 685         if( authz_policy & SASL_AUTHZ_TO ) {
 686                 rc = slap_sasl_check_authz( op, authcDN, authzDN,
 687                         slap_schema.si_ad_saslAuthzTo, authcDN );
 688                 if( rc == LDAP_SUCCESS ) {
 689                         goto DONE;
 690                 }
 691         }
 692
 693         /* Check destination rules */
 694         if( authz_policy & SASL_AUTHZ_FROM ) {
 695                 rc = slap_sasl_check_authz( op, authzDN, authcDN,
 696                         slap_schema.si_ad_saslAuthzFrom, authcDN );
 697                 if( rc == LDAP_SUCCESS ) {
 698                         goto DONE;
 699                 }
 700         }
 701
 702         rc = LDAP_INAPPROPRIATE_AUTH;
 703
 704 DONE:
 705
 706 #ifdef NEW_LOGGING
 707         LDAP_LOG( TRANSPORT, RESULTS, "slap_sasl_authorized: return %d\n", rc,0,0 );
 708 #else
 709         Debug( LDAP_DEBUG_TRACE,
 710                 "<== slap_sasl_authorized: return %d\n", rc, 0, 0 );
 711 #endif
 712
 713         return( rc );
 714 }