revert to d878d6f

ScilifelabDataCentre · Aug 4, 2022 · 8dfdfd9 · 8dfdfd9
1 parent 5d3ccde
commit 8dfdfd9
Show file tree

Hide file tree

Showing 7 changed files with 22 additions and 118 deletions.
diff --git a/.gitignore b/.gitignore
@@ -34,5 +34,4 @@ safespring_invoicespec.csv
 dds_web/development/invoicing/*
 dds_variables.env
 cython_tools
-coverage/*
-marshmallowtests.md
+coverage/*
diff --git a/dds_web/api/dds_decorators.py b/dds_web/api/dds_decorators.py
@@ -25,7 +25,7 @@
     MissingJsonError,
     S3ConnectionError,
 )
-from dds_web.utils import current_time, get_username_or_request_ip
+from dds_web.utils import get_username_or_request_ip
 
 # initiate logging
 action_logger = structlog.getLogger("actions")
@@ -39,9 +39,7 @@
 def handle_validation_errors(func):
     @functools.wraps(func)
     def handle_error(*args, **kwargs):
-        flask.current_app.logger.info(
-            f"- handle_validation_errors\t Current time: {current_time()}"
-        )
+
         try:
             result = func(*args, **kwargs)
         except (marshmallow.exceptions.ValidationError) as valerr:
@@ -187,7 +185,6 @@ def logging_bind_request(func):
 
     @functools.wraps(func)
     def wrapper_logging_bind_request(*args, **kwargs):
-        flask.current_app.logger.info(f"- logging_bind_request\t Current time: {current_time()}")
         with structlog.threadlocal.bound_threadlocal(
             resource=flask.request.path or "not applicable",
             project=flask.request.args.get("project") if flask.request.args else None,

diff --git a/dds_web/api/project.py b/dds_web/api/project.py
@@ -368,11 +368,8 @@ class GetPublic(flask_restful.Resource):
     def get(self):
         """Get public key from database."""
         # Verify project ID and access
-
         project = project_schemas.ProjectRequiredSchema().load(flask.request.args)
-        # project = models.Project.query.filter(
-        #     models.Project.public_id == sqlalchemy.func.binary(flask.request.args.get("project"))
-        # ).one_or_none()
+
         flask.current_app.logger.debug("Getting the public key.")
 
         if not project.public_key:
@@ -389,33 +386,22 @@ class GetPrivate(flask_restful.Resource):
     @handle_validation_errors
     def get(self):
         """Get private key from database."""
-        flask.current_app.logger.info(
-            f"- GetPrivate (before schema)\t Current time: {dds_web.utils.current_time()}"
-        )
         # Verify project ID and access
         project = project_schemas.ProjectRequiredSchema().load(flask.request.args)
-        flask.current_app.logger.info(
-            f"- GetPrivate (after schema)\t Current time: {dds_web.utils.current_time()}"
-        )
 
-        # flask.current_app.logger.debug("Getting the private key.")
-        flask.current_app.logger.info(
-            f"- GetPrivate (before obtain_project_private_key)\t Current time: {dds_web.utils.current_time()}"
-        )
-        dict_to_return = {
-            "private": obtain_project_private_key(
-                user=auth.current_user(),
-                project=project,
-                token=dds_web.security.auth.obtain_current_encrypted_token(),
-            )
-            .hex()
-            .upper()
-        }
-        flask.current_app.logger.info(
-            f"- GetPrivate (after obtain_project_private_key)\t Current time: {dds_web.utils.current_time()}"
-        )
+        flask.current_app.logger.debug("Getting the private key.")
 
-        return flask.jsonify(dict_to_return)
+        return flask.jsonify(
+            {
+                "private": obtain_project_private_key(
+                    user=auth.current_user(),
+                    project=project,
+                    token=dds_web.security.auth.obtain_current_encrypted_token(),
+                )
+                .hex()
+                .upper()
+            }
+        )
 
 
 class UserProjects(flask_restful.Resource):

diff --git a/dds_web/security/auth.py b/dds_web/security/auth.py
@@ -333,29 +333,14 @@ def extract_encrypted_token_sensitive_content(token, username):
     """Extract the sensitive content from inside the encrypted token."""
     if token is None:
         raise TokenMissingError(message="There is no token to extract sensitive content from.")
-
-    flask.current_app.logger.info(
-        f"- - - - - extract_encrypted_token_sensitive_content (before decrypt_and_verify_token_signature)\t Current time: {dds_web.utils.current_time()}"
-    )
     content = decrypt_and_verify_token_signature(token=token)
-    flask.current_app.logger.info(
-        f"- - - - - extract_encrypted_token_sensitive_content (after decrypt_and_verify_token_signature)\t Current time: {dds_web.utils.current_time()}"
-    )
-
     if content.get("sub") == username:
         return content.get("sen_con")
 
 
 def decrypt_and_verify_token_signature(token):
     """Streamline decryption and signature verification and return the claims."""
-    flask.current_app.logger.info(
-        f"- - - - - - decrypt_and_verify_token_signature (before verify_token_signature)\t Current time: {dds_web.utils.current_time()}"
-    )
-    verified_token_signature = verify_token_signature(token=decrypt_token(token=token))
-    flask.current_app.logger.info(
-        f"- - - - - - decrypt_and_verify_token_signature (after verify_token_signature)\t Current time: {dds_web.utils.current_time()}"
-    )
-    return verified_token_signature
+    return verify_token_signature(token=decrypt_token(token=token))
 
 
 def decrypt_token(token):

diff --git a/dds_web/security/project_user_keys.py b/dds_web/security/project_user_keys.py
@@ -18,28 +18,21 @@
     extract_encrypted_token_sensitive_content,
     extract_token_invite_key,
 )
-from dds_web import utils
 
 
 def __derive_key(user, password):
     if not user.kd_salt:
         raise KeySetupError(message="User keys are not properly setup!")
 
-    flask.current_app.logger.info(
-        f"- - - __derive_key (before hash_secret_raw)\t Current time: {utils.current_time()}"
-    )
     derived_key = argon2.low_level.hash_secret_raw(
         secret=password.encode(),
         salt=user.kd_salt,
         time_cost=2,
-        memory_cost=2097152,  # 16384 worked
+        memory_cost=flask.current_app.config["ARGON_KD_MEMORY_COST"],
         parallelism=8,
         hash_len=32,
         type=argon2.Type.ID,
     )
-    flask.current_app.logger.info(
-        f"- - - __derive_key (after hash_secret_raw)\t Current time: {utils.current_time()}"
-    )
 
     if len(derived_key) != 32:
         raise KeySetupError(message="Derived key is not 256 bits long!")
@@ -90,49 +83,24 @@ def __encrypt_project_private_key(owner, project_private_key):
 
 
 def __decrypt_project_private_key(user, token, encrypted_project_private_key):
-    flask.current_app.logger.info(
-        f"- - - __decrypt_project_private_key (before __decrypt_user_private_key_via_token)\t Current time: {utils.current_time()}"
-    )
     private_key_bytes = __decrypt_user_private_key_via_token(user, token)
-    flask.current_app.logger.info(
-        f"- - - __decrypt_project_private_key (after __decrypt_user_private_key_via_token)\t Current time: {utils.current_time()}"
-    )
-
     if not private_key_bytes:
         raise KeyOperationError(message="User private key could not be decrypted!")
 
     try:
         user_private_key = serialization.load_der_private_key(private_key_bytes, password=None)
-        flask.current_app.logger.info(
-            f"- - - __decrypt_project_private_key (before __decrypt_with_rsa)\t Current time: {utils.current_time()}"
-        )
         if isinstance(user_private_key, asymmetric.rsa.RSAPrivateKey):
             return __decrypt_with_rsa(encrypted_project_private_key, user_private_key)
     except ValueError as exc:
         raise KeyOperationError(message="User private key could not be loaded!") from exc
 
 
 def obtain_project_private_key(user, project, token):
-    flask.current_app.logger.info(
-        f"- - obtain_project_private_key (before ProjectUserKeys)\t Current time: {utils.current_time()}"
-    )
-
     project_key = models.ProjectUserKeys.query.filter_by(
         project_id=project.id, user_id=user.username
     ).first()
-    flask.current_app.logger.info(
-        f"- - obtain_project_private_key (after ProjectUserKeys)\t Current time: {utils.current_time()}"
-    )
-
-    flask.current_app.logger.info(
-        f"- - obtain_project_private_key (before __decrypt_project_private_key)\t Current time: {utils.current_time()}"
-    )
     if project_key:
         return __decrypt_project_private_key(user, token, project_key.key)
-    flask.current_app.logger.info(
-        f"- - obtain_project_private_key (after __decrypt_project_private_key)\t Current time: {utils.current_time()}"
-    )
-
     raise KeyNotFoundError(project=project.public_id)
 
 
@@ -253,52 +221,22 @@ def __encrypt_owner_private_key(owner, private_key, owner_key=None):
 
 def __decrypt_user_private_key(user, user_key):
     if user.private_key and user.nonce:
-        flask.current_app.logger.info(
-            f"- - - __decrypt_user_private_key (before __decrypt_with_aes)\t Current time: {utils.current_time()}"
-        )
-        decrypted_user_private_key = __decrypt_with_aes(
+        return __decrypt_with_aes(
             user_key,
             user.private_key,
             user.nonce,
             aad=b"private key for " + user.username.encode(),
         )
-        flask.current_app.logger.info(
-            f"- - - __decrypt_user_private_key (after __decrypt_with_aes)\t Current time: {utils.current_time()}"
-        )
-        return decrypted_user_private_key
     raise KeySetupError(message="User keys are not properly setup!")
 
 
 def __decrypt_user_private_key_via_token(user, token):
-    flask.current_app.logger.info(
-        f"- - - - __decrypt_user_private_key_via_token (before extract_encrypted_token_sensitive_content)\t Current time: {utils.current_time()}"
-    )
     password = extract_encrypted_token_sensitive_content(token, user.username)
-    flask.current_app.logger.info(
-        f"- - - - __decrypt_user_private_key_via_token (after extract_encrypted_token_sensitive_content)\t Current time: {utils.current_time()}"
-    )
-
     if not password:
-        flask.current_app.logger.info("There is no password found.")
         raise SensitiveContentMissingError
-
-    flask.current_app.logger.info(
-        f"- - - - __decrypt_user_private_key_via_token (before __derive_key)\t Current time: {utils.current_time()}"
-    )
     user_key = __derive_key(user, password)
-    flask.current_app.logger.info(
-        f"- - - - __decrypt_user_private_key_via_token (after __derive_key)\t Current time: {utils.current_time()}"
-    )
-
-    flask.current_app.logger.info(
-        f"- - - - __decrypt_user_private_key_via_token (before __decrypt_user_private_key)\t Current time: {utils.current_time()}"
-    )
-    decrypted_user_private_key = __decrypt_user_private_key(user, user_key)
-    flask.current_app.logger.info(
-        f"- - - - __decrypt_user_private_key_via_token (after __decrypt_user_private_key)\t Current time: {utils.current_time()}"
-    )
 
-    return decrypted_user_private_key
+    return __decrypt_user_private_key(user, user_key)
 
 
 def __decrypt_invite_private_key(invite, temporary_key):

diff --git a/dds_web/templates/base.html b/dds_web/templates/base.html
@@ -11,7 +11,7 @@
             else request.cookies.get('ddstheme'))) }}"
             rel="stylesheet" id="dds-stylesheet">
         <link rel="shortcut icon" href="{{ url_for('static', filename='img/favicon.png') }}" type="png">
-        <title>{% block page_title %}Data Delivery System - Test version 5{% endblock %}</title>
+        <title>{% block page_title %}Data Delivery System{% endblock %}</title>
     </head>
 
     <body>

diff --git a/dds_web/templates/home.html b/dds_web/templates/home.html
@@ -3,8 +3,7 @@
 
 <div class="row mb-5 pb-3">
     <div class="col-lg-6">
-        <p class="lead" style="justify-content: start;">
-            The Data Delivery System (DDS) is a cloud-based system for the delivery of data from SciLifeLab platforms to their users. It consists of a command line interface (CLI) and a web interface. The web interface will be improved on as soon as possible.</p>
+        <p class="lead" style="justify-content: start;">The Data Delivery System (DDS) is a cloud-based system for the delivery of data from SciLifeLab platforms to their users. It consists of a command line interface (CLI) and a web interface. The web interface will be improved on as soon as possible.</p>
         <br>
         <div class="row">
             <div class="col-xxl-8 offset-xxl-2 bg-light p-3" style="display: flex; flex-direction: column;">