SecureStore

def derive_key(password: str, salt: bytes) -> bytes:
    kdf = Argon2id(
        salt=salt,
        length=CryptoPrimitives.KEY_LENGTH,
        iterations=CryptoPrimitives.TIME_COST,
        lanes=CryptoPrimitives.PARALLELISM,
        memory_cost=CryptoPrimitives.MEMORY_COST
    )
    return kdf.derive(password.encode('utf-8'))

def login_and_derive_keys(self, password: str, encrypt_salt: bytes) -> None:
    self.master_key = CryptoPrimitives.derive_key(password, encrypt_salt)
    self.kek = HKDF(
        algorithm=hashes.SHA256(),
        length=32,
        salt=None,
        info=CryptoPrimitives.KEK_INFO,
    ).derive(self.master_key)

CHUNK_SIZE = 4 * 1024 * 1024  # 4MB
        
chunks = [plaintext_data[i:i + CHUNK_SIZE] for i in range(0, len(plaintext_data), CHUNK_SIZE)]
if not chunks:
    chunks = [b'']
        
encrypted_blocks = []  # List of (hash, encrypted_data)
block_hashes = []
block_keys_metadata = []
        
kek_to_use = override_kek if override_kek else self.kek
if not kek_to_use:
     raise Exception("No KEK available for upload")
        
for i, chunk in enumerate(chunks):
    # A. Derive Key: HMAC-SHA256(SyncKey, Chunk)
    h = hmac.new(kek_to_use, chunk, hashlib.sha256)
    derived_key = h.digest()
            
    # B. Encrypt Chunk with Derived Key + STATIC ZERO IV
    chunk_iv = b'\x00' * 12
    cipher = Cipher(algorithms.AES(derived_key), modes.GCM(chunk_iv))
    encryptor = cipher.encryptor()
            
    ciphertext_chunk = encryptor.update(chunk) + encryptor.finalize()
    chunk_tag = encryptor.tag
            
    # Full encrypted block = ciphertext + tag
    encrypted_block = ciphertext_chunk + chunk_tag
            
    # Compute SHA-256 hash of the encrypted block
    block_hash = hashlib.sha256(encrypted_block).hexdigest()
            
    encrypted_blocks.append((block_hash, encrypted_block))

@app.post("/file/version/negotiate", response_model=NegotiateVersionResponse)
async def negotiate_version(
    request: NegotiateVersionRequest,
    db: Session = Depends(get_db),
    current_user: str = Depends(get_current_user)
):
    """
    Negotiate which blocks need to be uploaded for a new file version.
    Client sends list of block hashes, server responds with missing blocks.
    """
    try:
        # Query existing blocks
        existing_blocks = db.query(BlockOwner.block_hash).filter(
            BlockOwner.user_id == current_user,
            BlockOwner.block_hash.in_(request.blocks)
        ).all()
        existing_set = {b.block_hash for b in existing_blocks}
        
        missing = [h for h in request.blocks if h not in existing_set]
        
        logger.info(f"Version negotiate for {request.file_id}: {len(request.blocks)} blocks, {len(missing)} missing")
        return NegotiateVersionResponse(missing_blocks=missing)
        
    except Exception as e:
        logger.error(f"Version negotiate error: {e}")
        raise HTTPException(status_code=500, detail=str(e))

pub fn reconstruct_file(blocks: &[Block]) -> Vec<u8> {
    let mut sorted_blocks = blocks.to_vec();
    sorted_blocks.sort_by_key(|b| b.order);
    
    let total_size: usize = sorted_blocks.iter().map(|b| b.data.len()).sum();
    let mut result = Vec::with_capacity(total_size);
    
    for block in sorted_blocks {
        result.extend_from_slice(&block.data);
    }
    
    result
}

/// Compute the hash of a block's data
pub fn compute_block_hash(data: &[u8]) -> String {
    let mut hasher = Sha256::new();
    hasher.update(data);
    hex::encode(hasher.finalize())
}

async loginAndDeriveKeys(password, encryptSaltHex) {
    try {
        await this.ensureHashWasmLoaded();

        const encryptSalt = this.hexToBytes(encryptSaltHex);
        const mkBytes = await hashwasm.argon2id({
            password: password,
            salt: encryptSalt, 
            parallelism: CRYPTO_CONFIG.PARALLELISM,
            iterations: CRYPTO_CONFIG.TIME_COST,
            memorySize: CRYPTO_CONFIG.MEMORY_COST,
            hashLength: CRYPTO_CONFIG.HASH_LENGTH,
            outputType: 'binary' 
        });

        const masterKeyMaterial = await window.crypto.subtle.importKey(
            "raw", mkBytes, "HKDF", false, ["deriveKey"]
        );

        this.kek = await window.crypto.subtle.deriveKey(
            {
                name: "HKDF",
                hash: "SHA-256",
                salt: new Uint8Array(0), 
                info: CRYPTO_CONFIG.KEK_INFO
            },
            masterKeyMaterial,
            { name: "AES-GCM", length: 256 },
            true,
            ["encrypt", "decrypt", "wrapKey", "unwrapKey"]
        );