Är det svårt att ladda ner e-böcker permanent?

    const K$e = class BBEncryptionMethod {
      constructor(e, t) {
        this.key = undefined;
        this.uid = undefined;
        this.userKey = null;
        this.userKeyPromise = undefined;
        this.key = e;
        this.uid = t;
        this.userKeyPromise = this.key === "" ? Promise.resolve(W$e.alloc(0)) : Q$e(this.key, this.uid);
      }
      async decrypt(e, t, n) {
        try {
          var r;
          this.userKey ||= await this.userKeyPromise;
          const t = "aes-128-cbc";
          const i = new Uint8Array(e.slice(0, 16));
          const o = W$e.from(e.slice(16));
          const a = (0, LG._7)(t, this.userKey, i);
          const s = W$e.concat([a.update(o), a.final()]);
          if (((r = n.encryptionProperties) == null ? undefined : r.compressionMethod) === 8) {
            return H$e.inflateRaw(s);
          }
          return s;
        } catch ($H) {
          zG("decrypt err", $H);
          throw $H;
        }
      }

import os
import zipfile
import shutil
from lxml import etree
from Crypto.Cipher import AES
import zlib

# Namespace map for Encryption.xml
NAMESPACES = {
    'enc': 'http://www.w3.org/2001/04/xmlenc#',
    'ds': 'http://www.w3.org/2000/09/xmldsig#',
    'comp': 'http://www.idpf.org/2016/encryption#compression'
}

def unzip_epub(epub_path, extract_dir):
    print(f"[+] Extracting EPUB '{epub_path}' to '{extract_dir}'")
    with zipfile.ZipFile(epub_path, 'r') as zip_ref:
        zip_ref.extractall(extract_dir)
    print("[+] Extraction done")

def zip_epub(folder_path, output_path):
    print(f"[+] Creating EPUB '{output_path}' from '{folder_path}'")
    with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
        for root, _, files in os.walk(folder_path):
            for file in files:
                full_path = os.path.join(root, file)
                arcname = os.path.relpath(full_path, folder_path)
                zipf.write(full_path, arcname)
    print("[+] EPUB repackaged")

def parse_encryption_xml(enc_xml_path):
    print(f"[+] Parsing Encryption.xml at '{enc_xml_path}'")
    tree = etree.parse(enc_xml_path)
    root = tree.getroot()
    encrypted_files = []

    for enc_data in root.findall('.//enc:EncryptedData', namespaces=NAMESPACES):
        cipher_ref = enc_data.find('.//enc:CipherReference', namespaces=NAMESPACES)
        if cipher_ref is None:
            print("[!] Found EncryptedData without CipherReference, skipping")
            continue
        uri = cipher_ref.get('URI')
        
        compression_elem = enc_data.find('.//enc:EncryptionProperty/comp:Compression', namespaces=NAMESPACES)
        compression = None
        original_length = None
        if compression_elem is not None:
            compression = compression_elem.get('Method')
            original_length = compression_elem.get('OriginalLength')

        encrypted_files.append({
            'URI': uri,
            'compression_method': compression,
            'original_length': int(original_length) if original_length else None
        })
        print(f"  -> Encrypted file: {uri}, compression: {compression}, original length: {original_length}")
    return encrypted_files

def remove_pkcs7_padding(data):
    pad_len = data[-1]
    if pad_len < 1 or pad_len > 16:
        raise ValueError(f"Invalid padding length: {pad_len}")
    if data[-pad_len:] != bytes([pad_len]) * pad_len:
        raise ValueError(f"Invalid PKCS7 padding bytes: {data[-pad_len:]}")
    return data[:-pad_len]

def decrypt_aes128_cbc(data, key):
    iv = data[:16]
    ciphertext = data[16:]
    print(f"[*] Using IV: {iv.hex()}")
    cipher = AES.new(key, AES.MODE_CBC, iv)
    decrypted = cipher.decrypt(ciphertext)
    try:
        unpadded = remove_pkcs7_padding(decrypted)
    except ValueError as e:
        print(f"    [!] Padding error: {e}")
        print("    [!] Returning raw decrypted data without padding removal")
        return decrypted
    return unpadded

def hexdump(data, length=20):
    return ' '.join(f'{b:02x}' for b in data[:length])

def decompress_if_needed(data, method):
    import zlib
    if method == "8":
        print(f"[*] First 20 bytes of decrypted data (hex): {hexdump(data)}")
        try:
            # Try decompress with zlib wrapper
            return zlib.decompress(data)
        except zlib.error:
            try:
                # Try raw deflate (wbits=-15)
                decompressed = zlib.decompress(data, wbits=-15)
                print("    [+] Successfully decompressed raw deflate data")
                return decompressed
            except zlib.error as e:
                print(f"    [!] Both zlib and raw deflate decompression failed: {e}")
                print("    [!] Returning raw decrypted data")
                return data
    else:
        print(f"[*] No or unknown compression method '{method}', skipping decompression")
        return data

def main(epub_path, secret_key, output_epub):
    workdir = 'tmp_epub_extracted'

    if os.path.exists(workdir):
        print(f"[!] Removing existing work directory '{workdir}'")
        shutil.rmtree(workdir)
    os.makedirs(workdir)

    unzip_epub(epub_path, workdir)

    encryption_xml_path = os.path.join(workdir, 'META-INF', 'encryption.xml')
    if not os.path.exists(encryption_xml_path):
        print("[!] No encryption.xml found, nothing to decrypt.")
        return

    encrypted_files = parse_encryption_xml(encryption_xml_path)

    for enc_file in encrypted_files:
        file_path = os.path.join(workdir, *enc_file['URI'].split('/'))
        if not os.path.exists(file_path):
            print(f"[!] Encrypted file '{enc_file['URI']}' not found, skipping")
            continue

        print(f"[+] Decrypting '{enc_file['URI']}'")
        with open(file_path, 'rb') as f:
            encrypted_data = f.read()

        print(f"[*] Encrypted data length: {len(encrypted_data)} bytes")
        decrypted_data = decrypt_aes128_cbc(encrypted_data, secret_key)
        print(f"[*] Decrypted data length: {len(decrypted_data)} bytes")
        
        decompressed_data = decompress_if_needed(decrypted_data, enc_file['compression_method'])
        print(f"[*] Final data length after decompression (if any): {len(decompressed_data)} bytes")

        with open(file_path, 'wb') as f:
            f.write(decompressed_data)
        print(f"    [+] Replaced encrypted file with decrypted content")

        enc_xml_path = os.path.join(workdir, 'META-INF', 'encryption.xml')
        if os.path.exists(enc_xml_path):
            print("[+] Removing encryption.xml to mark EPUB as decrypted")
            os.remove(enc_xml_path)

    zip_epub(workdir, output_epub)
    print(f"[+] Decrypted EPUB saved as '{output_epub}'")

if __name__ == "__main__":
    import sys
    if len(sys.argv) != 4:
        print("Usage: python decrypt_epub.py <encrypted.epub> <16-byte-hex-key> <output.epub>")
        print("Example key: 00112233445566778899aabbccddeeff")
        sys.exit(1)

    epub_path = sys.argv[1]
    key_hex = sys.argv[2]
    output_epub = sys.argv[3]

    key_bytes = bytes.fromhex(key_hex)
    if len(key_bytes) != 16:
        print("[!] Key must be 16 bytes (32 hex chars) for AES-128.")
        sys.exit(1)

    main(epub_path, key_bytes, output_epub)