Create providers/filen_provider.py

providers/filen_provider.py

@@ -0,0 +1,257 @@
+import os
+import json
+import time
+import hashlib
+import requests
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+import base64
+
+class FilenProvider:
+    def __init__(self, email=None, password=None):
+        self.email = email
+        self.password = password
+        self.api_key = None
+        self.master_keys = []
+        self.base_url = "https://gateway.filen.io"
+    
+    def validate_credentials(self, email, password):
+        """Validate Filen credentials"""
+        try:
+            # Get auth info
+            auth_info = self._get_auth_info(email)
+            if not auth_info:
+                return False
+            
+            # Derive password
+            derived = self._derive_password(password, auth_info['salt'], auth_info['authVersion'])
+            
+            # Try to login
+            login_result = self._login(email, derived['password'], auth_info['authVersion'])
+            return login_result is not None
+            
+        except Exception as e:
+            print(f"Filen validation error: {e}")
+            return False
+    
+    def _get_auth_info(self, email):
+        """Get authentication info for email"""
+        response = requests.post(
+            f"{self.base_url}/v3/auth/info",
+            json={"email": email}
+        )
+        
+        if response.status_code == 200:
+            return response.json()
+        return None
+    
+    def _derive_password(self, raw_password, salt, auth_version):
+        """Derive password and master key"""
+        if auth_version == 2:
+            # PBKDF2 derivation
+            kdf = PBKDF2HMAC(
+                algorithm=hashes.SHA512(),
+                length=64,
+                salt=salt.encode(),
+                iterations=200000,
+                backend=default_backend()
+            )
+            
+            derived_key = kdf.derive(raw_password.encode())
+            derived_hex = derived_key.hex()
+            
+            # Split the key
+            master_key = derived_hex[:len(derived_hex)//2]
+            password = derived_hex[len(derived_hex)//2:]
+            
+            # Hash password with SHA-512
+            password_hash = hashlib.sha512(password.encode()).hexdigest()
+            
+            return {
+                'master_key': master_key,
+                'password': password_hash
+            }
+        else:
+            raise Exception(f"Unsupported auth version: {auth_version}")
+    
+    def _login(self, email, password, auth_version):
+        """Login to Filen"""
+        response = requests.post(
+            f"{self.base_url}/v3/login",
+            json={
+                "email": email,
+                "password": password,
+                "authVersion": auth_version,
+                "twoFactorCode": "XXXXXX"
+            }
+        )
+        
+        if response.status_code == 200:
+            data = response.json()
+            self.api_key = data.get('apiKey')
+            return data
+        return None
+    
+    def upload(self, file_path, progress_callback=None):
+        """Upload file to Filen"""
+        try:
+            # First, authenticate
+            auth_info = self._get_auth_info(self.email)
+            derived = self._derive_password(self.password, auth_info['salt'], auth_info['authVersion'])
+            login_result = self._login(self.email, derived['password'], auth_info['authVersion'])
+            
+            if not login_result:
+                raise Exception("Failed to authenticate with Filen")
+            
+            # Get base folder
+            base_folder = self._get_base_folder()
+            if not base_folder:
+                raise Exception("Failed to get base folder")
+            
+            # Generate file UUID and encryption key
+            import uuid
+            file_uuid = str(uuid.uuid4())
+            file_key = os.urandom(32).hex()[:12]
+            
+            # Read and encrypt file in chunks
+            chunk_size = 1024 * 1024  # 1MB chunks
+            file_size = os.path.getsize(file_path)
+            chunks_uploaded = 0
+            total_chunks = (file_size + chunk_size - 1) // chunk_size
+            
+            with open(file_path, 'rb') as f:
+                chunk_index = 0
+                while True:
+                    chunk_data = f.read(chunk_size)
+                    if not chunk_data:
+                        break
+                    
+                    # Encrypt chunk
+                    encrypted_chunk = self._encrypt_chunk(chunk_data, file_key)
+                    
+                    # Upload chunk
+                    upload_result = self._upload_chunk(
+                        file_uuid,
+                        chunk_index,
+                        encrypted_chunk,
+                        base_folder['uuid']
+                    )
+                    
+                    if not upload_result:
+                        raise Exception(f"Failed to upload chunk {chunk_index}")
+                    
+                    chunk_index += 1
+                    chunks_uploaded += 1
+                    
+                    if progress_callback:
+                        progress = (chunks_uploaded / total_chunks) * 100
+                        progress_callback(progress)
+            
+            # Mark upload as complete
+            self._complete_upload(
+                file_uuid,
+                os.path.basename(file_path),
+                file_key,
+                file_size,
+                total_chunks,
+                base_folder['uuid']
+            )
+            
+            return {
+                'provider': 'filen',
+                'filename': os.path.basename(file_path),
+                'size': file_size,
+                'uuid': file_uuid
+            }
+            
+        except Exception as e:
+            print(f"Filen upload error: {e}")
+            return None
+    
+    def _get_base_folder(self):
+        """Get user's base folder"""
+        response = requests.get(
+            f"{self.base_url}/v3/user/baseFolder",
+            headers={"Authorization": f"Bearer {self.api_key}"}
+        )
+        
+        if response.status_code == 200:
+            return response.json()
+        return None
+    
+    def _encrypt_chunk(self, data, key):
+        """Encrypt a chunk of data"""
+        # Generate IV
+        iv = os.urandom(12)
+        
+        # Create cipher
+        cipher = Cipher(
+            algorithms.AES(key.encode()[:32]),
+            modes.GCM(iv),
+            backend=default_backend()
+        )
+        
+        encryptor = cipher.encryptor()
+        encrypted = encryptor.update(data) + encryptor.finalize()
+        
+        # Return IV + encrypted data + auth tag
+        return iv + encrypted + encryptor.tag
+    
+    def _upload_chunk(self, file_uuid, index, data, parent_uuid):
+        """Upload a single chunk"""
+        # Calculate hash
+        data_hash = hashlib.sha512(data).hexdigest()
+        
+        # Upload
+        response = requests.post(
+            f"{self.base_url}/v3/upload",
+            params={
+                "uuid": file_uuid,
+                "index": index,
+                "parent": parent_uuid,
+                "uploadKey": os.urandom(32).hex(),
+                "hash": data_hash
+            },
+            headers={"Authorization": f"Bearer {self.api_key}"},
+            data=data
+        )
+        
+        return response.status_code == 200
+    
+    def _complete_upload(self, file_uuid, filename, key, size, chunks, parent_uuid):
+        """Mark upload as complete"""
+        # Encrypt metadata
+        metadata = {
+            "name": filename,
+            "size": size,
+            "mime": "application/octet-stream",
+            "key": key
+        }
+        
+        encrypted_metadata = self._encrypt_metadata(json.dumps(metadata))
+        
+        response = requests.post(
+            f"{self.base_url}/v3/upload/done",
+            headers={"Authorization": f"Bearer {self.api_key}"},
+            json={
+                "uuid": file_uuid,
+                "name": encrypted_metadata,
+                "nameHashed": hashlib.sha512(filename.encode()).hexdigest(),
+                "size": size,
+                "chunks": chunks,
+                "mime": "application/octet-stream",
+                "rm": "",
+                "metadata": encrypted_metadata,
+                "version": 2,
+                "uploadKey": ""
+            }
+        )
+        
+        return response.status_code == 200
+    
+    def _encrypt_metadata(self, metadata):
+        """Encrypt metadata string"""
+        # Simplified - in production, use proper metadata encryption
+        return base64.b64encode(metadata.encode()).decode()