Hash.php

<?php
class Dsao_Hash
{
  protected $_algorithm = 'md5';

  protected $_hash = null;

  protected static $_hashInstalled = true;

  protected $_length = 0;

  protected $_readOnly = false;

  protected function __construct($hash = null, $length = 0, $algorithm = null)
  {
    // Falls kein Algorithmus übergeben wurde, Standardalgorithmus wählen
    if (null === $algorithm)
    {
      $algorithm = Dsao_Registry::get('config')->encryption->hashAlgorithm;
    }

    // Werte setzen
    $this->setAlgorithm($algorithm);
    $this->setHash($hash);
    $this->setLength($length);
  }

  public function __toString()
  {
    return $this->getHash();
  }

  protected function _generateHash($text = null)
  {
    $text = (null === $text ? uniqid(mt_rand(), true) : $text);

    $this->_hash = (self::_isHashInstalled() ?
      hash($this->_algorithm, $text) :
        call_user_func($this->_algorithm, $text));
  }

  protected static function _isHashInstalled()
  {
    if (null === self::$_hashInstalled)
    {
      self::$_hashInstalled = (function_exists('hash') ? true : false);
    }

    return self::$_hashInstalled;
  }

  public function compareTo(Dsao_Hash $hash)
  {
    return ($this->getHash() == $hash->getHash($this->getLength()));
  }

  public static function factory($hash = null, $length = 0)
  {
    return new self($hash, $length);
  }

  public static function fromText($text = null, $length = 0)
  {
    // Hash erstellen
    $hash = new self(null, $length);

    // Hash generieren und setzen
    $hash->_generateHash($text);

    return $hash;
  }

  public function getAlgorithm()
  {
    return $this->_algorithm;
  }

  public function getHash($length = 0)
  {
    // Falls ganzer String zurückgegeben werden soll, oder in Klasse keine
    // Länge definiert wurde
    if (0 === $length || (!$length && !$this->_length))
    {
      return $this->_hash;
    }
    // Falls keine Länge definiert wurde, die aus Klasse nehmen
    else if (!$length)
    {
      $length = $this->_length;
    }

    // Gekürzten Hash zurückgeben
    return substr($this->_hash, 0, $length);
  }

  public function getLength($trueLength = false)
  {
    // Falls wahre Länge zurück gegeben werden soll, oder Hash eh nicht gekürzt
    // werden sollte
    if ($trueLength || !$this->_length)
    {
      return strlen($this->_hash);
    }

    return $this->_length;
  }

  public function isReadOnly($throw = false)
  {
    if (true === $throw && true === $this->_readOnly)
    {
      throw new Dsao_Exception('dsao_hash_object_readonly');
    }

    return (bool) $this->_readOnly;
  }

  public function setAlgorithm($algorithm)
  {
    // Falls Objekt schreibgeschützt ist wird eine Exception geworfen
    $this->isReadOnly(true);

    // Falls Hash-Funktionen verfügbar
    if (self::_isHashInstalled())
    {
      // Algorithmus gültig?
      if (in_array($algorithm, hash_algos()))
      {
        $this->_algorithm = $algorithm;
      }
    }
    // Ansonsten schauen, ob Funktion selber vorhanden (md5(), sha1(), crc32()
    // usw.)
    else
    {
      if (function_exists($algorithm))
      {
        $this->_algorithm = $algorithm;
      }
    }

    return $this;
  }

  public function setHash($hash = null, $fromText = false)
  {
    // Falls Objekt schreibgeschützt ist wird eine Exception geworfen
    $this->isReadOnly(true);

    // Falls kein Hash übergeben wurde, zufälligen generieren
    if (null === $hash || $fromText)
    {
      $this->_generateHash(($fromText ? $hash : null));
    }
    else
    {
      $this->_hash = $hash;
    }

    return $this;
  }

  public function setLength($length = 0)
  {
    // Falls Objekt schreibgeschützt ist wird eine Exception geworfen
    $this->isReadOnly(true);

    $this->_length = $length;

    return $this;
  }

  public function setReadOnly($readOnly = true)
  {
    $this->_readOnly = (bool) $readOnly;

    return $this;
  }
}