View difference between Paste ID: ZVwQjmAh and UsCrFfJP

-#!/usr/bin/python
+#!/usr/bin/env python
 #
 # Updates July 2012 by Michael Newton
 # PWSD ID is no longer a MAC address, but should always
-#                      8====D~~~~ O:                     #
+# be stored in the registry. Script now works with OS X
 # and checks plist for values instead of registry. Must
 # have biplist installed for OS X support.
 #
 ##########################################################
 #                    KOBO DRM CRACK BY                   #
 #                      PHYSISTICATED                     #
 ##########################################################
 # This app was made for Python 2.7 on Windows 32-bit
 #
 # This app needs pycrypto - get from here:
 # http://www.voidspace.org.uk/python/modules.shtml
 #
 # Usage: obok.py
 # Choose the book you want to decrypt
 #
 # Shouts to my krew - you know who you are - and one in
 # particular who gave me a lot of help with this - thank
 # you so much!
 #
 # Kopimi /K\
 # Keep sharing, keep copying, but remember that nothing is
 # for free - make sure you compensate your favorite
 # authors - and cut out the middle man whenever possible
 # ;) ;) ;)
 #
 # DRM AUTOPSY
 # The Kobo DRM was incredibly easy to crack, but it took
 # me months to get around to making this. Here's the
 # basics of how it works:
 # 1: Get MAC address of first NIC in ipconfig (sometimes
 # stored in registry as pwsdid)
 # 2: Get user ID (stored in tons of places, this gets it
 # from HKEY_CURRENT_USER\Software\Kobo\Kobo Desktop
 # Edition\Browser\cookies)
 # 3: Concatenate and SHA256, take the second half - this
 # is your master key
 # 4: Open %LOCALAPPDATA%\Kobo Desktop Editions\Kobo.sqlite
 # and dump content_keys
 # 5: Unbase64 the keys, then decode these with the master
 # key - these are your page keys
 # 6: Unzip EPUB of your choice, decrypt each page with its
 # page key, then zip back up again
 #
 # WHY USE THIS WHEN INEPT WORKS FINE? (adobe DRM stripper)
 # Inept works very well, but authors on Kobo can choose
 # what DRM they want to use - and some have chosen not to
 # let people download them with Adobe Digital Editions -
 # they would rather lock you into a single platform.
 #
 # With Obok, you can sync Kobo Desktop, decrypt all your
 # ebooks, and then use them on whatever device you want
 # - you bought them, you own them, you can do what you
 # like with them.
 #
 # Obok is Kobo backwards, but it is also means "next to"
 # in Polish.
 # When you buy a real book, it is right next to you. You
 # can read it at home, at work, on a train, you can lend
 # it to a friend, you can scribble on it, and add your own
 # explanations/translations.
 #
 # Obok gives you this power over your ebooks - no longer
 # are you restricted to one device. This allows you to
 # embed foreign fonts into your books, as older Kobo's
 # can't display them properly. You can read your books
 # on your phones, in different PC readers, and different
-import _winreg
+
 # too, if you like - you can do that with a real book
 # after all.
 #
 """
 Decrypt Kobo encrypted EPUB books.
 """
 
 import os
-from uuid import getnode as get_mac
+import sys
 if sys.platform.startswith('win'):
     import _winreg
-	return hashlib.sha256(raw).hexdigest()
+elif sys.platform.startswith('darwin'):
     from biplist import readPlist
 import re
-	lastchar = binascii.b2a_hex(contents[-1:])
+
-	len = int(lastchar, 16)
+
-	padding = len
+
-	if(len == 1):
+
-		return contents[:-1]
+
-	if(len < 16):
+
-		for i in range(len):
+
-			testchar = binascii.b2a_hex(contents[-len:-(len-1)])
+
-			if(testchar != lastchar):
+
-				padding = 0
+    return hashlib.sha256(raw).hexdigest()
-	if(padding > 0):
+
-		contents = contents[:-padding]
+
-	return contents
+    lastchar = binascii.b2a_hex(contents[-1:])
-
+    strlen = int(lastchar, 16)
-def GetVolumeKeys(c):
+    padding = strlen
-	volumekeys = {}
+    if(strlen == 1):
-	for row in c.execute("SELECT * from content_keys"):
+        return contents[:-1]
-		if(row[0] not in volumekeys):
+    if(strlen < 16):
-			volumekeys[row[0]] = {}
+        for i in range(strlen):
-		volumekeys[row[0]][row[1]] = {}
+            testchar = binascii.b2a_hex(contents[-strlen:-(strlen-1)])
-		volumekeys[row[0]][row[1]]["encryptedkey"] = base64.b64decode(row[2])
+            if(testchar != lastchar):
-		volumekeys[row[0]][row[1]]["decryptedkey"] = enc.decrypt(volumekeys[row[0]][row[1]]["encryptedkey"])
+                padding = 0
-	# get book name
+    if(padding > 0):
-	for key in volumekeys.keys():
+        contents = contents[:-padding]
-		volumekeys[key]["title"] = c.execute("SELECT Title from content where ContentID = '%s'" % (key)).fetchone()[0]
+    return contents
-	return volumekeys
+
 def GetVolumeKeys(dbase, enc):
     volumekeys = {}
-def GetMacString():
+    for row in dbase.execute("SELECT * from content_keys"):
-	# terrible way, but get_mac() only returns proper interfaces
+        if(row[0] not in volumekeys):
-	# this will return the first in ipconfig
+            volumekeys[row[0]] = {}
-	# Kobo appears to do the same
+        volumekeys[row[0]][row[1]] = {}
-	ipconfig = os.popen('ipconfig /all').read()
+        volumekeys[row[0]][row[1]]["encryptedkey"] = base64.b64decode(row[2])
-	c = re.compile("Physical Address[^0-9A-F]+([0-9A-Fa-f-]+)", re.MULTILINE)
+        volumekeys[row[0]][row[1]]["decryptedkey"] = enc.decrypt(volumekeys[row[0]][row[1]]["encryptedkey"])
-	m = c.search(ipconfig)
+    # get book name
-	mac = re.sub("-", ":", m.group(1))
+    for key in volumekeys.keys():
-	return mac
+        volumekeys[key]["title"] = dbase.execute("SELECT Title from content where ContentID = '%s'" % (key)).fetchone()[0]
     return volumekeys
-	#macnum = get_mac()
+
-	#macarray = []
+def ByteArrayToString(bytearr):
-	#for i in range(6):
+    wincheck = re.match("@ByteArray\\((.+)\\)", bytearr)
-	#	macarray.append((hex((macnum >> (40-(i*8)) & 0xFF))[2:-1]).zfill(2))
+    if wincheck:
-	#return string.upper(string.join(macarray, ":"))
+        return wincheck.group(1)
     return bytearr
-def ByteArrayToString(bytearray):
+
-	return re.match("@ByteArray\\((.+)\\)", bytearray).group(1)
+def GetUserHexKey(prefs = ""):
     "find wsuid and pwsdid"
-def GetUserHexKey():
+    wsuid = ""
-	regkey_browser = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, "Software\\Kobo\\Kobo Desktop Edition\\Browser")
+    pwsdid = ""
-	cookies = _winreg.QueryValueEx(regkey_browser, "cookies")
+    if sys.platform.startswith('win'):
-	bytearrays = cookies[0]
+        regkey_browser = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, "Software\\Kobo\\Kobo Desktop Edition\\Browser")
-	# find wsuid and pwsdid
+        cookies = _winreg.QueryValueEx(regkey_browser, "cookies")
-	# pwsdid isn't always stored, but GetMacString() will get it for us
+        bytearrays = cookies[0]
-	wsuid = ""
+    elif sys.platform.startswith('darwin'):
-	pwsdid = GetMacString()
+        cookies = readPlist(prefs)
-	for bytearray in bytearrays:
+        bytearrays = cookies["Browser.cookies"]
-		cookie = ByteArrayToString(bytearray)
+    for bytearr in bytearrays:
-		wsuidcheck = re.match("^wsuid=([0-9a-f-]+)", cookie)
+        cookie = ByteArrayToString(bytearr)
-		if(wsuidcheck):
+        print cookie
-			wsuid = wsuidcheck.group(1)
+        wsuidcheck = re.match("^wsuid=([0-9a-f-]+)", cookie)
-	if(wsuid == ""):
+        if(wsuidcheck):
-		print "wsuid key not found :/"
+            wsuid = wsuidcheck.group(1)
-		exit()
+        pwsdidcheck = re.match("^pwsdid=([0-9a-f-]+)", cookie)
-	preuserkey = string.join((pwsdid, wsuid), "")
+        if (pwsdidcheck):
-	userkey = SHA256(preuserkey)
+            pwsdid = pwsdidcheck.group(1)
-	return userkey[32:]
+
     if(wsuid == "" or pwsdid == ""):
         print "wsuid or pwsdid key not found :/"
-userkeyhex = GetUserHexKey()
+        exit()
     preuserkey = string.join((pwsdid, wsuid), "")
     print SHA256(pwsdid)
     userkey = SHA256(preuserkey)
     return userkey[32:]
-kobodir = string.join((os.environ['LOCALAPPDATA'], "Kobo\\Kobo Desktop Edition"), "\\")
+
-sqlitefile = string.join((kobodir, "Kobo.sqlite"), "\\")
+
-bookdir = string.join((kobodir, "kepub"), "\\")
+if sys.platform.startswith('win'):
     delim = "\\"
     kobodir = string.join((os.environ['LOCALAPPDATA'], "Kobo\\Kobo Desktop Edition"), delim)
 elif sys.platform.startswith('darwin'):
-c = conn.cursor()
+    delim = "/"
     kobodir = string.join((os.environ['HOME'], "Library/Application Support/Kobo/Kobo Desktop Edition"), delim)
-volumekeys = GetVolumeKeys(c)
+    prefs = string.join((os.environ['HOME'], "Library/Preferences/com.kobo.Kobo Desktop Edition.plist"), delim)
 sqlitefile = string.join((kobodir, "Kobo.sqlite"), delim)
 bookdir = string.join((kobodir, "kepub"), delim)
 
 # get key
 userkeyhex = GetUserHexKey(prefs)
 # load into AES
 userkey = binascii.a2b_hex(userkeyhex)
-	print "%d: %s" % (i, volumekeys[key]["title"])
+
-	i+=1
+
 # open sqlite
 conn = sqlite3.connect(sqlitefile)
 dbcursor = conn.cursor()
 # get volume keys
 volumekeys = GetVolumeKeys(dbcursor, enc)
-	if(i==num):
+
-		volumeid = key
+
-	i+=1
+
 volumeid = ""
 print "Choose a book to decrypt:"
 i = 1
-	exit()
+
     print "%d: %s" % (i, volumekeys[key]["title"])
-zippath = string.join((bookdir, volumeid), "\\")
+    i += 1
 
 num = input("...")
 
-outname = "%s.epub" % (re.sub("[^a-zA-Z0-9 ]", "", volumekeys[volumeid]["title"]))
+
 for key in volumekeys.keys():
     if(i == num):
-	#print filename
+        volumeid = key
-	# read in and decrypt
+    i += 1
-	if(filename in volumekeys[volumeid]):
+
-		# do decrypted version
+
-		pagekey = volumekeys[volumeid][filename]["decryptedkey"]
+    exit()
-		penc = AES.new(pagekey, AES.MODE_ECB)
+
-		contents = RemoveAESPadding(penc.decrypt(z.read(filename)))
+zippath = string.join((bookdir, volumeid), delim)
-		# need to fix padding
+
-		zout.writestr(filename, contents)
+
-	else:
+
-		zout.writestr(filename, z.read(filename))
+outname = "%s.epub" % (re.sub("[^a-zA-Z0-9]", "", volumekeys[volumeid]["title"]))
 zout = zipfile.ZipFile(outname, "w", zipfile.ZIP_DEFLATED)
-print "Book saved as %s\\%s" % (os.getcwd(), outname)
+
     #print filename
     # read in and decrypt
     if(filename in volumekeys[volumeid]):
         # do decrypted version
         pagekey = volumekeys[volumeid][filename]["decryptedkey"]
         penc = AES.new(pagekey, AES.MODE_ECB)
         contents = RemoveAESPadding(penc.decrypt(z.read(filename)))
         # need to fix padding
         zout.writestr(filename, contents)
     else:
         zout.writestr(filename, z.read(filename))
 
 print "Book saved as %s%s%s" % (os.getcwd(), delim, outname)