From ce60ef528952112adb7eb76c740da8c561632921 Mon Sep 17 00:00:00 2001
From: Kamil Marczak <kamil.marczak@alergeek.ventures>
Date: Thu, 8 Oct 2026 14:53:24 +0200
Subject: [PATCH 1/3] fix(app): convert Windows paths in libanalyse and
 cracklib file access

libanalyse writes cipher results with ofstream and cracklib opens its
dictionary with fopen, both on paths CrypTool passes in Windows form. They
were built without mfcwx, so files landed under names like
"\var\folders\...\cry6.txt" in the working directory and the next read
crashed on a NULL FILE* (Caesar encryption, among others). Both libraries
are now compiled with mfcwx's fopen/fstream; their unit tests link stubs.

Also adds MFCWX_AUTOMATION, a small script runner (menu commands, dialog
buttons, control text, waits, snapshots) for reproducing UI flows.
---
 CMakeLists.txt                        |  13 ++++
 port/mfcwx/include/mfcwx/pathcompat.h |  17 +++++
 port/mfcwx/src/snapshot.cpp           | 103 ++++++++++++++++++++++++++
 port/mfcwx/tests/path_stubs.cpp       |  12 +++
 4 files changed, 145 insertions(+)
 create mode 100644 port/mfcwx/include/mfcwx/pathcompat.h
 create mode 100644 port/mfcwx/tests/path_stubs.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3810ed60..5033985c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -33,6 +33,19 @@ if(TARGET secude_compat)
     set_property(TARGET secude_compat PROPERTY INTERFACE_COMPILE_FEATURES "")
 endif()
 add_subdirectory(port/mfcwx)
+# These libraries open files by paths CrypTool passes in Windows form; the app links mfcwx, which
+# converts them, and the library tests use plain stubs.
+foreach(target cryptool_analyse cryptool_cracklib)
+    target_compile_options(${target} PRIVATE "SHELL:-iquote ${CMAKE_SOURCE_DIR}/port/mfcwx/include"
+                           "SHELL:-include ${CMAKE_SOURCE_DIR}/port/mfcwx/include/mfcwx/pathcompat.h")
+endforeach()
+add_library(mfcwx_path_stubs STATIC port/mfcwx/tests/path_stubs.cpp)
+target_include_directories(mfcwx_path_stubs PRIVATE port/mfcwx/include)
+foreach(test test_analyse test_cracklib)
+    if(TARGET ${test})
+        target_link_libraries(${test} PRIVATE mfcwx_path_stubs)
+    endif()
+endforeach()
 add_subdirectory(port/app)
 
 option(CRYPTOOL_DIALOG_GALLERY "Build the dialog snapshot tool" OFF)
diff --git a/port/mfcwx/include/mfcwx/pathcompat.h b/port/mfcwx/include/mfcwx/pathcompat.h
new file mode 100644
index 00000000..5422a201
--- /dev/null
+++ b/port/mfcwx/include/mfcwx/pathcompat.h
@@ -0,0 +1,17 @@
+#pragma once
+
+// Force-included into third-party libraries that open files by paths coming from CrypTool,
+// which are in Windows form ("\dir\file").
+
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+FILE* mfcwx_fopen(const char* name, const char* mode);
+#ifdef __cplusplus
+}
+#include "mfcwx/fstreamcompat.h"
+#endif
+
+#define fopen mfcwx_fopen
diff --git a/port/mfcwx/src/snapshot.cpp b/port/mfcwx/src/snapshot.cpp
index 88656884..68559456 100644
--- a/port/mfcwx/src/snapshot.cpp
+++ b/port/mfcwx/src/snapshot.cpp
@@ -7,6 +7,9 @@
 #include <wx/toplevel.h>
 
 #include <cstdlib>
+#include <fstream>
+#include <sstream>
+#include <vector>
 
 namespace mfcwx {
 
@@ -78,9 +81,109 @@ class SnapshotTimer : public wxTimer {
     int m_round = 0;
 };
 
+std::string SafeName(const wxString& title) {
+    std::string name;
+    for (wxUniChar c : title)
+        name += (c.IsAscii() && isalnum(static_cast<int>(c.GetValue()))) ? static_cast<char>(c.GetValue()) : '_';
+    return name.substr(0, 40);
+}
+
+wxWindow* ActiveDialog() {
+    wxWindow* found = nullptr;
+    for (wxWindow* w : wxTopLevelWindows) {
+        auto* d = wxDynamicCast(w, wxDialog);
+        if (d && d->IsShown())
+            found = d;
+    }
+    return found;
+}
+
+// Development aid: MFCWX_AUTOMATION=file runs one step per line on a timer, for UI tests:
+//   command <id>        WM_COMMAND to the main window
+//   button <id>         WM_COMMAND (BN_CLICKED) to the topmost dialog
+//   text <id> <text>    sets the text of a control of the topmost dialog
+//   wait <ms>
+//   snapshot <label>    PNGs of all shown top-level windows into MFCWX_SNAPSHOT_DIR (or .)
+//   quit
+class AutomationTimer : public wxTimer {
+public:
+    AutomationTimer(std::vector<std::string> steps, std::string dir) : m_steps(std::move(steps)), m_dir(std::move(dir)) {}
+
+    void Notify() override {
+        if (m_waitUntil != 0 && wxGetLocalTimeMillis() < m_waitUntil)
+            return;
+        m_waitUntil = 0;
+        if (m_next >= m_steps.size()) {
+            fprintf(stderr, "mfcwx automation: done\n");
+            fflush(stderr);
+            _exit(0);
+        }
+        std::string line = m_steps[m_next++];
+        std::istringstream in(line);
+        std::string op;
+        in >> op;
+        fprintf(stderr, "mfcwx automation: %s\n", line.c_str());
+        if (op == "command" || op == "button") {
+            int id = 0;
+            in >> id;
+            CWnd* target = op == "command" ? AfxGetMainWnd() : WrapperFor(ActiveDialog());
+            if (target && target->m_hWnd)
+                target->PostMessage(WM_COMMAND, MAKEWPARAM(id, BN_CLICKED), 0);
+            else
+                fprintf(stderr, "mfcwx automation: no target window\n");
+        } else if (op == "text") {
+            int id = 0;
+            in >> id;
+            std::string text;
+            std::getline(in, text);
+            if (!text.empty() && text[0] == ' ')
+                text.erase(0, 1);
+            CWnd* dlg = WrapperFor(ActiveDialog());
+            if (dlg && dlg->m_hWnd)
+                ::SetDlgItemText(dlg->m_hWnd, id, text.c_str());
+        } else if (op == "wait") {
+            long ms = 0;
+            in >> ms;
+            m_waitUntil = wxGetLocalTimeMillis() + ms;
+        } else if (op == "snapshot") {
+            std::string label;
+            in >> label;
+            int index = 0;
+            for (wxWindow* w : wxTopLevelWindows) {
+                if (!w->IsShown())
+                    continue;
+                char path[1024];
+                snprintf(path, sizeof path, "%s/%s_%d_%s.png", m_dir.c_str(), label.c_str(), index++,
+                         SafeName(w->GetLabel()).c_str());
+                bool ok = SnapshotWxWindow(w, path);
+                fprintf(stderr, "mfcwx snapshot %s %s\n", ok ? "saved" : "FAILED", path);
+            }
+        } else if (op == "quit") {
+            m_next = m_steps.size();
+        }
+    }
+
+private:
+    std::vector<std::string> m_steps;
+    std::string m_dir;
+    size_t m_next = 0;
+    wxLongLong m_waitUntil = 0;
+};
+
 } // namespace
 
 void StartSnapshotTimerFromEnvironment() {
+    if (const char* script = getenv("MFCWX_AUTOMATION")) {
+        std::ifstream f(script);
+        std::vector<std::string> steps;
+        for (std::string line; std::getline(f, line);)
+            if (!line.empty() && line[0] != '#')
+                steps.push_back(line);
+        const char* outDir = getenv("MFCWX_SNAPSHOT_DIR");
+        static AutomationTimer automation(steps, outDir && *outDir ? outDir : ".");
+        automation.Start(200);
+        return;
+    }
     const char* dir = getenv("MFCWX_SNAPSHOT_DIR");
     if (!dir || !*dir)
         return;
diff --git a/port/mfcwx/tests/path_stubs.cpp b/port/mfcwx/tests/path_stubs.cpp
new file mode 100644
index 00000000..1ef9e00e
--- /dev/null
+++ b/port/mfcwx/tests/path_stubs.cpp
@@ -0,0 +1,12 @@
+#include <cstdio>
+#include <string>
+
+#include "mfcwx/codepage.h"
+
+extern "C" FILE* mfcwx_fopen(const char* name, const char* mode) { return std::fopen(name, mode); }
+
+namespace mfcwx {
+
+std::string NativePath(const char* path) { return path ? path : ""; }
+
+} // namespace mfcwx

From 9953cb00225f3648d1e9aeb24cc3ea1a2eccec75 Mon Sep 17 00:00:00 2001
From: Kamil Marczak <kamil.marczak@alergeek.ventures>
Date: Thu, 8 Oct 2026 15:14:43 +0200
Subject: [PATCH 2/3] fix(mfcwx): detach window wrappers destroyed on worker
 threads

The brute-force analysis dialogs run in AfxBeginThread workers. Their
control members were destroyed there, but ~CWnd only detached from the wx
window on the main thread, so the deferred wx deletion sent WM_DESTROY to
freed objects. The detach now always runs on the main thread. CWnd::SetFocus
also tolerates a NULL wrapper like a NULL HWND (hybrid encryption demo).
---
 port/mfcwx/src/wnd.cpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/port/mfcwx/src/wnd.cpp b/port/mfcwx/src/wnd.cpp
index cbaf3156..026d4b46 100644
--- a/port/mfcwx/src/wnd.cpp
+++ b/port/mfcwx/src/wnd.cpp
@@ -718,7 +718,10 @@ const CWnd wndNoTopMost;
 CWnd::CWnd() : m_hWnd(nullptr) {}
 
 CWnd::~CWnd() {
-    if (m_hWnd && IsMainThread()) {
+    if (!m_hWnd)
+        return;
+    // Wrappers destroyed on worker threads (dialogs run from AfxBeginThread) must detach too.
+    OnMain([this] {
         wxWindow* w = GetWx();
         WindowState* st = GetState(w);
         if (st && st->permanent == this) {
@@ -730,7 +733,7 @@ CWnd::~CWnd() {
             }
         }
         m_hWnd = nullptr;
-    }
+    });
 }
 
 CWnd* CWnd::FromWx(wxWindow* window) { return WrapperFor(window); }
@@ -1455,7 +1458,7 @@ CWnd* CWnd::SetActiveWindow() { return FromHandle(::SetActiveWindow(m_hWnd)); }
 CWnd* CWnd::GetForegroundWindow() { return FromHandle(::GetForegroundWindow()); }
 BOOL CWnd::SetForegroundWindow() { return ::SetForegroundWindow(m_hWnd); }
 CWnd* CWnd::GetFocus() { return FromHandle(::GetFocus()); }
-CWnd* CWnd::SetFocus() { return FromHandle(::SetFocus(m_hWnd)); }
+CWnd* CWnd::SetFocus() { return FromHandle(::SetFocus(GetSafeHwnd())); }
 CWnd* CWnd::GetDesktopWindow() { return nullptr; }
 CWnd* CWnd::GetCapture() { return FromHandle(::GetCapture()); }
 CWnd* CWnd::SetCapture() { return FromHandle(::SetCapture(m_hWnd)); }

From c8b068c7fe9b694fa7da32f4b580ba6b0ec5449a Mon Sep 17 00:00:00 2001
From: Kamil Marczak <kamil.marczak@alergeek.ventures>
Date: Thu, 8 Oct 2026 15:14:43 +0200
Subject: [PATCH 3/3] fix(mfcwx): give the app the Microsoft C runtime's rand()

CrypTool sizes buffers for RAND_MAX 32767 (the PKCS #5 dialog writes two
rand() values into char[20] and overflowed with glibc/macOS RAND_MAX).
rand/srand now use the MSVC LCG and RAND_MAX 0x7fff, which also reproduces
the Windows random sequences; MIRACL's rand overloads are forwarded.
---
 port/app/CMakeLists.txt              |  3 ++-
 port/app/miracl_rand.cpp             |  5 +++++
 port/mfcwx/include/mfcwx/crtcompat.h | 12 ++++++++++++
 port/mfcwx/src/crt.cpp               | 13 +++++++++++++
 4 files changed, 32 insertions(+), 1 deletion(-)
 create mode 100644 port/app/miracl_rand.cpp

diff --git a/port/app/CMakeLists.txt b/port/app/CMakeLists.txt
index 18b2d002..94fc03af 100644
--- a/port/app/CMakeLists.txt
+++ b/port/app/CMakeLists.txt
@@ -18,7 +18,8 @@ file(GLOB CT_EXTRA_SOURCES CONFIGURE_DEPENDS
     ${REPO_ROOT}/libVolRen/CQuaternion.cpp ${REPO_ROOT}/libVolRen/CVector.cpp ${REPO_ROOT}/libVolRen/Volume.cpp
     ${REPO_ROOT}/libVolRen/VolumeUtilities.cpp ${REPO_ROOT}/ChallengeResponse/*.cpp)
 
-add_executable(CrypTool ${CT_SOURCES} ${CT_EXTRA_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/platform.cpp)
+add_executable(CrypTool ${CT_SOURCES} ${CT_EXTRA_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/platform.cpp
+                        ${CMAKE_CURRENT_SOURCE_DIR}/miracl_rand.cpp)
 mfcwx_add_rc(CrypTool RC ${CT_SRC}/CrypTool.rc MODULE CrypTool HEADERS ${CT_SRC}/resource.h
              REPLACE "[CRYPTOOL_VERSION_FULL]=CrypTool ${PROJECT_VERSION}" "[CRYPTOOL_VERSION]=${PROJECT_VERSION}")
 
diff --git a/port/app/miracl_rand.cpp b/port/app/miracl_rand.cpp
new file mode 100644
index 00000000..c7fe4326
--- /dev/null
+++ b/port/app/miracl_rand.cpp
@@ -0,0 +1,5 @@
+// Compiled without mfcwx/crtcompat.h: app code sees MIRACL's rand overloads renamed to mfcwx_rand.
+#include "BIG.H"
+
+Big mfcwx_rand(const Big& w) { return rand(w); }
+Big mfcwx_rand(int n, int b) { return rand(n, b); }
diff --git a/port/mfcwx/include/mfcwx/crtcompat.h b/port/mfcwx/include/mfcwx/crtcompat.h
index 17fe75b0..b2b2ac4c 100644
--- a/port/mfcwx/include/mfcwx/crtcompat.h
+++ b/port/mfcwx/include/mfcwx/crtcompat.h
@@ -387,8 +387,20 @@ int _findclose(intptr_t handle);
 #define _findfirsti64 _findfirst
 #define _findnexti64 _findnext
 
+/* rand() of the Microsoft C runtime (per-thread LCG, RAND_MAX 0x7fff); CrypTool sizes buffers for it. */
+int mfcwx_rand(void);
+void mfcwx_srand(unsigned int seed);
+#undef RAND_MAX
+#define RAND_MAX 0x7fff
+#define rand mfcwx_rand
+#define srand mfcwx_srand
+
 #endif /* _MFCWX_CRTCOMPAT */
 
 #ifdef __cplusplus
 }
+namespace std {
+using ::mfcwx_rand;
+using ::mfcwx_srand;
+}
 #endif
diff --git a/port/mfcwx/src/crt.cpp b/port/mfcwx/src/crt.cpp
index e9353cd5..5adc1ddd 100644
--- a/port/mfcwx/src/crt.cpp
+++ b/port/mfcwx/src/crt.cpp
@@ -848,3 +848,16 @@ intptr_t _spawnl(int mode, const char* cmdname, const char* arg0, ...) {
     CloseHandle(pi.hProcess);
     return 0;
 }
+
+namespace {
+
+thread_local unsigned int g_randSeed = 1;
+
+} // namespace
+
+extern "C" int mfcwx_rand(void) {
+    g_randSeed = g_randSeed * 214013u + 2531011u;
+    return static_cast<int>((g_randSeed >> 16) & 0x7fff);
+}
+
+extern "C" void mfcwx_srand(unsigned int seed) { g_randSeed = seed; }