def ecc_generate(): if request.method == 'GET': return render_template('ecc/generate/index.html') coef = int(request.form['x-coef']) const = int(request.form['const']) modulo = int(request.form['modulo']) if not is_prime(modulo): return "Error: Modulo must be prime" curve = EllipticCurve(coef, const, modulo) base_x = int(request.form['bpoint-x']) base_y = int(request.form['bpoint-y']) bpoint = Point(base_x, base_y, modulo) if not curve.contains(bpoint): return "Error: The base point is not a point in the curve" private_key = randrange(1, MAX_KEY) public_key = curve.multiply(private_key, bpoint) filename = request.form['filename'] public_file = FileStorage(stream=BytesIO(public_key.print().encode()), filename=filename + '.pub') public_file.save('static/' + public_file.filename) private_file = FileStorage(stream=BytesIO(str(private_key).encode()), filename=filename + '.pri') private_file.save('static/' + private_file.filename) return render_template('ecc/generate/result.html')
def ecc_encrypt(): if request.method == 'GET': return render_template('ecc/encrypt/index.html') message = request.files['message'].read() filename = 'encrypted_' + request.files['message'].filename kob = int(request.form['koblitz']) coef = int(request.form['x-coef']) const = int(request.form['const']) modulo = int(request.form['modulo']) if not is_prime(modulo): return "Error: Modulo must be prime" curve = EllipticCurve(coef, const, modulo) base_x = int(request.form['bpoint-x']) base_y = int(request.form['bpoint-y']) bpoint = Point(base_x, base_y, modulo) if not curve.contains(bpoint): return "Error: The base point is not a point in the curve" pubkey = request.files.get('pubkey-file', None) if pubkey == None: pubkey_x = int(request.form['pubkey-x']) pubkey_y = int(request.form['pubkey-y']) pubkey = Point(pubkey_x, pubkey_y, modulo) else: pubkey = pubkey.read().decode() pubkey = Point(0, 0, modulo, pubkey) if not curve.contains(pubkey): return "Error: The public key is not a point in the curve" plaintext = encode(curve, message, kob) start = default_timer() k = randrange(1, modulo) ciphertext = [ curve.add(point, curve.multiply(k, pubkey)) for point in plaintext ] ciphertext.append(curve.multiply(k, bpoint)) end = default_timer() string = ' '.join([point.print() for point in ciphertext]) file = FileStorage(stream=BytesIO(string.encode()), filename=filename) file.seek(0, SEEK_END) size = file.tell() file.seek(0) file.save('static/' + filename) return render_template('ecc/encrypt/result.html', plaintext=message, ciphertext=string, time=end - start, filename=filename, size=size)
def save_file(fs: FileStorage): """ Функция сохраняет файл на диск Для формирования имени файла используется hash-function md5 Делается это для избежания дублирования файлов Из функции возвращается путь до файла """ hasher = hashlib.new("md5") hasher.update(fs.stream.read()) filename = hasher.hexdigest() fs.stream.seek(0) extension = mimetypes.guess_extension(fs.mimetype) if not extension: _, extension = path.splitext(fs.name) filename = f"{filename}{extension}" fs.save(FilesService.get_path(filename)) return filename
def rsa_generate(): if request.method == 'GET': return render_template('rsa/generate/index.html') rsaKeyPair = RSAKeyPair(int(request.form['p']), int(request.form['q']), int(request.form['e'])) filename = request.form['filename'] public_file = FileStorage(stream=BytesIO( rsaKeyPair.public.to_json().encode()), filename=filename + '.pub') public_file.save('static/' + public_file.filename) private_file = FileStorage(stream=BytesIO( rsaKeyPair.private.to_json().encode()), filename=filename + '.pri') private_file.save('static/' + private_file.filename) return render_template('rsa/generate/result.html')
def ecc_decrypt(): if request.method == 'GET': return render_template('ecc/decrypt/index.html') message = request.files['message'].read() kob = int(request.form['koblitz']) coef = int(request.form['x-coef']) const = int(request.form['const']) modulo = int(request.form['modulo']) if not is_prime(modulo): return "Error: Modulo must be prime" curve = EllipticCurve(coef, const, modulo) prikey = request.files.get('prikey-file', None) if prikey == None: prikey = int(request.form['prikey']) else: prikey = int(prikey.read()) raw_ciphertext = message.decode().split(' ') while raw_ciphertext[-1] == '': del raw_ciphertext[-1] ciphertext = [Point(0, 0, modulo, point) for point in raw_ciphertext] start = default_timer() point_neg = curve.multiply(prikey, ciphertext[-1]) del ciphertext[-1] point_neg.negate() plaintext = [curve.add(point, point_neg) for point in ciphertext] end = default_timer() string = decode(plaintext, kob) filename = request.form['filename'] file = FileStorage(stream=BytesIO(string), filename=filename) file.seek(0, SEEK_END) size = file.tell() file.seek(0) file.save('static/' + filename) return render_template('ecc/decrypt/result.html', plaintext=string, ciphertext=message.decode(), time=end - start, filename=filename, size=size)
def rsa_encrypt(): if request.method == 'GET': return render_template('rsa/encrypt/index.html') if request.files['pubkey-file']: rsaPublicKey = RSAPublicKey.from_json( request.files['pubkey-file'].read()) else: rsaPublicKey = RSAPublicKey(int(request.form['n']), int(request.form['e'])) start = default_timer() n_byte_length = byte_length(rsaPublicKey.n) chunk_byte_length = n_byte_length - 1 if chunk_byte_length <= 0: return 'Modulus too small' message = request.files['message'].read() plaintext = len(message).to_bytes(4, byteorder) + message plaintext_chunks = [ plaintext[i:i + chunk_byte_length] for i in range(0, len(plaintext), chunk_byte_length) ] ciphertext = bytes() for chunk in plaintext_chunks: ciphertext += rsaPublicKey.encrypt(int.from_bytes( chunk, byteorder)).to_bytes(n_byte_length, byteorder) end = default_timer() filename = 'encrypted_' + request.files['message'].filename ciphertext_file = FileStorage(stream=BytesIO(ciphertext), filename=filename) ciphertext_file.seek(0, SEEK_END) size = ciphertext_file.tell() ciphertext_file.seek(0) ciphertext_file.save('static/' + filename) return render_template('rsa/encrypt/result.html', plaintext=message, ciphertext=ciphertext, time=end - start, filename=filename, size=size)
def _save_mod_zipball(mod_name: str, friendly_version: str, zipball: werkzeug.FileStorage) -> Tuple[str, str]: mod_name_sec = secure_filename(mod_name) storage_base = os.path.join( f'{secure_filename(current_user.username)}_{current_user.id!s}', mod_name_sec) storage = _cfg('storage') if not storage: return ('', '') storage_path = os.path.join(storage, storage_base) filename = f'{mod_name_sec}-{friendly_version}.zip' if not os.path.exists(storage_path): os.makedirs(storage_path) file_path = os.path.join(storage_path, filename) if os.path.isfile(file_path): os.remove(file_path) zipball.save(file_path) # Return tuple of (full path, relative path) return (file_path, os.path.join(storage_base, filename))
def upload_api(self, **post): _logger.info("inside upload_api") response = None try: username = post['username'] password = post['password'] # template_type_from_user = post['template_type'] file_storage = FileStorage(post['file']) except Exception: response = dict(errorCode=1, message='Bad Request') template_type_from_user = post.get('template_type', None) if response is None: user_api_settings = request.env['res.partner'].sudo().search([ ('api_username', '=', username), ('api_secret', '=', password) ]) if len(user_api_settings) == 1: user_id = user_api_settings[0].id directory_path = UPLOAD_DIR + str(datetime.now().strftime( "%d%m%Y")) + "/" + str(user_id) + "/" file_name = FileUploadController.random_string_generator( 10) + request.params['file'].filename if not os.path.exists(os.path.dirname(directory_path)): try: os.makedirs(os.path.dirname(directory_path)) except OSError as exc: if exc.errno != errno.EEXIST: raise uploaded_file_path = str(directory_path + file_name) file_storage.save(uploaded_file_path) response = request.env['sps.document.process'].sudo( ).process_document(user_api_settings, uploaded_file_path, template_type_from_user, str(request.params['file'].filename)) _logger.info("response :%r", response) else: response = dict(errorCode=3, message='UnAuthorized Access') if "errorCode" in response: self.send_mail("Sending API Response as " + str(response['message']) + " for user " + username) return json.JSONEncoder().encode(response)
def rsa_decrypt(): if request.method == 'GET': return render_template('rsa/decrypt/index.html') if request.files['prikey-file']: rsaPrivateKey = RSAPrivateKey.from_json( request.files['prikey-file'].read()) else: rsaPrivateKey = RSAPrivateKey(int(request.form['n']), int(request.form['d'])) start = default_timer() n_byte_length = byte_length(rsaPrivateKey.n) if n_byte_length <= 1: return 'Modulus too small' ciphertext = request.files['message'].read() ciphertext_chunks = [ ciphertext[i:i + n_byte_length] for i in range(0, len(ciphertext), n_byte_length) ] plaintext = bytes() for chunk in ciphertext_chunks: plaintext += rsaPrivateKey.decrypt(int.from_bytes( chunk, byteorder)).to_bytes(n_byte_length, byteorder)[:-1] plaintext = plaintext[4:int.from_bytes(plaintext[:4], byteorder) + 4] end = default_timer() filename = 'decrypted_' + request.files['message'].filename plaintext_file = FileStorage(stream=BytesIO(plaintext), filename=filename) plaintext_file.seek(0, SEEK_END) size = plaintext_file.tell() plaintext_file.seek(0) plaintext_file.save('static/' + filename) return render_template('rsa/decrypt/result.html', plaintext=plaintext, ciphertext=ciphertext, time=end - start, filename=filename, size=size)
def create(self, user_id: str, file_: FileStorage) -> Optional[File]: # Save file in local filename = secure_filename(file_.filename) temporary_path = FileHelper().get_temporary_path(filename) file_.save(temporary_path) # Update file to S3 path = S3().create_file(temporary_path, file_.content_type) fields = { 'user_id': user_id, 'name': filename, 'media_type': file_.content_type, 'path': path, 'size': os.path.getsize(temporary_path) } file_model = self.file_repository.create(fields) # Delete directory shutil.rmtree(os.path.dirname(temporary_path)) return file_model
def handle_file(file: FileStorage, upload_folder=UPLOAD_FOLDER, fps=FPS, resolution=RESOLUTION) -> Dict[str, np.array]: """Make the prediction if the data is coming from an uploaded file. Arguments: - *file*: The file, can be either an image or a video - *upload_folder*: Where the files are temporarly stored Returns: - for an image: a json of format ```json { "image": filename, "detected_trash": [ { "box": [1, 1, 2, 20], "label": "fragments", "score": 0.92 }, { "box": [10, 10, 25, 20], "label": "bottles", "score": 0.75 } ] } ``` - for a video: a json of format ```json { "video_length": 132, "fps": 2, "video_id": "GOPRO1234.mp4", "detected_trash": [ { "label": "bottles", "id": 0, "frame_to_box": { 23: [0, 0, 1, 10], 24: [1, 1, 4, 13] } }, { "label": "fragments", "id": 1, "frame_to_box": { 12: [10, 8, 9, 15] } } ] } ``` Raises: - *NotImplementedError*: If the format of data isn't handled yet """ filename = secure_filename(file.filename) full_filepath = os.path.join(upload_folder, filename) if not os.path.isdir(upload_folder): os.mkdir(upload_folder) if os.path.isfile(full_filepath): os.remove(full_filepath) file.save(full_filepath) file_type = file.mimetype.split("/")[ 0] # mimetype is for example 'image/png' and we only want the image if file_type == "image": image = cv2.imread(full_filepath) # cv2 opens in BGR os.remove(full_filepath) # remove it as we don't need it anymore return { "image": filename, "detected_trash": predict_and_format_image(image) } elif file_type in ["video", "application"]: # splitting video and saving frames folder = os.path.join(upload_folder, "{}_split".format(filename)) if os.path.isdir(folder): shutil.rmtree(folder) os.mkdir(folder) logger.info("Splitting video {} to {}.".format(full_filepath, folder)) split_video(full_filepath, folder, fps=fps, resolution=resolution) image_paths = read_folder(folder) if len(image_paths) == 0: raise ValueError("No output image") # making inference on frames logger.info("{} images to analyze on {} CPUs.".format( len(image_paths), CPU_COUNT)) with multiprocessing.Pool(CPU_COUNT) as p: inference_outputs = list( tqdm( p.imap(process_image, image_paths), total=len(image_paths), )) logger.info("Finish analyzing video {}.".format(full_filepath)) # tracking objects logger.info("Starting tracking.") object_tracker = ObjectTracking(filename, image_paths, inference_outputs, fps=fps) logger.info("Tracking finished.") return object_tracker.json_result() else: raise NotImplementedError(file_type)
def handle_file(file: FileStorage, upload_folder: str = UPLOAD_FOLDER, fps: int = FPS, resolution: Tuple[int, int] = RESOLUTION, **kwargs) -> Dict[str, np.array]: """Make the prediction if the data is coming from an uploaded file. Arguments: - *file*: The file, can be either an image or a video, or a zipped folder - *upload_folder*: Where the files are temporarly stored Returns: - for an image: a json of format ```json { "image": filename, "detected_trash": [ { "box": [1, 1, 2, 20], "label": "fragments", "score": 0.92 }, { "box": [10, 10, 25, 20], "label": "bottles", "score": 0.75 } ] } ``` - for a video or a zipped file: a json of format ```json { "video_length": 132, "fps": 2, "video_id": "GOPRO1234.mp4", "detected_trash": [ { "label": "bottles", "id": 0, "frame_to_box": { 23: [0, 0, 1, 10], 24: [1, 1, 4, 13] } }, { "label": "fragments", "id": 1, "frame_to_box": { 12: [10, 8, 9, 15] } } ] } ``` Raises: - *NotImplementedError*: If the format of data isn't handled yet """ if kwargs: logger.warning("Unused kwargs: {}".format(kwargs)) filename = secure_filename(file.filename) full_filepath = os.path.join(upload_folder, filename) if not os.path.isdir(upload_folder): os.mkdir(upload_folder) if os.path.isfile(full_filepath): os.remove(full_filepath) file.save(full_filepath) file_type = file.mimetype.split("/")[0] # mimetype is for example 'image/png' and we only want the image if file_type == "image": image = cv2.imread(full_filepath) # cv2 opens in BGR os.remove(full_filepath) # remove it as we don't need it anymore try: detected_trash = predict_and_format_image(image) except ValueError as e: return {"error": str(e)} return {"image": filename, "detected_trash": detected_trash} elif file_type in ["video", "application"]: folder = None if file.mimetype == "application/zip": # zip case ZipFile(full_filepath).extractall(upload_folder) dirname = None with ZipFile(full_filepath, 'r') as zipObj: listOfFileNames = zipObj.namelist() for fileName in listOfFileNames: dirname = os.path.dirname(fileName) zipObj.extract(fileName, upload_folder) folder = os.path.join(upload_folder, dirname) else: # video case: splitting video and saving frames folder = os.path.join(upload_folder, "{}_split".format(filename)) if os.path.isdir(folder): shutil.rmtree(folder) os.mkdir(folder) logger.info("Splitting video {} to {}.".format( full_filepath, folder)) split_video(full_filepath, folder, fps=fps, resolution=resolution) print("folder:", folder, "uplaod_folder:", upload_folder, "file.filename:", file.filename) image_paths = read_folder(folder) if len(image_paths) == 0: raise ValueError("No output image") # making inference on frames logger.info("{} images to analyze on {} CPUs.".format( len(image_paths), CPU_COUNT)) try: with multiprocessing.Pool(CPU_COUNT) as p: inference_outputs = list( tqdm( p.imap(process_image, image_paths), total=len(image_paths), )) except ValueError as e: return {"error": str(e)} logger.info("Finish analyzing video {}.".format(full_filepath)) # tracking objects logger.info("Starting tracking.") object_tracker = ObjectTracking(filename, image_paths, inference_outputs, fps=fps) tracks = object_tracker.compute_tracks() logger.info("Tracking finished.") return object_tracker.json_result(tracks) else: raise NotImplementedError(file_type)
def _save_request_content(destination, stream): file_storage = FileStorage(stream) file_storage.save(destination)