def reset_password(login_name): con, c = dbconnect.connect() if validate_email(login_name): query = " SELECT * FROM user WHERE user_email = %s " else: query = " SELECT * FROM user WHERE user_name = %s " con, c = dbconnect.connect() c.execute(query, (login_name,)) row = c.fetchall() if len(row) == 0: dbconnect.close(con, c) else: row = row[0] new_password = random_password() new_pass_hash = generate_password_hash(new_password) uid = row[0] email = row[1] username = row[2] query = " UPDATE user SET user.pass_hash = %s WHERE user.user_id = %s " c.execute(query, (new_pass_hash, uid)) con.commit() dbconnect.close(con, c) html_msg = render_template("resetpassword.html", username=username, new_password=new_password) from run import send_mail send_mail("Walk With Me New Password", [email], html_msg) return jsonify({"Status": 1, "Message": "New password has been sent to your email address if the account exist."})
def password(self, plaintext): """ Sets the user's password, converting the plain text argument to a hashed password. :param plaintext: the plain text being entered by the user, to be hased " """ self._password = generate_password_hash(plaintext)
def create_user(cls, email, password): try: cls.create( email=email, password=generate_password_hash(password) ) except: print "exception error"
def create_user(cls, username,email, password, admin=False): try: cls.create( username=username, email = email, password = generate_password_hash(password), is_admin=admin) except IntegrityError: raise ValueError('User already exists')
def create_user(cls, username, email, password): try: with db.transaction(): cls.create( username=username, email=email, password=generate_password_hash(password) ) except IntegrityError: raise ValueError("User already exists")
def set_password(self, plaintext, rounds=12): """Sets the password for the user. The password hash is created with the Bcrypt python library (http://www.mindrot.org/projects/py-bcrypt/). Args: plaintext: The plaintext password to hash rounds: Number of rounds to use for the bcrypt hashing """ password_hash = generate_password_hash(plaintext, rounds) self.password = unicode(password_hash)
def create_user(cls,name, email,password): try: cls.create( name=name, email=email, password=generate_password_hash(password) ) except IntegrityError: raise ValueError('user already exists')
def create_user(cls, username, email, password, admin=False): try: with DATABASE.transaction(): cls.create( username=username, email=email, password=generate_password_hash(password), is_admin=admin) except IntegrityError: raise ValueError("User already exists")
def add(cls, email, first_name, last_name, password): try: with DB.transaction(): cls.create( email=email, first_name=first_name, last_name=last_name, password=generate_password_hash(password) ) except IntegrityError: raise ValueError("User with that email already exists")
def set_password(self, plaintext, rounds=12): """Sets the password for the user. The password hash is created with the Bcrypt python library (http://www.mindrot.org/projects/py-bcrypt/). Args: plaintext: The plaintext password to hash rounds: Number of rounds to use for the bcrypt hashing """ password_hash = generate_password_hash(plaintext, rounds) if isinstance(password_hash, six.binary_type): password_hash = codecs.decode(password_hash, 'utf-8') self.password = password_hash
def save(self): if self.username and self.password: password = generate_password_hash(self.password).decode('utf-8') db = get_db() cursor = db.cursor() cursor.execute( 'INSERT INTO users (username, password) VALUES (%s, %s)', (self.username, password) ) db.commit()
def change_password(uid, new_password): if not is_strong_password(new_password): return jsonify({"Status": 0, "Message": "Your password is to weak, please try again."}) new_pass_hash = generate_password_hash(new_password) con, c = dbconnect.connect() query = " UPDATE user SET user.pass_hash = %s WHERE user.user_id = %s " c.execute(query, (new_pass_hash, uid)) con.commit() dbconnect.close(con, c) return jsonify({"Status": 1, "Message": "Password changed successfully, please login again."})
def test_hashed_password_is_not_plaintext(self): """ Check that the password is not plain text when we try to, for example, reset it. Check other aspects of changing User object's password """ user = User("xXx_Supa_Saiyan_xXx", "password1", "*****@*****.**", False, False) user.password = "******" self.assertNotEqual(user.password, "password1", "password not reset, password is plain text") self.assertNotEqual(user.password, generate_password_hash("password1"), "password not reset") self.assertNotEqual(user.password, "dogsname", "password is plain text") self.assertTrue(user.check_password("dogsname"), "password not changed successfully")
def test_check_hash(self): pw_hash = self.bcrypt.generate_password_hash('secret') # check a correct password self.assertTrue(self.bcrypt.check_password_hash(pw_hash, 'secret')) # check an incorrect password self.assertFalse(self.bcrypt.check_password_hash(pw_hash, 'hunter2')) # check unicode pw_hash = self.bcrypt.generate_password_hash(u'\u2603') self.assertTrue(self.bcrypt.check_password_hash(pw_hash, u'\u2603')) # check helpers pw_hash = generate_password_hash('hunter2') self.assertTrue(check_password_hash(pw_hash, 'hunter2'))
def reset_password(username): import random import string from app.models.Mailgun_Internal import mailgun_send_message str_length = 10 password = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(str_length)) user = User.query.filter_by(username=username).first() if user is None: return False else: user.password = generate_password_hash(password).decode('utf8') mailgun_send_message(None, username, "Password Reset", password, "PW_Reset") db.session.commit() return True
def signup(): if request.method == 'GET': return render_template('signin.html') username = request.form['username'] password = request.form['password'] confirm = request.form['confirm-password'] if confirm != password: resp = jsonify({'status': 412, 'message': 'Las contraseñas ingresadas no coinciden'}) resp.status_code = 412 return resp password_hash = generate_password_hash(password, BCrypt_iterations) new_user = User.User(username, password_hash, 'reviewer') session.add(new_user) try: session.commit() login_user(new_user) return redirect(url_for('mapa')) # return jsonify({'status': 200, 'message': 'OK'}) except Exception as e: return jsonify({'status': 500, 'message': 'El usuario no se puedo añadir'})
def CreateEmployer(): name = request.form['username'] employer = models.Employers( fname = request.form['first_name'], mname = request.form['middle_name'], lname = request.form['last_name'], street1 = request.form['street1'], street2 = request.form['street2'], city = request.form['city'], state = request.form['state'], zipcode = request.form['zipcode'], email = request.form['email'], username = request.form['username'], bestmethod = request.form['demo-priority'], _password = generate_password_hash(request.form['password'],12), phone = request.form['phone'] ) db.session.add(employer) db.session.commit() session['username'] = request.form['username'] user_name = escape(session['username']) return render_template('LandingPage.html',name=user_name)
def register(): error = None form = RegisterForm(request.form) if request.method == 'POST': if form.validate_on_submit(): new_user = User( form.email.data, bcrypt.generate_password_hash(form.password.data), confirmed=False, ) try: db.session.add(new_user) db.session.commit() except IntegrityError: error = 'כתובת הדוא"ל הזו כבר קיימת באתר.' return render_template('register.html', form=form, error=error) token = generate_confirmation_token(new_user.email) confirm_url = url_for('notifier.confirmed_email',token=token,_external=True) session['logged_in'] = True session['user_id'] = new_user.id session['user_email'] = new_user.email client = sendgrid.SendGridClient(SENDGRID_KEY) conf_mail = sendgrid.Mail() conf_mail.add_to(new_user.email) conf_mail.set_from(NOTIFIER_MAIL_ADDRESS) conf_mail.set_subject(MAIL_SUBJECT) conf_mail.set_html(render_template('user/activate.html',confirm_url=confirm_url)) client.send(conf_mail) flash(u'תודה שנרשמת. כעת ניתן להתחבר לאתר') return redirect(url_for('notifier.feeds_editor')) else: print(form.errors) return render_template("register.html", form=form, error=error)
def activate_user(user_id, data): log("User is activated", "HIGH", "PASS") val_num(user_id) val_num(data.get('accessToken')) val_alpha_num(data.get('username')) username = data.get('username') username = username.replace(" ", "") result = users.query.filter(users.userID == user_id).one() if result.activated == "False": if result.email == data.get('email'): if data.get('password') == data.get('repassword'): if data.get('accessToken') == result.accessToken: pw_hash = generate_password_hash(data.get('password')).decode('utf-8') result.password = pw_hash result.access = "True" result.activated = "True" result.userName = username db.session.add(result) db.session.commit() return {'message': 'User successfully activated'} else: log("User triggered error activation failed", "HIGH", "FAIL") return {'message': 'User could not be activated'}
def register(): """ Create a new user. Check if name exists first. :return: """ if request.method == 'POST': cur = g.db.execute('SELECT name FROM users WHERE name = ?', [request.form['name']]) if cur.fetchone() is None and request.form['name'] is not None and request.form['password'] is not None: cur = g.db.execute('INSERT INTO users (name, password) VALUES (?, ?)', [request.form['name'], generate_password_hash(request.form['password'])]) g.db.commit() result = cur.lastrowid if result > 0: session['logged_in'] = True session['user_name'] = request.form['name'] return redirect(url_for('home.home')) else: error = 'Something went wrong' return render_template('login.html', error=error) else: return render_template('login.html', error="That name is taken") else: return render_template('login.html')
def register(value): email = value["email"] username = value["username"] password = value["password"] age = int(value["age"]) gender = value["gender"] if validate_email(email, check_mx=MX_VERIFY, verify=FULL_VERIFY) == False: # Only checking domain has SMTP Server return jsonify({"Status": 0, "Message": "Please enter a valid email address."}) if not is_safe_username(username): return jsonify({"Status": 0, "Message": "Please enter a valid username."}) if not is_strong_password(password): return jsonify({"Status": 0, "Message": "Your password is to weak, please try again."}) con, c = dbconnect.connect() query = " SELECT user_id FROM user WHERE user_email = %s " if c.execute(query, (email,)) != 0: dbconnect.close(con, c) return jsonify({"Status": 0, "Message": "Email address has already been taken."}) query = " SELECT user_id FROM user WHERE user_name = %s " if c.execute(query, (username,)) != 0: dbconnect.close(con, c) return jsonify({"Status": 0, "Message": "Username has already been taken."}) pass_hash = generate_password_hash(password) query = " INSERT INTO user(user_email,user_name,pass_hash,age,gender) VALUES (%s,%s,%s,%s,%s);" c.execute(query, (email, username, pass_hash, age, gender)) con.commit() dbconnect.close(con, c) html_msg = render_template("welcome.html", username=username) from run import send_mail send_mail("Welcome to Walk With Me", [email], html_msg) return jsonify({"Status": 1, "Message": "Registration successful! Please login."})
def register(): if g.user is not None and g.user.is_authenticated: return redirect(url_for('index')) error = None if request.method == 'POST': if not request.form['username']: error = 'You have to enter a username' elif not request.form['email'] or \ '@' not in request.form['email']: error = 'You have to enter a valid email address' elif not request.form['password']: error = 'You have to enter a password' elif request.form['password'] != request.form['password2']: error = 'The two passwords do not match' elif User.query.filter_by(username = request.form['username']).first() is not None: error = 'The username is already taken' else: user = User(request.form['username'], request.form['email'], generate_password_hash(request.form['password'])) db.session.add(user) db.session.commit() flash('You were successfully registered and can login now') return redirect(url_for('login')) return render_template('register.html', error=error)
def evaluate_password(self, key, value): return generate_password_hash(value)
import datetime
def hashpw(password): return generate_password_hash(password, 10).decode('utf-8')
def _set_password(self, plaintext): self._password = generate_password_hash(plaintext, 12) if PY3: self._password = str(self._password, 'utf-8')
def _set_password(self, plaintext): self._password = generate_password_hash(plaintext)
def generate_pw_hash(self): self.password = generate_password_hash(password=self.password).decode('utf-8')
def test_unicode_hash(self): password = u'東京' h = generate_password_hash(password).decode('utf-8') self.assertTrue(check_password_hash(h, password))
def hash_password(password): return generate_password_hash(password)
def __init__(self, username, password): self.password = generate_password_hash(password) self.username = username
def save_new_password(self, new_password): self.password = generate_password_hash(new_password) self.is_active = True
class User(UserMixin, db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), index=True) email = db.Column(db.String(64), unique=True, index=True) password = db.Column( db.String(128), default=generate_password_hash('snsflaskapp') ) picture_path = db.Column(db.Text) # 有効か無効かのフラグ is_active = db.Column(db.Boolean, unique=False, default=False) create_at = db.Column(db.DateTime, default=datetime.now) update_at = db.Column(db.DateTime, default=datetime.now) def __init__(self, username, email): self.username = username self.email = email @classmethod def select_user_by_email(cls, email): return cls.query.filter_by(email=email).first() def validate_password(self, password): return check_password_hash(self.password, password) def create_new_user(self): db.session.add(self) @classmethod def select_user_by_id(cls, id): return cls.query.get(id) def save_new_password(self, new_password): self.password = generate_password_hash(new_password) self.is_active = True # UserConnectと紐づけます outer join @classmethod def search_by_name(cls, username, page=1): user_connect1 = aliased(UserConnect) # from_user_id: 検索相手のID、to_user_id: ログインユーザのIDでUserConnectに紐づける user_connect2 = aliased(UserConnect) # to_user_id: 検索相手のID、from_user_id: ログインユーザのIDでUserConnectに紐づける return cls.query.filter( cls.username.like(f'%{username}%'), cls.id != int(current_user.get_id()), cls.is_active == True ).outerjoin( user_connect1, and_( user_connect1.from_user_id == cls.id, user_connect1.to_user_id == current_user.get_id() ) ).outerjoin( user_connect2, and_( user_connect2.from_user_id == current_user.get_id(), user_connect2.to_user_id == cls.id ) ).with_entities( cls.id, cls.username, cls.picture_path, user_connect1.status.label("joined_status_to_from"), user_connect2.status.label("joined_status_from_to") ).order_by(cls.username).paginate(page, 50, False) @classmethod def select_friends(cls): return cls.query.join( UserConnect, or_( and_( UserConnect.to_user_id == cls.id, UserConnect.from_user_id == current_user.get_id(), UserConnect.status == 2 ), and_( UserConnect.from_user_id == cls.id, UserConnect.to_user_id == current_user.get_id(), UserConnect.status == 2 ) ) ).with_entities( cls.id, cls.username, cls.picture_path ).all() @classmethod def select_requested_friends(cls): return cls.query.join( UserConnect, and_( UserConnect.from_user_id == cls.id, UserConnect.to_user_id == current_user.get_id(), UserConnect.status == 1 ) ).with_entities( cls.id, cls.username, cls.picture_path ).all() @classmethod def select_requesting_friends(cls): return cls.query.join( UserConnect, and_( UserConnect.from_user_id == current_user.get_id(), UserConnect.to_user_id == cls.id, UserConnect.status == 1 ) ).with_entities( cls.id, cls.username, cls.picture_path ).all()
# benchmark.py from flask_bcrypt import generate_password_hash # Change the number of rounds (second argument) until it takes between # 0.25 and 0.5 seconds to run. generate_password_hash('password1', 12)
def set_password(self, password): self.password = generate_password_hash(password)
from airflow import models, settings from airflow.contrib.auth.backends.password_auth import PasswordUser from airflow.models import Variable from flask_bcrypt import generate_password_hash # Get password from variables password = Variable.get("user_password") user = PasswordUser(models.User()) user.username = '******' user.email = '*****@*****.**' user._password = generate_password_hash(password, 12) session = settings.Session() session.add(user) session.commit() session.close() exit()
def call(self): self.user.password = generate_password_hash(self.new_password).decode('utf-8') db.session.commit() return self.user.password
def new_user(cls, username, password, created): cls.create( username=username, password=generate_password_hash(password), created=created, )
print("") PY3 = version_info[0] == 3 args = sys.argv[1:] REQUIRED_NUM_OF_ARGS = 1 def print_usage_str(): print("""Usage: python airflow-gen-pwd-hash-from-local.py {plain_text_password}""") print("Argument List: " + str(str(args))) print("Argument Length: " + str(len(args))) if len(args) != REQUIRED_NUM_OF_ARGS: print("Invalid number of Argument. Requires " + str(REQUIRED_NUM_OF_ARGS) + " number of Argument(s). " + str(len(args)) + " provided.") print_usage_str() exit(1) pwd_plain_text = str(args[0]).strip() print("Password Plain Text: " + str(pwd_plain_text)) pwd_hash = generate_password_hash(pwd_plain_text, 12) if PY3: pwd_hash = str(pwd_hash, 'utf-8') print("") print("Password Hash: " + str(pwd_hash))
def password(self, user_pass): self.user_pass = generate_password_hash(user_pass)
def set_password(self, plain): self.password = generate_password_hash(plain, BCRYPT_LOG_ROUNDS)
def password(self, password): self.password_hash = generate_password_hash(password)
def add_user(self, email, passwd): passwd_hash = generate_password_hash(passwd).decode() query = "INSERT INTO users (email, passwd) VALUES (?, ?)" self.cur.execute(query, (email, passwd_hash)) self.con.commit()
def hash_password(self): pwd_hash = flask_bcrypt.generate_password_hash(self.password) self.password = pwd_hash.decode('utf8')
def create_objects(): session = Session() user = User(username='******', firstName='admin', lastName='admin', email='*****@*****.**', phone='+38099', userAuthStatus=UserStatus.notSignedIn, password=generate_password_hash('admin')) user2 = User(username='******', firstName='admin', lastName='admin', email='*****@*****.**', phone='+380990', userAuthStatus=UserStatus.notSignedIn, password=generate_password_hash('admin')) user3 = User(username='******', firstName='admin', lastName='admin', email='*****@*****.**', phone='+380940', userAuthStatus=UserStatus.notSignedIn, password=generate_password_hash('admin')) wallet13 = Wallet( name='MyFirstWallet', balance=10000, currency=Currency.USD, owner=user3, ) wallet23 = Wallet( name='MySecondWallet', balance=100, currency=Currency.UAH, owner=user3, ) wallet1 = Wallet( name='MyWallet', balance=10000, currency=Currency.USD, owner=user, ) wallet2 = Wallet( name='MySecoWallet', balance=100, currency=Currency.UAH, owner=user, ) session.add(user) session.add(user2) session.add(wallet1) session.add(wallet2) session.add(user3) session.add(wallet13) session.add(wallet23) session.commit()
def post(self): user = _user_parser.parse_args() user["password"] = generate_password_hash(user["password"], 12) new_user = UserModel().create(user) return str(new_user['_id'])
def __init__(self, **kwargs): self.username = kwargs.get('username') self.email = kwargs.get('email') self.password = generate_password_hash(kwargs.get('password'), 10).decode()
def set_password(self, password): self.password = generate_password_hash(password).decode('UTF-8')
def send_mail(recipient, subject, body): msg = MIMEMultipart() msg['From'] = app.config['EMAIL_SENDER'] msg['To'] = recipient msg['Subject'] = subject message = body msg.attach(MIMEText(message)) mailserver = smtplib.SMTP(app.config['SMTP_URL'], app.config['SMTP_PORT']) mailserver.ehlo() mailserver.starttls() mailserver.ehlo() mailserver.login(app.config['SMTP_USER'], app.config['SMTP_USER']) mailserver.sendmail(app.config['EMAIL_SENDER'], recipient, msg.as_string()) mailserver.quit() from api import routes if app.config['DEBUG']: from api import models with models.pony.orm.db_session: admin = models.User.get(email='*****@*****.**') if admin is None: print(generate_password_hash('admin').decode("utf-8")) admin = models.User( email='*****@*****.**', password=generate_password_hash('admin').decode("utf-8"), active=True, admin=True) models.pony.orm.commit()
def password(self, plaintext): """Sets password for the user""" self._password = generate_password_hash(plaintext, 12) if PY3: self._password = str(self._password, 'utf-8')
def set_password(self, password): """Set the user password.""" self.password_hash = generate_password_hash(password).decode("utf-8")
def password(self, password): self.password_hash = flask_bcrypt.generate_password_hash( password).decode('utf-8')
def hash_password(self): self.password = generate_password_hash(self.password).decode('utf8')
def __init__(self, nickname, email, password, verified): self.nickname = nickname self.email = email self.password = generate_password_hash(password) self.verified = verified
def _set_password(self, plaintext): self._password = generate_password_hash(plaintext, BCRYPT_LOG_ROUNDS)
def __init__(self, email, username, password): self.email = email self.username = username self.password = generate_password_hash(password)
def hash_password(password): return generate_password_hash(password).decode('utf8')
def __init__(self, username, email, password, is_admin=False): self.username = username self.email = email self.password = generate_password_hash(password) self.is_admin = is_admin