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)
