def add_users(count) -> None: """Retrieve 10 users and generate passwords for each user Save the name, email and password in a sqlite database :return: None """ for _ in range(count): create_user('user_info.db') with sqlite3.connect('user_info.db') as connection: cursor = connection.cursor() cursor.execute("SELECT name FROM sqlite_master WHERE type='table'") table_name = cursor.fetchall()[0][0] try: cursor.execute("ALTER TABLE " + table_name + " ADD COLUMN password") except sqlite3.OperationalError: pass finally: for i in range(1, count + 1): cursor.execute( "UPDATE " + table_name + " SET password=? WHERE id=?", (generate_password(random.choice(range(6, 13)), random.choice(range(1, 5))), i))
def create_user(self, dbname, username, password=None): if not password: password = generate_password() with settings(warn_only=True): result = sudo('%s | %s' % (CREATE_USER_QUERY, MYSQL_RUN_COMMAND) % (username, password)) return False if result.failed else password
def create_user(self, username): """ Creates user with given name and grans them full permission on specified base """ password = generate_password() with settings(warn_only=True): result = sudo('psql -c "create user %s with password \'%s\'"' % (username, password), user=PGSQL_USER) return False if result.failed else password
def update_pending_key(self): state = self.get_property('user_state') if state.value == 'pending': # TODO Implement expiration return state.get_parameter('key') key = generate_password(30) self.set_value('user_state', 'pending', key=key) return key
def install(self): if self.is_db_installed(): print 'Database already installed' return password = generate_password() sudo('debconf-set-selections <<< "mysql-server-5.5 mysql-server/root_password password %s"' % password) sudo('debconf-set-selections <<< "mysql-server-5.5 mysql-server/root_password_again password %s"' % password) add_os_package(' '.join(['mysql-server'] + self.required_system_packages)) local('touch passwords') return password
def hello_world(): # вью функция, эндпоинт # views.py # return redirect('https://pythonworld.ru/') length = parse_length(request.args.get('length', '10')) if type(length) is str: return Response(length, status=400) response = Response(generate_password(length) + '\n') return response
def update_generated_password(self): method = ['sha1sum'] if self.radioShaSum.isChecked(): method = ['sha1sum'] elif self.radioMd5Sum.isChecked(): method = ['md5sum'] self.plainGeneratedPassword.setPlainText(generate_password(self.lineMasterPassword.text(), self.lineSalt.text(), method, self.spinPasswordLength.value()))
def save(self): if self.cleaned_data: # Creating User first_name = self.cleaned_data['name'] email = self.cleaned_data.get('email', None) password = generate_password() user = User.objects.create_user(first_name, email, password) person = Client() person.user = user person.cnpf = self.cleaned_data['cnpf'] person.save() return person
def new_poll(): """View function for new poll page.""" if utils.valid_session(session): # Looks like a normal user; we won't bother them. form = NewPollForm() else: # Check they're human. form = NewPollFormWithCaptcha() # No further logic necessary for GET requests. if request.method == "GET": return render_template("new_poll.html", form=form) # It's a POST: check the form if not form.validate_on_submit(): for error_field, errors in form.errors.items(): for error in errors: flash("{0}: {1}".format(error_field, error)) return render_template("new_poll.html", form=form) title = form.title.data question = form.question.data # Make sure we only pay attention to non-empty choice inputs. choices = [field.data for field in form.choices if field.data.strip() != ""] if len(choices) < 2: flash("You must offer at least two non-empty choices") return render_template("new_poll.html", form=form) email = form.email.data # Calculate poll closing time. closing_time = (datetime.now() + time_diffs[form.close_in.data] ).replace(second=0, microsecond=0) password = form.password.data if password == "": # User didn't enter a password, generate one. password = utils.generate_password() # We need to know whether to tell the user what their password is. random_password = True else: random_password = False early_results = form.early_results.data poll_id = db_funcs.add_poll(title, question, choices, int(closing_time.timestamp()), early_results, password, email) if random_password: # Redirect to a page telling them what their password is. return render_template("random_password.html", poll_id=poll_id, password=password) else: # Send the user to their new poll. return redirect(url_for("polls.get_poll", poll_id=poll_id))
def confirm_signup(proxy, vk, phone, activation_id): global count code = wait_code(activation_id) if code == "resign": signup(proxy) return password = generate_password() if code != ["STATUS_CANCEL"]: vk.auth.confirm(client_id=2274003, client_secret="hHbZxrka2uZ6jB1inYsH", phone=phone, code=code.split(":")[1], password=password) requests.get( url=f"https://smshub.org/stubs/handler_api.php?api_key={sms_token}&action=setStatus&status=6&id={activation_id}") count += 1 print(f"{count} аккаунт зареган") logging.info(f"{count} аккаунт зареган") print(f"{phone}:{password}") logging.info(f"{phone}:{password}") write_log(login=phone, password=password, proxy=proxy) for _ in range(15): try: vk = vk_auth(login=phone, password=password, proxy=proxy) break except (requests.exceptions.ProxyError, requests.exceptions.ConnectionError): print(f"Ошибка авторизации Bad proxy {proxy}") logging.error(f"Ошибка авторизации Bad proxy {proxy}") sleep(20) except vk_api.Captcha as captcha: captcha_solver(captcha) try: upload_photo(vk) except vk_api.Captcha as captcha: captcha_solver(captcha) try: subscribe(vk) except vk_api.Captcha as captcha: captcha_solver(captcha)
def set_register_key(self, username, unregister=False): cc_list = self.get_property('cc_list') status = 'U' if unregister is True else 'S' # Find existing key for cc in cc_list: key = cc.get_parameter('key') if (cc.value == username and cc.get_parameter('status') == status and key is not None): # Reuse found key return key # Generate key key = generate_password(30) # Filter out username cc_list = [ cc for cc in cc_list if cc.value != username ] # Create new dict to force metadata commit cc_list.append(MetadataProperty(username, status=status, key=key)) self.set_property('cc_list', cc_list) return key
def set_register_key(self, username, unregister=False): cc_list = self.get_property('cc_list') status = 'U' if unregister is True else 'S' # Find existing key for cc in cc_list: key = cc.get_parameter('key') if (cc.value == username and cc.get_parameter('status') == status and key is not None): # Reuse found key return key # Generate key key = generate_password(30) # Filter out username cc_list = [cc for cc in cc_list if cc.value != username] # Create new dict to force metadata commit cc_list.append(MetadataProperty(username, status=status, key=key)) self.set_property('cc_list', cc_list) return key
def gen_pass(): # length = 20 query_params = request.args # length: str = query_params.get('length', '') or '10' length = query_params.get('length') or '' default_password_length = 10 minimum_password_length = 10 maximum_password_length = 200 if length.isdigit(): length = int(length) if length > maximum_password_length or length < minimum_password_length: length = default_password_length else: length = default_password_length return generate_password(length)
def folder(folder_name): try: f = Folder.get(name=folder_name) except peewee.DoesNotExist: return jsonify(message='error'), 404 if request.method == 'POST': file = request.files['file'] if file: actual_filename = secure_filename( folder_name + '_' + file.filename) if os.path.exists(os.path.join(app.config['UPLOAD_FOLDER'], actual_filename)): return jsonify(message='error'), 409 file.save( os.path.join(app.config['UPLOAD_FOLDER'], actual_filename)) f2 = File.create(folder=folder_name, filename=file.filename, public_share_url=generate_url(), private_share_url=generate_url(), private_share_password=generate_password(), open_public_share=False, open_private_share=False) f2.save() return jsonify(message='OK'), 201 if request.method == 'GET': files = File.select().where(File.folder == folder_name) items = [{ 'filename': x.filename, 'public': x.public_share_url, 'private': x.private_share_url, 'password': x.private_share_password, 'openPublic': x.open_public_share, 'openPrivate': x.open_private_share } for x in files] return jsonify(message='OK', items=items) if request.method == 'DELETE': try: f.delete_instance() except peewee.IntegrityError: return jsonify(message='error'), 409 return jsonify(message='OK')
def register_account(self, server): reactor.callLater(10, self._failed, "timeout") username = utils.generate_username() self._jid = "%s@%s" % (username, server) self._password = utils.generate_password() jid_obj = jid.JID(self._jid) if self._verbose: print "Connecting to", jid_obj.host a = RegisterAuthenticator(jid_obj, self._password) factory = xmlstream.XmlStreamFactory(a) factory.maxRetries = 0 factory.clientConnectionFailed = self._failed factory.addBootstrap(STREAM_CONNECTED_EVENT, self._connected) factory.addBootstrap(xmlstream.INIT_FAILED_EVENT, self._failed) factory.addBootstrap(RegisterInitializer.REGISTER_SUCCEEDED_EVENT, self._registered) factory.addBootstrap(RegisterInitializer.REGISTER_FAILED_EVENT, self._failed) reactor.connectTCP(jid_obj.host, 5222, factory, timeout=4) return self._deferred
def __init__(self, employee): """ Initialise employee class. :param employee: dictionary having basic employee details """ self.first_name = employee['firstName'] self.last_name = employee['lastName'] self.email = employee['email'] self.dob = employee['dob'] if 'photo' in employee: self.image = employee['photo'] else: self.image = 'NULL' self.prefix = employee['prefix'] self.employment = employee['employment'] self.employer = employee['employer'] self.marital_status = employee['maritalStatus'] self.prefer_commun = employee['communication'] self.password = generate_password()
def subscribe_user(self, email=None, user=None): root = self.get_resource('/') # Get the user if user is None: if email is None: raise ValueError, "email or user are mandatory" user = root.get_user_from_login(email) # Create it if needed if user is None: user = root.make_user(email, password=None) # Mark it as new key = generate_password(30) user.set_property('user_state', 'pending', key=key) # Add to subscribers list self.reset_register_key(user.name) return user
def new(request): if not auth.in_groups(request): logout(request) return HttpResponseRedirect( '/accounts/login/' ) if request.method == "POST": form = TempUserForm(data=request.POST) if form.is_valid(): duration = datetime.timedelta(days=form.cleaned_data['duration']) expires = datetime.datetime.now() + duration log = TempUserLog.objects.create( description=form.cleaned_data['description'], expires=expires, issued_by=request.user, count=form.cleaned_data['count']) for i in range(form.cleaned_data['count']): username = utils.generate_username() raw_password = utils.generate_password() # Store in Radius rc = Radcheck.objects.create( username=username, attribute='NT-Password', op=':=', value=utils.ntpass_hash(raw_password)) # store raw_password UserPass.objects.create( username=username, password=raw_password, radcheck_id=rc.id, log=log) messages.success(request, log.id) # Store the id in session, since we are redirecting messages.success(request, 'Successfully created user(s) in radius database.') return HttpResponseRedirect( reverse('main.views.new_created') ) else: form = TempUserForm(request.POST) return render_to_response('private/new.html', locals(), context_instance=RequestContext(request)) form = TempUserForm() return render_to_response('private/new.html', locals(), context_instance=RequestContext(request))
def test_functions() -> None: """test the generate_password and check_password_level functions to print success or fail. :return: None """ password_level1 = generate_password(5, 1) password_level2 = generate_password(5, 2) password_level3 = generate_password(5, 3) password_level4 = generate_password(5, 4) exception_level1 = generate_password(9, 1) exception_level2 = generate_password(9, 2) try: assert check_password_level(password_level1) == 1 assert check_password_level(password_level2) == 2 assert check_password_level(password_level3) == 3 assert check_password_level(password_level4) == 4 assert check_password_level(exception_level1) == 2 assert check_password_level(exception_level2) == 3 print('success') except AssertionError: print('fail')
def create_dummy_user(self): username = generate_password() password = generate_password() self.insert_dummy_user_in_db(username, password) print_credentials_on_terminal(username, password) create_dummy_user_file(username, password)
def save_formset(self, request, form, formset, change): instances = formset.save() for instance in instances: if not instance.token: instance.token = utils.generate_password(32) instance.save()
def create_new(cls, realm): return cls.create( realm=realm, rpc_password=generate_password(16), )
def get_random(length, specials, digits): return generate_password(length, specials, digits)
from werkzeug.security import check_password_hash, generate_password_hash from werkzeug.utils import secure_filename from utils import create_self_signed_cert, generate_password, get_local_ip, get_global_ip, upnp_add_port_mapping temp_dir = Path(__file__).with_name("temp") temp_dir.mkdir(exist_ok=True) secret_key_file = temp_dir / "app_secret_key" secret_key_file.touch() app = Flask(__name__, static_url_path='/assets', static_folder='assets') app.secret_key = secret_key_file.read_text() if len(app.secret_key) == 0: secret_key_file.write_text(generate_password(10)) root = Path("/tmp") users = {} auth = HTTPBasicAuth() ignored = [ '.bzr', '$RECYCLE.BIN', '.DAV', '.DS_Store', '.git', '.hg', '.htaccess', '.htpasswd', '.Spotlight-V100', '.svn', '__MACOSX', 'ehthumbs.db', 'robots.txt', 'Thumbs.db', 'thumbs.tps' ] datatypes = { 'audio': 'm4a,mp3,oga,ogg,webma,wav', 'archive': '7z,zip,rar,gz,tar', 'image': 'gif,ico,jpe,jpeg,jpg,png,svg,webp', 'pdf': 'pdf',
def get_random(args): return generate_password(args)