Bugfix for Nook PDFs?

Co-authored-by: ZolaLa <49111160+ZolaLa9@users.noreply.github.com>

.github/ISSUE_TEMPLATE/QUESTION.md

@@ -1,33 +0,0 @@
----
-name: Question
-about: Questions for DeDRM Project
-title: "[QUESTION] Title"
-labels: Question
----
-
-## CheckList
-<!-- Check with `[x]` -->
-- [ ] `The Title` and The `Log Title` are setted correctly.
-- [ ] Clarified about `my environment`.
-- [ ] Code block is used for `the log`.
-<!-- If you don't know the version, please specify 'Unknown'. -->
-<!-- In case of markdown To use the code block, enclose it in ```. -->
-<!-- If you don't need Log, please delete the log section. -->
-
----
-
-## Title
-<!-- content -->
-
-## My Environment
-### Calibre: `Version`
-### Kindle: `Version`
-### DeDRM: `Version`
-
-## Log
-<details><summary>Log Title</summary>
-
-```log
-PUT YOUR LOG
-```
-</details>

.github/ISSUE_TEMPLATE/QUESTION.yml

@@ -0,0 +1,41 @@
+name: Question
+description: Questions for DeDRM Project
+body:
+  - type: textarea
+    id: question
+    attributes:
+      label: Question / bug report
+      description: Please enter your question / your bug report.
+  - type: input
+    id: calibre-version
+    attributes:
+      label: Which version of Calibre are you running?
+      description: "Example: 5.32"
+      placeholder: "5.32"
+    validations: 
+      required: true
+  - type: input
+    id: plugin-version
+    attributes:
+      label: Which version of the DeDRM plugin are you running?
+      description: "Example: v10.0.0"
+      placeholder: "v10.0.0"
+    validations: 
+      required: true
+  - type: input
+    id: kindle-version
+    attributes:
+      label: If applicable, which version of the Kindle software are you running?
+      description: "Example: 1.24"
+      placeholder: "Leave empty if unrelated to Kindle books"
+    validations: 
+      required: false
+  - type: textarea
+    id: log
+    attributes:
+      label: Log output
+      description: If applicable, please post your log output here - into the code block.
+      value: |
+        ```log
+        Paste log output here.
+        ```

.github/workflows/Format.yaml

@@ -1,39 +0,0 @@
-name: Python code format
-on: 
-  push:
-    branches: master
-jobs:
-  Format:
-    if: "contains(github.event.head_commit.message, '!format')"
-    runs-on: ubuntu-20.04
-    strategy:
-      fail-fast: false
-    steps:
-      - uses: actions/checkout@main
-      - name: Set up Python
-        uses: actions/setup-python@main
-        with:
-          python-version: 3.x
-      - uses: actions/cache@main
-        with:
-          path: ~/.cache/pip
-          key: ${{ runner.os }}-pip-format
-          restore-keys: |
-            ${{ runner.os }}-pip-format
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          python -m pip install autopep8 pycodestyle
-      - name: Format by autopep8 then Push
-        env:
-          GIT_EMAIL: github-actions[bot]@users.noreply.github.com
-          GIT_ACTOR: github-actions[bot]
-        run: |
-          export HASH_SHORT=$(git rev-parse --short HEAD)
-          git checkout -b format--${HASH_SHORT}
-          git config --global user.email $GIT_EMAIL
-          git config --global user.name  $GIT_ACTOR
-          python -m autopep8 --in-place --aggressive --aggressive --experimental -r ./
-          git add -A
-          git commit -m 'Format by autopep8' -m From: -m $(git rev-parse HEAD)
-          git push --set-upstream origin format--${HASH_SHORT}

.github/workflows/Lint.yaml

@@ -1,26 +0,0 @@
-name: Python code review
-on: [push, pull_request]
-jobs:
-  Test:
-    runs-on: ubuntu-20.04
-    strategy:
-      fail-fast: false
-    steps:
-      - uses: actions/checkout@main
-      - name: Set up Python
-        uses: actions/setup-python@main
-        with:
-          python-version: 3.x
-      - uses: actions/cache@main
-        with:
-          path: ~/.cache/pip
-          key: ${{ runner.os }}-pip-lint
-          restore-keys: |
-            ${{ runner.os }}-pip-lint
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install flake8
-      - name: Lint with flake8
-        run: |
-          python -m flake8 . --builtins=_,I --ignore=E501 --count --benchmark --show-source --statistics

.github/workflows/main.yml

@@ -0,0 +1,20 @@
+name: Package plugin
+on:
+  push:
+    branches: [ master ]
+
+jobs:
+  package:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Package
+        run: python3 make_release.py
+      - name: Upload
+        uses: actions/upload-artifact@v2
+        with: 
+          name: plugin
+          path: |
+            DeDRM_tools_*.zip
+            DeDRM_tools.zip

.gitignore

@@ -1 +1,9 @@
+# Mac files
 .DS_Store
+
+# local test data
+/user_data/
+
+# Cache
+/DeDRM_plugin/__pycache__
+/DeDRM_plugin/standalone/__pycache__

CALIBRE_CLI_INSTRUCTIONS.md

@@ -13,16 +13,16 @@ platforms.
 
 #### Install plugins
   - Download the DeDRM `.zip` archive from DeDRM_tools'
-     [latest release](https://github.com/apprenticeharper/DeDRM_tools/releases/latest).
+     [latest release](https://github.com/noDRM/DeDRM_tools/releases/latest).
      Then unzip it.
   - Add the DeDRM plugin to Calibre:
      ```
      cd *the unzipped DeDRM_tools folder*
-     calibre-customize --add DeDRM_calibre_plugin/DeDRM_plugin.zip
+     calibre-customize --add DeDRM_plugin.zip
      ```
   - Add the Obok plugin:
     ```
-    calibre-customize --add Obok_calibre_plugin/obok_plugin.zip
+    calibre-customize --add Obok_plugin.zip
     ```
 
 #### Enter your keys

CHANGELOG.md

@@ -0,0 +1,64 @@
+# Changelog
+
+List of changes since the fork of Apprentice Harper's repository: 
+
+## Fixes in v10.0.0 (2021-11-17):
+
+- CI testing / linting removed as that always failed anyways. The CI now "just" packages the plugin.
+- ~Support for the Readium LCP DRM (also known as "CARE DRM" or "TEA DRM"). This supports EPUB and PDF files. It does not yet support Readium LCPDF/LPF/LCPA/LCPAU/LCPDI files, as I don't have access to any of these. If you have an LCP-protected file in one of these formats that this plugin does not work with, please open [an issue](https://github.com/noDRM/DeDRM_tools/issues) and attach the file to the report.~ (removed due to a DMCA request, see #18 )
+- Add new Github issue report form which forces the user to include stuff like their Calibre version to hopefully increase the quality of bug reports.
+- Issues with PDF files in Calibre 5 should be fixed (merged [apprenticeharper/DeDRM_tools#1689](https://github.com/apprenticeharper/DeDRM_tools/pull/1689) ).
+- Fixed tons of issues with the B&N PDF DRM removal script ignoblepdf.py. It looks like that has never been tested since the move to Python3. I have integrated the B&N-specific code into ineptpdf.py, the original ignoblepdf.py is now unused. Fairly untested as I don't have any PDFs with B&N DRM.
+- Issues with Obok key retrieval fixed (merged [apprenticeharper/DeDRM_tools#1691](https://github.com/apprenticeharper/DeDRM_tools/pull/1691) ).
+- Issues with obfuscated Adobe fonts fixed (fixes [apprenticeharper/DeDRM_tools#1828](https://github.com/apprenticeharper/DeDRM_tools/issues/1828) ).
+- Deobfuscate font files in EPUBs by default (can be disabled in the plugin settings).
+- The standalone adobekey.py script now includes the account UUID in the key file name.
+- When extracting the default key from an ADE install, include the account UUID in the key name.
+- Adobe key management window size increased to account for longer key names due to the UUID.
+- Verify that the decrypted book key has the correct format. This makes it way less likely for issue [apprenticeharper/DeDRM_tools#1862](https://github.com/apprenticeharper/DeDRM_tools/issues/1862) to cause trouble.
+- If the Adobe owner UUID of a book being imported happens to be included in a particular key's name, try this key first before trying all the others. This completely fixes [apprenticeharper/DeDRM_tools#1862](https://github.com/apprenticeharper/DeDRM_tools/issues/1862), but only if the key name contains the correct UUID (not always the case, especially for keys imported with older versions of the plugin). It also makes DRM removal faster as the plugin no longer has to attempt all possible keys.
+- Remove some additional DRM remnants in Amazon MOBI files (merged [apprenticeharper/DeDRM_tools#23](https://github.com/apprenticeharper/DeDRM_tools/pull/23) ).
+- Just in case it's necessary, added a setting to the B&N key generation script to optionally allow the user to select the old key generation algorithm. Who knows, they might want to remove DRM from old books with the old key scheme.
+- Add a more verbose error message when trying to remove DRM from a book with the new, not-yet-cracked version of the Adobe ADEPT DRM.
+- Added back support for Python2 (Calibre 2.0+). Only tested with ADEPT (PDF & EPUB) and Readium LCP so far, please open an issue if there's errors with other book types.
+- Begin work on removing some kinds of watermarks from files after DRM removal. This isn't tested a lot, and is disabled by default. You can enable it in the plugin settings.
+- If you're using the [ACSM Input Plugin / DeACSM](https://www.mobileread.com/forums/showthread.php?t=341975), the encryption key will automatically be extracted from that plugin if necessary.
+
+## Fixes in v10.0.1 (2021-11-19): 
+
+- Hotfix update to fix broken EPUB DRM removal due to a typo.
+
+## Fixes in v10.0.2 (2021-11-29):
+
+- Fix Kindle for Mac key retrieval (merged [apprenticeharper/DeDRM_tools#1936](https://github.com/apprenticeharper/DeDRM_tools/pull/1936) ), fixing #1. 
+- Fix Adobe key retrieval in case the username has been changed (merged [apprenticeharper/DeDRM_tools#1946](https://github.com/apprenticeharper/DeDRM_tools/pull/1946) ). This should fix the error "failed to decrypt user key key".
+- Fix small issue with elibri watermark removal.
+- Adobe key name will now contain account email.
+
+## Fixes on master (not yet released):
+
+- Fix issue where importing a key from Adobe Digital Editions would fail in Python2 (Calibre < 5) if there were non-ASCII characters in the username.
+- Add code to support importing multiple decryption keys from ADE.
+- Improve epubtest.py to also detect Kobo & Apple DRM.
+- ~Small updates to the LCP DRM error messages.~ (removed due to a DMCA request, see #18 ).
+- Merge ignobleepub into ineptepub so there's no duplicate code.
+- Support extracting the B&N / Nook key from the NOOK Microsoft Store application (based on [this script](https://github.com/noDRM/DeDRM_tools/discussions/9) by fesiwi).
+- Support extracting the B&N / Nook key from a data dump of the NOOK Android application.
+- Support adding an existing PassHash / B&N key base64 string without having to write it to a file first.
+- Support extracting PassHash keys from Adobe Digital Editions.
+- Fix a bug that might have stopped the eReader PDB DRM removal from working (untested, I don't have any PDB books)
+- Fix a bug where the watermark removal code wouldn't run for DRM-free files.
+- ineptpdf: Add code to plugin to support "Standard" (tested) and "Adobe.APS" (untested) encrypted PDFs using the ineptpdf implementation (PDF passwords can be entered in the plugin settings)
+- ineptpdf: Support for decrypting PDF with owner password instead of user password.
+- ineptpdf: Add function to return Filter name.
+- ineptpdf: Support for V=5, R=5 and R=6 PDF files, and for AES256-encrypted PDFs.
+- ineptpdf: Disable cross-reference streams in the output file. This may make PDFs slightly larger, but the current code for cross-reference streams seems to be buggy and sometimes creates corrupted PDFs.
+- Drop support for importing key data from the ancient, pre "DeDRM" Calibre plugins ("Ignoble Epub DeDRM", "eReader PDB 2 PML" and "K4MobiDeDRM"). These are from 2011, I doubt anyone still has these installed, I can't even find a working link for these to test them. If you still have encryption keys in one of these plugins, you will need to update to DeDRM v10.0.2 or older (to convert the keys) before updating to DeDRM v10.0.3 or newer.
+- Some Python3 bugfixes for Amazon books (merged #10 by ableeker).
+- Fix a bug where extracting an Adobe key from ADE on Linux through Wine did fail when using the OpenSSL backend (instead of PyCrypto). See #13 and #14 for details, thanks acaloiaro for the bugfix.
+- Make the plugin work on Calibre 6 (Qt 6). If you're running the Calibre 6 beta and you notice any issues, please open a bug report.
+- Fix IndexError when DeDRMing some Amazon eBooks.
+- Add support for books with the new ADE3.0+ DRM by merging #48 by a980e066a01. Thanks a lot!
+- Remove OpenSSL support, now the plugin will always use the Python crypto libraries.
+- Obok: Fix issues with invalid UTF-8 characters by merging #26 by baby-bell.
+- Try to fix PDF files with V3 key obfuscation algorithm.

DeDRM_plugin/DeDRM_ADE PassHash Key_Help.htm

@@ -0,0 +1,68 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+	"http://www.w3.org/TR/html4/strict.dtd">
+
+<html>
+
+<head>
+<meta http-equiv="content-type" content="text/html; charset=utf-8">
+<title>Managing Adobe PassHash (B&N) Keys</title>
+<style type="text/css">
+span.version {font-size: 50%}
+span.bold {font-weight: bold}
+h3 {margin-bottom: 0}
+p {margin-top: 0}
+li {margin-top: 0.5em}
+</style>
+</head>
+
+<body>
+
+<h1>Managing Adobe PassHash Keys</h1>
+
+<p>Adobe PassHash is a variant of the Adobe DRM which is used by retailers like Barnes and Noble. Instead of using certificates and device-based authorization, this uses a username and password combination. In B&&Ns implementation however, the user never gets access to these credentials, just to the credential hash.</p>
+
+<h3>Changes at Barnes & Noble</h3>
+
+<p>Since 2014, Barnes & Noble is no longer using the default Adobe key generation algorithm, which used to be the full name as "username" and the full credit card number as "password" for the PassHash algorithm. 
+Instead, they started generating a random key on their server and send that to the reading application during login. This means that the old method to decrypt these books will no longer work. </p>
+
+<p>There used to be a way to use the Android app's API to simulate a login to the Barnes and Noble servers, but that API has been shut down a while ago, too, and so far nobody has reverse-engineered the new one.</p>
+
+<h3>Importing PassHash / B&N keys</h3>
+
+<p>On the right-hand side of the plugin’s customization dialog, you will see a button with an icon that looks like a green plus sign (+). Clicking this button will open a new dialog for entering the necessary data to generate a new key.</p>
+<p>Currently, the only known ways to access the key are the following:</p>
+<ul>
+	<li>B&N: The encryption key can be extracted from the NOOK reading application available in the Microsoft store, or from the old "Nook Study" application. To do that, click on the "Extract key from Nook Windows application" option.</li>
+	<li>B&N: The encryption key can also be extracted from a data backup of the NOOK Android application. To do that, you'll need to have a rooted Android device, a hacked / modified Nook APK file, or an Android emulator to be able to access the app data. If you have that, click on "Extract key from Nook Android application" and follow the instructions.</li>
+	<li>B&N: The NOOK Android application supports / accepts user-added CA certificates, so you can set up something like mitmproxy on your computer, tunnel your phone's traffic through that, and extract the ccHash key data from the server response. You can then add that hash through the "Base64-encoded PassHash key string" option.</li>
+	<li>If you already have a copy of the Nook ccHash key string (or, more general, the PassHash key string) in base64 encoding, you can either click on "Import existing keyfiles" if it's a file in b64 format, or you click on the "Base64-encoded PassHash key string" option while adding a new PassHash key.</li>
+	<li>For retailers other than B&N that are using the PassHash algorihm as intended, you can click on "Adobe PassHash username & password" to enter your credentials while adding a key. This is the same algorihm as the original credit card number based key generation for B&N.</li>
+	<li>Windows only: If you've successfully opened a PassHash-encrypted book in Adobe Digital Editions by entering username and password, you can dump the stored credentials from ADE.</li>
+</ul>
+
+
+<p>After you've selected a key retrieval method from the settings, the dialog may change and request some additional information depending on the key retrieval method. Enter that, then click the OK button to create and store the generated key. Or Cancel if you don’t want to create a key.</p>
+<p>New keys are checked against the current list of keys before being added, and duplicates are discarded.</p>
+
+<h3>Deleting Keys:</h3>
+
+<p>On the right-hand side of the plugin’s customization dialog, you will see a button with an icon that looks like a red "X". Clicking this button will delete the highlighted key in the list. You will be prompted once to be sure that’s what you truly mean to do. Once gone, it’s permanently gone.</p>
+
+<h3>Renaming Keys:</h3>
+
+<p>On the right-hand side of the plugin’s customization dialog, you will see a button with an icon that looks like a sheet of paper. Clicking this button will prompt you to enter a new name for the highlighted key in the list. Enter the new name for the encryption key and click the OK button to use the new name, or Cancel to revert to the old name..</p>
+
+<h3>Exporting Keys:</h3>
+
+<p>On the right-hand side of the plugin’s customization dialog, you will see a button with an icon that looks like a computer’s hard-drive. Use this button to export the highlighted key to a file (with a ‘.b64’ file name extension). Used for backup purposes or to migrate key data to other computers/calibre installations. The dialog will prompt you for a place to save the file.</p>
+
+<h3>Importing Existing Keyfiles:</h3>
+
+<p>At the bottom-left of the plugin’s customization dialog, you will see a button labeled "Import Existing Keyfiles". Use this button to import existing ‘.b64’ key files. Key files might come from being exported from this or older plugins, or may have been generated using the original i♥cabbages script, or you may have made it by following the instructions above.</p>
+
+<p>Once done creating/deleting/renaming/importing decryption keys, click Close to exit the customization dialogue. Your changes will only be saved permanently when you click OK in the main configuration dialog.</p>
+
+</body>
+
+</html>

DeDRM_plugin/DeDRM_Barnes and Noble Key_Help.htm

@@ -1,68 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
-	"http://www.w3.org/TR/html4/strict.dtd">
-
-<html>
-
-<head>
-<meta http-equiv="content-type" content="text/html; charset=utf-8">
-<title>Managing Barnes and Noble Keys</title>
-<style type="text/css">
-span.version {font-size: 50%}
-span.bold {font-weight: bold}
-h3 {margin-bottom: 0}
-p {margin-top: 0}
-li {margin-top: 0.5em}
-</style>
-</head>
-
-<body>
-
-<h1>Managing Barnes and Noble Keys</h1>
-
-
-<p>If you have upgraded from an earlier version of the plugin, any existing Barnes and Noble keys will have been automatically imported, so you might not need to do any more configuration. Continue reading for key generation and management instructions.</p>
-
-<h3>Changes at Barnes & Noble</h3>
-
-<p>In mid-2014, Barnes & Noble changed the way they generated encryption keys. Instead of deriving the key from the user's name and credit card number, they started generating a random key themselves, sending that key through to devices when they connected to the Barnes & Noble servers. This means that most users will now find that no combination of their name and CC# will work in decrypting their recently downloaded ebooks.</p>
-
-<p>Someone commenting at Apprentice Alf's blog detailed a way to retrieve a new account key using the account's email address and password. This method has now been incorporated into the plugin.
-
-<h3>Creating New Keys:</h3>
-
-<p>On the right-hand side of the plugin’s customization dialog, you will see a button with an icon that looks like a green plus sign (+). Clicking this button will open a new dialog for entering the necessary data to generate a new key.</p>
-<ul>
-<li><span class="bold">Unique Key Name:</span> this is a unique name you choose to help you identify the key. This name will show in the list of configured keys. Choose something that will help you remember the data (account email address) it was created with.</li>
-<li><span class="bold">B&N/nook account email address:</span> This is the default email address for your Barnes and Noble/nook account. This email will not be stored anywhere on your computer or in calibre. It will only be used to fetch the account key that from the B&N server, and it is that key that will be stored in the preferences.</li>
-<li><span class="bold">B&N/nook account password:</span> this is the password for your Barnes and Noble/nook account. As with the email address, this will not be stored anywhere on your computer or in calibre. It will only be used to fetch the key from the B&N server.</li>
-</ul>
-
-<p>Click the OK button to create and store the generated key. Or Cancel if you don’t want to create a key.</p>
-<p>New keys are checked against the current list of keys before being added, and duplicates are discarded.</p>
-
-<h3>Deleting Keys:</h3>
-
-<p>On the right-hand side of the plugin’s customization dialog, you will see a button with an icon that looks like a red "X". Clicking this button will delete the highlighted key in the list. You will be prompted once to be sure that’s what you truly mean to do. Once gone, it’s permanently gone.</p>
-
-<h3>Renaming Keys:</h3>
-
-<p>On the right-hand side of the plugin’s customization dialog, you will see a button with an icon that looks like a sheet of paper. Clicking this button will prompt you to enter a new name for the highlighted key in the list. Enter the new name for the encryption key and click the OK button to use the new name, or Cancel to revert to the old name..</p>
-
-<h3>Exporting Keys:</h3>
-
-<p>On the right-hand side of the plugin’s customization dialog, you will see a button with an icon that looks like a computer’s hard-drive. Use this button to export the highlighted key to a file (with a ‘.b64’ file name extension). Used for backup purposes or to migrate key data to other computers/calibre installations. The dialog will prompt you for a place to save the file.</p>
-
-<h3>Importing Existing Keyfiles:</h3>
-
-<p>At the bottom-left of the plugin’s customization dialog, you will see a button labeled "Import Existing Keyfiles". Use this button to import existing ‘.b64’ key files. Key files might come from being exported from this or older plugins, or may have been generated using the original i♥cabbages script, or you may have made it by following the instructions above.</p>
-
-<p>Once done creating/deleting/renaming/importing decryption keys, click Close to exit the customization dialogue. Your changes will only be saved permanently when you click OK in the main configuration dialog.</p>
-
-<h3>NOOK Study</h3>
-<p>Books downloaded through NOOK Study may or may not use the key found using the above method. If a book is not decrypted successfully with any of the keys, the plugin will attempt to recover keys from the NOOK Study log file and use them.</p>
-
-
-
-</body>
-
-</html>

DeDRM_plugin/DeDRM_Help.htm

@@ -17,15 +17,19 @@ p {margin-top: 0}
 
 <body>
 
-<h1>DeDRM Plugin <span class="version">(v6.7.0)</span></h1>
+<h1>DeDRM Plugin <span class="version">(v10.0.2)</span></h1>
 
 <p>This plugin removes DRM from ebooks when they are imported into calibre. If you already have DRMed ebooks in your calibre library, you will need to remove them and import them again.</p>
 
+<p>It is a forked version created by NoDRM, based on the original plugin by Apprentice Alf and Apprentice Harper.</p>
+
 <h3>Installation</h3>
 <p>You have obviously managed to install the plugin, as otherwise you wouldn’t be reading this help file. However, you should also delete any older DRM removal plugins, as this DeDRM plugin replaces the five older plugins: Kindle and Mobipocket DeDRM (K4MobiDeDRM), Ignoble Epub DeDRM (ignobleepub), Inept Epub DeDRM (ineptepub), Inept PDF DeDRM (ineptepub) and eReader PDB 2 PML (eReaderPDB2PML).</p>
 
 <h3>Configuration</h3>
-<p>On Windows and Mac, the keys for ebooks downloaded for Kindle for Mac/PC and Adobe Digital Editions are automatically generated. If all your DRMed ebooks can be opened and read in Kindle for Mac/PC and/or Adobe Digital Editions on the same computer on which you are running calibre, you do not need to do any configuration of this plugin. On Linux, keys for Kindle for PC and Adobe Digital Editions need to be generated separately (see the Linux section below)</p>
+<p>On Windows and Mac, the keys for ebooks downloaded for Kindle for Mac/PC and Adobe Digital Editions are automatically generated. If all your DRMed ebooks can be opened and read in Kindle for Mac/PC and/or Adobe Digital Editions on the same computer on which you are running calibre, you do not need to do any configuration of this plugin. On Linux, keys for Kindle for PC and Adobe Digital Editions need to be generated separately (see the Linux section below).</p>
+
+<p>If you are using the <a href="https://www.mobileread.com/forums/showthread.php?t=341975">DeACSM / ACSM Input Plugin</a> for Calibre, the keys will also automatically be dumped for you.</p>
 
 <p>If you have other DRMed ebooks, you will need to enter extra configuration information. The buttons in this dialog will open individual configuration dialogs that will allow you to enter the needed information, depending on the type and source of your DRMed eBooks. Additional help on the information required is available in each of the the dialogs.</p>
 
@@ -42,11 +46,12 @@ p {margin-top: 0}
 
 <h3>Credits:</h3>
 <ul>
+<li>NoDRM for a bunch of updates and maintenance since November 2021, and the Readium LCP support</li>
 <li>The Dark Reverser for the Mobipocket and eReader scripts</li>
 <li>i♥cabbages for the Adobe Digital Editions scripts</li>
 <li>Skindle aka Bart Simpson for the Amazon Kindle for PC script</li>
 <li>CMBDTC for Amazon Topaz DRM removal script</li>
-<li>some_updates, clarknova and Bart Simpson for  Amazon Topaz conversion scripts</li>
+<li>some_updates, clarknova and Bart Simpson for Amazon Topaz conversion scripts</li>
 <li>DiapDealer for the first calibre plugin versions of the tools</li>
 <li>some_updates, DiapDealer, Apprentice Alf and mdlnx for Amazon Kindle/Mobipocket tools</li>
 <li>some_updates for the DeDRM all-in-one Python tool</li>
@@ -55,7 +60,8 @@ p {margin-top: 0}
 <li>And probably many more.</li>
 </ul>
 
-<h3> For additional help read the <a href="https://github.com/apprenticeharper/DeDRM_tools/blob/master/FAQs.md">FAQs</a> at <a href="https://github.com/apprenticeharper/DeDRM_tools/">Apprentice Harpers’s GitHub repository</a>. You can ask questions in the comments section of the <a href="http://apprenticealf.wordpress.com/2012/09/10/drm-removal-tools-for-ebooks/">first post</a> at <a href="http://wordpress.com/apprenticealf/">Apprentice Alf's blog</a> or <a href="https://github.com/apprenticeharper/DeDRM_tools/issues">raise an issue</a>. </h3>
+<h3>For additional help read the <a href="https://github.com/noDRM/DeDRM_tools/blob/master/FAQs.md">FAQs</a> at <a href="https://github.com/noDRM/DeDRM_tools">NoDRM's GitHub repository</a> (or the corresponding <a href="https://github.com/apprenticeharper/DeDRM_tools/blob/master/FAQs.md">FAQs</a> at <a href="https://github.com/apprenticeharper/DeDRM_tools/">Apprentice Harpers’s GitHub repository</a>). You can <a href="https://github.com/noDRM/DeDRM_tools/issues">open issue reports</a>related to this fork at NoDRM's GitHub repository.</h3>
+
 
 <h2>Linux Systems Only</h2>
 <h3>Generating decryption keys for Adobe Digital Editions and Kindle for PC</h3>

DeDRM_plugin/DeDRM_Mobipocket PID_Help.htm

@@ -35,7 +35,7 @@ li {margin-top: 0.5em}
 
 <p>On the right-hand side of the plugin’s customization dialog, you will see a button with an icon that looks like a red "X". Clicking this button will delete the highlighted Mobipocket PID from the list. You will be prompted once to be sure that’s what you truly mean to do. Once gone, it’s permanently gone.</p>
 
-<p>Once done creating/deleting PIDs, click Close to exit the customization dialogue. Your changes wil only be saved permanently when you click OK in the main configuration dialog.</p>
+<p>Once done creating/deleting PIDs, click Close to exit the customization dialogue. Your changes will only be saved permanently when you click OK in the main configuration dialog.</p>
 
 </body>
 

DeDRM_plugin/DeDRM_PDF passphrase_Help.htm

@@ -0,0 +1,39 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+	"http://www.w3.org/TR/html4/strict.dtd">
+
+<html>
+
+<head>
+<meta http-equiv="content-type" content="text/html; charset=utf-8">
+<title>Managing PDF passwords</title>
+<style type="text/css">
+span.version {font-size: 50%}
+span.bold {font-weight: bold}
+h3 {margin-bottom: 0}
+p {margin-top: 0}
+li {margin-top: 0.5em}
+</style>
+</head>
+
+<body>
+
+<h1>Managing PDF passwords</h1>
+
+<p>PDF files can be protected with a password / passphrase that will be required to open the PDF file. Enter your passphrases in the plugin settings to have the plugin automatically remove this encryption / restriction from PDF files you import. </p>
+
+
+<h3>Entering a passphrase:</h3>
+
+<p>On the right-hand side of the plugin’s customization dialog, you will see a button with an icon that looks like a green plus sign (+). Clicking this button will open a new dialog for entering a new passphrase.</p>
+
+<p>Just enter your passphrase for the PDF file, then click the OK button to save the passphrase. </p>
+
+<h3>Deleting a passphrase:</h3>
+
+<p>On the right-hand side of the plugin’s customization dialog, you will see a button with an icon that looks like a red "X". Clicking this button will delete the highlighted passphrase from the list. You will be prompted once to be sure that’s what you truly mean to do. Once gone, it’s permanently gone.</p>
+
+<p>Once done entering/deleting passphrases, click Close to exit the customization dialogue. Your changes will only be saved permanently when you click OK in the main configuration dialog.</p>
+
+</body>
+
+</html>

DeDRM_plugin/DeDRM_Readium LCP passphrase_Help.htm

@@ -0,0 +1,42 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+	"http://www.w3.org/TR/html4/strict.dtd">
+
+<html>
+
+<head>
+<meta http-equiv="content-type" content="text/html; charset=utf-8">
+<title>Managing Readium LCP passphrases</title>
+<style type="text/css">
+span.version {font-size: 50%}
+span.bold {font-weight: bold}
+h3 {margin-bottom: 0}
+p {margin-top: 0}
+li {margin-top: 0.5em}
+</style>
+</head>
+
+<body>
+
+<h1>Managing Readium LCP passphrases</h1>
+
+<p>Readium LCP is a relatively new eBook DRM. It's also known under the names "CARE DRM" or "TEA DRM". It does not rely on any accounts or key data that's difficult to acquire. All you need to open (or decrypt) LCP eBooks is the account passphrase given to you by the eBook provider - the very same passphrase you'd have to enter into your eBook reader device (once) to read LCP-encrypted books.</p>
+
+<p>This plugin no longer supports removing the Readium LCP DRM due to a DMCA takedown request issued by Readium. Please read the <a href="https://github.com/github/dmca/blob/master/2022/01/2022-01-04-readium.md">takedown notice</a> or <a href="https://github.com/noDRM/DeDRM_tools/issues/18">this bug report</a> for more information.</p>
+
+<h3>Entering an LCP passphrase:</h3>
+
+<p>On the right-hand side of the plugin’s customization dialog, you will see a button with an icon that looks like a green plus sign (+). Clicking this button will open a new dialog for entering a new passphrase.</p>
+
+<p>Just enter your passphrase as provided with the book, then click the OK button to save the passphrase. </p>
+
+<p>Usually, passphrases are identical for all books bought with the same account. So if you buy multiple LCP-protected eBooks, they'll usually all have the same passphrase if they've all been bought at the same store with the same account. </p>
+
+<h3>Deleting an LCP passphrase:</h3>
+
+<p>On the right-hand side of the plugin’s customization dialog, you will see a button with an icon that looks like a red "X". Clicking this button will delete the highlighted passphrase from the list. You will be prompted once to be sure that’s what you truly mean to do. Once gone, it’s permanently gone.</p>
+
+<p>Once done entering/deleting passphrases, click Close to exit the customization dialogue. Your changes will only be saved permanently when you click OK in the main configuration dialog.</p>
+
+</body>
+
+</html>

DeDRM_plugin/__calibre_compat_code.py

@@ -0,0 +1,20 @@
+
+#@@CALIBRE_COMPAT_CODE_START@@
+import sys, os
+
+# Explicitly allow importing everything ...
+if os.path.dirname(os.path.dirname(os.path.abspath(__file__))) not in sys.path:
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+if os.path.dirname(os.path.abspath(__file__)) not in sys.path:
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Bugfix for Calibre < 5:
+if "calibre" in sys.modules and sys.version_info[0] == 2:
+    from calibre.utils.config import config_dir
+    if os.path.join(config_dir, "plugins", "DeDRM.zip") not in sys.path:
+        sys.path.insert(0, os.path.join(config_dir, "plugins", "DeDRM.zip"))
+
+# Explicitly set the package identifier so we are allowed to import stuff ...
+#__package__ = "DeDRM_plugin"
+
+#@@CALIBRE_COMPAT_CODE_END@@

DeDRM_plugin/__main__.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# __main__.py for DeDRM_plugin
+# (CLI interface without Calibre)
+# Copyright © 2021 NoDRM
+
+__license__   = 'GPL v3'
+__docformat__ = 'restructuredtext en'
+
+# For revision history see __init__.py
+
+"""
+Run DeDRM plugin without Calibre.
+"""
+
+# Import __init__.py from the standalone folder so we can have all the 
+# standalone / non-Calibre code in that subfolder.
+
+import standalone.__init__ as mdata
+import sys
+
+mdata.main(sys.argv)

DeDRM_plugin/__version.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+#@@CALIBRE_COMPAT_CODE@@
+
+PLUGIN_NAME = "DeDRM"
+__version__ = '10.0.2'
+
+PLUGIN_VERSION_TUPLE = tuple([int(x) for x in __version__.split(".")])
+PLUGIN_VERSION = ".".join([str(x)for x in PLUGIN_VERSION_TUPLE])
+# Include an html helpfile in the plugin's zipfile with the following name.
+RESOURCE_NAME = PLUGIN_NAME + '_Help.htm'

DeDRM_plugin/_unused_activitybar.py

@@ -1,3 +1,5 @@
+# I think this file is unused?
+
 import sys
 import tkinter
 import tkinter.constants

DeDRM_plugin/_unused_scrolltextwidget.py

@@ -1,6 +1,9 @@
 #!/usr/bin/env python
 # vim:ts=4:sw=4:softtabstop=4:smarttab:expandtab
 
+# I think this file is unused?
+
+
 import tkinter
 import tkinter.constants
 

DeDRM_plugin/adobekey.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-# adobekey.pyw, version 6.0
-# Copyright © 2009-2020 i♥cabbages, Apprentice Harper et al.
+# adobekey.pyw, version 7.4
+# Copyright © 2009-2022 i♥cabbages, Apprentice Harper et al.
 
 # Released under the terms of the GNU General Public Licence, version 3
 # <http://www.gnu.org/licenses/>
@@ -29,13 +29,17 @@
 #   5.9 - moved unicode_argv call inside main for Windows DeDRM compatibility
 #   6.0 - Work if TkInter is missing
 #   7.0 - Python 3 for calibre 5
+#   7.1 - Fix "failed to decrypt user key key" error (read username from registry)
+#   7.2 - Fix decryption error on Python2 if there's unicode in the username
+#   7.3 - Fix OpenSSL in Wine
+#   7.4 - Remove OpenSSL support to only support PyCryptodome
 
 """
 Retrieve Adobe ADEPT user key.
 """
 
 __license__ = 'GPL v3'
-__version__ = '7.0'
+__version__ = '7.4'
 
 import sys, os, struct, getopt
 from base64 import b64decode
@@ -51,11 +55,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data, str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 
@@ -99,7 +109,7 @@ def unicode_argv():
         return ["adobekey.py"]
     else:
         argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
+        return [arg if (isinstance(arg, str) or isinstance(arg,unicode)) else str(arg, argvencoding) for arg in sys.argv]
 
 class ADEPTError(Exception):
     pass
@@ -111,72 +121,23 @@ if iswindows:
         c_long, c_ulong
 
     from ctypes.wintypes import LPVOID, DWORD, BOOL
-    import winreg
+    try:
+        import winreg
+    except ImportError:
+        import _winreg as winreg
 
-    def _load_crypto_libcrypto():
-        from ctypes.util import find_library
-        libcrypto = find_library('libeay32')
-        if libcrypto is None:
-            raise ADEPTError('libcrypto not found')
-        libcrypto = CDLL(libcrypto)
-        AES_MAXNR = 14
-        c_char_pp = POINTER(c_char_p)
-        c_int_p = POINTER(c_int)
-        class AES_KEY(Structure):
-            _fields_ = [('rd_key', c_long * (4 * (AES_MAXNR + 1))),
-                        ('rounds', c_int)]
-        AES_KEY_p = POINTER(AES_KEY)
+    try:
+        from Cryptodome.Cipher import AES
+    except ImportError:
+        from Crypto.Cipher import AES
 
-        def F(restype, name, argtypes):
-            func = getattr(libcrypto, name)
-            func.restype = restype
-            func.argtypes = argtypes
-            return func
-
-        AES_set_decrypt_key = F(c_int, 'AES_set_decrypt_key',
-                                [c_char_p, c_int, AES_KEY_p])
-        AES_cbc_encrypt = F(None, 'AES_cbc_encrypt',
-                            [c_char_p, c_char_p, c_ulong, AES_KEY_p, c_char_p,
-                             c_int])
-        class AES(object):
-            def __init__(self, userkey):
-                self._blocksize = len(userkey)
-                if (self._blocksize != 16) and (self._blocksize != 24) and (self._blocksize != 32) :
-                    raise ADEPTError('AES improper key used')
-                key = self._key = AES_KEY()
-                rv = AES_set_decrypt_key(userkey, len(userkey) * 8, key)
-                if rv < 0:
-                    raise ADEPTError('Failed to initialize AES key')
-            def decrypt(self, data):
-                out = create_string_buffer(len(data))
-                iv = (b"\x00" * self._blocksize)
-                rv = AES_cbc_encrypt(data, out, len(data), self._key, iv, 0)
-                if rv == 0:
-                    raise ADEPTError('AES decryption failed')
-                return out.raw
-        return AES
-
-    def _load_crypto_pycrypto():
-        from Crypto.Cipher import AES as _AES
-        class AES(object):
-            def __init__(self, key):
-                self._aes = _AES.new(key, _AES.MODE_CBC, b'\x00'*16)
-            def decrypt(self, data):
-                return self._aes.decrypt(data)
-        return AES
-
-    def _load_crypto():
-        AES = None
-        for loader in (_load_crypto_pycrypto, _load_crypto_libcrypto):
-            try:
-                AES = loader()
-                break
-            except (ImportError, ADEPTError):
-                pass
-        return AES
-
-    AES = _load_crypto()
+    def unpad(data, padding=16):
+        if sys.version_info[0] == 2:
+            pad_len = ord(data[-1])
+        else:
+            pad_len = data[-1]
 
+        return data[:-pad_len]
 
     DEVICE_KEY_PATH = r'Software\Adobe\Adept\Device'
     PRIVATE_LICENCE_KEY_PATH = r'Software\Adobe\Adept\Activation'
@@ -226,6 +187,27 @@ if iswindows:
         return GetUserName
     GetUserName = GetUserName()
 
+    def GetUserName2():
+        try:
+            from winreg import OpenKey, QueryValueEx, HKEY_CURRENT_USER
+        except ImportError:
+            # We're on Python 2
+            try:
+                # The default _winreg on Python2 isn't unicode-safe.
+                # Check if we have winreg_unicode, a unicode-safe alternative. 
+                # Without winreg_unicode, this will fail with Unicode chars in the username.
+                from adobekey_winreg_unicode import OpenKey, QueryValueEx, HKEY_CURRENT_USER
+            except:
+                from _winreg import OpenKey, QueryValueEx, HKEY_CURRENT_USER
+
+        try: 
+            DEVICE_KEY_PATH = r'Software\Adobe\Adept\Device'
+            regkey = OpenKey(HKEY_CURRENT_USER, DEVICE_KEY_PATH)
+            userREG = QueryValueEx(regkey, 'username')[0].encode('utf-16-le')[::2]
+            return userREG
+        except: 
+            return None
+
     PAGE_EXECUTE_READWRITE = 0x40
     MEM_COMMIT  = 0x1000
     MEM_RESERVE = 0x2000
@@ -263,8 +245,13 @@ if iswindows:
 
         def __del__(self):
             if self._buf is not None:
-                VirtualFree(self._buf)
-                self._buf = None
+                try: 
+                    VirtualFree(self._buf)
+                    self._buf = None
+                except TypeError:
+                    # Apparently this sometimes gets cleared on application exit
+                    # Causes a useless exception in the log, so let's just catch and ignore that.
+                    pass
 
     if struct.calcsize("P") == 4:
         CPUID0_INSNS = (
@@ -343,54 +330,76 @@ if iswindows:
     CryptUnprotectData = CryptUnprotectData()
 
     def adeptkeys():
-        if AES is None:
-            raise ADEPTError("PyCrypto or OpenSSL must be installed")
         root = GetSystemDirectory().split('\\')[0] + '\\'
         serial = GetVolumeSerialNumber(root)
         vendor = cpuid0()
         signature = struct.pack('>I', cpuid1())[1:]
-        user = GetUserName()
+        user = GetUserName2()
+        if user is None: 
+            user = GetUserName()
         entropy = struct.pack('>I12s3s13s', serial, vendor, signature, user)
         cuser = winreg.HKEY_CURRENT_USER
         try:
             regkey = winreg.OpenKey(cuser, DEVICE_KEY_PATH)
             device = winreg.QueryValueEx(regkey, 'key')[0]
-        except WindowsError:
+        except (WindowsError, FileNotFoundError):
             raise ADEPTError("Adobe Digital Editions not activated")
         keykey = CryptUnprotectData(device, entropy)
         userkey = None
         keys = []
+        names = []
         try:
             plkroot = winreg.OpenKey(cuser, PRIVATE_LICENCE_KEY_PATH)
-        except WindowsError:
+        except (WindowsError, FileNotFoundError):
             raise ADEPTError("Could not locate ADE activation")
-        for i in range(0, 16):
+
+        i = -1
+        while True:
+            i = i + 1   # start with 0
             try:
                 plkparent = winreg.OpenKey(plkroot, "%04d" % (i,))
-            except WindowsError:
+            except:
+                # No more keys
                 break
+                
             ktype = winreg.QueryValueEx(plkparent, None)[0]
             if ktype != 'credentials':
                 continue
+            uuid_name = ""
             for j in range(0, 16):
                 try:
                     plkkey = winreg.OpenKey(plkparent, "%04d" % (j,))
-                except WindowsError:
+                except (WindowsError, FileNotFoundError):
                     break
                 ktype = winreg.QueryValueEx(plkkey, None)[0]
-                if ktype != 'privateLicenseKey':
-                    continue
-                userkey = winreg.QueryValueEx(plkkey, 'value')[0]
-                userkey = b64decode(userkey)
-                aes = AES(keykey)
-                userkey = aes.decrypt(userkey)
-                userkey = userkey[26:-ord(userkey[-1:])]
-                #print "found key:",userkey.encode('hex')
-                keys.append(userkey)
+                if ktype == 'user':
+                    # Add Adobe UUID to key name
+                    uuid_name = uuid_name + winreg.QueryValueEx(plkkey, 'value')[0][9:] + "_"
+                if ktype == 'username':
+                    # Add account type & email to key name, if present
+                    try: 
+                        uuid_name = uuid_name + winreg.QueryValueEx(plkkey, 'method')[0] + "_" 
+                    except:
+                        pass
+                    try: 
+                        uuid_name = uuid_name + winreg.QueryValueEx(plkkey, 'value')[0] + "_"
+                    except:
+                        pass
+                if ktype == 'privateLicenseKey':
+                    userkey = winreg.QueryValueEx(plkkey, 'value')[0]
+                    userkey = unpad(AES.new(keykey, AES.MODE_CBC, b'\x00'*16).decrypt(b64decode(userkey)))[26:]
+                    # print ("found " + uuid_name + " key: " + str(userkey))
+                    keys.append(userkey)
+
+            if uuid_name == "":
+                names.append("Unknown")
+            else:
+                names.append(uuid_name[:-1])
+
         if len(keys) == 0:
             raise ADEPTError('Could not locate privateLicenseKey')
         print("Found {0:d} keys".format(len(keys)))
-        return keys
+        return keys, names
 
 
 elif isosx:
@@ -423,6 +432,8 @@ elif isosx:
         return None
 
     def adeptkeys():
+        # TODO: All the code to support extracting multiple activation keys
+        # TODO: seems to be Windows-only currently, still needs to be added for Mac.
         actpath = findActivationDat()
         if actpath is None:
             raise ADEPTError("Could not find ADE activation.dat file.")
@@ -430,18 +441,40 @@ elif isosx:
         adept = lambda tag: '{%s}%s' % (NSMAP['adept'], tag)
         expr = '//%s/%s' % (adept('credentials'), adept('privateLicenseKey'))
         userkey = tree.findtext(expr)
+
+        exprUUID = '//%s/%s' % (adept('credentials'), adept('user'))
+        keyName = ""
+        try: 
+            keyName = tree.findtext(exprUUID)[9:] + "_"
+        except: 
+            pass
+
+        try: 
+            exprMail = '//%s/%s' % (adept('credentials'), adept('username'))
+            keyName = keyName + tree.find(exprMail).attrib["method"] + "_"
+            keyName = keyName + tree.findtext(exprMail) + "_"
+        except:
+            pass
+
+        if keyName == "":
+            keyName = "Unknown"
+        else:
+            keyName = keyName[:-1]
+
+
+
         userkey = b64decode(userkey)
         userkey = userkey[26:]
-        return [userkey]
+        return [userkey], [keyName]
 
 else:
     def adeptkeys():
         raise ADEPTError("This script only supports Windows and Mac OS X.")
-        return []
+        return [], []
 
 # interface for Python DeDRM
 def getkey(outpath):
-    keys = adeptkeys()
+    keys, names = adeptkeys()
     if len(keys) > 0:
         if not os.path.isdir(outpath):
             outfile = outpath
@@ -450,15 +483,17 @@ def getkey(outpath):
             print("Saved a key to {0}".format(outfile))
         else:
             keycount = 0
+            name_index = 0
             for key in keys:
                 while True:
                     keycount += 1
-                    outfile = os.path.join(outpath,"adobekey_{0:d}.der".format(keycount))
+                    outfile = os.path.join(outpath,"adobekey{0:d}_uuid_{1}.der".format(keycount, names[name_index]))
                     if not os.path.exists(outfile):
                         break
                 with open(outfile, 'wb') as keyfileout:
                     keyfileout.write(key)
                 print("Saved a key to {0}".format(outfile))
+                name_index += 1
         return True
     return False
 
@@ -504,7 +539,7 @@ def cli_main():
     # make sure the outpath is the
     outpath = os.path.realpath(os.path.normpath(outpath))
 
-    keys = adeptkeys()
+    keys, names = adeptkeys()
     if len(keys) > 0:
         if not os.path.isdir(outpath):
             outfile = outpath
@@ -513,15 +548,17 @@ def cli_main():
             print("Saved a key to {0}".format(outfile))
         else:
             keycount = 0
+            name_index = 0
             for key in keys:
                 while True:
                     keycount += 1
-                    outfile = os.path.join(outpath,"adobekey_{0:d}.der".format(keycount))
+                    outfile = os.path.join(outpath,"adobekey{0:d}_uuid_{1}.der".format(keycount, names[name_index]))
                     if not os.path.exists(outfile):
                         break
                 with open(outfile, 'wb') as keyfileout:
                     keyfileout.write(key)
                 print("Saved a key to {0}".format(outfile))
+                name_index += 1
     else:
         print("Could not retrieve Adobe Adept key.")
     return 0
@@ -554,12 +591,15 @@ def gui_main():
     progpath, progname = os.path.split(argv[0])
     success = False
     try:
-        keys = adeptkeys()
+        keys, names = adeptkeys()
+        print(keys)
+        print(names)
         keycount = 0
+        name_index = 0
         for key in keys:
             while True:
                 keycount += 1
-                outfile = os.path.join(progpath,"adobekey_{0:d}.der".format(keycount))
+                outfile = os.path.join(progpath,"adobekey{0:d}_uuid_{1}.der".format(keycount, names[name_index]))
                 if not os.path.exists(outfile):
                     break
 
@@ -567,6 +607,7 @@ def gui_main():
                 keyfileout.write(key)
             success = True
             tkinter.messagebox.showinfo(progname, "Key successfully retrieved to {0}".format(outfile))
+            name_index += 1
     except ADEPTError as e:
         tkinter.messagebox.showerror(progname, "Error: {0}".format(str(e)))
     except Exception:

DeDRM_plugin/adobekey_get_passhash.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# adobekey_get_passhash.py, version 1
+# based on adobekey.pyw, version 7.2
+# Copyright © 2009-2021 i♥cabbages, Apprentice Harper et al.
+# Copyright © 2021 noDRM
+
+# Released under the terms of the GNU General Public Licence, version 3
+# <http://www.gnu.org/licenses/>
+
+# Revision history:
+#   1 - Initial release
+
+"""
+Retrieve Adobe ADEPT user passhash keys
+"""
+
+__license__ = 'GPL v3'
+__version__ = '1'
+
+import sys, os, time
+import base64, hashlib
+try: 
+    from Cryptodome.Cipher import AES
+except ImportError:
+    from Crypto.Cipher import AES
+
+
+def unpad(data, padding=16):
+    if sys.version_info[0] == 2:
+        pad_len = ord(data[-1])
+    else:
+        pad_len = data[-1]
+
+    return data[:-pad_len]
+
+PASS_HASH_SECRET = "9ca588496a1bc4394553d9e018d70b9e"
+
+
+try:
+    from calibre.constants import iswindows, isosx
+except:
+    iswindows = sys.platform.startswith('win')
+    isosx = sys.platform.startswith('darwin')
+
+
+class ADEPTError(Exception):
+    pass
+
+def decrypt_passhash(passhash, fp):
+
+    serial_number = base64.b64decode(fp).hex()
+
+    hash_key = hashlib.sha1(bytearray.fromhex(serial_number + PASS_HASH_SECRET)).digest()[:16]
+
+    encrypted_cc_hash = base64.b64decode(passhash)
+    cc_hash = unpad(AES.new(hash_key, AES.MODE_CBC, encrypted_cc_hash[:16]).decrypt(encrypted_cc_hash[16:]))
+    return base64.b64encode(cc_hash).decode("ascii")
+
+
+if iswindows:
+    try:
+        import winreg
+    except ImportError:
+        import _winreg as winreg
+
+    PRIVATE_LICENCE_KEY_PATH = r'Software\Adobe\Adept\Activation'
+
+    def passhash_keys():
+        cuser = winreg.HKEY_CURRENT_USER
+        keys = []
+        names = []
+        try:
+            plkroot = winreg.OpenKey(cuser, PRIVATE_LICENCE_KEY_PATH)
+        except WindowsError:
+            raise ADEPTError("Could not locate ADE activation")
+        except FileNotFoundError:
+            raise ADEPTError("Could not locate ADE activation")
+
+        idx = 1
+
+        fp = None
+
+        i = -1
+        while True:
+            i = i + 1   # start with 0
+            try:
+                plkparent = winreg.OpenKey(plkroot, "%04d" % (i,))
+            except:
+                # No more keys
+                break
+                
+            ktype = winreg.QueryValueEx(plkparent, None)[0]
+
+            if ktype == "activationToken":
+                # find fingerprint for hash decryption
+                j = -1
+                while True:
+                    j = j + 1   # start with 0
+                    try:
+                        plkkey = winreg.OpenKey(plkparent, "%04d" % (j,))
+                    except WindowsError:
+                        break
+                    except FileNotFoundError:
+                        break
+                    ktype = winreg.QueryValueEx(plkkey, None)[0]
+                    if ktype == 'fingerprint':
+                        fp = winreg.QueryValueEx(plkkey, 'value')[0]
+                        #print("Found fingerprint: " + fp)
+
+
+            # Note: There can be multiple lists, with multiple entries each.
+            if ktype == 'passHashList':
+            
+                # Find operator (used in key name)
+                j = -1
+                lastOperator = "Unknown"
+                while True:
+                    j = j + 1   # start with 0
+                    try:
+                        plkkey = winreg.OpenKey(plkparent, "%04d" % (j,))
+                    except WindowsError:
+                        break
+                    except FileNotFoundError:
+                        break
+                    ktype = winreg.QueryValueEx(plkkey, None)[0]
+                    if ktype == 'operatorURL':
+                        operatorURL = winreg.QueryValueEx(plkkey, 'value')[0]
+                        try: 
+                            lastOperator = operatorURL.split('//')[1].split('/')[0]
+                        except:
+                            pass
+                
+                
+                # Find hashes
+                j = -1
+                while True:
+                    j = j + 1   # start with 0
+                    try:
+                        plkkey = winreg.OpenKey(plkparent, "%04d" % (j,))
+                    except WindowsError:
+                        break
+                    except FileNotFoundError:
+                        break
+                    ktype = winreg.QueryValueEx(plkkey, None)[0]
+
+                    if ktype == "passHash":
+                        passhash_encrypted = winreg.QueryValueEx(plkkey, 'value')[0]
+                        names.append("ADE_key_" + lastOperator + "_" + str(int(time.time())) + "_" + str(idx))
+                        idx = idx + 1
+                        keys.append(passhash_encrypted)
+
+        if fp is None:
+            #print("Didn't find fingerprint for decryption ...")
+            return [], []
+
+        print("Found {0:d} passhashes".format(len(keys)), file=sys.stderr)
+
+        keys_decrypted = []
+
+        for key in keys:
+            decrypted = decrypt_passhash(key, fp)
+            #print("Input key: " + key)
+            #print("Output key: " + decrypted)
+            keys_decrypted.append(decrypted)
+
+        return keys_decrypted, names
+
+   
+else:
+    def passhash_keys():
+        raise ADEPTError("This script only supports Windows.")
+        #TODO: Add MacOS support by parsing the activation.xml file.
+        return [], []
+
+
+if __name__ == '__main__':
+    print("This is a python calibre plugin. It can't be directly executed.")

DeDRM_plugin/adobekey_winreg_unicode.py

@@ -0,0 +1,271 @@
+# This is based on https://github.com/DanielStutzbach/winreg_unicode
+# The original _winreg in Python2 doesn't support unicode.
+# This causes issues if there's unicode chars in the username needed to decrypt the key.
+
+'''
+Copyright 2010 Stutzbach Enterprises, LLC (daniel@stutzbachenterprises.com)
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+   2. Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+   3. The name of the author may not be used to endorse or promote
+      products derived from this software without specific prior written
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+'''
+
+import ctypes, ctypes.wintypes
+
+ERROR_SUCCESS = 0
+ERROR_MORE_DATA = 234
+
+KEY_READ = 0x20019
+
+REG_NONE = 0
+REG_SZ = 1
+REG_EXPAND_SZ = 2
+REG_BINARY = 3
+REG_DWORD = 4
+REG_DWORD_BIG_ENDIAN = 5
+REG_DWORD_LITTLE_ENDIAN = 4
+REG_LINK = 6
+REG_MULTI_SZ = 7
+REG_RESOURCE_LIST = 8
+REG_FULL_RESOURCE_DESCRIPTOR = 9
+REG_RESOURCE_REQUIREMENTS_LIST = 10
+
+c_HKEY = ctypes.c_void_p
+DWORD = ctypes.wintypes.DWORD
+BYTE = ctypes.wintypes.BYTE
+LPDWORD = ctypes.POINTER(DWORD)
+LPBYTE = ctypes.POINTER(BYTE)
+
+advapi32 = ctypes.windll.advapi32
+
+class FILETIME(ctypes.Structure):
+    _fields_ = [("dwLowDateTime", DWORD),
+                ("dwHighDateTime", DWORD)]
+
+RegCloseKey = advapi32.RegCloseKey
+RegCloseKey.restype = ctypes.c_long
+RegCloseKey.argtypes = [c_HKEY]
+
+RegOpenKeyEx = advapi32.RegOpenKeyExW
+RegOpenKeyEx.restype = ctypes.c_long
+RegOpenKeyEx.argtypes = [c_HKEY, ctypes.c_wchar_p, ctypes.c_ulong,
+                         ctypes.c_ulong, ctypes.POINTER(c_HKEY)]
+
+RegQueryInfoKey = advapi32.RegQueryInfoKeyW
+RegQueryInfoKey.restype = ctypes.c_long
+RegQueryInfoKey.argtypes = [c_HKEY, ctypes.c_wchar_p, LPDWORD, LPDWORD,
+                            LPDWORD, LPDWORD, LPDWORD, LPDWORD,
+                            LPDWORD, LPDWORD, LPDWORD,
+                            ctypes.POINTER(FILETIME)]
+
+RegEnumValue = advapi32.RegEnumValueW
+RegEnumValue.restype = ctypes.c_long
+RegEnumValue.argtypes = [c_HKEY, DWORD, ctypes.c_wchar_p, LPDWORD,
+                         LPDWORD, LPDWORD, LPBYTE, LPDWORD]
+
+RegEnumKeyEx = advapi32.RegEnumKeyExW
+RegEnumKeyEx.restype = ctypes.c_long
+RegEnumKeyEx.argtypes = [c_HKEY, DWORD, ctypes.c_wchar_p, LPDWORD,
+                         LPDWORD, ctypes.c_wchar_p, LPDWORD,
+                         ctypes.POINTER(FILETIME)]
+
+RegQueryValueEx = advapi32.RegQueryValueExW
+RegQueryValueEx.restype = ctypes.c_long
+RegQueryValueEx.argtypes = [c_HKEY, ctypes.c_wchar_p, LPDWORD, LPDWORD,
+                            LPBYTE, LPDWORD]
+
+def check_code(code):
+    if code == ERROR_SUCCESS:
+        return
+    raise ctypes.WinError(2)
+
+class HKEY(object):
+    def __init__(self):
+        self.hkey = c_HKEY()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type=None, exc_val=None, exc_tb=None):
+        self.Close()
+        return False
+
+    def Detach(self):
+        rv = self.cast(self.hkey, self.c_ulong).value
+        self.hkey = c_HKEY()
+        return rv
+
+    def __nonzero__(self):
+        return bool(self.hkey)
+
+    def Close(self):
+        if not self.hkey:
+            return
+        if RegCloseKey is None or check_code is None or c_HKEY is None:
+            return # globals become None during exit
+        rc = RegCloseKey(self.hkey)
+        self.hkey = c_HKEY()
+        check_code(rc)
+
+    def __del__(self):
+        self.Close()
+
+class RootHKEY(ctypes.Structure):
+    def __init__(self, value):
+        self.hkey = c_HKEY(value)
+
+    def Close(self):
+        pass
+
+HKEY_CLASSES_ROOT = RootHKEY(0x80000000)
+HKEY_CURRENT_USER = RootHKEY(0x80000001)
+HKEY_LOCAL_MACHINE = RootHKEY(0x80000002)
+HKEY_USERS = RootHKEY(0x80000003)
+HKEY_PERFORMANCE_DATA = RootHKEY(0x80000004)
+HKEY_CURRENT_CONFIG = RootHKEY(0x80000005)
+HKEY_DYN_DATA = RootHKEY(0x80000006)
+
+def OpenKey(key, sub_key):
+    new_key = HKEY()
+    rc = RegOpenKeyEx(key.hkey, sub_key, 0, KEY_READ,
+                      ctypes.cast(ctypes.byref(new_key.hkey),
+                                  ctypes.POINTER(c_HKEY)))
+    check_code(rc)
+    return new_key
+
+def QueryInfoKey(key):
+    null = LPDWORD()
+    num_sub_keys = DWORD()
+    num_values = DWORD()
+    ft = FILETIME()
+    rc = RegQueryInfoKey(key.hkey, ctypes.c_wchar_p(), null, null,
+                         ctypes.byref(num_sub_keys), null, null,
+                         ctypes.byref(num_values), null, null, null,
+                         ctypes.byref(ft))
+    check_code(rc)
+    return (num_sub_keys.value, num_values.value,
+            ft.dwLowDateTime | (ft.dwHighDateTime << 32))
+
+def EnumValue(key, index):
+    null = LPDWORD()
+    value_size = DWORD()
+    data_size = DWORD()
+    rc = RegQueryInfoKey(key.hkey, ctypes.c_wchar_p(), null, null, null,
+                         null, null, null,
+                         ctypes.byref(value_size), ctypes.byref(data_size),
+                         null, ctypes.POINTER(FILETIME)())
+    check_code(rc)
+    value_size.value += 1
+    data_size.value += 1
+
+    value = ctypes.create_unicode_buffer(value_size.value)
+
+    while True:
+        data = ctypes.create_string_buffer(data_size.value)
+
+        tmp_value_size = DWORD(value_size.value)
+        tmp_data_size = DWORD(data_size.value)
+        typ = DWORD()
+        rc = RegEnumValue(key.hkey, index,
+                          ctypes.cast(value, ctypes.c_wchar_p),
+                          ctypes.byref(tmp_value_size), null,
+                          ctypes.byref(typ),
+                          ctypes.cast(data, LPBYTE),
+                          ctypes.byref(tmp_data_size))
+
+        if rc != ERROR_MORE_DATA:
+            break
+
+        data_size.value *= 2
+
+    check_code(rc)
+    return (value.value, Reg2Py(data, tmp_data_size.value, typ.value),
+            typ.value)
+
+def split_multi_sz(data, size):
+    if size == 0:
+        return []
+    Q = size
+    P = 0
+    rv = []
+    while P < Q and data[P].value != u'\0':
+        rv.append[P]
+        while P < Q and data[P].value != u'\0':
+            P += 1
+        P += 1
+    rv.append(size)
+    return [ctypes.wstring_at(ctypes.pointer(data[rv[i]]),
+                              rv[i+1] - rv[i]).rstrip(u'\x00')
+            for i in range(len(rv)-1)]
+
+def Reg2Py(data, size, typ):
+    if typ == REG_DWORD:
+        if size == 0:
+            return 0
+        return ctypes.cast(data, ctypes.POINTER(ctypes.c_int)).contents.value
+    elif typ == REG_SZ or typ == REG_EXPAND_SZ:
+        return ctypes.wstring_at(data, size // 2).rstrip(u'\x00')
+    elif typ == REG_MULTI_SZ:
+        return split_multi_sz(ctypes.cast(data, ctypes.c_wchar_p), size // 2)
+    else:
+        if size == 0:
+            return None
+        return ctypes.string_at(data, size)
+
+def EnumKey(key, index):
+    tmpbuf = ctypes.create_unicode_buffer(257)
+    length = DWORD(257)
+    rc = RegEnumKeyEx(key.hkey, index,
+                      ctypes.cast(tmpbuf, ctypes.c_wchar_p),
+                      ctypes.byref(length),
+                      LPDWORD(), ctypes.c_wchar_p(), LPDWORD(),
+                      ctypes.POINTER(FILETIME)())
+    check_code(rc)
+    return ctypes.wstring_at(tmpbuf, length.value).rstrip(u'\x00')
+
+def QueryValueEx(key, value_name):
+    size = 256
+    typ = DWORD()
+    while True:
+        tmp_size = DWORD(size)
+        buf = ctypes.create_string_buffer(size)
+        rc = RegQueryValueEx(key.hkey, value_name, LPDWORD(),
+                             ctypes.byref(typ),
+                             ctypes.cast(buf, LPBYTE), ctypes.byref(tmp_size))
+        if rc != ERROR_MORE_DATA:
+            break
+
+        size *= 2
+    check_code(rc)
+    return (Reg2Py(buf, tmp_size.value, typ.value), typ.value)
+
+__all__ = ['OpenKey', 'QueryInfoKey', 'EnumValue', 'EnumKey', 'QueryValueEx',
+           'HKEY_CLASSES_ROOT', 'HKEY_CURRENT_USER', 'HKEY_LOCAL_MACHINE',
+           'HKEY_USERS', 'HKEY_PERFORMANCE_DATA', 'HKEY_CURRENT_CONFIG',
+           'HKEY_DYN_DATA', 'REG_NONE', 'REG_SZ', 'REG_EXPAND_SZ',
+           'REG_BINARY', 'REG_DWORD', 'REG_DWORD_BIG_ENDIAN',
+           'REG_DWORD_LITTLE_ENDIAN', 'REG_LINK', 'REG_MULTI_SZ',
+           'REG_RESOURCE_LIST', 'REG_FULL_RESOURCE_DESCRIPTOR',
+           'REG_RESOURCE_REQUIREMENTS_LIST']

DeDRM_plugin/alfcrypto.py

@@ -207,8 +207,9 @@ def _load_python_alfcrypto():
 
         def ctx_init(self, key):
             ctx1 = 0x0CAFFE19E
-            for keyChar in key:
-                keyByte = ord(keyChar)
+            if isinstance(key, str):
+                key = key.encode('latin-1')
+            for keyByte in key:
                 ctx2 = ctx1
                 ctx1 = ((((ctx1 >>2) * (ctx1 >>7))&0xFFFFFFFF) ^ (keyByte * keyByte * 0x0F902007)& 0xFFFFFFFF )
             self._ctx = [ctx1, ctx2]
@@ -220,8 +221,9 @@ def _load_python_alfcrypto():
             ctx1 = ctx[0]
             ctx2 = ctx[1]
             plainText = ""
-            for dataChar in data:
-                dataByte = ord(dataChar)
+            if isinstance(data, str):
+                data = data.encode('latin-1')
+            for dataByte in data:
                 m = (dataByte ^ ((ctx1 >> 3) &0xFF) ^ ((ctx2<<3) & 0xFF)) &0xFF
                 ctx2 = ctx1
                 ctx1 = (((ctx1 >> 2) * (ctx1 >> 7)) &0xFFFFFFFF) ^((m * m * 0x0F902007) &0xFFFFFFFF)

DeDRM_plugin/androidkindlekey.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 # androidkindlekey.py
-# Copyright © 2010-20 by Thom, Apprentice Harper et al.
+# Copyright © 2010-22 by Thom, Apprentice Harper et al.
 
 # Revision history:
 #  1.0   - AmazonSecureStorage.xml decryption to serial number
@@ -14,13 +14,14 @@
 #  1.4   - Fix some problems identified by Aldo Bleeker
 #  1.5   - Fix another problem identified by Aldo Bleeker
 #  2.0   - Python 3 compatibility
+#  2.1   - Remove OpenSSL support; only support PyCryptodome
 
 """
 Retrieve Kindle for Android Serial Number.
 """
 
 __license__ = 'GPL v3'
-__version__ = '2.0'
+__version__ = '2.1'
 
 import os
 import sys
@@ -33,6 +34,11 @@ from hashlib import md5
 from io import BytesIO
 from binascii import a2b_hex, b2a_hex
 
+try:
+    from Cryptodome.Cipher import AES, DES
+except ImportError:
+    from Crypto.Cipher import AES, DES
+
 # Routines common to Mac and PC
 
 # Wrap a stream so that output gets flushed immediately
@@ -45,11 +51,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data,str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 
@@ -93,7 +105,7 @@ def unicode_argv():
         return ["kindlekey.py"]
     else:
         argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
+        return [arg if (isinstance(arg, str) or isinstance(arg,unicode)) else str(arg, argvencoding) for arg in sys.argv]
 
 class DrmException(Exception):
     pass
@@ -102,6 +114,20 @@ STORAGE  = "backup.ab"
 STORAGE1 = "AmazonSecureStorage.xml"
 STORAGE2 = "map_data_storage.db"
 
+
+def unpad(data, padding=16):
+    if sys.version_info[0] == 2:
+        pad_len = ord(data[-1])
+    else:
+        pad_len = data[-1]
+
+    return data[:-pad_len]
+
+def pad(data, padding_len=16):
+    padding_data_len = padding_len - (len(data) % padding_len)
+    plaintext = data + chr(padding_data_len) * padding_data_len
+    return plaintext
+
 class AndroidObfuscation(object):
     '''AndroidObfuscation
     For the key, it's written in java, and run in android dalvikvm
@@ -109,24 +135,16 @@ class AndroidObfuscation(object):
 
     key = a2b_hex('0176e04c9408b1702d90be333fd53523')
 
+    def _get_cipher(self):
+        return AES.new(self.key, AES.MODE_ECB)
+
     def encrypt(self, plaintext):
-        cipher = self._get_cipher()
-        padding = len(self.key) - len(plaintext) % len(self.key)
-        plaintext += chr(padding) * padding
-        return b2a_hex(cipher.encrypt(plaintext.encode('utf-8')))
+        pt = pad(plaintext.encode('utf-8'), 16)
+        return b2a_hex(self._get_cipher().encrypt(pt))
 
     def decrypt(self, ciphertext):
-        cipher = self._get_cipher()
-        plaintext = cipher.decrypt(a2b_hex(ciphertext))
-        return plaintext[:-ord(plaintext[-1])]
-
-    def _get_cipher(self):
-        try:
-            from Crypto.Cipher import AES
-            return AES.new(self.key)
-        except ImportError:
-            from aescbc import AES, noPadding
-            return AES(self.key, padding=noPadding())
+        ct = a2b_hex(ciphertext)
+        return unpad(self._get_cipher().decrypt(ct), 16)
 
 class AndroidObfuscationV2(AndroidObfuscation):
     '''AndroidObfuscationV2
@@ -143,12 +161,7 @@ class AndroidObfuscationV2(AndroidObfuscation):
         self.iv = key[8:16]
 
     def _get_cipher(self):
-        try :
-            from Crypto.Cipher import DES
-            return DES.new(self.key, DES.MODE_CBC, self.iv)
-        except ImportError:
-            from python_des import Des, CBC
-            return Des(self.key, CBC, self.iv)
+        return DES.new(self.key, DES.MODE_CBC, self.iv)
 
 def parse_preference(path):
     ''' parse android's shared preference xml '''

DeDRM_plugin/argv_utils.py

@@ -41,7 +41,7 @@ def unicode_argv():
         return ["DeDRM.py"]
     else:
         argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
+        return [arg if (isinstance(arg, str) or isinstance(arg,unicode)) else str(arg, argvencoding) for arg in sys.argv]
 
 
 def add_cp65001_codec():

DeDRM_plugin/convert2xml.py

@@ -15,11 +15,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data, str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 

DeDRM_plugin/epubfontdecrypt.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# epubfontdecrypt.py
+# Copyright © 2021 by noDRM
+
+# Released under the terms of the GNU General Public Licence, version 3
+# <http://www.gnu.org/licenses/>
+
+
+# Revision history:
+#   1 - Initial release
+
+"""
+Decrypts / deobfuscates font files in EPUB files
+"""
+
+from __future__ import print_function
+
+__license__ = 'GPL v3'
+__version__ = "1"
+
+import os
+import traceback
+import zlib
+import zipfile
+from zipfile import ZipInfo, ZipFile, ZIP_STORED, ZIP_DEFLATED
+from contextlib import closing
+from lxml import etree
+import itertools
+import hashlib
+import binascii
+
+
+class Decryptor(object):
+    def __init__(self, obfuscationkeyIETF, obfuscationkeyAdobe, encryption):
+        enc = lambda tag: '{%s}%s' % ('http://www.w3.org/2001/04/xmlenc#', tag)
+        dsig = lambda tag: '{%s}%s' % ('http://www.w3.org/2000/09/xmldsig#', tag)
+        self.obfuscation_key_Adobe = obfuscationkeyAdobe
+        self.obfuscation_key_IETF = obfuscationkeyIETF
+        
+        self._encryption = etree.fromstring(encryption)
+        # This loops through all entries in the "encryption.xml" file
+        # to figure out which files need to be decrypted.
+        self._obfuscatedIETF = obfuscatedIETF = set()
+        self._obfuscatedAdobe = obfuscatedAdobe = set()
+        self._other = other = set()
+
+        self._json_elements_to_remove = json_elements_to_remove = set()
+        self._has_remaining_xml = False
+        expr = './%s/%s/%s' % (enc('EncryptedData'), enc('CipherData'),
+                               enc('CipherReference'))
+        for elem in self._encryption.findall(expr):
+            path = elem.get('URI', None)
+            encryption_type_url = (elem.getparent().getparent().find("./%s" % (enc('EncryptionMethod'))).get('Algorithm', None))
+            if path is not None:
+
+                if encryption_type_url == "http://www.idpf.org/2008/embedding":
+                    # Font files obfuscated with the IETF algorithm
+                    path = path.encode('utf-8')
+                    obfuscatedIETF.add(path)
+                    if (self.obfuscation_key_IETF is None):
+                        self._has_remaining_xml = True
+                    else:
+                        json_elements_to_remove.add(elem.getparent().getparent())
+
+                elif encryption_type_url == "http://ns.adobe.com/pdf/enc#RC":
+                    # Font files obfuscated with the Adobe algorithm.
+                    path = path.encode('utf-8')
+                    obfuscatedAdobe.add(path)
+                    if (self.obfuscation_key_Adobe is None):
+                        self._has_remaining_xml = True
+                    else:
+                        json_elements_to_remove.add(elem.getparent().getparent())
+
+                else: 
+                    path = path.encode('utf-8')
+                    other.add(path)
+                    self._has_remaining_xml = True
+                    # Other unsupported type.
+        
+        for elem in json_elements_to_remove:
+            elem.getparent().remove(elem)
+
+    def check_if_remaining(self):
+        return self._has_remaining_xml
+
+    def get_xml(self):
+        return "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + etree.tostring(self._encryption, encoding="utf-8", pretty_print=True, xml_declaration=False).decode("utf-8")
+
+    def decompress(self, bytes):
+        dc = zlib.decompressobj(-15)
+        try:
+            decompressed_bytes = dc.decompress(bytes)
+            ex = dc.decompress(b'Z') + dc.flush()
+            if ex:
+                decompressed_bytes = decompressed_bytes + ex
+        except:
+            # possibly not compressed by zip - just return bytes
+            return bytes, False
+        return decompressed_bytes , True
+    
+    def decrypt(self, path, data):
+        if path.encode('utf-8') in self._obfuscatedIETF and self.obfuscation_key_IETF is not None:
+            # de-obfuscate according to the IETF standard
+            data, was_decomp = self.decompress(data)
+
+            if len(data) <= 1040:
+                # de-obfuscate whole file
+                out = self.deobfuscate_single_data(self.obfuscation_key_IETF, data)
+            else: 
+                out = self.deobfuscate_single_data(self.obfuscation_key_IETF, data[:1040]) + data[1040:]
+
+            if (not was_decomp):
+                out, was_decomp = self.decompress(out)
+            return out
+
+        elif path.encode('utf-8') in self._obfuscatedAdobe and self.obfuscation_key_Adobe is not None:
+            # de-obfuscate according to the Adobe standard
+            data, was_decomp = self.decompress(data)
+
+            if len(data) <= 1024:
+                # de-obfuscate whole file
+                out = self.deobfuscate_single_data(self.obfuscation_key_Adobe, data)
+            else: 
+                out = self.deobfuscate_single_data(self.obfuscation_key_Adobe, data[:1024]) + data[1024:]
+
+            if (not was_decomp):
+                out, was_decomp = self.decompress(out)
+            return out
+
+        else: 
+            # Not encrypted or obfuscated
+            return data
+
+    def deobfuscate_single_data(self, key, data):
+        try: 
+            msg = bytes([c^k for c,k in zip(data, itertools.cycle(key))])
+        except TypeError:
+            # Python 2
+            msg = ''.join(chr(ord(c)^ord(k)) for c,k in itertools.izip(data, itertools.cycle(key)))
+        return msg
+
+
+
+def decryptFontsBook(inpath, outpath):
+
+    with closing(ZipFile(open(inpath, 'rb'))) as inf:
+        namelist = inf.namelist()
+        if 'META-INF/encryption.xml' not in namelist:
+            return 1
+
+        # Font key handling:
+
+        font_master_key = None
+        adobe_master_encryption_key = None
+
+        contNS = lambda tag: '{%s}%s' % ('urn:oasis:names:tc:opendocument:xmlns:container', tag)
+        path = None
+
+        try:
+            container = etree.fromstring(inf.read("META-INF/container.xml"))
+            rootfiles = container.find(contNS("rootfiles")).findall(contNS("rootfile"))
+            for rootfile in rootfiles: 
+                path = rootfile.get("full-path", None)
+                if (path is not None):
+                    break
+        except: 
+            pass
+
+        # If path is None, we didn't find an OPF, so we probably don't have a font key.
+        # If path is set, it's the path to the main content OPF file.
+
+        if (path is None):
+            print("FontDecrypt: No OPF for font obfuscation found")
+            return 1
+        else:
+            packageNS = lambda tag: '{%s}%s' % ('http://www.idpf.org/2007/opf', tag)
+            metadataDCNS = lambda tag: '{%s}%s' % ('http://purl.org/dc/elements/1.1/', tag) 
+
+            try:
+                container = etree.fromstring(inf.read(path))
+            except: 
+                container = []
+
+            ## IETF font key algorithm:
+            print("FontDecrypt: Checking {0} for IETF font obfuscation keys ... ".format(path), end='')
+            secret_key_name = None
+            try:
+                secret_key_name = container.get("unique-identifier")
+            except: 
+                pass
+
+            try: 
+                identify_element = container.find(packageNS("metadata")).find(metadataDCNS("identifier"))
+                if (secret_key_name is None or secret_key_name == identify_element.get("id")):
+                    font_master_key = identify_element.text
+            except: 
+                pass
+
+            if (font_master_key is not None):
+                if (secret_key_name is None):
+                    print("found '%s'" % (font_master_key))
+                else:
+                    print("found '%s' (%s)" % (font_master_key, secret_key_name))
+
+                # Trim / remove forbidden characters from the key, then hash it:
+                font_master_key = font_master_key.replace(' ', '')
+                font_master_key = font_master_key.replace('\t', '')
+                font_master_key = font_master_key.replace('\r', '')
+                font_master_key = font_master_key.replace('\n', '')
+                font_master_key = font_master_key.encode('utf-8')
+                font_master_key = hashlib.sha1(font_master_key).digest()
+            else:
+                print("not found")
+
+            ## Adobe font key algorithm
+            print("FontDecrypt: Checking {0} for Adobe font obfuscation keys ... ".format(path), end='')
+
+            try: 
+                metadata = container.find(packageNS("metadata"))
+                identifiers = metadata.findall(metadataDCNS("identifier"))
+
+                uid = None
+                uidMalformed = False
+
+                for identifier in identifiers: 
+                    if identifier.get(packageNS("scheme")) == "UUID":
+                        if identifier.text[:9] == "urn:uuid:":
+                            uid = identifier.text[9:]
+                        else: 
+                            uid = identifier.text
+                        break
+                    if identifier.text[:9] == "urn:uuid:":
+                        uid = identifier.text[9:]
+                        break
+
+                
+                if uid is not None:
+                    uid = uid.replace(chr(0x20),'').replace(chr(0x09),'')
+                    uid = uid.replace(chr(0x0D),'').replace(chr(0x0A),'').replace('-','')
+
+                    if len(uid) < 16:
+                        uidMalformed = True
+                    if not all(c in "0123456789abcdefABCDEF" for c in uid):
+                        uidMalformed = True
+                    
+                    
+                    if not uidMalformed:
+                        print("found '{0}'".format(uid))
+                        uid = uid + uid
+                        adobe_master_encryption_key = binascii.unhexlify(uid[:32])
+                
+                if adobe_master_encryption_key is None:
+                    print("not found")
+
+            except:
+                print("exception")
+                pass
+
+        # Begin decrypting.
+
+        try:
+            encryption = inf.read('META-INF/encryption.xml')
+            decryptor = Decryptor(font_master_key, adobe_master_encryption_key, encryption)
+            kwds = dict(compression=ZIP_DEFLATED, allowZip64=False)
+            with closing(ZipFile(open(outpath, 'wb'), 'w', **kwds)) as outf:
+
+                # Mimetype needs to be the first entry, so remove it from the list
+                # whereever it is, then add it at the beginning. 
+                namelist.remove("mimetype")
+
+                for path in (["mimetype"] + namelist):
+                    data = inf.read(path)
+                    zi = ZipInfo(path)
+                    zi.compress_type=ZIP_DEFLATED
+
+                    if path == "mimetype":
+                        # mimetype must not be compressed
+                        zi.compress_type = ZIP_STORED
+                    
+                    elif path == "META-INF/encryption.xml":
+                        # Check if there's still other entries not related to fonts
+                        if (decryptor.check_if_remaining()):
+                            data = decryptor.get_xml()
+                            print("FontDecrypt: There's remaining entries in encryption.xml, adding file ...")
+                        else: 
+                            # No remaining entries, no need for that file.
+                            continue
+
+                    try:
+                        # get the file info, including time-stamp
+                        oldzi = inf.getinfo(path)
+                        # copy across useful fields
+                        zi.date_time = oldzi.date_time
+                        zi.comment = oldzi.comment
+                        zi.extra = oldzi.extra
+                        zi.internal_attr = oldzi.internal_attr
+                        # external attributes are dependent on the create system, so copy both.
+                        zi.external_attr = oldzi.external_attr
+                        zi.create_system = oldzi.create_system
+                        if any(ord(c) >= 128 for c in path) or any(ord(c) >= 128 for c in zi.comment):
+                            # If the file name or the comment contains any non-ASCII char, set the UTF8-flag
+                            zi.flag_bits |= 0x800
+                    except:
+                        pass
+
+                    if path == "mimetype":
+                        outf.writestr(zi, inf.read('mimetype'))
+                    elif path == "META-INF/encryption.xml":
+                        outf.writestr(zi, data)
+                    else: 
+                        outf.writestr(zi, decryptor.decrypt(path, data))
+        except:
+            print("FontDecrypt: Could not decrypt fonts in {0:s} because of an exception:\n{1:s}".format(os.path.basename(inpath), traceback.format_exc()))
+            traceback.print_exc()
+            return 2
+    return 0
+

DeDRM_plugin/epubtest.py

@@ -12,6 +12,7 @@
 #  1.00 - Cut to epubtest.py, testing ePub files only by Apprentice Alf
 #  1.01 - Added routine for use by Windows DeDRM
 #  2.00 - Python 3, September 2020
+#  2.01 - Add new Adobe DRM, add Readium LCP
 #
 # Written in 2011 by Paul Durrant
 # Released with unlicense. See http://unlicense.org/
@@ -66,11 +67,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data, str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 
@@ -114,7 +121,7 @@ def unicode_argv():
         return ["epubtest.py"]
     else:
         argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
+        return [arg if (isinstance(arg, str) or isinstance(arg,unicode)) else str(arg, argvencoding) for arg in sys.argv]
 
 _FILENAME_LEN_OFFSET = 26
 _EXTRA_LEN_OFFSET = 28
@@ -168,29 +175,44 @@ def getfiledata(file, zi):
     return data
 
 def encryption(infile):
-    # returns encryption: one of Unencrypted, Adobe, B&N and Unknown
-    encryption = "Error When Checking."
+    # Supports Adobe (old & new), B&N, Kobo, Apple, Readium LCP.
+    encryption = "Error"
     try:
         with open(infile,'rb') as infileobject:
             bookdata = infileobject.read(58)
             # Check for Zip
             if bookdata[0:0+2] == b"PK":
-                foundrights = False
-                foundencryption = False
                 inzip = zipfile.ZipFile(infile,'r')
                 namelist = set(inzip.namelist())
-                if 'META-INF/rights.xml' not in namelist or 'META-INF/encryption.xml' not in namelist:
+                if (
+                    'META-INF/encryption.xml' in namelist and
+                    'META-INF/license.lcpl' in namelist and
+                    b"EncryptedContentKey" in inzip.read("META-INF/encryption.xml")):
+                    encryption = "Readium LCP"
+
+                elif 'META-INF/sinf.xml' in namelist and b"fairplay" in inzip.read("META-INF/sinf.xml"):
+                    # Untested, just found this info on Google
+                    encryption = "Apple"
+
+                elif 'META-INF/rights.xml' in namelist and b"<kdrm>" in inzip.read("META-INF/rights.xml"):
+                    # Untested, just found this info on Google
+                    encryption = "Kobo"
+                
+                elif 'META-INF/rights.xml' not in namelist or 'META-INF/encryption.xml' not in namelist:
                     encryption = "Unencrypted"
                 else:
-                    rights = etree.fromstring(inzip.read('META-INF/rights.xml'))
-                    adept = lambda tag: '{%s}%s' % (NSMAP['adept'], tag)
-                    expr = './/%s' % (adept('encryptedKey'),)
-                    bookkey = ''.join(rights.findtext(expr))
-                    if len(bookkey) == 172:
-                        encryption = "Adobe"
-                    elif len(bookkey) == 64:
-                        encryption = "B&N"
-                    else:
+                    try: 
+                        rights = etree.fromstring(inzip.read('META-INF/rights.xml'))
+                        adept = lambda tag: '{%s}%s' % (NSMAP['adept'], tag)
+                        expr = './/%s' % (adept('encryptedKey'),)
+                        bookkey = ''.join(rights.findtext(expr))
+                        if len(bookkey) >= 172:
+                            encryption = "Adobe"
+                        elif len(bookkey) == 64:
+                            encryption = "B&N"
+                        else:
+                            encryption = "Unknown (key len " + str(len(bookkey)) + ")"
+                    except: 
                         encryption = "Unknown"
     except:
         traceback.print_exc()

DeDRM_plugin/epubwatermark.py

@@ -0,0 +1,318 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# epubwatermark.py
+# Copyright © 2021 NoDRM
+
+# Revision history:
+#  1.0   - Initial version
+
+# Released under the terms of the GNU General Public Licence, version 3
+# <http://www.gnu.org/licenses/>
+
+"""
+Removes various watermarks from EPUB files
+"""
+
+import traceback
+from zipfile import ZipInfo, ZipFile, ZIP_STORED, ZIP_DEFLATED
+from contextlib import closing
+from lxml import etree
+import re
+
+# Runs a RegEx over all HTML/XHTML files to remove watermakrs.
+def removeHTMLwatermarks(object, path_to_ebook):
+    try: 
+        inf = ZipFile(open(path_to_ebook, 'rb'))
+        namelist = inf.namelist()
+
+        modded_names = []
+        modded_contents = []
+
+        count_adept = 0
+        count_pocketbook = 0
+        count_lemonink_invisible = 0
+        count_lemonink_visible = 0
+        lemonink_trackingID = None
+
+        for file in namelist:
+            if not (file.endswith('.html') or file.endswith('.xhtml') or file.endswith('.xml')):
+                continue
+
+            try:
+                file_str = inf.read(file).decode("utf-8")
+                str_new = file_str
+
+                # Remove Adobe ADEPT watermarks
+                # Match optional newline at the beginning, then a "meta" tag with name = "Adept.expected.resource" or "Adept.resource"
+                # and either a "value" or a "content" element with an Adobe UUID
+                pre_remove = str_new
+                str_new = re.sub(r'((\r\n|\r|\n)\s*)?\<meta\s+name=\"(Adept\.resource|Adept\.expected\.resource)\"\s+(content|value)=\"urn:uuid:[0-9a-fA-F\-]+\"\s*\/>', '', str_new)
+                str_new = re.sub(r'((\r\n|\r|\n)\s*)?\<meta\s+(content|value)=\"urn:uuid:[0-9a-fA-F\-]+\"\s+name=\"(Adept\.resource|Adept\.expected\.resource)\"\s*\/>', '', str_new)
+
+                if (str_new != pre_remove):
+                    count_adept += 1
+
+                # Remove Pocketbook watermarks
+                pre_remove = str_new
+                str_new = re.sub(r'\<div style\=\"padding\:0\;border\:0\;text\-indent\:0\;line\-height\:normal\;margin\:0 1cm 0.5cm 1cm\;[^\"]*opacity:0.0\;[^\"]*text\-decoration\:none\;[^\"]*background\:none\;[^\"]*\"\>(.*?)\<\/div\>', '', str_new)
+
+                if (str_new != pre_remove):
+                    count_pocketbook += 1
+
+
+                # Remove eLibri / LemonInk watermark
+                # Run this in a loop, as it is possible a file has been watermarked twice ...
+                while True: 
+                    pre_remove = str_new
+                    unique_id = re.search(r'<body[^>]+class="[^"]*(t0x[0-9a-fA-F]{25})[^"]*"[^>]*>', str_new)
+                    if (unique_id):
+                        lemonink_trackingID = unique_id.groups()[0]
+                        count_lemonink_invisible += 1
+                        str_new = re.sub(lemonink_trackingID, '', str_new)
+                        pre_remove = str_new
+                        pm = r'(<body[^>]+class="[^"]*"[^>]*>)'
+                        pm += r'\<div style\=\'padding\:0\;border\:0\;text\-indent\:0\;line\-height\:normal\;margin\:0 1cm 0.5cm 1cm\;[^\']*text\-decoration\:none\;[^\']*background\:none\;[^\']*\'\>(.*?)</div>'
+                        pm += r'\<div style\=\'padding\:0\;border\:0\;text\-indent\:0\;line\-height\:normal\;margin\:0 1cm 0.5cm 1cm\;[^\']*text\-decoration\:none\;[^\']*background\:none\;[^\']*\'\>(.*?)</div>'
+                        str_new = re.sub(pm, r'\1', str_new)
+
+                        if (str_new != pre_remove):
+                            count_lemonink_visible += 1
+                    else: 
+                        break
+
+            except:
+                traceback.print_exc()
+                continue
+
+            if (file_str == str_new):
+                continue
+
+            modded_names.append(file)
+            modded_contents.append(str_new)
+
+        
+        if len(modded_names) == 0:
+            # No file modified, return original
+            return path_to_ebook
+
+        if len(modded_names) != len(modded_contents):
+            # Something went terribly wrong, return original
+            print("Watermark: Error during watermark removal")
+            return path_to_ebook
+
+        # Re-package with modified files:
+        namelist.remove("mimetype")
+
+        try: 
+            output = object.temporary_file(".epub").name
+            kwds = dict(compression=ZIP_DEFLATED, allowZip64=False)
+            with closing(ZipFile(open(output, 'wb'), 'w', **kwds)) as outf:
+                for path in (["mimetype"] + namelist):
+
+                    data = inf.read(path)
+                    
+                    try: 
+                        modded_index = None
+                        modded_index = modded_names.index(path)
+                    except:
+                        pass
+
+                    if modded_index is not None:
+                        # Found modified file - replace contents
+                        data = modded_contents[modded_index]
+
+                    zi = ZipInfo(path)
+                    oldzi = inf.getinfo(path)
+                    try: 
+                        zi.compress_type = oldzi.compress_type
+                        if path == "mimetype":
+                            zi.compress_type = ZIP_STORED
+                        zi.date_time = oldzi.date_time
+                        zi.comment = oldzi.comment
+                        zi.extra = oldzi.extra
+                        zi.internal_attr = oldzi.internal_attr
+                        zi.external_attr = oldzi.external_attr
+                        zi.create_system = oldzi.create_system
+                        if any(ord(c) >= 128 for c in path) or any(ord(c) >= 128 for c in zi.comment):
+                            # If the file name or the comment contains any non-ASCII char, set the UTF8-flag
+                            zi.flag_bits |= 0x800
+                    except:
+                        pass
+
+                    outf.writestr(zi, data)
+        except:
+            traceback.print_exc()
+            return path_to_ebook
+
+        if (count_adept > 0):
+            print("Watermark: Successfully stripped {0} ADEPT watermark(s) from ebook.".format(count_adept))
+        
+        if (count_lemonink_invisible > 0 or count_lemonink_visible > 0):
+            print("Watermark: Successfully stripped {0} visible and {1} invisible LemonInk watermark(s) (\"{2}\") from ebook."
+                .format(count_lemonink_visible, count_lemonink_invisible, lemonink_trackingID))
+            
+        if (count_pocketbook > 0):
+            print("Watermark: Successfully stripped {0} Pocketbook watermark(s) from ebook.".format(count_pocketbook))
+
+        return output
+
+    except:
+        traceback.print_exc()
+        return path_to_ebook
+        
+
+
+
+# Finds the main OPF file, then uses RegEx to remove watermarks
+def removeOPFwatermarks(object, path_to_ebook):
+    contNS = lambda tag: '{%s}%s' % ('urn:oasis:names:tc:opendocument:xmlns:container', tag)
+    opf_path = None
+
+    try:
+        inf = ZipFile(open(path_to_ebook, 'rb'))
+        container = etree.fromstring(inf.read("META-INF/container.xml"))
+        rootfiles = container.find(contNS("rootfiles")).findall(contNS("rootfile"))
+        for rootfile in rootfiles: 
+            opf_path = rootfile.get("full-path", None)
+            if (opf_path is not None):
+                break
+    except: 
+        traceback.print_exc()
+        return path_to_ebook
+
+    # If path is None, we didn't find an OPF, so we probably don't have a font key.
+    # If path is set, it's the path to the main content OPF file.
+
+    if (opf_path is None):
+        # No OPF found - no watermark
+        return path_to_ebook
+    else:
+        try:
+            container_str = inf.read(opf_path).decode("utf-8")
+            container_str_new = container_str
+
+            had_amazon = False
+            had_elibri = False
+
+            # Remove Amazon hex watermarks
+            # Match optional newline at the beginning, then spaces, then a "meta" tag with name = "Watermark" or "Watermark_(hex)" and a "content" element.
+            # This regex also matches DuMont watermarks with meta name="watermark", with the case-insensitive match on the "w" in watermark.
+            pre_remove = container_str_new
+            container_str_new = re.sub(r'((\r\n|\r|\n)\s*)?\<meta\s+name=\"[Ww]atermark(_\(hex\))?\"\s+content=\"[0-9a-fA-F]+\"\s*\/>', '', container_str_new)
+            container_str_new = re.sub(r'((\r\n|\r|\n)\s*)?\<meta\s+content=\"[0-9a-fA-F]+\"\s+name=\"[Ww]atermark(_\(hex\))?\"\s*\/>', '', container_str_new)
+            if pre_remove != container_str_new:
+                had_amazon = True
+
+            # Remove elibri / lemonink watermark
+            # Lemonink replaces all "id" fields in the opf with "idX_Y", with X being the watermark and Y being a number for that particular ID.
+            # This regex replaces all "idX_Y" IDs with "id_Y", removing the watermark IDs.
+            pre_remove = container_str_new
+            container_str_new = re.sub(r'((\r\n|\r|\n)\s*)?\<\!\-\-\s*Wygenerowane przez elibri dla zamówienia numer [0-9a-fA-F]+\s*\-\-\>', '', container_str_new)
+            if pre_remove != container_str_new:
+                # To prevent this Regex from applying to books without that watermark, only do that if the watermark above was found.
+                container_str_new = re.sub(r'\=\"id[0-9]+_([0-9]+)\"', r'="id_\1"', container_str_new)
+            if pre_remove != container_str_new:
+                had_elibri = True
+
+        except:
+            traceback.print_exc()
+            return path_to_ebook
+
+        if (container_str == container_str_new):
+            # container didn't change - no watermark
+            return path_to_ebook
+
+        # Re-package without watermark
+        namelist = inf.namelist()
+        namelist.remove("mimetype")
+
+        try: 
+            output = object.temporary_file(".epub").name
+            kwds = dict(compression=ZIP_DEFLATED, allowZip64=False)
+            with closing(ZipFile(open(output, 'wb'), 'w', **kwds)) as outf:
+                for path in (["mimetype"] + namelist):
+
+                    data = inf.read(path)
+                    if path == opf_path:
+                        # Found OPF, replacing ...
+                        data = container_str_new
+
+                    zi = ZipInfo(path)
+                    oldzi = inf.getinfo(path)
+                    try: 
+                        zi.compress_type = oldzi.compress_type
+                        if path == "mimetype":
+                            zi.compress_type = ZIP_STORED
+                        zi.date_time = oldzi.date_time
+                        zi.comment = oldzi.comment
+                        zi.extra = oldzi.extra
+                        zi.internal_attr = oldzi.internal_attr
+                        zi.external_attr = oldzi.external_attr
+                        zi.create_system = oldzi.create_system
+                        if any(ord(c) >= 128 for c in path) or any(ord(c) >= 128 for c in zi.comment):
+                            # If the file name or the comment contains any non-ASCII char, set the UTF8-flag
+                            zi.flag_bits |= 0x800
+                    except:
+                        pass
+
+                    outf.writestr(zi, data)
+        except:
+            traceback.print_exc()
+            return path_to_ebook
+        
+        if had_elibri:
+            print("Watermark: Successfully stripped eLibri watermark from OPF file.")
+        if had_amazon:
+            print("Watermark: Successfully stripped Amazon watermark from OPF file.")
+
+        return output
+
+
+
+def removeCDPwatermark(object, path_to_ebook):
+    # "META-INF/cdp.info" is a watermark file used by some Tolino vendors. 
+    # We don't want that in our eBooks, so lets remove that file.
+    try: 
+        infile = ZipFile(open(path_to_ebook, 'rb'))
+        namelist = infile.namelist()
+        if 'META-INF/cdp.info' not in namelist:
+            return path_to_ebook
+
+        namelist.remove("mimetype")
+        namelist.remove("META-INF/cdp.info")
+
+        output = object.temporary_file(".epub").name
+
+        kwds = dict(compression=ZIP_DEFLATED, allowZip64=False)
+        with closing(ZipFile(open(output, 'wb'), 'w', **kwds)) as outf:
+            for path in (["mimetype"] + namelist):
+
+                data = infile.read(path)
+                
+                zi = ZipInfo(path)
+                oldzi = infile.getinfo(path)
+                try: 
+                    zi.compress_type = oldzi.compress_type
+                    if path == "mimetype":
+                        zi.compress_type = ZIP_STORED
+                    zi.date_time = oldzi.date_time
+                    zi.comment = oldzi.comment
+                    zi.extra = oldzi.extra
+                    zi.internal_attr = oldzi.internal_attr
+                    zi.external_attr = oldzi.external_attr
+                    zi.create_system = oldzi.create_system
+                    if any(ord(c) >= 128 for c in path) or any(ord(c) >= 128 for c in zi.comment):
+                        # If the file name or the comment contains any non-ASCII char, set the UTF8-flag
+                        zi.flag_bits |= 0x800
+                except:
+                    pass
+
+                outf.writestr(zi, data)
+        
+        print("Watermark: Successfully removed cdp.info watermark")
+        return output
+
+    except: 
+        traceback.print_exc()
+        return path_to_ebook

DeDRM_plugin/erdr2pml.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 # erdr2pml.py
-# Copyright © 2008-2020 The Dark Reverser, Apprentice Harper et al.
+# Copyright © 2008-2022 The Dark Reverser, Apprentice Harper, noDRM et al.
 #
 # Changelog
 #
@@ -64,16 +64,20 @@
 #  0.22 - Unicode and plugin support, different image folders for PMLZ and source
 #  0.23 - moved unicode_argv call inside main for Windows DeDRM compatibility
 #  1.00 - Added Python 3 compatibility for calibre 5.0
+#  1.01 - Bugfixes for standalone version.
+#  1.02 - Remove OpenSSL support; only use PyCryptodome
 
-__version__='1.00'
+__version__='1.02'
 
 import sys, re
-import struct, binascii, getopt, zlib, os, os.path, urllib, tempfile, traceback
+import struct, binascii, getopt, zlib, os, os.path, urllib, tempfile, traceback, hashlib
 
-if 'calibre' in sys.modules:
-    inCalibre = True
-else:
-    inCalibre = False
+try:
+    from Cryptodome.Cipher import DES
+except ImportError:
+    from Crypto.Cipher import DES
+
+#@@CALIBRE_COMPAT_CODE@@
 
 # Wrap a stream so that output gets flushed immediately
 # and also make sure that any unicode strings get
@@ -85,10 +89,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data,str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 
@@ -129,60 +140,7 @@ def unicode_argv():
         return ["mobidedrm.py"]
     else:
         argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
-
-Des = None
-if iswindows:
-    # first try with pycrypto
-    if inCalibre:
-        from calibre_plugins.dedrm import pycrypto_des
-    else:
-        import pycrypto_des
-    Des = pycrypto_des.load_pycrypto()
-    if Des == None:
-        # they try with openssl
-        if inCalibre:
-            from calibre_plugins.dedrm import openssl_des
-        else:
-            import openssl_des
-        Des = openssl_des.load_libcrypto()
-else:
-    # first try with openssl
-    if inCalibre:
-        from calibre_plugins.dedrm import openssl_des
-    else:
-        import openssl_des
-    Des = openssl_des.load_libcrypto()
-    if Des == None:
-        # then try with pycrypto
-        if inCalibre:
-            from calibre_plugins.dedrm import pycrypto_des
-        else:
-            import pycrypto_des
-        Des = pycrypto_des.load_pycrypto()
-
-# if that did not work then use pure python implementation
-# of DES and try to speed it up with Psycho
-if Des == None:
-    if inCalibre:
-        from calibre_plugins.dedrm import python_des
-    else:
-        import python_des
-    Des = python_des.Des
-    # Import Psyco if available
-    try:
-        # http://psyco.sourceforge.net
-        import psyco
-        psyco.full()
-    except ImportError:
-        pass
-
-try:
-    from hashlib import sha1
-except ImportError:
-    # older Python release
-    import sha
-    sha1 = lambda s: sha.new(s)
+        return [arg if (isinstance(arg, str) or isinstance(arg,unicode)) else str(arg, argvencoding) for arg in sys.argv]
 
 import cgi
 import logging
@@ -263,7 +221,7 @@ class EreaderProcessor(object):
             raise ValueError('incorrect eReader version %d (error 1)' % version)
         data = self.section_reader(1)
         self.data = data
-        des = Des(fixKey(data[0:8]))
+        des = DES.new(fixKey(data[0:8]), DES.MODE_ECB)
         cookie_shuf, cookie_size = struct.unpack('>LL', des.decrypt(data[-8:]))
         if cookie_shuf < 3 or cookie_shuf > 0x14 or cookie_size < 0xf0 or cookie_size > 0x200:
             raise ValueError('incorrect eReader version (error 2)')
@@ -327,7 +285,7 @@ class EreaderProcessor(object):
         if (self.flags & reqd_flags) != reqd_flags:
             print("Flags: 0x%X" % self.flags)
             raise ValueError('incompatible eReader file')
-        des = Des(fixKey(user_key))
+        des = DES.new(fixKey(user_key), DES.MODE_ECB)
         if version == 259:
             if drm_sub_version != 7:
                 raise ValueError('incorrect eReader version %d (error 3)' % drm_sub_version)
@@ -403,7 +361,7 @@ class EreaderProcessor(object):
     #     return bkinfo
 
     def getText(self):
-        des = Des(fixKey(self.content_key))
+        des = DES.new(fixKey(self.content_key), DES.MODE_ECB)
         r = b''
         for i in range(self.num_text_pages):
             logging.debug('get page %d', i)
@@ -416,7 +374,7 @@ class EreaderProcessor(object):
             sect = self.section_reader(self.first_footnote_page)
             fnote_ids = deXOR(sect, 0, self.xortable)
             # the remaining records of the footnote sections need to be decoded with the content_key and zlib inflated
-            des = Des(fixKey(self.content_key))
+            des = DES.new(fixKey(self.content_key), DES.MODE_ECB)
             for i in range(1,self.num_footnote_pages):
                 logging.debug('get footnotepage %d', i)
                 id_len = ord(fnote_ids[2])
@@ -440,7 +398,7 @@ class EreaderProcessor(object):
             sect = self.section_reader(self.first_sidebar_page)
             sbar_ids = deXOR(sect, 0, self.xortable)
             # the remaining records of the sidebar sections need to be decoded with the content_key and zlib inflated
-            des = Des(fixKey(self.content_key))
+            des = DES.new(fixKey(self.content_key), DES.MODE_ECB)
             for i in range(1,self.num_sidebar_pages):
                 id_len = ord(sbar_ids[2])
                 id = sbar_ids[3:3+id_len]

DeDRM_plugin/flatxml2html.py

@@ -473,8 +473,10 @@ class DocParser(object):
                     if (link > 0):
                         linktype = self.link_type[link-1]
                         title = self.link_title[link-1]
-                        if (title == b"") or (parares.rfind(title.decode('utf-8')) < 0):
-                            title=parares[lstart:].encode('utf-8')
+                        if isinstance(title, bytes):
+                            title = title.decode('utf-8')
+                        if (title == "") or (parares.rfind(title) < 0):
+                            title=parares[lstart:]
                         if linktype == 'external' :
                             linkhref = self.link_href[link-1]
                             linkhtml = '<a href="%s">' % linkhref
@@ -485,9 +487,9 @@ class DocParser(object):
                             else :
                                 # just link to the current page
                                 linkhtml = '<a href="#' + self.id + '">'
-                        linkhtml += title.decode('utf-8')
+                        linkhtml += title
                         linkhtml += '</a>'
-                        pos = parares.rfind(title.decode('utf-8'))
+                        pos = parares.rfind(title)
                         if pos >= 0:
                             parares = parares[0:pos] + linkhtml + parares[pos+len(title):]
                         else :
@@ -559,7 +561,7 @@ class DocParser(object):
                     if (link > 0):
                         linktype = self.link_type[link-1]
                         title = self.link_title[link-1]
-                        title = title.rstrip(b'. ')
+                        title = title.rstrip(b'. ').decode('utf-8')
                         alt_title = parares[lstart:]
                         alt_title = alt_title.strip()
                         # now strip off the actual printed page number
@@ -770,10 +772,10 @@ class DocParser(object):
                             first_para_continued = False
                         (pclass, pdesc) = self.getParaDescription(start,end, regtype)
                         if not pclass:
-                            if orig_regtype.endswith(b'.right')     : pclass = 'cl-right'
-                            elif orig_regtype.endswith(b'.center')  : pclass = 'cl-center'
-                            elif orig_regtype.endswith(b'.left')    : pclass = 'cl-left'
-                            elif orig_regtype.endswith(b'.justify') : pclass = 'cl-justify'
+                            if orig_regtype.endswith(b'.right')     : pclass = b'cl-right'
+                            elif orig_regtype.endswith(b'.center')  : pclass = b'cl-center'
+                            elif orig_regtype.endswith(b'.left')    : pclass = b'cl-left'
+                            elif orig_regtype.endswith(b'.justify') : pclass = b'cl-justify'
                         if pclass and (ptype == 'full') and (len(pclass) >= 6):
                             tag = 'p'
                             if pclass[3:6] == b'h1-' : tag = 'h4'

DeDRM_plugin/genbook.py

@@ -14,11 +14,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data, str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 
@@ -29,25 +35,17 @@ import getopt
 from struct import pack
 from struct import unpack
 
+#@@CALIBRE_COMPAT_CODE@@
+
+
 class TpzDRMError(Exception):
     pass
 
 # local support routines
-if 'calibre' in sys.modules:
-    inCalibre = True
-else:
-    inCalibre = False
-
-if inCalibre :
-    from calibre_plugins.dedrm import convert2xml
-    from calibre_plugins.dedrm import flatxml2html
-    from calibre_plugins.dedrm import flatxml2svg
-    from calibre_plugins.dedrm import stylexml2css
-else :
-    import convert2xml
-    import flatxml2html
-    import flatxml2svg
-    import stylexml2css
+import convert2xml
+import flatxml2html
+import flatxml2svg
+import stylexml2css
 
 # global switch
 buildXML = False

DeDRM_plugin/ignobleepub.py

@@ -1,441 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ignobleepub.py
-# Copyright © 2009-2020 by i♥cabbages, Apprentice Harper et al.
-
-# Released under the terms of the GNU General Public Licence, version 3
-# <http://www.gnu.org/licenses/>
-
-#
-# Revision history:
-#   1 - Initial release
-#   2 - Added OS X support by using OpenSSL when available
-#   3 - screen out improper key lengths to prevent segfaults on Linux
-#   3.1 - Allow Windows versions of libcrypto to be found
-#   3.2 - add support for encoding to 'utf-8' when building up list of files to decrypt from encryption.xml
-#   3.3 - On Windows try PyCrypto first, OpenSSL next
-#   3.4 - Modify interface to allow use with import
-#   3.5 - Fix for potential problem with PyCrypto
-#   3.6 - Revised to allow use in calibre plugins to eliminate need for duplicate code
-#   3.7 - Tweaked to match ineptepub more closely
-#   3.8 - Fixed to retain zip file metadata (e.g. file modification date)
-#   3.9 - moved unicode_argv call inside main for Windows DeDRM compatibility
-#   4.0 - Work if TkInter is missing
-#   4.1 - Import tkFileDialog, don't assume something else will import it.
-#   5.0 - Python 3 for calibre 5.0
-
-"""
-Decrypt Barnes & Noble encrypted ePub books.
-"""
-
-__license__ = 'GPL v3'
-__version__ = "5.0"
-
-import sys
-import os
-import traceback
-import base64
-import zlib
-import zipfile
-from zipfile import ZipInfo, ZipFile, ZIP_STORED, ZIP_DEFLATED
-from contextlib import closing
-import xml.etree.ElementTree as etree
-
-# Wrap a stream so that output gets flushed immediately
-# and also make sure that any unicode strings get
-# encoded using "replace" before writing them.
-class SafeUnbuffered:
-    def __init__(self, stream):
-        self.stream = stream
-        self.encoding = stream.encoding
-        if self.encoding == None:
-            self.encoding = "utf-8"
-    def write(self, data):
-        if isinstance(data,str):
-            data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-    def __getattr__(self, attr):
-        return getattr(self.stream, attr)
-
-try:
-    from calibre.constants import iswindows, isosx
-except:
-    iswindows = sys.platform.startswith('win')
-    isosx = sys.platform.startswith('darwin')
-
-def unicode_argv():
-    if iswindows:
-        # Uses shell32.GetCommandLineArgvW to get sys.argv as a list of Unicode
-        # strings.
-
-        # Versions 2.x of Python don't support Unicode in sys.argv on
-        # Windows, with the underlying Windows API instead replacing multi-byte
-        # characters with '?'.
-
-
-        from ctypes import POINTER, byref, cdll, c_int, windll
-        from ctypes.wintypes import LPCWSTR, LPWSTR
-
-        GetCommandLineW = cdll.kernel32.GetCommandLineW
-        GetCommandLineW.argtypes = []
-        GetCommandLineW.restype = LPCWSTR
-
-        CommandLineToArgvW = windll.shell32.CommandLineToArgvW
-        CommandLineToArgvW.argtypes = [LPCWSTR, POINTER(c_int)]
-        CommandLineToArgvW.restype = POINTER(LPWSTR)
-
-        cmd = GetCommandLineW()
-        argc = c_int(0)
-        argv = CommandLineToArgvW(cmd, byref(argc))
-        if argc.value > 0:
-            # Remove Python executable and commands if present
-            start = argc.value - len(sys.argv)
-            return [argv[i] for i in
-                    range(start, argc.value)]
-        return ["ineptepub.py"]
-    else:
-        argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
-
-
-class IGNOBLEError(Exception):
-    pass
-
-def _load_crypto_libcrypto():
-    from ctypes import CDLL, POINTER, c_void_p, c_char_p, c_int, c_long, \
-        Structure, c_ulong, create_string_buffer, cast
-    from ctypes.util import find_library
-
-    if iswindows:
-        libcrypto = find_library('libeay32')
-    else:
-        libcrypto = find_library('crypto')
-
-    if libcrypto is None:
-        raise IGNOBLEError('libcrypto not found')
-    libcrypto = CDLL(libcrypto)
-
-    AES_MAXNR = 14
-
-    c_char_pp = POINTER(c_char_p)
-    c_int_p = POINTER(c_int)
-
-    class AES_KEY(Structure):
-        _fields_ = [('rd_key', c_long * (4 * (AES_MAXNR + 1))),
-                    ('rounds', c_int)]
-    AES_KEY_p = POINTER(AES_KEY)
-
-    def F(restype, name, argtypes):
-        func = getattr(libcrypto, name)
-        func.restype = restype
-        func.argtypes = argtypes
-        return func
-
-    AES_set_decrypt_key = F(c_int, 'AES_set_decrypt_key',
-                            [c_char_p, c_int, AES_KEY_p])
-    AES_cbc_encrypt = F(None, 'AES_cbc_encrypt',
-                        [c_char_p, c_char_p, c_ulong, AES_KEY_p, c_char_p,
-                         c_int])
-
-    class AES(object):
-        def __init__(self, userkey):
-            self._blocksize = len(userkey)
-            if (self._blocksize != 16) and (self._blocksize != 24) and (self._blocksize != 32) :
-                raise IGNOBLEError('AES improper key used')
-                return
-            key = self._key = AES_KEY()
-            rv = AES_set_decrypt_key(userkey, len(userkey) * 8, key)
-            if rv < 0:
-                raise IGNOBLEError('Failed to initialize AES key')
-
-        def decrypt(self, data):
-            out = create_string_buffer(len(data))
-            iv = (b'\x00' * self._blocksize)
-            rv = AES_cbc_encrypt(data, out, len(data), self._key, iv, 0)
-            if rv == 0:
-                raise IGNOBLEError('AES decryption failed')
-            return out.raw
-
-    return AES
-
-def _load_crypto_pycrypto():
-    from Crypto.Cipher import AES as _AES
-
-    class AES(object):
-        def __init__(self, key):
-            self._aes = _AES.new(key, _AES.MODE_CBC, b'\x00'*16)
-
-        def decrypt(self, data):
-            return self._aes.decrypt(data)
-
-    return AES
-
-def _load_crypto():
-    AES = None
-    cryptolist = (_load_crypto_libcrypto, _load_crypto_pycrypto)
-    if sys.platform.startswith('win'):
-        cryptolist = (_load_crypto_pycrypto, _load_crypto_libcrypto)
-    for loader in cryptolist:
-        try:
-            AES = loader()
-            break
-        except (ImportError, IGNOBLEError):
-            pass
-    return AES
-
-AES = _load_crypto()
-
-META_NAMES = ('mimetype', 'META-INF/rights.xml', 'META-INF/encryption.xml')
-NSMAP = {'adept': 'http://ns.adobe.com/adept',
-         'enc': 'http://www.w3.org/2001/04/xmlenc#'}
-
-class Decryptor(object):
-    def __init__(self, bookkey, encryption):
-        enc = lambda tag: '{%s}%s' % (NSMAP['enc'], tag)
-        self._aes = AES(bookkey)
-        encryption = etree.fromstring(encryption)
-        self._encrypted = encrypted = set()
-        expr = './%s/%s/%s' % (enc('EncryptedData'), enc('CipherData'),
-                               enc('CipherReference'))
-        for elem in encryption.findall(expr):
-            path = elem.get('URI', None)
-            if path is not None:
-                path = path.encode('utf-8')
-                encrypted.add(path)
-
-    def decompress(self, bytes):
-        dc = zlib.decompressobj(-15)
-        bytes = dc.decompress(bytes)
-        ex = dc.decompress(b'Z') + dc.flush()
-        if ex:
-            bytes = bytes + ex
-        return bytes
-
-    def decrypt(self, path, data):
-        if bytes(path,'utf-8') in self._encrypted:
-            data = self._aes.decrypt(data)[16:]
-            data = data[:-data[-1]]
-            data = self.decompress(data)
-        return data
-
-# check file to make check whether it's probably an Adobe Adept encrypted ePub
-def ignobleBook(inpath):
-    with closing(ZipFile(open(inpath, 'rb'))) as inf:
-        namelist = set(inf.namelist())
-        if 'META-INF/rights.xml' not in namelist or \
-           'META-INF/encryption.xml' not in namelist:
-            return False
-        try:
-            rights = etree.fromstring(inf.read('META-INF/rights.xml'))
-            adept = lambda tag: '{%s}%s' % (NSMAP['adept'], tag)
-            expr = './/%s' % (adept('encryptedKey'),)
-            bookkey = ''.join(rights.findtext(expr))
-            if len(bookkey) == 64:
-                return True
-        except:
-            # if we couldn't check, assume it is
-            return True
-    return False
-
-def decryptBook(keyb64, inpath, outpath):
-    if AES is None:
-        raise IGNOBLEError("PyCrypto or OpenSSL must be installed.")
-    key = base64.b64decode(keyb64)[:16]
-    aes = AES(key)
-    with closing(ZipFile(open(inpath, 'rb'))) as inf:
-        namelist = set(inf.namelist())
-        if 'META-INF/rights.xml' not in namelist or \
-           'META-INF/encryption.xml' not in namelist:
-            print("{0:s} is DRM-free.".format(os.path.basename(inpath)))
-            return 1
-        for name in META_NAMES:
-            namelist.remove(name)
-        try:
-            rights = etree.fromstring(inf.read('META-INF/rights.xml'))
-            adept = lambda tag: '{%s}%s' % (NSMAP['adept'], tag)
-            expr = './/%s' % (adept('encryptedKey'),)
-            bookkey = ''.join(rights.findtext(expr))
-            if len(bookkey) != 64:
-                print("{0:s} is not a secure Barnes & Noble ePub.".format(os.path.basename(inpath)))
-                return 1
-            bookkey = aes.decrypt(base64.b64decode(bookkey))
-            bookkey = bookkey[:-bookkey[-1]]
-            encryption = inf.read('META-INF/encryption.xml')
-            decryptor = Decryptor(bookkey[-16:], encryption)
-            kwds = dict(compression=ZIP_DEFLATED, allowZip64=False)
-            with closing(ZipFile(open(outpath, 'wb'), 'w', **kwds)) as outf:
-                zi = ZipInfo('mimetype')
-                zi.compress_type=ZIP_STORED
-                try:
-                    # if the mimetype is present, get its info, including time-stamp
-                    oldzi = inf.getinfo('mimetype')
-                    # copy across fields to be preserved
-                    zi.date_time = oldzi.date_time
-                    zi.comment = oldzi.comment
-                    zi.extra = oldzi.extra
-                    zi.internal_attr = oldzi.internal_attr
-                    # external attributes are dependent on the create system, so copy both.
-                    zi.external_attr = oldzi.external_attr
-                    zi.create_system = oldzi.create_system
-                except:
-                    pass
-                outf.writestr(zi, inf.read('mimetype'))
-                for path in namelist:
-                    data = inf.read(path)
-                    zi = ZipInfo(path)
-                    zi.compress_type=ZIP_DEFLATED
-                    try:
-                        # get the file info, including time-stamp
-                        oldzi = inf.getinfo(path)
-                        # copy across useful fields
-                        zi.date_time = oldzi.date_time
-                        zi.comment = oldzi.comment
-                        zi.extra = oldzi.extra
-                        zi.internal_attr = oldzi.internal_attr
-                        # external attributes are dependent on the create system, so copy both.
-                        zi.external_attr = oldzi.external_attr
-                        zi.create_system = oldzi.create_system
-                    except:
-                        pass
-                    outf.writestr(zi, decryptor.decrypt(path, data))
-        except:
-            print("Could not decrypt {0:s} because of an exception:\n{1:s}".format(os.path.basename(inpath), traceback.format_exc()))
-            return 2
-    return 0
-
-
-def cli_main():
-    sys.stdout=SafeUnbuffered(sys.stdout)
-    sys.stderr=SafeUnbuffered(sys.stderr)
-    argv=unicode_argv()
-    progname = os.path.basename(argv[0])
-    if len(argv) != 4:
-        print("usage: {0} <keyfile.b64> <inbook.epub> <outbook.epub>".format(progname))
-        return 1
-    keypath, inpath, outpath = argv[1:]
-    userkey = open(keypath,'rb').read()
-    result = decryptBook(userkey, inpath, outpath)
-    if result == 0:
-        print("Successfully decrypted {0:s} as {1:s}".format(os.path.basename(inpath),os.path.basename(outpath)))
-    return result
-
-def gui_main():
-    try:
-        import tkinter
-        import tkinter.constants
-        import tkinter.filedialog
-        import tkinter.messagebox
-        import traceback
-    except:
-        return cli_main()
-
-    class DecryptionDialog(tkinter.Frame):
-        def __init__(self, root):
-            tkinter.Frame.__init__(self, root, border=5)
-            self.status = tkinter.Label(self, text="Select files for decryption")
-            self.status.pack(fill=tkinter.constants.X, expand=1)
-            body = tkinter.Frame(self)
-            body.pack(fill=tkinter.constants.X, expand=1)
-            sticky = tkinter.constants.E + tkinter.constants.W
-            body.grid_columnconfigure(1, weight=2)
-            tkinter.Label(body, text="Key file").grid(row=0)
-            self.keypath = tkinter.Entry(body, width=30)
-            self.keypath.grid(row=0, column=1, sticky=sticky)
-            if os.path.exists("bnepubkey.b64"):
-                self.keypath.insert(0, "bnepubkey.b64")
-            button = tkinter.Button(body, text="...", command=self.get_keypath)
-            button.grid(row=0, column=2)
-            tkinter.Label(body, text="Input file").grid(row=1)
-            self.inpath = tkinter.Entry(body, width=30)
-            self.inpath.grid(row=1, column=1, sticky=sticky)
-            button = tkinter.Button(body, text="...", command=self.get_inpath)
-            button.grid(row=1, column=2)
-            tkinter.Label(body, text="Output file").grid(row=2)
-            self.outpath = tkinter.Entry(body, width=30)
-            self.outpath.grid(row=2, column=1, sticky=sticky)
-            button = tkinter.Button(body, text="...", command=self.get_outpath)
-            button.grid(row=2, column=2)
-            buttons = tkinter.Frame(self)
-            buttons.pack()
-            botton = tkinter.Button(
-                buttons, text="Decrypt", width=10, command=self.decrypt)
-            botton.pack(side=tkinter.constants.LEFT)
-            tkinter.Frame(buttons, width=10).pack(side=tkinter.constants.LEFT)
-            button = tkinter.Button(
-                buttons, text="Quit", width=10, command=self.quit)
-            button.pack(side=tkinter.constants.RIGHT)
-
-        def get_keypath(self):
-            keypath = tkinter.filedialog.askopenfilename(
-                parent=None, title="Select Barnes & Noble \'.b64\' key file",
-                defaultextension=".b64",
-                filetypes=[('base64-encoded files', '.b64'),
-                           ('All Files', '.*')])
-            if keypath:
-                keypath = os.path.normpath(keypath)
-                self.keypath.delete(0, tkinter.constants.END)
-                self.keypath.insert(0, keypath)
-            return
-
-        def get_inpath(self):
-            inpath = tkinter.filedialog.askopenfilename(
-                parent=None, title="Select B&N-encrypted ePub file to decrypt",
-                defaultextension=".epub", filetypes=[('ePub files', '.epub')])
-            if inpath:
-                inpath = os.path.normpath(inpath)
-                self.inpath.delete(0, tkinter.constants.END)
-                self.inpath.insert(0, inpath)
-            return
-
-        def get_outpath(self):
-            outpath = tkinter.filedialog.asksaveasfilename(
-                parent=None, title="Select unencrypted ePub file to produce",
-                defaultextension=".epub", filetypes=[('ePub files', '.epub')])
-            if outpath:
-                outpath = os.path.normpath(outpath)
-                self.outpath.delete(0, tkinter.constants.END)
-                self.outpath.insert(0, outpath)
-            return
-
-        def decrypt(self):
-            keypath = self.keypath.get()
-            inpath = self.inpath.get()
-            outpath = self.outpath.get()
-            if not keypath or not os.path.exists(keypath):
-                self.status['text'] = "Specified key file does not exist"
-                return
-            if not inpath or not os.path.exists(inpath):
-                self.status['text'] = "Specified input file does not exist"
-                return
-            if not outpath:
-                self.status['text'] = "Output file not specified"
-                return
-            if inpath == outpath:
-                self.status['text'] = "Must have different input and output files"
-                return
-            userkey = open(keypath,'rb').read()
-            self.status['text'] = "Decrypting..."
-            try:
-                decrypt_status = decryptBook(userkey, inpath, outpath)
-            except Exception as e:
-                self.status['text'] = "Error: {0}".format(e.args[0])
-                return
-            if decrypt_status == 0:
-                self.status['text'] = "File successfully decrypted"
-            else:
-                self.status['text'] = "The was an error decrypting the file."
-
-    root = tkinter.Tk()
-    root.title("Barnes & Noble ePub Decrypter v.{0}".format(__version__))
-    root.resizable(True, False)
-    root.minsize(300, 0)
-    DecryptionDialog(root).pack(fill=tkinter.constants.X, expand=1)
-    root.mainloop()
-    return 0
-
-if __name__ == '__main__':
-    if len(sys.argv) > 1:
-        sys.exit(cli_main())
-    sys.exit(gui_main())

DeDRM_plugin/ignoblekeyAndroid.py

@@ -0,0 +1,68 @@
+'''
+Extracts the user's ccHash from an .adobe-digital-editions folder
+typically included in the Nook Android app's data folder.
+
+Based on ignoblekeyWindowsStore.py, updated for Android by noDRM.
+'''
+
+import sys
+import os
+import base64
+try: 
+    from Cryptodome.Cipher import AES
+except ImportError:
+    from Crypto.Cipher import AES
+import hashlib
+from lxml import etree
+
+def unpad(data, padding=16):
+    if sys.version_info[0] == 2:
+        pad_len = ord(data[-1])
+    else:
+        pad_len = data[-1]
+
+    return data[:-pad_len]
+
+
+PASS_HASH_SECRET = "9ca588496a1bc4394553d9e018d70b9e"
+
+
+def dump_keys(path_to_adobe_folder):
+    
+    activation_path = os.path.join(path_to_adobe_folder, "activation.xml")
+    device_path = os.path.join(path_to_adobe_folder, "device.xml")
+
+    if not os.path.isfile(activation_path):
+        print("Nook activation file is missing: %s\n" % activation_path)
+        return []
+    if not os.path.isfile(device_path):
+        print("Nook device file is missing: %s\n" % device_path)
+        return []
+
+    # Load files:
+    activation_xml = etree.parse(activation_path)
+    device_xml = etree.parse(device_path)
+    
+    # Get fingerprint: 
+    device_fingerprint = device_xml.findall(".//{http://ns.adobe.com/adept}fingerprint")[0].text
+    device_fingerprint = base64.b64decode(device_fingerprint).hex()
+
+    hash_key = hashlib.sha1(bytearray.fromhex(device_fingerprint + PASS_HASH_SECRET)).digest()[:16]
+
+    hashes = []
+
+    for pass_hash in activation_xml.findall(".//{http://ns.adobe.com/adept}passHash"):
+        try: 
+            encrypted_cc_hash = base64.b64decode(pass_hash.text)
+            cc_hash = unpad(AES.new(hash_key, AES.MODE_CBC, encrypted_cc_hash[:16]).decrypt(encrypted_cc_hash[16:]))
+            hashes.append(base64.b64encode(cc_hash).decode("ascii"))
+            #print("Nook ccHash is %s" % (base64.b64encode(cc_hash).decode("ascii")))
+        except:
+            pass
+
+    return hashes
+
+
+
+if __name__ == "__main__":
+    print("No standalone version available.")

DeDRM_plugin/ignoblekeyGenPassHash.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-# ignoblekeygen.py
-# Copyright © 2009-2020 i♥cabbages, Apprentice Harper et al.
+# ignoblekeyGenPassHash.py
+# Copyright © 2009-2022 i♥cabbages, Apprentice Harper et al.
 
 # Released under the terms of the GNU General Public Licence, version 3
 # <http://www.gnu.org/licenses/>
@@ -31,19 +31,25 @@
 #   2.7 - Work if TkInter is missing
 #   2.8 - Fix bug in stand-alone use (import tkFileDialog)
 #   3.0 - Added Python 3 compatibility for calibre 5.0
+#   3.1 - Remove OpenSSL support, only PyCryptodome is supported now
 
 """
 Generate Barnes & Noble EPUB user key from name and credit card number.
 """
 
 __license__ = 'GPL v3'
-__version__ = "3.0"
+__version__ = "3.1"
 
 import sys
 import os
 import hashlib
 import base64
 
+try:
+    from Cryptodome.Cipher import AES
+except ImportError:
+    from Crypto.Cipher import AES
+
 # Wrap a stream so that output gets flushed immediately
 # and also make sure that any unicode strings get
 # encoded using "replace" before writing them.
@@ -54,11 +60,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data, str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 
@@ -102,93 +114,12 @@ def unicode_argv():
         return ["ignoblekeygen.py"]
     else:
         argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
+        return [arg if (isinstance(arg, str) or isinstance(arg,unicode)) else str(arg, argvencoding) for arg in sys.argv]
 
 
 class IGNOBLEError(Exception):
     pass
 
-def _load_crypto_libcrypto():
-    from ctypes import CDLL, POINTER, c_void_p, c_char_p, c_int, c_long, \
-        Structure, c_ulong, create_string_buffer, cast
-    from ctypes.util import find_library
-
-    if iswindows:
-        libcrypto = find_library('libeay32')
-    else:
-        libcrypto = find_library('crypto')
-
-    if libcrypto is None:
-        raise IGNOBLEError('libcrypto not found')
-    libcrypto = CDLL(libcrypto)
-
-    AES_MAXNR = 14
-
-    c_char_pp = POINTER(c_char_p)
-    c_int_p = POINTER(c_int)
-
-    class AES_KEY(Structure):
-        _fields_ = [('rd_key', c_long * (4 * (AES_MAXNR + 1))),
-                    ('rounds', c_int)]
-    AES_KEY_p = POINTER(AES_KEY)
-
-    def F(restype, name, argtypes):
-        func = getattr(libcrypto, name)
-        func.restype = restype
-        func.argtypes = argtypes
-        return func
-
-    AES_set_encrypt_key = F(c_int, 'AES_set_encrypt_key',
-                            [c_char_p, c_int, AES_KEY_p])
-    AES_cbc_encrypt = F(None, 'AES_cbc_encrypt',
-                        [c_char_p, c_char_p, c_ulong, AES_KEY_p, c_char_p,
-                         c_int])
-
-    class AES(object):
-        def __init__(self, userkey, iv):
-            self._blocksize = len(userkey)
-            self._iv = iv
-            key = self._key = AES_KEY()
-            rv = AES_set_encrypt_key(userkey, len(userkey) * 8, key)
-            if rv < 0:
-                raise IGNOBLEError('Failed to initialize AES Encrypt key')
-
-        def encrypt(self, data):
-            out = create_string_buffer(len(data))
-            rv = AES_cbc_encrypt(data, out, len(data), self._key, self._iv, 1)
-            if rv == 0:
-                raise IGNOBLEError('AES encryption failed')
-            return out.raw
-
-    return AES
-
-def _load_crypto_pycrypto():
-    from Crypto.Cipher import AES as _AES
-
-    class AES(object):
-        def __init__(self, key, iv):
-            self._aes = _AES.new(key, _AES.MODE_CBC, iv)
-
-        def encrypt(self, data):
-            return self._aes.encrypt(data)
-
-    return AES
-
-def _load_crypto():
-    AES = None
-    cryptolist = (_load_crypto_libcrypto, _load_crypto_pycrypto)
-    if sys.platform.startswith('win'):
-        cryptolist = (_load_crypto_pycrypto, _load_crypto_libcrypto)
-    for loader in cryptolist:
-        try:
-            AES = loader()
-            break
-        except (ImportError, IGNOBLEError):
-            pass
-    return AES
-
-AES = _load_crypto()
-
 def normalize_name(name):
     return ''.join(x for x in name.lower() if x != ' ')
 
@@ -209,8 +140,7 @@ def generate_key(name, ccn):
     name_sha = hashlib.sha1(name).digest()[:16]
     ccn_sha = hashlib.sha1(ccn).digest()[:16]
     both_sha = hashlib.sha1(name + ccn).digest()
-    aes = AES(ccn_sha, name_sha)
-    crypt = aes.encrypt(both_sha + (b'\x0c' * 0x0c))
+    crypt = AES.new(ccn_sha, AES.MODE_CBC, name_sha).encrypt(both_sha + (b'\x0c' * 0x0c))
     userkey = hashlib.sha1(crypt).digest()
     return base64.b64encode(userkey)
 
@@ -220,11 +150,6 @@ def cli_main():
     sys.stderr=SafeUnbuffered(sys.stderr)
     argv=unicode_argv()
     progname = os.path.basename(argv[0])
-    if AES is None:
-        print("%s: This script requires OpenSSL or PyCrypto, which must be installed " \
-              "separately.  Read the top-of-script comment for details." % \
-              (progname,))
-        return 1
     if len(argv) != 4:
         print("usage: {0} <Name> <CC#> <keyfileout.b64>".format(progname))
         return 1
@@ -310,13 +235,6 @@ def gui_main():
             self.status['text'] = "Keyfile successfully generated"
 
     root = tkinter.Tk()
-    if AES is None:
-        root.withdraw()
-        tkinter.messagebox.showerror(
-            "Ignoble EPUB Keyfile Generator",
-            "This script requires OpenSSL or PyCrypto, which must be installed "
-            "separately.  Read the top-of-script comment for details.")
-        return 1
     root.title("Barnes & Noble ePub Keyfile Generator v.{0}".format(__version__))
     root.resizable(True, False)
     root.minsize(300, 0)

DeDRM_plugin/ignoblekeyNookStudy.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-# ignoblekey.py
+# ignoblekeyNookStudy.py
 # Copyright © 2015-2020 Apprentice Alf, Apprentice Harper et al.
 
 # Based on kindlekey.py, Copyright © 2010-2013 by some_updates and Apprentice Alf
@@ -37,11 +37,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data, str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 
@@ -85,7 +91,7 @@ def unicode_argv():
         return ["ignoblekey.py"]
     else:
         argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
+        return [arg if (isinstance(arg, str) or isinstance(arg,unicode)) else str(arg, argvencoding) for arg in sys.argv]
 
 class DrmException(Exception):
     pass
@@ -95,7 +101,10 @@ def getNookLogFiles():
     logFiles = []
     found = False
     if iswindows:
-        import winreg
+        try:
+            import winreg
+        except ImportError:
+            import _winreg as winreg
 
         # some 64 bit machines do not have the proper registry key for some reason
         # or the python interface to the 32 vs 64 bit registry is broken
@@ -148,7 +157,7 @@ def getNookLogFiles():
             logpath = path +'\\Barnes & Noble\\NOOKstudy\\logs\\BNClientLog.txt'
             if os.path.isfile(logpath):
                 found = True
-                print('Found nookStudy log file: ' + logpath.encode('ascii','ignore'))
+                print('Found nookStudy log file: ' + logpath.encode('ascii','ignore'), file=sys.stderr)
                 logFiles.append(logpath)
     else:
         home = os.getenv('HOME')
@@ -156,26 +165,26 @@ def getNookLogFiles():
         testpath = home + '/Library/Application Support/Barnes & Noble/DesktopReader/logs/BNClientLog.txt'
         if os.path.isfile(testpath):
             logFiles.append(testpath)
-            print('Found nookStudy log file: ' + testpath)
+            print('Found nookStudy log file: ' + testpath, file=sys.stderr)
             found = True
         testpath = home + '/Library/Application Support/Barnes & Noble/DesktopReader/indices/BNClientLog.txt'
         if os.path.isfile(testpath):
             logFiles.append(testpath)
-            print('Found nookStudy log file: ' + testpath)
+            print('Found nookStudy log file: ' + testpath, file=sys.stderr)
             found = True
         testpath = home + '/Library/Application Support/Barnes & Noble/BNDesktopReader/logs/BNClientLog.txt'
         if os.path.isfile(testpath):
             logFiles.append(testpath)
-            print('Found nookStudy log file: ' + testpath)
+            print('Found nookStudy log file: ' + testpath, file=sys.stderr)
             found = True
         testpath = home + '/Library/Application Support/Barnes & Noble/BNDesktopReader/indices/BNClientLog.txt'
         if os.path.isfile(testpath):
             logFiles.append(testpath)
-            print('Found nookStudy log file: ' + testpath)
+            print('Found nookStudy log file: ' + testpath, file=sys.stderr)
             found = True
 
     if not found:
-        print('No nook Study log files have been found.')
+        print('No nook Study log files have been found.', file=sys.stderr)
     return logFiles
 
 
@@ -196,7 +205,7 @@ def nookkeys(files = []):
     for file in files:
         fileKeys = getKeysFromLog(file)
         if fileKeys:
-            print("Found {0} keys in the Nook Study log files".format(len(fileKeys)))
+            print("Found {0} keys in the Nook Study log files".format(len(fileKeys)), file=sys.stderr)
             keys.extend(fileKeys)
     return list(set(keys))
 
@@ -209,7 +218,7 @@ def getkey(outpath, files=[]):
             outfile = outpath
             with open(outfile, 'w') as keyfileout:
                 keyfileout.write(keys[-1])
-            print("Saved a key to {0}".format(outfile))
+            print("Saved a key to {0}".format(outfile), file=sys.stderr)
         else:
             keycount = 0
             for key in keys:
@@ -220,7 +229,7 @@ def getkey(outpath, files=[]):
                         break
                 with open(outfile, 'w') as keyfileout:
                     keyfileout.write(key)
-                print("Saved a key to {0}".format(outfile))
+                print("Saved a key to {0}".format(outfile), file=sys.stderr)
         return True
     return False
 

DeDRM_plugin/ignoblekeyWindowsStore.py

@@ -0,0 +1,78 @@
+# vim:fileencoding=UTF-8:ts=4:sw=4:sta:et:sts=4:ai
+
+'''
+Obtain the user's ccHash from the Barnes & Noble Nook Windows Store app. 
+https://www.microsoft.com/en-us/p/nook-books-magazines-newspapers-comics/9wzdncrfj33h
+(Requires a recent Windows version in a supported region (US).)
+This procedure has been tested with Nook app version 1.11.0.4 under Windows 11.
+
+Based on experimental standalone python script created by fesiwi at 
+https://github.com/noDRM/DeDRM_tools/discussions/9
+'''
+
+import sys, os
+import apsw
+import base64
+import traceback
+try: 
+    from Cryptodome.Cipher import AES
+except:
+    from Crypto.Cipher import AES
+import hashlib
+from lxml import etree
+
+def unpad(data, padding=16):
+    if sys.version_info[0] == 2:
+        pad_len = ord(data[-1])
+    else:
+        pad_len = data[-1]
+
+    return data[:-pad_len]
+
+
+NOOK_DATA_FOLDER = "%LOCALAPPDATA%\\Packages\\BarnesNoble.Nook_ahnzqzva31enc\\LocalState"
+PASS_HASH_SECRET = "9ca588496a1bc4394553d9e018d70b9e"
+
+
+def dump_keys(print_result=False):
+    db_filename = os.path.expandvars(NOOK_DATA_FOLDER + "\\NookDB.db3")
+
+
+    if not os.path.isfile(db_filename):
+        print("Database file not found. Is the Nook Windows Store app installed?")
+        return []
+
+    
+    # Python2 has no fetchone() so we have to use fetchall() and discard everything but the first result.
+    # There should only be one result anyways.
+    serial_number = apsw.Connection(db_filename).cursor().execute(
+                "SELECT value FROM bn_internal_key_value_table WHERE key = 'serialNumber';").fetchall()[0][0]
+
+
+    hash_key = hashlib.sha1(bytearray.fromhex(serial_number + PASS_HASH_SECRET)).digest()[:16]
+
+    activation_file_name = os.path.expandvars(NOOK_DATA_FOLDER + "\\settings\\activation.xml")
+
+    if not os.path.isfile(activation_file_name):
+        print("Activation file not found. Are you logged in to your Nook account?")
+        return []
+
+
+    activation_xml = etree.parse(activation_file_name)
+
+    decrypted_hashes = []
+
+    for pass_hash in activation_xml.findall(".//{http://ns.adobe.com/adept}passHash"):
+        try: 
+            encrypted_cc_hash = base64.b64decode(pass_hash.text)
+            cc_hash = unpad(AES.new(hash_key, AES.MODE_CBC, encrypted_cc_hash[:16]).decrypt(encrypted_cc_hash[16:]), 16)
+            decrypted_hashes.append((base64.b64encode(cc_hash).decode("ascii")))
+            if print_result:
+                print("Nook ccHash is %s" % (base64.b64encode(cc_hash).decode("ascii")))
+        except: 
+            traceback.print_exc()
+    
+    return decrypted_hashes
+
+if __name__ == "__main__":
+    dump_keys(True)

DeDRM_plugin/ignoblekeyfetch.py

@@ -25,7 +25,12 @@
 #   2.0 - Python 3 for calibre 5.0
 
 """
-Fetch Barnes & Noble EPUB user key from B&N servers using email and password
+Fetch Barnes & Noble EPUB user key from B&N servers using email and password.
+
+NOTE: This script used to work in the past, but the server it uses is long gone.
+It can no longer be used to download keys from B&N servers, it is no longer
+supported by the Calibre plugin, and it will be removed in the future. 
+
 """
 
 __license__ = 'GPL v3'
@@ -44,11 +49,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data, str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 
@@ -92,7 +103,7 @@ def unicode_argv():
         return ["ignoblekeyfetch.py"]
     else:
         argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
+        return [arg if (isinstance(arg, str) or isinstance(arg,unicode)) else str(arg, argvencoding) for arg in sys.argv]
 
 
 class IGNOBLEError(Exception):

DeDRM_plugin/ineptepub.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 # ineptepub.py
-# Copyright © 2009-2020 by i♥cabbages, Apprentice Harper et al.
+# Copyright © 2009-2022 by i♥cabbages, Apprentice Harper et al.
 
 # Released under the terms of the GNU General Public Licence, version 3
 # <http://www.gnu.org/licenses/>
@@ -30,23 +30,44 @@
 #   6.5 - Completely remove erroneous check on DER file sanity
 #   6.6 - Import tkFileDialog, don't assume something else will import it.
 #   7.0 - Add Python 3 compatibility for calibre 5.0
+#   7.1 - Add ignoble support, dropping the dedicated ignobleepub.py script
+#   7.2 - Only support PyCryptodome; clean up the code
+#   8.0 - Add support for "hardened" Adobe DRM (RMSDK >= 10)
 
 """
 Decrypt Adobe Digital Editions encrypted ePub books.
 """
 
 __license__ = 'GPL v3'
-__version__ = "7.0"
+__version__ = "8.0"
 
-import codecs
 import sys
 import os
 import traceback
+import base64
 import zlib
 import zipfile
 from zipfile import ZipInfo, ZipFile, ZIP_STORED, ZIP_DEFLATED
 from contextlib import closing
-import xml.etree.ElementTree as etree
+from lxml import etree
+from uuid import UUID
+import hashlib
+
+try:
+    from Cryptodome.Cipher import AES, PKCS1_v1_5
+    from Cryptodome.PublicKey import RSA
+except ImportError:
+    from Crypto.Cipher import AES, PKCS1_v1_5
+    from Crypto.PublicKey import RSA
+
+
+def unpad(data, padding=16):
+    if sys.version_info[0] == 2:
+        pad_len = ord(data[-1])
+    else:
+        pad_len = data[-1]
+
+    return data[:-pad_len]
 
 # Wrap a stream so that output gets flushed immediately
 # and also make sure that any unicode strings get
@@ -58,11 +79,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data, str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 
@@ -104,252 +131,54 @@ def unicode_argv():
         return ["ineptepub.py"]
     else:
         argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
+        return [arg if (isinstance(arg, str) or isinstance(arg,unicode)) else str(arg, argvencoding) for arg in sys.argv]
 
 
 class ADEPTError(Exception):
     pass
 
-def _load_crypto_libcrypto():
-    from ctypes import CDLL, POINTER, c_void_p, c_char_p, c_int, c_long, \
-        Structure, c_ulong, create_string_buffer, cast
-    from ctypes.util import find_library
+class ADEPTNewVersionError(Exception):
+    pass
 
-    if iswindows:
-        libcrypto = find_library('libeay32')
-    else:
-        libcrypto = find_library('crypto')
-
-    if libcrypto is None:
-        raise ADEPTError('libcrypto not found')
-    libcrypto = CDLL(libcrypto)
-
-    RSA_NO_PADDING = 3
-    AES_MAXNR = 14
-
-    c_char_pp = POINTER(c_char_p)
-    c_int_p = POINTER(c_int)
-
-    class RSA(Structure):
-        pass
-    RSA_p = POINTER(RSA)
-
-    class AES_KEY(Structure):
-        _fields_ = [('rd_key', c_long * (4 * (AES_MAXNR + 1))),
-                    ('rounds', c_int)]
-    AES_KEY_p = POINTER(AES_KEY)
-
-    def F(restype, name, argtypes):
-        func = getattr(libcrypto, name)
-        func.restype = restype
-        func.argtypes = argtypes
-        return func
-
-    d2i_RSAPrivateKey = F(RSA_p, 'd2i_RSAPrivateKey',
-                          [RSA_p, c_char_pp, c_long])
-    RSA_size = F(c_int, 'RSA_size', [RSA_p])
-    RSA_private_decrypt = F(c_int, 'RSA_private_decrypt',
-                            [c_int, c_char_p, c_char_p, RSA_p, c_int])
-    RSA_free = F(None, 'RSA_free', [RSA_p])
-    AES_set_decrypt_key = F(c_int, 'AES_set_decrypt_key',
-                            [c_char_p, c_int, AES_KEY_p])
-    AES_cbc_encrypt = F(None, 'AES_cbc_encrypt',
-                        [c_char_p, c_char_p, c_ulong, AES_KEY_p, c_char_p,
-                         c_int])
-
-    class RSA(object):
-        def __init__(self, der):
-            buf = create_string_buffer(der)
-            pp = c_char_pp(cast(buf, c_char_p))
-            rsa = self._rsa = d2i_RSAPrivateKey(None, pp, len(der))
-            if rsa is None:
-                raise ADEPTError('Error parsing ADEPT user key DER')
-
-        def decrypt(self, from_):
-            rsa = self._rsa
-            to = create_string_buffer(RSA_size(rsa))
-            dlen = RSA_private_decrypt(len(from_), from_, to, rsa,
-                                       RSA_NO_PADDING)
-            if dlen < 0:
-                raise ADEPTError('RSA decryption failed')
-            return to[:dlen]
-
-        def __del__(self):
-            if self._rsa is not None:
-                RSA_free(self._rsa)
-                self._rsa = None
-
-    class AES(object):
-        def __init__(self, userkey):
-            self._blocksize = len(userkey)
-            if (self._blocksize != 16) and (self._blocksize != 24) and (self._blocksize != 32) :
-                raise ADEPTError('AES improper key used')
-                return
-            key = self._key = AES_KEY()
-            rv = AES_set_decrypt_key(userkey, len(userkey) * 8, key)
-            if rv < 0:
-                raise ADEPTError('Failed to initialize AES key')
-
-        def decrypt(self, data):
-            out = create_string_buffer(len(data))
-            iv = (b"\x00" * self._blocksize)
-            rv = AES_cbc_encrypt(data, out, len(data), self._key, iv, 0)
-            if rv == 0:
-                raise ADEPTError('AES decryption failed')
-            return out.raw
-
-    return (AES, RSA)
-
-def _load_crypto_pycrypto():
-    from Crypto.Cipher import AES as _AES
-    from Crypto.PublicKey import RSA as _RSA
-    from Crypto.Cipher import PKCS1_v1_5 as _PKCS1_v1_5
-
-    # ASN.1 parsing code from tlslite
-    class ASN1Error(Exception):
-        pass
-
-    class ASN1Parser(object):
-        class Parser(object):
-            def __init__(self, bytes):
-                self.bytes = bytes
-                self.index = 0
-
-            def get(self, length):
-                if self.index + length > len(self.bytes):
-                    raise ASN1Error("Error decoding ASN.1")
-                x = 0
-                for count in range(length):
-                    x <<= 8
-                    x |= self.bytes[self.index]
-                    self.index += 1
-                return x
-
-            def getFixBytes(self, lengthBytes):
-                bytes = self.bytes[self.index : self.index+lengthBytes]
-                self.index += lengthBytes
-                return bytes
-
-            def getVarBytes(self, lengthLength):
-                lengthBytes = self.get(lengthLength)
-                return self.getFixBytes(lengthBytes)
-
-            def getFixList(self, length, lengthList):
-                l = [0] * lengthList
-                for x in range(lengthList):
-                    l[x] = self.get(length)
-                return l
-
-            def getVarList(self, length, lengthLength):
-                lengthList = self.get(lengthLength)
-                if lengthList % length != 0:
-                    raise ASN1Error("Error decoding ASN.1")
-                lengthList = int(lengthList/length)
-                l = [0] * lengthList
-                for x in range(lengthList):
-                    l[x] = self.get(length)
-                return l
-
-            def startLengthCheck(self, lengthLength):
-                self.lengthCheck = self.get(lengthLength)
-                self.indexCheck = self.index
-
-            def setLengthCheck(self, length):
-                self.lengthCheck = length
-                self.indexCheck = self.index
-
-            def stopLengthCheck(self):
-                if (self.index - self.indexCheck) != self.lengthCheck:
-                    raise ASN1Error("Error decoding ASN.1")
-
-            def atLengthCheck(self):
-                if (self.index - self.indexCheck) < self.lengthCheck:
-                    return False
-                elif (self.index - self.indexCheck) == self.lengthCheck:
-                    return True
-                else:
-                    raise ASN1Error("Error decoding ASN.1")
-
-        def __init__(self, bytes):
-            p = self.Parser(bytes)
-            p.get(1)
-            self.length = self._getASN1Length(p)
-            self.value = p.getFixBytes(self.length)
-
-        def getChild(self, which):
-            p = self.Parser(self.value)
-            for x in range(which+1):
-                markIndex = p.index
-                p.get(1)
-                length = self._getASN1Length(p)
-                p.getFixBytes(length)
-            return ASN1Parser(p.bytes[markIndex:p.index])
-
-        def _getASN1Length(self, p):
-            firstLength = p.get(1)
-            if firstLength<=127:
-                return firstLength
-            else:
-                lengthLength = firstLength & 0x7F
-                return p.get(lengthLength)
-
-    class AES(object):
-        def __init__(self, key):
-            self._aes = _AES.new(key, _AES.MODE_CBC, b'\x00'*16)
-
-        def decrypt(self, data):
-            return self._aes.decrypt(data)
-
-    class RSA(object):
-        def __init__(self, der):
-            key = ASN1Parser([x for x in der])
-            key = [key.getChild(x).value for x in range(1, 4)]
-            key = [self.bytesToNumber(v) for v in key]
-            self._rsa = _RSA.construct(key)
-
-        def bytesToNumber(self, bytes):
-            total = 0
-            for byte in bytes:
-                total = (total << 8) + byte
-            return total
-
-        def decrypt(self, data):
-            return _PKCS1_v1_5.new(self._rsa).decrypt(data, 172)
-
-    return (AES, RSA)
-
-def _load_crypto():
-    AES = RSA = None
-    cryptolist = (_load_crypto_libcrypto, _load_crypto_pycrypto)
-    if sys.platform.startswith('win'):
-        cryptolist = (_load_crypto_pycrypto, _load_crypto_libcrypto)
-    for loader in cryptolist:
-        try:
-            AES, RSA = loader()
-            break
-        except (ImportError, ADEPTError):
-            pass
-    return (AES, RSA)
-
-AES, RSA = _load_crypto()
-
-META_NAMES = ('mimetype', 'META-INF/rights.xml', 'META-INF/encryption.xml')
+META_NAMES = ('mimetype', 'META-INF/rights.xml')
 NSMAP = {'adept': 'http://ns.adobe.com/adept',
          'enc': 'http://www.w3.org/2001/04/xmlenc#'}
 
 class Decryptor(object):
     def __init__(self, bookkey, encryption):
         enc = lambda tag: '{%s}%s' % (NSMAP['enc'], tag)
-        self._aes = AES(bookkey)
+        self._aes = AES.new(bookkey, AES.MODE_CBC, b'\x00'*16)
         encryption = etree.fromstring(encryption)
         self._encrypted = encrypted = set()
+        self._otherData = otherData = set()
+
+        self._json_elements_to_remove = json_elements_to_remove = set()
+        self._has_remaining_xml = False
         expr = './%s/%s/%s' % (enc('EncryptedData'), enc('CipherData'),
                                enc('CipherReference'))
         for elem in encryption.findall(expr):
             path = elem.get('URI', None)
+            encryption_type_url = (elem.getparent().getparent().find("./%s" % (enc('EncryptionMethod'))).get('Algorithm', None))
             if path is not None:
-                path = path.encode('utf-8')
-                encrypted.add(path)
+                if (encryption_type_url == "http://www.w3.org/2001/04/xmlenc#aes128-cbc"):
+                    # Adobe
+                    path = path.encode('utf-8')
+                    encrypted.add(path)
+                    json_elements_to_remove.add(elem.getparent().getparent())
+                else:
+                    path = path.encode('utf-8')
+                    otherData.add(path)
+                    self._has_remaining_xml = True
+
+        for elem in json_elements_to_remove:
+            elem.getparent().remove(elem)
+
+    def check_if_remaining(self):
+        return self._has_remaining_xml
+
+    def get_xml(self):
+        return "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + etree.tostring(self._encryption, encoding="utf-8", pretty_print=True, xml_declaration=False).decode("utf-8")
+
 
     def decompress(self, bytes):
         dc = zlib.decompressobj(-15)
@@ -361,8 +190,8 @@ class Decryptor(object):
         except:
             # possibly not compressed by zip - just return bytes
             return bytes
-        return decompressed_bytes 
-    
+        return decompressed_bytes
+
     def decrypt(self, path, data):
         if path.encode('utf-8') in self._encrypted:
             data = self._aes.decrypt(data)[16:]
@@ -386,19 +215,68 @@ def adeptBook(inpath):
             adept = lambda tag: '{%s}%s' % (NSMAP['adept'], tag)
             expr = './/%s' % (adept('encryptedKey'),)
             bookkey = ''.join(rights.findtext(expr))
-            if len(bookkey) == 172:
+            if len(bookkey) in [192, 172, 64]:
                 return True
         except:
             # if we couldn't check, assume it is
             return True
     return False
 
-def decryptBook(userkey, inpath, outpath):
-    if AES is None:
-        raise ADEPTError("PyCrypto or OpenSSL must be installed.")
-    rsa = RSA(userkey)
+def isPassHashBook(inpath):
+    # If this is an Adobe book, check if it's a PassHash-encrypted book (B&N)
     with closing(ZipFile(open(inpath, 'rb'))) as inf:
         namelist = set(inf.namelist())
+        if 'META-INF/rights.xml' not in namelist or \
+           'META-INF/encryption.xml' not in namelist:
+            return False
+        try:
+            rights = etree.fromstring(inf.read('META-INF/rights.xml'))
+            adept = lambda tag: '{%s}%s' % (NSMAP['adept'], tag)
+            expr = './/%s' % (adept('encryptedKey'),)
+            bookkey = ''.join(rights.findtext(expr))
+            if len(bookkey) == 64:
+                return True
+        except:
+            pass
+
+    return False
+
+# Checks the license file and returns the UUID the book is licensed for.
+# This is used so that the Calibre plugin can pick the correct decryption key
+# first try without having to loop through all possible keys.
+def adeptGetUserUUID(inpath):
+    with closing(ZipFile(open(inpath, 'rb'))) as inf:
+        try:
+            rights = etree.fromstring(inf.read('META-INF/rights.xml'))
+            adept = lambda tag: '{%s}%s' % (NSMAP['adept'], tag)
+            expr = './/%s' % (adept('user'),)
+            user_uuid = ''.join(rights.findtext(expr))
+            if user_uuid[:9] != "urn:uuid:":
+                return None
+            return user_uuid[9:]
+        except:
+            return None
+
+def removeHardening(rights, keytype, keydata):
+    adept = lambda tag: '{%s}%s' % (NSMAP['adept'], tag)
+    textGetter = lambda name: ''.join(rights.findtext('.//%s' % (adept(name),)))
+
+    # Gather what we need, and generate the IV
+    resourceuuid = UUID(textGetter("resource"))
+    deviceuuid = UUID(textGetter("device"))
+    fullfillmentuuid = UUID(textGetter("fulfillment")[:36])
+    kekiv = UUID(int=resourceuuid.int ^ deviceuuid.int ^ fullfillmentuuid.int).bytes
+
+    # Derive kek from just "keytype"
+    rem = int(keytype, 10) % 16
+    H = hashlib.sha256(keytype.encode("ascii")).digest()
+    kek = H[2*rem : 16 + rem] + H[rem : 2*rem]
+
+    return unpad(AES.new(kek, AES.MODE_CBC, kekiv).decrypt(keydata), 16) # PKCS#7
+
+def decryptBook(userkey, inpath, outpath):
+    with closing(ZipFile(open(inpath, 'rb'))) as inf:
+        namelist = inf.namelist()
         if 'META-INF/rights.xml' not in namelist or \
            'META-INF/encryption.xml' not in namelist:
             print("{0:s} is DRM-free.".format(os.path.basename(inpath)))
@@ -409,42 +287,65 @@ def decryptBook(userkey, inpath, outpath):
             rights = etree.fromstring(inf.read('META-INF/rights.xml'))
             adept = lambda tag: '{%s}%s' % (NSMAP['adept'], tag)
             expr = './/%s' % (adept('encryptedKey'),)
-            bookkey = ''.join(rights.findtext(expr))
-            if len(bookkey) != 172:
-                print("{0:s} is not a secure Adobe Adept ePub.".format(os.path.basename(inpath)))
+            bookkeyelem = rights.find(expr)
+            bookkey = bookkeyelem.text
+            keytype = bookkeyelem.attrib.get('keyType', '0')
+            if len(bookkey) >= 172 and int(keytype, 10) > 2:
+                print("{0:s} is a secure Adobe Adept ePub with hardening.".format(os.path.basename(inpath)))
+            elif len(bookkey) == 172:
+                print("{0:s} is a secure Adobe Adept ePub.".format(os.path.basename(inpath)))
+            elif len(bookkey) == 64:
+                print("{0:s} is a secure Adobe PassHash (B&N) ePub.".format(os.path.basename(inpath)))
+            else:
+                print("{0:s} is not an Adobe-protected ePub!".format(os.path.basename(inpath)))
                 return 1
-            bookkey = rsa.decrypt(codecs.decode(bookkey.encode('ascii'), 'base64'))
-            # Padded as per RSAES-PKCS1-v1_5
-            if len(bookkey) > 16:
-                if bookkey[-17] == '\x00' or bookkey[-17] == 0:
-                    bookkey = bookkey[-16:]
-                else:
+
+            if len(bookkey) != 64:
+                # Normal or "hardened" Adobe ADEPT
+                rsakey = RSA.import_key(userkey) # parses the ASN1 structure
+                bookkey = base64.b64decode(bookkey)
+                if int(keytype, 10) > 2:
+                    bookkey = removeHardening(rights, keytype, bookkey)
+                try:
+                    bookkey = PKCS1_v1_5.new(rsakey).decrypt(bookkey, None) # automatically unpads
+                except ValueError:
+                    bookkey = None
+
+                if bookkey is None:
                     print("Could not decrypt {0:s}. Wrong key".format(os.path.basename(inpath)))
                     return 2
+            else:
+                # Adobe PassHash / B&N
+                key = base64.b64decode(userkey)[:16]
+                bookkey = base64.b64decode(bookkey)
+                bookkey = unpad(AES.new(key, AES.MODE_CBC, b'\x00'*16).decrypt(bookkey), 16) # PKCS#7
+
+                if len(bookkey) > 16:
+                    bookkey = bookkey[-16:]
+
             encryption = inf.read('META-INF/encryption.xml')
             decryptor = Decryptor(bookkey, encryption)
             kwds = dict(compression=ZIP_DEFLATED, allowZip64=False)
             with closing(ZipFile(open(outpath, 'wb'), 'w', **kwds)) as outf:
-                zi = ZipInfo('mimetype')
-                zi.compress_type=ZIP_STORED
-                try:
-                    # if the mimetype is present, get its info, including time-stamp
-                    oldzi = inf.getinfo('mimetype')
-                    # copy across fields to be preserved
-                    zi.date_time = oldzi.date_time
-                    zi.comment = oldzi.comment
-                    zi.extra = oldzi.extra
-                    zi.internal_attr = oldzi.internal_attr
-                    # external attributes are dependent on the create system, so copy both.
-                    zi.external_attr = oldzi.external_attr
-                    zi.create_system = oldzi.create_system
-                except:
-                    pass
-                outf.writestr(zi, inf.read('mimetype'))
-                for path in namelist:
+
+                for path in (["mimetype"] + namelist):
                     data = inf.read(path)
                     zi = ZipInfo(path)
                     zi.compress_type=ZIP_DEFLATED
+
+                    if path == "mimetype":
+                        zi.compress_type = ZIP_STORED
+
+                    elif path == "META-INF/encryption.xml":
+                        # Check if there's still something in there
+                        if (decryptor.check_if_remaining()):
+                            data = decryptor.get_xml()
+                            print("Adding encryption.xml for the remaining embedded files.")
+                            # We removed DRM, but there's still stuff like obfuscated fonts.
+                        else:
+                            continue
+
+
                     try:
                         # get the file info, including time-stamp
                         oldzi = inf.getinfo(path)
@@ -456,9 +357,15 @@ def decryptBook(userkey, inpath, outpath):
                         # external attributes are dependent on the create system, so copy both.
                         zi.external_attr = oldzi.external_attr
                         zi.create_system = oldzi.create_system
+                        if any(ord(c) >= 128 for c in path) or any(ord(c) >= 128 for c in zi.comment):
+                            # If the file name or the comment contains any non-ASCII char, set the UTF8-flag
+                            zi.flag_bits |= 0x800
                     except:
                         pass
-                    outf.writestr(zi, decryptor.decrypt(path, data))
+                    if path == "META-INF/encryption.xml":
+                        outf.writestr(zi, data)
+                    else:
+                        outf.writestr(zi, decryptor.decrypt(path, data))
         except:
             print("Could not decrypt {0:s} because of an exception:\n{1:s}".format(os.path.basename(inpath), traceback.format_exc()))
             return 2

DeDRM_plugin/ion.py

@@ -30,8 +30,12 @@ import struct
 
 from io import BytesIO
 
-from Crypto.Cipher import AES
-from Crypto.Util.py3compat import bchr
+try:
+    from Cryptodome.Cipher import AES
+    from Cryptodome.Util.py3compat import bchr
+except ImportError:
+    from Crypto.Cipher import AES
+    from Crypto.Util.py3compat import bchr
 
 try:
     # lzma library from calibre 4.6.0 or later
@@ -512,6 +516,8 @@ class BinaryIonParser(object):
 
         if table is not None:
             self.symbols.import_(table, min(maxid, len(table.symnames)))
+            if len(table.symnames) < maxid:
+                self.symbols.importunknown(name + "-unknown", maxid - len(table.symnames))
         else:
             self.symbols.importunknown(name, maxid)
 
@@ -733,7 +739,10 @@ SYM_NAMES = [ 'com.amazon.drm.Envelope@1.0',
               'com.amazon.drm.EncryptedPage@2.0',
               'com.amazon.drm.PlainText@2.0', 'compression_algorithm',
               'com.amazon.drm.Compressed@1.0', 'page_index_table',
-              'com.amazon.drm.VoucherEnvelope@2.0', 'com.amazon.drm.VoucherEnvelope@3.0' ]
+              ] + ['com.amazon.drm.VoucherEnvelope@%d.0' % n
+                   for n in list(range(2, 29)) + [
+                                   9708, 1031, 2069, 9041, 3646,
+                                   6052, 9479, 9888, 4648, 5683]]
 
 def addprottable(ion):
     ion.addtocatalog("ProtectedData", 1, SYM_NAMES)
@@ -756,10 +765,49 @@ def pkcs7unpad(msg, blocklen):
     return msg[:-paddinglen]
 
 
+
+
+
 # every VoucherEnvelope version has a corresponding "word" and magic number, used in obfuscating the shared secret
-VOUCHER_VERSION_INFOS = {
-    2: [b'Antidisestablishmentarianism', 5],
-    3: [b'Floccinaucinihilipilification', 8]
+OBFUSCATION_TABLE = {
+    "V1":    (0x00, None),
+    "V2":    (0x05, b'Antidisestablishmentarianism'),
+    "V3":    (0x08, b'Floccinaucinihilipilification'),
+    "V4":    (0x07, b'>\x14\x0c\x12\x10-\x13&\x18U\x1d\x05Rlt\x03!\x19\x1b\x13\x04]Y\x19,\t\x1b'),
+    "V5":    (0x06, b'~\x18~\x16J\\\x18\x10\x05\x0b\x07\t\x0cZ\r|\x1c\x15\x1d\x11>,\x1b\x0e\x03"4\x1b\x01'),
+    "V6":    (0x09, b'3h\x055\x03[^>\x19\x1c\x08\x1b\rtm4\x02Rp\x0c\x16B\n'),
+    "V7":    (0x05, b'\x10\x1bJ\x18\nh!\x10"\x03>Z\'\r\x01]W\x06\x1c\x1e?\x0f\x13'),
+    "V8":    (0x09, b"K\x0c6\x1d\x1a\x17pO}Rk\x1d'w1^\x1f$\x1c{C\x02Q\x06\x1d`"),
+    "V9":    (0x05, b'X.\x0eW\x1c*K\x12\x12\t\n\n\x17Wx\x01\x02Yf\x0f\x18\x1bVXPi\x01'),
+    "V10":   (0x07, b'z3\n\x039\x12\x13`\x06=v,\x02MTK\x1e%}L\x1c\x1f\x15\x0c\x11\x02\x0c\n8\x17p'),
+    "V11":   (0x05, b'L=\nhVm\x07go\n6\x14\x06\x16L\r\x02\x0b\x0c\x1b\x04#p\t'),
+    "V12":   (0x06, b',n\x1d\rl\x13\x1c\x13\x16p\x14\x07U\x0c\x1f\x19w\x16\x16\x1d5T'),
+    "V13":   (0x07, b'I\x05\t\x08\x03r)\x01$N\x0fr3n\x0b062D\x0f\x13'),
+    "V14":   (0x05, b"\x03\x02\x1c9\x19\x15\x15q\x1057\x08\x16\x0cF\x1b.Fw\x01\x12\x03\x13\x02\x17S'hk6"),
+    "V15":   (0x0A, b'&,4B\x1dcI\x0bU\x03I\x07\x04\x1c\t\x05c\x07%ws\x0cj\t\x1a\x08\x0f'),
+    "V16":   (0x0A, b'\x06\x18`h,b><\x06PqR\x02Zc\x034\n\x16\x1e\x18\x06#e'),
+    "V17":   (0x07, b'y\r\x12\x08fw.[\x02\t\n\x13\x11\x0c\x11b\x1e8L\x10(\x13<Jx6c\x0f'),
+    "V18":   (0x07, b'I\x0b\x0e,\x19\x1aIa\x10s\x19g\\\x1b\x11!\x18yf\x0f\t\x1d7[bSp\x03'),
+    "V19":   (0x05, b'\n6>)N\x02\x188\x016s\x13\x14\x1b\x16jeN\n\x146\x04\x18\x1c\x0c\x19\x1f,\x02]'),
+    "V20":   (0x08, b'_\r\x01\x12]\\\x14*\x17i\x14\r\t!\x1e,~hZ\x12jK\x17\x1e*1'),
+    "V21":   (0x07, b'e\x1d\x19|\ty\x1di|N\x13\x0e\x04\x1bj<h\x13\x15k\x12\x08=\x1f\x16~\x13l'),
+    "V22":   (0x08, b'?\x17yi$k7Pc\tEo\x0c\x07\x07\t\x1f,*i\x12\x0cI0\x10I\x1a?2\x04'),
+    "V23":   (0x08, b'\x16+db\x13\x04\x18\rc%\x14\x17\x0f\x13F\x0c[\t9\x1ay\x01\x1eH'),
+    "V24":   (0x06, b'|6\\\x1a\r\x10\nP\x07\x0fu\x1f\t,\rr`uv\\~55\x11]N'),
+    "V25":   (0x09, b'\x07\x14w\x1e,^y\x01:\x08\x07\x1fr\tU#j\x16\x12\x1eB\x04\x16=\x06fZ\x07\x02\x06'),
+    "V26":   (0x06, b'\x03IL\x1e"K\x1f\x0f\x1fp0\x01`X\x02z0`\x03\x0eN\x07'),
+    "V27":   (0x07, b'Xk\x10y\x02\x18\x10\x17\x1d,\x0e\x05e\x10\x15"e\x0fh(\x06s\x1c\x08I\x0c\x1b\x0e'),
+    "V28":   (0x0A, b'6P\x1bs\x0f\x06V.\x1cM\x14\x02\n\x1b\x07{P0:\x18zaU\x05'),
+    "V9708": (0x05, b'\x1diIm\x08a\x17\x1e!am\x1d\x1aQ.\x16!\x06*\}x04\x11\t\x06\x04?'),
+    "V1031": (0x08, b'Antidisestablishmentarianism'),
+    "V2069": (0x07, b'Floccinaucinihilipilification'),
+    "V9041": (0x06, b'>\x14\x0c\x12\x10-\x13&\x18U\x1d\x05Rlt\x03!\x19\x1b\x13\x04]Y\x19,\t\x1b'),
+    "V3646": (0x09, b'~\x18~\x16J\\\x18\x10\x05\x0b\x07\t\x0cZ\r|\x1c\x15\x1d\x11>,\x1b\x0e\x03"4\x1b\x01'),
+    "V6052": (0x05, b'3h\x055\x03[^>\x19\x1c\x08\x1b\rtm4\x02Rp\x0c\x16B\n'),
+    "V9479": (0x09, b'\x10\x1bJ\x18\nh!\x10"\x03>Z\'\r\x01]W\x06\x1c\x1e?\x0f\x13'),
+    "V9888": (0x05, b"K\x0c6\x1d\x1a\x17pO}Rk\x1d'w1^\x1f$\x1c{C\x02Q\x06\x1d`"),
+    "V4648": (0x07, b'X.\x0eW\x1c*K\x12\x12\t\n\n\x17Wx\x01\x02Yf\x0f\x18\x1bVXPi\x01'),
+    "V5683": (0x05, b'z3\n\x039\x12\x13`\x06=v,\x02MTK\x1e%}L\x1c\x1f\x15\x0c\x11\x02\x0c\n8\x17p'),
 }
 
 
@@ -768,9 +816,7 @@ def obfuscate(secret, version):
     if version == 1:  # v1 does not use obfuscation
         return secret
 
-    params = VOUCHER_VERSION_INFOS[version]
-    word = params[0]
-    magic = params[1]
+    magic, word = OBFUSCATION_TABLE["V%d" % version]
 
     # extend secret so that its length is divisible by the magic number
     if len(secret) % magic != 0:
@@ -809,6 +855,12 @@ class DrmIonVoucher(object):
     def __init__(self, voucherenv, dsn, secret):
         self.dsn, self.secret = dsn, secret
 
+        if isinstance(dsn, str):
+            self.dsn = dsn.encode('ASCII')
+
+        if isinstance(secret, str):
+            self.secret = secret.encode('ASCII')
+
         self.lockparams = []
 
         self.envelope = BinaryIonParser(voucherenv)
@@ -993,6 +1045,7 @@ class DrmIon(object):
 
                 elif self.ion.gettypename() in ["com.amazon.drm.EncryptedPage@1.0", "com.amazon.drm.EncryptedPage@2.0"]:
                     decompress = False
+                    decrypt = True
                     ct = None
                     civ = None
                     self.ion.stepin()
@@ -1006,7 +1059,23 @@ class DrmIon(object):
                             civ = self.ion.lobvalue()
 
                     if ct is not None and civ is not None:
-                        self.processpage(ct, civ, outpages, decompress)
+                        self.processpage(ct, civ, outpages, decompress, decrypt)
+                    self.ion.stepout()
+
+                elif self.ion.gettypename() in ["com.amazon.drm.PlainText@1.0", "com.amazon.drm.PlainText@2.0"]:
+                    decompress = False
+                    decrypt = False
+                    plaintext = None
+                    self.ion.stepin()
+                    while self.ion.hasnext():
+                        self.ion.next()
+                        if self.ion.gettypename() == "com.amazon.drm.Compressed@1.0":
+                            decompress = True
+                        if self.ion.getfieldname() == "data":
+                            plaintext = self.ion.lobvalue()
+
+                    if plaintext is not None:
+                        self.processpage(plaintext, None, outpages, decompress, decrypt)
                     self.ion.stepout()
 
             self.ion.stepout()
@@ -1017,9 +1086,12 @@ class DrmIon(object):
     def print_(self, lst):
         self.ion.print_(lst)
 
-    def processpage(self, ct, civ, outpages, decompress):
-        aes = AES.new(self.key[:16], AES.MODE_CBC, civ[:16])
-        msg = pkcs7unpad(aes.decrypt(ct), 16)
+    def processpage(self, ct, civ, outpages, decompress, decrypt):
+        if decrypt:
+            aes = AES.new(self.key[:16], AES.MODE_CBC, civ[:16])
+            msg = pkcs7unpad(aes.decrypt(ct), 16)
+        else:
+            msg = ct
 
         if not decompress:
             outpages.write(msg)

DeDRM_plugin/k4mobidedrm.py

@@ -69,29 +69,24 @@ import getopt
 import re
 import traceback
 import time
-import html.entities
+try: 
+    import html.entities as htmlentitydefs
+except:
+    import htmlentitydefs
+
 import json
 
+#@@CALIBRE_COMPAT_CODE@@
+
+
 class DrmException(Exception):
     pass
 
-if 'calibre' in sys.modules:
-    inCalibre = True
-else:
-    inCalibre = False
-
-if inCalibre:
-    from calibre_plugins.dedrm import mobidedrm
-    from calibre_plugins.dedrm import topazextract
-    from calibre_plugins.dedrm import kgenpids
-    from calibre_plugins.dedrm import androidkindlekey
-    from calibre_plugins.dedrm import kfxdedrm
-else:
-    import mobidedrm
-    import topazextract
-    import kgenpids
-    import androidkindlekey
-    import kfxdedrm
+import mobidedrm
+import topazextract
+import kgenpids
+import androidkindlekey
+import kfxdedrm
 
 # Wrap a stream so that output gets flushed immediately
 # and also make sure that any unicode strings get
@@ -103,11 +98,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data, str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 
@@ -148,7 +149,7 @@ def unicode_argv():
         return ["mobidedrm.py"]
     else:
         argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
+        return [arg if (isinstance(arg, str) or isinstance(arg,unicode)) else str(arg, argvencoding) for arg in sys.argv]
 
 # cleanup unicode filenames
 # borrowed from calibre from calibre/src/calibre/__init__.py
@@ -218,8 +219,11 @@ def GetDecryptedBook(infile, kDatabases, androidFiles, serials, pids, starttime
     else:
         mb = topazextract.TopazBook(infile)
 
-    bookname = unescape(mb.getBookTitle())
-    print("Decrypting {1} ebook: {0}".format(bookname, mb.getBookType()))
+    try: 
+        bookname = unescape(mb.getBookTitle())
+        print("Decrypting {1} ebook: {0}".format(bookname, mb.getBookType()))
+    except: 
+        print("Decrypting {0} ebook.".format(mb.getBookType()))
 
     # copy list of pids
     totalpids = list(pids)
@@ -237,7 +241,7 @@ def GetDecryptedBook(infile, kDatabases, androidFiles, serials, pids, starttime
     try:
         mb.processBook(totalpids)
     except:
-        mb.cleanup
+        mb.cleanup()
         raise
 
     print("Decryption succeeded after {0:.1f} seconds".format(time.time()-starttime))

DeDRM_plugin/kfxdedrm.py

@@ -4,17 +4,23 @@
 # Engine to remove drm from Kindle KFX ebooks
 
 #  2.0   - Python 3 for calibre 5.0
+#  2.1   - Some fixes for debugging
+#  2.1.1 - Whitespace!
 
 
-import os
+import os, sys
 import shutil
+import traceback
 import zipfile
 
 from io import BytesIO
-try:
-    from ion import DrmIon, DrmIonVoucher
-except:
-    from calibre_plugins.dedrm.ion import DrmIon, DrmIonVoucher
+
+
+#@@CALIBRE_COMPAT_CODE@@
+
+
+from ion import DrmIon, DrmIonVoucher
+
 
 
 __license__ = 'GPL v3'
@@ -65,6 +71,9 @@ class KFXZipBook:
         print("Decrypting KFX DRM voucher: {0}".format(info.filename))
 
         for pid in [''] + totalpids:
+            # Belt and braces. PIDs should be unicode strings, but just in case...
+            if isinstance(pid, bytes):
+                pid = pid.decode('ascii')
             for dsn_len,secret_len in [(0,0), (16,0), (16,40), (32,40), (40,0), (40,40)]:
                 if len(pid) == dsn_len + secret_len:
                     break       # split pid into DSN and account secret
@@ -77,6 +86,7 @@ class KFXZipBook:
                 voucher.decryptvoucher()
                 break
             except:
+                traceback.print_exc()
                 pass
         else:
             raise Exception("Failed to decrypt KFX DRM voucher with any key")
@@ -85,8 +95,10 @@ class KFXZipBook:
 
         license_type = voucher.getlicensetype()
         if license_type != "Purchase":
-            raise Exception(("This book is licensed as {0}. "
-                    'These tools are intended for use on purchased books.').format(license_type))
+            #raise Exception(("This book is licensed as {0}. "
+            #        'These tools are intended for use on purchased books.').format(license_type))
+            print("Warning: This book is licensed as {0}. "
+                    "These tools are intended for use on purchased books. Continuing ...".format(license_type))
 
         self.voucher = voucher
 

DeDRM_plugin/kgenpids.py

@@ -209,7 +209,7 @@ def getK4Pids(rec209, token, kindleDatabase):
         kindleAccountToken = bytearray.fromhex((kindleDatabase[1])['kindle.account.tokens'])
 
     except KeyError:
-        kindleAccountToken=""
+        kindleAccountToken = b''
         pass
 
     try:

DeDRM_plugin/kindlekey.py

@@ -2,10 +2,10 @@
 # -*- coding: utf-8 -*-
 
 # kindlekey.py
-# Copyright © 2008-2020 Apprentice Harper et al.
+# Copyright © 2008-2022 Apprentice Harper et al.
 
 __license__ = 'GPL v3'
-__version__ = '3.0'
+__version__ = '3.1'
 
 # Revision history:
 #  1.0   - Kindle info file decryption, extracted from k4mobidedrm, etc.
@@ -30,6 +30,7 @@ __version__ = '3.0'
 #  2.7   - Finish .kinf2018 support, PC & Mac by Apprentice Sakuya
 #  2.8   - Fix for Mac OS X Big Sur
 #  3.0   - Python 3 for calibre 5.0
+#  3.1   - Only support PyCryptodome; clean up the code
 
 
 """
@@ -42,6 +43,16 @@ from struct import pack, unpack, unpack_from
 import json
 import getopt
 import traceback
+import hashlib
+
+try:
+    from Cryptodome.Cipher import AES
+    from Cryptodome.Util import Counter
+    from Cryptodome.Protocol.KDF import PBKDF2
+except ImportError:
+    from Crypto.Cipher import AES
+    from Crypto.Util import Counter
+    from Crypto.Protocol.KDF import PBKDF2
 
 try:
     RegError
@@ -61,11 +72,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data, str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 
@@ -109,28 +126,22 @@ def unicode_argv():
         return ["kindlekey.py"]
     else:
         argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
+        return [arg if (isinstance(arg, str) or isinstance(arg,unicode)) else str(arg, argvencoding) for arg in sys.argv]
 
 class DrmException(Exception):
     pass
 
 # crypto digestroutines
-import hashlib
 
 def MD5(message):
-    ctx = hashlib.md5()
-    ctx.update(message)
-    return ctx.digest()
+    return hashlib.md5(message).digest()
 
 def SHA1(message):
-    ctx = hashlib.sha1()
-    ctx.update(message)
-    return ctx.digest()
+    return hashlib.sha1(message).digest()
 
 def SHA256(message):
-    ctx = hashlib.sha256()
-    ctx.update(message)
-    return ctx.digest()
+    return hashlib.sha256(message).digest()
+
 
 # For K4M/PC 1.6.X and later
 def primes(n):
@@ -183,648 +194,28 @@ def decode(data,map):
         result += pack('B',value)
     return result
 
+def UnprotectHeaderData(encryptedData):
+    passwdData = b'header_key_data'
+    salt = b'HEADER.2011'
+    key_iv = PBKDF2(passwdData, salt, dkLen=256, count=128)
+    return AES.new(key_iv[0:32], AES.MODE_CBC, key_iv[32:48]).decrypt(encryptedData)
+
 # Routines unique to Mac and PC
 if iswindows:
     from ctypes import windll, c_char_p, c_wchar_p, c_uint, POINTER, byref, \
         create_unicode_buffer, create_string_buffer, CFUNCTYPE, addressof, \
         string_at, Structure, c_void_p, cast
 
-    import winreg
+    try:
+        import winreg
+    except ImportError:
+        import _winreg as winreg
+
     MAX_PATH = 255
     kernel32 = windll.kernel32
     advapi32 = windll.advapi32
     crypt32 = windll.crypt32
 
-    try:
-        # try to get fast routines from alfcrypto
-        from alfcrypto import AES_CBC, KeyIVGen
-    except:
-        # alfcrypto not available, so use python implementations
-        """
-            Routines for doing AES CBC in one file
-
-            Modified by some_updates to extract
-            and combine only those parts needed for AES CBC
-            into one simple to add python file
-
-            Original Version
-            Copyright (c) 2002 by Paul A. Lambert
-            Under:
-            CryptoPy Artistic License Version 1.0
-            See the wonderful pure python package cryptopy-1.2.5
-            and read its LICENSE.txt for complete license details.
-        """
-
-        class CryptoError(Exception):
-            """ Base class for crypto exceptions """
-            def __init__(self,errorMessage='Error!'):
-                self.message = errorMessage
-            def __str__(self):
-                return self.message
-
-        class InitCryptoError(CryptoError):
-            """ Crypto errors during algorithm initialization """
-        class BadKeySizeError(InitCryptoError):
-            """ Bad key size error """
-        class EncryptError(CryptoError):
-            """ Error in encryption processing """
-        class DecryptError(CryptoError):
-            """ Error in decryption processing """
-        class DecryptNotBlockAlignedError(DecryptError):
-            """ Error in decryption processing """
-
-        def xor(a,b):
-            """ XOR two byte arrays, to lesser length """
-            x = []
-            for i in range(min(len(a),len(b))):
-                x.append( a[i] ^ b[i])
-            return bytes(x)
-
-        """
-            Base 'BlockCipher' and Pad classes for cipher instances.
-            BlockCipher supports automatic padding and type conversion. The BlockCipher
-            class was written to make the actual algorithm code more readable and
-            not for performance.
-        """
-
-        class BlockCipher:
-            """ Block ciphers """
-            def __init__(self):
-                self.reset()
-
-            def reset(self):
-                self.resetEncrypt()
-                self.resetDecrypt()
-            def resetEncrypt(self):
-                self.encryptBlockCount = 0
-                self.bytesToEncrypt = b''
-            def resetDecrypt(self):
-                self.decryptBlockCount = 0
-                self.bytesToDecrypt = b''
-
-            def encrypt(self, plainText, more = None):
-                """ Encrypt a string and return a binary string """
-                self.bytesToEncrypt += plainText  # append plainText to any bytes from prior encrypt
-                numBlocks, numExtraBytes = divmod(len(self.bytesToEncrypt), self.blockSize)
-                cipherText = ''
-                for i in range(numBlocks):
-                    bStart = i*self.blockSize
-                    ctBlock = self.encryptBlock(self.bytesToEncrypt[bStart:bStart+self.blockSize])
-                    self.encryptBlockCount += 1
-                    cipherText += ctBlock
-                if numExtraBytes > 0:        # save any bytes that are not block aligned
-                    self.bytesToEncrypt = self.bytesToEncrypt[-numExtraBytes:]
-                else:
-                    self.bytesToEncrypt = ''
-
-                if more == None:   # no more data expected from caller
-                    finalBytes = self.padding.addPad(self.bytesToEncrypt,self.blockSize)
-                    if len(finalBytes) > 0:
-                        ctBlock = self.encryptBlock(finalBytes)
-                        self.encryptBlockCount += 1
-                        cipherText += ctBlock
-                    self.resetEncrypt()
-                return cipherText
-
-            def decrypt(self, cipherText, more = None):
-                """ Decrypt a string and return a string """
-                self.bytesToDecrypt += cipherText  # append to any bytes from prior decrypt
-
-                numBlocks, numExtraBytes = divmod(len(self.bytesToDecrypt), self.blockSize)
-                if more == None:  # no more calls to decrypt, should have all the data
-                    if numExtraBytes  != 0:
-                        raise DecryptNotBlockAlignedError('Data not block aligned on decrypt')
-
-                # hold back some bytes in case last decrypt has zero len
-                if (more != None) and (numExtraBytes == 0) and (numBlocks >0) :
-                    numBlocks -= 1
-                    numExtraBytes = self.blockSize
-
-                plainText = b''
-                for i in range(numBlocks):
-                    bStart = i*self.blockSize
-                    ptBlock = self.decryptBlock(self.bytesToDecrypt[bStart : bStart+self.blockSize])
-                    self.decryptBlockCount += 1
-                    plainText += ptBlock
-
-                if numExtraBytes > 0:        # save any bytes that are not block aligned
-                    self.bytesToEncrypt = self.bytesToEncrypt[-numExtraBytes:]
-                else:
-                    self.bytesToEncrypt = ''
-
-                if more == None:         # last decrypt remove padding
-                    plainText = self.padding.removePad(plainText, self.blockSize)
-                    self.resetDecrypt()
-                return plainText
-
-
-        class Pad:
-            def __init__(self):
-                pass              # eventually could put in calculation of min and max size extension
-
-        class padWithPadLen(Pad):
-            """ Pad a binary string with the length of the padding """
-
-            def addPad(self, extraBytes, blockSize):
-                """ Add padding to a binary string to make it an even multiple
-                    of the block size """
-                blocks, numExtraBytes = divmod(len(extraBytes), blockSize)
-                padLength = blockSize - numExtraBytes
-                return extraBytes + padLength*chr(padLength)
-
-            def removePad(self, paddedBinaryString, blockSize):
-                """ Remove padding from a binary string """
-                if not(0<len(paddedBinaryString)):
-                    raise DecryptNotBlockAlignedError('Expected More Data')
-                return paddedBinaryString[:-ord(paddedBinaryString[-1])]
-
-        class noPadding(Pad):
-            """ No padding. Use this to get ECB behavior from encrypt/decrypt """
-
-            def addPad(self, extraBytes, blockSize):
-                """ Add no padding """
-                return extraBytes
-
-            def removePad(self, paddedBinaryString, blockSize):
-                """ Remove no padding """
-                return paddedBinaryString
-
-        """
-            Rijndael encryption algorithm
-            This byte oriented implementation is intended to closely
-            match FIPS specification for readability.  It is not implemented
-            for performance.
-        """
-
-        class Rijndael(BlockCipher):
-            """ Rijndael encryption algorithm """
-            def __init__(self, key = None, padding = padWithPadLen(), keySize=16, blockSize=16 ):
-                self.name       = 'RIJNDAEL'
-                self.keySize    = keySize
-                self.strength   = keySize*8
-                self.blockSize  = blockSize  # blockSize is in bytes
-                self.padding    = padding    # change default to noPadding() to get normal ECB behavior
-
-                assert( keySize%4==0 and (keySize//4) in NrTable[4]),'key size must be 16,20,24,29 or 32 bytes'
-                assert( blockSize%4==0 and (blockSize//4) in NrTable), 'block size must be 16,20,24,29 or 32 bytes'
-
-                self.Nb = self.blockSize//4          # Nb is number of columns of 32 bit words
-                self.Nk = keySize//4                 # Nk is the key length in 32-bit words
-                self.Nr = NrTable[self.Nb][self.Nk] # The number of rounds (Nr) is a function of
-                                                    # the block (Nb) and key (Nk) sizes.
-                if key != None:
-                    self.setKey(key)
-
-            def setKey(self, key):
-                """ Set a key and generate the expanded key """
-                assert( len(key) == (self.Nk*4) ), 'Key length must be same as keySize parameter'
-                self.__expandedKey = keyExpansion(self, key)
-                self.reset()                   # BlockCipher.reset()
-
-            def encryptBlock(self, plainTextBlock):
-                """ Encrypt a block, plainTextBlock must be a array of bytes [Nb by 4] """
-                self.state = self._toBlock(plainTextBlock)
-                AddRoundKey(self, self.__expandedKey[0:self.Nb])
-                for round in range(1,self.Nr):          #for round = 1 step 1 to Nr
-                    SubBytes(self)
-                    ShiftRows(self)
-                    MixColumns(self)
-                    AddRoundKey(self, self.__expandedKey[round*self.Nb:(round+1)*self.Nb])
-                SubBytes(self)
-                ShiftRows(self)
-                AddRoundKey(self, self.__expandedKey[self.Nr*self.Nb:(self.Nr+1)*self.Nb])
-                return self._toBString(self.state)
-
-
-            def decryptBlock(self, encryptedBlock):
-                """ decrypt a block (array of bytes) """
-                self.state = self._toBlock(encryptedBlock)
-                AddRoundKey(self, self.__expandedKey[self.Nr*self.Nb:(self.Nr+1)*self.Nb])
-                for round in range(self.Nr-1,0,-1):
-                    InvShiftRows(self)
-                    InvSubBytes(self)
-                    AddRoundKey(self, self.__expandedKey[round*self.Nb:(round+1)*self.Nb])
-                    InvMixColumns(self)
-                InvShiftRows(self)
-                InvSubBytes(self)
-                AddRoundKey(self, self.__expandedKey[0:self.Nb])
-                return self._toBString(self.state)
-
-            def _toBlock(self, bs):
-                """ Convert binary string to array of bytes, state[col][row]"""
-                assert ( len(bs) == 4*self.Nb ), 'Rijndarl blocks must be of size blockSize'
-                return [[bs[4*i],bs[4*i+1],bs[4*i+2],bs[4*i+3]] for i in range(self.Nb)]
-
-            def _toBString(self, block):
-                """ Convert block (array of bytes) to binary string """
-                l = []
-                for col in block:
-                    for rowElement in col:
-                        l.append(rowElement)
-                return bytes(l)
-        #-------------------------------------
-        """    Number of rounds Nr = NrTable[Nb][Nk]
-
-                    Nb  Nk=4   Nk=5   Nk=6   Nk=7   Nk=8
-                    -------------------------------------   """
-        NrTable =  {4: {4:10,  5:11,  6:12,  7:13,  8:14},
-                    5: {4:11,  5:11,  6:12,  7:13,  8:14},
-                    6: {4:12,  5:12,  6:12,  7:13,  8:14},
-                    7: {4:13,  5:13,  6:13,  7:13,  8:14},
-                    8: {4:14,  5:14,  6:14,  7:14,  8:14}}
-        #-------------------------------------
-        def keyExpansion(algInstance, keyArray):
-            """ Expand a byte array of size keySize into a larger array """
-            Nk, Nb, Nr = algInstance.Nk, algInstance.Nb, algInstance.Nr # for readability
-            w = [[keyArray[4*i],keyArray[4*i+1],keyArray[4*i+2],keyArray[4*i+3]] for i in range(Nk)]
-            for i in range(Nk,Nb*(Nr+1)):
-                temp = w[i-1]        # a four byte column
-                if (i%Nk) == 0 :
-                    temp     = temp[1:]+[temp[0]]  # RotWord(temp)
-                    temp     = [ Sbox[byte] for byte in temp ]
-                    temp[0] ^= Rcon[i//Nk]
-                elif Nk > 6 and  i%Nk == 4 :
-                    temp     = [ Sbox[byte] for byte in temp ]  # SubWord(temp)
-                w.append( [ w[i-Nk][byte]^temp[byte] for byte in range(4) ] )
-            return w
-
-        Rcon = (0,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36,     # note extra '0' !!!
-                0x6c,0xd8,0xab,0x4d,0x9a,0x2f,0x5e,0xbc,0x63,0xc6,
-                0x97,0x35,0x6a,0xd4,0xb3,0x7d,0xfa,0xef,0xc5,0x91)
-
-        #-------------------------------------
-        def AddRoundKey(algInstance, keyBlock):
-            """ XOR the algorithm state with a block of key material """
-            for column in range(algInstance.Nb):
-                for row in range(4):
-                    algInstance.state[column][row] ^= keyBlock[column][row]
-        #-------------------------------------
-
-        def SubBytes(algInstance):
-            for column in range(algInstance.Nb):
-                for row in range(4):
-                    algInstance.state[column][row] = Sbox[algInstance.state[column][row]]
-
-        def InvSubBytes(algInstance):
-            for column in range(algInstance.Nb):
-                for row in range(4):
-                    algInstance.state[column][row] = InvSbox[algInstance.state[column][row]]
-
-        Sbox =    (0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,
-                   0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
-                   0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,
-                   0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
-                   0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,
-                   0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
-                   0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,
-                   0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
-                   0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,
-                   0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
-                   0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,
-                   0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
-                   0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,
-                   0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
-                   0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,
-                   0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
-                   0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,
-                   0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
-                   0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,
-                   0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
-                   0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,
-                   0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
-                   0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,
-                   0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
-                   0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,
-                   0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
-                   0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,
-                   0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
-                   0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,
-                   0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
-                   0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,
-                   0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16)
-
-        InvSbox = (0x52,0x09,0x6a,0xd5,0x30,0x36,0xa5,0x38,
-                   0xbf,0x40,0xa3,0x9e,0x81,0xf3,0xd7,0xfb,
-                   0x7c,0xe3,0x39,0x82,0x9b,0x2f,0xff,0x87,
-                   0x34,0x8e,0x43,0x44,0xc4,0xde,0xe9,0xcb,
-                   0x54,0x7b,0x94,0x32,0xa6,0xc2,0x23,0x3d,
-                   0xee,0x4c,0x95,0x0b,0x42,0xfa,0xc3,0x4e,
-                   0x08,0x2e,0xa1,0x66,0x28,0xd9,0x24,0xb2,
-                   0x76,0x5b,0xa2,0x49,0x6d,0x8b,0xd1,0x25,
-                   0x72,0xf8,0xf6,0x64,0x86,0x68,0x98,0x16,
-                   0xd4,0xa4,0x5c,0xcc,0x5d,0x65,0xb6,0x92,
-                   0x6c,0x70,0x48,0x50,0xfd,0xed,0xb9,0xda,
-                   0x5e,0x15,0x46,0x57,0xa7,0x8d,0x9d,0x84,
-                   0x90,0xd8,0xab,0x00,0x8c,0xbc,0xd3,0x0a,
-                   0xf7,0xe4,0x58,0x05,0xb8,0xb3,0x45,0x06,
-                   0xd0,0x2c,0x1e,0x8f,0xca,0x3f,0x0f,0x02,
-                   0xc1,0xaf,0xbd,0x03,0x01,0x13,0x8a,0x6b,
-                   0x3a,0x91,0x11,0x41,0x4f,0x67,0xdc,0xea,
-                   0x97,0xf2,0xcf,0xce,0xf0,0xb4,0xe6,0x73,
-                   0x96,0xac,0x74,0x22,0xe7,0xad,0x35,0x85,
-                   0xe2,0xf9,0x37,0xe8,0x1c,0x75,0xdf,0x6e,
-                   0x47,0xf1,0x1a,0x71,0x1d,0x29,0xc5,0x89,
-                   0x6f,0xb7,0x62,0x0e,0xaa,0x18,0xbe,0x1b,
-                   0xfc,0x56,0x3e,0x4b,0xc6,0xd2,0x79,0x20,
-                   0x9a,0xdb,0xc0,0xfe,0x78,0xcd,0x5a,0xf4,
-                   0x1f,0xdd,0xa8,0x33,0x88,0x07,0xc7,0x31,
-                   0xb1,0x12,0x10,0x59,0x27,0x80,0xec,0x5f,
-                   0x60,0x51,0x7f,0xa9,0x19,0xb5,0x4a,0x0d,
-                   0x2d,0xe5,0x7a,0x9f,0x93,0xc9,0x9c,0xef,
-                   0xa0,0xe0,0x3b,0x4d,0xae,0x2a,0xf5,0xb0,
-                   0xc8,0xeb,0xbb,0x3c,0x83,0x53,0x99,0x61,
-                   0x17,0x2b,0x04,0x7e,0xba,0x77,0xd6,0x26,
-                   0xe1,0x69,0x14,0x63,0x55,0x21,0x0c,0x7d)
-
-        #-------------------------------------
-        """ For each block size (Nb), the ShiftRow operation shifts row i
-            by the amount Ci.  Note that row 0 is not shifted.
-                         Nb      C1 C2 C3
-                       -------------------  """
-        shiftOffset  = { 4 : ( 0, 1, 2, 3),
-                         5 : ( 0, 1, 2, 3),
-                         6 : ( 0, 1, 2, 3),
-                         7 : ( 0, 1, 2, 4),
-                         8 : ( 0, 1, 3, 4) }
-        def ShiftRows(algInstance):
-            tmp = [0]*algInstance.Nb   # list of size Nb
-            for r in range(1,4):       # row 0 reamains unchanged and can be skipped
-                for c in range(algInstance.Nb):
-                    tmp[c] = algInstance.state[(c+shiftOffset[algInstance.Nb][r]) % algInstance.Nb][r]
-                for c in range(algInstance.Nb):
-                    algInstance.state[c][r] = tmp[c]
-        def InvShiftRows(algInstance):
-            tmp = [0]*algInstance.Nb   # list of size Nb
-            for r in range(1,4):       # row 0 reamains unchanged and can be skipped
-                for c in range(algInstance.Nb):
-                    tmp[c] = algInstance.state[(c+algInstance.Nb-shiftOffset[algInstance.Nb][r]) % algInstance.Nb][r]
-                for c in range(algInstance.Nb):
-                    algInstance.state[c][r] = tmp[c]
-        #-------------------------------------
-        def MixColumns(a):
-            Sprime = [0,0,0,0]
-            for j in range(a.Nb):    # for each column
-                Sprime[0] = mul(2,a.state[j][0])^mul(3,a.state[j][1])^mul(1,a.state[j][2])^mul(1,a.state[j][3])
-                Sprime[1] = mul(1,a.state[j][0])^mul(2,a.state[j][1])^mul(3,a.state[j][2])^mul(1,a.state[j][3])
-                Sprime[2] = mul(1,a.state[j][0])^mul(1,a.state[j][1])^mul(2,a.state[j][2])^mul(3,a.state[j][3])
-                Sprime[3] = mul(3,a.state[j][0])^mul(1,a.state[j][1])^mul(1,a.state[j][2])^mul(2,a.state[j][3])
-                for i in range(4):
-                    a.state[j][i] = Sprime[i]
-
-        def InvMixColumns(a):
-            """ Mix the four bytes of every column in a linear way
-                This is the opposite operation of Mixcolumn """
-            Sprime = [0,0,0,0]
-            for j in range(a.Nb):    # for each column
-                Sprime[0] = mul(0x0E,a.state[j][0])^mul(0x0B,a.state[j][1])^mul(0x0D,a.state[j][2])^mul(0x09,a.state[j][3])
-                Sprime[1] = mul(0x09,a.state[j][0])^mul(0x0E,a.state[j][1])^mul(0x0B,a.state[j][2])^mul(0x0D,a.state[j][3])
-                Sprime[2] = mul(0x0D,a.state[j][0])^mul(0x09,a.state[j][1])^mul(0x0E,a.state[j][2])^mul(0x0B,a.state[j][3])
-                Sprime[3] = mul(0x0B,a.state[j][0])^mul(0x0D,a.state[j][1])^mul(0x09,a.state[j][2])^mul(0x0E,a.state[j][3])
-                for i in range(4):
-                    a.state[j][i] = Sprime[i]
-
-        #-------------------------------------
-        def mul(a, b):
-            """ Multiply two elements of GF(2^m)
-                needed for MixColumn and InvMixColumn """
-            if (a !=0 and  b!=0):
-                return Alogtable[(Logtable[a] + Logtable[b])%255]
-            else:
-                return 0
-
-        Logtable = ( 0,   0,  25,   1,  50,   2,  26, 198,  75, 199,  27, 104,  51, 238, 223,   3,
-                   100,   4, 224,  14,  52, 141, 129, 239,  76, 113,   8, 200, 248, 105,  28, 193,
-                   125, 194,  29, 181, 249, 185,  39, 106,  77, 228, 166, 114, 154, 201,   9, 120,
-                   101,  47, 138,   5,  33,  15, 225,  36,  18, 240, 130,  69,  53, 147, 218, 142,
-                   150, 143, 219, 189,  54, 208, 206, 148,  19,  92, 210, 241,  64,  70, 131,  56,
-                   102, 221, 253,  48, 191,   6, 139,  98, 179,  37, 226, 152,  34, 136, 145,  16,
-                   126, 110,  72, 195, 163, 182,  30,  66,  58, 107,  40,  84, 250, 133,  61, 186,
-                    43, 121,  10,  21, 155, 159,  94, 202,  78, 212, 172, 229, 243, 115, 167,  87,
-                   175,  88, 168,  80, 244, 234, 214, 116,  79, 174, 233, 213, 231, 230, 173, 232,
-                    44, 215, 117, 122, 235,  22,  11, 245,  89, 203,  95, 176, 156, 169,  81, 160,
-                   127,  12, 246, 111,  23, 196,  73, 236, 216,  67,  31,  45, 164, 118, 123, 183,
-                   204, 187,  62,  90, 251,  96, 177, 134,  59,  82, 161, 108, 170,  85,  41, 157,
-                   151, 178, 135, 144,  97, 190, 220, 252, 188, 149, 207, 205,  55,  63,  91, 209,
-                    83,  57, 132,  60,  65, 162, 109,  71,  20,  42, 158,  93,  86, 242, 211, 171,
-                    68,  17, 146, 217,  35,  32,  46, 137, 180, 124, 184,  38, 119, 153, 227, 165,
-                   103,  74, 237, 222, 197,  49, 254,  24,  13,  99, 140, 128, 192, 247, 112,   7)
-
-        Alogtable= ( 1,   3,   5,  15,  17,  51,  85, 255,  26,  46, 114, 150, 161, 248,  19,  53,
-                    95, 225,  56,  72, 216, 115, 149, 164, 247,   2,   6,  10,  30,  34, 102, 170,
-                   229,  52,  92, 228,  55,  89, 235,  38, 106, 190, 217, 112, 144, 171, 230,  49,
-                    83, 245,   4,  12,  20,  60,  68, 204,  79, 209, 104, 184, 211, 110, 178, 205,
-                    76, 212, 103, 169, 224,  59,  77, 215,  98, 166, 241,   8,  24,  40, 120, 136,
-                   131, 158, 185, 208, 107, 189, 220, 127, 129, 152, 179, 206,  73, 219, 118, 154,
-                   181, 196,  87, 249,  16,  48,  80, 240,  11,  29,  39, 105, 187, 214,  97, 163,
-                   254,  25,  43, 125, 135, 146, 173, 236,  47, 113, 147, 174, 233,  32,  96, 160,
-                   251,  22,  58,  78, 210, 109, 183, 194,  93, 231,  50,  86, 250,  21,  63,  65,
-                   195,  94, 226,  61,  71, 201,  64, 192,  91, 237,  44, 116, 156, 191, 218, 117,
-                   159, 186, 213, 100, 172, 239,  42, 126, 130, 157, 188, 223, 122, 142, 137, 128,
-                   155, 182, 193,  88, 232,  35, 101, 175, 234,  37, 111, 177, 200,  67, 197,  84,
-                   252,  31,  33,  99, 165, 244,   7,   9,  27,  45, 119, 153, 176, 203,  70, 202,
-                    69, 207,  74, 222, 121, 139, 134, 145, 168, 227,  62,  66, 198,  81, 243,  14,
-                    18,  54,  90, 238,  41, 123, 141, 140, 143, 138, 133, 148, 167, 242,  13,  23,
-                    57,  75, 221, 124, 132, 151, 162, 253,  28,  36, 108, 180, 199,  82, 246,   1)
-
-
-
-
-        """
-            AES Encryption Algorithm
-            The AES algorithm is just Rijndael algorithm restricted to the default
-            blockSize of 128 bits.
-        """
-
-        class AES(Rijndael):
-            """ The AES algorithm is the Rijndael block cipher restricted to block
-                sizes of 128 bits and key sizes of 128, 192 or 256 bits
-            """
-            def __init__(self, key = None, padding = padWithPadLen(), keySize=16):
-                """ Initialize AES, keySize is in bytes """
-                if  not (keySize == 16 or keySize == 24 or keySize == 32) :
-                    raise BadKeySizeError('Illegal AES key size, must be 16, 24, or 32 bytes')
-
-                Rijndael.__init__( self, key, padding=padding, keySize=keySize, blockSize=16 )
-
-                self.name       = 'AES'
-
-
-        """
-            CBC mode of encryption for block ciphers.
-            This algorithm mode wraps any BlockCipher to make a
-            Cipher Block Chaining mode.
-        """
-        from random             import Random  # should change to crypto.random!!!
-
-
-        class CBC(BlockCipher):
-            """ The CBC class wraps block ciphers to make cipher block chaining (CBC) mode
-                algorithms.  The initialization (IV) is automatic if set to None.  Padding
-                is also automatic based on the Pad class used to initialize the algorithm
-            """
-            def __init__(self, blockCipherInstance, padding = padWithPadLen()):
-                """ CBC algorithms are created by initializing with a BlockCipher instance """
-                self.baseCipher = blockCipherInstance
-                self.name       = self.baseCipher.name + '_CBC'
-                self.blockSize  = self.baseCipher.blockSize
-                self.keySize    = self.baseCipher.keySize
-                self.padding    = padding
-                self.baseCipher.padding = noPadding()   # baseCipher should NOT pad!!
-                self.r          = Random()            # for IV generation, currently uses
-                                                      # mediocre standard distro version     <----------------
-                import time
-                newSeed = time.ctime()+str(self.r)    # seed with instance location
-                self.r.seed(newSeed)                  # to make unique
-                self.reset()
-
-            def setKey(self, key):
-                self.baseCipher.setKey(key)
-
-            # Overload to reset both CBC state and the wrapped baseCipher
-            def resetEncrypt(self):
-                BlockCipher.resetEncrypt(self)  # reset CBC encrypt state (super class)
-                self.baseCipher.resetEncrypt()  # reset base cipher encrypt state
-
-            def resetDecrypt(self):
-                BlockCipher.resetDecrypt(self)  # reset CBC state (super class)
-                self.baseCipher.resetDecrypt()  # reset base cipher decrypt state
-
-            def encrypt(self, plainText, iv=None, more=None):
-                """ CBC encryption - overloads baseCipher to allow optional explicit IV
-                    when iv=None, iv is auto generated!
-                """
-                if self.encryptBlockCount == 0:
-                    self.iv = iv
-                else:
-                    assert(iv==None), 'IV used only on first call to encrypt'
-
-                return BlockCipher.encrypt(self,plainText, more=more)
-
-            def decrypt(self, cipherText, iv=None, more=None):
-                """ CBC decryption - overloads baseCipher to allow optional explicit IV
-                    when iv=None, iv is auto generated!
-                """
-                if self.decryptBlockCount == 0:
-                    self.iv = iv
-                else:
-                    assert(iv==None), 'IV used only on first call to decrypt'
-
-                return BlockCipher.decrypt(self, cipherText, more=more)
-
-            def encryptBlock(self, plainTextBlock):
-                """ CBC block encryption, IV is set with 'encrypt' """
-                auto_IV = ''
-                if self.encryptBlockCount == 0:
-                    if self.iv == None:
-                        # generate IV and use
-                        self.iv = ''.join([chr(self.r.randrange(256)) for i in range(self.blockSize)])
-                        self.prior_encr_CT_block = self.iv
-                        auto_IV = self.prior_encr_CT_block    # prepend IV if it's automatic
-                    else:                       # application provided IV
-                        assert(len(self.iv) == self.blockSize ),'IV must be same length as block'
-                        self.prior_encr_CT_block = self.iv
-                """ encrypt the prior CT XORed with the PT """
-                ct = self.baseCipher.encryptBlock( xor(self.prior_encr_CT_block, plainTextBlock) )
-                self.prior_encr_CT_block = ct
-                return auto_IV+ct
-
-            def decryptBlock(self, encryptedBlock):
-                """ Decrypt a single block """
-
-                if self.decryptBlockCount == 0:   # first call, process IV
-                    if self.iv == None:    # auto decrypt IV?
-                        self.prior_CT_block = encryptedBlock
-                        return b''
-                    else:
-                        assert(len(self.iv)==self.blockSize),"Bad IV size on CBC decryption"
-                        self.prior_CT_block = self.iv
-
-                dct = self.baseCipher.decryptBlock(encryptedBlock)
-                """ XOR the prior decrypted CT with the prior CT """
-                dct_XOR_priorCT = xor( self.prior_CT_block, dct )
-
-                self.prior_CT_block = encryptedBlock
-
-                return dct_XOR_priorCT
-
-
-        """
-            AES_CBC Encryption Algorithm
-        """
-
-        class aescbc_AES_CBC(CBC):
-            """ AES encryption in CBC feedback mode """
-            def __init__(self, key=None, padding=padWithPadLen(), keySize=16):
-                CBC.__init__( self, AES(key, noPadding(), keySize), padding)
-                self.name       = 'AES_CBC'
-
-        class AES_CBC(object):
-            def __init__(self):
-                self._key = None
-                self._iv = None
-                self.aes = None
-
-            def set_decrypt_key(self, userkey, iv):
-                self._key = userkey
-                self._iv = iv
-                self.aes = aescbc_AES_CBC(userkey, noPadding(), len(userkey))
-
-            def decrypt(self, data):
-                iv = self._iv
-                cleartext = self.aes.decrypt(iv + data)
-                return cleartext
-
-        import hmac
-
-        class KeyIVGen(object):
-            # this only exists in openssl so we will use pure python implementation instead
-            # PKCS5_PBKDF2_HMAC_SHA1 = F(c_int, 'PKCS5_PBKDF2_HMAC_SHA1',
-            #                             [c_char_p, c_ulong, c_char_p, c_ulong, c_ulong, c_ulong, c_char_p])
-            def pbkdf2(self, passwd, salt, iter, keylen):
-
-                def xorbytes( a, b ):
-                    if len(a) != len(b):
-                        raise Exception("xorbytes(): lengths differ")
-                    return bytes([x ^ y for x, y in zip(a, b)])
-
-                def prf( h, data ):
-                    hm = h.copy()
-                    hm.update( data )
-                    return hm.digest()
-
-                def pbkdf2_F( h, salt, itercount, blocknum ):
-                    U = prf( h, salt + pack('>i',blocknum ) )
-                    T = U
-                    for i in range(2, itercount+1):
-                        U = prf( h, U )
-                        T = xorbytes( T, U )
-                    return T
-
-                sha = hashlib.sha1
-                digest_size = sha().digest_size
-                # l - number of output blocks to produce
-                l = keylen // digest_size
-                if keylen % digest_size != 0:
-                    l += 1
-                h = hmac.new( passwd, None, sha )
-                T = b""
-                for i in range(1, l+1):
-                    T += pbkdf2_F( h, salt, iter, i )
-                return T[0: keylen]
-
-    def UnprotectHeaderData(encryptedData):
-        passwdData = b'header_key_data'
-        salt = b'HEADER.2011'
-        iter = 0x80
-        keylen = 0x100
-        key_iv = KeyIVGen().pbkdf2(passwdData, salt, iter, keylen)
-        key = key_iv[0:32]
-        iv = key_iv[32:48]
-        aes=AES_CBC()
-        aes.set_decrypt_key(key, iv)
-        cleartext = aes.decrypt(encryptedData)
-        return cleartext
-
     # Various character maps used to decrypt kindle info values.
     # Probably supposed to act as obfuscation
     charMap2 = b"AaZzB0bYyCc1XxDdW2wEeVv3FfUuG4g-TtHh5SsIiR6rJjQq7KkPpL8lOoMm9Nn_"
@@ -1070,7 +461,7 @@ if iswindows:
             salt = str(0x6d8 * int(build)).encode('utf-8') + guid
             sp = GetUserName() + b'+@#$%+' + GetIDString().encode('utf-8')
             passwd = encode(SHA256(sp), charMap5)
-            key = KeyIVGen().pbkdf2(passwd, salt, 10000, 0x400)[:32]  # this is very slow
+            key = PBKDF2(passwd, salt, count=10000, dkLen=0x400)[:32]  # this is very slow
 
         # loop through the item records until all are processed
         while len(items) > 0:
@@ -1133,8 +524,6 @@ if iswindows:
                 entropy = SHA1(keyhash) + added_entropy
                 cleartext = CryptUnprotectData(encryptedValue, entropy, 1)
             elif version == 6:
-                from Crypto.Cipher import AES
-                from Crypto.Util import Counter
                 # decode using new testMap8 to get IV + ciphertext
                 iv_ciphertext = decode(encdata, testMap8)
                 # pad IV so that we can substitute AES-CTR for GCM
@@ -1164,114 +553,8 @@ if iswindows:
             DB = {}
         return DB
 elif isosx:
-    import copy
     import subprocess
 
-    # interface to needed routines in openssl's libcrypto
-    def _load_crypto_libcrypto():
-        from ctypes import CDLL, byref, POINTER, c_void_p, c_char_p, c_int, c_long, \
-            Structure, c_ulong, create_string_buffer, addressof, string_at, cast
-        from ctypes.util import find_library
-
-        libcrypto = find_library('crypto')
-        if libcrypto is None:
-            libcrypto = '/usr/lib/libcrypto.dylib'
-        try:
-            libcrypto = CDLL(libcrypto)
-        except Exception as e:
-            raise DrmException("libcrypto not found: " % e)
-
-        # From OpenSSL's crypto aes header
-        #
-        # AES_ENCRYPT     1
-        # AES_DECRYPT     0
-        # AES_MAXNR 14 (in bytes)
-        # AES_BLOCK_SIZE 16 (in bytes)
-        #
-        # struct aes_key_st {
-        #    unsigned long rd_key[4 *(AES_MAXNR + 1)];
-        #    int rounds;
-        # };
-        # typedef struct aes_key_st AES_KEY;
-        #
-        # int AES_set_decrypt_key(const unsigned char *userKey, const int bits, AES_KEY *key);
-        #
-        # note:  the ivec string, and output buffer are both mutable
-        # void AES_cbc_encrypt(const unsigned char *in, unsigned char *out,
-        #     const unsigned long length, const AES_KEY *key, unsigned char *ivec, const int enc);
-
-        AES_MAXNR = 14
-        c_char_pp = POINTER(c_char_p)
-        c_int_p = POINTER(c_int)
-
-        class AES_KEY(Structure):
-            _fields_ = [('rd_key', c_long * (4 * (AES_MAXNR + 1))), ('rounds', c_int)]
-        AES_KEY_p = POINTER(AES_KEY)
-
-        def F(restype, name, argtypes):
-            func = getattr(libcrypto, name)
-            func.restype = restype
-            func.argtypes = argtypes
-            return func
-
-        AES_cbc_encrypt = F(None, 'AES_cbc_encrypt',[c_char_p, c_char_p, c_ulong, AES_KEY_p, c_char_p,c_int])
-
-        AES_set_decrypt_key = F(c_int, 'AES_set_decrypt_key',[c_char_p, c_int, AES_KEY_p])
-
-        # From OpenSSL's Crypto evp/p5_crpt2.c
-        #
-        # int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen,
-        #                        const unsigned char *salt, int saltlen, int iter,
-        #                        int keylen, unsigned char *out);
-
-        PKCS5_PBKDF2_HMAC_SHA1 = F(c_int, 'PKCS5_PBKDF2_HMAC_SHA1',
-                                    [c_char_p, c_ulong, c_char_p, c_ulong, c_ulong, c_ulong, c_char_p])
-
-        class LibCrypto(object):
-            def __init__(self):
-                self._blocksize = 0
-                self._keyctx = None
-                self._iv = 0
-
-            def set_decrypt_key(self, userkey, iv):
-                self._blocksize = len(userkey)
-                if (self._blocksize != 16) and (self._blocksize != 24) and (self._blocksize != 32) :
-                    raise DrmException("AES improper key used")
-                    return
-                keyctx = self._keyctx = AES_KEY()
-                self._iv = iv
-                self._userkey = userkey
-                rv = AES_set_decrypt_key(userkey, len(userkey) * 8, keyctx)
-                if rv < 0:
-                    raise DrmException("Failed to initialize AES key")
-
-            def decrypt(self, data):
-                out = create_string_buffer(len(data))
-                mutable_iv = create_string_buffer(self._iv, len(self._iv))
-                keyctx = self._keyctx
-                rv = AES_cbc_encrypt(data, out, len(data), keyctx, mutable_iv, 0)
-                if rv == 0:
-                    raise DrmException("AES decryption failed")
-                return out.raw
-
-            def keyivgen(self, passwd, salt, iter, keylen):
-                saltlen = len(salt)
-                passlen = len(passwd)
-                out = create_string_buffer(keylen)
-                rv = PKCS5_PBKDF2_HMAC_SHA1(passwd, passlen, salt, saltlen, iter, keylen, out)
-                return out.raw
-        return LibCrypto
-
-    def _load_crypto():
-        LibCrypto = None
-        try:
-            LibCrypto = _load_crypto_libcrypto()
-        except (ImportError, DrmException):
-            pass
-        return LibCrypto
-
-    LibCrypto = _load_crypto()
-
     # Various character maps used to decrypt books. Probably supposed to act as obfuscation
     charMap1 = b'n5Pr6St7Uv8Wx9YzAb0Cd1Ef2Gh3Jk4M'
     charMap2 = b'ZB0bYyc1xDdW2wEV3Ff7KkPpL8UuGA4gz-Tme9Nn_tHh5SvXCsIiR6rJjQaqlOoM'
@@ -1401,33 +684,13 @@ elif isosx:
         #print "ID Strings:\n",strings
         return strings
 
-
-    # unprotect the new header blob in .kinf2011
-    # used in Kindle for Mac Version >= 1.9.0
-    def UnprotectHeaderData(encryptedData):
-        passwdData = b'header_key_data'
-        salt = b'HEADER.2011'
-        iter = 0x80
-        keylen = 0x100
-        crp = LibCrypto()
-        key_iv = crp.keyivgen(passwdData, salt, iter, keylen)
-        key = key_iv[0:32]
-        iv = key_iv[32:48]
-        crp.set_decrypt_key(key,iv)
-        cleartext = crp.decrypt(encryptedData)
-        return cleartext
-
-
     # implements an Pseudo Mac Version of Windows built-in Crypto routine
     class CryptUnprotectData(object):
         def __init__(self, entropy, IDString):
             sp = GetUserName() + b'+@#$%+' + IDString
             passwdData = encode(SHA256(sp),charMap2)
             salt = entropy
-            self.crp = LibCrypto()
-            iter = 0x800
-            keylen = 0x400
-            key_iv = self.crp.keyivgen(passwdData, salt, iter, keylen)
+            key_iv = PBKDF2(passwdData, salt, count=0x800, dkLen=0x400)
             self.key = key_iv[0:32]
             self.iv = key_iv[32:48]
             self.crp.set_decrypt_key(self.key, self.iv)
@@ -1516,7 +779,7 @@ elif isosx:
             b'SerialNumber',\
             b'UsernameHash',\
             b'kindle.directedid.info',\
-            b'DSN'
+            b'DSN',\
             b'kindle.accounttype.info',\
             b'krx.flashcardsplugin.data.encryption_key',\
             b'krx.notebookexportplugin.data.encryption_key',\
@@ -1565,7 +828,7 @@ elif isosx:
                     salt = str(0x6d8 * int(build)).encode('utf-8') + guid
                     sp = GetUserName() + b'+@#$%+' + IDString
                     passwd = encode(SHA256(sp), charMap5)
-                    key = LibCrypto().keyivgen(passwd, salt, 10000, 0x400)[:32]
+                    key = PBKDF2(passwd, salt, count=10000, dkLen=0x400)[:32]
 
                     #print ("salt",salt)
                     #print ("sp",sp)
@@ -1637,8 +900,6 @@ elif isosx:
                         cleartext = cud.decrypt(encryptedValue)
 
                     elif version == 6:
-                        from Crypto.Cipher import AES
-                        from Crypto.Util import Counter
                         # decode using new testMap8 to get IV + ciphertext
                         iv_ciphertext = decode(encdata, testMap8)
                         # pad IV so that we can substitute AES-CTR for GCM

DeDRM_plugin/kindlepid.py

@@ -26,11 +26,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data, str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 
@@ -71,7 +77,7 @@ def unicode_argv():
         return ["kindlepid.py"]
     else:
         argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
+        return [arg if (isinstance(arg, str) or isinstance(arg,unicode)) else str(arg, argvencoding) for arg in sys.argv]
 
 letters = 'ABCDEFGHIJKLMNPQRSTUVWXYZ123456789'
 

DeDRM_plugin/lcpdedrm.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# lcpdedrm.py
+# Copyright © 2021-2022 NoDRM
+
+# Released under the terms of the GNU General Public Licence, version 3
+# <http://www.gnu.org/licenses/>
+
+
+# Revision history:
+#   1 - Initial release
+#   2 - LCP DRM code removed due to a DMCA takedown.
+
+"""
+This file used to contain code to remove the Readium LCP DRM
+from eBooks. Unfortunately, Readium has issued a DMCA takedown 
+request, so I was forced to remove that code: 
+
+https://github.com/github/dmca/blob/master/2022/01/2022-01-04-readium.md
+
+This file now just returns an error message when asked to remove LCP DRM.
+For more information, see this issue: 
+https://github.com/noDRM/DeDRM_tools/issues/18 
+"""
+
+__license__ = 'GPL v3'
+__version__ = "2"
+
+import json
+from zipfile import ZipFile
+from contextlib import closing
+
+
+class LCPError(Exception):
+    pass
+
+# Check file to see if this is an LCP-protected file
+def isLCPbook(inpath):
+    try: 
+        with closing(ZipFile(open(inpath, 'rb'))) as lcpbook:
+            if ("META-INF/license.lcpl" not in lcpbook.namelist() or
+                "META-INF/encryption.xml" not in lcpbook.namelist() or
+                b"EncryptedContentKey" not in lcpbook.read("META-INF/encryption.xml")):
+                return False
+
+            license = json.loads(lcpbook.read('META-INF/license.lcpl'))
+
+            if "id" in license and "encryption" in license and "profile" in license["encryption"]:
+                return True
+
+    except: 
+        return False
+    
+    return False
+
+
+# Takes a file and a list of passphrases
+def decryptLCPbook(inpath, passphrases, parent_object):
+
+    if not isLCPbook(inpath):
+        raise LCPError("This is not an LCP-encrypted book")
+
+    print("LCP: LCP DRM removal no longer supported due to a DMCA takedown request.")
+    print("LCP: The takedown request can be found here: ")
+    print("LCP: https://github.com/github/dmca/blob/master/2022/01/2022-01-04-readium.md ")
+    print("LCP: More information can be found in the Github repository: ")
+    print("LCP: https://github.com/noDRM/DeDRM_tools/issues/18 ")
+
+    raise LCPError("LCP DRM removal no longer supported")

DeDRM_plugin/mobidedrm.py

@@ -7,7 +7,7 @@
 
 from __future__ import print_function
 __license__ = 'GPL v3'
-__version__ = "1.0"
+__version__ = "1.1"
 
 # This is a python script. You need a Python interpreter to run it.
 # For example, ActiveState Python, which exists for windows.
@@ -74,6 +74,7 @@ __version__ = "1.0"
 #  0.41 - Fixed potential unicode problem in command line calls
 #  0.42 - Added GPL v3 licence. updated/removed some print statements
 #  1.0  - Python 3 compatibility for calibre 5.0
+#  1.1  - Speed Python PC1 implementation up a little bit
 
 import sys
 import os
@@ -94,11 +95,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data, str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 
@@ -139,7 +146,7 @@ def unicode_argv():
         return ["mobidedrm.py"]
     else:
         argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
+        return [arg if (isinstance(arg, str) or isinstance(arg,unicode)) else str(arg, argvencoding) for arg in sys.argv]
 
 
 class DrmException(Exception):
@@ -169,7 +176,7 @@ def PC1(key, src, decryption=True):
     wkey = []
     for i in range(8):
         wkey.append(key[i*2]<<8 | key[i*2+1])
-    dst = b''
+    dst = bytearray(len(src))
     for i in range(len(src)):
         temp1 = 0;
         byteXorVal = 0;
@@ -188,8 +195,8 @@ def PC1(key, src, decryption=True):
             keyXorVal = curByte * 257;
         for j in range(8):
             wkey[j] ^= keyXorVal;
-        dst+=bytes([curByte])
-    return dst
+        dst[i] = curByte
+    return bytes(dst)
 
 # accepts unicode returns unicode
 def checksumPid(s):
@@ -320,6 +327,15 @@ class MobiBook:
                     elif type == 404 and size == 9:
                         # make sure text to speech is enabled
                         self.patchSection(0, b'\0', 16 + self.mobi_length + pos + 8)
+                    elif type == 405 and size == 9:
+                        # remove rented book flag
+                        self.patchSection(0, b'\0', 16 + self.mobi_length + pos + 8)
+                    elif type == 406 and size == 16:
+                        # remove rental due date
+                        self.patchSection(0, b'\0'*8, 16 + self.mobi_length + pos + 8)
+                    elif type == 208:
+                        # remove watermark (atv:kin: stuff)
+                        self.patchSection(0, b'\0'*(size-8), 16 + self.mobi_length + pos + 8)
                     # print type, size, content, content.encode('hex')
                     pos += size
         except Exception as e:
@@ -446,7 +462,8 @@ class MobiBook:
             data406 = self.meta_array[406]
             val406, = struct.unpack('>Q',data406)
             if val406 != 0:
-                raise DrmException("Cannot decode library or rented ebooks.")
+                print("Warning: This is a library or rented ebook ({0}). Continuing ...".format(val406))
+                #raise DrmException("Cannot decode library or rented ebooks.")
 
         goodpids = []
         # print("DEBUG ==== pidlist = ", pidlist)

DeDRM_plugin/openssl_des.py

@@ -1,89 +0,0 @@
-#!/usr/bin/env python
-# vim:ts=4:sw=4:softtabstop=4:smarttab:expandtab
-
-# implement just enough of des from openssl to make erdr2pml.py happy
-
-def load_libcrypto():
-    from ctypes import CDLL, POINTER, c_void_p, c_char_p, c_char, c_int, c_long, \
-        Structure, c_ulong, create_string_buffer, cast
-    from ctypes.util import find_library
-    import sys
-
-    if sys.platform.startswith('win'):
-        libcrypto = find_library('libeay32')
-    else:
-        libcrypto = find_library('crypto')
-
-    if libcrypto is None:
-        return None
-
-    libcrypto = CDLL(libcrypto)
-
-    # typedef struct DES_ks
-    #     {
-    #     union
-    #         {
-    #         DES_cblock cblock;
-    #         /* make sure things are correct size on machines with
-    #          * 8 byte longs */
-    #         DES_LONG deslong[2];
-    #         } ks[16];
-    #     } DES_key_schedule;
-
-    # just create a big enough place to hold everything
-    # it will have alignment of structure so we should be okay (16 byte aligned?)
-    class DES_KEY_SCHEDULE(Structure):
-        _fields_ = [('DES_cblock1', c_char * 16),
-                    ('DES_cblock2', c_char * 16),
-                    ('DES_cblock3', c_char * 16),
-                    ('DES_cblock4', c_char * 16),
-                    ('DES_cblock5', c_char * 16),
-                    ('DES_cblock6', c_char * 16),
-                    ('DES_cblock7', c_char * 16),
-                    ('DES_cblock8', c_char * 16),
-                    ('DES_cblock9', c_char * 16),
-                    ('DES_cblock10', c_char * 16),
-                    ('DES_cblock11', c_char * 16),
-                    ('DES_cblock12', c_char * 16),
-                    ('DES_cblock13', c_char * 16),
-                    ('DES_cblock14', c_char * 16),
-                    ('DES_cblock15', c_char * 16),
-                    ('DES_cblock16', c_char * 16)]
-
-    DES_KEY_SCHEDULE_p = POINTER(DES_KEY_SCHEDULE)
-
-    def F(restype, name, argtypes):
-        func = getattr(libcrypto, name)
-        func.restype = restype
-        func.argtypes = argtypes
-        return func
-
-    DES_set_key = F(None, 'DES_set_key',[c_char_p, DES_KEY_SCHEDULE_p])
-    DES_ecb_encrypt = F(None, 'DES_ecb_encrypt',[c_char_p, c_char_p, DES_KEY_SCHEDULE_p, c_int])
-
-
-    class DES(object):
-        def __init__(self, key):
-            if len(key) != 8 :
-                raise Exception('DES improper key used')
-                return
-            self.key = key
-            self.keyschedule = DES_KEY_SCHEDULE()
-            DES_set_key(self.key, self.keyschedule)
-        def desdecrypt(self, data):
-            ob = create_string_buffer(len(data))
-            DES_ecb_encrypt(data, ob, self.keyschedule, 0)
-            return ob.raw
-        def decrypt(self, data):
-            if not data:
-                return b''
-            i = 0
-            result = []
-            while i < len(data):
-                block = data[i:i+8]
-                processed_block = self.desdecrypt(block)
-                result.append(processed_block)
-                i += 8
-            return b''.join(result)
-
-    return DES

DeDRM_plugin/prefs.py

@@ -5,20 +5,32 @@
 __license__ = 'GPL v3'
 
 # Standard Python modules.
-import os, sys, re, hashlib
-import codecs, json
+import os, sys
 import traceback
 
-from calibre.utils.config import dynamic, config_dir, JSONConfig
-from calibre_plugins.dedrm.__init__ import PLUGIN_NAME, PLUGIN_VERSION
-from calibre.constants import iswindows, isosx
+
+#@@CALIBRE_COMPAT_CODE@@
+
+
+try: 
+    from calibre.utils.config import JSONConfig
+except:
+    from standalone.jsonconfig import JSONConfig
+
+from __init__ import PLUGIN_NAME
 
 class DeDRM_Prefs():
-    def __init__(self):
-        JSON_PATH = os.path.join("plugins", PLUGIN_NAME.strip().lower().replace(' ', '_') + '.json')
+    def __init__(self, json_path=None):
+        if json_path is None:
+            JSON_PATH = os.path.join("plugins", PLUGIN_NAME.strip().lower().replace(' ', '_') + '.json')
+        else:
+            JSON_PATH = json_path
+
         self.dedrmprefs = JSONConfig(JSON_PATH)
 
         self.dedrmprefs.defaults['configured'] = False
+        self.dedrmprefs.defaults['deobfuscate_fonts'] = True
+        self.dedrmprefs.defaults['remove_watermarks'] = False
         self.dedrmprefs.defaults['bandnkeys'] = {}
         self.dedrmprefs.defaults['adeptkeys'] = {}
         self.dedrmprefs.defaults['ereaderkeys'] = {}
@@ -26,6 +38,8 @@ class DeDRM_Prefs():
         self.dedrmprefs.defaults['androidkeys'] = {}
         self.dedrmprefs.defaults['pids'] = []
         self.dedrmprefs.defaults['serials'] = []
+        self.dedrmprefs.defaults['lcp_passphrases'] = []
+        self.dedrmprefs.defaults['adobe_pdf_passphrases'] = []
         self.dedrmprefs.defaults['adobewineprefix'] = ""
         self.dedrmprefs.defaults['kindlewineprefix'] = ""
 
@@ -47,6 +61,10 @@ class DeDRM_Prefs():
             self.dedrmprefs['pids'] = []
         if self.dedrmprefs['serials'] == []:
             self.dedrmprefs['serials'] = []
+        if self.dedrmprefs['lcp_passphrases'] == []:
+            self.dedrmprefs['lcp_passphrases'] = []
+        if self.dedrmprefs['adobe_pdf_passphrases'] == []:
+            self.dedrmprefs['adobe_pdf_passphrases'] = []
 
     def __getitem__(self,kind = None):
         if kind is not None:
@@ -86,210 +104,3 @@ class DeDRM_Prefs():
         except:
             traceback.print_exc()
         return False
-
-
-def convertprefs(always = False):
-
-    def parseIgnobleString(keystuff):
-        from calibre_plugins.dedrm.ignoblekeygen import generate_key
-        userkeys = []
-        ar = keystuff.split(':')
-        for keystring in ar:
-            try:
-                name, ccn = keystring.split(',')
-                # Generate Barnes & Noble EPUB user key from name and credit card number.
-                keyname = "{0}_{1}".format(name.strip(),ccn.strip()[-4:])
-                keyvalue = generate_key(name, ccn)
-                userkeys.append([keyname,keyvalue])
-            except Exception as e:
-                traceback.print_exc()
-                print(e.args[0])
-                pass
-        return userkeys
-
-    def parseeReaderString(keystuff):
-        from calibre_plugins.dedrm.erdr2pml import getuser_key
-        userkeys = []
-        ar = keystuff.split(':')
-        for keystring in ar:
-            try:
-                name, cc = keystring.split(',')
-                # Generate eReader user key from name and credit card number.
-                keyname = "{0}_{1}".format(name.strip(),cc.strip()[-4:])
-                keyvalue = codecs.encode(getuser_key(name,cc),'hex')
-                userkeys.append([keyname,keyvalue])
-            except Exception as e:
-                traceback.print_exc()
-                print(e.args[0])
-                pass
-        return userkeys
-
-    def parseKindleString(keystuff):
-        pids = []
-        serials = []
-        ar = keystuff.split(',')
-        for keystring in ar:
-            keystring = str(keystring).strip().replace(" ","")
-            if len(keystring) == 10 or len(keystring) == 8 and keystring not in pids:
-                pids.append(keystring)
-            elif len(keystring) == 16 and keystring[0] == 'B' and keystring not in serials:
-                serials.append(keystring)
-        return (pids,serials)
-
-    def getConfigFiles(extension, encoding = None):
-        # get any files with extension 'extension' in the config dir
-        userkeys = []
-        files = [f for f in os.listdir(config_dir) if f.endswith(extension)]
-        for filename in files:
-            try:
-                fpath = os.path.join(config_dir, filename)
-                key = os.path.splitext(filename)[0]
-                value = open(fpath, 'rb').read()
-                if encoding is not None:
-                    value = codecs.encode(value,encoding)
-                userkeys.append([key,value])
-            except:
-                traceback.print_exc()
-                pass
-        return userkeys
-
-    dedrmprefs = DeDRM_Prefs()
-
-    if (not always) and dedrmprefs['configured']:
-        # We've already converted old preferences,
-        # and we're not being forced to do it again, so just return
-        return
-
-
-    print("{0} v{1}: Importing configuration data from old DeDRM plugins".format(PLUGIN_NAME, PLUGIN_VERSION))
-
-    IGNOBLEPLUGINNAME = "Ignoble Epub DeDRM"
-    EREADERPLUGINNAME = "eReader PDB 2 PML"
-    OLDKINDLEPLUGINNAME = "K4PC, K4Mac, Kindle Mobi and Topaz DeDRM"
-
-    # get prefs from older tools
-    kindleprefs = JSONConfig(os.path.join("plugins", "K4MobiDeDRM"))
-    ignobleprefs = JSONConfig(os.path.join("plugins", "ignoble_epub_dedrm"))
-
-    # Handle the old ignoble plugin's customization string by converting the
-    # old string to stored keys... get that personal data out of plain sight.
-    from calibre.customize.ui import config
-    sc = config['plugin_customization']
-    val = sc.pop(IGNOBLEPLUGINNAME, None)
-    if val is not None:
-        print("{0} v{1}: Converting old Ignoble plugin configuration string.".format(PLUGIN_NAME, PLUGIN_VERSION))
-        priorkeycount = len(dedrmprefs['bandnkeys'])
-        userkeys = parseIgnobleString(str(val))
-        for keypair in userkeys:
-            name = keypair[0]
-            value = keypair[1]
-            dedrmprefs.addnamedvaluetoprefs('bandnkeys', name, value)
-        addedkeycount = len(dedrmprefs['bandnkeys'])-priorkeycount
-        print("{0} v{1}: {2:d} Barnes and Noble {3} imported from old Ignoble plugin configuration string".format(PLUGIN_NAME, PLUGIN_VERSION, addedkeycount, "key" if addedkeycount==1 else "keys"))
-    # Make the json write all the prefs to disk
-    dedrmprefs.writeprefs(False)
-
-    # Handle the old eReader plugin's customization string by converting the
-    # old string to stored keys... get that personal data out of plain sight.
-    val = sc.pop(EREADERPLUGINNAME, None)
-    if val is not None:
-        print("{0} v{1}: Converting old eReader plugin configuration string.".format(PLUGIN_NAME, PLUGIN_VERSION))
-        priorkeycount = len(dedrmprefs['ereaderkeys'])
-        userkeys = parseeReaderString(str(val))
-        for keypair in userkeys:
-            name = keypair[0]
-            value = keypair[1]
-            dedrmprefs.addnamedvaluetoprefs('ereaderkeys', name, value)
-        addedkeycount = len(dedrmprefs['ereaderkeys'])-priorkeycount
-        print("{0} v{1}: {2:d} eReader {3} imported from old eReader plugin configuration string".format(PLUGIN_NAME, PLUGIN_VERSION, addedkeycount, "key" if addedkeycount==1 else "keys"))
-    # Make the json write all the prefs to disk
-    dedrmprefs.writeprefs(False)
-
-    # get old Kindle plugin configuration string
-    val = sc.pop(OLDKINDLEPLUGINNAME, None)
-    if val is not None:
-        print("{0} v{1}: Converting old Kindle plugin configuration string.".format(PLUGIN_NAME, PLUGIN_VERSION))
-        priorpidcount = len(dedrmprefs['pids'])
-        priorserialcount = len(dedrmprefs['serials'])
-        pids, serials = parseKindleString(val)
-        for pid in pids:
-            dedrmprefs.addvaluetoprefs('pids',pid)
-        for serial in serials:
-            dedrmprefs.addvaluetoprefs('serials',serial)
-        addedpidcount = len(dedrmprefs['pids']) - priorpidcount
-        addedserialcount = len(dedrmprefs['serials']) - priorserialcount
-        print("{0} v{1}: {2:d} {3} and {4:d} {5} imported from old Kindle plugin configuration string.".format(PLUGIN_NAME, PLUGIN_VERSION, addedpidcount, "PID" if addedpidcount==1 else "PIDs", addedserialcount, "serial number" if addedserialcount==1 else "serial numbers"))
-    # Make the json write all the prefs to disk
-    dedrmprefs.writeprefs(False)
-
-    # copy the customisations back into calibre preferences, as we've now removed the nasty plaintext
-    config['plugin_customization'] = sc
-
-    # get any .b64 files in the config dir
-    priorkeycount = len(dedrmprefs['bandnkeys'])
-    bandnfilekeys = getConfigFiles('.b64')
-    for keypair in bandnfilekeys:
-        name = keypair[0]
-        value = keypair[1]
-        dedrmprefs.addnamedvaluetoprefs('bandnkeys', name, value)
-    addedkeycount = len(dedrmprefs['bandnkeys'])-priorkeycount
-    if addedkeycount > 0:
-        print("{0} v{1}: {2:d} Barnes and Noble {3} imported from config folder.".format(PLUGIN_NAME, PLUGIN_VERSION, addedkeycount, "key file" if addedkeycount==1 else "key files"))
-    # Make the json write all the prefs to disk
-    dedrmprefs.writeprefs(False)
-
-    # get any .der files in the config dir
-    priorkeycount = len(dedrmprefs['adeptkeys'])
-    adeptfilekeys = getConfigFiles('.der','hex')
-    for keypair in adeptfilekeys:
-        name = keypair[0]
-        value = keypair[1]
-        dedrmprefs.addnamedvaluetoprefs('adeptkeys', name, value)
-    addedkeycount = len(dedrmprefs['adeptkeys'])-priorkeycount
-    if addedkeycount > 0:
-        print("{0} v{1}: {2:d} Adobe Adept {3} imported from config folder.".format(PLUGIN_NAME, PLUGIN_VERSION, addedkeycount, "keyfile" if addedkeycount==1 else "keyfiles"))
-    # Make the json write all the prefs to disk
-    dedrmprefs.writeprefs(False)
-
-    # get ignoble json prefs
-    if 'keys' in ignobleprefs:
-        priorkeycount = len(dedrmprefs['bandnkeys'])
-        for name in ignobleprefs['keys']:
-            value = ignobleprefs['keys'][name]
-            dedrmprefs.addnamedvaluetoprefs('bandnkeys', name, value)
-        addedkeycount = len(dedrmprefs['bandnkeys']) - priorkeycount
-        # no need to delete old prefs, since they contain no recoverable private data
-        if addedkeycount > 0:
-            print("{0} v{1}: {2:d} Barnes and Noble {3} imported from Ignoble plugin preferences.".format(PLUGIN_NAME, PLUGIN_VERSION, addedkeycount, "key" if addedkeycount==1 else "keys"))
-    # Make the json write all the prefs to disk
-    dedrmprefs.writeprefs(False)
-
-    # get kindle json prefs
-    priorpidcount = len(dedrmprefs['pids'])
-    priorserialcount = len(dedrmprefs['serials'])
-    if 'pids' in kindleprefs:
-        pids, serials = parseKindleString(kindleprefs['pids'])
-        for pid in pids:
-            dedrmprefs.addvaluetoprefs('pids',pid)
-    if 'serials' in kindleprefs:
-        pids, serials = parseKindleString(kindleprefs['serials'])
-        for serial in serials:
-            dedrmprefs.addvaluetoprefs('serials',serial)
-    addedpidcount = len(dedrmprefs['pids']) - priorpidcount
-    if addedpidcount > 0:
-        print("{0} v{1}: {2:d} {3} imported from Kindle plugin preferences".format(PLUGIN_NAME, PLUGIN_VERSION, addedpidcount, "PID" if addedpidcount==1 else "PIDs"))
-    addedserialcount = len(dedrmprefs['serials']) - priorserialcount
-    if addedserialcount > 0:
-        print("{0} v{1}: {2:d} {3} imported from Kindle plugin preferences".format(PLUGIN_NAME, PLUGIN_VERSION, addedserialcount, "serial number" if addedserialcount==1 else "serial numbers"))
-    try:
-        if 'wineprefix' in kindleprefs and kindleprefs['wineprefix'] != "":
-            dedrmprefs.set('adobewineprefix',kindleprefs['wineprefix'])
-            dedrmprefs.set('kindlewineprefix',kindleprefs['wineprefix'])
-            print("{0} v{1}: WINEPREFIX ‘(2)’ imported from Kindle plugin preferences".format(PLUGIN_NAME, PLUGIN_VERSION, kindleprefs['wineprefix']))
-    except:
-        traceback.print_exc()
-
-
-    # Make the json write all the prefs to disk
-    dedrmprefs.writeprefs()
-    print("{0} v{1}: Finished setting up configuration data.".format(PLUGIN_NAME, PLUGIN_VERSION))

DeDRM_plugin/pycrypto_des.py

@@ -1,30 +0,0 @@
-#!/usr/bin/env python
-# vim:ts=4:sw=4:softtabstop=4:smarttab:expandtab
-
-
-def load_pycrypto():
-    try :
-        from Crypto.Cipher import DES as _DES
-    except:
-        return None
-
-    class DES(object):
-        def __init__(self, key):
-            if len(key) != 8 :
-                raise ValueError('DES improper key used')
-            self.key = key
-            self._des = _DES.new(key,_DES.MODE_ECB)
-        def desdecrypt(self, data):
-            return self._des.decrypt(data)
-        def decrypt(self, data):
-            if not data:
-                return ''
-            i = 0
-            result = []
-            while i < len(data):
-                block = data[i:i+8]
-                processed_block = self.desdecrypt(block)
-                result.append(processed_block)
-                i += 8
-            return ''.join(result)
-    return DES

DeDRM_plugin/python_des.py

@@ -1,220 +0,0 @@
-#!/usr/bin/env python
-# vim:ts=4:sw=4:softtabstop=4:smarttab:expandtab
-import sys
-
-ECB =   0
-CBC =   1
-class Des(object):
-    __pc1 = [56, 48, 40, 32, 24, 16,  8,  0, 57, 49, 41, 33, 25, 17,
-          9,  1, 58, 50, 42, 34, 26, 18, 10,  2, 59, 51, 43, 35,
-         62, 54, 46, 38, 30, 22, 14,  6, 61, 53, 45, 37, 29, 21,
-         13,  5, 60, 52, 44, 36, 28, 20, 12,  4, 27, 19, 11,  3]
-    __left_rotations = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]
-    __pc2 = [13, 16, 10, 23,  0,  4,2, 27, 14,  5, 20,  9,
-        22, 18, 11,  3, 25,  7, 15,  6, 26, 19, 12,  1,
-        40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47,
-        43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31]
-    __ip = [57, 49, 41, 33, 25, 17, 9,  1,      59, 51, 43, 35, 27, 19, 11, 3,
-        61, 53, 45, 37, 29, 21, 13, 5,  63, 55, 47, 39, 31, 23, 15, 7,
-        56, 48, 40, 32, 24, 16, 8,  0,  58, 50, 42, 34, 26, 18, 10, 2,
-        60, 52, 44, 36, 28, 20, 12, 4,  62, 54, 46, 38, 30, 22, 14, 6]
-    __expansion_table = [31,  0,  1,  2,  3,  4, 3,  4,  5,  6,  7,  8,
-         7,  8,  9, 10, 11, 12,11, 12, 13, 14, 15, 16,
-        15, 16, 17, 18, 19, 20,19, 20, 21, 22, 23, 24,
-        23, 24, 25, 26, 27, 28,27, 28, 29, 30, 31,  0]
-    __sbox = [[14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
-         0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
-         4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
-         15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13],
-        [15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
-         3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
-         0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
-         13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9],
-        [10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
-         13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
-         13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
-         1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12],
-        [7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
-         13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
-         10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
-         3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14],
-        [2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
-         14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
-         4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
-         11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3],
-        [12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
-         10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
-         9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
-         4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13],
-        [4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
-         13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
-         1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
-         6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12],
-        [13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
-         1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
-         7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
-         2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11],]
-    __p = [15, 6, 19, 20, 28, 11,27, 16, 0, 14, 22, 25,
-        4, 17, 30, 9, 1, 7,23,13, 31, 26, 2, 8,18, 12, 29, 5, 21, 10,3, 24]
-    __fp = [39,  7, 47, 15, 55, 23, 63, 31,38,  6, 46, 14, 54, 22, 62, 30,
-        37,  5, 45, 13, 53, 21, 61, 29,36,  4, 44, 12, 52, 20, 60, 28,
-        35,  3, 43, 11, 51, 19, 59, 27,34,  2, 42, 10, 50, 18, 58, 26,
-        33,  1, 41,  9, 49, 17, 57, 25,32,  0, 40,  8, 48, 16, 56, 24]
-    # Type of crypting being done
-    ENCRYPT =   0x00
-    DECRYPT =   0x01
-    def __init__(self, key, mode=ECB, IV=None):
-        if len(key) != 8:
-            raise ValueError("Invalid DES key size. Key must be exactly 8 bytes long.")
-        self.block_size = 8
-        self.key_size = 8
-        self.__padding = ''
-        self.setMode(mode)
-        if IV:
-            self.setIV(IV)
-        self.L = []
-        self.R = []
-        self.Kn = [ [0] * 48 ] * 16     # 16 48-bit keys (K1 - K16)
-        self.final = []
-        self.setKey(key)
-    def getKey(self):
-        return self.__key
-    def setKey(self, key):
-        self.__key = key
-        self.__create_sub_keys()
-    def getMode(self):
-        return self.__mode
-    def setMode(self, mode):
-        self.__mode = mode
-    def getIV(self):
-        return self.__iv
-    def setIV(self, IV):
-        if not IV or len(IV) != self.block_size:
-            raise ValueError("Invalid Initial Value (IV), must be a multiple of " + str(self.block_size) + " bytes")
-        self.__iv = IV
-    def getPadding(self):
-        return self.__padding
-    def __String_to_BitList(self, data):
-        l = len(data) * 8
-        result = [0] * l
-        pos = 0
-        for c in data:
-            i = 7
-            ch = ord(c)
-            while i >= 0:
-                if ch & (1 << i) != 0:
-                    result[pos] = 1
-                else:
-                    result[pos] = 0
-                pos += 1
-                i -= 1
-        return result
-    def __BitList_to_String(self, data):
-        result = ''
-        pos = 0
-        c = 0
-        while pos < len(data):
-            c += data[pos] << (7 - (pos % 8))
-            if (pos % 8) == 7:
-                result += chr(c)
-                c = 0
-            pos += 1
-        return result
-    def __permutate(self, table, block):
-        return [block[x] for x in table]
-    def __create_sub_keys(self):
-        key = self.__permutate(Des.__pc1, self.__String_to_BitList(self.getKey()))
-        i = 0
-        self.L = key[:28]
-        self.R = key[28:]
-        while i < 16:
-            j = 0
-            while j < Des.__left_rotations[i]:
-                self.L.append(self.L[0])
-                del self.L[0]
-                self.R.append(self.R[0])
-                del self.R[0]
-                j += 1
-            self.Kn[i] = self.__permutate(Des.__pc2, self.L + self.R)
-            i += 1
-    def __des_crypt(self, block, crypt_type):
-        block = self.__permutate(Des.__ip, block)
-        self.L = block[:32]
-        self.R = block[32:]
-        if crypt_type == Des.ENCRYPT:
-            iteration = 0
-            iteration_adjustment = 1
-        else:
-            iteration = 15
-            iteration_adjustment = -1
-        i = 0
-        while i < 16:
-            tempR = self.R[:]
-            self.R = self.__permutate(Des.__expansion_table, self.R)
-            self.R = [x ^ y for x,y in zip(self.R, self.Kn[iteration])]
-            B = [self.R[:6], self.R[6:12], self.R[12:18], self.R[18:24], self.R[24:30], self.R[30:36], self.R[36:42], self.R[42:]]
-            j = 0
-            Bn = [0] * 32
-            pos = 0
-            while j < 8:
-                m = (B[j][0] << 1) + B[j][5]
-                n = (B[j][1] << 3) + (B[j][2] << 2) + (B[j][3] << 1) + B[j][4]
-                v = Des.__sbox[j][(m << 4) + n]
-                Bn[pos] = (v & 8) >> 3
-                Bn[pos + 1] = (v & 4) >> 2
-                Bn[pos + 2] = (v & 2) >> 1
-                Bn[pos + 3] = v & 1
-                pos += 4
-                j += 1
-            self.R = self.__permutate(Des.__p, Bn)
-            self.R = [x ^ y for x, y in zip(self.R, self.L)]
-            self.L = tempR
-            i += 1
-            iteration += iteration_adjustment
-        self.final = self.__permutate(Des.__fp, self.R + self.L)
-        return self.final
-    def crypt(self, data, crypt_type):
-        if not data:
-            return ''
-        if len(data) % self.block_size != 0:
-            if crypt_type == Des.DECRYPT: # Decryption must work on 8 byte blocks
-                raise ValueError("Invalid data length, data must be a multiple of " + str(self.block_size) + " bytes\n.")
-            if not self.getPadding():
-                raise ValueError("Invalid data length, data must be a multiple of " + str(self.block_size) + " bytes\n. Try setting the optional padding character")
-            else:
-                data += (self.block_size - (len(data) % self.block_size)) * self.getPadding()
-        if self.getMode() == CBC:
-            if self.getIV():
-                iv = self.__String_to_BitList(self.getIV())
-            else:
-                raise ValueError("For CBC mode, you must supply the Initial Value (IV) for ciphering")
-        i = 0
-        dict = {}
-        result = []
-        while i < len(data):
-            block = self.__String_to_BitList(data[i:i+8])
-            if self.getMode() == CBC:
-                if crypt_type == Des.ENCRYPT:
-                    block = [x ^ y for x, y in zip(block, iv)]
-                processed_block = self.__des_crypt(block, crypt_type)
-                if crypt_type == Des.DECRYPT:
-                    processed_block = [x ^ y for x, y in zip(processed_block, iv)]
-                    iv = block
-                else:
-                    iv = processed_block
-            else:
-                processed_block = self.__des_crypt(block, crypt_type)
-            result.append(self.__BitList_to_String(processed_block))
-            i += 8
-        if crypt_type == Des.DECRYPT and self.getPadding():
-            s = result[-1]
-            while s[-1] == self.getPadding():
-                s = s[:-1]
-            result[-1] = s
-        return ''.join(result)
-    def encrypt(self, data, pad=''):
-        self.__padding = pad
-        return self.crypt(data, Des.ENCRYPT)
-    def decrypt(self, data, pad=''):
-        self.__padding = pad
-        return self.crypt(data, Des.DECRYPT)

DeDRM_plugin/scriptinterface.py

@@ -5,15 +5,19 @@
 
 import sys
 import os
+
+
+#@@CALIBRE_COMPAT_CODE@@
+
+
 import re
 import traceback
-import calibre_plugins.dedrm.ineptepub
-import calibre_plugins.dedrm.ignobleepub
-import calibre_plugins.dedrm.epubtest
-import calibre_plugins.dedrm.zipfix
-import calibre_plugins.dedrm.ineptpdf
-import calibre_plugins.dedrm.erdr2pml
-import calibre_plugins.dedrm.k4mobidedrm
+import ineptepub
+import epubtest
+import zipfix
+import ineptpdf
+import erdr2pml
+import k4mobidedrm
 
 def decryptepub(infile, outdir, rscpath):
     errlog = ''
@@ -50,8 +54,8 @@ def decryptepub(infile, outdir, rscpath):
                     errlog += traceback.format_exc()
                     errlog += str(e)
                     rv = 1
-    # now try with ignoble epub
-    elif  ignobleepub.ignobleBook(zippath):
+        
+        # now try with ignoble epub
         # try with any keyfiles (*.b64) in the rscpath
         files = os.listdir(rscpath)
         filefilter = re.compile("\.b64$", re.IGNORECASE)
@@ -62,7 +66,7 @@ def decryptepub(infile, outdir, rscpath):
                 userkey = open(keypath,'r').read()
                 #print userkey
                 try:
-                    rv = ignobleepub.decryptBook(userkey, zippath, outfile)
+                    rv = ineptepub.decryptBook(userkey, zippath, outfile)
                     if rv == 0:
                         print("Decrypted B&N ePub with key file {0}".format(filename))
                         break
@@ -121,7 +125,7 @@ def decryptpdb(infile, outdir, rscpath):
     rv = 1
     socialpath = os.path.join(rscpath,'sdrmlist.txt')
     if os.path.exists(socialpath):
-        keydata = file(socialpath,'r').read()
+        keydata = open(socialpath,'r').read()
         keydata = keydata.rstrip(os.linesep)
         ar = keydata.split(',')
         for i in ar:
@@ -148,7 +152,7 @@ def decryptk4mobi(infile, outdir, rscpath):
     pidnums = []
     pidspath = os.path.join(rscpath,'pidlist.txt')
     if os.path.exists(pidspath):
-        pidstr = file(pidspath,'r').read()
+        pidstr = open(pidspath,'r').read()
         pidstr = pidstr.rstrip(os.linesep)
         pidstr = pidstr.strip()
         if pidstr != '':
@@ -156,7 +160,7 @@ def decryptk4mobi(infile, outdir, rscpath):
     serialnums = []
     serialnumspath = os.path.join(rscpath,'seriallist.txt')
     if os.path.exists(serialnumspath):
-        serialstr = file(serialnumspath,'r').read()
+        serialstr = open(serialnumspath,'r').read()
         serialstr = serialstr.rstrip(os.linesep)
         serialstr = serialstr.strip()
         if serialstr != '':

DeDRM_plugin/simpleprefs.py

@@ -20,7 +20,10 @@ class SimplePrefs(object):
             self.file2key[filename] = key
         self.target = target + 'Prefs'
         if sys.platform.startswith('win'):
-            import winreg
+            try:
+                import winreg
+            except ImportError:
+                import _winreg as winreg
             regkey = winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders\\")
             path = winreg.QueryValueEx(regkey, 'Local AppData')[0]
             prefdir = path + os.sep + self.target

DeDRM_plugin/standalone/__init__.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# CLI interface for the DeDRM plugin (useable without Calibre, too)
+
+from __future__ import absolute_import, print_function
+
+# Copyright © 2021 NoDRM
+
+OPT_SHORT_TO_LONG = [
+    ["c", "config"],
+    ["e", "extract"],
+    ["f", "force"], 
+    ["h", "help"], 
+    ["i", "import"],
+    ["o", "output"],
+    ["p", "password"],
+    ["q", "quiet"],
+    ["t", "test"], 
+    ["u", "username"],
+    ["v", "verbose"],
+]
+
+#@@CALIBRE_COMPAT_CODE@@
+
+import os, sys
+
+
+global _additional_data
+global _additional_params
+global _function
+_additional_data = []
+_additional_params = []
+_function = None
+
+global config_file_path
+config_file_path = "dedrm.json"
+
+def print_fname(f, info):
+    print("  " + f.ljust(15) + " " + info)
+
+def print_opt(short, long, info):
+    if short is None:
+        short = "    "
+    else: 
+        short = "  -" + short
+    
+    if long is None: 
+        long = "            "
+    else:
+        long = "--" + long.ljust(16)
+
+    print(short + "  " + long + "  " + info, file=sys.stderr)
+
+def print_std_usage(name, param_string):
+    print("Usage: ", file=sys.stderr)
+    if "calibre" in sys.modules:
+        print("  calibre-debug -r \"DeDRM\" -- "+name+" " + param_string, file=sys.stderr)
+    else:
+        print("  python3 DeDRM_plugin.zip "+name+" "+param_string, file=sys.stderr)
+
+def print_err_header():
+    from __init__ import PLUGIN_NAME, PLUGIN_VERSION # type: ignore
+
+    print(PLUGIN_NAME + " v" + PLUGIN_VERSION + " - DRM removal plugin by noDRM")
+    print()
+
+def print_help():
+    from __version import PLUGIN_NAME, PLUGIN_VERSION
+    print(PLUGIN_NAME + " v" + PLUGIN_VERSION + " - DRM removal plugin by noDRM")
+    print("Based on DeDRM Calibre plugin by Apprentice Harper, Apprentice Alf and others.")
+    print("See https://github.com/noDRM/DeDRM_tools for more information.")
+    print()
+    if "calibre" in sys.modules:
+        print("This plugin can be run through Calibre - like you are doing right now - ")
+        print("but it can also be executed with a standalone Python interpreter.")
+    else:
+        print("This plugin can either be imported into Calibre, or be executed directly")
+        print("through Python like you are doing right now.")
+    print()
+    print("Available functions:")
+    print_fname("passhash", "Manage Adobe PassHashes")
+    print_fname("remove_drm", "Remove DRM from one or multiple books")
+    print()
+    
+    # TODO: All parameters that are global should be listed here.
+
+def print_credits():
+    from __version import PLUGIN_NAME, PLUGIN_VERSION
+    print(PLUGIN_NAME + " v" + PLUGIN_VERSION + " - Calibre DRM removal plugin by noDRM")
+    print("Based on DeDRM Calibre plugin by Apprentice Harper, Apprentice Alf and others.")
+    print("See https://github.com/noDRM/DeDRM_tools for more information.")
+    print()
+    print("Credits:")
+    print(" - noDRM for the current release of the DeDRM plugin")
+    print(" - Apprentice Alf and Apprentice Harper for the previous versions of the DeDRM plugin")
+    print(" - The Dark Reverser for the Mobipocket and eReader script")
+    print(" - i ♥ cabbages for the Adobe Digital Editions scripts")
+    print(" - Skindle aka Bart Simpson for the Amazon Kindle for PC script")
+    print(" - CMBDTC for Amazon Topaz DRM removal script")
+    print(" - some_updates, clarknova and Bart Simpson for Amazon Topaz conversion scripts")
+    print(" - DiapDealer for the first calibre plugin versions of the tools")
+    print(" - some_updates, DiapDealer, Apprentice Alf and mdlnx for Amazon Kindle/Mobipocket tools")
+    print(" - some_updates for the DeDRM all-in-one Python tool")
+    print(" - Apprentice Alf for the DeDRM all-in-one AppleScript tool")
+
+
+def handle_single_argument(arg, next):
+    used_up = 0
+    global _additional_params
+    global config_file_path
+    
+    if arg in ["--username", "--password", "--output", "--outputdir"]: 
+        used_up = 1
+        _additional_params.append(arg)
+        if next is None or len(next) == 0: 
+            print_err_header()
+            print("Missing parameter for argument " + arg, file=sys.stderr)
+            sys.exit(1)
+        else:
+            _additional_params.append(next[0])
+    
+    elif arg == "--config":
+        if next is None or len(next) == 0: 
+            print_err_header()
+            print("Missing parameter for argument " + arg, file=sys.stderr)
+            sys.exit(1)
+
+        config_file_path = next[0]
+        used_up = 1
+
+    elif arg in ["--help", "--credits", "--verbose", "--quiet", "--extract", "--import", "--overwrite", "--force"]:
+        _additional_params.append(arg)
+
+        
+    else:
+        print_err_header()
+        print("Unknown argument: " + arg, file=sys.stderr)
+        sys.exit(1)
+    
+    
+    # Used up 0 additional arguments
+    return used_up
+
+
+
+def handle_data(data):
+    global _function
+    global _additional_data
+
+    if _function is None: 
+        _function = str(data)
+    else:
+        _additional_data.append(str(data))
+
+def execute_action(action, filenames, params):
+    print("Executing '{0}' on file(s) {1} with parameters {2}".format(action, str(filenames), str(params)), file=sys.stderr)
+
+    if action == "help":
+        print_help()
+        sys.exit(0)
+    
+    elif action == "passhash": 
+        from standalone.passhash import perform_action
+        perform_action(params, filenames)
+
+    elif action == "remove_drm":
+        if not os.path.isfile(os.path.abspath(config_file_path)):
+            print("Config file missing ...")
+        
+        from standalone.remove_drm import perform_action
+        perform_action(params, filenames)
+        
+    elif action == "config":
+        import prefs
+        config = prefs.DeDRM_Prefs(os.path.abspath(config_file_path))
+        print(config["adeptkeys"])
+    
+    else:
+        print("Command '"+action+"' is unknown.", file=sys.stderr)
+
+
+def main(argv):
+    arguments = argv
+    skip_opts = False
+
+    # First element is always the ZIP name, remove that. 
+    if not arguments[0].lower().endswith(".zip") and not "calibre" in sys.modules:
+        print("Warning: File name does not end in .zip ...")
+        print(arguments)
+    arguments.pop(0)
+
+    while len(arguments) > 0:
+        arg = arguments.pop(0)
+
+        if arg == "--":
+            skip_opts = True
+            continue
+
+        if not skip_opts:
+            if arg.startswith("--"):
+                # Give the current arg, plus all remaining ones. 
+                # Return the number of additional args we used.
+                used = handle_single_argument(arg, arguments)
+                for _ in range(used):
+                    # Function returns number of additional arguments that were
+                    # "used up" by that argument. 
+                    # Remove that amount of arguments from the list.
+                    try: 
+                        arguments.pop(0)
+                    except:
+                        pass
+                continue
+            elif arg.startswith("-"):
+                single_args = list(arg[1:])
+                # single_args is now a list of single chars, for when you call the program like "ls -alR"
+                # with multiple single-letter options combined.
+                while len(single_args) > 0:
+                    c = single_args.pop(0)
+                
+                    # See if we have a long name for that option.
+                    for wrapper in OPT_SHORT_TO_LONG:
+                        if wrapper[0] == c:
+                            c = "--" + wrapper[1]
+                            break
+                    else: 
+                        c = "-" + c
+                    # c is now the long term (unless there is no long version, then it's the short version).
+
+                    if len(single_args) > 0:
+                        # If we have more short arguments, the argument for this one must be None.
+                        handle_single_argument(c, None)
+                        used = 0
+                    else: 
+                        # If not, then there might be parameters for this short argument.
+                        used = handle_single_argument(c, arguments)
+
+                    for _ in range(used):
+                        # Function returns number of additional arguments that were
+                        # "used up" by that argument. 
+                        # Remove that amount of arguments from the list.
+                        try: 
+                            arguments.pop(0)
+                        except: 
+                            pass
+                
+                continue
+        
+        handle_data(arg)
+        
+
+    if _function is None and "--credits" in _additional_params:
+        print_credits()
+        sys.exit(0)
+
+    if _function is None and "--help" in _additional_params:
+        print_help()
+        sys.exit(0)
+    
+    if _function is None:
+        print_help()
+        sys.exit(1)
+    
+    # Okay, now actually begin doing stuff.
+    # This function gets told what to do and gets additional data (filenames).
+    # It also receives additional parameters.
+    # The rest of the code will be in different Python files.
+    execute_action(_function.lower(), _additional_data, _additional_params)
+        
+
+    
+
+
+if __name__ == "__main__":
+    # NOTE: This MUST not do anything else other than calling main()
+    # All the code must be in main(), not in here.
+    import sys
+    main(sys.argv)

DeDRM_plugin/standalone/jsonconfig.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# CLI interface for the DeDRM plugin (useable without Calibre, too)
+# Config implementation
+
+from __future__ import absolute_import, print_function
+
+# Taken from Calibre code - Copyright © 2008, Kovid Goyal kovid@kovidgoyal.net, GPLv3
+
+#@@CALIBRE_COMPAT_CODE@@
+
+import sys, os, codecs, json
+
+config_dir = "/"
+CONFIG_DIR_MODE = 0o700
+iswindows = sys.platform.startswith('win')
+
+
+filesystem_encoding = sys.getfilesystemencoding()
+if filesystem_encoding is None:
+    filesystem_encoding = 'utf-8'
+else:
+    try:
+        if codecs.lookup(filesystem_encoding).name == 'ascii':
+            filesystem_encoding = 'utf-8'
+            # On linux, unicode arguments to os file functions are coerced to an ascii
+            # bytestring if sys.getfilesystemencoding() == 'ascii', which is
+            # just plain dumb. This is fixed by the icu.py module which, when
+            # imported changes ascii to utf-8
+    except Exception:
+        filesystem_encoding = 'utf-8'
+
+
+class JSONConfig(dict):
+
+    EXTENSION = '.json'
+
+
+    def __init__(self, rel_path_to_cf_file, base_path=config_dir):
+        dict.__init__(self)
+        self.no_commit = False
+        self.defaults = {}
+        self.file_path = os.path.join(base_path,
+                *(rel_path_to_cf_file.split('/')))
+        self.file_path = os.path.abspath(self.file_path)
+        if not self.file_path.endswith(self.EXTENSION):
+            self.file_path += self.EXTENSION
+
+        self.refresh()
+
+    def mtime(self):
+        try:
+            return os.path.getmtime(self.file_path)
+        except OSError:
+            return 0
+
+    def touch(self):
+        try:
+            os.utime(self.file_path, None)
+        except OSError:
+            pass
+
+
+    def decouple(self, prefix):
+        self.file_path = os.path.join(os.path.dirname(self.file_path), prefix + os.path.basename(self.file_path))
+        self.refresh()
+
+    def refresh(self, clear_current=True):
+        d = {}
+        if os.path.exists(self.file_path):
+            with open(self.file_path, "rb") as f:
+                raw = f.read()
+                try:
+                    d = self.raw_to_object(raw) if raw.strip() else {}
+                except SystemError:
+                    pass
+                except:
+                    import traceback
+                    traceback.print_exc()
+                    d = {}
+        if clear_current:
+            self.clear()
+        self.update(d)
+
+    def has_key(self, key):
+        return dict.__contains__(self, key)
+
+    def set(self, key, val):
+        self.__setitem__(key, val)
+
+    def __delitem__(self, key):
+        try:
+            dict.__delitem__(self, key)
+        except KeyError:
+            pass  # ignore missing keys
+        else:
+            self.commit()
+
+    def commit(self):
+        if self.no_commit:
+            return
+        if hasattr(self, 'file_path') and self.file_path:
+            dpath = os.path.dirname(self.file_path)
+            if not os.path.exists(dpath):
+                os.makedirs(dpath, mode=CONFIG_DIR_MODE)
+            with open(self.file_path, "w") as f:
+                raw = self.to_raw()
+                f.seek(0)
+                f.truncate()
+                f.write(raw)
+
+    def __enter__(self):
+        self.no_commit = True
+
+    def __exit__(self, *args):
+        self.no_commit = False
+        self.commit()
+
+    def raw_to_object(self, raw):
+        return json.loads(raw)
+
+    def to_raw(self):
+        return json.dumps(self, ensure_ascii=False)
+
+    def __getitem__(self, key):
+        try:
+            return dict.__getitem__(self, key)
+        except KeyError:
+            return self.defaults[key]
+
+    def get(self, key, default=None):
+        try:
+            return dict.__getitem__(self, key)
+        except KeyError:
+            return self.defaults.get(key, default)
+
+    def __setitem__(self, key, val):
+        dict.__setitem__(self, key, val)
+        self.commit()

DeDRM_plugin/standalone/passhash.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# CLI interface for the DeDRM plugin (useable without Calibre, too)
+# Adobe PassHash implementation
+
+from __future__ import absolute_import, print_function
+
+# Copyright © 2021 NoDRM
+
+#@@CALIBRE_COMPAT_CODE@@
+
+import os, sys
+
+from standalone.__init__ import print_opt, print_std_usage
+
+iswindows = sys.platform.startswith('win')
+isosx = sys.platform.startswith('darwin')
+
+def print_passhash_help():
+    from __version import PLUGIN_NAME, PLUGIN_VERSION
+    print(PLUGIN_NAME + " v" + PLUGIN_VERSION + " - Calibre DRM removal plugin by noDRM")
+    print()
+    print("passhash: Manage Adobe PassHashes")
+    print()
+    print_std_usage("passhash", "[ -u username -p password | -b base64str ] [ -i ] ")
+    
+    print()
+    print("Options: ")
+    print_opt("u", "username", "Generate a PassHash with the given username")
+    print_opt("p", "password", "Generate a PassHash with the given password")
+    print_opt("e", "extract", "Display PassHashes found on this machine")
+    print_opt("i", "import", "Import hashes into the JSON config file")
+
+def perform_action(params, files):
+    user = None
+    pwd = None
+
+    if len(params) == 0:
+        print_passhash_help()
+        return 0
+
+    extract = False
+    import_to_json = True
+
+    while len(params) > 0:
+        p = params.pop(0)
+        if p == "--username":
+            user = params.pop(0)
+        elif p == "--password":
+            pwd = params.pop(0)
+        elif p == "--extract":
+            extract = True
+        elif p == "--help":
+            print_passhash_help()
+            return 0
+        elif p == "--import":
+            import_to_json = True
+
+    if not extract and not import_to_json:
+        if user is None: 
+            print("Missing parameter: --username", file=sys.stderr)
+        if pwd is None: 
+            print("Missing parameter: --password", file=sys.stderr)
+        if user is None or pwd is None: 
+            return 1
+        
+    if user is None and pwd is not None: 
+        print("Parameter --password also requires --username", file=sys.stderr)
+        return 1
+    if user is not None and pwd is None: 
+        print("Parameter --username also requires --password", file=sys.stderr)
+        return 1
+
+    if user is not None and pwd is not None:
+        from ignoblekeyGenPassHash import generate_key
+        key = generate_key(user, pwd)
+        if import_to_json:
+            # TODO: Import the key to the JSON
+            pass
+
+        print(key.decode("utf-8"))
+    
+    if extract or import_to_json:
+        if not iswindows and not isosx:
+            print("Extracting PassHash keys not supported on Linux.", file=sys.stderr)
+            return 1
+        
+        keys = []
+
+        from ignoblekeyNookStudy import nookkeys
+        keys.extend(nookkeys())
+        
+        if iswindows:
+            from ignoblekeyWindowsStore import dump_keys
+            keys.extend(dump_keys())
+
+            from adobekey_get_passhash import passhash_keys
+            ade_keys, ade_names = passhash_keys()
+            keys.extend(ade_keys)
+
+        # Trim duplicates
+        newkeys = []
+        for k in keys:
+            if not k in newkeys:
+                newkeys.append(k)
+
+        # Print all found keys
+        for k in newkeys:
+            if import_to_json:
+                # TODO: Add keys to json
+                pass
+
+            if extract:
+                print(k)
+
+
+    return 0
+    
+
+if __name__ == "__main__":
+    print("This code is not intended to be executed directly!", file=sys.stderr)

DeDRM_plugin/standalone/remove_drm.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# CLI interface for the DeDRM plugin (useable without Calibre, too)
+# DRM removal
+
+from __future__ import absolute_import, print_function
+
+# Copyright © 2021 NoDRM
+
+#@@CALIBRE_COMPAT_CODE@@
+
+import os, sys
+
+from zipfile import ZipInfo, ZipFile, ZIP_STORED, ZIP_DEFLATED
+from contextlib import closing
+
+from standalone.__init__ import print_opt, print_std_usage
+
+iswindows = sys.platform.startswith('win')
+isosx = sys.platform.startswith('darwin')
+
+def print_removedrm_help():
+    from __init__ import PLUGIN_NAME, PLUGIN_VERSION
+    print(PLUGIN_NAME + " v" + PLUGIN_VERSION + " - Calibre DRM removal plugin by noDRM")
+    print()
+    print("remove_drm: Remove DRM from one or multiple files")
+    print()
+    print_std_usage("remove_drm", "<filename> ... [ -o <filename> ] [ -f ]")
+    
+    print()
+    print("Options: ")
+    print_opt(None, "outputdir", "Folder to export the file(s) to")
+    print_opt("o", "output", "File name to export the file to")
+    print_opt("f", "force", "Overwrite output file if it already exists")
+    print_opt(None, "overwrite", "Replace DRMed file with DRM-free file (implies --force)")
+
+
+def determine_file_type(file):
+    # Returns a file type:
+    # "PDF", "PDB", "MOBI", "TPZ", "LCP", "ADEPT", "ADEPT-PassHash", "KFX-ZIP", "ZIP" or None
+
+    f = open(file, "rb")
+    fdata = f.read(100)
+    f.close()
+
+    if fdata.startswith(b"PK\x03\x04"):
+        pass
+        # Either LCP, Adobe, or Amazon
+    elif fdata.startswith(b"%PDF"):
+        return "PDF"
+    elif fdata[0x3c:0x3c+8] == b"PNRdPPrs" or fdata[0x3c:0x3c+8] == b"PDctPPrs":
+        return "PDB"
+    elif fdata[0x3c:0x3c+8] == b"BOOKMOBI" or fdata[0x3c:0x3c+8] == b"TEXtREAd":
+        return "MOBI"
+    elif fdata.startswith(b"TPZ"):
+        return "TPZ"
+    else: 
+        return None
+        # Unknown file type
+
+    
+    # If it's a ZIP, determine the type. 
+
+    from lcpdedrm import isLCPbook
+    if isLCPbook(file):
+        return "LCP"
+
+    from ineptepub import adeptBook, isPassHashBook
+    if adeptBook(file):
+        if isPassHashBook(file):
+            return "ADEPT-PassHash"
+        else:
+            return "ADEPT"
+
+    try: 
+        # Amazon / KFX-ZIP has a file that starts with b'\xeaDRMION\xee' in the ZIP.
+        with closing(ZipFile(open(file, "rb"))) as book:
+            for subfilename in book.namelist():
+                with book.open(subfilename) as subfile:
+                    data = subfile.read(8)
+                    if data == b'\xeaDRMION\xee':
+                        return "KFX-ZIP"
+    except:
+        pass
+
+    return "ZIP"
+
+     
+
+
+def dedrm_single_file(input_file, output_file):
+    # When this runs, all the stupid file handling is done. 
+    # Just take the file at the absolute path "input_file"
+    # and export it, DRM-free, to "output_file". 
+
+    # Use a temp file as input_file and output_file
+    # might be identical.
+
+    # The output directory might not exist yet.
+
+    print("File " + input_file + " to " + output_file)
+
+    # Okay, first check the file type and don't rely on the extension. 
+    try: 
+        ftype = determine_file_type(input_file)
+    except: 
+        print("Can't determine file type for this file.")
+        ftype = None
+    
+    if ftype is None: 
+        return
+
+    
+    
+    
+
+def perform_action(params, files):
+    output = None
+    outputdir = None
+    force = False
+    overwrite_original = False
+
+
+    if len(files) == 0:
+        print_removedrm_help()
+        return 0
+
+    while len(params) > 0:
+        p = params.pop(0)
+        if p == "--output":
+            output = params.pop(0)
+        elif p == "--outputdir":
+            outputdir = params.pop(0)
+        elif p == "--force":
+            force = True
+        elif p == "--overwrite":
+            overwrite_original = True
+            force = True
+        elif p == "--help":
+            print_removedrm_help()
+            return 0
+
+    if overwrite_original and (output is not None or outputdir is not None):
+        print("Can't use --overwrite together with --output or --outputdir.", file=sys.stderr)
+        return 1
+
+    if output is not None and os.path.isfile(output) and not force:
+        print("Output file already exists. Use --force to overwrite.", file=sys.stderr)
+        return 1
+
+
+    if output is not None and len(files) > 1:
+        print("Cannot set output file name if there's multiple input files.", file=sys.stderr)
+        return 1
+    
+    if outputdir is not None and output is not None and os.path.isabs(output): 
+        print("--output parameter is absolute path despite --outputdir being set.", file=sys.stderr)
+        print("Remove --outputdir, or give a relative path to --output.", file=sys.stderr)
+        return 1
+
+
+
+    for file in files:
+
+        file = os.path.abspath(file)
+
+        if not os.path.isfile(file):
+            print("Skipping file " + file + " - not found.", file=sys.stderr)
+            continue
+
+        if overwrite_original:
+            output_filename = file
+        else:
+            if output is not None:
+                # Due to the check above, we DO only have one file here.
+                if outputdir is not None and not os.path.isabs(output):
+                    output_filename = os.path.join(outputdir, output)
+                else:    
+                    output_filename = os.path.abspath(output)
+            else:
+                if outputdir is None:
+                    outputdir = os.getcwd()
+                output_filename = os.path.join(outputdir, os.path.basename(file))
+                output_filename = os.path.abspath(output_filename)
+
+                if output_filename == file:
+                    # If we export to the import folder, add a suffix to the file name.
+                    fn, f_ext = os.path.splitext(output_filename)
+                    output_filename = fn + "_nodrm" + f_ext
+
+
+        
+        if os.path.isfile(output_filename) and not force:
+            print("Skipping file " + file + " because output file already exists (use --force).", file=sys.stderr)
+            continue
+
+        
+
+        dedrm_single_file(file, output_filename)
+
+       
+
+
+    return 0
+    
+
+if __name__ == "__main__":
+    print("This code is not intended to be executed directly!", file=sys.stderr)

DeDRM_plugin/topazextract.py

@@ -13,14 +13,16 @@ __version__ = '6.0'
 
 import sys
 import os, csv, getopt
+
+#@@CALIBRE_COMPAT_CODE@@
+
+
 import zlib, zipfile, tempfile, shutil
 import traceback
 from struct import pack
 from struct import unpack
-try:
-    from calibre_plugins.dedrm.alfcrypto import Topaz_Cipher
-except:
-    from alfcrypto import Topaz_Cipher
+
+from alfcrypto import Topaz_Cipher
 
 # Wrap a stream so that output gets flushed immediately
 # and also make sure that any unicode strings get
@@ -32,11 +34,17 @@ class SafeUnbuffered:
         if self.encoding == None:
             self.encoding = "utf-8"
     def write(self, data):
-        if isinstance(data, str):
+        if isinstance(data,str) or isinstance(data,unicode):
+            # str for Python3, unicode for Python2
             data = data.encode(self.encoding,"replace")
-        self.stream.buffer.write(data)
-        self.stream.buffer.flush()
-
+        try:
+            buffer = getattr(self.stream, 'buffer', self.stream)
+            # self.stream.buffer for Python3, self.stream for Python2
+            buffer.write(data)
+            buffer.flush()
+        except:
+            # We can do nothing if a write fails
+            raise
     def __getattr__(self, attr):
         return getattr(self.stream, attr)
 
@@ -77,17 +85,12 @@ def unicode_argv():
         return ["mobidedrm.py"]
     else:
         argvencoding = sys.stdin.encoding or "utf-8"
-        return [arg if isinstance(arg, str) else str(arg, argvencoding) for arg in sys.argv]
+        return [arg if (isinstance(arg, str) or isinstance(arg,unicode)) else str(arg, argvencoding) for arg in sys.argv]
 
 #global switch
 debug = False
 
-if 'calibre' in sys.modules:
-    inCalibre = True
-    from calibre_plugins.dedrm import kgenpids
-else:
-    inCalibre = False
-    import kgenpids
+import kgenpids
 
 
 class DrmException(Exception):
@@ -172,6 +175,8 @@ def decryptRecord(data,PID):
 # Try to decrypt a dkey record (contains the bookPID)
 def decryptDkeyRecord(data,PID):
     record = decryptRecord(data,PID)
+    if isinstance(record, str):
+       record = record.encode('latin-1')
     fields = unpack('3sB8sB8s3s',record)
     if fields[0] != b'PID' or fields[5] != b'pid' :
         raise DrmException("Didn't find PID magic numbers in record")
@@ -315,6 +320,8 @@ class TopazBook:
                 raise DrmException("Error: Attempt to decrypt without bookKey")
 
         if compressed:
+            if isinstance(record, str):
+                record = bytes(record, 'latin-1')
             record = zlib.decompress(record)
 
         return record
@@ -326,14 +333,11 @@ class TopazBook:
             keydata = self.getBookPayloadRecord(b'dkey', 0)
         except DrmException as e:
             print("no dkey record found, book may not be encrypted")
-            print("attempting to extrct files without a book key")
+            print("attempting to extract files without a book key")
             self.createBookDirectory()
             self.extractFiles()
             print("Successfully Extracted Topaz contents")
-            if inCalibre:
-                from calibre_plugins.dedrm import genbook
-            else:
-                import genbook
+            import genbook
 
             rv = genbook.generateBook(self.outdir, raw, fixedimage)
             if rv == 0:
@@ -345,6 +349,8 @@ class TopazBook:
         for pid in pidlst:
             # use 8 digit pids here
             pid = pid[0:8]
+            if isinstance(pid, str):
+                pid = pid.encode('latin-1')
             print("Trying: {0}".format(pid))
             bookKeys = []
             data = keydata
@@ -358,16 +364,13 @@ class TopazBook:
                 break
 
         if not bookKey:
-            raise DrmException("No key found in {0:d} keys tried. Read the FAQs at Harper's repository: https://github.com/apprenticeharper/DeDRM_tools/blob/master/FAQs.md".format(len(pidlst)))
+            raise DrmException("No key found in {0:d} keys tried. Read the FAQs at noDRM's repository: https://github.com/noDRM/DeDRM_tools/blob/master/FAQs.md".format(len(pidlst)))
 
         self.setBookKey(bookKey)
         self.createBookDirectory()
         self.extractFiles()
         print("Successfully Extracted Topaz contents")
-        if inCalibre:
-            from calibre_plugins.dedrm import genbook
-        else:
-            import genbook
+        import genbook
 
         rv = genbook.generateBook(self.outdir, raw, fixedimage)
         if rv == 0:
@@ -415,6 +418,8 @@ class TopazBook:
                     outputFile = os.path.join(destdir,fname)
                     print(".", end=' ')
                     record = self.getBookPayloadRecord(name,index)
+                    if isinstance(record, str):
+                        record=bytes(record, 'latin-1')
                     if record != b'':
                         open(outputFile, 'wb').write(record)
                 print(" ")

DeDRM_plugin/utilities.py

@@ -1,7 +1,9 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-from calibre_plugins.dedrm.ignoblekeygen import generate_key
+#@@CALIBRE_COMPAT_CODE@@
+
+from ignoblekeyGenPassHash import generate_key
 
 __license__ = 'GPL v3'
 

DeDRM_plugin/wineutils.py

@@ -5,7 +5,10 @@ __license__ = 'GPL v3'
 
 # Standard Python modules.
 import os, sys, re, hashlib, traceback
-from calibre_plugins.dedrm.__init__ import PLUGIN_NAME, PLUGIN_VERSION
+
+#@@CALIBRE_COMPAT_CODE@@
+
+from __init__ import PLUGIN_NAME, PLUGIN_VERSION
 
 
 class NoWinePython3Exception(Exception):
@@ -74,7 +77,7 @@ def WineGetKeys(scriptpath, extension, wineprefix=""):
         pyexec = WinePythonCLI(wineprefix)
     except NoWinePython3Exception:
         print('{0} v{1}: Unable to find python3 executable in WINEPREFIX="{2}"'.format(PLUGIN_NAME, PLUGIN_VERSION, wineprefix))
-        return []
+        return [], []
 
     basepath, script = os.path.split(scriptpath)
     print("{0} v{1}: Running {2} under Wine".format(PLUGIN_NAME, PLUGIN_VERSION, script))
@@ -93,6 +96,7 @@ def WineGetKeys(scriptpath, extension, wineprefix=""):
 
     # try finding winekeys anyway, even if above code errored
     winekeys = []
+    winekey_names = []
     # get any files with extension in the output dir
     files = [f for f in os.listdir(outdirpath) if f.endswith(extension)]
     for filename in files:
@@ -104,9 +108,10 @@ def WineGetKeys(scriptpath, extension, wineprefix=""):
                 else:
                     new_key_value = keyfile.read()
             winekeys.append(new_key_value)
+            winekey_names.append(filename)
         except:
             print("{0} v{1}: Error loading file {2}".format(PLUGIN_NAME, PLUGIN_VERSION, filename))
             traceback.print_exc()
         os.remove(fpath)
     print("{0} v{1}: Found and decrypted {2} {3}".format(PLUGIN_NAME, PLUGIN_VERSION, len(winekeys), "key file" if len(winekeys) == 1 else "key files"))
-    return winekeys
+    return winekeys, winekey_names

DeDRM_plugin/zipfilerugged.py

@@ -209,6 +209,7 @@ def _EndRecData(fpin):
         fpin.seek(-sizeEndCentDir, 2)
     except IOError:
         return None
+        
     data = fpin.read()
     if data[0:4] == stringEndArchive and data[-2:] == "\000\000":
         # the signature is correct and there's no comment, unpack structure
@@ -662,7 +663,8 @@ class ZipFile:
         self.comment = b''
 
         # Check if we were passed a file-like object
-        if isinstance(file, str):
+        # "str" is python3, "unicode" is python2
+        if isinstance(file, str) or isinstance(file, unicode):
             self._filePassed = 0
             self.filename = file
             modeDict = {'r' : 'rb', 'w': 'wb', 'a' : 'r+b'}

DeDRM_plugin/zipfix.py

@@ -20,14 +20,12 @@ Re-write zip (or ePub) fixing problems with file names (and mimetype entry).
 __license__ = 'GPL v3'
 __version__ = "1.1"
 
-import sys
+import sys, os
+
+#@@CALIBRE_COMPAT_CODE@@
+
 import zlib
-try:
-    import zipfilerugged
-except:
-    import calibre_plugins.dedrm.zipfilerugged as zipfilerugged
-import os
-import os.path
+import zipfilerugged
 import getopt
 from struct import unpack
 
@@ -153,6 +151,7 @@ class fixZip:
                 nzinfo.internal_attr=zinfo.internal_attr
                 nzinfo.external_attr=zinfo.external_attr
                 nzinfo.create_system=zinfo.create_system
+                nzinfo.flag_bits = zinfo.flag_bits & 0x800  # preserve UTF-8 flag
                 self.outzip.writestr(nzinfo,data)
 
         self.bzf.close()

DeDRM_plugin_ReadMe.txt

@@ -4,10 +4,10 @@ DeDRM_plugin.zip
 This plugin will remove the DRM from:
 
  - Kindle ebooks (files from Kindle for Mac/PC and eInk Kindles).
- - Adobe Digital Editions (v2.0.1***) ePubs (including Kobo and Google ePubs downloaded to ADE)
- - Adobe Digital Editions (v2.0.1) PDFs
+ - Adobe Digital Editions ePubs (including Kobo and Google ePubs downloaded to ADE)
+ - Adobe Digital Editions PDFs
 
-For limitations and work-arounds, see the FAQ at https://github.com/apprenticeharper/DeDRM_tools/blob/master/FAQs.md
+For limitations and work-arounds, see the FAQ at https://github.com/noDRM/DeDRM_tools/blob/master/FAQs.md (or the FAQ in Apprentice Harper's original repository at https://github.com/apprenticeharper/DeDRM_tools/blob/master/FAQs.md)
 
 
 Installation
@@ -31,4 +31,6 @@ If you find that the DeDRM plugin is not working for you (imported ebooks still
  - Once calibre has re-started, import the problem ebook.
  - Now close calibre.
 
-A log will appear that you can copy and paste into a comment at Apprentice Alf's blog, http://apprenticealf.wordpress.com/ or an issue at Apprentice Harper's repository, https://github.com/apprenticeharper/DeDRM_tools/issues . You should also give details of your computer, and how you obtained the ebook file.
+A log will appear that you can copy and paste into a GitHub issue report at https://github.com/noDRM/DeDRM_tools/issues. Please also include information about the eBook file.
+
+If you're using Apprentice Harper's original version, you can also comment at Apprentice Alf's blog, http://apprenticealf.wordpress.com/ or open an issue at Apprentice Harper's repository, https://github.com/apprenticeharper/DeDRM_tools/issues.

FAQs.md

@@ -9,32 +9,29 @@ DRM ("Digital Rights Management") is a way of using encryption to tie the books
 When your ebooks have DRM you are unable to convert the ebook from one format to another (e.g. Kindle KF8 to Kobo ePub), so you are restricted in the range of ebook stores you can use. DRM also allows publishers to restrict what you can do with the ebook you've bought, e.g. preventing the use of text-to-speech software. Longer term, you can never be sure that you'll be able to come back and re-read your ebooks if they have DRM, even if you save back-up copies.
 
 ## So how can I remove DRM from my ebooks?
-Just download and use these tools, that's all! Uh, almost. There are a few, uh, provisos, a, a couple of quid pro quos. 
+Just download and use these tools, that's all! Uh, almost. There are a few, uh, provisos, a couple of quid pro quos. 
 
 * The tools don't work on all ebooks. For example, they don't work on any ebooks from Apple's iBooks store.
 * You must own the ebook - the tools won't work on library ebooks or rented ebooks or books from a friend.
 * You must not use these tools to give your ebooks to a hundred of your closest friends. Or to a million strangers. Authors need to sell books to be able to write more books. Don't be mean to the authors.
-* Do NOT use Adobe Digital Editions 3.0 or later to download your ePubs. ADE 3.0 and later might use a new encryption scheme that the tools can't handle. While major ebook stores aren't using the new scheme yet, using ADE 2.0.1 will ensure that your ebooks are downloaded using the old scheme. Once a book has been downloaded with the new scheme, it's IMPOSSIBLE to re-download using the old scheme (without buying it again).
-
-But otherwise, if your ebook is from Amazon, Kobo, Barnes & Noble or any of the ebook stores selling ebooks compatible with Adobe Digital Editions 2.0.1, you should be able to remove the DRM that's been applied to your ebooks.
 
 ### Recent Changes to Kindle for PC/Kindle for Mac
 Starting with version 1.19, Kindle for PC/Mac uses Amazon's new KFX format which isn't quite as good a source for conversion to ePub as the older KF8 (& MOBI) formats. There are two options to get the older formats. Either stick with version 1.17 or earlier, or modify the executable by changing a file name (PC) or disabling a component of the application (Mac). 
 
-Version 1.17 of Kindle is no longer available directly from Amazon, so you will need to search for the proper file name and find it on a third party site. The name is `KindleForPC-installer-1.17.44170.exe` for PC and `KindleForMac-44182.dmg` for Mac.
+Version 1.17 of Kindle is no longer available directly from Amazon, so you will need to search for the proper file name and find it on a third party site. The name is `KindleForPC-installer-1.17.44170.exe` for PC and `KindleForMac-44182.dmg` for Mac.  (Note that this is a 32-bit application on the Mac, so will not work on Catalina and newer versions of macOS.)
 Verify the one of the following cryptographic hash values, using software of your choice, before installing the downloaded file in order to avoid viruses. If the hash does not match, delete the downloaded file and try again from another site.
 
 #### Kindle for PC `KindleForPC-installer-1.17.44170.exe`:
 * MD-5: 53F793B562F4823721AA47D7DE099869
 * SHA-1: 73C404D719F0DD8D4AE1C2C96612B095D6C86255
-* SHA-256: 14E0F0053F1276C0C7C446892DC170344F707FBFE99B695176 2C120144163200
+* SHA-256: 14E0F0053F1276C0C7C446892DC170344F707FBFE99B6951762C120144163200
 
 #### Kindle for Mac `KindleForMac-44182.dmg`:
 * MD-5: E7E36D5369E1F3CF1D28E5D9115DF15F
 * SHA-1: 7AB9A86B954CB23D622BD79E3257F8E2182D791C
-* SHA-256: 28DC21246A9C7CDEDD2D6F0F4082E6BF7EF9DB9CE9D485548E 8A9E1D19EAE2AC. 
+* SHA-256: 28DC21246A9C7CDEDD2D6F0F4082E6BF7EF9DB9CE9D485548E8A9E1D19EAE2AC
 
-You will need to go to the preferences and uncheck the auto update checkbox. Then download and install 1.17 over the top of the newer installation. You'll also need to delete the KFX folders from your My Kindle Content folder. You may also need to take further action to prevent an auto update. The simplest wayis to find the 'updates' folder and replace it with a file. See [this thread] (http://www.mobileread.com/forums/showthread.php?t=283371) at MobileRead for a Script to do this on a PC. On a Mac you can find the folder at ~/Library/Application Support/Kindle/ just delete the folder 'updates' and save a blank text file called 'updates' in its place.
+You will need to go to the preferences and uncheck the auto update checkbox. Then download and install 1.17 over the top of the newer installation. You'll also need to delete the KFX folders from your My Kindle Content folder. You may also need to take further action to prevent an auto update. The simplest wayis to find the 'updates' folder and replace it with a file. See [this thread] (http://www.mobileread.com/forums/showthread.php?t=283371) at MobileRead for a Script to do this on a PC. On a Mac you can find the folder at ~/Library/Application Support/Kindle/. Make the 'updates' folder read-only, or delete it and save a blank text file called 'updates' in its place.
 
 Another possible solution is to use 1.19 or later, but disable KFX by renaming or disabling a necessary component of the application. This may or may not work on versions after 1.25. In a command window, enter the following commands when Kindle for PC/Mac is not running:
 
@@ -46,29 +43,31 @@ PC Note: The renderer-test program may be in a different location in some Kindle
 #### Macintosh
 `chmod -x /Applications/Kindle.app/Contents/MacOS/renderer-test`
 
-Mac Note: If the chmod command fails with a permission error try again using `sudo` before `chmod` - `sudo chmod` [...]
+Mac Note: If the chmod command fails with a permission error try again using `sudo` before `chmod` - `sudo chmod` [...]. This only works on Kindle for Mac 1.19 thru 1.31, it does NOT work with 1.32 or newer.
 
-After restarting the Kindle program any books previously downloaded in KFX format will no longer open. You will need to remove them from your device and re-download them. All future downloads will use the older Kindle formats instead of KFX although they will continue to be placed in one individual subdirectory per book. Note that books soudl be downoad by right-click and 'Download', not by just opening the book. Recent (1.25+) versions of Kindle for Mac/PC may convert KF8 files to a new format that is not supported by these tools when the book is opened for reading.
+After restarting the Kindle program any books previously downloaded in KFX format will no longer open. You will need to remove them from your device and re-download them. All future downloads will use the older Kindle formats instead of KFX although they will continue to be placed in one individual subdirectory per book. Note that books should be downloaded by right-click and 'Download', not by just opening the book. Recent (1.25+) versions of Kindle for Mac/PC may convert KF8 files to a new format that is not supported by these tools when the book is opened for reading.
 
 #### Decrypting KFX
-Thanks to work by several people, the tools can now decrypt KFX format ebooks from Kindle for Mac/PC version 1.26 or earlier (version later than 1.26 use a new encryption scheme for KFX files). In addition to the DeDRM plugin, calibre users will also need to install jhowell's KFX Input plugin which is available through the standard plugin menu in calibre, or directly from [his plugin thread](https://www.mobileread.com/forums/showthread.php?t=291290) on Mobileread. 
+Thanks to work by several people, the tools can now decrypt KFX format ebooks from Kindle for Mac/PC. In addition to the DeDRM plugin, calibre users will also need to install jhowell's KFX Input plugin which is available through the standard plugin menu in calibre, or directly from [his plugin thread](https://www.mobileread.com/forums/showthread.php?t=291290) on Mobileread. 
+
+It's quite possible that Amazon will update their KFX DeDRM to prevent DRM removal from KFX books again. So Remove DRM as soon as possible!
 
 #### Thanks
 Thanks to jhowell for his investigations into KFX format and the KFX Input plugin. Some of these instructions are from [his thread on the subject](https://www.mobileread.com/forums/showthread.php?t=283371) at MobileRead.
 
 ## Where can I get the latest version of these free DRM removal tools?
-Right here at github. Just go to the [releases page](https://github.com/apprenticeharper/DeDRM_tools/releases) and download the latest zip archive of the tools, named `DeDRM\_tools\_X.X.X.zip`, where X.X.X is the version number. You do not need to download the source code archive.
+Right here at github. Just go to the [releases page](https://github.com/noDRM/DeDRM_tools/releases) and download the latest zip archive of the tools, named `DeDRM\_tools\_X.X.X.zip`, where X.X.X is the version number. You do not need to download the source code archive. This will get you the forked version by noDRM. If you want to download the original version by Apprentice Harper, go to [this page](https://github.com/apprenticeharper/DeDRM_tools/releases) instead. 
 
 ## I've downloaded the tools archive. Now what?
-First, unzip the archive. You should now have a DeDRM folder containing several other folders and a `ReadMe_Overview.txt` file. Please read the `ReadMe_Overview.txt` file! That will explain what the folders are, and you'll be able to work out which of the tools you need.
+First, unzip the archive. You should now have a DeDRM folder containing several files, including a `ReadMe_Overview.txt` file. Please read the `ReadMe_Overview.txt` file! That will explain what the files are, and you'll be able to work out which of the tools you need.
 
 ## That's a big complicated ReadMe file! Isn't there a quick guide?
 Install calibre. Install the DeDRM\_plugin in calibre. Install the Obok\_plugin in calibre. Restart calibre. In the DeDRM_plugin customisation dialog add in any E-Ink Kindle serial numbers. Remember that the plugin only tries to remove DRM when ebooks are imported.
 
 # Installing the Tools
 ## The calibre plugin
-### I am trying to install the calibre plugin, but calibre says "ERROR: Unhandled exception: InvalidPlugin: The plugin in u’[path]DeDRM\_tools\_6.5.3.zip’ is invalid. It does not contain a top-level \_\_init\_\_.py file"
-You are trying to add the tools archive (e.g. `DeDRM_tools_6.8.0.zip`) instead of the plugin. The tools archive is not the plugin. It is a collection of DRM removal tools which includes the plugin. You must unzip the archive, and install the calibre plugin `DeDRM_plugin.zip` from a folder called `DeDRM_calibre_plugin` in the unzipped archive.
+### I am trying to install the calibre plugin, but calibre says "ERROR: Unhandled exception: InvalidPlugin: The plugin in '[path]DeDRM\_tools\_X.X.X.zip' is invalid. It does not contain a top-level \_\_init\_\_.py file"
+You are trying to add the tools archive (e.g. `DeDRM_tools_10.0.2.zip`) instead of the plugin. The tools archive is not the plugin. It is a collection of DRM removal tools which includes the plugin. You must unzip the archive, and install the calibre plugin `DeDRM_plugin.zip` from inside the unzipped archive.
 
 ### I’ve unzipped the tools archive, but I can’t find the calibre plugin when I try to add them to calibre. I use Windows.
 You should select the zip file that is in the `DeDRM_calibre_plugin` folder, not any files inside the plugin’s zip archive. Make sure you are selecting from the folder that you created when you unzipped the tools archive and not selecting a file inside the still-zipped tools archive.
@@ -93,7 +92,7 @@ Your ebooks are stored on your computer or on your ebook reader. You need to fin
 ### Macintosh
 Navigating from your home folder,
 
-Kindle for Mac ebooks are in either `Library/Application Support/Kindle/My Kindle Content` or `Documents/My Kindle Content or Library/Containers/com.amazon.Kindle/Data/Library/Application Support/Kindle/My Kindle Content`, depending on your version of Kindle for Mac.
+Kindle for Mac ebooks are in either `Library/Application Support/Kindle/My Kindle Content` or `Documents/My Kindle Content` or `Library/Containers/com.amazon.Kindle/Data/Library/Application Support/Kindle/My Kindle Content`, depending on your version of Kindle for Mac.
 
 Adobe Digital Editions ebooks are in `Documents/Digital Editions`
 
@@ -118,21 +117,20 @@ If this book is from Kindle for Mac or Kindle for PC, you must have the Kindle S
 
 If the book is from Kindle for PC or Kindle for Mac and you think you are doing everything right, and you are getting this message, it is possible that the files containing the encryption key aren’t quite in the format the tools expect. To try to fix this:
 
-1. Deregister Kindle for PC(Mac) from your Amazon account.
-1. Uninstall Kindle for PC(Mac)
-1. Delete the Kindle for PC(Mac) preferences
+1. Deregister Kindle for PC/Mac from your Amazon account.
+1. Uninstall Kindle for PC/Mac
+1. Delete the Kindle for PC/Mac preferences
     * PC: Delete the directory `[home folder]\AppData\Local\Amazon` (it might be hidden) and `[home folder]\My Documents\My Kindle Content`
     * Mac: Delete the directory `[home folder]/Library/Application Support/Kindle/` and/or `[home folder]/Library/Containers/com.amazon.Kindle/Data/Library/Application Support/Kindle/` (one or both may be present and should be deleted)
-1. Reinstall Kindle for PC(Mac) version 1.17 or earlier (see above for download links).
-1. Re-register Kindle for PC(Mac) with your Amazon account
+1. Reinstall Kindle for PC/Mac version 1.17 or earlier (see above for download links).
+1. Re-register Kindle for PC/Mac with your Amazon account
 1. Download the ebook again. Do not use the files you have downloaded previously.
 
 ## Some of my books had their DRM removed, but some still say that they have DRM and will not convert.
 There are several possible reasons why only some books get their DRM removed.
 * You still don’t have the DRM removal tools working correctly, but some of your books didn’t have DRM in the first place.
-* Kindle only: It is a Topaz format book and contains some coding that the tools do not understand. You will need to get a log of the DeDRM attempt, and then create a [new issue at Apprentice Harper's github repository](https://github.com/apprenticeharper/DeDRM_tools/issues/), attaching the book and the log, so that the tools can be updated.
 
-If you are still having problems with particular books, you will need to create a log of the DRM removal attempt for one of the problem books, and post that in a comment at Apprentice Alf's blog or in a new issue at Apprentice Harper's github repository.
+If you are still having problems with particular books, you will need to create a log of the DRM removal attempt for one of the problem books. If you're using NoDRM's fork, open [a new issue](https://github.com/noDRM/DeDRM_tools/issues) in the GitHub repo. If you're using Apprentice Harper's version, post that logfile in a new issue at [Apprentice Harper's github repository](https://github.com/apprenticeharper/DeDRM_tools/issues).
 
 ## My Kindle book has imported and the DRM has been removed, but all the pictures are gone.
 Most likely, this is a book downloaded from Amazon directly to an eInk Kindle (e.g. Paperwhite). Unfortunately, the pictures are probably in a `.azw6` file that the tools don't understand. You must download the book manually from Amazon's web site "For transfer via USB" to your Kindle. When you download the eBook in this manner, Amazon will package the pictures in the with text in a single file that the tools will be able to import successfully.
@@ -143,33 +141,32 @@ You have found a Print Replica Kindle ebook. This is a PDF in a Kindle wrapper.
 ## Do the tools work on books from Kobo?
 If you use the Kobo desktop application for Mac or PC, install the Obok plugin. This will import and remove the DRM from your Kobo books, and is the easiest method for Kobo ebooks.
 
-## I registered Adobe Digital Editions 3.0 or later with an Adobe ID before downloading, but my epub or PDF still has DRM.
-Adobe introduced a new DRM scheme with ADE 3.0 and later. Install ADE 2.0.1 and register with the same Adobe ID. If you can't open your book in ADE 2.01, then you have a book with the new DRM scheme. These tools can't help. You can avoid the new DRM scheme by always downloading your ebooks with ADE 2.0.1. Some retailers will require ADE 3.0 or later, in which case you won't be able to download with ADE 2.0.1.
-
-## The DRM wasn't removed and the log says "Failed to decrypt with error: Cannot decode library or rented ebooks." What now?
-You're trying to remove the DRM from an ebook that's only on loan to you. No help will be given to remove DRM from such ebooks. If you think that you have received this message for a book you own, please create an issue at github, or comment at the blog.
-
 ## I cannot solve my problem with the DeDRM plugin, and now I need to ‘post a log’. How do I do that?
-Remove the DRMed book from calibre. Click the Preferences drop-down menu and choose 'Restart in debug mode'. Once calibre has re-started, import the problem ebook. Now close calibre. A log will appear that you can copy and paste into a comment at Apprentice Alf's blog, or into a new issue at Apprentice Harper's github repository.
+Remove the DRMed book from calibre. Click the Preferences drop-down menu and choose 'Restart in debug mode'. Once calibre has re-started, import the problem ebook. Now close calibre. A log will appear that you can copy and paste into [a new issue](https://github.com/noDRM/DeDRM_tools/issues) in NoDRM’s GitHub repo. If you're using Apprentice Harper’s version, post that logfile in a new issue at [Apprentice Harper's GitHub repository](https://github.com/apprenticeharper/DeDRM_tools/issues).
 
 ## Is there a way to use the DeDRM plugin for Calibre from the command line?
 See the [Calibre command line interface (CLI) instructions](CALIBRE_CLI_INSTRUCTIONS.md).
 
+## The plugin displays a "MemoryError" in its log file during DRM removal. 
+A "MemoryError" usually occurs when you're using the 32-bit version of Calibre (which is limited in the amount of useable RAM). If you have a 64-bit installation of your operating system (on Windows, press Windows+Break, then make sure it says "64-bit Operating System" under "System type"), try downloading the 64-bit version of Calibre instead of the 32-bit version. 
+
+If the error still occurs, even with the 64-bit version, please open a bug report.
+
 # General Questions
 
 ## Once the DRM has been removed, is there any trace of my personal identity left in the ebook?
-The tools only remove the DRM. No attempt is made to remove any personally identifying information.
+That question cannot be answered for sure. While it is easy to check if a book has DRM or not, it is very difficult to verify if all (traces of) personal information have been removed from a book. The tools attempt to remove watermarks when they are detected (optionally, there's an option in the plugin settings to enable that), but that will not be the case for all watermarks. 
 
 ## Why do some of my Kindle ebooks import as HTMLZ format in calibre?
 Most Amazon Kindle ebooks are Mobipocket format ebooks, or the new KF8 format. However, some are in a format known as Topaz. The Topaz format is only used by Amazon. A Topaz ebook is a collections of glyphs and their positions on each page tagged with some additional information from that page including OCRed text (Optical Character Recognition generated Text) to allow searching, and some additional layout information. Each page of a Topaz ebook is effectively a description of an image of that page. To convert a Topaz ebook to another format is not easy as there is not a one-to-one mapping between glyphs and characters/fonts. To account for this, two different formats are generated by the DRM removal software. The first is an html description built from the OCRtext and images stored in the Topaz file (HTMLZ). This format is easily reflowed but may suffer from typical OCRtext errors including typos, garbled text, missing italics, missing bolds, etc. The second format uses the glyph and position information to create an accurate scalable vector graphics (SVG) image of each page of the book that can be viewed in web browsers that support svg images (Safari, Firefox 4 or later, etc). Additional conversion software can be used to convert these SVG images to an image only PDF file. The DeDRM calibre plugin only imports the HTMLZ versions of the Topaz ebook. The html version can be manually cleaned up and spell checked and then converted using Sigil/calibre to epubs, mobi ebooks, and etc.
 
 ## Are the tools open source? How can I be sure they are safe and not a trojan horse?
-All the DRM removal tools hosted here are almost entirely scripts of one kind or another: Python, Applescript or Windows Batch files. So they are inherently open source, and open to inspection by everyone who downloads them.
+All the DRM removal tools hosted here are almost entirely written in Python. So they are inherently open source, and open to inspection by everyone who downloads them.
 
-There are some optional shared libraries (`*.dll`, `*.dylib`, and `*.so`) included for performance. The source for any compiled pieces are provided within `alfcrypto_src.zip`. If this is a concern either delete the binary files or manually rebuild them.
+There are some optional shared libraries (`*.dll`, `*.dylib`, and `*.so`) included for performance. The source for any compiled pieces are provided within `alfcrypto_src.zip`. If this is a concern either delete the binary files (there's fallback code in the plugin that allows it to work without these, it will just be slower) or manually rebuild them from source.
 
 ## What ebooks do these tools work on?
-The tools linked from this blog remove DRM from PDF, ePub, kePub (Kobo), eReader, Kindle (Mobipocket, KF8, Print Replica and Topaz) format ebooks using Adobe Adept, Barnes & Noble, Amazon, Kobo and eReader DRM schemes.
+The Calibre plugin removes DRM from PDF, ePub, kePub (Kobo), eReader, Kindle (Mobipocket, KF8, Print Replica and Topaz) format ebooks using Adobe Adept, Barnes & Noble, Amazon, Kobo and eReader DRM schemes. It used to remove Readium LCP DRM from ePub or PDF files in the past, but that functionality had to be removed due to a [DMCA takedown request](https://github.com/noDRM/DeDRM_tools/issues/18).
 
 Note these tools do NOT ‘crack’ the DRM. They simply allow the book’s owner to use the encryption key information already stored someplace on their computer or device to decrypt the ebook in the same manner the official ebook reading software uses.
 
@@ -185,14 +182,19 @@ Amazon turned off backup for Kindle for Android, so the tools can no longer find
 ## Why don't the tools work on books from the Apple iBooks Store?
 Apple regularly change the details of their DRM and so the tools in the main tools archive will not work with these ebooks. Apple’s Fairplay DRM scheme can be removed using Requiem if the appropriate version of iTunes can still be installed and used. See the post Apple and ebooks: iBookstore DRM and how to remove it at Apprentice Alf's blog for more details.
 
+## Why don't the tools work with LCP-encrypted ebooks? / Error message about a "DMCA takedown"
+Support for LCP DRM removal was included in the past, but Readium (the company who developed that particular DRM) has decided to [open a DMCA takedown request](https://github.com/github/dmca/blob/master/2022/01/2022-01-04-readium.md) in January 2022. This means that for legal reasons, this GitHun repository no longer contains the code needed to remove DRM from LCP-encrypted books. For more information please read [this bug report](https://github.com/noDRM/DeDRM_tools/issues/18). 
+
 ## I’ve got the tools archive and I’ve read all the FAQs but I still can’t install the tools and/or the DRM removal doesn’t work
 * Read the `ReadMe_Overview.txt` file in the top level of the tools archive
 * Read the ReadMe file for the tool you want to use.
-* If you still can’t remove the DRM, ask in the comments section of Apprentice Alf's blog or create a new issue at Apprentice Harper's github repository, reporting the error as precisely as you can, what platform you use, what tool you have tried, what errors you get, and what versions you are using. If the problem happens when running one of the tools, post a log (see previous questions on how to do this).
+* If you still can’t remove the DRM, create a new [GitHub issue](https://github.com/noDRM/DeDRM_tools/issues). If you are using Apprentice Harper's original version and not this fork, you can also create a new issue at Apprentice Harper's github repository. If you do report an issue in any of the GitHub repositories, please report the error as precisely as you can. Include what platform you use, what tool you have tried, what errors you get, and what versions you are using. If the problem happens when running one of the tools, post a log (see previous questions on how to do this).
 
 ## Who wrote these scripts?
 The authors tend to identify themselves only by pseudonyms:
 * The Adobe Adept and Barnes & Noble scripts were created by i♥cabbages
+* The Adobe Adept support for ADE3.0+ DRM was added by a980e066a01
+* ~The Readium LCP support for this plugin was created by NoDRM~ (removed due to a DMCA takedown, see [#18](https://github.com/noDRM/DeDRM_tools/issues/18) )
 * The Amazon Mobipocket and eReader scripts were created by The Dark Reverser
 * The Amazon K4PC DRM/format was further decoded by Bart Simpson aka Skindle
 * The Amazon K4 Mobi tool was created by by some_updates, mdlnx and others

Obok_plugin/__init__.py

@@ -3,7 +3,7 @@ from __future__ import (unicode_literals, division, absolute_import,
                         print_function)
 
 __license__   = 'GPL v3'
-__version__ = '7.1.0'
+__version__ = '10.0.0'
 __docformat__ = 'restructuredtext en'
 
 #####################################################################
@@ -20,7 +20,7 @@ except NameError:
 PLUGIN_NAME = 'Obok DeDRM'
 PLUGIN_SAFE_NAME = PLUGIN_NAME.strip().lower().replace(' ', '_')
 PLUGIN_DESCRIPTION = _('Removes DRM from Kobo kepubs and adds them to the library.')
-PLUGIN_VERSION_TUPLE = (7, 1, 0)
+PLUGIN_VERSION_TUPLE = (10, 0, 0)
 PLUGIN_VERSION = '.'.join([str(x) for x in PLUGIN_VERSION_TUPLE])
 HELPFILE_NAME = PLUGIN_SAFE_NAME + '_Help.htm'
 PLUGIN_AUTHORS = 'Anon'

Obok_plugin/action.py

@@ -375,7 +375,6 @@ class InterfacePluginAction(InterfaceAction):
         #print ('Kobo library filename: {0}'.format(book.filename))
         for userkey in self.userkeys:
             print (_('Trying key: '), codecs.encode(userkey, 'hex'))
-            check = True
             try:
                 fileout = PersistentTemporaryFile('.epub', dir=self.tdir)
                 #print ('Temp file: {0}'.format(fileout.name))
@@ -396,8 +395,7 @@ class InterfacePluginAction(InterfaceAction):
                         file = book.encryptedfiles[filename]
                         contents = file.decrypt(userkey, contents)
                         # Parse failures mean the key is probably wrong.
-                        if check:
-                            check = not file.check(contents)
+                        file.check(contents)
                     zout.writestr(filename, contents)
                 zout.close()
                 zin.close()

Obok_plugin/config.py

@@ -118,7 +118,13 @@ class ManageKeysDialog(QDialog):
         self._delete_key_button.clicked.connect(self.delete_key)
         button_layout.addWidget(self._delete_key_button)
 
-        spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
+        try: 
+            # QT 6
+            spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Policy.Minimum, QtGui.QSizePolicy.Policy.Expanding)
+        except AttributeError:
+            # QT 5
+            spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
+            
         button_layout.addItem(spacerItem)
 
         layout.addSpacing(5)
@@ -204,7 +210,7 @@ class AddSerialDialog(QDialog):
 
     def accept(self):
         if len(self.key_name) == 0 or self.key_name.isspace():
-            errmsg = "Please enter an eInk Kindle Serial Number or click Cancel in the dialog."
+            errmsg = "Please enter an eInk Kobo Serial Number or click Cancel in the dialog."
             return error_dialog(None, "{0} {1}".format(PLUGIN_NAME, PLUGIN_VERSION), errmsg, show=True, show_copy_button=False)
         if len(self.key_name) != 13:
             errmsg = "EInk Kobo Serial Numbers must be 13 characters long. This is {0:d} characters long.".format(len(self.key_name))

Obok_plugin/obok/legacy_obok.py

@@ -42,7 +42,10 @@ class legacy_obok(object):
         pwsdid = ''
         try:
             if sys.platform.startswith('win'):
-                import winreg
+                try:
+                    import winreg
+                except ImportError:
+                    import _winreg as winreg
                 regkey_browser = winreg.OpenKey(winreg.HKEY_CURRENT_USER, 'Software\\Kobo\\Kobo Desktop Edition\\Browser')
                 cookies = winreg.QueryValueEx(regkey_browser, 'cookies')
                 bytearrays = cookies[0]

Obok_plugin/obok/obok.py

@@ -1,9 +1,16 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
+# Version 10.0.1 February 2022
+# Remove OpenSSL support to only support PyCryptodome; clean up the code.
+#
+# Version 10.0.0 November 2021
+# Merge https://github.com/apprenticeharper/DeDRM_tools/pull/1691 to fix
+# key fetch issues on some machines.
+#
 # Version 4.1.0 February 2021
 # Add detection for Kobo directory location on Linux
-
+#
 # Version 4.0.0 September 2020
 # Python 3.0
 #
@@ -158,8 +165,8 @@
 """Manage all Kobo books, either encrypted or DRM-free."""
 from __future__ import print_function
 
-__version__ = '4.0.0'
-__about__ =  "Obok v{0}\nCopyright © 2012-2020 Physisticated et al.".format(__version__)
+__version__ = '10.0.1'
+__about__ =  "Obok v{0}\nCopyright © 2012-2022 Physisticated et al.".format(__version__)
 
 import sys
 import os
@@ -176,6 +183,20 @@ import shutil
 import argparse
 import tempfile
 
+try:
+    from Cryptodome.Cipher import AES
+except ImportError:
+    from Crypto.Cipher import AES
+
+def unpad(data, padding=16):
+    if sys.version_info[0] == 2:
+        pad_len = ord(data[-1])
+    else:
+        pad_len = data[-1]
+
+    return data[:-pad_len]
+
+
 can_parse_xml = True
 try:
   from xml.etree import ElementTree as ET
@@ -190,88 +211,6 @@ KOBO_HASH_KEYS = ['88b3a2e13', 'XzUhGYdFp', 'NoCanLook','QJhwzAtXL']
 class ENCRYPTIONError(Exception):
     pass
 
-def _load_crypto_libcrypto():
-    from ctypes import CDLL, POINTER, c_void_p, c_char_p, c_int, c_long, \
-        Structure, c_ulong, create_string_buffer, cast
-    from ctypes.util import find_library
-
-    if sys.platform.startswith('win'):
-        libcrypto = find_library('libeay32')
-    else:
-        libcrypto = find_library('crypto')
-
-    if libcrypto is None:
-        raise ENCRYPTIONError('libcrypto not found')
-    libcrypto = CDLL(libcrypto)
-
-    AES_MAXNR = 14
-
-    c_char_pp = POINTER(c_char_p)
-    c_int_p = POINTER(c_int)
-
-    class AES_KEY(Structure):
-        _fields_ = [('rd_key', c_long * (4 * (AES_MAXNR + 1))),
-                    ('rounds', c_int)]
-    AES_KEY_p = POINTER(AES_KEY)
-
-    def F(restype, name, argtypes):
-        func = getattr(libcrypto, name)
-        func.restype = restype
-        func.argtypes = argtypes
-        return func
-
-    AES_set_decrypt_key = F(c_int, 'AES_set_decrypt_key',
-                            [c_char_p, c_int, AES_KEY_p])
-    AES_ecb_encrypt = F(None, 'AES_ecb_encrypt',
-                        [c_char_p, c_char_p, AES_KEY_p, c_int])
-
-    class AES(object):
-        def __init__(self, userkey):
-            self._blocksize = len(userkey)
-            if (self._blocksize != 16) and (self._blocksize != 24) and (self._blocksize != 32) :
-                raise ENCRYPTIONError(_('AES improper key used'))
-                return
-            key = self._key = AES_KEY()
-            rv = AES_set_decrypt_key(userkey, len(userkey) * 8, key)
-            if rv < 0:
-                raise ENCRYPTIONError(_('Failed to initialize AES key'))
-
-        def decrypt(self, data):
-            clear = b''
-            for i in range(0, len(data), 16):
-                out = create_string_buffer(16)
-                rv = AES_ecb_encrypt(data[i:i+16], out, self._key, 0)
-                if rv == 0:
-                    raise ENCRYPTIONError(_('AES decryption failed'))
-                clear += out.raw
-            return clear
-
-    return AES
-
-def _load_crypto_pycrypto():
-    from Crypto.Cipher import AES as _AES
-    class AES(object):
-        def __init__(self, key):
-            self._aes = _AES.new(key, _AES.MODE_ECB)
-
-        def decrypt(self, data):
-            return self._aes.decrypt(data)
-
-    return AES
-
-def _load_crypto():
-    AES = None
-    cryptolist = (_load_crypto_pycrypto, _load_crypto_libcrypto)
-    for loader in cryptolist:
-        try:
-            AES = loader()
-            break
-        except (ImportError, ENCRYPTIONError):
-            pass
-    return AES
-
-AES = _load_crypto()
-
 # Wrap a stream so that output gets flushed immediately
 # and also make sure that any unicode strings get
 # encoded using "replace" before writing them.
@@ -356,7 +295,10 @@ class KoboLibrary(object):
 
             if (self.kobodir == u""):
                 if sys.platform.startswith('win'):
-                    import winreg
+                    try:
+                        import winreg
+                    except ImportError:
+                        import _winreg as winreg
                     if sys.getwindowsversion().major > 5:
                         if 'LOCALAPPDATA' in os.environ.keys():
                             # Python 2.x does not return unicode env. Use Python 3.x
@@ -417,6 +359,7 @@ class KoboLibrary(object):
             olddb.close()
             self.newdb.close()
             self.__sqlite = sqlite3.connect(self.newdb.name)
+            self.__sqlite.text_factory = lambda b: b.decode("utf-8", errors="ignore")
             self.__cursor = self.__sqlite.cursor()
             self._userkeys = []
             self._books = []
@@ -470,15 +413,22 @@ class KoboLibrary(object):
         """The list of all MAC addresses on this machine."""
         macaddrs = []
         if sys.platform.startswith('win'):
-            c = re.compile('\s(' + '[0-9a-f]{2}-' * 5 + '[0-9a-f]{2})(\s|$)', re.IGNORECASE)
-            output = subprocess.Popen('ipconfig /all', shell=True, stdout=subprocess.PIPE, text=True).stdout
-            for line in output:
-                m = c.search(line)
-                if m:
-                    macaddrs.append(re.sub("-", ":", m.group(1)).upper())
+            c = re.compile('\s?(' + '[0-9a-f]{2}[:\-]' * 5 + '[0-9a-f]{2})(\s|$)', re.IGNORECASE)
+            try: 
+                output = subprocess.Popen('ipconfig /all', shell=True, stdout=subprocess.PIPE, text=True).stdout
+                for line in output:
+                    m = c.search(line)
+                    if m:
+                        macaddrs.append(re.sub("-", ":", m.group(1)).upper())
+            except:
+                output = subprocess.Popen('wmic nic where PhysicalAdapter=True get MACAddress', shell=True, stdout=subprocess.PIPE, text=True).stdout
+                for line in output:
+                    m = c.search(line)
+                    if m:
+                        macaddrs.append(re.sub("-", ":", m.group(1)).upper())
         elif sys.platform.startswith('darwin'):
             c = re.compile('\s(' + '[0-9a-f]{2}:' * 5 + '[0-9a-f]{2})(\s|$)', re.IGNORECASE)
-            output = subprocess.check_output('/sbin/ifconfig -a', shell=True)
+            output = subprocess.check_output('/sbin/ifconfig -a', shell=True, encoding='utf-8')
             matches = c.findall(output)
             for m in matches:
                 # print "m:{0}".format(m[0])
@@ -616,11 +566,9 @@ class KoboFile(object):
         file page key. The caller must determine if the decrypted
         data is correct."""
         # The userkey decrypts the page key (self.key)
-        keyenc = AES(userkey)
-        decryptedkey = keyenc.decrypt(self.key)
-        # The decrypted page key decrypts the content
-        pageenc = AES(decryptedkey)
-        return self.__removeaespadding(pageenc.decrypt(contents))
+        decryptedkey = AES.new(userkey, AES.MODE_ECB).decrypt(self.key)
+        # The decrypted page key decrypts the content. Padding is PKCS#7
+        return unpad(AES.new(decryptedkey, AES.MODE_ECB).decrypt(contents), 16)
 
     def check (self, contents):
         """
@@ -690,23 +638,6 @@ class KoboFile(object):
                 raise ValueError()
         return False
 
-    def __removeaespadding (self, contents):
-        """
-        Remove the trailing padding, using what appears to be the CMS
-        algorithm from RFC 5652 6.3"""
-        lastchar = binascii.b2a_hex(contents[-1:])
-        strlen = int(lastchar, 16)
-        padding = strlen
-        if strlen == 1:
-            return contents[:-1]
-        if strlen < 16:
-            for i in range(strlen):
-                testchar = binascii.b2a_hex(contents[-strlen:-(strlen-1)])
-                if testchar != lastchar:
-                    padding = 0
-        if padding > 0:
-            contents = contents[:-padding]
-        return contents
 
 def decrypt_book(book, lib):
     print("Converting {0}".format(book.title))
@@ -774,7 +705,7 @@ def cli_main():
                 books = [lib.books[num - 1]]
             except (ValueError, IndexError):
                 print("Invalid choice. Exiting...")
-                exit()
+                sys.exit()
 
     results = [decrypt_book(book, lib) for book in books]
     lib.close()

Obok_plugin/obok_dedrm_Help.htm

@@ -8,7 +8,7 @@
 <body>
 
 <h1>Obok DeDRM Plugin</h1>
-<h3>(version 3.1.3)</h3>
+<h3>(version 10.0.0)</h3>
 
 <h3>Installation:</h3>
 
@@ -22,7 +22,7 @@
 
 <h3>Troubleshooting:</h3>
 
-<p >If you find that it’s not working for you , you can save a lot of time by using the plugin with Calibre in debug mode. This will print out a lot of helpful info that can be copied into any online help requests.</p>
+<p >If you find that it’s not working for you, you can save a lot of time by using the plugin with Calibre in debug mode. This will print out a lot of helpful info that can be copied into any online help requests.</p>
 
 <p>Open a command prompt (terminal window) and type "calibre-debug -g" (without the quotes). Calibre will launch, and you can use the plugin the usual way. The debug info will be output to the original command prompt (terminal window). Copy the resulting output and paste it into the comment you make at Apprentice Alf's blog.</p>
 

Other_Tools/DRM_Key_Scripts/Adobe_Digital_Editions/adobekey.pyw

@@ -129,7 +129,10 @@ if iswindows:
         c_long, c_ulong
 
     from ctypes.wintypes import LPVOID, DWORD, BOOL
-    import winreg
+    try:
+        import winreg
+    except ImportError:
+        import _winreg as winreg
 
     def _load_crypto_libcrypto():
         from ctypes.util import find_library

Other_Tools/DRM_Key_Scripts/Barnes_and_Noble_ePubs/ignoblekey.pyw

@@ -98,7 +98,10 @@ def getNookLogFiles():
     logFiles = []
     found = False
     if iswindows:
-        import winreg
+        try:
+            import winreg
+        except ImportError:
+            import _winreg as winreg
 
         # some 64 bit machines do not have the proper registry key for some reason
         # or the python interface to the 32 vs 64 bit registry is broken

Other_Tools/DRM_Key_Scripts/Kindle_for_Mac_and_PC/kindlekey.pyw

@@ -177,7 +177,10 @@ if iswindows:
         create_unicode_buffer, create_string_buffer, CFUNCTYPE, addressof, \
         string_at, Structure, c_void_p, cast
 
-    import winreg
+    try:
+        import winreg
+    except ImportError:
+        import _winreg as winreg
     MAX_PATH = 255
     kernel32 = windll.kernel32
     advapi32 = windll.advapi32

Other_Tools/Kobo/obok.py

@@ -346,7 +346,10 @@ class KoboLibrary(object):
         if (self.kobodir == u""):
             # step 4. we haven't found a device with serials, so try desktop apps
             if sys.platform.startswith('win'):
-                import winreg
+                try:
+                    import winreg
+                except ImportError:
+                    import _winreg as winreg
                 if sys.getwindowsversion().major > 5:
                     if 'LOCALAPPDATA' in os.environ.keys():
                         # Python 2.x does not return unicode env. Use Python 3.x
@@ -736,7 +739,7 @@ def cli_main():
                 books = [lib.books[num - 1]]
             except (ValueError, IndexError):
                 print("Invalid choice. Exiting...")
-                exit()
+                sys.exit()
 
     results = [decrypt_book(book, lib) for book in books]
     lib.close()

README.md

@@ -1,27 +1,30 @@
-# [Guide] How to remove DRM
-Refer to [Wiki Page](https://github.com/apprenticeharper/DeDRM_tools/wiki/Exactly-how-to-remove-DRM)
-
 # DeDRM_tools
 DeDRM tools for ebooks
 
+This is a fork of Apprentice Harper's version of the DeDRM tools. I've added some of the PRs that still haven't been merged, as well as added some more features / bugfixes myself.
+
+Take a look at [the CHANGELOG](https://github.com/noDRM/DeDRM_tools/blob/master/CHANGELOG.md) to see a list of changes since the last version by Apprentice Harper (v7.2.1). This plugin will start with version v10.0.0 so there won't be conflicting / duplicate version numbers when Apprentice Harper's version is updated again.
+
+The v10.0.0 versions of this plugin should both work with Calibre 5.x (Python 3) as well as Calibre 4.x and lower (Python 2). If you encounter issues with this plugin in Calibre 4.x or lower, please open a bug report.
+
+# Original README from Apprentice Harper
+
 This is a repository that tracks all the scripts and other tools for removing DRM from ebooks that I could find, committed in date order as best as I could manage. (Except for the Requiem tools for Apple's iBooks, and Convert LIT for Microsoft's .lit ebooks.) This includes the tools from a time before Apprentice Alf had a blog, and continues through to when Apprentice Harper (with help) took over maintenance of the tools.
 
 The individual scripts are now released as two plugins for calibre: DeDRM and Obok. 
-The DeDRM plugin handles books that use Amazon DRM, Adobe Digital Editions DRM (version 1), Barnes & Noble DRM, and some historical formats.
+The DeDRM plugin handles books that use Amazon DRM, Adobe Digital Editions DRM, Barnes & Noble DRM, and some historical formats.
 The Obok plugin handles Kobo DRM.
 
-Users with calibre 5.x or later should use release 7.0.0b2 or later of the tools.
-Users with calibe 4.x or earlier should use release 6.8.0 of the tools.
-
-Developers might be interested in forking the repository, as it contains unzipped versions of those tools that are zipped to make the changes over time easier to follow.
+Users with calibre 5.x or later should use release 7.2.0 or later of the tools.
+Users with calibe 4.x or earlier should use release 6.8.x of the tools.
 
 For the latest Amazon KFX format, users of the calibre plugin should also install the KFX Input plugin from the standard calibre plugin menu. It's also available from the MobileRead thread here: https://www.mobileread.com/forums/showthread.php?t=291290
 
-Note that DRM can only be removed from KFX format files downloaded with Kindle for PC/Mac 1.26 or earlier. Amazon changes the DRM for KFX files in Kindle for PC/Mac 1.27 and later.
+Note that Amazon changes the DRM for KFX files frequently. What works for KFX today might not work tomorrow.
 
 I welcome contributions from others to improve these tools, from expanding the range of books handled, improving key retrieval,  to just general bug fixes, speed improvements and UI enhancements.
 
-I urge people to read the FAQs. But to cover the most common: Use ADE 2.0.1 to be sure not to get the new DRM scheme that these tools can't handle. Do remember to unzip the downloaded archive to get the plugin (beta versions may be just the plugin  don't unzip that). You can't load the whole tools archive into calibre.
+I urge people to read the FAQs. But to cover the most common: Do remember to unzip the downloaded archive to get the plugin (beta versions may be just the plugin  don't unzip that). You can't load the whole tools archive into calibre.
 
 My special thanks to all those developers who have done the hard work of reverse engineering to provide the initial tools.
 

ReadMe_Overview.txt

@@ -1,32 +1,33 @@
 Welcome to the tools!
 =====================
 
-This file is to give users a quick overview of what is available and how to get started. This document is part of the DeDRM Tools archive from Apprentice Harper's github repository: https://github.com/apprenticeharper/DeDRM_tools/
+This file is to give users a quick overview of what is available and how to get started. This document is part of the DeDRM Tools archive from noDRM's github repository: https://github.com/noDRM/DeDRM_tools/
 
 This archive includes calibre plugins to remove DRM from:
 
  - Kindle ebooks (files from Kindle for Mac/PC and eInk Kindles).
- - Adobe Digital Editions (v2.0.1***) ePubs (including Kobo and Google ePubs downloaded to ADE)
- - Adobe Digital Editions (v2.0.1) PDFs
+ - Adobe Digital Editions ePubs (including Kobo and Google ePubs downloaded to ADE)
+ - Adobe Digital Editions PDFs
  - Kobo kePubs from the Kobo Desktop application and attached Kobo readers.
 
 These tools do NOT work with Apple's iBooks FairPlay DRM. Use iBook Copy from TunesKit.
 These tools no longer work well with books from Barnes & Noble.
+Due to a DMCA request, these tools no longer work with LCP-encrypted books - see https://github.com/noDRM/DeDRM_tools/issues/18 for details.
 
-For limitations and work-arounds, see the FAQ at https://github.com/apprenticeharper/DeDRM_tools/blob/master/FAQs.md
+For limitations and work-arounds, see the FAQ at https://github.com/noDRM/DeDRM_tools/blob/master/FAQs.md
 
 About the tools
 ---------------
-These tools are updated and maintained by Apprentice Harper and many others. You can find the latest updates at Apprentice Harper's github repository https://github.com/apprenticeharper/DeDRM_tools/ and get support by creating an issue at the repository (github account required) or by posting a comment at Apprentice Alf's blog: http://www.apprenticealf.wordpress.com/
+These tools are updated and maintained by noDRM and many others. They are based on Apprentice Harper's Calibre plugin. You can find the latest updates at noDRM's github repository https://github.com/noDRM/DeDRM_tools/ and get support by creating an issue at the repository (github account required).
 
-If you re-post these tools, a link to the repository and/or the blog would be appreciated.
+If you re-post these tools, a link to the repository would be appreciated.
 
 The tools are provided in the form of plugins for calibre. Calibre is an open source freeware ebook library manager. It is the best tool around for keeping track of your ebooks.
 
 
-DeDRM plugin for calibre (Mac OS X, Windows)
+DeDRM plugin for calibre (Linux, Mac OS X and Windows)
 -------------------------------------------------------
-calibe 5.x and later are now written in Python 3, and plugins must also use Python 3. If you have calibre 5, you must use version 7.x or later of the plugins. For calibre 4.x and earlier, use version 6.8.0 of the plugins.
+calibe 5.x and later are now written in Python 3, and plugins must also use Python 3. 
 
 The DeDRM plugin for calibre removes DRM from your Kindle and Adobe DRM ebooks when they are imported to calibre. Just install the DeDRM plugin (DeDRM_plugin.zip), following the instructions and configuration directions provided in the ReadMe file and the help links in the plugin's configuration dialogs.
 
@@ -40,27 +41,17 @@ To import ebooks from the Kobo Desktop app or from a Kobo ebook reader, install
 For instructions, see the obok_plugin_ReadMe.txt file.
 
 
-DeDRM application for Mac OS X users: (Mac OS X 10.6 and above)
----------------------------------------------------------------
-DeDRM application for Windows users: (Windows XP through Windows 10)
-------------------------------------------------------------------
-As of Version 6.7 of the tools, these are no longer provided or supported.
-
-
-Linux support
--------------
-It may be possible to use the plugins on a Linux system, but no support is given at this time.
-
-
 Credits
 -------
 The original inept and ignoble scripts were by i♥cabbages
+~The original Readium LCP DRM removal by NoDRM~ (removed due to a DMCA request)
 The original mobidedrm and erdr2pml scripts were by The Dark Reverser
 The original topaz DRM removal script was by CMBDTC
 The original topaz format conversion scripts were by some_updates, clarknova and Bart Simpson
 The original KFX format decryption was by lulzkabulz, converted to python by Apprentice Naomi and integrated into the tools by tomthumb1997
 The alfcrypto library is by some_updates
-The DeDRM plugin was based on plugins by DiapDealer and is maintained by Apprentice Alf and Apprentice Harper
+The DeDRM plugin is based on plugins by DiapDealer and is currently maintained by noDRM
+The DeDRM plugin has been maintained by Apprentice Alf and Apprentice Harper until 2021.
 
 The original obok script was by Physisticated
 The plugin conversion was done anonymously.

make_release.py

@@ -14,19 +14,65 @@ import shutil
 
 
 DEDRM_SRC_DIR = 'DeDRM_plugin'
+DEDRM_SRC_TMP_DIR = 'DeDRM_plugin_temp'
 DEDRM_README= 'DeDRM_plugin_ReadMe.txt'
 OBOK_SRC_DIR = 'Obok_plugin'
 OBOK_README = 'obok_plugin_ReadMe.txt'
 RELEASE_DIR = 'release'
 
+def patch_file(filepath):
+    f = open(filepath, "rb")
+    fn = open(filepath + ".tmp", "wb")
+    patch = open(os.path.join(DEDRM_SRC_DIR, "__calibre_compat_code.py"), "rb")
+    patchdata = patch.read()
+    patch.close()
+
+    while True:
+        line = f.readline()
+        if len(line) == 0:
+            break
+
+        if line.strip().startswith(b"#@@CALIBRE_COMPAT_CODE@@"):
+            fn.write(patchdata)
+        else:
+            fn.write(line)
+
+    f.close()
+    fn.close()
+    shutil.move(filepath + ".tmp", filepath)
+
+
 
 def make_release(version):
     try:
         shutil.rmtree(RELEASE_DIR)
     except:
         pass
+    try:
+        shutil.rmtree(DEDRM_SRC_TMP_DIR)
+    except:
+        pass
+
     os.mkdir(RELEASE_DIR)
-    shutil.make_archive(DEDRM_SRC_DIR, 'zip', DEDRM_SRC_DIR)
+
+    # Copy folder 
+    shutil.copytree(DEDRM_SRC_DIR, DEDRM_SRC_TMP_DIR)
+
+    # Modify folder
+    try: 
+        shutil.rmtree(os.path.join(os.path.abspath(DEDRM_SRC_TMP_DIR), "__pycache__"))
+    except:
+        pass
+
+    # Patch file to add compat code.
+    for root, dirs, files in os.walk(DEDRM_SRC_TMP_DIR):
+        for name in files:
+            if name.endswith(".py"):
+                patch_file(os.path.join(root, name))
+
+
+    # Package
+    shutil.make_archive(DEDRM_SRC_DIR, 'zip', DEDRM_SRC_TMP_DIR)
     shutil.make_archive(OBOK_SRC_DIR, 'zip', OBOK_SRC_DIR)
     shutil.move(DEDRM_SRC_DIR+'.zip', RELEASE_DIR)
     shutil.move(OBOK_SRC_DIR+'.zip', RELEASE_DIR)
@@ -34,7 +80,13 @@ def make_release(version):
     shutil.copy(OBOK_README, RELEASE_DIR)
     shutil.copy("ReadMe_Overview.txt", RELEASE_DIR)
 
-    release_name = 'DeDRM_tools_{}'.format(version)
+    # Remove temp folder:
+    shutil.rmtree(DEDRM_SRC_TMP_DIR)
+
+    if version is not None:
+        release_name = 'DeDRM_tools_{}'.format(version)
+    else:
+        release_name = 'DeDRM_tools'
     result = shutil.make_archive(release_name, 'zip', RELEASE_DIR)
     try:
         shutil.rmtree(RELEASE_DIR)
@@ -48,6 +100,6 @@ if __name__ == '__main__':
     try:
         version = sys.argv[1]
     except IndexError:
-        raise SystemExit('Usage: {} version'.format(__file__))
+        version = None
 
     print(make_release(version))