public static function checkPasswordForUser($password, UserEntity $user)
 {
     if (hash_equals($user->getPassword(), crypt($password, $user->getPassword()))) {
         return true;
     }
     return false;
 }

 public function login($username, $password)
 {
     # Check dependencies
     self::dependencies(isset($this->settings, $username, $password));
     # Call plugins
     $this->plugins(__METHOD__, 0, func_get_args());
     # Check login with MD5 hash
     if ($username === $this->settings['username'] && $password === $this->settings['password']) {
         $_SESSION['login'] = true;
         return true;
     }
     # Check login with crypted hash
     if ($username === $this->settings['username'] && $this->settings['password'] === crypt($password, $this->settings['password'])) {
         $_SESSION['login'] = true;
         return true;
     }
     # No login
     if ($this->settings['username'] === '' && $this->settings['password'] === '') {
         $_SESSION['login'] = true;
         return true;
     }
     # Call plugins
     $this->plugins(__METHOD__, 1, func_get_args());
     return false;
 }

    public function addUser()
    {
        $username = $this->input->post('username');
        $query = 'INSERT INTO users (username, name, email, password, created_at, updated_at)
	          				  VALUES(?, ?, ?, ? ,NOW(), NOW())';
        return $this->db->query($query, array($username, $this->input->post('name'), $this->input->post('email'), crypt($this->input->post('pword'), "SecretSaltyGoodness23")));
    }

 public function guardar()
 {
     $arrayprivilegios = $this->input->post('privilegios');
     $usuario = new Usuario($this->input->post('idusuario'));
     $password = $this->input->post('password');
     if ($usuario->exists()) {
         if (!empty($password)) {
             $usuario->password = crypt($password, 'mr%fsdfOk5ad');
         }
     } else {
         $usuario->password = crypt($password, 'mr%fsdfOk5ad');
     }
     $usuario->usuario = $this->input->post('usuario');
     $usuario->email = $this->input->post('email');
     $usuario->save();
     //guardamos los privilegios...
     $privilegios = new Privilegio();
     $privilegios->get();
     $usuario->delete($privilegios->all);
     //borramos todos...
     foreach ($arrayprivilegios as $idprivilegio) {
         $privilegio = new Privilegio($idprivilegio);
         $usuario->save($privilegio);
     }
     redirect('admin/usuarios/listado');
 }

 function ADODB_Session_Key()
 {
     $ADODB_CRYPT_KEY = 'CRYPTED ADODB SESSIONS ROCK!';
     /* USE THIS FUNCTION TO CREATE THE ENCRYPTION KEY FOR CRYPTED SESSIONS	*/
     /* Crypt the used key, $ADODB_CRYPT_KEY as key and session_ID as SALT	*/
     return crypt($ADODB_CRYPT_KEY, session_ID());
 }

 /**
  * @param string $secret
  * @param int $code
  * @return bool
  */
 public function authenticate($secret, $code)
 {
     $correct = false;
     for ($i = -1; $i <= 1; $i++) {
         if ($this->calculateCode($secret) == $code) {
             $correct = true;
             break;
         }
     }
     // If they're not using a cache to prevent people being able to use the same code twice or if they were wrong anyway...
     if (!isset($this->cachePool) || $correct == false) {
         return $correct;
     }
     // If we're here then we must be using a cache, and we must be right
     // We generate the key as securely as possible, then salt it using something that will always be replicatable.
     // We're doing this hashing for de-duplication (aka, we want to know if it exists), but as we're also possibly
     // securing the secret somewhere, we want to try and have as secure as possible
     //
     // If someone has any better suggestions on how to achieve this, please send in a PR! :P
     $key = crypt($secret . "|" . $code, md5($code));
     // If it existed, then we want this function to return false
     if ($this->cachePool->hasItem($key)) {
         return false;
     }
     // If it didn't, then we want this function to add it to the cache
     // In PSR-6 getItem will always contain an CacheItemInterface and that seems to be the only way to add stuff
     // to the cachePool
     $item = $this->cachePool->getItem($key);
     // It's a quick expiry thing, 30 seconds is more than long enough
     $item->expiresAfter(new \DateInterval("PT30S"));
     // We don't care about the value at all, it's just something that's needed to use the caching interface
     $item->set(true);
     $this->cachePool->save($item);
     return true;
 }

function hash_pwd($pwd)
{
    $salt = strtr(base64_encode(mcrypt_create_iv(16, MCRYPT_DEV_URANDOM)), '+', '.');
    $salt = sprintf("\$2a\$%02d\$", 10) . $salt;
    $hash = crypt($pwd, $salt);
    return $hash;
}

 public static function check($input, $stored_hash)
 {
     if (version_compare(PHP_VERSION, '5.3') < 0) {
         throw new Exception("Bcrypt requires PHP 5.3 or above");
     }
     return crypt($input, $stored_hash) == $stored_hash;
 }

 /**
  * Encrypt value
  *
  * @param string $value
  * @param string $salt   Salt or crypted hash
  * @return string
  */
 public function encrypt($value, $salt = null)
 {
     if ($value instanceof Fs_File) {
         $value = $value->getContents();
     }
     $value .= $this->secret;
     switch (strtolower($this->method)) {
         case null:
         case 'crypt':
             return crypt($value, $salt);
         case 'std_des':
             if (!CRYPT_STD_DES) {
                 throw new Exception("Unable to encrypt value: Standard DES-based encryption with crypt() not available.");
             }
             return crypt($value, isset($salt) ? substr($salt, 0, 2) : $this->makesalt(2));
             break;
         case 'ext_des':
             if (!CRYPT_EXT_DES) {
                 throw new Exception("Unable to encrypt value: Extended DES-based encryption with crypt() not available.");
             }
             return crypt($value, isset($salt) ? $salt : $this->makesalt(9));
         case 'md5':
             if (!CRYPT_MD5) {
                 throw new Exception("Unable to encrypt value: MD5 encryption with crypt() not available.");
             }
             return crypt($value, isset($salt) ? $salt : $this->makesalt(12));
         case 'blowfish':
             if (!CRYPT_BLOWFISH) {
                 throw new Exception("Unable to encrypt value: Blowfish encryption with crypt() not available.");
             }
             return crypt($value, isset($salt) ? $salt : $this->makesalt(29));
         default:
             throw new Exception("Unable to encrypt value: Unknown crypt method '{$this->method}'");
     }
 }

 public function isValidUser($userName, $password)
 {
     $user = $this->getByUsername($userName);
     if (is_null($user)) {
         return null;
     }
     $savedPassword = $user->getField($this->getUserTable()->password);
     $validatedUser = null;
     if ($savedPassword === AUTH_PASSWORD_NOT_CACHED) {
         return null;
     }
     if ($this->passwordIsLegacyHash($savedPassword)) {
         if ($savedPassword === md5($password . $this->_siteSalt) || $savedPassword === md5($password) || $savedPassword === md5(addslashes($password) . $this->_siteSalt) || $savedPassword === md5(addslashes($password))) {
             $validatedUser = $user;
         }
     } else {
         if (!function_exists('crypt')) {
             throw new ErrorException("Crypt must be loaded for password_verify to function");
         }
         $ret = crypt($password, $savedPassword);
         if (!is_string($ret) || strlen($ret) != strlen($savedPassword) || strlen($ret) <= 13) {
             return null;
         }
         $status = 0;
         $lenRet = strlen($ret);
         for ($i = 0; $i < $lenRet; $i++) {
             $status |= ord($ret[$i]) ^ ord($savedPassword[$i]);
         }
         if ($status === 0) {
             $validatedUser = $user;
         }
     }
     return $validatedUser;
 }

 public static function verify($str, $hash)
 {
     if ($hash == crypt($str, $hash)) {
         return true;
     }
     return false;
 }

 /**
  * Authenticates the password with the users current password.
  *
  * @param string $password
  *
  * @return boolean
  */
 public function authenticate($password)
 {
     if ($this->password_ver == 'crypt') {
         return $this->password === crypt($password, $this->password);
     } else {
     }
 }

 public function validate($strPlainText, $strHash)
 {
     if (CRYPT_SHA512 != 1) {
         throw new Exception('Hashing mechanism not supported.');
     }
     return crypt($strPlainText, $strHash) == $strHash ? true : false;
 }

 /**
  * Encrypts the data
  * @param string $data
  * @return string
  * @throws \InvalidArgumentException
  * @see hash()
  */
 public function encrypt($data)
 {
     if (!is_string($data)) {
         throw new \InvalidArgumentException('data');
     }
     return crypt($data, $this->getSalt());
 }

function authenticate($username, $password)
{
    $encrypted_old = md5($password);
    $row = dbFetchRow('SELECT username,password FROM `users` WHERE `username`= ?', array($username), true);
    if ($row['username'] && $row['username'] == $username) {
        // Migrate from old, unhashed password
        if ($row['password'] == $encrypted_old) {
            $row_type = dbFetchRow('DESCRIBE users password');
            if ($row_type['Type'] == 'varchar(34)') {
                changepassword($username, $password);
            }
            return 1;
        } else {
            if (substr($row['password'], 0, 3) == '$1$') {
                $row_type = dbFetchRow('DESCRIBE users password');
                if ($row_type['Type'] == 'varchar(60)') {
                    if ($row['password'] == crypt($password, $row['password'])) {
                        changepassword($username, $password);
                    }
                }
            }
        }
        $hasher = new PasswordHash(8, false);
        if ($hasher->CheckPassword($password, $row['password'])) {
            return 1;
        }
    }
    //end if
    return 0;
}

 public function CreateHash($input)
 {
     global $cphp_config;
     $hash = crypt($input, "\$5\$rounds=50000\${$this->uSalt}{$cphp_config->salt}\$");
     $parts = explode("\$", $hash);
     return $parts[4];
 }

 public function login($user, $passw, $token, $device_id)
 {
     $resultToken = mysql_query("SELECT COUNT(*) FROM aplicacion WHERE sesion_token = '{$token}' and id_dispositivo = '{$device_id}' and vencimiento_sesion > CURRENT_TIMESTAMP ");
     $countToken = mysql_fetch_row($resultToken);
     if ($countToken[0] == 0) {
         $result = mysql_query("SELECT COUNT(*) FROM usuarios WHERE correo='{$user}' ");
         $count = mysql_fetch_row($result);
         if ($count[0] == 0) {
             return false;
         } else {
             $resultPass = mysql_query("SELECT contrasena FROM usuarios WHERE correo='{$user}' ");
             $arrPass = mysql_fetch_row($resultPass);
             if (crypt($passw, $arrPass[0]) == $arrPass[0]) {
                 // crear token
                 $tokenNuevo = base64_encode($user . mt_rand());
                 $resultToken = mysql_query("SELECT COUNT(*) FROM aplicacion WHERE correo='{$user}'");
                 $countToken = mysql_fetch_row($resultToken);
                 if ($countToken[0] == 0) {
                     $sql_usr = "INSERT INTO aplicacion (correo,sesion_token,id_dispositivo ,vencimiento_sesion) VALUES ('{$user}', '{$tokenNuevo}', '{$device_id}', Date_Add(CURRENT_TIMESTAMP, INTERVAL 30 DAY))";
                 } else {
                     $sql_usr = "UPDATE aplicacion SET sesion_token = '{$tokenNuevo}', id_dispositivo  = '{$device_id}', vencimiento_sesion = Date_Add(CURRENT_TIMESTAMP, INTERVAL 30 DAY) Where correo = '{$user}'";
                 }
                 mysql_query($sql_usr);
                 return true;
             } else {
                 return false;
             }
         }
     } else {
         return true;
     }
 }

 private function verifyPassword($clearPassword, $hashPassword)
 {
     //PHP 5.5.0
     //return password_verify($clearPassword,$hashPassword);
     //PHP <5.5.0
     return crypt($clearPassword, $hashPassword) == $hashPassword;
 }

function passwordVerifyUF($password, $hash)
{
    if (getPasswordHashTypeUF($hash) == "sha1") {
        $salt = substr($hash, 0, 25);
        // Extract the salt from the hash
        $hash_input = $salt . sha1($salt . $password);
        if ($hash_input == $hash) {
            return true;
        } else {
            return false;
        }
    } else {
        if (getPasswordHashTypeUF($hash) == "homegrown") {
            /*used for manual implementation of bcrypt*/
            $cost = '12';
            if (substr($hash, 0, 60) == crypt($password, "\$2y\$" . $cost . "\$" . substr($hash, 60))) {
                return true;
            } else {
                return false;
            }
            // Modern implementation
        } else {
            return password_verify($password, $hash);
        }
    }
}

 public static function my_hash($var)
 {
     $salt = 'ABC';
     $salt2 = 'CBA';
     $var = crypt(md5($var . $salt), $salt2);
     return $var;
 }