SecureStore

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)
    # Sent to Firebase instead of the password; independent of the KEK (different HKDF label)
    self.auth_key_hex = HKDF(
        algorithm=hashes.SHA256(),
        length=32,
        salt=None,
        info=CryptoPrimitives.AUTH_INFO,
    ).derive(self.master_key).hex()

for i, chunk in enumerate(chunks):
    h = hmac.new(kek_to_use, chunk, hashlib.sha256)
    derived_key = h.digest()
            
    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
            
    encrypted_block = ciphertext_chunk + chunk_tag
            
    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())
}

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", "deriveBits"]
);

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"]
);

// Sent to Firebase instead of the password; independent of the KEK (different HKDF label)
const authBits = await window.crypto.subtle.deriveBits(
    { name: "HKDF", hash: "SHA-256", salt: new Uint8Array(0), info: CRYPTO_CONFIG.AUTH_INFO },
    masterKeyMaterial,
    256
);
this.authKeyHex = this.bytesToHex(new Uint8Array(authBits));