dynamic-image-encryption 0.1.0__tar.gz

dynamic_image_encryption-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Safouane Akrimi
+
+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.

dynamic_image_encryption-0.1.0/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: dynamic-image-encryption
+Version: 0.1.0
+Summary: Research-oriented dynamic byte-level image and NIfTI encryption library.
+Author-email: Safouane Akrimi <safouaneakrimi@gmail.com>
+License: MIT
+Keywords: image encryption,cryptography,NIfTI,medical imaging,security
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: image
+Requires-Dist: numpy>=1.24; extra == "image"
+Requires-Dist: Pillow>=10.0; extra == "image"
+Provides-Extra: nifti
+Requires-Dist: numpy>=1.24; extra == "nifti"
+Requires-Dist: nibabel>=5.0; extra == "nifti"
+Provides-Extra: all
+Requires-Dist: numpy>=1.24; extra == "all"
+Requires-Dist: Pillow>=10.0; extra == "all"
+Requires-Dist: nibabel>=5.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# Dynamic Image Encryption
+
+Research-oriented Python implementation of a dynamic byte-level encryption
+algorithm using modular addition, modular subtraction, XOR and circular
+8-bit rotation.
+
+For each byte:
+
+```text
+S_i = K_i mod 4
+```
+
+Then:
+
+```text
+S=0 -> C=(P+K) mod 256
+S=1 -> C=(P-K) mod 256
+S=2 -> C=P XOR K
+S=3 -> C=ROL(P,K mod 8)
+```
+
+Decryption applies the corresponding inverse operation.
+
+## Security note
+
+This package is intended for research, experimentation and academic
+evaluation. It is not a replacement for established authenticated
+encryption schemes such as AES-GCM. No authentication/integrity mechanism
+is provided, and the key has the same length as the encrypted byte sequence.
+
+## Install
+
+```bash
+pip install "dynamic-image-encryption[all]"
+```
+
+## Byte API
+
+```python
+from image_encryption import encrypt, decrypt
+
+ciphertext, key = encrypt(b"Hello")
+plaintext = decrypt(ciphertext, key)
+
+assert plaintext == b"Hello"
+```
+
+## Image API
+
+```python
+from image_encryption import encrypt_image, decrypt_image, save_key
+
+key = encrypt_image("input.png", "encrypted.ienc")
+save_key(key, "image.key")
+decrypt_image("encrypted.ienc", key, "decrypted.png")
+```
+
+The image API works on decoded pixel bytes. Native Pillow modes are L, RGB
+and RGBA; other modes are converted to RGB. The decrypted conventional image
+is written as PNG.
+
+## NIfTI API
+
+NIfTI voxel values are not reduced modulo 256. The raw bytes representing
+each voxel are encrypted. Thus an int16 voxel such as 7899 is encrypted as
+its two dtype/endianness-dependent bytes.
+
+```python
+from image_encryption import encrypt_nifti, decrypt_nifti, save_key
+
+key = encrypt_nifti("brain.nii.gz", "brain.ienc")
+save_key(key, "brain.key")
+decrypt_nifti("brain.ienc", key, "brain.decrypted.nii.gz")
+```
+
+The implementation stores the raw voxel dtype/shape, affine, NIfTI header,
+extensions and scaling information needed for reconstruction.
+
+## Tests
+
+```bash
+pip install -e ".[all,dev]"
+pytest -q
+```
+
+## Build
+
+Change the PyPI `name` in `pyproject.toml` if the chosen name is already
+registered.
+
+```bash
+python -m build
+python -m twine check dist/*
+python -m twine upload --repository testpypi dist/*
+python -m twine upload dist/*
+```
+
+## Structure
+
+```text
+image-encryption/
+├── pyproject.toml
+├── README.md
+├── LICENSE
+├── .gitignore
+├── src/image_encryption/
+│   ├── __init__.py
+│   ├── core.py
+│   ├── key.py
+│   ├── operations.py
+│   ├── container.py
+│   ├── image.py
+│   ├── nifti.py
+│   └── exceptions.py
+├── tests/
+└── examples/
+```
+
+## License
+
+MIT.

dynamic_image_encryption-0.1.0/README.md

@@ -0,0 +1,121 @@
+# Dynamic Image Encryption
+
+Research-oriented Python implementation of a dynamic byte-level encryption
+algorithm using modular addition, modular subtraction, XOR and circular
+8-bit rotation.
+
+For each byte:
+
+```text
+S_i = K_i mod 4
+```
+
+Then:
+
+```text
+S=0 -> C=(P+K) mod 256
+S=1 -> C=(P-K) mod 256
+S=2 -> C=P XOR K
+S=3 -> C=ROL(P,K mod 8)
+```
+
+Decryption applies the corresponding inverse operation.
+
+## Security note
+
+This package is intended for research, experimentation and academic
+evaluation. It is not a replacement for established authenticated
+encryption schemes such as AES-GCM. No authentication/integrity mechanism
+is provided, and the key has the same length as the encrypted byte sequence.
+
+## Install
+
+```bash
+pip install "dynamic-image-encryption[all]"
+```
+
+## Byte API
+
+```python
+from image_encryption import encrypt, decrypt
+
+ciphertext, key = encrypt(b"Hello")
+plaintext = decrypt(ciphertext, key)
+
+assert plaintext == b"Hello"
+```
+
+## Image API
+
+```python
+from image_encryption import encrypt_image, decrypt_image, save_key
+
+key = encrypt_image("input.png", "encrypted.ienc")
+save_key(key, "image.key")
+decrypt_image("encrypted.ienc", key, "decrypted.png")
+```
+
+The image API works on decoded pixel bytes. Native Pillow modes are L, RGB
+and RGBA; other modes are converted to RGB. The decrypted conventional image
+is written as PNG.
+
+## NIfTI API
+
+NIfTI voxel values are not reduced modulo 256. The raw bytes representing
+each voxel are encrypted. Thus an int16 voxel such as 7899 is encrypted as
+its two dtype/endianness-dependent bytes.
+
+```python
+from image_encryption import encrypt_nifti, decrypt_nifti, save_key
+
+key = encrypt_nifti("brain.nii.gz", "brain.ienc")
+save_key(key, "brain.key")
+decrypt_nifti("brain.ienc", key, "brain.decrypted.nii.gz")
+```
+
+The implementation stores the raw voxel dtype/shape, affine, NIfTI header,
+extensions and scaling information needed for reconstruction.
+
+## Tests
+
+```bash
+pip install -e ".[all,dev]"
+pytest -q
+```
+
+## Build
+
+Change the PyPI `name` in `pyproject.toml` if the chosen name is already
+registered.
+
+```bash
+python -m build
+python -m twine check dist/*
+python -m twine upload --repository testpypi dist/*
+python -m twine upload dist/*
+```
+
+## Structure
+
+```text
+image-encryption/
+├── pyproject.toml
+├── README.md
+├── LICENSE
+├── .gitignore
+├── src/image_encryption/
+│   ├── __init__.py
+│   ├── core.py
+│   ├── key.py
+│   ├── operations.py
+│   ├── container.py
+│   ├── image.py
+│   ├── nifti.py
+│   └── exceptions.py
+├── tests/
+└── examples/
+```
+
+## License
+
+MIT.

dynamic_image_encryption-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dynamic-image-encryption"
+version = "0.1.0"
+description = "Research-oriented dynamic byte-level image and NIfTI encryption library."
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [{name = "Safouane Akrimi", email="safouaneakrimi@gmail.com" }]
+keywords = ["image encryption", "cryptography", "NIfTI", "medical imaging", "security"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = []
+
+[project.optional-dependencies]
+image = ["numpy>=1.24", "Pillow>=10.0"]
+nifti = ["numpy>=1.24", "nibabel>=5.0"]
+all = ["numpy>=1.24", "Pillow>=10.0", "nibabel>=5.0"]
+dev = ["pytest>=8.0", "build>=1.2", "twine>=5.0"]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

dynamic_image_encryption-0.1.0/setup.cfg

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

dynamic_image_encryption-0.1.0/src/dynamic_image_encryption.egg-info/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: dynamic-image-encryption
+Version: 0.1.0
+Summary: Research-oriented dynamic byte-level image and NIfTI encryption library.
+Author-email: Safouane Akrimi <safouaneakrimi@gmail.com>
+License: MIT
+Keywords: image encryption,cryptography,NIfTI,medical imaging,security
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: image
+Requires-Dist: numpy>=1.24; extra == "image"
+Requires-Dist: Pillow>=10.0; extra == "image"
+Provides-Extra: nifti
+Requires-Dist: numpy>=1.24; extra == "nifti"
+Requires-Dist: nibabel>=5.0; extra == "nifti"
+Provides-Extra: all
+Requires-Dist: numpy>=1.24; extra == "all"
+Requires-Dist: Pillow>=10.0; extra == "all"
+Requires-Dist: nibabel>=5.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# Dynamic Image Encryption
+
+Research-oriented Python implementation of a dynamic byte-level encryption
+algorithm using modular addition, modular subtraction, XOR and circular
+8-bit rotation.
+
+For each byte:
+
+```text
+S_i = K_i mod 4
+```
+
+Then:
+
+```text
+S=0 -> C=(P+K) mod 256
+S=1 -> C=(P-K) mod 256
+S=2 -> C=P XOR K
+S=3 -> C=ROL(P,K mod 8)
+```
+
+Decryption applies the corresponding inverse operation.
+
+## Security note
+
+This package is intended for research, experimentation and academic
+evaluation. It is not a replacement for established authenticated
+encryption schemes such as AES-GCM. No authentication/integrity mechanism
+is provided, and the key has the same length as the encrypted byte sequence.
+
+## Install
+
+```bash
+pip install "dynamic-image-encryption[all]"
+```
+
+## Byte API
+
+```python
+from image_encryption import encrypt, decrypt
+
+ciphertext, key = encrypt(b"Hello")
+plaintext = decrypt(ciphertext, key)
+
+assert plaintext == b"Hello"
+```
+
+## Image API
+
+```python
+from image_encryption import encrypt_image, decrypt_image, save_key
+
+key = encrypt_image("input.png", "encrypted.ienc")
+save_key(key, "image.key")
+decrypt_image("encrypted.ienc", key, "decrypted.png")
+```
+
+The image API works on decoded pixel bytes. Native Pillow modes are L, RGB
+and RGBA; other modes are converted to RGB. The decrypted conventional image
+is written as PNG.
+
+## NIfTI API
+
+NIfTI voxel values are not reduced modulo 256. The raw bytes representing
+each voxel are encrypted. Thus an int16 voxel such as 7899 is encrypted as
+its two dtype/endianness-dependent bytes.
+
+```python
+from image_encryption import encrypt_nifti, decrypt_nifti, save_key
+
+key = encrypt_nifti("brain.nii.gz", "brain.ienc")
+save_key(key, "brain.key")
+decrypt_nifti("brain.ienc", key, "brain.decrypted.nii.gz")
+```
+
+The implementation stores the raw voxel dtype/shape, affine, NIfTI header,
+extensions and scaling information needed for reconstruction.
+
+## Tests
+
+```bash
+pip install -e ".[all,dev]"
+pytest -q
+```
+
+## Build
+
+Change the PyPI `name` in `pyproject.toml` if the chosen name is already
+registered.
+
+```bash
+python -m build
+python -m twine check dist/*
+python -m twine upload --repository testpypi dist/*
+python -m twine upload dist/*
+```
+
+## Structure
+
+```text
+image-encryption/
+├── pyproject.toml
+├── README.md
+├── LICENSE
+├── .gitignore
+├── src/image_encryption/
+│   ├── __init__.py
+│   ├── core.py
+│   ├── key.py
+│   ├── operations.py
+│   ├── container.py
+│   ├── image.py
+│   ├── nifti.py
+│   └── exceptions.py
+├── tests/
+└── examples/
+```
+
+## License
+
+MIT.

dynamic_image_encryption-0.1.0/src/dynamic_image_encryption.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+src/dynamic_image_encryption.egg-info/PKG-INFO
+src/dynamic_image_encryption.egg-info/SOURCES.txt
+src/dynamic_image_encryption.egg-info/dependency_links.txt
+src/dynamic_image_encryption.egg-info/requires.txt
+src/dynamic_image_encryption.egg-info/top_level.txt
+src/image_encryption/__init__.py
+src/image_encryption/container.py
+src/image_encryption/core.py
+src/image_encryption/exceptions.py
+src/image_encryption/image.py
+src/image_encryption/key.py
+src/image_encryption/nifti.py
+src/image_encryption/operations.py
+tests/test_core.py
+tests/test_images.py
+tests/test_nifti.py
+tests/test_operations.py

dynamic_image_encryption-0.1.0/src/dynamic_image_encryption.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dynamic_image_encryption-0.1.0/src/dynamic_image_encryption.egg-info/requires.txt

@@ -0,0 +1,18 @@
+
+[all]
+numpy>=1.24
+Pillow>=10.0
+nibabel>=5.0
+
+[dev]
+pytest>=8.0
+build>=1.2
+twine>=5.0
+
+[image]
+numpy>=1.24
+Pillow>=10.0
+
+[nifti]
+numpy>=1.24
+nibabel>=5.0

dynamic_image_encryption-0.1.0/src/dynamic_image_encryption.egg-info/top_level.txt

@@ -0,0 +1 @@
+image_encryption

dynamic_image_encryption-0.1.0/src/image_encryption/__init__.py

@@ -0,0 +1,15 @@
+from .core import decrypt, decrypt_bytes, encrypt, encrypt_bytes
+from .exceptions import ImageEncryptionError, InvalidContainerError, InvalidKeyError, UnsupportedFormatError
+from .image import decrypt_image, encrypt_image
+from .key import generate_key, load_key, save_key
+from .nifti import decrypt_nifti, encrypt_nifti
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "encrypt", "decrypt", "encrypt_bytes", "decrypt_bytes",
+    "encrypt_image", "decrypt_image", "encrypt_nifti", "decrypt_nifti",
+    "generate_key", "save_key", "load_key",
+    "ImageEncryptionError", "InvalidContainerError",
+    "InvalidKeyError", "UnsupportedFormatError",
+]

dynamic_image_encryption-0.1.0/src/image_encryption/container.py

@@ -0,0 +1,62 @@
+import json
+import struct
+from pathlib import Path
+
+from .exceptions import InvalidContainerError
+
+MAGIC = b"IENC"
+VERSION = 1
+_MAX_METADATA = 16 * 1024 * 1024
+_PREFIX = struct.Struct(">4sBQ")
+
+
+def pack_container(metadata: dict, ciphertext: bytes) -> bytes:
+    if not isinstance(metadata, dict):
+        raise TypeError("metadata must be a dictionary")
+    ciphertext = bytes(ciphertext)
+    metadata_bytes = json.dumps(
+        metadata, ensure_ascii=False, separators=(",", ":"), sort_keys=True
+    ).encode("utf-8")
+    if len(metadata_bytes) > _MAX_METADATA:
+        raise InvalidContainerError("metadata is too large")
+    return _PREFIX.pack(MAGIC, VERSION, len(metadata_bytes)) + metadata_bytes + ciphertext
+
+
+def unpack_container(raw: bytes):
+    raw = bytes(raw)
+    if len(raw) < _PREFIX.size:
+        raise InvalidContainerError("container is too small")
+
+    magic, version, metadata_length = _PREFIX.unpack_from(raw)
+    if magic != MAGIC:
+        raise InvalidContainerError("invalid container magic")
+    if version != VERSION:
+        raise InvalidContainerError(f"unsupported container version: {version}")
+
+    start = _PREFIX.size
+    end = start + metadata_length
+    if end > len(raw):
+        raise InvalidContainerError("metadata extends beyond container")
+    if metadata_length > _MAX_METADATA:
+        raise InvalidContainerError("metadata is too large")
+
+    try:
+        metadata = json.loads(raw[start:end].decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise InvalidContainerError("invalid metadata JSON") from exc
+
+    if not isinstance(metadata, dict):
+        raise InvalidContainerError("metadata must be an object")
+
+    return metadata, raw[end:]
+
+
+def write_container(path, metadata, ciphertext):
+    output = Path(path)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_bytes(pack_container(metadata, ciphertext))
+    return output
+
+
+def read_container(path):
+    return unpack_container(Path(path).read_bytes())

dynamic_image_encryption-0.1.0/src/image_encryption/core.py

@@ -0,0 +1,36 @@
+from .key import generate_key, validate_key
+from .operations import decrypt_byte, encrypt_byte
+
+
+def _as_bytes(data, name="data") -> bytes:
+    if not isinstance(data, (bytes, bytearray, memoryview)):
+        raise TypeError(f"{name} must be bytes-like")
+    return bytes(data)
+
+
+def encrypt_bytes(data, key) -> bytes:
+    plaintext = _as_bytes(data)
+    key_bytes = validate_key(key, len(plaintext))
+    ciphertext = bytearray(len(plaintext))
+    for i, (p, k) in enumerate(zip(plaintext, key_bytes)):
+        ciphertext[i] = encrypt_byte(p, k)
+    return bytes(ciphertext)
+
+
+def decrypt_bytes(data, key) -> bytes:
+    ciphertext = _as_bytes(data)
+    key_bytes = validate_key(key, len(ciphertext))
+    plaintext = bytearray(len(ciphertext))
+    for i, (c, k) in enumerate(zip(ciphertext, key_bytes)):
+        plaintext[i] = decrypt_byte(c, k)
+    return bytes(plaintext)
+
+
+def encrypt(data, key=None):
+    plaintext = _as_bytes(data)
+    key_bytes = generate_key(len(plaintext)) if key is None else validate_key(key, len(plaintext))
+    return encrypt_bytes(plaintext, key_bytes), key_bytes
+
+
+def decrypt(data, key) -> bytes:
+    return decrypt_bytes(data, key)

dynamic_image_encryption-0.1.0/src/image_encryption/exceptions.py

@@ -0,0 +1,14 @@
+class ImageEncryptionError(Exception):
+    """Base exception."""
+
+
+class InvalidKeyError(ImageEncryptionError):
+    """Invalid or incorrectly sized key."""
+
+
+class InvalidContainerError(ImageEncryptionError):
+    """Malformed or unsupported encrypted container."""
+
+
+class UnsupportedFormatError(ImageEncryptionError):
+    """Unsupported input/output format."""

dynamic_image_encryption-0.1.0/src/image_encryption/image.py

@@ -0,0 +1,104 @@
+from pathlib import Path
+import math
+
+from .container import read_container, write_container
+from .core import decrypt_bytes, encrypt_bytes
+from .exceptions import InvalidContainerError, UnsupportedFormatError
+from .key import generate_key, validate_key
+
+_SUPPORTED_MODES = {"L", "RGB", "RGBA"}
+
+
+def _deps():
+    try:
+        import numpy as np
+        from PIL import Image
+    except ImportError as exc:
+        raise ImportError(
+            "Install image support with: pip install dynamic-image-encryption[image]"
+        ) from exc
+    return np, Image
+
+
+def _default_decrypted_path(path):
+    name = path.name[:-5] if path.name.endswith(".ienc") else path.stem
+    return path.with_name(name + ".decrypted.png")
+
+
+def encrypt_image(input_path, output_path=None, key=None):
+    np, Image = _deps()
+    source = Path(input_path)
+    if not source.is_file():
+        raise FileNotFoundError(source)
+
+    with Image.open(source) as image:
+        source_mode = image.mode
+        source_format = image.format or source.suffix.lstrip(".").upper()
+        working = image.copy() if image.mode in _SUPPORTED_MODES else image.convert("RGB")
+
+    array = np.ascontiguousarray(np.asarray(working, dtype=np.uint8))
+    mode = working.mode
+
+    plaintext = array.tobytes(order="C")
+    key_bytes = generate_key(len(plaintext)) if key is None else validate_key(key, len(plaintext))
+    ciphertext = encrypt_bytes(plaintext, key_bytes)
+
+    metadata = {
+        "kind": "image",
+        "container_version": 1,
+        "source_format": source_format,
+        "source_mode": source_mode,
+        "mode": mode,
+        "shape": list(array.shape),
+        "dtype": array.dtype.str,
+    }
+
+    output = Path(output_path) if output_path is not None else Path(str(source) + ".ienc")
+    write_container(output, metadata, ciphertext)
+    return key_bytes
+
+
+def decrypt_image(input_path, key, output_path=None):
+    np, Image = _deps()
+    source = Path(input_path)
+    metadata, ciphertext = read_container(source)
+
+    if metadata.get("kind") != "image":
+        raise InvalidContainerError("container does not contain an image")
+
+    mode = metadata.get("mode")
+    shape = metadata.get("shape")
+    dtype_text = metadata.get("dtype")
+
+    if mode not in _SUPPORTED_MODES:
+        raise InvalidContainerError(f"unsupported stored image mode: {mode}")
+    if not isinstance(shape, list) or not all(isinstance(x, int) and x >= 0 for x in shape):
+        raise InvalidContainerError("invalid image shape")
+
+    try:
+        dtype = np.dtype(dtype_text)
+    except (TypeError, ValueError) as exc:
+        raise InvalidContainerError("invalid stored dtype") from exc
+
+    if dtype != np.dtype(np.uint8):
+        raise InvalidContainerError("stored image dtype must be uint8")
+
+    dimensions = 2 if mode == "L" else 3
+    if len(shape) != dimensions:
+        raise InvalidContainerError("image shape does not match mode")
+
+    expected = math.prod(shape) * dtype.itemsize
+    if len(ciphertext) != expected:
+        raise InvalidContainerError("ciphertext length does not match image data")
+
+    plaintext = decrypt_bytes(ciphertext, key)
+    array = np.frombuffer(plaintext, dtype=dtype).reshape(tuple(shape)).copy()
+    image = Image.fromarray(array)
+
+    output = Path(output_path) if output_path is not None else _default_decrypted_path(source)
+    if output.suffix.lower() != ".png":
+        raise UnsupportedFormatError("decrypted conventional images must use a .png output path")
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    image.save(output, format="PNG")
+    return output

dynamic_image_encryption-0.1.0/src/image_encryption/key.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+import secrets
+
+from .exceptions import InvalidKeyError
+
+
+def generate_key(length: int) -> bytes:
+    if isinstance(length, bool) or not isinstance(length, int):
+        raise TypeError("length must be an integer")
+    if length < 0:
+        raise ValueError("length cannot be negative")
+    return secrets.token_bytes(length)
+
+
+def validate_key(key, expected_length: int | None = None) -> bytes:
+    if not isinstance(key, (bytes, bytearray, memoryview)):
+        raise InvalidKeyError("key must be bytes-like")
+    key_bytes = bytes(key)
+    if expected_length is not None and len(key_bytes) != expected_length:
+        raise InvalidKeyError(
+            f"key length is {len(key_bytes)}, expected {expected_length}"
+        )
+    return key_bytes
+
+
+def save_key(key, path) -> Path:
+    key_bytes = validate_key(key)
+    output = Path(path)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_bytes(key_bytes)
+    return output
+
+
+def load_key(path) -> bytes:
+    return Path(path).read_bytes()

dynamic_image_encryption-0.1.0/src/image_encryption/nifti.py

@@ -0,0 +1,210 @@
+from pathlib import Path
+import base64
+import io
+import math
+
+from .container import read_container, write_container
+from .core import decrypt_bytes, encrypt_bytes
+from .exceptions import InvalidContainerError, UnsupportedFormatError
+from .key import generate_key, validate_key
+
+
+def _deps():
+    try:
+        import nibabel as nib
+        import numpy as np
+    except ImportError as exc:
+        raise ImportError(
+            "Install NIfTI support with: pip install dynamic-image-encryption[nifti]"
+        ) from exc
+    return nib, np
+
+
+def _raw_data(image):
+    dataobj = image.dataobj
+    getter = getattr(dataobj, "get_unscaled", None)
+    return getter() if callable(getter) else dataobj
+
+
+def _scaling(image):
+    dataobj = image.dataobj
+    slope = getattr(dataobj, "slope", None)
+    inter = getattr(dataobj, "inter", None)
+
+    if slope is None or inter is None:
+        try:
+            slope = float(image.header["scl_slope"])
+            inter = float(image.header["scl_inter"])
+        except Exception:
+            return None
+
+    try:
+        slope, inter = float(slope), float(inter)
+    except (TypeError, ValueError):
+        return None
+
+    if not (slope == slope and inter == inter):
+        return None
+
+    return {"slope": slope, "inter": inter}
+
+
+def _serialize_extensions(header):
+    result = []
+    for extension in header.extensions:
+        content = extension.get_content()
+        content = content.encode("utf-8") if isinstance(content, str) else bytes(content)
+        result.append({
+            "code": int(extension.get_code()),
+            "content": base64.b64encode(content).decode("ascii"),
+        })
+    return result
+
+
+def _restore_extensions(header, extensions):
+    import nibabel as nib
+    for item in extensions:
+        try:
+            code = int(item["code"])
+            content = base64.b64decode(item["content"], validate=True)
+        except Exception as exc:
+            raise InvalidContainerError("invalid NIfTI extension metadata") from exc
+        header.extensions.append(nib.nifti1.Nifti1Extension(code, content))
+
+
+def _header_class(nib, name):
+    if name == "Nifti1Header":
+        return nib.Nifti1Header
+    if name == "Nifti2Header":
+        return nib.Nifti2Header
+    raise InvalidContainerError(f"unsupported NIfTI header class: {name}")
+
+
+def _image_class(nib, name):
+    if name == "Nifti1Image":
+        return nib.Nifti1Image
+    if name == "Nifti2Image":
+        return nib.Nifti2Image
+    raise InvalidContainerError(f"unsupported NIfTI image class: {name}")
+
+
+def _default_decrypted_path(path):
+    name = path.name[:-5] if path.name.endswith(".ienc") else path.name
+    if name.endswith(".nii.gz"):
+        stem = name[:-7]
+    elif name.endswith(".nii"):
+        stem = name[:-4]
+    else:
+        stem = Path(name).stem
+    return path.with_name(stem + ".decrypted.nii.gz")
+
+
+def encrypt_nifti(input_path, output_path=None, key=None):
+    nib, np = _deps()
+    source = Path(input_path)
+
+    if not source.is_file():
+        raise FileNotFoundError(source)
+    if not (source.name.lower().endswith(".nii") or source.name.lower().endswith(".nii.gz")):
+        raise UnsupportedFormatError("input must be .nii or .nii.gz")
+
+    image = nib.load(str(source))
+    if not isinstance(image, (nib.Nifti1Image, nib.Nifti2Image)):
+        raise UnsupportedFormatError("only NIfTI-1 and NIfTI-2 are supported")
+
+    data = np.ascontiguousarray(_raw_data(image))
+    if data.dtype.hasobject:
+        raise UnsupportedFormatError("object voxel dtype is not supported")
+
+    plaintext = data.tobytes(order="C")
+    key_bytes = generate_key(len(plaintext)) if key is None else validate_key(key, len(plaintext))
+    ciphertext = encrypt_bytes(plaintext, key_bytes)
+
+    affine = image.affine
+    if affine is None:
+        affine = np.eye(4, dtype=np.float64)
+
+    metadata = {
+        "kind": "nifti",
+        "container_version": 1,
+        "image_class": type(image).__name__,
+        "header_class": type(image.header).__name__,
+        "header_b64": base64.b64encode(image.header.binaryblock).decode("ascii"),
+        "extensions": _serialize_extensions(image.header),
+        "affine": np.asarray(affine, dtype=np.float64).tolist(),
+        "shape": list(data.shape),
+        "dtype": data.dtype.str,
+        "original_filename": source.name,
+    }
+
+    scaling = _scaling(image)
+    if scaling is not None:
+        metadata["scaling"] = scaling
+
+    output = Path(output_path) if output_path is not None else Path(str(source) + ".ienc")
+    write_container(output, metadata, ciphertext)
+    return key_bytes
+
+
+def decrypt_nifti(input_path, key, output_path=None):
+    nib, np = _deps()
+    source = Path(input_path)
+    metadata, ciphertext = read_container(source)
+
+    if metadata.get("kind") != "nifti":
+        raise InvalidContainerError("container does not contain NIfTI data")
+
+    shape = metadata.get("shape")
+    if not isinstance(shape, list) or not all(isinstance(x, int) and x >= 0 for x in shape):
+        raise InvalidContainerError("invalid NIfTI shape")
+
+    try:
+        dtype = np.dtype(metadata["dtype"])
+    except (TypeError, ValueError, KeyError) as exc:
+        raise InvalidContainerError("invalid NIfTI dtype") from exc
+
+    expected = math.prod(shape) * dtype.itemsize
+    if len(ciphertext) != expected:
+        raise InvalidContainerError("ciphertext length does not match voxel data")
+
+    plaintext = decrypt_bytes(ciphertext, key)
+    data = np.frombuffer(plaintext, dtype=dtype).reshape(tuple(shape)).copy()
+
+    try:
+        header_bytes = base64.b64decode(metadata["header_b64"], validate=True)
+    except Exception as exc:
+        raise InvalidContainerError("invalid NIfTI header data") from exc
+
+    header_cls = _header_class(nib, metadata.get("header_class"))
+    try:
+        header = header_cls.from_fileobj(io.BytesIO(header_bytes))
+    except Exception as exc:
+        raise InvalidContainerError("could not reconstruct NIfTI header") from exc
+
+    scaling = metadata.get("scaling")
+    if scaling is not None:
+        try:
+            header["scl_slope"] = float(scaling["slope"])
+            header["scl_inter"] = float(scaling["inter"])
+        except Exception as exc:
+            raise InvalidContainerError("invalid NIfTI scaling metadata") from exc
+
+    affine = np.asarray(metadata.get("affine"), dtype=np.float64)
+    if affine.shape != (4, 4):
+        raise InvalidContainerError("NIfTI affine must be 4x4")
+
+    image_cls = _image_class(nib, metadata.get("image_class"))
+
+    try:
+        image = image_cls(data, affine, header=header)
+        _restore_extensions(image.header, metadata.get("extensions", []))
+    except Exception as exc:
+        raise InvalidContainerError("could not reconstruct NIfTI image") from exc
+
+    output = Path(output_path) if output_path is not None else _default_decrypted_path(source)
+    if not (output.name.lower().endswith(".nii") or output.name.lower().endswith(".nii.gz")):
+        raise UnsupportedFormatError("NIfTI output must end with .nii or .nii.gz")
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    nib.save(image, str(output))
+    return output

dynamic_image_encryption-0.1.0/src/image_encryption/operations.py

@@ -0,0 +1,58 @@
+def _check_byte(value: int, name: str) -> None:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError(f"{name} must be an integer")
+    if not 0 <= value <= 255:
+        raise ValueError(f"{name} must be in the range 0..255")
+
+
+def rotate_left(value: int, shift: int) -> int:
+    _check_byte(value, "value")
+    if isinstance(shift, bool) or not isinstance(shift, int):
+        raise TypeError("shift must be an integer")
+    shift %= 8
+    if shift == 0:
+        return value
+    return ((value << shift) | (value >> (8 - shift))) & 0xFF
+
+
+def rotate_right(value: int, shift: int) -> int:
+    _check_byte(value, "value")
+    if isinstance(shift, bool) or not isinstance(shift, int):
+        raise TypeError("shift must be an integer")
+    shift %= 8
+    if shift == 0:
+        return value
+    return ((value >> shift) | (value << (8 - shift))) & 0xFF
+
+
+def selector(key_byte: int) -> int:
+    _check_byte(key_byte, "key_byte")
+    return key_byte % 4
+
+
+def encrypt_byte(plain_byte: int, key_byte: int) -> int:
+    _check_byte(plain_byte, "plain_byte")
+    _check_byte(key_byte, "key_byte")
+    s = selector(key_byte)
+
+    if s == 0:
+        return (plain_byte + key_byte) % 256
+    if s == 1:
+        return (plain_byte - key_byte) % 256
+    if s == 2:
+        return plain_byte ^ key_byte
+    return rotate_left(plain_byte, key_byte % 8)
+
+
+def decrypt_byte(cipher_byte: int, key_byte: int) -> int:
+    _check_byte(cipher_byte, "cipher_byte")
+    _check_byte(key_byte, "key_byte")
+    s = selector(key_byte)
+
+    if s == 0:
+        return (cipher_byte - key_byte) % 256
+    if s == 1:
+        return (cipher_byte + key_byte) % 256
+    if s == 2:
+        return cipher_byte ^ key_byte
+    return rotate_right(cipher_byte, key_byte % 8)

dynamic_image_encryption-0.1.0/tests/test_core.py

@@ -0,0 +1,23 @@
+import pytest
+
+from image_encryption import decrypt_bytes, encrypt, encrypt_bytes, generate_key
+from image_encryption.exceptions import InvalidKeyError
+
+
+@pytest.mark.parametrize("length", [0, 1, 2, 7, 256, 4097])
+def test_roundtrip(length):
+    data = bytes((i * 17 + 31) % 256 for i in range(length))
+    key = generate_key(length)
+    assert decrypt_bytes(encrypt_bytes(data, key), key) == data
+
+
+def test_encrypt_generates_key():
+    data = b"hello research encryption"
+    ciphertext, key = encrypt(data)
+    assert len(key) == len(data)
+    assert decrypt_bytes(ciphertext, key) == data
+
+
+def test_invalid_key_length():
+    with pytest.raises(InvalidKeyError):
+        encrypt_bytes(b"abcdef", b"123")

dynamic_image_encryption-0.1.0/tests/test_images.py

@@ -0,0 +1,25 @@
+import numpy as np
+from PIL import Image
+
+from image_encryption import decrypt_image, encrypt_image, load_key, save_key
+
+
+def test_rgb_image_roundtrip(tmp_path):
+    data = np.zeros((32, 32, 3), dtype=np.uint8)
+    data[0, 0] = [12, 34, 56]
+    data[10, 20] = [255, 128, 7]
+
+    source = tmp_path / "input.png"
+    encrypted = tmp_path / "image.ienc"
+    decrypted = tmp_path / "decrypted.png"
+    key_file = tmp_path / "image.key"
+
+    Image.fromarray(data, mode="RGB").save(source)
+
+    key = encrypt_image(source, encrypted)
+    save_key(key, key_file)
+
+    decrypt_image(encrypted, load_key(key_file), decrypted)
+
+    restored = np.asarray(Image.open(decrypted))
+    assert np.array_equal(restored, data)

dynamic_image_encryption-0.1.0/tests/test_nifti.py

@@ -0,0 +1,44 @@
+import numpy as np
+import pytest
+
+nib = pytest.importorskip("nibabel")
+
+from image_encryption import decrypt_nifti, encrypt_nifti
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        np.array([-32768, -1000, 0, 1, 7899, 32767], dtype=np.int16).reshape(2, 3, 1),
+        np.array([-3.5, 0.0, 1.25, 7899.125], dtype=np.float32).reshape(2, 2, 1),
+    ],
+)
+def test_nifti_roundtrip(tmp_path, data):
+    source = tmp_path / "input.nii.gz"
+    encrypted = tmp_path / "volume.ienc"
+    decrypted = tmp_path / "restored.nii.gz"
+
+    affine = np.array([
+        [1.0, 0.0, 0.0, 10.0],
+        [0.0, 2.0, 0.0, 20.0],
+        [0.0, 0.0, 3.0, 30.0],
+        [0.0, 0.0, 0.0, 1.0],
+    ])
+
+    image = nib.Nifti1Image(data, affine)
+    image.header["descrip"] = b"dynamic encryption test"
+    nib.save(image, source)
+
+    key = encrypt_nifti(source, encrypted)
+    decrypt_nifti(encrypted, key, decrypted)
+
+    original = nib.load(source)
+    restored = nib.load(decrypted)
+
+    original_raw = np.asarray(original.dataobj.get_unscaled())
+    restored_raw = np.asarray(restored.dataobj.get_unscaled())
+
+    assert np.array_equal(original_raw, restored_raw)
+    assert original_raw.dtype.str == restored_raw.dtype.str
+    assert np.allclose(original.affine, restored.affine)
+    assert bytes(original.header["descrip"]) == bytes(restored.header["descrip"])

dynamic_image_encryption-0.1.0/tests/test_operations.py

@@ -0,0 +1,17 @@
+from image_encryption.operations import decrypt_byte, encrypt_byte, rotate_left, rotate_right
+
+
+def test_every_byte_and_key_roundtrip():
+    for plain in range(256):
+        for key in range(256):
+            cipher = encrypt_byte(plain, key)
+            assert 0 <= cipher <= 255
+            assert decrypt_byte(cipher, key) == plain
+
+
+def test_rotation():
+    value = 0b10000001
+    assert rotate_left(value, 1) == 0b00000011
+    assert rotate_right(0b00000011, 1) == value
+    assert rotate_left(value, 8) == value
+    assert rotate_right(value, 8) == value