Browser extension for SecureBit Chat — a P2P messenger with military-grade cryptography.

extension-background.js

@@ -0,0 +1,162 @@
+// Background script for SecureBit Chat Extension
+// Handles extension lifecycle, notifications, and communication
+
+class SecureBitBackground {
+    constructor() {
+        this.initializeExtension();
+    }
+
+    initializeExtension() {
+        // Handle extension installation
+        chrome.runtime.onInstalled.addListener((details) => {
+            console.log('SecureBit Chat Extension installed:', details);
+            this.setupDefaultSettings();
+        });
+
+        // Handle extension startup
+        chrome.runtime.onStartup.addListener(() => {
+            console.log('SecureBit Chat Extension started');
+        });
+
+        // Handle messages from content scripts and popup
+        chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
+            this.handleMessage(request, sender, sendResponse);
+            return true; // Keep message channel open for async responses
+        });
+
+        // Handle tab updates for content script injection
+        chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
+            if (changeInfo.status === 'complete' && tab.url) {
+                this.injectContentScriptIfNeeded(tabId, tab.url);
+            }
+        });
+    }
+
+    setupDefaultSettings() {
+        // Set default extension settings
+        chrome.storage.local.set({
+            'securebit_settings': {
+                autoConnect: true,
+                notifications: true,
+                theme: 'dark',
+                language: 'en',
+                encryptionLevel: 'military',
+                lastActive: Date.now()
+            }
+        });
+    }
+
+    async handleMessage(request, sender, sendResponse) {
+        try {
+            switch (request.action) {
+                case 'getSettings':
+                    const settings = await this.getSettings();
+                    sendResponse({ success: true, data: settings });
+                    break;
+
+                case 'updateSettings':
+                    await this.updateSettings(request.data);
+                    sendResponse({ success: true });
+                    break;
+
+                case 'showNotification':
+                    await this.showNotification(request.data);
+                    sendResponse({ success: true });
+                    break;
+
+                case 'getActiveTab':
+                    const tab = await this.getActiveTab();
+                    sendResponse({ success: true, data: tab });
+                    break;
+
+                case 'executeScript':
+                    const result = await this.executeScript(request.script, request.tabId);
+                    sendResponse({ success: true, data: result });
+                    break;
+
+                case 'getStorageData':
+                    const data = await this.getStorageData(request.key);
+                    sendResponse({ success: true, data: data });
+                    break;
+
+                case 'setStorageData':
+                    await this.setStorageData(request.key, request.value);
+                    sendResponse({ success: true });
+                    break;
+
+                default:
+                    sendResponse({ success: false, error: 'Unknown action' });
+            }
+        } catch (error) {
+            console.error('Background script error:', error);
+            sendResponse({ success: false, error: error.message });
+        }
+    }
+
+    async getSettings() {
+        const result = await chrome.storage.local.get(['securebit_settings']);
+        return result.securebit_settings || {};
+    }
+
+    async updateSettings(newSettings) {
+        const currentSettings = await this.getSettings();
+        const updatedSettings = { ...currentSettings, ...newSettings };
+        await chrome.storage.local.set({ 'securebit_settings': updatedSettings });
+    }
+
+    async showNotification(data) {
+        if (data.title && data.message) {
+            await chrome.notifications.create({
+                type: 'basic',
+                iconUrl: 'logo/icon-128x128.png',
+                title: data.title,
+                message: data.message
+            });
+        }
+    }
+
+    async getActiveTab() {
+        const tabs = await chrome.tabs.query({ active: true, currentWindow: true });
+        return tabs[0] || null;
+    }
+
+    async executeScript(script, tabId) {
+        try {
+            const results = await chrome.scripting.executeScript({
+                target: { tabId: tabId || (await this.getActiveTab()).id },
+                func: new Function(script)
+            });
+            return results[0]?.result;
+        } catch (error) {
+            console.error('Script execution error:', error);
+            throw error;
+        }
+    }
+
+    async getStorageData(key) {
+        const result = await chrome.storage.local.get([key]);
+        return result[key];
+    }
+
+    async setStorageData(key, value) {
+        await chrome.storage.local.set({ [key]: value });
+    }
+
+    async injectContentScriptIfNeeded(tabId, url) {
+        // Only inject on http/https pages
+        if (url.startsWith('http://') || url.startsWith('https://')) {
+            try {
+                await chrome.scripting.executeScript({
+                    target: { tabId: tabId },
+                    files: ['content.js']
+                });
+            } catch (error) {
+                // Content script might already be injected
+                console.log('Content script injection skipped:', error.message);
+            }
+        }
+    }
+}
+
+// Initialize the background script
+new SecureBitBackground();