interface/modules/zend_modules/library/Zend/Ldap/Attribute.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Ldap;
  11
  12 use DateTime;
  13
  14 /**
  15  * Zend\Ldap\Attribute is a collection of LDAP attribute related functions.
  16  */
  17 class Attribute
  18 {
  19     const PASSWORD_HASH_MD5   = 'md5';
  20     const PASSWORD_HASH_SMD5  = 'smd5';
  21     const PASSWORD_HASH_SHA   = 'sha';
  22     const PASSWORD_HASH_SSHA  = 'ssha';
  23     const PASSWORD_UNICODEPWD = 'unicodePwd';
  24
  25     /**
  26      * Sets a LDAP attribute.
  27      *
  28      * @param  array                     $data
  29      * @param  string                    $attribName
  30      * @param  string|array|\Traversable $value
  31      * @param  bool                   $append
  32      * @return void
  33      */
  34     public static function setAttribute(array &$data, $attribName, $value, $append = false)
  35     {
  36         $attribName = strtolower($attribName);
  37         $valArray   = array();
  38         if (is_array($value) || ($value instanceof \Traversable)) {
  39             foreach ($value as $v) {
  40                 $v = static::valueToLdap($v);
  41                 if ($v !== null) {
  42                     $valArray[] = $v;
  43                 }
  44             }
  45         } elseif ($value !== null) {
  46             $value = static::valueToLdap($value);
  47             if ($value !== null) {
  48                 $valArray[] = $value;
  49             }
  50         }
  51
  52         if ($append === true && isset($data[$attribName])) {
  53             if (is_string($data[$attribName])) {
  54                 $data[$attribName] = array($data[$attribName]);
  55             }
  56             $data[$attribName] = array_merge($data[$attribName], $valArray);
  57         } else {
  58             $data[$attribName] = $valArray;
  59         }
  60     }
  61
  62     /**
  63      * Gets a LDAP attribute.
  64      *
  65      * @param  array   $data
  66      * @param  string  $attribName
  67      * @param  int $index
  68      * @return array|mixed
  69      */
  70     public static function getAttribute(array $data, $attribName, $index = null)
  71     {
  72         $attribName = strtolower($attribName);
  73         if ($index === null) {
  74             if (!isset($data[$attribName])) {
  75                 return array();
  76             }
  77             $retArray = array();
  78             foreach ($data[$attribName] as $v) {
  79                 $retArray[] = static::valueFromLdap($v);
  80             }
  81             return $retArray;
  82         } elseif (is_int($index)) {
  83             if (!isset($data[$attribName])) {
  84                 return null;
  85             } elseif ($index >= 0 && $index < count($data[$attribName])) {
  86                 return static::valueFromLdap($data[$attribName][$index]);
  87             } else {
  88                 return null;
  89             }
  90         }
  91
  92         return null;
  93     }
  94
  95     /**
  96      * Checks if the given value(s) exist in the attribute
  97      *
  98      * @param array       $data
  99      * @param string      $attribName
 100      * @param mixed|array $value
 101      * @return bool
 102      */
 103     public static function attributeHasValue(array &$data, $attribName, $value)
 104     {
 105         $attribName = strtolower($attribName);
 106         if (!isset($data[$attribName])) {
 107             return false;
 108         }
 109
 110         if (is_scalar($value)) {
 111             $value = array($value);
 112         }
 113
 114         foreach ($value as $v) {
 115             $v = self::valueToLdap($v);
 116             if (!in_array($v, $data[$attribName], true)) {
 117                 return false;
 118             }
 119         }
 120
 121         return true;
 122     }
 123
 124     /**
 125      * Removes duplicate values from a LDAP attribute
 126      *
 127      * @param array  $data
 128      * @param string $attribName
 129      * @return void
 130      */
 131     public static function removeDuplicatesFromAttribute(array &$data, $attribName)
 132     {
 133         $attribName = strtolower($attribName);
 134         if (!isset($data[$attribName])) {
 135             return;
 136         }
 137         $data[$attribName] = array_values(array_unique($data[$attribName]));
 138     }
 139
 140     /**
 141      * Remove given values from a LDAP attribute
 142      *
 143      * @param array       $data
 144      * @param string      $attribName
 145      * @param mixed|array $value
 146      * @return void
 147      */
 148     public static function removeFromAttribute(array &$data, $attribName, $value)
 149     {
 150         $attribName = strtolower($attribName);
 151         if (!isset($data[$attribName])) {
 152             return;
 153         }
 154
 155         if (is_scalar($value)) {
 156             $value = array($value);
 157         }
 158
 159         $valArray = array();
 160         foreach ($value as $v) {
 161             $v = self::valueToLdap($v);
 162             if ($v !== null) {
 163                 $valArray[] = $v;
 164             }
 165         }
 166
 167         $resultArray = $data[$attribName];
 168         foreach ($valArray as $rv) {
 169             $keys = array_keys($resultArray, $rv);
 170             foreach ($keys as $k) {
 171                 unset($resultArray[$k]);
 172             }
 173         }
 174         $resultArray       = array_values($resultArray);
 175         $data[$attribName] = $resultArray;
 176     }
 177
 178     /**
 179      * @param  mixed $value
 180      * @return string|null
 181      */
 182     private static function valueToLdap($value)
 183     {
 184         return Converter\Converter::toLdap($value);
 185     }
 186
 187     /**
 188      * @param  string $value
 189      * @return mixed
 190      */
 191     private static function valueFromLdap($value)
 192     {
 193         try {
 194             $return = Converter\Converter::fromLdap($value, Converter\Converter::STANDARD, false);
 195             if ($return instanceof DateTime) {
 196                 return Converter\Converter::toLdapDateTime($return, false);
 197             } else {
 198                 return $return;
 199             }
 200         } catch (Exception\InvalidArgumentException $e) {
 201             return $value;
 202         }
 203     }
 204
 205     /**
 206      * Sets a LDAP password.
 207      *
 208      * @param array  $data
 209      * @param string $password
 210      * @param string $hashType   Optional by default MD5
 211      * @param string $attribName Optional
 212      */
 213     public static function setPassword(
 214         array &$data, $password, $hashType = self::PASSWORD_HASH_MD5,
 215         $attribName = null
 216     )
 217     {
 218         if ($attribName === null) {
 219             if ($hashType === self::PASSWORD_UNICODEPWD) {
 220                 $attribName = 'unicodePwd';
 221             } else {
 222                 $attribName = 'userPassword';
 223             }
 224         }
 225
 226         $hash = static::createPassword($password, $hashType);
 227         static::setAttribute($data, $attribName, $hash, false);
 228     }
 229
 230     /**
 231      * Creates a LDAP password.
 232      *
 233      * @param  string $password
 234      * @param  string $hashType
 235      * @return string
 236      */
 237     public static function createPassword($password, $hashType = self::PASSWORD_HASH_MD5)
 238     {
 239         switch ($hashType) {
 240             case self::PASSWORD_UNICODEPWD:
 241                 /* see:
 242                  * http://msdn.microsoft.com/en-us/library/cc223248(PROT.10).aspx
 243                  */
 244                 $password = '"' . $password . '"';
 245                 if (function_exists('mb_convert_encoding')) {
 246                     $password = mb_convert_encoding($password, 'UTF-16LE', 'UTF-8');
 247                 } elseif (function_exists('iconv')) {
 248                     $password = iconv('UTF-8', 'UTF-16LE', $password);
 249                 } else {
 250                     $len = strlen($password);
 251                     $new = '';
 252                     for ($i = 0; $i < $len; $i++) {
 253                         $new .= $password[$i] . "\x00";
 254                     }
 255                     $password = $new;
 256                 }
 257                 return $password;
 258             case self::PASSWORD_HASH_SSHA:
 259                 $salt    = substr(sha1(uniqid(mt_rand(), true), true), 0, 4);
 260                 $rawHash = sha1($password . $salt, true) . $salt;
 261                 $method  = '{SSHA}';
 262                 break;
 263             case self::PASSWORD_HASH_SHA:
 264                 $rawHash = sha1($password, true);
 265                 $method  = '{SHA}';
 266                 break;
 267             case self::PASSWORD_HASH_SMD5:
 268                 $salt    = substr(sha1(uniqid(mt_rand(), true), true), 0, 4);
 269                 $rawHash = md5($password . $salt, true) . $salt;
 270                 $method  = '{SMD5}';
 271                 break;
 272             case self::PASSWORD_HASH_MD5:
 273             default:
 274                 $rawHash = md5($password, true);
 275                 $method  = '{MD5}';
 276                 break;
 277         }
 278         return $method . base64_encode($rawHash);
 279     }
 280
 281     /**
 282      * Sets a LDAP date/time attribute.
 283      *
 284      * @param  array                      $data
 285      * @param  string                     $attribName
 286      * @param  int|array|\Traversable $value
 287      * @param  bool                    $utc
 288      * @param  bool                    $append
 289      */
 290     public static function setDateTimeAttribute(
 291         array &$data, $attribName, $value, $utc = false,
 292         $append = false
 293     )
 294     {
 295         $convertedValues = array();
 296         if (is_array($value) || ($value instanceof \Traversable)) {
 297             foreach ($value as $v) {
 298                 $v = static::valueToLdapDateTime($v, $utc);
 299                 if ($v !== null) {
 300                     $convertedValues[] = $v;
 301                 }
 302             }
 303         } elseif ($value !== null) {
 304             $value = static::valueToLdapDateTime($value, $utc);
 305             if ($value !== null) {
 306                 $convertedValues[] = $value;
 307             }
 308         }
 309         static::setAttribute($data, $attribName, $convertedValues, $append);
 310     }
 311
 312     /**
 313      * @param  int $value
 314      * @param  bool $utc
 315      * @return string|null
 316      */
 317     private static function valueToLdapDateTime($value, $utc)
 318     {
 319         if (is_int($value)) {
 320             return Converter\Converter::toLdapDateTime($value, $utc);
 321         }
 322
 323         return null;
 324     }
 325
 326     /**
 327      * Gets a LDAP date/time attribute.
 328      *
 329      * @param  array   $data
 330      * @param  string  $attribName
 331      * @param  int $index
 332      * @return array|int
 333      */
 334     public static function getDateTimeAttribute(array $data, $attribName, $index = null)
 335     {
 336         $values = static::getAttribute($data, $attribName, $index);
 337         if (is_array($values)) {
 338             for ($i = 0; $i < count($values); $i++) {
 339                 $newVal = static::valueFromLdapDateTime($values[$i]);
 340                 if ($newVal !== null) {
 341                     $values[$i] = $newVal;
 342                 }
 343             }
 344         } else {
 345             $newVal = static::valueFromLdapDateTime($values);
 346             if ($newVal !== null) {
 347                 $values = $newVal;
 348             }
 349         }
 350
 351         return $values;
 352     }
 353
 354     /**
 355      * @param  string|DateTime $value
 356      * @return int|null
 357      */
 358     private static function valueFromLdapDateTime($value)
 359     {
 360         if ($value instanceof DateTime) {
 361             return $value->format('U');
 362         } elseif (is_string($value)) {
 363             try {
 364                 return Converter\Converter::fromLdapDateTime($value, false)->format('U');
 365             } catch (Converter\Exception\InvalidArgumentException $e) {
 366                 return null;
 367             }
 368         }
 369
 370         return null;
 371     }
 372 }