Database Table Authentication - Zend_Auth

Database Table Authentication


Zend_Auth_Adapter_DbTable provides the ability to authenticate against credentials stored in a database table. Because Zend_Auth_Adapter_DbTable requires an instance of Zend_Db_Adapter_Abstract to be passed to its constructor, each instance is bound to a particular database connection. Other configuration options may be set through the constructor and through instance methods, one for each option.

The available configuration options include:

  • tableName: This is the name of the database table that contains the authentication credentials, and against which the database authentication query is performed.

  • identityColumn: This is the name of the database table column used to represent the identity. The identity column must contain unique values, such as a username or e-mail address.

  • credentialColumn: This is the name of the database table column used to represent the credential. Under a simple identity and password authentication scheme, the credential value corresponds to the password. See also the credentialTreatment option.

  • credentialTreatment: In many cases, passwords and other sensitive data are encrypted, hashed, encoded, obscured, salted or otherwise treated through some function or algorithm. By specifying a parameterized treatment string with this method, such as ' MD5(?)' or ' PASSWORD(?)', a developer may apply such arbitrary SQL upon input credential data. Since these functions are specific to the underlying RDBMS, check the database manual for the availability of such functions for your database system.

Example #1 Basic Usage

As explained in the introduction, the Zend_Auth_Adapter_DbTable constructor requires an instance of Zend_Db_Adapter_Abstract that serves as the database connection to which the authentication adapter instance is bound. First, the database connection should be created.

The following code creates an adapter for an in-memory database, creates a simple table schema, and inserts a row against which we can perform an authentication query later. This example requires the PDO SQLite extension to be available:

  1. // Create an in-memory SQLite database connection
  2. $dbAdapter = new Zend_Db_Adapter_Pdo_Sqlite(array('dbname' =>
  3.                                                   ':memory:'));
  5. // Build a simple table creation query
  6. $sqlCreate = 'CREATE TABLE [users] ('
  7.            . '[id] INTEGER  NOT NULL PRIMARY KEY, '
  8.            . '[username] VARCHAR(50) UNIQUE NOT NULL, '
  9.            . '[password] VARCHAR(32) NULL, '
  10.            . '[real_name] VARCHAR(150) NULL)';
  12. // Create the authentication credentials table
  13. $dbAdapter->query($sqlCreate);
  15. // Build a query to insert a row for which authentication may succeed
  16. $sqlInsert = "INSERT INTO users (username, password, real_name) "
  17.            . "VALUES ('my_username', 'my_password', 'My Real Name')";
  19. // Insert the data
  20. $dbAdapter->query($sqlInsert);

With the database connection and table data available, an instance of Zend_Auth_Adapter_DbTable may be created. Configuration option values may be passed to the constructor or deferred as parameters to setter methods after instantiation:

  1. // Configure the instance with constructor parameters...
  2. $authAdapter = new Zend_Auth_Adapter_DbTable(
  3.     $dbAdapter,
  4.     'users',
  5.     'username',
  6.     'password'
  7. );
  9. // ...or configure the instance with setter methods
  10. $authAdapter = new Zend_Auth_Adapter_DbTable($dbAdapter);
  12. $authAdapter
  13.     ->setTableName('users')
  14.     ->setIdentityColumn('username')
  15.     ->setCredentialColumn('password')
  16. ;

At this point, the authentication adapter instance is ready to accept authentication queries. In order to formulate an authentication query, the input credential values are passed to the adapter prior to calling the authenticate() method:

  1. // Set the input credential values (e.g., from a login form)
  2. $authAdapter
  3.     ->setIdentity('my_username')
  4.     ->setCredential('my_password')
  5. ;
  7. // Perform the authentication query, saving the result

In addition to the availability of the getIdentity() method upon the authentication result object, Zend_Auth_Adapter_DbTable also supports retrieving the table row upon authentication success:

  1. // Print the identity
  2. echo $result->getIdentity() . "\n\n";
  4. // Print the result row
  5. print_r($authAdapter->getResultRowObject());
  7. /* Output:
  8. my_username
  10. Array
  11. (
  12.     [id] => 1
  13.     [username] => my_username
  14.     [password] => my_password
  15.     [real_name] => My Real Name
  16. )

Since the table row contains the credential value, it is important to secure the values against unintended access.

Advanced Usage: Persisting a DbTable Result Object

By default, Zend_Auth_Adapter_DbTable returns the identity supplied back to the auth object upon successful authentication. Another use case scenario, where developers want to store to the persistent storage mechanism of Zend_Auth an identity object containing other useful information, is solved by using the getResultRowObject() method to return a stdClass object. The following code snippet illustrates its use:

  1. // authenticate with Zend_Auth_Adapter_DbTable
  2. $result = $this->_auth->authenticate($adapter);
  4. if ($result->isValid()) {
  5.     // store the identity as an object where only the username and
  6.     // real_name have been returned
  7.     $storage = $this->_auth->getStorage();
  8.     $storage->write($adapter->getResultRowObject(array(
  9.         'username',
  10.         'real_name',
  11.     )));
  13.     // store the identity as an object where the password column has
  14.     // been omitted
  15.     $storage->write($adapter->getResultRowObject(
  16.         null,
  17.         'password'
  18.     ));
  20.     /* ... */
  22. } else {
  24.     /* ... */
  26. }

Advanced Usage By Example

While the primary purpose of Zend_Auth (and consequently Zend_Auth_Adapter_DbTable) is primarily authentication and not authorization, there are a few instances and problems that toe the line between which domain they fit within. Depending on how you've decided to explain your problem, it sometimes makes sense to solve what could look like an authorization problem within the authentication adapter.

With that disclaimer out of the way, Zend_Auth_Adapter_DbTable has some built in mechanisms that can be leveraged for additional checks at authentication time to solve some common user problems.

  1. // The status field value of an account is not equal to "compromised"
  2. $adapter = new Zend_Auth_Adapter_DbTable(
  3.     $db,
  4.     'users',
  5.     'username',
  6.     'password',
  7.     'MD5(?) AND status != "compromised"'
  8. );
  10. // The active field value of an account is equal to "TRUE"
  11. $adapter = new Zend_Auth_Adapter_DbTable(
  12.     $db,
  13.     'users',
  14.     'username',
  15.     'password',
  16.     'MD5(?) AND active = "TRUE"'

Another scenario can be the implementation of a salting mechanism. Salting is a term referring to a technique which can highly improve your application's security. It's based on the idea that concatenating a random string to every password makes it impossible to accomplish a successful brute force attack on the database using pre-computed hash values from a dictionary.

Therefore, we need to modify our table to store our salt string:

  1. $sqlAlter = "ALTER TABLE [users] "
  2.           . "ADD COLUMN [password_salt] "
  3.           . "AFTER [password]";

Here's a simple way to generate a salt string for every user at registration:

  1. for ($i = 0; $i < 50; $i++) {
  2.     $dynamicSalt .= chr(rand(33, 126));

And now let's build the adapter:

  1. $adapter = new Zend_Auth_Adapter_DbTable(
  2.     $db,
  3.     'users',
  4.     'username',
  5.     'password',
  6.     "MD5(CONCAT('"
  7.     . Zend_Registry::get('staticSalt')
  8.     . "', ?, password_salt))"
  9. );

Note: You can improve security even more by using a static salt value hard coded into your application. In the case that your database is compromised (e. g. by an SQL injection attack) but your web server is intact your data is still unusable for the attacker.

Another alternative is to use the getDbSelect() method of the Zend_Auth_Adapter_DbTable after the adapter has been constructed. This method will return the Zend_Db_Select object instance it will use to complete the authenticate() routine. It is important to note that this method will always return the same object regardless if authenticate() has been called or not. This object will not have any of the identity or credential information in it as those values are placed into the select object at authenticate() time.

An example of a situation where one might want to use the getDbSelect() method would check the status of a user, in other words to see if that user's account is enabled.

  1. // Continuing with the example from above
  2. $adapter = new Zend_Auth_Adapter_DbTable(
  3.     $db,
  4.     'users',
  5.     'username',
  6.     'password',
  7.     'MD5(?)'
  8. );
  10. // get select object (by reference)
  11. $select = $adapter->getDbSelect();
  12. $select->where('active = "TRUE"');
  14. // authenticate, this ensures that = TRUE
  15. $adapter->authenticate();


© 2006-2022 by Zend by Perforce. Made with by awesome contributors.

This website is built using zend-expressive and it runs on PHP 7.