<?xml version="1.0"?>

<config>
  <tabs>
    <mbtec translate="label" module="mbtec_test">
      <label>Mbtec</label>
      <sort_order>450</sort_order>
    </mbtec>
  </tabs>
  <sections>
    <mbtec_test translate="label" module="mbtec_test">
      <label>Test</label>
      <tab>mbtec</tab>
      <sort_order>100</sort_order>
      <show_in_default>1</show_in_default>
      <show_in_website>1</show_in_website>
      <show_in_store>1</show_in_store>
      <groups>
        <settings translate="label">
          <label>Settings</label>
          <frontend_type>text</frontend_type>
          <sort_order>100</sort_order>
          <show_in_default>1</show_in_default>
          <show_in_website>0</show_in_website>
          <show_in_store>0</show_in_store>
          <fields>
            <option_one translate="label,comment">
              <label>Options</label>
              <comment>
                <![CDATA[Please select one option.]]>
              </comment>
              <frontend_type>select</frontend_type>
              <source_model>
                adminhtml/system_config_source_yesno
              </source_model>
              <sort_order>10</sort_order>
              <show_in_default>1</show_in_default>
              <show_in_website>0</show_in_website>
              <show_in_store>0</show_in_store>
            </option_one>
            <option_two translate="label">
              <label>Eingabe Feld</label>
              <frontend_type>text</frontend_type>
              <sort_order>20</sort_order>
              <show_in_default>1</show_in_default>
              <show_in_website>0</show_in_website>
              <show_in_store>0</show_in_store>
              <depends><option_one>1</option_one></depends>
            </option_two>
          </fields>
        </settings>
      </groups>
    </mbtec_test>
  </sections>
</config>

Magento Backend Options

De typische Verzeichnisstruktur eines Magento Moduls

magento
`-- app
    `-- code
        |-- community
        |-- core
        `-- local
            `-- Mbtec
                |-- Test
                |-- etc
                |   |-- config.xml
                |   `-- system.xml
                |-- Helper
                |   `-- Data.php
                `-- Model
                    `-- Adminhtml
                        `-- System
                            `-- Config
                                `-- Source
                                    `-- Options.php

Die Modulkonfiguration
Datei etc/config.xml
<?xml version="1.0"?>
<config>
  <modules>
    <mbtec_test>
      <version>0.0.1</version>
    </mbtec_test>
  </modules>
  <global>
    <models>
      <mbtec_test>
        <class>Mbtec_Test_Model</class>
      </mbtec_test>
    </models>
    <helpers>
      <mbtec_test>
        <class>Mbtec_Test_Helper</class>
      </mbtec_test>
    </helpers>
  </global>
  <adminhtml>
    <acl>
      <resources>
        <admin>
          <children>
            <system>
              <children>
                <config>
                  <children>
                    <mbtec_test>
                      <title>Test</title>
                    </mbtec_test>
                  </children>
                </config>
              </children>
            </system>
          </children>
        </admin>
      </resources>
    </acl>
  </adminhtml>
</config>
Die Systemkonfiguration mit der die Selects zum Admin Panel hinzugefügt werden.

Datei etc/system.xml
<?xml version="1.0"?>
<config>
  <tabs>
    <mbtec translate="label" module="mbtec_test">
      <label>Mbtec</label>
      <sort_order>450</sort_order>
    </mbtec>
  </tabs>
  <sections>
    <mbtec_test translate="label" module="mbtec_test">
      <label>Test</label>
      <tab>mbtec</tab>
      <sort_order>100</sort_order>
      <show_in_default>1</show_in_default>
      <show_in_website>1</show_in_website>
      <show_in_store>1</show_in_store>
      <groups>
        <settings translate="label">
          <label>Settings</label>
          <frontend_type>text</frontend_type>
          <sort_order>100</sort_order>
          <show_in_default>1</show_in_default>
          <show_in_website>0</show_in_website>
          <show_in_store>0</show_in_store>
          <fields>
            <optionselect translate="label,comment">
              <label>Options</label>
              <comment>
                <![CDATA[Please select one option.]]>
              </comment>
              <frontend_type>select</frontend_type>
              <source_model>
                mbtec_test/adminhtml_system_config_source_options
              </source_model>
              <sort_order>10</sort_order>
              <show_in_default>1</show_in_default>
              <show_in_website>0</show_in_website>
              <show_in_store>0</show_in_store>
            </optionselect>
            <optionmultiselect translate="label,comment">
              <label>Options</label>
              <comment>
                <![CDATA[Please select one option.]]>
              </comment>
              <frontend_type>multiselect</frontend_type>
              <source_model>
                mbtec_test/adminhtml_system_config_source_options
              </source_model>
              <sort_order>20</sort_order>
              <show_in_default>1</show_in_default>
              <show_in_website>0</show_in_website>
              <show_in_store>0</show_in_store>
            </optionmultiselect>
          </fields>
        </settings>
      </groups>
    </mbtec_test>
  </sections>
</config>
Der leere Helper-Stub welcher für die Translations notwendig ist.

Datei Helper/Data.php
<?php

class Mbtec_Test_Helper_Data extends Mage_Core_Helper_Abstract
{

}
Die Datenquelle für die Selects.

Datei: Models/Adminhtml/System/Config/Source/Options
<?php

class Mbtec_Test_Model_Adminhtml_System_Config_Source_Options
{
    /**
     * Options getter
     *
     * @return array
     */
    public function toOptionArray()
    {
        $helper = Mage::helper('mbtec_test');
        return array(
            array(
                'value' => 'foo',
                'label'=> $helper->__('Foo')
            ),
            array(
                'value' => 'bar',
                'label'=> $helper->__('Bar')
            ),
            array(
                'value' => 'baz',
                'label'=> $helper->__('Baz')
            )
        );
    }
}
Die Konfigurationswerte können dann ausgelesen werden mit
$option = Mage::getStoreConfig(
    'mbtec_test/settings/optionselect'
);

$multioption = Mage::getStoreConfig(
    'mbtec_test/settings/optionmultiselect'
);
Hinweis: Cache löschen nicht vergessen  

Download Smarty von www.smarty.net

Im ersten Schritt erweitern wir die Klasse Zend_View_Abstract mit unserer eigenen Smarty Logik. Wir erstellen also eine neue Datei mit dem Namen Smarty.php unter library/Mbtec/View/

Die Verzeichnisstruktur sollte der hier ähneln

...
/myapp
    /application
        /configs
            application.ini
        /doctrine
        /modules
        /smarty
            /compile
                ...
            /cache
                ...
    Bootstrap.php
    /library
        /doctrine
        /Mbtec
            /Controller
            /Resource
            /View
                Smarty.php
        /Smarty
            /plugins
            /sysplugins
            /debug.tpl
            Smarty.class.php
        /Zend
    /public
    /var

Hier nun der Smarty Wrapper für den View

<?php

/**
 * Smarty template engine integration into Zend Framework
 * Some ideas borrowed from
 * http://devzone.zend.com/article/120
 * Most ideas borrowed from
 * http://www.gediminasm.org/article/smarty-3-extension-for-zend-framework
 */

class Mbtec_View_Smarty extends Zend_View_Abstract
{
    /**
     * Instance of Smarty
     * @var Smarty
     */
    protected $_smarty = null;

    /**
     * Template explicitly set to render in this view
     * @var string
     */
    protected $_customTemplate = '';

    /**
     * Smarty config
     * @var array
     */
    private $_config = null;

    /**
     * Class definition and constructor
     *
     * Let's start with the class definition and the
     * constructor part. My class Travello_View_Smarty
     * is extending the Zend_View_Abstract class.
     * In the constructor the parent constructor from
     * Zend_View_Abstract is called first. After that a
     * Smarty object is instantiated, configured and stored
     * in a private attribute.
     * Please note that I use a configuration object from
     * the object store to get the configuration data for
     * Smarty.
     *
     * @param array $smartyConfig
     * @param array $config
     */
    public function __construct($sConfig, $config = array())
    {
        $this->_config = $sConfig;
        parent::__construct($config);
        $this->_loadSmarty();
    }

    /**
     * Return the template engine object
     *
     * @return Smarty
     */
    public function getEngine()
    {
        return $this->_smarty;
    }

    /**
     * Implement _run() method
     *
     * The method _run() is the only method that needs to be
     * implemented in any subclass of Zend_View_Abstract.
     * It is called automatically within the render() method.
     * My implementation just uses the display() method from
     * Smarty to generate and output the template.
     *
     * @param string $template
     * @return void
     */
    protected function _run()
    {
        $file = func_num_args() > 0 &&
                  file_exists(func_get_arg(0))
                      ? func_get_arg(0)
                      : '';
        if ($this->_customTemplate || $file) {
            $template = $this->_customTemplate;
            if (!$template) {
                $template = $file;
            }

            $this->_smarty->display($template);
        }
        else {
            throw new Zend_View_Exception(
                'Cannot render view without any template
                 being assigned or file does not exist'
            );
        }
    }

    /**
     * Overwrite assign() method
     *
     * The next part is an overwrite of the assign() method
     * from Zend_View_Abstract, which works in a similar
     * way. The big difference is that the values are
     * assigned to the Smarty object and not to the
     * $this->_vars variables array of Zend_View_Abstract.
     *
     * @param string|array $var
     * @return void
     */
    public function assign($var, $value = null)
    {
        if (is_string($var)) {
            $this->_smarty->assign($var, $value);
        }
        elseif (is_array($var)) {
            foreach ($var as $key => $value) {
                $this->assign($key, $value);
            }
        }
        else {
            throw new Zend_View_Exception(
                'assign() expects a string or array, got '
              . gettype($var)
            );
        }
    }

    /**
     * Overwrite escape() method
     *
     * The next part is an overwrite of the escape() method
     * from Zend_View_Abstract. It works both for string
     * and array values and also uses the escape() method
     * from the Zend_View_Abstract. The advantage of this
     * is that I don't have to care about each value of an
     * array to get properly escaped.
     *
     * @param mixed $var
     * @return mixed
     */
    public function escape($var)
    {
        if (is_string($var)) {
            return parent::escape($var);
        }

        if (is_array($var)) {
            foreach ($var as $key => $val) {
                $var[$key] = $this->escape($val);
            }
        }

        return $var;
    }

    /**
     * Use Smarty caching
     *
     * The last two methods were created to simply integrate
     * the Smarty caching mechanism in the View class.
     * With the first one you can check for cached template
     * and with the second one you can set the caching
     * on or off.
     *
     * @param string $template
     * @return bool
     */
    public function isCached($template)
    {
        return $this->_smarty->is_cached($template);
    }

    /**
     * Enable/disable caching
     *
     * @param bool $caching
     * @return void
     */
    public function setCaching($caching)
    {
        $this->_smarty->caching = $caching;
    }

    /**
     * Template getter (return file path)
     * @return string
     */
    public function getTemplate()
    {
        return $this->_customTemplate;
    }

    /**
     * Template filename setter
     * @param string
     * @return void
     */
    public function setTemplate($tpl)
    {
        $this->_customTemplate = $tpl;
    }

    /**
     * Magic setter for Zend_View compatibility.
     * Performs assign()
     *
     * @param string $key
     * @param mixed $val
     */
    public function __set($key, $val)
    {
        $this->assign($key, $val);
    }

    /**
     * Magic getter for Zend_View compatibility.
     * Retrieves template var
     *
     * @param string $key
     * @return mixed
     */
    public function __get($key)
    {
        return $this->_smarty->getTemplateVars($key);
    }

    /**
     * Magic getter for Zend_View compatibility.
     * Removes template var
     *
     * @see View/Zend_View_Abstract::__unset()
     * @param string $key
     * @return void
     */
    public function __unset($key)
    {
        $this->_smarty->clearAssign($key);
    }

    /**
     * Allows testing with empty() and isset() to work
     * Zend_View compatibility. Checks template var for
     * existance
     *
     * @param string $key
     * @return boolean
     */
    public function __isset($key)
    {
        return
            (null !== $this->_smarty->getTemplateVars($key));
    }

    /**
     * Zend_View compatibility. Retrieves all template vars
     *
     * @see Zend_View_Abstract::getVars()
     * @return array
     */
    public function getVars()
    {
        return $this->_smarty->getTemplateVars();
    }

    /**
     * Updates Smarty's template_dir field with new value
     *
     * @param string $dir
     * @return void
     */
    public function setTemplateDir($dir)
    {
        $this->_smarty->setTemplateDir($dir);
    }

    /**
     * Adds another Smarty template_dir to scan for templates
     *
     * @param string $dir
     * @return void
     */
    public function addTemplateDir($dir)
    {
        $this->_smarty->addTemplateDir($dir);
    }

    /**
     * Adds another Smarty plugin directory to scan
     * for plugins
     *
     * @param string $dir
     * @return void
     */
    public function addPluginDir($dir)
    {
        $this->_smarty->addPluginsDir($dir);
    }

    /**
     * Zend_View compatibility. Removes all template vars
     *
     * @see View/Zend_View_Abstract::clearVars()
     * @return void
     */
    public function clearVars()
    {
        $this->_smarty->clearAllAssign();
        $this->assign('this', $this);
    }

    /**
     * Magic clone method, on clone create diferent
     * smarty object
     * @return void
     */
    public function __clone()
    {
        $this->_loadSmarty();
    }

    /**
     * Initializes the smarty and populates config params
     *
     * @throws Zend_View_Exception
     * @return void
     */
    private function _loadSmarty()
    {
        if (!class_exists('Smarty', true)) {
            require_once 'Smarty/Smarty.class.php';
        }

        $this->_smarty = new Smarty();

        if ($this->_config === null) {
            throw new Zend_View_Exception(
                "Could not locate Smarty config"
            );
        }

        $this->_smarty->caching
            = $this->_config['caching'];
        $this->_smarty->cache_lifetime
            = $this->_config['cache_lifetime'];
        $this->_smarty->template_dir
            = $this->_config['template_dir'];
        $this->_smarty->compile_dir
            = $this->_config['compile_dir'];
        $this->_smarty->config_dir
            = $this->_config['config_dir'];
        $this->_smarty->cache_dir
            = $this->_config['cache_dir'];
        $this->_smarty->left_delimiter
            = $this->_config['left_delimiter'];
        $this->_smarty->right_delimiter
            = $this->_config['right_delimiter'];
        $this->assign('this', $this);
    }
}

Wir konfigurieren Smarty in der application.ini

; --- Smarty ---

smarty.caching = 1
smarty.cache_lifetime = 14400 ; 4 hours
smarty.template_dir
    = APPLICATION_PATH "/modules/default/views/scripts/"
smarty.compile_dir = APPLICATION_PATH "/smarty/compile/"
smarty.config_dir = ""
smarty.cache_dir = APPLICATION_PATH "/smarty/cache/"
smarty.left_delimiter = "{"
smarty.right_delimiter = "}"

Wir initialisieren Smarty in der Bootstrap.php

...
/**
 * Bootstrap Smarty view
 * @return Mbtec_View_Smarty
 */
protected function _initView()
{
    // initialize smarty view
    $view = new Mbtec_View_Smarty($this->getOption('smarty'));

    // setup viewRenderer with suffix and view
    $viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper('ViewRenderer');
    $viewRenderer->setViewSuffix('tpl');
    $viewRenderer->setView($view);

    // ensure we have layout bootstraped
    $this->bootstrap('layout');

    // set the tpl suffix to layout also
    $layout = Zend_Layout::getMvcInstance();
    $layout->setViewSuffix('tpl');

    return $view;
}
...

Hiermit sind die Vorbereitungen schon abgeschlossen und Smarty sollte aktiv sein. Smarty benutzt standardmäßig die Dateiendung .tpl – also dürfen die Templates nicht mehr mit .phtml enden.

Hier ein kleines Beispiel mit Controller und View:

Datei indexController.php

    ....
    public function indexAction()
    {
        $em = Zend_Registry::get('em');
        $items = $em->createQueryBuilder()
                    ->select('i')
                    ->from('Entities\Item', 'i')
                    ->orderBy('i.foo', 'ASC')
                    ->getQuery()
                    ->getResult();
        $this->view->assign('items', $items);
    }
    ....

Datei index.tpl

{include 'header.tpl' head1='Station' head2='Liste'}

{foreach $this->items as $item}
    <a href="{$this->url([
        'controller' => 'items',
        'action' => 'edit',
        'id' => $item->getId()])}">
        {$this->escape($item->getFoo())}
    </a>
    {$this->escape($item->getBar())}
    {$this->escape($item->getBaz())}
{/foreach}

Datei header.tpl

{$head1}
{$head2}

{$this->flashMessenger()}

sudo vim /etc/mysql/my.cnf

Hier wird dann die folgende Zeile editiert:

#datadir = /var/lib/mysql
datadir = /home/matthias/mysql

Nach dieser Änderung kann es passieren, daß der MySql Dienst nicht wieder gestartet werden kann, weil AppArmor das geänderte Datenverzeichnis nicht kennt und daher die Ausführung des Dienstes verweigert. Im syslog sieht das dann etwa so aus:

Jan 31 14:07:32 Server kernel: [17462.035561] type=1400
audit(1296479252.398:421): apparmor="DENIED" operation="open" parent=1
profile="/usr/sbin/mysqld" name="/home/matthias/mysql/ibdata1"
pid=14807 comm="mysqld" requested_mask="rw" denied_mask="rw"
fsuid=115 ouid=115

Abhilfe ist ganz einfach. Man muss AppArmor das neue Datenverzeichnis bekannt geben.

sudo vim /etc/apparmor.d/usr.sbin.mysqld

Man ergänzt die folgenden Zeilen:

/home/matthias/mysql/ r,
/home/matthias/mysql/** rwk,

Nach einem Neustart von AppArmor

sudo /etc/init.d/apparmor restart

sollte der Mysql Dienst

sudo /etc/init.d/mysql restart

dann wieder starten.

Um z.B. Magento debuggen zu können, benötigt man das ChromePHP – Plugin für den Client sowie ein kleines serverseitiges PHP-Script.

Im Mangento Root Ordner wird ein Verzeichnis “tools” angelegt, in welches das PHP-Script kopiert wird. Danach erweitern wir die index.php um ein paar Zeilen. Um es einfach zu halten, führe ich eine globale Funktion “debug” ein, die als Wrapper für die ChromePHP Methode log dient.

...
// ChromePHP Ext
$filepathChromePhp = 'tools/ChromePhp.php';
if ( is_readable($filepathChromePhp) ) {
    include_once $filepathChromePhp;
}

...
function debug($output)
{
    if ( class_exists('ChromePhp') ) {
        ChromePhp::log($output);
    }
}

So kann in jedem Script eine Debug-Ausgabe erfolgen:

debug($var);

Man sollte jetzt eine solche Ausgabe sehen können:



Wichtig: Das ChromePHP Plugin muss aktiv sein, sonst funktioniert es nicht. Das Symbol oben rechts muss blau leuchten.

ERROR 1064 (42000) at line 1561: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ‘USING BTREE, …

Schuld daran ist das veränderte SQL Syntax der Version 5.1.
Aufgrund eines fehlenden Kompatibilitätsschalters beim Export ( wie zum Beispiel mysqldump -comptability=mysql50 ) bleibt hier nur die Möglichkeit, den Dump an das 5.0 Syntax anzupassen.
Unter Linux geht dies über die Konsole:

sed -i -r 's/\(([^)]+)\) USING BTREE/USING BTREE (\1)/g' mydump.sql

application/configs/application.ini

; General
project.identifier = "Testprojekt"
project.maintainer.email = "info@mb-tec.eu"
project.emails.sender.defaults.email = "info@mb-tec.eu"
project.emails.sender.defaults.name	= "Matthias Büsing"

resources.frontController.plugins.initTranslator = "Mbtec_Controller_Plugin_InitTranslator"

; Hier steht wirklich nichts mehr rechts vom Gleichzeichen (=).
; Diese Zeile darf aber auf keinen Fall weggelassen werden,
; da sonst die Ressource nicht geladen wird.
resources.log = 

library/Mbtec/Resource/Log.php

class Mbtec_Resource_Log extends Zend_Application_Resource_ResourceAbstract
{
  public function init()
  {
    $options = $this->getOptions();
    $config = Zend_Registry::get('config');

    // Mail writer
    $mail = new Zend_Mail();
    $mail->setFrom($config->project->emails->sender->defaults->email)
           ->addTo($config->project->maintainer->email);
    $writer = new Zend_Log_Writer_Mail($mail);
    $writer->setSubjectPrependText(
      'Error in Project ' . $config->project->identifier
    );
    $logEmail = new Zend_Log($writer);

    Zend_Registry::set('Zend_Log_Email', $logEmail);
  }
}

library/Mbtec/Controller/Plugin/InitTranslator.php

class Mbtec_Controller_Plugin_InitTranslator extends Zend_Controller_Plugin_Abstract
{
  public function routeShutdown(Zend_Controller_Request_Abstract $request)
  {
    // In jedem Modul-Verzeichnis liegt ein Unterorder 'translations'
    // Hier liegen die Übersetzungs CSVs
    $moduleDir = Zend_Controller_Front::getInstance()->getModuleDirectory();

    // Eine fest eingestellte Sprache
    // Hier müsste noch eine Logik implementiert werden falls mehrere Sprachen verwendet werden sollen.
    $language = 'de';
    $translateParams = array(
      'adapter'         => Zend_Translate::AN_CSV,
      'content'         => $moduleDir . '/translations/de.csv',
      'locale'          => $language,
      'log'             => Zend_Registry::get('Zend_Log_Email'),
      'logUntranslated' => true,
      'disableNotices'  => false
    );
    Zend_Registry::set(
      'Zend_Translate',
      new Zend_Translate($translateParams)
    );
  }
}

Selbstverständlich kann der Email Writer auch für andere wichtige Meldungen benutzt werden. Mit

Zend_Registry::get('Zend_Log_Email')->info('Nachricht');

kann an jeder beliebigen Stelle im Script eine eMail versandt werden.

Bitte hierzu auch den Artikel Der Versand von eMails über SMTP mit Zend_Mail beachten.

application.ini

project.emails.transport.type          = "smtp"
project.emails.transport.smtp.host     = "[SMTP Host z.B. mb-tec.eu]"
project.emails.transport.smtp.username = "[SMTP Username]"
project.emails.transport.smtp.password = "[SMTP Passwort]"
project.emails.sender.defaults.email   = "info@mb-tec.eu"

PHP

$conf = Zend_Registry::get('config')->project->emails;

switch ( $conf->transport->type ) {
  case 'smtp':
    $smtpConf = array(
      'auth' => 'login',
        'username' => $conf->transport->smtp->username,
       	'password' => $conf->transport->smtp->password
    );
    $transport =
    new Zend_Mail_Transport_Smtp(
      $conf->transport->smtp->host,
      $smtpConf
    );
    break;
  default:
    $transport =
    new Zend_Mail_Transport_Sendmail(
      '-f' . $conf->sender->defaults->email
    );
  }

$mail = new Zend_Mail('UTF-8');
//
// ...
//
$mail->send($transport);

Es funktioniert sehr einfach.
Im ersten Schritt meldet man sich per SSH Konsole als root auf dem Server an.
Man wechselt in das Konfigurationsverzeichnis der betreffenden Domain

cd /var/www/vhosts/domain.tld/conf/

bzw. der Subdomain.

cd /var/www/vhosts/domain.tld/subdomains/name_der_subdomain/conf/

Hier wird jetzt eine neue Konfigurationsdatei angelegt und mit einem Texteditor editiert.

touch vhost.conf
vi vhost.conf

Es wird nun der Pfad zum neuen DocumentRoot Verzeichnis angegeben

DocumentRoot /var/www/vhosts/domain.tld/subdomains/name_der_subdomain/httpdocs/public

Die Datei wird nun abgespeichert und anschließend muss das PLESK die Änderungen noch übernehmen.

/usr/local/psa/admin/sbin/websrvmng --reconfigure-vhost --vhost-name=domain.tld

Als Letztes wird die neue Konfiguration noch in den Apache Webserver übernommen.

/etc/init.d/apache2 reload

Die Grundidee besteht darin, ein gegebenes Passwort mit einem Hauptpasswort und dem Salt zu ergänzen und von dieser Kombination mehrfach rekursiv den Hashwert zu bilden. Dabei muss jedoch der Salt zusätzlich zum Haswert gespeichert werden, da sonst eine Prüfung nicht möglich wäre.

Als erstes legen wir in der application.ini das Hauptpasswort, die Anzahl der Hashingdurchgänge und die Läge des Salts fest. Einmal festgelegt, dürfen sich diese Werte niemals ändern, da sonst alle Passworte nicht mehr prüfbar wären.

; !!! DON'T CHANGE
security.passwordStorage.masterPassword = "h?qHs8(b"
security.passwordStorage.rounds = 2000
security.passwordStorage.saltLength = 10
; !!! DON'T CHANGE

So wird geprüft ob ein eingegebenes Passwort ($password) mit dem Hashwert aus der Datenbank ($hash) überein stimmt.

if ( $this->_helper->password->compare($password, $hash) ) {
  // Passwort stimmt überein
}
else {
  // Das Passwort ist falsch
}

Hiermit wird der Hashwert aus einem gegebenem Passwort erzeugt.

$hash = $this->_helper->password($password);

Und hier der dazugehörige Action Helper

class Mbtec_Controller_Action_Helper_Password extends Zend_Controller_Action_Helper_Abstract
{
  const SEPARATOR = ';';

  public function direct($pwd)
  {
    return $this->password($pwd);
  }

  public function password($pwd)
  {
    return $this->_generateHash($pwd);
  }

  // Passwirt und Hash vergleichen
  public function compare($pwd = '', $hash = '')
  {
    if ( 1 != substr_count($hash, self::SEPARATOR) ) {
      return false;
    }

    list($salt, $value) = explode(self::SEPARATOR, $hash);

    return ( $this->_generateHash($pwd, $salt) == $hash );
  }

  // Hash erzeugen
  private function _generateHash($password = '', $salt = null)
  {
    $config = Zend_Registry::get('config')->security->password;

    if ( null === $salt ) {
      $salt = self::_generateSalt($config->saltLength);
    }

    $hashAlgo = self::_getHashAlgo();
    $hash = hash_hmac(
      $hashAlgo, $salt . $password, $config->password->masterPassword
    );
    $rounds = (int) $config->password->rounds;

    if ( 1 > $rounds ) {
      $rounds = 2000;
    }

    for ( $i = 0; $i < $rounds; ++$i ) {
      $hash = hash($hashAlgo, $hash);
    }

    return $salt . self::SEPARATOR . $hash;
  }

  // Einen zufälligen Salt generieren
  protected function _generateSalt($length = 10)
  {
    $chars = array_merge(
      range('a', 'z'), range('A', 'Z'), range('0', '9')
    );
    $charsQty = count($chars);
    $salt = '';

    for ( $i = 0; $i < $length; ++$i ) {
      shuffle($chars);
      $rndId = mt_rand(0, $charsQty - 1);
      $salt .= $chars[$rndId];
    }

    return $salt;
  }

  // Welcher Hashing Algorithmus kann benutzt werden
  protected function _getHashAlgo()
  {
    $algos = hash_algos();

    if ( in_array('sha256', $algos) ) {
      return 'sha256';
    }
    elseif ( in_array('sha1', $algos) ) {
      return 'sha1';
    }

    return 'md5';
  }
}

In der Datenbank sieht der Hashwert mit SHA256 und 10 stelligem Salt so aus:
UmXioVNsRu;f9b47bd49fd303c4712dd6393f3fd929e350be743497a251ff0399a6376f1096