0
0
package plc
import (
"cmp"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"strconv"
"sync"
"time"
"github.com/bluesky-social/indigo/atproto/atdata"
"github.com/johnandersen777/socialweb-computer-kcp/internal/didkey"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/httpjson"
)
type Error struct {
Status int
Message string
}
func (e *Error) Error() string { return e.Message }
func errorf(status int, format string, args ...any) *Error {
return &Error{Status: status, Message: fmt.Sprintf(format, args...)}
}
type Options struct {
Store Store
Version string
VerifySignature func(ctx context.Context, did string, data, sig []byte) (bool, error)
}
type Server struct {
store Store
version string
verifySig func(ctx context.Context, did string, data, sig []byte) (bool, error)
mu sync.Mutex
handler http.Handler
}
func NewServer(opts Options) *Server {
store := opts.Store
if store == nil {
store = NewMemoryStore()
}
version := opts.Version
version = cmp.Or(version, "0.1.0")
s := &Server{store: store, version: version, verifySig: opts.VerifySignature}
if s.verifySig == nil {
s.verifySig = func(ctx context.Context, did string, data, sig []byte) (bool, error) {
err := didkey.Verify(did, data, sig)
if err != nil {
return false, err
}
return true, nil
}
}
mux := http.NewServeMux()
mux.HandleFunc("GET /health", s.handleHealth)
mux.HandleFunc("GET /export", s.handleExport)
mux.HandleFunc("GET /{did}", s.handleResolve)
mux.HandleFunc("POST /{did}", s.handleSubmit)
mux.HandleFunc("GET /{did}/log", s.handleLog)
mux.HandleFunc("GET /{did}/log/audit", s.handleAudit)
mux.HandleFunc("GET /{did}/log/last", s.handleLogLast)
mux.HandleFunc("GET /{did}/data", s.handleData)
s.handler = withCORS(mux)
return s
}
func (s *Server) Store() Store { return s.store }
func (s *Server) Handler() http.Handler { return s.handler }
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
s.handler.ServeHTTP(w, r)
}
func (s *Server) Submit(ctx context.Context, did string, raw map[string]any) (*LogEntry, error) {
if _, ok := raw["type"]; !ok {
return nil, errorf(400, "Operation must be an object")
}
if msg := ValidateStructure(raw); msg != "" {
return nil, errorf(400, "%s", msg)
}
op := NewOperationFromObject(raw)
s.mu.Lock()
defer s.mu.Unlock()
audit, err := s.store.GetAuditLog(ctx, did)
if err != nil {
return nil, err
}
current, err := s.store.GetCurrentOps(ctx, did)
if err != nil {
return nil, err
}
switch op.Type {
case TypeCreate:
if len(audit) > 0 {
return nil, errorf(400, "Genesis operation requires empty log")
}
case TypeOperation, TypeTombstone:
if op.Prev == nil && len(audit) > 0 {
return nil, errorf(400, "Genesis operation requires empty log")
}
if err := validatePrevChain(op.Prev, current); err != nil {
return nil, err
}
if len(current) > 0 {
head := current[len(current)-1].Operation
if head.Type == TypeTombstone {
return nil, errorf(410, "DID not available: %s", did)
}
if head.Type == TypeOperation {
if !s.verifySignatures(ctx, op, head.RotationKeys) {
return nil, errorf(400, "Invalid Signature")
}
}
} else {
if !s.verifySignatures(ctx, op, op.RotationKeys) {
return nil, errorf(400, "Invalid Signature")
}
if op.Type == TypeOperation {
derived, err := OperationDID(op)
if err != nil {
return nil, errorf(400, "Failed to compute operation CID")
}
if derived != did {
return nil, errorf(400, "DID does not match operation")
}
}
}
default:
return nil, errorf(400, "Unknown operation type: %s", op.Type)
}
cid, err := OperationCID(op)
if err != nil {
return nil, errorf(400, "Failed to compute operation CID")
}
if op.Type == TypeOperation && op.Prev != nil && len(current) > 0 {
prevIdx := -1
for i := range current {
if current[i].CID == *op.Prev {
prevIdx = i
break
}
}
if prevIdx >= 0 && prevIdx < len(current)-1 {
toNullify := make([]string, 0, len(current)-prevIdx-1)
for _, e := range current[prevIdx+1:] {
toNullify = append(toNullify, e.CID)
}
if err := s.store.NullifyOps(ctx, did, toNullify); err != nil {
return nil, err
}
}
}
entry := LogEntry{
DID: did,
Operation: *op,
CID: cid,
Nullified: false,
CreatedAt: time.Now().UTC().Format("2006-01-02T15:04:05.000Z"),
}
if err := s.store.InsertOp(ctx, entry); err != nil {
return nil, err
}
return &entry, nil
}
func (s *Server) Resolve(ctx context.Context, did string) (*DIDDocument, error) {
ops, err := s.store.GetCurrentOps(ctx, did)
if err != nil {
return nil, err
}
if len(ops) == 0 {
return nil, errorf(404, "DID not registered: %s", did)
}
if ops[len(ops)-1].Operation.Type == TypeTombstone {
return nil, errorf(410, "DID not available: %s", did)
}
doc := ResolveDocument(did, ops)
if doc == nil {
return nil, errorf(410, "DID not available: %s", did)
}
return doc, nil
}
func (s *Server) Log(ctx context.Context, did string) ([]Operation, error) {
ops, err := s.store.GetCurrentOps(ctx, did)
if err != nil {
return nil, err
}
if len(ops) == 0 {
return nil, errorf(404, "DID not registered: %s", did)
}
out := make([]Operation, len(ops))
for i, e := range ops {
out[i] = e.Operation
}
return out, nil
}
func (s *Server) AuditLog(ctx context.Context, did string) ([]LogEntry, error) {
ops, err := s.store.GetAuditLog(ctx, did)
if err != nil {
return nil, err
}
if len(ops) == 0 {
return nil, errorf(404, "DID not registered: %s", did)
}
return ops, nil
}
func (s *Server) Export(ctx context.Context, after *time.Time, count int) ([]LogEntry, error) {
return s.store.ExportLogs(ctx, after, count)
}
func (s *Server) verifySignatures(ctx context.Context, op *Operation, keys []string) bool {
sig, err := decodeSignature(op.Sig)
if err != nil {
return false
}
unsigned, err := atdata.MarshalCBOR(op.UnsignedObject())
if err != nil {
return false
}
for _, key := range keys {
ok, err := s.verifySig(ctx, key, unsigned, sig)
if err == nil && ok {
return true
}
}
return false
}
func validatePrevChain(prev *string, current []LogEntry) *Error {
if prev == nil {
if len(current) > 0 {
return errorf(400, "Genesis operation requires empty log")
}
return nil
}
for _, e := range current {
if e.CID == *prev {
return nil
}
}
return errorf(400, "prev CID not found in current chain: %s", *prev)
}
func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
httpjson.Write(w, http.StatusOK, map[string]string{"version": s.version})
}
func (s *Server) handleExport(w http.ResponseWriter, r *http.Request) {
q := r.URL.Query()
var after *time.Time
if v := q.Get("after"); v != "" {
t, err := time.Parse(time.RFC3339Nano, v)
if err != nil {
httpjson.Write(w, http.StatusBadRequest, map[string]string{"message": "Invalid Query Parameter: after"})
return
}
after = &t
}
count := -1
if v := q.Get("count"); v != "" {
n, err := strconv.Atoi(v)
if err != nil || n < 0 {
httpjson.Write(w, http.StatusBadRequest, map[string]string{"message": "Invalid Query Parameter: count"})
return
}
count = min(n, 1000)
}
entries, err := s.store.ExportLogs(r.Context(), after, count)
if err != nil {
writeError(w, err)
return
}
httpjson.Write(w, http.StatusOK, entries)
}
func (s *Server) handleResolve(w http.ResponseWriter, r *http.Request) {
doc, err := s.Resolve(r.Context(), r.PathValue("did"))
if err != nil {
writeError(w, err)
return
}
httpjson.Write(w, http.StatusOK, doc)
}
func (s *Server) handleSubmit(w http.ResponseWriter, r *http.Request) {
body, err := io.ReadAll(io.LimitReader(r.Body, 4<<20))
if err != nil {
httpjson.Write(w, http.StatusBadRequest, map[string]string{"message": "Invalid JSON body"})
return
}
var decoded any
if err := json.Unmarshal(body, &decoded); err != nil {
httpjson.Write(w, http.StatusBadRequest, map[string]string{"message": "Invalid JSON body"})
return
}
raw, ok := decoded.(map[string]any)
if !ok {
httpjson.Write(w, http.StatusBadRequest, map[string]string{"message": "Operation must be an object"})
return
}
entry, err := s.Submit(r.Context(), r.PathValue("did"), raw)
if err != nil {
writeError(w, err)
return
}
httpjson.Write(w, http.StatusOK, entry)
}
func (s *Server) handleLog(w http.ResponseWriter, r *http.Request) {
ops, err := s.Log(r.Context(), r.PathValue("did"))
if err != nil {
writeError(w, err)
return
}
httpjson.Write(w, http.StatusOK, ops)
}
// handleLogLast: the DID's last operation (plc.directory's /:did/log/last), a tombstone included
func (s *Server) handleLogLast(w http.ResponseWriter, r *http.Request) {
ops, err := s.Log(r.Context(), r.PathValue("did"))
if err != nil {
writeError(w, err)
return
}
httpjson.Write(w, http.StatusOK, ops[len(ops)-1])
}
// handleData: the DID's current state (plc.directory's /:did/data); a tombstoned DID has none (410)
func (s *Server) handleData(w http.ResponseWriter, r *http.Request) {
did := r.PathValue("did")
ops, err := s.Log(r.Context(), did)
if err != nil {
writeError(w, err)
return
}
last := ops[len(ops)-1]
if last.Type == TypeTombstone {
writeError(w, errorf(410, "DID not available: %s", did))
return
}
services := map[string]Service{}
for k, v := range last.Services {
services[k] = v
}
httpjson.Write(w, http.StatusOK, map[string]any{"did": did, "rotationKeys": last.RotationKeys,
"verificationMethods": last.VerificationMethods, "alsoKnownAs": last.AlsoKnownAs, "services": services})
}
func (s *Server) handleAudit(w http.ResponseWriter, r *http.Request) {
entries, err := s.AuditLog(r.Context(), r.PathValue("did"))
if err != nil {
writeError(w, err)
return
}
httpjson.Write(w, http.StatusOK, entries)
}
func writeError(w http.ResponseWriter, err error) {
var pe *Error
if errors.As(err, &pe) {
httpjson.Write(w, pe.Status, map[string]string{"message": pe.Message})
return
}
httpjson.Write(w, http.StatusInternalServerError, map[string]string{"message": "Internal Server Error"})
}
func withCORS(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Methods", "GET,HEAD,PUT,PATCH,POST,DELETE,OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", r.Header.Get("Access-Control-Request-Headers"))
if r.Method == http.MethodOptions {
w.WriteHeader(http.StatusNoContent)
return
}
next.ServeHTTP(w, r)
})
}