Diff for /servers/slapd/overlays/ppolicy.c between versions 1.31 and 1.31.2.21

version 1.31, 2004/12/05 01:00:19 version 1.31.2.21, 2006/05/13 03:55:00
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/ppolicy.c,v 1.30 2004/12/01 15:01:04 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/ppolicy.c,v 1.31.2.20 2006/05/09 17:43:12 kurt Exp $ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 2004 The OpenLDAP Foundation.   * Copyright 2004-2006 The OpenLDAP Foundation.
  * Portions Copyright 2004 Howard Chu, Symas Corporation.   * Portions Copyright 2004-2005 Howard Chu, Symas Corporation.
  * Portions Copyright 2004 Hewlett-Packard Company.   * Portions Copyright 2004 Hewlett-Packard Company.
  * All rights reserved.   * All rights reserved.
  *   *
Line 23 Line 23
 #include "portable.h"  #include "portable.h"
   
 /* This file implements "Password Policy for LDAP Directories",  /* This file implements "Password Policy for LDAP Directories",
  * based on draft behera-ldap-password-policy-07   * based on draft behera-ldap-password-policy-09
  */   */
   
 #ifdef SLAPD_OVER_PPOLICY  #ifdef SLAPD_OVER_PPOLICY
   
 #if SLAPD_OVER_PPOLICY == SLAPD_MOD_DYNAMIC  
 #define SLAPD_IMPORT  
 #endif  
   
 #include <ldap.h>  #include <ldap.h>
 #include "lutil.h"  #include "lutil.h"
 #include "slap.h"  #include "slap.h"
 #if SLAPD_MODULES  #if SLAPD_MODULES
   #define LIBLTDL_DLL_IMPORT      /* Win32: don't re-export libltdl's symbols */
 #include <ltdl.h>  #include <ltdl.h>
 #endif  #endif
 #include <ac/errno.h>  #include <ac/errno.h>
Line 58  typedef struct pp_info { Line 55  typedef struct pp_info {
  * used by all instances   * used by all instances
  */   */
 typedef struct pw_conn {  typedef struct pw_conn {
         int restrict;           /* TRUE if connection is restricted */          struct berval dn;       /* DN of restricted user */
 } pw_conn;  } pw_conn;
   
 static pw_conn *pwcons;  static pw_conn *pwcons;
Line 74  typedef struct pass_policy { Line 71  typedef struct pass_policy {
         int pwdMinLength; /* minimum number of chars in password */          int pwdMinLength; /* minimum number of chars in password */
         int pwdExpireWarning; /* number of seconds that warning controls are          int pwdExpireWarning; /* number of seconds that warning controls are
                                                         sent before a password expires */                                                          sent before a password expires */
         int pwdGraceLoginLimit; /* number of times you can log in with an          int pwdGraceAuthNLimit; /* number of times you can log in with an
                                                         expired password */                                                          expired password */
         int pwdLockout; /* 0 = do not lockout passwords, 1 = lock them out */          int pwdLockout; /* 0 = do not lockout passwords, 1 = lock them out */
         int pwdLockoutDuration; /* time in seconds a password is locked out for */          int pwdLockoutDuration; /* time in seconds a password is locked out for */
Line 101  typedef struct pw_hist { Line 98  typedef struct pw_hist {
   
 /* Operational attributes */  /* Operational attributes */
 static AttributeDescription *ad_pwdChangedTime, *ad_pwdAccountLockedTime,  static AttributeDescription *ad_pwdChangedTime, *ad_pwdAccountLockedTime,
         *ad_pwdExpirationWarned, *ad_pwdFailureTime, *ad_pwdHistory,          *ad_pwdFailureTime, *ad_pwdHistory, *ad_pwdGraceUseTime, *ad_pwdReset,
         *ad_pwdGraceUseTime, *ad_pwdReset, *ad_pwdPolicySubentry;          *ad_pwdPolicySubentry;
   
 static struct schema_info {  static struct schema_info {
         char *def;          char *def;
Line 114  static struct schema_info { Line 111  static struct schema_info {
                 "EQUALITY generalizedTimeMatch "                  "EQUALITY generalizedTimeMatch "
                 "ORDERING generalizedTimeOrderingMatch "                  "ORDERING generalizedTimeOrderingMatch "
                 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 "                  "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 "
                 "SINGLE-VALUE USAGE directoryOperation )",                  "SINGLE-VALUE NO-USER-MODIFICATION USAGE directoryOperation )",
                 &ad_pwdChangedTime },                  &ad_pwdChangedTime },
         {       "( 1.3.6.1.4.1.42.2.27.8.1.17 "          {       "( 1.3.6.1.4.1.42.2.27.8.1.17 "
                 "NAME ( 'pwdAccountLockedTime' ) "                  "NAME ( 'pwdAccountLockedTime' ) "
Line 122  static struct schema_info { Line 119  static struct schema_info {
                 "EQUALITY generalizedTimeMatch "                  "EQUALITY generalizedTimeMatch "
                 "ORDERING generalizedTimeOrderingMatch "                  "ORDERING generalizedTimeOrderingMatch "
                 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 "                  "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 "
                 "SINGLE-VALUE USAGE directoryOperation )",                  "SINGLE-VALUE "
   #if 0
                   /* Not until MANAGEDIT control is released */
                   "NO-USER-MODIFICATION "
   #endif
                   "USAGE directoryOperation )",
                 &ad_pwdAccountLockedTime },                  &ad_pwdAccountLockedTime },
         {       "( 1.3.6.1.4.1.42.2.27.8.1.18 "  
                 "NAME ( 'pwdExpirationWarned' ) "  
                 "DESC 'The time the user was first warned about the coming expiration of the password' "  
                 "EQUALITY generalizedTimeMatch "  
                 "ORDERING generalizedTimeOrderingMatch "  
                 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 "  
                 "SINGLE-VALUE USAGE directoryOperation )",  
                 &ad_pwdExpirationWarned },  
         {       "( 1.3.6.1.4.1.42.2.27.8.1.19 "          {       "( 1.3.6.1.4.1.42.2.27.8.1.19 "
                 "NAME ( 'pwdFailureTime' ) "                  "NAME ( 'pwdFailureTime' ) "
                 "DESC 'The timestamps of the last consecutive authentication failures' "                  "DESC 'The timestamps of the last consecutive authentication failures' "
                 "EQUALITY generalizedTimeMatch "                  "EQUALITY generalizedTimeMatch "
                 "ORDERING generalizedTimeOrderingMatch "                  "ORDERING generalizedTimeOrderingMatch "
                 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 "                  "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 "
                 "USAGE directoryOperation )",                  "NO-USER-MODIFICATION USAGE directoryOperation )",
                 &ad_pwdFailureTime },                  &ad_pwdFailureTime },
         {       "( 1.3.6.1.4.1.42.2.27.8.1.20 "          {       "( 1.3.6.1.4.1.42.2.27.8.1.20 "
                 "NAME ( 'pwdHistory' ) "                  "NAME ( 'pwdHistory' ) "
                 "DESC 'The history of users passwords' "                  "DESC 'The history of users passwords' "
                 "EQUALITY octetStringMatch "                  "EQUALITY octetStringMatch "
                 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 "                  "SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 "
                 "USAGE directoryOperation )",                  "NO-USER-MODIFICATION USAGE directoryOperation )",
                 &ad_pwdHistory },                  &ad_pwdHistory },
         {       "( 1.3.6.1.4.1.42.2.27.8.1.21 "          {       "( 1.3.6.1.4.1.42.2.27.8.1.21 "
                 "NAME ( 'pwdGraceUseTime' ) "                  "NAME ( 'pwdGraceUseTime' ) "
                 "DESC 'The timestamps of the grace login once the password has expired' "                  "DESC 'The timestamps of the grace login once the password has expired' "
                 "EQUALITY generalizedTimeMatch "                  "EQUALITY generalizedTimeMatch "
                 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 "                  "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 "
                 "USAGE directoryOperation )",                  "NO-USER-MODIFICATION USAGE directoryOperation )",
                 &ad_pwdGraceUseTime },                   &ad_pwdGraceUseTime }, 
         {       "( 1.3.6.1.4.1.42.2.27.8.1.22 "          {       "( 1.3.6.1.4.1.42.2.27.8.1.22 "
                 "NAME ( 'pwdReset' ) "                  "NAME ( 'pwdReset' ) "
Line 166  static struct schema_info { Line 160  static struct schema_info {
                 "DESC 'The pwdPolicy subentry in effect for this object' "                  "DESC 'The pwdPolicy subentry in effect for this object' "
                 "EQUALITY distinguishedNameMatch "                  "EQUALITY distinguishedNameMatch "
                 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 "                  "SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 "
                 "SINGLE-VALUE USAGE directoryOperation )",                  "SINGLE-VALUE "
   #if 0
                   /* Not until MANAGEDIT control is released */
                   "NO-USER-MODIFICATION "
   #endif
                   "USAGE directoryOperation )",
                 &ad_pwdPolicySubentry },                  &ad_pwdPolicySubentry },
         { NULL, NULL }          { NULL, NULL }
 };  };
Line 174  static struct schema_info { Line 173  static struct schema_info {
 /* User attributes */  /* User attributes */
 static AttributeDescription *ad_pwdMinAge, *ad_pwdMaxAge, *ad_pwdInHistory,  static AttributeDescription *ad_pwdMinAge, *ad_pwdMaxAge, *ad_pwdInHistory,
         *ad_pwdCheckQuality, *ad_pwdMinLength, *ad_pwdMaxFailure,           *ad_pwdCheckQuality, *ad_pwdMinLength, *ad_pwdMaxFailure, 
         *ad_pwdGraceLoginLimit, *ad_pwdExpireWarning, *ad_pwdLockoutDuration,          *ad_pwdGraceAuthNLimit, *ad_pwdExpireWarning, *ad_pwdLockoutDuration,
         *ad_pwdFailureCountInterval, *ad_pwdCheckModule, *ad_pwdLockout,          *ad_pwdFailureCountInterval, *ad_pwdCheckModule, *ad_pwdLockout,
         *ad_pwdMustChange, *ad_pwdAllowUserChange, *ad_pwdSafeModify,          *ad_pwdMustChange, *ad_pwdAllowUserChange, *ad_pwdSafeModify,
         *ad_pwdAttribute;          *ad_pwdAttribute;
Line 189  static struct schema_info pwd_UsSchema[] Line 188  static struct schema_info pwd_UsSchema[]
         TAB(pwdCheckQuality),          TAB(pwdCheckQuality),
         TAB(pwdMinLength),          TAB(pwdMinLength),
         TAB(pwdMaxFailure),          TAB(pwdMaxFailure),
         TAB(pwdGraceLoginLimit),          TAB(pwdGraceAuthNLimit),
         TAB(pwdExpireWarning),          TAB(pwdExpireWarning),
         TAB(pwdLockout),          TAB(pwdLockout),
         TAB(pwdLockoutDuration),          TAB(pwdLockoutDuration),
Line 222  account_locked( Operation *op, Entry *e, Line 221  account_locked( Operation *op, Entry *e,
                 PassPolicy *pp, Modifications **mod )                   PassPolicy *pp, Modifications **mod ) 
 {  {
         Attribute       *la;          Attribute       *la;
         int rc;  
         Entry *de;  
   
         assert(mod);          assert(mod != NULL);
   
         if ( (la = attr_find( e->e_attrs, ad_pwdAccountLockedTime )) != NULL ) {          if ( (la = attr_find( e->e_attrs, ad_pwdAccountLockedTime )) != NULL ) {
                 BerVarray vals = la->a_nvals;                  BerVarray vals = la->a_nvals;
Line 236  account_locked( Operation *op, Entry *e, Line 233  account_locked( Operation *op, Entry *e,
                  */                   */
                 if (vals[0].bv_val != NULL) {                  if (vals[0].bv_val != NULL) {
                         time_t then, now;                          time_t then, now;
                         struct berval bv;  
                         Modifications *m;                          Modifications *m;
   
                           if (!pp->pwdLockoutDuration)
                                   return 1;
   
                         if ((then = parse_time( vals[0].bv_val )) == (time_t)0)                          if ((then = parse_time( vals[0].bv_val )) == (time_t)0)
                                 return 1;                                  return 1;
   
Line 249  account_locked( Operation *op, Entry *e, Line 248  account_locked( Operation *op, Entry *e,
   
                         m = ch_calloc( sizeof(Modifications), 1 );                          m = ch_calloc( sizeof(Modifications), 1 );
                         m->sml_op = LDAP_MOD_DELETE;                          m->sml_op = LDAP_MOD_DELETE;
                           m->sml_flags = 0;
                         m->sml_type = ad_pwdAccountLockedTime->ad_cname;                          m->sml_type = ad_pwdAccountLockedTime->ad_cname;
                         m->sml_desc = ad_pwdAccountLockedTime;                          m->sml_desc = ad_pwdAccountLockedTime;
                         m->sml_next = *mod;                          m->sml_next = *mod;
Line 259  account_locked( Operation *op, Entry *e, Line 259  account_locked( Operation *op, Entry *e,
         return 0;          return 0;
 }  }
   
 #define PPOLICY_WARNING 0xa0L  /* IMPLICIT TAGS, all context-specific */
 #define PPOLICY_ERROR 0xa1L  #define PPOLICY_WARNING 0xa0L   /* constructed + 0 */
   #define PPOLICY_ERROR 0x81L     /* primitive + 1 */
     
 #define PPOLICY_EXPIRE 0xa0L  #define PPOLICY_EXPIRE 0x80L    /* primitive + 0 */
 #define PPOLICY_GRACE  0xa1L  #define PPOLICY_GRACE  0x81L    /* primitive + 1 */
   
 static LDAPControl *  static LDAPControl *
 create_passcontrol( int exptime, int grace, LDAPPasswordPolicyError err )  create_passcontrol( int exptime, int grace, LDAPPasswordPolicyError err )
Line 317  ppolicy_get( Operation *op, Entry *e, Pa Line 318  ppolicy_get( Operation *op, Entry *e, Pa
         pp_info *pi = on->on_bi.bi_private;          pp_info *pi = on->on_bi.bi_private;
         Attribute *a;          Attribute *a;
         BerVarray vals;          BerVarray vals;
         int i, rc, nent;          int rc;
         Entry *pe = NULL;          Entry *pe = NULL;
         AttributeDescription *oca = slap_schema.si_ad_objectClass;  #if 0
         const char *text;          const char *text;
         AttributeDescription *ad;  #endif
         struct berval bv;  
   
         memset( pp, 0, sizeof(PassPolicy) );          memset( pp, 0, sizeof(PassPolicy) );
   
Line 358  ppolicy_get( Operation *op, Entry *e, Pa Line 358  ppolicy_get( Operation *op, Entry *e, Pa
         pp->ad = slap_schema.si_ad_userPassword;          pp->ad = slap_schema.si_ad_userPassword;
 #endif  #endif
   
         if ((a = attr_find( pe->e_attrs, ad_pwdMinAge )))          if ( ( a = attr_find( pe->e_attrs, ad_pwdMinAge ) )
                 pp->pwdMinAge = atoi(a->a_vals[0].bv_val );                          && lutil_atoi( &pp->pwdMinAge, a->a_vals[0].bv_val ) != 0 )
         if ((a = attr_find( pe->e_attrs, ad_pwdMaxAge )))                  goto defaultpol;
                 pp->pwdMaxAge = atoi(a->a_vals[0].bv_val );          if ( ( a = attr_find( pe->e_attrs, ad_pwdMaxAge ) )
         if ((a = attr_find( pe->e_attrs, ad_pwdInHistory )))                          && lutil_atoi( &pp->pwdMaxAge, a->a_vals[0].bv_val ) != 0 )
                 pp->pwdInHistory = atoi(a->a_vals[0].bv_val );                  goto defaultpol;
         if ((a = attr_find( pe->e_attrs, ad_pwdCheckQuality )))          if ( ( a = attr_find( pe->e_attrs, ad_pwdInHistory ) )
                 pp->pwdCheckQuality = atoi(a->a_vals[0].bv_val );                          && lutil_atoi( &pp->pwdInHistory, a->a_vals[0].bv_val ) != 0 )
         if ((a = attr_find( pe->e_attrs, ad_pwdMinLength )))                  goto defaultpol;
                 pp->pwdMinLength = atoi(a->a_vals[0].bv_val );          if ( ( a = attr_find( pe->e_attrs, ad_pwdCheckQuality ) )
         if ((a = attr_find( pe->e_attrs, ad_pwdMaxFailure )))                          && lutil_atoi( &pp->pwdCheckQuality, a->a_vals[0].bv_val ) != 0 )
                 pp->pwdMaxFailure = atoi(a->a_vals[0].bv_val );                  goto defaultpol;
         if ((a = attr_find( pe->e_attrs, ad_pwdGraceLoginLimit )))          if ( ( a = attr_find( pe->e_attrs, ad_pwdMinLength ) )
                 pp->pwdGraceLoginLimit = atoi(a->a_vals[0].bv_val );                          && lutil_atoi( &pp->pwdMinLength, a->a_vals[0].bv_val ) != 0 )
         if ((a = attr_find( pe->e_attrs, ad_pwdExpireWarning )))                  goto defaultpol;
                 pp->pwdExpireWarning = atoi(a->a_vals[0].bv_val );          if ( ( a = attr_find( pe->e_attrs, ad_pwdMaxFailure ) )
         if ((a = attr_find( pe->e_attrs, ad_pwdFailureCountInterval )))                          && lutil_atoi( &pp->pwdMaxFailure, a->a_vals[0].bv_val ) != 0 )
                 pp->pwdFailureCountInterval = atoi(a->a_vals[0].bv_val );                  goto defaultpol;
         if ((a = attr_find( pe->e_attrs, ad_pwdLockoutDuration )))          if ( ( a = attr_find( pe->e_attrs, ad_pwdGraceAuthNLimit ) )
                 pp->pwdLockoutDuration = atoi(a->a_vals[0].bv_val );                          && lutil_atoi( &pp->pwdGraceAuthNLimit, a->a_vals[0].bv_val ) != 0 )
                   goto defaultpol;
         if ((a = attr_find( pe->e_attrs, ad_pwdCheckModule ))) {          if ( ( a = attr_find( pe->e_attrs, ad_pwdExpireWarning ) )
                 strncpy(pp->pwdCheckModule, a->a_vals[0].bv_val,                          && lutil_atoi( &pp->pwdExpireWarning, a->a_vals[0].bv_val ) != 0 )
                         sizeof(pp->pwdCheckModule));                  goto defaultpol;
           if ( ( a = attr_find( pe->e_attrs, ad_pwdFailureCountInterval ) )
                           && lutil_atoi( &pp->pwdFailureCountInterval, a->a_vals[0].bv_val ) != 0 )
                   goto defaultpol;
           if ( ( a = attr_find( pe->e_attrs, ad_pwdLockoutDuration ) )
                           && lutil_atoi( &pp->pwdLockoutDuration, a->a_vals[0].bv_val ) != 0 )
                   goto defaultpol;
   
           if ( ( a = attr_find( pe->e_attrs, ad_pwdCheckModule ) ) ) {
                   strncpy( pp->pwdCheckModule, a->a_vals[0].bv_val,
                           sizeof(pp->pwdCheckModule) );
                 pp->pwdCheckModule[sizeof(pp->pwdCheckModule)-1] = '\0';                  pp->pwdCheckModule[sizeof(pp->pwdCheckModule)-1] = '\0';
         }          }
   
Line 423  password_scheme( struct berval *cred, st Line 433  password_scheme( struct berval *cred, st
   
         for(e = 1; cred->bv_val[e] && cred->bv_val[e] != '}'; e++);          for(e = 1; cred->bv_val[e] && cred->bv_val[e] != '}'; e++);
         if (cred->bv_val[e]) {          if (cred->bv_val[e]) {
                 char *sc = ch_calloc( sizeof(char), e + 2);                  int rc;
                 sc[e + 1] = '\0'; /* terminate string */                  rc = lutil_passwd_scheme( cred->bv_val );
                 strncpy( sc, cred->bv_val, e + 1);                  if (rc && sch) {
                 e = lutil_passwd_scheme( sc );  
                 free( sc );  
                 if (e && sch) {  
                         sch->bv_val = cred->bv_val;                          sch->bv_val = cred->bv_val;
                         sch->bv_len = e;                          sch->bv_len = e;
                         return LDAP_SUCCESS;                          return LDAP_SUCCESS;
Line 442  check_password_quality( struct berval *c Line 449  check_password_quality( struct berval *c
 {  {
         int rc = LDAP_SUCCESS, ok = LDAP_SUCCESS;          int rc = LDAP_SUCCESS, ok = LDAP_SUCCESS;
         char *ptr = cred->bv_val;          char *ptr = cred->bv_val;
         char *modpath;  
         struct berval sch;          struct berval sch;
   
         assert( cred != NULL );          assert( cred != NULL );
Line 635  make_pwd_history_value( char *timebuf, s Line 641  make_pwd_history_value( char *timebuf, s
         int nlen;          int nlen;
   
         snprintf( str, MAX_PWD_HISTORY_SZ,          snprintf( str, MAX_PWD_HISTORY_SZ,
                   "%s#%s#%d#", timebuf,                    "%s#%s#%lu#", timebuf,
                   pa->a_desc->ad_type->sat_syntax->ssyn_oid,                    pa->a_desc->ad_type->sat_syntax->ssyn_oid,
                   pa->a_nvals[0].bv_len );                    (unsigned long) pa->a_nvals[0].bv_len );
         str[MAX_PWD_HISTORY_SZ-1] = 0;          str[MAX_PWD_HISTORY_SZ-1] = 0;
         nlen = strlen(str);          nlen = strlen(str);
   
Line 691  ppolicy_bind_resp( Operation *op, SlapRe Line 697  ppolicy_bind_resp( Operation *op, SlapRe
         slap_overinst *on = ppb->on;          slap_overinst *on = ppb->on;
         Modifications *mod = ppb->mod, *m;          Modifications *mod = ppb->mod, *m;
         int pwExpired = 0;          int pwExpired = 0;
         int ngut = -1, warn = -1, age, rc, i;          int ngut = -1, warn = -1, age, rc;
         Attribute *a;          Attribute *a;
         struct tm *tm;          time_t now, pwtime = (time_t)-1;
         time_t now, then, pwtime = (time_t)-1;  
         const char *txt;  
         char nowstr[ LDAP_LUTIL_GENTIME_BUFSIZE ];          char nowstr[ LDAP_LUTIL_GENTIME_BUFSIZE ];
           struct berval timestamp;
         BackendInfo *bi = op->o_bd->bd_info;          BackendInfo *bi = op->o_bd->bd_info;
         Entry *e;          Entry *e;
   
Line 714  ppolicy_bind_resp( Operation *op, SlapRe Line 719  ppolicy_bind_resp( Operation *op, SlapRe
         }          }
   
         now = slap_get_time(); /* stored for later consideration */          now = slap_get_time(); /* stored for later consideration */
         ldap_pvt_thread_mutex_lock( &gmtime_mutex );          timestamp.bv_val = nowstr;
         tm = gmtime(&now);          timestamp.bv_len = sizeof(nowstr);
         lutil_gentime( nowstr, sizeof(nowstr), tm );          slap_timestamp( &now, &timestamp );
         ldap_pvt_thread_mutex_unlock( &gmtime_mutex );  
   
         if ( rs->sr_err == LDAP_INVALID_CREDENTIALS ) {          if ( rs->sr_err == LDAP_INVALID_CREDENTIALS ) {
                 int i = 0, fc = 0;                  int i = 0, fc = 0;
   
                 m = ch_calloc( sizeof(Modifications), 1 );                  m = ch_calloc( sizeof(Modifications), 1 );
                 m->sml_op = LDAP_MOD_ADD;                  m->sml_op = LDAP_MOD_ADD;
                   m->sml_flags = 0;
                 m->sml_type = ad_pwdFailureTime->ad_cname;                  m->sml_type = ad_pwdFailureTime->ad_cname;
                 m->sml_desc = ad_pwdFailureTime;                  m->sml_desc = ad_pwdFailureTime;
                 m->sml_values = ch_calloc( sizeof(struct berval), 2 );                  m->sml_values = ch_calloc( sizeof(struct berval), 2 );
                   m->sml_nvalues = ch_calloc( sizeof(struct berval), 2 );
   
                 ber_str2bv( nowstr, 0, 1, &m->sml_values[0] );                  ber_dupbv( &m->sml_values[0], &timestamp );
                   ber_dupbv( &m->sml_nvalues[0], &timestamp );
                 m->sml_next = mod;                  m->sml_next = mod;
                 mod = m;                  mod = m;
   
Line 770  ppolicy_bind_resp( Operation *op, SlapRe Line 777  ppolicy_bind_resp( Operation *op, SlapRe
                          */                           */
                         m = ch_calloc( sizeof(Modifications), 1 );                          m = ch_calloc( sizeof(Modifications), 1 );
                         m->sml_op = LDAP_MOD_REPLACE;                          m->sml_op = LDAP_MOD_REPLACE;
                           m->sml_flags = 0;
                         m->sml_type = ad_pwdAccountLockedTime->ad_cname;                          m->sml_type = ad_pwdAccountLockedTime->ad_cname;
                         m->sml_desc = ad_pwdAccountLockedTime;                          m->sml_desc = ad_pwdAccountLockedTime;
                         m->sml_values = ch_calloc( sizeof(struct berval), 2 );                          m->sml_values = ch_calloc( sizeof(struct berval), 2 );
                         ber_str2bv( nowstr, 0, 1, &m->sml_values[0] );                          m->sml_nvalues = ch_calloc( sizeof(struct berval), 2 );
                           ber_dupbv( &m->sml_values[0], &timestamp );
                           ber_dupbv( &m->sml_nvalues[0], &timestamp );
                         m->sml_next = mod;                          m->sml_next = mod;
                         mod = m;                          mod = m;
                 }                  }
Line 785  ppolicy_bind_resp( Operation *op, SlapRe Line 795  ppolicy_bind_resp( Operation *op, SlapRe
                 if ( attr_find( e->e_attrs, ad_pwdFailureTime )) {                  if ( attr_find( e->e_attrs, ad_pwdFailureTime )) {
                         m = ch_calloc( sizeof(Modifications), 1 );                          m = ch_calloc( sizeof(Modifications), 1 );
                         m->sml_op = LDAP_MOD_DELETE;                          m->sml_op = LDAP_MOD_DELETE;
                           m->sml_flags = 0;
                         m->sml_type = ad_pwdFailureTime->ad_cname;                          m->sml_type = ad_pwdFailureTime->ad_cname;
                         m->sml_desc = ad_pwdFailureTime;                          m->sml_desc = ad_pwdFailureTime;
                         m->sml_next = mod;                          m->sml_next = mod;
Line 803  ppolicy_bind_resp( Operation *op, SlapRe Line 814  ppolicy_bind_resp( Operation *op, SlapRe
                          * that we are disallowed from doing anything                           * that we are disallowed from doing anything
                          * other than change password.                           * other than change password.
                          */                           */
                         pwcons[op->o_conn->c_conn_idx].restrict = 1;                          ber_dupbv( &pwcons[op->o_conn->c_conn_idx].dn,
                                   &op->o_conn->c_ndn );
   
                         ppb->pErr = PP_changeAfterReset;                          ppb->pErr = PP_changeAfterReset;
   
Line 846  grace: Line 858  grace:
                 if (!pwExpired) goto check_expiring_password;                  if (!pwExpired) goto check_expiring_password;
                                   
                 if ((a = attr_find( e->e_attrs, ad_pwdGraceUseTime )) == NULL)                  if ((a = attr_find( e->e_attrs, ad_pwdGraceUseTime )) == NULL)
                         ngut = ppb->pp.pwdGraceLoginLimit;                          ngut = ppb->pp.pwdGraceAuthNLimit;
                 else {                  else {
                         for(ngut=0; a->a_nvals[ngut].bv_val; ngut++);                          for(ngut=0; a->a_nvals[ngut].bv_val; ngut++);
                         ngut = ppb->pp.pwdGraceLoginLimit - ngut;                          ngut = ppb->pp.pwdGraceAuthNLimit - ngut;
                 }                  }
   
                 /*                  /*
Line 870  grace: Line 882  grace:
                  */                   */
                 m = ch_calloc( sizeof(Modifications), 1 );                  m = ch_calloc( sizeof(Modifications), 1 );
                 m->sml_op = LDAP_MOD_ADD;                  m->sml_op = LDAP_MOD_ADD;
                   m->sml_flags = 0;
                 m->sml_type = ad_pwdGraceUseTime->ad_cname;                  m->sml_type = ad_pwdGraceUseTime->ad_cname;
                 m->sml_desc = ad_pwdGraceUseTime;                  m->sml_desc = ad_pwdGraceUseTime;
                 m->sml_values = ch_calloc( sizeof(struct berval), 2 );                  m->sml_values = ch_calloc( sizeof(struct berval), 2 );
                 ber_str2bv( nowstr, 0, 1, &m->sml_values[0] );                  m->sml_nvalues = ch_calloc( sizeof(struct berval), 2 );
                   ber_dupbv( &m->sml_values[0], &timestamp );
                   ber_dupbv( &m->sml_nvalues[0], &timestamp );
                 m->sml_next = mod;                  m->sml_next = mod;
                 mod = m;                  mod = m;
   
Line 901  check_expiring_password: Line 916  check_expiring_password:
                  */                   */
                 if (ppb->pp.pwdMaxAge - age < ppb->pp.pwdExpireWarning ) {                  if (ppb->pp.pwdMaxAge - age < ppb->pp.pwdExpireWarning ) {
                         /*                          /*
                          * Set the warning value, add expiration warned timestamp to the entry.                           * Set the warning value.
                          */                           */
                         if ((a = attr_find( e->e_attrs, ad_pwdExpirationWarned )) == NULL) {  
                                 m = ch_calloc( sizeof(Modifications), 1 );  
                                 m->sml_op = LDAP_MOD_ADD;  
                                 m->sml_type = ad_pwdExpirationWarned->ad_cname;  
                                 m->sml_desc = ad_pwdExpirationWarned;  
                                 m->sml_values = ch_calloc( sizeof(struct berval), 2 );  
                                 ber_str2bv( nowstr, 0, 1, &m->sml_values[0] );  
                                 m->sml_next = mod;  
                                 mod = m;  
                         }  
                           
                         warn = ppb->pp.pwdMaxAge - age; /* seconds left until expiry */                          warn = ppb->pp.pwdMaxAge - age; /* seconds left until expiry */
                         if (warn < 0) warn = 0; /* something weird here - why is pwExpired not set? */                          if (warn < 0) warn = 0; /* something weird here - why is pwExpired not set? */
                                                   
Line 943  locked: Line 947  locked:
                 op2.o_ndn = op->o_bd->be_rootndn;                  op2.o_ndn = op->o_bd->be_rootndn;
                 op2.o_bd->bd_info = (BackendInfo *)on->on_info;                  op2.o_bd->bd_info = (BackendInfo *)on->on_info;
                 rc = op->o_bd->be_modify( &op2, &r2 );                  rc = op->o_bd->be_modify( &op2, &r2 );
                 slap_mods_free( mod );                  slap_mods_free( mod, 1 );
         }          }
   
         if ( ppb->send_ctrl ) {          if ( ppb->send_ctrl ) {
Line 968  ppolicy_bind( Operation *op, SlapReply * Line 972  ppolicy_bind( Operation *op, SlapReply *
 {  {
         slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;          slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
   
           /* Reset lockout status on all Bind requests */
           if ( !BER_BVISEMPTY( &pwcons[op->o_conn->c_conn_idx].dn )) {
                   ch_free( pwcons[op->o_conn->c_conn_idx].dn.bv_val );
                   BER_BVZERO( &pwcons[op->o_conn->c_conn_idx].dn );
           }
   
         /* Root bypasses policy */          /* Root bypasses policy */
         if ( !be_isroot_dn( op->o_bd, &op->o_req_ndn )) {          if ( !be_isroot_dn( op->o_bd, &op->o_req_ndn )) {
                 Entry *e;                  Entry *e;
                 int i, rc;                  int rc;
                 ppbind *ppb;                  ppbind *ppb;
                 slap_callback *cb;                  slap_callback *cb;
   
Line 1020  ppolicy_bind( Operation *op, SlapReply * Line 1030  ppolicy_bind( Operation *op, SlapReply *
         return SLAP_CB_CONTINUE;          return SLAP_CB_CONTINUE;
 }  }
   
 /* Reset the restrict flag for the next session on this connection */  /* Reset the restricted info for the next session on this connection */
 static int  static int
 ppolicy_unbind( Operation *op, SlapReply *rs )  ppolicy_connection_destroy( BackendDB *bd, Connection *conn )
 {  {
         pwcons[op->o_conn->c_conn_idx].restrict = 0;          if ( !BER_BVISEMPTY( &pwcons[conn->c_conn_idx].dn )) {
                   ch_free( pwcons[conn->c_conn_idx].dn.bv_val );
                   BER_BVZERO( &pwcons[conn->c_conn_idx].dn );
           }
         return SLAP_CB_CONTINUE;          return SLAP_CB_CONTINUE;
 }  }
   
Line 1035  ppolicy_restrict( Line 1048  ppolicy_restrict(
         SlapReply *rs )          SlapReply *rs )
 {  {
         slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;          slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
         int i, send_ctrl = 0;          int send_ctrl = 0;
   
         /* Did we receive a password policy request control? */          /* Did we receive a password policy request control? */
         if ( op->o_ctrlflag[ppolicy_cid] ) {          if ( op->o_ctrlflag[ppolicy_cid] ) {
                 send_ctrl = 1;                  send_ctrl = 1;
         }          }
   
         if ( op->o_conn && pwcons[op->o_conn->c_conn_idx].restrict ) {          if ( op->o_conn && !BER_BVISEMPTY( &pwcons[op->o_conn->c_conn_idx].dn )) {
                   /* if the current authcDN doesn't match the one we recorded,
                    * then an intervening Bind has succeeded and the restriction
                    * no longer applies. (ITS#4516)
                    */
                   if ( !dn_match( &op->o_conn->c_ndn,
                                   &pwcons[op->o_conn->c_conn_idx].dn )) {
                           ch_free( pwcons[op->o_conn->c_conn_idx].dn.bv_val );
                           BER_BVZERO( &pwcons[op->o_conn->c_conn_idx].dn );
                           return SLAP_CB_CONTINUE;
                   }
   
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "connection restricted to password changing only\n", 0, 0, 0);                          "connection restricted to password changing only\n", 0, 0, 0);
                 if ( send_ctrl ) {                  if ( send_ctrl ) {
Line 1054  ppolicy_restrict( Line 1078  ppolicy_restrict(
                         rs->sr_ctrls = ctrls;                          rs->sr_ctrls = ctrls;
                 }                  }
                 op->o_bd->bd_info = (BackendInfo *)on->on_info;                  op->o_bd->bd_info = (BackendInfo *)on->on_info;
                 send_ldap_error( op, rs, LDAP_UNWILLING_TO_PERFORM,                  send_ldap_error( op, rs, LDAP_INSUFFICIENT_ACCESS, 
                         "Operations are restricted to bind/unbind/abandon/StartTLS/modify password" );                          "Operations are restricted to bind/unbind/abandon/StartTLS/modify password" );
                 return rs->sr_err;                  return rs->sr_err;
         }          }
Line 1070  ppolicy_add( Line 1094  ppolicy_add(
         slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;          slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
         pp_info *pi = on->on_bi.bi_private;          pp_info *pi = on->on_bi.bi_private;
         PassPolicy pp;          PassPolicy pp;
         int pw;  
         Attribute *pa;          Attribute *pa;
         const char *txt;          const char *txt;
   
         if ( ppolicy_restrict( op, rs ) != SLAP_CB_CONTINUE )          if ( ppolicy_restrict( op, rs ) != SLAP_CB_CONTINUE )
                 return rs->sr_err;                  return rs->sr_err;
   
           /* If this is a replica, assume the master checked everything */
           if ( be_shadow_update( op ))
                   return SLAP_CB_CONTINUE;
   
         /* Check for password in entry */          /* Check for password in entry */
         if ((pa = attr_find( op->oq_add.rs_e->e_attrs,          if ((pa = attr_find( op->oq_add.rs_e->e_attrs,
                 slap_schema.si_ad_userPassword )))                  slap_schema.si_ad_userPassword )))
Line 1089  ppolicy_add( Line 1116  ppolicy_add(
                 ppolicy_get( op, op->ora_e, &pp );                  ppolicy_get( op, op->ora_e, &pp );
                 if (pp.pwdCheckQuality > 0 && !be_isroot( op )) {                  if (pp.pwdCheckQuality > 0 && !be_isroot( op )) {
                         struct berval *bv = &(pa->a_vals[0]);                          struct berval *bv = &(pa->a_vals[0]);
                         int rc, i, send_ctrl = 0;                           int rc, send_ctrl = 0;
                         LDAPPasswordPolicyError pErr = PP_noError;                          LDAPPasswordPolicyError pErr = PP_noError;
   
                         /* Did we receive a password policy request control? */                          /* Did we receive a password policy request control? */
Line 1110  ppolicy_add( Line 1137  ppolicy_add(
                                 send_ldap_error( op, rs, rc, "Password fails quality checking policy" );                                  send_ldap_error( op, rs, rc, "Password fails quality checking policy" );
                                 return rs->sr_err;                                  return rs->sr_err;
                         }                          }
                             /*                  }
                              * A controversial bit. We hash cleartext                          /*
                              * passwords provided via add and modify operations                           * A controversial bit. We hash cleartext
                              * You're not really supposed to do this, since                           * passwords provided via add and modify operations
                              * the X.500 model says "store attributes" as they                           * You're not really supposed to do this, since
                              * get provided. By default, this is what we do                           * the X.500 model says "store attributes" as they
                              *                           * get provided. By default, this is what we do
                              * But if the hash_passwords flag is set, we hash                           *
                              * any cleartext password attribute values via the                           * But if the hash_passwords flag is set, we hash
                              * default password hashing scheme.                           * any cleartext password attribute values via the
                              */                           * default password hashing scheme.
                         if ((pi->hash_passwords) &&                           */
                                 (password_scheme( &(pa->a_vals[0]), NULL ) != LDAP_SUCCESS)) {                  if ((pi->hash_passwords) &&
                                 struct berval hpw;                          (password_scheme( &(pa->a_vals[0]), NULL ) != LDAP_SUCCESS)) {
                           struct berval hpw;
                                 slap_passwd_hash( &(pa->a_vals[0]), &hpw, &txt );  
                                 if (hpw.bv_val == NULL) {  
                                     /*  
                                      * hashing didn't work. Emit an error.  
                                      */  
                                         rs->sr_err = LDAP_OTHER;  
                                         rs->sr_text = txt;  
                                         send_ldap_error( op, rs, LDAP_OTHER, "Password hashing failed" );  
                                         return rs->sr_err;  
                                 }  
   
                                 memset( pa->a_vals[0].bv_val, 0, pa->a_vals[0].bv_len);                          slap_passwd_hash( &(pa->a_vals[0]), &hpw, &txt );
                                 ber_memfree( pa->a_vals[0].bv_val );                          if (hpw.bv_val == NULL) {
                                 pa->a_vals[0].bv_val = hpw.bv_val;                                  /*
                                 pa->a_vals[0].bv_len = hpw.bv_len;                                   * hashing didn't work. Emit an error.
                                    */
                                   rs->sr_err = LDAP_OTHER;
                                   rs->sr_text = txt;
                                   send_ldap_error( op, rs, LDAP_OTHER, "Password hashing failed" );
                                   return rs->sr_err;
                         }                          }
   
                           memset( pa->a_vals[0].bv_val, 0, pa->a_vals[0].bv_len);
                           ber_memfree( pa->a_vals[0].bv_val );
                           pa->a_vals[0].bv_val = hpw.bv_val;
                           pa->a_vals[0].bv_len = hpw.bv_len;
                 }                  }
   
                 /* If password aging is in effect, set the pwdChangedTime */                  /* If password aging is in effect, set the pwdChangedTime */
                 if (( pp.pwdMaxAge || pp.pwdMinAge ) && !be_isupdate( op )) {                  if ( pp.pwdMaxAge || pp.pwdMinAge ) {
                         struct berval timestamp;                          struct berval timestamp;
                         char timebuf[ LDAP_LUTIL_GENTIME_BUFSIZE ];                          char timebuf[ LDAP_LUTIL_GENTIME_BUFSIZE ];
                         struct tm *ltm;  
                         time_t now = slap_get_time();                          time_t now = slap_get_time();
   
                         ldap_pvt_thread_mutex_lock( &gmtime_mutex );  
                         ltm = gmtime( &now );  
                         lutil_gentime( timebuf, sizeof(timebuf), ltm );  
                         ldap_pvt_thread_mutex_unlock( &gmtime_mutex );  
   
                         timestamp.bv_val = timebuf;                          timestamp.bv_val = timebuf;
                         timestamp.bv_len = strlen(timebuf);                          timestamp.bv_len = sizeof(timebuf);
                           slap_timestamp( &now, &timestamp );
   
                         attr_merge_one( op->ora_e, ad_pwdChangedTime, &timestamp, NULL );                          attr_merge_one( op->ora_e, ad_pwdChangedTime, &timestamp, &timestamp );
                 }                  }
         }          }
         return SLAP_CB_CONTINUE;          return SLAP_CB_CONTINUE;
Line 1168  ppolicy_modify( Operation *op, SlapReply Line 1191  ppolicy_modify( Operation *op, SlapReply
 {  {
         slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;          slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;
         pp_info                 *pi = on->on_bi.bi_private;          pp_info                 *pi = on->on_bi.bi_private;
         int                     i, rc, mod_pw_only, pwmod, pwmop, deladd,          int                     i, rc, mod_pw_only, pwmod, pwmop = -1, deladd,
                                 hsize = 0;                                  hsize = 0;
         PassPolicy              pp;          PassPolicy              pp;
         Modifications           *mods = NULL, *modtail, *ml, *delmod, *addmod;          Modifications           *mods = NULL, *modtail = NULL,
         Attribute               *pa, *ha, *ra, at;                                  *ml, *delmod, *addmod;
         int                     repl_user = be_isupdate( op );          Attribute               *pa, *ha, at;
         const char              *txt;          const char              *txt;
         pw_hist                 *tl = NULL, *p;          pw_hist                 *tl = NULL, *p;
         int                     zapReset, send_ctrl = 0;          int                     zapReset, send_ctrl = 0;
Line 1188  ppolicy_modify( Operation *op, SlapReply Line 1211  ppolicy_modify( Operation *op, SlapReply
   
         if ( rc != LDAP_SUCCESS ) return SLAP_CB_CONTINUE;          if ( rc != LDAP_SUCCESS ) return SLAP_CB_CONTINUE;
   
           /* If this is a replica, we may need to tweak some of the
            * master's modifications. Otherwise, just pass it through.
            */
           if ( be_shadow_update( op )) {
                   Modifications **prev;
                   int got_del_grace = 0, got_del_lock = 0, got_pw = 0, got_del_fail = 0;
                   Attribute *a_grace, *a_lock, *a_fail;
   
                   a_grace = attr_find( e->e_attrs, ad_pwdGraceUseTime );
                   a_lock = attr_find( e->e_attrs, ad_pwdAccountLockedTime );
                   a_fail = attr_find( e->e_attrs, ad_pwdFailureTime );
   
                   for( prev = &op->oq_modify.rs_modlist, ml = *prev; ml; ml = *prev ) {
   
                           if ( ml->sml_desc == slap_schema.si_ad_userPassword )
                                   got_pw = 1;
   
                           /* If we're deleting an attr that didn't exist,
                            * drop this delete op
                            */
                           if ( ml->sml_op == LDAP_MOD_DELETE ) {
                                   int drop = 0;
   
                                   if ( ml->sml_desc == ad_pwdGraceUseTime ) {
                                           got_del_grace = 1;
                                           if ( !a_grace )
                                                   drop = 1;
                                   } else
                                   if ( ml->sml_desc == ad_pwdAccountLockedTime ) {
                                           got_del_lock = 1;
                                           if ( !a_lock )
                                                   drop = 1;
                                   } else
                                   if ( ml->sml_desc == ad_pwdFailureTime ) {
                                           got_del_fail = 1;
                                           if ( !a_fail )
                                                   drop = 1;
                                   }
                                   if ( drop ) {
                                           *prev = ml->sml_next;
                                           ml->sml_next = NULL;
                                           slap_mods_free( ml, 1 );
                                           continue;
                                   }
                           }
                           prev = &ml->sml_next;
                   }
   
                   /* If we're resetting the password, make sure grace, accountlock,
                    * and failure also get removed.
                    */
                   if ( got_pw ) {
                           if ( a_grace && !got_del_grace ) {
                                   ml = (Modifications *) ch_malloc( sizeof( Modifications ) );
                                   ml->sml_op = LDAP_MOD_DELETE;
                                   ml->sml_flags = SLAP_MOD_INTERNAL;
                                   ml->sml_type.bv_val = NULL;
                                   ml->sml_desc = ad_pwdGraceUseTime;
                                   ml->sml_values = NULL;
                                   ml->sml_nvalues = NULL;
                                   ml->sml_next = NULL;
                                   *prev = ml;
                                   prev = &ml->sml_next;
                           }
                           if ( a_lock && !got_del_lock ) {
                                   ml = (Modifications *) ch_malloc( sizeof( Modifications ) );
                                   ml->sml_op = LDAP_MOD_DELETE;
                                   ml->sml_flags = SLAP_MOD_INTERNAL;
                                   ml->sml_type.bv_val = NULL;
                                   ml->sml_desc = ad_pwdAccountLockedTime;
                                   ml->sml_values = NULL;
                                   ml->sml_nvalues = NULL;
                                   ml->sml_next = NULL;
                                   *prev = ml;
                           }
                           if ( a_fail && !got_del_fail ) {
                                   ml = (Modifications *) ch_malloc( sizeof( Modifications ) );
                                   ml->sml_op = LDAP_MOD_DELETE;
                                   ml->sml_flags = SLAP_MOD_INTERNAL;
                                   ml->sml_type.bv_val = NULL;
                                   ml->sml_desc = ad_pwdFailureTime;
                                   ml->sml_values = NULL;
                                   ml->sml_nvalues = NULL;
                                   ml->sml_next = NULL;
                                   *prev = ml;
                           }
                   }
                   op->o_bd->bd_info = (BackendInfo *)on->on_info;
                   be_entry_release_r( op, e );
                   return SLAP_CB_CONTINUE;
           }
   
         /* Did we receive a password policy request control? */          /* Did we receive a password policy request control? */
         if ( op->o_ctrlflag[ppolicy_cid] ) {          if ( op->o_ctrlflag[ppolicy_cid] ) {
                 send_ctrl = 1;                  send_ctrl = 1;
Line 1212  ppolicy_modify( Operation *op, SlapReply Line 1327  ppolicy_modify( Operation *op, SlapReply
   
         ppolicy_get( op, e, &pp );          ppolicy_get( op, e, &pp );
   
         for(ml = op->oq_modify.rs_modlist,          for ( ml = op->oq_modify.rs_modlist,
                         pwmod = 0, mod_pw_only = 1,                          pwmod = 0, mod_pw_only = 1,
                         deladd = 0, delmod = NULL,                          deladd = 0, delmod = NULL,
                         addmod = NULL,                          addmod = NULL,
                         zapReset = 1;                          zapReset = 1;
                 ml != NULL; modtail = ml, ml = ml->sml_next ) {                  ml != NULL; modtail = ml, ml = ml->sml_next )
           {
                 if ( ml->sml_desc == pp.ad ) {                  if ( ml->sml_desc == pp.ad ) {
                         pwmod = 1;                          pwmod = 1;
                         pwmop = ml->sml_op;                          pwmop = ml->sml_op;
Line 1256  ppolicy_modify( Operation *op, SlapReply Line 1372  ppolicy_modify( Operation *op, SlapReply
                 }                  }
         }          }
                   
         if (pwcons[op->o_conn->c_conn_idx].restrict && !mod_pw_only) {          if (!BER_BVISEMPTY( &pwcons[op->o_conn->c_conn_idx].dn ) && !mod_pw_only ) {
                 Debug( LDAP_DEBUG_TRACE,                  if ( dn_match( &op->o_conn->c_ndn,
                         "connection restricted to password changing only\n", 0, 0, 0 );                                  &pwcons[op->o_conn->c_conn_idx].dn )) {
                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;                          Debug( LDAP_DEBUG_TRACE,
                 rs->sr_text = "Operations are restricted to bind/unbind/abandon/StartTLS/modify password";                                  "connection restricted to password changing only\n", 0, 0, 0 );
                 pErr = PP_changeAfterReset;                          rs->sr_err = LDAP_INSUFFICIENT_ACCESS; 
                 goto return_results;                          rs->sr_text = "Operations are restricted to bind/unbind/abandon/StartTLS/modify password";
                           pErr = PP_changeAfterReset;
                           goto return_results;
                   } else {
                           ch_free( pwcons[op->o_conn->c_conn_idx].dn.bv_val );
                           BER_BVZERO( &pwcons[op->o_conn->c_conn_idx].dn );
                   }
         }          }
   
         /*          /*
Line 1295  ppolicy_modify( Operation *op, SlapReply Line 1417  ppolicy_modify( Operation *op, SlapReply
         if (pp.pwdInHistory > 0 && (ha = attr_find( e->e_attrs, ad_pwdHistory ))) {          if (pp.pwdInHistory > 0 && (ha = attr_find( e->e_attrs, ad_pwdHistory ))) {
                 struct berval oldpw;                  struct berval oldpw;
                 time_t oldtime;                  time_t oldtime;
                 char *oid;  
   
                 for(i=0; ha->a_nvals[i].bv_val; i++) {                  for(i=0; ha->a_nvals[i].bv_val; i++) {
                         rc = parse_pwdhistory( &(ha->a_nvals[i]), NULL,                          rc = parse_pwdhistory( &(ha->a_nvals[i]), NULL,
Line 1322  ppolicy_modify( Operation *op, SlapReply Line 1443  ppolicy_modify( Operation *op, SlapReply
         if (pp.pwdSafeModify && oldpw.bv_val ) {          if (pp.pwdSafeModify && oldpw.bv_val ) {
                 ml = (Modifications *) ch_malloc( sizeof( Modifications ) );                  ml = (Modifications *) ch_malloc( sizeof( Modifications ) );
                 ml->sml_op = LDAP_MOD_DELETE;                  ml->sml_op = LDAP_MOD_DELETE;
                   ml->sml_flags = SLAP_MOD_INTERNAL;
                 ml->sml_desc = pp.ad;                  ml->sml_desc = pp.ad;
                 ml->sml_type = pp.ad->ad_cname;                  ml->sml_type = pp.ad->ad_cname;
                 ml->sml_values = (BerVarray) ch_malloc( 2 * sizeof( struct berval ) );                  ml->sml_values = (BerVarray) ch_malloc( 2 * sizeof( struct berval ) );
Line 1339  ppolicy_modify( Operation *op, SlapReply Line 1461  ppolicy_modify( Operation *op, SlapReply
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "change password must use DELETE followed by ADD/REPLACE\n",                          "change password must use DELETE followed by ADD/REPLACE\n",
                         0, 0, 0 );                          0, 0, 0 );
                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;                  rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
                 rs->sr_text = "Must supply old password to be changed as well as new one";                  rs->sr_text = "Must supply old password to be changed as well as new one";
                 pErr = PP_mustSupplyOldPassword;                  pErr = PP_mustSupplyOldPassword;
                 goto return_results;                  goto return_results;
         }          }
   
         if (!pp.pwdAllowUserChange) {          if (!pp.pwdAllowUserChange) {
                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;                  rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
                 rs->sr_text = "User alteration of password is not allowed";                  rs->sr_text = "User alteration of password is not allowed";
                 pErr = PP_passwordModNotAllowed;                  pErr = PP_passwordModNotAllowed;
                 goto return_results;                  goto return_results;
Line 1361  ppolicy_modify( Operation *op, SlapReply Line 1483  ppolicy_modify( Operation *op, SlapReply
                 now = slap_get_time();                  now = slap_get_time();
                 age = (int)(now - pwtime);                  age = (int)(now - pwtime);
                 if ((pwtime != (time_t)-1) && (age < pp.pwdMinAge)) {                  if ((pwtime != (time_t)-1) && (age < pp.pwdMinAge)) {
                         rs->sr_err = LDAP_UNWILLING_TO_PERFORM;                          rs->sr_err = LDAP_CONSTRAINT_VIOLATION;
                         rs->sr_text = "Password is too young to change";                          rs->sr_text = "Password is too young to change";
                         pErr = PP_passwordTooYoung;                          pErr = PP_passwordTooYoung;
                         goto return_results;                          goto return_results;
Line 1376  ppolicy_modify( Operation *op, SlapReply Line 1498  ppolicy_modify( Operation *op, SlapReply
                 const char *txt;                  const char *txt;
                                   
                 bv = oldpw.bv_val ? &oldpw : delmod->sml_values;                  bv = oldpw.bv_val ? &oldpw : delmod->sml_values;
                 rc = slap_passwd_check( op->o_conn, pa, bv, &txt );                  /* FIXME: no access checking? */
                   rc = slap_passwd_check( op, NULL, pa, bv, &txt );
                 if (rc != LDAP_SUCCESS) {                  if (rc != LDAP_SUCCESS) {
                         Debug( LDAP_DEBUG_TRACE,                          Debug( LDAP_DEBUG_TRACE,
                                 "old password check failed: %s\n", txt, 0, 0 );                                  "old password check failed: %s\n", txt, 0, 0 );
Line 1420  ppolicy_modify( Operation *op, SlapReply Line 1543  ppolicy_modify( Operation *op, SlapReply
                 /*                  /*
                  * Last check - the password history.                   * Last check - the password history.
                  */                   */
                 if (slap_passwd_check( op->o_conn, pa, bv, &txt ) == LDAP_SUCCESS) {                  /* FIXME: no access checking? */
                   if (slap_passwd_check( op, NULL, pa, bv, &txt ) == LDAP_SUCCESS) {
                         /*                          /*
                          * This is bad - it means that the user is attempting                           * This is bad - it means that the user is attempting
                          * to set the password to the same as the old one.                           * to set the password to the same as the old one.
Line 1442  ppolicy_modify( Operation *op, SlapReply Line 1566  ppolicy_modify( Operation *op, SlapReply
                 cr[1].bv_val = NULL;                  cr[1].bv_val = NULL;
                 for(p=tl; p; p=p->next) {                  for(p=tl; p; p=p->next) {
                         cr[0] = p->pw;                          cr[0] = p->pw;
                         rc = slap_passwd_check( op->o_conn, &at, bv, &txt );                          /* FIXME: no access checking? */
                           rc = slap_passwd_check( op, NULL, &at, bv, &txt );
                                                   
                         if (rc != LDAP_SUCCESS) continue;                          if (rc != LDAP_SUCCESS) continue;
                                                   
Line 1454  ppolicy_modify( Operation *op, SlapReply Line 1579  ppolicy_modify( Operation *op, SlapReply
         }          }
   
 do_modify:  do_modify:
         if ((pwmod) && (!repl_user)) {          if (pwmod) {
                 struct berval timestamp;                  struct berval timestamp;
                 char timebuf[ LDAP_LUTIL_GENTIME_BUFSIZE ];                  char timebuf[ LDAP_LUTIL_GENTIME_BUFSIZE ];
                 struct tm *ltm;  
                 time_t now = slap_get_time();                  time_t now = slap_get_time();
                 Attribute *ga;  
                                   
                 /*                  /*
                  * keep the necessary pwd.. operational attributes                   * keep the necessary pwd.. operational attributes
                  * up to date.                   * up to date.
                  */                   */
   
                 ldap_pvt_thread_mutex_lock( &gmtime_mutex );  
                 ltm = gmtime( &now );  
                 lutil_gentime( timebuf, sizeof(timebuf), ltm );  
                 ldap_pvt_thread_mutex_unlock( &gmtime_mutex );  
   
                 timestamp.bv_val = timebuf;                  timestamp.bv_val = timebuf;
                 timestamp.bv_len = strlen(timebuf);                  timestamp.bv_len = sizeof(timebuf);
                   slap_timestamp( &now, &timestamp );
   
                 mods = (Modifications *) ch_malloc( sizeof( Modifications ) );                  mods = (Modifications *) ch_malloc( sizeof( Modifications ) );
                 mods->sml_type.bv_val = NULL;                  mods->sml_type.bv_val = NULL;
                 mods->sml_desc = ad_pwdChangedTime;                  mods->sml_desc = ad_pwdChangedTime;
                 if (pwmop != LDAP_MOD_DELETE) {                  if (pwmop != LDAP_MOD_DELETE) {
                         mods->sml_op = LDAP_MOD_REPLACE;                          mods->sml_op = LDAP_MOD_REPLACE;
                         mods->sml_values = (BerVarray) ch_malloc( 2 * sizeof( struct berval ) );                          mods->sml_values = (BerVarray) ch_malloc( 2 * sizeof( struct berval ) );
                           mods->sml_nvalues = (BerVarray) ch_malloc( 2 * sizeof( struct berval ) );
                         ber_dupbv( &mods->sml_values[0], &timestamp );                          ber_dupbv( &mods->sml_values[0], &timestamp );
                           ber_dupbv( &mods->sml_nvalues[0], &timestamp );
                         mods->sml_values[1].bv_len = 0;                          mods->sml_values[1].bv_len = 0;
                         mods->sml_values[1].bv_val = NULL;                          mods->sml_values[1].bv_val = NULL;
                         assert( mods->sml_values[0].bv_val );                          assert( mods->sml_values[0].bv_val != NULL );
                 } else {                  } else {
                         mods->sml_op = LDAP_MOD_DELETE;                          mods->sml_op = LDAP_MOD_DELETE;
                         mods->sml_values = NULL;                          mods->sml_values = NULL;
                 }                  }
                   mods->sml_flags = SLAP_MOD_INTERNAL;
                 mods->sml_nvalues = NULL;                  mods->sml_nvalues = NULL;
                 mods->sml_next = NULL;                  mods->sml_next = NULL;
                 modtail->sml_next = mods;                  modtail->sml_next = mods;
Line 1495  do_modify: Line 1618  do_modify:
                 if (attr_find(e->e_attrs, ad_pwdGraceUseTime )) {                  if (attr_find(e->e_attrs, ad_pwdGraceUseTime )) {
                         mods = (Modifications *) ch_malloc( sizeof( Modifications ) );                          mods = (Modifications *) ch_malloc( sizeof( Modifications ) );
                         mods->sml_op = LDAP_MOD_DELETE;                          mods->sml_op = LDAP_MOD_DELETE;
                           mods->sml_flags = SLAP_MOD_INTERNAL;
                         mods->sml_type.bv_val = NULL;                          mods->sml_type.bv_val = NULL;
                         mods->sml_desc = ad_pwdGraceUseTime;                          mods->sml_desc = ad_pwdGraceUseTime;
                         mods->sml_values = NULL;                          mods->sml_values = NULL;
Line 1504  do_modify: Line 1628  do_modify:
                         modtail = mods;                          modtail = mods;
                 }                  }
   
                 if (attr_find(e->e_attrs, ad_pwdExpirationWarned )) {                  if (attr_find(e->e_attrs, ad_pwdAccountLockedTime )) {
                         mods = (Modifications *) ch_malloc( sizeof( Modifications ) );                          mods = (Modifications *) ch_malloc( sizeof( Modifications ) );
                         mods->sml_op = LDAP_MOD_DELETE;                          mods->sml_op = LDAP_MOD_DELETE;
                           mods->sml_flags = SLAP_MOD_INTERNAL;
                         mods->sml_type.bv_val = NULL;                          mods->sml_type.bv_val = NULL;
                         mods->sml_desc = ad_pwdExpirationWarned;                          mods->sml_desc = ad_pwdAccountLockedTime;
                           mods->sml_values = NULL;
                           mods->sml_nvalues = NULL;
                           mods->sml_next = NULL;
                           modtail->sml_next = mods;
                           modtail = mods;
                   }
   
                   if (attr_find(e->e_attrs, ad_pwdFailureTime )) {
                           mods = (Modifications *) ch_malloc( sizeof( Modifications ) );
                           mods->sml_op = LDAP_MOD_DELETE;
                           mods->sml_flags = SLAP_MOD_INTERNAL;
                           mods->sml_type.bv_val = NULL;
                           mods->sml_desc = ad_pwdFailureTime;
                         mods->sml_values = NULL;                          mods->sml_values = NULL;
                         mods->sml_nvalues = NULL;                          mods->sml_nvalues = NULL;
                         mods->sml_next = NULL;                          mods->sml_next = NULL;
Line 1520  do_modify: Line 1658  do_modify:
                 if ((zapReset) && (attr_find(e->e_attrs, ad_pwdReset ))) {                  if ((zapReset) && (attr_find(e->e_attrs, ad_pwdReset ))) {
                         mods = (Modifications *) ch_malloc( sizeof( Modifications ) );                          mods = (Modifications *) ch_malloc( sizeof( Modifications ) );
                         mods->sml_op = LDAP_MOD_DELETE;                          mods->sml_op = LDAP_MOD_DELETE;
                           mods->sml_flags = SLAP_MOD_INTERNAL;
                         mods->sml_type.bv_val = NULL;                          mods->sml_type.bv_val = NULL;
                         mods->sml_desc = ad_pwdReset;                          mods->sml_desc = ad_pwdReset;
                         mods->sml_values = NULL;                          mods->sml_values = NULL;
Line 1549  do_modify: Line 1688  do_modify:
                                  */                                   */
                                 mods = (Modifications *) ch_malloc( sizeof( Modifications ) );                                  mods = (Modifications *) ch_malloc( sizeof( Modifications ) );
                                 mods->sml_op = LDAP_MOD_DELETE;                                  mods->sml_op = LDAP_MOD_DELETE;
                                   mods->sml_flags = SLAP_MOD_INTERNAL;
                                 mods->sml_type.bv_val = NULL;                                  mods->sml_type.bv_val = NULL;
                                 mods->sml_desc = ad_pwdHistory;                                  mods->sml_desc = ad_pwdHistory;
                                 mods->sml_nvalues = NULL;                                  mods->sml_nvalues = NULL;
Line 1581  do_modify: Line 1721  do_modify:
                         if ((pa = attr_find( e->e_attrs, pp.ad )) != NULL) {                          if ((pa = attr_find( e->e_attrs, pp.ad )) != NULL) {
                                 mods = (Modifications *) ch_malloc( sizeof( Modifications ) );                                  mods = (Modifications *) ch_malloc( sizeof( Modifications ) );
                                 mods->sml_op = LDAP_MOD_ADD;                                  mods->sml_op = LDAP_MOD_ADD;
                                   mods->sml_flags = SLAP_MOD_INTERNAL;
                                 mods->sml_type.bv_val = NULL;                                  mods->sml_type.bv_val = NULL;
                                 mods->sml_desc = ad_pwdHistory;                                  mods->sml_desc = ad_pwdHistory;
                                 mods->sml_nvalues = NULL;                                  mods->sml_nvalues = NULL;
Line 1676  ppolicy_parseCtrl( Line 1817  ppolicy_parseCtrl(
 }  }
   
 static int  static int
   attrPretty(
           Syntax *syntax,
           struct berval *val,
           struct berval *out,
           void *ctx )
   {
           AttributeDescription *ad = NULL;
           const char *err;
           int code;
   
           code = slap_bv2ad( val, &ad, &err );
           if ( !code ) {
                   ber_dupbv_x( out, &ad->ad_type->sat_cname, ctx );
           }
           return code;
   }
   
   static int
   attrNormalize(
           slap_mask_t use,
           Syntax *syntax,
           MatchingRule *mr,
           struct berval *val,
           struct berval *out,
           void *ctx )
   {
           AttributeDescription *ad = NULL;
           const char *err;
           int code;
   
           code = slap_bv2ad( val, &ad, &err );
           if ( !code ) {
                   ber_str2bv_x( ad->ad_type->sat_oid, 0, 1, out, ctx );
           }
           return code;
   }
   
   static int
 ppolicy_db_init(  ppolicy_db_init(
         BackendDB *be          BackendDB *be
 )  )
Line 1694  ppolicy_db_init( Line 1873  ppolicy_db_init(
                                 return code;                                  return code;
                         }                          }
                 }                  }
                   {
                           Syntax *syn;
                           MatchingRule *mr;
   
                           syn = ch_malloc( sizeof( Syntax ));
                           *syn = *ad_pwdAttribute->ad_type->sat_syntax;
                           syn->ssyn_pretty = attrPretty;
                           ad_pwdAttribute->ad_type->sat_syntax = syn;
   
                           mr = ch_malloc( sizeof( MatchingRule ));
                           *mr = *ad_pwdAttribute->ad_type->sat_equality;
                           mr->smr_normalize = attrNormalize;
                           ad_pwdAttribute->ad_type->sat_equality = mr;
                   }
         }          }
   
         on->on_bi.bi_private = ch_calloc( sizeof(pp_info), 1 );          on->on_bi.bi_private = ch_calloc( sizeof(pp_info), 1 );
Line 1705  ppolicy_db_init( Line 1898  ppolicy_db_init(
 }  }
   
 static int  static int
   ppolicy_db_open(
       BackendDB *be
   )
   {
           return overlay_register_control( be, LDAP_CONTROL_PASSWORDPOLICYREQUEST );
   }
   
   static int
 ppolicy_close(  ppolicy_close(
         BackendDB *be          BackendDB *be
 )  )
Line 1762  ppolicy_config( Line 1963  ppolicy_config(
                         return ( 1 );                          return ( 1 );
                 }                  }
                 pi->hash_passwords = 1;                  pi->hash_passwords = 1;
                   return 0;
         }          }
         return SLAP_CONF_UNKNOWN;          return SLAP_CONF_UNKNOWN;
 }  }
Line 1773  static char *extops[] = { Line 1975  static char *extops[] = {
   
 static slap_overinst ppolicy;  static slap_overinst ppolicy;
   
 int ppolicy_init()  int ppolicy_initialize()
 {  {
         LDAPAttributeType *at;          LDAPAttributeType *at;
         const char *err;          const char *err;
Line 1787  int ppolicy_init() Line 1989  int ppolicy_init()
                                 ldap_scherr2str(code), err );                                  ldap_scherr2str(code), err );
                         return code;                          return code;
                 }                  }
                 code = at_add( at, &err );                  code = at_add( at, 0, NULL, &err );
                 if ( !code ) {                  if ( !code ) {
                         slap_str2ad( at->at_names[0], pwd_OpSchema[i].ad, &err );                          slap_str2ad( at->at_names[0], pwd_OpSchema[i].ad, &err );
                 }                  }
Line 1797  int ppolicy_init() Line 1999  int ppolicy_init()
                                 scherr2str(code), err );                                  scherr2str(code), err );
                         return code;                          return code;
                 }                  }
                   /* Allow Manager to set these as needed */
                   if ( is_at_no_user_mod( (*pwd_OpSchema[i].ad)->ad_type )) {
                           (*pwd_OpSchema[i].ad)->ad_type->sat_flags |=
                                   SLAP_AT_MANAGEABLE;
                   }
         }          }
   
         code = register_supported_control( LDAP_CONTROL_PASSWORDPOLICYREQUEST,          code = register_supported_control( LDAP_CONTROL_PASSWORDPOLICYREQUEST,
                 SLAP_CTRL_ADD|SLAP_CTRL_BIND|SLAP_CTRL_MODIFY, extops,                  SLAP_CTRL_ADD|SLAP_CTRL_BIND|SLAP_CTRL_MODIFY|SLAP_CTRL_HIDE, extops,
                 ppolicy_parseCtrl, &ppolicy_cid );                  ppolicy_parseCtrl, &ppolicy_cid );
         if ( code != LDAP_SUCCESS ) {          if ( code != LDAP_SUCCESS ) {
                 fprintf( stderr, "Failed to register control %d\n", code );                  fprintf( stderr, "Failed to register control %d\n", code );
Line 1811  int ppolicy_init() Line 2018  int ppolicy_init()
   
         ppolicy.on_bi.bi_type = "ppolicy";          ppolicy.on_bi.bi_type = "ppolicy";
         ppolicy.on_bi.bi_db_init = ppolicy_db_init;          ppolicy.on_bi.bi_db_init = ppolicy_db_init;
           ppolicy.on_bi.bi_db_open = ppolicy_db_open;
         ppolicy.on_bi.bi_db_config = ppolicy_config;          ppolicy.on_bi.bi_db_config = ppolicy_config;
         ppolicy.on_bi.bi_db_close = ppolicy_close;          ppolicy.on_bi.bi_db_close = ppolicy_close;
   
         ppolicy.on_bi.bi_op_add = ppolicy_add;          ppolicy.on_bi.bi_op_add = ppolicy_add;
         ppolicy.on_bi.bi_op_bind = ppolicy_bind;          ppolicy.on_bi.bi_op_bind = ppolicy_bind;
         ppolicy.on_bi.bi_op_unbind = ppolicy_unbind;  
         ppolicy.on_bi.bi_op_compare = ppolicy_restrict;          ppolicy.on_bi.bi_op_compare = ppolicy_restrict;
         ppolicy.on_bi.bi_op_delete = ppolicy_restrict;          ppolicy.on_bi.bi_op_delete = ppolicy_restrict;
         ppolicy.on_bi.bi_op_modify = ppolicy_modify;          ppolicy.on_bi.bi_op_modify = ppolicy_modify;
         ppolicy.on_bi.bi_op_search = ppolicy_restrict;          ppolicy.on_bi.bi_op_search = ppolicy_restrict;
           ppolicy.on_bi.bi_connection_destroy = ppolicy_connection_destroy;
   
         return overlay_register( &ppolicy );          return overlay_register( &ppolicy );
 }  }
   
 #if SLAPD_OVER_PPOLICY == SLAPD_MOD_DYNAMIC  #if SLAPD_OVER_PPOLICY == SLAPD_MOD_DYNAMIC
 int init_module(int argc, char *argv[]) {  int init_module(int argc, char *argv[]) {
         return ppolicy_init();          return ppolicy_initialize();
 }  }
 #endif  #endif
   

Removed from v.1.31  
changed lines
  Added in v.1.31.2.21


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org