nstools 1.1.0__tar.gz

nstools-1.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: nstools
+Version: 1.1.0
+Home-page: https://github.com/seiya-dev/NSTools
+Requires-Python: >=3.10
+Requires-Dist: zstandard
+Requires-Dist: enlighten
+Requires-Dist: requests
+Requires-Dist: pycryptodome
+
+tools for xci/xcz/nsp/nsz

nstools-1.1.0/nstools/Fs/BaseFs.py

@@ -0,0 +1,178 @@
+from binascii import hexlify as hx, unhexlify as uhx
+
+from nstools.nut import Print
+
+from . import Bktr
+from . import Type
+
+from .File import File
+from .File import MemoryFile
+from .Cnmt import Cnmt
+
+
+class EncryptedSection:
+	def __init__(self, offset, size, cryotoType, cryptoKey, cryptoCounter):
+		self.offset = offset
+		self.size = size
+		self.cryptoType = cryotoType
+		self.cryptoKey = cryptoKey
+		self.cryptoCounter = cryptoCounter
+
+class BaseFs(File):
+	def __init__(self, buffer, path = None, mode = None, cryptoType = -1, cryptoKey = -1, cryptoCounter = -1):		
+		self.buffer = buffer
+		self.sectionStart = 0
+		self.fsType = None
+		self.cryptoType = None
+		self.size = 0
+		self.cryptoCounter = None
+		self.magic = None
+		self._headerSize = None
+		self.bktrRelocation = None
+		self.bktrSubsection = None
+			
+		self.files = []
+		
+		if buffer:
+			self.buffer = buffer
+			try:
+				self.fsType = Type.Fs(buffer[0x3])
+			except:
+				self.fsType = buffer[0x3]
+
+			try:
+				self.cryptoType = Type.Crypto(buffer[0x4])
+			except:
+				self.cryptoType = buffer[0x4]
+			
+			self.cryptoCounter = bytearray((b"\x00"*8) + buffer[0x140:0x148])
+			self.cryptoCounter = self.cryptoCounter[::-1]
+			
+			cryptoType = self.cryptoType
+			cryptoCounter = self.cryptoCounter
+			
+			self.bktr1Buffer = buffer[0x100:0x120]
+			self.bktr2Buffer = buffer[0x120:0x140]
+		else:
+			self.bktr1Buffer = None
+			self.bktr2Buffer = None
+			
+		super(BaseFs, self).__init__(path, mode, cryptoType, cryptoKey, cryptoCounter)
+		
+	def __getitem__(self, key):
+		if isinstance(key, str):
+			for f in self.files:
+				if (hasattr(f, 'name') and f.name == key) or (hasattr(f, '_path') and f._path == key):
+					return f
+		elif isinstance(key, int):
+			return self.files[key]
+				
+		raise IOError('FS File Not Found')
+		
+	def getEncryptionSections(self):
+		sections = []
+		
+		if self.hasBktr():
+			sectionOffset = self.realOffset()
+
+			for entry in self.bktrSubsection.getAllEntries():
+				ctr = self.setBktrCounter(entry.ctr, 0)
+				sections.append(EncryptedSection(self.realOffset() + entry.virtualOffset, entry.size, self.cryptoType, self.cryptoKey, ctr))
+			
+			if len(sections) == 0:
+				sections.append(EncryptedSection(sectionOffset, self.size, self.cryptoType, self.cryptoKey, self.cryptoCounter))
+			else:
+				offset = sections[-1].offset + sections[-1].size
+				sections.append(EncryptedSection(offset, (sectionOffset + self.size) - offset, self.cryptoType, self.cryptoKey, self.cryptoCounter))
+				
+		else:
+			sections.append(EncryptedSection(self.realOffset(), self.size, self.cryptoType, self.cryptoKey, self.cryptoCounter))
+		return sections
+
+	def realOffset(self):
+		return self.offset - self.sectionStart
+		
+	def hasBktr(self):
+		return (False if self.bktrSubsection is None else True) and self.bktrSubsection.isValid()
+		
+		
+	def open(self, path = None, mode = 'rb', cryptoType = -1, cryptoKey = -1, cryptoCounter = -1):
+		r = super(BaseFs, self).open(path, mode, cryptoType, cryptoKey, cryptoCounter)
+
+		if self.bktr1Buffer:
+			try:
+				self.bktrRelocation = Bktr.Bktr1(MemoryFile(self.bktr1Buffer), 'rb', nca = self)
+			except BaseException as e:
+				Print.info('bktr reloc exception: ' + str(e))
+			
+		if self.bktr2Buffer:
+			try:
+				self.bktrSubsection = Bktr.Bktr2(MemoryFile(self.bktr2Buffer), 'rb', nca = self)
+			except BaseException as e:
+				Print.info('bktr subsection exception: ' + str(e))
+		
+	def bktrRead(self, size = None, direct = False):
+		self.cryptoOffset = 0
+		self.ctr_val = 0
+		'''
+		if self.bktrRelocation:
+			entry = self.bktrRelocation.getRelocationEntry(self.tell())
+		
+			if entry:
+				self.ctr_val = entry.ctr
+				#self.cryptoOffset = entry.virtualOffset + entry.physicalOffset
+		'''
+		if self.bktrSubsection is not None:
+			entries = self.bktrSubsection.getEntries(self.tell(), size)
+			#print('offset = %x' % self.tell())
+			for entry in entries:
+				#print('offset = %x' % self.tell())
+				entry.printInfo()
+				#sys.exit(0)
+		#else:
+		#	print('unknown offset = %x' % self.tell())
+				
+		return super(BaseFs, self).read(size, direct)
+		
+	def read(self, size = None, direct = False):
+		'''
+		if self.cryptoType == Type.Crypto.BKTR or self.bktrSubsection is not None:
+			return self.bktrRead(size, True)
+		else:
+			return super(BaseFs, self).read(size, direct)
+		'''
+		return super(BaseFs, self).read(size, direct)
+		
+	def getCnmt(self):
+		for f in self:
+			if isinstance(f, Cnmt):
+				return f
+		raise("No Cnmt found!")
+	
+	def printInfo(self, maxDepth = 3, indent = 0):
+		tabs = '\t' * indent
+		Print.info(tabs + 'magic = ' + str(self.magic))
+		Print.info(tabs + 'fsType = ' + str(self.fsType))
+		Print.info(tabs + 'cryptoType = ' + str(self.cryptoType))
+		Print.info(tabs + 'size = ' + str(self.size))
+		Print.info(tabs + 'headerSize = %s' % (str(self._headerSize)))
+		Print.info(tabs + 'offset = %s - (%s)' % (str(self.offset), str(self.sectionStart)))
+		if self.cryptoCounter:
+			Print.info(tabs + 'cryptoCounter = ' + str(hx(self.cryptoCounter)))
+			
+		if self.cryptoKey:
+			Print.info(tabs + 'cryptoKey = ' + str(hx(self.cryptoKey)))
+		
+		Print.info('\n%s\t%s\n' % (tabs, '*' * 64))
+		Print.info('\n%s\tFiles:\n' % (tabs))
+		
+		if(indent+1 < maxDepth):
+			for f in self:
+				f.printInfo(maxDepth, indent+1)
+				Print.info('\n%s\t%s\n' % (tabs, '*' * 64))
+				
+		if self.bktrRelocation:
+			self.bktrRelocation.printInfo(maxDepth, indent+1)
+
+		if self.bktrSubsection:
+			self.bktrSubsection.printInfo(maxDepth, indent+1)

nstools-1.1.0/nstools/Fs/Bktr.py

@@ -0,0 +1,268 @@
+from binascii import hexlify as hx, unhexlify as uhx
+from struct import pack as pk, unpack as upk
+from hashlib import sha256
+
+import os
+import re
+import pathlib
+
+from nstools.nut import aes128
+from nstools.nut import Hex
+from nstools.nut import Keys, Print
+
+from .File import File, MemoryFile
+
+
+MEDIA_SIZE = 0x200
+
+class Header(File):
+	def __init__(self, path = None, mode = None, cryptoType = -1, cryptoKey = -1, cryptoCounter = -1, nca = None):
+		self.size = 0
+		self.offset = 0
+		self.nca = nca
+		self.bktr_offset = 0
+		self.bktr_size = 0
+		self.magic = None
+		self.version = None
+		self.enctryCount = 0
+		self.reserved = None
+		self.buffer = None
+		super(Header, self).__init__(path, mode, cryptoType, cryptoKey, cryptoCounter)
+
+	def open(self, file = None, mode = 'rb', cryptoType = -1, cryptoKey = -1, cryptoCounter = -1):
+		super(Header, self).open(file, mode, cryptoType, cryptoKey, cryptoCounter)
+		self.rewind()
+
+		self.bktr_offset = self.readInt64()
+		self.bktr_size = self.readInt64()
+		self.magic = self.read(0x4)
+		self.version = self.readInt32()
+		self.enctryCount = self.readInt32()
+		self.reserved = self.readInt32()
+
+	def printInfo(self, maxDepth = 3, indent = 0):
+		if not self.bktr_size:
+			return
+
+		tabs = '\t' * indent
+		Print.info('\n%sBKTR' % (tabs))
+		Print.info('%soffset = %d' % (tabs, self.bktr_offset))
+		Print.info('%ssize = %d' % (tabs, self.bktr_size))
+		Print.info('%sentry count = %d' % (tabs, self.enctryCount))
+		
+		Print.info('\n')
+
+class BktrRelocationEntry:
+	def __init__(self, f):
+		self.virtualOffset = f.readInt64()
+		self.physicalOffset = f.readInt64()
+		self.isPatch = f.readInt32()
+		
+	def printInfo(self, maxDepth = 3, indent = 0):
+		tabs = '\t' * indent
+		Print.info('%sRelocation Entry %s %x = %x' % (tabs, 'Patch' if self.isPatch else 'Base', self.physicalOffset, self.virtualOffset))
+		
+class BktrSubsectionEntry:
+	def __init__(self, f):
+		self.virtualOffset = f.readInt64()
+		self.size = 0
+		self.padding = f.readInt32()
+		self.ctr = f.readInt32()
+		
+	def printInfo(self, maxDepth = 3, indent = 0):
+		tabs = '\t' * indent
+		Print.info('%sSubsection Entry %d, CTR = %x' % (tabs, self.virtualOffset, self.ctr))
+		
+class BktrBucket:
+	def __init__(self, f):
+		self.padding = f.readInt32()
+		self.entryCount = f.readInt32()
+		self.endOffset = f.readInt64()
+		self.entries = []
+		
+	def getEntry(self, offset):
+		index = 0
+		last = self.entries[index]
+		for entry in self.entries:
+			if entry.virtualOffset > offset:
+				break
+				
+			last = self.entries[index]
+			index += 1
+			
+		return last
+
+			
+	def printInfo(self, maxDepth = 3, indent = 0):
+		tabs = '\t' * indent
+		Print.info('\n%sBKTR Bucket' % tabs)
+		Print.info('%sentries: %d' % (tabs, self.entryCount))
+		Print.info('%send offset: %d' % (tabs, self.endOffset))
+		
+		for entry in self.entries:
+			entry.printInfo(maxDepth, indent + 1)
+			
+class BktrSubsectionBucket(BktrBucket):
+	def __init__(self, f):
+		super(BktrSubsectionBucket, self).__init__(f)
+		
+		for i in range(self.entryCount):
+			self.entries.append(BktrSubsectionEntry(f))
+			
+			
+class BktrRelocationBucket(BktrBucket):
+	def __init__(self, f):
+		super(BktrRelocationBucket, self).__init__(f)
+		
+		if self.entryCount > 0xFFFF:
+			raise IOError('Too many entries')
+			
+		for i in range(self.entryCount):
+			self.entries.append(BktrRelocationEntry(f))
+			
+		
+class Bktr(Header):
+	def __init__(self, path = None, mode = None, cryptoType = -1, cryptoKey = -1, cryptoCounter = -1, nca = None):
+		self.basePhysicalOffsets  = []
+		super(Bktr, self).__init__(path, mode, cryptoType, cryptoKey, cryptoCounter, nca)
+		
+		
+	def open(self, file = None, mode = 'rb', cryptoType = -1, cryptoKey = -1, cryptoCounter = -1):
+		super(Bktr, self).open(file, mode, cryptoType, cryptoKey, cryptoCounter)
+		
+		if self.bktr_size:
+			self.nca.seek(self.bktr_offset)
+			self.nca.readInt32() # padding
+			self.bucketCount = self.nca.readInt32()
+			self.totalPatchImageSize = self.nca.readInt64()
+			self.basePhysicalOffsets = []
+			for i in range(int(0x3FF0 / 8)):
+				self.basePhysicalOffsets.append(self.nca.readInt64())
+				
+	def isValid(self):
+		return True if self.bktr_size > 0 else False
+				
+	def getBucket(self, offset):
+		if len(self.buckets) == 0:
+			return None
+			
+		index = 0
+		last = self.buckets[0]
+		
+		for virtualOffset in self.basePhysicalOffsets:
+			if index >= len(self.buckets):
+				break
+				
+			if offset > virtualOffset:
+				break
+				
+			last = self.buckets[index]
+			index += 1
+			
+		return last
+
+	def printInfo(self, maxDepth = 3, indent = 0):
+		super(Bktr, self).printInfo(maxDepth, indent)
+		tabs = '\t' * indent
+		Print.info('%sOffsets' % (tabs))
+		
+		i = 0
+		for off in self.basePhysicalOffsets:
+			i += 1
+			if off == 0 and i != 1:
+				break
+			Print.info('%s %x' % (tabs, off))
+		
+
+		
+class Bktr1(Bktr):
+	def __init__(self, path = None, mode = None, cryptoType = -1, cryptoKey = -1, cryptoCounter = -1, nca = None):
+		self.buckets = []
+		super(Bktr1, self).__init__(path, mode, cryptoType, cryptoKey, cryptoCounter, nca)
+		
+	def open(self, file = None, mode = 'rb', cryptoType = -1, cryptoKey = -1, cryptoCounter = -1):
+		super(Bktr1, self).open(file, mode, cryptoType, cryptoKey, cryptoCounter)
+		
+		self.buckets = []
+		
+		#if self.bktr_size:
+		#	for i in range(self.bucketCount):
+		#		self.buckets.append(BktrRelocationBucket(self.nca))
+				
+	def getRelocationEntry(self, offset):
+		if len(self.buckets) == 0:
+			return None
+
+		bucket = self.buckets[0]		
+
+		index = 0
+		for virtualOffset in self.basePhysicalOffsets:
+
+			if virtualOffset > offset or index >= len(self.buckets):
+				break
+
+			bucket = self.buckets[index]
+			index += 1
+			
+		result = bucket.entries[0]
+		for entry in bucket.entries:
+			if offset > entry.virtualOffset:
+				break
+			result = entry
+			
+		return entry
+			
+		
+	def printInfo(self, maxDepth = 3, indent = 0):
+		super(Bktr1, self).printInfo(maxDepth, indent)
+		tabs = '\t' * indent
+
+		for bucket in self.buckets:
+			bucket.printInfo(maxDepth, indent+1)
+		
+class Bktr2(Bktr):
+	def __init__(self, path = None, mode = None, cryptoType = -1, cryptoKey = -1, cryptoCounter = -1, nca = None):
+		self.buckets = []
+		super(Bktr2, self).__init__(path, mode, cryptoType, cryptoKey, cryptoCounter, nca)
+		
+	def open(self, file = None, mode = 'rb', cryptoType = -1, cryptoKey = -1, cryptoCounter = -1):
+		super(Bktr2, self).open(file, mode, cryptoType, cryptoKey, cryptoCounter)
+	
+		self.buckets = []
+		
+		if self.bktr_size:
+			for i in range(self.bucketCount):
+				self.buckets.append(BktrSubsectionBucket(self.nca))
+		
+	def getEntries(self, offset, size):
+		entries = []
+		
+		bucket = self.getBucket(offset)
+		if bucket is not None:
+			entries.append(bucket.getEntry(offset))		
+		
+		return entries
+		
+	def getAllEntries(self):
+		entries = []
+
+		for bucket in self.buckets:
+			last = None
+			for entry in bucket.entries:
+				if last is not None:
+					last.size = entry.virtualOffset - last.virtualOffset
+				last = entry
+				entries.append(entry)
+				
+			if len(entries) != 0:
+				entries[-1].size = bucket.endOffset - entries[-1].virtualOffset
+		
+		return entries
+		
+	def printInfo(self, maxDepth = 3, indent = 0):
+		super(Bktr2, self).printInfo(maxDepth, indent)
+
+		for bucket in self.buckets:
+			bucket.printInfo(maxDepth, indent+1)
+
+		

nstools-1.1.0/nstools/Fs/Cnmt.py

@@ -0,0 +1,80 @@
+from binascii import hexlify as hx, unhexlify as uhx
+
+from nstools.nut import Print, Keys
+
+from .File import File
+
+
+class MetaEntry:
+	def __init__(self, f):
+		self.titleId = hx(f.read(8)[::-1]).decode()
+		self.version = f.readInt32()
+		self.type = f.readInt8()
+		self.install = f.readInt8()
+
+		f.readInt16() # junk
+
+class ContentEntry:
+	def __init__(self, f):
+		self.hash = f.read(32)
+		self.ncaId = hx(f.read(16)).decode()
+		self.size = f.readInt48()
+		self.type = f.readInt8()
+
+		f.readInt8() # junk
+
+
+class Cnmt(File):
+	def __init__(self, path = None, mode = None, cryptoType = -1, cryptoKey = -1, cryptoCounter = -1):
+		super(Cnmt, self).__init__(path, mode, cryptoType, cryptoKey, cryptoCounter)
+
+		self.titleId = None
+		self.version = None
+		self.titleType = None
+		self.headerOffset = None
+		self.contentEntryCount = None
+		self.metaEntryCount = None
+		self.contentEntries = []
+		self.metaEntries = []
+
+
+	def open(self, file = None, mode = 'rb', cryptoType = -1, cryptoKey = -1, cryptoCounter = -1):
+		super(Cnmt, self).open(file, mode, cryptoType, cryptoKey, cryptoCounter)
+		self.rewind()
+
+		self.titleId = hx(self.read(8)[::-1]).decode()
+		self.version = self.readInt32()
+		self.titleType = self.readInt8()
+
+		self.readInt8() # junk
+
+		self.headerOffset = self.readInt16()
+		self.contentEntryCount = self.readInt16()
+		self.metaEntryCount = self.readInt16()
+
+		self.contentEntries = []
+		self.metaEntries = []
+
+		self.seek(0x20 + self.headerOffset)
+		for i in range(self.contentEntryCount):
+			self.contentEntries.append(ContentEntry(self))
+
+		for i in range(self.metaEntryCount):
+			self.metaEntries.append(MetaEntry(self))
+
+
+
+
+
+	def printInfo(self, maxDepth = 3, indent = 0):
+		tabs = '\t' * indent
+		Print.info('\n%sCnmt\n' % (tabs))
+		Print.info('%stitleId = %s' % (tabs, self.titleId))
+		Print.info('%sversion = %x' % (tabs, self.version))
+		Print.info('%stitleType = %x' % (tabs, self.titleType))
+
+		for i in self.contentEntries:
+			Print.info('%s\tncaId: %s  type = %x' % (tabs, i.ncaId, i.type))
+		super(Cnmt, self).printInfo(maxDepth, indent)
+
+