televault 0.1.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

televault/crypto.py

@@ -2,12 +2,11 @@
 
 import os
 import struct
-from typing import BinaryIO, Iterator
 from dataclasses import dataclass
 
+from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
-from cryptography.hazmat.backends import default_backend
 
 # Constants
 SALT_SIZE = 16
@@ -23,34 +22,28 @@ BLOCK_SIZE = 64 * 1024  # 64KB blocks for streaming encryption
 @dataclass
 class EncryptionHeader:
     """Header prepended to encrypted data."""
-    
+
     salt: bytes
     nonce: bytes
-    
+
     def to_bytes(self) -> bytes:
         return self.salt + self.nonce
-    
+
     @classmethod
     def from_bytes(cls, data: bytes) -> "EncryptionHeader":
         if len(data) < HEADER_SIZE:
             raise ValueError(f"Header too short: {len(data)} < {HEADER_SIZE}")
-        return cls(
-            salt=data[:SALT_SIZE],
-            nonce=data[SALT_SIZE:HEADER_SIZE]
-        )
-    
+        return cls(salt=data[:SALT_SIZE], nonce=data[SALT_SIZE:HEADER_SIZE])
+
     @classmethod
     def generate(cls) -> "EncryptionHeader":
-        return cls(
-            salt=os.urandom(SALT_SIZE),
-            nonce=os.urandom(NONCE_SIZE)
-        )
+        return cls(salt=os.urandom(SALT_SIZE), nonce=os.urandom(NONCE_SIZE))
 
 
 def derive_key(password: str, salt: bytes) -> bytes:
     """
     Derive encryption key from password using Scrypt.
-    
+
     Using Scrypt instead of Argon2id for broader compatibility.
     Parameters tuned for ~100ms on modern hardware.
     """
@@ -58,9 +51,9 @@ def derive_key(password: str, salt: bytes) -> bytes:
         salt=salt,
         length=KEY_SIZE,
         n=2**17,  # CPU/memory cost
-        r=8,      # Block size
-        p=1,      # Parallelization
-        backend=default_backend()
+        r=8,  # Block size
+        p=1,  # Parallelization
+        backend=default_backend(),
     )
     return kdf.derive(password.encode("utf-8"))
 
@@ -68,13 +61,13 @@ def derive_key(password: str, salt: bytes) -> bytes:
 def encrypt_chunk(data: bytes, password: str) -> bytes:
     """
     Encrypt a chunk of data.
-    
+
     Returns: header (28 bytes) + ciphertext + tag (16 bytes)
     """
     header = EncryptionHeader.generate()
     key = derive_key(password, header.salt)
     cipher = AESGCM(key)
-    
+
     ciphertext = cipher.encrypt(header.nonce, data, None)
     return header.to_bytes() + ciphertext
 
@@ -82,13 +75,13 @@ def encrypt_chunk(data: bytes, password: str) -> bytes:
 def decrypt_chunk(encrypted_data: bytes, password: str) -> bytes:
     """
     Decrypt a chunk of data.
-    
+
     Expects: header (28 bytes) + ciphertext + tag (16 bytes)
     """
     header = EncryptionHeader.from_bytes(encrypted_data)
     key = derive_key(password, header.salt)
     cipher = AESGCM(key)
-    
+
     ciphertext = encrypted_data[HEADER_SIZE:]
     return cipher.decrypt(header.nonce, ciphertext, None)
 
@@ -96,22 +89,22 @@ def decrypt_chunk(encrypted_data: bytes, password: str) -> bytes:
 class StreamingEncryptor:
     """
     Streaming encryptor for large files.
-    
+
     Note: For simplicity, this encrypts the entire file with one key/nonce.
     For very large files, consider chunking with per-chunk nonces.
     """
-    
+
     def __init__(self, password: str):
         self.password = password
         self.header = EncryptionHeader.generate()
         self.key = derive_key(password, self.header.salt)
         self.cipher = AESGCM(self.key)
         self._counter = 0
-    
+
     def get_header(self) -> bytes:
         """Get the header to prepend to encrypted output."""
         return self.header.to_bytes()
-    
+
     def _get_nonce(self) -> bytes:
         """Generate unique nonce for each block using counter mode."""
         # Use base nonce + counter to ensure uniqueness
@@ -122,7 +115,7 @@ class StreamingEncryptor:
         for i in range(8):
             nonce[i] ^= counter_bytes[i]
         return bytes(nonce)
-    
+
     def encrypt_block(self, data: bytes, is_last: bool = False) -> bytes:
         """Encrypt a block of data."""
         nonce = self._get_nonce()
@@ -133,13 +126,13 @@ class StreamingEncryptor:
 
 class StreamingDecryptor:
     """Streaming decryptor for large files."""
-    
+
     def __init__(self, password: str, header: EncryptionHeader):
         self.password = password
         self.header = header
         self.key = derive_key(password, header.salt)
         self.cipher = AESGCM(self.key)
-    
+
     def decrypt_block(self, encrypted_block: bytes) -> bytes:
         """Decrypt a block of data."""
         # Extract nonce from block
@@ -152,9 +145,9 @@ def encrypt_file_simple(input_path: str, output_path: str, password: str) -> Non
     """Simple file encryption - loads entire file into memory."""
     with open(input_path, "rb") as f:
         data = f.read()
-    
+
     encrypted = encrypt_chunk(data, password)
-    
+
     with open(output_path, "wb") as f:
         f.write(encrypted)
 
@@ -163,8 +156,8 @@ def decrypt_file_simple(input_path: str, output_path: str, password: str) -> Non
     """Simple file decryption - loads entire file into memory."""
     with open(input_path, "rb") as f:
         encrypted = f.read()
-    
+
     decrypted = decrypt_chunk(encrypted, password)
-    
+
     with open(output_path, "wb") as f:
         f.write(decrypted)

televault/models.py

@@ -1,23 +1,22 @@
 """Data models for TeleVault - stored as JSON on Telegram."""
 
-from dataclasses import dataclass, field, asdict
-from datetime import datetime
-from typing import Optional
 import json
+from dataclasses import asdict, dataclass, field
+from datetime import datetime
 
 
 @dataclass
 class ChunkInfo:
     """Information about a single chunk stored on Telegram."""
-    
+
     index: int  # Chunk order (0-based)
     message_id: int  # Telegram message ID
     size: int  # Chunk size in bytes
     hash: str  # BLAKE3 hash for verification
-    
+
     def to_dict(self) -> dict:
         return asdict(self)
-    
+
     @classmethod
     def from_dict(cls, data: dict) -> "ChunkInfo":
         return cls(**data)
@@ -29,49 +28,49 @@ class FileMetadata:
     Metadata for a file stored on Telegram.
     This is stored as a JSON text message, with chunks replying to it.
     """
-    
+
     id: str  # Unique file ID (short hash)
     name: str  # Original filename
     size: int  # Original file size in bytes
     hash: str  # BLAKE3 hash of original file
     chunks: list[ChunkInfo] = field(default_factory=list)
-    
+
     # Optional fields
     encrypted: bool = True
     compressed: bool = False
-    compression_ratio: Optional[float] = None
-    mime_type: Optional[str] = None
-    
+    compression_ratio: float | None = None
+    mime_type: str | None = None
+
     # Timestamps
     created_at: float = field(default_factory=lambda: datetime.now().timestamp())
-    modified_at: Optional[float] = None
-    
+    modified_at: float | None = None
+
     # Telegram reference
-    message_id: Optional[int] = None  # Message ID of this metadata
-    
+    message_id: int | None = None  # Message ID of this metadata
+
     def to_json(self) -> str:
         """Serialize to JSON for storage on Telegram."""
         data = asdict(self)
         # Convert ChunkInfo objects
         data["chunks"] = [c.to_dict() if isinstance(c, ChunkInfo) else c for c in data["chunks"]]
         return json.dumps(data, separators=(",", ":"))  # Compact JSON
-    
+
     @classmethod
     def from_json(cls, text: str) -> "FileMetadata":
         """Deserialize from JSON stored on Telegram."""
         data = json.loads(text)
         data["chunks"] = [ChunkInfo.from_dict(c) for c in data.get("chunks", [])]
         return cls(**data)
-    
+
     @property
     def chunk_count(self) -> int:
         return len(self.chunks)
-    
+
     @property
     def total_stored_size(self) -> int:
         """Total size of all chunks (after compression/encryption)."""
         return sum(c.size for c in self.chunks)
-    
+
     def is_complete(self) -> bool:
         """Check if all chunks are present."""
         if not self.chunks:
@@ -87,14 +86,14 @@ class VaultIndex:
     Master index of all files in the vault.
     Stored as pinned message in the channel.
     """
-    
+
     version: int = 1
     files: dict[str, int] = field(default_factory=dict)  # file_id -> metadata_message_id
     updated_at: float = field(default_factory=lambda: datetime.now().timestamp())
-    
+
     def to_json(self) -> str:
         return json.dumps(asdict(self), separators=(",", ":"))
-    
+
     @classmethod
     def from_json(cls, text: str) -> "VaultIndex":
         data = json.loads(text)
@@ -104,12 +103,12 @@ class VaultIndex:
             files=data.get("files", {}),
             updated_at=data.get("updated_at", datetime.now().timestamp()),
         )
-    
+
     def add_file(self, file_id: str, message_id: int) -> None:
         self.files[file_id] = message_id
         self.updated_at = datetime.now().timestamp()
-    
-    def remove_file(self, file_id: str) -> Optional[int]:
+
+    def remove_file(self, file_id: str) -> int | None:
         msg_id = self.files.pop(file_id, None)
         if msg_id:
             self.updated_at = datetime.now().timestamp()
@@ -122,26 +121,26 @@ class TransferProgress:
     Progress tracking for resumable transfers.
     Stored as a temporary message, deleted on completion.
     """
-    
+
     operation: str  # "upload" or "download"
     file_id: str
     file_name: str
     total_chunks: int
     completed_chunks: list[int] = field(default_factory=list)  # Completed chunk indices
     started_at: float = field(default_factory=lambda: datetime.now().timestamp())
-    
+
     def to_json(self) -> str:
         return json.dumps(asdict(self), separators=(",", ":"))
-    
+
     @classmethod
     def from_json(cls, text: str) -> "TransferProgress":
         return cls(**json.loads(text))
-    
+
     @property
     def pending_chunks(self) -> list[int]:
         completed = set(self.completed_chunks)
         return [i for i in range(self.total_chunks) if i not in completed]
-    
+
     @property
     def progress_percent(self) -> float:
         if self.total_chunks == 0: