def upload(): form = UploadForm() if form.validate_on_submit(): if not user_has_roles(current_user, RoleEnum.USER): return flask.abort(HTTPStatus.FORBIDDEN, description="You do not have the permission to start jobs.") # flask-uploads already uses werkzeug.secure_filename() filename = cap_uploads.save(request.files['capture'], folder=current_user.username) cap_path = Path(app.config['CAPTURES_DIR']) / filename cap_path = Path(shlex.quote(str(cap_path))) try: file_22000 = convert_to_22000(cap_path) except (FileNotFoundError, InvalidFileError) as error: logger.exception(error) return flask.abort(HTTPStatus.BAD_REQUEST, description="Bad input capture file.") Thread(target=download_wordlist, args=(form.get_wordlist_path(),)).start() folder_split_by_essid = split_by_essid(file_22000) tasks = {} hashcat_args = ' '.join(form.hashcat_args()) for file_essid in folder_split_by_essid.iterdir(): bssid_essid = next(bssid_essid_from_22000(file_essid)) bssid, essid = bssid_essid.split(':') essid = bytes.fromhex(essid).decode('utf-8') new_task = UploadedTask(user_id=current_user.id, filename=cap_path.name, wordlist=form.get_wordlist_name(), rule=form.rule.data, bssid=bssid, essid=essid, hashcat_args=hashcat_args) tasks[file_essid] = new_task db.session.add_all(tasks.values()) db.session.commit() for file_essid, task in tasks.items(): hashcat_worker.submit_capture(file_essid, uploaded_form=form, task=task) flask.flash(f"Uploaded {filename}") return redirect(url_for('user_profile')) return render_template('upload.html', title='Upload', form=form)
def callback_attack(self, future: concurrent.futures.Future): # called when the future is done or cancelled try: exception = future.exception() except concurrent.futures.CancelledError as cancelled_error: exception = None if exception is not None: logger.exception(repr(exception), exc_info=False) job_id = id(future) lock = self.locks.pop(job_id, None) if lock is None: logger.error("Could not find lock for job {}".format(job_id)) return with lock: if future.cancelled(): lock.set_status(TaskInfoStatus.CANCELLED) else: lock.set_status(TaskInfoStatus.COMPLETED) if exception is not None: if isinstance(exception, CancelledError): lock.set_status(TaskInfoStatus.CANCELLED) else: lock.set_status(repr(exception)) lock.finish() update_dict = lock.update_dict() task_id = lock.task_id UploadedTask.query.filter_by(id=task_id).update(update_dict) db.session.commit() self.locks_onetime.append(lock)
async def error_middleware(request: Request, handler: Handler) -> Response: """Обработка ошибок по типу 404, 500 и т.д.""" try: response = await handler(request) except web.HTTPClientError as e: response = await render_error_template(request, e.status_code) except Exception: logger.exception("Произошла непредвиденная ошибка!") response = await render_error_template(request, 500) finally: return response # noqa: B012
def start_get_password(message): if Guards.is_cancel(message) or Guards.is_command(message): return bot.reply_to(message, 'Action was canceled. Type /start to repeat') chat_id, ctx = get_or_create_context(message) password = message.text try: rf_user = execute(login_to_rf(ctx.username, password)) # fixme # Yes, this is extremely bad to store unhashed password, but I have no choice for now. # If you really concern - self host this bot. # Meanwhile I am trying to create better solution. ctx.password = password ctx.is_authorized = True ctx.save() msg = bot.send_message( chat_id, f'Hi, {rf_user.surname} {rf_user.name}!\n' f'Your login and password is correct!\n' f'\n' f'Now, paste URL to the destination node:\n' ) bot.register_next_step_handler(msg, setup_complete) except Exception as e: logger.exception(e) msg = bot.send_message( chat_id, 'Something went wrong. Please try again or type /cancel\n' 'Type your username (email):' ) bot.register_next_step_handler(msg, start_get_username) finally: bot.delete_message(chat_id, message.message_id)
def catch_all(message): chat_id, ctx = get_or_create_context(message) if Guards.is_cancel(message): return bot.reply_to(message, 'Nothing to cancel') if Guards.is_command(message): return bot.reply_to( message, 'Unsupported command\n' f'{COMMANDS}' ) if not Guards.is_authorized(ctx): return bot.reply_to(message, 'You have to /start first') if not Guards.is_setup_completed(ctx): return bot.reply_to(message, 'You have to /setup first') try: rf_node = execute(create_new_node(ctx, text_to_html(message.text))) url = link_to_node(rf_node.map_id, rf_node.id) bot.reply_to(message, f'<a href="{url}">Saved</a>', parse_mode='HTML') except Exception as e: logger.exception(e) target_url = link_to_node(ctx.target.map_id, ctx.target.node_id) bot.reply_to( message, 'Something went wrong. Please check if you have access to the destination node and try again\n' f'<a href="{target_url}">Destination node</a>', parse_mode='HTML' )
def fill_missing_review_data(review_id): logger.info(f'filling missing for {review_id}') reviews_without_name = list( maybe_filter(Review.objects.select_related('reviewable').filter( Q(name__isnull=True) | Q(name='')), id=review_id)) logger.info(f'reviews_without_name: {reviews_without_name}') context = PageCache() for review in tqdm(reviews_without_name): try: good_title = get_good_title_for_page(review.url, context) except Exception: logger.exception('could not fetch {}'.format(review.url)) else: if good_title: review.name = good_title review.save(update_fields=['name']) reviewables_without_image = list( maybe_filter(Reviewable.objects.filter( Q(image_url__isnull=True) | Q(image_url='')), review__id=review_id)) logger.info(f'reviewables_without_image: {reviewables_without_image}') for reviewable in tqdm(reviewables_without_image): try: good_image = get_good_image_for_page(reviewable.url, context) except Exception: logger.exception('could not fetch {}'.format(reviewable.url)) else: if good_image: reviewable.image_url = good_image reviewable.save(update_fields=['image_url'])
async def http_exception_handler(request: Request, exc: HTTPException): if exc.status_code == 500: logger.exception(exc) else: logger.info(exc) return UJSONResponse({'message': exc.detail}, exc.status_code)