c2beb4f658f91c5599acb2abfd2d7e2a259a33a5
[moodle.git] / auth / ldap / auth.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Authentication Plugin: LDAP Authentication
19  * Authentication using LDAP (Lightweight Directory Access Protocol).
20  *
21  * @package auth_ldap
22  * @author Martin Dougiamas
23  * @author IƱaki Arenaza
24  * @license http://www.gnu.org/copyleft/gpl.html GNU Public License
25  */
27 defined('MOODLE_INTERNAL') || die();
29 // See http://support.microsoft.com/kb/305144 to interprete these values.
30 if (!defined('AUTH_AD_ACCOUNTDISABLE')) {
31     define('AUTH_AD_ACCOUNTDISABLE', 0x0002);
32 }
33 if (!defined('AUTH_AD_NORMAL_ACCOUNT')) {
34     define('AUTH_AD_NORMAL_ACCOUNT', 0x0200);
35 }
36 if (!defined('AUTH_NTLMTIMEOUT')) {  // timewindow for the NTLM SSO process, in secs...
37     define('AUTH_NTLMTIMEOUT', 10);
38 }
40 // UF_DONT_EXPIRE_PASSWD value taken from MSDN directly
41 if (!defined('UF_DONT_EXPIRE_PASSWD')) {
42     define ('UF_DONT_EXPIRE_PASSWD', 0x00010000);
43 }
45 // The Posix uid and gid of the 'nobody' account and 'nogroup' group.
46 if (!defined('AUTH_UID_NOBODY')) {
47     define('AUTH_UID_NOBODY', -2);
48 }
49 if (!defined('AUTH_GID_NOGROUP')) {
50     define('AUTH_GID_NOGROUP', -2);
51 }
53 // Regular expressions for a valid NTLM username and domain name.
54 if (!defined('AUTH_NTLM_VALID_USERNAME')) {
55     define('AUTH_NTLM_VALID_USERNAME', '[^/\\\\\\\\\[\]:;|=,+*?<>@"]+');
56 }
57 if (!defined('AUTH_NTLM_VALID_DOMAINNAME')) {
58     define('AUTH_NTLM_VALID_DOMAINNAME', '[^\\\\\\\\\/:*?"<>|]+');
59 }
60 // Default format for remote users if using NTLM SSO
61 if (!defined('AUTH_NTLM_DEFAULT_FORMAT')) {
62     define('AUTH_NTLM_DEFAULT_FORMAT', '%domain%\\%username%');
63 }
64 if (!defined('AUTH_NTLM_FASTPATH_ATTEMPT')) {
65     define('AUTH_NTLM_FASTPATH_ATTEMPT', 0);
66 }
67 if (!defined('AUTH_NTLM_FASTPATH_YESFORM')) {
68     define('AUTH_NTLM_FASTPATH_YESFORM', 1);
69 }
70 if (!defined('AUTH_NTLM_FASTPATH_YESATTEMPT')) {
71     define('AUTH_NTLM_FASTPATH_YESATTEMPT', 2);
72 }
74 // Allows us to retrieve a diagnostic message in case of LDAP operation error
75 if (!defined('LDAP_OPT_DIAGNOSTIC_MESSAGE')) {
76     define('LDAP_OPT_DIAGNOSTIC_MESSAGE', 0x0032);
77 }
79 require_once($CFG->libdir.'/authlib.php');
80 require_once($CFG->libdir.'/ldaplib.php');
81 require_once($CFG->dirroot.'/user/lib.php');
83 /**
84  * LDAP authentication plugin.
85  */
86 class auth_plugin_ldap extends auth_plugin_base {
88     /**
89      * Init plugin config from database settings depending on the plugin auth type.
90      */
91     function init_plugin($authtype) {
92         $this->pluginconfig = 'auth/'.$authtype;
93         $this->config = get_config($this->pluginconfig);
94         if (empty($this->config->ldapencoding)) {
95             $this->config->ldapencoding = 'utf-8';
96         }
97         if (empty($this->config->user_type)) {
98             $this->config->user_type = 'default';
99         }
101         $ldap_usertypes = ldap_supported_usertypes();
102         $this->config->user_type_name = $ldap_usertypes[$this->config->user_type];
103         unset($ldap_usertypes);
105         $default = ldap_getdefaults();
107         // Use defaults if values not given
108         foreach ($default as $key => $value) {
109             // watch out - 0, false are correct values too
110             if (!isset($this->config->{$key}) or $this->config->{$key} == '') {
111                 $this->config->{$key} = $value[$this->config->user_type];
112             }
113         }
115         // Hack prefix to objectclass
116         if (empty($this->config->objectclass)) {
117             // Can't send empty filter
118             $this->config->objectclass = '(objectClass=*)';
119         } else if (stripos($this->config->objectclass, 'objectClass=') === 0) {
120             // Value is 'objectClass=some-string-here', so just add ()
121             // around the value (filter _must_ have them).
122             $this->config->objectclass = '('.$this->config->objectclass.')';
123         } else if (strpos($this->config->objectclass, '(') !== 0) {
124             // Value is 'some-string-not-starting-with-left-parentheses',
125             // which is assumed to be the objectClass matching value.
126             // So build a valid filter with it.
127             $this->config->objectclass = '(objectClass='.$this->config->objectclass.')';
128         } else {
129             // There is an additional possible value
130             // '(some-string-here)', that can be used to specify any
131             // valid filter string, to select subsets of users based
132             // on any criteria. For example, we could select the users
133             // whose objectClass is 'user' and have the
134             // 'enabledMoodleUser' attribute, with something like:
135             //
136             //   (&(objectClass=user)(enabledMoodleUser=1))
137             //
138             // In this particular case we don't need to do anything,
139             // so leave $this->config->objectclass as is.
140         }
141     }
143     /**
144      * Constructor with initialisation.
145      */
146     function auth_plugin_ldap() {
147         $this->authtype = 'ldap';
148         $this->roleauth = 'auth_ldap';
149         $this->errorlogtag = '[AUTH LDAP] ';
150         $this->init_plugin($this->authtype);
151     }
153     /**
154      * Returns true if the username and password work and false if they are
155      * wrong or don't exist.
156      *
157      * @param string $username The username (without system magic quotes)
158      * @param string $password The password (without system magic quotes)
159      *
160      * @return bool Authentication success or failure.
161      */
162     function user_login($username, $password) {
163         if (! function_exists('ldap_bind')) {
164             print_error('auth_ldapnotinstalled', 'auth_ldap');
165             return false;
166         }
168         if (!$username or !$password) {    // Don't allow blank usernames or passwords
169             return false;
170         }
172         $extusername = core_text::convert($username, 'utf-8', $this->config->ldapencoding);
173         $extpassword = core_text::convert($password, 'utf-8', $this->config->ldapencoding);
175         // Before we connect to LDAP, check if this is an AD SSO login
176         // if we succeed in this block, we'll return success early.
177         //
178         $key = sesskey();
179         if (!empty($this->config->ntlmsso_enabled) && $key === $password) {
180             $cf = get_cache_flags($this->pluginconfig.'/ntlmsess');
181             // We only get the cache flag if we retrieve it before
182             // it expires (AUTH_NTLMTIMEOUT seconds).
183             if (!isset($cf[$key]) || $cf[$key] === '') {
184                 return false;
185             }
187             $sessusername = $cf[$key];
188             if ($username === $sessusername) {
189                 unset($sessusername);
190                 unset($cf);
192                 // Check that the user is inside one of the configured LDAP contexts
193                 $validuser = false;
194                 $ldapconnection = $this->ldap_connect();
195                 // if the user is not inside the configured contexts,
196                 // ldap_find_userdn returns false.
197                 if ($this->ldap_find_userdn($ldapconnection, $extusername)) {
198                     $validuser = true;
199                 }
200                 $this->ldap_close();
202                 // Shortcut here - SSO confirmed
203                 return $validuser;
204             }
205         } // End SSO processing
206         unset($key);
208         $ldapconnection = $this->ldap_connect();
209         $ldap_user_dn = $this->ldap_find_userdn($ldapconnection, $extusername);
211         // If ldap_user_dn is empty, user does not exist
212         if (!$ldap_user_dn) {
213             $this->ldap_close();
214             return false;
215         }
217         // Try to bind with current username and password
218         $ldap_login = @ldap_bind($ldapconnection, $ldap_user_dn, $extpassword);
220         // If login fails and we are using MS Active Directory, retrieve the diagnostic
221         // message to see if this is due to an expired password, or that the user is forced to
222         // change the password on first login. If it is, only proceed if we can change
223         // password from Moodle (otherwise we'll get stuck later in the login process).
224         if (!$ldap_login && ($this->config->user_type == 'ad')
225             && $this->can_change_password()
226             && (!empty($this->config->expiration) and ($this->config->expiration == 1))) {
228             // We need to get the diagnostic message right after the call to ldap_bind(),
229             // before any other LDAP operation.
230             ldap_get_option($ldapconnection, LDAP_OPT_DIAGNOSTIC_MESSAGE, $diagmsg);
232             if ($this->ldap_ad_pwdexpired_from_diagmsg($diagmsg)) {
233                 // If login failed because user must change the password now or the
234                 // password has expired, let the user in. We'll catch this later in the
235                 // login process when we explicitly check for expired passwords.
236                 $ldap_login = true;
237             }
238         }
239         $this->ldap_close();
240         return $ldap_login;
241     }
243     /**
244      * Reads user information from ldap and returns it in array()
245      *
246      * Function should return all information available. If you are saving
247      * this information to moodle user-table you should honor syncronization flags
248      *
249      * @param string $username username
250      *
251      * @return mixed array with no magic quotes or false on error
252      */
253     function get_userinfo($username) {
254         $extusername = core_text::convert($username, 'utf-8', $this->config->ldapencoding);
256         $ldapconnection = $this->ldap_connect();
257         if(!($user_dn = $this->ldap_find_userdn($ldapconnection, $extusername))) {
258             $this->ldap_close();
259             return false;
260         }
262         $search_attribs = array();
263         $attrmap = $this->ldap_attributes();
264         foreach ($attrmap as $key => $values) {
265             if (!is_array($values)) {
266                 $values = array($values);
267             }
268             foreach ($values as $value) {
269                 if (!in_array($value, $search_attribs)) {
270                     array_push($search_attribs, $value);
271                 }
272             }
273         }
275         if (!$user_info_result = ldap_read($ldapconnection, $user_dn, '(objectClass=*)', $search_attribs)) {
276             $this->ldap_close();
277             return false; // error!
278         }
280         $user_entry = ldap_get_entries_moodle($ldapconnection, $user_info_result);
281         if (empty($user_entry)) {
282             $this->ldap_close();
283             return false; // entry not found
284         }
286         $result = array();
287         foreach ($attrmap as $key => $values) {
288             if (!is_array($values)) {
289                 $values = array($values);
290             }
291             $ldapval = NULL;
292             foreach ($values as $value) {
293                 $entry = array_change_key_case($user_entry[0], CASE_LOWER);
294                 if (($value == 'dn') || ($value == 'distinguishedname')) {
295                     $result[$key] = $user_dn;
296                     continue;
297                 }
298                 if (!array_key_exists($value, $entry)) {
299                     continue; // wrong data mapping!
300                 }
301                 if (is_array($entry[$value])) {
302                     $newval = core_text::convert($entry[$value][0], $this->config->ldapencoding, 'utf-8');
303                 } else {
304                     $newval = core_text::convert($entry[$value], $this->config->ldapencoding, 'utf-8');
305                 }
306                 if (!empty($newval)) { // favour ldap entries that are set
307                     $ldapval = $newval;
308                 }
309             }
310             if (!is_null($ldapval)) {
311                 $result[$key] = $ldapval;
312             }
313         }
315         $this->ldap_close();
316         return $result;
317     }
319     /**
320      * Reads user information from ldap and returns it in an object
321      *
322      * @param string $username username (with system magic quotes)
323      * @return mixed object or false on error
324      */
325     function get_userinfo_asobj($username) {
326         $user_array = $this->get_userinfo($username);
327         if ($user_array == false) {
328             return false; //error or not found
329         }
330         $user_array = truncate_userinfo($user_array);
331         $user = new stdClass();
332         foreach ($user_array as $key=>$value) {
333             $user->{$key} = $value;
334         }
335         return $user;
336     }
338     /**
339      * Returns all usernames from LDAP
340      *
341      * get_userlist returns all usernames from LDAP
342      *
343      * @return array
344      */
345     function get_userlist() {
346         return $this->ldap_get_userlist("({$this->config->user_attribute}=*)");
347     }
349     /**
350      * Checks if user exists on LDAP
351      *
352      * @param string $username
353      */
354     function user_exists($username) {
355         $extusername = core_text::convert($username, 'utf-8', $this->config->ldapencoding);
357         // Returns true if given username exists on ldap
358         $users = $this->ldap_get_userlist('('.$this->config->user_attribute.'='.ldap_filter_addslashes($extusername).')');
359         return count($users);
360     }
362     /**
363      * Creates a new user on LDAP.
364      * By using information in userobject
365      * Use user_exists to prevent duplicate usernames
366      *
367      * @param mixed $userobject  Moodle userobject
368      * @param mixed $plainpass   Plaintext password
369      */
370     function user_create($userobject, $plainpass) {
371         $extusername = core_text::convert($userobject->username, 'utf-8', $this->config->ldapencoding);
372         $extpassword = core_text::convert($plainpass, 'utf-8', $this->config->ldapencoding);
374         switch ($this->config->passtype) {
375             case 'md5':
376                 $extpassword = '{MD5}' . base64_encode(pack('H*', md5($extpassword)));
377                 break;
378             case 'sha1':
379                 $extpassword = '{SHA}' . base64_encode(pack('H*', sha1($extpassword)));
380                 break;
381             case 'plaintext':
382             default:
383                 break; // plaintext
384         }
386         $ldapconnection = $this->ldap_connect();
387         $attrmap = $this->ldap_attributes();
389         $newuser = array();
391         foreach ($attrmap as $key => $values) {
392             if (!is_array($values)) {
393                 $values = array($values);
394             }
395             foreach ($values as $value) {
396                 if (!empty($userobject->$key) ) {
397                     $newuser[$value] = core_text::convert($userobject->$key, 'utf-8', $this->config->ldapencoding);
398                 }
399             }
400         }
402         //Following sets all mandatory and other forced attribute values
403         //User should be creted as login disabled untill email confirmation is processed
404         //Feel free to add your user type and send patches to paca@sci.fi to add them
405         //Moodle distribution
407         switch ($this->config->user_type)  {
408             case 'edir':
409                 $newuser['objectClass']   = array('inetOrgPerson', 'organizationalPerson', 'person', 'top');
410                 $newuser['uniqueId']      = $extusername;
411                 $newuser['logindisabled'] = 'TRUE';
412                 $newuser['userpassword']  = $extpassword;
413                 $uadd = ldap_add($ldapconnection, $this->config->user_attribute.'='.ldap_addslashes($extusername).','.$this->config->create_context, $newuser);
414                 break;
415             case 'rfc2307':
416             case 'rfc2307bis':
417                 // posixAccount object class forces us to specify a uidNumber
418                 // and a gidNumber. That is quite complicated to generate from
419                 // Moodle without colliding with existing numbers and without
420                 // race conditions. As this user is supposed to be only used
421                 // with Moodle (otherwise the user would exist beforehand) and
422                 // doesn't need to login into a operating system, we assign the
423                 // user the uid of user 'nobody' and gid of group 'nogroup'. In
424                 // addition to that, we need to specify a home directory. We
425                 // use the root directory ('/') as the home directory, as this
426                 // is the only one can always be sure exists. Finally, even if
427                 // it's not mandatory, we specify '/bin/false' as the login
428                 // shell, to prevent the user from login in at the operating
429                 // system level (Moodle ignores this).
431                 $newuser['objectClass']   = array('posixAccount', 'inetOrgPerson', 'organizationalPerson', 'person', 'top');
432                 $newuser['cn']            = $extusername;
433                 $newuser['uid']           = $extusername;
434                 $newuser['uidNumber']     = AUTH_UID_NOBODY;
435                 $newuser['gidNumber']     = AUTH_GID_NOGROUP;
436                 $newuser['homeDirectory'] = '/';
437                 $newuser['loginShell']    = '/bin/false';
439                 // IMPORTANT:
440                 // We have to create the account locked, but posixAccount has
441                 // no attribute to achive this reliably. So we are going to
442                 // modify the password in a reversable way that we can later
443                 // revert in user_activate().
444                 //
445                 // Beware that this can be defeated by the user if we are not
446                 // using MD5 or SHA-1 passwords. After all, the source code of
447                 // Moodle is available, and the user can see the kind of
448                 // modification we are doing and 'undo' it by hand (but only
449                 // if we are using plain text passwords).
450                 //
451                 // Also bear in mind that you need to use a binding user that
452                 // can create accounts and has read/write privileges on the
453                 // 'userPassword' attribute for this to work.
455                 $newuser['userPassword']  = '*'.$extpassword;
456                 $uadd = ldap_add($ldapconnection, $this->config->user_attribute.'='.ldap_addslashes($extusername).','.$this->config->create_context, $newuser);
457                 break;
458             case 'ad':
459                 // User account creation is a two step process with AD. First you
460                 // create the user object, then you set the password. If you try
461                 // to set the password while creating the user, the operation
462                 // fails.
464                 // Passwords in Active Directory must be encoded as Unicode
465                 // strings (UCS-2 Little Endian format) and surrounded with
466                 // double quotes. See http://support.microsoft.com/?kbid=269190
467                 if (!function_exists('mb_convert_encoding')) {
468                     print_error('auth_ldap_no_mbstring', 'auth_ldap');
469                 }
471                 // Check for invalid sAMAccountName characters.
472                 if (preg_match('#[/\\[\]:;|=,+*?<>@"]#', $extusername)) {
473                     print_error ('auth_ldap_ad_invalidchars', 'auth_ldap');
474                 }
476                 // First create the user account, and mark it as disabled.
477                 $newuser['objectClass'] = array('top', 'person', 'user', 'organizationalPerson');
478                 $newuser['sAMAccountName'] = $extusername;
479                 $newuser['userAccountControl'] = AUTH_AD_NORMAL_ACCOUNT |
480                                                  AUTH_AD_ACCOUNTDISABLE;
481                 $userdn = 'cn='.ldap_addslashes($extusername).','.$this->config->create_context;
482                 if (!ldap_add($ldapconnection, $userdn, $newuser)) {
483                     print_error('auth_ldap_ad_create_req', 'auth_ldap');
484                 }
486                 // Now set the password
487                 unset($newuser);
488                 $newuser['unicodePwd'] = mb_convert_encoding('"' . $extpassword . '"',
489                                                              'UCS-2LE', 'UTF-8');
490                 if(!ldap_modify($ldapconnection, $userdn, $newuser)) {
491                     // Something went wrong: delete the user account and error out
492                     ldap_delete ($ldapconnection, $userdn);
493                     print_error('auth_ldap_ad_create_req', 'auth_ldap');
494                 }
495                 $uadd = true;
496                 break;
497             default:
498                print_error('auth_ldap_unsupportedusertype', 'auth_ldap', '', $this->config->user_type_name);
499         }
500         $this->ldap_close();
501         return $uadd;
502     }
504     /**
505      * Returns true if plugin allows resetting of password from moodle.
506      *
507      * @return bool
508      */
509     function can_reset_password() {
510         return !empty($this->config->stdchangepassword);
511     }
513     /**
514      * Returns true if plugin can be manually set.
515      *
516      * @return bool
517      */
518     function can_be_manually_set() {
519         return true;
520     }
522     /**
523      * Returns true if plugin allows signup and user creation.
524      *
525      * @return bool
526      */
527     function can_signup() {
528         return (!empty($this->config->auth_user_create) and !empty($this->config->create_context));
529     }
531     /**
532      * Sign up a new user ready for confirmation.
533      * Password is passed in plaintext.
534      *
535      * @param object $user new user object
536      * @param boolean $notify print notice with link and terminate
537      * @return boolean success
538      */
539     function user_signup($user, $notify=true) {
540         global $CFG, $DB, $PAGE, $OUTPUT;
542         require_once($CFG->dirroot.'/user/profile/lib.php');
543         require_once($CFG->dirroot.'/user/lib.php');
545         if ($this->user_exists($user->username)) {
546             print_error('auth_ldap_user_exists', 'auth_ldap');
547         }
549         $plainslashedpassword = $user->password;
550         unset($user->password);
552         if (! $this->user_create($user, $plainslashedpassword)) {
553             print_error('auth_ldap_create_error', 'auth_ldap');
554         }
556         $user->id = user_create_user($user, false, false);
558         user_add_password_history($user->id, $plainslashedpassword);
560         // Save any custom profile field information
561         profile_save_data($user);
563         $this->update_user_record($user->username);
564         // This will also update the stored hash to the latest algorithm
565         // if the existing hash is using an out-of-date algorithm (or the
566         // legacy md5 algorithm).
567         update_internal_user_password($user, $plainslashedpassword);
569         $user = $DB->get_record('user', array('id'=>$user->id));
571         \core\event\user_created::create_from_userid($user->id)->trigger();
573         if (! send_confirmation_email($user)) {
574             print_error('noemail', 'auth_ldap');
575         }
577         if ($notify) {
578             $emailconfirm = get_string('emailconfirm');
579             $PAGE->set_url('/auth/ldap/auth.php');
580             $PAGE->navbar->add($emailconfirm);
581             $PAGE->set_title($emailconfirm);
582             $PAGE->set_heading($emailconfirm);
583             echo $OUTPUT->header();
584             notice(get_string('emailconfirmsent', '', $user->email), "{$CFG->wwwroot}/index.php");
585         } else {
586             return true;
587         }
588     }
590     /**
591      * Returns true if plugin allows confirming of new users.
592      *
593      * @return bool
594      */
595     function can_confirm() {
596         return $this->can_signup();
597     }
599     /**
600      * Confirm the new user as registered.
601      *
602      * @param string $username
603      * @param string $confirmsecret
604      */
605     function user_confirm($username, $confirmsecret) {
606         global $DB;
608         $user = get_complete_user_data('username', $username);
610         if (!empty($user)) {
611             if ($user->auth != $this->authtype) {
612                 return AUTH_CONFIRM_ERROR;
614             } else if ($user->secret == $confirmsecret && $user->confirmed) {
615                 return AUTH_CONFIRM_ALREADY;
617             } else if ($user->secret == $confirmsecret) {   // They have provided the secret key to get in
618                 if (!$this->user_activate($username)) {
619                     return AUTH_CONFIRM_FAIL;
620                 }
621                 $user->confirmed = 1;
622                 user_update_user($user, false);
623                 return AUTH_CONFIRM_OK;
624             }
625         } else {
626             return AUTH_CONFIRM_ERROR;
627         }
628     }
630     /**
631      * Return number of days to user password expires
632      *
633      * If userpassword does not expire it should return 0. If password is already expired
634      * it should return negative value.
635      *
636      * @param mixed $username username
637      * @return integer
638      */
639     function password_expire($username) {
640         $result = 0;
642         $extusername = core_text::convert($username, 'utf-8', $this->config->ldapencoding);
644         $ldapconnection = $this->ldap_connect();
645         $user_dn = $this->ldap_find_userdn($ldapconnection, $extusername);
646         $search_attribs = array($this->config->expireattr);
647         $sr = ldap_read($ldapconnection, $user_dn, '(objectClass=*)', $search_attribs);
648         if ($sr)  {
649             $info = ldap_get_entries_moodle($ldapconnection, $sr);
650             if (!empty ($info)) {
651                 $info = array_change_key_case($info[0], CASE_LOWER);
652                 if (isset($info[$this->config->expireattr][0])) {
653                     $expiretime = $this->ldap_expirationtime2unix($info[$this->config->expireattr][0], $ldapconnection, $user_dn);
654                     if ($expiretime != 0) {
655                         $now = time();
656                         if ($expiretime > $now) {
657                             $result = ceil(($expiretime - $now) / DAYSECS);
658                         } else {
659                             $result = floor(($expiretime - $now) / DAYSECS);
660                         }
661                     }
662                 }
663             }
664         } else {
665             error_log($this->errorlogtag.get_string('didtfindexpiretime', 'auth_ldap'));
666         }
668         return $result;
669     }
671     /**
672      * Syncronizes user fron external LDAP server to moodle user table
673      *
674      * Sync is now using username attribute.
675      *
676      * Syncing users removes or suspends users that dont exists anymore in external LDAP.
677      * Creates new users and updates coursecreator status of users.
678      *
679      * @param bool $do_updates will do pull in data updates from LDAP if relevant
680      */
681     function sync_users($do_updates=true) {
682         global $CFG, $DB;
684         print_string('connectingldap', 'auth_ldap');
685         $ldapconnection = $this->ldap_connect();
687         $dbman = $DB->get_manager();
689     /// Define table user to be created
690         $table = new xmldb_table('tmp_extuser');
691         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
692         $table->add_field('username', XMLDB_TYPE_CHAR, '100', null, XMLDB_NOTNULL, null, null);
693         $table->add_field('mnethostid', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, null);
694         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
695         $table->add_index('username', XMLDB_INDEX_UNIQUE, array('mnethostid', 'username'));
697         print_string('creatingtemptable', 'auth_ldap', 'tmp_extuser');
698         $dbman->create_temp_table($table);
700         ////
701         //// get user's list from ldap to sql in a scalable fashion
702         ////
703         // prepare some data we'll need
704         $filter = '(&('.$this->config->user_attribute.'=*)'.$this->config->objectclass.')';
706         $contexts = explode(';', $this->config->contexts);
708         if (!empty($this->config->create_context)) {
709             array_push($contexts, $this->config->create_context);
710         }
712         $ldap_pagedresults = ldap_paged_results_supported($this->config->ldap_version);
713         $ldap_cookie = '';
714         foreach ($contexts as $context) {
715             $context = trim($context);
716             if (empty($context)) {
717                 continue;
718             }
720             do {
721                 if ($ldap_pagedresults) {
722                     ldap_control_paged_result($ldapconnection, $this->config->pagesize, true, $ldap_cookie);
723                 }
724                 if ($this->config->search_sub) {
725                     // Use ldap_search to find first user from subtree.
726                     $ldap_result = ldap_search($ldapconnection, $context, $filter, array($this->config->user_attribute));
727                 } else {
728                     // Search only in this context.
729                     $ldap_result = ldap_list($ldapconnection, $context, $filter, array($this->config->user_attribute));
730                 }
731                 if(!$ldap_result) {
732                     continue;
733                 }
734                 if ($ldap_pagedresults) {
735                     ldap_control_paged_result_response($ldapconnection, $ldap_result, $ldap_cookie);
736                 }
737                 if ($entry = @ldap_first_entry($ldapconnection, $ldap_result)) {
738                     do {
739                         $value = ldap_get_values_len($ldapconnection, $entry, $this->config->user_attribute);
740                         $value = core_text::convert($value[0], $this->config->ldapencoding, 'utf-8');
741                         $value = trim($value);
742                         $this->ldap_bulk_insert($value);
743                     } while ($entry = ldap_next_entry($ldapconnection, $entry));
744                 }
745                 unset($ldap_result); // Free mem.
746             } while ($ldap_pagedresults && $ldap_cookie !== null && $ldap_cookie != '');
747         }
749         // If LDAP paged results were used, the current connection must be completely
750         // closed and a new one created, to work without paged results from here on.
751         if ($ldap_pagedresults) {
752             $this->ldap_close(true);
753             $ldapconnection = $this->ldap_connect();
754         }
756         /// preserve our user database
757         /// if the temp table is empty, it probably means that something went wrong, exit
758         /// so as to avoid mass deletion of users; which is hard to undo
759         $count = $DB->count_records_sql('SELECT COUNT(username) AS count, 1 FROM {tmp_extuser}');
760         if ($count < 1) {
761             print_string('didntgetusersfromldap', 'auth_ldap');
762             exit;
763         } else {
764             print_string('gotcountrecordsfromldap', 'auth_ldap', $count);
765         }
768 /// User removal
769         // Find users in DB that aren't in ldap -- to be removed!
770         // this is still not as scalable (but how often do we mass delete?)
772         if ($this->config->removeuser == AUTH_REMOVEUSER_FULLDELETE) {
773             $sql = "SELECT u.*
774                       FROM {user} u
775                  LEFT JOIN {tmp_extuser} e ON (u.username = e.username AND u.mnethostid = e.mnethostid)
776                      WHERE u.auth = :auth
777                            AND u.deleted = 0
778                            AND e.username IS NULL";
779             $remove_users = $DB->get_records_sql($sql, array('auth'=>$this->authtype));
781             if (!empty($remove_users)) {
782                 print_string('userentriestoremove', 'auth_ldap', count($remove_users));
783                 foreach ($remove_users as $user) {
784                     if (delete_user($user)) {
785                         echo "\t"; print_string('auth_dbdeleteuser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)); echo "\n";
786                     } else {
787                         echo "\t"; print_string('auth_dbdeleteusererror', 'auth_db', $user->username); echo "\n";
788                     }
789                 }
790             } else {
791                 print_string('nouserentriestoremove', 'auth_ldap');
792             }
793             unset($remove_users); // Free mem!
795         } else if ($this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
796             $sql = "SELECT u.*
797                       FROM {user} u
798                  LEFT JOIN {tmp_extuser} e ON (u.username = e.username AND u.mnethostid = e.mnethostid)
799                      WHERE u.auth = :auth
800                            AND u.deleted = 0
801                            AND u.suspended = 0
802                            AND e.username IS NULL";
803             $remove_users = $DB->get_records_sql($sql, array('auth'=>$this->authtype));
805             if (!empty($remove_users)) {
806                 print_string('userentriestoremove', 'auth_ldap', count($remove_users));
808                 foreach ($remove_users as $user) {
809                     $updateuser = new stdClass();
810                     $updateuser->id = $user->id;
811                     $updateuser->suspended = 1;
812                     user_update_user($updateuser, false);
813                     echo "\t"; print_string('auth_dbsuspenduser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)); echo "\n";
814                     \core\session\manager::kill_user_sessions($user->id);
815                 }
816             } else {
817                 print_string('nouserentriestoremove', 'auth_ldap');
818             }
819             unset($remove_users); // Free mem!
820         }
822 /// Revive suspended users
823         if (!empty($this->config->removeuser) and $this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
824             $sql = "SELECT u.id, u.username
825                       FROM {user} u
826                       JOIN {tmp_extuser} e ON (u.username = e.username AND u.mnethostid = e.mnethostid)
827                      WHERE (u.auth = 'nologin' OR (u.auth = ? AND u.suspended = 1)) AND u.deleted = 0";
828             // Note: 'nologin' is there for backwards compatibility.
829             $revive_users = $DB->get_records_sql($sql, array($this->authtype));
831             if (!empty($revive_users)) {
832                 print_string('userentriestorevive', 'auth_ldap', count($revive_users));
834                 foreach ($revive_users as $user) {
835                     $updateuser = new stdClass();
836                     $updateuser->id = $user->id;
837                     $updateuser->auth = $this->authtype;
838                     $updateuser->suspended = 0;
839                     user_update_user($updateuser, false);
840                     echo "\t"; print_string('auth_dbreviveduser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)); echo "\n";
841                 }
842             } else {
843                 print_string('nouserentriestorevive', 'auth_ldap');
844             }
846             unset($revive_users);
847         }
850 /// User Updates - time-consuming (optional)
851         if ($do_updates) {
852             // Narrow down what fields we need to update
853             $all_keys = array_keys(get_object_vars($this->config));
854             $updatekeys = array();
855             foreach ($all_keys as $key) {
856                 if (preg_match('/^field_updatelocal_(.+)$/', $key, $match)) {
857                     // If we have a field to update it from
858                     // and it must be updated 'onlogin' we
859                     // update it on cron
860                     if (!empty($this->config->{'field_map_'.$match[1]})
861                          and $this->config->{$match[0]} === 'onlogin') {
862                         array_push($updatekeys, $match[1]); // the actual key name
863                     }
864                 }
865             }
866             unset($all_keys); unset($key);
868         } else {
869             print_string('noupdatestobedone', 'auth_ldap');
870         }
871         if ($do_updates and !empty($updatekeys)) { // run updates only if relevant
872             $users = $DB->get_records_sql('SELECT u.username, u.id
873                                              FROM {user} u
874                                             WHERE u.deleted = 0 AND u.auth = ? AND u.mnethostid = ?',
875                                           array($this->authtype, $CFG->mnet_localhost_id));
876             if (!empty($users)) {
877                 print_string('userentriestoupdate', 'auth_ldap', count($users));
879                 $sitecontext = context_system::instance();
880                 if (!empty($this->config->creators) and !empty($this->config->memberattribute)
881                   and $roles = get_archetype_roles('coursecreator')) {
882                     $creatorrole = array_shift($roles);      // We can only use one, let's use the first one
883                 } else {
884                     $creatorrole = false;
885                 }
887                 $transaction = $DB->start_delegated_transaction();
888                 $xcount = 0;
889                 $maxxcount = 100;
891                 foreach ($users as $user) {
892                     echo "\t"; print_string('auth_dbupdatinguser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id));
893                     if (!$this->update_user_record($user->username, $updatekeys, true)) {
894                         echo ' - '.get_string('skipped');
895                     }
896                     echo "\n";
897                     $xcount++;
899                     // Update course creators if needed
900                     if ($creatorrole !== false) {
901                         if ($this->iscreator($user->username)) {
902                             role_assign($creatorrole->id, $user->id, $sitecontext->id, $this->roleauth);
903                         } else {
904                             role_unassign($creatorrole->id, $user->id, $sitecontext->id, $this->roleauth);
905                         }
906                     }
907                 }
908                 $transaction->allow_commit();
909                 unset($users); // free mem
910             }
911         } else { // end do updates
912             print_string('noupdatestobedone', 'auth_ldap');
913         }
915 /// User Additions
916         // Find users missing in DB that are in LDAP
917         // and gives me a nifty object I don't want.
918         // note: we do not care about deleted accounts anymore, this feature was replaced by suspending to nologin auth plugin
919         $sql = 'SELECT e.id, e.username
920                   FROM {tmp_extuser} e
921                   LEFT JOIN {user} u ON (e.username = u.username AND e.mnethostid = u.mnethostid)
922                  WHERE u.id IS NULL';
923         $add_users = $DB->get_records_sql($sql);
925         if (!empty($add_users)) {
926             print_string('userentriestoadd', 'auth_ldap', count($add_users));
928             $sitecontext = context_system::instance();
929             if (!empty($this->config->creators) and !empty($this->config->memberattribute)
930               and $roles = get_archetype_roles('coursecreator')) {
931                 $creatorrole = array_shift($roles);      // We can only use one, let's use the first one
932             } else {
933                 $creatorrole = false;
934             }
936             $transaction = $DB->start_delegated_transaction();
937             foreach ($add_users as $user) {
938                 $user = $this->get_userinfo_asobj($user->username);
940                 // Prep a few params
941                 $user->modified   = time();
942                 $user->confirmed  = 1;
943                 $user->auth       = $this->authtype;
944                 $user->mnethostid = $CFG->mnet_localhost_id;
945                 // get_userinfo_asobj() might have replaced $user->username with the value
946                 // from the LDAP server (which can be mixed-case). Make sure it's lowercase
947                 $user->username = trim(core_text::strtolower($user->username));
948                 if (empty($user->lang)) {
949                     $user->lang = $CFG->lang;
950                 }
951                 if (empty($user->calendartype)) {
952                     $user->calendartype = $CFG->calendartype;
953                 }
955                 $id = user_create_user($user, false);
956                 echo "\t"; print_string('auth_dbinsertuser', 'auth_db', array('name'=>$user->username, 'id'=>$id)); echo "\n";
957                 $euser = $DB->get_record('user', array('id' => $id));
959                 if (!empty($this->config->forcechangepassword)) {
960                     set_user_preference('auth_forcepasswordchange', 1, $id);
961                 }
963                 // Add course creators if needed
964                 if ($creatorrole !== false and $this->iscreator($user->username)) {
965                     role_assign($creatorrole->id, $id, $sitecontext->id, $this->roleauth);
966                 }
968             }
969             $transaction->allow_commit();
970             unset($add_users); // free mem
971         } else {
972             print_string('nouserstobeadded', 'auth_ldap');
973         }
975         $dbman->drop_table($table);
976         $this->ldap_close();
978         return true;
979     }
981     /**
982      * Update a local user record from an external source.
983      * This is a lighter version of the one in moodlelib -- won't do
984      * expensive ops such as enrolment.
985      *
986      * If you don't pass $updatekeys, there is a performance hit and
987      * values removed from LDAP won't be removed from moodle.
988      *
989      * @param string $username username
990      * @param boolean $updatekeys true to update the local record with the external LDAP values.
991      * @param bool $triggerevent set false if user_updated event should not be triggered.
992      *             This will not affect user_password_updated event triggering.
993      * @return stdClass|bool updated user record or false if there is no new info to update.
994      */
995     function update_user_record($username, $updatekeys = false, $triggerevent = false) {
996         global $CFG, $DB;
998         // Just in case check text case
999         $username = trim(core_text::strtolower($username));
1001         // Get the current user record
1002         $user = $DB->get_record('user', array('username'=>$username, 'mnethostid'=>$CFG->mnet_localhost_id));
1003         if (empty($user)) { // trouble
1004             error_log($this->errorlogtag.get_string('auth_dbusernotexist', 'auth_db', '', $username));
1005             print_error('auth_dbusernotexist', 'auth_db', '', $username);
1006             die;
1007         }
1009         // Protect the userid from being overwritten
1010         $userid = $user->id;
1012         if ($newinfo = $this->get_userinfo($username)) {
1013             $newinfo = truncate_userinfo($newinfo);
1015             if (empty($updatekeys)) { // all keys? this does not support removing values
1016                 $updatekeys = array_keys($newinfo);
1017             }
1019             if (!empty($updatekeys)) {
1020                 $newuser = new stdClass();
1021                 $newuser->id = $userid;
1023                 foreach ($updatekeys as $key) {
1024                     if (isset($newinfo[$key])) {
1025                         $value = $newinfo[$key];
1026                     } else {
1027                         $value = '';
1028                     }
1030                     if (!empty($this->config->{'field_updatelocal_' . $key})) {
1031                         // Only update if it's changed.
1032                         if ($user->{$key} != $value) {
1033                             $newuser->$key = $value;
1034                         }
1035                     }
1036                 }
1037                 user_update_user($newuser, false, $triggerevent);
1038             }
1039         } else {
1040             return false;
1041         }
1042         return $DB->get_record('user', array('id'=>$userid, 'deleted'=>0));
1043     }
1045     /**
1046      * Bulk insert in SQL's temp table
1047      */
1048     function ldap_bulk_insert($username) {
1049         global $DB, $CFG;
1051         $username = core_text::strtolower($username); // usernames are __always__ lowercase.
1052         $DB->insert_record_raw('tmp_extuser', array('username'=>$username,
1053                                                     'mnethostid'=>$CFG->mnet_localhost_id), false, true);
1054         echo '.';
1055     }
1057     /**
1058      * Activates (enables) user in external LDAP so user can login
1059      *
1060      * @param mixed $username
1061      * @return boolean result
1062      */
1063     function user_activate($username) {
1064         $extusername = core_text::convert($username, 'utf-8', $this->config->ldapencoding);
1066         $ldapconnection = $this->ldap_connect();
1068         $userdn = $this->ldap_find_userdn($ldapconnection, $extusername);
1069         switch ($this->config->user_type)  {
1070             case 'edir':
1071                 $newinfo['loginDisabled'] = 'FALSE';
1072                 break;
1073             case 'rfc2307':
1074             case 'rfc2307bis':
1075                 // Remember that we add a '*' character in front of the
1076                 // external password string to 'disable' the account. We just
1077                 // need to remove it.
1078                 $sr = ldap_read($ldapconnection, $userdn, '(objectClass=*)',
1079                                 array('userPassword'));
1080                 $info = ldap_get_entries($ldapconnection, $sr);
1081                 $info[0] = array_change_key_case($info[0], CASE_LOWER);
1082                 $newinfo['userPassword'] = ltrim($info[0]['userpassword'][0], '*');
1083                 break;
1084             case 'ad':
1085                 // We need to unset the ACCOUNTDISABLE bit in the
1086                 // userAccountControl attribute ( see
1087                 // http://support.microsoft.com/kb/305144 )
1088                 $sr = ldap_read($ldapconnection, $userdn, '(objectClass=*)',
1089                                 array('userAccountControl'));
1090                 $info = ldap_get_entries($ldapconnection, $sr);
1091                 $info[0] = array_change_key_case($info[0], CASE_LOWER);
1092                 $newinfo['userAccountControl'] = $info[0]['useraccountcontrol'][0]
1093                                                  & (~AUTH_AD_ACCOUNTDISABLE);
1094                 break;
1095             default:
1096                 print_error('user_activatenotsupportusertype', 'auth_ldap', '', $this->config->user_type_name);
1097         }
1098         $result = ldap_modify($ldapconnection, $userdn, $newinfo);
1099         $this->ldap_close();
1100         return $result;
1101     }
1103     /**
1104      * Returns true if user should be coursecreator.
1105      *
1106      * @param mixed $username    username (without system magic quotes)
1107      * @return mixed result      null if course creators is not configured, boolean otherwise.
1108      */
1109     function iscreator($username) {
1110         if (empty($this->config->creators) or empty($this->config->memberattribute)) {
1111             return null;
1112         }
1114         $extusername = core_text::convert($username, 'utf-8', $this->config->ldapencoding);
1116         $ldapconnection = $this->ldap_connect();
1118         if ($this->config->memberattribute_isdn) {
1119             if(!($userid = $this->ldap_find_userdn($ldapconnection, $extusername))) {
1120                 return false;
1121             }
1122         } else {
1123             $userid = $extusername;
1124         }
1126         $group_dns = explode(';', $this->config->creators);
1127         $creator = ldap_isgroupmember($ldapconnection, $userid, $group_dns, $this->config->memberattribute);
1129         $this->ldap_close();
1131         return $creator;
1132     }
1134     /**
1135      * Called when the user record is updated.
1136      *
1137      * Modifies user in external LDAP server. It takes olduser (before
1138      * changes) and newuser (after changes) compares information and
1139      * saves modified information to external LDAP server.
1140      *
1141      * @param mixed $olduser     Userobject before modifications    (without system magic quotes)
1142      * @param mixed $newuser     Userobject new modified userobject (without system magic quotes)
1143      * @return boolean result
1144      *
1145      */
1146     function user_update($olduser, $newuser) {
1147         global $USER;
1149         if (isset($olduser->username) and isset($newuser->username) and $olduser->username != $newuser->username) {
1150             error_log($this->errorlogtag.get_string('renamingnotallowed', 'auth_ldap'));
1151             return false;
1152         }
1154         if (isset($olduser->auth) and $olduser->auth != $this->authtype) {
1155             return true; // just change auth and skip update
1156         }
1158         $attrmap = $this->ldap_attributes();
1159         // Before doing anything else, make sure we really need to update anything
1160         // in the external LDAP server.
1161         $update_external = false;
1162         foreach ($attrmap as $key => $ldapkeys) {
1163             if (!empty($this->config->{'field_updateremote_'.$key})) {
1164                 $update_external = true;
1165                 break;
1166             }
1167         }
1168         if (!$update_external) {
1169             return true;
1170         }
1172         $extoldusername = core_text::convert($olduser->username, 'utf-8', $this->config->ldapencoding);
1174         $ldapconnection = $this->ldap_connect();
1176         $search_attribs = array();
1177         foreach ($attrmap as $key => $values) {
1178             if (!is_array($values)) {
1179                 $values = array($values);
1180             }
1181             foreach ($values as $value) {
1182                 if (!in_array($value, $search_attribs)) {
1183                     array_push($search_attribs, $value);
1184                 }
1185             }
1186         }
1188         if(!($user_dn = $this->ldap_find_userdn($ldapconnection, $extoldusername))) {
1189             return false;
1190         }
1192         $success = true;
1193         $user_info_result = ldap_read($ldapconnection, $user_dn, '(objectClass=*)', $search_attribs);
1194         if ($user_info_result) {
1195             $user_entry = ldap_get_entries_moodle($ldapconnection, $user_info_result);
1196             if (empty($user_entry)) {
1197                 $attribs = join (', ', $search_attribs);
1198                 error_log($this->errorlogtag.get_string('updateusernotfound', 'auth_ldap',
1199                                                           array('userdn'=>$user_dn,
1200                                                                 'attribs'=>$attribs)));
1201                 return false; // old user not found!
1202             } else if (count($user_entry) > 1) {
1203                 error_log($this->errorlogtag.get_string('morethanoneuser', 'auth_ldap'));
1204                 return false;
1205             }
1207             $user_entry = array_change_key_case($user_entry[0], CASE_LOWER);
1209             foreach ($attrmap as $key => $ldapkeys) {
1210                 $profilefield = '';
1211                 // Only process if the moodle field ($key) has changed and we
1212                 // are set to update LDAP with it
1213                 $customprofilefield = 'profile_field_' . $key;
1214                 if (isset($olduser->$key) and isset($newuser->$key)
1215                     and ($olduser->$key !== $newuser->$key)) {
1216                     $profilefield = $key;
1217                 } else if (isset($olduser->$customprofilefield) && isset($newuser->$customprofilefield)
1218                     && $olduser->$customprofilefield !== $newuser->$customprofilefield) {
1219                     $profilefield = $customprofilefield;
1220                 }
1222                 if (!empty($profilefield) && !empty($this->config->{'field_updateremote_' . $key})) {
1223                     // For ldap values that could be in more than one
1224                     // ldap key, we will do our best to match
1225                     // where they came from
1226                     $ambiguous = true;
1227                     $changed   = false;
1228                     if (!is_array($ldapkeys)) {
1229                         $ldapkeys = array($ldapkeys);
1230                     }
1231                     if (count($ldapkeys) < 2) {
1232                         $ambiguous = false;
1233                     }
1235                     $nuvalue = core_text::convert($newuser->$profilefield, 'utf-8', $this->config->ldapencoding);
1236                     empty($nuvalue) ? $nuvalue = array() : $nuvalue;
1237                     $ouvalue = core_text::convert($olduser->$profilefield, 'utf-8', $this->config->ldapencoding);
1239                     foreach ($ldapkeys as $ldapkey) {
1240                         $ldapkey   = $ldapkey;
1241                         $ldapvalue = $user_entry[$ldapkey][0];
1242                         if (!$ambiguous) {
1243                             // Skip update if the values already match
1244                             if ($nuvalue !== $ldapvalue) {
1245                                 // This might fail due to schema validation
1246                                 if (@ldap_modify($ldapconnection, $user_dn, array($ldapkey => $nuvalue))) {
1247                                     $changed = true;
1248                                     continue;
1249                                 } else {
1250                                     $success = false;
1251                                     error_log($this->errorlogtag.get_string ('updateremfail', 'auth_ldap',
1252                                                                              array('errno'=>ldap_errno($ldapconnection),
1253                                                                                    'errstring'=>ldap_err2str(ldap_errno($ldapconnection)),
1254                                                                                    'key'=>$key,
1255                                                                                    'ouvalue'=>$ouvalue,
1256                                                                                    'nuvalue'=>$nuvalue)));
1257                                     continue;
1258                                 }
1259                             }
1260                         } else {
1261                             // Ambiguous. Value empty before in Moodle (and LDAP) - use
1262                             // 1st ldap candidate field, no need to guess
1263                             if ($ouvalue === '') { // value empty before - use 1st ldap candidate
1264                                 // This might fail due to schema validation
1265                                 if (@ldap_modify($ldapconnection, $user_dn, array($ldapkey => $nuvalue))) {
1266                                     $changed = true;
1267                                     continue;
1268                                 } else {
1269                                     $success = false;
1270                                     error_log($this->errorlogtag.get_string ('updateremfail', 'auth_ldap',
1271                                                                              array('errno'=>ldap_errno($ldapconnection),
1272                                                                                    'errstring'=>ldap_err2str(ldap_errno($ldapconnection)),
1273                                                                                    'key'=>$key,
1274                                                                                    'ouvalue'=>$ouvalue,
1275                                                                                    'nuvalue'=>$nuvalue)));
1276                                     continue;
1277                                 }
1278                             }
1280                             // We found which ldap key to update!
1281                             if ($ouvalue !== '' and $ouvalue === $ldapvalue ) {
1282                                 // This might fail due to schema validation
1283                                 if (@ldap_modify($ldapconnection, $user_dn, array($ldapkey => $nuvalue))) {
1284                                     $changed = true;
1285                                     continue;
1286                                 } else {
1287                                     $success = false;
1288                                     error_log($this->errorlogtag.get_string ('updateremfail', 'auth_ldap',
1289                                                                              array('errno'=>ldap_errno($ldapconnection),
1290                                                                                    'errstring'=>ldap_err2str(ldap_errno($ldapconnection)),
1291                                                                                    'key'=>$key,
1292                                                                                    'ouvalue'=>$ouvalue,
1293                                                                                    'nuvalue'=>$nuvalue)));
1294                                     continue;
1295                                 }
1296                             }
1297                         }
1298                     }
1300                     if ($ambiguous and !$changed) {
1301                         $success = false;
1302                         error_log($this->errorlogtag.get_string ('updateremfailamb', 'auth_ldap',
1303                                                                  array('key'=>$key,
1304                                                                        'ouvalue'=>$ouvalue,
1305                                                                        'nuvalue'=>$nuvalue)));
1306                     }
1307                 }
1308             }
1309         } else {
1310             error_log($this->errorlogtag.get_string ('usernotfound', 'auth_ldap'));
1311             $success = false;
1312         }
1314         $this->ldap_close();
1315         return $success;
1317     }
1319     /**
1320      * Changes userpassword in LDAP
1321      *
1322      * Called when the user password is updated. It assumes it is
1323      * called by an admin or that you've otherwise checked the user's
1324      * credentials
1325      *
1326      * @param  object  $user        User table object
1327      * @param  string  $newpassword Plaintext password (not crypted/md5'ed)
1328      * @return boolean result
1329      *
1330      */
1331     function user_update_password($user, $newpassword) {
1332         global $USER;
1334         $result = false;
1335         $username = $user->username;
1337         $extusername = core_text::convert($username, 'utf-8', $this->config->ldapencoding);
1338         $extpassword = core_text::convert($newpassword, 'utf-8', $this->config->ldapencoding);
1340         switch ($this->config->passtype) {
1341             case 'md5':
1342                 $extpassword = '{MD5}' . base64_encode(pack('H*', md5($extpassword)));
1343                 break;
1344             case 'sha1':
1345                 $extpassword = '{SHA}' . base64_encode(pack('H*', sha1($extpassword)));
1346                 break;
1347             case 'plaintext':
1348             default:
1349                 break; // plaintext
1350         }
1352         $ldapconnection = $this->ldap_connect();
1354         $user_dn = $this->ldap_find_userdn($ldapconnection, $extusername);
1356         if (!$user_dn) {
1357             error_log($this->errorlogtag.get_string ('nodnforusername', 'auth_ldap', $user->username));
1358             return false;
1359         }
1361         switch ($this->config->user_type) {
1362             case 'edir':
1363                 // Change password
1364                 $result = ldap_modify($ldapconnection, $user_dn, array('userPassword' => $extpassword));
1365                 if (!$result) {
1366                     error_log($this->errorlogtag.get_string ('updatepasserror', 'auth_ldap',
1367                                                                array('errno'=>ldap_errno($ldapconnection),
1368                                                                      'errstring'=>ldap_err2str(ldap_errno($ldapconnection)))));
1369                 }
1370                 // Update password expiration time, grace logins count
1371                 $search_attribs = array($this->config->expireattr, 'passwordExpirationInterval', 'loginGraceLimit');
1372                 $sr = ldap_read($ldapconnection, $user_dn, '(objectClass=*)', $search_attribs);
1373                 if ($sr) {
1374                     $entry = ldap_get_entries_moodle($ldapconnection, $sr);
1375                     $info = array_change_key_case($entry[0], CASE_LOWER);
1376                     $newattrs = array();
1377                     if (!empty($info[$this->config->expireattr][0])) {
1378                         // Set expiration time only if passwordExpirationInterval is defined
1379                         if (!empty($info['passwordexpirationinterval'][0])) {
1380                            $expirationtime = time() + $info['passwordexpirationinterval'][0];
1381                            $ldapexpirationtime = $this->ldap_unix2expirationtime($expirationtime);
1382                            $newattrs['passwordExpirationTime'] = $ldapexpirationtime;
1383                         }
1385                         // Set gracelogin count
1386                         if (!empty($info['logingracelimit'][0])) {
1387                            $newattrs['loginGraceRemaining']= $info['logingracelimit'][0];
1388                         }
1390                         // Store attribute changes in LDAP
1391                         $result = ldap_modify($ldapconnection, $user_dn, $newattrs);
1392                         if (!$result) {
1393                             error_log($this->errorlogtag.get_string ('updatepasserrorexpiregrace', 'auth_ldap',
1394                                                                        array('errno'=>ldap_errno($ldapconnection),
1395                                                                              'errstring'=>ldap_err2str(ldap_errno($ldapconnection)))));
1396                         }
1397                     }
1398                 }
1399                 else {
1400                     error_log($this->errorlogtag.get_string ('updatepasserrorexpire', 'auth_ldap',
1401                                                              array('errno'=>ldap_errno($ldapconnection),
1402                                                                    'errstring'=>ldap_err2str(ldap_errno($ldapconnection)))));
1403                 }
1404                 break;
1406             case 'ad':
1407                 // Passwords in Active Directory must be encoded as Unicode
1408                 // strings (UCS-2 Little Endian format) and surrounded with
1409                 // double quotes. See http://support.microsoft.com/?kbid=269190
1410                 if (!function_exists('mb_convert_encoding')) {
1411                     error_log($this->errorlogtag.get_string ('needmbstring', 'auth_ldap'));
1412                     return false;
1413                 }
1414                 $extpassword = mb_convert_encoding('"'.$extpassword.'"', "UCS-2LE", $this->config->ldapencoding);
1415                 $result = ldap_modify($ldapconnection, $user_dn, array('unicodePwd' => $extpassword));
1416                 if (!$result) {
1417                     error_log($this->errorlogtag.get_string ('updatepasserror', 'auth_ldap',
1418                                                              array('errno'=>ldap_errno($ldapconnection),
1419                                                                    'errstring'=>ldap_err2str(ldap_errno($ldapconnection)))));
1420                 }
1421                 break;
1423             default:
1424                 // Send LDAP the password in cleartext, it will md5 it itself
1425                 $result = ldap_modify($ldapconnection, $user_dn, array('userPassword' => $extpassword));
1426                 if (!$result) {
1427                     error_log($this->errorlogtag.get_string ('updatepasserror', 'auth_ldap',
1428                                                              array('errno'=>ldap_errno($ldapconnection),
1429                                                                    'errstring'=>ldap_err2str(ldap_errno($ldapconnection)))));
1430                 }
1432         }
1434         $this->ldap_close();
1435         return $result;
1436     }
1438     /**
1439      * Take expirationtime and return it as unix timestamp in seconds
1440      *
1441      * Takes expiration timestamp as read from LDAP and returns it as unix timestamp in seconds
1442      * Depends on $this->config->user_type variable
1443      *
1444      * @param mixed time   Time stamp read from LDAP as it is.
1445      * @param string $ldapconnection Only needed for Active Directory.
1446      * @param string $user_dn User distinguished name for the user we are checking password expiration (only needed for Active Directory).
1447      * @return timestamp
1448      */
1449     function ldap_expirationtime2unix ($time, $ldapconnection, $user_dn) {
1450         $result = false;
1451         switch ($this->config->user_type) {
1452             case 'edir':
1453                 $yr=substr($time, 0, 4);
1454                 $mo=substr($time, 4, 2);
1455                 $dt=substr($time, 6, 2);
1456                 $hr=substr($time, 8, 2);
1457                 $min=substr($time, 10, 2);
1458                 $sec=substr($time, 12, 2);
1459                 $result = mktime($hr, $min, $sec, $mo, $dt, $yr);
1460                 break;
1461             case 'rfc2307':
1462             case 'rfc2307bis':
1463                 $result = $time * DAYSECS; // The shadowExpire contains the number of DAYS between 01/01/1970 and the actual expiration date
1464                 break;
1465             case 'ad':
1466                 $result = $this->ldap_get_ad_pwdexpire($time, $ldapconnection, $user_dn);
1467                 break;
1468             default:
1469                 print_error('auth_ldap_usertypeundefined', 'auth_ldap');
1470         }
1471         return $result;
1472     }
1474     /**
1475      * Takes unix timestamp and returns it formated for storing in LDAP
1476      *
1477      * @param integer unix time stamp
1478      */
1479     function ldap_unix2expirationtime($time) {
1480         $result = false;
1481         switch ($this->config->user_type) {
1482             case 'edir':
1483                 $result=date('YmdHis', $time).'Z';
1484                 break;
1485             case 'rfc2307':
1486             case 'rfc2307bis':
1487                 $result = $time ; // Already in correct format
1488                 break;
1489             default:
1490                 print_error('auth_ldap_usertypeundefined2', 'auth_ldap');
1491         }
1492         return $result;
1494     }
1496     /**
1497      * Returns user attribute mappings between moodle and LDAP
1498      *
1499      * @return array
1500      */
1502     function ldap_attributes () {
1503         $moodleattributes = array();
1504         // If we have custom fields then merge them with user fields.
1505         $customfields = $this->get_custom_user_profile_fields();
1506         if (!empty($customfields) && !empty($this->userfields)) {
1507             $userfields = array_merge($this->userfields, $customfields);
1508         } else {
1509             $userfields = $this->userfields;
1510         }
1512         foreach ($userfields as $field) {
1513             if (!empty($this->config->{"field_map_$field"})) {
1514                 $moodleattributes[$field] = core_text::strtolower(trim($this->config->{"field_map_$field"}));
1515                 if (preg_match('/,/', $moodleattributes[$field])) {
1516                     $moodleattributes[$field] = explode(',', $moodleattributes[$field]); // split ?
1517                 }
1518             }
1519         }
1520         $moodleattributes['username'] = core_text::strtolower(trim($this->config->user_attribute));
1521         return $moodleattributes;
1522     }
1524     /**
1525      * Returns all usernames from LDAP
1526      *
1527      * @param $filter An LDAP search filter to select desired users
1528      * @return array of LDAP user names converted to UTF-8
1529      */
1530     function ldap_get_userlist($filter='*') {
1531         $fresult = array();
1533         $ldapconnection = $this->ldap_connect();
1535         if ($filter == '*') {
1536            $filter = '(&('.$this->config->user_attribute.'=*)'.$this->config->objectclass.')';
1537         }
1539         $contexts = explode(';', $this->config->contexts);
1540         if (!empty($this->config->create_context)) {
1541             array_push($contexts, $this->config->create_context);
1542         }
1544         $ldap_cookie = '';
1545         $ldap_pagedresults = ldap_paged_results_supported($this->config->ldap_version);
1546         foreach ($contexts as $context) {
1547             $context = trim($context);
1548             if (empty($context)) {
1549                 continue;
1550             }
1552             do {
1553                 if ($ldap_pagedresults) {
1554                     ldap_control_paged_result($ldapconnection, $this->config->pagesize, true, $ldap_cookie);
1555                 }
1556                 if ($this->config->search_sub) {
1557                     // Use ldap_search to find first user from subtree.
1558                     $ldap_result = ldap_search($ldapconnection, $context, $filter, array($this->config->user_attribute));
1559                 } else {
1560                     // Search only in this context.
1561                     $ldap_result = ldap_list($ldapconnection, $context, $filter, array($this->config->user_attribute));
1562                 }
1563                 if(!$ldap_result) {
1564                     continue;
1565                 }
1566                 if ($ldap_pagedresults) {
1567                     ldap_control_paged_result_response($ldapconnection, $ldap_result, $ldap_cookie);
1568                 }
1569                 $users = ldap_get_entries_moodle($ldapconnection, $ldap_result);
1570                 // Add found users to list.
1571                 for ($i = 0; $i < count($users); $i++) {
1572                     $extuser = core_text::convert($users[$i][$this->config->user_attribute][0],
1573                                                 $this->config->ldapencoding, 'utf-8');
1574                     array_push($fresult, $extuser);
1575                 }
1576                 unset($ldap_result); // Free mem.
1577             } while ($ldap_pagedresults && !empty($ldap_cookie));
1578         }
1580         // If paged results were used, make sure the current connection is completely closed
1581         $this->ldap_close($ldap_pagedresults);
1582         return $fresult;
1583     }
1585     /**
1586      * Indicates if password hashes should be stored in local moodle database.
1587      *
1588      * @return bool true means flag 'not_cached' stored instead of password hash
1589      */
1590     function prevent_local_passwords() {
1591         return !empty($this->config->preventpassindb);
1592     }
1594     /**
1595      * Returns true if this authentication plugin is 'internal'.
1596      *
1597      * @return bool
1598      */
1599     function is_internal() {
1600         return false;
1601     }
1603     /**
1604      * Returns true if this authentication plugin can change the user's
1605      * password.
1606      *
1607      * @return bool
1608      */
1609     function can_change_password() {
1610         return !empty($this->config->stdchangepassword) or !empty($this->config->changepasswordurl);
1611     }
1613     /**
1614      * Returns the URL for changing the user's password, or empty if the default can
1615      * be used.
1616      *
1617      * @return moodle_url
1618      */
1619     function change_password_url() {
1620         if (empty($this->config->stdchangepassword)) {
1621             if (!empty($this->config->changepasswordurl)) {
1622                 return new moodle_url($this->config->changepasswordurl);
1623             } else {
1624                 return null;
1625             }
1626         } else {
1627             return null;
1628         }
1629     }
1631     /**
1632      * Will get called before the login page is shownr. Ff NTLM SSO
1633      * is enabled, and the user is in the right network, we'll redirect
1634      * to the magic NTLM page for SSO...
1635      *
1636      */
1637     function loginpage_hook() {
1638         global $CFG, $SESSION;
1640         // HTTPS is potentially required
1641         //httpsrequired(); - this must be used before setting the URL, it is already done on the login/index.php
1643         if (($_SERVER['REQUEST_METHOD'] === 'GET'         // Only on initial GET of loginpage
1644              || ($_SERVER['REQUEST_METHOD'] === 'POST'
1645                  && (get_local_referer() != strip_querystring(qualified_me()))))
1646                                                           // Or when POSTed from another place
1647                                                           // See MDL-14071
1648             && !empty($this->config->ntlmsso_enabled)     // SSO enabled
1649             && !empty($this->config->ntlmsso_subnet)      // have a subnet to test for
1650             && empty($_GET['authldap_skipntlmsso'])       // haven't failed it yet
1651             && (isguestuser() || !isloggedin())           // guestuser or not-logged-in users
1652             && address_in_subnet(getremoteaddr(), $this->config->ntlmsso_subnet)) {
1654             // First, let's remember where we were trying to get to before we got here
1655             if (empty($SESSION->wantsurl)) {
1656                 $SESSION->wantsurl = null;
1657                 $referer = get_safe_referer(false);
1658                 if ($referer &&
1659                         $referer != $CFG->wwwroot &&
1660                         $referer != $CFG->wwwroot . '/' &&
1661                         $referer != $CFG->httpswwwroot . '/login/' &&
1662                         $referer != $CFG->httpswwwroot . '/login/index.php') {
1663                     $SESSION->wantsurl = $referer;
1664                 }
1665             }
1667             // Now start the whole NTLM machinery.
1668             if($this->config->ntlmsso_ie_fastpath == AUTH_NTLM_FASTPATH_YESATTEMPT ||
1669                 $this->config->ntlmsso_ie_fastpath == AUTH_NTLM_FASTPATH_YESFORM) {
1670                 if (core_useragent::is_ie()) {
1671                     $sesskey = sesskey();
1672                     redirect($CFG->wwwroot.'/auth/ldap/ntlmsso_magic.php?sesskey='.$sesskey);
1673                 } else if ($this->config->ntlmsso_ie_fastpath == AUTH_NTLM_FASTPATH_YESFORM) {
1674                     redirect($CFG->httpswwwroot.'/login/index.php?authldap_skipntlmsso=1');
1675                 }
1676             }
1677             redirect($CFG->wwwroot.'/auth/ldap/ntlmsso_attempt.php');
1678         }
1680         // No NTLM SSO, Use the normal login page instead.
1682         // If $SESSION->wantsurl is empty and we have a 'Referer:' header, the login
1683         // page insists on redirecting us to that page after user validation. If
1684         // we clicked on the redirect link at the ntlmsso_finish.php page (instead
1685         // of waiting for the redirection to happen) then we have a 'Referer:' header
1686         // we don't want to use at all. As we can't get rid of it, just point
1687         // $SESSION->wantsurl to $CFG->wwwroot (after all, we came from there).
1688         if (empty($SESSION->wantsurl)
1689             && (get_referer() == $CFG->httpswwwroot.'/auth/ldap/ntlmsso_finish.php')) {
1691             $SESSION->wantsurl = $CFG->wwwroot;
1692         }
1693     }
1695     /**
1696      * To be called from a page running under NTLM's
1697      * "Integrated Windows Authentication".
1698      *
1699      * If successful, it will set a special "cookie" (not an HTTP cookie!)
1700      * in cache_flags under the $this->pluginconfig/ntlmsess "plugin" and return true.
1701      * The "cookie" will be picked up by ntlmsso_finish() to complete the
1702      * process.
1703      *
1704      * On failure it will return false for the caller to display an appropriate
1705      * error message (probably saying that Integrated Windows Auth isn't enabled!)
1706      *
1707      * NOTE that this code will execute under the OS user credentials,
1708      * so we MUST avoid dealing with files -- such as session files.
1709      * (The caller should define('NO_MOODLE_COOKIES', true) before including config.php)
1710      *
1711      */
1712     function ntlmsso_magic($sesskey) {
1713         if (isset($_SERVER['REMOTE_USER']) && !empty($_SERVER['REMOTE_USER'])) {
1715             // HTTP __headers__ seem to be sent in ISO-8859-1 encoding
1716             // (according to my reading of RFC-1945, RFC-2616 and RFC-2617 and
1717             // my local tests), so we need to convert the REMOTE_USER value
1718             // (i.e., what we got from the HTTP WWW-Authenticate header) into UTF-8
1719             $username = core_text::convert($_SERVER['REMOTE_USER'], 'iso-8859-1', 'utf-8');
1721             switch ($this->config->ntlmsso_type) {
1722                 case 'ntlm':
1723                     // The format is now configurable, so try to extract the username
1724                     $username = $this->get_ntlm_remote_user($username);
1725                     if (empty($username)) {
1726                         return false;
1727                     }
1728                     break;
1729                 case 'kerberos':
1730                     // Format is username@DOMAIN
1731                     $username = substr($username, 0, strpos($username, '@'));
1732                     break;
1733                 default:
1734                     error_log($this->errorlogtag.get_string ('ntlmsso_unknowntype', 'auth_ldap'));
1735                     return false; // Should never happen!
1736             }
1738             $username = core_text::strtolower($username); // Compatibility hack
1739             set_cache_flag($this->pluginconfig.'/ntlmsess', $sesskey, $username, AUTH_NTLMTIMEOUT);
1740             return true;
1741         }
1742         return false;
1743     }
1745     /**
1746      * Find the session set by ntlmsso_magic(), validate it and
1747      * call authenticate_user_login() to authenticate the user through
1748      * the auth machinery.
1749      *
1750      * It is complemented by a similar check in user_login().
1751      *
1752      * If it succeeds, it never returns.
1753      *
1754      */
1755     function ntlmsso_finish() {
1756         global $CFG, $USER, $SESSION;
1758         $key = sesskey();
1759         $cf = get_cache_flags($this->pluginconfig.'/ntlmsess');
1760         if (!isset($cf[$key]) || $cf[$key] === '') {
1761             return false;
1762         }
1763         $username   = $cf[$key];
1765         // Here we want to trigger the whole authentication machinery
1766         // to make sure no step is bypassed...
1767         $user = authenticate_user_login($username, $key);
1768         if ($user) {
1769             complete_user_login($user);
1771             // Cleanup the key to prevent reuse...
1772             // and to allow re-logins with normal credentials
1773             unset_cache_flag($this->pluginconfig.'/ntlmsess', $key);
1775             // Redirection
1776             if (user_not_fully_set_up($USER)) {
1777                 $urltogo = $CFG->wwwroot.'/user/edit.php';
1778                 // We don't delete $SESSION->wantsurl yet, so we get there later
1779             } else if (isset($SESSION->wantsurl) and (strpos($SESSION->wantsurl, $CFG->wwwroot) === 0)) {
1780                 $urltogo = $SESSION->wantsurl;    // Because it's an address in this site
1781                 unset($SESSION->wantsurl);
1782             } else {
1783                 // No wantsurl stored or external - go to homepage
1784                 $urltogo = $CFG->wwwroot.'/';
1785                 unset($SESSION->wantsurl);
1786             }
1787             // We do not want to redirect if we are in a PHPUnit test.
1788             if (!PHPUNIT_TEST) {
1789                 redirect($urltogo);
1790             }
1791         }
1792         // Should never reach here.
1793         return false;
1794     }
1796     /**
1797      * Sync roles for this user
1798      *
1799      * @param $user object user object (without system magic quotes)
1800      */
1801     function sync_roles($user) {
1802         $iscreator = $this->iscreator($user->username);
1803         if ($iscreator === null) {
1804             return; // Nothing to sync - creators not configured
1805         }
1807         if ($roles = get_archetype_roles('coursecreator')) {
1808             $creatorrole = array_shift($roles);      // We can only use one, let's use the first one
1809             $systemcontext = context_system::instance();
1811             if ($iscreator) { // Following calls will not create duplicates
1812                 role_assign($creatorrole->id, $user->id, $systemcontext->id, $this->roleauth);
1813             } else {
1814                 // Unassign only if previously assigned by this plugin!
1815                 role_unassign($creatorrole->id, $user->id, $systemcontext->id, $this->roleauth);
1816             }
1817         }
1818     }
1820     /**
1821      * Prints a form for configuring this authentication plugin.
1822      *
1823      * This function is called from admin/auth.php, and outputs a full page with
1824      * a form for configuring this plugin.
1825      *
1826      * @param array $page An object containing all the data for this page.
1827      */
1828     function config_form($config, $err, $user_fields) {
1829         global $CFG, $OUTPUT;
1831         if (!function_exists('ldap_connect')) { // Is php-ldap really there?
1832             echo $OUTPUT->notification(get_string('auth_ldap_noextension', 'auth_ldap'));
1833             return;
1834         }
1836         include($CFG->dirroot.'/auth/ldap/config.html');
1837     }
1839     /**
1840      * Processes and stores configuration data for this authentication plugin.
1841      */
1842     function process_config($config) {
1843         // Set to defaults if undefined
1844         if (!isset($config->host_url)) {
1845              $config->host_url = '';
1846         }
1847         if (!isset($config->start_tls)) {
1848              $config->start_tls = false;
1849         }
1850         if (empty($config->ldapencoding)) {
1851          $config->ldapencoding = 'utf-8';
1852         }
1853         if (!isset($config->pagesize)) {
1854             $config->pagesize = LDAP_DEFAULT_PAGESIZE;
1855         }
1856         if (!isset($config->contexts)) {
1857              $config->contexts = '';
1858         }
1859         if (!isset($config->user_type)) {
1860              $config->user_type = 'default';
1861         }
1862         if (!isset($config->user_attribute)) {
1863              $config->user_attribute = '';
1864         }
1865         if (!isset($config->search_sub)) {
1866              $config->search_sub = '';
1867         }
1868         if (!isset($config->opt_deref)) {
1869              $config->opt_deref = LDAP_DEREF_NEVER;
1870         }
1871         if (!isset($config->preventpassindb)) {
1872              $config->preventpassindb = 0;
1873         }
1874         if (!isset($config->bind_dn)) {
1875             $config->bind_dn = '';
1876         }
1877         if (!isset($config->bind_pw)) {
1878             $config->bind_pw = '';
1879         }
1880         if (!isset($config->ldap_version)) {
1881             $config->ldap_version = '3';
1882         }
1883         if (!isset($config->objectclass)) {
1884             $config->objectclass = '';
1885         }
1886         if (!isset($config->memberattribute)) {
1887             $config->memberattribute = '';
1888         }
1889         if (!isset($config->memberattribute_isdn)) {
1890             $config->memberattribute_isdn = '';
1891         }
1892         if (!isset($config->creators)) {
1893             $config->creators = '';
1894         }
1895         if (!isset($config->create_context)) {
1896             $config->create_context = '';
1897         }
1898         if (!isset($config->expiration)) {
1899             $config->expiration = '';
1900         }
1901         if (!isset($config->expiration_warning)) {
1902             $config->expiration_warning = '10';
1903         }
1904         if (!isset($config->expireattr)) {
1905             $config->expireattr = '';
1906         }
1907         if (!isset($config->gracelogins)) {
1908             $config->gracelogins = '';
1909         }
1910         if (!isset($config->graceattr)) {
1911             $config->graceattr = '';
1912         }
1913         if (!isset($config->auth_user_create)) {
1914             $config->auth_user_create = '';
1915         }
1916         if (!isset($config->forcechangepassword)) {
1917             $config->forcechangepassword = 0;
1918         }
1919         if (!isset($config->stdchangepassword)) {
1920             $config->stdchangepassword = 0;
1921         }
1922         if (!isset($config->passtype)) {
1923             $config->passtype = 'plaintext';
1924         }
1925         if (!isset($config->changepasswordurl)) {
1926             $config->changepasswordurl = '';
1927         }
1928         if (!isset($config->removeuser)) {
1929             $config->removeuser = AUTH_REMOVEUSER_KEEP;
1930         }
1931         if (!isset($config->ntlmsso_enabled)) {
1932             $config->ntlmsso_enabled = 0;
1933         }
1934         if (!isset($config->ntlmsso_subnet)) {
1935             $config->ntlmsso_subnet = '';
1936         }
1937         if (!isset($config->ntlmsso_ie_fastpath)) {
1938             $config->ntlmsso_ie_fastpath = 0;
1939         }
1940         if (!isset($config->ntlmsso_type)) {
1941             $config->ntlmsso_type = 'ntlm';
1942         }
1943         if (!isset($config->ntlmsso_remoteuserformat)) {
1944             $config->ntlmsso_remoteuserformat = '';
1945         }
1947         // Try to remove duplicates before storing the contexts (to avoid problems in sync_users()).
1948         $config->contexts = explode(';', $config->contexts);
1949         $config->contexts = array_map(create_function('$x', 'return core_text::strtolower(trim($x));'),
1950                                       $config->contexts);
1951         $config->contexts = implode(';', array_unique($config->contexts));
1953         // Save settings
1954         set_config('host_url', trim($config->host_url), $this->pluginconfig);
1955         set_config('start_tls', $config->start_tls, $this->pluginconfig);
1956         set_config('ldapencoding', trim($config->ldapencoding), $this->pluginconfig);
1957         set_config('pagesize', (int)trim($config->pagesize), $this->pluginconfig);
1958         set_config('contexts', $config->contexts, $this->pluginconfig);
1959         set_config('user_type', core_text::strtolower(trim($config->user_type)), $this->pluginconfig);
1960         set_config('user_attribute', core_text::strtolower(trim($config->user_attribute)), $this->pluginconfig);
1961         set_config('search_sub', $config->search_sub, $this->pluginconfig);
1962         set_config('opt_deref', $config->opt_deref, $this->pluginconfig);
1963         set_config('preventpassindb', $config->preventpassindb, $this->pluginconfig);
1964         set_config('bind_dn', trim($config->bind_dn), $this->pluginconfig);
1965         set_config('bind_pw', $config->bind_pw, $this->pluginconfig);
1966         set_config('ldap_version', $config->ldap_version, $this->pluginconfig);
1967         set_config('objectclass', trim($config->objectclass), $this->pluginconfig);
1968         set_config('memberattribute', core_text::strtolower(trim($config->memberattribute)), $this->pluginconfig);
1969         set_config('memberattribute_isdn', $config->memberattribute_isdn, $this->pluginconfig);
1970         set_config('creators', trim($config->creators), $this->pluginconfig);
1971         set_config('create_context', trim($config->create_context), $this->pluginconfig);
1972         set_config('expiration', $config->expiration, $this->pluginconfig);
1973         set_config('expiration_warning', trim($config->expiration_warning), $this->pluginconfig);
1974         set_config('expireattr', core_text::strtolower(trim($config->expireattr)), $this->pluginconfig);
1975         set_config('gracelogins', $config->gracelogins, $this->pluginconfig);
1976         set_config('graceattr', core_text::strtolower(trim($config->graceattr)), $this->pluginconfig);
1977         set_config('auth_user_create', $config->auth_user_create, $this->pluginconfig);
1978         set_config('forcechangepassword', $config->forcechangepassword, $this->pluginconfig);
1979         set_config('stdchangepassword', $config->stdchangepassword, $this->pluginconfig);
1980         set_config('passtype', $config->passtype, $this->pluginconfig);
1981         set_config('changepasswordurl', trim($config->changepasswordurl), $this->pluginconfig);
1982         set_config('removeuser', $config->removeuser, $this->pluginconfig);
1983         set_config('ntlmsso_enabled', (int)$config->ntlmsso_enabled, $this->pluginconfig);
1984         set_config('ntlmsso_subnet', trim($config->ntlmsso_subnet), $this->pluginconfig);
1985         set_config('ntlmsso_ie_fastpath', (int)$config->ntlmsso_ie_fastpath, $this->pluginconfig);
1986         set_config('ntlmsso_type', $config->ntlmsso_type, 'auth/ldap');
1987         set_config('ntlmsso_remoteuserformat', trim($config->ntlmsso_remoteuserformat), 'auth/ldap');
1989         return true;
1990     }
1992     /**
1993      * Get password expiration time for a given user from Active Directory
1994      *
1995      * @param string $pwdlastset The time last time we changed the password.
1996      * @param resource $lcapconn The open LDAP connection.
1997      * @param string $user_dn The distinguished name of the user we are checking.
1998      *
1999      * @return string $unixtime
2000      */
2001     function ldap_get_ad_pwdexpire($pwdlastset, $ldapconn, $user_dn){
2002         global $CFG;
2004         if (!function_exists('bcsub')) {
2005             error_log($this->errorlogtag.get_string ('needbcmath', 'auth_ldap'));
2006             return 0;
2007         }
2009         // If UF_DONT_EXPIRE_PASSWD flag is set in user's
2010         // userAccountControl attribute, the password doesn't expire.
2011         $sr = ldap_read($ldapconn, $user_dn, '(objectClass=*)',
2012                         array('userAccountControl'));
2013         if (!$sr) {
2014             error_log($this->errorlogtag.get_string ('useracctctrlerror', 'auth_ldap', $user_dn));
2015             // Don't expire password, as we are not sure if it has to be
2016             // expired or not.
2017             return 0;
2018         }
2020         $entry = ldap_get_entries_moodle($ldapconn, $sr);
2021         $info = array_change_key_case($entry[0], CASE_LOWER);
2022         $useraccountcontrol = $info['useraccountcontrol'][0];
2023         if ($useraccountcontrol & UF_DONT_EXPIRE_PASSWD) {
2024             // Password doesn't expire.
2025             return 0;
2026         }
2028         // If pwdLastSet is zero, the user must change his/her password now
2029         // (unless UF_DONT_EXPIRE_PASSWD flag is set, but we already
2030         // tested this above)
2031         if ($pwdlastset === '0') {
2032             // Password has expired
2033             return -1;
2034         }
2036         // ----------------------------------------------------------------
2037         // Password expiration time in Active Directory is the composition of
2038         // two values:
2039         //
2040         //   - User's pwdLastSet attribute, that stores the last time
2041         //     the password was changed.
2042         //
2043         //   - Domain's maxPwdAge attribute, that sets how long
2044         //     passwords last in this domain.
2045         //
2046         // We already have the first value (passed in as a parameter). We
2047         // need to get the second one. As we don't know the domain DN, we
2048         // have to query rootDSE's defaultNamingContext attribute to get
2049         // it. Then we have to query that DN's maxPwdAge attribute to get
2050         // the real value.
2051         //
2052         // Once we have both values, we just need to combine them. But MS
2053         // chose to use a different base and unit for time measurements.
2054         // So we need to convert the values to Unix timestamps (see
2055         // details below).
2056         // ----------------------------------------------------------------
2058         $sr = ldap_read($ldapconn, ROOTDSE, '(objectClass=*)',
2059                         array('defaultNamingContext'));
2060         if (!$sr) {
2061             error_log($this->errorlogtag.get_string ('rootdseerror', 'auth_ldap'));
2062             return 0;
2063         }
2065         $entry = ldap_get_entries_moodle($ldapconn, $sr);
2066         $info = array_change_key_case($entry[0], CASE_LOWER);
2067         $domaindn = $info['defaultnamingcontext'][0];
2069         $sr = ldap_read ($ldapconn, $domaindn, '(objectClass=*)',
2070                          array('maxPwdAge'));
2071         $entry = ldap_get_entries_moodle($ldapconn, $sr);
2072         $info = array_change_key_case($entry[0], CASE_LOWER);
2073         $maxpwdage = $info['maxpwdage'][0];
2075         // ----------------------------------------------------------------
2076         // MSDN says that "pwdLastSet contains the number of 100 nanosecond
2077         // intervals since January 1, 1601 (UTC), stored in a 64 bit integer".
2078         //
2079         // According to Perl's Date::Manip, the number of seconds between
2080         // this date and Unix epoch is 11644473600. So we have to
2081         // substract this value to calculate a Unix time, once we have
2082         // scaled pwdLastSet to seconds. This is the script used to
2083         // calculate the value shown above:
2084         //
2085         //    #!/usr/bin/perl -w
2086         //
2087         //    use Date::Manip;
2088         //
2089         //    $date1 = ParseDate ("160101010000 UTC");
2090         //    $date2 = ParseDate ("197001010000 UTC");
2091         //    $delta = DateCalc($date1, $date2, \$err);
2092         //    $secs = Delta_Format($delta, 0, "%st");
2093         //    print "$secs \n";
2094         //
2095         // MSDN also says that "maxPwdAge is stored as a large integer that
2096         // represents the number of 100 nanosecond intervals from the time
2097         // the password was set before the password expires." We also need
2098         // to scale this to seconds. Bear in mind that this value is stored
2099         // as a _negative_ quantity (at least in my AD domain).
2100         //
2101         // As a last remark, if the low 32 bits of maxPwdAge are equal to 0,
2102         // the maximum password age in the domain is set to 0, which means
2103         // passwords do not expire (see
2104         // http://msdn2.microsoft.com/en-us/library/ms974598.aspx)
2105         //
2106         // As the quantities involved are too big for PHP integers, we
2107         // need to use BCMath functions to work with arbitrary precision
2108         // numbers.
2109         // ----------------------------------------------------------------
2111         // If the low order 32 bits are 0, then passwords do not expire in
2112         // the domain. Just do '$maxpwdage mod 2^32' and check the result
2113         // (2^32 = 4294967296)
2114         if (bcmod ($maxpwdage, 4294967296) === '0') {
2115             return 0;
2116         }
2118         // Add up pwdLastSet and maxPwdAge to get password expiration
2119         // time, in MS time units. Remember maxPwdAge is stored as a
2120         // _negative_ quantity, so we need to substract it in fact.
2121         $pwdexpire = bcsub ($pwdlastset, $maxpwdage);
2123         // Scale the result to convert it to Unix time units and return
2124         // that value.
2125         return bcsub( bcdiv($pwdexpire, '10000000'), '11644473600');
2126     }
2128     /**
2129      * Connect to the LDAP server, using the plugin configured
2130      * settings. It's actually a wrapper around ldap_connect_moodle()
2131      *
2132      * @return resource A valid LDAP connection (or dies if it can't connect)
2133      */
2134     function ldap_connect() {
2135         // Cache ldap connections. They are expensive to set up
2136         // and can drain the TCP/IP ressources on the server if we
2137         // are syncing a lot of users (as we try to open a new connection
2138         // to get the user details). This is the least invasive way
2139         // to reuse existing connections without greater code surgery.
2140         if(!empty($this->ldapconnection)) {
2141             $this->ldapconns++;
2142             return $this->ldapconnection;
2143         }
2145         if($ldapconnection = ldap_connect_moodle($this->config->host_url, $this->config->ldap_version,
2146                                                  $this->config->user_type, $this->config->bind_dn,
2147                                                  $this->config->bind_pw, $this->config->opt_deref,
2148                                                  $debuginfo, $this->config->start_tls)) {
2149             $this->ldapconns = 1;
2150             $this->ldapconnection = $ldapconnection;
2151             return $ldapconnection;
2152         }
2154         print_error('auth_ldap_noconnect_all', 'auth_ldap', '', $debuginfo);
2155     }
2157     /**
2158      * Disconnects from a LDAP server
2159      *
2160      * @param force boolean Forces closing the real connection to the LDAP server, ignoring any
2161      *                      cached connections. This is needed when we've used paged results
2162      *                      and want to use normal results again.
2163      */
2164     function ldap_close($force=false) {
2165         $this->ldapconns--;
2166         if (($this->ldapconns == 0) || ($force)) {
2167             $this->ldapconns = 0;
2168             @ldap_close($this->ldapconnection);
2169             unset($this->ldapconnection);
2170         }
2171     }
2173     /**
2174      * Search specified contexts for username and return the user dn
2175      * like: cn=username,ou=suborg,o=org. It's actually a wrapper
2176      * around ldap_find_userdn().
2177      *
2178      * @param resource $ldapconnection a valid LDAP connection
2179      * @param string $extusername the username to search (in external LDAP encoding, no db slashes)
2180      * @return mixed the user dn (external LDAP encoding) or false
2181      */
2182     function ldap_find_userdn($ldapconnection, $extusername) {
2183         $ldap_contexts = explode(';', $this->config->contexts);
2184         if (!empty($this->config->create_context)) {
2185             array_push($ldap_contexts, $this->config->create_context);
2186         }
2188         return ldap_find_userdn($ldapconnection, $extusername, $ldap_contexts, $this->config->objectclass,
2189                                 $this->config->user_attribute, $this->config->search_sub);
2190     }
2193     /**
2194      * A chance to validate form data, and last chance to do stuff
2195      * before it is inserted in config_plugin
2196      *
2197      * @param object object with submitted configuration settings (without system magic quotes)
2198      * @param array $err array of error messages (passed by reference)
2199      */
2200     function validate_form($form, &$err) {
2201         if ($form->ntlmsso_type == 'ntlm') {
2202             $format = trim($form->ntlmsso_remoteuserformat);
2203             if (!empty($format) && !preg_match('/%username%/i', $format)) {
2204                 $err['ntlmsso_remoteuserformat'] = get_string('auth_ntlmsso_missing_username', 'auth_ldap');
2205             }
2206         }
2207     }
2210     /**
2211      * When using NTLM SSO, the format of the remote username we get in
2212      * $_SERVER['REMOTE_USER'] may vary, depending on where from and how the web
2213      * server gets the data. So we let the admin configure the format using two
2214      * place holders (%domain% and %username%). This function tries to extract
2215      * the username (stripping the domain part and any separators if they are
2216      * present) from the value present in $_SERVER['REMOTE_USER'], using the
2217      * configured format.
2218      *
2219      * @param string $remoteuser The value from $_SERVER['REMOTE_USER'] (converted to UTF-8)
2220      *
2221      * @return string The remote username (without domain part or
2222      *                separators). Empty string if we can't extract the username.
2223      */
2224     protected function get_ntlm_remote_user($remoteuser) {
2225         if (empty($this->config->ntlmsso_remoteuserformat)) {
2226             $format = AUTH_NTLM_DEFAULT_FORMAT;
2227         } else {
2228             $format = $this->config->ntlmsso_remoteuserformat;
2229         }
2231         $format = preg_quote($format);
2232         $formatregex = preg_replace(array('#%domain%#', '#%username%#'),
2233                                     array('('.AUTH_NTLM_VALID_DOMAINNAME.')', '('.AUTH_NTLM_VALID_USERNAME.')'),
2234                                     $format);
2235         if (preg_match('#^'.$formatregex.'$#', $remoteuser, $matches)) {
2236             $user = end($matches);
2237             return $user;
2238         }
2240         /* We are unable to extract the username with the configured format. Probably
2241          * the format specified is wrong, so log a warning for the admin and return
2242          * an empty username.
2243          */
2244         error_log($this->errorlogtag.get_string ('auth_ntlmsso_maybeinvalidformat', 'auth_ldap'));
2245         return '';
2246     }
2248     /**
2249      * Check if the diagnostic message for the LDAP login error tells us that the
2250      * login is denied because the user password has expired or the password needs
2251      * to be changed on first login (using interactive SMB/Windows logins, not
2252      * LDAP logins).
2253      *
2254      * @param string the diagnostic message for the LDAP login error
2255      * @return bool true if the password has expired or the password must be changed on first login
2256      */
2257     protected function ldap_ad_pwdexpired_from_diagmsg($diagmsg) {
2258         // The format of the diagnostic message is (actual examples from W2003 and W2008):
2259         // "80090308: LdapErr: DSID-0C090334, comment: AcceptSecurityContext error, data 52e, vece"  (W2003)
2260         // "80090308: LdapErr: DSID-0C090334, comment: AcceptSecurityContext error, data 773, vece"  (W2003)
2261         // "80090308: LdapErr: DSID-0C0903AA, comment: AcceptSecurityContext error, data 52e, v1771" (W2008)
2262         // "80090308: LdapErr: DSID-0C0903AA, comment: AcceptSecurityContext error, data 773, v1771" (W2008)
2263         // We are interested in the 'data nnn' part.
2264         //   if nnn == 773 then user must change password on first login
2265         //   if nnn == 532 then user password has expired
2266         $diagmsg = explode(',', $diagmsg);
2267         if (preg_match('/data (773|532)/i', trim($diagmsg[2]))) {
2268             return true;
2269         }
2270         return false;
2271     }
2273 } // End of the class