0
0
package trust
import (
"context"
"encoding/json"
"errors"
"fmt"
"slices"
"strings"
"sync"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/identlink"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/opt"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/ttlcache"
"github.com/johnandersen777/socialweb-computer-kcp/internal/policyengine/atproto"
"github.com/johnandersen777/socialweb-computer-kcp/internal/policyengine/cache"
"github.com/johnandersen777/socialweb-computer-kcp/internal/policyengine/models"
)
const (
VouchNSID = "sh.tangled.graph.vouch"
defaultTrustCacheTTL = 5 * time.Minute
trustErrorTTL = 5 * time.Second
)
type Host interface {
Resolve(ctx context.Context, ref atproto.StrongRef) (map[string]any, error)
Walk(ctx context.Context, did string, assoc Association) (identlink.Result, error)
Vouches(ctx context.Context, voucher, subject string) (bool, error)
Log(level, msg string, meta map[string]any)
}
var ErrUnconfirmed = errors.New("trust: a lookup failed")
type Snapshot struct {
OperatorOf map[string]string `json:"operatorOf"`
VouchedBy map[string][]string `json:"vouchedBy"`
TrustedOperators []string `json:"trustedOperators"`
Unconfirmed []string `json:"-"`
walkUnconfirmed bool
unconfirmedVouches []vouchPair
selfDid string
counterpartyDid string
selfSide []string
cpSide []string
}
func (s *Snapshot) addVouch(voucher, subject string) {
s.VouchedBy[voucher] = append(s.VouchedBy[voucher], subject)
switch {
case slices.Contains(s.selfSide, voucher) && slices.Contains(s.cpSide, subject):
s.VouchedBy[voucher] = append(s.VouchedBy[voucher], s.counterpartyDid)
case slices.Contains(s.cpSide, voucher) && slices.Contains(s.selfSide, subject):
s.VouchedBy[s.counterpartyDid] = append(s.VouchedBy[s.counterpartyDid], s.selfDid)
}
}
func (s *Snapshot) compact() {
for voucher, list := range s.VouchedBy {
slices.Sort(list)
s.VouchedBy[voucher] = slices.Compact(list)
}
}
func (s Snapshot) AssumingUnconfirmedVouches() (Snapshot, bool) {
if s.walkUnconfirmed || len(s.unconfirmedVouches) == 0 {
return Snapshot{}, false
}
out := s
out.Unconfirmed = nil
out.unconfirmedVouches = nil
out.VouchedBy = make(map[string][]string, len(s.VouchedBy))
for voucher, list := range s.VouchedBy {
out.VouchedBy[voucher] = slices.Clone(list)
}
for _, p := range s.unconfirmedVouches {
out.addVouch(p.voucher, p.subject)
}
out.compact()
return out, true
}
type ResolverOptions struct {
Client *atproto.Client
Source identlink.Source
Store *cache.Store
TTL time.Duration
Log func(level, msg string, meta map[string]any)
}
type walkKey struct {
did string
assoc Association
}
type vouchKey struct {
voucher string
subject string
}
type Resolver struct {
client *atproto.Client
source identlink.Source
store *cache.Store
log func(level, msg string, meta map[string]any)
now func() time.Time
ttl time.Duration
walks *ttlcache.Cache[walkKey, identlink.Result]
vouch *ttlcache.Cache[vouchKey, bool]
}
func NewResolver(opts ResolverOptions) *Resolver {
client := opts.Client
if client == nil {
client = atproto.NewClient()
}
source := opts.Source
if source == nil {
source = identlink.NewRemote(identlink.PLCDirectory(client.PLCURL, client.HTTP), client.HTTP)
}
ttl := opt.Positive(opts.TTL, defaultTrustCacheTTL)
log := opts.Log
if log == nil {
log = func(string, string, map[string]any) {}
}
return &Resolver{
client: client,
source: source,
store: opts.Store,
log: log,
now: time.Now,
ttl: ttl,
walks: ttlcache.New[walkKey, identlink.Result](ttlcache.Options{TTL: ttl}),
vouch: ttlcache.New[vouchKey, bool](ttlcache.Options{TTL: ttl}),
}
}
func (r *Resolver) Resolve(ctx context.Context, ref atproto.StrongRef) (map[string]any, error) {
if r.store != nil {
if value, ok := cache.ReadRecord(r.store, ref); ok {
return value, nil
}
}
repo, collection, rkey := atproto.SplitURI(ref.URI)
value, held, err := r.verifiedRecord(ctx, repo, collection, rkey)
if err != nil {
return nil, err
}
if value == nil {
return nil, fmt.Errorf("%w: %s", atproto.ErrRecordNotFound, ref.URI)
}
if ref.CID != "" && held != ref.CID {
return nil, fmt.Errorf("%w: %s holds %s, not %s", atproto.ErrRecordNotFound, ref.URI, held, ref.CID)
}
if r.store != nil {
cache.WriteRecord(r.store, ref, value)
}
return value, nil
}
type verifiedSource interface {
GetVerifiedRecord(ctx context.Context, did, collection, rkey string) (map[string]any, string, error)
}
func (r *Resolver) verifiedRecord(ctx context.Context, repo, collection, rkey string) (map[string]any, string, error) {
if source, ok := r.source.(verifiedSource); ok {
return source.GetVerifiedRecord(ctx, repo, collection, rkey)
}
value, err := r.source.GetRecord(ctx, repo, collection, rkey)
if err != nil || value == nil {
return value, "", err
}
held, err := identlink.RecordCID(value)
return value, held, err
}
func (r *Resolver) Record(ctx context.Context, repo, collection, rkey string) (map[string]any, error) {
return r.source.GetRecord(ctx, repo, collection, rkey)
}
type walkIO struct {
r *Resolver
requireContract bool
}
func (w walkIO) ResolveDID(ctx context.Context, did string) (*identlink.Doc, error) {
return w.r.source.ResolveDID(ctx, did)
}
func (w walkIO) GetRecord(ctx context.Context, repo, collection, rkey string) (map[string]any, error) {
value, err := w.r.source.GetRecord(ctx, repo, collection, rkey)
if _, scoped := value["contract"]; w.requireContract && collection == identlink.GrantNSID && !scoped {
return nil, err
}
return value, err
}
func (w walkIO) ContractHeld(ctx context.Context, contract identlink.StrongRef, authorities []string) (bool, error) {
return w.r.contractHeld(ctx, atproto.StrongRef{URI: contract.URI, CID: contract.CID}, authorities)
}
func (w walkIO) Now() time.Time {
return w.r.now()
}
func (r *Resolver) Walk(ctx context.Context, did string, assoc Association) (identlink.Result, error) {
did = strings.TrimSpace(did)
assoc = assoc.normal()
key := walkKey{did: did, assoc: assoc}
if res, ok := r.walks.Get(key); ok {
return res, nil
}
res := identlink.Walk(ctx, walkIO{r: r, requireContract: assoc.RequireContract}, did, identlink.Options{MaxDepth: assoc.MaxDepth})
if err := ctx.Err(); err != nil {
return identlink.Result{}, err
}
if len(res.Errors) > 0 {
r.log("warn", "identlink walk left edges unconfirmed", map[string]any{"did": did, "errors": res.Errors})
r.walks.SetTTL(key, res, trustErrorTTL)
return res, nil
}
ttl := r.ttl
for _, a := range res.Ancestors {
if a.ExpiresAt != nil {
ttl = min(ttl, max(a.ExpiresAt.Sub(r.now()), time.Second))
}
}
r.walks.SetTTL(key, res, ttl)
return res, nil
}
func (r *Resolver) Vouches(ctx context.Context, voucher, subject string) (bool, error) {
voucher = strings.TrimSpace(voucher)
subject = strings.TrimSpace(subject)
if voucher == "" || !strings.HasPrefix(subject, "did:") {
return false, nil
}
key := vouchKey{voucher: voucher, subject: subject}
if vouched, ok := r.vouch.Get(key); ok {
return vouched, nil
}
value, err := r.Record(ctx, voucher, VouchNSID, subject)
if err != nil {
if ctx.Err() != nil {
return false, ctx.Err()
}
r.log("warn", "vouches failed", map[string]any{"voucher": voucher, "subject": subject, "error": err.Error()})
return false, fmt.Errorf("%w: the vouch %s -> %s: %v", ErrUnconfirmed, voucher, subject, err)
}
kind, _ := value["kind"].(string)
vouched := value != nil && kind != "denounce"
r.vouch.Set(key, vouched)
return vouched, nil
}
func (r *Resolver) Log(level, msg string, meta map[string]any) {
r.log(level, msg, meta)
}
func (r *Resolver) ApplyEvent(did, rkey string) {
named := func(x string) bool { return x != "" && (x == did || x == rkey) }
r.walks.DeleteFunc(func(key walkKey, res identlink.Result) bool {
return named(key.did) || slices.ContainsFunc(res.Ancestors, func(a identlink.Ancestor) bool { return named(a.DID) })
})
if did != "" {
r.source.Forget(did)
}
r.vouch.DeleteKeys(func(key vouchKey) bool { return named(key.voucher) })
}
func (r *Resolver) Invalidate() {
r.walks.DeleteKeys(func(walkKey) bool { return true })
r.vouch.DeleteKeys(func(vouchKey) bool { return true })
}
type walked struct {
res identlink.Result
err error
}
type vouchResult struct {
voucher string
subject string
vouched bool
err error
}
func BuildSnapshot(ctx context.Context, host Host, selfDid, counterpartyDid string, assoc Association) (Snapshot, error) {
snapshot := Snapshot{
OperatorOf: make(map[string]string),
VouchedBy: make(map[string][]string),
TrustedOperators: []string{},
}
if host == nil {
return snapshot, nil
}
var wg sync.WaitGroup
defer wg.Wait()
ctx, cancel := context.WithCancel(ctx)
defer cancel()
var self, cp walked
wg.Go(func() { self.res, self.err = host.Walk(ctx, selfDid, Association{MaxDepth: assoc.MaxDepth}) })
if counterpartyDid != "" && counterpartyDid != selfDid {
wg.Go(func() { cp.res, cp.err = host.Walk(ctx, counterpartyDid, assoc) })
}
wg.Wait()
if err := errors.Join(self.err, cp.err); err != nil {
return snapshot, err
}
snapshot.Unconfirmed = slices.Concat(self.res.Errors, cp.res.Errors)
snapshot.walkUnconfirmed = len(snapshot.Unconfirmed) > 0
snapshot.OperatorOf = operatorsOf(selfDid, counterpartyDid, self.res, cp.res)
selfSide := self.res.Side()
snapshot.TrustedOperators = selfSide
if counterpartyDid == "" || counterpartyDid == selfDid {
snapshot.VouchedBy[selfDid] = []string{}
return snapshot, nil
}
cpSide := cp.res.Side()
snapshot.selfDid, snapshot.counterpartyDid, snapshot.selfSide, snapshot.cpSide = selfDid, counterpartyDid, selfSide, cpSide
pairs := vouchPairs(selfSide, cpSide)
for _, p := range pairs {
snapshot.VouchedBy[p.voucher] = []string{}
}
results := make(chan vouchResult, len(pairs))
for _, p := range pairs {
wg.Go(func() {
vouched, err := host.Vouches(ctx, p.voucher, p.subject)
results <- vouchResult{voucher: p.voucher, subject: p.subject, vouched: vouched, err: err}
})
}
for range pairs {
result := <-results
if errors.Is(result.err, ErrUnconfirmed) {
snapshot.Unconfirmed = append(snapshot.Unconfirmed, result.err.Error())
snapshot.unconfirmedVouches = append(snapshot.unconfirmedVouches, vouchPair{voucher: result.voucher, subject: result.subject})
continue
}
if result.err != nil {
return snapshot, result.err
}
if result.vouched {
snapshot.addVouch(result.voucher, result.subject)
}
}
snapshot.compact()
return snapshot, nil
}
func operatorsOf(selfDid, counterpartyDid string, self, cp identlink.Result) map[string]string {
out := map[string]string{selfDid: selfDid}
if len(self.Roots) > 0 {
out[selfDid] = self.Roots[0]
}
if counterpartyDid == "" || counterpartyDid == selfDid {
return out
}
for _, root := range self.Roots {
if slices.Contains(cp.Roots, root) {
out[selfDid], out[counterpartyDid] = root, root
return out
}
}
for _, root := range cp.Roots {
if root != counterpartyDid {
out[counterpartyDid] = root
break
}
}
return out
}
type vouchPair struct {
voucher, subject string
}
func vouchPairs(selfSide, cpSide []string) []vouchPair {
var out []vouchPair
add := func(voucher, subject string) {
p := vouchPair{voucher: voucher, subject: subject}
if voucher != subject && len(out) < identlink.DefaultBudget && !slices.Contains(out, p) {
out = append(out, p)
}
}
for sum := 0; sum <= len(selfSide)+len(cpSide)-2; sum++ {
for i := max(0, sum-len(cpSide)+1); i <= min(sum, len(selfSide)-1); i++ {
add(selfSide[i], cpSide[sum-i])
add(cpSide[sum-i], selfSide[i])
}
}
return out
}
func (s Snapshot) ActionVouchedBy() map[string][]string {
out := make(map[string][]string, len(s.VouchedBy))
for voucher, list := range s.VouchedBy {
out[voucher] = slices.Clone(list)
}
if len(s.TrustedOperators) == 0 {
return out
}
self := s.TrustedOperators[0]
merged := []string{}
for _, operator := range s.TrustedOperators {
merged = append(merged, s.VouchedBy[operator]...)
}
slices.Sort(merged)
out[self] = slices.Compact(merged)
return out
}
func (s Snapshot) CacheFiles() models.CacheEntry {
operatorOf, _ := json.Marshal(s.OperatorOf)
vouchedBy, _ := json.Marshal(s.ActionVouchedBy())
trustedOperators, _ := json.Marshal(s.TrustedOperators)
return models.CacheEntry{
"operatorOf.json": {Data: string(operatorOf), Encoding: models.CacheEncodingText},
"vouchedBy.json": {Data: string(vouchedBy), Encoding: models.CacheEncodingText},
"trustedOperators.json": {Data: string(trustedOperators), Encoding: models.CacheEncodingText},
}
}