private long OpenNcaFs(ServiceCtx context, string ncaPath, LibHac.IO.IStorage ncaStorage)
{
Nca nca = new Nca(context.Device.System.KeySet, ncaStorage, false);
NcaSection romfsSection = nca.Sections.FirstOrDefault(x => x?.Type == SectionType.Romfs);
NcaSection pfsSection = nca.Sections.FirstOrDefault(x => x?.Type == SectionType.Pfs0);
if (romfsSection != null)
{
LibHac.IO.IStorage romfsStorage = nca.OpenSection(romfsSection.SectionNum, false, context.Device.System.FsIntegrityCheckLevel, false);
IFileSystem ncaFileSystem = new IFileSystem(ncaPath, new RomFsProvider(romfsStorage));
MakeObject(context, ncaFileSystem);
}
else if (pfsSection != null)
{
LibHac.IO.IStorage pfsStorage = nca.OpenSection(pfsSection.SectionNum, false, context.Device.System.FsIntegrityCheckLevel, false);
Pfs pfs = new Pfs(pfsStorage);
IFileSystem ncaFileSystem = new IFileSystem(ncaPath, new PFsProvider(pfs));
MakeObject(context, ncaFileSystem);
}
else
{
return(MakeError(ErrorModule.Fs, FsErr.PartitionNotFound));
}
return(0);
}
private long OpenNcaFs(ServiceCtx Context, string NcaPath, Stream NcaStream)
{
Nca Nca = new Nca(Context.Device.System.KeySet, NcaStream, false);
NcaSection RomfsSection = Nca.Sections.FirstOrDefault(x => x?.Type == SectionType.Romfs);
NcaSection PfsSection = Nca.Sections.FirstOrDefault(x => x?.Type == SectionType.Pfs0);
if (RomfsSection != null)
{
Stream RomfsStream = Nca.OpenSection(RomfsSection.SectionNum, false, Context.Device.System.FsIntegrityCheckLevel);
IFileSystem NcaFileSystem = new IFileSystem(NcaPath, new RomFsProvider(RomfsStream));
MakeObject(Context, NcaFileSystem);
}
else if (PfsSection != null)
{
Stream PfsStream = Nca.OpenSection(PfsSection.SectionNum, false, Context.Device.System.FsIntegrityCheckLevel);
Pfs Pfs = new Pfs(PfsStream);
IFileSystem NcaFileSystem = new IFileSystem(NcaPath, new PFsProvider(Pfs));
MakeObject(Context, NcaFileSystem);
}
else
{
return(MakeError(ErrorModule.Fs, FsErr.PartitionNotFound));
}
return(0);
}
public void Load(System.IO.Stream stream)
{
var Keys = Forms.SwitchKeySelectionForm.ShowKeySelector();
if (Keys == null)
{
throw new Exception("Failed to get keys. Please select valid paths!");
}
var Nca = new Nca(Keys, stream.AsStorage(), true);
Romfs romfs = new Romfs(
Nca.OpenSection(Nca.Sections.FirstOrDefault
(s => s?.Type == SectionType.Romfs || s?.Type == SectionType.Bktr)
.SectionNum, false, IntegrityCheckLevel.None, true));
if (Nca.CanOpenSection((int)ProgramPartitionType.Code))
{
var exefs = new Pfs(Nca.OpenSection((int)ProgramPartitionType.Code,
false, IntegrityCheckLevel.None, true));
foreach (var file in exefs.Files)
{
files.Add(new NSP.ExefsEntry(exefs, file));
}
}
for (int i = 0; i < romfs.Files.Count; i++)
{
files.Add(new NSP.FileEntry(romfs, romfs.Files[i]));
}
}
public void Load(System.IO.Stream stream)
{
var Keys = Forms.SwitchKeySelectionForm.ShowKeySelector();
if (Keys == null)
{
throw new Exception("Failed to get keys. Please select valid paths!");
}
var Pfs = new Pfs(stream.AsStorage());
var CnmtNca = new Nca(Keys, Pfs.OpenFile(Pfs.Files.FirstOrDefault(s => s.Name.Contains(".cnmt.nca"))), false);
var CnmtPfs = new Pfs(CnmtNca.OpenSection(0, false, IntegrityCheckLevel.None, true));
var Cnmt = new Cnmt(CnmtPfs.OpenFile(CnmtPfs.Files[0]).AsStream());
foreach (var entry in Cnmt.ContentEntries)
{
if (entry.Type == CnmtContentType.Program)
{
var Program = entry;
string ncaFileName = $"{Program.NcaId.ToHexString().ToLower()}.nca";
Stream Input = Pfs.OpenFile(ncaFileName).AsStream();
var Nca = new Nca(Keys, Input.AsStorage(), true);
string root = Nca.Header.TitleId.ToString("X");
Romfs romfs = new Romfs(
Nca.OpenSection(Nca.Sections.FirstOrDefault
(s => s?.Type == SectionType.Romfs || s?.Type == SectionType.Bktr)
.SectionNum, false, IntegrityCheckLevel.None, true));
if (Nca.CanOpenSection((int)ProgramPartitionType.Code))
{
var exefs = new Pfs(Nca.OpenSection((int)ProgramPartitionType.Code,
false, IntegrityCheckLevel.None, true));
foreach (var file in exefs.Files)
{
files.Add(new ExefsEntry(exefs, file, root));
}
}
for (int i = 0; i < romfs.Files.Count; i++)
{
files.Add(new FileEntry(romfs, romfs.Files[i], root));
}
}
}
var CtrlEntry = Cnmt.ContentEntries.FirstOrDefault(c => c.Type == CnmtContentType.Control);
if (CtrlEntry != null)
{
Control = new Nca(Keys, Pfs.OpenFile($"{CtrlEntry.NcaId.ToHexString().ToLower()}.nca"), false);
}
}
public void Load(System.IO.Stream stream)
{
string homeFolder = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
string KeyFile = Path.Combine(homeFolder, ".switch", "prod.keys");
string TitleKeyFile = Path.Combine(homeFolder, ".switch", "title.keys");
var Keys = ExternalKeys.ReadKeyFile(KeyFile, TitleKeyFile);
Stream Input;
var Pfs = new Pfs(stream.AsStorage());
var CnmtNca = new Nca(Keys, Pfs.OpenFile(Pfs.Files.FirstOrDefault(s => s.Name.Contains(".cnmt.nca"))), false);
var CnmtPfs = new Pfs(CnmtNca.OpenSection(0, false, IntegrityCheckLevel.None, true));
var Cnmt = new Cnmt(CnmtPfs.OpenFile(CnmtPfs.Files[0]).AsStream());
var Program = Cnmt.ContentEntries.FirstOrDefault(c => c.Type == CnmtContentType.Program);
var CtrlEntry = Cnmt.ContentEntries.FirstOrDefault(c => c.Type == CnmtContentType.Control);
if (CtrlEntry != null)
{
Control = new Nca(Keys, Pfs.OpenFile($"{CtrlEntry.NcaId.ToHexString().ToLower()}.nca"), false);
}
Input = Pfs.OpenFile($"{Program.NcaId.ToHexString().ToLower()}.nca").AsStream();
var Nca = new Nca(Keys, Input.AsStorage(), true);
Romfs romfs = new Romfs(
Nca.OpenSection(Nca.Sections.FirstOrDefault
(s => s?.Type == SectionType.Romfs || s?.Type == SectionType.Bktr)
.SectionNum, false, IntegrityCheckLevel.None, true));
for (int i = 0; i < romfs.Files.Count; i++)
{
files.Add(new FileEntry(romfs, romfs.Files[i]));
}
}
public static void ExtractSection(this Nca nca, int index, string outputDir, bool verify = false, IProgressReport logger = null)
{
if (index < 0 || index > 3)
{
throw new IndexOutOfRangeException();
}
if (nca.Sections[index] == null)
{
return;
}
NcaSection section = nca.Sections[index];
Stream stream = nca.OpenSection(index, false, verify);
switch (section.Type)
{
case SectionType.Invalid:
break;
case SectionType.Pfs0:
var pfs0 = new Pfs(stream);
pfs0.Extract(outputDir, logger);
break;
case SectionType.Romfs:
var romfs = new Romfs(stream);
romfs.Extract(outputDir, logger);
break;
case SectionType.Bktr:
break;
}
}
public static byte[] GetFirmwareData(Switch device)
{
long titleId = 0x0100000000000809;
string contentPath = device.System.ContentManager.GetInstalledContentPath(titleId, StorageId.NandSystem, ContentType.Data);
if (string.IsNullOrWhiteSpace(contentPath))
{
return(null);
}
string firmwareTitlePath = device.FileSystem.SwitchPathToSystemPath(contentPath);
using (FileStream firmwareStream = File.Open(firmwareTitlePath, FileMode.Open, FileAccess.Read))
{
Nca firmwareContent = new Nca(device.System.KeySet, firmwareStream.AsStorage(), false);
IStorage romFsStorage = firmwareContent.OpenSection(0, false, device.System.FsIntegrityCheckLevel, false);
if (romFsStorage == null)
{
return(null);
}
Romfs firmwareRomFs = new Romfs(romFsStorage);
IStorage firmwareFile = firmwareRomFs.OpenFile("/file");
byte[] data = new byte[firmwareFile.Length];
firmwareFile.Read(data, 0);
return(data);
}
}
public void ReadControlData(Nca controlNca)
{
Romfs controlRomfs = new Romfs(controlNca.OpenSection(0, false, FsIntegrityCheckLevel, true));
IStorage controlFile = controlRomfs.OpenFile("/control.nacp");
ControlData = new Nacp(controlFile.AsStream());
}
public void ReadControlData(Nca ControlNca)
{
Romfs ControlRomfs = new Romfs(ControlNca.OpenSection(0, false, EnableFsIntegrityChecks));
byte[] ControlFile = ControlRomfs.GetFile("/control.nacp");
BinaryReader Reader = new BinaryReader(new MemoryStream(ControlFile));
ControlData = new Nacp(Reader);
}
public void ReadControlData(Nca controlNca)
{
Romfs controlRomfs = new Romfs(controlNca.OpenSection(0, false, FsIntegrityCheckLevel));
byte[] controlFile = controlRomfs.GetFile("/control.nacp");
BinaryReader reader = new BinaryReader(new MemoryStream(controlFile));
ControlData = new Nacp(reader);
}
// OpenDataStorageByDataId(u8 storageId, nn::ApplicationId tid) -> object<nn::fssrv::sf::IStorage> dataStorage
public long OpenDataStorageByDataId(ServiceCtx Context)
{
StorageId StorageId = (StorageId)Context.RequestData.ReadByte();
byte[] Padding = Context.RequestData.ReadBytes(7);
long TitleId = Context.RequestData.ReadInt64();
StorageId InstalledStorage =
Context.Device.System.ContentManager.GetInstalledStorage(TitleId, ContentType.Data, StorageId);
if (InstalledStorage == StorageId.None)
{
InstalledStorage =
Context.Device.System.ContentManager.GetInstalledStorage(TitleId, ContentType.AocData, StorageId);
}
if (InstalledStorage != StorageId.None)
{
string ContentPath = Context.Device.System.ContentManager.GetInstalledContentPath(TitleId, StorageId, ContentType.AocData);
if (string.IsNullOrWhiteSpace(ContentPath))
{
ContentPath = Context.Device.System.ContentManager.GetInstalledContentPath(TitleId, StorageId, ContentType.AocData);
}
string InstallPath = Context.Device.FileSystem.SwitchPathToSystemPath(ContentPath);
if (!string.IsNullOrWhiteSpace(InstallPath))
{
string NcaPath = InstallPath;
if (File.Exists(NcaPath))
{
FileStream NcaStream = new FileStream(NcaPath, FileMode.Open, FileAccess.Read);
Nca Nca = new Nca(Context.Device.System.KeySet, NcaStream, false);
NcaSection RomfsSection = Nca.Sections.FirstOrDefault(x => x?.Type == SectionType.Romfs);
Stream RomfsStream = Nca.OpenSection(RomfsSection.SectionNum, false, Context.Device.System.FsIntegrityCheckLevel);
MakeObject(Context, new IStorage(RomfsStream));
return(0);
}
else
{
throw new FileNotFoundException($"No Nca found in Path `{NcaPath}`.");
}
}
else
{
throw new DirectoryNotFoundException($"Path for title id {TitleId:x16} on Storage {StorageId} was not found in Path {InstallPath}.");
}
}
throw new FileNotFoundException($"System archive with titleid {TitleId:x16} was not found on Storage {StorageId}. Found in {InstalledStorage}.");
}
// OpenDataStorageByDataId(u8 storageId, nn::ApplicationId tid) -> object<nn::fssrv::sf::IStorage> dataStorage
public long OpenDataStorageByDataId(ServiceCtx context)
{
StorageId storageId = (StorageId)context.RequestData.ReadByte();
byte[] padding = context.RequestData.ReadBytes(7);
long titleId = context.RequestData.ReadInt64();
StorageId installedStorage =
context.Device.System.ContentManager.GetInstalledStorage(titleId, ContentType.Data, storageId);
if (installedStorage == StorageId.None)
{
installedStorage =
context.Device.System.ContentManager.GetInstalledStorage(titleId, ContentType.AocData, storageId);
}
if (installedStorage != StorageId.None)
{
string contentPath = context.Device.System.ContentManager.GetInstalledContentPath(titleId, storageId, ContentType.AocData);
if (string.IsNullOrWhiteSpace(contentPath))
{
contentPath = context.Device.System.ContentManager.GetInstalledContentPath(titleId, storageId, ContentType.AocData);
}
string installPath = context.Device.FileSystem.SwitchPathToSystemPath(contentPath);
if (!string.IsNullOrWhiteSpace(installPath))
{
string ncaPath = installPath;
if (File.Exists(ncaPath))
{
FileStream ncaStream = new FileStream(ncaPath, FileMode.Open, FileAccess.Read);
Nca nca = new Nca(context.Device.System.KeySet, ncaStream, false);
NcaSection romfsSection = nca.Sections.FirstOrDefault(x => x?.Type == SectionType.Romfs);
Stream romfsStream = nca.OpenSection(romfsSection.SectionNum, false, context.Device.System.FsIntegrityCheckLevel);
MakeObject(context, new IStorage(romfsStream));
return(0);
}
else
{
throw new FileNotFoundException($"No Nca found in Path `{ncaPath}`.");
}
}
else
{
throw new DirectoryNotFoundException($"Path for title id {titleId:x16} on Storage {storageId} was not found in Path {installPath}.");
}
}
throw new FileNotFoundException($"System archive with titleid {titleId:x16} was not found on Storage {storageId}. Found in {installedStorage}.");
}
public void Load(System.IO.Stream stream)
{
string homeFolder = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
string KeyFile = Path.Combine(homeFolder, ".switch", "prod.keys");
string TitleKeyFile = Path.Combine(homeFolder, ".switch", "title.keys");
var Keys = ExternalKeys.ReadKeyFile(KeyFile, TitleKeyFile);
var Nca = new Nca(Keys, stream.AsStorage(), true);
Romfs romfs = new Romfs(
Nca.OpenSection(Nca.Sections.FirstOrDefault
(s => s?.Type == SectionType.Romfs || s?.Type == SectionType.Bktr)
.SectionNum, false, IntegrityCheckLevel.None, true));
for (int i = 0; i < romfs.Files.Count; i++)
{
files.Add(new NSP.FileEntry(romfs, romfs.Files[i]));
}
}
public static byte[] GetFirmwareData(Switch Device)
{
byte[] Data = null;
long TitleId = 0x0100000000000809;
string ContentPath = Device.System.ContentManager.GetInstalledContentPath(TitleId, StorageId.NandSystem, ContentType.Data);
if (string.IsNullOrWhiteSpace(ContentPath))
{
return(null);
}
string FirmwareTitlePath = Device.FileSystem.SwitchPathToSystemPath(ContentPath);
FileStream FirmwareStream = File.Open(FirmwareTitlePath, FileMode.Open, FileAccess.Read);
Nca FirmwareContent = new Nca(Device.System.KeySet, FirmwareStream, false);
Stream RomFsStream = FirmwareContent.OpenSection(0, false, Device.System.FsIntegrityCheckLevel);
if (RomFsStream == null)
{
return(null);
}
Romfs FirmwareRomFs = new Romfs(RomFsStream);
using (MemoryStream MemoryStream = new MemoryStream())
{
using (Stream FirmwareFile = FirmwareRomFs.OpenFile("/file"))
{
FirmwareFile.CopyTo(MemoryStream);
}
Data = MemoryStream.ToArray();
}
FirmwareContent.Dispose();
FirmwareStream.Dispose();
return(Data);
}
public static byte[] GetFirmwareData(Switch device)
{
byte[] data = null;
long titleId = 0x0100000000000809;
string contentPath = device.System.ContentManager.GetInstalledContentPath(titleId, StorageId.NandSystem, ContentType.Data);
if (string.IsNullOrWhiteSpace(contentPath))
{
return(null);
}
string firmwareTitlePath = device.FileSystem.SwitchPathToSystemPath(contentPath);
FileStream firmwareStream = File.Open(firmwareTitlePath, FileMode.Open, FileAccess.Read);
Nca firmwareContent = new Nca(device.System.KeySet, firmwareStream, false);
Stream romFsStream = firmwareContent.OpenSection(0, false, device.System.FsIntegrityCheckLevel);
if (romFsStream == null)
{
return(null);
}
Romfs firmwareRomFs = new Romfs(romFsStream);
using (MemoryStream memoryStream = new MemoryStream())
{
using (Stream firmwareFile = firmwareRomFs.OpenFile("/file"))
{
firmwareFile.CopyTo(memoryStream);
}
data = memoryStream.ToArray();
}
firmwareContent.Dispose();
firmwareStream.Dispose();
return(data);
}
private static void processControlNca(Nca nca, ref Title title)
{
log?.WriteLine("Processing Control NCA");
if (nca.Header.ContentType == ContentType.Control)
{
title.titleID = String.Format("{0:X16}", nca.Header.TitleId);
if (title.type == TitleType.Patch)
{
title.titleID = title.titleID.Substring(0, Math.Min(title.titleID.Length, 13)) + "800";
}
try
{
Romfs romfs = new Romfs(nca.OpenSection(0, false, IntegrityCheckLevel.ErrorOnInvalid, true));
RomfsFile[] romfsFiles = romfs.Files.ToArray();
foreach (RomfsFile romfsFile in romfsFiles)
{
if (romfsFile.Name.Equals("control.nacp"))
{
using (var control = romfs.OpenFile(romfsFile).AsStream())
{
processControlNacp(control, ref title);
}
}
}
}
catch (MissingKeyException ex)
{
title.error = String.Format("Missing {0}: {1}", ex.Type == KeyType.Title ? "Title Key" : "Key", ex.Name.Replace("key_area_key_application", "master_key"));
log?.WriteLine(title.error);
}
catch (FileNotFoundException) { }
}
}
public static void ExportSection(this Nca nca, int index, string filename, bool raw = false, bool verify = false, IProgressReport logger = null)
{
if (index < 0 || index > 3)
{
throw new IndexOutOfRangeException();
}
if (nca.Sections[index] == null)
{
return;
}
Stream section = nca.OpenSection(index, raw, verify);
string dir = Path.GetDirectoryName(filename);
if (!string.IsNullOrWhiteSpace(dir))
{
Directory.CreateDirectory(dir);
}
using (var outFile = new FileStream(filename, FileMode.Create, FileAccess.ReadWrite))
{
section.CopyStream(outFile, section.Length, logger);
}
}
private void Open()
{
treeView1.Nodes.Clear();
string FileToOpen = null;
if (Program.FileArg != null)
{
FileToOpen = Program.FileArg;
}
else
{
FileToOpen = openFileDialog1.FileName;
}
Program.FileArg = null;
Stream Input = null;
try
{
string ExpEnv(string In) => Environment.ExpandEnvironmentVariables(In);
var ProdKeys = ExpEnv(@"%USERPROFILE%\.switch\prod.keys");
var TitleKeys = ExpEnv(@"%USERPROFILE%\.switch\title.keys");
var Keys = ExternalKeys.ReadKeyFile(ProdKeys, TitleKeys);
var Ext = (new FileInfo(FileToOpen).Extension);
if (Ext == ".nsp")
{
var InputPFS = File.OpenRead(FileToOpen);
var Pfs = new Pfs(InputPFS);
var CnmtNca = new Nca(Keys, Pfs.OpenFile(Pfs.Files.FirstOrDefault(s => s.Name.Contains(".cnmt.nca"))), false);
var CnmtPfs = new Pfs(CnmtNca.OpenSection(0, false, IntegrityCheckLevel.None));
var Cnmt = new Cnmt(CnmtPfs.OpenFile(CnmtPfs.Files[0]));
var Program = Cnmt.ContentEntries.FirstOrDefault(c => c.Type == CnmtContentType.Program);
var CtrlEntry = Cnmt.ContentEntries.FirstOrDefault(c => c.Type == CnmtContentType.Control);
if (CtrlEntry != null)
{
Control = new Nca(Keys, Pfs.OpenFile($"{CtrlEntry.NcaId.ToHexString().ToLower()}.nca"), false);
}
Input = Pfs.OpenFile($"{Program.NcaId.ToHexString().ToLower()}.nca");
}
else if (Ext == ".xci")
{
var InputPFS = File.OpenRead(FileToOpen);
var Xci = new Xci(Keys, InputPFS);
var CnmtNca = new Nca(Keys, Xci.SecurePartition.OpenFile(Xci.SecurePartition.Files.FirstOrDefault(s => s.Name.Contains(".cnmt.nca"))), false);
var CnmtPfs = new Pfs(CnmtNca.OpenSection(0, false, IntegrityCheckLevel.None));
var Cnmt = new Cnmt(CnmtPfs.OpenFile(CnmtPfs.Files[0]));
var Program = Cnmt.ContentEntries.FirstOrDefault(c => c.Type == CnmtContentType.Program);
var CtrlEntry = Cnmt.ContentEntries.FirstOrDefault(c => c.Type == CnmtContentType.Control);
if (CtrlEntry != null)
{
Control = new Nca(Keys, Xci.SecurePartition.OpenFile($"{CtrlEntry.NcaId.ToHexString().ToLower()}.nca"), false);
}
Input = Xci.SecurePartition.OpenFile($"{Program.NcaId.ToHexString().ToLower()}.nca");
}
else if (FileToOpen.Split('.')[1] == "cnmt" && Ext == ".nca")
{
var TargetFile = File.OpenRead(FileToOpen);
var CnmtNca = new Nca(Keys, TargetFile, false);
var CnmtPfs = new Pfs(CnmtNca.OpenSection(0, false, IntegrityCheckLevel.None));
var Cnmt = new Cnmt(CnmtPfs.OpenFile(CnmtPfs.Files[0]));
var Program = Cnmt.ContentEntries.FirstOrDefault(c => c.Type == CnmtContentType.Program);
var CtrlEntry = Cnmt.ContentEntries.FirstOrDefault(c => c.Type == CnmtContentType.Control);
if (CtrlEntry != null)
{
Control = new Nca(Keys, File.OpenRead($"{CtrlEntry.NcaId.ToHexString().ToLower()}.nca"), false);
}
Input = File.OpenRead($"{Program.NcaId.ToHexString().ToLower()}.nca");
}
else
{
Input = File.OpenRead(FileToOpen);
}
try
{
Nca = new Nca(Keys, Input, true);
if (Nca.HasRightsId && !Keys.TitleKeys.Keys.Any(k => k.SequenceEqual(Nca.Header.RightsId)))
{
MessageBox.Show($"Error: the titlekey for {Nca.Header.RightsId.ToHexString().ToLower()} is not present in your key file.");
}
else
{
bool isUpdateNca = false;
if (Nca.Sections.Any(s => s?.Type == SectionType.Bktr))
{
isUpdateNca = true;
}
if (isUpdateNca)
{
openFileDialog1.Title = "Select base Nca";
openFileDialog1.ShowDialog();
var Input2 = File.OpenRead(openFileDialog1.FileName);
Patch = new Nca(Keys, Input2, true);
Nca.SetBaseNca(Patch);
}
new Thread
(
() =>
{
Thread.CurrentThread.IsBackground = true;
var Info = GetTitleMeta($"{Nca.Header.TitleId:x16}");
label2.Invoke(new Action(() => { label2.Text = Info[0]; label3.Text = Info[1]; }));
}
)
.Start();
Rom = new Romfs
(
Nca.OpenSection
(
Nca.Sections.FirstOrDefault
(s => s?.Type == SectionType.Romfs || s?.Type == SectionType.Bktr)
.SectionNum,
false,
IntegrityCheckLevel.None
)
);
IO.PopulateTreeView(treeView1.Nodes, Rom.RootDir);
}
}
catch
{
MessageBox.Show("There was an error reading the NCA. Are you sure the correct keys are present in your keyfiles?");
}
}
catch (ArgumentNullException)
{
MessageBox.Show("Error: key files are missing!");
}
}
private void Open()
{
treeView1.Nodes.Clear();
string FileToOpen = null;
if (Program.FileArg != null)
{
FileToOpen = Program.FileArg;
}
else
{
FileToOpen = openFileDialog1.FileName;
}
Program.FileArg = null;
Stream Input = null;
try
{
string ExpEnv(string In)
{
return(Environment.ExpandEnvironmentVariables(In));
}
var ProdKeys = ExpEnv(@"%USERPROFILE%\.switch\prod.keys");
var TitleKeys = ExpEnv(@"%USERPROFILE%\.switch\title.keys");
var Keys = ExternalKeys.ReadKeyFile(ProdKeys, TitleKeys);
var Ext = (new FileInfo(FileToOpen).Extension);
if (Ext == ".nsp")
{
var InputPFS = File.OpenRead(FileToOpen);
var Pfs = new Pfs(InputPFS);
Input = Pfs.OpenFile
(
Pfs.Files.OrderByDescending(s => s.Size)
.FirstOrDefault()
);
}
else if (Ext == ".xci")
{
var InputPFS = File.OpenRead(FileToOpen);
var Xci = new Xci(Keys, InputPFS);
Input = Xci.SecurePartition.OpenFile
(
Xci.SecurePartition.Files
.OrderByDescending(s => s.Size)
.FirstOrDefault()
);
}
else
{
Input = File.OpenRead(FileToOpen);
}
try
{
Nca = new Nca(Keys, Input, true);
if (Nca.HasRightsId)
{
if (!Keys.TitleKeys.Keys.Contains(Nca.Header.RightsId))
{
MessageBox.Show($"Error: the titlekey for {Nca.Header.RightsId.ToHexString()} is not present in your key file.");
}
}
bool IsUpdateNca = false;
foreach (var Section in Nca.Sections)
{
if (Section?.Type == SectionType.Bktr)
{
IsUpdateNca = true;
}
}
if (IsUpdateNca)
{
openFileDialog1.Title = "Select base Nca";
openFileDialog1.ShowDialog();
var Input2 = File.OpenRead(openFileDialog1.FileName);
Patch = new Nca(Keys, Input2, true);
Nca.SetBaseNca(Patch);
}
new Thread
(
() =>
{
Thread.CurrentThread.IsBackground = true;
var Info = GetTitleMeta($"{Nca.Header.TitleId:x16}");
label2.Invoke
(
new Action
(
() => { label2.Text = Info[0]; }
)
);
label3.Invoke
(
new Action
(
() => { label3.Text = Info[1]; }
)
);
}
)
.Start();
Rom = new Romfs
(
Nca.OpenSection
(
Nca.Sections.FirstOrDefault
(s => s?.Type == SectionType.Romfs || s?.Type == SectionType.Bktr)
.SectionNum,
false,
false
)
);
IO.PopulateTreeView(treeView1.Nodes, Rom.RootDir);
}
catch (Exception)
{
MessageBox.Show("There was an error reading the NCA. Are you sure the correct keys are present in your keyfiles?");
}
}
catch (Exception)
{
MessageBox.Show("Error: key files are missing!");
}
}
//Open update only
private void Open_NSP_Update(object sender, EventArgs e)
{
var Dialog = openFileDialog1.ShowDialog();
if (Dialog != DialogResult.Cancel)
{
Console.WriteLine("LOADING.");
label8.Visible = true;
this.Update();
treeView1.Nodes.Clear();
string FileToOpen = null;
if (Program.FileArg != null)
{
FileToOpen = Program.FileArg;
}
else
{
FileToOpen = openFileDialog1.FileName;
}
Program.FileArg = null;
Stream Input = null;
try
{
string ExpEnv(string In) => Environment.ExpandEnvironmentVariables(In);
var ProdKeys = ExpEnv(@"%USERPROFILE%\.switch\prod.keys");
var TitleKeys = ExpEnv(@"%USERPROFILE%\.switch\title.keys");
Console.WriteLine(FileToOpen);
var Keys = ExternalKeys.ReadKeyFile(ProdKeys, TitleKeys);
var Ext = (new FileInfo(FileToOpen).Extension);
if (Ext == ".nsp")
{
var InputPFS = File.OpenRead(FileToOpen);
var Pfs = new Pfs(InputPFS.AsStorage());
var CnmtNca = new Nca(Keys, Pfs.OpenFile(Pfs.Files.FirstOrDefault(s => s.Name.Contains(".cnmt.nca"))), false);
var CnmtPfs = new Pfs(CnmtNca.OpenSection(0, false, IntegrityCheckLevel.None, true));
var Cnmt = new Cnmt(CnmtPfs.OpenFile(CnmtPfs.Files[0]).AsStream());
var Program = Cnmt.ContentEntries.FirstOrDefault(c => c.Type == CnmtContentType.Program);
var CtrlEntry = Cnmt.ContentEntries.FirstOrDefault(c => c.Type == CnmtContentType.Control);
if (CtrlEntry != null)
{
Control = new Nca(Keys, Pfs.OpenFile($"{CtrlEntry.NcaId.ToHexString().ToLower()}.nca"), false);
}
Input = Pfs.OpenFile($"{Program.NcaId.ToHexString().ToLower()}.nca").AsStream();
}
else
{
Input = File.OpenRead(FileToOpen);
}
try
{
Nca = new Nca(Keys, Input.AsStorage(), true);
if (Nca.HasRightsId && !Keys.TitleKeys.Keys.Any(k => k.SequenceEqual(Nca.Header.RightsId)))
{
MessageBox.Show($"Error: the titlekey for {Nca.Header.RightsId.ToHexString().ToLower()} is not present in your key file.");
}
else
{
var isUpdateNca = false;
if (Nca.Sections.Any(s => s?.Type == SectionType.Bktr))
{
isUpdateNca = true;
}
if (isUpdateNca)
{
var InputPFS = File.OpenRead(FileToOpen);
var Pfs = new Pfs(InputPFS.AsStorage());
var CnmtNca = new Nca(Keys, Pfs.OpenFile(Pfs.Files.FirstOrDefault(s => s.Name.Contains(".cnmt.nca"))), false);
var CnmtPfs = new Pfs(CnmtNca.OpenSection(0, false, IntegrityCheckLevel.None, true));
var Cnmt = new Cnmt(CnmtPfs.OpenFile(CnmtPfs.Files[0]).AsStream());
var Program = Cnmt.ContentEntries.FirstOrDefault(c => c.Type == CnmtContentType.Program);
var CtrlEntry = Cnmt.ContentEntries.FirstOrDefault(c => c.Type == CnmtContentType.Control);
if (CtrlEntry != null)
{
Control = new Nca(Keys, Pfs.OpenFile($"{CtrlEntry.NcaId.ToHexString().ToLower()}.nca"), false);
}
Input = Pfs.OpenFile($"{Program.NcaId.ToHexString().ToLower()}.nca").AsStream();
var Input2 = Pfs.OpenFile($"{Program.NcaId.ToHexString().ToLower()}.nca").AsStream();
Patch = new Nca(Keys, Input2.AsStorage(), true);
Nca.SetBaseNca(Patch);
}
new Thread
(() =>
{
Thread.CurrentThread.IsBackground = true;
var Info = GetTitleMeta($"{Nca.Header.TitleId:x16}");
label2.Invoke(new Action(() => { label2.Text = Info[0]; label3.Text = Info[1]; }));
}).Start();
Rom = new Romfs(
Nca.OpenSection(Nca.Sections.FirstOrDefault
(s => s?.Type == SectionType.Romfs || s?.Type == SectionType.Bktr)
.SectionNum, false, IntegrityCheckLevel.None, true)
);
IO.PopulateTreeView(treeView1.Nodes, Rom.RootDir);
Console.WriteLine("DONE.");
fileToolStripMenuItem.Text = "File / Explore";
label8.Visible = false;
this.Update();
}
}
catch
{
MessageBox.Show("There was an error reading the NCA. Are you sure the correct keys are present in your keyfiles?");
}
}
catch (ArgumentNullException) { MessageBox.Show("Error: key files are missing!"); }
}
}
static void Main(string[] args)
{
Console.WriteLine("Nintendo Switch NSP Verifier v1.00");
Console.WriteLine("Copyright 2018 CaitSith2");
Console.WriteLine("");
_path = args.Length >= 1
? string.Join(" ", args)
: Environment.CurrentDirectory;
if (new[] { "--help", "-h" }.Any(x => x.Equals(_path, StringComparison.InvariantCultureIgnoreCase)))
{
Console.WriteLine("Usage: NSPVerify [path to NSP directory]");
Console.WriteLine("");
Console.WriteLine("If the tool is run without specifying a path, it will look for NSPs in the current directory and ALL sub-directories of current directory");
return;
}
if (!Directory.Exists(_path))
{
Console.WriteLine("ERROR: Specified directory does not exist. specify --help for usage information.");
return;
}
var fs = new FileSystem(_path);
var keys = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".switch", "prod.keys");
if (File.Exists("keys.txt"))
{
keys = "keys.txt";
}
if (!File.Exists(keys))
{
Console.WriteLine($"Cannot verify NSPs without keys.txt. Either put it in the same directory as this tool,");
Console.WriteLine($"or place it in \"{Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".switch")}\" named as prod.keys");
PressAnyKey();
return;
}
var keyset = ExternalKeys.ReadKeyFile(keys);
var badlist = new List <string>();
var exceptionlist = new List <string>();
var files = fs.GetFileSystemEntries("", "*.nsp", SearchOption.AllDirectories).ToList();
files.AddRange(fs.GetFileSystemEntries("", "*.nsx", SearchOption.AllDirectories));
if (files.Count == 0)
{
Console.WriteLine("Error: No NSP/NSX files in specified directory");
PressAnyKey();
return;
}
foreach (var file in files)
{
var filename = Path.GetFileName(file);
var relativefilename = Util.GetRelativePath(file, Path.GetFullPath(_path));
Console.Write($"Checking {filename}: ");
try
{
bool ok = true;
using (var nspfile = fs.OpenFile(file, FileMode.Open, FileAccess.Read))
{
var nspdata = new Pfs(nspfile);
var cnmtfile = nspdata.Files.FirstOrDefault(x => x.Name.ToLowerInvariant().EndsWith(".cnmt.nca"));
if (cnmtfile == null)
{
Console.WriteLine($"\rChecking {filename}: No cnmt.nca file present");
badlist.Add(relativefilename);
continue;
}
var cnmtdata = nspdata.OpenFile(cnmtfile);
Cnmt cnmt;
using (var sr = new BinaryReader(cnmtdata))
{
var cnmthash = SHA256.Create().ComputeHash(sr.ReadBytes((int)cnmtdata.Length));
if (!cnmtfile.Name.ToLowerInvariant().Contains(cnmthash.Take(16).ToArray().ToHexString()))
{
//Put failure here
Console.WriteLine($"\rChecking {filename}: cnmt.nca file is corrupted");
badlist.Add(relativefilename);
cnmtdata.Dispose();
continue;
}
cnmtdata.Position = 0;
var cnmtnca = new Nca(keyset, cnmtdata, false);
var section = cnmtnca.OpenSection(0, false);
var sectionpfs = new Pfs(section);
cnmt = new Cnmt(sectionpfs.OpenFile(sectionpfs.Files[0]));
}
foreach (var entry in cnmt.ContentEntries)
{
var entryfile = nspdata.Files.FirstOrDefault(x => x.Name.ToLowerInvariant().EndsWith(entry.NcaId.ToHexString() + ".nca"));
if (entryfile == null)
{
if (entry.Type != CnmtContentType.UpdatePatch)
{
//Put failure here
Console.WriteLine($"\rChecking {filename}: one of the entries required by the cnmt.nca is missing.");
badlist.Add(relativefilename);
break;
}
continue;
}
using (var entrynca = nspdata.OpenFile(entryfile))
{
var hash = SHA256.Create();
using (var sr = new BinaryReader(entrynca))
{
while (entrynca.Length != entrynca.Position)
{
var entryncadata = sr.ReadBytes(0x100000);
hash.TransformBlock(entryncadata, 0, entryncadata.Length, entryncadata, 0);
Console.Write($"\rChecking {filename}: {((entrynca.Position * 100.0) / entrynca.Length):0.0}%");
}
hash.TransformFinalBlock(new byte[0], 0, 0);
}
if (hash.Hash.ToHexString().Equals(entry.Hash.ToHexString()))
{
Console.Write($"\rChecking {filename}: {100:0.0}%");
continue;
}
//Put failure here
Console.WriteLine($"\rChecking {filename}: one of the entries required by the cnmt.nca is corrupted");
badlist.Add(relativefilename);
ok = false;
break;
}
}
if (ok)
{
Console.WriteLine($"\rChecking {filename}: OK ");
}
//Put Success here
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
exceptionlist.Add($"{relativefilename}{Environment.NewLine}Exception: \"{ex.GetType()}\" {ex.Message}{Environment.NewLine}Stack Trace: {ex.StackTrace}{Environment.NewLine}");
}
}
badlist.Insert(0, badlist.Count == 0
? "None of the files are corrupted. :)"
: "The following NSP/NSX files are corrupted:");
exceptionlist.Insert(0, exceptionlist.Count == 0
? "No exceptions to log. :)"
: "Exceptions caused while parsing the following NSP/NSX files:");
try
{
File.WriteAllText("Corrupted NSPs.txt", string.Join(Environment.NewLine, badlist));
File.WriteAllText("Exception Log.txt", string.Join(Environment.NewLine, exceptionlist));
}
catch (Exception ex)
{
Console.WriteLine($"Could not write the output files \"Corrupted NSPs.txt\" and \"Exception Log.txt\" due to the following exception.");
Console.WriteLine($"Exception: \"{ex.GetType()}\" {ex.Message}");
Console.WriteLine($"Stack Trace: {ex.StackTrace}{Environment.NewLine}");
Console.WriteLine(string.Join(Environment.NewLine, badlist));
Console.WriteLine();
Console.WriteLine(string.Join(Environment.NewLine, exceptionlist));
Console.WriteLine();
}
Console.WriteLine("Done.");
PressAnyKey();
}
public void LoadNca(Nca mainNca, Nca controlNca)
{
if (mainNca.Header.ContentType != ContentType.Program)
{
Logger.PrintError(LogClass.Loader, "Selected NCA is not a \"Program\" NCA");
return;
}
Stream romfsStream = mainNca.OpenSection(ProgramPartitionType.Data, false, FsIntegrityCheckLevel);
Stream exefsStream = mainNca.OpenSection(ProgramPartitionType.Code, false, FsIntegrityCheckLevel);
if (exefsStream == null)
{
Logger.PrintError(LogClass.Loader, "No ExeFS found in NCA");
return;
}
if (romfsStream == null)
{
Logger.PrintWarning(LogClass.Loader, "No RomFS found in NCA");
}
else
{
Device.FileSystem.SetRomFs(romfsStream);
}
Pfs exefs = new Pfs(exefsStream);
Npdm metaData = null;
if (exefs.FileExists("main.npdm"))
{
Logger.PrintInfo(LogClass.Loader, "Loading main.npdm...");
metaData = new Npdm(exefs.OpenFile("main.npdm"));
}
else
{
Logger.PrintWarning(LogClass.Loader, $"NPDM file not found, using default values!");
metaData = GetDefaultNpdm();
}
List <IExecutable> staticObjects = new List <IExecutable>();
void LoadNso(string filename)
{
foreach (PfsFileEntry file in exefs.Files.Where(x => x.Name.StartsWith(filename)))
{
if (Path.GetExtension(file.Name) != string.Empty)
{
continue;
}
Logger.PrintInfo(LogClass.Loader, $"Loading {filename}...");
NxStaticObject staticObject = new NxStaticObject(exefs.OpenFile(file));
staticObjects.Add(staticObject);
}
}
Nacp ReadControlData()
{
Romfs controlRomfs = new Romfs(controlNca.OpenSection(0, false, FsIntegrityCheckLevel));
byte[] controlFile = controlRomfs.GetFile("/control.nacp");
BinaryReader reader = new BinaryReader(new MemoryStream(controlFile));
Nacp controlData = new Nacp(reader);
CurrentTitle = controlData.Languages[(int)State.DesiredTitleLanguage].Title;
if (string.IsNullOrWhiteSpace(CurrentTitle))
{
CurrentTitle = controlData.Languages.ToList().Find(x => !string.IsNullOrWhiteSpace(x.Title)).Title;
}
return(controlData);
}
if (controlNca != null)
{
ReadControlData();
}
else
{
CurrentTitle = metaData.Aci0.TitleId.ToString("x16");
}
if (!metaData.Is64Bits)
{
throw new NotImplementedException("32-bit titles are not supported!");
}
LoadNso("rtld");
LoadNso("main");
LoadNso("subsdk");
LoadNso("sdk");
ContentManager.LoadEntries();
ProgramLoader.LoadStaticObjects(this, metaData, staticObjects.ToArray());
}
public static void Process(Context ctx)
{
using (var file = new StreamStorage(new FileStream(ctx.Options.InFile, FileMode.Open, FileAccess.Read), false))
{
var nca = new Nca(ctx.Keyset, file, false);
nca.ValidateMasterHashes();
nca.ParseNpdm();
if (ctx.Options.BaseNca != null)
{
var baseFile = new StreamStorage(new FileStream(ctx.Options.BaseNca, FileMode.Open, FileAccess.Read), false);
var baseNca = new Nca(ctx.Keyset, baseFile, false);
nca.SetBaseNca(baseNca);
}
for (int i = 0; i < 3; i++)
{
if (ctx.Options.SectionOut[i] != null)
{
nca.ExportSection(i, ctx.Options.SectionOut[i], ctx.Options.Raw, ctx.Options.IntegrityLevel, ctx.Logger);
}
if (ctx.Options.SectionOutDir[i] != null)
{
nca.ExtractSection(i, ctx.Options.SectionOutDir[i], ctx.Options.IntegrityLevel, ctx.Logger);
}
if (ctx.Options.Validate && nca.Sections[i] != null)
{
nca.VerifySection(i, ctx.Logger);
}
}
if (ctx.Options.ListRomFs && nca.Sections[1] != null)
{
var romfs = new Romfs(nca.OpenSection(1, false, ctx.Options.IntegrityLevel, true));
foreach (RomfsFile romfsFile in romfs.Files)
{
ctx.Logger.LogMessage(romfsFile.FullPath);
}
}
if (ctx.Options.RomfsOutDir != null || ctx.Options.RomfsOut != null)
{
NcaSection section = nca.Sections.FirstOrDefault(x => x?.Type == SectionType.Romfs || x?.Type == SectionType.Bktr);
if (section == null)
{
ctx.Logger.LogMessage("NCA has no RomFS section");
return;
}
if (section.Type == SectionType.Bktr && ctx.Options.BaseNca == null)
{
ctx.Logger.LogMessage("Cannot save BKTR section without base RomFS");
return;
}
if (ctx.Options.RomfsOut != null)
{
nca.ExportSection(section.SectionNum, ctx.Options.RomfsOut, ctx.Options.Raw, ctx.Options.IntegrityLevel, ctx.Logger);
}
if (ctx.Options.RomfsOutDir != null)
{
var romfs = new Romfs(nca.OpenSection(section.SectionNum, false, ctx.Options.IntegrityLevel, true));
romfs.Extract(ctx.Options.RomfsOutDir, ctx.Logger);
}
}
if (ctx.Options.ExefsOutDir != null || ctx.Options.ExefsOut != null)
{
if (nca.Header.ContentType != ContentType.Program)
{
ctx.Logger.LogMessage("NCA's content type is not \"Program\"");
return;
}
NcaSection section = nca.Sections[(int)ProgramPartitionType.Code];
if (section == null)
{
ctx.Logger.LogMessage("Could not find an ExeFS section");
return;
}
if (ctx.Options.ExefsOut != null)
{
nca.ExportSection(section.SectionNum, ctx.Options.ExefsOut, ctx.Options.Raw, ctx.Options.IntegrityLevel, ctx.Logger);
}
if (ctx.Options.ExefsOutDir != null)
{
nca.ExtractSection(section.SectionNum, ctx.Options.ExefsOutDir, ctx.Options.IntegrityLevel, ctx.Logger);
}
}
if (ctx.Options.PlaintextOut != null)
{
nca.OpenDecryptedNca().WriteAllBytes(ctx.Options.PlaintextOut, ctx.Logger);
}
ctx.Logger.LogMessage(nca.Print());
}
}
public static void Process(Context ctx)
{
using (IStorage file = new LocalStorage(ctx.Options.InFile, FileAccess.Read))
{
var nca = new Nca(ctx.Keyset, file, false);
nca.ValidateMasterHashes();
nca.ParseNpdm();
if (ctx.Options.BaseNca != null)
{
IStorage baseFile = new LocalStorage(ctx.Options.BaseNca, FileAccess.Read);
var baseNca = new Nca(ctx.Keyset, baseFile, false);
nca.SetBaseNca(baseNca);
}
for (int i = 0; i < 3; i++)
{
if (ctx.Options.SectionOut[i] != null)
{
nca.ExportSection(i, ctx.Options.SectionOut[i], ctx.Options.Raw, ctx.Options.IntegrityLevel, ctx.Logger);
}
if (ctx.Options.SectionOutDir[i] != null)
{
nca.ExtractSection(i, ctx.Options.SectionOutDir[i], ctx.Options.IntegrityLevel, ctx.Logger);
}
if (ctx.Options.Validate && nca.Sections[i] != null)
{
nca.VerifySection(i, ctx.Logger);
}
}
if (ctx.Options.ListRomFs && nca.Sections[1] != null)
{
var romfs = new RomFsFileSystem(nca.OpenSection(1, false, ctx.Options.IntegrityLevel, true));
foreach (DirectoryEntry entry in romfs.EnumerateEntries())
{
ctx.Logger.LogMessage(entry.FullPath);
}
}
if (ctx.Options.RomfsOutDir != null || ctx.Options.RomfsOut != null || ctx.Options.ReadBench)
{
NcaSection section = nca.Sections.FirstOrDefault(x => x?.Type == SectionType.Romfs || x?.Type == SectionType.Bktr);
if (section == null)
{
ctx.Logger.LogMessage("NCA has no RomFS section");
return;
}
if (section.Type == SectionType.Bktr && ctx.Options.BaseNca == null)
{
ctx.Logger.LogMessage("Cannot save BKTR section without base RomFS");
return;
}
if (ctx.Options.RomfsOut != null)
{
nca.ExportSection(section.SectionNum, ctx.Options.RomfsOut, ctx.Options.Raw, ctx.Options.IntegrityLevel, ctx.Logger);
}
if (ctx.Options.RomfsOutDir != null)
{
IFileSystem romfs = nca.OpenSectionFileSystem(section.SectionNum, ctx.Options.IntegrityLevel);
romfs.Extract(ctx.Options.RomfsOutDir, ctx.Logger);
}
if (ctx.Options.ReadBench)
{
long bytesToRead = 1024L * 1024 * 1024 * 5;
IStorage storage = nca.OpenSection(section.SectionNum, false, ctx.Options.IntegrityLevel, true);
var dest = new NullStorage(storage.Length);
int iterations = (int)(bytesToRead / storage.Length) + 1;
ctx.Logger.LogMessage(iterations.ToString());
ctx.Logger.StartNewStopWatch();
for (int i = 0; i < iterations; i++)
{
storage.CopyTo(dest, ctx.Logger);
ctx.Logger.LogMessage(ctx.Logger.GetRateString());
}
ctx.Logger.PauseStopWatch();
ctx.Logger.LogMessage(ctx.Logger.GetRateString());
}
}
if (ctx.Options.ExefsOutDir != null || ctx.Options.ExefsOut != null)
{
if (nca.Header.ContentType != ContentType.Program)
{
ctx.Logger.LogMessage("NCA's content type is not \"Program\"");
return;
}
NcaSection section = nca.Sections[(int)ProgramPartitionType.Code];
if (section == null)
{
ctx.Logger.LogMessage("Could not find an ExeFS section");
return;
}
if (ctx.Options.ExefsOut != null)
{
nca.ExportSection(section.SectionNum, ctx.Options.ExefsOut, ctx.Options.Raw, ctx.Options.IntegrityLevel, ctx.Logger);
}
if (ctx.Options.ExefsOutDir != null)
{
IFileSystem pfs = nca.OpenSectionFileSystem(section.SectionNum, ctx.Options.IntegrityLevel);
pfs.Extract(ctx.Options.ExefsOutDir, ctx.Logger);
}
}
if (ctx.Options.PlaintextOut != null)
{
nca.OpenDecryptedNca().WriteAllBytes(ctx.Options.PlaintextOut, ctx.Logger);
}
if (!ctx.Options.ReadBench)
{
ctx.Logger.LogMessage(nca.Print());
}
}
}
public void EnsureInitialized(ContentManager contentManager)
{
if (_fontData == null)
{
_device.Memory.FillWithZeros(_physicalAddress, Horizon.FontSize);
uint fontOffset = 0;
FontInfo CreateFont(string name)
{
if (contentManager.TryGetFontTitle(name, out long fontTitle))
{
string contentPath = contentManager.GetInstalledContentPath(fontTitle, StorageId.NandSystem, ContentType.Data);
string fontPath = _device.FileSystem.SwitchPathToSystemPath(contentPath);
if (!string.IsNullOrWhiteSpace(fontPath))
{
int fileIndex = 0;
//Use second file in Chinese Font title for standard
if (name == "FontChineseSimplified")
{
fileIndex = 1;
}
byte[] data;
using (FileStream ncaFileStream = new FileStream(fontPath, FileMode.Open, FileAccess.Read))
{
Nca nca = new Nca(_device.System.KeySet, ncaFileStream.AsStorage(), false);
NcaSection romfsSection = nca.Sections.FirstOrDefault(x => x?.Type == SectionType.Romfs);
Romfs romfs = new Romfs(nca.OpenSection(romfsSection.SectionNum, false, _device.System.FsIntegrityCheckLevel, false));
Stream fontFile = romfs.OpenFile(romfs.Files[fileIndex]).AsStream();
data = DecryptFont(fontFile);
}
FontInfo info = new FontInfo((int)fontOffset, data.Length);
WriteMagicAndSize(_physicalAddress + fontOffset, data.Length);
fontOffset += 8;
uint start = fontOffset;
for (; fontOffset - start < data.Length; fontOffset++)
{
_device.Memory.WriteByte(_physicalAddress + fontOffset, data[fontOffset - start]);
}
return(info);
}
}
string fontFilePath = Path.Combine(_fontsPath, name + ".ttf");
if (File.Exists(fontFilePath))
{
byte[] data = File.ReadAllBytes(fontFilePath);
FontInfo info = new FontInfo((int)fontOffset, data.Length);
WriteMagicAndSize(_physicalAddress + fontOffset, data.Length);
fontOffset += 8;
uint start = fontOffset;
for (; fontOffset - start < data.Length; fontOffset++)
{
_device.Memory.WriteByte(_physicalAddress + fontOffset, data[fontOffset - start]);
}
return(info);
}
else
{
throw new InvalidSystemResourceException($"Font \"{name}.ttf\" not found. Please provide it in \"{_fontsPath}\".");
}
}
_fontData = new Dictionary <SharedFontType, FontInfo>
{
{ SharedFontType.JapanUsEurope, CreateFont("FontStandard") },
{ SharedFontType.SimplifiedChinese, CreateFont("FontChineseSimplified") },
{ SharedFontType.SimplifiedChineseEx, CreateFont("FontExtendedChineseSimplified") },
{ SharedFontType.TraditionalChinese, CreateFont("FontChineseTraditional") },
{ SharedFontType.Korean, CreateFont("FontKorean") },
{ SharedFontType.NintendoEx, CreateFont("FontNintendoExtended") }
};
if (fontOffset > Horizon.FontSize)
{
throw new InvalidSystemResourceException(
$"The sum of all fonts size exceed the shared memory size. " +
$"Please make sure that the fonts don't exceed {Horizon.FontSize} bytes in total. " +
$"(actual size: {fontOffset} bytes).");
}
}
}
private static (string, string) processCnmtNca(Nca nca, ref Title title, bool cnmtContent = true)
{
string biggestNca = null, controlNca = null;
log?.WriteLine("Processing CNMT NCA");
try
{
Pfs ncaPfs = new Pfs(nca.OpenSection(0, false, IntegrityCheckLevel.ErrorOnInvalid, true));
PfsFileEntry[] ncaFileEntries = ncaPfs.Files;
foreach (PfsFileEntry pfsEntry in ncaFileEntries)
{
Cnmt cnmt = new Cnmt(ncaPfs.OpenFile(pfsEntry).AsStream());
if (title.version == unchecked ((uint)-1) || cnmt.TitleVersion?.Version > title.version)
{
title.type = cnmt.Type;
title.titleID = String.Format("{0:X16}", cnmt.TitleId);
title.baseTitleID = String.Format("{0:X16}", cnmt.ApplicationTitleId);
title.version = cnmt.TitleVersion?.Version ?? title.version;
title.systemVersion = cnmt.MinimumSystemVersion?.Version ?? unchecked ((uint)-1);
title.applicationVersion = cnmt.MinimumApplicationVersion?.Version ?? unchecked ((uint)-1);
if (cnmtContent)
{
CnmtContentEntry[] contentEntries = cnmt.ContentEntries;
foreach (CnmtContentEntry contentEntry in contentEntries)
{
if (title.type == TitleType.Application || title.type == TitleType.Patch)
{
if (contentEntry.Type == CnmtContentType.Program)
{
biggestNca = BitConverter.ToString(contentEntry.NcaId).Replace("-", "").ToLower() + ".nca";
log?.WriteLine("Found Biggest NCA {0}", biggestNca);
}
else if (contentEntry.Type == CnmtContentType.Control)
{
controlNca = BitConverter.ToString(contentEntry.NcaId).Replace("-", "").ToLower() + ".nca";
log?.WriteLine("Found Control NCA {0}", controlNca);
}
}
else if (title.type == TitleType.AddOnContent)
{
if (contentEntry.Type == CnmtContentType.Data)
{
biggestNca = BitConverter.ToString(contentEntry.NcaId).Replace("-", "").ToLower() + ".nca";
log?.WriteLine("Found Biggest NCA {0}", biggestNca);
}
}
}
}
}
}
}
catch (MissingKeyException ex)
{
title.error = String.Format("Missing {0}: {1}", ex.Type == KeyType.Title ? "Title Key" : "Key", ex.Name.Replace("key_area_key_application", "master_key"));
log?.WriteLine(title.error);
}
catch (FileNotFoundException) { }
return(biggestNca, controlNca);
}
public void EnsureInitialized(ContentManager ContentManager)
{
if (FontData == null)
{
Device.Memory.FillWithZeros(PhysicalAddress, Horizon.FontSize);
uint FontOffset = 0;
FontInfo CreateFont(string Name)
{
if (ContentManager.TryGetFontTitle(Name, out long FontTitle))
{
string ContentPath = ContentManager.GetInstalledContentPath(FontTitle, StorageId.NandSystem, ContentType.Data);
string FontPath = Device.FileSystem.SwitchPathToSystemPath(ContentPath);
if (!string.IsNullOrWhiteSpace(FontPath))
{
int FileIndex = 0;
//Use second file in Chinese Font title for standard
if (Name == "FontChineseSimplified")
{
FileIndex = 1;
}
FileStream NcaFileStream = new FileStream(FontPath, FileMode.Open, FileAccess.Read);
Nca Nca = new Nca(Device.System.KeySet, NcaFileStream, false);
NcaSection RomfsSection = Nca.Sections.FirstOrDefault(x => x?.Type == SectionType.Romfs);
Romfs Romfs = new Romfs(Nca.OpenSection(RomfsSection.SectionNum, false, Device.System.FsIntegrityCheckLevel));
Stream FontFile = Romfs.OpenFile(Romfs.Files[FileIndex]);
byte[] Data = DecryptFont(FontFile);
FontInfo Info = new FontInfo((int)FontOffset, Data.Length);
WriteMagicAndSize(PhysicalAddress + FontOffset, Data.Length);
FontOffset += 8;
uint Start = FontOffset;
for (; FontOffset - Start < Data.Length; FontOffset++)
{
Device.Memory.WriteByte(PhysicalAddress + FontOffset, Data[FontOffset - Start]);
}
NcaFileStream.Dispose();
Nca.Dispose();
return(Info);
}
}
string FontFilePath = Path.Combine(FontsPath, Name + ".ttf");
if (File.Exists(FontFilePath))
{
byte[] Data = File.ReadAllBytes(FontFilePath);
FontInfo Info = new FontInfo((int)FontOffset, Data.Length);
WriteMagicAndSize(PhysicalAddress + FontOffset, Data.Length);
FontOffset += 8;
uint Start = FontOffset;
for (; FontOffset - Start < Data.Length; FontOffset++)
{
Device.Memory.WriteByte(PhysicalAddress + FontOffset, Data[FontOffset - Start]);
}
return(Info);
}
else
{
throw new InvalidSystemResourceException($"Font \"{Name}.ttf\" not found. Please provide it in \"{FontsPath}\".");
}
}
FontData = new Dictionary <SharedFontType, FontInfo>()
{
{ SharedFontType.JapanUsEurope, CreateFont("FontStandard") },
{ SharedFontType.SimplifiedChinese, CreateFont("FontChineseSimplified") },
{ SharedFontType.SimplifiedChineseEx, CreateFont("FontExtendedChineseSimplified") },
{ SharedFontType.TraditionalChinese, CreateFont("FontChineseTraditional") },
{ SharedFontType.Korean, CreateFont("FontKorean") },
{ SharedFontType.NintendoEx, CreateFont("FontNintendoExtended") }
};
if (FontOffset > Horizon.FontSize)
{
throw new InvalidSystemResourceException(
$"The sum of all fonts size exceed the shared memory size. " +
$"Please make sure that the fonts don't exceed {Horizon.FontSize} bytes in total. " +
$"(actual size: {FontOffset} bytes).");
}
}
}
private void OnNandFound()
{
Nand nand = NANDService.NAND;
Stream NANDSource = NANDService.NANDSource;
NANDSource.Seek(0x804000, SeekOrigin.Begin); // BCPKG2-1-Normal-Main offset + length of BootConfig
FileStream pkg2stream = HACGUIKeyset.TempPkg2FileInfo.Create();
NANDSource.CopyToNew(pkg2stream, 0x7FC000); // rest of BCPPKG2-Normal-Main partition
pkg2stream.Seek(0, SeekOrigin.Begin);
byte[] pkg2raw = new byte[pkg2stream.Length];
pkg2stream.Read(pkg2raw, 0, pkg2raw.Length);
Package2 pkg2 = new Package2(HACGUIKeyset.Keyset, new MemoryStream(pkg2raw));
HACGUIKeyset.RootTempPkg2FolderInfo.Create();
FileStream kernelstream = HACGUIKeyset.TempKernelFileInfo.Create();
FileStream INI1stream = HACGUIKeyset.TempINI1FileInfo.Create();
pkg2.OpenKernel().CopyTo(kernelstream);
pkg2.OpenIni1().CopyTo(INI1stream);
kernelstream.Close();
INI1stream.Close();
Ini1 INI1 = new Ini1(pkg2.OpenIni1());
List <HashSearchEntry> hashes = new List <HashSearchEntry>();
Dictionary <byte[], byte[]> keys = new Dictionary <byte[], byte[]>();
HACGUIKeyset.RootTempINI1Folder.Create();
foreach (Kip kip in INI1.Kips)
{
Stream rodatastream, datastream;
switch (kip.Header.Name)
{
case "FS":
hashes.Add(new HashSearchEntry(NintendoKeys.KeyAreaKeyApplicationSourceHash, 0x10));
hashes.Add(new HashSearchEntry(NintendoKeys.KeyAreaKeyOceanSourceHash, 0x10));
hashes.Add(new HashSearchEntry(NintendoKeys.KeyAreaKeySystemSourceHash, 0x10));
hashes.Add(new HashSearchEntry(NintendoKeys.HeaderKekSourceHash, 0x10));
hashes.Add(new HashSearchEntry(NintendoKeys.SaveMacKekSourceHash, 0x10));
hashes.Add(new HashSearchEntry(NintendoKeys.SaveMacKeySourceHash, 0x10));
rodatastream = new MemoryStream(kip.DecompressSection(1));
keys = rodatastream.FindKeyViaHash(hashes, new SHA256Managed(), 0x10);
Array.Copy(keys[NintendoKeys.KeyAreaKeyApplicationSourceHash], HACGUIKeyset.Keyset.KeyAreaKeyApplicationSource, 0x10);
Array.Copy(keys[NintendoKeys.KeyAreaKeyOceanSourceHash], HACGUIKeyset.Keyset.KeyAreaKeyOceanSource, 0x10);
Array.Copy(keys[NintendoKeys.KeyAreaKeySystemSourceHash], HACGUIKeyset.Keyset.KeyAreaKeySystemSource, 0x10);
Array.Copy(keys[NintendoKeys.HeaderKekSourceHash], HACGUIKeyset.Keyset.HeaderKekSource, 0x10);
Array.Copy(keys[NintendoKeys.SaveMacKekSourceHash], HACGUIKeyset.Keyset.SaveMacKekSource, 0x10);
Array.Copy(keys[NintendoKeys.SaveMacKeySourceHash], HACGUIKeyset.Keyset.SaveMacKeySource, 0x10);
hashes.Clear();
rodatastream.Seek(0, SeekOrigin.Begin);
bool sdWarn = false;
hashes.Add(new HashSearchEntry(NintendoKeys.SDCardKekSourceHash, 0x10));
try
{
keys = rodatastream.FindKeyViaHash(hashes, new SHA256Managed(), 0x10);
Array.Copy(keys[NintendoKeys.SDCardKekSourceHash], HACGUIKeyset.Keyset.SdCardKekSource, 0x10);
}
catch (EndOfStreamException)
{
MessageBox.Show("Failed to find SD card kek source! The NAND is probably from 1.0.0.");
sdWarn = true;
}
if (!sdWarn) // don't try to find the rest of the keys if the other one couldn't be found
{
hashes.Clear();
rodatastream.Seek(0, SeekOrigin.Begin);
hashes.Add(new HashSearchEntry(NintendoKeys.SDCardSaveKeySourceHash, 0x20));
hashes.Add(new HashSearchEntry(NintendoKeys.SDCardNcaKeySourceHash, 0x20));
keys = rodatastream.FindKeyViaHash(hashes, new SHA256Managed(), 0x20);
Array.Copy(keys[NintendoKeys.SDCardSaveKeySourceHash], HACGUIKeyset.Keyset.SdCardKeySources[0], 0x20);
Array.Copy(keys[NintendoKeys.SDCardNcaKeySourceHash], HACGUIKeyset.Keyset.SdCardKeySources[1], 0x20);
}
hashes.Clear();
rodatastream.Close();
hashes.Add(new HashSearchEntry(NintendoKeys.HeaderKeySourceHash, 0x20));
datastream = new MemoryStream(kip.DecompressSection(2));
keys = datastream.FindKeyViaHash(hashes, new SHA256Managed(), 0x20);
Array.Copy(keys[NintendoKeys.HeaderKeySourceHash], HACGUIKeyset.Keyset.HeaderKeySource, 0x20);
datastream.Close();
hashes.Clear();
break;
case "spl":
hashes.Add(new HashSearchEntry(NintendoKeys.AesKeyGenerationSourceHash, 0x10));
rodatastream = new MemoryStream(kip.DecompressSection(1));
keys = rodatastream.FindKeyViaHash(hashes, new SHA256Managed(), 0x10);
Array.Copy(keys[NintendoKeys.AesKeyGenerationSourceHash], HACGUIKeyset.Keyset.AesKeyGenerationSource, 0x10);
rodatastream.Close();
hashes.Clear();
break;
}
FileStream kipstream = HACGUIKeyset.RootTempINI1Folder.GetFile(kip.Header.Name + ".kip").Create();
kip.OpenRawFile().CopyTo(kipstream);
kipstream.Close();
}
pkg2stream.Close();
INI1stream.Close();
HACGUIKeyset.Keyset.DeriveKeys();
SwitchFs fs = new SwitchFs(HACGUIKeyset.Keyset, NANDService.NAND.OpenSystemPartition());
foreach (KeyValuePair <string, Nca> kv in fs.Ncas)
{
Nca nca = kv.Value;
switch (nca.Header.TitleId)
{
case 0x0100000000000033: // es
switch (nca.Header.ContentType)
{
case ContentType.Program:
NcaSection exefsSection = nca.Sections.FirstOrDefault(x => x?.Type == SectionType.Pfs0);
Stream pfsStream = nca.OpenSection(exefsSection.SectionNum, false, false);
Pfs pfs = new Pfs(pfsStream);
Nso nso = new Nso(pfs.OpenFile("main"));
NsoSection section = nso.Sections[1];
Stream data = new MemoryStream(section.DecompressSection());
hashes.Clear();
hashes.Add(new HashSearchEntry(NintendoKeys.EticketRsaKekSourceHash, 0x10));
hashes.Add(new HashSearchEntry(NintendoKeys.EticketRsaKekekSourceHash, 0x10));
keys = data.FindKeyViaHash(hashes, new SHA256Managed(), 0x10, data.Length);
byte[] EticketRsaKekSource = new byte[0x10];
byte[] EticketRsaKekekSource = new byte[0x10];
Array.Copy(keys[NintendoKeys.EticketRsaKekSourceHash], EticketRsaKekSource, 0x10);
Array.Copy(keys[NintendoKeys.EticketRsaKekekSourceHash], EticketRsaKekekSource, 0x10);
byte[] RsaOaepKekGenerationSource;
XOR(NintendoKeys.KekMasks[0], NintendoKeys.KekSeeds[3], out RsaOaepKekGenerationSource);
byte[] key1 = new byte[0x10];
Crypto.DecryptEcb(HACGUIKeyset.Keyset.MasterKeys[0], RsaOaepKekGenerationSource, key1, 0x10);
byte[] key2 = new byte[0x10];
Crypto.DecryptEcb(key1, EticketRsaKekekSource, key2, 0x10);
byte[] key3 = new byte[0x10];
Crypto.DecryptEcb(key2, EticketRsaKekSource, HACGUIKeyset.Keyset.EticketRsaKek, 0x10);
break;
}
break;
}
}
Stream prodinfo = nand.OpenProdInfo();
Stream prodinfoFile = HACGUIKeyset.TempPRODINFOFileInfo.Create();
prodinfo.CopyTo(prodinfoFile);
prodinfo.Close();
prodinfoFile.Seek(0, SeekOrigin.Begin);
Calibration cal0 = new Calibration(prodinfoFile);
HACGUIKeyset.Keyset.EticketExtKeyRsa = Crypto.DecryptRsaKey(cal0.EticketExtKeyRsa, HACGUIKeyset.Keyset.EticketRsaKek);
prodinfoFile.Close();
List <Ticket> tickets = new List <Ticket>();
NandPartition system = nand.OpenSystemPartition();
Stream e1Stream = system.OpenFile("save\\80000000000000E1", FileMode.Open, FileAccess.Read);
tickets.AddRange(ReadTickets(HACGUIKeyset.Keyset, e1Stream));
Stream e2Stream = system.OpenFile("save\\80000000000000E2", FileMode.Open, FileAccess.Read);
tickets.AddRange(ReadTickets(HACGUIKeyset.Keyset, e2Stream));
Stream nsAppmanStream = system.OpenFile("save\\8000000000000043", FileMode.Open, FileAccess.Read);
Savefile save = new Savefile(HACGUIKeyset.Keyset, nsAppmanStream, false);
Stream privateStream = save.OpenFile("/private");
byte[] sdSeed = new byte[0x10];
privateStream.Read(sdSeed, 0, 0x10); // Seek doesn't work so i just read twice
privateStream.Read(sdSeed, 0, 0x10);
HACGUIKeyset.Keyset.SetSdSeed(sdSeed);
foreach (Ticket ticket in tickets)
{
HACGUIKeyset.Keyset.TitleKeys[ticket.RightsId] = new byte[0x10];
Array.Copy(ticket.TitleKeyBlock, HACGUIKeyset.Keyset.TitleKeys[ticket.RightsId], 0x10);
}
NANDService.Stop();
HACGUIKeyset.ProductionKeysFileInfo.Create().WriteString(HACGUIKeyset.PrintCommonKeys(HACGUIKeyset.Keyset, true));
HACGUIKeyset.ExtraKeysFileInfo.Create().WriteString(HACGUIKeyset.PrintCommonWithoutFriendlyKeys(HACGUIKeyset.Keyset));
HACGUIKeyset.ConsoleKeysFileInfo.Create().WriteString(ExternalKeys.PrintUniqueKeys(HACGUIKeyset.Keyset));
HACGUIKeyset.GetConsoleKeysFileInfoByName(PickConsole.ConsoleName).Create().WriteString(ExternalKeys.PrintUniqueKeys(HACGUIKeyset.Keyset));
HACGUIKeyset.TitleKeysFileInfo.Create().WriteString(ExternalKeys.PrintTitleKeys(HACGUIKeyset.Keyset));
}
public static void Process(Context ctx)
{
using (var file = new FileStream(ctx.Options.InFile, FileMode.Open, FileAccess.Read))
{
var xci = new Xci(ctx.Keyset, file.AsStorage());
ctx.Logger.LogMessage(xci.Print());
if (ctx.Options.RootDir != null)
{
xci.RootPartition?.Extract(ctx.Options.RootDir, ctx.Logger);
}
if (ctx.Options.UpdateDir != null)
{
xci.UpdatePartition?.Extract(ctx.Options.UpdateDir, ctx.Logger);
}
if (ctx.Options.NormalDir != null)
{
xci.NormalPartition?.Extract(ctx.Options.NormalDir, ctx.Logger);
}
if (ctx.Options.SecureDir != null)
{
xci.SecurePartition?.Extract(ctx.Options.SecureDir, ctx.Logger);
}
if (ctx.Options.LogoDir != null)
{
xci.LogoPartition?.Extract(ctx.Options.LogoDir, ctx.Logger);
}
if (ctx.Options.OutDir != null && xci.RootPartition != null)
{
XciPartition root = xci.RootPartition;
if (root == null)
{
ctx.Logger.LogMessage("Could not find root partition");
return;
}
foreach (PfsFileEntry sub in root.Files)
{
var subPfs = new Pfs(root.OpenFile(sub));
string subDir = Path.Combine(ctx.Options.OutDir, sub.Name);
subPfs.Extract(subDir, ctx.Logger);
}
}
if (ctx.Options.ExefsOutDir != null || ctx.Options.ExefsOut != null)
{
Nca mainNca = GetXciMainNca(xci, ctx);
if (mainNca == null)
{
ctx.Logger.LogMessage("Could not find Program NCA");
return;
}
NcaSection exefsSection = mainNca.Sections[(int)ProgramPartitionType.Code];
if (exefsSection == null)
{
ctx.Logger.LogMessage("NCA has no ExeFS section");
return;
}
if (ctx.Options.ExefsOutDir != null)
{
mainNca.ExtractSection(exefsSection.SectionNum, ctx.Options.ExefsOutDir, ctx.Options.IntegrityLevel, ctx.Logger);
}
if (ctx.Options.ExefsOut != null)
{
mainNca.ExportSection(exefsSection.SectionNum, ctx.Options.ExefsOut, ctx.Options.Raw, ctx.Options.IntegrityLevel, ctx.Logger);
}
}
if (ctx.Options.RomfsOutDir != null || ctx.Options.RomfsOut != null)
{
Nca mainNca = GetXciMainNca(xci, ctx);
if (mainNca == null)
{
ctx.Logger.LogMessage("Could not find Program NCA");
return;
}
NcaSection romfsSection = mainNca.Sections.FirstOrDefault(x => x.Type == SectionType.Romfs);
if (romfsSection == null)
{
ctx.Logger.LogMessage("NCA has no RomFS section");
return;
}
if (ctx.Options.RomfsOutDir != null)
{
var romfs = new Romfs(mainNca.OpenSection(romfsSection.SectionNum, false, ctx.Options.IntegrityLevel, true));
romfs.Extract(ctx.Options.RomfsOutDir, ctx.Logger);
}
if (ctx.Options.RomfsOut != null)
{
mainNca.ExportSection(romfsSection.SectionNum, ctx.Options.RomfsOut, ctx.Options.Raw, ctx.Options.IntegrityLevel, ctx.Logger);
}
}
}
}
public void LoadNca(Nca MainNca, Nca ControlNca)
{
NcaSection RomfsSection = MainNca.Sections.FirstOrDefault(x => x?.Type == SectionType.Romfs || x?.Type == SectionType.Bktr);
NcaSection ExefsSection = MainNca.Sections.FirstOrDefault(x => x?.IsExefs == true);
if (ExefsSection == null)
{
Logger.PrintError(LogClass.Loader, "No ExeFS found in NCA");
return;
}
if (RomfsSection == null)
{
Logger.PrintWarning(LogClass.Loader, "No RomFS found in NCA");
}
else
{
Stream RomfsStream = MainNca.OpenSection(RomfsSection.SectionNum, false, EnableFsIntegrityChecks);
Device.FileSystem.SetRomFs(RomfsStream);
}
Stream ExefsStream = MainNca.OpenSection(ExefsSection.SectionNum, false, EnableFsIntegrityChecks);
Pfs Exefs = new Pfs(ExefsStream);
Npdm MetaData = null;
if (Exefs.FileExists("main.npdm"))
{
Logger.PrintInfo(LogClass.Loader, "Loading main.npdm...");
MetaData = new Npdm(Exefs.OpenFile("main.npdm"));
}
else
{
Logger.PrintWarning(LogClass.Loader, $"NPDM file not found, using default values!");
}
Process MainProcess = MakeProcess(MetaData);
void LoadNso(string Filename)
{
foreach (PfsFileEntry File in Exefs.Files.Where(x => x.Name.StartsWith(Filename)))
{
if (Path.GetExtension(File.Name) != string.Empty)
{
continue;
}
Logger.PrintInfo(LogClass.Loader, $"Loading {Filename}...");
string Name = Path.GetFileNameWithoutExtension(File.Name);
Nso Program = new Nso(Exefs.OpenFile(File), Name);
MainProcess.LoadProgram(Program);
}
}
Nacp ReadControlData()
{
Romfs ControlRomfs = new Romfs(ControlNca.OpenSection(0, false, EnableFsIntegrityChecks));
byte[] ControlFile = ControlRomfs.GetFile("/control.nacp");
BinaryReader Reader = new BinaryReader(new MemoryStream(ControlFile));
Nacp ControlData = new Nacp(Reader);
CurrentTitle = ControlData.Languages[(int)State.DesiredTitleLanguage].Title;
if (string.IsNullOrWhiteSpace(CurrentTitle))
{
CurrentTitle = ControlData.Languages.ToList().Find(x => !string.IsNullOrWhiteSpace(x.Title)).Title;
}
return(ControlData);
}
if (ControlNca != null)
{
MainProcess.ControlData = ReadControlData();
}
else
{
CurrentTitle = MainProcess.MetaData.ACI0.TitleId.ToString("x16");
}
if (!MainProcess.MetaData.Is64Bits)
{
throw new NotImplementedException("32-bit titles are unsupported!");
}
LoadNso("rtld");
MainProcess.SetEmptyArgs();
LoadNso("main");
LoadNso("subsdk");
LoadNso("sdk");
MainProcess.Run();
}
