background.js

// background.js - Service Worker para la extensión HackBar

// Importar módulos (solo si estamos en un contexto tipo worker)
if (typeof importScripts === 'function') {
  importScripts('config/payloads.js', 'utils/encoding.js');
}

// Estado global
const state = {
  currentUrl: '',
  postData: '',
  referrer: '',
  history: []
};

// ============================================
// MANEJADOR DE MENSAJES
// ============================================
browser.runtime.onMessage.addListener((message, sender, sendResponse) => {
  console.log('[HackBar] Message received:', message.action);
  
  handleMessage(message, sender)
    .then(response => sendResponse(response))
    .catch(error => {
      console.error('[HackBar] Error:', error);
      sendResponse({ error: error.message });
    });
  
  return true; // Mantener el canal abierto para respuestas asíncronas
});

// ============================================
// MANEJADOR PRINCIPAL
// ============================================
async function handleMessage(message, sender) {
  switch (message.action) {
    // URL Operations
    case 'getCurrentUrl':
      return await getCurrentUrl();
    
    case 'splitUrl':
      return splitUrl(message.url);
    
    case 'loadUrl':
      return await loadUrl(message.url, message.postData, message.referrer);
    
    // Encoding/Decoding
    case 'encodeText':
      return await encodeText(message.text, message.method);
    
    // Hashing
    case 'hashText':
      return await hashText(message.text, message.algorithm);
    
    // SQL Generation
    case 'generateSQL':
      return await generateSQL(message.type, message.params);
    
    // XSS Generation
    case 'generateXSS':
      return await generateXSS(message.type, message.params);
    
    // State Management
    case 'getState':
      return state;
    
    case 'updateState':
      return updateState(message.updates);
    
    default:
      throw new Error(`Unknown action: ${message.action}`);
  }
}

// ============================================
// URL OPERATIONS
// ============================================
async function getCurrentUrl() {
  try {
    const tabs = await browser.tabs.query({ active: true, currentWindow: true });
    if (tabs.length > 0) {
      state.currentUrl = tabs[0].url;
      return tabs[0].url;
    }
    return '';
  } catch (error) {
    console.error('[HackBar] Error getting current URL:', error);
    return '';
  }
}

function splitUrl(url) {
  try {
    if (!url) return '';
    
    // Parsear la URL
    const urlObj = new URL(url);
    let result = urlObj.origin + urlObj.pathname;
    
    // Agregar parámetros en líneas separadas
    if (urlObj.search) {
      const params = new URLSearchParams(urlObj.search);
      result += '\n';
      for (const [key, value] of params) {
        result += `${key}=${value}\n`;
      }
    }
    
    return result;
  } catch (error) {
    console.error('[HackBar] Error splitting URL:', error);
    return url;
  }
}

async function loadUrl(url, postData = '', referrer = '') {
  try {
    const tabs = await browser.tabs.query({ active: true, currentWindow: true });
    if (tabs.length === 0) {
      return { success: false, error: 'No active tab found' };
    }
    
    const tabId = tabs[0].id;
    
    // Si hay POST data, necesitamos usar un enfoque diferente
    if (postData) {
      // Inyectar script para hacer POST request
      await browser.tabs.executeScript(tabId, {
        code: `
          (function() {
            const form = document.createElement('form');
            form.method = 'POST';
            form.action = '${url}';
            
            ${postData.split('&').map(pair => {
              const [key, value] = pair.split('=');
              return `
                const input_${key} = document.createElement('input');
                input_${key}.type = 'hidden';
                input_${key}.name = '${key}';
                input_${key}.value = '${decodeURIComponent(value || '')}';
                form.appendChild(input_${key});
              `;
            }).join('\n')}
            
            document.body.appendChild(form);
            form.submit();
          })();
        `
      });
    } else {
      // Simple GET request
      await browser.tabs.update(tabId, { url: url });
    }
    
    // Guardar en historial
    state.history.push({
      url: url,
      postData: postData,
      referrer: referrer,
      timestamp: Date.now()
    });
    
    return { success: true };
  } catch (error) {
    console.error('[HackBar] Error loading URL:', error);
    return { success: false, error: error.message };
  }
}

// ============================================
// ENCODING OPERATIONS
// ============================================
async function encodeText(text, method) {
  try {
    switch (method) {
      case 'urlencode':
        return EncodingUtils.urlEncode(text);
      
      case 'urldecode':
        return EncodingUtils.urlDecode(text);
      
      case 'urlencodeall':
        return EncodingUtils.urlEncodeAll(text);
      
      case 'base64encode':
        return EncodingUtils.base64Encode(text);
      
      case 'base64decode':
        return EncodingUtils.base64Decode(text);
      
      case 'hexencode':
        return EncodingUtils.stringToHex(text);
      
      case 'hexdecode':
        return EncodingUtils.hexToString(text);
      
      case 'htmlencode':
        return EncodingUtils.htmlEntityEncode(text);
      
      case 'htmldecode':
        return EncodingUtils.htmlDecode(text);
      
      case 'unicodeencode':
        return EncodingUtils.unicodeEncode(text);
      
      case 'unicodedecode':
        return EncodingUtils.unicodeDecode(text);
      
      case 'mysqlchar':
        return EncodingUtils.toMySQLChar(text);
      
      case 'mssqlchar':
        return EncodingUtils.toMSSQLChar(text);
      
      case 'oraclechar':
        return EncodingUtils.toOracleChar(text);
      
      default:
        return 'Error: Unknown encoding method';
    }
  } catch (error) {
    console.error('[HackBar] Encoding error:', error);
    return 'Error: ' + error.message;
  }
}

// ============================================
// HASHING OPERATIONS
// ============================================
async function hashText(text, algorithm) {
  try {
    switch (algorithm.toLowerCase()) {
      case 'md5':
        return await EncodingUtils.md5(text);
      
      case 'sha1':
        return await EncodingUtils.sha1(text);
      
      case 'sha256':
        return await EncodingUtils.sha256(text);
      
      case 'sha512':
        return await EncodingUtils.sha512(text);
      
      default:
        return 'Error: Unknown hash algorithm';
    }
  } catch (error) {
    console.error('[HackBar] Hashing error:', error);
    return 'Error: ' + error.message;
  }
}

// ============================================
// SQL PAYLOAD GENERATION
// ============================================
async function generateSQL(type, params = {}) {
  try {
    console.log('[HackBar] Generating SQL:', type, params);
    
    // Navegar por la estructura de PayloadConfig
    const parts = type.split('.');
    let payload = PayloadConfig.sql;
    
    for (const part of parts) {
      if (payload && payload[part]) {
        payload = payload[part];
      } else {
        return 'Error: Payload not found';
      }
    }
    
    // Si el payload tiene una función generate, llamarla
    if (payload && typeof payload.generate === 'function') {
      const result = payload.generate(params.value, params.value2);
      return result;
    }
    
    // Compatibilidad con el sistema antiguo
    return generateSQLLegacy(type, params);
  } catch (error) {
    console.error('[HackBar] SQL generation error:', error);
    return 'Error: ' + error.message;
  }
}

// Mantener compatibilidad con el sistema antiguo
function generateSQLLegacy(type, params) {
  switch (type) {
    case 'selectionToUnionSelect':
      const columns = params.columns || 10;
      const cols = Array.from({length: columns}, (_, i) => i + 1).join(',');
      return `+UNION+ALL+SELECT+${cols}`;
    
    case 'UnionSelectGen':
      const choice = params.choice || '1';
      if (choice === '1') {
        return PayloadConfig.sql.union.null.generate(params.columns || 10);
      }
      return PayloadConfig.sql.union.basic.generate(params.columns || 10);
    
    case 'ErrorBased':
      const errorChoice = params.choice || '1';
      if (errorChoice === '1') {
        return PayloadConfig.sql.errorBased.basic.generate();
      } else if (errorChoice === '2') {
        return PayloadConfig.sql.errorBased.database.generate();
      }
      return PayloadConfig.sql.errorBased.version.generate();
    
    case 'char':
      const dbEngine = params.dbEngine || 'mysql';
      const text = params.text || '[TEXT]';
      if (dbEngine === 'mysql') {
        return EncodingUtils.toMySQLChar(text);
      } else if (dbEngine === 'mssql') {
        return EncodingUtils.toMSSQLChar(text);
      } else if (dbEngine === 'oracle') {
        return EncodingUtils.toOracleChar(text);
      }
      return 'Error: Unknown database engine';
    
    case 'statement':
      const stmtChoice = params.choice || '1';
      if (stmtChoice === '1') {
        return PayloadConfig.sql.information.version.generate();
      }
      return 'Error: Unknown statement type';
    
    case 'select':
      const selectChoice = params.choice || '3';
      if (selectChoice === '3') {
        return PayloadConfig.sql.information.databases.generate();
      }
      return 'Error: Unknown select type';
    
    case 'waf':
      const wafChoice = params.choice || '1';
      const wafText = params.text || 'SELECT * FROM users';
      if (wafChoice === '1') {
        return PayloadConfig.sql.wafBypass.comments.generate(wafText);
      } else if (wafChoice === '2') {
        return PayloadConfig.sql.wafBypass.versionComment.generate(wafText);
      }
      return PayloadConfig.sql.wafBypass.caseManipulation.generate(wafText);
    
    default:
      return 'Error: Unknown SQL payload type';
  }
}

// ============================================
// XSS PAYLOAD GENERATION
// ============================================
async function generateXSS(type, params = {}) {
  try {
    const parts = type.split('.');
    let payload = PayloadConfig.xss;
    
    for (const part of parts) {
      if (payload && payload[part]) {
        payload = payload[part];
      } else {
        return 'Error: Payload not found';
      }
    }
    
    if (payload && typeof payload.generate === 'function') {
      return payload.generate(params.value);
    }
    
    return 'Error: Invalid XSS payload';
  } catch (error) {
    console.error('[HackBar] XSS generation error:', error);
    return 'Error: ' + error.message;
  }
}

// ============================================
// STATE MANAGEMENT
// ============================================
function updateState(updates) {
  Object.assign(state, updates);
  return state;
}

// ============================================
// INITIALIZATION
// ============================================
console.log('[HackBar] Background script loaded');
console.log('[HackBar] Payloads available:', Object.keys(PayloadConfig));