4d9a26498e
Paste a secret, get a link, send it. The first person to open it and press
Reveal sees the secret; the link dies at that moment. The recipient needs a
browser and nothing else — no account, no client, no installed tooling.
The server cannot read what it stores. AES-256-GCM happens in the browser and
the key lives in the URL fragment, which browsers never transmit, so hushd
holds ciphertext and no key material. That is a property of where the key sits
rather than a promise about our conduct, which is why there is deliberately no
endpoint accepting a plaintext secret and no server-side-encryption fallback:
two guarantees behind one URL would be worse than one honest guarantee.
Three decisions carry the design:
* GET /s/{id} touches NO storage, not even to check existence. Slack, Teams,
WhatsApp, iMessage and Outlook Safe Links all fetch a URL before a human
sees it, so destroying on GET would destroy most secrets in transit and the
recipient's "already used" would be indistinguishable from interception.
Only POST /reveal consumes. Bot user-agent detection is an arms race;
removing the side effect from GET is not. Pinned by
TestGettingTheRevealPageNeverConsumesTheSecret.
* Destruction is one Redis GETDEL, which is atomic. GET-then-DEL has a window
where two simultaneous readers both win, and for a one-time secret that
window is the product. The store contract demands atomicity and the same
concurrency test runs against both implementations.
* Missing, already-revealed, expired and evicted are ONE indistinguishable
410. Separating them would confirm to a prober that a given link was real.
The secret id IS the capability, so secret.ID is a struct whose every
accidental path — %v, %s, String(), slog, json.Marshal — emits a redacted
handle or refuses, and the raw value needs an explicit Value(). The first
version tried to prevent leaks by implementing no String() at all; its own test
caught that Go's fmt prints unexported fields anyway, so forbidding the method
had removed the control rather than the leak.
Operationally: structured JSON on stdout in the fleet's wire format, which
Vector already collects with no annotation; six hush_* metrics on the chassis
registry with no id, IP or path in any label; five alert rules wired into
vmalert. The public Ingress enumerates /, /s/ and /api/ so /metrics, /healthz
and /readyz share the port but are unreachable from the internet — no
basic-auth middleware to maintain and get wrong.
Dependencies are vendored because go-chassis is private: the Woodpecker test
step and the in-cluster Kaniko build both run -mod=vendor with GOPROXY=off and
hold no git credential.
cmd/hush-mcp is a stdio MCP server doing the same client-side crypto locally,
so using hush from an agent preserves the same guarantee as using it from a
browser.
56 lines
1.6 KiB
Go
56 lines
1.6 KiB
Go
// Copyright 2022 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package cpu
|
|
|
|
import "strconv"
|
|
|
|
// parseRelease parses a dot-separated version number from the prefix
|
|
// of rel. It returns ok=true only if at least the major and minor
|
|
// components were successfully parsed; the patch component is
|
|
// best-effort. Trailing vendor or build suffixes such as
|
|
// "-generic", "+", "_hi3535", or "-rc1" are ignored.
|
|
//
|
|
// This is a copy of the Go runtime's parseRelease from
|
|
// https://golang.org/cl/209597, updated in https://golang.org/cl/781800.
|
|
func parseRelease(rel string) (major, minor, patch int, ok bool) {
|
|
// next consumes a run of decimal digits from the front of rel,
|
|
// returning the parsed value. If the digits are followed by a
|
|
// '.', it is consumed and more is set so the caller knows to
|
|
// parse another component; otherwise scanning terminates and
|
|
// the rest of rel is discarded.
|
|
next := func() (n int, more, ok bool) {
|
|
i := 0
|
|
for i < len(rel) && rel[i] >= '0' && rel[i] <= '9' {
|
|
i++
|
|
}
|
|
if i == 0 {
|
|
return 0, false, false
|
|
}
|
|
n, err := strconv.Atoi(rel[:i])
|
|
if err != nil {
|
|
return 0, false, false
|
|
}
|
|
if i < len(rel) && rel[i] == '.' {
|
|
rel = rel[i+1:]
|
|
return n, true, true
|
|
}
|
|
rel = ""
|
|
return n, false, true
|
|
}
|
|
|
|
var more bool
|
|
if major, more, ok = next(); !ok || !more {
|
|
return 0, 0, 0, false
|
|
}
|
|
if minor, more, ok = next(); !ok {
|
|
return 0, 0, 0, false
|
|
}
|
|
if !more {
|
|
return major, minor, 0, true
|
|
}
|
|
patch, _, _ = next()
|
|
return major, minor, patch, true
|
|
}
|