reaper-arcade-hub 1.0.0

package/verify/js/firebase-client.js

@@ -0,0 +1,427 @@
+// REAPER HUB - Firebase Realtime Engine, Live Chat & Server Security Service
+
+const firebaseConfig = {
+  apiKey: "AIzaSyBuLsNUpp1DAGWI9cKni_MZJQsgB97xfHA",
+  authDomain: "gabasd-69d8a.firebaseapp.com",
+  databaseURL: "https://gabasd-69d8a-default-rtdb.firebaseio.com",
+  projectId: "gabasd-69d8a",
+  storageBucket: "gabasd-69d8a.firebasestorage.app",
+  messagingSenderId: "1088727880080",
+  appId: "1:1088727880080:web:b7765ab900e4c1dd492315",
+  measurementId: "G-S8PPR0SBKL"
+};
+
+class FirebaseService {
+  constructor() {
+    this.app = null;
+    this.db = null;
+    this.isInitialized = false;
+  }
+
+  async init() {
+    try {
+      if (typeof firebase !== 'undefined' && firebase.initializeApp) {
+        if (!firebase.apps.length) {
+          this.app = firebase.initializeApp(firebaseConfig);
+        } else {
+          this.app = firebase.app();
+        }
+        this.db = firebase.database();
+        this.isInitialized = true;
+        console.log("[REAPER HUB] Realtime DB Connected successfully.");
+      }
+    } catch (e) {
+      console.warn("[REAPER HUB] Firebase init error:", e);
+    }
+  }
+
+  // Realtime Live Chat
+  listenChatMessages(callback) {
+    if (this.db) {
+      try {
+        const chatRef = this.db.ref("reaperChat").limitToLast(60);
+        chatRef.on("value", (snapshot) => {
+          const val = snapshot.val();
+          let messages = [];
+          if (val) {
+            messages = Object.values(val);
+            messages.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
+          }
+          callback(messages);
+        }, (error) => {
+          console.error("[REAPER CHAT ERROR]", error);
+          const localChat = JSON.parse(localStorage.getItem("reaper_local_chat") || "[]");
+          callback(localChat);
+        });
+      } catch (err) {
+        const localChat = JSON.parse(localStorage.getItem("reaper_local_chat") || "[]");
+        callback(localChat);
+      }
+    } else {
+      const localChat = JSON.parse(localStorage.getItem("reaper_local_chat") || "[]");
+      callback(localChat);
+    }
+  }
+
+  async sendChatMessage(msgData) {
+    const msgId = 'msg_' + Date.now() + '_' + Math.random().toString(36).substring(2, 6);
+    msgData.id = msgId;
+
+    const localChat = JSON.parse(localStorage.getItem("reaper_local_chat") || "[]");
+    localChat.push(msgData);
+    if (localChat.length > 80) localChat.shift();
+    localStorage.setItem("reaper_local_chat", JSON.stringify(localChat));
+
+    if (this.db) {
+      try {
+        await this.db.ref(`reaperChat/${msgId}`).set(msgData);
+      } catch (e) {
+        console.error("[REAPER CHAT SEND ERROR]", e);
+      }
+    }
+    return true;
+  }
+
+  async deleteChatMessage(msgId) {
+    let localChat = JSON.parse(localStorage.getItem("reaper_local_chat") || "[]");
+    localChat = localChat.filter(m => m.id !== msgId);
+    localStorage.setItem("reaper_local_chat", JSON.stringify(localChat));
+
+    if (this.db) {
+      try {
+        await this.db.ref(`reaperChat/${msgId}`).remove();
+      } catch (e) {
+        console.error("[REAPER CHAT DELETE ERROR]", e);
+      }
+    }
+    return true;
+  }
+
+  listenChatLock(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperChatLocked").on("value", (snap) => {
+          callback(Boolean(snap.val()));
+        });
+      } catch (e) {}
+    }
+  }
+
+  async setChatLock(isLocked) {
+    localStorage.setItem("reaper_chat_locked", isLocked ? 'true' : 'false');
+    if (this.db) {
+      try {
+        await this.db.ref("reaperChatLocked").set(isLocked);
+      } catch (e) {}
+    }
+  }
+
+  // Realtime Bans & Leaderboard Progress Purge
+  listenBannedUsers(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperBannedUsers").on("value", (snap) => {
+          const bans = snap.val() || {};
+          const bannedList = Object.keys(bans);
+          localStorage.setItem('reaper_banned_users', JSON.stringify(bannedList));
+          callback(bannedList);
+        });
+      } catch (e) {
+        const local = JSON.parse(localStorage.getItem('reaper_banned_users') || '[]');
+        callback(local);
+      }
+    } else {
+      const local = JSON.parse(localStorage.getItem('reaper_banned_users') || '[]');
+      callback(local);
+    }
+  }
+
+  async banUser(username) {
+    if (!username || username === 'owner') return;
+
+    if (this.db) {
+      try {
+        await this.db.ref(`reaperBannedUsers/${username}`).set(true);
+        await this.db.ref(`reaperPlaytime/${username}`).remove();
+        const chatSnap = await this.db.ref('reaperChat').once('value');
+        if (chatSnap.exists()) {
+          const chats = chatSnap.val();
+          for (const msgId of Object.keys(chats)) {
+            if (chats[msgId].username === username) {
+              await this.db.ref(`reaperChat/${msgId}`).remove();
+            }
+          }
+        }
+      } catch (e) {
+        console.warn("Error banning user on Firebase:", e);
+      }
+    }
+
+    const localBans = JSON.parse(localStorage.getItem('reaper_banned_users') || '[]');
+    if (!localBans.includes(username)) {
+      localBans.push(username);
+      localStorage.setItem('reaper_banned_users', JSON.stringify(localBans));
+    }
+  }
+
+  async unbanUser(username) {
+    if (this.db) {
+      try {
+        await this.db.ref(`reaperBannedUsers/${username}`).remove();
+      } catch (e) {
+        console.warn("Error unbanning user on Firebase:", e);
+      }
+    }
+    const localBans = JSON.parse(localStorage.getItem('reaper_banned_users') || '[]').filter(u => u !== username);
+    localStorage.setItem('reaper_banned_users', JSON.stringify(localBans));
+  }
+
+  // Realtime Site Lockdown (Main Portal)
+  listenSiteLockdown(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperSiteLockdown").on("value", (snap) => {
+          const isLocked = Boolean(snap.val());
+          localStorage.setItem('reaper_site_lockdown', isLocked ? 'true' : 'false');
+          callback(isLocked);
+        });
+      } catch (e) {
+        callback(localStorage.getItem('reaper_site_lockdown') === 'true');
+      }
+    } else {
+      callback(localStorage.getItem('reaper_site_lockdown') === 'true');
+    }
+  }
+
+  async setSiteLockdown(isLocked) {
+    localStorage.setItem('reaper_site_lockdown', isLocked ? 'true' : 'false');
+    if (this.db) {
+      try {
+        await this.db.ref("reaperSiteLockdown").set(isLocked);
+      } catch (e) {}
+    }
+  }
+
+  // Realtime Verify Gateway Lockdown
+  listenVerifyLockdown(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperVerifyLockdown").on("value", (snap) => {
+          const isLocked = Boolean(snap.val());
+          localStorage.setItem('reaper_verify_lockdown', isLocked ? 'true' : 'false');
+          callback(isLocked);
+        });
+      } catch (e) {
+        callback(localStorage.getItem('reaper_verify_lockdown') === 'true');
+      }
+    } else {
+      callback(localStorage.getItem('reaper_verify_lockdown') === 'true');
+    }
+  }
+
+  async setVerifyLockdown(isLocked) {
+    localStorage.setItem('reaper_verify_lockdown', isLocked ? 'true' : 'false');
+    if (this.db) {
+      try {
+        await this.db.ref("reaperVerifyLockdown").set(isLocked);
+      } catch (e) {}
+    }
+  }
+
+  // Realtime Keys Pause / Freeze Lock
+  listenKeysLocked(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperKeysLocked").on("value", (snap) => {
+          const isLocked = Boolean(snap.val());
+          localStorage.setItem('reaper_keys_locked', isLocked ? 'true' : 'false');
+          callback(isLocked);
+        });
+      } catch (e) {
+        callback(localStorage.getItem('reaper_keys_locked') === 'true');
+      }
+    } else {
+      callback(localStorage.getItem('reaper_keys_locked') === 'true');
+    }
+  }
+
+  async setKeysLocked(isLocked) {
+    localStorage.setItem('reaper_keys_locked', isLocked ? 'true' : 'false');
+    if (this.db) {
+      try {
+        await this.db.ref("reaperKeysLocked").set(isLocked);
+      } catch (e) {}
+    }
+  }
+
+  // Realtime Emergency Google Redirect Lock (Panic Mode)
+  listenRedirectGoogle(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperRedirectGoogle").on("value", (snap) => {
+          const isRedirect = Boolean(snap.val());
+          localStorage.setItem('reaper_redirect_google', isRedirect ? 'true' : 'false');
+          callback(isRedirect);
+        });
+      } catch (e) {
+        callback(localStorage.getItem('reaper_redirect_google') === 'true');
+      }
+    } else {
+      callback(localStorage.getItem('reaper_redirect_google') === 'true');
+    }
+  }
+
+  async setRedirectGoogle(isRedirect) {
+    localStorage.setItem('reaper_redirect_google', isRedirect ? 'true' : 'false');
+    if (this.db) {
+      try {
+        await this.db.ref("reaperRedirectGoogle").set(isRedirect);
+      } catch (e) {}
+    }
+  }
+
+  // Permanent Shutdown Mode ("WE ARE SHUTTING DOWN FOR GOOD")
+  listenShutdownMode(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperShutdownMode").on("value", (snap) => {
+          const isShutdown = Boolean(snap.val());
+          localStorage.setItem('reaper_shutdown_mode', isShutdown ? 'true' : 'false');
+          callback(isShutdown);
+        });
+      } catch (e) {}
+    }
+  }
+
+  async setShutdownMode(isShutdown) {
+    localStorage.setItem('reaper_shutdown_mode', isShutdown ? 'true' : 'false');
+    if (this.db) {
+      try {
+        await this.db.ref("reaperShutdownMode").set(isShutdown);
+      } catch (e) {}
+    }
+  }
+
+  // Purge All Server Data
+  async purgeAllServerData() {
+    if (this.db) {
+      try {
+        await this.db.ref('reaperChat').remove();
+        await this.db.ref('reaperPlaytime').remove();
+        await this.db.ref('reaperGeneratedKeys').remove();
+        await this.db.ref('reaperTimeouts').remove();
+      } catch (e) {
+        console.error("Purge error on Firebase:", e);
+      }
+    }
+    localStorage.removeItem('reaper_local_chat');
+    localStorage.removeItem('reaper_generated_keys');
+  }
+
+  // Cross-Domain Realtime Key Management
+  listenGeneratedKeys(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperGeneratedKeys").on("value", (snap) => {
+          const keys = snap.val() || {};
+          localStorage.setItem('reaper_generated_keys', JSON.stringify(keys));
+          callback(keys);
+        });
+      } catch (e) {
+        const local = JSON.parse(localStorage.getItem('reaper_generated_keys') || '{}');
+        callback(local);
+      }
+    } else {
+      const local = JSON.parse(localStorage.getItem('reaper_generated_keys') || '{}');
+      callback(local);
+    }
+  }
+
+  async saveKey(keyName, keyInfo) {
+    const local = JSON.parse(localStorage.getItem('reaper_generated_keys') || '{}');
+    local[keyName] = keyInfo;
+    localStorage.setItem('reaper_generated_keys', JSON.stringify(local));
+
+    if (this.db) {
+      try {
+        await this.db.ref(`reaperGeneratedKeys/${keyName}`).set(keyInfo);
+      } catch (e) {
+        console.warn("Error saving key to Firebase:", e);
+      }
+    }
+  }
+
+  async deleteKey(keyName) {
+    const local = JSON.parse(localStorage.getItem('reaper_generated_keys') || '{}');
+    delete local[keyName];
+    localStorage.setItem('reaper_generated_keys', JSON.stringify(local));
+
+    if (this.db) {
+      try {
+        await this.db.ref(`reaperGeneratedKeys/${keyName}`).remove();
+      } catch (e) {
+        console.warn("Error deleting key from Firebase:", e);
+      }
+    }
+  }
+
+  async fetchKeyInfo(keyName) {
+    if (!keyName) return null;
+    const cleanKey = keyName.trim().toUpperCase();
+
+    if (this.db) {
+      try {
+        // 1. Direct match
+        let snap = await this.db.ref(`reaperGeneratedKeys/${cleanKey}`).once('value');
+        if (snap.exists()) return snap.val();
+
+        // 2. Prefixed with REAPER-
+        if (!cleanKey.startsWith('REAPER-')) {
+          snap = await this.db.ref(`reaperGeneratedKeys/REAPER-${cleanKey}`).once('value');
+          if (snap.exists()) return snap.val();
+        }
+
+        // 3. Case-insensitive scan across all keys
+        const allSnap = await this.db.ref('reaperGeneratedKeys').once('value');
+        if (allSnap.exists()) {
+          const allKeys = allSnap.val();
+          for (const k of Object.keys(allKeys)) {
+            if (k.toUpperCase() === cleanKey || k.toUpperCase() === 'REAPER-' + cleanKey) {
+              return allKeys[k];
+            }
+          }
+        }
+      } catch (e) {}
+    }
+
+    const local = JSON.parse(localStorage.getItem('reaper_generated_keys') || '{}');
+    if (local[cleanKey]) return local[cleanKey];
+    if (local['REAPER-' + cleanKey]) return local['REAPER-' + cleanKey];
+    for (const k of Object.keys(local)) {
+      if (k.toUpperCase() === cleanKey || k.toUpperCase() === 'REAPER-' + cleanKey) {
+        return local[k];
+      }
+    }
+    return null;
+  }
+
+  async incrementKeyUsage(keyName) {
+    if (this.db) {
+      try {
+        const keyRef = this.db.ref(`reaperGeneratedKeys/${keyName}`);
+        const snap = await keyRef.once('value');
+        if (snap.exists()) {
+          const info = snap.val();
+          const newUsed = (info.usedCount || 0) + 1;
+          if (newUsed >= (info.maxUses || 999999)) {
+            await keyRef.remove();
+          } else {
+            await keyRef.update({ usedCount: newUsed });
+          }
+        }
+      } catch (e) {}
+    }
+  }
+}
+
+window.reaperFirebase = new FirebaseService();

package/verify/js/security-shield.js

@@ -0,0 +1,225 @@
+// REAPER HUB - Universal Anti-Extension Spy Shield & System Defense Engine
+// Scans, detects, isolates, and terminates browser extension hooks, surveillance content-scripts, and DOM inspectors.
+
+(function() {
+  'use strict';
+
+  class ReaperSecurityShield {
+    constructor() {
+      this.bannedSignatures = [
+        { id: 'goguardian', name: 'GoGuardian Surveillance Hook', category: 'School Spyware', risk: 'CRITICAL' },
+        { id: 'securly', name: 'Securly Filter & Activity Probe', category: 'School Spyware', risk: 'CRITICAL' },
+        { id: 'hapara', name: 'Hapara Highlights Screen Grabber', category: 'School Spyware', risk: 'CRITICAL' },
+        { id: 'blocksi', name: 'Blocksi Web Content Scanner', category: 'School Spyware', risk: 'CRITICAL' },
+        { id: 'lightspeed', name: 'Lightspeed Relay Screen Spy', category: 'School Spyware', risk: 'HIGH' },
+        { id: 'lanschool', name: 'LanSchool Classroom Monitor', category: 'School Spyware', risk: 'CRITICAL' },
+        { id: 'imperosoftware', name: 'Impero Education Spy Hook', category: 'School Spyware', risk: 'CRITICAL' },
+        { id: 'contentkeeper', name: 'ContentKeeper Behavioral Monitor', category: 'School Spyware', risk: 'HIGH' },
+        { id: 'deledao', name: 'Deledao AI Web Telemetry', category: 'School Spyware', risk: 'HIGH' },
+        { id: 'linewize', name: 'Linewize School Filter Probe', category: 'School Spyware', risk: 'HIGH' },
+        { id: 'bark', name: 'Bark Youth Monitoring Probe', category: 'Activity Spy', risk: 'MEDIUM' },
+        { id: 'cisco-umbrella', name: 'Cisco Umbrella DNS Sniffer', category: 'Network Filter', risk: 'HIGH' },
+        { id: 'netsupport', name: 'NetSupport School Screen Catcher', category: 'School Spyware', risk: 'CRITICAL' },
+        { id: 'aristotle', name: 'Aristotle Insight Telemetry', category: 'School Spyware', risk: 'HIGH' },
+        { id: 'smoothwall', name: 'Smoothwall Web Policy Monitor', category: 'School Spyware', risk: 'HIGH' },
+        { id: 'grammarly', name: 'Grammarly DOM Text Keystroke Hook', category: 'Input Sniffer', risk: 'MEDIUM' },
+        { id: 'lastpass', name: 'LastPass Autofill Hook', category: 'Autofill Extension', risk: 'LOW' },
+        { id: 'tampermonkey', name: 'UserScript / Userscript Manager', category: 'DOM Injector', risk: 'MEDIUM' },
+        { id: 'adblock', name: 'AdBlocker Content Scraper', category: 'Ad Filter', risk: 'LOW' }
+      ];
+
+      this.autoShield = localStorage.getItem('reaper_auto_shield') !== 'false';
+      this.detectedExtensions = [];
+      this.blockedCount = 0;
+      this.isScanning = false;
+
+      this.init();
+    }
+
+    init() {
+      // 1. Defend Against DevTools Inspection Shortcuts
+      window.addEventListener('keydown', (e) => {
+        if (e.key === 'F12' || e.keyCode === 123) {
+          e.preventDefault();
+          e.stopPropagation();
+          return false;
+        }
+        if (e.ctrlKey && e.shiftKey && ['I','i','J','j','C','c','K','k','E','e','S','s'].includes(e.key)) {
+          e.preventDefault();
+          e.stopPropagation();
+          return false;
+        }
+        if (e.ctrlKey && (e.key === 'U' || e.key === 'u')) {
+          e.preventDefault();
+          e.stopPropagation();
+          return false;
+        }
+      }, true);
+
+      // 2. Cloak chrome.runtime messaging
+      try {
+        if (window.chrome && window.chrome.runtime) {
+          const origSendMessage = window.chrome.runtime.sendMessage;
+          const bannedIds = this.bannedSignatures.map(s => s.id);
+          window.chrome.runtime.sendMessage = function() {
+            if (arguments[0] && typeof arguments[0] === 'object') {
+              const payload = JSON.stringify(arguments[0]).toLowerCase();
+              for (let i = 0; i < bannedIds.length; i++) {
+                if (payload.includes(bannedIds[i])) {
+                  return Promise.resolve({ blocked: true });
+                }
+              }
+            }
+            if (origSendMessage) {
+              try {
+                return origSendMessage.apply(this, arguments);
+              } catch (err) {}
+            }
+          };
+        }
+      } catch (e) {}
+
+      // 3. Setup continuous MutationObserver to instantly strip injected extension nodes
+      if (typeof MutationObserver !== 'undefined') {
+        const observer = new MutationObserver((mutations) => {
+          for (let i = 0; i < mutations.length; i++) {
+            const added = mutations[i].addedNodes;
+            for (let j = 0; j < added.length; j++) {
+              const node = added[j];
+              if (this.isSpyElement(node)) {
+                if (node.parentNode) {
+                  node.parentNode.removeChild(node);
+                  this.blockedCount++;
+                }
+              }
+            }
+          }
+        });
+
+        const target = document.documentElement || document;
+        observer.observe(target, { childList: true, subtree: true });
+      }
+
+      // 4. Auto-Purge Loop if enabled
+      if (this.autoShield) {
+        setInterval(() => this.purgeSpyInjections(), 800);
+      }
+
+      // Initial scan
+      setTimeout(() => this.scanExtensions(), 500);
+      console.log("%c[REAPER SECURITY SHIELD]%c Active & Monitoring.", "color: #00d2ff; font-weight: 900;", "color: #88ccff;");
+    }
+
+    isSpyElement(node) {
+      if (!node || node.nodeType !== 1) return false;
+      try {
+        const id = (node.id || '').toLowerCase();
+        const cls = (typeof node.className === 'string' ? node.className : '').toLowerCase();
+        const src = (node.src || '').toLowerCase();
+        const href = (node.href || '').toLowerCase();
+
+        for (let i = 0; i < this.bannedSignatures.length; i++) {
+          const sig = this.bannedSignatures[i].id;
+          if (id.includes(sig) || cls.includes(sig) || src.includes(sig) || href.includes(sig)) {
+            return true;
+          }
+        }
+
+        if ((src.startsWith('chrome-extension://') || href.startsWith('chrome-extension://')) &&
+            !src.includes('firebase') && !src.includes('gstatic')) {
+          return true;
+        }
+      } catch (e) {}
+      return false;
+    }
+
+    scanExtensions() {
+      this.isScanning = true;
+      const detected = [];
+
+      // Probe DOM elements, scripts, styles, iframes
+      this.bannedSignatures.forEach(sig => {
+        let isPresent = false;
+        let details = 'No active DOM hooks found';
+
+        // Check DOM selectors
+        const found = document.querySelectorAll(`[id*="${sig.id}" i], [class*="${sig.id}" i], script[src*="${sig.id}" i], link[href*="${sig.id}" i]`);
+        if (found.length > 0) {
+          isPresent = true;
+          details = `${found.length} injected DOM element(s) detected`;
+        }
+
+        // Check global window artifacts
+        const keys = Object.keys(window);
+        for (let i = 0; i < keys.length; i++) {
+          if (keys[i].toLowerCase().includes(sig.id)) {
+            isPresent = true;
+            details = `Global object window.${keys[i]} detected`;
+            break;
+          }
+        }
+
+        detected.push({
+          id: sig.id,
+          name: sig.name,
+          category: sig.category,
+          risk: sig.risk,
+          status: isPresent ? 'ACTIVE_BLOCKED' : 'NEUTRALIZED',
+          details: details
+        });
+      });
+
+      // Probe for generic chrome-extension scripts
+      const extElements = document.querySelectorAll('script[src^="chrome-extension://"], iframe[src^="chrome-extension://"]');
+      if (extElements.length > 0) {
+        detected.unshift({
+          id: 'generic-ext',
+          name: 'External Chrome Extension Content Script',
+          category: 'Browser Extension',
+          risk: 'HIGH',
+          status: 'ACTIVE_BLOCKED',
+          details: `${extElements.length} chrome-extension:// script/iframe hook(s)`
+        });
+      }
+
+      this.detectedExtensions = detected;
+      this.isScanning = false;
+      return detected;
+    }
+
+    purgeSpyInjections() {
+      let count = 0;
+      try {
+        this.bannedSignatures.forEach(sig => {
+          const found = document.querySelectorAll(`[id*="${sig.id}" i], [class*="${sig.id}" i], iframe[src*="${sig.id}" i], script[src*="${sig.id}" i]`);
+          for (let i = 0; i < found.length; i++) {
+            const el = found[i];
+            if (el && el.parentNode && el.id !== 'app-splash-screen' && !el.closest('#app-layout')) {
+              el.parentNode.removeChild(el);
+              count++;
+            }
+          }
+        });
+
+        // Kill generic chrome-extension injections
+        const extNodes = document.querySelectorAll('iframe[src^="chrome-extension://"], script[src^="chrome-extension://"]');
+        for (let i = 0; i < extNodes.length; i++) {
+          if (extNodes[i] && extNodes[i].parentNode) {
+            extNodes[i].parentNode.removeChild(extNodes[i]);
+            count++;
+          }
+        }
+      } catch (e) {}
+
+      this.blockedCount += count;
+      return count;
+    }
+
+    setAutoPurge(enabled) {
+      this.autoShield = enabled;
+      localStorage.setItem('reaper_auto_shield', enabled ? 'true' : 'false');
+    }
+  }
+
+  window.reaperShield = new ReaperSecurityShield();
+})();