flask_session_azure_c 0.4.6__tar.gz

flask_session_azure_c-0.4.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Claas Diederichs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flask_session_azure_c-0.4.6/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: flask_session_azure_c
+Version: 0.4.6
+Summary: Flask Session using Azure Table Storage or CosmosDB table API
+Home-page: https://github.com/bassmandan/FlaskAzureTableSession
+Author: Claas Diederichs, Daniel Harding
+Author-email: 
+License: MIT
+Classifier: Framework :: Flask
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: azure-data-tables
+Requires-Dist: pycryptodomex>=3.9.7
+Requires-Dist: flask
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Flask Session using Azure table storage (Using Azure-Data-Tables Library)
+
+
+[![PyPI - License](https://img.shields.io/pypi/l/flask-session-azure)](https://pypi.org/project/flask-session-azure/)
+[![PyPI](https://img.shields.io/pypi/v/flask-session-azure)](https://pypi.org/project/flask-session-azure/)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/flask-session-azure)
+
+This module can be used as a Flask Session handler for Azure table storage or Azure CosmosDB.
+All stored data is encrypted using AES encryption.
+
+Example usage:
+
+```python
+import flask
+from flask_session_azure import storage_account_interface
+
+app = flask.Flask(__name__)
+app.secret_key = "MyVerySecretEnryptionKeyForEverything" # must be at least 16 characters, the longer the better
+connection_string = "DefaultEndpointsProtocol=https;AccountName=someAccount;AccountKey=someKey;EndpointSuffix=core.windows.net"
+app.session_interface = storage_account_interface(connection_string)
+```
+
+This will store the session data in a table called `flasksession`, with a partition key called `default_session`. IF the table does not yet exists, it will be created the first time a session is stored.
+You can overwrite these default when creating the session interface:
+```python
+app.session_interface = storage_account_interface(connection_string, table_name="mytablename", partition_key="app1", create_table_if_not_exists=False)
+```
+
+If you use this in Azure Function, or Azure Web-Service, you most certainly already have a storage account connection in your environment variable `AzureWebJobsStorage`:
+```python
+import os
+import flask
+from flask_session_azure import storage_account_interface
+
+app = flask.Flask(__name__)
+app.secret_key = "MyVerySecretEnryptionKeyForEverything" # must be at least 16 characters, the longer the better
+connection_string = os.environ.get("AzureWebjobsStorage")
+app.session_interface = storage_account_interface(connection_string)
+```
+
+## Changelog
+
+### 0.4.5
+- Edited functions to use updated Azure-Core library instead of deprecated Azure-Common. Updated flask elements to use newer app.config format.
+
+### 0.4.4
+- Edited functions to use the Azure-Data-Tables library that is actively maintained by Microsoft
+
+### 0.4.3
+- Fixed issue with secret key length and secret key containing non-asci characters
+
+### 0.4.2
+- Fixed issue if "samesite" cookie value was not set (i.e. set to none). If it is not set, it is now set to Lax to work in an azure function (see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite)
+
+### 0.4.1
+- First public release

flask_session_azure_c-0.4.6/README.md

@@ -0,0 +1,56 @@
+# Flask Session using Azure table storage (Using Azure-Data-Tables Library)
+
+
+[![PyPI - License](https://img.shields.io/pypi/l/flask-session-azure)](https://pypi.org/project/flask-session-azure/)
+[![PyPI](https://img.shields.io/pypi/v/flask-session-azure)](https://pypi.org/project/flask-session-azure/)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/flask-session-azure)
+
+This module can be used as a Flask Session handler for Azure table storage or Azure CosmosDB.
+All stored data is encrypted using AES encryption.
+
+Example usage:
+
+```python
+import flask
+from flask_session_azure import storage_account_interface
+
+app = flask.Flask(__name__)
+app.secret_key = "MyVerySecretEnryptionKeyForEverything" # must be at least 16 characters, the longer the better
+connection_string = "DefaultEndpointsProtocol=https;AccountName=someAccount;AccountKey=someKey;EndpointSuffix=core.windows.net"
+app.session_interface = storage_account_interface(connection_string)
+```
+
+This will store the session data in a table called `flasksession`, with a partition key called `default_session`. IF the table does not yet exists, it will be created the first time a session is stored.
+You can overwrite these default when creating the session interface:
+```python
+app.session_interface = storage_account_interface(connection_string, table_name="mytablename", partition_key="app1", create_table_if_not_exists=False)
+```
+
+If you use this in Azure Function, or Azure Web-Service, you most certainly already have a storage account connection in your environment variable `AzureWebJobsStorage`:
+```python
+import os
+import flask
+from flask_session_azure import storage_account_interface
+
+app = flask.Flask(__name__)
+app.secret_key = "MyVerySecretEnryptionKeyForEverything" # must be at least 16 characters, the longer the better
+connection_string = os.environ.get("AzureWebjobsStorage")
+app.session_interface = storage_account_interface(connection_string)
+```
+
+## Changelog
+
+### 0.4.5
+- Edited functions to use updated Azure-Core library instead of deprecated Azure-Common. Updated flask elements to use newer app.config format.
+
+### 0.4.4
+- Edited functions to use the Azure-Data-Tables library that is actively maintained by Microsoft
+
+### 0.4.3
+- Fixed issue with secret key length and secret key containing non-asci characters
+
+### 0.4.2
+- Fixed issue if "samesite" cookie value was not set (i.e. set to none). If it is not set, it is now set to Lax to work in an azure function (see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite)
+
+### 0.4.1
+- First public release

flask_session_azure_c-0.4.6/flask_session_azure/__init__.py

@@ -0,0 +1,15 @@
+def storage_account_interface(connection_str: str, table_name: str = "flasksession",
+                              partition_key: str = "default_session", create_table_if_not_exists: bool = True):
+    """
+    Creates a Session object as replacement for the default flask session
+    The Session uses Azure storage accounts or Azure cosmosDB with Table API as backend
+    :param connection_str: Connection string to storage account or CosmosDb with Table-API
+    :param table_name: the table name. Default is "flasksession". When overwriting this, follow the table name rules
+        https://docs.microsoft.com/en-us/rest/api/storageservices/Understanding-the-Table-Service-Data-Model#table-names
+    :param partition_key: the partition key within the table. Use a unique partition_key if applications share a table
+    :param create_table_if_not_exists: set to False if you do not want this application to create a table for you
+    :return: a Flask session manager
+    """
+    from flask_session_azure.storage_account_session import StorageAccountSessionInterface
+    return StorageAccountSessionInterface(connection_str, table_name=table_name, partition_key=partition_key,
+                                          create_table_if_not_exists=create_table_if_not_exists)

flask_session_azure_c-0.4.6/flask_session_azure/storage_account.py

@@ -0,0 +1,95 @@
+import base64
+from typing import Dict, List, Union, Tuple
+
+from Cryptodome.Cipher import AES
+from azure.core.exceptions import ResourceNotFoundError
+from flask.json.tag import TaggedJSONSerializer
+from azure.data.tables import TableClient
+
+class StorageAccount(object):
+    json_serializer = TaggedJSONSerializer()
+
+    def __init__(self, connection_str: str, table_name: str, partition_key: str, create_table_if_not_exists: bool):
+        self.table_name = table_name
+        self.partition_key = partition_key
+        self.create_table_if_not_exists = create_table_if_not_exists
+        self.table_service = TableClient.from_connection_string(conn_str=connection_str, table_name=self.table_name)
+
+    def write(self, key: str, data: dict, encryption_key: bytes) -> None:
+        """
+        serializes and encrypts the passed dict object object and writes it to the storage
+        """
+
+        data = self.json_serializer.dumps(data)
+        encoded_data, tag, nonce = self.encrypt(data, encryption_key)
+        entity = {
+            "PartitionKey": self.partition_key,
+            "RowKey": key,
+            "Data": encoded_data,
+            "Tag": tag,
+            "Nonce": nonce
+        }
+        try:
+            self.table_service.upsert_entity(entity=entity)
+        except ResourceNotFoundError:
+            if not self.create_table_if_not_exists:
+                raise
+            self.table_service.create_table()
+            self.table_service.upsert_entity(entity=entity)
+
+    def read(self, key: str, app_key: bytes) -> Union[List[Dict], None]:
+        """
+        reads encrypted data from storage and decrypts and deserializes it.
+        Returns None if no data was found or decryption failed.
+        """
+        try:
+            data = self.table_service.get_entity(self.partition_key, key)
+            decoded = self.decrypt(data["Data"], data["Tag"], data["Nonce"], app_key)
+            if decoded is not None:
+                return self.json_serializer.loads(decoded)
+            return None
+        except ResourceNotFoundError:
+            return None
+
+    def delete(self, key: str) -> None:
+        """
+        Removes an element from storage if it exists
+        """
+        try:
+            self.table_service.delete_entity(self.partition_key, key)
+        except ResourceNotFoundError:
+            pass
+
+    @staticmethod
+    def encrypt(data: str, secret_text: bytes) -> Tuple[str, str, str]:
+        """
+        encrypts the passed data with the secret text.
+        :return: a tuple of three elements: encrypted data, verification_tag and nonce element.
+        All elements are base64 encoded strings
+        """
+        cipher = AES.new(secret_text, AES.MODE_EAX)
+        ciphertext, tag = cipher.encrypt_and_digest((data.encode("utf-8")))
+        return (base64.b64encode(ciphertext).decode("ascii"),
+                base64.b64encode(tag).decode("ascii"),
+                base64.b64encode(cipher.nonce).decode("ascii"))
+
+    @staticmethod
+    def decrypt(encrypted_data: str, verification_tag: str, nonce: str, secret_text: bytes) -> Union[str, None]:
+        """
+        Decrypts encoded data using the passed secret_text
+        :param encrypted_data:  as base64 encoded string or byte array
+        :param verification_tag: as base64 encoded string or byte array
+        :param nonce: as base64 encoded string or byte array
+        :param secret_text: the same secret text with wich the element was encoded
+        :return: the plaintext on success, None if the data could not be decoded or verified
+        """
+        nonce = base64.b64decode(nonce)
+        cipher = AES.new(secret_text, AES.MODE_EAX, nonce=nonce)
+        data = base64.b64decode(encrypted_data)
+        plaintext = cipher.decrypt(data)
+        tag = base64.b64decode(verification_tag)
+        try:
+            cipher.verify(tag)
+            return plaintext.decode("utf-8")
+        except ValueError:
+            return None

flask_session_azure_c-0.4.6/flask_session_azure/storage_account_session.py

@@ -0,0 +1,102 @@
+from uuid import uuid4
+
+import flask
+from flask.sessions import SessionMixin, SessionInterface
+from werkzeug.datastructures import CallbackDict
+
+from flask_session_azure.storage_account import StorageAccount
+
+
+class StorageAccountSession(CallbackDict, SessionMixin):
+    def __init__(self, sid: str, initial=None):
+        def on_update(self):
+            self.modified = True
+
+        CallbackDict.__init__(self, initial, on_update)
+        self.sid = sid
+        self.modified = False
+
+
+class StorageAccountSessionInterface(SessionInterface):
+    """
+    Replacement session interface for flask that uses Azure-Storage account tables as storage backend
+    Data is encrypted and tagged for manipulation using AES encryption
+    """
+    session_class = StorageAccountSession
+
+    def __init__(self, connection_str: str, table_name="flasksession", partition_key="default_session",
+                 create_table_if_not_exists: bool = True):
+        """
+        :param connection_str: the connection string to the azure table storage (or cosmos db)
+        :param table_name: the table name. Default is "flasksession". When overwriting this, follow the table name rules
+        https://docs.microsoft.com/en-us/rest/api/storageservices/Understanding-the-Table-Service-Data-Model#table-names
+        :param partition_key: the partition key within the table. Use a unique partition_key if applications share a table
+        """
+        self.storage = StorageAccount(connection_str, table_name, partition_key, create_table_if_not_exists)
+
+    @staticmethod
+    def get_encryption_key_from_app_secret(app) -> bytes:
+        """
+        Checks if the app secret_key is set, and if it is long enough to use it as AES encryption key.
+        Returns the key truncated to a length of multiples of 8, to use it as AES encryption key
+        """
+        if app.secret_key is None:
+            raise RuntimeError(
+                "The session is unavailable because no secret key was set. "
+                "Set the secret_key on the application to something unique and secret.")
+        try:
+            # if secret_text is a string, make it bytes
+            secret_key = app.secret_key.encode("utf-8")
+        except AttributeError:
+            secret_key = app.secret_key
+
+        if len(secret_key) < 16:
+            raise RuntimeError(
+                "The session is unavailable because the secret is too short. "
+                f"The secret must be 16 characters or longer, but is only {len(app.secret_key)} character(s).")
+
+        # only use multiples of 8 from the secret_key tu use it as AES encryption_key
+        characters = len(app.secret_key)
+        characters = min(32, characters - characters % 8)
+        return secret_key[:characters]
+
+    def open_session(self, app: flask.Flask, request: flask.Request) -> StorageAccountSession:
+        """
+        Reads the session data from table storage, decrypts the data and returns the session object
+        """
+        sid = request.cookies.get(app.config["SESSION_COOKIE_NAME"])
+        if not sid:
+            sid = str(uuid4())
+            return self.session_class(sid=sid)
+        encryption_key = self.get_encryption_key_from_app_secret(app)
+        data = self.storage.read(sid, encryption_key)
+        if data is not None:
+            return self.session_class(sid=sid, initial=data)
+        return self.session_class(sid=sid)
+
+    def save_session(self, app: flask.Flask, session: StorageAccountSession, response: flask.Response) -> None:
+        """
+        Serializes the data to JSON, encrypts the data using AES
+        and stores the encrypted data along with a verification tag to azure storage.
+        Only stores the UUID of the table entry inside the session_cookie
+        """
+
+        domain = self.get_cookie_domain(app)
+        path = self.get_cookie_path(app)
+        if not session:
+            if session.modified:
+                self.storage.delete(session.sid)
+            response.delete_cookie(app.config["SESSION_COOKIE_NAME"], domain=domain, path=path)
+            return
+
+        if session.modified:
+            encryption_key = self.get_encryption_key_from_app_secret(app)
+            self.storage.write(session.sid, dict(session), encryption_key)
+        httponly = True
+        secure = self.get_cookie_secure(app)
+        samesite = self.get_cookie_samesite(app)
+        if samesite is None:
+            samesite = 'Lax'
+        expires = self.get_expiration_time(app, session)
+        response.set_cookie(app.config["SESSION_COOKIE_NAME"], session.sid, expires=expires, httponly=httponly, domain=domain,
+                            path=path, secure=secure, samesite=samesite)

flask_session_azure_c-0.4.6/flask_session_azure_c.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: flask_session_azure_c
+Version: 0.4.6
+Summary: Flask Session using Azure Table Storage or CosmosDB table API
+Home-page: https://github.com/bassmandan/FlaskAzureTableSession
+Author: Claas Diederichs, Daniel Harding
+Author-email: 
+License: MIT
+Classifier: Framework :: Flask
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: azure-data-tables
+Requires-Dist: pycryptodomex>=3.9.7
+Requires-Dist: flask
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Flask Session using Azure table storage (Using Azure-Data-Tables Library)
+
+
+[![PyPI - License](https://img.shields.io/pypi/l/flask-session-azure)](https://pypi.org/project/flask-session-azure/)
+[![PyPI](https://img.shields.io/pypi/v/flask-session-azure)](https://pypi.org/project/flask-session-azure/)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/flask-session-azure)
+
+This module can be used as a Flask Session handler for Azure table storage or Azure CosmosDB.
+All stored data is encrypted using AES encryption.
+
+Example usage:
+
+```python
+import flask
+from flask_session_azure import storage_account_interface
+
+app = flask.Flask(__name__)
+app.secret_key = "MyVerySecretEnryptionKeyForEverything" # must be at least 16 characters, the longer the better
+connection_string = "DefaultEndpointsProtocol=https;AccountName=someAccount;AccountKey=someKey;EndpointSuffix=core.windows.net"
+app.session_interface = storage_account_interface(connection_string)
+```
+
+This will store the session data in a table called `flasksession`, with a partition key called `default_session`. IF the table does not yet exists, it will be created the first time a session is stored.
+You can overwrite these default when creating the session interface:
+```python
+app.session_interface = storage_account_interface(connection_string, table_name="mytablename", partition_key="app1", create_table_if_not_exists=False)
+```
+
+If you use this in Azure Function, or Azure Web-Service, you most certainly already have a storage account connection in your environment variable `AzureWebJobsStorage`:
+```python
+import os
+import flask
+from flask_session_azure import storage_account_interface
+
+app = flask.Flask(__name__)
+app.secret_key = "MyVerySecretEnryptionKeyForEverything" # must be at least 16 characters, the longer the better
+connection_string = os.environ.get("AzureWebjobsStorage")
+app.session_interface = storage_account_interface(connection_string)
+```
+
+## Changelog
+
+### 0.4.5
+- Edited functions to use updated Azure-Core library instead of deprecated Azure-Common. Updated flask elements to use newer app.config format.
+
+### 0.4.4
+- Edited functions to use the Azure-Data-Tables library that is actively maintained by Microsoft
+
+### 0.4.3
+- Fixed issue with secret key length and secret key containing non-asci characters
+
+### 0.4.2
+- Fixed issue if "samesite" cookie value was not set (i.e. set to none). If it is not set, it is now set to Lax to work in an azure function (see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite)
+
+### 0.4.1
+- First public release

flask_session_azure_c-0.4.6/flask_session_azure_c.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+setup.py
+flask_session_azure/__init__.py
+flask_session_azure/storage_account.py
+flask_session_azure/storage_account_session.py
+flask_session_azure_c.egg-info/PKG-INFO
+flask_session_azure_c.egg-info/SOURCES.txt
+flask_session_azure_c.egg-info/dependency_links.txt
+flask_session_azure_c.egg-info/requires.txt
+flask_session_azure_c.egg-info/top_level.txt

flask_session_azure_c-0.4.6/flask_session_azure_c.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

flask_session_azure_c-0.4.6/flask_session_azure_c.egg-info/requires.txt

@@ -0,0 +1,3 @@
+azure-data-tables
+pycryptodomex>=3.9.7
+flask

flask_session_azure_c-0.4.6/flask_session_azure_c.egg-info/top_level.txt

@@ -0,0 +1 @@
+flask_session_azure

flask_session_azure_c-0.4.6/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

flask_session_azure_c-0.4.6/setup.py

@@ -0,0 +1,32 @@
+from setuptools import setup
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setup(
+    name='flask_session_azure_c',
+    version='0.4.6',
+    packages=['flask_session_azure'],
+    url='https://github.com/bassmandan/FlaskAzureTableSession',
+    license='MIT',
+    author='Claas Diederichs, Daniel Harding',
+    author_email='',
+    description='Flask Session using Azure Table Storage or CosmosDB table API',
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    classifiers=[
+        "Framework :: Flask",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires='>=3.6',
+    install_requires=[
+        "azure-data-tables",
+        "pycryptodomex>=3.9.7",
+        "flask"
+    ]
+)