BookStack Code Mirror - bookstack/blob - app/Auth/Access/LdapService.php

   1 <?php namespace BookStack\Auth\Access;
   2
   3 use BookStack\Auth\User;
   4 use BookStack\Exceptions\JsonDebugException;
   5 use BookStack\Exceptions\LdapException;
   6 use ErrorException;
   7
   8 /**
   9  * Class LdapService
  10  * Handles any app-specific LDAP tasks.
  11  */
  12 class LdapService extends ExternalAuthService
  13 {
  14
  15     protected $ldap;
  16     protected $ldapConnection;
  17     protected $config;
  18     protected $enabled;
  19
  20     /**
  21      * LdapService constructor.
  22      */
  23     public function __construct(Ldap $ldap)
  24     {
  25         $this->ldap = $ldap;
  26         $this->config = config('services.ldap');
  27         $this->enabled = config('auth.method') === 'ldap';
  28     }
  29
  30     /**
  31      * Check if groups should be synced.
  32      * @return bool
  33      */
  34     public function shouldSyncGroups()
  35     {
  36         return $this->enabled && $this->config['user_to_groups'] !== false;
  37     }
  38
  39     /**
  40      * Search for attributes for a specific user on the ldap.
  41      * @throws LdapException
  42      */
  43     private function getUserWithAttributes(string $userName, array $attributes): ?array
  44     {
  45         $ldapConnection = $this->getConnection();
  46         $this->bindSystemUser($ldapConnection);
  47
  48         // Clean attributes
  49         foreach ($attributes as $index => $attribute) {
  50             if (strpos($attribute, 'BIN;') === 0) {
  51                 $attributes[$index] = substr($attribute, strlen('BIN;'));
  52             }
  53         }
  54
  55         // Find user
  56         $userFilter = $this->buildFilter($this->config['user_filter'], ['user' => $userName]);
  57         $baseDn = $this->config['base_dn'];
  58
  59         $followReferrals = $this->config['follow_referrals'] ? 1 : 0;
  60         $this->ldap->setOption($ldapConnection, LDAP_OPT_REFERRALS, $followReferrals);
  61         $users = $this->ldap->searchAndGetEntries($ldapConnection, $baseDn, $userFilter, $attributes);
  62         if ($users['count'] === 0) {
  63             return null;
  64         }
  65
  66         return $users[0];
  67     }
  68
  69     /**
  70      * Get the details of a user from LDAP using the given username.
  71      * User found via configurable user filter.
  72      * @throws LdapException
  73      */
  74     public function getUserDetails(string $userName): ?array
  75     {
  76         $idAttr = $this->config['id_attribute'];
  77         $emailAttr = $this->config['email_attribute'];
  78         $displayNameAttr = $this->config['display_name_attribute'];
  79         $thumbnailAttr = $this->config['thumbnail_attribute'];
  80
  81         $user = $this->getUserWithAttributes($userName, ['cn', 'dn', $idAttr, $emailAttr, $displayNameAttr]);
  82
  83         if ($user === null) {
  84             return null;
  85         }
  86
  87         $userCn = $this->getUserResponseProperty($user, 'cn', null);
  88         $formatted = [
  89             'uid'   => $this->getUserResponseProperty($user, $idAttr, $user['dn']),
  90             'name'  => $this->getUserResponseProperty($user, $displayNameAttr, $userCn),
  91             'dn'    => $user['dn'],
  92             'email' => $this->getUserResponseProperty($user, $emailAttr, null),
  93             'avatar'=> $this->getUserResponseProperty($user, $thumbnailAttr, null),
  94         ];
  95
  96         if ($this->config['dump_user_details']) {
  97             throw new JsonDebugException([
  98                 'details_from_ldap' => $user,
  99                 'details_bookstack_parsed' => $formatted,
 100             ]);
 101         }
 102
 103         return $formatted;
 104     }
 105
 106     /**
 107      * Get a property from an LDAP user response fetch.
 108      * Handles properties potentially being part of an array.
 109      * If the given key is prefixed with 'BIN;', that indicator will be stripped
 110      * from the key and any fetched values will be converted from binary to hex.
 111      */
 112     protected function getUserResponseProperty(array $userDetails, string $propertyKey, $defaultValue)
 113     {
 114         $isBinary = strpos($propertyKey, 'BIN;') === 0;
 115         $propertyKey = strtolower($propertyKey);
 116         $value = $defaultValue;
 117
 118         if ($isBinary) {
 119             $propertyKey = substr($propertyKey, strlen('BIN;'));
 120         }
 121
 122         if (isset($userDetails[$propertyKey])) {
 123             $value = (is_array($userDetails[$propertyKey]) ? $userDetails[$propertyKey][0] : $userDetails[$propertyKey]);
 124             if ($isBinary) {
 125                 $value = bin2hex($value);
 126             }
 127         }
 128
 129         return $value;
 130     }
 131
 132     /**
 133      * Check if the given credentials are valid for the given user.
 134      * @throws LdapException
 135      */
 136     public function validateUserCredentials(?array $ldapUserDetails, string $password): bool
 137     {
 138         if (is_null($ldapUserDetails)) {
 139             return false;
 140         }
 141
 142         $ldapConnection = $this->getConnection();
 143         try {
 144             $ldapBind = $this->ldap->bind($ldapConnection, $ldapUserDetails['dn'], $password);
 145         } catch (ErrorException $e) {
 146             $ldapBind = false;
 147         }
 148
 149         return $ldapBind;
 150     }
 151
 152     /**
 153      * Bind the system user to the LDAP connection using the given credentials
 154      * otherwise anonymous access is attempted.
 155      * @param $connection
 156      * @throws LdapException
 157      */
 158     protected function bindSystemUser($connection)
 159     {
 160         $ldapDn = $this->config['dn'];
 161         $ldapPass = $this->config['pass'];
 162
 163         $isAnonymous = ($ldapDn === false || $ldapPass === false);
 164         if ($isAnonymous) {
 165             $ldapBind = $this->ldap->bind($connection);
 166         } else {
 167             $ldapBind = $this->ldap->bind($connection, $ldapDn, $ldapPass);
 168         }
 169
 170         if (!$ldapBind) {
 171             throw new LdapException(($isAnonymous ? trans('errors.ldap_fail_anonymous') : trans('errors.ldap_fail_authed')));
 172         }
 173     }
 174
 175     /**
 176      * Get the connection to the LDAP server.
 177      * Creates a new connection if one does not exist.
 178      * @return resource
 179      * @throws LdapException
 180      */
 181     protected function getConnection()
 182     {
 183         if ($this->ldapConnection !== null) {
 184             return $this->ldapConnection;
 185         }
 186
 187         // Check LDAP extension in installed
 188         if (!function_exists('ldap_connect') && config('app.env') !== 'testing') {
 189             throw new LdapException(trans('errors.ldap_extension_not_installed'));
 190         }
 191
 192          // Check if TLS_INSECURE is set. The handle is set to NULL due to the nature of
 193          // the LDAP_OPT_X_TLS_REQUIRE_CERT option. It can only be set globally and not per handle.
 194         if ($this->config['tls_insecure']) {
 195             $this->ldap->setOption(null, LDAP_OPT_X_TLS_REQUIRE_CERT, LDAP_OPT_X_TLS_NEVER);
 196         }
 197
 198         $serverDetails = $this->parseServerString($this->config['server']);
 199         $ldapConnection = $this->ldap->connect($serverDetails['host'], $serverDetails['port']);
 200
 201         if ($ldapConnection === false) {
 202             throw new LdapException(trans('errors.ldap_cannot_connect'));
 203         }
 204
 205         // Set any required options
 206         if ($this->config['version']) {
 207             $this->ldap->setVersion($ldapConnection, $this->config['version']);
 208         }
 209
 210         $this->ldapConnection = $ldapConnection;
 211         return $this->ldapConnection;
 212     }
 213
 214     /**
 215      * Parse a LDAP server string and return the host and port for a connection.
 216      * Is flexible to formats such as 'ldap.example.com:8069' or 'ldaps://ldap.example.com'.
 217      */
 218     protected function parseServerString(string $serverString): array
 219     {
 220         $serverNameParts = explode(':', $serverString);
 221
 222         // If we have a protocol just return the full string since PHP will ignore a separate port.
 223         if ($serverNameParts[0] === 'ldaps' || $serverNameParts[0] === 'ldap') {
 224             return ['host' => $serverString, 'port' => 389];
 225         }
 226
 227         // Otherwise, extract the port out
 228         $hostName = $serverNameParts[0];
 229         $ldapPort = (count($serverNameParts) > 1) ? intval($serverNameParts[1]) : 389;
 230         return ['host' => $hostName, 'port' => $ldapPort];
 231     }
 232
 233     /**
 234      * Build a filter string by injecting common variables.
 235      */
 236     protected function buildFilter(string $filterString, array $attrs): string
 237     {
 238         $newAttrs = [];
 239         foreach ($attrs as $key => $attrText) {
 240             $newKey = '${' . $key . '}';
 241             $newAttrs[$newKey] = $this->ldap->escape($attrText);
 242         }
 243         return strtr($filterString, $newAttrs);
 244     }
 245
 246     /**
 247      * Get the groups a user is a part of on ldap.
 248      * @throws LdapException
 249      */
 250     public function getUserGroups(string $userName): array
 251     {
 252         $groupsAttr = $this->config['group_attribute'];
 253         $user = $this->getUserWithAttributes($userName, [$groupsAttr]);
 254
 255         if ($user === null) {
 256             return [];
 257         }
 258
 259         $userGroups = $this->groupFilter($user);
 260         $userGroups = $this->getGroupsRecursive($userGroups, []);
 261         return $userGroups;
 262     }
 263
 264     /**
 265      * Get the parent groups of an array of groups.
 266      * @throws LdapException
 267      */
 268     private function getGroupsRecursive(array $groupsArray, array $checked): array
 269     {
 270         $groupsToAdd = [];
 271         foreach ($groupsArray as $groupName) {
 272             if (in_array($groupName, $checked)) {
 273                 continue;
 274             }
 275
 276             $parentGroups = $this->getGroupGroups($groupName);
 277             $groupsToAdd = array_merge($groupsToAdd, $parentGroups);
 278             $checked[] = $groupName;
 279         }
 280
 281         $groupsArray = array_unique(array_merge($groupsArray, $groupsToAdd), SORT_REGULAR);
 282
 283         if (empty($groupsToAdd)) {
 284             return $groupsArray;
 285         }
 286
 287         return $this->getGroupsRecursive($groupsArray, $checked);
 288     }
 289
 290     /**
 291      * Get the parent groups of a single group.
 292      * @throws LdapException
 293      */
 294     private function getGroupGroups(string $groupName): array
 295     {
 296         $ldapConnection = $this->getConnection();
 297         $this->bindSystemUser($ldapConnection);
 298
 299         $followReferrals = $this->config['follow_referrals'] ? 1 : 0;
 300         $this->ldap->setOption($ldapConnection, LDAP_OPT_REFERRALS, $followReferrals);
 301
 302         $baseDn = $this->config['base_dn'];
 303         $groupsAttr = strtolower($this->config['group_attribute']);
 304
 305         $groupFilter = 'CN=' . $this->ldap->escape($groupName);
 306         $groups = $this->ldap->searchAndGetEntries($ldapConnection, $baseDn, $groupFilter, [$groupsAttr]);
 307         if ($groups['count'] === 0) {
 308             return [];
 309         }
 310
 311         return $this->groupFilter($groups[0]);
 312     }
 313
 314     /**
 315      * Filter out LDAP CN and DN language in a ldap search return.
 316      * Gets the base CN (common name) of the string.
 317      */
 318     protected function groupFilter(array $userGroupSearchResponse): array
 319     {
 320         $groupsAttr = strtolower($this->config['group_attribute']);
 321         $ldapGroups = [];
 322         $count = 0;
 323
 324         if (isset($userGroupSearchResponse[$groupsAttr]['count'])) {
 325             $count = (int)$userGroupSearchResponse[$groupsAttr]['count'];
 326         }
 327
 328         for ($i = 0; $i < $count; $i++) {
 329             $dnComponents = $this->ldap->explodeDn($userGroupSearchResponse[$groupsAttr][$i], 1);
 330             if (!in_array($dnComponents[0], $ldapGroups)) {
 331                 $ldapGroups[] = $dnComponents[0];
 332             }
 333         }
 334
 335         return $ldapGroups;
 336     }
 337
 338     /**
 339      * Sync the LDAP groups to the user roles for the current user.
 340      * @throws LdapException
 341      */
 342     public function syncGroups(User $user, string $username)
 343     {
 344         $userLdapGroups = $this->getUserGroups($username);
 345         $this->syncWithGroups($user, $userLdapGroups);
 346     }
 347 }