git.sur5r.net Git - openldap/blob - servers/ldapd/bind.c

   1 /*
   2  * Copyright (c) 1990 Regents of the University of Michigan.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms are permitted
   6  * provided that this notice is preserved and that due credit is given
   7  * to the University of Michigan at Ann Arbor. The name of the University
   8  * may not be used to endorse or promote products derived from this
   9  * software without specific prior written permission. This software
  10  * is provided ``as is'' without express or implied warranty.
  11  */
  12
  13 #include "portable.h"
  14
  15 #include <stdio.h>
  16
  17 #include <ac/socket.h>
  18 #include <ac/string.h>          /* get SAFEMEMCPY */
  19
  20 #include <quipu/commonarg.h>
  21 #include <quipu/attrvalue.h>
  22 #include <quipu/ds_error.h>
  23 #include <quipu/bind.h>
  24 #include <quipu/compare.h>
  25
  26 #include "lber.h"
  27 #include "ldap.h"
  28 #include "common.h"
  29
  30 #ifdef LDAP_COMPAT20
  31 #define BINDTAG (ldap_compat == 20 ? OLD_LDAP_RES_BIND : LDAP_RES_BIND)
  32 #else
  33 #define BINDTAG LDAP_RES_BIND
  34 #endif
  35
  36 /*
  37  * do_bind - perform an X.500 bind operation.  Since we always respond
  38  * to the request in here, always return 0 to signify the incoming message
  39  * can be discarded.
  40  */
  41
  42 int
  43 do_bind(
  44     Sockbuf     *clientsb,
  45     struct msg  *m,
  46     BerElement  *ber,
  47     int         *bound
  48 )
  49 {
  50         int             err;
  51         unsigned long   method;
  52         unsigned long   len;
  53         char            *dn, *pw;
  54         char            *matched;
  55         struct PSAPaddr *addr;
  56
  57         Debug( LDAP_DEBUG_TRACE, "do_bind\n", 0, 0, 0 );
  58
  59         /*
  60          * Parse the bind request.  It looks like this:
  61          *      BindRequest ::= SEQUENCE {
  62          *              version         INTEGER,                 -- version
  63          *              name            DistinguishedName,       -- dn
  64          *              authentication  CHOICE {
  65          *                      simple          [0] OCTET STRING -- passwd
  66          *                      krbv42ldap      [1] OCTET STRING
  67          *                      krbv42dsa       [1] OCTET STRING
  68          *              }
  69          *      }
  70          */
  71
  72         if ( ber_scanf( ber, "{ia", &version, &dn ) == LBER_ERROR ) {
  73                 Debug( LDAP_DEBUG_ANY, "ber_scanf failed\n", 0, 0, 0 );
  74                 send_ldap_msgresult( clientsb, BINDTAG, m,
  75                     LDAP_PROTOCOL_ERROR, NULL, "Decoding error" );
  76                 return( 0 );
  77         }
  78 #ifdef LDAP_COMPAT30
  79         if ( ldap_compat == 30 )
  80                 method = ber_skip_tag( ber, &len );
  81         else
  82 #endif
  83                 method = ber_peek_tag( ber, &len );
  84
  85         if ( ber_scanf( ber, "la}", &len, &pw ) == LBER_ERROR ) {
  86                 Debug( LDAP_DEBUG_ANY, "ber_scanf2 failed\n", 0, 0, 0 );
  87                 send_ldap_msgresult( clientsb, BINDTAG, m,
  88                     LDAP_PROTOCOL_ERROR, NULL, "Decoding error" );
  89                 return( 0 );
  90         }
  91
  92         if ( version != LDAP_VERSION1 && version != LDAP_VERSION2 ) {
  93                 Debug( LDAP_DEBUG_ANY, "unknown version %d\n", version, 0, 0 );
  94                 send_ldap_msgresult( clientsb, BINDTAG, m,
  95                     LDAP_PROTOCOL_ERROR, NULL, "Version not supported" );
  96                 return( 0 );
  97         }
  98
  99         Debug( LDAP_DEBUG_ARGS, "do_bind: version %d dn (%s) method %lu\n",
 100             version, dn, method );
 101
 102         if ( m->m_conn->c_paddr == NULLPA ) {
 103                 char    buf[256];
 104
 105                 sprintf( buf, "Bad DSA address (%s)", dsa_address ?
 106                     dsa_address : "NULL" );
 107                 send_ldap_msgresult( clientsb, BINDTAG, m,
 108                     LDAP_OPERATIONS_ERROR, NULL, buf );
 109                 return( 0 );
 110         }
 111
 112         if ( m->m_conn->c_dn )
 113                 free( m->m_conn->c_dn );
 114         if ( m->m_conn->c_cred )
 115                 free( m->m_conn->c_cred );
 116         m->m_conn->c_dn = dn;
 117         m->m_conn->c_cred = pw;
 118         m->m_conn->c_credlen = len;
 119         m->m_conn->c_method = method;
 120
 121         err = do_bind_real( m->m_conn, bound, &matched );
 122
 123         send_ldap_msgresult( clientsb, BINDTAG, m, err, matched, "" );
 124
 125         if ( matched != NULL )
 126                 free( matched );
 127
 128         return( 0 );
 129 }
 130
 131 int
 132 do_bind_real(
 133     struct conn *dsaconn,
 134     int         *bound,
 135     char        **matched
 136 )
 137 {
 138         struct ds_bind_arg      ba;
 139         struct ds_bind_arg      br;
 140         struct ds_bind_error    be;
 141         struct DSError          dse;
 142         char                    *dn = dsaconn->c_dn;
 143         int                     err;
 144 #ifdef HAVE_KERBEROS
 145         u_long                  nonce;
 146 #endif
 147         Debug( LDAP_DEBUG_TRACE, "do_bind_real\n", 0, 0, 0 );
 148
 149         *matched = NULL;
 150         if ( (ba.dba_dn = ldap_str2dn( dn )) == NULLDN && *dn != '\0' ) {
 151                 Debug( LDAP_DEBUG_ANY, "ldap_str2dn (%s) failed\n", dn, 0, 0 );
 152                 return( LDAP_INVALID_DN_SYNTAX );
 153         }
 154
 155         switch ( dsaconn->c_method ) {
 156 #ifdef LDAP_COMPAT20
 157         case OLD_LDAP_AUTH_SIMPLE:
 158 #endif
 159 #ifdef LDAP_COMPAT30
 160         case LDAP_AUTH_SIMPLE_30:
 161 #endif
 162         case LDAP_AUTH_SIMPLE:  /* x.500 simple authentication */
 163                 if ( dsaconn->c_credlen > DBA_MAX_PASSWD_LEN ) {
 164                         Debug( LDAP_DEBUG_ANY, "Password too long\n", 0, 0, 0 );
 165                         return( LDAP_INAPPROPRIATE_AUTH );
 166                 }
 167                 if (( ba.dba_passwd_len = dsaconn->c_credlen ) > 0 ) {
 168                         SAFEMEMCPY( ba.dba_passwd, dsaconn->c_cred,
 169                             ba.dba_passwd_len );
 170                         ba.dba_auth_type = DBA_AUTH_SIMPLE;
 171                 } else {
 172                         ba.dba_auth_type = DBA_AUTH_NONE;
 173                 }
 174                 ba.dba_version = DBA_VERSION_V1988;
 175                 break;
 176
 177 #ifdef HAVE_KERBEROS
 178 #ifdef LDAP_COMPAT20
 179         case OLD_LDAP_AUTH_KRBV4:
 180 #endif
 181 #ifdef LDAP_COMPAT30
 182         case LDAP_AUTH_KRBV41_30:
 183 #endif
 184         case LDAP_AUTH_KRBV41:  /* kerberos authentication to ldap server */
 185                 return( kerberosv4_ldap_auth( dsaconn->c_cred,
 186                     dsaconn->c_credlen ) );
 187                 break;
 188
 189 #ifdef LDAP_COMPAT20
 190         case OLD_LDAP_AUTH_KRBV42:
 191 #endif
 192 #ifdef LDAP_COMPAT30
 193         case LDAP_AUTH_KRBV42_30:
 194 #endif
 195         case LDAP_AUTH_KRBV42:  /* kerberos authentication to x500 dsa */
 196                 if ( (err = kerberosv4_bindarg( &ba, ba.dba_dn, dsaconn->c_cred,
 197                     dsaconn->c_credlen, &nonce )) != 0 )
 198                         return( err );
 199                 break;
 200 #endif
 201
 202         default:
 203                 return( LDAP_PROTOCOL_ERROR );
 204                 break;
 205         }
 206
 207         if ( dsaconn->c_ad != -1 )
 208                 dap_unbind( dsaconn->c_ad );
 209
 210         Debug( LDAP_DEBUG_TRACE, "dap_bind to dsa (%s)...\n", paddr2str(
 211             dsaconn->c_paddr, NULLNA ), 0, 0 );
 212
 213         err = dap_bind( &dsaconn->c_ad, &ba, &be, &br, dsaconn->c_paddr );
 214
 215         if ( err != DS_OK && ba.dba_dn != NULLDN && ba.dba_auth_type
 216             == DBA_AUTH_NONE && be.dbe_type == DBE_TYPE_SECURITY ) {
 217                 /* if doing a NULL bind, retry with a NULL dn */
 218                 Debug( LDAP_DEBUG_TRACE, "retring NULL dap_bind\n", 0, 0, 0 );
 219                 dn_free( ba.dba_dn );
 220                 ba.dba_dn = NULLDN;
 221                 err = dap_bind( &dsaconn->c_ad, &ba, &be, &br,
 222                     dsaconn->c_paddr );
 223         }
 224
 225         if ( err != DS_OK ) {
 226                 if ( ba.dba_dn != NULLDN )
 227                         dn_free( ba.dba_dn );
 228
 229                 if ( be.dbe_type == DBE_TYPE_SERVICE ) {
 230                         dse.dse_type = DSE_SERVICEERROR;
 231                         dse.ERR_SERVICE.DSE_sv_problem = be.dbe_value;
 232                 } else if ( be.dbe_type == DBE_TYPE_SECURITY ) {
 233                         dse.dse_type = DSE_SECURITYERROR;
 234                         dse.ERR_SECURITY.DSE_sc_problem = be.dbe_value;
 235                 } else {
 236                         dse.dse_type = DSE_REMOTEERROR;
 237                 }
 238                 err = x500err2ldaperr( &dse, matched );
 239
 240 #ifdef LDAP_DEBUG
 241                 if ( ldap_debug )
 242                         print_error( &dse );    /* prints and then frees */
 243                 else
 244 #endif
 245                         ds_error_free( &dse );
 246
 247                 dsaconn->c_ad = -1;
 248
 249                 return( err );
 250         }
 251         bind_arg_free( &br );
 252
 253         Debug( LDAP_DEBUG_TRACE, "dap_bind successful\n", 0, 0, 0 );
 254
 255 #ifdef HAVE_KERBEROS
 256 /* XXX why doesn't this work??
 257         if ( dsaconn->c_method == LDAP_AUTH_KRBV42 &&
 258             kerberos_check_mutual( &br, nonce ) != 0 ) {
 259                 Debug( LDAP_DEBUG_ANY, "Mutual authentication failed\n", 0, 0,
 260                     0 );
 261                 return( LDAP_INVALID_CREDENTIALS );
 262         }
 263 */
 264 #endif
 265
 266         *bound = 1;
 267
 268         return( LDAP_SUCCESS );
 269 }