def get_context_data(self, **kwargs): context = super(ReportSQSJobs, self).get_context_data(**kwargs) form = self.get_form_class()(self.request.GET) if form.is_bound: if form.is_valid(): date = form.cleaned_data.get('date') if not os.path.exists(get_report_fname(date)): context['error_msg'] = ("Report does not exist. Now it's already being generated." "Please wait a few minutes and try again.") run_report_generation(date) return context with open(get_report_fname(date), 'r') as fh: reports = json.loads(fh.read()) context['by_server'] = sorted([(server, data) for server, data in dicts_to_ordered_lists(reports['by_server']).items()]) context['by_spider'] = sorted([(spider, data) for spider, data in dicts_to_ordered_lists(reports['by_spider']).items()]) # generate CSV files csv_by_server = report_to_csv(["server", "spider", "num of jobs"], context['by_server']) csv_by_site = report_to_csv(["spider", "server", "num of jobs"], context['by_spider']) site = Site.objects.get_current() context['csv_by_server'] = 'http://' + site.domain + str(reverse_lazy( 'report-get-csv', kwargs={'encrypted_filename': encrypt(csv_by_server)} )) context['csv_by_site'] = 'http://' + site.domain + str(reverse_lazy( 'report-get-csv', kwargs={'encrypted_filename': encrypt(csv_by_site)} )) return context
def open_file(self): file = fd.askopenfilename(title="Open text file", initialdir=self.cwd, filetypes=self.filetypes) prefix = os.path.basename(file)[0:3] if file: try: if prefix == "ENC": enc_filename = file file = utils.change_prefix_and_decrypt(file, Login.KEY) file_screen = tk.Toplevel(self) file_screen.geometry('300x400+{}+{}'.format( self.position_right, self.position_down)) file_screen.resizable(0, 0) text = ScrolledText(file_screen, wrap="word", height=30, width=30) with open(file, 'r', encoding="iso-8859-2") as f: text.insert(tk.END, f.read()) text.pack() if prefix == "ENC": utils.encrypt(file, Login.KEY) os.rename(file, enc_filename) ttk.Button(file_screen, text="STOP", command=file_screen.destroy).pack() except Exception: utils.not_authorized_message()
def login(self, username, password): """使用 用户名+密码 登录""" captchaToken, returnUrl, paramId = self._redirect() validateCode = self._needcaptcha(captchaToken, username) url = self._auth_url + "loginSubmit.do" data = { "appKey": "cloud", "accountType": '01', "userName": "******" + b64tohex(encrypt(username)), "password": "******" + b64tohex(encrypt(password)), "validateCode": validateCode, "captchaToken": captchaToken, "returnUrl": returnUrl, "mailSuffix": "@189.cn", "paramId": paramId } r = self._post(url, data=data) msg = r.json()["msg"] if msg == "登录成功": self._get(r.json()["toUrl"]) code, token = self.get_token(username, password) if code == Cloud189.SUCCESS: self.set_session(*token) return Cloud189.SUCCESS print(msg) self.login(username, password) return Cloud189.FAILED
def write(self): """Pick data from write queue and send it to C2 server.""" self.logger.info("Started write thread!") logging.getLogger().addHandler(self.queue_handler) while self.active.is_set(): if not self.writeque.empty(): data = self.writeque.get() try: if isinstance(data.get("result"), Exception): data["result"] = str(data.get("result")) data = json.dumps(data, cls=MessageEncoder).encode() if self.key and self.key_change.is_set(): # encrypt assign response with original key if C2_ENCRYPTION_KEY: data = encrypt(data, C2_ENCRYPTION_KEY) self.key_change.clear() elif self.key: data = encrypt(data, self.key) data = struct.pack('!L', len(data)) + data except Exception as e: self.logger.warning( "Failed to serialize dict: {}".format(e)) continue self.s.sendall(data) # self.logger.debug("Sent data to {}: {}".format(self.s.getpeername(), data)) time.sleep(0.5) logging.getLogger().removeHandler(self.queue_handler) self.logger.info("Stopped write thread!")
def updateDataStore(): with open(f'./dataStore/{websiteName}', 'a+') as file: file.write(utils.encrypt(encryptionKey, username)) file.write('\n') encryptionText = utils.encrypt(encryptionKey, password) file.writelines(encryptionText) file.write("\n") print(f'Encrypted Password : {encryptionText}')
def handle_uploaded_file(f,fileMap): id = '%s' % fileMap.id suffix = fileMap.linkSuffix internal_file_name = location % suffix password = '******' if not fileMap.password_protected else fileMap.password.encode('ascii','ignore') destination = open(internal_file_name, 'wb+') encrypt(f,destination,password) return suffix
def saveSettings(self): settings.BAIDU_APPID = self.baiduAppidInput.text() settings.BAIDU_SECRET = self.baiduSecretInput.text() self.newSettings['BaiduAppid'] = encrypt(settings.BAIDU_APPID) self.newSettings['BaiduSecret'] = encrypt(settings.BAIDU_SECRET) for key in list(DEFAULT_SETTINGS.keys()): settings[key] = self.newSettings[key] settings.writeSettings() self.close()
def handle_uploaded_file(f, fileMap): id = '%s' % fileMap.id suffix = fileMap.linkSuffix internal_file_name = location % suffix password = '******' if not fileMap.password_protected else fileMap.password.encode( 'ascii', 'ignore') destination = open(internal_file_name, 'wb+') encrypt(f, destination, password) return suffix
def run(self): self._logger.info('mysqldump run') # clean self.watch() # save filepath self.dump() # encrypt if self.__use_encrypt(): self._logger.info('use encrypt') encrypt(self.__filepath(), self.__filepath_encrypt(), self._config.encrypt_pass, self._config.compress_level) return self.__filepath_encrypt() return self.__filepath()
def update_github_secrets(keys, token, org): click.echo("Now updating all repositories with new keys...") s = requests.Session() s.headers = {"Authorization": f"token {token}", "User-Agent": "Requests"} url_base = f"https://api.github.com/repos/{org.login}" results = {} for repo_name, (access_key_id, secret_access_key) in keys.items(): ci_keys = s.get(f"{url_base}/{repo_name}/actions/secrets/public-key") if ci_keys.status_code != requests.codes.ok: results[repo_name] = ci_keys.status_code continue ci_keys = ci_keys.json() access_key_id = encrypt(ci_keys["key"], access_key_id) secret_access_key = encrypt(ci_keys["key"], secret_access_key) encrypted_token = encrypt(ci_keys["key"], token) r = s.put( f"{url_base}/{repo_name}/actions/secrets/AWS_ACCESS_KEY_ID", json={ "encrypted_value": access_key_id, "key_id": ci_keys["key_id"] }, ) r = s.put( f"{url_base}/{repo_name}/actions/secrets/AWS_SECRET_ACCESS_KEY", json={ "encrypted_value": secret_access_key, "key_id": ci_keys["key_id"] }, ) r = s.put( f"{url_base}/{repo_name}/actions/secrets/API_TOKEN_GITHUB", json={ "encrypted_value": encrypted_token, "key_id": ci_keys["key_id"] }, ) results[repo_name] = r.status_code return results
def post(self): user = self.current_user password = self.get_argument("pwd", "") new_pwd = self.get_argument("new_pwd", "") if user.get_password() != encrypt(password): self.render("account/pwd.html", error=141) return if new_pwd == "": self.render("account/pwd.html", error=142) return result = user.update_password(encrypt(new_pwd)) if result: self.render("account/pwd.html", error=143) return self.render("account/pwd.html", error=140)
def encrypt(): return json.dumps({ 'response': utils.encrypt(request.args.get('message'), int(request.args.get('n'), 16), int(request.args.get('e'), 16)).hex() })
def new_transaction(): tx_data = request.get_json() required_fields = ["pub_key", "vote"] for field in required_fields: if not tx_data.get(field): return "Invalid transaction data", 404 if "timestamp" not in tx_data: tx_data["timestamp"] = time.time() if "sign" not in tx_data: tx_data["sign"] = utils.sign_transaction(tx_data["pub_key"], tx_data["vote"]) verified = utils.verify_transaction(tx_data) if not verified: return "Invalid transaction", 404 # If the transaction is present in the local pool, return the transaction id txn = { "pub_key": tx_data["pub_key"], "vote": tx_data["vote"], "timestamp": tx_data["timestamp"], "sign": tx_data["sign"] } encrypted = utils.encrypt(txn) if (encrypted in blockchain.encrypted_transactions): return blockchain.encrypted_transactions[encrypted], 201 if "transaction_id" not in tx_data: transaction_id = blockchain.add_new_transaction(tx_data) tx_data["transaction_id"] = transaction_id else: transaction = { "pub_key": tx_data["pub_key"], "vote": tx_data["vote"], "timestamp": tx_data["timestamp"], "sign": tx_data["sign"] } transaction_id = tx_data["transaction_id"] blockchain.transactions[transaction_id] = transaction blockchain.encrypted_transactions[encrypted] = transaction_id data = {"transaction_id": transaction_id} headers = {'Content-Type': "application/json"} responses = [] for peer in blockchain.peers: resp = requests.post(peer + '/receive_adv_txn', data=json.dumps(data), headers=headers).json() responses.append(resp) for response in responses: if (response["requested"]): requests.post(response["peer"] + '/new_transaction', data=json.dumps(tx_data), headers=headers) return str(transaction_id), 201
def Register(): if not isValidEmail(request.form['email']): return jsonify({'error': 'E-mail inválido'}), 400 if len(request.form['password']) < PASSWORD_MIN_LENGTH: return jsonify({'error': 'Senha muito curta'}), 400 if len(request.form['password']) > PASSWORD_MAX_LENGTH: return jsonify({'error': 'Senha muito longa'}), 400 exists = User.query.filter_by(email=request.form['email']).first() if exists: return jsonify({'error': 'Email já registrado'}), 400 name = request.form['name'] if not len(name): return jsonify({'error': 'É necessário informar um nome'}), 400 exists = User.query.filter_by(name=request.form['name']).first() if exists: return jsonify({'error': 'Nome já registrado'}), 400 user = User(email=request.form['email'], password=encrypt(request.form['password']), name=name, role_id=2, regDate=time.time(), coins=50) db.session.add(user) db.session.commit() team = Team(name='Time de ' + name, user_id=user.id) db.session.add(team) db.session.commit() return jsonify(user.toJSON()), 201
def post(self): username = self.get_argument('username', '') password = self.get_argument('password', '') self.set_header("Content-Type", "application/json") if not (username and password): ret = { 'error': 110, 'msg': self.error_message['110'], 'url': '/admin/index' } return self.write(json_encode(ret)) user = User.get_by_username(username) if not user: ret = {'error': 121, 'msg': self.error_message['121']} return self.write(json_encode(ret)) if user.get_password() != encrypt(password): ret = {'error': 122, 'msg': self.error_message['122']} return self.write(json_encode(ret)) self.set_secure_cookie("admin_user_id", str(user.user_id), expires_days=7) ret = {'error': 0, 'msg': '登录成功', 'url': '/admin/index'} return self.write(json_encode(ret))
def validate_login(cls, form): users = cls.all() for u in users: if u.username == form.get("username") and u.password == encrypt( form.get("password")): return u return None
def get(self, **kwargs): admin = False user = self.current_user page_id = kwargs.get('pageid') options_dict = {} try: pages = Page.get(user.pages) for p in pages: if p.id == page_id: admin = True page = p widgets = Widget.all().filter('page =', page).filter('deleted = ', False).order('order') options = Option.all().filter('type_reference =', page) for option in options: options_dict[option.name] = {'id': str(option.key().id()), 'value': option.value} except: page = None widgets = None options_dict = None if admin: #page = Page.get_by_key_name(str(page_id)) #add_app_url = 'https://www.facebook.com/add.php?api_key=a284fdd504b5191923362afabc0ea6c7&pages=1&page=141947329155355' upload_url = blobstore.create_upload_url('/upload') page_id = encrypt(page_id).encode('hex') self.render("app/edit.html", admin=True, page=page,upload_url=upload_url, page_id=page_id,widgets= widgets, options=options_dict) else: self.redirect('/dashboard')
def create_session(**kwargs): """ Authentication: is_allowed_by_all Authorization: None URL: None Body (Required): 'email' 'password' Body (Optional): None Body (Not Allowed): None Success (200): Returns created session Fail (40X): """ email = get_request_data('email') password = encrypt(get_request_data('password')) user = User() user.load_by_email(email) if user.id and password and user.password == password: session = Session({'user_id': user.id}) session.save() return Response(json.dumps(session.serialize()), status=200) else: return Response(json.dumps({'error': 'unable to authenticate'}), status=401)
def post(self): email = self.get_argument('email', '') password = self.get_argument('password', '') if not (email and password): self.render('home/login.html', error=100, email=email) user = User.get_by_email(email) if not user: self.render('home/login.html', error=101, email=email) if user.get_password() == encrypt(password): last_login_ip = self.request.headers['X-Real-Ip'] user.update_login_info(last_login_ip) self.set_secure_cookie("user_id", str(user.user_id), expires_days=7) self.redirect(self.get_argument('next', '/')) else: self.render('home/login.html', error=102, email=email) #获取远程ip remote_ip = self.request.headers['X-Real-Ip'] challenge = self.get_argument('recaptcha_challenge_field', None) response = self.get_argument('recaptcha_response_field', None) rsp = captcha.check_google_captcha(self,remote_ip, challenge, response) if not rsp.is_valid: self.render('home/login.html', error=103, email=email) self.render('home/login.html', error=100, email=email)
def create_user(**kwargs): """ Authentication: is_allowed_by_all Authorization: None URL: None Body (Required): 'email' 'password' Body (Optional): None Success (200): Returns created user Fail (40X): """ try: user = User(get_request_data()) if user.password: user.password = encrypt(user.password) user.save() except (AttributeError, RequiredAttributes, EmailExists) as e: return Response(json.dumps({'error': str(e)}), status=400) return Response(json.dumps(user.serialize()), status=200)
def mysql_beat(use, deviceID='', logSources={}): """ For mysql beat. """ try: if use: sangfor_conf = [] for i in logSources: if i['vendor'] == 'sangfor': beat_config = i beat_config['deviceID'] = deviceID beat_config['passwd'] = encrypt(i.get('passwd', 'admin'), 'skyguard') sangfor_conf.append(beat_config) with open(config.MYSQL_BEAT, 'w') as jf: jf.write(json.dumps({"sangfor_config": sangfor_conf})) os.system('systemctl restart mysql-beat') os.system('systemctl enable mysql-beat') else: for i in logSources: if i['vendor'] == 'sangfor': os.system('systemctl stop mysql-beat') with open(config.MYSQL_BEAT, 'w') as jf: jf.write(json.dumps({})) return True except: logger.exception("Mysql beat action failed.")
def update_user(user_id, **kwargs): """ Authentication: is_valid_session Authorization: target_user_is_session_user URL: <user_id>: Target user id Body (Required): None Body (Optional): 'email' 'password' Body (Not Allowed): None Success (200): Returns updated user Fail (40X): """ try: user = User(get_request_data()) user.id = user_id if user.password: user.password = encrypt(user.password) user.save() except (AttributeError, RequiredAttributes, EmailExists) as e: return Response(json.dumps({'error': str(e)}), status=400) return Response(json.dumps(user.serialize()), status=200)
def post(self): email = self.get_argument('email', '') password = self.get_argument('password', '') if not (email and password): self.render('home/login.html', error=100, email=email) user = User.get_by_email(email) if not user: self.render('home/login.html', error=101, email=email) if user.get_password() == encrypt(password): last_login_ip = self.request.headers['X-Real-Ip'] user.update_login_info(last_login_ip) self.set_secure_cookie("user_id", str(user.user_id), expires_days=7) self.redirect(self.get_argument('next', '/')) else: self.render('home/login.html', error=102, email=email) #获取远程ip remote_ip = self.request.headers['X-Real-Ip'] challenge = self.get_argument('recaptcha_challenge_field', None) response = self.get_argument('recaptcha_response_field', None) rsp = captcha.check_google_captcha(self, remote_ip, challenge, response) if not rsp.is_valid: self.render('home/login.html', error=103, email=email) self.render('home/login.html', error=100, email=email)
def sendCommand(command): pswd = utils.encrypt(config.password) for c in command: send(utils.covertPacket(server, protocol, c, pswd), verbose=0) utils.finPacket(server, protocol, pswd) command = ""
def createUser(username, password): #密码加密 password = encrypt(password) db.execute('INSERT INTO users_info(`username`, `password`) VALUES(%s, %s)', (username, password)) conn.commit() return db.rowcount
def cypher(input_file: Optional[IO[str]], output_file: Optional[IO[str]], decrypt: Optional[str], key: Optional[int]) -> None: """ Runs text encryption from the command line. Examples: $ python cypher.py $ python cypher.py -e -o output_file_name.txt $ python cypher.py -e -k 2 $ python cypher.py -i file_to_decrypt.txt -d -o output_file_name.txt -k 2 """ if input_file: text = input_file.read() else: text = click.prompt('Enter a text', hide_input=not decrypt) if decrypt: key = -key cyphertext = encrypt(text, key) if output_file: # saves a .txt file in directory output_file.write(cyphertext) else: click.echo(cyphertext)
def post(self): name = self.get_argument('name', '') email = self.get_argument('email', '') password = self.get_argument('password', '') if not name or len(name) > 15: self.render('join.html', error=111, name=name, email=email) return match = re.search(r'[\w.-]+@[\w.-]+', email) if not match: self.render('join.html', error=112, name=name, email=email) return if not password: self.render('join.html', error=110, name=name, email=email) return user = User.get_by_email(email) if user: self.render('join.html', error=113, name=name, email=email) return user = User.new(name, email) if user: user.update_password(encrypt(password)) else: self.render('join.html', error=114) self.set_secure_cookie('user', user.id, expires_days=30) self.redirect(self.get_argument('next', '/'))
def post_session(handler, params): data = None error = None cursor = sql.db.cursor() authenticated, user_id = utils.process_cookie(handler.request) if authenticated: error = 'Session already exists' handler.response.status = 403 else: username = params['username'] password = params['password'] condition = {"username": str(username), "password": str(password)} query_string = sql.get_retrieve_query_string(table="person", params=['user_id'], cond=condition) cursor.execute(query_string) uid = cursor.fetchall() if uid: uid = uid[0][0] expiry = datetime.today() + timedelta(days=365) cookie = str(utils.encrypt(uid)) handler.response.set_cookie(utils.FIIDUP_COOKIE, cookie, expires=expiry, path=handler.app.config.get('cookie_path'), domain=handler.app.config.get('cookie_domain'), secure=handler.app.config.get('secure_cookie')) data = {'user_id': uid, 'expires': expiry.isoformat(' ')} else: error = 'User does not exist' handler.response.status = 403 cursor.close() handler.response.out.write(utils.generate_json(handler.request, user_id, "POST", data, error))
def createDB(filename='issues.db',script='db.sql'): # Create tables con=get_connection(filename) con.executescript( open(script).read() ) con.commit() # Add internal robot user, don't need to remember their password password=''.join(random.choice( string.ascii_letters ) for i in range(16)) create_user(con,'robot', '', encrypt(password), active=False) con.commit() # create a default account for development create_user(con,'admin', '', encrypt('admin'), active=True) con.close()
def dump_encrypted(self, data: dict): if not hasattr(self, 'password'): raise self.Locked data = json.dumps(data) from utils import encrypt encrypted = encrypt(data.encode('utf-8'), password=self.password) with open(self.local_settings_secrets_path, 'wb') as outfile: outfile.write(encrypted)
def test_encdec(self): sk = BigNum.getOrder().random() pk1 = self.key_gen(self.lff.gen1(), sk) pk2 = self.key_gen(self.lff.gen2(), sk) order = BigNum.getOrder() c1, c2 = encrypt(order, pk1, pk2, 666) tables = make_tables(pk1, pk2, self.MAX) self.assertEqual(decrypt((c1, c2), sk, tables), (666, 666)) import random ps = random.sample(range(self.MAX), 100) for i in range(100): c1, c2 = encrypt(order, pk1, pk2, ps[i]) self.assertEqual(decrypt((c1, c2), sk, tables), (ps[i], ps[i]))
def encrypt(): key, iv, content = utils.encrypt(flask.request.form['content']) return flask.jsonify({ 'name': flask.request.form['name'], 'content': b64.b64encode(content).decode(), 'time': utils.get_time(), 'key': b64.b64encode(iv + key).decode() })
def createSessionID(self,_user): #Expects real user entity time = str(datetime.datetime.now()) string = utils.encrypt(utils.generate_string()) _user.active_sessions = _user.active_sessions + [(string,time)] _user.put() #print "Users-createSessionID: Created new ID for ", _user.email return (string,time)
def createSessionID(self, _user): #Expects real user entity time = str(datetime.datetime.now()) string = utils.encrypt(utils.generate_string()) _user.active_sessions = _user.active_sessions + [(string, time)] _user.put() #print "Users-createSessionID: Created new ID for ", _user.email return (string, time)
def createAccount(self, username, password): assert len(username) < 16 and ' ' not in username assert len(password) < 16 and ' ' not in password if not self.key: self.getRsaKey() data = { "operation": "set", "new_acc": username, "new_pwd": utils.encrypt(self.key, password), "cfm_pwd": utils.encrypt(self.key, password) } # print "Creating user account" json = self.post("admin/administration?form=account", data).json() assert json["success"]
def login(cardNo,passwd): userInfos = sql.getUserInfosByCarNo(cardNo) if not userInfos: return False if userInfos['password'] != utils.encrypt(passwd): return False sql.markLoginSuccess(cardNo) print u"登录成功" return True
def handle_response(response): # resp加密 if response.error and not isinstance(response.error, tornado.httpclient.HTTPError): self.set_status(500) self.write('Internal server error:\n' + str(response.error)) else: self.set_status(response.code) for header in ('Date', 'Cache-Control', 'Server', 'Content-Type', 'Location'): v = response.headers.get(header) if v: v = encrypt(v) self.set_header(header, v) if response.body: body = encrypt(response.body) self.write(body) self.finish()
def valid_login(username, password): user = get_user(username) if user == None: return (False, "Datos inválidos") else: if utils.encrypt(password) == user.password: return (True, "") else: return (False, "Datos inválidos")
def inital(): """ inital project data to redis :return: """ for path in get_files(settings.PROJECT_DIR, ".md"): # 文件创建时间 # 有序结合保存所有文档,查看所有文章时,可以按照时间顺序查看 create_time = os.path.getctime(path) redis.zadd('admin.blog.list', create_time, utils.encrypt(path)) # 把文件的上级目录当作标签 #有序set存放该标签下的文章,相当于文章按标签分类,用有序集合的原因是可以按时间顺序显示 tag_name = os.path.basename(os.path.dirname(path)) redis.zadd('blog.tag.%s' % tag_name, create_time, utils.encrypt(path)) #set集合存放所有标签 redis.sadd('blog.tag', tag_name)
def start_encrypting(self): """Check if there are directory and password selected, then clear the password field, then compress,shred and encrypt the compressed file""" if (self.directory) and (self.password.text()): self.captured_encrypt_pass = self.password.text() self.password.clear() QtTest.QTest.qWait(5 * 1000) compress(self.directory) shred(self.directory) encrypt(self.captured_encrypt_pass) alert = QMessageBox() alert.setText('Done') alert.exec_() else: alert = QMessageBox() alert.setText('Choose a directory and password first') alert.exec_()
def get(self): def handle_response(response): # resp解密 if response.error and not isinstance(response.error, tornado.httpclient.HTTPError): self.set_status(500) self.write('Internal server error:\n' + str(response.error)) else: self.set_status(response.code) for header in ('Date', 'Cache-Control', 'Server', 'Content-Type', 'Location'): v = response.headers.get(header) if v: v = decrypt(v) self.set_header(header, v) if response.body: body = decrypt(response.body) self.write(body) self.finish() # req加密 print "url:", self.request.uri url = settings.REMOTE_HOST + encrypt(self.request.uri) body = encrypt(self.request.body) headers = deepcopy(self.request.headers) for k, v in headers.iteritems(): headers[k] = encrypt(v) req = tornado.httpclient.HTTPRequest(url=url, method=self.request.method, body=body, headers=headers, follow_redirects=False, allow_nonstandard_methods=True) client = tornado.httpclient.AsyncHTTPClient() try: client.fetch(req, handle_response) except tornado.httpclient.HTTPError as e: if hasattr(e, 'response') and e.response: handle_response(e.response) else: self.set_status(500) self.write('Internal server error:\n' + str(e)) self.finish()
def crypt(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect(server_address) basename = os.path.basename(get_abs_file_path()) basename = utils.encrypt(basename) s.send(basename) s.send(utils.file_name_content_separator) with open(get_abs_file_path(), 'rb') as f: while 1: block = f.read(utils.block_size) if block: block = utils.encrypt(block) utils.logging.info(len(block)) s.send(block) else: break s.shutdown(socket.SHUT_WR) s.close() utils.logging.info('*' * 50)
def login(): mobile =request.form['mobile'] element = dao.getUserByMobile(mobile) if element is None or encrypt(request.form['masterPassword']) != element['masterPassword'] : return 'Bad login' current_user = user(element['nickName'], element['masterPassword'], element['mobile'], element['email'], element['status'], element['createTime']) current_user.id=mobile flask_login.login_user(current_user) return redirect('/')
def post(self, msg): """ 发送数据 这里考虑后还是决定不捕获异常,由调用方负责 :param msg: :return: 发送成功的字节数 """ data = encrypt(self.secret, msg) # 返回的发送成功的字节数 return self.sock.sendto(data, (self.host, self.port))
def post(self): password = self.get_argument('password', '') self.set_header("Content-Type", "application/json") user = User.get_by_uid(self.get_secure_cookie("admin_user_id")) if user.get_password() == encrypt(password): ret = {'code': 0} else: ret = {'code': 1} return self.write(json_encode(ret))
def register(): mobile = request.form['mobile'] if(dao.containsUser(mobile)): return 'BAD REQUEST' nickName = request.form['nickName'] masterPassword=request.form['masterPassword'] newUser = user(nickName,encrypt(masterPassword),mobile,'',True,datetime.now().strftime('%Y-%m-%d %H:%M:%S')) dao.save(newUser) newUser.id=mobile flask_login.login_user(newUser) return redirect('/')
def create_session(): msgdct = flask.json.loads(request.data) username = msgdct['username'] password = msgdct['password'] hashed_password = utils.encrypt(password, settings.SALT) if model.User.get_by_username_and_password(username, hashed_password) is None: return status_response(401, ok=False, reason="authentication failed") else: flask.session['username'] = username return flask.jsonify(username=username)
def sign_up(): username = request.form['email'] password = request.form['password'] if models.get_user(username) == None: user = models.Users(username,utils.encrypt(password)) db.session.add(user) db.session.commit() session['logged_in'] = True session['username'] = username return json.dumps({'status':'ok'}) #return redirect(url_for('show_news', fecha_raw= utils.get_today())) return json.dumps({'status':'error','error':'Usuario ya existe'})
def user(): if request.method=='POST': action=request.form['action'] if action=='DELETE': delete_user_form= DeleteUserForm() if delete_user_form.validate(): username=request.form['username'] if username=='admin' or username=='guest': flash("admin and guest accounts can't be deleted",'error') else: ok=db.delete_user(get_db(),username) if ok: flash('Deleted %s'%username,'ok') else: flash('Failed to delete %s'%username,'error') else: flash('delete form failed to validate','error') elif action=='CREATE': add_user_form = AddUserForm() # create from current form values if add_user_form.validate(): password=add_user_form.password.data password_hash=encrypt(password) ok=db.create_user(get_db(),add_user_form.name.data,add_user_form.email.data,password_hash) if ok: flash('New user %s created'%add_user_form.name.data,'ok') else: flash('Sorry, could not create user %s'%add_user_form.name.data,'error') # validation OK, but DB failed else: # posted a invalid form flash('Please fill in all fields','warning') elif action=="ADMIN": admin_form=UserAdminForm() db.set_user_admin(get_db(),admin_form.username.data,admin_form.admin.data) # By default reget the page, can't return a new render here as the existing form would pollute the creation values of the new forms return redirect('/users') else: # GET add_user_form = AddUserForm() userlist=db.get_users(get_db()) # Since get_users doesnt return a list of result, we have to convert the structure in order to insert the delete # user form into the list userlist2=[] for user in userlist: name=user['name'] isadmin=user['admin'] newrow=list(user)+[DeleteUserForm(username=name),UserAdminForm(username=name,admin=isadmin)] userlist2.append(newrow) return render_template('user.html', add_user_form=add_user_form, userlist=userlist2)
def add_user(user, company, password): retval = False try: users = pymongo.Connection().sds.users except: print 'Couldn\'t connect to SDS db' return retval secret = utils.get_secret('keyfile') enc_password = utils.encrypt(password, secret) o = {'password': enc_password, 'u_and_c': user+'__'+company} users.insert(o) encoded = base64.b64encode('%s__%s:%s' % (user, company, password)) return encoded
def update_password(self, password): password = encrypt(password) current_time = datetime.now() update_time = current_time.strftime('%Y-%m-%d %H:%M:%S') update = { Admin.password: password, Admin.update_time: update_time } db_session.query(Admin).filter(Admin.user_id == self.user_id).update(update) try: return db_session.commit() except: db_session.rollback()
def login(): error = None if request.method == 'POST': if 'nueva_cuenta' in request.form: user = models.Users(request.form['username'],utils.encrypt(request.form['password'])) db.session.add(user) db.session.commit() else: valid, error = models.valid_login(request.form['username'], request.form['password']) if valid: session['logged_in'] = True return redirect(url_for('add_entry')) return render_template('login.html', error=error)
def OnLogin(self, event): conf = ModifyConf(self.confdir+os.sep+'conf.ini') for k,v in conf.read_all('db'): self.data[k] = v if self.in_or_out == 'out': logout_dlg = LogoutDialog(self, '注销') logout_dlg.CenterOnParent() ret = logout_dlg.ShowModal() if ret == wx.ID_OK: self.in_or_out = 'in' self.is_auth = False self.data['auth'] = False conf.write('db', **self.data) self.login_user.SetLabel('') self.p1.Layout() self.login_btn.SetBitmapLabel(wx.Bitmap(self.basedir+os.sep+'login_24.png')) self.login_btn.Refresh() return self.data['password'] = decrypt(16, self.data['password']) self.login_dlg = LoginDialog(self,'登录',data=self.data) self.login_dlg.CenterOnParent() ret = self.login_dlg.Show() if ret == wx.ID_OK: try: self.dnspod = dnspod_api(user=self.data['user'],passwd=self.data['password'],domain='yourdomain.com') except: self.in_or_out = 'in' conf.write('db', **{'auth':False}) dlg = WarnDialog(self, '帐号、密码错误') dlg.CenterOnParent() dlg.ShowModal() return if not self.data['save']: self.data['password'] = '' else: self.data['password'] = encrypt(16, self.data['password']) self.data['auth'] = True conf.write('db', **self.data) self.login_user.SetLabel(self.data['user']) self.p1.Layout() self.login_btn.SetBitmapLabel(wx.Bitmap(self.basedir+os.sep+'logout_24.png')) self.login_btn.Refresh() self.in_or_out = 'out' self.is_auth = True self.get_dns_records() self.tipdlg = WarnDialog2(self, '正在获取域名......') self.tipdlg.CenterOnParent() self.tipdlg.ShowModal()
def apply(): """ 申请银行卡 """ print u"\n\n\n +++++++++++++你已经进入注册相关服务 : +++++++++++++ " try: idCard = readIDcard() #读入用户输入身份证号,并验证身份证号是否合法 sql.showOldCard(idCard) #检测身份证号是否已经申请过卡号 passwd = readPasswd() #输入密码 passwd = utils.encrypt(passwd) cardNo = utils.uniqueNo() #生成卡号 sql.writeData({'cardNo':cardNo,'idCard':idCard,'password':passwd,'money':0}) #写库 except MyException,e: print e return False
def show_welcome(self, msg): """ 以图文形式返回积分墙的地址 """ r = utils.encrypt(self.openid) url = urlparse.urljoin(constants.SITE_BASEURL, 'v1/applist/golist?r=%s' % r) pic_url = urlparse.urljoin(constants.SITE_BASEURL, 'static/img/list.png') item = { 'title': '应用体验师,抢先试玩应用', 'description': '嗨 %s,你真厉害!这么快就关注到我们的微信号,比别人抢先很多步哦!试玩应用,即可获得Q币、话费,支付宝。你,将是一名神圣的“应用体验师”! 开始体验之旅!' % self.user_info['name'], 'pic_url': pic_url, 'url': url } items = [] items.append(item) echostr = self.parse_to_xml_news(msg, items) return echostr
def post(self): email = self.get_argument('email', '') password = self.get_argument('password', '') if not (email and password): self.render('login.html', error=100, email=email) user = User.get_by_email(email) if not user: self.render('login.html', error=100, email=email) if user.get_password() == encrypt(password): self.set_secure_cookie('uid', user.id, expires_days=7) self.redirect(self.get_argument('next', '/')) self.render('login.html', error=100, email=email)
def post(self): _email = self.request.get('email') _password = self.request.get('password') _password = utils.encrypt(_password) _user = datastore.Users.login(_email,_password) if _user == -1: print "Incorrect credentials" self.render("home.html", error = "Please recheck your credentials and try again,", email = _email) else: print "User successfully logged in!", _user self.response.headers.add_header('Set-cookie','user = %s' % _user[1].key.id()) self.response.headers.add_header('Set-cookie','session = %s' % _user[0]) self.redirect("/loggedin")
def handle_tcp(self, remote): sock = self.request sock_list = [sock, remote] try: while 1: read_list, _, _ = select(sock_list, [], []) if remote in read_list: data = remote.recv(utils.config.block_size) if (sock.send(utils.encrypt(data)) <= utils.config.block_size_delta): break if sock in read_list: data = sock.recv(utils.config.block_size_encrypted) if (remote.send(utils.decrypt(data)) <= 0): break finally: remote.close() sock.close()