Sends the login packet with specific password.
 Read the result with `read`.
 Warning: Strongly disencouraged. Use tokens instead, when possible.
320993
def login_with_password(bot, name, password)
            send Common::Login.new(bot, name, password, nil)
        end
451665
def get_password(self, service, username):
        
        result = self._get_entry(self._keyring, service, username)
        if result:
            result = self._decrypt(result)
        return result
1230593
def changeLocalUserPassword(self, login, user, password):
    
    self.send_changeLocalUserPassword(login, user, password)
    self.recv_changeLocalUserPassword()
1133630
def password(self, password):
        
        from boiler.user.util.passlib import passlib_context
        password = str(password)
        encrypted = passlib_context.encrypt(password)
        self._password = encrypted
1173867
def encrypt(self, password):
        
        if not password or not self._crypter:
            return password or b''
        return self._crypter.encrypt(password)
846925
def authenticate(self, dn='', password=''):
        
        try:
            self.connection.simple_bind_s(dn, password)
        except tuple(self.failed_authentication_exceptions):
            return False
        else:
            return True
972245
def check_password(self, hashed_password, plain_password):
        
        salt, encrypted_password = hashed_password.split('$')
        re_encrypted_password = self.get_hash(salt, plain_password)
        return encrypted_password == re_encrypted_password
353163
def set_password(self, password, encryptAlgo='MD5'):
		
		if not password:
			self.info['encryptionAlgorithmID'] = None
			self.info['keyHashAlgorithm'] = None
			return

		self.password = gntp.shim.b(password)
		self.encryptAlgo = encryptAlgo.upper()

		if not self.encryptAlgo in self.hash_algo:
			raise errors.UnsupportedError('INVALID HASH "%s"' % self.encryptAlgo)

		hashfunction = self.hash_algo.get(self.encryptAlgo)

		password = password.encode('utf8')
		seed = time.ctime().encode('utf8')
		salt = hashfunction(seed).hexdigest()
		saltHash = hashfunction(seed).digest()
		keyBasis = password + saltHash
		key = hashfunction(keyBasis).digest()
		keyHash = hashfunction(key).hexdigest()

		self.info['keyHashAlgorithmID'] = self.encryptAlgo
		self.info['keyHash'] = keyHash.upper()
		self.info['salt'] = salt.upper()
915326
def input_password(self, message=None):
        
        message = self.__prompt_formatter.format_prompt(message)
        try:
            if message:
                return getpass.getpass(message)
            else:
                return getpass.getpass()
        except BaseException:
            self.__screen.println('Warning: Unable to mask input; characters will be echoed to console')
            return self.input(message)
882788
def generate_password
      if(self.password.nil?)
        self.password = Digest::SHA1.hexdigest(self.username + self.enterprise_id)
      else
        self.password = Digest::SHA1.hexdigest(self.password + self.enterprise_id)
      end
    end
648108
def auth_token(cls, token):
        

        store = goldman.sess.store
        login = store.find(cls.RTYPE, 'token', token)

        if not login:
            msg = 'No login found with that token. It may have been revoked.'
            raise AuthRejected(**{'detail': msg})
        elif login.locked:
            msg = 'The login account is currently locked out.'
            raise AuthRejected(**{'detail': msg})
        else:
            login.post_authenticate()
225765
def handle_get_passphrase(self, conn, _):
        """"""
        p1 = self.client.device.ui.get_passphrase('Symmetric encryption:')
        p2 = self.client.device.ui.get_passphrase('Re-enter encryption:')
        if p1 == p2:
            result = b'D ' + util.assuan_serialize(p1.encode('ascii'))
            keyring.sendline(conn, result, confidential=True)
        else:
            log.warning('Passphrase does not match!')
266397
def login
      response = @client.call(:login,
        cookies: @auth_cookie,
        message: {
          username: @username, 
          password: decrypt(@password)
        })

      @auth_cookie = response.http.cookies if @auth_cookie.nil?
      @login_token = response.hash[:envelope][:body][:login_response][:login_result]
      response
    end
721076
def login(self, username, password):
        

        data = self._authenticate(
            grant_type='password',
            username=username,
            password=password,
            client_id=self._client_id,
            client_secret=self._client_secret
        )

        self._username = username
        self._password = password

        return data
945230
def _login(self, password):
        
        self.smtp = self.connection(self.host, self.port, **self.kwargs)
        self.smtp.set_debuglevel(self.debuglevel)
        if self.starttls:
            self.smtp.ehlo()
            if self.starttls is True:
                self.smtp.starttls()
            else:
                self.smtp.starttls(**self.starttls)
            self.smtp.ehlo()
        self.is_closed = False
        if not self.smtp_skip_login:
            password = self.handle_password(self.user, password)
            self.smtp.login(self.user, password)
        self.log.info("Connected to SMTP @ %s:%s as %s", self.host, self.port, self.user)
1325004
def ask_password(*question: Token) -> str:
    
    tokens = get_ask_tokens(question)
    info(*tokens)
    answer = read_password()
    return answer
804607
def _read_response(self, response):
        
        # self.password = ''  # never returned
        self.name = response['name']
        self.email = response['email']
        self.admin = response['admin']
        self.profileUpdatable = response['profileUpdatable']
        self.internalPasswordDisabled = response['internalPasswordDisabled']
        self._groups = response['groups'] if 'groups' in response else []
        self._lastLoggedIn = response['lastLoggedIn'] if 'lastLoggedIn' in response else []
        self._realm = response['realm'] if 'realm' in response else []