Skip to content

Commit

Permalink
Qt: Improve PS3 Binaries Decryption tool
Browse files Browse the repository at this point in the history
  • Loading branch information
@elad335
elad335 committed Jun 10, 2023
1 parent b2842dc commit ec1a1a0
Show file tree
Hide file tree
Showing 5 changed files with 147 additions and 76 deletions.
102 changes: 55 additions & 47 deletions rpcs3/Crypto/decrypt_binaries.cpp
View file
Expand Up @@ -11,34 +11,66 @@

LOG_CHANNEL(dec_log, "DECRYPT");

void decrypt_sprx_libraries(std::vector<std::string> modules, std::function<std::string(std::string old_path, std::string path, bool tried)> input_cb)
usz decrypt_binaries_t::decrypt(std::string klic_input)
{
if (modules.empty())
if (m_index >= m_modules.size())
{
std::cout << "No paths specified" << std::endl; // For CLI
return;
m_index = umax;
return umax;
}

dec_log.notice("Decrypting binaries...");
std::cout << "Decrypting binaries..." << std::endl; // For CLI
if (m_klics.empty())
{
dec_log.notice("Decrypting binaries...");
std::cout << "Decrypting binaries..." << std::endl; // For CLI

// Always start with no KLIC
std::vector<u128> klics{u128{}};
// Always start with no KLIC
m_klics.emplace_back(u128{});

if (const auto keys = g_fxo->try_get<loaded_npdrm_keys>())
{
// Second klic: get it from a running game
if (const u128 klic = keys->last_key())
if (const auto keys = g_fxo->try_get<loaded_npdrm_keys>())
{
klics.emplace_back(klic);
// Second klic: get it from a running game
if (const u128 klic = keys->last_key())
{
m_klics.emplace_back(klic);
}
}

// Try to use the key that has been for the current running ELF
m_klics.insert(m_klics.end(), Emu.klic.begin(), Emu.klic.end());
}

// Try to use the key that has been for the current running ELF
klics.insert(klics.end(), Emu.klic.begin(), Emu.klic.end());
if (std::string_view text = std::string_view{klic_input}.substr(klic_input.find_first_of('x') + 1); text.size() == 32)
{
// Allowed to fail (would simply repeat the operation if fails again)
u64 lo = 0;
u64 hi = 0;
bool success = false;

if (auto res = std::from_chars(text.data() + 0, text.data() + 16, lo, 16); res.ec == std::errc() && res.ptr == text.data() + 16)
{
if (res = std::from_chars(text.data() + 16, text.data() + 32, hi, 16); res.ec == std::errc() && res.ptr == text.data() + 32)
{
success = true;
}
}

if (success)
{
lo = std::bit_cast<be_t<u64>>(lo);
hi = std::bit_cast<be_t<u64>>(hi);

if (u128 input_key = ((u128{hi} << 64) | lo))
{
m_klics.emplace_back(input_key);
}
}
}

for (const std::string& _module : modules)
while (m_index < m_modules.size())
{
const std::string& _module = m_modules[m_index];
const std::string old_path = _module;

fs::file elf_file;
Expand All @@ -50,7 +82,7 @@ void decrypt_sprx_libraries(std::vector<std::string> modules, std::function<std:

while (true)
{
for (; key_it < klics.size(); key_it++)
for (; key_it < m_klics.size(); key_it++)
{
if (!elf_file.open(old_path) || !elf_file.read(file_magic))
{
Expand All @@ -62,7 +94,7 @@ void decrypt_sprx_libraries(std::vector<std::string> modules, std::function<std:
case "SCE\0"_u32:
{
// First KLIC is no KLIC
elf_file = decrypt_self(std::move(elf_file), key_it != 0 ? reinterpret_cast<u8*>(&klics[key_it]) : nullptr);
elf_file = decrypt_self(std::move(elf_file), key_it != 0 ? reinterpret_cast<u8*>(&m_klics[key_it]) : nullptr);

if (!elf_file)
{
Expand All @@ -75,7 +107,7 @@ void decrypt_sprx_libraries(std::vector<std::string> modules, std::function<std:
case "NPD\0"_u32:
{
// EDAT / SDAT
elf_file = DecryptEDAT(elf_file, old_path, key_it != 0 ? 8 : 1, reinterpret_cast<u8*>(&klics[key_it]), true);
elf_file = DecryptEDAT(elf_file, old_path, key_it != 0 ? 8 : 1, reinterpret_cast<u8*>(&m_klics[key_it]), true);

if (!elf_file)
{
Expand Down Expand Up @@ -111,11 +143,13 @@ void decrypt_sprx_libraries(std::vector<std::string> modules, std::function<std:
new_file.write(elf_file.to_string());
dec_log.success("Decrypted %s -> %s", old_path, new_path);
std::cout << "Decrypted " << old_path << " -> " << new_path << std::endl; // For CLI
m_index++;
}
else
{
dec_log.error("Failed to create %s", new_path);
std::cout << "Failed to create " << new_path << std::endl; // For CLI
m_index = umax;
}

break;
Expand All @@ -124,42 +158,16 @@ void decrypt_sprx_libraries(std::vector<std::string> modules, std::function<std:
if (!invalid)
{
// Allow the user to manually type KLIC if decryption failed

const std::string filename = old_path.substr(old_path.find_last_of(fs::delim) + 1);
const std::string text = input_cb ? input_cb(old_path, filename, tried) : "";

if (!text.empty())
{
auto& klic = (tried ? klics.back() : klics.emplace_back());

ensure(text.size() == 32);

// It must succeed (only hex characters are present)
u64 lo_ = 0;
u64 hi_ = 0;
std::from_chars(&text[0], &text[16], lo_, 16);
std::from_chars(&text[16], &text[32], hi_, 16);

be_t<u64> lo = std::bit_cast<be_t<u64>>(lo_);
be_t<u64> hi = std::bit_cast<be_t<u64>>(hi_);

klic = (u128{+hi} << 64) | +lo;

// Retry with specified KLIC
key_it -= +std::exchange(tried, true); // Rewind on second and above attempt
dec_log.notice("KLIC entered for %s: %s", filename, klic);
continue;
}

dec_log.notice("User has cancelled entering KLIC.");
return m_index;
}

dec_log.error("Failed to decrypt \"%s\".", old_path);
std::cout << "Failed to decrypt \"" << old_path << "\"." << std::endl; // For CLI
break;
return m_index;
}
}

dec_log.notice("Finished decrypting all binaries.");
std::cout << "Finished decrypting all binaries." << std::endl; // For CLI
return m_index;
}
25 changes: 24 additions & 1 deletion rpcs3/Crypto/decrypt_binaries.h
View file
@@ -1,3 +1,26 @@
#pragma once

void decrypt_sprx_libraries(std::vector<std::string> modules, std::function<std::string(std::string old_path, std::string path, bool tried)> input_cb);
class decrypt_binaries_t
{
std::vector<u128> m_klics;
std::vector<std::string> m_modules;
usz m_index = 0;

public:
decrypt_binaries_t(std::vector<std::string> modules) noexcept
: m_modules(std::move(modules))
{
}

usz decrypt(std::string klic_input = {});

bool done() const
{
return m_index >= m_klics.size();
}

const std::string& operator[](usz index) const
{
return ::at32(m_modules, index);
}
};
2 changes: 1 addition & 1 deletion rpcs3/Emu/Cell/Modules/sceNp.cpp
View file
Expand Up @@ -468,7 +468,7 @@ error_code npDrmIsAvailable(vm::cptr<u8> k_licensee_addr, vm::cptr<char> drm_pat
if (k_licensee_addr)
{
std::memcpy(&k_licensee, k_licensee_addr.get_ptr(), sizeof(k_licensee));
sceNp.notice("npDrmIsAvailable(): KLicense key %s", std::bit_cast<be_t<u128>>(k_licensee));
sceNp.notice("npDrmIsAvailable(): KLicense key or KLIC=%s", std::bit_cast<be_t<u128>>(k_licensee));
}

if (Emu.GetFakeCat() == "PE")
Expand Down
34 changes: 25 additions & 9 deletions rpcs3/main.cpp
View file
Expand Up @@ -1103,29 +1103,45 @@ int main(int argc, char** argv)
std::cout << "Not a file: " << mod.toStdString() << std::endl;
return 1;
}

vec_modules.push_back(fi.absoluteFilePath().toStdString());
}

const auto input_cb = [](std::string old_path, std::string path, bool tried) -> std::string
Emu.Init();

std::shared_ptr<decrypt_binaries_t> decrypter = std::make_shared<decrypt_binaries_t>(std::move(vec_modules));

usz mod_index = decrypter->decrypt();
usz repeat_count = mod_index == 0 ? 1 : 0;

while (!decrypter->done())
{
const std::string& path = (*decrypter)[mod_index];
const std::string filename = path.substr(path.find_last_of(fs::delim) + 1);

const std::string hint = fmt::format("Hint: KLIC (KLicense key) is a 16-byte long string. (32 hexadecimal characters)"
"\nAnd is logged with some sceNpDrm* functions when the game/application which owns \"%0\" is running.", path);
"\nAnd is logged with some sceNpDrm* functions when the game/application which owns \"%0\" is running.", filename);

if (tried)
if (repeat_count >= 2)
{
std::cout << "Failed to decrypt " << old_path << " with specfied KLIC, retrying.\n" << hint << std::endl;
std::cout << "Failed to decrypt " << path << " with specfied KLIC, retrying.\n" << hint << std::endl;
}

std::cout << "Enter KLIC of " << path << "\nHexadecimal only, 32 characters:" << std::endl;
std::cout << "Enter KLIC of " << filename << "\nHexadecimal only, 32 characters:" << std::endl;

std::string input;
std::cin >> input;

return input;
};
if (input.empty())
{
break;
}

const usz new_index = decrypter->decrypt(input);
repeat_count = new_index == mod_index ? repeat_count + 1 : 0;
mod_index = new_index;
}

Emu.Init();
decrypt_sprx_libraries(vec_modules, input_cb);
Emu.Quit(true);
return 0;
}
Expand Down
60 changes: 42 additions & 18 deletions rpcs3/rpcs3qt/main_window.cpp
View file
Expand Up @@ -1584,40 +1584,64 @@ void main_window::DecryptSPRXLibraries()
vec_modules.push_back(mod.toStdString());
}

const auto input_cb = [this](std::string old_path, std::string path, bool tried) -> std::string
auto iterate = std::make_shared<std::function<void(usz, usz)>>();
const auto decrypter = std::make_shared<decrypt_binaries_t>(std::move(vec_modules));

*iterate = [this, iterate, decrypter](usz mod_index, usz repeat_count)
{
const QString hint = tr("Hint: KLIC (KLicense key) is a 16-byte long string. (32 hexadecimal characters)"
"\nAnd is logged with some sceNpDrm* functions when the game/application which owns \"%0\" is running.").arg(qstr(path));
const std::string& path = (*decrypter)[mod_index];
const std::string filename = path.substr(path.find_last_of(fs::delim) + 1);

const QString hint = tr("Hint: KLIC (KLicense key) is a 16-byte long string. (32 hexadecimal characters, can be prefixed with \"KLIC=0x\" from the log message)"
"\nAnd is logged with some sceNpDrm* functions when the game/application which owns \"%0\" is running.").arg(qstr(filename));

if (tried)
if (repeat_count >= 2)
{
gui_log.error("Failed to decrypt %s with specfied KLIC, retrying.\n%s", old_path, sstr(hint));
gui_log.error("Failed to decrypt %s with specified KLIC, retrying.\n%s", path, sstr(hint));
}

input_dialog dlg(32, "", tr("Enter KLIC of %0").arg(qstr(path)),
tried ? tr("Decryption failed with provided KLIC.\n%0").arg(hint) : tr("Hexadecimal only."), "00000000000000000000000000000000", this);
input_dialog* dlg = new input_dialog(39, "", tr("Enter KLIC of %0").arg(qstr(filename)),
repeat_count >= 2 ? tr("Decryption failed with provided KLIC.\n%0").arg(hint) : tr("Hexadecimal value."), "KLIC=0x00000000000000000000000000000000", this);

QFont mono = QFontDatabase::systemFont(QFontDatabase::FixedFont);
mono.setPointSize(8);
dlg.set_input_font(mono, true, '0');
dlg.set_clear_button_enabled(false);
dlg.set_button_enabled(QDialogButtonBox::StandardButton::Ok, false);
dlg.set_validator(new QRegularExpressionValidator(QRegularExpression("^[a-fA-F0-9]*$"))); // HEX only
dlg->set_input_font(mono, true, '0');
dlg->set_clear_button_enabled(false);
dlg->set_button_enabled(QDialogButtonBox::StandardButton::Ok, false);
dlg->set_validator(new QRegularExpressionValidator(QRegularExpression("^((((((K?L)?I)?C)?=)?0)?x)?[a-fA-F0-9]{0,32}$"))); // HEX only (with additional KLIC=0x prefix for convenience)
dlg->setAttribute(Qt::WA_DeleteOnClose);

connect(&dlg, &input_dialog::text_changed, &dlg, [&dlg](const QString& text)
connect(dlg, &input_dialog::text_changed, dlg, [dlg](const QString& text)
{
dlg.set_button_enabled(QDialogButtonBox::StandardButton::Ok, text.size() == 32);
dlg->set_button_enabled(QDialogButtonBox::StandardButton::Ok, text.size() - (text.indexOf('x') + 1) == 32);
});

if (dlg.exec() == QDialog::Accepted)
connect(dlg, &QDialog::accepted, this, [this, iterate, dlg, mod_index, decrypter, repeat_count]()
{
return sstr(dlg.get_input_text());
}
std::string text = sstr(dlg->get_input_text());

if (usz new_index = decrypter->decrypt(std::move(text)); !decrypter->done())
{
QTimer::singleShot(0, [iterate, mod_index, repeat_count, new_index]()
{
// Increase repeat count if "stuck" on the same file
(*iterate)(new_index, new_index == mod_index ? repeat_count + 1 : 0);
});
}
});

connect(dlg, &QDialog::rejected, this, []()
{
gui_log.notice("User has cancelled entering KLIC.");
});

return {};
dlg->show();
};

decrypt_sprx_libraries(vec_modules, input_cb);
if (usz new_index = decrypter->decrypt(); !decrypter->done())
{
(*iterate)(new_index, new_index == 0 ? 1 : 0);
}
}

/** Needed so that when a backup occurs of window state in gui_settings, the state is current.
Expand Down

0 comments on commit ec1a1a0

Please sign in to comment.