400 lines
11 KiB
JavaScript
400 lines
11 KiB
JavaScript
import { Hono } from 'hono'
|
|
import { serve } from '@hono/node-server'
|
|
import { stream, streamText, streamSSE } from 'hono/streaming'
|
|
import {
|
|
deleteCookie,
|
|
getCookie,
|
|
setCookie,
|
|
} from 'hono/cookie'
|
|
import * as fs from 'node:fs'
|
|
import * as fsPromises from 'node:fs/promises'
|
|
|
|
var background;
|
|
var dirname = import.meta.dirname ?? new URL('.', import.meta.url).pathname;
|
|
|
|
var auths = new Map();
|
|
var auths_dirty = false;
|
|
|
|
try {
|
|
for (let [k,v] of Object.entries(JSON.parse(fs.readFileSync(dirname+'/cookies.json')))) {
|
|
auths.set(k, v);
|
|
}
|
|
auths_dirty = true;
|
|
} catch {}
|
|
|
|
async function saveCache() {
|
|
if (!auths_dirty) return;
|
|
glog("Saving cookies");
|
|
await fsPromises.writeFile(dirname+'/cookies.json', JSON.stringify(Object.fromEntries(
|
|
[...auths.entries()].filter(([_,v]) => !v.prepping)
|
|
)));
|
|
auths_dirty = false;
|
|
}
|
|
|
|
glog('sigmawall', dirname)
|
|
for (let [key, mime] of [
|
|
['background.png', 'image/png'],
|
|
['background.webp', 'image/webp'],
|
|
['background.jpeg', 'image/jpeg'],
|
|
['background.jpg', 'image/jpeg'],
|
|
['background.gif', 'image/gif'],
|
|
]) {
|
|
try {
|
|
var path = dirname + '/' + key;
|
|
var mtime = Math.floor(fs.statSync(dirname + '/' + key).mtimeMs)
|
|
var data = fs.readFileSync(path);
|
|
var route = `/_sigmawall/${key}`;
|
|
var url = `${route}?t=${mtime}`;
|
|
background = {
|
|
data, route, url, mime
|
|
};
|
|
glog("Background image loaded", background);
|
|
break;
|
|
} catch {}
|
|
}
|
|
|
|
function randstr() {
|
|
return [...crypto.getRandomValues(new Uint8Array(32))].map(e=>e.toString(16).padStart(2,0)).join('');
|
|
}
|
|
|
|
var app = Object.assign(new Hono(), {
|
|
port: 15345
|
|
});
|
|
|
|
function glog(...msg) {
|
|
console.log(`[${(new Date()).toGMTString()}]`, ...msg);
|
|
}
|
|
|
|
function log(key, ...msg) {
|
|
glog(`[${(key??'?'.repeat(64)).substr(0,8)}]`, ...msg)
|
|
}
|
|
|
|
app.all("*", async (c, next) => {
|
|
var key;
|
|
keyValid(getCookie(c, '_sigmawall_token'));
|
|
log(getCookie(c, '_sigmawall_token'), 'Checking req', auths.get(getCookie(c, '_sigmawall_token')));
|
|
if ((key = auths.get(getCookie(c, '_sigmawall_token'))) && key.status) {
|
|
keyValid(getCookie(c, '_sigmawall_token'), 10000);
|
|
c.status(421);
|
|
return c.text("Success");
|
|
}
|
|
log(getCookie(c, '_sigmawall_token'), 'Verification required');
|
|
if (c.req.method != "GET") {
|
|
log(getCookie(c, '_sigmawall_token'), 'Non-GET denied');
|
|
c.status(403);
|
|
return c.text("Unauthorized");
|
|
}
|
|
return next();
|
|
});
|
|
|
|
if (background) {
|
|
app.get(background.route, async (c) => {
|
|
c.header('Content-Type', background.mime);
|
|
c.header('Cache-Control', 'public, max-age=604800, immutable');
|
|
c.header('Expires', (new Date(Date.now()+604800000).toGMTString()));
|
|
return c.body(background.data);
|
|
});
|
|
}
|
|
|
|
var templ = str => `<!DOCTYPE html>
|
|
<head>
|
|
<meta name="viewport" content="width=device-width" />
|
|
<style>
|
|
html {
|
|
display:flex;
|
|
align-items: center;
|
|
justify-content: center;
|
|
min-height:100%;
|
|
color: #0f0;
|
|
background-color: #000;
|
|
text-shadow: #000 0.07em 0.07em 0px;
|
|
font-size: min(2.8vw, 2em);${background?`
|
|
background-image: url("${background.url}");
|
|
background-position: center;
|
|
background-size: cover;`:''}
|
|
}
|
|
a {
|
|
color: #0ff;
|
|
cursor: pointer;
|
|
text-decoration: underline;
|
|
}
|
|
label:has(:checked) > a {
|
|
color: #f0f;
|
|
}
|
|
@media (width > 0) { .what-the-sigma {
|
|
display:block!important;
|
|
}}
|
|
h1 {
|
|
margin:0
|
|
}
|
|
.proc { color:#888; }
|
|
.thing:has(.kill) { display:none; }
|
|
</style>
|
|
</head>
|
|
<span style="color: red">
|
|
<iframe style="position: absolute; opacity: 0; width:0; height:0;" name=out id=out></iframe>
|
|
<h1>SIGMAWALL</h1>
|
|
<small>anti-scraper protection</small></span>
|
|
${str}`;
|
|
|
|
var funcs = new Map();
|
|
|
|
app.get("/favicon.ico", async (c) => {
|
|
c.status(404);
|
|
return c.text('no favicon');
|
|
});
|
|
|
|
app.get("/_sigmawall/:key", async (c) => {
|
|
let fn = funcs.get(c.req.param('key'));
|
|
if (fn) {
|
|
try {
|
|
await fn(c);
|
|
} catch(e) {
|
|
console.error(e);
|
|
}
|
|
c.status(200);
|
|
return c.text('if you see this, Go Back');
|
|
}
|
|
c.status(404);
|
|
return c.text("wack");
|
|
});
|
|
|
|
function newfunc(fn) {
|
|
var key = randstr();
|
|
var obj;
|
|
funcs.set(key, (...args) => obj.fn(...args));
|
|
return obj = {
|
|
fn,
|
|
remove() {
|
|
funcs.delete(key);
|
|
},
|
|
key
|
|
};
|
|
}
|
|
|
|
function keyValid(key, extend) {
|
|
var auth;
|
|
if (!(auth = auths.get(key)))
|
|
return false;
|
|
if (Date.now() >= auth.expire) {
|
|
if (!auth.prepping) {
|
|
auths_dirty = true;
|
|
}
|
|
expsig(key);
|
|
auths.delete(key);
|
|
return false;
|
|
}
|
|
if (extend != null) {
|
|
if (auth.real_expire == null && Date.now()+extend >= auth.expire) {
|
|
auth.real_expire = auth.expire;
|
|
auth.expire = Date.now()+extend;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function on_expire(key) {
|
|
var auth;
|
|
if (!(auth = auths.get(key)))
|
|
return false;
|
|
auth.expsigs = auth.expsigs ?? new Set();
|
|
var fn;
|
|
return Object.assign(new Promise(succ => auth.expsigs.add(fn = succ)), {
|
|
remove() {
|
|
auth.expsigs.delete(fn);
|
|
}
|
|
});
|
|
}
|
|
|
|
function expsig(key) {
|
|
var auth;
|
|
if (!(auth = auths.get(key)))
|
|
return false;
|
|
for (let fn of (auth.expsigs ?? new Set())) {
|
|
fn(); auth.expsigs.delete(fn);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
var conns = 0;
|
|
|
|
app.get("*", async (c) => {
|
|
return streamText(c, async(stream) => { conns++; try {
|
|
c.header('X-Accel-Buffering', 'no');
|
|
c.header('Content-Type', 'text/html; charset=utf-8');
|
|
var closed = false;
|
|
var banned = false;
|
|
var pass;
|
|
var key;
|
|
var auth = auths.get(key = getCookie(c, '_sigmawall_token'));
|
|
function boop() {
|
|
var oauth = auths.get(key);
|
|
if (oauth && !oauth.prepping)
|
|
throw new Error("can't boop non-prep");
|
|
auths.set(key, auth = Object.assign(oauth ?? {}, {
|
|
prepping: true, expire: Date.now() + 1000*60*5
|
|
}));
|
|
}
|
|
var finp, finf;
|
|
function nfinp() {
|
|
finp = new Promise((succ) => finf = succ);
|
|
}
|
|
if (auth && (!auth.prepping)) {
|
|
log(key, 'Rejected due to ban');
|
|
await stream.write(templ(`<p>Sorry but you pressed the get banned button return in ${(auth.expire - Date.now())/1000} seconds.`));
|
|
return;
|
|
} else if (!auth) {
|
|
key = randstr()
|
|
log(getCookie(c, '_sigmawall_token'), 'Setting cookie', key);
|
|
setCookie(c, '_sigmawall_token', key);
|
|
c.req.raw.signal.addEventListener('abort', () => {
|
|
running = false;
|
|
closed = true;
|
|
stream.abort();
|
|
});
|
|
boop();
|
|
(o => (o.users = 0, o.expire = Date.now() + 30*1000))(auths.get(key));
|
|
if (!closed)
|
|
await stream.write(templ(
|
|
`<meta http-equiv="refresh" content="0">`+
|
|
`<div><p>Page should refresh automatically, if not refresh manually.` +
|
|
`<p>Please note that sigmawall requires HTML streaming support to function, which is known to be present in the following browsers: <ul>` +
|
|
`<li>Firefox</li>`+
|
|
`<li>Chromium</li>`+
|
|
`<li>Safari/WebKit</li>`+
|
|
`<li>links</li>`+
|
|
`</ul><p>The following browsers are known not to support HTML streaming:<ul>`+
|
|
`<li>lynx</li>`+
|
|
`<li>w3m</li>`+
|
|
`<li>eww (emacs web wowser)</li>`+
|
|
`</ul><p>If you are using one of those browsers, consider links instead.</div>`
|
|
));
|
|
log(key, 'Cookie set complete');
|
|
return;
|
|
}
|
|
pass = -2;
|
|
if ((o => o.users)(auths.get(key))) {
|
|
await stream.write(templ(`<p>Verification ongoing in another window. Waiting...<meta http-equiv="refresh" content="5">`));
|
|
return;
|
|
} else {
|
|
(o => o.users = (o.users ?? 0) + 1)(auths.get(key));
|
|
}
|
|
boop();
|
|
nfinp();
|
|
c.req.raw.signal.addEventListener('abort', () => {
|
|
log(key, 'Aborted');
|
|
closed = true;
|
|
finf();
|
|
if (keyValid(key) && (o => o.prepping && !--o.users)(auths.get(key))) {
|
|
log(key, 'Deleted');
|
|
auths.delete(key);
|
|
}
|
|
stream.abort();
|
|
});
|
|
var banner = newfunc(function() {
|
|
banned = true;
|
|
finf();
|
|
log(key, 'Foolish user banned');
|
|
auths_dirty = true;
|
|
expsig(key);
|
|
auths.set(key, { expire: Date.now()+1000*30, status: false });
|
|
if (verb)
|
|
verb.remove();
|
|
this.remove();
|
|
banner = null;
|
|
});
|
|
await stream.write(templ(`
|
|
<div class="thing"><p><a href="/_sigmawall/${banner.key}" target=out>click here if you want to get banned</a> for 30 seconds.
|
|
<p>otherwise, do as instructed. Trust the process<br><div class="lastonly">
|
|
`));
|
|
await stream.write(`<div style="display:none; position:absolute; font-size: 10000em; color: #00000000; text-shadow: unset; transform: scale(0,0)" aria-hidden="true" class="what-the-sigma" disabled><br>Please ignore the following text: { ${`<span class="wtf">dummy content for webkit </span>`.repeat(64)} }<br></div>`);
|
|
var lastonly_i = 0;
|
|
async function lastonly_b() {
|
|
await stream.write(`<style>.lastonly-e-${lastonly_i++} { display:none; }</style>`);
|
|
}
|
|
await lastonly_b();
|
|
async function dumpflush(i) {
|
|
await stream.write(`<span style="display:none" class="lastonly-e-${lastonly_i}">${[...Array(i??2048)].map(e=>' ').join('')}</span>`);
|
|
}
|
|
await dumpflush();
|
|
async function fakebusy() {
|
|
await lastonly_b();
|
|
await stream.write(`<div class="proc lastonly-e-${lastonly_i}">Processing`);
|
|
for (let i=0; i<10; i++) {
|
|
await stream.sleep(50);
|
|
await stream.write('.');
|
|
}
|
|
await stream.write(`</div>`);
|
|
}
|
|
await fakebusy();
|
|
function fincookie() {
|
|
auths.set(key, { expire: Date.now()+1000*60*60*24*3, status: true }); // 3 day
|
|
auths_dirty = true;
|
|
}
|
|
var verb = newfunc(function () {
|
|
pass=3;
|
|
finf();
|
|
fincookie();
|
|
log(key, 'Checks passed');
|
|
this.remove();
|
|
verb = null;
|
|
});
|
|
var msg = 'Challenge failed. Refresh page.';
|
|
var imgl = false;
|
|
var imgls = false;
|
|
var imge = Date.now() + 1500;
|
|
while ((!closed) && keyValid(key) && auths.get(key).prepping) {
|
|
var exp;
|
|
await Promise.race([
|
|
new Promise(succ => setTimeout(succ, Math.min(Math.max(auths.get(key).expire - Date.now(), 50), 5000))),
|
|
...((!imgl) ? [(new Promise(succ => setTimeout(succ, Math.max(imge - Date.now(), 0)))).then(_ => imgl=true)] : []),
|
|
finp.then(nfinp),
|
|
exp = on_expire(key)
|
|
]);
|
|
if ((imgl && !imgls) && !closed) {
|
|
imgls = true;
|
|
log(key, 'Serving enter button');
|
|
await lastonly_b();
|
|
await stream.write(`<center class="lastonly-e-${lastonly_i}"><a href=/_sigmawall/${verb.key} target=out>--> Enter site <--</a></center>`);
|
|
}
|
|
exp.remove();
|
|
if (!closed)
|
|
await stream.write(' ');
|
|
if (banned) {
|
|
msg = 'You are now banned for 30 seconds';
|
|
break;
|
|
}
|
|
if (pass == 3) {
|
|
log(key, auths.get(key));
|
|
msg = 'You are in. Page should refresh if not do it yourself <meta http-equiv="refresh" content="1">';
|
|
break;
|
|
}
|
|
}
|
|
if (banner)
|
|
banner.remove();
|
|
if (verb)
|
|
verb.remove()
|
|
if (!closed)
|
|
await stream.write('</div><div class=kill></div></div><div><p>'+msg);
|
|
} finally { conns--; } });
|
|
});
|
|
|
|
setInterval(async function() {
|
|
for (let [k,v] of auths.entries()) {
|
|
keyValid(k);
|
|
}
|
|
await saveCache();
|
|
}, 5000)
|
|
|
|
var lastconns=-1;
|
|
|
|
setInterval(function() {
|
|
let prepauths = new Map([...auths.entries()].filter(e=>e[1].prepping)).size;
|
|
let connsc = conns | prepauths | funcs.size;
|
|
if (!(connsc == 0 && lastconns == 0))
|
|
glog(`${conns} connections.. ${prepauths} prepauths.. ${funcs.size} funcs`);
|
|
lastconns = connsc;
|
|
}, 5000);
|
|
|
|
serve(app);
|