PHP BackendAuthentication::getEncryptedString方法代码示例

 /**
  * Validate the form
  */
 private function validateForm()
 {
     // is the form submitted?
     if ($this->frm->isSubmitted()) {
         // cleanup the submitted fields, ignore fields that were added by hackers
         $this->frm->cleanupFields();
         // email is present
         if ($this->frm->getField('email')->isFilled(BL::err('EmailIsRequired'))) {
             // is this an email-address
             if ($this->frm->getField('email')->isEmail(BL::err('EmailIsInvalid'))) {
                 // was this emailaddress deleted before
                 if (BackendUsersModel::emailDeletedBefore($this->frm->getField('email')->getValue())) {
                     $this->frm->getField('email')->addError(sprintf(BL::err('EmailWasDeletedBefore'), BackendModel::createURLForAction('undo_delete', null, null, array('email' => $this->frm->getField('email')->getValue()))));
                 } else {
                     // email already exists
                     if (BackendUsersModel::existsEmail($this->frm->getField('email')->getValue())) {
                         $this->frm->getField('email')->addError(BL::err('EmailAlreadyExists'));
                     }
                 }
             }
         }
         // required fields
         $this->frm->getField('password')->isFilled(BL::err('PasswordIsRequired'));
         $this->frm->getField('nickname')->isFilled(BL::err('NicknameIsRequired'));
         $this->frm->getField('name')->isFilled(BL::err('NameIsRequired'));
         $this->frm->getField('surname')->isFilled(BL::err('SurnameIsRequired'));
         $this->frm->getField('interface_language')->isFilled(BL::err('FieldIsRequired'));
         $this->frm->getField('date_format')->isFilled(BL::err('FieldIsRequired'));
         $this->frm->getField('time_format')->isFilled(BL::err('FieldIsRequired'));
         $this->frm->getField('number_format')->isFilled(BL::err('FieldIsRequired'));
         $this->frm->getField('groups')->isFilled(BL::err('FieldIsRequired'));
         if ($this->frm->getField('password')->isFilled()) {
             if ($this->frm->getField('password')->getValue() !== $this->frm->getField('confirm_password')->getValue()) {
                 $this->frm->getField('confirm_password')->addError(BL::err('ValuesDontMatch'));
             }
         }
         // validate avatar
         if ($this->frm->getField('avatar')->isFilled()) {
             // correct extension
             if ($this->frm->getField('avatar')->isAllowedExtension(array('jpg', 'jpeg', 'gif', 'png'), BL::err('JPGGIFAndPNGOnly'))) {
                 // correct mimetype?
                 $this->frm->getField('avatar')->isAllowedMimeType(array('image/gif', 'image/jpg', 'image/jpeg', 'image/png'), BL::err('JPGGIFAndPNGOnly'));
             }
         }
         // no errors?
         if ($this->frm->isCorrect()) {
             // build settings-array
             $settings['nickname'] = $this->frm->getField('nickname')->getValue();
             $settings['name'] = $this->frm->getField('name')->getValue();
             $settings['surname'] = $this->frm->getField('surname')->getValue();
             $settings['interface_language'] = $this->frm->getField('interface_language')->getValue();
             $settings['date_format'] = $this->frm->getField('date_format')->getValue();
             $settings['time_format'] = $this->frm->getField('time_format')->getValue();
             $settings['datetime_format'] = $settings['date_format'] . ' ' . $settings['time_format'];
             $settings['number_format'] = $this->frm->getField('number_format')->getValue();
             $settings['csv_split_character'] = $this->frm->getField('csv_split_character')->getValue();
             $settings['csv_line_ending'] = $this->frm->getField('csv_line_ending')->getValue();
             $settings['password_key'] = uniqid();
             $settings['current_password_change'] = time();
             $settings['avatar'] = 'no-avatar.gif';
             $settings['api_access'] = (bool) $this->frm->getField('api_access')->getChecked();
             // get selected groups
             $groups = $this->frm->getField('groups')->getChecked();
             // init var
             $newSequence = BackendGroupsModel::getSetting($groups[0], 'dashboard_sequence');
             // loop through groups and collect all dashboard widget sequences
             foreach ($groups as $group) {
                 $sequences[] = BackendGroupsModel::getSetting($group, 'dashboard_sequence');
             }
             // loop through sequences
             foreach ($sequences as $sequence) {
                 // loop through modules inside a sequence
                 foreach ($sequence as $moduleKey => $module) {
                     // loop through widgets inside a module
                     foreach ($module as $widgetKey => $widget) {
                         // if widget present set true
                         if ($widget['present']) {
                             $newSequence[$moduleKey][$widgetKey]['present'] = true;
                         }
                     }
                 }
             }
             // add new sequence to settings
             $settings['dashboard_sequence'] = $newSequence;
             // build user-array
             $user['email'] = $this->frm->getField('email')->getValue();
             $user['password'] = BackendAuthentication::getEncryptedString($this->frm->getField('password')->getValue(true), $settings['password_key']);
             // save the password strength
             $passwordStrength = BackendAuthentication::checkPassword($this->frm->getField('password')->getValue(true));
             $settings['password_strength'] = $passwordStrength;
             // save changes
             $user['id'] = (int) BackendUsersModel::insert($user, $settings);
             // has the user submitted an avatar?
             if ($this->frm->getField('avatar')->isFilled()) {
                 // create new filename
                 $filename = rand(0, 3) . '_' . $user['id'] . '.' . $this->frm->getField('avatar')->getExtension();
                 // add into settings to update
//.........这里部分代码省略.........

    /**
     * Login the user with the given credentials.
     * Will return a boolean that indicates if the user is logged in.
     *
     * @return	bool
     * @param	string $login		The users login.
     * @param	string $password	The password provided by the user.
     */
    public static function loginUser($login, $password)
    {
        // redefine
        $login = (string) $login;
        $password = (string) $password;
        // init vars
        $db = BackendModel::getDB(true);
        // fetch the encrypted password
        $passwordEncrypted = BackendAuthentication::getEncryptedPassword($login, $password);
        // check in database (is the user active and not deleted, are the email and password correct?)
        $userId = (int) $db->getVar('SELECT u.id
										FROM users AS u
										WHERE u.email = ? AND u.password = ? AND u.active = ? AND u.deleted = ?
										LIMIT 1', array($login, $passwordEncrypted, 'Y', 'N'));
        // not 0 = valid user!
        if ($userId !== 0) {
            // cleanup old sessions
            self::cleanupOldSessions();
            // build the session array (will be stored in the database)
            $session = array();
            $session['user_id'] = $userId;
            $session['secret_key'] = BackendAuthentication::getEncryptedString(SpoonSession::getSessionId(), $userId);
            $session['session_id'] = SpoonSession::getSessionId();
            $session['date'] = BackendModel::getUTCDate();
            // insert a new row in the session-table
            $db->insert('users_sessions', $session);
            // store some values in the session
            SpoonSession::set('backend_logged_in', true);
            SpoonSession::set('backend_secret_key', $session['secret_key']);
            // return result
            return true;
        } else {
            // reset values for invalid users. We can't destroy the session because session-data can be used on the site.
            SpoonSession::set('backend_logged_in', false);
            SpoonSession::set('backend_secret_key', '');
            // return result
            return false;
        }
    }

 /**
  * Validate the forms
  */
 private function validateForm()
 {
     if ($this->frm->isSubmitted()) {
         $txtEmail = $this->frm->getField('backend_email');
         $txtPassword = $this->frm->getField('backend_password');
         // required fields
         if (!$txtEmail->isFilled() || !$txtPassword->isFilled()) {
             // add error
             $this->frm->addError('fields required');
             // show error
             $this->tpl->assign('hasError', true);
         }
         // invalid form-token?
         if ($this->frm->getToken() != $this->frm->getField('form_token')->getValue()) {
             // set a correct header, so bots understand they can't mess with us.
             if (!headers_sent()) {
                 header('400 Bad Request', true, 400);
             }
         }
         // all fields are ok?
         if ($txtEmail->isFilled() && $txtPassword->isFilled() && $this->frm->getToken() == $this->frm->getField('form_token')->getValue()) {
             // try to login the user
             if (!BackendAuthentication::loginUser($txtEmail->getValue(), $txtPassword->getValue())) {
                 // add error
                 $this->frm->addError('invalid login');
                 // store attempt in session
                 $current = SpoonSession::exists('backend_login_attempts') ? (int) SpoonSession::get('backend_login_attempts') : 0;
                 // increment and store
                 SpoonSession::set('backend_login_attempts', ++$current);
                 // show error
                 $this->tpl->assign('hasError', true);
             }
         }
         // check sessions
         if (SpoonSession::exists('backend_login_attempts') && (int) SpoonSession::get('backend_login_attempts') >= 5) {
             // get previous attempt
             $previousAttempt = SpoonSession::exists('backend_last_attempt') ? SpoonSession::get('backend_last_attempt') : time();
             // calculate timeout
             $timeout = 5 * (SpoonSession::get('backend_login_attempts') - 4);
             // too soon!
             if (time() < $previousAttempt + $timeout) {
                 // sleep untill the user can login again
                 sleep($timeout);
                 // set a correct header, so bots understand they can't mess with us.
                 if (!headers_sent()) {
                     header('503 Service Unavailable', true, 503);
                 }
             } else {
                 // increment and store
                 SpoonSession::set('backend_last_attempt', time());
             }
             // too many attempts
             $this->frm->addEditor('too many attempts');
             // show error
             $this->tpl->assign('hasTooManyAttemps', true);
             $this->tpl->assign('hasError', false);
         }
         // no errors in the form?
         if ($this->frm->isCorrect()) {
             // cleanup sessions
             SpoonSession::delete('backend_login_attempts');
             SpoonSession::delete('backend_last_attempt');
             // create filter with modules which may not be displayed
             $filter = array('authentication', 'error', 'core');
             // get all modules
             $modules = array_diff(BackendModel::getModules(), $filter);
             // loop through modules and break on first allowed module
             foreach ($modules as $module) {
                 if (BackendAuthentication::isAllowedModule($module)) {
                     break;
                 }
             }
             // redirect to the correct URL (URL the user was looking for or fallback)
             $this->redirect($this->getParameter('querystring', 'string', BackendModel::createUrlForAction(null, $module)));
         }
     }
     // is the form submitted
     if ($this->frmForgotPassword->isSubmitted()) {
         // backend email
         $email = $this->frmForgotPassword->getField('backend_email_forgot')->getValue();
         // required fields
         if ($this->frmForgotPassword->getField('backend_email_forgot')->isEmail(BL::err('EmailIsInvalid'))) {
             // check if there is a user with the given emailaddress
             if (!BackendUsersModel::existsEmail($email)) {
                 $this->frmForgotPassword->getField('backend_email_forgot')->addError(BL::err('EmailIsUnknown'));
             }
         }
         // no errors in the form?
         if ($this->frmForgotPassword->isCorrect()) {
             // generate the key for the reset link and fetch the user ID for this email
             $key = BackendAuthentication::getEncryptedString($email, uniqid());
             // insert the key and the timestamp into the user settings
             $userId = BackendUsersModel::getIdByEmail($email);
             $user = new BackendUser($userId);
             $user->setSetting('reset_password_key', $key);
             $user->setSetting('reset_password_timestamp', time());
             // variables to parse in the e-mail
//.........这里部分代码省略.........

 /**
  * Default authentication
  *
  * @return	bool
  */
 public static function authorize()
 {
     // grab data
     $email = SpoonFilter::getGetValue('email', null, '');
     $nonce = SpoonFilter::getGetValue('nonce', null, '');
     $secret = SpoonFilter::getGetValue('secret', null, '');
     // data can be available in the POST, so check it
     if ($email == '') {
         $email = SpoonFilter::getPostValue('email', null, '');
     }
     if ($nonce == '') {
         $nonce = SpoonFilter::getPostValue('nonce', null, '');
     }
     if ($secret == '') {
         $secret = SpoonFilter::getPostValue('secret', null, '');
     }
     // check if needed elements are available
     if ($email == '') {
         self::output(self::BAD_REQUEST, array('message' => 'No email-parameter provided.'));
     }
     if ($nonce == '') {
         self::output(self::BAD_REQUEST, array('message' => 'No nonce-parameter provided.'));
     }
     if ($secret == '') {
         self::output(self::BAD_REQUEST, array('message' => 'No secret-parameter provided.'));
     }
     // get the user
     $user = new BackendUser(null, $email);
     // user is god!
     if ($user->isGod()) {
         return true;
     }
     // get settings
     $apiAccess = $user->getSetting('api_access', false);
     $apiKey = $user->getSetting('api_key');
     // no API-access
     if (!$apiAccess) {
         self::output(self::FORBIDDEN, array('message' => 'Your account isn\'t allowed to use the API. Contact an administrator.'));
     }
     // create hash
     $hash = BackendAuthentication::getEncryptedString($email . $apiKey, $nonce);
     // output
     if ($secret != $hash) {
         self::output(self::FORBIDDEN, array('message' => 'Invalid secret.'));
     }
     // return
     return true;
 }

 /**
  * Update the user password
  *
  * @param BackendUser $user An instance of BackendUser.
  * @param string $password The new password for the user.
  */
 public static function updatePassword(BackendUser $user, $password)
 {
     // fetch user info
     $userId = $user->getUserId();
     $key = $user->getSetting('password_key');
     // update user
     BackendModel::getDB(true)->update('users', array('password' => BackendAuthentication::getEncryptedString((string) $password, $key)), 'id = ?', $userId);
     // remove the user settings linked to the resetting of passwords
     self::deleteResetPasswordSettings($userId);
 }