Skip to content

Instantly share code, notes, and snippets.

@fireattack

fireattack/DumpAZW6_v01.py

Last active Mar 11, 2020
Embed
What would you like to do?
Py3 version
#!/usr/bin/env python
# vim:fileencoding=UTF-8:ts=4:sw=4:sta:et:sts=4:ai
import sys
import os, getopt, struct
import imghdr
def get_image_type(imgname, imgdata=None):
imgtype = imghdr.what(imgname, imgdata)
# horrible hack since imghdr detects jxr/wdp as tiffs
if imgtype is not None and imgtype == "tiff":
imgtype = "wdp"
# imghdr only checks for JFIF or Exif JPEG files. Apparently, there are some
# with only the magic JPEG bytes out there...
# ImageMagick handles those, so, do it too.
if imgtype is None:
if imgdata[0:2] == b'\xFF\xD8':
# Get last non-null bytes
last = len(imgdata)
while (imgdata[last-1:last] == b'\x00'):
last-=1
# Be extra safe, check the trailing bytes, too.
if imgdata[last-2:last] == b'\xFF\xD9':
imgtype = "jpeg"
return imgtype
def processCRES(i, data):
data = data[12:]
imgtype = get_image_type(None, data)
if imgtype is None:
print(" Warning: CRES Section %s does not contain a recognised resource" % i)
imgtype = "dat"
imgname = "HDimage%05d.%s" % (i, imgtype)
imgdir = os.path.join(".", "azw6_images")
if not os.path.exists(imgdir):
os.mkdir(imgdir)
print(" Extracting HD image: {0:s} from section {1:d}".format(imgname,i))
imgpath = os.path.join(imgdir, imgname)
with open(imgpath, 'wb') as f:
f.write(data)
return
# this is just guesswork so far, making big assumption that
# metavalue key numbers reamin the same in the CONT EXTH
def dump_contexth(codec, extheader):
# determine text encoding
if extheader == '':
return
id_map_strings = {
1 : 'Drm Server Id (1)',
2 : 'Drm Commerce Id (2)',
3 : 'Drm Ebookbase Book Id(3)',
100 : 'Creator_(100)',
101 : 'Publisher_(101)',
102 : 'Imprint_(102)',
103 : 'Description_(103)',
104 : 'ISBN_(104)',
105 : 'Subject_(105)',
106 : 'Published_(106)',
107 : 'Review_(107)',
108 : 'Contributor_(108)',
109 : 'Rights_(109)',
110 : 'SubjectCode_(110)',
111 : 'Type_(111)',
112 : 'Source_(112)',
113 : 'ASIN_(113)',
114 : 'versionNumber_(114)',
117 : 'Adult_(117)',
118 : 'Price_(118)',
119 : 'Currency_(119)',
122 : 'fixed-layout_(122)',
123 : 'book-type_(123)',
124 : 'orientation-lock_(124)',
126 : 'original-resolution_(126)',
127 : 'zero-gutter_(127)',
128 : 'zero-margin_(128)',
129 : 'K8_Masthead/Cover_Image_(129)',
132 : 'RegionMagnification_(132)',
200 : 'DictShortName_(200)',
208 : 'Watermark_(208)',
501 : 'cdeType_(501)',
502 : 'last_update_time_(502)',
503 : 'Updated_Title_(503)',
504 : 'ASIN_(504)',
508 : 'Unknown_Title_Furigana?_(508)',
517 : 'Unknown_Creator_Furigana?_(517)',
522 : 'Unknown_Publisher_Furigana?_(522)',
524 : 'Language_(524)',
525 : 'primary-writing-mode_(525)',
526 : 'Unknown_(526)',
527 : 'page-progression-direction_(527)',
528 : 'override-kindle_fonts_(528)',
529 : 'Unknown_(529)',
534 : 'Input_Source_Type_(534)',
535 : 'Kindlegen_BuildRev_Number_(535)',
536 : 'Container_Info_(536)', # CONT_Header is 0, Ends with CONTAINER_BOUNDARY (or Asset_Type?)
538 : 'Container_Resolution_(538)',
539 : 'Container_Mimetype_(539)',
542 : 'Unknown_but_changes_with_filename_only_(542)',
543 : 'Container_id_(543)', # FONT_CONTAINER, BW_CONTAINER, HD_CONTAINER
544 : 'Unknown_(544)',
}
id_map_values = {
115 : 'sample_(115)',
116 : 'StartOffset_(116)',
121 : 'K8(121)_Boundary_Section_(121)',
125 : 'K8_Count_of_Resources_Fonts_Images_(125)',
131 : 'K8_Unidentified_Count_(131)',
201 : 'CoverOffset_(201)',
202 : 'ThumbOffset_(202)',
203 : 'Fake_Cover_(203)',
204 : 'Creator_Software_(204)',
205 : 'Creator_Major_Version_(205)',
206 : 'Creator_Minor_Version_(206)',
207 : 'Creator_Build_Number_(207)',
401 : 'Clipping_Limit_(401)',
402 : 'Publisher_Limit_(402)',
404 : 'Text_to_Speech_Disabled_(404)',
}
id_map_hexstrings = {
209 : 'Tamper_Proof_Keys_(209_in_hex)',
300 : 'Font_Signature_(300_in_hex)',
}
_length, num_items = struct.unpack('>LL', extheader[4:12])
extheader = extheader[12:]
pos = 0
for _ in range(num_items):
id, size = struct.unpack('>LL', extheader[pos:pos+8])
content = extheader[pos + 8: pos + size]
if id in list(id_map_strings.keys()):
name = id_map_strings[id]
print('\n Key: "%s"\n Value: "%s"' % (name, str(content, codec)))
elif id in list(id_map_values.keys()):
name = id_map_values[id]
if size == 9:
value, = struct.unpack('B',content)
print('\n Key: "%s"\n Value: 0x%01x' % (name, value))
elif size == 10:
value, = struct.unpack('>H',content)
print('\n Key: "%s"\n Value: 0x%02x' % (name, value))
elif size == 12:
value, = struct.unpack('>L',content)
print('\n Key: "%s"\n Value: 0x%04x' % (name, value))
else:
print("\nError: Value for %s has unexpected size of %s" % (name, size))
elif id in list(id_map_hexstrings.keys()):
name = id_map_hexstrings[id]
print('\n Key: "%s"\n Value: 0x%s' % (name, content.hex()))
else:
print("\nWarning: Unknown metadata with id %s found" % id)
name = str(id) + ' (hex)'
print(' Key: "%s"\n Value: 0x%s' % (name, content.hex()))
pos += size
return
def sortedHeaderKeys(mheader):
hdrkeys = sorted(list(mheader.keys()), key=lambda akey: mheader[akey][0])
return hdrkeys
class dumpHeaderException(Exception):
pass
class PalmDB:
# important palmdb header offsets
unique_id_seed = 68
number_of_pdb_records = 76
first_pdb_record = 78
def __init__(self, palmdata):
self.data = palmdata
self.nsec, = struct.unpack_from('>H',self.data,PalmDB.number_of_pdb_records)
def getsecaddr(self,secno):
secstart, = struct.unpack_from('>L', self.data, PalmDB.first_pdb_record+secno*8)
if secno == self.nsec-1:
secend = len(self.data)
else:
secend, = struct.unpack_from('>L',self.data,PalmDB.first_pdb_record+(secno+1)*8)
return secstart,secend
def readsection(self,secno):
if secno < self.nsec:
secstart, secend = self.getsecaddr(secno)
return self.data[secstart:secend]
return ''
def getnumsections(self):
return self.nsec
class HdrParser:
cont_header = {
'magic' : (0x00, '4s', 4),
'record_size' : (0x04, '>L', 4),
'type' : (0x08, '>H', 2),
'count' : (0x0A, '>H', 2),
'codepage' : (0x0C, '>L', 4),
'unknown0' : (0x10, '>L', 4),
'unknown1' : (0x14, '>L', 4),
'num_resc_recs' : (0x18, '>L', 4),
'num_wo_placeholders' : (0x1C, '>L', 4),
'offset_to_hrefs' : (0x20, '>L', 4),
'unknown2' : (0x24, '>L', 4),
'title_offset' : (0x28, '>L', 4),
'title_length' : (0x2C, '>L', 4),
}
cont_header_sorted_keys = sortedHeaderKeys(cont_header)
def __init__(self, header, start):
self.header = header
self.start = start
self.hdr = {}
# set it up for the proper header version
self.header_sorted_keys = HdrParser.cont_header_sorted_keys
self.cont_header = HdrParser.cont_header
# parse the header information
for key in self.header_sorted_keys:
(pos, format, tot_len) = self.cont_header[key]
if pos < 48:
val, = struct.unpack_from(format, self.header, pos)
self.hdr[key] = val
self.exth = self.header[48:]
self.title_offset = self.hdr['title_offset']
self.title_length = self.hdr['title_length']
self.title = self.header[self.title_offset: self.title_offset + self.title_length]
self.codec = 'windows-1252'
self.codec_map = {
1252 : 'windows-1252',
65001: 'utf-8',
}
if self.hdr['codepage'] in list(self.codec_map.keys()):
self.codec = self.codec_map[self.hdr['codepage']]
self.title = self.title.decode(self.codec)
def dumpHeaderInfo(self):
for key in self.cont_header_sorted_keys:
(pos, format, tot_len) = self.cont_header[key]
if pos < 48:
if key == 'magic':
print(" Field: %20s Offset: 0x%03x Width: %d Value: %s" % (key, pos, tot_len, self.hdr[key].decode()))
else:
print((" Field: %20s Offset: 0x%03x Width: %d Value: 0x%0" + str(tot_len) + "x") % (key, pos, tot_len, self.hdr[key]))
print("EXTH Region Length: 0x%0x" % len(self.exth))
print("EXTH MetaData")
#print(f'stdin: {sys.stdin.encoding}, stdout: {sys.stdout.encoding}')
try:
print(self.title)
except: # It will have problem otherwise in certain env, such as when redirect output to '> 1.txt'
print(self.title.encode(sys.stdout.encoding, "ignore").decode(sys.stdout.encoding))
dump_contexth(self.codec, self.exth)
return
def usage(progname):
print("")
print("Description:")
print(" Dump the image from an AZW6 HD container file")
print(" ")
print("Usage:")
print(" %s -h infile.azw6" % progname)
print(" ")
print("Options:")
print(" -h print this help message")
def main(argv=sys.argv):
print("DumpAZW6 v01")
progname = os.path.basename(argv[0])
try:
opts, args = getopt.getopt(argv[1:], "h")
except getopt.GetoptError as err:
print(str(err))
usage(progname)
sys.exit(2)
if len(args) != 1:
usage(progname)
sys.exit(2)
for o, a in opts:
if o == "-h":
usage(progname)
sys.exit(0)
infile = args[0]
infileext = os.path.splitext(infile)[1].upper()
print(infile, infileext)
if infileext not in ['.AZW6','.RES']:
print("Error: first parameter must be a Kindle AZW6 HD container file.")
return 1
try:
# make sure it is really an hd container file
contdata = open(infile, 'rb').read()
palmheader = contdata[0:78]
ident = palmheader[0x3C:0x3C+8]
if ident != b'RBINCONT':
raise dumpHeaderException('invalid file format')
headers = {}
pp = PalmDB(contdata)
header = pp.readsection(0)
print("\n\nFirst Header Dump from Section %d" % 0)
hp = HdrParser(header, 0)
hp.dumpHeaderInfo()
# now dump a basic sector map of the palmdb
n = pp.getnumsections()
dtmap = {
b"FONT": "FONT",
b"RESC": "RESC",
b"CRES": "CRES",
b"CONT": "CONT",
b'\xa0\xa0\xa0\xa0': "Empty_Image/Resource_Placeholder",
b'\xe9\x8e\r\n': "EOF_RECORD",
}
dtmap2 = {
b"kindle:embed" : "KINDLE:EMBED",
}
tr = -1
off = -1
hp = None
secmap = {}
print("\nMap of Palm DB Sections")
print(" Dec - Hex : Description")
print(" ---- - ---- -----------")
for i in range(n):
before, after = pp.getsecaddr(i)
data = pp.readsection(i)
dlen = len(data)
dt = data[0:4]
dtext = data[0:12]
desc = ''
if dtext in list(dtmap2.keys()):
desc = data.decode()
linkhrefs = []
hreflist = desc.split('|')
for href in hreflist:
if href != "":
linkhrefs.append(" " + href)
desc = "\n" + "\n".join(linkhrefs)
elif dt in list(dtmap.keys()):
desc = dtmap[dt]
if dt == b"CONT":
desc="Cont Header"
elif dt == b"CRES":
processCRES(i, data)
else:
desc = dtext.hex()
desc = desc + " " + dtext.decode()
if desc != "CONT":
print(" %04d - %04x: %s [%d]" % (i, i, desc, dlen))
except Exception as e:
print("Error: %s" % e)
return 1
return 0
if __name__ == '__main__':
sys.exit(main())
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.