mystiatech/GreenCoast
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: mystiatech:deployment-test
Branches Tags
mystiatech:main mystiatech:EndUserEnhancements mystiatech:deployment-test
...
compare: mystiatech:d87e9322b50938cbbd104c7078cff03804347b5d
Branches Tags
mystiatech:EndUserEnhancements mystiatech:deployment-test mystiatech:main

5 Commits
deployment ... d87e9322b5

Author SHA1 Message Date
Dani
d87e9322b5 Added example/dropin replacements for .env.example 
Fixed the issue with PlainText (Complete Anon) posting
Need to fix device sign on issues.
Need to make it so that the non-signed in devices can only see their equalivant level of posts. (i.e. plaintext, public-encrypted, private-encrypted)
 2025-08-22 22:59:05 -04:00
Dani
6a274f4259 Revert "Added the examples to .env.example" 
This reverts commit 1f2d2cf30b.
 2025-08-22 22:56:47 -04:00
Dani
1f2d2cf30b Added the examples to .env.example 
Fixed Anon Plaintext posting.
Need to fix the DeviceSignin
Changed the layout to be more Facebook-esqe
 2025-08-22 22:56:15 -04:00
Dani
fec7535c40 Added a more user friendly legalese pages 2025-08-22 20:14:45 -04:00
Dani
0bf00e3f00 Added avatars to make it a bit more friendly 2025-08-22 19:35:00 -04:00
16 changed files with 1689 additions and 1545 deletions
Expand all files Collapse all files

7
.env.example
View File

@@ -0,0 +1,7 @@
CF_TUNNEL_TOKEN=YOUR_CF_TUNNEL_TOKEN_HERE
GC_DISCORD_CLIENT_ID=YOUR_DISCORD_CLIENT_ID_HERE
GC_DISCORD_CLIENT_SECRET=YOUR_DISCORD_CLIENT_SECRET_HERE
GC_DISCORD_REDIRECT_URI=YOUR_DISCORD_REDIRECT_URI_HERE
GC_SIGNING_SECRET_HEX=YOUR_SIGNING_SECRET_HEXKEY_HERE
GC_ALLOW_ANON_PLAINTEXT=true # Enable PlainText
GC_DEV_ALLOW_UNAUTH=true # False when public

876
client/app.js
View File

@@ -1,339 +1,605 @@
import { encryptString, decryptToString, toBlob } from "./crypto.js"; // GreenCoast client — Trusted-Types safe, 3 visibility modes, PoP auth, x-post,
// plaintext publishes are anonymous (no Authorization / PoP) when enabled server-side.
// ---------- DOM ---------- const els = {};
const els = { function $(id){ return document.getElementById(id); }
shardUrl: document.getElementById("shardUrl"), function on(el, ev, fn){ if (el) el.addEventListener(ev, fn, false); }
bearer: document.getElementById("bearer"),
passphrase: document.getElementById("passphrase"),
saveConn: document.getElementById("saveConn"),
keySignIn: document.getElementById("keySignIn"),
panicWipe: document.getElementById("panicWipe"),
health: document.getElementById("health"),
visibility: document.getElementById("visibility"),
title: document.getElementById("title"),
body: document.getElementById("body"),
publish: document.getElementById("publish"),
publishStatus: document.getElementById("publishStatus"),
posts: document.getElementById("posts"),
discordStart: document.getElementById("discordStart"),
};
// ---------- Config (no bearer in localStorage) ----------
const LS_KEY = "gc_client_config_v1";
const POSTS_KEY = "gc_posts_index_v1";
function loadConfig(){ try { return JSON.parse(localStorage.getItem(LS_KEY)) ?? {}; } catch { return {}; } }
function saveConfig(c){ localStorage.setItem(LS_KEY, JSON.stringify({ url: c.url, passphrase: c.passphrase })); Object.assign(cfg, c); }
function getPosts(){ try { return JSON.parse(localStorage.getItem(POSTS_KEY)) ?? []; } catch { return []; } }
function setPosts(v){ localStorage.setItem(POSTS_KEY, JSON.stringify(v)); renderPosts(); }
function norm(u){ return (u||"").replace(/\/+$/,""); } function norm(u){ return (u||"").replace(/\/+$/,""); }
function getBearer(){ return sessionStorage.getItem("gc_bearer") || ""; } function flash(msg, ms=1800){ if(!els.flash) return; els.flash.textContent=msg; els.flash.style.display="block"; setTimeout(()=>els.flash.style.display="none", ms); }
function setBearer(tok){ if (!tok) sessionStorage.removeItem("gc_bearer"); else sessionStorage.setItem("gc_bearer", tok); els.bearer.value = tok ? "••• (session)" : ""; } function setText(el, s){ if(el) el.textContent = s; }
const cfg = loadConfig(); function currentPath(){ const h=location.hash||"#/"; const p=h.replace(/^#/, ""); return p||"/"; }
// ---------- Security helpers ---------- const HAS_SUBTLE = !!(window.isSecureContext && window.crypto && crypto.subtle && crypto.subtle.generateKey);
const enc = new TextEncoder(); const routes = { "/":"feed", "/privacy":"privacy.html", "/gdpr":"gdpr.html", "/terms":"terms.html" };
const dec = new TextDecoder();
const b64 = (u) => { let s=""; u=new Uint8Array(u); for (let i=0;i<u.length;i++) s+=String.fromCharCode(u[i]); return btoa(s).replace(/\+/g,"-").replace(/\//g,"_").replace(/=+$/,""); };
const ub64 = (s) => { s=s.replace(/-/g,"+").replace(/_/g,"/"); while(s.length%4) s+="="; const bin=atob(s); const b=new Uint8Array(bin.length); for(let i=0;i<bin.length;i++) b[i]=bin.charCodeAt(i); return b.buffer; };
async function sha256Hex(buf){ const h = await crypto.subtle.digest("SHA-256", buf); return [...new Uint8Array(h)].map(x=>x.toString(16).padStart(2,"0")).join(""); }
// Device key (P-256), stored locally (not a bearer) // ---------- Router (Trusted-Types safe text-only render of legal pages) ----------
async function getDevice() { function setActiveTab(path){
let dev = JSON.parse(localStorage.getItem('gc_device_key_v1')||'null'); const cur = path in routes ? path : "/";
if (!dev) { document.querySelectorAll(".tabs a").forEach(a=>{
const kp = await crypto.subtle.generateKey({name:"ECDSA", namedCurve:"P-256"}, true, ["sign","verify"]); const href = new URL(a.href, location.origin).hash.replace(/^#/, "") || "/";
const pkcs8 = await crypto.subtle.exportKey("pkcs8", kp.privateKey); a.classList.toggle("active", href===cur);
const rawPub = await crypto.subtle.exportKey("raw", kp.publicKey); // 65B 0x04||X||Y });
dev = { alg:"p256", priv: b64(pkcs8), pub: b64(rawPub) }; }
localStorage.setItem('gc_device_key_v1', JSON.stringify(dev)); async function renderRoute(path){
} setActiveTab(path);
return dev; const target = routes[path] ?? "feed";
if (target === "feed"){ els.page.hidden=true; els.feed.hidden=false; return; }
els.feed.hidden=true; els.page.hidden=false;
setText(els.pageContent, "Loading…");
try{
const res = await fetch("./"+target, { cache:"no-store" });
const html = await res.text();
const body = (html.match(/<body[^>]*>([\s\S]*?)<\/body>/i)?.[1] || html).replace(/<[^>]*>/g,"");
setText(els.pageContent, body);
}catch{ setText(els.pageContent, "Failed to load page."); }
} }
// Proof-of-Possession headers for this request // ---------- Config ----------
async function popHeaders(method, pathOnly, bodyBuf){ const LS_KEY="gc_client_config_v10", POSTS_KEY="gc_posts_index_v10", KEY_PKCS8="gc_key_pkcs8", KEY_PUB_RAW="gc_key_pub_raw";
const dev = await getDevice();
const ts = Math.floor(Date.now()/1000).toString();
const hashHex = await sha256Hex(bodyBuf || new Uint8Array());
const msg = enc.encode(method.toUpperCase()+"\n"+pathOnly+"\n"+ts+"\n"+hashHex);
const priv = await crypto.subtle.importKey("pkcs8", ub64(dev.priv), { name:"ECDSA", namedCurve:"P-256" }, false, ["sign"]);
const sig = await crypto.subtle.sign({ name:"ECDSA", hash:"SHA-256" }, priv, msg);
return {
"X-GC-Key": "p256:"+dev.pub,
"X-GC-TS": ts,
"X-GC-Proof": b64(sig),
};
}
// Idle timeout → clear bearer
(function idleGuard(){
let idle;
const bump=()=>{ clearTimeout(idle); idle=setTimeout(()=>setBearer(""), 30*60*1000); }; // 30 min
["click","keydown","mousemove","touchstart","focus","visibilitychange"].forEach(ev=>addEventListener(ev,bump,{passive:true}));
bump();
})();
// ---------- API base detection ----------
function defaultApiBase() { function defaultApiBase() {
try { try { const qs = new URLSearchParams(window.location.search); const qApi = qs.get("api"); if (qApi) return qApi.replace(/\/+$/,""); } catch {}
const qs = new URLSearchParams(window.location.search); const m=document.querySelector('meta[name="gc-api-base"]'); if(m&&m.content) return m.content.replace(/\/+$/,"");
const qApi = qs.get("api"); if (qApi) return qApi.replace(/\/+$/, ""); try{
} catch {} const u=new URL(window.location.href); const proto=u.protocol, host=u.hostname, portStr=u.port; const bracketHost=host.includes(":")?`[${host}]`:host;
const m = document.querySelector('meta[name="gc-api-base"]'); const port = portStr ? parseInt(portStr,10) : null; let apiPort=port;
if (m && m.content) return m.content.replace(/\/+$/, ""); if (port===8082) apiPort=8080; else if (port===9082) apiPort=9080; else if (port) apiPort=Math.max(1,port-2);
try {
const u = new URL(window.location.href);
const proto = u.protocol, host = u.hostname, portStr = u.port;
const bracketHost = host.includes(":") ? `[${host}]` : host;
const port = portStr ? parseInt(portStr, 10) : null;
let apiPort = port;
if (port === 8082) apiPort = 8080;
else if (port === 9082) apiPort = 9080;
else if (port) apiPort = Math.max(1, port - 2);
return apiPort ? `${proto}//${bracketHost}:${apiPort}` : `${proto}//${bracketHost}`; return apiPort ? `${proto}//${bracketHost}:${apiPort}` : `${proto}//${bracketHost}`;
} catch { } catch { return window.location.origin.replace(/\/+$/,""); }
return window.location.origin.replace(/\/+$/, "");
}
} }
function loadCfg(){ try { return JSON.parse(localStorage.getItem(LS_KEY)) ?? {}; } catch { return {}; } }
// ---------- App init ---------- const cfg = loadCfg();
function applyConfig(){ function saveCfg(c){ localStorage.setItem(LS_KEY, JSON.stringify(Object.assign(cfg,c))); }
function applyCfg(){
els.shardUrl.value = cfg.url ?? defaultApiBase(); els.shardUrl.value = cfg.url ?? defaultApiBase();
els.bearer.value = cfg.bearer ?? "";
els.passphrase.value = cfg.passphrase ?? ""; els.passphrase.value = cfg.passphrase ?? "";
els.bearer.value = getBearer() ? "••• (session)" : "";
} }
applyConfig(); checkHealth(); syncIndex(); sse(); function isAuthorized(){ return !!cfg.bearer; }
function updateLimitedUI(){
// ---------- UI wiring ---------- const limited = !isAuthorized();
els.saveConn.onclick = async () => { if (els.banner) els.banner.hidden = !limited;
const c = { url: norm(els.shardUrl.value), passphrase: els.passphrase.value }; for (const id of ["visibility","shareVis"]){
saveConfig(c); await checkHealth(); await syncIndex(); sse(true); const sel = $(id); if (!sel) continue;
}; for (const val of ["members","private"]){
els.publish.onclick = publish; const opt = [...sel.options].find(o => o.value===val);
els.discordStart.onclick = discordStart; if (opt) opt.disabled = limited;
els.keySignIn.onclick = keySignIn; }
els.panicWipe.onclick = panicWipe; if (limited && (sel.value==="members" || sel.value==="private")) sel.value="plaintext";
}
// Panic wipe hotkey (double-tap ESC) }
let escT=0;
addEventListener("keydown", (e) => { // ---------- Crypto helpers ----------
if (e.key === "Escape") { function b64uEncode(buf){ const bin=Array.from(new Uint8Array(buf)).map(b=>String.fromCharCode(b)).join(""); return btoa(bin).replace(/\+/g,"-").replace(/\//g,"_").replace(/=+$/,""); }
const now = Date.now(); function b64uDecodeToBytes(s){ s=s.replace(/-/g,"+").replace(/_/g,"/"); while(s.length%4) s+="="; const bin=atob(s); const out=new Uint8Array(bin.length); for(let i=0;i<bin.length;i++) out[i]=bin.charCodeAt(i); return out; }
if (now - escT < 600) panicWipe(); async function sha256(bytes){ return new Uint8Array(await crypto.subtle.digest("SHA-256", bytes)); }
escT = now; async function sha256Hex(str){ const out=await sha256(new TextEncoder().encode(str)); return Array.from(out).map(b=>b.toString(16).padStart(2,"0")).join(""); }
}
}); async function getOrCreateKeyPair(){
if (!HAS_SUBTLE) throw new Error("WebCrypto not available");
// ---------- Health / Index / SSE ---------- const pkcs8 = sessionStorage.getItem(KEY_PKCS8); const pubRaw = sessionStorage.getItem(KEY_PUB_RAW);
async function checkHealth() { if (pkcs8 && pubRaw){
if (!cfg.url) return; els.health.textContent = "Checking…"; try{
try { const r = await fetch(cfg.url + "/healthz"); els.health.textContent = r.ok ? "Connected ✔" : `Error: ${r.status}`; } const priv = await crypto.subtle.importKey("pkcs8", b64uDecodeToBytes(pkcs8), {name:"ECDSA", namedCurve:"P-256"}, true, ["sign"]);
catch { els.health.textContent = "Not reachable"; } const pub = await crypto.subtle.importKey("raw", b64uDecodeToBytes(pubRaw), {name:"ECDSA", namedCurve:"P-256"}, true, ["verify"]);
} return { priv, pub, pkcs8B64u: pkcs8, pubRawB64u: pubRaw };
}catch{}
async function syncIndex() { }
if (!cfg.url) return; const kp = await crypto.subtle.generateKey({name:"ECDSA", namedCurve:"P-256"}, true, ["sign","verify"]);
try { const pkcs8New = await crypto.subtle.exportKey("pkcs8", kp.privateKey);
const hdrs = {}; const pubRawBytes = await crypto.subtle.exportKey("raw", kp.publicKey);
const b = getBearer(); const pkcs8B64 = b64uEncode(pkcs8New); const pubRawB64 = b64uEncode(pubRawBytes);
if (b) Object.assign(hdrs, await popHeaders("GET", "/v1/index", new Uint8Array())); sessionStorage.setItem(KEY_PKCS8, pkcs8B64); sessionStorage.setItem(KEY_PUB_RAW, pubRawB64);
const r = await fetch(cfg.url + "/v1/index", { headers: Object.assign(hdrs, b?{Authorization:"Bearer "+b}:{}) }); return { priv: kp.privateKey, pub: kp.publicKey, pkcs8B64u: pkcs8B64, pubRawB64u: pubRawB64 };
if (!r.ok) throw new Error("index fetch failed"); }
const entries = await r.json(); async function deriveMembersPassphrase(saltBytes){
setPosts(entries.map(e => ({ hash:e.hash, title:"(title unknown — fetch)", bytes:e.bytes, ts:e.stored_at, enc:e.private, tz:e.creator_tz||"" }))); const kp = await getOrCreateKeyPair();
} catch(e){ console.warn("index sync failed", e); } const seed = await sha256(b64uDecodeToBytes(kp.pkcs8B64u));
} const cat = new Uint8Array(seed.length + 1 + saltBytes.length);
cat.set(seed,0); cat.set(new Uint8Array([1]), seed.length); cat.set(saltBytes, seed.length+1);
let sseCtrl; const out = await sha256(cat);
function sse(reset){ return b64uEncode(out);
if (!cfg.url) return; }
if (sseCtrl) { sseCtrl.abort(); sseCtrl = undefined; } async function deriveAesKey(passphraseB64u, saltBytes){
sseCtrl = new AbortController(); const raw = b64uDecodeToBytes(passphraseB64u);
const url = cfg.url + "/v1/index/stream"; const keyMat = await crypto.subtle.importKey("raw", raw, "PBKDF2", false, ["deriveKey"]);
const b = getBearer(); return crypto.subtle.deriveKey(
const start = async () => { { name:"PBKDF2", salt:saltBytes, iterations:120000, hash:"SHA-256" },
const hdrs = {}; keyMat, { name:"AES-GCM", length:256 }, false, ["encrypt","decrypt"]
if (b) Object.assign(hdrs, await popHeaders("GET", "/v1/index/stream", new Uint8Array()), { Authorization: "Bearer "+b }); );
fetch(url, { headers: hdrs, signal: sseCtrl.signal }).then(async resp => { }
if (!resp.ok) return; async function aesEncryptString(str, passphraseB64u){
const reader = resp.body.getReader(); const decoder = new TextDecoder(); const salt = crypto.getRandomValues(new Uint8Array(16));
let buf = ""; const key = await deriveAesKey(passphraseB64u, salt);
while (true) { const iv = crypto.getRandomValues(new Uint8Array(12));
const { value, done } = await reader.read(); if (done) break; const ct = new Uint8Array(await crypto.subtle.encrypt({name:"AES-GCM", iv}, key, new TextEncoder().encode(str)));
buf += decoder.decode(value, { stream:true }); return { alg:"aes-256-gcm", iv:b64uEncode(iv), salt:b64uEncode(salt), ct:b64uEncode(ct) };
let idx; while ((idx = buf.indexOf("\n\n")) >= 0) { }
const chunk = buf.slice(0, idx); buf = buf.slice(idx+2); async function aesDecryptToString(obj, passphraseB64u){
if (chunk.startsWith("data: ")) { const key = await deriveAesKey(passphraseB64u, b64uDecodeToBytes(obj.salt));
try { const pt = await crypto.subtle.decrypt({name:"AES-GCM", iv:b64uDecodeToBytes(obj.iv)}, key, b64uDecodeToBytes(obj.ct));
const ev = JSON.parse(chunk.slice(6)); return new TextDecoder().decode(pt);
if (ev.event === "put") { }
const e = ev.data; function makeEnvelope(mode, encObj, meta){ return JSON.stringify({ gc:"2", mode, enc:encObj, meta }); }
const posts = getPosts(); function tryParseJSON(t){ try{ return JSON.parse(t); }catch{ return null; } }
if (!posts.find(p => p.hash === e.hash)) {
posts.unshift({ hash:e.hash, title:"(title unknown — fetch)", bytes:e.bytes, ts:e.stored_at, enc:e.private, tz:e.creator_tz||"" }); // ---------- Avatar ----------
setPosts(posts); function parseGC2(tok){ try{ const p=tok.split("."); if(p.length!==3) return {}; const pl=JSON.parse(atob(p[1].replace(/-/g,"+").replace(/_/g,"/"))); return {sub:pl.sub||"", cnf:pl.cnf||""}; }catch{ return {}; } }
} function identiconPNGFromHex(hex, size=64){
} else if (ev.event === "delete") { const cells=5, cell=Math.floor(size/cells), pad=Math.floor((size-cell*cells)/2);
const h = ev.data.hash; setPosts(getPosts().filter(p => p.hash !== h)); const hexBytes=(h)=>{const u=new Uint8Array(h.length/2); for(let i=0;i<u.length;i++) u[i]=parseInt(h.substr(i*2,2),16); return u;};
} const b=hexBytes(hex); const hue=b[0]/255*360; const bg=`hsl(${hue},35%,16%)`; const fg=`hsl(${(hue+180)%360},70%,60%)`;
} catch {} const bits=[]; for(const x of b) for(let i=0;i<8;i++) bits.push((x>>i)&1);
} const c=document.createElement("canvas"); c.width=c.height=size; const g=c.getContext("2d");
} g.fillStyle=bg; g.fillRect(0,0,size,size); let k=0;
} for(let y=0;y<cells;y++){ for(let x=0;x<3;x++){ if(bits[k++]===1){ const px=pad+x*cell, py=pad+y*cell;
}).catch(()=>{}); g.fillStyle=fg; g.fillRect(px,py,cell-1,cell-1); const mx=pad+(cells-1-x)*cell; if(cells-1-x!==x) g.fillRect(mx,py,cell-1,cell-1); } } }
}; return c.toDataURL("image/png");
start(); }
} async function renderAvatar(){
if (!els.avatar) return;
// ---------- Auth ---------- let seed=null, label="(pseudonymous)";
async function keySignIn(){ if (cfg.bearer){ const p=parseGC2(cfg.bearer); seed=p.cnf||p.sub||null; if(p.sub) label=p.sub; }
try { if (!seed){ els.avatar.removeAttribute("src"); setText(els.fp,"(pseudonymous)"); return; }
if (!cfg.url) { alert("Set shard URL first."); return; } const hex = await sha256Hex(seed);
// 1) challenge els.avatar.onerror = ()=>{ els.avatar.removeAttribute("src"); setText(els.fp,"(pseudonymous)"); };
const cResp = await fetch(cfg.url + "/v1/auth/key/challenge", { method:"POST" }); els.avatar.src=identiconPNGFromHex(hex, 64);
const cTxt = await cResp.text(); setText(els.fp, label+" (pseudonymous)");
if (!cResp.ok) { alert("Challenge failed: " + cTxt); return; } }
const c = JSON.parse(cTxt);
// 2) sign and verify // ---------- Auth / PoP ----------
const dev = await getDevice(); async function requireChallengeAlive(base) {
const priv = await crypto.subtle.importKey("pkcs8", ub64(dev.priv), { name:"ECDSA", namedCurve:"P-256" }, false, ["sign"]); try {
const msg = enc.encode("key-verify\n" + c.nonce); const r = await fetch(base + "/v1/auth/key/challenge", { method: "POST" });
const sig = await crypto.subtle.sign({ name:"ECDSA", hash:"SHA-256" }, priv, msg); if (r.status === 404) {
const vResp = await fetch(cfg.url + "/v1/auth/key/verify", { alert(
method:"POST", "Shard URL looks wrong: /v1/auth/key/challenge not found.\n\n" +
headers: { "Content-Type":"application/json" }, "Current base:\n" + base + "\n\n" +
body: JSON.stringify({ nonce:c.nonce, alg:"p256", pub: dev.pub, sig: b64(sig) }) "Set it to your API host (e.g. https://api-gc.fullmooncyberworks.com) and Save."
}); );
const vTxt = await vResp.text(); return false;
if (!vResp.ok) { alert("Verify failed: " + vTxt); return; } }
const j = JSON.parse(vTxt); return r.ok;
setBearer(j.bearer); } catch {
alert("Signed in ✔ (session)"); alert("Cannot reach shard at: " + base);
await syncIndex(); return false;
} catch (e) { }
alert("Key sign-in exception: " + (e?.message || e)); }
}
} async function deviceKeySignIn(){
if (!HAS_SUBTLE) { alert("Device keys not supported. Use Discord or a modern browser."); return; }
async function panicWipe(){ const base = cfg.url || defaultApiBase(); if (!base){ alert("Set shard URL first."); return; }
try { if (!(await requireChallengeAlive(base))) return;
if (cfg.url) await fetch(cfg.url + "/v1/session/clear", { method:"POST" }); flash("Signing in…");
} catch {} try{
sessionStorage.clear(); const { priv, pubRawB64u } = await getOrCreateKeyPair();
localStorage.clear(); const rc = await fetch(base + "/v1/auth/key/challenge", { method:"POST" });
caches && caches.keys().then(keys => keys.forEach(k => caches.delete(k))); if (!rc.ok) throw new Error("challenge "+rc.status);
location.replace("about:blank"); const cj = await rc.json();
} const msg = new TextEncoder().encode("key-verify\n"+cj.nonce);
const sig = await crypto.subtle.sign({name:"ECDSA", hash:"SHA-256"}, priv, msg);
// ---------- Publishing / Viewing ---------- const body = JSON.stringify({ nonce:cj.nonce, alg:"p256", pub:pubRawB64u, sig:b64uEncode(sig) });
function msg(t, err=false){ els.publishStatus.textContent=t; els.publishStatus.style.color = err ? "#ff6b6b" : "inherit"; } const rv = await fetch(base + "/v1/auth/key/verify", { method:"POST", headers:{"Content-Type":"application/json"}, body });
if (!rv.ok) throw new Error("verify "+rv.status);
async function publish() { const vj = await rv.json();
if (!cfg.url) return msg("Set shard URL first.", true); saveCfg({ bearer: vj.bearer }); applyCfg(); updateLimitedUI();
const b = getBearer(); if (!b) return msg("Sign in first (device key).", true); await renderAvatar(); await checkHealth(); await syncIndex(); sse(true); flash("Signed in");
}catch(e){ console.error(e); alert("Sign-in error: "+(e?.message||e)); }
const title = els.title.value.trim(); }
const body = els.body.value;
const vis = els.visibility.value; async function signPoPHeaders(method, pathOnly, bodyBytes){
try { if (!HAS_SUBTLE) return {};
let blob, encp=false; const pubRaw = sessionStorage.getItem(KEY_PUB_RAW); const pkcs8 = sessionStorage.getItem(KEY_PKCS8);
if (vis === "private") { if (!pubRaw || !pkcs8) return {};
if (!cfg.passphrase) return msg("Set a passphrase for private posts.", true); const priv = await crypto.subtle.importKey("pkcs8", b64uDecodeToBytes(pkcs8), {name:"ECDSA", namedCurve:"P-256"}, false, ["sign"]);
const payload = await encryptString(JSON.stringify({ title, body }), cfg.passphrase); const bodyHash = new Uint8Array(await crypto.subtle.digest("SHA-256", bodyBytes || new Uint8Array()));
blob = toBlob(payload); encp=true; const hex = Array.from(bodyHash).map(b=>b.toString(16).padStart(2,"0")).join("");
} else { const ts = Math.floor(Date.now()/1000).toString();
blob = toBlob(JSON.stringify({ title, body })); const msg = new TextEncoder().encode(method.toUpperCase()+"\n"+pathOnly+"\n"+ts+"\n"+hex);
const sig = await crypto.subtle.sign({name:"ECDSA", hash:"SHA-256"}, priv, msg);
return { "X-GC-Key":"p256:"+pubRaw, "X-GC-TS":ts, "X-GC-Proof":b64uEncode(sig) };
}
async function fetchWithPoP(url, opts){
const u = new URL(url); const path = u.pathname; const method = (opts?.method||"GET").toUpperCase();
const bodyBuf = opts?.body instanceof Blob ? new Uint8Array(await opts.body.arrayBuffer())
: (opts?.body instanceof ArrayBuffer ? new Uint8Array(opts.body) : new Uint8Array());
const pop = await signPoPHeaders(method, path, bodyBuf);
const headers = new Headers(opts?.headers||{});
if (cfg.bearer) headers.set("Authorization", "Bearer "+cfg.bearer);
for (const [k,v] of Object.entries(pop)) headers.set(k,v);
return fetch(url, { ...(opts||{}), headers });
}
// Anonymous fetch: strip any auth/PoP headers completely (for plaintext writes)
function stripAuthHeaders(h){ h.delete("Authorization"); h.delete("X-GC-Key"); h.delete("X-GC-TS"); h.delete("X-GC-Proof"); return h; }
async function fetchAnon(url, opts){
const headers = new Headers(opts?.headers || {});
return fetch(url, { ...(opts||{}), headers: stripAuthHeaders(headers) });
}
// ---------- Leak detection ----------
const SECRET_PATTERNS = [
/\b(passphrase|password|secret|gc[-_ ]?pass|shared[-_ ]?key)\s*[:=]\s*[^\s]{8,}/i,
/\b(ASIA|AKIA|AIza)[0-9A-Za-z_\-]{10,}/,
/\b[A-Za-z0-9+/_-]{32,}={0,2}\b/,
/\b[0-9a-f]{64,}\b/i,
/-----BEGIN [A-Z ]{5,}-----[\s\S]+?-----END [A-Z ]{5,}-----/
];
function containsSecret(text, passphrase){
if (!text) return false;
if (passphrase && passphrase.length>=6 && text.includes(passphrase)) return true;
return SECRET_PATTERNS.some(rx => rx.test(text));
}
// ---------- X-post helpers ----------
const TRACKING_PARAMS = [/^utm_/i,/^gclid$/i,/^fbclid$/i,/^msclkid$/i,/^mc_(eid|cid)$/i,/^vero_id$/i,/^oly_(anon|enc)_id$/i,/^_hs(enc|mi|mi)/i,/^s?cid$/i,/^igshid$/i,/^ttclid$/i,/^spm$/i,/^ref$/i,/^ref_src$/i,/^ref_url$/i];
function sanitizeUrl(input){
try{
const u = new URL(input.trim());
for (const [k] of u.searchParams){ if (TRACKING_PARAMS.some(rx=>rx.test(k))) u.searchParams.delete(k); }
u.hash = "";
return u.toString();
}catch{ return ""; }
}
function shortHost(h){ try{ const p=h.split("."); return p.length>2 ? p.slice(-2).join(".") : h; }catch{ return h; } }
function renderXCard(container, cleanUrl, note){
container.replaceChildren();
if (!cleanUrl){ const m=document.createElement("div"); m.className="xmeta"; m.textContent="Enter a valid URL."; container.appendChild(m); return; }
const u = new URL(cleanUrl);
const row = document.createElement("div"); row.className="xrow";
const pill = document.createElement("span"); pill.className="xpill"; pill.textContent=shortHost(u.hostname);
const title = document.createElement("span"); title.className="xtitle"; title.textContent=note || `${shortHost(u.hostname)} link`;
row.appendChild(pill); row.appendChild(title);
const meta = document.createElement("div"); meta.className="xmeta"; meta.textContent=(u.pathname||"/")+(u.search||"");
const btn = document.createElement("div"); btn.className="xbtn";
const a = document.createElement("a"); a.href=cleanUrl; a.target="_blank"; a.rel="noreferrer noopener"; a.referrerPolicy="no-referrer"; a.textContent="Open privately ↗";
btn.appendChild(a);
container.appendChild(row); container.appendChild(meta); container.appendChild(btn);
}
// ---------- Compose / Publish ----------
function msg(t, err=false){ setText(els.publishStatus, t); els.publishStatus.style.color = err ? "#ff6b6b" : "#8b949e"; }
async function publish(){
const base = cfg.url || defaultApiBase(); if (!base) return msg("Set shard URL first.", true);
const mode = els.visibility.value; // plaintext | members | private
const title = els.title.value.trim();
const body = els.body.value;
if ((mode==="members"||mode==="private") && !isAuthorized()){ msg("Authorize your device to publish encrypted posts.", true); return; }
const currentPass = els.passphrase.value.trim();
if (containsSecret(body, currentPass)){ msg("Blocked: content appears to include a passkey/secret.", true); return; }
try{
let blob, headers={"Content-Type":"application/octet-stream"}, enc=false;
if (mode==="plaintext"){
blob = new Blob([JSON.stringify({ title, body, type:"plaintext" })], {type:"application/json"});
} else if (mode==="members"){
const salt = crypto.getRandomValues(new Uint8Array(16));
const pp = await deriveMembersPassphrase(salt);
const encObj = await aesEncryptString(JSON.stringify({ title, body, type:"members" }), pp);
const env = makeEnvelope("members", encObj, { tz: Intl.DateTimeFormat().resolvedOptions().timeZone || "" });
blob = new Blob([env], {type:"application/json"}); headers["X-GC-Private"]="1"; enc=true;
} else if (mode==="private"){
if (!currentPass) return msg("Set a passphrase for Private-Encrypted posts.", true);
const pp = b64uEncode(new TextEncoder().encode(currentPass));
const encObj = await aesEncryptString(JSON.stringify({ title, body, type:"private" }), pp);
const env = makeEnvelope("private", encObj, { tz: Intl.DateTimeFormat().resolvedOptions().timeZone || "" });
blob = new Blob([env], {type:"application/json"}); headers["X-GC-Private"]="1"; enc=true;
}
const tz = Intl.DateTimeFormat().resolvedOptions().timeZone; if (tz) headers["X-GC-TZ"]=tz;
const url = base + "/v1/object";
let r;
if (mode === "plaintext") {
// truly anonymous write (requires allow_anon_plaintext on shard)
r = await fetchAnon(url, { method:"PUT", headers, body: blob });
} else {
r = await fetchWithPoP(url, { method:"PUT", headers, body: blob });
} }
const buf = new Uint8Array(await blob.arrayBuffer());
const path = "/v1/object";
const headers = { "Content-Type":"application/octet-stream", Authorization: "Bearer "+b };
if (encp) headers["X-GC-Private"] = "1";
const pop = await popHeaders("PUT", path, buf);
Object.assign(headers, pop);
const r = await fetch(cfg.url + path, { method:"PUT", headers, body: buf });
if (!r.ok) throw new Error(await r.text()); if (!r.ok) throw new Error(await r.text());
const j = await r.json(); const j = await r.json();
const posts = getPosts(); const posts = getPosts();
posts.unshift({ hash:j.hash, title: title || "(untitled)", bytes:j.bytes, ts:j.stored_at, enc:j.private, tz:j.creator_tz||"" }); posts.unshift({ hash:j.hash, title: title || (enc?"(encrypted)":"(untitled)"), bytes:j.bytes, ts:j.stored_at, enc, mode, author:j.author||null, tz:j.creator_tz||null });
setPosts(posts); setPosts(posts);
els.body.value = ""; msg(`Published ${encp?"private":"public"} post. Hash: ${j.hash}`); els.body.value="";
} catch(e){ msg("Publish failed: " + (e?.message||e), true); } msg(`Published ${mode}. Hash: ${j.hash}`);
}catch(e){ msg("Publish failed: "+(e?.message||e), true); }
} }
async function viewPost(p, pre) { async function publishShare(){
pre.textContent = "Loading…"; const base = cfg.url || defaultApiBase(); if (!base) return alert("Set shard URL first.");
try { const clean = sanitizeUrl(els.shareUrl.value); if (!clean) return alert("Enter a valid URL.");
const path = "/v1/object/" + p.hash;
const headers = {}; const mode = els.shareVis.value;
const b = getBearer(); const note = els.shareNote.value || "";
if (b) Object.assign(headers, await popHeaders("GET", path, new Uint8Array()), { Authorization: "Bearer "+b });
const r = await fetch(cfg.url + path, { headers }); if ((mode==="members"||mode==="private") && !isAuthorized()){ alert("Authorize your device to publish encrypted links."); return; }
if (!r.ok) throw new Error("fetch failed " + r.status); if (containsSecret(note, els.passphrase.value.trim())){ alert("Blocked: content appears to include a passkey/secret."); return; }
try{
let blob, headers={"Content-Type":"application/octet-stream"}, enc=false;
if (mode==="plaintext"){
blob = new Blob([JSON.stringify({ type:"xpost", url: clean, note, created_at:new Date().toISOString() })], {type:"application/json"});
} else if (mode==="members"){
const salt = crypto.getRandomValues(new Uint8Array(16));
const pp = await deriveMembersPassphrase(salt);
const encObj = await aesEncryptString(JSON.stringify({ type:"xpost", url: clean, note, created_at:new Date().toISOString() }), pp);
const env = makeEnvelope("members", encObj, { tz: Intl.DateTimeFormat().resolvedOptions().timeZone || "" });
blob = new Blob([env], {type:"application/json"}); headers["X-GC-Private"]="1"; enc=true;
} else {
const pass = els.passphrase.value.trim(); if (!pass) return alert("Set a passphrase for Private-Encrypted links.");
const pp = b64uEncode(new TextEncoder().encode(pass));
const encObj = await aesEncryptString(JSON.stringify({ type:"xpost", url: clean, note, created_at:new Date().toISOString() }), pp);
const env = makeEnvelope("private", encObj, { tz: Intl.DateTimeFormat().resolvedOptions().timeZone || "" });
blob = new Blob([env], {type:"application/json"}); headers["X-GC-Private"]="1"; enc=true;
}
const tz = Intl.DateTimeFormat().resolvedOptions().timeZone; if (tz) headers["X-GC-TZ"]=tz;
const url = base + "/v1/object";
let r;
if (mode === "plaintext") {
r = await fetchAnon(url, { method:"PUT", headers, body: blob });
} else {
r = await fetchWithPoP(url, { method:"PUT", headers, body: blob });
}
if (!r.ok) throw new Error(await r.text());
const j = await r.json();
const posts = getPosts();
posts.unshift({ hash:j.hash, title:"(link)", bytes:j.bytes, ts:j.stored_at, enc, mode, author:j.author||null, tz:j.creator_tz||null });
setPosts(posts);
els.shareUrl.value=""; els.shareNote.value="";
renderXCard(els.shareCard, "", "");
flash("Link published");
}catch(e){ alert("Publish failed: "+(e?.message||e)); }
}
// ---------- View / Decrypt ----------
async function viewPost(p, pre){
const base = cfg.url || defaultApiBase(); pre.textContent="Loading…";
try{
const r = await fetch(base + "/v1/object/"+p.hash);
if (!r.ok) throw new Error("fetch failed "+r.status);
const buf = new Uint8Array(await r.arrayBuffer()); const buf = new Uint8Array(await r.arrayBuffer());
let text; const text = new TextDecoder().decode(buf);
if (p.enc) {
if (!cfg.passphrase) throw new Error("passphrase required"); const env = tryParseJSON(text);
text = await decryptToString(buf, cfg.passphrase); if (env && env.gc==="2" && env.enc && env.mode){
} else { text = new TextDecoder().decode(buf); } const enc = env.enc; let pt;
try { if (env.mode==="members"){
const j = JSON.parse(text); if (!HAS_SUBTLE) throw new Error("Cannot decrypt on this browser.");
pre.textContent = (j.title ? `# ${j.title}\n\n` : "") + (j.body ?? text); const pp = await deriveMembersPassphrase(b64uDecodeToBytes(enc.salt));
} catch { pre.textContent = text; } pt = await aesDecryptToString(enc, pp);
} catch (e) { pre.textContent = "Error: " + (e?.message || e); } } else if (env.mode==="private"){
const pass = els.passphrase.value.trim(); if (!pass) throw new Error("Passphrase required");
const pp = b64uEncode(new TextEncoder().encode(pass));
pt = await aesDecryptToString(enc, pp);
} else { throw new Error("Unknown mode"); }
const j = tryParseJSON(pt);
if (j && j.type==="xpost" && j.url){
const wrap = pre.parentElement; const card = document.createElement("div"); card.className="xcard";
renderXCard(card, sanitizeUrl(j.url), j.note||""); wrap.replaceChild(card, pre); return;
}
pre.textContent = (j?.title?`# ${j.title}\n\n`:"") + (j?.body ?? pt);
return;
}
const j = tryParseJSON(text);
if (j){
if (j.type==="xpost" && j.url){
const wrap = pre.parentElement; const card = document.createElement("div"); card.className="xcard";
renderXCard(card, sanitizeUrl(j.url), j.note||""); wrap.replaceChild(card, pre); return;
}
pre.textContent = (j.title?`# ${j.title}\n\n`:"") + (j.body ?? text);
return;
}
pre.textContent = text;
}catch(e){ pre.textContent="Error: "+(e?.message||e); }
} }
async function saveBlob(p) { async function saveBlob(p){
const path = "/v1/object/" + p.hash; const base = cfg.url || defaultApiBase();
const headers = {}; const r = await fetch(base + "/v1/object/"+p.hash);
const b = getBearer(); if (!r.ok) return alert("download failed "+r.status);
if (b) Object.assign(headers, await popHeaders("GET", path, new Uint8Array()), { Authorization: "Bearer "+b }); const b = await r.blob(); const a=document.createElement("a"); a.href=URL.createObjectURL(b);
const r = await fetch(cfg.url + path, { headers }); a.download=p.hash+(p.enc?".gcenc":".json"); a.click(); URL.revokeObjectURL(a.href);
if (!r.ok) return alert("download failed " + r.status);
const bl = await r.blob();
const a = document.createElement("a"); a.href = URL.createObjectURL(bl);
a.download = p.hash + (p.enc ? ".gcenc" : ".json"); a.click(); URL.revokeObjectURL(a.href);
} }
async function delServer(p){
async function delServer(p) { const base = cfg.url || defaultApiBase();
const path = "/v1/object/" + p.hash;
const b = getBearer(); if (!b) return alert("Sign in first.");
const headers = { Authorization: "Bearer "+b };
Object.assign(headers, await popHeaders("DELETE", path, new Uint8Array()));
if (!confirm("Delete blob from server by hash?")) return; if (!confirm("Delete blob from server by hash?")) return;
const r = await fetch(cfg.url + path, { method:"DELETE", headers }); const r = await fetchWithPoP(base + "/v1/object/"+p.hash, { method:"DELETE" });
if (!r.ok) return alert("delete failed " + r.status); if (!r.ok) return alert("delete failed "+r.status);
setPosts(getPosts().filter(x=>x.hash!==p.hash)); setPosts(getPosts().filter(x=>x.hash!==p.hash));
} }
// ---------- Discord SSO ---------- // ---------- Index / SSE / Health ----------
async function discordStart() { function getPosts(){ try { return JSON.parse(localStorage.getItem(POSTS_KEY)) ?? []; } catch { return []; } }
if (!cfg.url) { alert("Set shard URL first."); return; } function setPosts(v){ localStorage.setItem(POSTS_KEY, JSON.stringify(v)); renderPosts(); }
const r = await fetch(cfg.url + "/v1/auth/discord/start", { headers: { "X-GC-3P-Assent":"1" }}); async function syncIndex(){
if (!r.ok) { alert("Discord SSO not available"); return; } const base = cfg.url || defaultApiBase(); if (!base) return;
const j = await r.json(); try{
location.href = j.url; const r = await fetch(base + "/v1/index");
if (!r.ok) throw new Error("index fetch failed");
const entries = await r.json();
setPosts(entries.map(e=>({
hash:e.hash, title:"(title unknown — fetch)", bytes:e.bytes, ts:e.stored_at,
enc:e.private, mode: e.private ? "encrypted" : "plaintext",
author:e.author||null, tz:e.creator_tz||null
})));
}catch(e){ console.warn("index sync failed", e); }
}
let sseCtrl;
function sse(reset=false){
const base = cfg.url || defaultApiBase(); if (!base) return;
if (sseCtrl){ sseCtrl.abort(); sseCtrl=undefined; if(!reset) return; }
sseCtrl = new AbortController();
fetch(base + "/v1/index/stream", { signal:sseCtrl.signal }).then(async resp=>{
if (!resp.ok) return;
const reader = resp.body.getReader(); const dec = new TextDecoder(); let buf="";
while(true){ const {value,done}=await reader.read(); if(done) break;
buf += dec.decode(value,{stream:true});
let i; while((i=buf.indexOf("\n\n"))>=0){
const chunk=buf.slice(0,i); buf=buf.slice(i+2);
if (chunk.startsWith("data: ")){
try{
const ev = JSON.parse(chunk.slice(6));
if (ev.event==="put"){
const e=ev.data; const posts=getPosts();
if (!posts.find(p=>p.hash===e.hash)){
posts.unshift({hash:e.hash,title:"(title unknown — fetch)",bytes:e.bytes,ts:e.stored_at,enc:e.private,mode:e.private?"encrypted":"plaintext",author:e.author||null,tz:e.creator_tz||null});
setPosts(posts);
}
} else if (ev.event==="delete"){
const h=ev.data.hash; setPosts(getPosts().filter(x=>x.hash!==h));
}
}catch{}
}
}
}
}).catch(()=>{});
}
async function checkHealth(){
const base = cfg.url || defaultApiBase();
if (!base) { setText(els.health,"Set URL"); return; }
setText(els.health,"Checking…");
try { const r = await fetch(base + "/healthz"); setText(els.health, r.ok ? "Connected ✔" : `Error: ${r.status}`); }
catch { setText(els.health,"Not reachable"); }
} }
// ---------- Render ---------- // ---------- Render posts (no innerHTML) ----------
function renderPosts() { function renderPosts() {
const posts = getPosts(); els.posts.innerHTML = ""; const posts = getPosts();
const root = els.posts;
if (!root) return;
while (root.firstChild) root.removeChild(root.firstChild);
for (const p of posts) { for (const p of posts) {
const div = document.createElement("div"); div.className = "post"; const wrap = document.createElement("div");
const badge = p.enc ? `<span class="badge">private</span>` : `<span class="badge">public</span>`; wrap.className = "post";
div.innerHTML = `
<div class="meta"><code>${p.hash.slice(0,10)}…</code> · ${p.bytes} bytes · ${p.ts} ${badge}</div> const meta = document.createElement("div");
<div class="actions"> meta.className = "meta";
<button data-act="view">View</button>
<button data-act="save">Save blob</button> const codeEl = document.createElement("code");
<button data-act="delete">Delete (server)</button> codeEl.textContent = `${p.hash.slice(0, 10)}…`;
<button data-act="remove">Remove (local)</button> meta.appendChild(codeEl);
</div>
<pre class="content"></pre>`; const metaText = [
const pre = div.querySelector(".content"); ` · ${p.bytes} bytes`,
div.querySelector('[data-act="view"]').onclick = () => viewPost(p, pre); ` · ${p.ts}`,
div.querySelector('[data-act="save"]').onclick = () => saveBlob(p); p.tz ? ` · tz:${p.tz}` : "",
div.querySelector('[data-act="delete"]').onclick = () => delServer(p); p.author ? ` · by ${p.author.slice(0, 8)}…` : "",
div.querySelector('[data-act="remove"]').onclick = () => { setPosts(getPosts().filter(x=>x.hash!==p.hash)); }; " "
els.posts.appendChild(div); ].join("");
meta.appendChild(document.createTextNode(metaText));
const badge = document.createElement("span");
badge.className = "badge";
badge.textContent = p.enc ? (p.mode==="private"?"private":"encrypted") : "plaintext";
meta.appendChild(badge);
wrap.appendChild(meta);
const actions = document.createElement("div");
actions.className = "actions";
const mkBtn = (label, onClick) => {
const b = document.createElement("button");
b.type = "button";
b.textContent = label;
b.addEventListener("click", onClick);
return b;
};
const pre = document.createElement("pre");
pre.className = "content";
pre.style.whiteSpace = "pre-wrap";
pre.style.marginTop = ".5rem";
actions.appendChild(mkBtn("View", () => viewPost(p, pre)));
actions.appendChild(mkBtn("Save blob", () => saveBlob(p)));
actions.appendChild(mkBtn("Delete (server)", () => delServer(p)));
actions.appendChild(mkBtn("Remove (local)", () => {
setPosts(getPosts().filter((x) => x.hash !== p.hash));
}));
wrap.appendChild(actions);
const contentWrap = document.createElement("div");
contentWrap.className = "content-wrap";
contentWrap.appendChild(pre);
wrap.appendChild(contentWrap);
root.appendChild(wrap);
} }
} }
// ---------- Save/Init ----------
async function onSaveConn(){
const c = { url: norm(els.shardUrl.value || defaultApiBase()), bearer: els.bearer.value.trim(), passphrase: els.passphrase.value };
saveCfg(c); flash("Saved");
updateLimitedUI(); await checkHealth(); await syncIndex(); sse(true); await renderAvatar();
}
async function panicWipe(){
flash("Wiping local state…");
try { const base = cfg.url || defaultApiBase(); if (base) await fetch(base + "/v1/session/clear", { method:"POST" }); } catch {}
localStorage.clear(); sessionStorage.clear(); caches?.keys?.().then(keys => keys.forEach(k => caches.delete(k)));
flash("Cleared — reloading"); setTimeout(()=>location.reload(), 300);
}
async function discordStart(){
const base = cfg.url || defaultApiBase(); if (!base){ alert("Set shard URL first."); return; }
const r = await fetch(base + "/v1/auth/discord/start", { headers: { "X-GC-3P-Assent":"1" }});
if (!r.ok){ alert("Discord SSO not available"); return; }
const j = await r.json(); location.href = j.url;
}
// ---------- Boot ----------
window.addEventListener("DOMContentLoaded", () => {
Object.assign(els, {
shardUrl:$("shardUrl"), bearer:$("bearer"), passphrase:$("passphrase"),
saveConn:$("saveConn"), health:$("health"), visibility:$("visibility"),
title:$("title"), body:$("body"), publish:$("publish"), publishStatus:$("publishStatus"),
posts:$("posts"), discordStart:$("discordStart"), signIn:$("signIn"), panic:$("panic"),
avatar:$("avatar"), fp:$("fp"), flash:$("flash"), banner:$("banner"),
feed:$("feed"), page:$("page"), pageContent:$("pageContent"),
shareUrl:$("shareUrl"), shareNote:$("shareNote"), shareVis:$("shareVis"),
sharePreview:$("sharePreview"), sharePublish:$("sharePublish"), shareCard:$("shareCard")
});
on(els.saveConn, "click", onSaveConn);
on(els.publish, "click", publish);
on(els.discordStart, "click", discordStart);
on(els.signIn, "click", deviceKeySignIn);
on(els.panic, "click", panicWipe);
on(els.sharePreview, "click", ()=>renderXCard(els.shareCard, sanitizeUrl(els.shareUrl.value), els.shareNote.value));
on(els.sharePublish, "click", publishShare);
window.addEventListener('hashchange', ()=>renderRoute(currentPath()));
if (!HAS_SUBTLE) {
const cap = $("capWarn");
if (cap){
cap.hidden=false;
cap.textContent = "This browser lacks secure WebCrypto. Device-key and members-encrypted posts require a modern browser over HTTPS. Discord sign-in remains available.";
}
if (els.signIn){ els.signIn.disabled = true; els.signIn.textContent = "Device key not supported"; }
}
applyCfg(); updateLimitedUI();
(async () => { await checkHealth(); await syncIndex(); sse(); await renderAvatar(); })();
renderRoute(currentPath());
flash("GC client loaded");
});

44
client/avatar.js Normal file
View File

@@ -0,0 +1,44 @@
// Deterministic, local-only avatars. No network calls.
export function avatarDataURL(seed, size = 40) {
// Hash seed → bytes
const h = sha256(seed);
// Colors from bytes
const hue = h[0] % 360;
const bg = `hsl(${(h[1]*3)%360} 25% 14%)`;
const fg = `hsl(${hue} 70% 60%)`;
// 5x5 grid mirrored; draw squares where bits set
const cells = 5, scale = Math.floor(size / cells);
let rects = "";
for (let y = 0; y < cells; y++) {
for (let x = 0; x < Math.ceil(cells/2); x++) {
const bit = (h[(y*3 + x) % h.length] >> (y % 5)) & 1;
if (bit) {
const xL = x*scale, xR = (cells-1-x)*scale, yP = y*scale;
rects += `<rect x="${xL}" y="${yP}" width="${scale}" height="${scale}" rx="2" ry="2" fill="${fg}"/>`;
if (x !== cells-1-x) {
rects += `<rect x="${xR}" y="${yP}" width="${scale}" height="${scale}" rx="2" ry="2" fill="${fg}"/>`;
}
}
}
}
const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${cells*scale} ${cells*scale}">
<rect width="100%" height="100%" fill="${bg}"/>${rects}
</svg>`;
return "data:image/svg+xml;base64," + btoa(unescape(encodeURIComponent(svg)));
}
function sha256(s) {
// Simple synchronous hash-ish bytes from string (non-cryptographic; fine for visuals)
let h1 = 0x6a09e667, h2 = 0xbb67ae85;
for (let i=0;i<s.length;i++) {
const c = s.charCodeAt(i);
h1 = (h1 ^ c) * 0x45d9f3b + ((h1<<7) | (h1>>>25));
h2 = (h2 ^ (c<<1)) * 0x27d4eb2d + ((h2<<9) | (h2>>>23));
}
const out = new Uint8Array(32);
for (let i=0;i<32;i++){
out[i] = (h1 >> (i%24)) ^ (h2 >> ((i*3)%24)) ^ (i*31);
}
return out;
}

38
client/gdpr.html Normal file
View File

@@ -0,0 +1,38 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8"/>
<title>GDPR Notice — GreenCoast</title>
<meta name="viewport" content="width=device-width,initial-scale=1"/>
<link rel="stylesheet" href="./styles.css"/>
</head>
<body class="container">
<h1>GDPR Notice</h1>
<p class="muted">Effective: 2025-08-22</p>
<h2>Controller</h2>
<p>The operator of this shard acts as data controller. Contact: <em>dsapelli@yahoo.com</em>.</p>
<h2>Lawful bases</h2>
<ul>
<li><strong>Public posts:</strong> performance of service you request.</li>
<li><strong>Private posts:</strong> performance of service; encryption keys never leave your device.</li>
<li><strong>SSO (optional):</strong> your consent with the chosen provider.</li>
</ul>
<h2>Minimization & storage</h2>
<p>No user profile, no behavioral analytics. Objects are stored by content hash; server logs are minimized and scrubbed of IPs/UA where feasible.</p>
<h2>International transfers</h2>
<p>Content may be hosted where you deploy the shard. Using third-party SSO may transfer data to those providers’ regions.</p>
<h2>Data subject rights</h2>
<p>Access/erasure/rectification: We do not keep a server-side identity. Uploaders can delete objects by hash if they still possess authorization. Encrypted content cannot be decrypted server-side.</p>
<h2>Complaints</h2>
<p>You may lodge a complaint with your local supervisory authority.</p>
<p class="muted small">This document is informational and not legal advice.</p>
<p><a href="./index.html">Back</a></p>
</body>
</html>

210
client/index.html
View File

@@ -4,74 +4,168 @@
<meta charset="utf-8"/> <meta charset="utf-8"/>
<title>GreenCoast — Client</title> <title>GreenCoast — Client</title>
<meta name="viewport" content="width=device-width,initial-scale=1"/> <meta name="viewport" content="width=device-width,initial-scale=1"/>
<link rel="stylesheet" href="./styles.css"/> <!-- Hard-pin API host so mobiles pick the right shard -->
<!-- Optional: explicit API base -->
<meta name="gc-api-base" content="https://api-gc.fullmooncyberworks.com"> <meta name="gc-api-base" content="https://api-gc.fullmooncyberworks.com">
<link rel="stylesheet" href="./styles.css"/>
</head> </head>
<body> <body>
<div class="container"> <header class="topbar">
<h1>GreenCoast (Client)</h1> <div class="brand">GreenCoast</div>
<nav class="tabs">
<a data-route href="#/">Feed</a>
<a data-route href="#/privacy">Privacy</a>
<a data-route href="#/gdpr">GDPR</a>
<a data-route href="#/terms">Terms</a>
</nav>
<div class="actions">
<button id="signIn" type="button">Sign in (device key)</button>
<button id="discordStart" type="button">Discord</button>
<button id="panic" type="button">Panic wipe</button>
</div>
</header>
<section class="card"> <div id="capWarn" class="warn is-hidden"></div>
<h2>Connect</h2>
<div class="row"> <div id="banner" class="banner is-hidden">
<label>Shard URL</label> You are in <strong>anonymous (limited) mode</strong>. Only plaintext posts are available until you authorize this device.
<input id="shardUrl" placeholder="https://api-gc.fullmooncyberworks.com" /> </div>
</div>
<div class="row"> <div class="shell">
<label>Bearer (session)</label> <aside id="left" class="col">
<input id="bearer" placeholder="(auto after sign-in)" disabled /> <section class="card">
</div> <h3>Profile</h3>
<div class="row"> <div class="profile">
<label>Passphrase (private posts)</label> <img id="avatar" alt="avatar" width="56" height="56"/>
<input id="passphrase" type="password" placeholder="••••••••" /> <div class="profile-meta">
</div> <div><code id="fp">(pseudonymous)</code></div>
<div class="row"> <div class="muted small">Avatar is derived locally.</div>
<label>3rd-party SSO</label>
<div>
<button id="discordStart">Sign in with Discord</button>
<div class="muted" id="ssoNote">
We use external providers only if you choose to. We cannot vouch for their security.
</div> </div>
</div> </div>
</div> </section>
<div class="actions">
<button id="saveConn">Save</button>
<button id="keySignIn">Sign in (device key)</button>
<button id="panicWipe" class="danger">Panic wipe</button>
</div>
<div id="health" class="muted"></div>
</section>
<section class="card"> <section class="card">
<h2>Compose</h2> <h3>Quick links</h3>
<div class="row"> <ul class="links">
<label>Visibility</label> <li><a data-route href="#/">Feed</a></li>
<select id="visibility"> <li><a data-route href="#/privacy">Privacy Policy</a></li>
<option value="private">Private (E2EE via passphrase)</option> <li><a data-route href="#/gdpr">GDPR</a></li>
<option value="public">Public (plaintext)</option> <li><a data-route href="#/terms">Terms</a></li>
</select> </ul>
</div> </section>
<div class="row"> </aside>
<label>Title</label>
<input id="title" placeholder="Optional title"/>
</div>
<div class="row">
<label>Body</label>
<textarea id="body" rows="6" placeholder="Write your post..."></textarea>
</div>
<div class="actions">
<button id="publish">Publish</button>
</div>
<div id="publishStatus" class="muted"></div>
</section>
<section class="card"> <main id="feed" class="col">
<h2>Posts (live index)</h2> <section class="card">
<div id="posts"></div> <h2>Connection</h2>
</section> <div class="row">
<label>Shard URL</label>
<input id="shardUrl" placeholder="https://api-gc.fullmooncyberworks.com"/>
</div>
<details id="adv" class="advanced">
<summary>Advanced (security)</summary>
<div class="row">
<label>Bearer (hidden)</label>
<input id="bearer" type="password" placeholder="gc2 token" autocomplete="off"/>
</div>
<div class="row">
<label>Passphrase (for Private-Encrypted)</label>
<input id="passphrase" type="password" placeholder="••••••••" autocomplete="off"/>
</div>
<p class="muted small">
Security fields are local to your browser. We do not store PII or logs.
Third-party SSO is optional and not endorsed for security.
</p>
</details>
<button id="saveConn" type="button">Save</button>
<div id="health" class="muted"></div>
</section>
<!-- Cross-post -->
<section class="card">
<h2>Share (x-post, privacy-safe)</h2>
<div class="row">
<label>Link</label>
<input id="shareUrl" placeholder="https://www.tiktok.com/@user/video/..." />
</div>
<div class="row">
<label>Note</label>
<input id="shareNote" placeholder="Optional caption…"/>
</div>
<div class="row">
<label>Visibility</label>
<select id="shareVis">
<option value="plaintext">Plaintext</option>
<option value="members">Public-Encrypted (members)</option>
<option value="private">Private-Encrypted (passphrase)</option>
</select>
</div>
<div class="row">
<button id="sharePreview" type="button">Preview</button>
<button id="sharePublish" type="button">Publish link</button>
</div>
<div id="shareCard" class="xcard muted small"></div>
</section>
<section class="card">
<h2>Compose</h2>
<div class="row">
<label>Visibility</label>
<select id="visibility">
<option value="plaintext">Plaintext (last resort)</option>
<option value="members">Public-Encrypted (members)</option>
<option value="private">Private-Encrypted (passphrase)</option>
</select>
</div>
<div class="row">
<label>Title</label>
<input id="title" placeholder="Optional title"/>
</div>
<div class="row">
<label>Body</label>
<textarea id="body" rows="6" placeholder="Write your post..."></textarea>
</div>
<button id="publish" type="button">Publish</button>
<div id="publishStatus" class="muted status"></div>
</section>
<section class="card">
<h2>Posts (live index)</h2>
<div id="posts"></div>
</section>
</main>
<main id="page" class="col is-hidden">
<section class="card">
<div id="pageContent">Loading…</div>
</section>
</main>
<aside id="right" class="col">
<section class="card">
<h3>About</h3>
<p class="muted small">Welcome to GreenCoast, a privacy-focused social media site. Zero-trust, E2EE optional, no analytics, no PII.</p>
</section>
<section class="card">
<h3>Legal</h3>
<ul class="links">
<li><a data-route href="#/privacy">Privacy</a></li>
<li><a data-route href="#/gdpr">GDPR</a></li>
<li><a data-route href="#/terms">Terms</a></li>
</ul>
</section>
</aside>
</div> </div>
<footer class="footer">
<a data-route href="#/privacy">Privacy</a> ·
<a data-route href="#/gdpr">GDPR</a> ·
<a data-route href="#/terms">Terms</a>
</footer>
<div id="flash" class="flash"></div>
<script type="module" src="./app.js"></script> <script type="module" src="./app.js"></script>
</body> </body>
</html> </html>

41
client/privacy.html Normal file
View File

@@ -0,0 +1,41 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8"/>
<title>Privacy Policy — GreenCoast</title>
<meta name="viewport" content="width=device-width,initial-scale=1"/>
<link rel="stylesheet" href="./styles.css"/>
</head>
<body class="container">
<h1>Privacy Policy</h1>
<p class="muted">Effective: 2025-08-22</p>
<h2>What we are</h2>
<p>GreenCoast is a zero-trust, end-to-end encrypted (E2EE) social platform. By default, we do not collect analytics, do not store personal data, and do not maintain server logs that identify users.</p>
<h2>Data we process</h2>
<ul>
<li><strong>Public posts:</strong> Stored as plaintext objects keyed by content hash. No account profile is required.</li>
<li><strong>Private posts:</strong> Encrypted <em>client-side</em> with a passphrase only you know. The server sees ciphertext only.</li>
<li><strong>Authorization:</strong> Device-key and/or third-party SSO (if you choose) issue a short-lived bearer. We do not persist profile data.</li>
</ul>
<h2>Third-party SSO</h2>
<p>If you use Discord/Google/etc., those providers may process your data under their own terms. We cannot vouch for their security.</p>
<h2>Cookies & local storage</h2>
<p>We use browser storage on your device to keep connection settings and, if you choose, session tokens. You can wipe them with “Panic wipe”.</p>
<h2>Security</h2>
<p>E2EE for private content, proof-of-possession on mutations, rate-limits, CSP/COOP/COEP, and optional hardware keys via WebAuthn (if enabled on your shard).</p>
<h2>Your rights</h2>
<p>Because we do not maintain user identities or server-side profiles, requests to access/correct/erase personal data typically do not apply. For encrypted content, we cannot decrypt it for you.</p>
<h2>Contact</h2>
<p>Email: <em>dsapelli@yahoo.com</em></p>
<p class="muted small">This page describes our reference shard. Self-hosted deployments may differ.</p>
<p><a href="./index.html">Back</a></p>
</body>
</html>

87
client/styles.css
View File

@@ -1,15 +1,72 @@
:root { color-scheme: light dark; } :root{
body { font-family: system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, "Noto Sans", sans-serif; margin: 0; padding: 2rem; } --bg:#0f172a;--surface:#111827;--muted:#8b949e;--text:#e5e7eb;--accent:#22c55e;
.container { max-width: 860px; margin: 0 auto; } --card:#0b1222;--border:#1f2937;--tab:#0b1222;--tab-active:#1f2937
h1 { margin: 0 0 1rem 0; } }
.card { border: 1px solid #30363d; border-radius: 16px; padding: 1rem; margin: 1rem 0; box-shadow: 0 2px 6px rgba(0,0,0,.1); } *{box-sizing:border-box}
.row { display: grid; grid-template-columns: 160px 1fr; gap: .8rem; align-items: center; margin: .6rem 0; } html,body{margin:0;padding:0;background:var(--bg);color:var(--text);
label { opacity: .8; } font-family:ui-sans-serif,system-ui,Segoe UI,Roboto,Ubuntu,"Helvetica Neue","Noto Sans",Arial}
input, textarea, select, button { font: inherit; padding: .6rem .7rem; border-radius: 10px; border: 1px solid #30363d; background: transparent; color: inherit; } a{color:#93c5fd;text-decoration:none}
button { cursor: pointer; } a:hover{text-decoration:underline}
button.danger { border-color: #a4002a; color: #a4002a; }
.actions { display: flex; gap: .6rem; flex-wrap: wrap; margin-top: .4rem; } .topbar{display:flex;align-items:center;justify-content:space-between;padding:.6rem 1rem;
.muted { opacity: .7; font-size: .9rem; } border-bottom:1px solid var(--border);background:#0b1222;position:sticky;top:0;z-index:10}
.badge { display: inline-block; padding: .1rem .4rem; border-radius: 8px; border: 1px solid #30363d; font-size: .75rem; margin-left: .4rem; } .brand{font-weight:700}
.post { border-top: 1px dashed #30363d; padding: .6rem 0; } .actions button{margin-left:.5rem}
pre.content { white-space: pre-wrap; margin-top: .5rem; } button{background:#134e4a;border:1px solid #0f766e;color:white;border-radius:.6rem;padding:.45rem .7rem;cursor:pointer}
button:hover{filter:brightness(1.05)}
input[type="password"]{letter-spacing:.2em}
.tabs{display:flex;gap:.25rem;margin:0 .75rem}
.tabs a{padding:.35rem .6rem;border:1px solid var(--border);border-radius:.5rem;background:var(--tab)}
.tabs a.active{background:var(--tab-active);border-color:#334155}
.banner{background:#1f2937;color:#e5e7eb;border-bottom:1px solid var(--border);padding:.6rem 1rem}
.shell{max-width:1100px;margin:1rem auto;display:grid;grid-template-columns:280px 1fr 300px;gap:1rem;padding:0 1rem}
.col{min-width:0}
.card{background:var(--card);border:1px solid var(--border);border-radius:.75rem;padding:1rem;margin-bottom:1rem}
.row{display:flex;gap:.75rem;align-items:center;margin:.5rem 0}
.row label{min-width:140px;color:#cbd5e1}
.row input,.row select,textarea{flex:1;background:#0f172a;border:1px solid var(--border);border-radius:.5rem;padding:.55rem .65rem;color:var(--text)}
.muted{color:var(--muted)} .small{font-size:.9rem}
.profile{display:flex;align-items:center;gap:1rem}
#avatar{border-radius:50%;border:1px solid var(--border);background:#0f172a;image-rendering:pixelated}
.post{border:1px dashed var(--border);border-radius:.5rem;padding:.6rem .7rem;margin-bottom:.6rem}
.post .meta{color:var(--muted);font-size:.9rem;margin-bottom:.25rem}
.badge{background:var(--surface);border:1px solid var(--border);border-radius:999px;padding:.05rem .5rem;font-size:.75rem;margin-left:.5rem}
.advanced summary{cursor:pointer;color:#cbd5e1;margin:.25rem 0}
.links{list-style:none;padding:0;margin:0}
.links li{margin:.25rem 0}
.footer{max-width:1100px;margin:1rem auto 2rem auto;padding:0 1rem;color:#94a3b8}
.flash{position:fixed;right:12px;bottom:12px;background:#0b1222;border:1px solid #1f2937;color:#e5e7eb;
padding:.55rem .7rem;border-radius:.5rem;box-shadow:0 6px 18px rgba(0,0,0,.35);display:none;z-index:9999}
.flash.visible{display:block}
.warn{background:#3b1d1d;border:1px solid #7f1d1d;color:#ffd7d7;padding:.6rem .8rem;border-radius:.6rem;margin:0 1rem 1rem}
.banner{margin:0 1rem 1rem;padding:.6rem .8rem;border-radius:.6rem;background:#10212b;border:1px solid #1d3340;color:#dbeafe}
.is-hidden{display:none !important}
.mt-4{margin-top:.4rem}
/* content presentation that was previously set via JS */
.pre-content{white-space:pre-wrap;margin-top:.5rem}
.status.error{color:#ff6b6b}
.status.ok{color:#8b949e}
/* x-post chips */
.xcard{border:1px solid #263444;border-radius:.5rem;padding:.6rem}
.xrow{display:flex;gap:.5rem;align-items:center}
.xpill{font-size:.85rem;border:1px solid #30445a;border-radius:999px;padding:.1rem .5rem}
.xtitle{font-weight:600}
.xmeta{opacity:.85;margin:.25rem 0}
.xbtn{margin-top:.25rem}
code{background:#0f172a;border:1px solid var(--border);border-radius:.35rem;padding:.05rem .35rem}
@media (max-width: 980px){
.shell{grid-template-columns:1fr;gap:.75rem}
#left,#right{order:2}
#feed,#page{order:1}
}

33
client/terms.html Normal file
View File

@@ -0,0 +1,33 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8"/>
<title>Terms of Service — GreenCoast</title>
<meta name="viewport" content="width=device-width,initial-scale=1"/>
<link rel="stylesheet" href="./styles.css"/>
</head>
<body class="container">
<h1>Terms of Service</h1>
<p class="muted">Effective: 2025-08-22</p>
<h2>Service</h2>
<p>GreenCoast is provided “as-is”, with no warranties. You may self-host under the Unlicense. This reference shard has no paid plans.</p>
<h2>User content</h2>
<p>You are responsible for content you publish. Do not post illegal content or abuse others. We reserve the right to remove content that violates applicable law.</p>
<h2>Accounts & authorization</h2>
<p>Device-key and optional SSO are used to prove control of a device. We do not maintain user profiles.</p>
<h2>Third-party services</h2>
<p>If you connect SSO providers, your use of those services is governed by their terms and privacy policies.</p>
<h2>Limitation of liability</h2>
<p>To the fullest extent permitted by law, the operator is not liable for indirect or consequential damages.</p>
<h2>Changes</h2>
<p>We may update these Terms by posting a new version on this page.</p>
<p><a href="./index.html">Back</a></p>
</body>
</html>

338
cmd/shard/main.go
View File

@@ -1,163 +1,241 @@
// cmd/shard/main.go
package main package main
import ( import (
"crypto/sha256"
"encoding/hex"
"io"
"log" "log"
"net/http"
"os" "os"
"strconv" "path/filepath"
"strings"
"syscall"
"time" "time"
"greencoast/internal/api" "greencoast/internal/api"
"greencoast/internal/index" "greencoast/internal/index"
"greencoast/internal/storage"
"gopkg.in/yaml.v3"
) )
func getenvBool(key string, def bool) bool { type cfgPrivacy struct {
v := os.Getenv(key) AllowAnonPlaintext bool `yaml:"allow_anon_plaintext"`
if v == "" { }
return def type shardConfig struct {
Privacy cfgPrivacy `yaml:"privacy"`
}
func boolEnv(keys ...string) bool {
for _, k := range keys {
v := strings.ToLower(strings.TrimSpace(os.Getenv(k)))
if v == "1" || v == "true" || v == "yes" || v == "on" {
return true
}
} }
b, err := strconv.ParseBool(v) return false
}
func loadYAMLAllow(path string) bool {
f, err := os.Open(path)
if err != nil { if err != nil {
return def return false
} }
return b defer f.Close()
var sc shardConfig
if err := yaml.NewDecoder(f).Decode(&sc); err != nil {
return false
}
return sc.Privacy.AllowAnonPlaintext
} }
func staticHeaders(next http.Handler) http.Handler { /* -------------------------
onion := os.Getenv("GC_ONION_LOCATION") // optional: e.g., http://xxxxxxxx.onion/ Minimal FS blob store (implements api.BlobStore)
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { Layout:
// Security headers + strict CSP (no inline) + COEP /var/lib/greencoast/objects/<hash> content
w.Header().Set("Referrer-Policy", "no-referrer") /var/lib/greencoast/objects/<hash>.priv empty sidecar => private
w.Header().Set("Cross-Origin-Opener-Policy", "same-origin") --------------------------*/
w.Header().Set("Cross-Origin-Resource-Policy", "same-site")
w.Header().Set("Permissions-Policy", "camera=(), microphone=(), geolocation=(), interest-cohort=(), browsing-topics=()")
w.Header().Set("X-Frame-Options", "DENY")
w.Header().Set("X-Content-Type-Options", "nosniff")
w.Header().Set("Strict-Transport-Security", "max-age=15552000; includeSubDomains; preload")
w.Header().Set("Cross-Origin-Embedder-Policy", "require-corp")
// Allow only self + HTTPS for fetch/SSE; no inline styles/scripts
w.Header().Set("Content-Security-Policy",
"default-src 'self'; "+
"script-src 'self'; "+
"style-src 'self'; "+
"img-src 'self' data:; "+
"connect-src 'self' https:; "+
"frame-ancestors 'none'; object-src 'none'; base-uri 'none'; form-action 'self'; "+
"require-trusted-types-for 'script'")
if onion != "" {
w.Header().Set("Onion-Location", onion)
}
// Basic CORS for static (GET only effectively) type fsStore struct {
w.Header().Set("Access-Control-Allow-Origin", "*") root string
if r.Method == http.MethodOptions {
w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
w.WriteHeader(http.StatusNoContent)
return
}
next.ServeHTTP(w, r)
})
} }
func newFSStore(root string) *fsStore { return &fsStore{root: root} }
func (s *fsStore) ensureRoot() error {
// create both parent and leaf to be safe on fresh volumes
if err := os.MkdirAll(filepath.Dir(s.root), 0o755); err != nil {
return err
}
return os.MkdirAll(s.root, 0o755)
}
func (s *fsStore) pathFor(hash string) string { return filepath.Join(s.root, hash) }
func (s *fsStore) privPathFor(hash string) string { return filepath.Join(s.root, hash+".priv") }
func (s *fsStore) Get(hash string) (io.ReadCloser, int64, error) {
if err := s.ensureRoot(); err != nil {
return nil, 0, err
}
f, err := os.Open(s.pathFor(hash))
if err != nil {
return nil, 0, err
}
st, err := f.Stat()
if err != nil {
_ = f.Close()
return nil, 0, err
}
return f, st.Size(), nil
}
func (s *fsStore) Put(r io.Reader, private bool) (string, int64, time.Time, error) {
if err := s.ensureRoot(); err != nil {
return "", 0, time.Time{}, err
}
tmp, err := os.CreateTemp(s.root, "put-*")
if err != nil {
return "", 0, time.Time{}, err
}
tmpName := tmp.Name()
defer func() {
// best-effort cleanup of temp path (original name)
_ = os.Remove(tmpName)
}()
h := sha256.New()
w := io.MultiWriter(tmp, h)
n, err := io.Copy(w, r)
if err != nil {
_ = tmp.Close()
return "", 0, time.Time{}, err
}
// IMPORTANT on Windows bind mounts: flush & close before rename
if err := tmp.Sync(); err != nil {
_ = tmp.Close()
return "", 0, time.Time{}, err
}
if err := tmp.Close(); err != nil {
return "", 0, time.Time{}, err
}
hash := hex.EncodeToString(h.Sum(nil))
final := s.pathFor(hash)
// If a previous file with this hash exists, remove it first (idempotent writes)
_ = os.Remove(final)
if err := os.Rename(tmpName, final); err != nil {
return "", 0, time.Time{}, err
}
// Optional: fsync directory to harden the rename on some filesystems
if df, err := os.Open(s.root); err == nil {
_ = syscall.Fsync(int(df.Fd()))
_ = df.Close()
}
st, err := os.Stat(final)
if err != nil {
return "", 0, time.Time{}, err
}
// create sidecar only after main content is durable
if private {
if err := os.WriteFile(s.privPathFor(hash), nil, 0o600); err != nil {
_ = os.Remove(final)
return "", 0, time.Time{}, err
}
}
return hash, n, st.ModTime().UTC(), nil
}
func (s *fsStore) Delete(hash string) error {
if err := s.ensureRoot(); err != nil {
return err
}
_ = os.Remove(s.privPathFor(hash))
return os.Remove(s.pathFor(hash))
}
func (s *fsStore) Walk(fn func(hash string, bytes int64, private bool, storedAt time.Time) error) (int, error) {
if err := s.ensureRoot(); err != nil {
return 0, err
}
ents, err := os.ReadDir(s.root)
if err != nil {
return 0, err
}
count := 0
for _, e := range ents {
if e.IsDir() {
continue
}
name := e.Name()
// skip sidecars and non-64-hex filenames
if strings.HasSuffix(name, ".priv") || len(name) != 64 || !isHex(name) {
continue
}
full := s.pathFor(name)
st, err := os.Stat(full)
if err != nil {
continue
}
private := false
if _, err := os.Stat(s.privPathFor(name)); err == nil {
private = true
}
if err := fn(name, st.Size(), private, st.ModTime().UTC()); err != nil {
return count, err
}
count++
}
return count, nil
}
func isHex(s string) bool {
for i := 0; i < len(s); i++ {
c := s[i]
if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) {
return false
}
}
return true
}
/* -------------------------
main
--------------------------*/
func main() { func main() {
// ---- Config ---- // Store & index
httpAddr := os.Getenv("GC_HTTP_ADDR") store := newFSStore("/var/lib/greencoast/objects")
if httpAddr == "" { idx := index.New()
httpAddr = ":9080"
}
httpsAddr := os.Getenv("GC_HTTPS_ADDR")
certFile := os.Getenv("GC_TLS_CERT")
keyFile := os.Getenv("GC_TLS_KEY")
staticAddr := os.Getenv("GC_STATIC_ADDR") // Flags: env wins, else YAML (/app/shard.yaml), else false
if staticAddr == "" { allowAnon := boolEnv("GC_ALLOW_ANON_PLAINTEXT")
staticAddr = ":9082" if !allowAnon {
} if st, err := os.Stat("/app/shard.yaml"); err == nil && !st.IsDir() {
staticDir := os.Getenv("GC_STATIC_DIR") allowAnon = loadYAMLAllow("/app/shard.yaml")
if staticDir == "" {
staticDir = "/opt/greencoast/client"
}
dataDir := os.Getenv("GC_DATA_DIR")
if dataDir == "" {
dataDir = "/var/lib/greencoast"
}
coarseTS := getenvBool("GC_COARSE_TS", true) // safer default (less precise metadata)
zeroTrust := getenvBool("GC_ZERO_TRUST", true)
encRequired := getenvBool("GC_ENCRYPTION_REQUIRED", true) // operator-blind by default
requirePOP := getenvBool("GC_REQUIRE_POP", true) // logged only here
signingSecretHex := os.Getenv("GC_SIGNING_SECRET_HEX")
if len(signingSecretHex) < 64 {
log.Printf("WARN: GC_SIGNING_SECRET_HEX length=%d (need >=64 hex chars)", len(signingSecretHex))
} else {
log.Printf("GC_SIGNING_SECRET_HEX OK (len=%d)", len(signingSecretHex))
}
discID := os.Getenv("GC_DISCORD_CLIENT_ID")
discSecret := os.Getenv("GC_DISCORD_CLIENT_SECRET")
discRedirect := os.Getenv("GC_DISCORD_REDIRECT_URI")
// ---- Storage & Index ----
store, err := storage.NewFS(dataDir)
if err != nil {
log.Fatalf("storage init: %v", err)
}
ix := index.New()
// Reindex on boot from existing files (coarse time if enabled)
if err := store.Walk(func(hash string, size int64, mod time.Time) error {
when := mod.UTC()
if coarseTS {
when = when.Truncate(time.Minute)
} }
return ix.Put(index.Entry{
Hash: hash,
Bytes: size,
StoredAt: when.Format(time.RFC3339Nano),
Private: false, // unknown here
})
}); err != nil {
log.Printf("reindex on boot: %v", err)
} }
devMode := boolEnv("GC_DEV_ALLOW_UNAUTH")
// ---- Auth providers ---- log.Printf("boot: privacy.allow_anon_plaintext=%v dev=%v at=%s", allowAnon, devMode, time.Now().UTC().Format(time.RFC3339))
providers := api.AuthProviders{
SigningSecretHex: signingSecretHex,
Discord: api.DiscordProvider{
Enabled: discID != "" && discSecret != "" && discRedirect != "",
ClientID: discID,
ClientSecret: discSecret,
RedirectURI: discRedirect,
},
}
// ---- API server ---- var providers api.AuthProviders
srv := api.New(store, ix, coarseTS, zeroTrust, providers, encRequired) srv := api.New(store, idx, true, devMode, providers, allowAnon)
// ---- Static file server (separate listener) ---- // Frontend (static)
go func() { go func() {
fs := http.FileServer(http.Dir(staticDir)) if err := srv.ListenFrontend("0.0.0.0:9082"); err != nil {
h := staticHeaders(fs) log.Printf("frontend server exited: %v", err)
log.Printf("static listening on %s (dir=%s)", staticAddr, staticDir)
if err := http.ListenAndServe(staticAddr, h); err != nil {
log.Fatalf("static server: %v", err)
} }
}() }()
// ---- Start API (HTTP or HTTPS) ---- // API
if httpsAddr != "" && certFile != "" && keyFile != "" { if err := srv.ListenHTTP("0.0.0.0:9080"); err != nil {
log.Printf("API HTTPS %s POP:%v ENC_REQUIRED:%v", httpsAddr, requirePOP, encRequired)
if err := srv.ListenHTTPS(httpsAddr, certFile, keyFile); err != nil {
log.Fatal(err)
}
return
}
log.Printf("API HTTP %s POP:%v ENC_REQUIRED:%v", httpAddr, requirePOP, encRequired)
if err := srv.ListenHTTP(httpAddr); err != nil {
log.Fatal(err) log.Fatal(err)
} }
} }

43
configs/shard.test.yaml
View File

@@ -1,32 +1,32 @@
shard_id: "gc-test-001" shard_id: "gc-test-001"
listen: listen:
http: "0.0.0.0:9080" # API for testers http: "0.0.0.0:9080"
https: "" # if you terminate TLS at a proxy, leave empty https: ""
ws: "0.0.0.0:9081" # reserved ws: "0.0.0.0:9081"
tls: tls:
enable: false # set true only if serving HTTPS directly here enable: false
cert_file: "/etc/greencoast/tls/cert.pem" cert_file: "/etc/greencoast/tls/cert.pem"
key_file: "/etc/greencoast/tls/key.pem" key_file: "/etc/greencoast/tls/key.pem"
federation: federation:
mtls_enable: false mtls_enable: false
listen: "0.0.0.0:9443" listen: "0.0.0.0:9443"
cert_file: "/etc/greencoast/fed/cert.pem" cert_file: "/etc/greencoast/fed/cert.pem"
key_file: "/etc/greencoast/fed/key.pem" key_file: "/etc/greencoast/fed/key.pem"
client_ca_file: "/etc/greencoast/fed/clients_ca.pem" client_ca_file: "/etc/greencoast/fed/clients_ca.pem"
ui: ui:
enable: true enable: true
path: "./client" path: "./client"
base_url: "/" base_url: "/"
frontend_http: "0.0.0.0:9082" # static client for testers frontend_http: "0.0.0.0:9082"
storage: storage:
backend: "fs" backend: "fs"
path: "/var/lib/greencoast/objects" path: "/var/lib/greencoast/objects"
max_object_kb: 128 # lower if you want to constrain uploads max_object_kb: 128
security: security:
zero_trust: true zero_trust: true
@@ -38,27 +38,20 @@ privacy:
retain_ip: "no" retain_ip: "no"
retain_user_agent: "no" retain_user_agent: "no"
retain_timestamps: "coarse" retain_timestamps: "coarse"
allow_anon_plaintext: true
auth: auth:
# IMPORTANT: rotate this per environment (use `openssl rand -hex 32`) # Choose either YAML OR env for the signing secret — not both.
signing_secret: "D941C4F91D0046D28CDBC3F425DE0B4EA26BD2A80434E0F160D1B7C813EB43F8" # If you keep it here, make sure it's EXACTLY the same as the env value.
signing_secret: GC_SIGNING_SECRET_HEX
sso: sso:
discord: discord:
enabled: true enabled: true
client_id: "1408292766319906946" client_id: GC_DISCORD_CLIENT_ID
client_secret: "zJ6GnUUykHbMFbWsPPneNxNK-PtOXYg1" client_secret: GC_DISCORD_CLIENT_SECRET
# must exactly match your Discord app's allowed redirect redirect_uri: GC_DISCORD_REDIRECT_URI
redirect_uri: "https://greencoast.fullmooncyberworks.com/auth-callback.html" google: { enabled: false, client_id: "", client_secret: "", redirect_uri: "" }
google: facebook: { enabled: false, client_id: "", client_secret: "", redirect_uri: "" }
enabled: false
client_id: ""
client_secret: ""
redirect_uri: ""
facebook:
enabled: false
client_id: ""
client_secret: ""
redirect_uri: ""
two_factor: two_factor:
webauthn_enabled: false webauthn_enabled: false
totp_enabled: false totp_enabled: false
@@ -66,4 +59,4 @@ auth:
limits: limits:
rate: rate:
burst: 20 burst: 20
per_minute: 60 # slightly tighter for external testing per_minute: 60

12
docker-compose.test.yml
View File

@@ -1,18 +1,14 @@
version: "3.9"
services: services:
shard-test: shard-test:
build: . build: .
env_file:
- .env
container_name: greencoast-shard-test container_name: greencoast-shard-test
restart: unless-stopped restart: unless-stopped
user: "0:0" user: "0:0"
# These ports are optional (useful for local debug). Tunnel doesn't need them.
ports: ports:
- "9080:9080" # API - "9080:9080"
- "9082:9082" # Frontend - "9082:9082"
environment:
- GC_DEV_ALLOW_UNAUTH=true
- GC_SIGNING_SECRET_HEX=92650f92d67d55368c852713a5007b90d933bff507bc77c980de7bf5442844ca
volumes: volumes:
- ./testdata:/var/lib/greencoast - ./testdata:/var/lib/greencoast
- ./configs/shard.test.yaml:/app/shard.yaml:ro - ./configs/shard.test.yaml:/app/shard.yaml:ro

971
internal/api/http.go
View File

File diff suppressed because it is too large Load Diff

88
internal/api/ratelimit.go
View File

@@ -1,31 +1,33 @@
package api package api
import ( import (
"net"
"net/http"
"sync" "sync"
"time" "time"
) )
// Simple token-bucket rate limiter used by Server.cors middleware.
type tokenBucket struct {
tokens float64
lastFill time.Time
}
type rateLimiter struct { type rateLimiter struct {
mu sync.Mutex rate float64 // tokens per second
bk map[string]*bucket burst float64
rate float64 // tokens per second mu sync.Mutex
burst float64 bk map[string]*tokenBucket
window time.Duration evictDur time.Duration
lastGC time.Time
} }
type bucket struct { func newRateLimiter(rate float64, burst int, evict time.Duration) *rateLimiter {
tokens float64
last time.Time
}
func newRateLimiter(rps float64, burst int, window time.Duration) *rateLimiter {
return &rateLimiter{ return &rateLimiter{
bk: make(map[string]*bucket), rate: rate,
rate: rps, burst: float64(burst),
burst: float64(burst), bk: make(map[string]*tokenBucket),
window: window, evictDur: evict,
lastGC: time.Now(),
} }
} }
@@ -34,45 +36,37 @@ func (rl *rateLimiter) allow(key string) bool {
rl.mu.Lock() rl.mu.Lock()
defer rl.mu.Unlock() defer rl.mu.Unlock()
b := rl.bk[key] // GC old buckets occasionally
if b == nil { if now.Sub(rl.lastGC) > rl.evictDur {
b = &bucket{tokens: rl.burst, last: now} for k, b := range rl.bk {
if now.Sub(b.lastFill) > rl.evictDur {
delete(rl.bk, k)
}
}
rl.lastGC = now
}
b, ok := rl.bk[key]
if !ok {
b = &tokenBucket{tokens: rl.burst, lastFill: now}
rl.bk[key] = b rl.bk[key] = b
} }
// refill
elapsed := now.Sub(b.last).Seconds()
b.tokens = min(rl.burst, b.tokens+elapsed*rl.rate)
b.last = now
if b.tokens < 1.0 { // Refill
return false elapsed := now.Sub(b.lastFill).Seconds()
} b.tokens = minf(rl.burst, b.tokens+elapsed*rl.rate)
b.tokens -= 1.0 b.lastFill = now
// occasional cleanup if b.tokens >= 1.0 {
for k, v := range rl.bk { b.tokens -= 1.0
if now.Sub(v.last) > rl.window { return true
delete(rl.bk, k)
}
} }
return true return false
} }
func min(a, b float64) float64 { func minf(a, b float64) float64 {
if a < b { if a < b {
return a return a
} }
return b return b
} }
func clientIP(r *http.Request) string {
// Prefer Cloudflare’s header if present; fall back to RemoteAddr.
if ip := r.Header.Get("CF-Connecting-IP"); ip != "" {
return ip
}
host, _, err := net.SplitHostPort(r.RemoteAddr)
if err != nil {
return r.RemoteAddr
}
return host
}

83
internal/api/static.go
View File

@@ -2,28 +2,75 @@ package api
import ( import (
"net/http" "net/http"
"os"
"path/filepath"
"strings"
"time"
) )
// secureHeaders adds strict, privacy-preserving headers to static responses. // ListenFrontend serves the static client from s.StaticDir on a separate port (e.g. :9082).
func (s *Server) secureHeaders(next http.Handler) http.Handler { func (s *Server) ListenFrontend(addr string) error {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { root := s.StaticDir
w.Header().Set("Referrer-Policy", "no-referrer") if root == "" {
root = "./client"
}
// Basic security/CSP headers for static content.
addCommonHeaders := func(w http.ResponseWriter) {
// CORS: static site can be embedded by any origin if you want, keep strict by default
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Cross-Origin-Opener-Policy", "same-origin") w.Header().Set("Cross-Origin-Opener-Policy", "same-origin")
w.Header().Set("Cross-Origin-Resource-Policy", "same-site") w.Header().Set("Cross-Origin-Resource-Policy", "same-site")
w.Header().Set("Permissions-Policy", "camera=(), microphone=(), geolocation=(), interest-cohort=(), browsing-topics=()") w.Header().Set("Referrer-Policy", "no-referrer")
w.Header().Set("X-Frame-Options", "DENY")
w.Header().Set("X-Content-Type-Options", "nosniff") w.Header().Set("X-Content-Type-Options", "nosniff")
w.Header().Set("Strict-Transport-Security", "max-age=15552000; includeSubDomains; preload") w.Header().Set("X-Frame-Options", "DENY")
next.ServeHTTP(w, r) // Cache: avoid caching during test
}) w.Header().Set("Cache-Control", "no-store")
} // CSP: no inline scripts/styles; allow XHR/SSE/Ws to any (tunnel/api) host
w.Header().Set("Content-Security-Policy",
// MountStatic mounts a static file server under a prefix onto the provided mux. strings.Join([]string{
// Usage (from main): s.MountStatic(mux, "/", http.Dir(staticDir)) "default-src 'self'",
func (s *Server) MountStatic(mux *http.ServeMux, prefix string, fs http.FileSystem) { "script-src 'self'",
if prefix == "" { "style-src 'self'",
prefix = "/" "img-src 'self' data:",
"font-src 'self'",
"connect-src *",
"frame-ancestors 'none'",
"base-uri 'self'",
"form-action 'self'",
}, "; "),
)
} }
h := http.StripPrefix(prefix, http.FileServer(fs))
mux.Handle(prefix, s.secureHeaders(h)) // File handler with index.html fallback for “/”.
fileServer := http.FileServer(http.Dir(root))
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
addCommonHeaders(w)
// Serve index.html at root or when requesting a directory.
p := r.URL.Path
if p == "/" || p == "" {
http.ServeFile(w, r, filepath.Join(root, "index.html"))
return
}
// If path maps to a directory, try its index.html.
full := filepath.Join(root, filepath.Clean(strings.TrimPrefix(p, "/")))
if st, err := os.Stat(full); err == nil && st.IsDir() {
indexFile := filepath.Join(full, "index.html")
if _, err := os.Stat(indexFile); err == nil {
http.ServeFile(w, r, indexFile)
return
}
}
// Normal static file.
fileServer.ServeHTTP(w, r)
})
srv := &http.Server{
Addr: addr,
Handler: handler,
ReadHeaderTimeout: 5 * time.Second,
}
return srv.ListenAndServe()
} }

42
internal/index/index.go
View File

@@ -1,62 +1,48 @@
package index package index
import ( import (
"errors"
"sync" "sync"
) )
// Entry is the minimal metadata we expose to clients. // Entry is the index record returned to clients.
// Keep metadata minimal to protect users.
type Entry struct { type Entry struct {
Hash string `json:"hash"` Hash string `json:"hash"`
Bytes int64 `json:"bytes"` Bytes int64 `json:"bytes"`
StoredAt string `json:"stored_at"` // RFC3339Nano StoredAt string `json:"stored_at"` // RFC3339Nano string
Private bool `json:"private"` // true if client marked encrypted Private bool `json:"private"`
CreatorTZ string `json:"creator_tz,omitempty"` // optional IANA TZ from client CreatorTZ string `json:"creator_tz,omitempty"`
Author string `json:"author,omitempty"` // pseudonymous (thumbprint), optional
} }
// Index is an in-memory map from hash -> Entry, safe for concurrent use.
type Index struct { type Index struct {
mu sync.RWMutex mu sync.RWMutex
m map[string]Entry data map[string]Entry
} }
func New() *Index { func New() *Index {
return &Index{m: make(map[string]Entry)} return &Index{data: make(map[string]Entry)}
} }
func (ix *Index) Put(e Entry) error { func (ix *Index) Put(e Entry) error {
if e.Hash == "" {
return errors.New("empty hash")
}
ix.mu.Lock() ix.mu.Lock()
ix.m[e.Hash] = e ix.data[e.Hash] = e
ix.mu.Unlock() ix.mu.Unlock()
return nil return nil
} }
func (ix *Index) Delete(hash string) error { func (ix *Index) Delete(hash string) error {
if hash == "" {
return errors.New("empty hash")
}
ix.mu.Lock() ix.mu.Lock()
delete(ix.m, hash) delete(ix.data, hash)
ix.mu.Unlock() ix.mu.Unlock()
return nil return nil
} }
func (ix *Index) Get(hash string) (Entry, bool) {
ix.mu.RLock()
e, ok := ix.m[hash]
ix.mu.RUnlock()
return e, ok
}
// All returns an unsorted copy of all entries.
func (ix *Index) All() []Entry { func (ix *Index) All() []Entry {
ix.mu.RLock() ix.mu.RLock()
out := make([]Entry, 0, len(ix.m)) out := make([]Entry, 0, len(ix.data))
for _, v := range ix.m { for _, e := range ix.data {
out = append(out, v) out = append(out, e)
} }
ix.mu.RUnlock() ix.mu.RUnlock()
return out return out

321
internal/storage/fs.go
View File

@@ -1,240 +1,151 @@
package storage package api
import ( import (
"errors" "crypto/sha256"
"encoding/hex"
"io" "io"
"io/fs"
"os" "os"
"path/filepath" "path/filepath"
"strings" "strings"
"time" "time"
) )
type FSStore struct { // SimpleFSStore is a minimal FS-backed implementation of BlobStore.
root string // Layout under root:
objects string //
// <root>/<hash> - content
// <root>/<hash>.priv - presence means "private"
type SimpleFSStore struct {
root string
} }
func NewFS(dir string) (*FSStore, error) { func NewSimpleFSStore(root string) *SimpleFSStore {
if dir == "" { return &SimpleFSStore{root: root}
return nil, errors.New("empty storage dir")
}
o := filepath.Join(dir, "objects")
if err := os.MkdirAll(o, 0o755); err != nil {
return nil, err
}
return &FSStore{root: dir, objects: o}, nil
} }
func (s *FSStore) pathFlat(hash string) (string, error) { func (fs *SimpleFSStore) ensureRoot() error {
if hash == "" { return os.MkdirAll(fs.root, 0o755)
return "", errors.New("empty hash")
}
return filepath.Join(s.objects, hash), nil
} }
func isHexHash(name string) bool { func (fs *SimpleFSStore) pathFor(hash string) string {
if len(name) != 64 { return filepath.Join(fs.root, hash)
return false }
} func (fs *SimpleFSStore) privPathFor(hash string) string {
for i := 0; i < 64; i++ { return filepath.Join(fs.root, hash+".priv")
c := name[i]
if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f')) {
return false
}
}
return true
} }
func (s *FSStore) findBlobPath(hash string) (string, error) { // Get implements BlobStore.Get
if hash == "" { func (fs *SimpleFSStore) Get(hash string) (io.ReadCloser, int64, error) {
return "", errors.New("empty hash") if err := fs.ensureRoot(); err != nil {
}
// 1) flat
if p, _ := s.pathFlat(hash); fileExists(p) {
return p, nil
}
// 2) objects/<hash>/{blob,data,content}
dir := filepath.Join(s.objects, hash)
for _, cand := range []string{"blob", "data", "content"} {
p := filepath.Join(dir, cand)
if fileExists(p) {
return p, nil
}
}
// 3) objects/<hash>/<single file>
if st, err := os.Stat(dir); err == nil && st.IsDir() {
ents, _ := os.ReadDir(dir)
var picked string
var pickedMod time.Time
for _, de := range ents {
if de.IsDir() {
continue
}
p := filepath.Join(dir, de.Name())
fi, err := os.Stat(p)
if err == nil && fi.Mode().IsRegular() {
if picked == "" || fi.ModTime().After(pickedMod) {
picked, pickedMod = p, fi.ModTime()
}
}
}
if picked != "" {
return picked, nil
}
}
// 4) two-level prefix objects/aa/<hash>
if len(hash) >= 2 {
p := filepath.Join(s.objects, hash[:2], hash)
if fileExists(p) {
return p, nil
}
}
// 5) recursive search
var best string
var bestMod time.Time
_ = filepath.WalkDir(s.objects, func(p string, d fs.DirEntry, err error) error {
if err != nil || d.IsDir() {
return nil
}
base := filepath.Base(p)
if base == hash {
best = p
return fs.SkipDir
}
parent := filepath.Base(filepath.Dir(p))
if parent == hash {
if fi, err := os.Stat(p); err == nil && fi.Mode().IsRegular() {
if best == "" || fi.ModTime().After(bestMod) {
best, bestMod = p, fi.ModTime()
}
}
}
return nil
})
if best != "" {
return best, nil
}
return "", os.ErrNotExist
}
func fileExists(p string) bool {
fi, err := os.Stat(p)
return err == nil && fi.Mode().IsRegular()
}
func (s *FSStore) Put(hash string, r io.Reader) error {
p, err := s.pathFlat(hash)
if err != nil {
return err
}
if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
return err
}
tmp := p + ".tmp"
f, err := os.Create(tmp)
if err != nil {
return err
}
_, werr := io.Copy(f, r)
cerr := f.Close()
if werr != nil {
_ = os.Remove(tmp)
return werr
}
if cerr != nil {
_ = os.Remove(tmp)
return cerr
}
return os.Rename(tmp, p)
}
func (s *FSStore) Get(hash string) (io.ReadCloser, int64, error) {
p, err := s.findBlobPath(hash)
if err != nil {
return nil, 0, err return nil, 0, err
} }
f, err := os.Open(p) f, err := os.Open(fs.pathFor(hash))
if err != nil { if err != nil {
return nil, 0, err return nil, 0, err
} }
st, err := f.Stat() st, err := f.Stat()
if err != nil { if err != nil {
return f, 0, nil _ = f.Close()
return nil, 0, err
} }
return f, st.Size(), nil return f, st.Size(), nil
} }
func (s *FSStore) Delete(hash string) error { // Put implements BlobStore.Put
if p, _ := s.pathFlat(hash); fileExists(p) { func (fs *SimpleFSStore) Put(r io.Reader, private bool) (string, int64, time.Time, error) {
if err := os.Remove(p); err == nil || errors.Is(err, os.ErrNotExist) { if err := fs.ensureRoot(); err != nil {
return nil return "", 0, time.Time{}, err
}
tmp, err := os.CreateTemp(fs.root, "put-*")
if err != nil {
return "", 0, time.Time{}, err
}
defer func() {
_ = tmp.Close()
_ = os.Remove(tmp.Name())
}()
h := sha256.New()
w := io.MultiWriter(tmp, h)
n, err := io.Copy(w, r)
if err != nil {
return "", 0, time.Time{}, err
}
hash := hex.EncodeToString(h.Sum(nil))
final := fs.pathFor(hash)
if err := os.Rename(tmp.Name(), final); err != nil {
return "", 0, time.Time{}, err
}
if private {
if err := os.WriteFile(fs.privPathFor(hash), nil, 0o600); err != nil {
_ = os.Remove(final)
return "", 0, time.Time{}, err
} }
} }
dir := filepath.Join(s.objects, hash)
for _, cand := range []string{"blob", "data", "content"} { st, err := os.Stat(final)
p := filepath.Join(dir, cand) if err != nil {
if fileExists(p) { return "", 0, time.Time{}, err
if err := os.Remove(p); err == nil || errors.Is(err, os.ErrNotExist) {
return nil
}
}
} }
if len(hash) >= 2 { return hash, n, st.ModTime().UTC(), nil
p := filepath.Join(s.objects, hash[:2], hash)
if fileExists(p) {
if err := os.Remove(p); err == nil || errors.Is(err, os.ErrNotExist) {
return nil
}
}
}
if p, err := s.findBlobPath(hash); err == nil {
if err := os.Remove(p); err == nil || errors.Is(err, os.ErrNotExist) {
return nil
}
}
return nil
} }
func (s *FSStore) Walk(fn func(hash string, size int64, mod time.Time) error) error { // Delete implements BlobStore.Delete
type rec struct { func (fs *SimpleFSStore) Delete(hash string) error {
size int64 if err := fs.ensureRoot(); err != nil {
mod time.Time return err
} }
agg := make(map[string]rec) _ = os.Remove(fs.privPathFor(hash))
_ = filepath.WalkDir(s.objects, func(p string, d fs.DirEntry, err error) error { return os.Remove(fs.pathFor(hash))
if err != nil || d.IsDir() { }
return nil
} // Walk implements BlobStore.Walk
fi, err := os.Stat(p) func (fs *SimpleFSStore) Walk(fn func(hash string, bytes int64, private bool, storedAt time.Time) error) (int, error) {
if err != nil || !fi.Mode().IsRegular() { if err := fs.ensureRoot(); err != nil {
return nil return 0, err
} }
base := filepath.Base(p) ents, err := os.ReadDir(fs.root)
if isHexHash(base) { if err != nil {
if r, ok := agg[base]; !ok || fi.ModTime().After(r.mod) { return 0, err
agg[base] = rec{fi.Size(), fi.ModTime()} }
} count := 0
return nil for _, e := range ents {
} if e.IsDir() {
parent := filepath.Base(filepath.Dir(p)) continue
if isHexHash(parent) { }
if r, ok := agg[parent]; !ok || fi.ModTime().After(r.mod) { name := e.Name()
agg[parent] = rec{fi.Size(), fi.ModTime()} // skip sidecars and non-64-hex filenames
} if strings.HasSuffix(name, ".priv") || len(name) != 64 || !isHex(name) {
return nil continue
} }
if len(base) == 64 && isHexHash(strings.ToLower(base)) { full := fs.pathFor(name)
if r, ok := agg[base]; !ok || fi.ModTime().After(r.mod) { st, err := os.Stat(full)
agg[base] = rec{fi.Size(), fi.ModTime()} if err != nil {
} continue
} }
return nil private := false
}) if _, err := os.Stat(fs.privPathFor(name)); err == nil {
for h, r := range agg { private = true
if err := fn(h, r.size, r.mod); err != nil { }
return err if err := fn(name, st.Size(), private, st.ModTime().UTC()); err != nil {
} return count, err
} }
return nil count++
}
return count, nil
}
func isHex(s string) bool {
for i := 0; i < len(s); i++ {
c := s[i]
if !((c >= '0' && c <= '9') ||
(c >= 'a' && c <= 'f') ||
(c >= 'A' && c <= 'F')) {
return false
}
}
return true
} }