otdf-python 0.1.9__py3-none-any.whl → 0.3.1__py3-none-any.whl

otdf_python/nanotdf_type.py

@@ -0,0 +1,43 @@
+from enum import Enum
+
+
+class ECCurve(Enum):
+    SECP256R1 = "secp256r1"
+    SECP384R1 = "secp384r1"
+    SECP521R1 = "secp384r1"
+    SECP256K1 = "secp256k1"
+
+    def __str__(self):
+        return self.value
+
+
+class Protocol(Enum):
+    HTTP = "HTTP"
+    HTTPS = "HTTPS"
+
+
+class IdentifierType(Enum):
+    NONE = 0
+    TWO_BYTES = 2
+    EIGHT_BYTES = 8
+    THIRTY_TWO_BYTES = 32
+
+    def get_length(self):
+        return self.value
+
+
+class PolicyType(Enum):
+    REMOTE_POLICY = 0
+    EMBEDDED_POLICY_PLAIN_TEXT = 1
+    EMBEDDED_POLICY_ENCRYPTED = 2
+    EMBEDDED_POLICY_ENCRYPTED_POLICY_KEY_ACCESS = 3
+
+
+class Cipher(Enum):
+    AES_256_GCM_64_TAG = 0
+    AES_256_GCM_96_TAG = 1
+    AES_256_GCM_104_TAG = 2
+    AES_256_GCM_112_TAG = 3
+    AES_256_GCM_120_TAG = 4
+    AES_256_GCM_128_TAG = 5
+    EAD_AES_256_HMAC_SHA_256 = 6

otdf_python/policy_binding_serializer.py

@@ -0,0 +1,39 @@
+from typing import Any
+
+
+class PolicyBinding:
+    """
+    Represents a policy binding in the TDF manifest.
+    This is a placeholder implementation as the complete details of
+    the PolicyBinding class aren't provided in the code snippets.
+    """
+
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+
+class PolicyBindingSerializer:
+    """
+    Handles serialization and deserialization of policy bindings.
+    This class provides static methods to convert between JSON representations
+    and PolicyBinding objects.
+    """
+
+    @staticmethod
+    def deserialize(
+        json_data: Any, typeofT: type | None = None, context: Any = None
+    ) -> Any:
+        if isinstance(json_data, dict):
+            return PolicyBinding(**json_data)
+        if isinstance(json_data, str):
+            return json_data
+        raise ValueError("Invalid type for PolicyBinding deserialization")
+
+    @staticmethod
+    def serialize(
+        src: Any, typeofSrc: type | None = None, context: Any = None
+    ) -> dict | str:
+        if isinstance(src, PolicyBinding):
+            return vars(src)
+        return str(src)

otdf_python/policy_info.py

@@ -0,0 +1,78 @@
+class PolicyInfo:
+    def __init__(
+        self,
+        policy_type: int = 0,
+        has_ecdsa_binding: bool = False,
+        body: bytes | None = None,
+        binding: bytes | None = None,
+    ):
+        self.policy_type = policy_type
+        self.has_ecdsa_binding = has_ecdsa_binding
+        self.body = body
+        self.binding = binding
+
+    def set_embedded_plain_text_policy(self, body: bytes):
+        self.body = body
+        self.policy_type = 1  # Placeholder for EMBEDDED_POLICY_PLAIN_TEXT
+
+    def set_embedded_encrypted_text_policy(self, body: bytes):
+        self.body = body
+        self.policy_type = 2  # Placeholder for EMBEDDED_POLICY_ENCRYPTED
+
+    def set_policy_binding(self, binding: bytes):
+        self.binding = binding
+
+    def get_body(self) -> bytes | None:
+        return self.body
+
+    def get_binding(self) -> bytes | None:
+        return self.binding
+
+    def get_total_size(self) -> int:
+        size = 1  # policy_type
+        size += 2  # body_len
+        size += len(self.body) if self.body else 0
+        size += 1  # binding_len
+        size += len(self.binding) if self.binding else 0
+        return size
+
+    def write_into_buffer(self, buffer: bytearray, offset: int = 0) -> int:
+        start = offset
+        buffer[offset] = self.policy_type
+        offset += 1
+        body_len = len(self.body) if self.body else 0
+        buffer[offset : offset + 2] = body_len.to_bytes(2, "big")
+        offset += 2
+        if self.body:
+            buffer[offset : offset + body_len] = self.body
+            offset += body_len
+        binding_len = len(self.binding) if self.binding else 0
+        buffer[offset] = binding_len
+        offset += 1
+        if self.binding:
+            buffer[offset : offset + binding_len] = self.binding
+            offset += binding_len
+        return offset - start
+
+    @staticmethod
+    def from_bytes_with_size(buffer: bytes, ecc_mode):
+        # Based on Java implementation: parse policy_type (1 byte), body_len (2 bytes), body, binding_len (1 byte), binding
+        offset = 0
+        if len(buffer) < 4:
+            raise ValueError("Buffer too short for PolicyInfo header")
+        policy_type = buffer[offset]
+        offset += 1
+        body_len = int.from_bytes(buffer[offset : offset + 2], "big")
+        offset += 2
+        if len(buffer) < offset + body_len + 1:
+            raise ValueError("Buffer too short for PolicyInfo body")
+        body = buffer[offset : offset + body_len]
+        offset += body_len
+        binding_len = buffer[offset]
+        offset += 1
+        if len(buffer) < offset + binding_len:
+            raise ValueError("Buffer too short for PolicyInfo binding")
+        binding = buffer[offset : offset + binding_len]
+        offset += binding_len
+        pi = PolicyInfo(policy_type=policy_type, body=body, binding=binding)
+        return pi, offset

otdf_python/policy_object.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class AttributeObject:
+    attribute: str
+    display_name: str | None = None
+    is_default: bool = False
+    pub_key: str | None = None
+    kas_url: str | None = None
+
+
+@dataclass
+class PolicyBody:
+    data_attributes: list[AttributeObject]
+    dissem: list[str]
+
+
+@dataclass
+class PolicyObject:
+    uuid: str
+    body: PolicyBody

otdf_python/policy_stub.py

@@ -0,0 +1,2 @@
+# TODO: Replace this with a proper Policy UUID values
+NULL_POLICY_UUID: str = "00000000-0000-0000-0000-000000000000"

otdf_python/resource_locator.py

@@ -0,0 +1,44 @@
+class ResourceLocator:
+    def __init__(self, resource_url: str | None = None, identifier: str | None = None):
+        self.resource_url = resource_url
+        self.identifier = identifier
+
+    def get_resource_url(self):
+        return self.resource_url
+
+    def get_identifier(self):
+        return self.identifier
+
+    def to_bytes(self):
+        # Based on Java implementation: [url_len][url_bytes][id_len][id_bytes], each len is 1 byte
+        url_bytes = (self.resource_url or "").encode()
+        id_bytes = (self.identifier or "").encode()
+        if len(url_bytes) > 255 or len(id_bytes) > 255:
+            raise ValueError("ResourceLocator fields too long for 1-byte length prefix")
+        return bytes([len(url_bytes)]) + url_bytes + bytes([len(id_bytes)]) + id_bytes
+
+    def get_total_size(self) -> int:
+        return len(self.to_bytes())
+
+    def write_into_buffer(self, buffer: bytearray, offset: int = 0) -> int:
+        data = self.to_bytes()
+        buffer[offset : offset + len(data)] = data
+        return len(data)
+
+    @staticmethod
+    def from_bytes_with_size(buffer: bytes):
+        # Based on Java implementation: [url_len][url_bytes][id_len][id_bytes]
+        if len(buffer) < 2:
+            raise ValueError("Buffer too short for ResourceLocator")
+        url_len = buffer[0]
+        if len(buffer) < 1 + url_len + 1:
+            raise ValueError("Buffer too short for ResourceLocator url")
+        url_bytes = buffer[1 : 1 + url_len]
+        id_len = buffer[1 + url_len]
+        if len(buffer) < 1 + url_len + 1 + id_len:
+            raise ValueError("Buffer too short for ResourceLocator id")
+        id_bytes = buffer[1 + url_len + 1 : 1 + url_len + 1 + id_len]
+        resource_url = url_bytes.decode()
+        identifier = id_bytes.decode()
+        size = 1 + url_len + 1 + id_len
+        return ResourceLocator(resource_url, identifier), size