technology software

documentation technical

government public service

cryptocurrency blockchain

news media journalism

English

Within the application-focused generic top-level domain (.app), 'wooden-gray-bgao9epg0w-fzdrz4ip8h.edgeone.app' is registered and includes subdomain 'wooden-gray-bgao9epg0w-fzdrz4ip8h'. The registrable portion 'edgeone' spans 7 characters holding 4 vowels versus three consonants. Segmentation suggests two words: edge, one. The median word length lands at 3.5 characters. No strong language cues emerged from the frequency lists.

html/6d/09/6d090d53-8217-4414-a09b-7950325117c1_fallback.html.gz

viewport

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

child-src 'none';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources 'self';trusted-types;worker-src blob: 'self';frame-ancestors 'none';

child-src https:  chrome-untrusted://new-tab-page/ chrome-untrusted://ntp-microsoft-auth/;connect-src chrome://resources chrome://theme 'self';default-src 'self';font-src chrome://resources 'self';img-src chrome://resources chrome://theme chrome://image chrome://favicon2 chrome://app-icon chrome://extension-icon chrome://fileicon blob: data: 'self';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources chrome://webui-test 'self';style-src chrome://resources chrome://theme 'self' 'unsafe-inline';trusted-types parse-html-subset sanitize-inner-html static-types webui-test-script webui-test-html polymer-html-literal polymer-template-event-attribute-policy lit-html-desktop;frame-ancestors 'none';

child-src 'none';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources 'self';trusted-types;frame-ancestors 'none';

base-uri 'none';child-src https:;form-action https://ogs.google.com https://*.corp.google.com;object-src 'none';script-src 'self' 'unsafe-inline' https:;frame-ancestors chrome://new-tab-page/


// --- Utility functions ---
function randInt(a,b){return Math.floor(Math.random()*(b-a+1))+a}
function randHex(len){let s='';for(let i=0;i<len;i++)s+="0123456789abcdef"[Math.floor(Math.random()*16)];return s}
function base64enc(u){return btoa(unescape(encodeURIComponent(u)))}
function base64dec(s){try{return decodeURIComponent(escape(atob(s)));}catch(e){return atob(s);} }

// Lua keywords (do not rename)
const LUA_KEYWORDS = new Set(["and","break","do","else","elseif","end","false","for","function","goto","if","in","local","nil","not","or","repeat","return","then","true","until","while",]);

function generateName(style, used){
  if(style==='short'){
    // a,b,c,...z,aa,ab
    let i=used.size;let s='';while(true){s=String.fromCharCode(97+(i%26))+s;i=Math.floor(i/26);if(i===0)break}return s
  }
  if(style==='hex') return 'x'+randHex(8)
  // random unicode-like
  let len=randInt(6,12);let s='';for(let i=0;i<len;i++){let code=randInt(97,122);s+=String.fromCharCode(code);}return '_'+s+randInt(0,99999)
}

function escapeForLua(s){return s.replace(/\\/g,'\\\\').replace(/"/g,'\\\"').replace(/\n/g,'\\n').replace(/\r/g,'\\r')}

// --- Obfuscation passes ---
function extractStrings(src){
  // Replace long strings and quoted strings with placeholders
  let strings=[];let out='';let i=0;while(i<src.length){
    let c=src[i];
    if(c==='\"' || c==="'" ){let q=c;let j=i+1;let buf='';while(j<src.length){if(src[j]==='\\' && j+1<src.length){buf+=src[j]+src[j+1]; j+=2; continue} if(src[j]===q){break} buf+=src[j]; j++;}
      strings.push(q+buf+q); out+=`__STR${strings.length-1}__`; i=j+1;continue}
    if(c==='[' && src[i+1]==='['){ // long bracket
      let j=i+2;let buf='';while(j<src.length){ if(src[j]===']' && src[j+1]===']'){break} buf+=src[j]; j++; }
      strings.push('[['+buf+']]'); out+=`__STR${strings.length-1}__`; i=j+2; continue }
    out+=c; i++ }
  return {src:out, strings:strings}
}

function restorePlaceholders(src, strings){
  return src.replace(/__STR(\d+)__/g,(m,n)=>strings[Number(n)])
}

function collectIdentifiers(src){
  // crude identifier matcher: words not preceded by '.' or ':' and not keywords
  let idset=new Set();
  let re=/\b([A-Za-z_][A-Za-z0-9_]*)\b/g;let m;while((m=re.exec(src))!==null){let w=m[1];if(LUA_KEYWORDS.has(w)) continue; idset.add(w)}
  return Array.from(idset)
}

function renameIdentifiers(src, style){
  // Be careful to not rename builtin functions like print, pairs, etc. We'll keep a short allowlist of common globals
  const builtin = new Set(['print','pairs','ipairs','math','string','table','tonumber','tostring','type','next','pcall','xpcall','error','select','unpack','require','coroutine','os','io','loadstring','load','setmetatable','getmetatable','rawget','rawset']);
  let ids=collectIdentifiers(src).filter(x=>!builtin.has(x));
  let map={};let used=new Set();for(let i=0;i<ids.length;i++){map[ids[i]]=generateName(document.getElementById('renameStyle').value, used); used.add(map[ids[i]])}
  // Replace word boundaries only
  let out=src.replace(/\b([A-Za-z_][A-Za-z0-9_]*)\b/g,(m,w)=>{return map[w]||m});
  return {src:out,map:map}
}

function xorEncrypt(s,key){let out='';for(let i=0;i<s.length;i++){out+=String.fromCharCode(s.charCodeAt(i) ^ key.charCodeAt(i%key.length))}return out}

function encryptStrings(strings,keyLen){
  let encrypted=[];let keys=[];
  for(let s of strings){
    // strip surrounding quotes for storage; keep markers
    let raw=s;
    let q=null; if(raw[0]==='\"' || raw[0]==="'"){q=raw[0]; raw=raw.slice(1,-1)}
    if(raw.startsWith('[[')) { raw=raw.slice(2,-2); q='[[' }
    let key='';for(let i=0;i<keyLen;i++) key+=String.fromCharCode(randInt(33,126));
    let cipher=xorEncrypt(raw,key);
    encrypted.push(base64enc(cipher)); keys.push(base64enc(key));
  }
  return {enc:encrypted,keys:keys}
}

function insertJunk(src,density){
  // insert harmless no-op blocks and misleading functions
  let lines=src.split('\n');
  let out=[];
  for(let line of lines){ out.push(line);
    if(Math.random()*100<density){ let junk='\n-- junk start\n' + generateJunkBlock() + '\n-- junk end\n'; out.push(junk)} }
  return out.join('\n')
}

function generateJunkBlock(){
  let funcs = [
    'local function '..randHex(6)..'() return nil end',
    'local function '..randHex(6)..'(a,b) local x=a or b; return x end',
  ];
  // But we can't use .. operator in JS string like that; build programmatically
  let name1='_' + randHex(6);
  let name2='_' + randHex(6);
  return `local function ${name1}()\n  return nil\nend\nlocal function ${name2}(a,b)\n  local x = a or b\n  return x\nend\n`;
}

function controlFlowFlatten(src){
  // Very simple flatten: split function bodies into table of chunks and dispatch
  // This is a gentle transform and may not preserve all edge cases. Use with caution.
  return src.replace(/function\s+([A-Za-z_][A-Za-z0-9_]*)\s*$([^)]*)$\s*(.-)\s*end/gms,(m,name,args,body)=>{
    let parts=body.split(/\n{1,}/).filter(x=>x.trim());
    if(parts.length<3) return m; // skip small functions
    let tableName = '_chunks_' + randHex(6);
    let out = `local ${tableName} = {}`;
    for(let i=0;i<parts.length;i++){ let b = parts[i].replace(/\"/g,'\\\"'); out += `\n${tableName}[${i+1}] = "${escapeForLua(parts[i])}"` }
    out += `\nlocal function ${name}(${args})\n  local i=1; while i<=#${tableName} do\n    local chunk = ${tableName}[i]\n    local f = loadstring(chunk)\n    if f then local ok = pcall(f) end\n    i=i+1\n  end\nend`;
    return out;
  })
}

function chunkSplit(src){
  // Split into pieces and build decoder that concatenates
  let size=randInt(80,220);
  let parts=[];for(let i=0;i<src.length;i+=size) parts.push(src.slice(i,i+size));
  let pieces = parts.map(p=>`\"${escapeForLua(p)}\"`).join(',\n');
  let wrapper=`(function()\n  local pieces = {\n${pieces}\n  }\n  local s=''; for i=1,#pieces do s = s .. pieces[i] end\n  local f = loadstring(s)\n  if f then return f() end\nend)()`;
  return wrapper;
}

// --- Main UI actions ---
function doObf(maxProtect){
  try{
    let src = document.getElementById('input').value;
    if(!src.trim()){alert('Paste Lua source first');return}
    // 1. extract strings
    let {src:placeholderSrc, strings} = extractStrings(src);
    // 2. rename identifiers
    let renameEnabled=document.getElementById('optRename').checked;
    let renamed={src:placeholderSrc,map:{}};
    if(renameEnabled){renamed = renameIdentifiers(placeholderSrc, document.getElementById('renameStyle').value)}
    // 3. control flow
    if(document.getElementById('optCF').checked){renamed.src = controlFlowFlatten(renamed.src)}
    // 4. insert junk
    if(document.getElementById('optJunk').checked){renamed.src = insertJunk(renamed.src, parseInt(document.getElementById('junkDensity').value))}
    // 5. restore placeholders but encrypt strings
    let keyLen = parseInt(document.getElementById('keyLen').value) || 16;
    let {enc,keys} = encryptStrings(strings,keyLen);
    // Replace placeholders with runtime decryption references: __STRi__ => __DECRYPT(i)
    let finalSrc = renamed.src.replace(/__STR(\d+)__/g,(m,n)=>`__DECRYPT__(${n})`);

    // Build runtime decoder: reconstruct encrypted strings table and keys
    let encTable = '['+enc.map(e=>`\"${e}\"`).join(',')+']';
    let keyTable = '['+keys.map(k=>`\"${k}\"`).join(',')+']';

    let decoder = `local __ENC = ${encTable}\nlocal __KEYS = ${keyTable}\nlocal function __b64(s) return (s and s:len()>0) and (require and (function() local ok,mod=pcall(require,'mime') if ok and mod then return mod.unb64(s) end; return s end)()) or s end\nlocal function __xor(s,k) local out=''; for i=1,#s do out = out .. string.char(string.byte(s,i) ~ string.byte(k,((i-1) % #k)+1)) end; return out end\nlocal function __decode_b64(s) local b=''; -- fallback base64 decode in pure lua\n  local b=''; local chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; s = s:gsub("=+$","")
  for i=1,#s,4 do
    local a = chars:find(s:sub(i,i)) or 0
    local b1 = chars:find(s:sub(i+1,i+1)) or 0
    local c = chars:find(s:sub(i+2,i+2)) or 0
    local d = chars:find(s:sub(i+3,i+3)) or 0
    local n = a*262144 + b1*4096 + c*64 + d
    local c1 = math.floor(n/65536)%256
    local c2 = math.floor(n/256)%256
    local c3 = n%256
    if c~=0 then b = b .. string.char(c1) end
    if d~=0 then b = b .. string.char(c2,c3) end
  end
  return b
end\nlocal function __DECRYPT__(i) local s = __ENC[i+1]; local k = __KEYS[i+1]; if not s then return '' end; local raw = __decode_b64(s); local dec = __xor(raw,k); return dec end\n`;

    // wrap final source so that __DECRYPT__ calls are replaced at runtime
    let wrapped = decoder + '\n' + finalSrc;
    // Optionally chunk-split
    if(document.getElementById('optSplit').checked){ wrapped = chunkSplit(wrapped) }

    // final JS-friendly output
    document.getElementById('output').value = wrapped;
  }catch(e){alert('Obfuscation failed: '+e.message)}
}

function doDeobf(){
  // Attempt to reverse what this tool produced if possible: naive approach — look for __ENC and __KEYS definitions
  try{
    let src = document.getElementById('input').value;
    if(!src.trim()){alert('Paste obfuscated source in the input area first');return}
    // Try to detect our pattern
    let encMatch = src.match(/local __ENC = \[([\s\S]*?)\]/);
    let keyMatch = src.match(/local __KEYS = \[([\s\S]*?)\]/);
    if(!encMatch || !keyMatch){alert('No recognizable encoded tables found — full reverse not guaranteed'); return}
    // parse entries
    function parseTable(inner){ let entries = inner.split(/,(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/).map(x=>x.trim()).filter(x=>x); return entries.map(e=>e.replace(/^\"|\"$/g,'')); }
    let enc = parseTable(encMatch[1]); let keys = parseTable(keyMatch[1]);
    // decode each
    let outSrc = src;
    for(let i=0;i<enc.length;i++){ let e = enc[i]; let k = keys[i]; // base64 decode in JS
      let raw = base64dec(e);
      let dec = '';
      for(let j=0;j<raw.length;j++){ dec += String.fromCharCode(raw.charCodeAt(j) ^ k.charCodeAt(j%k.length)); }
      // naive replacement: replace __DECRYPT__(i) with quoted string
      let quoted = '"' + dec.replace(/"/g,'\\"').replace(/\n/g,'\\n') + '"'; outSrc = outSrc.replace(new RegExp('__DECRYPT__\$'+i+'\$','g'), quoted);
    }
    document.getElementById('output').value = outSrc;
  }catch(e){alert('Deobfuscation failed: '+e.message)}
}

function downloadOutput(){
  let txt = document.getElementById('output').value; if(!txt) {alert('Nothing to download');return}
  let blob = new Blob([txt],{type:'text/plain'}); let url=URL.createObjectURL(blob);
  let a=document.createElement('a'); a.href=url; a.download='obfuscated.lua'; document.body.appendChild(a); a.click(); a.remove(); URL.revokeObjectURL(url);
}

// small bindings
document.getElementById('junkDensity').addEventListener('input',()=>document.getElementById('junkVal').innerText=document.getElementById('junkDensity').value);

function generateWatermark(){
  const now=new Date();
  const pad=n=>String(n).padStart(2,'0');
  const ts=`${now.getFullYear()}-${pad(now.getMonth()+1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
  const id=Math.floor(Math.random()*899999+100000);
  return `--[[Protected by Sen Lua Obsfucator V3 | ${ts} | id:${id}]]`;
}
// prepend watermark in doObf()
const _oldDoObf=doObf;
window.doObf=function(maxProtect){_oldDoObf(maxProtect);let out=document.getElementById('output').value;if(out.trim())document.getElementById('output').value=generateWatermark()+"

"+out;};


Lua Max-Protection Obfuscator (HTML)

✅ Low Risk - https://wooden-gray-bgao9epg0w-fzdrz4ip8h.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
2	43.152.26.58	Singapore	AS139341ACE
2	1	-	-

Security Scan Report: wooden-gray-bgao9epg0w-fzdrz4ip8h.edgeone.app

Summary

AI Security Verdict

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History