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 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 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 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)
