Master PDF Editor patch analysis

curl 'http://reg.code-industry.net/mpe-5/pr/index-5.php?1=1&2=test&3=6C074FFE-0939-5A8A-BC0F-4994FCA543E0-5986&4=6d61634f532031352e33202d2031352e33' \
-H 'Host: reg.code-industry.net' \
-H 'Connection: Keep-Alive' \
-H 'Accept-Language: en-US,*' \
-H 'User-Agent: Mozilla/5.0'

ioreg -rd1 -c IOPlatformExpertDevice | awk '/IOPlatformUUID/ { print $3; }'

"6C074FFE-0939-5A8A-BC0F-4994FCA543E0"

void __fastcall MainWindow::ValidateLicense(MainWindow *this, const QString *a2)
{
  // variables declarations removed for clarity

  if ( *(_DWORD *)(*((_QWORD *)this + 138) + 4LL) && !*((_BYTE *)this + 98) )
  {
    *((_BYTE *)this + 98) = 1;  // Set license flag
    
    if ( *(_DWORD *)(*((_QWORD *)this + 139) + 4LL) )
    {
      // License server validation path
      MainReg::ReadReg((MainReg *)&MainReg::GetInstance(void)::instance, &v32);
      
      // [Memory cleanup code removed]
      
      MainReg::ActivateFromLicenseServer(
        (MainReg *)&MainReg::GetInstance(void)::instance,
        (const QString *)this + 138,
        (const QString *)this + 143,
        (const QString *)this + 139,
        (const QString *)this + 140);
        
      MainReg::ReadReg((MainReg *)&MainReg::GetInstance(void)::instance, v28);
      *((_BYTE *)this + 97) = *((_DWORD *)v28[0].d + 1) != 0;  // Set validity flag
      
      // [Memory cleanup code removed]
      
      QDocTab::SetRegProgram(*((QDocTab **)this + 18), *((_BYTE *)this + 97));
      
      if ( *((_BYTE *)this + 97) )  // If license is valid
      {
        // Update window title and handle concurrent licensing
        // [Window title update code removed]
      }
      else if ( byte_101D16CC1 )
      {
        // Show license server connection failure
        QMetaObject::tr(&v29, (QMetaObject *)&MainWindow::staticMetaObject, 
                        "Failed to connect to License server", 0LL, -1);
        // [Message box code retained]
      }
    }
    else
    {
      // Local validation path
      QString::toLatin1_helper(v28, (QString *)this + 138, a2);
      IsConcurrent = RegCrypt::IsConcurrent((RegCrypt *)v28, v8);
      
      // [Memory cleanup code removed]
      
      if ( (IsConcurrent & 1) != 0 )
        return;
      
      // Generate registration URL and validate via network
      // [Network request setup code retained]
      v21 = QNetworkAccessManager::get(v19, (const QNetworkRequest *)&v29);
      QObject::connect(&v23, v21, "2finished()", this, "1Check_for_Validation_Finished()", 0LL);
      
      // [Cleanup code removed]
    }
  }
}

__int64 __fastcall MainWindow::ReadReg(MainWindow *this)
{
  // Reset license flag
  *((_BYTE *)this + 100) = 0;
  
  // Clear any existing registration data
  // [Memory cleanup code removed]
  
  // Read license information from settings
  GeneralSettings::GeneralSettings((GeneralSettings *)v67);
  MainVersion = GeneralSettings::GetMainVersion((GeneralSettings *)v67);
  
  // Get registration code
  GeneralSettings::GetRegistrationCode((GeneralSettings *)v67, v4, v5);
  QString::trimmed_helper(&v66, &v65, v6);
  *((QString *)this + 138) = v66;
  
  // [Memory cleanup code removed]
  
  // Get license server IP
  GeneralSettings::GetLicenseServerIp((__int64 *)&v66, (GeneralSettings *)v67, v10);
  *((QString *)this + 139) = v66;
  
  // Get license server port
  LicenseServerPort = (QString *)GeneralSettings::GetLicenseServerPort((GeneralSettings *)v67);
  QString::number(&v66, LicenseServerPort, 10, v15);
  *((QString *)this + 140) = v66;
  
  // Check if license is concurrent
  if ( !*((_DWORD *)*v13 + 1) )
    goto LABEL_47;
    
  QString::toLatin1_helper(&v66, (QString *)this + 138, v16);
  IsConcurrent = RegCrypt::IsConcurrent((RegCrypt *)&v66, v18);
  
  // [Memory cleanup code removed]
  
  if ( IsConcurrent )
  {
    // Remove activation code if license is concurrent
    QPDFSettings::Remove((QPDFSettings *)v67, v22);
    // [Memory cleanup code removed]
  }
  else
  {
LABEL_47:
    // Get activation code for non-concurrent license
    GeneralSettings::GetActivationCode((__int64 *)&v65, (GeneralSettings *)v67);
    QString::trimmed_helper(&v66, &v65, v24);
    *((QString *)this + 141) = v66;
  }
  
  // Load machine ID
  LoadMachineID(&v66);
  *((QString *)this + 143) = v66;
  
  // [Machine ID handling code removed]
  
  // Version check logic
  if ( MainVersion <= 5729 && MainVersion )
  {
    // Handle old version
    // [Old version code removed]
    return 0LL;
  }
  
  // Validation check
  if ( *(_DWORD *)(*((_QWORD *)this + 139) + 4LL) || *(int *)(*((_QWORD *)this + 141) + 4LL) > 50 )
  {
    if ( *((int *)*v13 + 1) < 18 || *(int *)(*((_QWORD *)this + 141) + 4LL) < 40 )
      return 0LL;
      
    // Perform license validation
    RegCrypt::CheckActivation(&v58, v41, v42, v40, &v65, 0LL);
    
    // [Memory cleanup code removed]
    
    return 1LL;  // This is the key return value for license validation success
  }
  
  // License validation failed path
  QPDFSettings::Remove((QPDFSettings *)v67, v34);
  
  // Log error
  Logger::LogMessage(v47, v50, v51);
  
  // [Memory cleanup code removed]
  
  return 0LL;  // Return failure
}

GeneralSettings::GetRegistrationCode((__int64 *)&v73, (GeneralSettings *)v75, v4);
QString::trimmed_helper(&v74, &v73, v5);
*((QString *)this + 138) = v74;

void __fastcall MainWindow::on_actionRegister_triggered(MainWindow *this)
{
  // Initial setup and flags
  if ( (*(_BYTE *)(*((_QWORD *)this + 5) + 10LL) & 1) != 0 )
    *((_BYTE *)this + 101) = 1;
    
  // Create and show registration dialog
  v2 = (RegDialog *)operator new(0xE8uLL);
  RegDialog::RegDialog(v2, this);
  RegDialog::SetRegProgram(v2, *((_BYTE *)this + 97), (const QString *)this + 143);
  (*(void (__fastcall **)(RegDialog *))(*(_QWORD *)v2 + 424LL))(v2);
  
  // Get registration status from dialog
  v14 = 0;
  RegProgram = RegDialog::getRegProgram(v2, &v14);
  *((_BYTE *)this + 97) = RegProgram;  // Set validity flag
  *((_BYTE *)this + 98) = RegProgram;  // Set license flag
  
  // Update window title
  QString::operator=((char *)this + 1088, &qword_101D78C40);
  
  // Handle unregistered state
  if ( *((_BYTE *)this + 97) || *((_BYTE *)this + 391) )
    goto LABEL_17;
    
  // [Unregistered title update code removed]
  
LABEL_17:
  // Clean up dialog
  (*(void (__fastcall **)(RegDialog *))(*(_QWORD *)v2 + 32LL))(v2);
  
  // Update window title and document tabs
  MainWindow::SetWindowTitle(this, v8);
  QDocTab::SetRegProgram(*((QDocTab **)this + 18), *((_BYTE *)this + 97));
  
  // Validate license if newly registered
  if ( *((_BYTE *)this + 97) )
  {
    if ( v14 )
    {
      *((_BYTE *)this + 98) = 0;  // Reset license flag
      MainWindow::ReadReg(this);  // Read registration info
      MainWindow::ValidateLicense(this, v10);  // Validate license
    }
  }
}

atomic_uint *__usercall MainReg::ReadReg@<X0>(MainReg *this@<X0>, _QWORD *a2@<X8>)
{
  // [Variables and initial setup removed for clarity]

  // Get registration and activation information
  GeneralSettings::GeneralSettings((GeneralSettings *)v33);
  GeneralSettings::GetRegistrationCode((GeneralSettings *)v33, v5, v6);
  // [Memory management code removed]
  GeneralSettings::GetActivationCode((__int64 *)&v34, (GeneralSettings *)v33);
  // [Memory management code removed]
  
  // Load machine ID for validation
  LoadMachineID(&v31[4]);
  *(_DWORD *)v31 = -1;
  
  // Check if registration/activation codes are valid length
  if ( d[1] >= 18 && v10[1] >= 19 )
  {
    // Prepare parameters for validation
    v30.d = d;  // Registration code
    v29 = *(atomic_uint **)&v31[4];  // Machine ID
    v28 = v10;  // Activation code
    
    // Validate the registration
    RegCrypt::CheckActivation(&v30, v14, v15, v13, (const QString *)v31, 0LL);
    
    // [Memory cleanup code removed]
    
    // Store result and return
    *a2 = *(_QWORD *)&v31[4];
    *(_QWORD *)&v31[4] = &QArrayData::shared_null;
  }
  else
  {
    // Log error if codes don't meet length requirements
    v19 = (Logger *)*((_QWORD *)this + 9);
    v27 = (atomic_uint *)QString::fromAscii_helper((QString *)"Registration", (const char *)0xC, v12);
    QString::number(&v34, (QString *)*(unsigned int *)v31, 10, v20);
    QString::fromUtf8_helper(&v26, (QString *)"Error: REG0", (const char *)0xB, v21);
    QString::append(&v26, &v34);
    Logger::LogMessage(v19, v22, v23);
    
    // [Memory cleanup code removed]
    
    *a2 = &QArrayData::shared_null;
  }
  
  // [Final memory cleanup removed]
  
  return result;
}

RegCrypt::CheckActivation(&v30, v14, v15, v13, (const QString *)v31, 0LL);
    v16 = v28;
    if ( *v28 != -1 )
    {
      if ( *v28 )
      {
        if ( atomic_fetch_add(v28, 0xFFFFFFFF) != 1 )
          goto LABEL_29;
        v16 = v28;
      }
      QArrayData::deallocate(v16, 2LL, 8LL);
    }

__int64 __fastcall MainWindow::ReadReg(MainWindow *this)
{
  // Reset license validation flag
  *((_BYTE *)this + 100) = 0;
  
  // Load registration settings
  GeneralSettings::GeneralSettings((GeneralSettings *)v75);
  MainVersion = GeneralSettings::GetMainVersion((GeneralSettings *)v75);
  
  // Retrieve stored codes
  GeneralSettings::GetRegistrationCode((__int64 *)&v73, (GeneralSettings *)v75, v4);
  GeneralSettings::GetLicenseServerIp((__int64 *)&v74, (GeneralSettings *)v75, v9);
  GeneralSettings::GetActivationCode((__int64 *)&v73, (GeneralSettings *)v75);
  
  // Check for concurrent licensing
  if ( !*(_DWORD *)(*(_QWORD *)v12 + 4LL) )
    goto LABEL_47;
    
  IsConcurrent = RegCrypt::IsConcurrent((RegCrypt *)&v74, v17);
  
  // Core validation logic
  if ( *(int *)(*(_QWORD *)v12 + 4LL) >= 18 && *(int *)(*((_QWORD *)this + 139) + 4LL) >= 40 )
  {
    // Prepare validation parameters
    v66 = *(atomic_uint **)v12;        // Registration code
    v65 = (atomic_uint *)*((_QWORD *)this + 141);  // Machine ID
    v64 = (atomic_uint *)*((_QWORD *)this + 139);  // Activation code
    
    // Perform cryptographic validation
    v43 = RegCrypt::CheckActivation((RegCrypt *)&v66, v40, v41, v39, &v73, 0, v29);
    
    if ( (v43 & 1) != 0 )
      return 1;  // ← TARGET: Force return 1 here
  }
  
  // Cleanup and error handling
  LODWORD(v73.d) = 7;
  QPDFSettings::Remove((QPDFSettings *)v75, v48);  // Remove invalid codes
  
  return 0;  // Registration failed
}

void MainWindow::ValidateLicense() {
    QString regCode = MainReg::GetInstance()->GetRegistrationCode();

    if (regCode.length > 0 && !this->field_107) {
        this->field_107 = 1; // Guard flag

        MainReg::GetInstance()->ReloadLicenseData();

        if (MainReg::IsCentralServerActivationValid(&errorCode)
            && !MainReg::IsConcurrent()) {
            // Subscription checks...
        }

        this->field_105 = MainReg::IsValidLicense();
        QDocTab::SetRegProgram(qdoctab, this->field_105);
    }
}

void hooked_ValidateLicense(void *self) {
    // self+107 = validation-in-progress flag (prevents re-entry)
    *((uint8_t *)self + 107) = 1;
    
    // self+105 = license-valid flag  
    *((uint8_t *)self + 105) = 1;
    
    // Call QDocTab::SetRegProgram to update UI
    // self+184 (slot 23) = QDocTab pointer
    void **qdoctab = (void **)((char *)self + 184);
    if (qdoctab && *qdoctab) {
        SetRegProgram(*qdoctab, YES);
    }
}

int idx = imageIndex("Master PDF Editor");
intptr_t slide = _dyld_get_image_vmaddr_slide(idx);
void *runtimeAddress = (void *)(0x10034d4f0 + slide);

tiny_hook(runtimeAddress, hooked_ValidateLicense, NULL);

uintptr_t kSetRegProgram = 0x10026c430;
intptr_t slide = _dyld_get_image_vmaddr_slide(imageIndex);
fn_SetRegProgram = (void *)(kSetRegProgram + slide);

#import <Foundation/Foundation.h>
#import <mach-o/dyld.h>
#include "tinyhook.h"

#define kValidateLicenseAddress 0x10034D4F0
#define kSetRegProgramAddress   0x10026C430
#define kGuardFlagOffset        107
#define kLicenseFlagOffset      105
#define kQDocTabPointerOffset   184

static void (*setRegProgram)(void *, BOOL);

static void hooked_ValidateLicense(void *self) {
    *((uint8_t *)self + kGuardFlagOffset) = 1;
    *((uint8_t *)self + kLicenseFlagOffset) = 1;

    void **qdoctab = (void **)((char *)self + kQDocTabPointerOffset);
    if (qdoctab && *qdoctab) {
        setRegProgram(*qdoctab, YES);
    }
}

static int imageIndex(const char *name) {
    uint32_t count = _dyld_image_count();
    for (uint32_t i = 0; i < count; i++) {
        const char *path = _dyld_get_image_name(i);
        const char *last = strrchr(path, '/');
        if (last && strcmp(last + 1, name) == 0) return i;
        if (!last && strcmp(path, name) == 0) return i;
    }
    return -1;
}

__attribute__((constructor))
static void init() {
    @autoreleasepool {
        NSLog(@"[MPE] loaded");

        int idx = imageIndex("Master PDF Editor");
        if (idx < 0) {
            NSLog(@"[MPE] ERROR: image not found");
            return;
        }

        intptr_t slide = _dyld_get_image_vmaddr_slide(idx);

        void *target = (void *)(kValidateLicenseAddress + slide);
        if (tiny_hook(target, hooked_ValidateLicense, NULL) != 0) {
            NSLog(@"[MPE] ERROR: hook failed");
            return;
        }

        setRegProgram = (void (*)(void *, BOOL))(kSetRegProgramAddress + slide);

        NSLog(@"[MPE] ready");
    }
}

% DYLD_INSERT_LIBRARIES=/path/to/MasterPDFEditor.dylib '/Applications/Master PDF Editor.app/Contents/MacOS/Master PDF Editor'