NinjaCheetah/libWiiPy
1
0
Fork 0
mirror of https://github.com/NinjaCheetah/libWiiPy.git synced 2025-04-26 05:11:02 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #16 from NinjaCheetah/wad_packing

Browse Source 
Full WAD packing support
This commit is contained in:
Campbell 2024-04-03 18:09:44 -04:00 committed by GitHub
commit b3b10f9315
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
11 changed files with 1220 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
README.md
View File

@ -6,6 +6,11 @@ libWiiPy is inspired by [libWiiSharp](https://github.com/TheShadowEevee/libWiiSh
**Note:** While libWiiPy is directly inspired by libWiiSharp and aims to have feature parity with it, no code from either libWiiSharp or Wii.py was used in the making of this library. All code is original and is written by [@NinjaCheetah](https://github.com/NinjaCheetah), [@rvtr](https://github.com/rvtr), and any other GitHub contributors.
# Features
This list will expand as libWiiPy is developed, but these features are currently available:
- TMD, ticket, and WAD parsing
- WAD content extraction, decryption, re-encryption, and packing
# Usage
A wiki, and in the future a potential documenation site, is being worked on, and can be accessed [here](https://github.com/NinjaCheetah/libWiiPy/wiki). It is currently fairly barebones, but it will be improved in the future.

11
src/libWiiPy/__init__.py
View File

@ -0,0 +1,11 @@
# "__init__.py" from libWiiPy by NinjaCheetah & Contributors
# https://github.com/NinjaCheetah/libWiiPy
#
# These are the essential modules from libWiiPy that you'd probably want imported by default.
from .commonkeys import *
from .content import *
from .ticket import *
from .title import *
from .tmd import *
from .wad import *

5
src/libWiiPy/commonkeys.py
View File

@ -8,8 +8,9 @@ korean_key = '63b82bb4f4614e2e13f2fefbba4c9b7e'
vwii_key = '30bfc76e7c19afbb23163330ced7c28d'
def get_common_key(common_key_index):
"""Gets the specified Wii Common Key based on the index provided.
def get_common_key(common_key_index) -> bytes:
"""
Gets the specified Wii Common Key based on the index provided.
Possible values for common_key_index: 0: Common Key, 1: Korean Key, 2: vWii Key

310
src/libWiiPy/content.py
View File

@ -8,27 +8,41 @@ import sys
import hashlib
from typing import List
from .types import ContentRecord
from .crypto import decrypt_content
from .crypto import decrypt_content, encrypt_content
class ContentRegion:
"""Creates a ContentRegion object to parse the continuous content region of a WAD.
"""
A ContentRegion object to parse the continuous content region of a WAD. Allows for retrieving content from the
region in both encrypted or decrypted form, and setting new content.
Attributes
----------
content_records : List[ContentRecord]
The content records for the content stored in the region.
num_contents : int
The total number of contents stored in the region.
"""
def __init__(self):
self.content_records: List[ContentRecord] = []
self.content_region_size: int = 0 # Size of the content region.
self.num_contents: int = 0 # Number of contents in the content region.
self.content_start_offsets: List[int] = [0] # The start offsets of each content in the content region.
self.content_list: List[bytes] = []
def load(self, content_region: bytes, content_records: List[ContentRecord]) -> None:
"""
Loads the raw content region and builds a list of all the contents.
Parameters
----------
content_region : bytes
A bytes object containing the content region of a WAD file.
The raw data for the content region being loaded.
content_records : list[ContentRecord]
A list of ContentRecord objects detailing all contents contained in the region.
"""
def __init__(self, content_region, content_records: List[ContentRecord]):
self.content_region = content_region
self.content_records = content_records
self.content_region_size: int # Size of the content region.
self.num_contents: int # Number of contents in the content region.
self.content_start_offsets: List[int] = [0] # The start offsets of each content in the content region.
with io.BytesIO(content_region) as content_region_data:
# Get the total size of the content region.
self.content_region_size = sys.getsizeof(content_region_data)
@ -41,9 +55,49 @@ class ContentRegion:
if (content.content_size % 64) != 0:
start_offset += 64 - (content.content_size % 64)
self.content_start_offsets.append(start_offset)
# Build a list of all the encrypted content data.
for content in range(len(self.content_start_offsets)):
# Seek to the start of the content based on the list of offsets.
content_region_data.seek(self.content_start_offsets[content])
# Calculate the number of bytes we need to read by adding bytes up the nearest multiple of 16 if needed.
bytes_to_read = self.content_records[content].content_size
if (bytes_to_read % 16) != 0:
bytes_to_read += 16 - (bytes_to_read % 16)
# Read the file based on the size of the content in the associated record, then append that data to
# the list of content.
content_enc = content_region_data.read(bytes_to_read)
self.content_list.append(content_enc)
def get_enc_content(self, index: int) -> bytes:
"""Gets an individual content from the content region based on the provided content record, in encrypted form.
def dump(self) -> bytes:
"""
Takes the list of contents and assembles them back into one content region. Returns this content region as a
bytes object and sets the raw content region variable to this result, then calls load() again to make sure the
content list matches the raw data.
Returns
-------
bytes
The full WAD file as bytes.
"""
# Open the stream and begin writing data to it.
with io.BytesIO() as content_region_data:
for content in self.content_list:
# Calculate padding after this content before the next one.
padding_bytes = 0
if (len(content) % 64) != 0:
padding_bytes = 64 - (len(content) % 64)
# Write content data, then the padding afterward if necessary.
content_region_data.write(content)
if padding_bytes > 0:
content_region_data.write(b'\x00' * padding_bytes)
content_region_data.seek(0x0)
content_region_raw = content_region_data.read()
# Return the raw ContentRegion for the data contained in the object.
return content_region_raw
def get_enc_content_by_index(self, index: int) -> bytes:
"""
Gets an individual content from the content region based on the provided index, in encrypted form.
Parameters
----------
@ -55,19 +109,50 @@ class ContentRegion:
bytes
The encrypted content listed in the content record.
"""
with io.BytesIO(self.content_region) as content_region_data:
# Seek to the start of the requested content based on the list of offsets.
content_region_data.seek(self.content_start_offsets[index])
# Calculate the number of bytes we need to read by adding bytes up the nearest multiple of 16 if needed.
bytes_to_read = self.content_records[index].content_size
if (bytes_to_read % 16) != 0:
bytes_to_read += 16 - (bytes_to_read % 16)
# Read the file based on the size of the content in the associated record.
content_enc = content_region_data.read(bytes_to_read)
content_enc = self.content_list[index]
return content_enc
def get_content(self, index: int, title_key: bytes) -> bytes:
"""Gets an individual content from the content region based on the provided content record, in decrypted form.
def get_enc_content_by_cid(self, cid: int) -> bytes:
"""
Gets an individual content from the content region based on the provided Content ID, in encrypted form.
Parameters
----------
cid : int
The Content ID of the content you want to get. Expected to be in decimal form.
Returns
-------
bytes
The encrypted content listed in the content record.
"""
# Find the index of the requested Content ID.
content_index = None
for content in self.content_records:
if content.content_id == cid:
content_index = content.index
# If finding a matching ID was unsuccessful, that means that no content with that ID is in the TMD, so
# return a Value Error.
if content_index is None:
raise ValueError("The Content ID requested does not exist in the TMD's content records.")
# Call get_enc_content_by_index() using the index we just found.
content_enc = self.get_enc_content_by_index(content_index)
return content_enc
def get_enc_contents(self) -> List[bytes]:
"""
Gets a list of all encrypted contents from the content region.
Returns
-------
List[bytes]
A list containing all encrypted contents.
"""
return self.content_list
def get_content_by_index(self, index: int, title_key: bytes) -> bytes:
"""
Gets an individual content from the content region based on the provided index, in decrypted form.
Parameters
----------
@ -82,17 +167,188 @@ class ContentRegion:
The decrypted content listed in the content record.
"""
# Load the encrypted content at the specified index and then decrypt it with the Title Key.
content_enc = self.get_enc_content(index)
content_enc = self.get_enc_content_by_index(index)
content_dec = decrypt_content(content_enc, title_key, self.content_records[index].index,
self.content_records[index].content_size)
# Hash the decrypted content and ensure that the hash matches the one in its Content Record.
# If it does not, then something has gone wrong in the decryption, and an error will be thrown.
content_dec_hash = hashlib.sha1(content_dec)
content_dec_hash = hashlib.sha1(content_dec).hexdigest()
content_record_hash = str(self.content_records[index].content_hash.decode())
# Compare the hash and throw a ValueError if the hash doesn't match.
if content_dec_hash.hexdigest() != content_record_hash:
if content_dec_hash != content_record_hash:
raise ValueError("Content hash did not match the expected hash in its record! The incorrect Title Key may "
"have been used!.\n"
"Expected hash is: {}\n".format(content_record_hash) +
"Actual hash is: {}".format(content_dec_hash.hexdigest()))
"Actual hash is: {}".format(content_dec_hash))
return content_dec
def get_content_by_cid(self, cid: int, title_key: bytes) -> bytes:
"""
Gets an individual content from the content region based on the provided Content ID, in decrypted form.
Parameters
----------
cid : int
The Content ID of the content you want to get. Expected to be in decimal form.
title_key : bytes
The Title Key for the title the content is from.
Returns
-------
bytes
The decrypted content listed in the content record.
"""
# Find the index of the requested Content ID.
content_index = None
for content in self.content_records:
if content.content_id == cid:
content_index = content.index
# If finding a matching ID was unsuccessful, that means that no content with that ID is in the TMD, so
# return a Value Error.
if content_index is None:
raise ValueError("The Content ID requested does not exist in the TMD's content records.")
# Call get_content_by_index() using the index we just found.
content_dec = self.get_content_by_index(content_index, title_key)
return content_dec
def get_contents(self, title_key: bytes) -> List[bytes]:
"""
Gets a list of all contents from the content region, in decrypted form.
Parameters
----------
title_key : bytes
The Title Key for the title the content is from.
Returns
-------
List[bytes]
A list containing all decrypted contents.
"""
dec_contents: List[bytes] = []
# Iterate over every content, get the decrypted version of it, then add it to a list and return it.
for content in range(self.num_contents):
dec_contents.append(self.get_content_by_index(content, title_key))
return dec_contents
def set_enc_content(self, enc_content: bytes, cid: int, index: int, content_type: int, content_size: int,
content_hash: bytes) -> None:
"""
Sets the provided index to a new content with the provided Content ID. Hashes and size of the content are
set in the content record, with a new record being added if necessary.
Parameters
----------
enc_content : bytes
The new encrypted content to set.
cid : int
The Content ID to assign the new content in the content record.
index : int
The index to place the new content at.
content_type : int
The type of the new content.
content_size : int
The size of the new encrypted content when decrypted.
content_hash : bytes
The hash of the new encrypted content when decrypted.
"""
# Save the number of contents currently in the content region and records.
num_contents = len(self.content_records)
# Check if a record already exists for this index. If it doesn't, create it.
if (index + 1) > num_contents:
# Ensure that you aren't attempting to create a gap before appending.
if (index + 1) > num_contents + 1:
raise ValueError("You are trying to set the content at position " + str(index) + ", but no content "
"exists at position " + str(index - 1) + "!")
self.content_records.append(ContentRecord(cid, index, content_type, content_size, content_hash))
# If it does, reassign the values in it.
else:
self.content_records[index].content_id = cid
self.content_records[index].content_type = content_type
self.content_records[index].content_size = content_size
self.content_records[index].content_hash = content_hash
# Check if a content already occupies the provided index. If it does, reassign it to the new content, if it
# doesn't, then append a new entry.
if (index + 1) > num_contents:
self.content_list.append(enc_content)
else:
self.content_list[index] = enc_content
def set_content(self, dec_content: bytes, cid: int, index: int, content_type: int, title_key: bytes) -> None:
"""
Sets the provided index to a new content with the provided Content ID. Hashes and size of the content are
set in the content record, with a new record being added if necessary.
Parameters
----------
dec_content : bytes
The new decrypted content to set.
cid : int
The Content ID to assign the new content in the content record.
index : int
The index to place the new content at.
content_type : int
The type of the new content.
title_key : bytes
The Title Key that matches the new decrypted content.
"""
# Store the size of the new content.
dec_content_size = len(dec_content)
# Calculate the hash of the new content.
dec_content_hash = str.encode(hashlib.sha1(dec_content).hexdigest())
# Encrypt the content using the provided Title Key and index.
enc_content = encrypt_content(dec_content, title_key, index)
# Pass values to set_enc_content()
self.set_enc_content(enc_content, cid, index, content_type, dec_content_size, dec_content_hash)
def load_enc_content(self, enc_content: bytes, index: int) -> None:
"""
Loads the provided encrypted content into the content region at the specified index, with the assumption that
it matches the record at that index. Not recommended for most use cases, use decrypted content and
load_content() instead.
Parameters
----------
enc_content : bytes
The encrypted content to load.
index : int
The content index to load the content at.
"""
if (index + 1) > len(self.content_records) or len(self.content_records) == 0:
raise IndexError("No content records have been loaded, or that index is higher than the highest entry in "
"the content records.")
if (index + 1) > len(self.content_list):
self.content_list.append(enc_content)
else:
self.content_list[index] = enc_content
def load_content(self, dec_content: bytes, index: int, title_key: bytes) -> None:
"""
Loads the provided decrypted content into the content region at the specified index, but first checks to make
sure it matches the record at that index before loading. This content will be encrypted when loaded.
Parameters
----------
dec_content : bytes
The decrypted content to load.
index : int
The content index to load the content at.
title_key: bytes
The Title Key that matches the decrypted content.
"""
# Make sure that content records exist and that the provided index exists in them.
if (index + 1) > len(self.content_records) or len(self.content_records) == 0:
raise IndexError("No content records have been loaded, or that index is higher than the highest entry in "
"the content records.")
# Check the hash of the content against the hash stored in the record to ensure it matches.
content_hash = hashlib.sha1(dec_content).hexdigest()
if content_hash != self.content_records[index].content_hash.decode():
raise ValueError("The decrypted content provided does not match the record at the provided index. \n"
"Expected hash is: {}\n".format(self.content_records[index].content_hash.decode()) +
"Actual hash is: {}".format(content_hash))
# If the hash matches, encrypt the content and set it where it belongs.
enc_content = encrypt_content(dec_content, title_key, index)
if (index + 1) > len(self.content_list):
self.content_list.append(enc_content)
else:
self.content_list[index] = enc_content

54
src/libWiiPy/crypto.py
View File

@ -7,7 +7,8 @@ from Crypto.Cipher import AES
def decrypt_title_key(title_key_enc, common_key_index, title_id) -> bytes:
"""Gets the decrypted version of the encrypted Title Key provided.
"""
Gets the decrypted version of the encrypted Title Key provided.
Requires the index of the common key to use, and the Title ID of the title that the Title Key is for.
@ -37,9 +38,11 @@ def decrypt_title_key(title_key_enc, common_key_index, title_id) -> bytes:
def decrypt_content(content_enc, title_key, content_index, content_length) -> bytes:
"""Gets the decrypted version of the encrypted content.
"""
Gets the decrypted version of the encrypted content.
Requires the index of the common key to use, and the Title ID of the title that the Title Key is for.
This requires the index of the content to decrypt as it is used as the IV, as well as the content length to adjust
padding as necessary.
Parameters
----------
@ -61,9 +64,9 @@ def decrypt_content(content_enc, title_key, content_index, content_length) -> by
content_index_bin = struct.pack('>H', content_index)
while len(content_index_bin) < 16:
content_index_bin += b'\x00'
# Align content to 64 bytes to ensure that all the data is being decrypted, and so it works with AES encryption.
if (len(content_enc) % 64) != 0:
content_enc = content_enc + (b'\x00' * (64 - (len(content_enc) % 64)))
# Align content to 16 bytes to ensure that it works with AES encryption.
if (len(content_enc) % 16) != 0:
content_enc = content_enc + (b'\x00' * (16 - (len(content_enc) % 16)))
# Create a new AES object with the values provided, with the content's unique ID as the IV.
aes = AES.new(title_key, AES.MODE_CBC, content_index_bin)
# Decrypt the content using the AES object.
@ -72,3 +75,42 @@ def decrypt_content(content_enc, title_key, content_index, content_length) -> by
while len(content_dec) > content_length:
content_dec = content_dec[:-1]
return content_dec
def encrypt_content(content_dec, title_key, content_index) -> bytes:
"""
Gets the encrypted version of the decrypted content.
This requires the index of the content to encrypt as it is used as the IV, as well as the content length to adjust
padding as necessary.
Parameters
----------
content_dec : bytes
The decrypted content.
title_key : bytes
The Title Key for the title the content is from.
content_index : int
The index in the TMD's content record of the content being decrypted.
Returns
-------
bytes
The encrypted content.
"""
# Generate the IV from the Content Index of the content to be decrypted.
content_index_bin = struct.pack('>H', content_index)
while len(content_index_bin) < 16:
content_index_bin += b'\x00'
# Calculate the intended size of the encrypted content.
enc_size = len(content_dec) + (16 - (len(content_dec) % 16))
# Align content to 16 bytes to ensure that it works with AES encryption.
if (len(content_dec) % 16) != 0:
content_dec = content_dec + (b'\x00' * (16 - (len(content_dec) % 16)))
# Create a new AES object with the values provided, with the content's unique ID as the IV.
aes = AES.new(title_key, AES.MODE_CBC, content_index_bin)
# Encrypt the content using the AES object.
content_enc = aes.encrypt(content_dec)
# Trim down the encrypted content.
content_enc = content_enc[:enc_size]
return content_enc

47
src/libWiiPy/shared.py
View File

@ -0,0 +1,47 @@
# "shared.py" from libWiiPy by NinjaCheetah & Contributors
# https://github.com/NinjaCheetah/libWiiPy
#
# This file defines general functions that may be useful in other modules of libWiiPy. Putting them here cuts down on
# clutter in other files.
def align_value(value, alignment=64) -> int:
"""
Aligns the provided value to the set alignment (defaults to 64).
Parameters
----------
value : int
The value to align.
alignment : int
The number to align to. Defaults to 64.
Returns
-------
int
The aligned value.
"""
if (value % alignment) != 0:
aligned_value = value + (alignment - (value % alignment))
return aligned_value
return value
def pad_bytes_stream(data, alignment=64) -> bytes:
"""
Pads the provided bytes stream to the provided alignment (defaults to 64).
Parameters
----------
data : BytesIO
The data to align.
alignment : int
The number to align to. Defaults to 64.
Returns
-------
BytesIO
The aligned data.
"""
while (data.getbuffer().nbytes % alignment) != 0:
data.write(b'\x00')
return data

227
src/libWiiPy/ticket.py
View File

@ -4,37 +4,15 @@
# See https://wiibrew.org/wiki/Ticket for details about the ticket format
import io
import binascii
from .crypto import decrypt_title_key
from dataclasses import dataclass
from .types import TitleLimit
from typing import List
@dataclass
class TitleLimit:
"""Creates a TitleLimit object that contains the type of restriction and the limit.
Attributes
----------
limit_type : int
The type of play limit applied.
maximum_usage : int
The maximum value for the type of play limit applied.
"""
# The type of play limit applied. The following types exist:
# 0 = None, 1 = Time Limit, 3 = None, 4 = Launch Count
limit_type: int
# The maximum value of the limit applied.
# This is either the number of minutes for a time limit, or the number of launches for a launch limit.
maximum_usage: int
class Ticket:
"""Creates a Ticket object to parse a Ticket file to retrieve the Title Key needed to decrypt it.
Parameters
----------
ticket : bytes
A bytes object containing the contents of a ticket file.
"""
A Ticket object that allows for either loading and editing an existing Ticket or creating one manually if desired.
Attributes
----------
@ -53,89 +31,188 @@ class Ticket:
common_key_index : int
The index of the common key required to decrypt this ticket's Title Key.
"""
def __init__(self, ticket):
self.ticket = ticket
def __init__(self):
# Signature blob header
self.signature_type: bytes # Type of signature, always 0x10001 for RSA-2048
self.signature: bytes # Actual signature data
self.signature_type: bytes = b'' # Type of signature, always 0x10001 for RSA-2048
self.signature: bytes = b'' # Actual signature data
# v0 ticket data
self.signature_issuer: str # Who issued the signature for the ticket
self.ecdh_data: bytes # Involved in created one-time keys for console-specific title installs.
self.ticket_version: int # The version of the current ticket file.
self.title_key_enc: bytes # The title key of the ticket's respective title, encrypted by a common key.
self.ticket_id: bytes # Used as the IV when decrypting the title key for console-specific title installs.
self.console_id: int # ID of the console that the ticket was issued for.
self.title_id: bytes # TID/IV used for AES-CBC encryption.
self.title_version: int # Version of the ticket's associated title.
self.permitted_titles: bytes # Permitted titles mask
self.permit_mask: bytes # "Permit mask. The current disc title is ANDed with the inverse of this mask to see if the result matches the Permitted Titles Mask."
self.title_export_allowed: int # Whether title export is allowed with a PRNG key or not.
self.common_key_index: int # Which common key should be used. 0 = Common Key, 1 = Korean Key, 2 = vWii Key
self.content_access_permissions: bytes # "Content access permissions (one bit for each content)"
self.signature_issuer: str = "" # Who issued the signature for the ticket
self.ecdh_data: bytes = b'' # Involved in created one-time keys for console-specific title installs.
self.ticket_version: int = 0 # The version of the current ticket file.
self.title_key_enc: bytes = b'' # The title key of the ticket's respective title, encrypted by a common key.
self.ticket_id: bytes = b'' # Used as the IV when decrypting the title key for console-specific title installs.
self.console_id: int = 0 # ID of the console that the ticket was issued for.
self.title_id: bytes = b'' # TID/IV used for AES-CBC encryption.
self.title_id_str: str = "" # TID in string form for comparing against the TMD.
self.unknown1: bytes = b'' # Some unknown data, not always the same so reading it just in case.
self.title_version: int = 0 # Version of the ticket's associated title.
self.permitted_titles: bytes = b'' # Permitted titles mask
self.permit_mask: bytes = b'' # "Permit mask. The current disc title is ANDed with the inverse of this mask to see if the result matches the Permitted Titles Mask."
self.title_export_allowed: int = 0 # Whether title export is allowed with a PRNG key or not.
self.common_key_index: int = 0 # Which common key should be used. 0 = Common Key, 1 = Korean Key, 2 = vWii Key
self.unknown2: bytes = b'' # More unknown data. Varies for VC/non-VC titles so reading it to ensure it matches.
self.content_access_permissions: bytes = b'' # "Content access permissions (one bit for each content)"
self.title_limits_list: List[TitleLimit] = [] # List of play limits applied to the title.
# v1 ticket data
# TODO: Figure out v1 ticket stuff
with io.BytesIO(self.ticket) as ticket_data:
# TODO: Write in v1 ticket attributes here. This code can currently only handle v0 tickets, and will reject v1.
def load(self, ticket: bytes) -> None:
"""
Loads raw Ticket data and sets all attributes of the WAD object. This allows for manipulating an already
existing Ticket.
Parameters
----------
ticket : bytes
The data for the Ticket you wish to load.
"""
with io.BytesIO(ticket) as ticket_data:
# ====================================================================================
# Parses each of the keys contained in the Ticket.
# ====================================================================================
# Signature type
# Signature type.
ticket_data.seek(0x0)
self.signature_type = ticket_data.read(4)
# Signature data
# Signature data.
ticket_data.seek(0x04)
self.signature = ticket_data.read(256)
# Signature issuer
# Signature issuer.
ticket_data.seek(0x140)
self.signature_issuer = str(ticket_data.read(64).decode())
# ECDH data
# ECDH data.
ticket_data.seek(0x180)
self.ecdh_data = ticket_data.read(60)
# Ticket version
# Ticket version.
ticket_data.seek(0x1BC)
self.ticket_version = int.from_bytes(ticket_data.read(1))
# Title Key (Encrypted by a common key)
if self.ticket_version == 1:
raise ValueError("This appears to be a v1 ticket, which is not currently supported by libWiiPy. This "
"feature is planned for a later release. Only v0 tickets are supported at this time.")
# Title Key (Encrypted by a common key).
ticket_data.seek(0x1BF)
self.title_key_enc = ticket_data.read(16)
# Ticket ID
# Ticket ID.
ticket_data.seek(0x1D0)
self.ticket_id = ticket_data.read(8)
# Console ID
# Console ID.
ticket_data.seek(0x1D8)
self.console_id = int.from_bytes(ticket_data.read(4))
# Title ID
# Title ID.
ticket_data.seek(0x1DC)
self.title_id = ticket_data.read(8)
# Title version
# Title ID (as a string).
title_id_hex = binascii.hexlify(self.title_id)
self.title_id_str = str(title_id_hex.decode())
# Unknown data 1.
ticket_data.seek(0x1E4)
self.unknown1 = ticket_data.read(2)
# Title version.
ticket_data.seek(0x1E6)
title_version_high = int.from_bytes(ticket_data.read(1)) * 256
ticket_data.seek(0x1E7)
title_version_low = int.from_bytes(ticket_data.read(1))
self.title_version = title_version_high + title_version_low
# Permitted titles mask
# Permitted titles mask.
ticket_data.seek(0x1E8)
self.permitted_titles = ticket_data.read(4)
# Permit mask
# Permit mask.
ticket_data.seek(0x1EC)
self.permit_mask = ticket_data.read(4)
# Whether title export with a PRNG key is allowed
# Whether title export with a PRNG key is allowed.
ticket_data.seek(0x1F0)
self.title_export_allowed = int.from_bytes(ticket_data.read(1))
# Common key index
# Common key index.
ticket_data.seek(0x1F1)
self.common_key_index = int.from_bytes(ticket_data.read(1))
# Content access permissions
# Unknown data 2.
ticket_data.seek(0x1F2)
self.unknown2 = ticket_data.read(48)
# Content access permissions.
ticket_data.seek(0x222)
self.content_access_permissions = ticket_data.read(64)
# Content limits
# Content limits.
ticket_data.seek(0x264)
for limit in range(0, 8):
limit_type = int.from_bytes(ticket_data.read(4))
limit_value = int.from_bytes(ticket_data.read(4))
self.title_limits_list.append(TitleLimit(limit_type, limit_value))
def get_title_id(self):
"""Gets the Title ID of the ticket's associated title.
def dump(self) -> bytes:
"""
Dumps the Ticket object back into bytes. This also sets the raw Ticket attribute of Ticket object to the
dumped data, and triggers load() again to ensure that the raw data and object match.
Returns
-------
bytes
The full Ticket file as bytes.
"""
# Open the stream and begin writing to it.
with io.BytesIO() as ticket_data:
# Signature type.
ticket_data.write(self.signature_type)
# Signature data.
ticket_data.write(self.signature)
# Padding to 64 bytes.
ticket_data.write(b'\x00' * 60)
# Signature issuer.
ticket_data.write(str.encode(self.signature_issuer))
# ECDH data.
ticket_data.write(self.ecdh_data)
# Ticket version.
ticket_data.write(int.to_bytes(self.ticket_version, 1))
# Reserved (all \0x00).
ticket_data.write(b'\x00\x00')
# Title Key.
ticket_data.write(self.title_key_enc)
# Unknown (write \0x00).
ticket_data.write(b'\x00')
# Ticket ID.
ticket_data.write(self.ticket_id)
# Console ID.
ticket_data.write(int.to_bytes(self.console_id, 4))
# Title ID.
ticket_data.write(self.title_id)
# Unknown data 1.
ticket_data.write(self.unknown1)
# Title version.
title_version_high = round(self.title_version / 256)
ticket_data.write(int.to_bytes(title_version_high, 1))
title_version_low = self.title_version % 256
ticket_data.write(int.to_bytes(title_version_low, 1))
# Permitted titles mask.
ticket_data.write(self.permitted_titles)
# Permit mask.
ticket_data.write(self.permit_mask)
# Title Export allowed.
ticket_data.write(int.to_bytes(self.title_export_allowed, 1))
# Common Key index.
ticket_data.write(int.to_bytes(self.common_key_index, 1))
# Unknown data 2.
ticket_data.write(self.unknown2)
# Content access permissions.
ticket_data.write(self.content_access_permissions)
# Padding (always \x00).
ticket_data.write(b'\x00\x00')
# Iterate over Title Limit objects, write them back into raw data, then add them to the Ticket.
for title_limit in range(len(self.title_limits_list)):
title_limit_data = io.BytesIO()
# Write all fields from the title limit entry.
title_limit_data.write(int.to_bytes(self.title_limits_list[title_limit].limit_type, 4))
title_limit_data.write(int.to_bytes(self.title_limits_list[title_limit].maximum_usage, 4))
# Seek to the start and write the entry to the Ticket.
title_limit_data.seek(0x0)
ticket_data.write(title_limit_data.read())
title_limit_data.close()
# Set the Ticket attribute of the object to the new raw Ticket.
ticket_data.seek(0x0)
ticket_data_raw = ticket_data.read()
# Return the raw TMD for the data contained in the object.
return ticket_data_raw
def get_title_id(self) -> str:
"""
Gets the Title ID of the ticket's associated title.
Returns
-------
@ -145,8 +222,9 @@ class Ticket:
title_id_str = str(self.title_id.decode())
return title_id_str
def get_common_key_type(self):
"""Gets the name of the common key used to encrypt the Title Key contained in the ticket.
def get_common_key_type(self) -> str:
"""
Gets the name of the common key used to encrypt the Title Key contained in the ticket.
Returns
-------
@ -165,8 +243,9 @@ class Ticket:
case 2:
return "vWii"
def get_title_key(self):
"""Gets the decrypted title key contained in the ticket.
def get_title_key(self) -> bytes:
"""
Gets the decrypted title key contained in the ticket.
Returns
-------
@ -175,3 +254,17 @@ class Ticket:
"""
title_key = decrypt_title_key(self.title_key_enc, self.common_key_index, self.title_id)
return title_key
def set_title_id(self, title_id) -> None:
"""
Sets the Title ID of the title in the Ticket.
Parameters
----------
title_id : str
The new Title ID of the title.
"""
if len(title_id) != 16:
raise ValueError("Invalid Title ID! Title IDs must be 8 bytes long.")
self.title_id_str = title_id
self.title_id = binascii.unhexlify(title_id)

234
src/libWiiPy/title.py Normal file
View File

@ -0,0 +1,234 @@
# "title.py" from libWiiPy by NinjaCheetah & Contributors
# https://github.com/NinjaCheetah/libWiiPy
#
# See https://wiibrew.org/wiki/Title for details about how titles are formatted
from .content import ContentRegion
from .ticket import Ticket
from .tmd import TMD
from .wad import WAD
class Title:
"""
A Title object that contains all components of a title, and allows altering them. Provides higher-level access
than manually creating WAD, TMD, Ticket, and ContentRegion objects and ensures that any data that needs to match
between files matches.
Attributes
----------
wad : WAD
A WAD object of a WAD containing the title's data.
tmd : TMD
A TMD object of the title's TMD.
ticket : Ticket
A Ticket object of the title's Ticket.
content: ContentRegion
A ContentRegion object containing the title's contents.
"""
def __init__(self):
self.wad: WAD = WAD()
self.tmd: TMD = TMD()
self.ticket: Ticket = Ticket()
self.content: ContentRegion = ContentRegion()
def load_wad(self, wad: bytes) -> None:
"""
Load existing WAD data into the title and create WAD, TMD, Ticket, and ContentRegion objects based off of it
to allow you to modify that data. Note that this will overwrite any existing data for this title.
Parameters
----------
wad : bytes
The data for the WAD you wish to load.
"""
# Create a new WAD object based on the WAD data provided.
self.wad = WAD()
self.wad.load(wad)
# Load the TMD.
self.tmd = TMD()
self.tmd.load(self.wad.get_tmd_data())
# Load the ticket.
self.ticket = Ticket()
self.ticket.load(self.wad.get_ticket_data())
# Load the content.
self.content = ContentRegion()
self.content.load(self.wad.get_content_data(), self.tmd.content_records)
# Ensure that the Title IDs of the TMD and Ticket match before doing anything else. If they don't, throw an
# error because clearly something strange has gone on with the WAD and editing it probably won't work.
if self.tmd.title_id != self.ticket.title_id_str:
raise ValueError("The Title IDs of the TMD and Ticket in this WAD do not match. This WAD appears to be "
"invalid.")
def dump_wad(self) -> bytes:
"""
Dumps all title components (TMD, Ticket, and contents) back into the WAD object, and then dumps the WAD back
into raw data and returns it.
Returns
-------
wad_data : bytes
The raw data of the WAD.
"""
# Dump the TMD and set it in the WAD.
self.wad.set_tmd_data(self.tmd.dump())
# Dump the Ticket and set it in the WAD.
self.wad.set_ticket_data(self.ticket.dump())
# Dump the ContentRegion and set it in the WAD.
self.wad.set_content_data(self.content.dump())
# Dump the WAD with the new regions back into raw data and return it.
wad_data = self.wad.dump()
return wad_data
def load_tmd(self, tmd: bytes) -> None:
"""
Load existing TMD data into the title. Note that this will overwrite any existing TMD data for this title.
Parameters
----------
tmd : bytes
The data for the WAD you wish to load.
"""
# Load TMD.
self.tmd.load(tmd)
def load_ticket(self, ticket: bytes) -> None:
"""
Load existing Ticket data into the title. Note that this will overwrite any existing Ticket data for this
title.
Parameters
----------
ticket : bytes
The data for the WAD you wish to load.
"""
# Load Ticket.
self.ticket.load(ticket)
def load_content_records(self) -> None:
"""
Load content records from the TMD into the ContentRegion to allow loading content files based on the records.
This requires that a TMD has already been loaded and will throw an exception if it isn't.
"""
if not self.tmd.content_records:
ValueError("No TMD appears to have been loaded, so content records cannot be read from it.")
# Load the content records into the ContentRegion object.
self.content.content_records = self.tmd.content_records
def set_title_id(self, title_id: str) -> None:
"""
Sets the Title ID of the title in both the TMD and Ticket.
Parameters
----------
title_id : str
The new Title ID of the title.
"""
if len(title_id) != 16:
raise ValueError("Invalid Title ID! Title IDs must be 8 bytes long.")
self.tmd.set_title_id(title_id)
self.ticket.set_title_id(title_id)
def get_content_by_index(self, index: id) -> bytes:
"""
Gets an individual content from the content region based on the provided index, in decrypted form.
Parameters
----------
index : int
The index of the content you want to get.
Returns
-------
bytes
The decrypted content listed in the content record.
"""
# Load the Title Key from the Ticket.
title_key = self.ticket.get_title_key()
# Get the decrypted content and return it.
dec_content = self.content.get_content_by_index(index, title_key)
return dec_content
def get_content_by_cid(self, cid: int) -> bytes:
"""
Gets an individual content from the content region based on the provided Content ID, in decrypted form.
Parameters
----------
cid : int
The Content ID of the content you want to get. Expected to be in decimal form.
Returns
-------
bytes
The decrypted content listed in the content record.
"""
# Load the Title Key from the Ticket.
title_key = self.ticket.get_title_key()
# Get the decrypted content and return it.
dec_content = self.content.get_content_by_cid(cid, title_key)
return dec_content
def set_enc_content(self, enc_content: bytes, cid: int, index: int, content_type: int, content_size: int,
content_hash: bytes) -> None:
"""
Sets the provided index to a new content with the provided Content ID. Hashes and size of the content are
set in the content record, with a new record being added if necessary. The TMD is also updated to match the new
records.
Parameters
----------
enc_content : bytes
The new encrypted content to set.
cid : int
The Content ID to assign the new content in the content record.
index : int
The index to place the new content at.
content_type : int
The type of the new content.
content_size : int
The size of the new encrypted content when decrypted.
content_hash : bytes
The hash of the new encrypted content when decrypted.
"""
# Set the encrypted content.
self.content.set_enc_content(enc_content, cid, index, content_type, content_size, content_hash)
# Update the TMD to match.
self.tmd.content_records = self.content.content_records
def set_content(self, dec_content: bytes, cid: int, index: int, content_type: int) -> None:
"""
Sets the provided index to a new content with the provided Content ID. Hashes and size of the content are
set in the content record, with a new record being added if necessary. The Title Key is sourced from this
title's loaded ticket. The TMD is also updated to match the new records.
Parameters
----------
dec_content : bytes
The new decrypted content to set.
cid : int
The Content ID to assign the new content in the content record.
index : int
The index to place the new content at.
content_type : int
The type of the new content.
"""
# Set the decrypted content.
self.content.set_content(dec_content, cid, index, content_type, self.ticket.get_title_key())
# Update the TMD to match.
self.tmd.content_records = self.content.content_records
def load_content(self, dec_content: bytes, index: int) -> None:
"""
Loads the provided decrypted content into the content region at the specified index, but first checks to make
sure it matches the record at that index before loading. This content will be encrypted when loaded.
Parameters
----------
dec_content : bytes
The decrypted content to load.
index : int
The content index to load the content at.
"""
# Load the decrypted content.
self.content.load_content(dec_content, index, self.ticket.get_title_key())

220
src/libWiiPy/tmd.py
View File

@ -12,12 +12,7 @@ from .types import ContentRecord
class TMD:
"""
Creates a TMD object to parse a TMD file to retrieve information about a title.
Parameters
----------
tmd : bytes
A bytes object containing the contents of a TMD file.
A TMD object that allows for either loading and editing an existing TMD or creating one manually if desired.
Attributes
----------
@ -34,90 +29,107 @@ class TMD:
num_contents : int
The number of contents listed in the TMD.
"""
def __init__(self, tmd):
self.tmd = tmd
self.sig_type: int
self.sig: bytearray
self.issuer: bytearray # Follows the format "Root-CA%08x-CP%08x"
self.tmd_version: int # This seems to always be 0 no matter what?
self.ca_crl_version: int
self.signer_crl_version: int
self.vwii: int # Whether the title is for the vWii. 0 = No, 1 = Yes
self.ios_tid: str # The Title ID of the IOS version the associated title runs on.
self.ios_version: int # The IOS version the associated title runs on.
self.title_id: str # The Title ID of the associated title.
self.content_type: str # The type of content contained within the associated title.
self.group_id: int # The ID of the publisher of the associated title.
self.region: int # The ID of the region of the associated title.
self.ratings: int
self.access_rights: int
self.title_version: int # The version of the associated title.
self.num_contents: int # The number of contents contained in the associated title.
self.boot_index: int
def __init__(self):
self.blob_header: bytes = b''
self.sig_type: int = 0
self.sig: bytes = b''
self.issuer: bytes = b'' # Follows the format "Root-CA%08x-CP%08x"
self.tmd_version: int = 0 # This seems to always be 0 no matter what?
self.ca_crl_version: int = 0
self.signer_crl_version: int = 0
self.vwii: int = 0 # Whether the title is for the vWii. 0 = No, 1 = Yes
self.ios_tid: str = "" # The Title ID of the IOS version the associated title runs on.
self.ios_version: int = 0 # The IOS version the associated title runs on.
self.title_id: str = "" # The Title ID of the associated title.
self.content_type: str = "" # The type of content contained within the associated title.
self.group_id: int = 0 # The ID of the publisher of the associated title.
self.region: int = 0 # The ID of the region of the associated title.
self.ratings: bytes = b''
self.ipc_mask: bytes = b''
self.access_rights: bytes = b''
self.title_version: int = 0 # The version of the associated title.
self.num_contents: int = 0 # The number of contents contained in the associated title.
self.boot_index: int = 0
self.content_records: List[ContentRecord] = []
# Load data from TMD file
with io.BytesIO(self.tmd) as tmd_data:
def load(self, tmd: bytes) -> None:
"""
Loads raw TMD data and sets all attributes of the WAD object. This allows for manipulating an already
existing TMD.
Parameters
----------
tmd : bytes
The data for the TMD you wish to load.
"""
with io.BytesIO(tmd) as tmd_data:
# ====================================================================================
# Parses each of the keys contained in the TMD.
# ====================================================================================
# Signing certificate issuer
tmd_data.seek(0x0)
self.blob_header = tmd_data.read(320)
# Signing certificate issuer.
tmd_data.seek(0x140)
self.issuer = tmd_data.read(64)
# TMD version, seems to usually be 0, but I've seen references to other numbers
# TMD version, seems to usually be 0, but I've seen references to other numbers.
tmd_data.seek(0x180)
self.tmd_version = int.from_bytes(tmd_data.read(1))
# TODO: label
# Root certificate crl version.
tmd_data.seek(0x181)
self.ca_crl_version = tmd_data.read(1)
# TODO: label
self.ca_crl_version = int.from_bytes(tmd_data.read(1))
# Signer crl version.
tmd_data.seek(0x182)
self.signer_crl_version = tmd_data.read(1)
# If this is a vWii title or not
self.signer_crl_version = int.from_bytes(tmd_data.read(1))
# If this is a vWii title or not.
tmd_data.seek(0x183)
self.vwii = int.from_bytes(tmd_data.read(1))
# TID of the IOS to use for the title, set to 0 if this title is the IOS, set to boot2 version if boot2
# TID of the IOS to use for the title, set to 0 if this title is the IOS, set to boot2 version if boot2.
tmd_data.seek(0x184)
ios_version_bin = tmd_data.read(8)
ios_version_hex = binascii.hexlify(ios_version_bin)
self.ios_tid = str(ios_version_hex.decode())
# Get IOS version based on TID
# Get IOS version based on TID.
self.ios_version = int(self.ios_tid[-2:], 16)
# Title ID of the title
# Title ID of the title.
tmd_data.seek(0x18C)
title_id_bin = tmd_data.read(8)
title_id_hex = binascii.hexlify(title_id_bin)
self.title_id = str(title_id_hex.decode())
# Type of content
# Type of content.
tmd_data.seek(0x194)
content_type_bin = tmd_data.read(4)
content_type_hex = binascii.hexlify(content_type_bin)
self.content_type = str(content_type_hex.decode())
# Publisher of the title
# Publisher of the title.
tmd_data.seek(0x198)
self.group_id = tmd_data.read(2)
# Region of the title, 0 = JAP, 1 = USA, 2 = EUR, 3 = NONE, 4 = KOR
self.group_id = int.from_bytes(tmd_data.read(2))
# Region of the title, 0 = JAP, 1 = USA, 2 = EUR, 3 = NONE, 4 = KOR.
tmd_data.seek(0x19C)
region_hex = tmd_data.read(2)
self.region = int.from_bytes(region_hex)
# TODO: figure this one out
# Likely the localized content rating for the title. (ESRB, CERO, PEGI, etc.)
tmd_data.seek(0x19E)
self.ratings = tmd_data.read(16)
# Access rights of the title; DVD-video access and AHBPROT
# IPC mask.
tmd_data.seek(0x1BA)
self.ipc_mask = tmd_data.read(12)
# Access rights of the title; DVD-video access and AHBPROT.
tmd_data.seek(0x1D8)
self.access_rights = tmd_data.read(4)
# Calculate the version number by multiplying 0x1DC by 256 and adding 0x1DD
# Calculate the version number by multiplying 0x1DC by 256 and adding 0x1DD.
tmd_data.seek(0x1DC)
title_version_high = int.from_bytes(tmd_data.read(1)) * 256
tmd_data.seek(0x1DD)
title_version_low = int.from_bytes(tmd_data.read(1))
self.title_version = title_version_high + title_version_low
# The number of contents listed in the TMD
# The number of contents listed in the TMD.
tmd_data.seek(0x1DE)
self.num_contents = int.from_bytes(tmd_data.read(2))
# Content index in content list that contains the boot file
# Content index in content list that contains the boot file.
tmd_data.seek(0x1E0)
self.boot_index = tmd_data.read(2)
self.boot_index = int.from_bytes(tmd_data.read(2))
# Get content records for the number of contents in num_contents.
self.content_records = []
for content in range(0, self.num_contents):
tmd_data.seek(0x1E4 + (36 * content))
content_record_hdr = struct.unpack(">LHH4x4s20s", tmd_data.read(36))
@ -126,8 +138,85 @@ class TMD:
int(content_record_hdr[2]), int.from_bytes(content_record_hdr[3]),
binascii.hexlify(content_record_hdr[4])))
def get_title_region(self):
"""Gets the region of the TMD's associated title.
def dump(self) -> bytes:
"""
Dumps the TMD object back into bytes. This also sets the raw TMD attribute of TMD object to the dumped data,
and triggers load() again to ensure that the raw data and object match.
Returns
-------
bytes
The full TMD file as bytes.
"""
# Open the stream and begin writing to it.
with io.BytesIO() as tmd_data:
# Signed blob header.
tmd_data.write(self.blob_header)
# Signing certificate issuer.
tmd_data.write(self.issuer)
# TMD version.
tmd_data.write(int.to_bytes(self.tmd_version, 1))
# Root certificate crl version.
tmd_data.write(int.to_bytes(self.ca_crl_version, 1))
# Signer crl version.
tmd_data.write(int.to_bytes(self.signer_crl_version, 1))
# If this is a vWii title or not.
tmd_data.write(int.to_bytes(self.vwii, 1))
# IOS Title ID.
tmd_data.write(binascii.unhexlify(self.ios_tid))
# Title's Title ID.
tmd_data.write(binascii.unhexlify(self.title_id))
# Content type.
tmd_data.write(binascii.unhexlify(self.content_type))
# Group ID.
tmd_data.write(int.to_bytes(self.group_id, 2))
# 2 bytes of zero for reasons.
tmd_data.write(b'\x00\x00')
# Region.
tmd_data.write(int.to_bytes(self.region, 2))
# Ratings.
tmd_data.write(self.ratings)
# Reserved (all \x00).
tmd_data.write(b'\x00' * 12)
# IPC mask.
tmd_data.write(self.ipc_mask)
# Reserved (all \x00).
tmd_data.write(b'\x00' * 18)
# Access rights.
tmd_data.write(self.access_rights)
# Title version.
title_version_high = round(self.title_version / 256)
tmd_data.write(int.to_bytes(title_version_high, 1))
title_version_low = self.title_version % 256
tmd_data.write(int.to_bytes(title_version_low, 1))
# Number of contents.
tmd_data.write(int.to_bytes(self.num_contents, 2))
# Boot index.
tmd_data.write(int.to_bytes(self.boot_index, 2))
# Minor version. Unused so write \x00.
tmd_data.write(b'\x00\x00')
# Iterate over content records, write them back into raw data, then add them to the TMD.
for content_record in range(self.num_contents):
content_data = io.BytesIO()
# Write all fields from the content record.
content_data.write(int.to_bytes(self.content_records[content_record].content_id, 4))
content_data.write(int.to_bytes(self.content_records[content_record].index, 2))
content_data.write(int.to_bytes(self.content_records[content_record].content_type, 2))
content_data.write(int.to_bytes(self.content_records[content_record].content_size, 8))
content_data.write(binascii.unhexlify(self.content_records[content_record].content_hash))
# Seek to the start and write the record to the TMD.
content_data.seek(0x0)
tmd_data.write(content_data.read())
content_data.close()
# Set the TMD attribute of the object to the new raw TMD.
tmd_data.seek(0x0)
tmd_data_raw = tmd_data.read()
# Return the raw TMD for the data contained in the object.
return tmd_data_raw
def get_title_region(self) -> str:
"""
Gets the region of the TMD's associated title.
Can be one of several possible values:
'JAP', 'USA', 'EUR', 'NONE', or 'KOR'.
@ -149,8 +238,9 @@ class TMD:
case 4:
return "KOR"
def get_is_vwii_title(self):
"""Gets whether the TMD is designed for the vWii or not.
def get_is_vwii_title(self) -> bool:
"""
Gets whether the TMD is designed for the vWii or not.
Returns
-------
@ -162,8 +252,9 @@ class TMD:
else:
return False
def get_title_type(self):
"""Gets the type of the TMD's associated title.
def get_title_type(self) -> str:
"""
Gets the type of the TMD's associated title.
Can be one of several possible values:
'System', 'Game', 'Channel', 'SystemChannel', 'GameWithChannel', or 'HiddenChannel'
@ -193,7 +284,8 @@ class TMD:
return "Unknown"
def get_content_type(self):
"""Gets the type of content contained in the TMD's associated title.
"""
Gets the type of content contained in the TMD's associated title.
Can be one of several possible values:
'Normal', 'Development/Unknown', 'Hash Tree', 'DLC', or 'Shared'
@ -217,8 +309,9 @@ class TMD:
case _:
return "Unknown"
def get_content_record(self, record):
"""Gets the content record at the specified index.
def get_content_record(self, record) -> ContentRecord:
"""
Gets the content record at the specified index.
Parameters
----------
@ -235,3 +328,16 @@ class TMD:
else:
raise IndexError("Invalid content record! TMD lists '" + str(self.num_contents - 1) +
"' contents but index was '" + str(record) + "'!")
def set_title_id(self, title_id) -> None:
"""
Sets the Title ID of the title in the ticket.
Parameters
----------
title_id : str
The new Title ID of the title.
"""
if len(title_id) != 16:
raise ValueError("Invalid Title ID! Title IDs must be 8 bytes long.")
self.title_id = title_id

25
src/libWiiPy/types.py
View File

@ -7,7 +7,9 @@ from dataclasses import dataclass
@dataclass
class ContentRecord:
"""
Creates a content record object that contains the details of a content contained in a title.
A content record object that contains the details of a content contained in a title. This information must match
the content stored at the index in the record, or else the content will not decrypt properly, as the hash of the
decrypted data will not match the hash in the content record.
Attributes
----------
@ -27,3 +29,24 @@ class ContentRecord:
content_type: int # Type of content, possible values of: 0x0001: Normal, 0x4001: DLC, 0x8001: Shared.
content_size: int # Size of the content when decrypted.
content_hash: bytes # SHA-1 hash of the content when decrypted.
@dataclass
class TitleLimit:
"""
A TitleLimit object that contains the type of restriction and the limit. The limit type can be one of the following:
0 = None, 1 = Time Limit, 3 = None, or 4 = Launch Count. The maximum usage is then either the time in minutes the
title can be played or the maximum number of launches allowed for that title, based on the type of limit applied.
Attributes
----------
limit_type : int
The type of play limit applied.
maximum_usage : int
The maximum value for the type of play limit applied.
"""
# The type of play limit applied.
# 0 = None, 1 = Time Limit, 3 = None, 4 = Launch Count
limit_type: int
# The maximum value of the limit applied.
maximum_usage: int

376
src/libWiiPy/wad.py
View File

@ -5,39 +5,70 @@
import io
import binascii
from .shared import align_value, pad_bytes_stream
class WAD:
"""
Creates a WAD object to parse the header of a WAD file and retrieve the data contained in it.
A WAD object that allows for either loading and editing an existing WAD or creating a new WAD from raw data.
Attributes
----------
wad_type : str
The type of WAD, either ib for boot2 or Is for normal installable WADs. libWiiPy only supports Is currently.
wad_cert_size : int
The size of the WAD's certificate.
wad_crl_size : int
The size of the WAD's crl.
wad_tik_size : int
The size of the WAD's Ticket.
wad_tmd_size : int
The size of the WAD's TMD.
wad_content_size : int
The size of WAD's total content region.
wad_meta_size : int
The size of the WAD's meta/footer.
"""
def __init__(self):
self.wad_hdr_size: int = 64
self.wad_type: str = "Is"
self.wad_version: bytes = b'\x00\x00'
# === Sizes ===
self.wad_cert_size: int = 0
self.wad_crl_size: int = 0
self.wad_tik_size: int = 0
self.wad_tmd_size: int = 0
# This is the size of the content region, which contains all app files combined.
self.wad_content_size: int = 0
self.wad_meta_size: int = 0
# === Data ===
self.wad_cert_data: bytes = b''
self.wad_crl_data: bytes = b''
self.wad_tik_data: bytes = b''
self.wad_tmd_data: bytes = b''
self.wad_content_data: bytes = b''
self.wad_meta_data: bytes = b''
def load(self, wad_data) -> None:
"""
Loads raw WAD data and sets all attributes of the WAD object. This allows for manipulating an already
existing WAD file.
Parameters
----------
wad : bytes
A bytes object containing the contents of a WAD file.
wad_data : bytes
The data for the WAD you wish to load.
"""
def __init__(self, wad):
self.wad = wad
self.wad_hdr_size: int
self.wad_type: str
self.wad_version: int
# === Sizes ===
self.wad_cert_size: int
self.wad_crl_size: int
self.wad_tik_size: int
self.wad_tmd_size: int
# This is the size of the content region, which contains all app files combined.
self.wad_content_size: int
self.wad_meta_size: int
# === Offsets ===
self.wad_cert_offset: int
self.wad_crl_offset: int
self.wad_tik_offset: int
self.wad_tmd_offset: int
self.wad_content_offset: int
self.wad_meta_offset: int
# Load header data from WAD stream
with io.BytesIO(self.wad) as wad_data:
with io.BytesIO(wad_data) as wad_data:
# Read the first 8 bytes of the file to ensure that it's a WAD. This will currently reject boot2 WADs, but
# this tool cannot handle them correctly right now anyway.
wad_data.seek(0x0)
wad_magic_bin = wad_data.read(8)
wad_magic_hex = binascii.hexlify(wad_magic_bin)
wad_magic = str(wad_magic_hex.decode())
if wad_magic != "0000002049730000":
raise TypeError("This does not appear to be a valid WAD file, or is a boot2 WAD, which is not currently"
" supported by this library.")
# ====================================================================================
# Get the sizes of each data region contained within the WAD.
# ====================================================================================
@ -64,95 +95,100 @@ class WAD:
# WAD content size.
wad_data.seek(0x18)
self.wad_content_size = int(binascii.hexlify(wad_data.read(4)), 16)
# Publisher of the title contained in the WAD.
# Time/build stamp for the title contained in the WAD.
wad_data.seek(0x1c)
self.wad_meta_size = int(binascii.hexlify(wad_data.read(4)), 16)
# ====================================================================================
# Calculate file offsets from sizes. Every section of the WAD is padded out to a multiple of 0x40.
# ====================================================================================
self.wad_cert_offset = self.wad_hdr_size
wad_cert_offset = self.wad_hdr_size
# crl isn't ever used, however an entry for its size exists in the header, so its calculated just in case.
self.wad_crl_offset = int(64 * round((self.wad_cert_offset + self.wad_cert_size) / 64))
self.wad_tik_offset = int(64 * round((self.wad_crl_offset + self.wad_crl_size) / 64))
self.wad_tmd_offset = int(64 * round((self.wad_tik_offset + self.wad_tik_size) / 64))
self.wad_content_offset = int(64 * round((self.wad_tmd_offset + self.wad_tmd_size) / 64))
# meta is also never used, but Nintendo's tools calculate it, so we should too.
self.wad_meta_offset = int(64 * round((self.wad_content_offset + self.wad_content_size) / 64))
wad_crl_offset = align_value(wad_cert_offset + self.wad_cert_size)
wad_tik_offset = align_value(wad_crl_offset + self.wad_crl_size)
wad_tmd_offset = align_value(wad_tik_offset + self.wad_tik_size)
# meta isn't guaranteed to be used, but some older SDK titles use it, and not reading it breaks things.
wad_meta_offset = align_value(wad_tmd_offset + self.wad_tmd_size)
wad_content_offset = align_value(wad_meta_offset + self.wad_meta_size)
# ====================================================================================
# Load data for each WAD section based on the previously calculated offsets.
# ====================================================================================
# Cert data.
wad_data.seek(wad_cert_offset)
self.wad_cert_data = wad_data.read(self.wad_cert_size)
# Crl data.
wad_data.seek(wad_crl_offset)
self.wad_crl_data = wad_data.read(self.wad_crl_size)
# Ticket data.
wad_data.seek(wad_tik_offset)
self.wad_tik_data = wad_data.read(self.wad_tik_size)
# TMD data.
wad_data.seek(wad_tmd_offset)
self.wad_tmd_data = wad_data.read(self.wad_tmd_size)
# Content data.
wad_data.seek(wad_content_offset)
self.wad_content_data = wad_data.read(self.wad_content_size)
# Meta data.
wad_data.seek(wad_meta_offset)
self.wad_meta_data = wad_data.read(self.wad_meta_size)
def get_cert_region(self):
"""Gets the offset and size of the certificate data.
def dump(self) -> bytes:
"""
Dumps the WAD object into the raw WAD file. This allows for creating a WAD file from the data contained in
the WAD object.
Returns
-------
int
The offset of the certificate data in the WAD.
int
The size of the certificate data in the WAD.
bytes
The full WAD file as bytes.
"""
return self.wad_cert_offset, self.wad_cert_size
# Open the stream and begin writing data to it.
with io.BytesIO() as wad_data:
# Lead-in data.
wad_data.write(b'\x00\x00\x00\x20')
# WAD type.
wad_data.write(str.encode(self.wad_type))
# WAD version.
wad_data.write(self.wad_version)
# WAD cert size.
wad_data.write(int.to_bytes(self.wad_cert_size, 4))
# WAD crl size.
wad_data.write(int.to_bytes(self.wad_crl_size, 4))
# WAD ticket size.
wad_data.write(int.to_bytes(self.wad_tik_size, 4))
# WAD TMD size.
wad_data.write(int.to_bytes(self.wad_tmd_size, 4))
# WAD content size.
wad_data.write(int.to_bytes(self.wad_content_size, 4))
# WAD meta size.
wad_data.write(int.to_bytes(self.wad_meta_size, 4))
wad_data = pad_bytes_stream(wad_data)
# Retrieve the cert data and write it out.
wad_data.write(self.get_cert_data())
wad_data = pad_bytes_stream(wad_data)
# Retrieve the crl data and write it out.
wad_data.write(self.get_crl_data())
wad_data = pad_bytes_stream(wad_data)
# Retrieve the ticket data and write it out.
wad_data.write(self.get_ticket_data())
wad_data = pad_bytes_stream(wad_data)
# Retrieve the TMD data and write it out.
wad_data.write(self.get_tmd_data())
wad_data = pad_bytes_stream(wad_data)
# Retrieve the meta/footer data and write it out.
wad_data.write(self.get_meta_data())
wad_data = pad_bytes_stream(wad_data)
# Retrieve the content data and write it out.
wad_data.write(self.get_content_data())
wad_data = pad_bytes_stream(wad_data)
# Seek to the beginning and save this as the WAD data for the object.
wad_data.seek(0x0)
wad_data_raw = wad_data.read()
# Return the raw WAD file for the data contained in the object.
return wad_data_raw
def get_crl_region(self):
"""Gets the offset and size of the crl data.
Returns
-------
int
The offset of the crl data in the WAD.
int
The size of the crl data in the WAD.
def get_wad_type(self) -> str:
"""
return self.wad_crl_offset, self.wad_crl_size
def get_ticket_region(self):
"""Gets the offset and size of the ticket data.
Returns
-------
int
The offset of the ticket data in the WAD.
int
The size of the ticket data in the WAD.
"""
return self.wad_tik_offset, self.wad_tik_size
def get_tmd_region(self):
"""Gets the offset and size of the TMD data.
Returns
-------
int
The offset of the TMD data in the WAD.
int
The size of the TMD data in the WAD.
"""
return self.wad_tmd_offset, self.wad_tmd_size
def get_content_region(self):
"""Gets the offset and size of the content of the WAD.
Returns
-------
int
The offset of the content data in the WAD.
int
The size of the content data in the WAD.
"""
return self.wad_content_offset, self.wad_content_size
def get_meta_region(self):
"""Gets the offset and size of the meta region of the WAD, which is typically unused.
Returns
-------
int
The offset of the meta region in the WAD.
int
The size of the meta region in the WAD.
"""
return self.wad_meta_offset, self.wad_meta_size
def get_wad_type(self):
"""Gets the type of the WAD.
Gets the type of the WAD.
Returns
-------
@ -161,80 +197,146 @@ class WAD:
"""
return self.wad_type
def get_cert_data(self):
"""Gets the certificate data from the WAD.
def get_cert_data(self) -> bytes:
"""
Gets the certificate data from the WAD.
Returns
-------
bytes
The certificate data.
"""
wad_data = io.BytesIO(self.wad)
wad_data.seek(self.wad_cert_offset)
cert_data = wad_data.read(self.wad_cert_size)
return cert_data
return self.wad_cert_data
def get_crl_data(self):
"""Gets the crl data from the WAD, if it exists.
def get_crl_data(self) -> bytes:
"""
Gets the crl data from the WAD, if it exists.
Returns
-------
bytes
The crl data.
"""
wad_data = io.BytesIO(self.wad)
wad_data.seek(self.wad_crl_offset)
crl_data = wad_data.read(self.wad_crl_size)
return crl_data
return self.wad_crl_data
def get_ticket_data(self):
"""Gets the ticket data from the WAD.
def get_ticket_data(self) -> bytes:
"""
Gets the ticket data from the WAD.
Returns
-------
bytes
The ticket data.
"""
wad_data = io.BytesIO(self.wad)
wad_data.seek(self.wad_tik_offset)
ticket_data = wad_data.read(self.wad_tik_size)
return ticket_data
return self.wad_tik_data
def get_tmd_data(self):
"""Returns the TMD data from the WAD.
def get_tmd_data(self) -> bytes:
"""
Returns the TMD data from the WAD.
Returns
-------
bytes
The TMD data.
"""
wad_data = io.BytesIO(self.wad)
wad_data.seek(self.wad_tmd_offset)
tmd_data = wad_data.read(self.wad_tmd_size)
return tmd_data
return self.wad_tmd_data
def get_content_data(self):
"""Gets the content of the WAD.
def get_content_data(self) -> bytes:
"""
Gets the content of the WAD.
Returns
-------
bytes
The content data.
"""
wad_data = io.BytesIO(self.wad)
wad_data.seek(self.wad_content_offset)
content_data = wad_data.read(self.wad_content_size)
return content_data
return self.wad_content_data
def get_meta_data(self):
"""Gets the meta region of the WAD, which is typically unused.
def get_meta_data(self) -> bytes:
"""
Gets the meta region of the WAD, which is typically unused.
Returns
-------
bytes
The meta region.
"""
wad_data = io.BytesIO(self.wad)
wad_data.seek(self.wad_meta_offset)
meta_data = wad_data.read(self.wad_meta_size)
return meta_data
return self.wad_meta_data
def set_cert_data(self, cert_data) -> None:
"""
Sets the certificate data of the WAD. Also calculates the new size.
Parameters
----------
cert_data : bytes
The new certificate data.
"""
self.wad_cert_data = cert_data
# Calculate the size of the new cert data.
self.wad_cert_size = len(cert_data)
def set_crl_data(self, crl_data) -> None:
"""
Sets the crl data of the WAD. Also calculates the new size.
Parameters
----------
crl_data : bytes
The new crl data.
"""
self.wad_crl_data = crl_data
# Calculate the size of the new crl data.
self.wad_crl_size = len(crl_data)
def set_tmd_data(self, tmd_data) -> None:
"""
Sets the TMD data of the WAD. Also calculates the new size.
Parameters
----------
tmd_data : bytes
The new TMD data.
"""
self.wad_tmd_data = tmd_data
# Calculate the size of the new TMD data.
self.wad_tmd_size = len(tmd_data)
def set_ticket_data(self, tik_data) -> None:
"""
Sets the Ticket data of the WAD. Also calculates the new size.
Parameters
----------
tik_data : bytes
The new TMD data.
"""
self.wad_tik_data = tik_data
# Calculate the size of the new Ticket data.
self.wad_tik_size = len(tik_data)
def set_content_data(self, content_data) -> None:
"""
Sets the content data of the WAD. Also calculates the new size.
Parameters
----------
content_data : bytes
The new content data.
"""
self.wad_content_data = content_data
# Calculate the size of the new content data.
self.wad_content_size = len(content_data)
def set_meta_data(self, meta_data) -> None:
"""
Sets the meta data of the WAD. Also calculates the new size.
Parameters
----------
meta_data : bytes
The new meta data.
"""
self.wad_meta_data = meta_data
# Calculate the size of the new meta data.
self.wad_meta_size = len(meta_data)