NinjaCheetah/libWiiPy
1
0
Fork 0
mirror of https://github.com/NinjaCheetah/libWiiPy.git synced 2025-04-26 13:21:01 -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. **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 # 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. 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' vwii_key = '30bfc76e7c19afbb23163330ced7c28d'
def get_common_key(common_key_index): def get_common_key(common_key_index) -> bytes:
"""Gets the specified Wii Common Key based on the index provided. """
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 Possible values for common_key_index: 0: Common Key, 1: Korean Key, 2: vWii Key

318
src/libWiiPy/content.py
View File

@ -8,27 +8,41 @@ import sys
import hashlib import hashlib
from typing import List from typing import List
from .types import ContentRecord from .types import ContentRecord
from .crypto import decrypt_content from .crypto import decrypt_content, encrypt_content
class ContentRegion: 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.
Parameters Attributes
---------- ----------
content_region : bytes content_records : List[ContentRecord]
A bytes object containing the content region of a WAD file. The content records for the content stored in the region.
content_records : list[ContentRecord] num_contents : int
A list of ContentRecord objects detailing all contents contained in the region. The total number of contents stored in the region.
""" """
def __init__(self, content_region, content_records: List[ContentRecord]): def __init__(self):
self.content_region = content_region self.content_records: List[ContentRecord] = []
self.content_records = content_records self.content_region_size: int = 0 # Size of the content region.
self.content_region_size: int # Size of the content region. self.num_contents: int = 0 # Number of contents in 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. 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
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.
"""
self.content_records = content_records
with io.BytesIO(content_region) as content_region_data: with io.BytesIO(content_region) as content_region_data:
# Get the total size of the content region. # Get the total size of the content region.
self.content_region_size = sys.getsizeof(content_region_data) self.content_region_size = sys.getsizeof(content_region_data)
@ -41,9 +55,49 @@ class ContentRegion:
if (content.content_size % 64) != 0: if (content.content_size % 64) != 0:
start_offset += 64 - (content.content_size % 64) start_offset += 64 - (content.content_size % 64)
self.content_start_offsets.append(start_offset) 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: def dump(self) -> bytes:
"""Gets an individual content from the content region based on the provided content record, in encrypted form. """
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 Parameters
---------- ----------
@ -55,19 +109,50 @@ class ContentRegion:
bytes bytes
The encrypted content listed in the content record. The encrypted content listed in the content record.
""" """
with io.BytesIO(self.content_region) as content_region_data: content_enc = self.content_list[index]
# Seek to the start of the requested content based on the list of offsets. return content_enc
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)
return content_enc
def get_content(self, index: int, title_key: bytes) -> bytes: def get_enc_content_by_cid(self, cid: int) -> bytes:
"""Gets an individual content from the content region based on the provided content record, in decrypted form. """
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 Parameters
---------- ----------
@ -82,17 +167,188 @@ class ContentRegion:
The decrypted content listed in the content record. The decrypted content listed in the content record.
""" """
# Load the encrypted content at the specified index and then decrypt it with the Title Key. # 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, content_dec = decrypt_content(content_enc, title_key, self.content_records[index].index,
self.content_records[index].content_size) self.content_records[index].content_size)
# Hash the decrypted content and ensure that the hash matches the one in its Content Record. # 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. # 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()) content_record_hash = str(self.content_records[index].content_hash.decode())
# Compare the hash and throw a ValueError if the hash doesn't match. # 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" raise ValueError("Content hash did not match the expected hash in its record! The incorrect Title Key may "
"have been used!.\n" "have been used!.\n"
"Expected hash is: {}\n".format(content_record_hash) + "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 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: 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. 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: 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 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) content_index_bin = struct.pack('>H', content_index)
while len(content_index_bin) < 16: while len(content_index_bin) < 16:
content_index_bin += b'\x00' 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. # Align content to 16 bytes to ensure that it works with AES encryption.
if (len(content_enc) % 64) != 0: if (len(content_enc) % 16) != 0:
content_enc = content_enc + (b'\x00' * (64 - (len(content_enc) % 64))) 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. # 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) aes = AES.new(title_key, AES.MODE_CBC, content_index_bin)
# Decrypt the content using the AES object. # 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: while len(content_dec) > content_length:
content_dec = content_dec[:-1] content_dec = content_dec[:-1]
return content_dec 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 # See https://wiibrew.org/wiki/Ticket for details about the ticket format
import io import io
import binascii
from .crypto import decrypt_title_key from .crypto import decrypt_title_key
from dataclasses import dataclass from .types import TitleLimit
from typing import List 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: class Ticket:
"""Creates a Ticket object to parse a Ticket file to retrieve the Title Key needed to decrypt it. """
A Ticket object that allows for either loading and editing an existing Ticket or creating one manually if desired.
Parameters
----------
ticket : bytes
A bytes object containing the contents of a ticket file.
Attributes Attributes
---------- ----------
@ -53,89 +31,188 @@ class Ticket:
common_key_index : int common_key_index : int
The index of the common key required to decrypt this ticket's Title Key. The index of the common key required to decrypt this ticket's Title Key.
""" """
def __init__(self, ticket): def __init__(self):
self.ticket = ticket
# Signature blob header # Signature blob header
self.signature_type: bytes # Type of signature, always 0x10001 for RSA-2048 self.signature_type: bytes = b'' # Type of signature, always 0x10001 for RSA-2048
self.signature: bytes # Actual signature data self.signature: bytes = b'' # Actual signature data
# v0 ticket data # v0 ticket data
self.signature_issuer: str # Who issued the signature for the ticket 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.ecdh_data: bytes = b'' # Involved in created one-time keys for console-specific title installs.
self.ticket_version: int # The version of the current ticket file. self.ticket_version: int = 0 # 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.title_key_enc: bytes = b'' # 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.ticket_id: bytes = b'' # 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.console_id: int = 0 # ID of the console that the ticket was issued for.
self.title_id: bytes # TID/IV used for AES-CBC encryption. self.title_id: bytes = b'' # TID/IV used for AES-CBC encryption.
self.title_version: int # Version of the ticket's associated title. self.title_id_str: str = "" # TID in string form for comparing against the TMD.
self.permitted_titles: bytes # Permitted titles mask self.unknown1: bytes = b'' # Some unknown data, not always the same so reading it just in case.
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_version: int = 0 # Version of the ticket's associated title.
self.title_export_allowed: int # Whether title export is allowed with a PRNG key or not. self.permitted_titles: bytes = b'' # Permitted titles mask
self.common_key_index: int # Which common key should be used. 0 = Common Key, 1 = Korean Key, 2 = vWii Key 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.content_access_permissions: bytes # "Content access permissions (one bit for each content)" 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. self.title_limits_list: List[TitleLimit] = [] # List of play limits applied to the title.
# v1 ticket data # v1 ticket data
# TODO: Figure out v1 ticket stuff # TODO: Write in v1 ticket attributes here. This code can currently only handle v0 tickets, and will reject v1.
with io.BytesIO(self.ticket) as ticket_data:
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. # Parses each of the keys contained in the Ticket.
# ==================================================================================== # ====================================================================================
# Signature type # Signature type.
ticket_data.seek(0x0) ticket_data.seek(0x0)
self.signature_type = ticket_data.read(4) self.signature_type = ticket_data.read(4)
# Signature data # Signature data.
ticket_data.seek(0x04) ticket_data.seek(0x04)
self.signature = ticket_data.read(256) self.signature = ticket_data.read(256)
# Signature issuer # Signature issuer.
ticket_data.seek(0x140) ticket_data.seek(0x140)
self.signature_issuer = str(ticket_data.read(64).decode()) self.signature_issuer = str(ticket_data.read(64).decode())
# ECDH data # ECDH data.
ticket_data.seek(0x180) ticket_data.seek(0x180)
self.ecdh_data = ticket_data.read(60) self.ecdh_data = ticket_data.read(60)
# Ticket version # Ticket version.
ticket_data.seek(0x1BC) ticket_data.seek(0x1BC)
self.ticket_version = int.from_bytes(ticket_data.read(1)) 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) ticket_data.seek(0x1BF)
self.title_key_enc = ticket_data.read(16) self.title_key_enc = ticket_data.read(16)
# Ticket ID # Ticket ID.
ticket_data.seek(0x1D0) ticket_data.seek(0x1D0)
self.ticket_id = ticket_data.read(8) self.ticket_id = ticket_data.read(8)
# Console ID # Console ID.
ticket_data.seek(0x1D8) ticket_data.seek(0x1D8)
self.console_id = int.from_bytes(ticket_data.read(4)) self.console_id = int.from_bytes(ticket_data.read(4))
# Title ID # Title ID.
ticket_data.seek(0x1DC) ticket_data.seek(0x1DC)
self.title_id = ticket_data.read(8) 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) ticket_data.seek(0x1E6)
title_version_high = int.from_bytes(ticket_data.read(1)) * 256 title_version_high = int.from_bytes(ticket_data.read(1)) * 256
ticket_data.seek(0x1E7) ticket_data.seek(0x1E7)
title_version_low = int.from_bytes(ticket_data.read(1)) title_version_low = int.from_bytes(ticket_data.read(1))
self.title_version = title_version_high + title_version_low self.title_version = title_version_high + title_version_low
# Permitted titles mask # Permitted titles mask.
ticket_data.seek(0x1E8) ticket_data.seek(0x1E8)
self.permitted_titles = ticket_data.read(4) self.permitted_titles = ticket_data.read(4)
# Permit mask # Permit mask.
ticket_data.seek(0x1EC) ticket_data.seek(0x1EC)
self.permit_mask = ticket_data.read(4) 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) ticket_data.seek(0x1F0)
self.title_export_allowed = int.from_bytes(ticket_data.read(1)) self.title_export_allowed = int.from_bytes(ticket_data.read(1))
# Common key index # Common key index.
ticket_data.seek(0x1F1) ticket_data.seek(0x1F1)
self.common_key_index = int.from_bytes(ticket_data.read(1)) 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) ticket_data.seek(0x222)
self.content_access_permissions = ticket_data.read(64) self.content_access_permissions = ticket_data.read(64)
# Content limits # Content limits.
ticket_data.seek(0x264) ticket_data.seek(0x264)
for limit in range(0, 8): for limit in range(0, 8):
limit_type = int.from_bytes(ticket_data.read(4)) limit_type = int.from_bytes(ticket_data.read(4))
limit_value = 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)) self.title_limits_list.append(TitleLimit(limit_type, limit_value))
def get_title_id(self): def dump(self) -> bytes:
"""Gets the Title ID of the ticket's associated title. """
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 Returns
------- -------
@ -145,8 +222,9 @@ class Ticket:
title_id_str = str(self.title_id.decode()) title_id_str = str(self.title_id.decode())
return title_id_str return title_id_str
def get_common_key_type(self): def get_common_key_type(self) -> str:
"""Gets the name of the common key used to encrypt the Title Key contained in the ticket. """
Gets the name of the common key used to encrypt the Title Key contained in the ticket.
Returns Returns
------- -------
@ -165,8 +243,9 @@ class Ticket:
case 2: case 2:
return "vWii" return "vWii"
def get_title_key(self): def get_title_key(self) -> bytes:
"""Gets the decrypted title key contained in the ticket. """
Gets the decrypted title key contained in the ticket.
Returns Returns
------- -------
@ -175,3 +254,17 @@ class Ticket:
""" """
title_key = decrypt_title_key(self.title_key_enc, self.common_key_index, self.title_id) title_key = decrypt_title_key(self.title_key_enc, self.common_key_index, self.title_id)
return title_key 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: class TMD:
""" """
Creates a TMD object to parse a TMD file to retrieve information about a title. A TMD object that allows for either loading and editing an existing TMD or creating one manually if desired.
Parameters
----------
tmd : bytes
A bytes object containing the contents of a TMD file.
Attributes Attributes
---------- ----------
@ -34,90 +29,107 @@ class TMD:
num_contents : int num_contents : int
The number of contents listed in the TMD. The number of contents listed in the TMD.
""" """
def __init__(self, tmd): def __init__(self):
self.tmd = tmd self.blob_header: bytes = b''
self.sig_type: int self.sig_type: int = 0
self.sig: bytearray self.sig: bytes = b''
self.issuer: bytearray # Follows the format "Root-CA%08x-CP%08x" self.issuer: bytes = b'' # Follows the format "Root-CA%08x-CP%08x"
self.tmd_version: int # This seems to always be 0 no matter what? self.tmd_version: int = 0 # This seems to always be 0 no matter what?
self.ca_crl_version: int self.ca_crl_version: int = 0
self.signer_crl_version: int self.signer_crl_version: int = 0
self.vwii: int # Whether the title is for the vWii. 0 = No, 1 = Yes 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_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.ios_version: int = 0 # The IOS version the associated title runs on.
self.title_id: str # The Title ID of the associated title. 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.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.group_id: int = 0 # The ID of the publisher of the associated title.
self.region: int # The ID of the region of the associated title. self.region: int = 0 # The ID of the region of the associated title.
self.ratings: int self.ratings: bytes = b''
self.access_rights: int self.ipc_mask: bytes = b''
self.title_version: int # The version of the associated title. self.access_rights: bytes = b''
self.num_contents: int # The number of contents contained in the associated title. self.title_version: int = 0 # The version of the associated title.
self.boot_index: int self.num_contents: int = 0 # The number of contents contained in the associated title.
self.boot_index: int = 0
self.content_records: List[ContentRecord] = [] 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. # 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) tmd_data.seek(0x140)
self.issuer = tmd_data.read(64) 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) tmd_data.seek(0x180)
self.tmd_version = int.from_bytes(tmd_data.read(1)) self.tmd_version = int.from_bytes(tmd_data.read(1))
# TODO: label # Root certificate crl version.
tmd_data.seek(0x181) tmd_data.seek(0x181)
self.ca_crl_version = tmd_data.read(1) self.ca_crl_version = int.from_bytes(tmd_data.read(1))
# TODO: label # Signer crl version.
tmd_data.seek(0x182) tmd_data.seek(0x182)
self.signer_crl_version = tmd_data.read(1) self.signer_crl_version = int.from_bytes(tmd_data.read(1))
# If this is a vWii title or not # If this is a vWii title or not.
tmd_data.seek(0x183) tmd_data.seek(0x183)
self.vwii = int.from_bytes(tmd_data.read(1)) 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) tmd_data.seek(0x184)
ios_version_bin = tmd_data.read(8) ios_version_bin = tmd_data.read(8)
ios_version_hex = binascii.hexlify(ios_version_bin) ios_version_hex = binascii.hexlify(ios_version_bin)
self.ios_tid = str(ios_version_hex.decode()) 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) self.ios_version = int(self.ios_tid[-2:], 16)
# Title ID of the title # Title ID of the title.
tmd_data.seek(0x18C) tmd_data.seek(0x18C)
title_id_bin = tmd_data.read(8) title_id_bin = tmd_data.read(8)
title_id_hex = binascii.hexlify(title_id_bin) title_id_hex = binascii.hexlify(title_id_bin)
self.title_id = str(title_id_hex.decode()) self.title_id = str(title_id_hex.decode())
# Type of content # Type of content.
tmd_data.seek(0x194) tmd_data.seek(0x194)
content_type_bin = tmd_data.read(4) content_type_bin = tmd_data.read(4)
content_type_hex = binascii.hexlify(content_type_bin) content_type_hex = binascii.hexlify(content_type_bin)
self.content_type = str(content_type_hex.decode()) self.content_type = str(content_type_hex.decode())
# Publisher of the title # Publisher of the title.
tmd_data.seek(0x198) tmd_data.seek(0x198)
self.group_id = tmd_data.read(2) self.group_id = int.from_bytes(tmd_data.read(2))
# Region of the title, 0 = JAP, 1 = USA, 2 = EUR, 3 = NONE, 4 = KOR # Region of the title, 0 = JAP, 1 = USA, 2 = EUR, 3 = NONE, 4 = KOR.
tmd_data.seek(0x19C) tmd_data.seek(0x19C)
region_hex = tmd_data.read(2) region_hex = tmd_data.read(2)
self.region = int.from_bytes(region_hex) 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) tmd_data.seek(0x19E)
self.ratings = tmd_data.read(16) 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) tmd_data.seek(0x1D8)
self.access_rights = tmd_data.read(4) 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) tmd_data.seek(0x1DC)
title_version_high = int.from_bytes(tmd_data.read(1)) * 256 title_version_high = int.from_bytes(tmd_data.read(1)) * 256
tmd_data.seek(0x1DD) tmd_data.seek(0x1DD)
title_version_low = int.from_bytes(tmd_data.read(1)) title_version_low = int.from_bytes(tmd_data.read(1))
self.title_version = title_version_high + title_version_low 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) tmd_data.seek(0x1DE)
self.num_contents = int.from_bytes(tmd_data.read(2)) 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) 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. # Get content records for the number of contents in num_contents.
self.content_records = []
for content in range(0, self.num_contents): for content in range(0, self.num_contents):
tmd_data.seek(0x1E4 + (36 * content)) tmd_data.seek(0x1E4 + (36 * content))
content_record_hdr = struct.unpack(">LHH4x4s20s", tmd_data.read(36)) 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]), int(content_record_hdr[2]), int.from_bytes(content_record_hdr[3]),
binascii.hexlify(content_record_hdr[4]))) binascii.hexlify(content_record_hdr[4])))
def get_title_region(self): def dump(self) -> bytes:
"""Gets the region of the TMD's associated title. """
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: Can be one of several possible values:
'JAP', 'USA', 'EUR', 'NONE', or 'KOR'. 'JAP', 'USA', 'EUR', 'NONE', or 'KOR'.
@ -149,8 +238,9 @@ class TMD:
case 4: case 4:
return "KOR" return "KOR"
def get_is_vwii_title(self): def get_is_vwii_title(self) -> bool:
"""Gets whether the TMD is designed for the vWii or not. """
Gets whether the TMD is designed for the vWii or not.
Returns Returns
------- -------
@ -162,8 +252,9 @@ class TMD:
else: else:
return False return False
def get_title_type(self): def get_title_type(self) -> str:
"""Gets the type of the TMD's associated title. """
Gets the type of the TMD's associated title.
Can be one of several possible values: Can be one of several possible values:
'System', 'Game', 'Channel', 'SystemChannel', 'GameWithChannel', or 'HiddenChannel' 'System', 'Game', 'Channel', 'SystemChannel', 'GameWithChannel', or 'HiddenChannel'
@ -193,7 +284,8 @@ class TMD:
return "Unknown" return "Unknown"
def get_content_type(self): 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: Can be one of several possible values:
'Normal', 'Development/Unknown', 'Hash Tree', 'DLC', or 'Shared' 'Normal', 'Development/Unknown', 'Hash Tree', 'DLC', or 'Shared'
@ -217,8 +309,9 @@ class TMD:
case _: case _:
return "Unknown" return "Unknown"
def get_content_record(self, record): def get_content_record(self, record) -> ContentRecord:
"""Gets the content record at the specified index. """
Gets the content record at the specified index.
Parameters Parameters
---------- ----------
@ -235,3 +328,16 @@ class TMD:
else: else:
raise IndexError("Invalid content record! TMD lists '" + str(self.num_contents - 1) + raise IndexError("Invalid content record! TMD lists '" + str(self.num_contents - 1) +
"' contents but index was '" + str(record) + "'!") "' 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 @dataclass
class ContentRecord: 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 Attributes
---------- ----------
@ -27,3 +29,24 @@ class ContentRecord:
content_type: int # Type of content, possible values of: 0x0001: Normal, 0x4001: DLC, 0x8001: Shared. 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_size: int # Size of the content when decrypted.
content_hash: bytes # SHA-1 hash 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

374
src/libWiiPy/wad.py
View File

@ -5,39 +5,70 @@
import io import io
import binascii import binascii
from .shared import align_value, pad_bytes_stream
class WAD: 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.
Parameters Attributes
---------- ----------
wad : bytes wad_type : str
A bytes object containing the contents of a WAD file. 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, wad): def __init__(self):
self.wad = wad self.wad_hdr_size: int = 64
self.wad_hdr_size: int self.wad_type: str = "Is"
self.wad_type: str self.wad_version: bytes = b'\x00\x00'
self.wad_version: int
# === Sizes === # === Sizes ===
self.wad_cert_size: int self.wad_cert_size: int = 0
self.wad_crl_size: int self.wad_crl_size: int = 0
self.wad_tik_size: int self.wad_tik_size: int = 0
self.wad_tmd_size: int self.wad_tmd_size: int = 0
# This is the size of the content region, which contains all app files combined. # This is the size of the content region, which contains all app files combined.
self.wad_content_size: int self.wad_content_size: int = 0
self.wad_meta_size: int self.wad_meta_size: int = 0
# === Offsets === # === Data ===
self.wad_cert_offset: int self.wad_cert_data: bytes = b''
self.wad_crl_offset: int self.wad_crl_data: bytes = b''
self.wad_tik_offset: int self.wad_tik_data: bytes = b''
self.wad_tmd_offset: int self.wad_tmd_data: bytes = b''
self.wad_content_offset: int self.wad_content_data: bytes = b''
self.wad_meta_offset: int self.wad_meta_data: bytes = b''
# Load header data from WAD stream
with io.BytesIO(self.wad) as wad_data: 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_data : bytes
The data for the WAD you wish to load.
"""
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. # Get the sizes of each data region contained within the WAD.
# ==================================================================================== # ====================================================================================
@ -64,95 +95,100 @@ class WAD:
# WAD content size. # WAD content size.
wad_data.seek(0x18) wad_data.seek(0x18)
self.wad_content_size = int(binascii.hexlify(wad_data.read(4)), 16) 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) wad_data.seek(0x1c)
self.wad_meta_size = int(binascii.hexlify(wad_data.read(4)), 16) 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. # 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. # 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)) wad_crl_offset = align_value(wad_cert_offset + self.wad_cert_size)
self.wad_tik_offset = int(64 * round((self.wad_crl_offset + self.wad_crl_size) / 64)) wad_tik_offset = align_value(wad_crl_offset + self.wad_crl_size)
self.wad_tmd_offset = int(64 * round((self.wad_tik_offset + self.wad_tik_size) / 64)) wad_tmd_offset = align_value(wad_tik_offset + self.wad_tik_size)
self.wad_content_offset = int(64 * round((self.wad_tmd_offset + self.wad_tmd_size) / 64)) # meta isn't guaranteed to be used, but some older SDK titles use it, and not reading it breaks things.
# meta is also never used, but Nintendo's tools calculate it, so we should too. wad_meta_offset = align_value(wad_tmd_offset + self.wad_tmd_size)
self.wad_meta_offset = int(64 * round((self.wad_content_offset + self.wad_content_size) / 64)) 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): def dump(self) -> bytes:
"""Gets the offset and size of the certificate data. """
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 Returns
------- -------
int bytes
The offset of the certificate data in the WAD. The full WAD file as bytes.
int
The size of the certificate data in the WAD.
""" """
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): def get_wad_type(self) -> str:
"""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.
""" """
return self.wad_crl_offset, self.wad_crl_size Gets the type of the WAD.
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.
Returns Returns
------- -------
@ -161,80 +197,146 @@ class WAD:
""" """
return self.wad_type return self.wad_type
def get_cert_data(self): def get_cert_data(self) -> bytes:
"""Gets the certificate data from the WAD. """
Gets the certificate data from the WAD.
Returns Returns
------- -------
bytes bytes
The certificate data. The certificate data.
""" """
wad_data = io.BytesIO(self.wad) return self.wad_cert_data
wad_data.seek(self.wad_cert_offset)
cert_data = wad_data.read(self.wad_cert_size)
return cert_data
def get_crl_data(self): def get_crl_data(self) -> bytes:
"""Gets the crl data from the WAD, if it exists. """
Gets the crl data from the WAD, if it exists.
Returns Returns
------- -------
bytes bytes
The crl data. The crl data.
""" """
wad_data = io.BytesIO(self.wad) return self.wad_crl_data
wad_data.seek(self.wad_crl_offset)
crl_data = wad_data.read(self.wad_crl_size)
return crl_data
def get_ticket_data(self): def get_ticket_data(self) -> bytes:
"""Gets the ticket data from the WAD. """
Gets the ticket data from the WAD.
Returns Returns
------- -------
bytes bytes
The ticket data. The ticket data.
""" """
wad_data = io.BytesIO(self.wad) return self.wad_tik_data
wad_data.seek(self.wad_tik_offset)
ticket_data = wad_data.read(self.wad_tik_size)
return ticket_data
def get_tmd_data(self): def get_tmd_data(self) -> bytes:
"""Returns the TMD data from the WAD. """
Returns the TMD data from the WAD.
Returns Returns
------- -------
bytes bytes
The TMD data. The TMD data.
""" """
wad_data = io.BytesIO(self.wad) return self.wad_tmd_data
wad_data.seek(self.wad_tmd_offset)
tmd_data = wad_data.read(self.wad_tmd_size)
return tmd_data
def get_content_data(self): def get_content_data(self) -> bytes:
"""Gets the content of the WAD. """
Gets the content of the WAD.
Returns Returns
------- -------
bytes bytes
The content data. The content data.
""" """
wad_data = io.BytesIO(self.wad) return self.wad_content_data
wad_data.seek(self.wad_content_offset)
content_data = wad_data.read(self.wad_content_size)
return content_data
def get_meta_data(self): def get_meta_data(self) -> bytes:
"""Gets the meta region of the WAD, which is typically unused. """
Gets the meta region of the WAD, which is typically unused.
Returns Returns
------- -------
bytes bytes
The meta region. The meta region.
""" """
wad_data = io.BytesIO(self.wad) return self.wad_meta_data
wad_data.seek(self.wad_meta_offset)
meta_data = wad_data.read(self.wad_meta_size) def set_cert_data(self, cert_data) -> None:
return meta_data """
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)