From 60c586001cf4d21ef1351be8c8ad7a269a6f005a Mon Sep 17 00:00:00 2001 From: Elvis Claros Castro Date: Sat, 3 Oct 2026 19:03:27 -0300 Subject: Share one session through a public link claude-logbook -s REF --share uploads a session to a share server and prints its link; --shares lists them, --unshare deletes them, --expire picks how long they live. Before uploading it shows what goes up and warns about anything that looks like a credential. server/ is that share server: Go, standard library only, a FROM scratch image. It serves /share/ as a page, .txt and .json, accepts only the JSON payload (never HTML), pins the template's scripts with a CSP, keeps secrets hashed and rate-limits per client IP. --- server/.gitignore | 1 + server/README.md | 115 ++++++++++++++ server/go.mod | 3 + server/home.html | 101 ++++++++++++ server/limit.go | 127 +++++++++++++++ server/main.go | 431 ++++++++++++++++++++++++++++++++++++++++++++++++++ server/render.go | 206 ++++++++++++++++++++++++ server/server_test.go | 269 +++++++++++++++++++++++++++++++ server/store.go | 265 +++++++++++++++++++++++++++++++ 9 files changed, 1518 insertions(+) create mode 100644 server/.gitignore create mode 100644 server/README.md create mode 100644 server/go.mod create mode 100644 server/home.html create mode 100644 server/limit.go create mode 100644 server/main.go create mode 100644 server/render.go create mode 100644 server/server_test.go create mode 100644 server/store.go (limited to 'server') diff --git a/server/.gitignore b/server/.gitignore new file mode 100644 index 0000000..93598e4 --- /dev/null +++ b/server/.gitignore @@ -0,0 +1 @@ +template.html diff --git a/server/README.md b/server/README.md new file mode 100644 index 0000000..8e2de37 --- /dev/null +++ b/server/README.md @@ -0,0 +1,115 @@ +# claude-logbook share server + +Serves the sessions published with `claude-logbook -s REF --share`: + +| Route | | +| --- | --- | +| `GET /` | Home with the instructions. | +| `GET /share/` | The conversation as a page (the CLI's `template.html`). | +| `GET /share/.txt` | Plain text transcript. | +| `GET /share/.json` | The stored payload. | +| `POST /api/shares` | `{"payload": {...}, "expire": "30d"}` → `201 {id, url, secret, expires}` | +| `PUT /api/shares/` | `Authorization: Bearer `; replaces the payload. | +| `DELETE /api/shares/` | `Authorization: Bearer `. | +| `GET /healthz` | `ok`. | + +Anyone can create a share; only the holder of the secret returned on +creation can replace or delete it. The server keeps only the secret's SHA-256. + +## Security model + +- **No HTML is accepted.** The payload is the JSON of `claude-logbook --json -s`; + it is checked field by field, unknown keys are dropped, memories are refused, + and the page is built from the template embedded in the binary. +- The data goes inside ``) + +// NewPage splits the template at its single marker and computes the CSP that +// allows exactly its inline scripts. +func NewPage(template string) (*Page, error) { + if n := strings.Count(template, dataMarker); n != 1 { + return nil, fmt.Errorf("template must contain exactly one %s (found %d)", dataMarker, n) + } + var hashes []string + for _, m := range scriptRE.FindAllStringSubmatch(template, -1) { + if strings.Contains(m[1], "application/json") { + continue // data, not code: CSP does not apply to it + } + sum := sha256.Sum256([]byte(m[2])) + hashes = append(hashes, "'sha256-"+base64.StdEncoding.EncodeToString(sum[:])+"'") + } + if len(hashes) == 0 { + return nil, errors.New("template has no scripts") + } + before, after, _ := strings.Cut(template, dataMarker) + csp := "default-src 'none'; script-src " + strings.Join(hashes, " ") + + "; style-src 'unsafe-inline'; img-src data:; base-uri 'none'; " + + "form-action 'none'; frame-ancestors 'none'" + return &Page{before: before, after: after, csp: csp}, nil +} + +// EncodeData does what encode_payload in webpage.py does: the HTML parser +// ends a tag."}]}` + +func payload(sessions ...string) string { + if len(sessions) == 0 { + sessions = []string{session} + } + return `{"s":[` + strings.Join(sessions, ",") + `],"m":[]}` +} + +type harness struct { + t *testing.T + srv *Server + h http.Handler +} + +func newHarness(t *testing.T, mod func(*Config)) *harness { + t.Helper() + cfg := Config{Addr: ":0", DataDir: t.TempDir(), PublicURL: "https://x.test", + MaxBytes: 1 << 20, MaxSessions: 1, TrustedProxy: "10.0.0.1", + CreatesPerH: 100, WritesPerH: 100} + if mod != nil { + mod(&cfg) + } + srv, err := NewServer(cfg) + if err != nil { + t.Fatal(err) + } + return &harness{t: t, srv: srv, h: srv.Routes()} +} + +func (h *harness) do(method, path, body, secret string) *httptest.ResponseRecorder { + req := httptest.NewRequest(method, path, strings.NewReader(body)) + req.RemoteAddr = "192.0.2.1:1234" + if secret != "" { + req.Header.Set("Authorization", "Bearer "+secret) + } + rec := httptest.NewRecorder() + h.h.ServeHTTP(rec, req) + return rec +} + +func (h *harness) create(body string) shareResp { + h.t.Helper() + rec := h.do("POST", "/api/shares", body, "") + if rec.Code != http.StatusCreated { + h.t.Fatalf("create: %d %s", rec.Code, rec.Body) + } + var r shareResp + if err := json.Unmarshal(rec.Body.Bytes(), &r); err != nil { + h.t.Fatal(err) + } + return r +} + +func TestCreateAndRead(t *testing.T) { + h := newHarness(t, nil) + r := h.create(`{"payload":` + payload() + `,"expire":"7d"}`) + if !ValidID(r.ID) || r.Secret == "" || r.URL != "https://x.test/share/"+r.ID { + t.Fatalf("bad response %+v", r) + } + if d := time.Until(r.Expires); d < 6*24*time.Hour || d > 8*24*time.Hour { + t.Fatalf("expiry %v", r.Expires) + } + + page := h.do("GET", "/share/"+r.ID, "", "") + if page.Code != 200 || !strings.Contains(page.Header().Get("Content-Type"), "text/html") { + t.Fatalf("html: %d", page.Code) + } + csp := page.Header().Get("Content-Security-Policy") + if !strings.Contains(csp, "script-src 'sha256-") || strings.Contains(csp, "unsafe-inline' ;") { + t.Fatalf("csp: %s", csp) + } + if page.Header().Get("X-Robots-Tag") == "" { + t.Fatal("no X-Robots-Tag") + } + body := page.Body.String() + // The data block must hold exactly one : its own end. + start := strings.Index(body, `") + if strings.Contains(body[start:start+end], " tag." { + t.Fatalf("json roundtrip: %v %s", err, js.Body) + } + + if rec := h.do("GET", "/share/"+r.ID+".pdf", "", ""); rec.Code != 404 { + t.Fatalf("unknown extension: %d", rec.Code) + } +} + +func TestUpdateAndDeleteNeedTheSecret(t *testing.T) { + h := newHarness(t, nil) + r := h.create(`{"payload":` + payload() + `}`) + newer := strings.Replace(payload(), "Fix the build", "Fixed the build", 1) + + if rec := h.do("PUT", "/api/shares/"+r.ID, `{"payload":`+newer+`}`, ""); rec.Code != 401 { + t.Fatalf("no secret: %d", rec.Code) + } + if rec := h.do("PUT", "/api/shares/"+r.ID, `{"payload":`+newer+`}`, "nope"); rec.Code != 403 { + t.Fatalf("wrong secret: %d", rec.Code) + } + if rec := h.do("PUT", "/api/shares/"+r.ID, `{"payload":`+newer+`}`, r.Secret); rec.Code != 200 { + t.Fatalf("update: %d %s", rec.Code, rec.Body) + } + if !strings.Contains(h.do("GET", "/share/"+r.ID+".txt", "", "").Body.String(), "Fixed the build") { + t.Fatal("update not visible") + } + if rec := h.do("DELETE", "/api/shares/"+r.ID, "", "nope"); rec.Code != 403 { + t.Fatalf("delete wrong secret: %d", rec.Code) + } + if rec := h.do("DELETE", "/api/shares/"+r.ID, "", r.Secret); rec.Code != 204 { + t.Fatalf("delete: %d", rec.Code) + } + if rec := h.do("GET", "/share/"+r.ID, "", ""); rec.Code != 404 { + t.Fatalf("after delete: %d", rec.Code) + } + if rec := h.do("DELETE", "/api/shares/"+r.ID, "", r.Secret); rec.Code != 404 { + t.Fatalf("delete twice: %d", rec.Code) + } +} + +func TestExpiry(t *testing.T) { + h := newHarness(t, nil) + r := h.create(`{"payload":` + payload() + `,"expire":"1d"}`) + h.srv.store.now = func() time.Time { return time.Now().Add(25 * time.Hour) } + if rec := h.do("GET", "/share/"+r.ID, "", ""); rec.Code != 404 { + t.Fatalf("expired share served: %d", rec.Code) + } + if n := h.srv.store.Sweep(); n != 1 { + t.Fatalf("swept %d", n) + } +} + +func TestNotFound(t *testing.T) { + h := newHarness(t, nil) + for _, p := range []string{"/share/AAAAAAAAAA", "/share/..%2Fetc%2Fpasswd", "/share/x", "/nope"} { + if rec := h.do("GET", p, "", ""); rec.Code != 404 { + t.Fatalf("%s: %d", p, rec.Code) + } + } +} + +func TestRejectsBadPayloads(t *testing.T) { + h := newHarness(t, nil) + bad := map[string]string{ + "html": `{"payload":""}`, + "no sessions": `{"payload":{"s":[],"m":[]}}`, + "two sessions": `{"payload":` + payload(session, session) + `}`, + "bad role": `{"payload":` + payload(strings.Replace(session, `"r":"t"`, `"r":"z"`, 1)) + `}`, + "bad type": `{"payload":` + payload(strings.Replace(session, `"u":1`, `"u":"1"`, 1)) + `}`, + "memories": `{"payload":{"s":[` + session + `],"m":[{"name":"x"}]}}`, + "bad expire": `{"payload":` + payload() + `,"expire":"never"}`, + "extra field": `{"payload":` + payload() + `,"html":"x"}`, + "no payload": `{"expire":"1d"}`, + "not json": `hello`, + } + for name, body := range bad { + if rec := h.do("POST", "/api/shares", body, ""); rec.Code != 400 { + t.Errorf("%s: %d %s", name, rec.Code, rec.Body) + } + } +} + +func TestUnknownKeysAreDropped(t *testing.T) { + h := newHarness(t, nil) + evil := strings.Replace(session, `"ai":true`, `"ai":true,"evil":""`, 1) + r := h.create(`{"payload":{"s":[` + evil + `],"m":[],"x":1}}`) + js := h.do("GET", "/share/"+r.ID+".json", "", "").Body.String() + if strings.Contains(js, "evil") || strings.Contains(js, `"x":1`) { + t.Fatalf("unknown keys kept: %s", js) + } +} + +func TestTooLarge(t *testing.T) { + h := newHarness(t, func(c *Config) { c.MaxBytes = 512 }) + big := payload(strings.Replace(session, "why does", strings.Repeat("x", 1000), 1)) + if rec := h.do("POST", "/api/shares", `{"payload":`+big+`}`, ""); rec.Code != 413 { + t.Fatalf("too large: %d %s", rec.Code, rec.Body) + } +} + +func TestRateLimit(t *testing.T) { + h := newHarness(t, func(c *Config) { c.CreatesPerH = 2 }) + body := `{"payload":` + payload() + `}` + h.create(body) + h.create(body) + if rec := h.do("POST", "/api/shares", body, ""); rec.Code != 429 { + t.Fatalf("third create: %d", rec.Code) + } +} + +func TestClientIP(t *testing.T) { + c, err := NewClientIP("10.0.0.1, 172.16.0.0/12") + if err != nil { + t.Fatal(err) + } + cases := []struct{ remote, xff, want string }{ + {"192.0.2.1:1", "203.0.113.9", "192.0.2.1"}, // not the proxy: header ignored + {"10.0.0.1:1", "203.0.113.9", "203.0.113.9"}, // the proxy + {"10.0.0.1:1", "6.6.6.6, 203.0.113.9", "203.0.113.9"}, // client forged the left part + {"172.20.0.5:1", "203.0.113.9, 10.0.0.1", "203.0.113.9"}, // chain of proxies + {"10.0.0.1:1", "", "10.0.0.1"}, + } + for _, tc := range cases { + r := httptest.NewRequest("GET", "/", nil) + r.RemoteAddr = tc.remote + if tc.xff != "" { + r.Header.Set("X-Forwarded-For", tc.xff) + } + if got := c.Of(r); got != tc.want { + t.Errorf("%s %q: got %s want %s", tc.remote, tc.xff, got, tc.want) + } + } +} + +func TestHome(t *testing.T) { + h := newHarness(t, nil) + rec := h.do("GET", "/", "", "") + if rec.Code != 200 || !strings.Contains(rec.Body.String(), "https://x.test/share/<id>.txt") { + t.Fatalf("home: %d", rec.Code) + } + if strings.Contains(rec.Body.String(), "{{") { + t.Fatal("placeholder left") + } + if rec := h.do("GET", "/healthz", "", ""); rec.Code != 200 { + t.Fatalf("healthz: %d", rec.Code) + } +} + +func TestStoredFilesArePrivate(t *testing.T) { + h := newHarness(t, nil) + r := h.create(`{"payload":` + payload() + `}`) + raw, meta, err := h.srv.store.Get(r.ID) + if err != nil || len(raw) == 0 { + t.Fatal(err) + } + if meta.SecretHash == r.Secret || !bytes.Equal([]byte(meta.SecretHash), []byte(hashOf(r.Secret))) { + t.Fatal("secret must be stored hashed") + } +} diff --git a/server/store.go b/server/store.go new file mode 100644 index 0000000..b4b4b7c --- /dev/null +++ b/server/store.go @@ -0,0 +1,265 @@ +package main + +// Shares live as two files in the data directory: +// +// .json the payload exactly as it was uploaded +// .meta who may change it and until when it lives +// +// No database: the binary stays static and fits in a scratch image. Every +// write goes to a temporary file that is then renamed over the old one. + +import ( + "crypto/rand" + "crypto/sha256" + "crypto/subtle" + "encoding/base64" + "encoding/hex" + "encoding/json" + "errors" + "math/big" + "os" + "path/filepath" + "regexp" + "strings" + "sync" + "time" +) + +const idLen = 10 + +var ( + idRE = regexp.MustCompile(`^[0-9A-Za-z]{10}$`) + ErrNotFound = errors.New("not found") + ErrDenied = errors.New("wrong secret") +) + +const base62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + +type Meta struct { + SecretHash string `json:"secret_hash"` + Created time.Time `json:"created"` + Updated time.Time `json:"updated"` + Expires time.Time `json:"expires"` + IPHash string `json:"ip_hash"` +} + +type Store struct { + dir string + mu sync.Mutex // serializes writes; reads go straight to disk + now func() time.Time +} + +func NewStore(dir string) (*Store, error) { + if err := os.MkdirAll(dir, 0o700); err != nil { + return nil, err + } + return &Store{dir: dir, now: func() time.Time { return time.Now().UTC() }}, nil +} + +func ValidID(id string) bool { return idRE.MatchString(id) } + +func newID() (string, error) { + var b strings.Builder + max := big.NewInt(int64(len(base62))) + for i := 0; i < idLen; i++ { + n, err := rand.Int(rand.Reader, max) + if err != nil { + return "", err + } + b.WriteByte(base62[n.Int64()]) + } + return b.String(), nil +} + +func newSecret() (string, error) { + buf := make([]byte, 32) + if _, err := rand.Read(buf); err != nil { + return "", err + } + return base64.RawURLEncoding.EncodeToString(buf), nil +} + +func hashOf(s string) string { + sum := sha256.Sum256([]byte(s)) + return hex.EncodeToString(sum[:]) +} + +func (s *Store) path(id, ext string) string { return filepath.Join(s.dir, id+ext) } + +func writeAtomic(path string, data []byte) error { + tmp, err := os.CreateTemp(filepath.Dir(path), ".tmp-*") + if err != nil { + return err + } + defer os.Remove(tmp.Name()) // no-op once renamed + if _, err := tmp.Write(data); err != nil { + tmp.Close() + return err + } + if err := tmp.Chmod(0o600); err != nil { + tmp.Close() + return err + } + if err := tmp.Close(); err != nil { + return err + } + return os.Rename(tmp.Name(), path) +} + +func (s *Store) readMeta(id string) (Meta, error) { + var m Meta + raw, err := os.ReadFile(s.path(id, ".meta")) + if errors.Is(err, os.ErrNotExist) { + return m, ErrNotFound + } + if err != nil { + return m, err + } + if err := json.Unmarshal(raw, &m); err != nil { + return m, err + } + if !s.now().Before(m.Expires) { + return m, ErrNotFound + } + return m, nil +} + +func (s *Store) writeMeta(id string, m Meta) error { + raw, err := json.Marshal(m) + if err != nil { + return err + } + return writeAtomic(s.path(id, ".meta"), raw) +} + +// Create stores a new share and returns its id and secret. The secret is +// only ever kept hashed. +func (s *Store) Create(payload []byte, ttl time.Duration, ip string) (string, string, Meta, error) { + s.mu.Lock() + defer s.mu.Unlock() + secret, err := newSecret() + if err != nil { + return "", "", Meta{}, err + } + for { + id, err := newID() + if err != nil { + return "", "", Meta{}, err + } + if _, err := os.Stat(s.path(id, ".meta")); err == nil { + continue // taken, even if expired and not swept yet + } + now := s.now() + m := Meta{SecretHash: hashOf(secret), Created: now, Updated: now, + Expires: now.Add(ttl), IPHash: hashOf(ip)} + // Payload first: a meta without payload would be a share that 500s. + if err := writeAtomic(s.path(id, ".json"), payload); err != nil { + return "", "", Meta{}, err + } + if err := s.writeMeta(id, m); err != nil { + os.Remove(s.path(id, ".json")) + return "", "", Meta{}, err + } + return id, secret, m, nil + } +} + +// Get returns the payload of a live share. +func (s *Store) Get(id string) ([]byte, Meta, error) { + if !ValidID(id) { + return nil, Meta{}, ErrNotFound + } + m, err := s.readMeta(id) + if err != nil { + return nil, m, err + } + raw, err := os.ReadFile(s.path(id, ".json")) + if errors.Is(err, os.ErrNotExist) { + return nil, m, ErrNotFound + } + return raw, m, err +} + +func (s *Store) authorize(id, secret string) (Meta, error) { + if !ValidID(id) { + return Meta{}, ErrNotFound + } + m, err := s.readMeta(id) + if err != nil { + return m, err + } + if subtle.ConstantTimeCompare([]byte(hashOf(secret)), []byte(m.SecretHash)) != 1 { + return m, ErrDenied + } + return m, nil +} + +// Update replaces the payload; ttl > 0 also restarts the expiry from now. +func (s *Store) Update(id, secret string, payload []byte, ttl time.Duration) (Meta, error) { + s.mu.Lock() + defer s.mu.Unlock() + m, err := s.authorize(id, secret) + if err != nil { + return m, err + } + if err := writeAtomic(s.path(id, ".json"), payload); err != nil { + return m, err + } + m.Updated = s.now() + if ttl > 0 { + m.Expires = m.Updated.Add(ttl) + } + return m, s.writeMeta(id, m) +} + +func (s *Store) Delete(id, secret string) error { + s.mu.Lock() + defer s.mu.Unlock() + if _, err := s.authorize(id, secret); err != nil { + return err + } + s.remove(id) + return nil +} + +func (s *Store) remove(id string) { + // Meta first: without it the share is already gone for readers. + os.Remove(s.path(id, ".meta")) + os.Remove(s.path(id, ".json")) +} + +// Sweep deletes expired shares, payloads left without meta and stale +// temporary files. Returns how many shares it removed. +func (s *Store) Sweep() int { + s.mu.Lock() + defer s.mu.Unlock() + entries, err := os.ReadDir(s.dir) + if err != nil { + return 0 + } + now := s.now() + removed := 0 + for _, e := range entries { + name := e.Name() + switch { + case strings.HasPrefix(name, ".tmp-"): + if info, err := e.Info(); err == nil && now.Sub(info.ModTime()) > time.Hour { + os.Remove(filepath.Join(s.dir, name)) + } + case strings.HasSuffix(name, ".meta"): + id := strings.TrimSuffix(name, ".meta") + if _, err := s.readMeta(id); errors.Is(err, ErrNotFound) { + s.remove(id) + removed++ + } + case strings.HasSuffix(name, ".json"): + id := strings.TrimSuffix(name, ".json") + if _, err := os.Stat(s.path(id, ".meta")); errors.Is(err, os.ErrNotExist) { + if info, err := e.Info(); err == nil && now.Sub(info.ModTime()) > time.Hour { + os.Remove(filepath.Join(s.dir, name)) + } + } + } + } + return removed +} -- cgit v1.2.3