tools v6.0.2

2013-04-05 17:44:48 +01:00
parent a2f044e672
commit d586f74faa
72 changed files with 12418 additions and 13112 deletions
--- a/DeDRM_Windows_Application/DeDRM_App/DeDRM_Drop_Target.bat
+++ b/DeDRM_Windows_Application/DeDRM_App/DeDRM_Drop_Target.bat
@@ -1 +1 @@
-chcp 65001 > nul && set PWD=%~dp0 && cd /d %~dp0DeDRM_lib && start /min python DeDRM_App.pyw %*
+chcp 65001 > nul && set PWD="%~dp0" && cd /d "%~dp0DeDRM_lib" && start /min python DeDRM_App.pyw %*
--- a/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/DeDRM_app.pyw
+++ b/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/DeDRM_app.pyw
@@ -7,8 +7,9 @@
 # Revision history:
 #   6.0.0 - Release along with unified plugin
 #   6.0.1 - Bug Fixes for Windows App
+#   6.0.2 - Changes only in the plugin so far

-__version__ = '6.0.1'
+__version__ = '6.0.2'

 import sys
 import os, os.path
--- a/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/DeDRM_Adobe
+++ b/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/DeDRM_Adobe
@@ -44,11 +44,16 @@ 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 computer’s hard-drive. Use this button to export the highlighted key to a file (with a ‘.der’ 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>Linux Users: WINEPREFIX</h3>
+
+<p>Under the list of keys, Linux users will see a text field labeled "WINEPREFIX". If you are use Adobe Digital Editions under Wine, and your wine installation containing Adobe Digital Editions isn't the default Wine installation, you may enter the full path to the correct Wine installation here. Leave blank if you are unsure.</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 ‘.der’ key files. Key files might come from being exported from this or older plugins, or may have been generated using the adobekey.pyw script running under Wine on Linux systems.</p>

-<p>Once done creating/deleting/renaming/importing decryption keys, 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/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>

--- a/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/DeDRM_Kindle
+++ b/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/DeDRM_Kindle
@@ -44,6 +44,10 @@ 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 computer’s hard-drive. Use this button to export the highlighted key to a file (with a ‘.der’ 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>Linux Users: WINEPREFIX</h3>
+
+<p>Under the list of keys, Linux users will see a text field labeled "WINEPREFIX". If you are use Kindle for PC under Wine, and your wine installation containing Kindle for PC isn't the default Wine installation, you may enter the full path to the correct Wine installation here. Leave blank if you are unsure.</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 ‘.k4i’ key files. Key files might come from being exported from this plugin, or may have been generated using the kindlekey.pyw script running under Wine on Linux systems.</p>
--- a/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/init.py
+++ b/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/init.py
@@ -26,14 +26,15 @@ __docformat__ = 'restructuredtext en'
 #
 # Revision history:
 #   6.0.0 - Initial release
-#   6.0.1 - Bug Fixes for Windows App
+#   6.0.1 - Bug Fixes for Windows App, Kindle for Mac and Windows Adobe Digital Editions
+#   6.0.2 - Restored call to Wine to get Kindle for PC keys

 """
 Decrypt DRMed ebooks.
 """

 PLUGIN_NAME = u"DeDRM"
-PLUGIN_VERSION_TUPLE = (6, 0, 1)
+PLUGIN_VERSION_TUPLE = (6, 0, 2)
 PLUGIN_VERSION = u".".join([unicode(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'
@@ -83,9 +84,11 @@ class DeDRM(FileTypePlugin):

    def initialize(self):
        # convert old preferences, if necessary.
-        import calibre_plugins.dedrm.config
-
-        config.convertprefs()
+        try:
+            from calibre_plugins.dedrm.prefs import convertprefs
+            convertprefs()
+        except:
+            traceback.print_exc()

        """
        Dynamic modules can't be imported/loaded from a zipfile... so this routine
@@ -101,7 +104,7 @@ class DeDRM(FileTypePlugin):
            elif isosx:
                names = [u"libalfcrypto.dylib"]
            else:
-                names = [u"libalfcrypto32.so",u"libalfcrypto64.so"]
+                names = [u"libalfcrypto32.so",u"libalfcrypto64.so",u"kindlekey.py",u"adobekey.py",u"subasyncio.py"]
            lib_dict = self.load_resources(names)
            self.pluginsdir = os.path.join(config_dir,u"plugins")
            if not os.path.exists(self.pluginsdir):
@@ -112,7 +115,7 @@ class DeDRM(FileTypePlugin):
            self.helpdir = os.path.join(self.maindir,u"help")
            if not os.path.exists(self.helpdir):
                os.mkdir(self.helpdir)
-            self.alfdir = os.path.join(self.maindir,u"alfcrypto")
+            self.alfdir = os.path.join(self.maindir,u"libraryfiles")
            if not os.path.exists(self.alfdir):
                os.mkdir(self.alfdir)
            for entry, data in lib_dict.items():
@@ -129,25 +132,27 @@ class DeDRM(FileTypePlugin):

        inf = self.temporary_file(u".epub")
        try:
-            print u"{0} v{1}: Verifying zip archive integrity.".format(PLUGIN_NAME, PLUGIN_VERSION)
+            print u"{0} v{1}: Verifying zip archive integrity".format(PLUGIN_NAME, PLUGIN_VERSION)
            fr = zipfix.fixZip(path_to_ebook, inf.name)
            fr.fix()
        except Exception, e:
-            print u"{0} v{1}: Error \'{2}\' when checking zip archive.".format(PLUGIN_NAME, PLUGIN_VERSION, e.args[0])
+            print u"{0} v{1}: Error \'{2}\' when checking zip archive".format(PLUGIN_NAME, PLUGIN_VERSION, e.args[0])
            raise Exception(e)

        # import the decryption keys
-        import calibre_plugins.dedrm.config as config
+        import calibre_plugins.dedrm.prefs as prefs
+        dedrmprefs = prefs.DeDRM_Prefs()

        # import the Barnes & Noble ePub handler
        import calibre_plugins.dedrm.ignobleepub as ignobleepub

+
        #check the book
        if  ignobleepub.ignobleBook(inf.name):
-            print u"{0} v{1}: “{2}” is a secure Barnes & Noble ePub.".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook))
+            print u"{0} v{1}: “{2}” is a secure Barnes & Noble ePub".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook))

            # Attempt to decrypt epub with each encryption key (generated or provided).
-            for keyname, userkey in config.dedrmprefs['bandnkeys'].items():
+            for keyname, userkey in dedrmprefs['bandnkeys'].items():
                keyname_masked = u"".join((u'X' if (x.isdigit()) else x) for x in keyname)
                print u"{0} v{1}: Trying Encryption key {2:s}".format(PLUGIN_NAME, PLUGIN_VERSION, keyname_masked)
                of = self.temporary_file(u".epub")
@@ -162,7 +167,7 @@ class DeDRM(FileTypePlugin):
                    # Return the modified PersistentTemporary file to calibre.
                    return of.name

-                print u"{0} v{1}: Failed to decrypt with key {2:s} after {3:.1f} seconds.".format(PLUGIN_NAME, PLUGIN_VERSION,keyname_masked,time.time()-self.starttime)
+                print u"{0} v{1}: Failed to decrypt with key {2:s} after {3:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,keyname_masked,time.time()-self.starttime)

            print u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
            raise DeDRMError(u"{0} v{1}: Ultimately failed to decrypt “{2}” after {3:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook),time.time()-self.starttime))
@@ -171,10 +176,10 @@ class DeDRM(FileTypePlugin):
        import calibre_plugins.dedrm.ineptepub as ineptepub

        if ineptepub.adeptBook(inf.name):
-            print u"{0} v{1}: {2} is a secure Adobe Adept ePub.".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook))
+            print u"{0} v{1}: {2} is a secure Adobe Adept ePub".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook))

            # Attempt to decrypt epub with each encryption key (generated or provided).
-            for keyname, userkeyhex in config.dedrmprefs['adeptkeys'].items():
+            for keyname, userkeyhex in dedrmprefs['adeptkeys'].items():
                userkey = userkeyhex.decode('hex')
                print u"{0} v{1}: Trying Encryption key {2:s}".format(PLUGIN_NAME, PLUGIN_VERSION, keyname)
                of = self.temporary_file(u".epub")
@@ -192,54 +197,64 @@ class DeDRM(FileTypePlugin):
                    # Return the modified PersistentTemporary file to calibre.
                    return of.name

-                print u"{0} v{1}: Failed to decrypt with key {2:s} after {3:.1f} seconds.".format(PLUGIN_NAME, PLUGIN_VERSION,keyname,time.time()-self.starttime)
+                print u"{0} v{1}: Failed to decrypt with key {2:s} after {3:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,keyname,time.time()-self.starttime)

            # perhaps we need to get a new default ADE key
-            if iswindows or isosx:
-                print u"{0} v{1}: Looking for new default Adobe Digital Editions Keys".format(PLUGIN_NAME, PLUGIN_VERSION)
+            print u"{0} v{1}: Looking for new default Adobe Digital Editions Keys after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)

-                # get the default Adobe keys
-                import calibre_plugins.dedrm.adobekey as adobe
+            # get the default Adobe keys
+            defaultkeys = []

+            try:
+                if iswindows or isosx:
+                    from calibre_plugins.dedrm.adobekey import adeptkeys
+
+                    defaultkeys = adeptkeys()
+                else: # linux
+                    from wineutils import WineGetKeys
+
+                    scriptpath = os.join(self.alfdir,u"adobekey.py")
+                    defaultkeys = WineGetKeys(scriptpath, u".der",dedrmprefs['adobewineprefix'])
+
+                self.default_key = default_keys[0]
+            except:
+                traceback.print_exc()
+                self.default_key = u""
+
+            newkeys = []
+            for keyvalue in defaultkeys:
+                if keyvalue.encode('hex') not in dedrmprefs['adeptkeys'].values():
+                    newkeys.append(keyvalue)
+
+            if len(newkeys) > 0:
                try:
-                    defaultkeys = adobe.adeptkeys()
-                except:
-                    defaultkeys = []
+                    for i,userkey in enumerate(newkeys):
+                        print u"{0} v{1}: Trying a new default key".format(PLUGIN_NAME, PLUGIN_VERSION)
+                        of = self.temporary_file(u".epub")

-                newkeys = []
-                for keyvalue in defaultkeys:
-                    if keyvalue.encode('hex') not in config.dedrmprefs['adeptkeys'].values():
-                        newkeys.append(keyvalue)
+                        # Give the user key, ebook and TemporaryPersistent file to the decryption function.
+                        try:
+                            result = ineptepub.decryptBook(userkey, inf.name, of.name)
+                        except:
+                            result = 1

-                if len(newkeys) > 0:
-                    try:
-                        for i,userkey in enumerate(newkeys):
-                            print u"{0} v{1}: Trying a new default key.".format(PLUGIN_NAME, PLUGIN_VERSION)
-                            of = self.temporary_file(u".epub")
+                        of.close()

-                            # Give the user key, ebook and TemporaryPersistent file to the decryption function.
+                        if  result == 0:
+                            # Decryption was a success
+                            # Store the new successful key in the defaults
+                            print u"{0} v{1}: Saving a new default key".format(PLUGIN_NAME, PLUGIN_VERSION)
                            try:
-                                result = ineptepub.decryptBook(userkey, inf.name, of.name)
+                                dedrmprefs.addnamedvaluetoprefs('adeptkeys','default_key',keyvalue.encode('hex'))
+                                dedrmprefs.writeprefs()
                            except:
-                                result = 1
+                                traceback.print_exc()
+                            # Return the modified PersistentTemporary file to calibre.
+                            return of.name

-                            of.close()
-
-                            if  result == 0:
-                                # Decryption was a success
-                                # Store the new successful key in the defaults
-                                print u"{0} v{1}: Saving a new default key.".format(PLUGIN_NAME, PLUGIN_VERSION)
-                                try:
-                                    config.addnamedvaluetoprefs('adeptkeys','default_key',keyvalue.encode('hex'))
-                                    config.writeprefs()
-                                except:
-                                    traceback.print_exc()
-                                # Return the modified PersistentTemporary file to calibre.
-                                return of.name
-
-                            print u"{0} v{1}: Failed to decrypt with new default key after {2:.1f} seconds.".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
-                    except Exception, e:
-                        pass
+                        print u"{0} v{1}: Failed to decrypt with new default key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
+                except Exception, e:
+                    pass

            # Something went wrong with decryption.
            print u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
@@ -247,16 +262,17 @@ class DeDRM(FileTypePlugin):

        # Not a Barnes & Noble nor an Adobe Adept
        # Import the fixed epub.
-        print u"{0} v{1}: “{2}” is neither an Adobe Adept nor a Barnes & Noble encrypted ePub.".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook))
+        print u"{0} v{1}: “{2}” is neither an Adobe Adept nor a Barnes & Noble encrypted ePub".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook))
        return inf.name

    def PDFDecrypt(self,path_to_ebook):
-        import calibre_plugins.dedrm.config as config
+        import calibre_plugins.dedrm.prefs as prefs
        import calibre_plugins.dedrm.ineptpdf

+        dedrmprefs = prefs.DeDRM_Prefs()
        # Attempt to decrypt epub with each encryption key (generated or provided).
-        print u"{0} v{1}: {2} is a PDF ebook.".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook))
-        for keyname, userkeyhex in config.dedrmprefs['adeptkeys'].items():
+        print u"{0} v{1}: {2} is a PDF ebook".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook))
+        for keyname, userkeyhex in dedrmprefs['adeptkeys'].items():
            userkey = userkeyhex.decode('hex')
            print u"{0} v{1}: Trying Encryption key {2:s}".format(PLUGIN_NAME, PLUGIN_VERSION, keyname)
            of = self.temporary_file(u".pdf")
@@ -275,56 +291,68 @@ class DeDRM(FileTypePlugin):
                return of.name

            # perhaps we need to get a new default ADE key
-            if iswindows or isosx:
-                print u"{0} v{1}: Looking for new default Adobe Digital Editions Keys".format(PLUGIN_NAME, PLUGIN_VERSION)
+            print u"{0} v{1}: Looking for new default Adobe Digital Editions Keys after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)

-                # get the default Adobe keys
+            # get the default Adobe keys
+            defaultkeys = []
+
+            if iswindows or isosx:
                import calibre_plugins.dedrm.adobekey as adobe

                try:
                    defaultkeys = adobe.adeptkeys()
                except:
-                    defaultkeys = []
+                    pass
+            else:
+                # linux
+                try:
+                    from wineutils import WineGetKeys

-                newkeys = []
-                for keyvalue in defaultkeys:
-                    if keyvalue.encode('hex') not in config.dedrmprefs['adeptkeys'].values():
-                        newkeys.append(keyvalue)
+                    scriptpath = os.join(self.alfdir,u"adobekey.py")
+                    defaultkeys = self.WineGetKeys(scriptpath, u".der",dedrmprefs['adobewineprefix'])
+                except:
+                    pass

-                if len(newkeys) > 0:
-                    try:
-                        for i,userkey in enumerate(newkeys):
-                            print u"{0} v{1}: Trying a new default key.".format(PLUGIN_NAME, PLUGIN_VERSION)
-                            of = self.temporary_file(u".pdf")
+            newkeys = []
+            for keyvalue in defaultkeys:
+                if keyvalue.encode('hex') not in dedrmprefs['adeptkeys'].values():
+                    newkeys.append(keyvalue)

-                            # Give the user key, ebook and TemporaryPersistent file to the decryption function.
+            if len(newkeys) > 0:
+                try:
+                    for i,userkey in enumerate(newkeys):
+                        print u"{0} v{1}: Trying a new default key".format(PLUGIN_NAME, PLUGIN_VERSION)
+                        of = self.temporary_file(u".pdf")
+
+                        # Give the user key, ebook and TemporaryPersistent file to the decryption function.
+                        try:
+                            result = ineptepdf.decryptBook(userkey, inf.name, of.name)
+                        except:
+                            result = 1
+
+                        of.close()
+
+                        if  result == 0:
+                            # Decryption was a success
+                            # Store the new successful key in the defaults
+                            print u"{0} v{1}: Saving a new default key".format(PLUGIN_NAME, PLUGIN_VERSION)
                            try:
-                                result = ineptepdf.decryptBook(userkey, inf.name, of.name)
+                                dedrmprefs.addnamedvaluetoprefs('adeptkeys','default_key',keyvalue.encode('hex'))
+                                dedrmprefs.writeprefs()
                            except:
-                                result = 1
+                                traceback.print_exc()
+                            # Return the modified PersistentTemporary file to calibre.
+                            return of.name

-                            of.close()
-
-                            if  result == 0:
-                                # Decryption was a success
-                                # Store the new successful key in the defaults
-                                print u"{0} v{1}: Saving a new default key.".format(PLUGIN_NAME, PLUGIN_VERSION)
-                                try:
-                                    config.addnamedvaluetoprefs('adeptkeys','default_key',keyvalue.encode('hex'))
-                                    config.writeprefs()
-                                except:
-                                    traceback.print_exc()
-                                # Return the modified PersistentTemporary file to calibre.
-                                return of.name
-
-                            print u"{0} v{1}: Failed to decrypt with new default key after {2:.1f} seconds.".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
-                    except Exception, e:
-                        pass
+                        print u"{0} v{1}: Failed to decrypt with new default key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
+                except Exception, e:
+                    pass

        # Something went wrong with decryption.
        print u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
        raise DeDRMError(u"{0} v{1}: Ultimately failed to decrypt “{2}” after {3:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook),time.time()-self.starttime))

+
    def KindleMobiDecrypt(self,path_to_ebook):

        # add the alfcrypto directory to sys.path so alfcrypto.py
@@ -333,42 +361,53 @@ class DeDRM(FileTypePlugin):
        # Had to move this import here so the custom libs can be
        # extracted to the appropriate places beforehand these routines
        # look for them.
-        import calibre_plugins.dedrm.config as config
+        import calibre_plugins.dedrm.prefs as prefs
        import calibre_plugins.dedrm.k4mobidedrm

-        pids = config.dedrmprefs['pids']
-        serials = config.dedrmprefs['serials']
-        kindleDatabases = config.dedrmprefs['kindlekeys'].items()
+        dedrmprefs = prefs.DeDRM_Prefs()
+        pids = dedrmprefs['pids']
+        serials = dedrmprefs['serials']
+        kindleDatabases = dedrmprefs['kindlekeys'].items()

        try:
            book = k4mobidedrm.GetDecryptedBook(path_to_ebook,kindleDatabases,serials,pids,self.starttime)
        except Exception, e:
            decoded = False
            # perhaps we need to get a new default Kindle for Mac/PC key
-            if iswindows or isosx:
-                print u"{0} v{1}: Failed to decrypt with error: {2}".format(PLUGIN_NAME, PLUGIN_VERSION,e.args[0])
-                print u"{0} v{1}: Looking for new default Kindle Key".format(PLUGIN_NAME, PLUGIN_VERSION)
-                import calibre_plugins.dedrm.kindlekey as amazon
+            defaultkeys = []
+            print u"{0} v{1}: Failed to decrypt with error: {2}".format(PLUGIN_NAME, PLUGIN_VERSION,e.args[0])
+            print u"{0} v{1}: Looking for new default Kindle Key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)

+            try:
+                if iswindows or isosx:
+                    from calibre_plugins.dedrm.kindlekey import kindlekeys
+
+                    defaultkeys = kindlekeys()
+                else: # linux
+                    from wineutils import WineGetKeys
+
+                    scriptpath = os.join(self.alfdir,u"kindlekey.py")
+                    defaultkeys = self.WineGetKeys(scriptpath, u".k4i",dedrmprefs['kindlewineprefix'])
+            except:
+                pass
+
+            newkeys = {}
+            for i,keyvalue in enumerate(defaultkeys):
+                keyname = u"default_key_{0:d}".format(i+1)
+                if keyvalue not in dedrmprefs['kindlekeys'].values():
+                    newkeys[keyname] = keyvalue
+            if len(newkeys) > 0:
+                print u"{0} v{1}: Found {2} new {3}".format(PLUGIN_NAME, PLUGIN_VERSION, len(newkeys), u"key" if len(newkeys)==1 else u"keys")
                try:
-                    defaultkeys = amazon.kindlekeys()
-                except:
-                    defaultkeys = []
-                newkeys = {}
-                for i,keyvalue in enumerate(defaultkeys):
-                    keyname = u"default_key_{0:d}".format(i+1)
-                    if keyvalue not in config.dedrmprefs['kindlekeys'].values():
-                        newkeys[keyname] = keyvalue
-                if len(newkeys) > 0:
-                    try:
-                        book = k4mobidedrm.GetDecryptedBook(path_to_ebook,newkeys.items(),[],[],self.starttime)
-                        decoded = True
-                        # store the new successful keys in the defaults
-                        for keyvalue in newkeys.values():
-                            config.addnamedvaluetoprefs('kindlekeys','default_key',keyvalue)
-                        config.writeprefs()
-                    except Exception, e:
-                        pass
+                    book = k4mobidedrm.GetDecryptedBook(path_to_ebook,newkeys.items(),[],[],self.starttime)
+                    decoded = True
+                    # store the new successful keys in the defaults
+                    print u"{0} v{1}: Saving {2} new {3}".format(PLUGIN_NAME, PLUGIN_VERSION, len(newkeys), u"key" if len(newkeys)==1 else u"keys")
+                    for keyvalue in newkeys.values():
+                        dedrmprefs.addnamedvaluetoprefs('kindlekeys','default_key',keyvalue)
+                    dedrmprefs.writeprefs()
+                except Exception, e:
+                    pass
            if not decoded:
                #if you reached here then no luck raise and exception
                print u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
@@ -384,11 +423,12 @@ class DeDRM(FileTypePlugin):

    def eReaderDecrypt(self,path_to_ebook):

-        import calibre_plugins.dedrm.config as config
+        import calibre_plugins.dedrm.prefs as prefs
        import calibre_plugins.dedrm.erdr2pml

+        dedrmrefs = prefs.DeDRM_Prefs()
        # Attempt to decrypt epub with each encryption key (generated or provided).
-        for keyname, userkey in config.dedrmprefs['ereaderkeys'].items():
+        for keyname, userkey in dedrmprefs['ereaderkeys'].items():
            keyname_masked = u"".join((u'X' if (x.isdigit()) else x) for x in keyname)
            print u"{0} v{1}: Trying Encryption key {2:s}".format(PLUGIN_NAME, PLUGIN_VERSION, keyname_masked)
            of = self.temporary_file(u".pmlz")
@@ -403,7 +443,7 @@ class DeDRM(FileTypePlugin):
            if  result == 0:
                return of.name

-            print u"{0} v{1}: Failed to decrypt with key {2:s} after {3:.1f} seconds.".format(PLUGIN_NAME, PLUGIN_VERSION,keyname_masked,time.time()-self.starttime)
+            print u"{0} v{1}: Failed to decrypt with key {2:s} after {3:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,keyname_masked,time.time()-self.starttime)

        print u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
        raise DeDRMError(u"{0} v{1}: Ultimately failed to decrypt “{2}” after {3:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook),time.time()-self.starttime))
@@ -415,7 +455,7 @@ class DeDRM(FileTypePlugin):
        sys.stdout=SafeUnbuffered(sys.stdout)
        sys.stderr=SafeUnbuffered(sys.stderr)

-        print u"{0} v{1}: Trying to decrypt {2}.".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook))
+        print u"{0} v{1}: Trying to decrypt {2}".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook))
        self.starttime = time.time()

        booktype = os.path.splitext(path_to_ebook)[1].lower()[1:]
@@ -434,7 +474,7 @@ class DeDRM(FileTypePlugin):
            # Adobe Adept or B&N ePub
            decrypted_ebook = self.ePubDecrypt(path_to_ebook)
        else:
-            print u"Unknown booktype {0}. Passing back to calibre unchanged.".format(booktype)
+            print u"Unknown booktype {0}. Passing back to calibre unchanged".format(booktype)
            return path_to_ebook
        print u"{0} v{1}: Successfully decrypted book after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
        return decrypted_ebook
@@ -445,7 +485,7 @@ class DeDRM(FileTypePlugin):

    def config_widget(self):
        import calibre_plugins.dedrm.config as config
-        return config.ConfigWidget(self.plugin_path)
+        return config.ConfigWidget(self.plugin_path, self.alfdir)

    def save_settings(self, config_widget):
        config_widget.save_settings()
--- a/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/adobekey.py
+++ b/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/adobekey.py
@@ -47,13 +47,14 @@ from __future__ import with_statement
 #   5.7 - Unicode support added, renamed adobekey from ineptkey
 #   5.8 - Added getkey interface for Windows DeDRM application
 #   5.9 - moved unicode_argv call inside main for Windows DeDRM compatibility
+#   6.0 - Work if TkInter is missing

 """
 Retrieve Adobe ADEPT user key.
 """

 __license__ = 'GPL v3'
-__version__ = '5.9'
+__version__ = '6.0'

 import sys, os, struct, getopt

@@ -402,9 +403,11 @@ if iswindows:
                aes = AES(keykey)
                userkey = aes.decrypt(userkey)
                userkey = userkey[26:-ord(userkey[-1])]
+                #print "found key:",userkey.encode('hex')
                keys.append(userkey)
        if len(keys) == 0:
            raise ADEPTError('Could not locate privateLicenseKey')
+        print u"Found {0:d} keys".format(len(keys))
        return keys


@@ -485,6 +488,8 @@ def usage(progname):
    print u"    {0:s} [-h] [<outpath>]".format(progname)

 def cli_main():
+    sys.stdout=SafeUnbuffered(sys.stdout)
+    sys.stderr=SafeUnbuffered(sys.stderr)
    argv=unicode_argv()
    progname = os.path.basename(argv[0])
    print u"{0} v{1}\nCopyright © 2009-2013 i♥cabbages and Apprentice Alf".format(progname,__version__)
@@ -541,10 +546,13 @@ def cli_main():


 def gui_main():
-    import Tkinter
-    import Tkconstants
-    import tkMessageBox
-    import traceback
+    try:
+        import Tkinter
+        import Tkconstants
+        import tkMessageBox
+        import traceback
+    except:
+        return cli_main()

    class ExceptionDialog(Tkinter.Frame):
        def __init__(self, root, text):
@@ -577,7 +585,7 @@ def gui_main():
                keyfileout.write(key)
            success = True
            tkMessageBox.showinfo(progname, u"Key successfully retrieved to {0}".format(outfile))
-    except DrmException, e:
+    except ADEPTError, e:
        tkMessageBox.showerror(progname, u"Error: {0}".format(str(e)))
    except Exception:
        root.wm_state('normal')
@@ -591,7 +599,5 @@ def gui_main():

 if __name__ == '__main__':
    if len(sys.argv) > 1:
-        sys.stdout=SafeUnbuffered(sys.stdout)
-        sys.stderr=SafeUnbuffered(sys.stderr)
        sys.exit(cli_main())
    sys.exit(gui_main())
--- a/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/config.py
+++ b/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/config.py
--- a/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/ignobleepub.py
+++ b/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/ignobleepub.py
@@ -34,13 +34,14 @@ from __future__ import with_statement
 #   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

 """
 Decrypt Barnes & Noble encrypted ePub books.
 """

 __license__ = 'GPL v3'
-__version__ = "3.9"
+__version__ = "4.0"

 import sys
 import os
@@ -318,6 +319,8 @@ def decryptBook(keyb64, inpath, outpath):


 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:
@@ -331,10 +334,13 @@ def cli_main():
    return result

 def gui_main():
-    import Tkinter
-    import Tkconstants
-    import tkFileDialog
-    import traceback
+    try:
+        import Tkinter
+        import Tkconstants
+        import tkMessageBox
+        import traceback
+    except:
+        return cli_main()

    class DecryptionDialog(Tkinter.Frame):
        def __init__(self, root):
@@ -442,7 +448,5 @@ def gui_main():

 if __name__ == '__main__':
    if len(sys.argv) > 1:
-        sys.stdout=SafeUnbuffered(sys.stdout)
-        sys.stderr=SafeUnbuffered(sys.stderr)
        sys.exit(cli_main())
    sys.exit(gui_main())
--- a/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/ignoblekeygen.py
+++ b/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/ignoblekeygen.py
@@ -32,13 +32,14 @@ from __future__ import with_statement
 #   2.4 - Improvements to UI and now works in plugins
 #   2.5 - Additional improvement for unicode and plugin support
 #   2.6 - moved unicode_argv call inside main for Windows DeDRM compatibility
+#   2.7 - Work if TkInter is missing

 """
 Generate Barnes & Noble EPUB user key from name and credit card number.
 """

 __license__ = 'GPL v3'
-__version__ = "2.6"
+__version__ = "2.7"

 import sys
 import os
@@ -216,6 +217,8 @@ def generate_key(name, ccn):


 def cli_main():
+    sys.stdout=SafeUnbuffered(sys.stdout)
+    sys.stderr=SafeUnbuffered(sys.stderr)
    argv=unicode_argv()
    progname = os.path.basename(argv[0])
    if AES is None:
@@ -233,10 +236,13 @@ def cli_main():


 def gui_main():
-    import Tkinter
-    import Tkconstants
-    import tkFileDialog
-    import tkMessageBox
+    try:
+        import Tkinter
+        import Tkconstants
+        import tkMessageBox
+        import traceback
+    except:
+        return cli_main()

    class DecryptionDialog(Tkinter.Frame):
        def __init__(self, root):
@@ -320,7 +326,5 @@ def gui_main():

 if __name__ == '__main__':
    if len(sys.argv) > 1:
-        sys.stdout=SafeUnbuffered(sys.stdout)
-        sys.stderr=SafeUnbuffered(sys.stderr)
        sys.exit(cli_main())
    sys.exit(gui_main())
--- a/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/ineptepub.py
+++ b/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/ineptepub.py
@@ -35,14 +35,15 @@ from __future__ import with_statement
 #   5.7 - Fix for potential problem with PyCrypto
 #   5.8 - Revised to allow use in calibre plugins to eliminate need for duplicate code
 #   5.9 - Fixed to retain zip file metadata (e.g. file modification date)
-#   5.10 - moved unicode_argv call inside main for Windows DeDRM compatibility
+#   6.0 - moved unicode_argv call inside main for Windows DeDRM compatibility
+#   6.1 - Work if TkInter is missing

 """
 Decrypt Adobe Digital Editions encrypted ePub books.
 """

 __license__ = 'GPL v3'
-__version__ = "5.10"
+__version__ = "6.1"

 import sys
 import os
@@ -460,6 +461,8 @@ def decryptBook(userkey, inpath, outpath):


 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:
@@ -473,10 +476,13 @@ def cli_main():
    return result

 def gui_main():
-    import Tkinter
-    import Tkconstants
-    import tkFileDialog
-    import traceback
+    try:
+        import Tkinter
+        import Tkconstants
+        import tkMessageBox
+        import traceback
+    except:
+        return cli_main()

    class DecryptionDialog(Tkinter.Frame):
        def __init__(self, root):
@@ -584,7 +590,5 @@ def gui_main():

 if __name__ == '__main__':
    if len(sys.argv) > 1:
-        sys.stdout=SafeUnbuffered(sys.stdout)
-        sys.stderr=SafeUnbuffered(sys.stderr)
        sys.exit(cli_main())
    sys.exit(gui_main())
--- a/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/ineptpdf.py
+++ b/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/ineptpdf.py
@@ -51,13 +51,14 @@ from __future__ import with_statement
 #   7.12 - Revised to allow use in calibre plugins to eliminate need for duplicate code
 #   7.13 - Fixed erroneous mentions of ineptepub
 #   7.14 - moved unicode_argv call inside main for Windows DeDRM compatibility
+#   8.0 - Work if TkInter is missing

 """
 Decrypts Adobe ADEPT-encrypted PDF files.
 """

 __license__ = 'GPL v3'
-__version__ = "7.14"
+__version__ = "8.0"

 import sys
 import os
@@ -2187,6 +2188,8 @@ def decryptBook(userkey, inpath, outpath):


 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:
@@ -2201,10 +2204,13 @@ def cli_main():


 def gui_main():
-    import Tkinter
-    import Tkconstants
-    import tkFileDialog
-    import tkMessageBox
+    try:
+        import Tkinter
+        import Tkconstants
+        import tkMessageBox
+        import traceback
+    except:
+        return cli_main()

    class DecryptionDialog(Tkinter.Frame):
        def __init__(self, root):
@@ -2321,7 +2327,5 @@ def gui_main():

 if __name__ == '__main__':
    if len(sys.argv) > 1:
-        sys.stdout=SafeUnbuffered(sys.stdout)
-        sys.stderr=SafeUnbuffered(sys.stderr)
        sys.exit(cli_main())
    sys.exit(gui_main())
--- a/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/kindlekey.py
+++ b/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/kindlekey.py
@@ -17,6 +17,7 @@ from __future__ import with_statement
 #  1.4   - Remove dependency on alfcrypto
 #  1.5   - moved unicode_argv call inside main for Windows DeDRM compatibility
 #  1.6   - Fixed a problem getting the disk serial numbers
+#  1.7   - Work if TkInter is missing


 """
@@ -24,7 +25,7 @@ Retrieve Kindle for PC/Mac user key.
 """

 __license__ = 'GPL v3'
-__version__ = '1.6'
+__version__ = '1.7'

 import sys, os, re
 from struct import pack, unpack, unpack_from
@@ -1804,6 +1805,8 @@ def usage(progname):


 def cli_main():
+    sys.stdout=SafeUnbuffered(sys.stdout)
+    sys.stderr=SafeUnbuffered(sys.stderr)
    argv=unicode_argv()
    progname = os.path.basename(argv[0])
    print u"{0} v{1}\nCopyright © 2010-2013 some_updates and Apprentice Alf".format(progname,__version__)
@@ -1845,10 +1848,13 @@ def cli_main():


 def gui_main():
-    import Tkinter
-    import Tkconstants
-    import tkMessageBox
-    import traceback
+    try:
+        import Tkinter
+        import Tkconstants
+        import tkMessageBox
+        import traceback
+    except:
+        return cli_main()

    class ExceptionDialog(Tkinter.Frame):
        def __init__(self, root, text):
@@ -1895,7 +1901,5 @@ def gui_main():

 if __name__ == '__main__':
    if len(sys.argv) > 1:
-        sys.stdout=SafeUnbuffered(sys.stdout)
-        sys.stderr=SafeUnbuffered(sys.stderr)
        sys.exit(cli_main())
    sys.exit(gui_main())
--- a/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/prefs.py
+++ b/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/prefs.py
@@ -0,0 +1,293 @@
+#!/usr/bin/env python
+# vim:fileencoding=UTF-8:ts=4:sw=4:sta:et:sts=4:ai
+
+from __future__ import with_statement
+__license__ = 'GPL v3'
+
+# Standard Python modules.
+import os, sys, re, hashlib
+import json
+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
+
+class DeDRM_Prefs():
+    def __init__(self):
+        JSON_PATH = os.path.join(u"plugins", PLUGIN_NAME.strip().lower().replace(' ', '_') + '.json')
+        self.dedrmprefs = JSONConfig(JSON_PATH)
+
+        self.dedrmprefs.defaults['configured'] = False
+        self.dedrmprefs.defaults['bandnkeys'] = {}
+        self.dedrmprefs.defaults['adeptkeys'] = {}
+        self.dedrmprefs.defaults['ereaderkeys'] = {}
+        self.dedrmprefs.defaults['kindlekeys'] = {}
+        self.dedrmprefs.defaults['pids'] = []
+        self.dedrmprefs.defaults['serials'] = []
+        self.dedrmprefs.defaults['adobewineprefix'] = ""
+        self.dedrmprefs.defaults['kindlewineprefix'] = ""
+
+        # initialise
+        # we must actually set the prefs that are dictionaries and lists
+        # to empty dictionaries and lists, otherwise we are unable to add to them
+        # as then it just adds to the (memory only) dedrmprefs.defaults versions!
+        if self.dedrmprefs['bandnkeys'] == {}:
+            self.dedrmprefs['bandnkeys'] = {}
+        if self.dedrmprefs['adeptkeys'] == {}:
+            self.dedrmprefs['adeptkeys'] = {}
+        if self.dedrmprefs['ereaderkeys'] == {}:
+            self.dedrmprefs['ereaderkeys'] = {}
+        if self.dedrmprefs['kindlekeys'] == {}:
+            self.dedrmprefs['kindlekeys'] = {}
+        if self.dedrmprefs['pids'] == []:
+            self.dedrmprefs['pids'] = []
+        if self.dedrmprefs['serials'] == []:
+            self.dedrmprefs['serials'] = []
+
+    def __getitem__(self,kind = None):
+        if kind is not None:
+            return self.dedrmprefs[kind]
+        return self.dedrmprefs
+
+    def set(self, kind, value):
+        self.dedrmprefs[kind] = value
+
+    def writeprefs(self,value = True):
+        self.dedrmprefs['configured'] = value
+
+    def addnamedvaluetoprefs(self, prefkind, keyname, keyvalue):
+        try:
+            if keyvalue not in self.dedrmprefs[prefkind].values():
+                # ensure that the keyname is unique
+                # by adding a number (starting with 2) to the name if it is not
+                namecount = 1
+                newname = keyname
+                while newname in self.dedrmprefs[prefkind]:
+                    namecount += 1
+                    newname = "{0:s}_{1:d}".format(keyname,namecount)
+                # add to the preferences
+                self.dedrmprefs[prefkind][newname] = keyvalue
+                return (True, newname)
+        except:
+            traceback.print_exc()
+            pass
+        return (False, keyname)
+
+    def addvaluetoprefs(self, prefkind, prefsvalue):
+        # ensure the keyvalue isn't already in the preferences
+        try:
+            if prefsvalue not in self.dedrmprefs[prefkind]:
+                self.dedrmprefs[prefkind].append(prefsvalue)
+                return True
+        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 = u"{0}_{1}".format(name.strip(),ccn.strip()[-4:])
+                keyvalue = generate_key(name, ccn)
+                userkeys.append([keyname,keyvalue])
+            except Exception, 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 = u"{0}_{1}".format(name.strip(),cc.strip()[-4:])
+                keyvalue = getuser_key(name,cc).encode('hex')
+                userkeysappend([keyname,keyvalue])
+            except Exception, 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 = value.encode(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 u"{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(u"plugins", u"K4MobiDeDRM"))
+    ignobleprefs = JSONConfig(os.path.join(u"plugins", u"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 u"{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 u"{0} v{1}: {2:d} Barnes and Noble {3} imported from old Ignoble plugin configuration string".format(PLUGIN_NAME, PLUGIN_VERSION, addedkeycount, u"key" if addedkeycount==1 else u"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 u"{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 u"{0} v{1}: {2:d} eReader {3} imported from old eReader plugin configuration string".format(PLUGIN_NAME, PLUGIN_VERSION, addedkeycount, u"key" if addedkeycount==1 else u"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 u"{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 u"{0} v{1}: {2:d} {3} and {4:d} {5} imported from old Kindle plugin configuration string.".format(PLUGIN_NAME, PLUGIN_VERSION, addedpidcount, u"PID" if addedpidcount==1 else u"PIDs", addedserialcount, u"serial number" if addedserialcount==1 else u"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 u"{0} v{1}: {2:d} Barnes and Noble {3} imported from config folder.".format(PLUGIN_NAME, PLUGIN_VERSION, ignoblecount, u"key file" if ignoblecount==1 else u"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')
+    ineptcount = addConfigFiles('.der', 'adeptkeys')
+    for keypair in adeptfilekeys:
+        name = keypair[0]
+        value = keypair[1]
+        dedrmprefs.addnamedvaluetoprefs('adeptkeys', name, value)
+    addedkeycount = len(dedrmprefs['adeptkeys'])-priorkeycount
+    if addedkeycount > 0:
+        print u"{0} v{1}: {2:d} Adobe Adept {3} imported from config folder.".format(PLUGIN_NAME, PLUGIN_VERSION, ineptcount, u"keyfile" if ineptcount==1 else u"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 u"{0} v{1}: {2:d} Barnes and Noble {3} imported from Ignoble plugin preferences.".format(PLUGIN_NAME, PLUGIN_VERSION, addedkeycount, u"key" if addedkeycount==1 else u"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 u"{0} v{1}: {2:d} {3} imported from Kindle plugin preferences".format(PLUGIN_NAME, PLUGIN_VERSION, addedpidcount, u"PID" if addedpidcount==1 else u"PIDs")
+    addedserialcount = len(dedrmprefs['serials']) - priorserialcount
+    if addedserialcount > 0:
+        print u"{0} v{1}: {2:d} {3} imported from Kindle plugin preferences".format(PLUGIN_NAME, PLUGIN_VERSION, addedserialcount, u"serial number" if addedserialcount==1 else u"serial numbers")
+    try:
+        if kindleprefs['wineprefix'] != "":
+            dedrmprefs.set('adobewineprefix',kindleprefs['wineprefix'])
+            dedrmprefs.set('kindlewineprefix',kindleprefs['wineprefix'])
+            print u"{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 u"{0} v{1}: Finished setting up configuration data.".format(PLUGIN_NAME, PLUGIN_VERSION)
--- a/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/wineutils.py
+++ b/DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/wineutils.py
@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from __future__ import with_statement
+
+__license__ = 'GPL v3'
+
+# Standard Python modules.
+import os, sys, re, hashlib
+from calibre_plugins.dedrm.__init__ import PLUGIN_NAME, PLUGIN_VERSION
+
+def WineGetKeys(scriptpath, extension, wineprefix=""):
+    import subprocess
+    from subprocess import Popen, PIPE, STDOUT
+
+    import subasyncio
+    from subasyncio import Process
+
+    if extension == u".k4i":
+        import json
+
+    basepath, script = os.path.split(scriptpath)
+    print u"{0} v{1}: Running {2} under Wine".format(PLUGIN_NAME, PLUGIN_VERSION, script)
+
+    outdirpath = os.path.join(basepath, u"winekeysdir")
+    if not os.path.exists(outdirpath):
+        os.mkdir(outdirpath)
+
+    if wineprefix != "" and os.path.exists(wineprefix):
+         cmdline = u"WINEPREFIX=\"{2}\" wine python.exe \"{0}\" \"{1}\"".format(scriptpath,outdirpath,wineprefix)
+    else:
+        cmdline = u"wine python.exe \"{0}\" \"{1}\"".format(scriptpath,outdirpath)
+    print u"{0} v{1}: Command line: “{2}”".format(PLUGIN_NAME, PLUGIN_VERSION, cmdline)
+
+    try:
+        cmdline = cmdline.encode(sys.getfilesystemencoding())
+        p2 = Process(cmdline, shell=True, bufsize=1, stdin=None, stdout=sys.stdout, stderr=STDOUT, close_fds=False)
+        result = p2.wait("wait")
+    except Exception, e:
+        print u"{0} v{1}: Wine subprocess call error: {2}".format(PLUGIN_NAME, PLUGIN_VERSION, e.args[0])
+        return []
+
+    winekeys = []
+    # 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:
+        try:
+            fpath = os.path.join(outdirpath, filename)
+            with open(fpath, 'rb') as keyfile:
+                if extension == u".k4i":
+                    new_key_value = json.loads(keyfile.read())
+                else:
+                    new_key_value = keyfile.read()
+            winekeys.append(new_key_value)
+        except:
+            print u"{0} v{1}: Error loading file {2}".format(PLUGIN_NAME, PLUGIN_VERSION, filename)
+            traceback.print_exc()
+        os.remove(fpath)
+    print u"{0} v{1}: Found and decrypted {2} {3}".format(PLUGIN_NAME, PLUGIN_VERSION, len(winekeys), u"key file" if len(winekeys) == 1 else u"key files")
+    return winekeys