wcpan-drive-crypt 3.1.0__tar.gz

wcpan_drive_crypt-3.1.0/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Wei-Cheng Pan<legnaleurc@gmail.com>
+
+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.

wcpan_drive_crypt-3.1.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.1
+Name: wcpan-drive-crypt
+Version: 3.1.0
+Summary: crypt middleware for wcpan.drive
+License: MIT
+Author: Wei-Cheng Pan
+Author-email: legnaleurc@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: numpy (>=1.18.0,<2.0.0)
+Requires-Dist: wcpan.drive.core (>=3.0.0,<4.0.0)
+Description-Content-Type: text/markdown
+
+# wcpan.drive.crypt
+
+Crypt middleware for `wcpan.drive`.
+
+Please use `wcpan.drive.crypt.middleware.CryptMiddleware` as the middleware
+class.
+

wcpan_drive_crypt-3.1.0/README.md

@@ -0,0 +1,6 @@
+# wcpan.drive.crypt
+
+Crypt middleware for `wcpan.drive`.
+
+Please use `wcpan.drive.crypt.middleware.CryptMiddleware` as the middleware
+class.

wcpan_drive_crypt-3.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[tool.poetry]
+name = "wcpan.drive.crypt"
+version = "3.1.0"
+description = "crypt middleware for wcpan.drive"
+authors = ["Wei-Cheng Pan <legnaleurc@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+packages = [{include = "wcpan"}]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+numpy = "^1.18.0"
+"wcpan.drive.core" = "^3.0.0"
+
+[tool.poetry.group.dev.dependencies]
+black = "^23.1.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

wcpan_drive_crypt-3.1.0/wcpan/drive/crypt/__init__.py

@@ -0,0 +1,4 @@
+from importlib.metadata import version
+
+
+__version__ = version(__package__ or __name__)

wcpan_drive_crypt-3.1.0/wcpan/drive/crypt/middleware.py

@@ -0,0 +1,212 @@
+from typing import AsyncGenerator
+import contextlib
+
+from wcpan.drive.core.types import (
+    ChangeDict,
+    MediaInfo,
+    Node,
+    PrivateDict,
+    ReadOnlyContext,
+)
+from wcpan.drive.core.abc import (
+    ReadableFile,
+    WritableFile,
+    Middleware,
+    Hasher,
+    RemoteDriver,
+)
+from wcpan.drive.core.exceptions import NodeConflictedError
+
+from .util import (
+    DecryptReadableFile,
+    EncryptHasher,
+    EncryptWritableFile,
+    InvalidCryptVersion,
+    decrypt_name,
+    encrypt_name,
+)
+
+
+class CryptMiddleware(Middleware):
+    @classmethod
+    def get_version_range(cls):
+        return (3, 3)
+
+    def __init__(self, context: ReadOnlyContext, driver: RemoteDriver):
+        self._context = context
+        self._driver = driver
+        self._raii = None
+
+    async def __aenter__(self) -> Middleware:
+        async with contextlib.AsyncExitStack() as stack:
+            self._driver = await stack.enter_async_context(self._driver)
+            self._raii = stack.pop_all()
+        return self
+
+    async def __aexit__(self, et, ev, tb) -> bool:
+        await self._raii.aclose()
+        self._raii = None
+
+    @property
+    def remote(self):
+        return self._driver
+
+    async def get_initial_check_point(self) -> str:
+        return await self._driver.get_initial_check_point()
+
+    async def fetch_root_node(self) -> Node:
+        return await self._driver.fetch_root_node()
+
+    async def trash_node(self, node: Node) -> None:
+        return await self._driver.trash_node(node)
+
+    async def fetch_changes(
+        self,
+        check_point: str,
+    ) -> AsyncGenerator[tuple[str, list[ChangeDict]], None]:
+        async for check_point, changes in self._driver.fetch_changes(check_point):
+            decoded = [decode_change(change) for change in changes]
+            yield check_point, decoded
+
+    async def rename_node(
+        self,
+        node: Node,
+        *,
+        new_parent: Node | None,
+        new_name: str | None,
+    ) -> Node:
+        private = node.private
+        if not private or "crypt" not in private:
+            return await self._driver.rename_node(
+                node,
+                new_parent=new_parent,
+                new_name=new_name,
+            )
+        if private["crypt"] != "1":
+            raise InvalidCryptVersion()
+
+        if node.name is not None:
+            name = encrypt_name(node.name)
+            node = node.clone(name=name)
+        if new_name is not None:
+            new_name = encrypt_name(new_name)
+
+        try:
+            return await self._driver.rename_node(
+                node,
+                new_parent=new_parent,
+                new_name=new_name,
+            )
+        except NodeConflictedError as e:
+            name = decrypt_name(e.node.name)
+            node = e.node.clone(name=name)
+            raise NodeConflictedError(node) from e
+
+    async def download(self, node: Node) -> ReadableFile:
+        private = node.private
+        if not private:
+            return await self._driver.download(node)
+        if "crypt" not in private:
+            return await self._driver.download(node)
+        if private["crypt"] != "1":
+            raise InvalidCryptVersion()
+
+        readable = await self._driver.download(node)
+        return DecryptReadableFile(readable)
+
+    async def upload(
+        self,
+        parent_node: Node,
+        file_name: str,
+        *,
+        file_size: int | None,
+        mime_type: str | None,
+        media_info: MediaInfo | None,
+        private: PrivateDict | None,
+    ) -> WritableFile:
+        if private is None:
+            private = {}
+        if "crypt" not in private:
+            private["crypt"] = "1"
+        if private["crypt"] != "1":
+            raise InvalidCryptVersion()
+
+        file_name = encrypt_name(file_name)
+
+        try:
+            writable = await self._driver.upload(
+                parent_node,
+                file_name,
+                file_size=file_size,
+                mime_type=mime_type,
+                media_info=media_info,
+                private=private,
+            )
+            return EncryptWritableFile(writable)
+        except NodeConflictedError as e:
+            name = decrypt_name(e.node.name)
+            node = e.node.clone(name=name)
+            raise NodeConflictedError(node) from e
+
+    async def create_folder(
+        self,
+        parent_node: Node,
+        folder_name: str,
+        *,
+        exist_ok: bool,
+        private: PrivateDict | None,
+    ) -> Node:
+        if private is None:
+            private = {}
+        if "crypt" not in private:
+            private["crypt"] = "1"
+        if private["crypt"] != "1":
+            raise InvalidCryptVersion()
+
+        folder_name = encrypt_name(folder_name)
+
+        try:
+            return await self._driver.create_folder(
+                parent_node=parent_node,
+                folder_name=folder_name,
+                exist_ok=exist_ok,
+                private=private,
+            )
+        except NodeConflictedError as e:
+            name = decrypt_name(e.node.name)
+            node = e.node.clone(name=name)
+            raise NodeConflictedError(node) from e
+
+    async def get_hasher(self) -> Hasher:
+        hasher = await self._driver.get_hasher()
+        return EncryptHasher(hasher)
+
+    async def is_authorized(self) -> bool:
+        return await self._driver.is_authorized()
+
+    async def get_oauth_url(self) -> str:
+        return await self._driver.get_oauth_url()
+
+    async def set_oauth_token(self, token: str) -> None:
+        return await self._driver.set_oauth_token(token)
+
+
+def decode_change(change: ChangeDict) -> ChangeDict:
+    if change["removed"]:
+        return change
+
+    dict_ = change["node"]
+    if dict_["name"] is None:
+        return change
+
+    private = dict_.get("private", None)
+    if not private:
+        return change
+    if "crypt" not in private:
+        return change
+    if private["crypt"] != "1":
+        raise InvalidCryptVersion()
+
+    name = decrypt_name(dict_["name"])
+    dict_["name"] = name
+    return change

wcpan_drive_crypt-3.1.0/wcpan/drive/crypt/util.py

@@ -0,0 +1,113 @@
+from typing import AsyncIterator
+import contextlib
+
+import numpy
+
+from wcpan.drive.core.types import Node
+from wcpan.drive.core.abc import ReadableFile, WritableFile, Hasher
+from wcpan.drive.core.exceptions import DriveError
+
+
+class InvalidCryptVersion(DriveError):
+    pass
+
+
+class DecryptReadableFile(ReadableFile):
+    def __init__(self, stream: ReadableFile) -> None:
+        self._stream = stream
+        self._raii = None
+
+    async def __aenter__(self) -> ReadableFile:
+        async with contextlib.AsyncExitStack() as stack:
+            await stack.enter_async_context(self._stream)
+            self._raii = stack.pop_all()
+        return self
+
+    async def __aexit__(self, et, e, tb) -> bool:
+        await self._raii.aclose()
+        self._raii = None
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        async for chunk in self._stream:
+            yield decrypt(chunk)
+
+    async def read(self, length: int) -> bytes:
+        chunk = await self._stream.read(length)
+        return decrypt(chunk)
+
+    async def seek(self, offset: int) -> None:
+        await self._stream.seek(offset)
+
+    async def node(self) -> Node:
+        return await self._stream.node()
+
+
+class EncryptWritableFile(WritableFile):
+    def __init__(self, stream: WritableFile) -> None:
+        self._stream = stream
+        self._raii = None
+
+    async def __aenter__(self) -> WritableFile:
+        async with contextlib.AsyncExitStack() as stack:
+            await stack.enter_async_context(self._stream)
+            self._raii = stack.pop_all()
+        return self
+
+    async def __aexit__(self, et, ev, tb) -> bool:
+        await self._raii.aclose()
+        self._raii = None
+
+    async def tell(self) -> int:
+        return await self._stream.tell()
+
+    async def seek(self, offset: int) -> None:
+        await self._stream.seek(offset)
+
+    async def write(self, chunk: bytes) -> int:
+        crypted = encrypt(chunk)
+        return await self._stream.write(crypted)
+
+    async def node(self) -> Node:
+        return await self._stream.node()
+
+
+class EncryptHasher(Hasher):
+    def __init__(self, hasher: Hasher) -> None:
+        self._hasher = hasher
+
+    def update(self, data: bytes) -> None:
+        self._hasher.update(encrypt(data))
+
+    def digest(self) -> bytes:
+        return self._hasher.digest()
+
+    def hexdigest(self) -> str:
+        return self._hasher.hexdigest()
+
+    def copy(self) -> Hasher:
+        return EncryptHasher(self._hasher.copy())
+
+
+def encrypt(chunk: bytes) -> bytes:
+    buffer = numpy.frombuffer(chunk, dtype=numpy.uint8)
+    buffer = numpy.bitwise_not(buffer)
+    return buffer.tobytes()
+
+
+def decrypt(chunk: bytes) -> bytes:
+    buffer = numpy.frombuffer(chunk, dtype=numpy.uint8)
+    buffer = numpy.bitwise_not(buffer)
+    return buffer.tobytes()
+
+
+def encrypt_name(name: str) -> str:
+    bname = name.encode("utf-8")
+    bname = encrypt(bname)
+    return "".join(("%02x" % c for c in bname))
+
+
+def decrypt_name(name: str) -> str:
+    hex_list = (name[i : i + 2] for i in range(0, len(name), 2))
+    bname = bytes((int(c, 16) for c in hex_list))
+    bname = decrypt(bname)
+    return bname.decode("utf-8")