2:10:20 AM

merge to win-on-arm

.github/workflows/dos-djgpp.yml

@@ -42,7 +42,7 @@ jobs:
       - name: Setup build environment
         run: |
           sudo apt -y update
-          sudo apt -y install build-essential cmake wget 7zip git flex libfl-dev nasm libslang2-dev pkg-config libslang2-modules gcc-multilib
+          sudo apt -y install build-essential cmake wget 7zip git flex libfl-dev nasm libslang2-dev pkg-config libslang2-modules gcc-multilib dosbox
 
       - name: Download and Setup DJGPP Toolchain
         run: |
@@ -59,7 +59,16 @@ jobs:
           make -f djgpp.mak
           ln -s ${WATT_ROOT}/lib/libwatt.a ${{ github.workspace }}/djgpp/lib
 
+      - name: Cache OpenSSL 3.1.2
+        uses: actions/cache/restore@v4
+        id: cache-openssl
+        with:
+          path: |
+            ${{ github.workspace }}/djgpp
+          key: openssl-3.1.2-${{ hashFiles('**/CMakeLists.txt') }}
+
       - name: Checkout and Cross Compile OpenSSL 3.1.2
+        if: steps.cache-openssl.outputs.cache-hit != 'true'
         run: |
           git clone https://github.com/UMSKT/openssl.git openssl
           pushd openssl
@@ -68,6 +77,14 @@ jobs:
           make && make install_sw
           popd
 
+      - name: Save OpenSSL 3.1.2
+        if: steps.cache-openssl.outputs.cache-hit != 'true'
+        uses: actions/cache/save@v4
+        with:
+          path: |
+            ${{ github.workspace }}/djgpp
+          key: openssl-3.1.2-${{ hashFiles('**/CMakeLists.txt') }}
+
       - name: Build
         run: |
           source ${{ github.workspace }}/djgpp/setenv
@@ -75,6 +92,84 @@ jobs:
           cmake ../ -D DJGPP_WATT32=${WATT_ROOT}/lib/libwatt.a -D CMAKE_FIND_ROOT_PATH=${CMAKE_FIND_ROOT_PATH}
           make
 
+      - name: Setup DOSBox test environment
+        run: |
+          mkdir -p dosbox_test
+          cp build/umskt.exe dosbox_test/
+          # Download DPMI server directly
+          wget https://github.com/UMSKT/winactiontest/raw/refs/heads/main/CWSDPMI.EXE -O dosbox_test/CWSDPMI.EXE
+          # Create test batch file
+          cat > dosbox_test/test.bat << EOL
+          @echo off
+          echo Running test 1...
+          umskt.exe -b 2C -c 365 -s 069420 -v > TEST1.TXT
+          if errorlevel 1 goto error
+          echo Running test 2...
+          umskt.exe -i 253286028742154311079061239762245184619981623171292574 > TEST2.TXT
+          if errorlevel 1 goto error
+          echo Tests completed > DONE.TXT
+          goto end
+          :error
+          echo Test failed > ERROR.TXT
+          :end
+          exit
+          EOL
+          # Create DOSBox configuration
+          cat > dosbox_test/dosbox.conf << EOL
+          [sdl]
+          nosound=true
+          [cpu]
+          core=dynamic
+          cycles=max
+          [autoexec]
+          mount c .
+          c:
+          test.bat
+          exit
+          EOL
+
+      - name: Run tests in DOSBox
+        run: |
+          cd dosbox_test
+          timeout 30s dosbox -conf dosbox.conf -nogui -exit
+          # Check if the test completed successfully
+          if [ ! -f DONE.TXT ]; then
+            echo "Tests did not complete successfully"
+            if [ -f ERROR.TXT ]; then
+              echo "Test execution failed"
+            fi
+            if [ -f TEST1.TXT ]; then
+              echo "Test 1 output:"
+              cat TEST1.TXT
+            fi
+            if [ -f TEST2.TXT ]; then
+              echo "Test 2 output:"
+              cat TEST2.TXT
+            fi
+            exit 1
+          fi
+          # Verify test outputs
+          if [ ! -f TEST1.TXT ] || [ ! -f TEST2.TXT ]; then
+            echo "Test output files missing"
+            exit 1
+          fi
+          # Check test results - looking for key format patterns
+          if ! grep -qE '[A-Z0-9]{5}-[A-Z0-9]{5}-[A-Z0-9]{5}-[A-Z0-9]{5}-[A-Z0-9]{5}' TEST1.TXT || \
+             ! grep -qE '[0-9]{6}-[0-9]{6}-[0-9]{6}-[0-9]{6}-[0-9]{6}-[0-9]{6}-[0-9]{6}' TEST2.TXT; then
+            echo "Tests failed - unexpected output format"
+            echo "Test 1 output:"
+            cat TEST1.TXT
+            echo "Test 2 output:"
+            cat TEST2.TXT
+            exit 1
+          else
+            echo "All tests passed successfully"
+            echo "Test 1 output:"
+            cat TEST1.TXT
+            echo "Test 2 output:"
+            cat TEST2.TXT
+          fi
+
       - name: Move executable to upload directory
         run: |
           mkdir build/actions_upload

.github/workflows/freebsd.yml

@@ -21,12 +21,9 @@
  name: C/C++ CI (FreeBSD) 
   
  on: 
-  #push:
+  push:
-  #  branches: [ "*" ]
+    branches: [ "*" ]
-  #  paths-ignore: [ '**.md', 'doc/**', '.idea/**'] # If only these files are edited, skip
+    paths-ignore: [ '**.md', 'doc/**', '.idea/**'] # If only these files are edited, skip
-  #pull_request:
-  #  branches: [ "*" ]
-  #  paths-ignore: [ '**.md', 'doc/**', '.idea/**'] # If only these files are edited, skip
 
   workflow_dispatch:
   
@@ -39,19 +36,42 @@
   
      - name: Build & Test in FreeBSD 
        id: test 
-       uses: vmactions/freebsd-vm@v1 
+       uses: vmactions/freebsd-vm@v1.2.1
        with: 
          envs: 'MYTOKEN MYTOKEN2' 
          usesh: true 
          prepare: | 
            pkg install -y cmake openssl git bash 
+           # Debug: Show system state
+           uname -a
+           pwd
+           df -h
+           ls -la
   
          run: | 
+           # Debug: Initial environment
+           echo "Starting build process..."
+           pwd
+           ls -la
+           # Create/clean build directory
+           echo "Setting up build directory..."
+           rm -rf build
            mkdir build
            cd build
+           echo "Running cmake..."
            cmake ..
+           echo "Starting make..."
            make
-           ./umskt  # Execute the test here 
+           ./umskt -b 2C -c 365 -s 069420 -v
+           ./umskt -i 253286028742154311079061239762245184619981623171292574
+           # Debug: List files and permissions
+           ls -la
+           pwd
+           # Ensure directory exists and has correct permissions
+           mkdir -p actions_upload
+           cp umskt actions_upload/
+           chmod -R 755 .
+           ls -la actions_upload/
   
      - name: Move files to correct directory 
        run: | 

.github/workflows/linux.yml

@@ -28,18 +28,25 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-latest
     strategy:
       matrix:
         include:
           - arch: x86
+            runner: ubuntu-latest
+            use_alpine: true
           - arch: x86_64
+            runner: ubuntu-latest
+            use_alpine: true
           - arch: aarch64
+            runner: ubuntu-24.04-arm
+            use_alpine: false
+    runs-on: ${{ matrix.runner }}
     steps:
     - name: Checkout Source Tree
       uses: actions/checkout@v4
 
-    - name: Setup latest Alpine Linux for ${{ matrix.arch }}
+    - name: Setup latest Alpine Linux
+      if: ${{ matrix.use_alpine }}
       uses: jirutka/setup-alpine@v1
       with:
         packages: >
@@ -54,13 +61,42 @@ jobs:
         arch: ${{ matrix.arch }}
         shell-name: alpine-target.sh
 
-    - name: Configure and build UMSKT
+    - name: Install Dependencies (Ubuntu ARM64)
+      if: ${{ !matrix.use_alpine }}
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y build-essential cmake git libssl-dev zlib1g-dev
+
+    - name: Configure and build UMSKT (Alpine)
+      if: ${{ matrix.use_alpine }}
       uses: threeal/cmake-action@7ef2eb8da6e5ec0a6de6b1ddc96987080bed06e8
       with:
         options: MUSL_STATIC=ON
         run-build: true
         shell: alpine-target.sh {0}
 
+    - name: Configure and build UMSKT (Ubuntu)
+      if: ${{ !matrix.use_alpine }}
+      uses: threeal/cmake-action@7ef2eb8da6e5ec0a6de6b1ddc96987080bed06e8
+      with:
+        options: MUSL_STATIC=ON
+        run-build: true
+
+    - name: Test UMSKT (Alpine)
+      if: ${{ matrix.use_alpine }}
+      run: |
+        cd build
+        ./umskt -b 2C -c 365 -s 069420 -v
+        ./umskt -i 253286028742154311079061239762245184619981623171292574
+      shell: alpine-target.sh {0}
+
+    - name: Test UMSKT (Ubuntu)
+      if: ${{ !matrix.use_alpine }}
+      run: |
+        cd build
+        ./umskt -b 2C -c 365 -s 069420 -v
+        ./umskt -i 253286028742154311079061239762245184619981623171292574
+
     - name: Move files to correct directory
       run: |
           mkdir -p build/actions_upload
@@ -72,16 +108,62 @@ jobs:
         name: UMSKT-linux-${{ matrix.arch }}-static
         path: build/actions_upload
 
-    - name: Configure and build static internal deps UMSKT
+    - name: Configure and build static internal deps UMSKT (Alpine)
+      if: ${{ matrix.use_alpine }}
       uses: threeal/cmake-action@7ef2eb8da6e5ec0a6de6b1ddc96987080bed06e8
       with:
         options: MUSL_STATIC=OFF BUILD_SHARED_LIBS=OFF
         run-build: true
         shell: alpine-target.sh {0}
 
-    - name: Configure and build shared deps UMSKT
+    - name: Configure and build static internal deps UMSKT (Ubuntu)
+      if: ${{ !matrix.use_alpine }}
+      uses: threeal/cmake-action@7ef2eb8da6e5ec0a6de6b1ddc96987080bed06e8
+      with:
+        options: MUSL_STATIC=OFF BUILD_SHARED_LIBS=OFF
+        run-build: true
+
+    - name: Test static internal deps UMSKT (Alpine)
+      if: ${{ matrix.use_alpine }}
+      run: |
+        cd build
+        ./umskt -b 2C -c 365 -s 069420 -v
+        ./umskt -i 253286028742154311079061239762245184619981623171292574
+      shell: alpine-target.sh {0}
+
+    - name: Test static internal deps UMSKT (Ubuntu)
+      if: ${{ !matrix.use_alpine }}
+      run: |
+        cd build
+        ./umskt -b 2C -c 365 -s 069420 -v
+        ./umskt -i 253286028742154311079061239762245184619981623171292574
+
+    - name: Configure and build shared deps UMSKT (Alpine)
+      if: ${{ matrix.use_alpine }}
       uses: threeal/cmake-action@7ef2eb8da6e5ec0a6de6b1ddc96987080bed06e8
       with:
         options: MUSL_STATIC=OFF BUILD_SHARED_LIBS=ON
         run-build: true
         shell: alpine-target.sh {0}
+
+    - name: Configure and build shared deps UMSKT (Ubuntu)
+      if: ${{ !matrix.use_alpine }}
+      uses: threeal/cmake-action@7ef2eb8da6e5ec0a6de6b1ddc96987080bed06e8
+      with:
+        options: MUSL_STATIC=OFF BUILD_SHARED_LIBS=ON
+        run-build: true
+
+    - name: Test shared deps UMSKT (Alpine)
+      if: ${{ matrix.use_alpine }}
+      run: |
+        cd build
+        ./umskt -b 2C -c 365 -s 069420 -v
+        ./umskt -i 253286028742154311079061239762245184619981623171292574
+      shell: alpine-target.sh {0}
+
+    - name: Test shared deps UMSKT (Ubuntu)
+      if: ${{ !matrix.use_alpine }}
+      run: |
+        cd build
+        ./umskt -b 2C -c 365 -s 069420 -v
+        ./umskt -i 253286028742154311079061239762245184619981623171292574

.github/workflows/macos.yml

@@ -85,7 +85,8 @@ jobs:
       - name: Run tests
         run: |
           cd build/actions_upload
-          ./umskt
+          ./umskt -b 2C -c 365 -s 069420 -v
+          ./umskt -i 253286028742154311079061239762245184619981623171292574
 
       - name: Upload platform-specific build
         uses: actions/upload-artifact@v4.6.2

.github/workflows/windows.yml

@@ -27,13 +27,14 @@ on:
   workflow_dispatch:
 
 jobs:
-  build-tdm:
+  build:
     runs-on: windows-latest
     strategy:
       matrix:
-        arch: [x64, x86]
+        arch: [x64, x86, arm64]
     steps:
       - name: Setup TDM-GCC
+        if: matrix.arch != 'arm64'
         run: |
           Write-Host Downloading TDM-GCC v10.3.0...
           Invoke-WebRequest -Uri 'https://github.com/jmeubank/tdm-gcc/releases/download/v10.3.0-tdm64-2/tdm64-gcc-10.3.0-2.exe' -OutFile 'C:\Windows\temp\TDM-GCC-64.exe'
@@ -49,10 +50,17 @@ jobs:
           $env:PATH = 'C:\TDM-GCC-64\bin;' + $env:PATH
           [Environment]::SetEnvironmentVariable('PATH', $env:PATH, [EnvironmentVariableTarget]::Machine)
 
+      - name: Setup MSVC for ARM64
+        if: matrix.arch == 'arm64'
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: arm64
+
       - name: Checkout Source Tree
         uses: actions/checkout@v4
 
       - name: Download OpenSSL-TDM release asset
+        if: matrix.arch != 'arm64'
         shell: pwsh
         run: |
           if ('${{ matrix.arch }}' -eq 'x64') {
@@ -74,7 +82,39 @@ jobs:
           echo "OPENSSL_LIBDIR=$libdir" | Out-File -FilePath $env:GITHUB_ENV -Append
           echo "CMAKE_FLAGS=$cmake_flags" | Out-File -FilePath $env:GITHUB_ENV -Append
 
+      - name: Setup vcpkg for ARM64
+        if: matrix.arch == 'arm64'
+        shell: pwsh
+        run: |
+          git clone https://github.com/Microsoft/vcpkg.git
+          cd vcpkg
+          .\bootstrap-vcpkg.bat
+          echo "VCPKG_ROOT=$env:GITHUB_WORKSPACE/vcpkg" | Out-File -FilePath $env:GITHUB_ENV -Append
+          echo "VCPKG_DEFAULT_BINARY_CACHE=$env:GITHUB_WORKSPACE/vcpkg/bincache" | Out-File -FilePath $env:GITHUB_ENV -Append
+          echo "VCPKG_BINARY_SOURCES=clear;default,readwrite" | Out-File -FilePath $env:GITHUB_ENV -Append
+
+      - name: Cache vcpkg packages
+        if: matrix.arch == 'arm64'
+        uses: actions/cache@v4
+        with:
+          path: |
+            ${{ github.workspace }}/vcpkg/bincache
+            ${{ github.workspace }}/vcpkg/installed
+            ${{ github.workspace }}/vcpkg/packages
+          key: vcpkg-arm64-${{ hashFiles('**/CMakeLists.txt') }}-${{ hashFiles('**/*.cmake') }}
+          restore-keys: |
+            vcpkg-arm64-${{ hashFiles('**/CMakeLists.txt') }}-
+            vcpkg-arm64-
+
+      - name: Install OpenSSL for ARM64
+        if: matrix.arch == 'arm64'
+        shell: pwsh
+        run: |
+          New-Item -ItemType Directory -Force -Path $env:VCPKG_DEFAULT_BINARY_CACHE
+          & "$env:VCPKG_ROOT\vcpkg.exe" install openssl:arm64-windows-static --clean-after-build
+
       - name: Configure UMSKT (TDM-GCC ${{ matrix.arch }})
+        if: matrix.arch != 'arm64'
         shell: pwsh
         run: |
           $env:PATH = 'C:\TDM-GCC-64\bin;' + $env:PATH
@@ -92,14 +132,56 @@ jobs:
             -DCMAKE_CXX_FLAGS="$env:CMAKE_FLAGS" `
             .
 
+      - name: Configure UMSKT (MSVC ARM64)
+        if: matrix.arch == 'arm64'
+        shell: pwsh
+        run: |
+          cmake -G "Visual Studio 17 2022" `
+            -A ARM64 `
+            -DWINDOWS_ARM=ON `
+            -DCMAKE_TOOLCHAIN_FILE="$env:VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake" `
+            -DVCPKG_TARGET_TRIPLET=arm64-windows-static `
+            .
+
       - name: Build UMSKT (TDM-GCC ${{ matrix.arch }})
+        if: matrix.arch != 'arm64'
         shell: pwsh
         run: |
           $env:PATH = 'C:\TDM-GCC-64\bin;' + $env:PATH
           mingw32-make
 
+      - name: Build UMSKT (MSVC ARM64)
+        if: matrix.arch == 'arm64'
+        shell: pwsh
+        run: |
+          cmake --build . --config Release
+
+      - name: Run tests (x86/x64)
+        if: matrix.arch != 'arm64'
+        shell: pwsh
+        run: |
+          .\umskt.exe -b 2C -c 365 -s 069420 -v
+          .\umskt.exe -i 253286028742154311079061239762245184619981623171292574
+
       - name: Upload build artifact
         uses: actions/upload-artifact@v4.6.2
         with:
-          name: UMSKT-TDM${{ matrix.arch }}
+          name: UMSKT-${{ matrix.arch }}
-          path: umskt.exe
+          path: ${{ matrix.arch == 'arm64' && 'Release/umskt.exe' || 'umskt.exe' }}
+
+  test-arm64:
+    needs: build
+    if: success()
+    runs-on: windows-11-arm
+    steps:
+      - name: Download ARM64 artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: UMSKT-arm64
+          path: .
+
+      - name: Run tests (ARM64)
+        shell: pwsh
+        run: |
+          .\umskt.exe -b 2C -c 365 -s 069420 -v
+          .\umskt.exe -i 253286028742154311079061239762245184619981623171292574

CMakeLists.txt

@@ -26,6 +26,24 @@ if (WIN32 AND NOT MSVC)
     set(CMAKE_C_COMPILER "C:/TDM-GCC-64/bin/gcc.exe" CACHE FILEPATH "C Compiler" FORCE)
     set(CMAKE_CXX_COMPILER "C:/TDM-GCC-64/bin/g++.exe" CACHE FILEPATH "C++ Compiler" FORCE)
     message(STATUS "[UMSKT] Forcing use of TDM-GCC in C:/TDM-GCC-64")
+    
+    # Configure windres for resource compilation
+    set(CMAKE_RC_COMPILER "C:/TDM-GCC-64/bin/windres.exe")
+    set(CMAKE_RC_COMPILER_INIT windres)
+    enable_language(RC)
+    set(CMAKE_RC_FLAGS "--use-temp-file -c65001")
+    
+    # Match resource architecture with target architecture
+    if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+        set(CMAKE_RC_FLAGS "${CMAKE_RC_FLAGS} -F pe-i386")
+    else()
+        set(CMAKE_RC_FLAGS "${CMAKE_RC_FLAGS} -F pe-x86-64")
+    endif()
+    
+    set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> <FLAGS> -O coff -I${CMAKE_CURRENT_SOURCE_DIR}/src/windows <DEFINES> -i <SOURCE> -o <OBJECT>")
+    
+    # Set the Windows resource file for GCC builds
+    set(UMSKT_EXE_WINDOWS_EXTRA src/windows/umskt.rc)
 endif()
 
 SET(CMAKE_CXX_STANDARD 17)
@@ -36,6 +54,7 @@ OPTION(UMSKT_USE_SHARED_OPENSSL "Force linking against the system-wide OpenSSL l
 OPTION(MUSL_STATIC "Enable fully static builds in a muslc environment (i.e. Alpine Linux)" OFF)
 OPTION(DJGPP_WATT32 "Enable compilation and linking with DJGPP/WATT32/OpenSSL" OFF)
 OPTION(MSVC_MSDOS_STUB "Specify a custom MS-DOS stub for a 32-bit MSVC compilation" OFF)
+OPTION(WINDOWS_ARM "Enable compilation for Windows on ARM (requires appropriate toolchain)" OFF)
 
 SET(UMSKT_LINK_LIBS ${UMSKT_LINK_LIBS})
 SET(UMSKT_LINK_DIRS ${UMSKT_LINK_DIRS})
@@ -60,7 +79,22 @@ ELSE()
     MESSAGE(STATUS "[UMSKT] Requesting static version of OpenSSL")
 ENDIF()
 
-
+# Configure ARM-specific settings if enabled
+if (WINDOWS_ARM)
+    if (MSVC)
+        # MSVC ARM64 settings
+        set(CMAKE_SYSTEM_PROCESSOR ARM64)
+        set(CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE ARM64)
+    else()
+        # MinGW/GCC ARM settings
+        set(CMAKE_SYSTEM_PROCESSOR arm)
+        if (CMAKE_CROSSCOMPILING)
+            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv8-a")
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv8-a")
+        endif()
+    endif()
+    message(STATUS "[UMSKT] Configuring for Windows on ARM")
+endif()
 
 IF(DJGPP_WATT32)
     SET(CMAKE_SYSTEM_NAME MSDOS)

src/libumskt/confid/confid.cpp

@@ -29,6 +29,10 @@
 
 #include "confid.h"
 
+#if defined(_MSC_VER)
+#include <intrin.h>
+#endif
+
 QWORD MOD = 0;
 QWORD NON_RESIDUE = 0;
 QWORD f[6] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
@@ -75,6 +79,12 @@ inline QWORD ConfirmationID::__umul128(QWORD a, QWORD b, QWORD* hi)
 #else
 #define __umul128 _umul128
 #endif
+#elif defined(_M_ARM64) // Microsoft implementation of ARM64
+inline QWORD ConfirmationID::__umul128(QWORD a, QWORD b, QWORD* hi)
+{
+    *hi = __umulh(a, b);
+    return a * b;
+}
 #elif defined(__i386__) || defined(_M_IX86) || defined(__arm__) || defined(__EMSCRIPTEN__)
 inline QWORD ConfirmationID::__umul128(QWORD multiplier, QWORD multiplicand, QWORD *product_hi) {
     // multiplier   = ab = a * 2^32 + b

src/libumskt/libumskt.cpp

@@ -88,6 +88,10 @@ int UMSKT::umskt_rand_bytes(unsigned char *buf, int num) {
         buf[i] ^= (unsigned char)(rand() & 0xFF);
     }
     return 1;
+#elif defined(__FreeBSD__)
+    // use arc4random_buf
+    arc4random_buf(buf, num);
+    return 1;
 #else
     // Use OpenSSL's RAND_bytes for non-DOS systems
     return RAND_bytes(buf, num);
@@ -127,6 +131,39 @@ int UMSKT::umskt_bn_rand(BIGNUM *rnd, int bits, int top, int bottom) {
         BN_set_bit(rnd, 0);
     }
     
+    return 1;
+#elif defined(__FreeBSD__)
+    // FreeBSD-compatible RNG implementation for BIGNUMs
+    unsigned char *buf = (unsigned char *)malloc((bits + 7) / 8);
+    if (!buf) return 0;
+    
+    // Generate random bytes using arc4random_buf
+    arc4random_buf(buf, (bits + 7) / 8);
+    
+    // Convert to BIGNUM
+    if (!BN_bin2bn(buf, (bits + 7) / 8, rnd)) {
+        free(buf);
+        return 0;
+    }
+    
+    free(buf);
+    
+    // Apply top/bottom constraints like BN_rand does
+    if (top != -1) {
+        if (top) {
+            if (bits == 0) {
+                BN_zero(rnd);
+                return 1;
+            }
+            BN_set_bit(rnd, bits - 1);
+        }
+        BN_mask_bits(rnd, bits);
+    }
+    
+    if (bottom) {
+        BN_set_bit(rnd, 0);
+    }
+    
     return 1;
 #else
     // Use OpenSSL's BN_rand for non-DOS systems

src/libumskt/libumskt.h

@@ -60,7 +60,18 @@
 #define HIBYTES(field, bytes)          NEXTSNBITS((QWORD)(field), ((bytes) * 8), ((bytes) * 8))
 #define LOBYTES(field, bytes)          FIRSTNBITS((QWORD)(field), ((bytes) * 8))
 
+// Platform-specific byte order handling
+#if defined(__FreeBSD__)
+#include <sys/endian.h>
+#define BYDWORD(n) le32toh(*((const DWORD*)(n)))
+#define HTOLE32(n) htole32(n)
+#define LETOH32(n) le32toh(n)
+#else
 #define BYDWORD(n) (DWORD)(*((n) + 0) | *((n) + 1) << 8 | *((n) + 2) << 16 | *((n) + 3) << 24)
+#define HTOLE32(n) (n)
+#define LETOH32(n) (n)
+#endif
+
 #define BITMASK(n)                     ((1ULL << (n)) - 1)
 
 // RNG utility functions

src/libumskt/pidgen3/BINK1998.cpp

@@ -29,6 +29,43 @@
 
 #include "BINK1998.h"
 
+// Helper function to calculate SHA1 using EVP interface
+static void calculate_sha1(const unsigned char* data, size_t len, unsigned char* digest) {
+    EVP_MD_CTX* ctx = EVP_MD_CTX_new();
+    if (!ctx) {
+        fmt::print(UMSKT::debug, "Error: Failed to create EVP_MD_CTX\n");
+        return;
+    }
+
+    const EVP_MD* sha1 = EVP_sha1();
+    if (!sha1) {
+        fmt::print(UMSKT::debug, "Error: Failed to get SHA1 algorithm\n");
+        EVP_MD_CTX_free(ctx);
+        return;
+    }
+
+    if (EVP_DigestInit_ex(ctx, sha1, NULL) != 1) {
+        fmt::print(UMSKT::debug, "Error: Failed to initialize SHA1\n");
+        EVP_MD_CTX_free(ctx);
+        return;
+    }
+
+    if (EVP_DigestUpdate(ctx, data, len) != 1) {
+        fmt::print(UMSKT::debug, "Error: Failed to update SHA1\n");
+        EVP_MD_CTX_free(ctx);
+        return;
+    }
+
+    unsigned int md_len;
+    if (EVP_DigestFinal_ex(ctx, digest, &md_len) != 1) {
+        fmt::print(UMSKT::debug, "Error: Failed to finalize SHA1\n");
+        EVP_MD_CTX_free(ctx);
+        return;
+    }
+
+    EVP_MD_CTX_free(ctx);
+}
+
 /* Unpacks a Windows XP-like Product Key. */
 void PIDGEN3::BINK1998::Unpack(
         QWORD (&pRaw)[2],
@@ -102,6 +139,8 @@ bool PIDGEN3::BINK1998::Verify(
     fmt::print(UMSKT::debug, "\n");
 
     pData = pSerial << 1 | pUpgrade;
+    // Convert to little-endian for consistent hash calculation
+    DWORD leData = HTOLE32(pData);
 
     /*
      *
@@ -148,18 +187,50 @@ bool PIDGEN3::BINK1998::Verify(
     BN_bn2lebin(x, xBin, FIELD_BYTES);
     BN_bn2lebin(y, yBin, FIELD_BYTES);
 
-    // Assemble the SHA message.
+    // Convert pData to little-endian bytes
-    memcpy((void *)&msgBuffer[0], (void *)&pData, 4);
+    BYTE leBytes[4];
+    leBytes[0] = (BYTE)(leData & 0xFF);
+    leBytes[1] = (BYTE)((leData >> 8) & 0xFF);
+    leBytes[2] = (BYTE)((leData >> 16) & 0xFF);
+    leBytes[3] = (BYTE)((leData >> 24) & 0xFF);
+
+    // Assemble the SHA message with little-endian data
+    memcpy((void *)&msgBuffer[0], leBytes, 4);
     memcpy((void *)&msgBuffer[4], (void *)xBin, FIELD_BYTES);
     memcpy((void *)&msgBuffer[4 + FIELD_BYTES], (void *)yBin, FIELD_BYTES);
 
-    // compHash = SHA1(pSerial || P.x || P.y)
+    // Debug: Print message buffer contents
-    SHA1(msgBuffer, SHA_MSG_LENGTH_XP, msgDigest);
+    fmt::print(UMSKT::debug, "Debug: Message buffer contents:\n");
+    fmt::print(UMSKT::debug, "  leData: 0x{:08x}\n", leData);
+    fmt::print(UMSKT::debug, "  First 4 bytes: 0x{:02x}{:02x}{:02x}{:02x}\n", 
+        msgBuffer[0], msgBuffer[1], msgBuffer[2], msgBuffer[3]);
+    fmt::print(UMSKT::debug, "  Full buffer:");
+    for(size_t i = 0; i < SHA_MSG_LENGTH_XP; i++) {
+        if(i % 16 == 0) fmt::print(UMSKT::debug, "\n    ");
+        fmt::print(UMSKT::debug, "{:02x} ", msgBuffer[i]);
+    }
+    fmt::print(UMSKT::debug, "\n");
     
-    // Translate the byte digest into a 32-bit integer - this is our computed hash.
+    // pHash = SHA1(pSerial || R.x || R.y)
-    // Truncate the hash to 28 bits.
+    calculate_sha1((unsigned char *)msgBuffer, SHA_MSG_LENGTH_XP, msgDigest);
+
+    // Debug: Print SHA1 digest
+    fmt::print(UMSKT::debug, "Debug: SHA1 digest:\n");
+    for(int i = 0; i < SHA_DIGEST_LENGTH; i++) {
+        fmt::print(UMSKT::debug, "{:02x}", msgDigest[i]);
+    }
+    fmt::print(UMSKT::debug, "\n");
+
+    // Translate the byte digest into a 32-bit integer - this is our computed pHash.
+    // Truncate the pHash to 28 bits.
     DWORD compHash = BYDWORD(msgDigest) >> 4 & BITMASK(28);
     
+    // Debug: Print hash calculation steps
+    fmt::print(UMSKT::debug, "Debug: Hash calculation:\n");
+    fmt::print(UMSKT::debug, "  Raw BYDWORD: 0x{:08x}\n", BYDWORD(msgDigest));
+    fmt::print(UMSKT::debug, "  After shift: 0x{:08x}\n", BYDWORD(msgDigest) >> 4);
+    fmt::print(UMSKT::debug, "  Final hash:  0x{:08x}\n", compHash);
+
     BN_free(e);
     BN_free(s);
     BN_free(x);
@@ -196,6 +267,8 @@ void PIDGEN3::BINK1998::Generate(
 
     // Data segment of the RPK.
     DWORD pData = pSerial << 1 | pUpgrade;
+    // Convert to little-endian for consistent hash calculation
+    DWORD leData = HTOLE32(pData);
 
     do {
         EC_POINT *r = EC_POINT_new(eCurve);
@@ -220,18 +293,50 @@ void PIDGEN3::BINK1998::Generate(
         BN_bn2lebin(x, xBin, FIELD_BYTES);
         BN_bn2lebin(y, yBin, FIELD_BYTES);
 
-        // Assemble the SHA message.
+        // Convert pData to little-endian bytes
-        memcpy((void *)&msgBuffer[0], (void *)&pData, 4);
+        BYTE leBytes[4];
+        leBytes[0] = (BYTE)(leData & 0xFF);
+        leBytes[1] = (BYTE)((leData >> 8) & 0xFF);
+        leBytes[2] = (BYTE)((leData >> 16) & 0xFF);
+        leBytes[3] = (BYTE)((leData >> 24) & 0xFF);
+
+        // Assemble the SHA message with little-endian data
+        memcpy((void *)&msgBuffer[0], leBytes, 4);
         memcpy((void *)&msgBuffer[4], (void *)xBin, FIELD_BYTES);
         memcpy((void *)&msgBuffer[4 + FIELD_BYTES], (void *)yBin, FIELD_BYTES);
 
+        // Debug: Print message buffer contents
+        fmt::print(UMSKT::debug, "Debug: Message buffer contents:\n");
+        fmt::print(UMSKT::debug, "  leData: 0x{:08x}\n", leData);
+        fmt::print(UMSKT::debug, "  First 4 bytes: 0x{:02x}{:02x}{:02x}{:02x}\n", 
+            msgBuffer[0], msgBuffer[1], msgBuffer[2], msgBuffer[3]);
+        fmt::print(UMSKT::debug, "  Full buffer:");
+        for(size_t i = 0; i < SHA_MSG_LENGTH_XP; i++) {
+            if(i % 16 == 0) fmt::print(UMSKT::debug, "\n    ");
+            fmt::print(UMSKT::debug, "{:02x} ", msgBuffer[i]);
+        }
+        fmt::print(UMSKT::debug, "\n");
+        
         // pHash = SHA1(pSerial || R.x || R.y)
-        SHA1(msgBuffer, SHA_MSG_LENGTH_XP, msgDigest);
+        calculate_sha1((unsigned char *)msgBuffer, SHA_MSG_LENGTH_XP, msgDigest);
+
+        // Debug: Print SHA1 digest
+        fmt::print(UMSKT::debug, "Debug: SHA1 digest:\n");
+        for(int i = 0; i < SHA_DIGEST_LENGTH; i++) {
+            fmt::print(UMSKT::debug, "{:02x}", msgDigest[i]);
+        }
+        fmt::print(UMSKT::debug, "\n");
 
         // Translate the byte digest into a 32-bit integer - this is our computed pHash.
         // Truncate the pHash to 28 bits.
         DWORD pHash = BYDWORD(msgDigest) >> 4 & BITMASK(28);
         
+        // Debug: Print hash calculation steps
+        fmt::print(UMSKT::debug, "Debug: Hash calculation:\n");
+        fmt::print(UMSKT::debug, "  Raw BYDWORD: 0x{:08x}\n", BYDWORD(msgDigest));
+        fmt::print(UMSKT::debug, "  After shift: 0x{:08x}\n", BYDWORD(msgDigest) >> 4);
+        fmt::print(UMSKT::debug, "  Final hash:  0x{:08x}\n", pHash);
+
         /*
          *
          * Scalars:

src/main.cpp

@@ -26,6 +26,9 @@
 Options options;
 
 int main(int argc, char *argv[]) {
+    // Initialize OpenSSL
+    OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL);
+
     if (!CLI::parseCommandLine(argc, argv, &options)) {
         fmt::print("error parsing command line options\n");
         CLI::showHelp(argv);