fix: typo

src/dumper/main.cs

@@ -13,9 +13,9 @@ using Newtonsoft.Json;
 
 class DumpByDaylight
 {
-    private const string _pakDir = "E:\\Program Files (x86)\\Steam\\steamapps\\common\\Dead by Daylight\\DeadByDaylight\\Content\\Paks";
+    private const string _pakDir = "D:\\XboxGames\\Dead By Daylight\\Content\\DeadByDaylight\\Content\\Paks";
     private const string _aesKey = "0x22B1639B548124925CF7B9CBAA09F9AC295FCF0324586D6B37EE1D42670B39B3";
-    private const string _mappingURL = "https://github.com/Masusder/FModel-DbdMappings/raw/refs/heads/main/Mappings/9.5.0/5.4.4-3172922+++DeadByDaylight+Quiche_REL-DeadByDaylight.usmap";
+    private const string _mappingURL = "https://git.neru.rip/neru/UnlockedByDaylight/raw/branch/main/res/mappings/latest-xbox.usmap";
 
     public static async Task<string?> DownloadMappingFileAsync(string url, string savePath)
     {
@@ -67,7 +67,7 @@ class DumpByDaylight
 
         Console.WriteLine("\nProvider Initialized. Extracting Databases...");
 
-        var dataPak = provider.GetArchive("pakchunk4-Windows.utoc");
+        var dataPak = provider.GetArchive("pakchunk4-WinGDK.utoc");
 
         /*
          *  itemdb dump

src/unlocker/cert_manager.cpp

@@ -13,6 +13,7 @@
 #include <ctime>
 
 #include <processthreadsapi.h>
+#include <cstring>
 
 std::string randomizeString(size_t length)
 {
@@ -133,8 +134,11 @@ bool CertManager::GenerateCA()
 
     Log::info("Generated new CA key and certificate files. Installing to Windows Root CA store automatically...");
 
-    STARTUPINFOA si = {sizeof(si)};
+    STARTUPINFOA si;
+    memset(&si, 0, sizeof(si));
+    si.cb = sizeof(si);
     PROCESS_INFORMATION pi;
+    memset(&pi, 0, sizeof(pi));
     char cmd[] = "certutil.exe -user -addstore root ca_cert.pem";
     if (CreateProcessA(NULL, cmd, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi))
     {

src/unlocker/proxy.cpp

@@ -335,6 +335,10 @@ void Proxy::handleClient(SOCKET hClientSocket)
                     {
                         std::string emptyBody = "";
                         OnClientRequest.run(url, emptyBody, headers);
+
+                        if (!pendingUrls.empty())
+                            pendingUrls.back() = url;
+
                         SSL_write(remoteSSL, headers.data(), (int)headers.size());
                         clientStream.buffer.erase(0, clientStream.headersEnd + 4);
                         clientStream.reset();
@@ -383,6 +387,9 @@ void Proxy::handleClient(SOCKET hClientSocket)
                     if (complete)
                     {
                         OnClientRequest.run(url, body, headers);
+                        if (!pendingUrls.empty() && pendingUrls.back() != url)
+                            pendingUrls.back() = url;
+
                         SSL_write(remoteSSL, headers.data(), (int)headers.size());
                         SSL_write(remoteSSL, clientStream.buffer.data() + bodyStart,
                                   (int)(clientStream.buffer.size() - bodyStart));
@@ -534,10 +541,6 @@ void Proxy::handleClient(SOCKET hClientSocket)
                         if (!pendingUrls.empty()) pendingUrls.pop_front();
 
                         std::string respHeaders = serverStream.buffer.substr(0, bStart);
-                        size_t firstSpace = respHeaders.find(' ');
-                        int sc =
-                            (firstSpace != std::string::npos) ? safe_stoi(respHeaders.substr(firstSpace + 1, 3)) : 0;
-
                         OnServerResponse.run(url, body, respHeaders);
 
                         removeHeader(respHeaders, "Transfer-Encoding");

src/unlocker/proxy.h

@@ -25,7 +25,7 @@ class Proxy
         bool Init();
         void Shutdown();
 
-        CallbackEvent<const std::string&, const std::string&, std::string&> OnClientRequest;
+        CallbackEvent<std::string&, const std::string&, std::string&> OnClientRequest;
         CallbackEvent<const std::string&, std::string&, std::string&> OnServerResponse;
 
     private:

src/unlocker/spoofing.cpp

@@ -33,6 +33,10 @@ void Spoofer::registerListeners(Proxy* proxy)
     proxy->OnServerResponse.addListener([this](const std::string& url, std::string& body, std::string& respHeaders) {
         this->serverResponseHandler(url, body, respHeaders);
     });
+
+    proxy->OnClientRequest.addListener([this](std::string& url, const std::string& body, std::string& reqHeaders) {
+        this->clientRequestHandler(url, body, reqHeaders);
+    });
 }
 
 void Spoofer::loadData()
@@ -212,6 +216,7 @@ void Spoofer::modifyCharacterData(json& js)
     stackableIds.insert(_camperOfferingIds.begin(), _camperOfferingIds.end());
     stackableIds.insert(_camperAddonIds.begin(), _camperAddonIds.end());
     stackableIds.insert(_slasherAddonIds.begin(), _slasherAddonIds.end());
+    stackableIds.insert(_slasherOfferingIds.begin(), _slasherOfferingIds.end());
 
     if (js.contains("characterItems") && js["characterItems"].is_array())
     {
@@ -259,9 +264,11 @@ void Spoofer::modifyCharacterData(json& js)
     }
 }
 
-void Spoofer::serverResponseHandler(const std::string& url, std::string& body, std::string& /*respHeaders*/)
+void Spoofer::serverResponseHandler(const std::string& url, std::string& body, std::string& respHeaders)
 {
+#ifdef _DEBUG
     if (url.find("bhvrdbd.com") != std::string::npos) Log::verbose("BHVR api res @ {}", url);
+#endif
 
     if (url.find("api/v1/extensions/store/getCatalogItems") != std::string::npos) return parseAndDumpCatalog(body);
 
@@ -278,14 +285,6 @@ void Spoofer::serverResponseHandler(const std::string& url, std::string& body, s
             std::unordered_set<std::string> foundOfferings;
             std::unordered_set<std::string> foundCatalogItems;
 
-            //std::unordered_set<std::string> objectIds;
-            //objectIds.insert(_camperItemIds.begin(), _camperItemIds.end());
-            //objectIds.insert(_slasherPowerIds.begin(), _slasherPowerIds.end());
-
-            //std::unordered_set<std::string> addonIds;
-            //addonIds.insert(_camperAddonIds.begin(), _camperAddonIds.end());
-            //addonIds.insert(_slasherAddonIds.begin(), _slasherAddonIds.end());
-
             std::unordered_set<std::string> offeringIds;
             offeringIds.insert(_camperOfferingIds.begin(), _camperOfferingIds.end());
             offeringIds.insert(_slasherOfferingIds.begin(), _slasherOfferingIds.end());
@@ -302,20 +301,6 @@ void Spoofer::serverResponseHandler(const std::string& url, std::string& body, s
             {
                 std::string objectId = item["objectId"];
 
-                /*if (objectIds.find(objectId) != objectIds.end())
-                {
-                    foundObjects.insert(objectId);
-                    item["quantity"] = 100;
-                    continue;
-                }
-
-                if (addonIds.find(objectId) != addonIds.end())
-                {
-                    foundAddons.insert(objectId);
-                    item["quantity"] = 100;
-                    continue;
-                }*/
-
                 if (perkIds.find(objectId) != perkIds.end())
                 {
                     foundPerks.insert(objectId);
@@ -337,30 +322,6 @@ void Spoofer::serverResponseHandler(const std::string& url, std::string& body, s
                 }
             }
 
-            /*for (const std::string& id : objectIds)
-            {
-                if (foundObjects.find(id) == foundObjects.end())
-                {
-                    itemsArr.push_back({
-                        {"objectId", id},
-                        {"quantity", 100},
-                        {"lastUpdateAt", std::time(nullptr)},
-                    });
-                }
-            }
-
-            for (const std::string& id : addonIds)
-            {
-                if (foundAddons.find(id) == foundAddons.end())
-                {
-                    itemsArr.push_back({
-                        {"objectId", id},
-                        {"quantity", 100},
-                        {"lastUpdateAt", std::time(nullptr)},
-                    });
-                }
-            }*/
-
             for (const std::string& id : perkIds)
             {
                 if (foundPerks.find(id) == foundPerks.end())
@@ -423,11 +384,24 @@ void Spoofer::serverResponseHandler(const std::string& url, std::string& body, s
 
             for (auto& charInfo : charList)
             {
-                charInfo["isEntitled"] = true;
-                if (charInfo.contains("bloodWebLevel") && charInfo["bloodWebLevel"] <= 1)
+                if (charInfo.contains("bloodWebLevel") && charInfo.at("bloodWebLevel").get<int>() <= 15)
+                    if (!charInfo.contains("prestigeLevel") || charInfo.at("prestigeLevel").get<int>() <= 0)
+                        charInfo["bloodWebLevel"] = 15;
+
+                if (charInfo.contains("bloodWebData") && charInfo.at("bloodWebData").contains("level"))
+                    charInfo["bloodWebData"]["level"] = 1;
+
+                if (charInfo["isEntitled"] == false)
                 {
-                    charInfo["bloodWebLevel"] = 15;
-                    if (charInfo["bloodWebData"].contains("level")) charInfo["bloodWebData"]["level"] = 1;
+                    charInfo["isEntitled"] = true;
+                    if (charInfo.contains("origin"))
+                    {
+                        charInfo["purchaseInfo"] = {{"quantity", 1},
+                                                    {"origin", "PlayerInventory"},
+                                                    {"reason", "Item(s) added via Purchase"},
+                                                    {"lastUpdateAt", 1770702482},
+                                                    {"objectId", charInfo["characterName"]}};
+                    }
                 }
 
                 modifyCharacterData(charInfo);
@@ -446,8 +420,36 @@ void Spoofer::serverResponseHandler(const std::string& url, std::string& body, s
         try
         {
             json doc = json::parse(body);
-            modifyCharacterData(doc);
-            body = doc.dump();
+
+            if (body.find("NotAllowedException") != std::string::npos && body.find("not owned") != std::string::npos)
+            {
+                Log::info("Spoofing bloodweb error for unowned character");
+                json mock;
+                mock["bloodWebLevelChanged"] = false;
+                mock["updatedWallets"] = json::array();
+                mock["bloodWebLevel"] = 15;
+                mock["prestigeLevel"] = 0;
+                mock["bloodWebData"] = {{"ringData", json::array()}, {"paths", json::array()}};
+                mock["characterItems"] = json::array();
+                mock["characterName"] = this->_lastBloodWebChar;
+
+                modifyCharacterData(mock);
+
+                size_t firstSpace = respHeaders.find(' ');
+                if (firstSpace != std::string::npos)
+                {
+                    respHeaders.replace(firstSpace + 1, 3, "200");
+                }
+
+                body = mock.dump();
+                return;
+            }
+            else
+            {
+                modifyCharacterData(doc);
+                body = doc.dump();
+            }
+            return;
         }
         catch (const json::parse_error& e)
         {
@@ -456,3 +458,23 @@ void Spoofer::serverResponseHandler(const std::string& url, std::string& body, s
         return;
     }
 }
+
+void Spoofer::clientRequestHandler(std::string& url, const std::string& body, std::string& /*reqHeaders*/)
+{
+    if (url.find("api/v1/dbd-character-data/bloodweb") != std::string::npos ||
+        url.find("api/v1/dbd-character-data/bulk-spending-bloodweb") != std::string::npos)
+    {
+        try
+        {
+            json req = json::parse(body);
+            if (req.contains("characterName"))
+            {
+                this->_lastBloodWebChar = req["characterName"];
+                Log::info("Detected bloodweb request for character: {}", this->_lastBloodWebChar);
+            }
+        }
+        catch (...)
+        {
+        }
+    }
+}

src/unlocker/spoofing.h

@@ -22,6 +22,7 @@ class Spoofer
         void modifyCharacterData(nlohmann::json& js);
 
         void serverResponseHandler(const std::string& url, std::string& body, std::string& respHeaders);
+        void clientRequestHandler(std::string& url, const std::string& body, std::string& reqHeaders);
 
         std::unordered_set<std::string> _camperItemIds;
         std::unordered_set<std::string> _slasherPowerIds;
@@ -37,4 +38,6 @@ class Spoofer
 
         std::unordered_set<std::string> _catalogOutfitIds;
         std::unordered_set<std::string> _catalogItemIds;
+
+        std::string _lastBloodWebChar = "Ace";
 };