commit 857121c076de13032ae78892db108196b605d858 · edouard.paris/did-method-plc

go-didplc/.gitignore

···

       1
       1
       +
       ./webplc

     

       2
       2
       +
       /plan.txt

     

       3
       3
       +
       !static/.well-known/

     

       4
       4
       +
       !.gitignore

+42

go-didplc/Makefile

···

       1
       1
       +
       

     

       2
       2
       +
       SHELL = /bin/bash

     

       3
       3
       +
       .SHELLFLAGS = -o pipefail -c

     

       4
       4
       +
       

     

       5
       5
       +
       .PHONY: help

     

       6
       6
       +
       help: ## Print info about all commands

     

       7
       7
       +
       	@echo "Commands:"

     

       8
       8
       +
       	@echo

     

       9
       9
       +
       	@grep -E '^[a-zA-Z0-9_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "    \033[01;32m%-20s\033[0m %s\n", $$1, $$2}'

     

       10
       10
       +
       

     

       11
       11
       +
       .PHONY: build

     

       12
       12
       +
       build: ## Build all executables

     

       13
       13
       +
       	go build ./cmd/webplc

     

       14
       14
       +
       

     

       15
       15
       +
       .PHONY: test

     

       16
       16
       +
       test: ## Run all tests

     

       17
       17
       +
       	go test ./...

     

       18
       18
       +
       

     

       19
       19
       +
       .PHONY: coverage-html

     

       20
       20
       +
       coverage-html: ## Generate test coverage report and open in browser

     

       21
       21
       +
       	go test ./... -coverpkg=./... -coverprofile=test-coverage.out

     

       22
       22
       +
       	go tool cover -html=test-coverage.out

     

       23
       23
       +
       

     

       24
       24
       +
       .PHONY: lint

     

       25
       25
       +
       lint: ## Verify code style and run static checks

     

       26
       26
       +
       	go vet ./...

     

       27
       27
       +
       	test -z $(gofmt -l ./...)

     

       28
       28
       +
       

     

       29
       29
       +
       .PHONY: fmt

     

       30
       30
       +
       fmt: ## Run syntax re-formatting (modify in place)

     

       31
       31
       +
       	go fmt ./...

     

       32
       32
       +
       

     

       33
       33
       +
       .PHONY: check

     

       34
       34
       +
       check: ## Compile everything, checking syntax (does not output binaries)

     

       35
       35
       +
       	go build ./...

     

       36
       36
       +
       

     

       37
       37
       +
       .env:

     

       38
       38
       +
       	if [ ! -f ".env" ]; then cp example.dev.env .env; fi

     

       39
       39
       +
       

     

       40
       40
       +
       .PHONY: run-dev-webplc

     

       41
       41
       +
       run-dev-webplc: .env ## Runs 'bskyweb' for local dev

     

       42
       42
       +
       	GOLOG_LOG_LEVEL=info go run ./cmd/webplc serve --debug

+23

go-didplc/README.md

···

       1
       1
       +
       

     

       2
       2
       +
       `go-didplc`: did:plc in golang

     

       3
       3
       +
       ==============================

     

       4
       4
       +
       

     

       5
       5
       +
       This golang package will eventually be an implementation of the did:plc specification in golang, including at a minimum verification of DID documents from a PLC operation log.

     

       6
       6
       +
       

     

       7
       7
       +
       For now it primarily contains a basic website for the PLC directory, allowing lookup of individual DID documents.

     

       8
       8
       +
       

     

       9
       9
       +
       

     

       10
       10
       +
       ## Developer Quickstart

     

       11
       11
       +
       

     

       12
       12
       +
       Install golang. We are generally using v1.20+.

     

       13
       13
       +
       

     

       14
       14
       +
       In this directory (`go-didplc/`):

     

       15
       15
       +
       

     

       16
       16
       +
           # re-build and run daemon

     

       17
       17
       +
           go run ./cmd/webplc serve

     

       18
       18
       +
       

     

       19
       19
       +
           # build and output a binary

     

       20
       20
       +
           go build -o webplc ./cmd/webplc/

     

       21
       21
       +
       

     

       22
       22
       +
       The easiest way to configure the daemon is to copy `example.env` to `.env` and

     

       23
       23
       +
       fill in auth values there.

+60

go-didplc/cmd/webplc/main.go

···

       1
       1
       +
       package main

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"os"

     

       5
       5
       +
       

     

       6
       6
       +
       	_ "github.com/joho/godotenv/autoload"

     

       7
       7
       +
       

     

       8
       8
       +
       	logging "github.com/ipfs/go-log"

     

       9
       9
       +
       	"github.com/urfave/cli/v2"

     

       10
       10
       +
       )

     

       11
       11
       +
       

     

       12
       12
       +
       var log = logging.Logger("webplc")

     

       13
       13
       +
       

     

       14
       14
       +
       func init() {

     

       15
       15
       +
       	logging.SetAllLoggers(logging.LevelDebug)

     

       16
       16
       +
       	//logging.SetAllLoggers(logging.LevelWarn)

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

       19
       19
       +
       func main() {

     

       20
       20
       +
       	run(os.Args)

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       func run(args []string) {

     

       24
       24
       +
       

     

       25
       25
       +
       	app := cli.App{

     

       26
       26
       +
       		Name:  "webplc",

     

       27
       27
       +
       		Usage: "web server for bsky.app web app (SPA)",

     

       28
       28
       +
       	}

     

       29
       29
       +
       

     

       30
       30
       +
       	app.Commands = []*cli.Command{

     

       31
       31
       +
       		&cli.Command{

     

       32
       32
       +
       			Name:   "serve",

     

       33
       33
       +
       			Usage:  "run the web server",

     

       34
       34
       +
       			Action: serve,

     

       35
       35
       +
       			Flags: []cli.Flag{

     

       36
       36
       +
       				&cli.StringFlag{

     

       37
       37
       +
       					Name:  "plc-host",

     

       38
       38
       +
       					Usage: "method, hostname, and port of PLC instance",

     

       39
       39
       +
       					Value: "https://plc.directory",

     

       40
       40
       +
       					EnvVars: []string{"ATP_PLC_HOST"},

     

       41
       41
       +
       				},

     

       42
       42
       +
       				&cli.StringFlag{

     

       43
       43
       +
       					Name:     "http-address",

     

       44
       44
       +
       					Usage:    "Specify the local IP/port to bind to",

     

       45
       45
       +
       					Required: false,

     

       46
       46
       +
       					Value:    ":8700",

     

       47
       47
       +
       					EnvVars:  []string{"HTTP_ADDRESS"},

     

       48
       48
       +
       				},

     

       49
       49
       +
       				&cli.BoolFlag{

     

       50
       50
       +
       					Name:     "debug",

     

       51
       51
       +
       					Usage:    "Enable debug mode",

     

       52
       52
       +
       					Value:    false,

     

       53
       53
       +
       					Required: false,

     

       54
       54
       +
       					EnvVars:  []string{"DEBUG"},

     

       55
       55
       +
       				},

     

       56
       56
       +
       			},

     

       57
       57
       +
       		},

     

       58
       58
       +
       	}

     

       59
       59
       +
       	app.RunAndExitOnError()

     

       60
       60
       +
       }

+82

go-didplc/cmd/webplc/renderer.go

···

       1
       1
       +
       package main

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"bytes"

     

       5
       5
       +
       	"embed"

     

       6
       6
       +
       	"errors"

     

       7
       7
       +
       	"fmt"

     

       8
       8
       +
       	"io"

     

       9
       9
       +
       	"path/filepath"

     

       10
       10
       +
       

     

       11
       11
       +
       	"github.com/flosch/pongo2/v6"

     

       12
       12
       +
       	"github.com/labstack/echo/v4"

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       type RendererLoader struct {

     

       16
       16
       +
       	prefix string

     

       17
       17
       +
       	fs     *embed.FS

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       20
       20
       +
       func NewRendererLoader(prefix string, fs *embed.FS) pongo2.TemplateLoader {

     

       21
       21
       +
       	return &RendererLoader{

     

       22
       22
       +
       		prefix: prefix,

     

       23
       23
       +
       		fs:     fs,

     

       24
       24
       +
       	}

     

       25
       25
       +
       }

     

       26
       26
       +
       func (l *RendererLoader) Abs(_, name string) string {

     

       27
       27
       +
       	// TODO: remove this workaround

     

       28
       28
       +
       	// Figure out why this method is being called

     

       29
       29
       +
       	// twice on template names resulting in a failure to resolve

     

       30
       30
       +
       	// the template name.

     

       31
       31
       +
       	if filepath.HasPrefix(name, l.prefix) {

     

       32
       32
       +
       		return name

     

       33
       33
       +
       	}

     

       34
       34
       +
       	return filepath.Join(l.prefix, name)

     

       35
       35
       +
       }

     

       36
       36
       +
       

     

       37
       37
       +
       func (l *RendererLoader) Get(path string) (io.Reader, error) {

     

       38
       38
       +
       	b, err := l.fs.ReadFile(path)

     

       39
       39
       +
       	if err != nil {

     

       40
       40
       +
       		return nil, fmt.Errorf("reading template %q failed: %w", path, err)

     

       41
       41
       +
       	}

     

       42
       42
       +
       	return bytes.NewReader(b), nil

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       45
       45
       +
       type Renderer struct {

     

       46
       46
       +
       	TemplateSet *pongo2.TemplateSet

     

       47
       47
       +
       	Debug       bool

     

       48
       48
       +
       }

     

       49
       49
       +
       

     

       50
       50
       +
       func NewRenderer(prefix string, fs *embed.FS, debug bool) *Renderer {

     

       51
       51
       +
       	return &Renderer{

     

       52
       52
       +
       		TemplateSet: pongo2.NewSet(prefix, NewRendererLoader(prefix, fs)),

     

       53
       53
       +
       		Debug:       debug,

     

       54
       54
       +
       	}

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       57
       57
       +
       func (r Renderer) Render(w io.Writer, name string, data interface{}, c echo.Context) error {

     

       58
       58
       +
       	var ctx pongo2.Context

     

       59
       59
       +
       

     

       60
       60
       +
       	if data != nil {

     

       61
       61
       +
       		var ok bool

     

       62
       62
       +
       		ctx, ok = data.(pongo2.Context)

     

       63
       63
       +
       		if !ok {

     

       64
       64
       +
       			return errors.New("no pongo2.Context data was passed")

     

       65
       65
       +
       		}

     

       66
       66
       +
       	}

     

       67
       67
       +
       

     

       68
       68
       +
       	var t *pongo2.Template

     

       69
       69
       +
       	var err error

     

       70
       70
       +
       

     

       71
       71
       +
       	if r.Debug {

     

       72
       72
       +
       		t, err = pongo2.FromFile(name)

     

       73
       73
       +
       	} else {

     

       74
       74
       +
       		t, err = r.TemplateSet.FromFile(name)

     

       75
       75
       +
       	}

     

       76
       76
       +
       

     

       77
       77
       +
       	if err != nil {

     

       78
       78
       +
       		return err

     

       79
       79
       +
       	}

     

       80
       80
       +
       

     

       81
       81
       +
       	return t.ExecuteWriter(ctx, w)

     

       82
       82
       +
       }

+78

go-didplc/cmd/webplc/resolve.go

···

       1
       1
       +
       

     

       2
       2
       +
       package main

     

       3
       3
       +
       

     

       4
       4
       +
       import (

     

       5
       5
       +
       	"io"

     

       6
       6
       +
       	"fmt"

     

       7
       7
       +
       	"net/http"

     

       8
       8
       +
       	"encoding/json"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       type VerificationMethod struct {

     

       12
       12
       +
       	Id string `json:"id"`

     

       13
       13
       +
       	Type string `json:"type"`

     

       14
       14
       +
       	Controller string `json:"controller"`

     

       15
       15
       +
       	PublicKeyMultibase string `json:"publicKeyMultibase"`

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       type DidService struct {

     

       19
       19
       +
       	Id string `json:"id"`

     

       20
       20
       +
       	Type string `json:"type"`

     

       21
       21
       +
       	ServiceEndpoint string `json:"serviceEndpoint"`

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       24
       24
       +
       type DidDoc struct {

     

       25
       25
       +
       	AlsoKnownAs []string `json:"alsoKnownAs"`

     

       26
       26
       +
       	VerificationMethod []VerificationMethod `json:"verificationMethod"`

     

       27
       27
       +
       	Service []DidService `json:"service"`

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       type ResolutionResult struct {

     

       31
       31
       +
       	Doc *DidDoc

     

       32
       32
       +
       	DocJson *string

     

       33
       33
       +
       	StatusCode int

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       36
       36
       +
       func ResolveDidPlc(client *http.Client, plc_host, did string) (*ResolutionResult, error) {

     

       37
       37
       +
       	result := ResolutionResult{}

     

       38
       38
       +
       	res, err := client.Get(fmt.Sprintf("%s/%s", plc_host, did))

     

       39
       39
       +
       	if err != nil {

     

       40
       40
       +
       		return nil, fmt.Errorf("error making http request: %v", err)

     

       41
       41
       +
       	}

     

       42
       42
       +
       	defer res.Body.Close()

     

       43
       43
       +
       	log.Debugf("PLC resolution result status=%d did=%s", res.StatusCode, did)

     

       44
       44
       +
       

     

       45
       45
       +
       	result.StatusCode = res.StatusCode

     

       46
       46
       +
       	if res.StatusCode == 404 {

     

       47
       47
       +
       		return nil, fmt.Errorf("DID not found in PLC directory: %s", did)

     

       48
       48
       +
       	} else if res.StatusCode != 200 {

     

       49
       49
       +
       		return &result, nil

     

       50
       50
       +
       	}

     

       51
       51
       +
       

     

       52
       52
       +
       	respBytes, err := io.ReadAll(res.Body)

     

       53
       53
       +
       	if err != nil {

     

       54
       54
       +
       		return nil, fmt.Errorf("failed to read PLC result body: %v", err)

     

       55
       55
       +
       	}

     

       56
       56
       +
       

     

       57
       57
       +
       	doc := DidDoc{}

     

       58
       58
       +
       	err = json.Unmarshal(respBytes, &doc)

     

       59
       59
       +
       	if err != nil {

     

       60
       60
       +
       		return nil, fmt.Errorf("failed to parse DID Document JSON:", err)

     

       61
       61
       +
       	}

     

       62
       62
       +
       	result.Doc = &doc

     

       63
       63
       +
       

     

       64
       64
       +
       	// parse and re-serialize JSON in pretty (indent) style

     

       65
       65
       +
       	var data map[string]interface{}

     

       66
       66
       +
       	err = json.Unmarshal(respBytes, &data)

     

       67
       67
       +
       	if err != nil {

     

       68
       68
       +
       		return nil, fmt.Errorf("failed to parse DID Document JSON:", err)

     

       69
       69
       +
       	}

     

       70
       70
       +
       	indentJson, err := json.MarshalIndent(data, "", "  ")

     

       71
       71
       +
       	if err != nil {

     

       72
       72
       +
       		return nil, fmt.Errorf("failed to parse DID Document JSON:", err)

     

       73
       73
       +
       	}

     

       74
       74
       +
       	s := string(indentJson)

     

       75
       75
       +
       	result.DocJson = &s

     

       76
       76
       +
       

     

       77
       77
       +
       	return &result, nil

     

       78
       78
       +
       }

+240

go-didplc/cmd/webplc/server.go

···

       1
       1
       +
       package main

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"embed"

     

       6
       6
       +
       	"errors"

     

       7
       7
       +
       	"io/fs"

     

       8
       8
       +
       	"net/http"

     

       9
       9
       +
       	"os"

     

       10
       10
       +
       	"os/signal"

     

       11
       11
       +
       	"strings"

     

       12
       12
       +
       	"syscall"

     

       13
       13
       +
       	"time"

     

       14
       14
       +
       	"fmt"

     

       15
       15
       +
       

     

       16
       16
       +
       	"github.com/russross/blackfriday/v2"

     

       17
       17
       +
       	"github.com/klauspost/compress/gzhttp"

     

       18
       18
       +
       	"github.com/klauspost/compress/gzip"

     

       19
       19
       +
       	"github.com/flosch/pongo2/v6"

     

       20
       20
       +
       	"github.com/labstack/echo/v4"

     

       21
       21
       +
       	"github.com/labstack/echo/v4/middleware"

     

       22
       22
       +
       	"github.com/urfave/cli/v2"

     

       23
       23
       +
       )

     

       24
       24
       +
       

     

       25
       25
       +
       //go:embed templates/*

     

       26
       26
       +
       var TemplateFS embed.FS

     

       27
       27
       +
       

     

       28
       28
       +
       //go:embed static/*

     

       29
       29
       +
       var StaticFS embed.FS

     

       30
       30
       +
       

     

       31
       31
       +
       //go:embed spec/v0.1/did-plc.md

     

       32
       32
       +
       var specZeroOneMarkdown []byte

     

       33
       33
       +
       

     

       34
       34
       +
       type Server struct {

     

       35
       35
       +
       	echo     *echo.Echo

     

       36
       36
       +
       	httpd    *http.Server

     

       37
       37
       +
       	client   *http.Client

     

       38
       38
       +
       	plcHost	 string

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       func serve(cctx *cli.Context) error {

     

       42
       42
       +
       	debug := cctx.Bool("debug")

     

       43
       43
       +
       	httpAddress := cctx.String("http-address")

     

       44
       44
       +
       

     

       45
       45
       +
       	// Echo

     

       46
       46
       +
       	e := echo.New()

     

       47
       47
       +
       

     

       48
       48
       +
       	// create a new session (no auth)

     

       49
       49
       +
       	client := http.Client{

     

       50
       50
       +
       		Transport: &http.Transport{

     

       51
       51
       +
       			Proxy:                 http.ProxyFromEnvironment,

     

       52
       52
       +
       			ForceAttemptHTTP2:     true,

     

       53
       53
       +
       			MaxIdleConns:          100,

     

       54
       54
       +
       			IdleConnTimeout:       90 * time.Second,

     

       55
       55
       +
       			TLSHandshakeTimeout:   10 * time.Second,

     

       56
       56
       +
       			ExpectContinueTimeout: 1 * time.Second,

     

       57
       57
       +
       		},

     

       58
       58
       +
       	}

     

       59
       59
       +
       

     

       60
       60
       +
       	// httpd variable

     

       61
       61
       +
       	var (

     

       62
       62
       +
       		httpTimeout          = 2 * time.Minute

     

       63
       63
       +
       		httpMaxHeaderBytes   = 2 * (1024 * 1024)

     

       64
       64
       +
       		gzipMinSizeBytes     = 1024 * 2

     

       65
       65
       +
       		gzipCompressionLevel = gzip.BestSpeed

     

       66
       66
       +
       		gzipExceptMIMETypes  = []string{"image/png"}

     

       67
       67
       +
       	)

     

       68
       68
       +
       

     

       69
       69
       +
       	// Wrap the server handler in a gzip handler to compress larger responses.

     

       70
       70
       +
       	gzipHandler, err := gzhttp.NewWrapper(

     

       71
       71
       +
       		gzhttp.MinSize(gzipMinSizeBytes),

     

       72
       72
       +
       		gzhttp.CompressionLevel(gzipCompressionLevel),

     

       73
       73
       +
       		gzhttp.ExceptContentTypes(gzipExceptMIMETypes),

     

       74
       74
       +
       	)

     

       75
       75
       +
       	if err != nil {

     

       76
       76
       +
       		return err

     

       77
       77
       +
       	}

     

       78
       78
       +
       

     

       79
       79
       +
       	server := &Server{

     

       80
       80
       +
       		echo:     e,

     

       81
       81
       +
       		client:   &client,

     

       82
       82
       +
       		plcHost:  cctx.String("plc-host"),

     

       83
       83
       +
       	}

     

       84
       84
       +
       

     

       85
       85
       +
       	server.httpd = &http.Server{

     

       86
       86
       +
       		Handler:        gzipHandler(server),

     

       87
       87
       +
       		Addr:           httpAddress,

     

       88
       88
       +
       		WriteTimeout:   httpTimeout,

     

       89
       89
       +
       		ReadTimeout:    httpTimeout,

     

       90
       90
       +
       		MaxHeaderBytes: httpMaxHeaderBytes,

     

       91
       91
       +
       	}

     

       92
       92
       +
       

     

       93
       93
       +
       	e.HideBanner = true

     

       94
       94
       +
       	// SECURITY: Do not modify without due consideration.

     

       95
       95
       +
       	e.Use(middleware.SecureWithConfig(middleware.SecureConfig{

     

       96
       96
       +
       		ContentTypeNosniff: "nosniff",

     

       97
       97
       +
       		XFrameOptions:      "SAMEORIGIN",

     

       98
       98
       +
       		HSTSMaxAge:         31536000, // 365 days

     

       99
       99
       +
       		// TODO:

     

       100
       100
       +
       		// ContentSecurityPolicy

     

       101
       101
       +
       		// XSSProtection

     

       102
       102
       +
       	}))

     

       103
       103
       +
       	e.Use(middleware.LoggerWithConfig(middleware.LoggerConfig{

     

       104
       104
       +
       		// Don't log requests for static content.

     

       105
       105
       +
       		Skipper: func(c echo.Context) bool {

     

       106
       106
       +
       			return strings.HasPrefix(c.Request().URL.Path, "/static")

     

       107
       107
       +
       		},

     

       108
       108
       +
       	}))

     

       109
       109
       +
       	e.Renderer = NewRenderer("templates/", &TemplateFS, debug)

     

       110
       110
       +
       	e.HTTPErrorHandler = server.errorHandler

     

       111
       111
       +
       

     

       112
       112
       +
       	// redirect trailing slash to non-trailing slash.

     

       113
       113
       +
       	// all of our current endpoints have no trailing slash.

     

       114
       114
       +
       	e.Use(middleware.RemoveTrailingSlashWithConfig(middleware.TrailingSlashConfig{

     

       115
       115
       +
       		RedirectCode: http.StatusFound,

     

       116
       116
       +
       	}))

     

       117
       117
       +
       

     

       118
       118
       +
       	staticHandler := http.FileServer(func() http.FileSystem {

     

       119
       119
       +
       		if debug {

     

       120
       120
       +
       			log.Debugf("serving static file from the local file system")

     

       121
       121
       +
       			return http.FS(os.DirFS("static"))

     

       122
       122
       +
       		}

     

       123
       123
       +
       		fsys, err := fs.Sub(StaticFS, "static")

     

       124
       124
       +
       		if err != nil {

     

       125
       125
       +
       			log.Fatal(err)

     

       126
       126
       +
       		}

     

       127
       127
       +
       		return http.FS(fsys)

     

       128
       128
       +
       	}())

     

       129
       129
       +
       

     

       130
       130
       +
       	// static file routes

     

       131
       131
       +
       	e.GET("/robots.txt", echo.WrapHandler(staticHandler))

     

       132
       132
       +
       	e.GET("/favicon.ico", echo.WrapHandler(staticHandler))

     

       133
       133
       +
       	e.GET("/static/*", echo.WrapHandler(http.StripPrefix("/static/", staticHandler)))

     

       134
       134
       +
       	e.GET("/.well-known/*", echo.WrapHandler(staticHandler))

     

       135
       135
       +
       	e.GET("/security.txt", func(c echo.Context) error {

     

       136
       136
       +
       		return c.Redirect(http.StatusMovedPermanently, "/.well-known/security.txt")

     

       137
       137
       +
       	})

     

       138
       138
       +
       

     

       139
       139
       +
       	// actual pages/views

     

       140
       140
       +
       	e.GET("/", server.WebHome)

     

       141
       141
       +
       	e.GET("/resolve", server.WebResolve)

     

       142
       142
       +
       	e.GET("/did/:did", server.WebDid)

     

       143
       143
       +
       	e.GET("/spec/v0.1/did-plc", server.WebSpecZeroOne)

     

       144
       144
       +
       	// TODO: e.GET("/api/redoc", server.WebSpecZeroOne)

     

       145
       145
       +
       	// TODO: e.GET("/api/openapi3.json", server.WebSpecZeroOne)

     

       146
       146
       +
       

     

       147
       147
       +
       	// Start the server.

     

       148
       148
       +
       	log.Infof("starting server address=%s", httpAddress)

     

       149
       149
       +
       	go func() {

     

       150
       150
       +
       		if err := server.httpd.ListenAndServe(); err != nil {

     

       151
       151
       +
       			if !errors.Is(err, http.ErrServerClosed) {

     

       152
       152
       +
       				log.Errorf("HTTP server shutting down unexpectedly: %s", err)

     

       153
       153
       +
       			}

     

       154
       154
       +
       		}

     

       155
       155
       +
       	}()

     

       156
       156
       +
       

     

       157
       157
       +
       	// Wait for a signal to exit.

     

       158
       158
       +
       	log.Info("registering OS exit signal handler")

     

       159
       159
       +
       	quit := make(chan struct{})

     

       160
       160
       +
       	exitSignals := make(chan os.Signal, 1)

     

       161
       161
       +
       	signal.Notify(exitSignals, syscall.SIGINT, syscall.SIGTERM)

     

       162
       162
       +
       	go func() {

     

       163
       163
       +
       		sig := <-exitSignals

     

       164
       164
       +
       		log.Infof("received OS exit signal: %s", sig)

     

       165
       165
       +
       

     

       166
       166
       +
       		// Shut down the HTTP server.

     

       167
       167
       +
       		if err := server.Shutdown(); err != nil {

     

       168
       168
       +
       			log.Errorf("HTTP server shutdown error: %s", err)

     

       169
       169
       +
       		}

     

       170
       170
       +
       

     

       171
       171
       +
       		// Trigger the return that causes an exit.

     

       172
       172
       +
       		close(quit)

     

       173
       173
       +
       	}()

     

       174
       174
       +
       	<-quit

     

       175
       175
       +
       	log.Infof("graceful shutdown complete")

     

       176
       176
       +
       	return nil

     

       177
       177
       +
       }

     

       178
       178
       +
       

     

       179
       179
       +
       func (srv *Server) ServeHTTP(rw http.ResponseWriter, req *http.Request) {

     

       180
       180
       +
       	srv.echo.ServeHTTP(rw, req)

     

       181
       181
       +
       }

     

       182
       182
       +
       

     

       183
       183
       +
       func (srv *Server) Shutdown() error {

     

       184
       184
       +
       	log.Info("shutting down")

     

       185
       185
       +
       

     

       186
       186
       +
       	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)

     

       187
       187
       +
       	defer cancel()

     

       188
       188
       +
       

     

       189
       189
       +
       	return srv.httpd.Shutdown(ctx)

     

       190
       190
       +
       }

     

       191
       191
       +
       

     

       192
       192
       +
       func (srv *Server) errorHandler(err error, c echo.Context) {

     

       193
       193
       +
       	code := http.StatusInternalServerError

     

       194
       194
       +
       	if he, ok := err.(*echo.HTTPError); ok {

     

       195
       195
       +
       		code = he.Code

     

       196
       196
       +
       	}

     

       197
       197
       +
       	c.Logger().Error(err)

     

       198
       198
       +
       	data := pongo2.Context{

     

       199
       199
       +
       		"statusCode": code,

     

       200
       200
       +
       	}

     

       201
       201
       +
       	c.Render(code, "error.html", data)

     

       202
       202
       +
       }

     

       203
       203
       +
       

     

       204
       204
       +
       func (srv *Server) WebHome(c echo.Context) error {

     

       205
       205
       +
       	data := pongo2.Context{}

     

       206
       206
       +
       	return c.Render(http.StatusOK, "templates/home.html", data)

     

       207
       207
       +
       }

     

       208
       208
       +
       

     

       209
       209
       +
       func (srv *Server) WebSpecZeroOne(c echo.Context) error {

     

       210
       210
       +
       	data := pongo2.Context{}

     

       211
       211
       +
       	data["html_title"] = "did:plc Specification v0.1"

     

       212
       212
       +
       	data["markdown_html"] = string(blackfriday.Run(specZeroOneMarkdown))

     

       213
       213
       +
       	return c.Render(http.StatusOK, "templates/markdown.html", data)

     

       214
       214
       +
       }

     

       215
       215
       +
       

     

       216
       216
       +
       func (srv *Server) WebResolve(c echo.Context) error {

     

       217
       217
       +
       	data := pongo2.Context{}

     

       218
       218
       +
       	did := c.QueryParam("did")

     

       219
       219
       +
       	if did != "" {

     

       220
       220
       +
       		return c.Redirect(http.StatusMovedPermanently, "/did/" + did)

     

       221
       221
       +
       	}

     

       222
       222
       +
       	return c.Render(http.StatusOK, "templates/resolve.html", data)

     

       223
       223
       +
       }

     

       224
       224
       +
       

     

       225
       225
       +
       func (srv *Server) WebDid(c echo.Context) error {

     

       226
       226
       +
       	data := pongo2.Context{}

     

       227
       227
       +
       	did := c.Param("did")

     

       228
       228
       +
       	data["did"] = did

     

       229
       229
       +
       	if !strings.HasPrefix(did, "did:plc:") {

     

       230
       230
       +
       		return fmt.Errorf("Not a valid DID PLC identifier: %s", did)

     

       231
       231
       +
       	}

     

       232
       232
       +
       	res, err := ResolveDidPlc(srv.client, srv.plcHost, did)

     

       233
       233
       +
       	if err != nil {

     

       234
       234
       +
       		return err

     

       235
       235
       +
       	}

     

       236
       236
       +
       	data["result"] = res

     

       237
       237
       +
       	fmt.Println(res.Doc)

     

       238
       238
       +
       	fmt.Println(res.Doc.VerificationMethod)

     

       239
       239
       +
       	return c.Render(http.StatusOK, "templates/did.html", data)

     

       240
       240
       +
       }

+400

go-didplc/cmd/webplc/spec/v0.1/did-plc.md

···

       1
       1
       +
       

     

       2
       2
       +
       DID PLC Specification v0.1

     

       3
       3
       +
       ==========================

     

       4
       4
       +
       

     

       5
       5
       +
       DID Placeholder is a self-authenticating [DID](https://www.w3.org/TR/did-core/) which is strongly-consistent, recoverable, and allows for key rotation.

     

       6
       6
       +
       

     

       7
       7
       +
       An example DID is: `did:plc:yk4dd2qkboz2yv6tpubpc6co`

     

       8
       8
       +
       

     

       9
       9
       +
       Control over a `did:plc` identity rests in a set of re-configurable "rotation" keys pairs. These keys can sign update "operations" to mutate the identity (including key rotations), with each operation referencing a prior version of the identity state by hash. Each identity starts from an initial "genesis" operation, and the hash of this initial object is what defines the DID itself (that is, the DID URI "identifier" string). A central "directory" server collects and validates operations, and maintains a transparent log of operations for each DID.

     

       10
       10
       +
       

     

       11
       11
       +
       ## Motivation

     

       12
       12
       +
       

     

       13
       13
       +
       [Bluesky](https://blueskyweb.xyz/) developed DID Placeholder when designing the [AT Protocol](https://atproto.com) ("atproto") because we were not satisfied with any of the existing DID methods.

     

       14
       14
       +
       We wanted a strongly consistent, highly available, recoverable, and cryptographically secure method with fast and cheap propagation of updates.

     

       15
       15
       +
       

     

       16
       16
       +
       We titled the method "Placeholder", because we _don't_ want it to stick around forever in its current form. We are actively hoping to replace it with or evolve it into something less centralized - likely a permissioned DID consortium. That being said, we do intend to support `did:plc` in the current form until after any successor is deployed, with a reasonable grace period. We would also provide a migration route to allow continued use of existing `did:plc` identifiers.

     

       17
       17
       +
       

     

       18
       18
       +
       ## How it works

     

       19
       19
       +
       

     

       20
       20
       +
       The core data fields associated with an active `did:plc` identifier at any point in time are listed below. The encoding and structure differs somewhat from DID document formatting and semantics, but this information is sufficient to render a valid DID document.

     

       21
       21
       +
       

     

       22
       22
       +
       - `did` (string): the full DID identifier

     

       23
       23
       +
       - `rotationKeys` (array of strings): priority-ordered list of public keys in `did:key` encoding. must include least 1 key and at most 5 keys, with no duplication. control of the DID identifier rests in these keys. not included in DID document.

     

       24
       24
       +
       - `verificationMethods` (map with string keys and values): a set service / public key mappings. the values are public keys `did:key` encoding; they get re-encoded in "multibase" form when rendered in DID document. the key strings should not include a `#` prefix; that will be added when rendering the DID document. used to generate `verificationMethods` of DID document. these keys do not have control over the DID document

     

       25
       25
       +
       - `alsoKnownAs` (array of strings): priority-ordered list of URIs which indicate other names or aliases associated with the DID identifier

     

       26
       26
       +
       - `services` (map with string keys; values are maps with `type` and `endpoint` string fields): a set of service / URL mappings. the key strings should not include a `#` prefix; that will be added when rendering the DID document.

     

       27
       27
       +
       

     

       28
       28
       +
       Every update "operation" to the DID identifier, including the initial creation operation ("genesis" operation), contains all of the above information, except for the `did` field. The DID itself is generated from a hash of the signed genesis operation (details described below), which makes the DID entirely self-certifying. Updates after initial creation contain a pointer to the most-recent previous operation (by hash).

     

       29
       29
       +
       

     

       30
       30
       +
       "Operations" are signed and submitted to the central PLC directory server over an un-authenticated HTTP request. The PLC server validates operations against any and all existing operations on the DID (including signature validation, recovery time windows, etc), and either rejects the operation or accepts and permanently stores the operation, along with a server-generated timestamp.

     

       31
       31
       +
       

     

       32
       32
       +
       A special operation type is a "tombstone", which clears all of the data fields and permanently "de-activates" the DID. Note that the usual recovery time window applies to "tombstone" operations.

     

       33
       33
       +
       

     

       34
       34
       +
       Note that `rotationKeys` and `verificationMethods` ("signing keys") may have public keys which are re-used across many accounts. There is not necessarily a one-to-one mapping between a DID and either "rotation" keys or "signing" keys.

     

       35
       35
       +
       

     

       36
       36
       +
       Only `secp256k1` ("k256") and NIST P-256 ("p256") keys are currently supported, for both "rotation" and "signing" keys.

     

       37
       37
       +
       

     

       38
       38
       +
       ### Use with AT Protocol

     

       39
       39
       +
       

     

       40
       40
       +
       The following information should be included for use with atproto:

     

       41
       41
       +
       

     

       42
       42
       +
       - `verificationMethods`: an `atproto` entry with a "blessed" public key type, to be used as a "signing key" for authenticating updates to the account's repository. the signing key does not have any control over the DID identity unless also included in the `rotationKeys` list. best practice is to maintain separation between rotation keys and atproto signing keys

     

       43
       43
       +
       - `alsoKnownAs`: should include an `at://` URI indicating a "handle" (hostname) for the account. note that the handle/DID mapping needs to be validated bi-directionally (via handle resolution), and needs to be re-verified periodically

     

       44
       44
       +
       - `services`: an `atproto_pds` entry with an `AtprotoPersonalDataServer` type and http/https URL `endpoint` indicating the account's current PDS hostname. for example, `https://pds.example.com` (no `/xrpc/` suffix needed).

     

       45
       45
       +
       

     

       46
       46
       +
       ### Operation Serialization, Signing, and Validation

     

       47
       47
       +
       

     

       48
       48
       +
       There are a couple variations on the "operation" data object schema. The operations are also serialized both as simple JSON objects, or binary DAG-CBOR encoding for the purpose of hashing or signing.

     

       49
       49
       +
       

     

       50
       50
       +
       A regular creation or update operation contains the following fields:

     

       51
       51
       +
       

     

       52
       52
       +
       - `type` (string): with fixed value `plc_operation`

     

       53
       53
       +
       - `rotationKeys` (array of strings): as described above

     

       54
       54
       +
       - `verificationMethods` (mapping of string keys and values): as described above

     

       55
       55
       +
       - `alsoKnownAs` (array of strings): as described above

     

       56
       56
       +
       - `services` (mapping of string keys and object values): as described above

     

       57
       57
       +
       - `prev` (string, nullable): a "CID" hash pointer to a previous operation if an update, or `null` for a creation. if `null`, the key should actually be part of the object, with value `null`, not simply omitted. in DAG-CBOR encoding, the CID is string-encoded, not a binary IPLD "Link"

     

       58
       58
       +
       - `sig` (string): signature of the operation in `base64url` encoding

     

       59
       59
       +
       

     

       60
       60
       +
       A tombstone operation contains:

     

       61
       61
       +
       

     

       62
       62
       +
       - `type` (string): with fixed value `plc_tombstone`

     

       63
       63
       +
       - `prev` (string): same as above, but not nullable

     

       64
       64
       +
       - `sig` (string): signature of the operation (same as above)

     

       65
       65
       +
       

     

       66
       66
       +
       There is also a deprecated legacy operation format, supported *only* for creation ("genesis") operations:

     

       67
       67
       +
       

     

       68
       68
       +
       - `type` (string): with fixed value `create`

     

       69
       69
       +
       - `signingKey` (string): single `did:key` value (not an array of strings)

     

       70
       70
       +
       - `recoveryKey` (string): single `did:key` value (not an array of strings); and note "recovery" terminology, not "rotation"

     

       71
       71
       +
       - `handle` (string): single value, indicating atproto handle, instead of `alsoKnownAs`. bare handle, with no `at://` prefix

     

       72
       72
       +
       - `service` (string): single value, http/https URL of atproto PDS

     

       73
       73
       +
       - `prev` (null): always include, but always with value `null`

     

       74
       74
       +
       - `sig` (string): signature of the operation (same as above)

     

       75
       75
       +
       

     

       76
       76
       +
       Legacy `create` operations are stored in the PLC registry and may be returned in responses, so validating software needs to support that format. Conversion of the legacy format to "regular" operation format is relatively straight-forward, but there exist many `did:plc` identifiers where the DID identifier itself is based on the hash of the old format, so they will unfortunately be around forever.

     

       77
       77
       +
       

     

       78
       78
       +
       The process for signing and hashing operation objects is to first encode them in the DAG-CBOR binary serialization format. [DAG-CBOR](https://ipld.io/specs/codecs/dag-cbor/spec/) is a restricted subset of the Concise Binary Object Representation (CBOR), an IETF standard (RFC 8949), with semantics and value types similar to JSON.

     

       79
       79
       +
       

     

       80
       80
       +
       As an anti-abuse mechanism, operations have a maximum size when encoded as DAG-CBOR. The current limit is 7500 bytes.

     

       81
       81
       +
       

     

       82
       82
       +
       For signatures, the object is first encoded as DAG-CBOR *without* the `sig` field at all (as opposed to a `null` value in that field). Those bytes are signed, and then the signature bytes are encoded as a string using `base64url` encoding. The `sig` value is then populated with the string. In strongly typed programming languages it is a best practice to have distinct "signed" and "unsigned" types.

     

       83
       83
       +
       

     

       84
       84
       +
       When working with signatures, note that ECDSA signatures are not necessarily *deterministic* or *unique*. That is, the same key signing the same bytes *might* generate the same signature every time, or it might generate a *different* signature every time, depending on the cryptographic library and configuration. In some cases it is also easy for a third party to take a valid signature and transform it in to a new, distinct signature, which also validates. Be sure to always use the "validate signature" routine from a cryptographic library, instead of re-signing bytes and directly comparing the signature bytes.

     

       85
       85
       +
       

     

       86
       86
       +
       For `prev` references, the SHA-256 of the previous operation's bytes are encoded as a "[CID](https://github.com/multiformats/cid)", with the following parameters:

     

       87
       87
       +
       

     

       88
       88
       +
       - CIDv1

     

       89
       89
       +
       - `base32` multibase encoding (prefix: `b`)

     

       90
       90
       +
       - `dag-cbor` multibase type (code: 0x71)

     

       91
       91
       +
       - `sha-256` multihash (code: 0x12)

     

       92
       92
       +
       

     

       93
       93
       +
       Rotation keys are serialized as strings using [did:key](https://w3c-ccg.github.io/did-method-key/), and only `secp256k1` ("k256") and NIST P-256 ("p256") are currently supported.

     

       94
       94
       +
       

     

       95
       95
       +
       The signing keys (`verificationMethods`) are also serialized using `did:key` in operations. When rendered in a DID document, signing keys are represented as objects, with the actual keys in multibase encoding, as required by the DID Core specification.

     

       96
       96
       +
       

     

       97
       97
       +
       The DID itself is derived from the hash of the first operation in the log, called the "genesis" operation. The signed operation is encoded in DAG-CBOR; the bytes are hashed with SHA-256; the hash bytes are `base32`-encoded (not hex encoded) as a string; and that string is truncated to 24 chars to yield the "identifier" segment of the DID.

     

       98
       98
       +
       

     

       99
       99
       +
       In pseudo-code: 

     

       100
       100
       +
       `did:plc:${base32Encode(sha256(createOp)).slice(0,24)}`

     

       101
       101
       +
       

     

       102
       102
       +
       ### Identifier Syntax

     

       103
       103
       +
       

     

       104
       104
       +
       The DID Placeholder method name is `plc`. The identifier part is 24 characters

     

       105
       105
       +
       long, including only characters from the `base32` encoding set. An example is

     

       106
       106
       +
       `did:plc:yk4dd2qkboz2yv6tpubpc6co`. This means:

     

       107
       107
       +
       

     

       108
       108
       +
       - the overall identifier length is 32 characters

     

       109
       109
       +
       - the entire identifier is lower-case (and should be normalized to lower-case)

     

       110
       110
       +
       - the entire identifier is ASCII, and includes only the characters `a-z`, `0-9`, and `:` (and does not even use digits `0189`)

     

       111
       111
       +
       

     

       112
       112
       +
       

     

       113
       113
       +
       ### Key Rotation & Account Recovery

     

       114
       114
       +
       

     

       115
       115
       +
       Any key specified in `rotationKeys` has the ability to sign operations for the DID document.

     

       116
       116
       +
       

     

       117
       117
       +
       The set of rotation keys for a DID is not included in the DID document. They are an internal detail of PLC, and are stored in the operation log.

     

       118
       118
       +
       

     

       119
       119
       +
       Keys are listed in the `rotationKeys` field of operations in order of descending authority. 

     

       120
       120
       +
       

     

       121
       121
       +
       The PLC server provides a 72hr window during which a higher authority rotation key can "rewrite" history, clobbering any operations (or chain of operations) signed by a lower-authority rotation key.

     

       122
       122
       +
       

     

       123
       123
       +
       To do so, that key must sign a new operation that points to the CID of the last "valid" operation - ie the fork point.

     

       124
       124
       +
       The PLC server will accept this recovery operation as long as:

     

       125
       125
       +
       

     

       126
       126
       +
       - it is submitted within 72hrs of the referenced operation

     

       127
       127
       +
       - the key used for the signature has a lower index in the `rotationKeys` array than the key that signed the to-be-invalidated operation

     

       128
       128
       +
       

     

       129
       129
       +
       

     

       130
       130
       +
       ### Privacy and Security Concerns

     

       131
       131
       +
       

     

       132
       132
       +
       The full history of DID operations and updates, including timestamps, is permanently publicly accessible. This is true even after DID deactivation. It is important to recognize (and communicate to account holders) that any personally identifiable information (PII) encoded in `alsoKnownAs` URIs will be publicly visible even after DID deactivation, and can not be redacted or purged.

     

       133
       133
       +
       

     

       134
       134
       +
       In the context of atproto, this includes the full history of handle updates and PDS locations (URLs) over time. To be explicit, it does not include any other account metadata such as email addresses or IP addresses. Handle history could potentially de-anonymize account holders if they switch handles between a known identity and an anonymous or pseudonymous identity.

     

       135
       135
       +
       

     

       136
       136
       +
       The PLC server does not cross-validate `alsoKnownAs` or `service` entries in operations. This means that any DID can "claim" to have any identity, or to have an active account with any service (identified by URL). This data should *not* be trusted without bi-directionally verification, for example using handle resolution.

     

       137
       137
       +
       

     

       138
       138
       +
       The timestamp metadata encoded in the PLC audit log could be cross-verified against network traffic or other information to de-anonymize account holders. It also makes the "identity creation date" public.

     

       139
       139
       +
       

     

       140
       140
       +
       If "rotation" and "signing" keys are re-used across multiple account, it could reveal non-public identity details or relationships. For example, if two individuals cross-share rotation keys as a trusted backup, that information is public. If device-local recovery or signing keys are uniquely shared by two identifiers, that would indicate that those identities may actually be the same person.

     

       141
       141
       +
       

     

       142
       142
       +
       

     

       143
       143
       +
       #### PLC Server Trust Model

     

       144
       144
       +
       

     

       145
       145
       +
       The PLC server has a public endpoint to receive operation objects from any client (without authentication). The server verifies operations, orders them according to recovery rules, and makes the log of operations publicly available.

     

       146
       146
       +
       

     

       147
       147
       +
       The operation log is self-certifying, and contains all the information needed to construct (or verify) the the current state of the DID document.

     

       148
       148
       +
       

     

       149
       149
       +
       Some trust is required in the PLC server. Its attacks are limited to:

     

       150
       150
       +
       

     

       151
       151
       +
       - Denial of service: rejecting valid operations, or refusing to serve some information about the DID

     

       152
       152
       +
       - Misordering: In the event of a fork in DID document history, the server could choose to serve the "wrong" fork

     

       153
       153
       +
       

     

       154
       154
       +
       

     

       155
       155
       +
       ### DID Creation

     

       156
       156
       +
       

     

       157
       157
       +
       To summarize the process of creating a new `did:plc` identifier:

     

       158
       158
       +
       

     

       159
       159
       +
       - collect values for all of the core data fields, including generating new secure key pairs if necessary

     

       160
       160
       +
       - construct an "unsigned" regular operation object. include a `prev` field with `null` value. do not use the deprecated/legacy operation format for new DID creations

     

       161
       161
       +
       - serialize the "unsigned" operation with DAG-CBOR, and sign the resulting bytes with one of the initial `rotationKeys`. encode the signature as `base64url`, and use that to construct a "signed" operation object

     

       162
       162
       +
       - serialize the "signed" operation with DAG-CBOR, take the SHA-256 hash of those bytes, and encode the hash bytes in `base32`. use the first 24 characters to generate DID value (`did:plc:<hashchars>`)

     

       163
       163
       +
       - serialize the "signed" operation as simple JSON, and submit it via HTTP POST to `https://plc.directory/:did`

     

       164
       164
       +
       - if the HTTP status code is successful, the DID has been registered

     

       165
       165
       +
       

     

       166
       166
       +
       When "signing" using a "`rotationKey`", what is meant is to sign using the private key associated the public key in the `rotationKey` list.

     

       167
       167
       +
       

     

       168
       168
       +
       ### DID Update

     

       169
       169
       +
       

     

       170
       170
       +
       To summarize the process of updating a new `did:plc` identifier:

     

       171
       171
       +
       

     

       172
       172
       +
       - if the current DID state isn't known, fetch the current state from `https://plc.directory/:did/data`

     

       173
       173
       +
       - if the most recent valid DID operation CID (hash) isn't known, fetch the audit log from `https://plc.directory/:did/log/audit`, identify the most recent valid operation, and get the `cid` value. if this is a recovery operation, the relevant "valid" operation to fork from may not be the most recent in the audit log

     

       174
       174
       +
       - collect updated values for all of the core data fields, including generating new secure key pairs if necessary (eg, key rotation)

     

       175
       175
       +
       - construct an "unsigned" regular operation object. include a `prev` field with the CID (hash) of the previous valid operation

     

       176
       176
       +
       - serialize the "unsigned" operation with DAG-CBOR, and sign the resulting bytes with one of the previously-existing `rotationKeys`. encode the signature as `base64url`, and use that to construct a "signed" operation object

     

       177
       177
       +
       - serialize the "signed" operation as simple JSON, and submit it via HTTP POST to `https://plc.directory/:did`

     

       178
       178
       +
       - if the HTTP status code is successful, the DID has been updated

     

       179
       179
       +
       - the DID update may be nullified by a "rotation" operation during the recovery window (currently 72hr)

     

       180
       180
       +
       

     

       181
       181
       +
       ### DID Deactivation

     

       182
       182
       +
       

     

       183
       183
       +
       To summarize the process of de-activating an existing `did:plc` identifier:

     

       184
       184
       +
       

     

       185
       185
       +
       - if the most recent valid DID operation CID (hash) isn't known, fetch the audit log from `https://plc.directory/:did/log/audit`, identify the most recent valid operation, and get the `cid` value

     

       186
       186
       +
       - construct an "unsigned" tombstone operation object. include a `prev` field with the CID (hash) of the previous valid operation

     

       187
       187
       +
       - serialize the "unsigned" tombstone operation with DAG-CBOR, and sign the resulting bytes with one of the previously-existing `rotationKeys`. encode the signature as `base64url`, and use that to construct a "signed" tombstone operation object

     

       188
       188
       +
       - serialize the "signed" tombstone operation as simple JSON, and submit it via HTTP POST to `https://plc.directory/:did`

     

       189
       189
       +
       - if the HTTP status code is successful, the DID has been deactivated

     

       190
       190
       +
       - the DID deactivation may be nullified by a "rotation" operation during the recovery window (currently 72hr)

     

       191
       191
       +
       

     

       192
       192
       +
       ### DID Resolution

     

       193
       193
       +
       

     

       194
       194
       +
       PLC DIDs are resolved to a DID document (JSON) by making simple HTTP GET request to the PLC server. The resolution endpoint is: `https://plc.directory/:did`

     

       195
       195
       +
       

     

       196
       196
       +
       The PLC-specific state data (based on the most recent operation) can be fetched as a JSON object at: `https://plc.directory/:did/data`

     

       197
       197
       +
       

     

       198
       198
       +
       

     

       199
       199
       +
       ### Audit Logs

     

       200
       200
       +
       

     

       201
       201
       +
       As an additional check against abuse by the PLC server, and to promote resiliency, the set of all identifiers is enumerable, and the set of all operations for all identifiers (even "nullified" operations) can be enumerated and audited.

     

       202
       202
       +
       

     

       203
       203
       +
       The log of currently-valid operations for a given DID, as JSON, can be found at: `https://plc.directory/:did/log/audit`

     

       204
       204
       +
       

     

       205
       205
       +
       The audit history of a given DID (complete with timestamps and invalidated forked histories), as JSON, can be found at: `https://plc.directory/:did/log/audit`

     

       206
       206
       +
       

     

       207
       207
       +
       To fully validate a DID document against the operation log:

     

       208
       208
       +
       

     

       209
       209
       +
       - fetch the full audit log

     

       210
       210
       +
       - for the genesis operation, validate the DID

     

       211
       211
       +
           - note that the genesis operation may be in deprecated/legacy format, and should be encoded and verified in that format

     

       212
       212
       +
           - see the "DID Creation" section above for details

     

       213
       213
       +
       - for each operation in the log, validate signatures:

     

       214
       214
       +
           - identify the set of valid `rotationKeys` at that point of time: either the initial keys for a "genesis" operation, or the keys in the `prev` operation

     

       215
       215
       +
           - remove any `sig` field and serialize the "unsigned" operation with DAG-CBOR, yielding bytes

     

       216
       216
       +
           - decode the `base64url` `sig` field to bytes

     

       217
       217
       +
           - for each of the `rotationKeys`, attempt to verify the signature against the "unsigned" bytes

     

       218
       218
       +
           - if no key matches, there has been a trust violation; the PLC server should never have accepted the operation

     

       219
       219
       +
       - verify the correctness of "nullified" operations and the current active operation log using the rules around rotation keys and recovery windows

     

       220
       220
       +
       

     

       221
       221
       +
       The complete log of operations for all DIDs on the PLC server can be enumerated efficiently:

     

       222
       222
       +
       

     

       223
       223
       +
       - HTTP endpoint: `https://plc.directory/export`

     

       224
       224
       +
       - output format: [JSON lines](https://jsonlines.org/)

     

       225
       225
       +
       - `count` query parameter, as an integer, maximum 1000 lines per request

     

       226
       226
       +
       - `after` query parameter, based on `createdAt` timestamp, for pagination

     

       227
       227
       +
       

     

       228
       228
       +
       

     

       229
       229
       +
       ## Example

     

       230
       230
       +
       

     

       231
       231
       +
       ```ts

     

       232
       232
       +
       // note: we use shorthand for keys for ease of reference, but consider them valid did:keys

     

       233
       233
       +
       

     

       234
       234
       +
       // Genesis operation

     

       235
       235
       +
       const genesisOp = {

     

       236
       236
       +
         type: 'plc_operation',

     

       237
       237
       +
         verificationMethods: {

     

       238
       238
       +
           atproto: "did:key:zSigningKey"

     

       239
       239
       +
         },

     

       240
       240
       +
         rotationKeys: [

     

       241
       241
       +
           "did:key:zRecoveryKey",

     

       242
       242
       +
           "did:key:zRotationKey"

     

       243
       243
       +
         ],

     

       244
       244
       +
         alsoKnownAs: [

     

       245
       245
       +
           "at://alice.test"

     

       246
       246
       +
         ],

     

       247
       247
       +
         services: {

     

       248
       248
       +
           atproto_pds: {

     

       249
       249
       +
             type: "AtprotoPersonalDataServer",

     

       250
       250
       +
             endpoint: "https://example.test"

     

       251
       251
       +
           }

     

       252
       252
       +
         },

     

       253
       253
       +
         prev: null,

     

       254
       254
       +
         sig: 'sig_from_did:key:zRotationKey'

     

       255
       255
       +
       }

     

       256
       256
       +
       

     

       257
       257
       +
       // Operation to update recovery key

     

       258
       258
       +
       const updateKeys = {

     

       259
       259
       +
         type: 'plc_operation',

     

       260
       260
       +
         verificationMethods: {

     

       261
       261
       +
           atproto: "did:key:zSigningKey"

     

       262
       262
       +
         },

     

       263
       263
       +
         rotationKeys: [

     

       264
       264
       +
           "did:key:zNewRecoveryKey",

     

       265
       265
       +
           "did:key:zRotationKey"

     

       266
       266
       +
         ],

     

       267
       267
       +
         alsoKnownAs: [

     

       268
       268
       +
           "at://alice.test"

     

       269
       269
       +
         ],

     

       270
       270
       +
         services: {

     

       271
       271
       +
           atproto_pds: {

     

       272
       272
       +
             type: "AtprotoPersonalDataServer",

     

       273
       273
       +
             endpoint: "https://example.test"

     

       274
       274
       +
           }

     

       275
       275
       +
         },

     

       276
       276
       +
         prev: CID(genesisOp),

     

       277
       277
       +
         sig: 'sig_from_did:key:zRotationKey'

     

       278
       278
       +
       }

     

       279
       279
       +
       

     

       280
       280
       +
       // Invalid operation that will be rejected

     

       281
       281
       +
       // because did:key:zAttackerKey is not listed in rotationKeys

     

       282
       282
       +
       const invalidUpdate = {

     

       283
       283
       +
         type: 'plc_operation',

     

       284
       284
       +
         verificationMethods: {

     

       285
       285
       +
           atproto: "did:key:zAttackerKey"

     

       286
       286
       +
         },

     

       287
       287
       +
         rotationKeys: [

     

       288
       288
       +
           "did:key:zAttackerKey"

     

       289
       289
       +
         ],

     

       290
       290
       +
         alsoKnownAs: [

     

       291
       291
       +
           "at://bob.test"

     

       292
       292
       +
         ],

     

       293
       293
       +
         services: {

     

       294
       294
       +
           atproto_pds: {

     

       295
       295
       +
             type: "AtprotoPersonalDataServer",

     

       296
       296
       +
             endpoint: "https://example.test"

     

       297
       297
       +
           }

     

       298
       298
       +
         },

     

       299
       299
       +
         prev: CID(updateKeys),

     

       300
       300
       +
         sig: 'sig_from_did:key:zAttackerKey'

     

       301
       301
       +
       }

     

       302
       302
       +
       

     

       303
       303
       +
       // Valid recovery operation that "undoes" updateKeys

     

       304
       304
       +
       const recoveryOp = {

     

       305
       305
       +
         type: 'plc_operation',

     

       306
       306
       +
         verificationMethods: {

     

       307
       307
       +
           atproto: "did:key:zSigningKey"

     

       308
       308
       +
         },

     

       309
       309
       +
         rotationKeys: [

     

       310
       310
       +
           "did:key:zRecoveryKey"

     

       311
       311
       +
         ],

     

       312
       312
       +
         alsoKnownAs: [

     

       313
       313
       +
           "at://alice.test"

     

       314
       314
       +
         ],

     

       315
       315
       +
         services: {

     

       316
       316
       +
           atproto_pds: {

     

       317
       317
       +
             type: "AtprotoPersonalDataServer",

     

       318
       318
       +
             endpoint: "https://example.test"

     

       319
       319
       +
           }

     

       320
       320
       +
         },

     

       321
       321
       +
         prev: CID(genesisOp),

     

       322
       322
       +
         sig: 'sig_from_did:key:zRecoveryKey'

     

       323
       323
       +
       }

     

       324
       324
       +
       ```

     

       325
       325
       +
       

     

       326
       326
       +
       ## Presentation as DID Document 

     

       327
       327
       +
       

     

       328
       328
       +
       The following data:

     

       329
       329
       +
       

     

       330
       330
       +
       ```ts

     

       331
       331
       +
       {

     

       332
       332
       +
         did: 'did:plc:7iza6de2dwap2sbkpav7c6c6',

     

       333
       333
       +
         verificationMethods: {

     

       334
       334
       +
           atproto: 'did:key:zDnaeh9v2RmcMo13Du2d6pjUf5bZwtauYxj3n9dYjw4EZUAR7'

     

       335
       335
       +
         },

     

       336
       336
       +
         rotationKeys: [

     

       337
       337
       +
           'did:key:zDnaedvvAsDE6H3BDdBejpx9ve2Tz95cymyCAKF66JbyMh1Lt',

     

       338
       338
       +
           'did:key:zDnaeh9v2RmcMo13Du2d6pjUf5bZwtauYxj3n9dYjw4EZUAR7'

     

       339
       339
       +
         ],

     

       340
       340
       +
         alsoKnownAs: [

     

       341
       341
       +
           'at://alice.test'

     

       342
       342
       +
         ],

     

       343
       343
       +
         services: {

     

       344
       344
       +
           atproto_pds: {

     

       345
       345
       +
             type: "AtprotoPersonalDataServer",

     

       346
       346
       +
             endpoint: "https://example.test"

     

       347
       347
       +
           }

     

       348
       348
       +
         }

     

       349
       349
       +
       }

     

       350
       350
       +
       ```

     

       351
       351
       +
       

     

       352
       352
       +
       Will be presented as the following DID document:

     

       353
       353
       +
       

     

       354
       354
       +
       ```ts

     

       355
       355
       +
       {

     

       356
       356
       +
         '@context': [

     

       357
       357
       +
           'https://www.w3.org/ns/did/v1',

     

       358
       358
       +
           'https://w3id.org/security/suites/ecdsa-2019/v1'

     

       359
       359
       +
         ],

     

       360
       360
       +
         id: 'did:plc:7iza6de2dwap2sbkpav7c6c6',

     

       361
       361
       +
         alsoKnownAs: [ 'at://alice.test' ],

     

       362
       362
       +
         verificationMethod: [

     

       363
       363
       +
           {

     

       364
       364
       +
             id: '#atproto',

     

       365
       365
       +
             type: 'EcdsaSecp256r1VerificationKey2019',

     

       366
       366
       +
             controller: 'did:plc:7iza6de2dwap2sbkpav7c6c6',

     

       367
       367
       +
             publicKeyMultibase: 'zSSa7w8s5aApu6td45gWTAAFkqCnaWY6ZsJ8DpyzDdYmVy4fARKqbn5F1UYBUMeVvYTBsoSoLvZnPdjd3pVHbmAHP'

     

       368
       368
       +
           }

     

       369
       369
       +
         ],

     

       370
       370
       +
         service: [

     

       371
       371
       +
           {

     

       372
       372
       +
             id: '#atproto_pds',

     

       373
       373
       +
             type: 'AtprotoPersonalDataServer',

     

       374
       374
       +
             serviceEndpoint: 'https://example2.com'

     

       375
       375
       +
           }

     

       376
       376
       +
         ]

     

       377
       377
       +
       }

     

       378
       378
       +
       ```

     

       379
       379
       +
       

     

       380
       380
       +
       ## Possible Future Changes

     

       381
       381
       +
       

     

       382
       382
       +
       The set of allowed ("blessed") public key cryptographic algorithms (aka, curves) may expanded over time, slowly. Likewise, support for additional "blessed" CID types and parameters may be expanded over time, slowly.

     

       383
       383
       +
       

     

       384
       384
       +
       The recovery time window may become configurable, within constraints, as part of the DID metadata itself.

     

       385
       385
       +
       

     

       386
       386
       +
       Support for "DID Controller Delegation" could be useful (eg, in the context of atproto PDS hosts), and may be incorporated.

     

       387
       387
       +
       

     

       388
       388
       +
       In the context of atproto, support for multiple "handles" for the same DID is being considered, with a single "primary" handle. But no final decision has been made yet.

     

       389
       389
       +
       

     

       390
       390
       +
       We welcome proposals for small additions to make `did:plc` more generic and reusable for applications other than atproto. But no promises: atproto will remain the focus for the near future.

     

       391
       391
       +
       

     

       392
       392
       +
       Moving governance of the `did:plc` method, and operation of registry servers, out of the sole control of Bluesky PBLLC is something we are enthusiastic about. Audit log snapshots, mirroring, and automated third-party auditing have all been considered as mechanisms to mitigate the centralized nature of the PLC server.

     

       393
       393
       +
       

     

       394
       394
       +
       The size of the `verificationMethods`, `alsoKnownAs`, and `service` mappings/arrays may be specifically constrained. And the maximum DAG-CBOR size may be constrained.

     

       395
       395
       +
       

     

       396
       396
       +
       As an anti-abuse mechanisms, the PLC server load balancer restricts the number of HTTP requests per time window. The limits are generous, and operating large services or scraping the operation log should not run in to limits. Specific per-DID limits on operation rate may be introduced over time. For example, no more than N operations per DID per rotation key per 24 hour window.

     

       397
       397
       +
       

     

       398
       398
       +
       A "DID PLC history explorer" web interface would make the public nature of the DID audit log more publicly understandable.

     

       399
       399
       +
       

     

       400
       400
       +
       It is concievable that longer DID PLCs, with more of the SHA-256 characters, will be supported in the future. It is also concievable that a different hash algorithm would be allowed. Any such changes would allow existing DIDs in their existing syntax to continue being used.

go-didplc/cmd/webplc/static

···

       1
       1
       +
       ../../static/

go-didplc/cmd/webplc/templates

···

       1
       1
       +
       ../../templates/

go-didplc/example.dev.env

···

       1
       1
       +
       ATP_PLC_HOST='http://localhost:2582'

     

       2
       2
       +
       DEBUG='true'

     

       3
       3
       +
       GOLOG_LOG_LEVEL=debug

go-didplc/example.env

···

       1
       1
       +
       #ATP_PLC_HOST='https://plc.directory'

     

       2
       2
       +
       #HTTP_ADDRESS=':8700'

     

       3
       3
       +
       #DEBUG='false'

     

       4
       4
       +
       #GOLOG_LOG_LEVEL=warn

+35

go-didplc/go.mod

···

       1
       1
       +
       module github.com/bluesky-social/did-method-plc/webplc

     

       2
       2
       +
       

     

       3
       3
       +
       go 1.20

     

       4
       4
       +
       

     

       5
       5
       +
       require (

     

       6
       6
       +
       	github.com/flosch/pongo2/v6 v6.0.0

     

       7
       7
       +
       	github.com/ipfs/go-log v1.0.5

     

       8
       8
       +
       	github.com/joho/godotenv v1.5.1

     

       9
       9
       +
       	github.com/klauspost/compress v1.16.7

     

       10
       10
       +
       	github.com/labstack/echo/v4 v4.11.1

     

       11
       11
       +
       	github.com/urfave/cli/v2 v2.25.7

     

       12
       12
       +
       )

     

       13
       13
       +
       

     

       14
       14
       +
       require (

     

       15
       15
       +
       	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect

     

       16
       16
       +
       	github.com/gogo/protobuf v1.3.2 // indirect

     

       17
       17
       +
       	github.com/golang-jwt/jwt v3.2.2+incompatible // indirect

     

       18
       18
       +
       	github.com/ipfs/go-log/v2 v2.1.3 // indirect

     

       19
       19
       +
       	github.com/labstack/gommon v0.4.0 // indirect

     

       20
       20
       +
       	github.com/mattn/go-colorable v0.1.13 // indirect

     

       21
       21
       +
       	github.com/mattn/go-isatty v0.0.19 // indirect

     

       22
       22
       +
       	github.com/opentracing/opentracing-go v1.2.0 // indirect

     

       23
       23
       +
       	github.com/russross/blackfriday/v2 v2.1.0 // indirect

     

       24
       24
       +
       	github.com/valyala/bytebufferpool v1.0.0 // indirect

     

       25
       25
       +
       	github.com/valyala/fasttemplate v1.2.2 // indirect

     

       26
       26
       +
       	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect

     

       27
       27
       +
       	go.uber.org/atomic v1.7.0 // indirect

     

       28
       28
       +
       	go.uber.org/multierr v1.6.0 // indirect

     

       29
       29
       +
       	go.uber.org/zap v1.16.0 // indirect

     

       30
       30
       +
       	golang.org/x/crypto v0.11.0 // indirect

     

       31
       31
       +
       	golang.org/x/net v0.12.0 // indirect

     

       32
       32
       +
       	golang.org/x/sys v0.10.0 // indirect

     

       33
       33
       +
       	golang.org/x/text v0.11.0 // indirect

     

       34
       34
       +
       	golang.org/x/time v0.3.0 // indirect

     

       35
       35
       +
       )

+136

go-didplc/go.sum

···

       1
       1
       +
       github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=

     

       2
       2
       +
       github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8=

     

       3
       3
       +
       github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=

     

       4
       4
       +
       github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=

     

       5
       5
       +
       github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     

       6
       6
       +
       github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=

     

       7
       7
       +
       github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     

       8
       8
       +
       github.com/flosch/pongo2/v6 v6.0.0 h1:lsGru8IAzHgIAw6H2m4PCyleO58I40ow6apih0WprMU=

     

       9
       9
       +
       github.com/flosch/pongo2/v6 v6.0.0/go.mod h1:CuDpFm47R0uGGE7z13/tTlt1Y6zdxvr2RLT5LJhsHEU=

     

       10
       10
       +
       github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=

     

       11
       11
       +
       github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=

     

       12
       12
       +
       github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY=

     

       13
       13
       +
       github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=

     

       14
       14
       +
       github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=

     

       15
       15
       +
       github.com/ipfs/go-log v1.0.5 h1:2dOuUCB1Z7uoczMWgAyDck5JLb72zHzrMnGnCNNbvY8=

     

       16
       16
       +
       github.com/ipfs/go-log v1.0.5/go.mod h1:j0b8ZoR+7+R99LD9jZ6+AJsrzkPbSXbZfGakb5JPtIo=

     

       17
       17
       +
       github.com/ipfs/go-log/v2 v2.1.3 h1:1iS3IU7aXRlbgUpN8yTTpJ53NXYjAe37vcI5+5nYrzk=

     

       18
       18
       +
       github.com/ipfs/go-log/v2 v2.1.3/go.mod h1:/8d0SH3Su5Ooc31QlL1WysJhvyOTDCjcCZ9Axpmri6g=

     

       19
       19
       +
       github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=

     

       20
       20
       +
       github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=

     

       21
       21
       +
       github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=

     

       22
       22
       +
       github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=

     

       23
       23
       +
       github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I=

     

       24
       24
       +
       github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=

     

       25
       25
       +
       github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=

     

       26
       26
       +
       github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=

     

       27
       27
       +
       github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=

     

       28
       28
       +
       github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=

     

       29
       29
       +
       github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=

     

       30
       30
       +
       github.com/labstack/echo/v4 v4.11.1 h1:dEpLU2FLg4UVmvCGPuk/APjlH6GDpbEPti61srUUUs4=

     

       31
       31
       +
       github.com/labstack/echo/v4 v4.11.1/go.mod h1:YuYRTSM3CHs2ybfrL8Px48bO6BAnYIN4l8wSTMP6BDQ=

     

       32
       32
       +
       github.com/labstack/gommon v0.4.0 h1:y7cvthEAEbU0yHOf4axH8ZG2NH8knB9iNSoTO8dyIk8=

     

       33
       33
       +
       github.com/labstack/gommon v0.4.0/go.mod h1:uW6kP17uPlLJsD3ijUYn3/M5bAxtlZhMI6m3MFxTMTM=

     

       34
       34
       +
       github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=

     

       35
       35
       +
       github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=

     

       36
       36
       +
       github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=

     

       37
       37
       +
       github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=

     

       38
       38
       +
       github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=

     

       39
       39
       +
       github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=

     

       40
       40
       +
       github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=

     

       41
       41
       +
       github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs=

     

       42
       42
       +
       github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc=

     

       43
       43
       +
       github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=

     

       44
       44
       +
       github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=

     

       45
       45
       +
       github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=

     

       46
       46
       +
       github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=

     

       47
       47
       +
       github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=

     

       48
       48
       +
       github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=

     

       49
       49
       +
       github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=

     

       50
       50
       +
       github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=

     

       51
       51
       +
       github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=

     

       52
       52
       +
       github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=

     

       53
       53
       +
       github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=

     

       54
       54
       +
       github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=

     

       55
       55
       +
       github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs=

     

       56
       56
       +
       github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=

     

       57
       57
       +
       github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=

     

       58
       58
       +
       github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=

     

       59
       59
       +
       github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=

     

       60
       60
       +
       github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=

     

       61
       61
       +
       github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=

     

       62
       62
       +
       github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=

     

       63
       63
       +
       github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=

     

       64
       64
       +
       github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

     

       65
       65
       +
       github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

     

       66
       66
       +
       go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=

     

       67
       67
       +
       go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=

     

       68
       68
       +
       go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=

     

       69
       69
       +
       go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU=

     

       70
       70
       +
       go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4=

     

       71
       71
       +
       go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=

     

       72
       72
       +
       go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=

     

       73
       73
       +
       go.uber.org/zap v1.16.0 h1:uFRZXykJGK9lLY4HtgSw44DnIcAM+kRBP7x5m+NpAOM=

     

       74
       74
       +
       go.uber.org/zap v1.16.0/go.mod h1:MA8QOfq0BHJwdXa996Y4dYkAqRKB8/1K1QMMZVaNZjQ=

     

       75
       75
       +
       golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=

     

       76
       76
       +
       golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=

     

       77
       77
       +
       golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=

     

       78
       78
       +
       golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=

     

       79
       79
       +
       golang.org/x/crypto v0.11.0 h1:6Ewdq3tDic1mg5xRO4milcWCfMVQhI4NkqWWvqejpuA=

     

       80
       80
       +
       golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=

     

       81
       81
       +
       golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs=

     

       82
       82
       +
       golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=

     

       83
       83
       +
       golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=

     

       84
       84
       +
       golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=

     

       85
       85
       +
       golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=

     

       86
       86
       +
       golang.org/x/mod v0.8.0 h1:LUYupSeNrTNCGzR/hVBk2NHZO4hXcVaW1k4Qx7rjPx8=

     

       87
       87
       +
       golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=

     

       88
       88
       +
       golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=

     

       89
       89
       +
       golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=

     

       90
       90
       +
       golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=

     

       91
       91
       +
       golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=

     

       92
       92
       +
       golang.org/x/net v0.12.0 h1:cfawfvKITfUsFCeJIHJrbSxpeu/E81khclypR0GVT50=

     

       93
       93
       +
       golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=

     

       94
       94
       +
       golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       95
       95
       +
       golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       96
       96
       +
       golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       97
       97
       +
       golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=

     

       98
       98
       +
       golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

     

       99
       99
       +
       golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

     

       100
       100
       +
       golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       101
       101
       +
       golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       102
       102
       +
       golang.org/x/sys v0.0.0-20211103235746-7861aae1554b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       103
       103
       +
       golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       104
       104
       +
       golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       105
       105
       +
       golang.org/x/sys v0.10.0 h1:SqMFp9UcQJZa+pmYuAKjd9xq1f0j5rLcDIk0mj4qAsA=

     

       106
       106
       +
       golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       107
       107
       +
       golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

     

       108
       108
       +
       golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=

     

       109
       109
       +
       golang.org/x/text v0.11.0 h1:LAntKIrcmeSKERyiOh0XMV39LXS8IE9UL2yP7+f5ij4=

     

       110
       110
       +
       golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=

     

       111
       111
       +
       golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=

     

       112
       112
       +
       golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=

     

       113
       113
       +
       golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

     

       114
       114
       +
       golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=

     

       115
       115
       +
       golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=

     

       116
       116
       +
       golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=

     

       117
       117
       +
       golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=

     

       118
       118
       +
       golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=

     

       119
       119
       +
       golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=

     

       120
       120
       +
       golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=

     

       121
       121
       +
       golang.org/x/tools v0.6.0 h1:BOw41kyTf3PuCW1pVQf8+Cyg8pMlkYB1oo9iJ6D/lKM=

     

       122
       122
       +
       golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

     

       123
       123
       +
       golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

     

       124
       124
       +
       golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

     

       125
       125
       +
       golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

     

       126
       126
       +
       gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

     

       127
       127
       +
       gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

     

       128
       128
       +
       gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=

     

       129
       129
       +
       gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=

     

       130
       130
       +
       gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=

     

       131
       131
       +
       gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

     

       132
       132
       +
       gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

     

       133
       133
       +
       gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

     

       134
       134
       +
       gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

     

       135
       135
       +
       honnef.co/go/tools v0.0.1-2019.2.3 h1:3JgtbtFHMiCmsznwGVTUWbgGov+pVqnlf1dEJTNAXeM=

     

       136
       136
       +
       honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=

go-didplc/static/.well-known/security.txt

···

       1
       1
       +
       Contact: mailto:security@bsky.app

     

       2
       2
       +
       Preferred-Languages: en

     

       3
       3
       +
       Canonical: https://web.plc.directory/.well-known/security.txt

go-didplc/static/robots.txt

···

       1
       1
       +
       # Hello Friends!

     

       2
       2
       +
       

     

       3
       3
       +
       # By default, may crawl anything on this domain. HTTP 429 ("backoff") status codes are used for rate-limiting. Up to a handful of concurrent requests should be ok.

     

       4
       4
       +
       User-Agent: *

     

       5
       5
       +
       Allow: /

+44

go-didplc/templates/base.html

···

       1
       1
       +
       <!doctype html>

     

       2
       2
       +
       <html lang="en">

     

       3
       3
       +
       <head>

     

       4
       4
       +
         <meta charset="utf-8">

     

       5
       5
       +
         <meta name="referrer" content="origin-when-cross-origin">

     

       6
       6
       +
         <meta name="viewport" content="width=device-width, initial-scale=1">

     

       7
       7
       +
         <link rel="stylesheet" href="/static/simple.min.css">

     

       8
       8
       +
         <title>{%- block head_title -%}did:plc Directory{%- endblock -%}</title>

     

       9
       9
       +
         

     

       10
       10
       +
         <style>

     

       11
       11
       +
         </style>

     

       12
       12
       +
       

     

       13
       13
       +
       	<!--

     

       14
       14
       +
         <link rel="apple-touch-icon" sizes="180x180" href="/static/apple-touch-icon.png">

     

       15
       15
       +
         <link rel="icon" type="image/png" sizes="32x32" href="/static/favicon-32x32.png">

     

       16
       16
       +
         <link rel="icon" type="image/png" sizes="16x16" href="/static/favicon-16x16.png">

     

       17
       17
       +
         -->

     

       18
       18
       +
         {% block html_head_extra -%}{%- endblock %}

     

       19
       19
       +
         <meta name="application-name" name="did:plc Website">

     

       20
       20
       +
         <meta name="generator" name="webplc">

     

       21
       21
       +
       </head>

     

       22
       22
       +
       <body>

     

       23
       23
       +
       {%- block body_all %}

     

       24
       24
       +
       

     

       25
       25
       +
       

     

       26
       26
       +
       <header>

     

       27
       27
       +
         <nav>

     

       28
       28
       +
           <a href="/">Home</a>

     

       29
       29
       +
           <a href="/resolve" >Lookup</a>

     

       30
       30
       +
           <a href="/spec/v0.1/did-plc" >Specification</a>

     

       31
       31
       +
           <a href="https://github.com/bluesky-social/did-method-plc">Source Code</a>

     

       32
       32
       +
         </nav>

     

       33
       33
       +
         <h1>did:plc Identifier Directory</h1>

     

       34
       34
       +
         <p>a self-authenticating Decentralized Identifier (DID) system which is strongly-consistent, recoverable, and allows for key rotation</p>

     

       35
       35
       +
       </header>

     

       36
       36
       +
       <main>

     

       37
       37
       +
         {% block main %}{% endblock %}

     

       38
       38
       +
       </main>

     

       39
       39
       +
       <footer>

     

       40
       40
       +
         <p>Developed by <a href="https://blueskyweb.xyz">Bluesky</a> for <a href="https://atproto.com">atproto</a>.</p>

     

       41
       41
       +
       </footer>

     

       42
       42
       +
       {% endblock -%}

     

       43
       43
       +
       </body>

     

       44
       44
       +
       </html>

+80

go-didplc/templates/did.html

···

       1
       1
       +
       {% extends "base.html" %}

     

       2
       2
       +
       

     

       3
       3
       +
       {% block head_title %}

     

       4
       4
       +
       {{ did }}

     

       5
       5
       +
       {% endblock %}

     

       6
       6
       +
       

     

       7
       7
       +
       {% block main -%}

     

       8
       8
       +
       <h3 style="font-family: monospace;">{{ did }}</h3>

     

       9
       9
       +
       

     

       10
       10
       +
       {% if result.StatusCode == 200 %}

     

       11
       11
       +
       

     

       12
       12
       +
       <h4>Names and Aliases</h4>

     

       13
       13
       +
       <div style="width: 100%; overflow-x: auto;">

     

       14
       14
       +
       <table style="width: 100%;">

     

       15
       15
       +
         <thead>

     

       16
       16
       +
           <tr>

     

       17
       17
       +
             <th>URI</th>

     

       18
       18
       +
           </tr>

     

       19
       19
       +
         </thead>

     

       20
       20
       +
         <tbody style="font-family: monospace;">

     

       21
       21
       +
         	{% for uri in result.Doc.AlsoKnownAs %}

     

       22
       22
       +
           <tr>

     

       23
       23
       +
             <td>{{ uri }}</td>

     

       24
       24
       +
           </tr>

     

       25
       25
       +
         	{% endfor %}

     

       26
       26
       +
         </tbody>

     

       27
       27
       +
       </table>

     

       28
       28
       +
       </div>

     

       29
       29
       +
       

     

       30
       30
       +
       <h4>Services</h4>

     

       31
       31
       +
       <div style="width: 100%; overflow-x: auto;">

     

       32
       32
       +
       <table style="width: 100%;">

     

       33
       33
       +
         <thead>

     

       34
       34
       +
           <tr>

     

       35
       35
       +
             <th>ID</th>

     

       36
       36
       +
             <th>Type</th>

     

       37
       37
       +
             <th>URL</th>

     

       38
       38
       +
           </tr>

     

       39
       39
       +
         </thead>

     

       40
       40
       +
         <tbody style="font-family: monospace;">

     

       41
       41
       +
         	{% for vm in result.Doc.Service %}

     

       42
       42
       +
           <tr>

     

       43
       43
       +
           	<td>{{ vm.Id }}</td>

     

       44
       44
       +
           	<td>{{ vm.Type }}</td>

     

       45
       45
       +
           	<td>{{ vm.ServiceEndpoint }}</td>

     

       46
       46
       +
           </tr>

     

       47
       47
       +
         	{% endfor %}

     

       48
       48
       +
         </tbody>

     

       49
       49
       +
       </table>

     

       50
       50
       +
       </div>

     

       51
       51
       +
       

     

       52
       52
       +
       <h4>Verification Methods</h4>

     

       53
       53
       +
       <div style="width: 100%; overflow-x: auto;">

     

       54
       54
       +
       <table style="width: 100%;">

     

       55
       55
       +
         <thead>

     

       56
       56
       +
           <tr>

     

       57
       57
       +
             <th>ID</th>

     

       58
       58
       +
             <th>Type</th>

     

       59
       59
       +
             <th>Public Key (multibase-encoded)</th>

     

       60
       60
       +
           </tr>

     

       61
       61
       +
         </thead>

     

       62
       62
       +
         <tbody style="font-family: monospace;">

     

       63
       63
       +
         	{% for vm in result.Doc.VerificationMethod %}

     

       64
       64
       +
           <tr>

     

       65
       65
       +
           	<td>{{ vm.Id }}</td>

     

       66
       66
       +
           	<td>{{ vm.Type }}</td>

     

       67
       67
       +
           	<td>{{ vm.PublicKeyMultibase }}</td>

     

       68
       68
       +
           </tr>

     

       69
       69
       +
         	{% endfor %}

     

       70
       70
       +
         </tbody>

     

       71
       71
       +
       </table>

     

       72
       72
       +
       </div>

     

       73
       73
       +
       

     

       74
       74
       +
       <h4>DID Document JSON</h4>

     

       75
       75
       +
       <pre><code>

     

       76
       76
       +
       {{- result.DocJson -}}

     

       77
       77
       +
       </code></pre>

     

       78
       78
       +
       {% endif %}

     

       79
       79
       +
       

     

       80
       80
       +
       {%- endblock %}

go-didplc/templates/error.html

···

       1
       1
       +
       {% extends "base.html" %}

     

       2
       2
       +
       

     

       3
       3
       +
       {% block head_title %}Error {{ statusCode }} - did:plc{% endblock %}

     

       4
       4
       +
       

     

       5
       5
       +
       {%- block body_all %}

     

       6
       6
       +
           <h1>{{ statusCode }}: Server Error</h1>

     

       7
       7
       +
           <p>Sorry about that! Our <a href="https://status.bsky.app/">Status Page</a> might have more context.

     

       8
       8
       +
         {% endif %}

     

       9
       9
       +
       {% endblock -%}

go-didplc/templates/home.html

···

       1
       1
       +
       {% extends "base.html" %}

     

       2
       2
       +
       

     

       3
       3
       +
       {% block main -%}

     

       4
       4
       +
         <h2>Motivation</h2>

     

       5
       5
       +
         <p>Bluesky developed DID Placeholder when designing the AT Protocol ("atproto") because we were not satisfied with any of the existing DID methods. We wanted a strongly consistent, highly available, recoverable, and cryptographically secure method with fast and cheap propagation of updates.</p>

     

       6
       6
       +
       

     

       7
       7
       +
         <p>We titled the method "Placeholder", because we don't want it to stick around forever in its current form. We are actively hoping to replace it with or evolve it into something less centralized - likely a permissioned DID consortium. That being said, we do intend to support did:plc in the current form until after any successor is deployed, with a reasonable grace period. We would also provide a migration route to allow continued use of existing did:plc identifiers.</p>

     

       8
       8
       +
       {%- endblock %}

go-didplc/templates/markdown.html

···

       1
       1
       +
       {% extends "base.html" %}

     

       2
       2
       +
       

     

       3
       3
       +
       {% block head_title %}

     

       4
       4
       +
       {{ html_title }}

     

       5
       5
       +
       {% endblock %}

     

       6
       6
       +
       

     

       7
       7
       +
       {% block main -%}

     

       8
       8
       +
       {{ markdown_html|safe }}

     

       9
       9
       +
       {%- endblock %}

+15

go-didplc/templates/resolve.html

···

       1
       1
       +
       {% extends "base.html" %}

     

       2
       2
       +
       

     

       3
       3
       +
       {% block head_title %}

     

       4
       4
       +
       Resolve did:plc

     

       5
       5
       +
       {% endblock %}

     

       6
       6
       +
       

     

       7
       7
       +
       {% block main -%}

     

       8
       8
       +
       <h2>Resolve a did:plc Identifier</h2>

     

       9
       9
       +
       <form action="/resolve" method="get">

     

       10
       10
       +
         <p><label>DID</label>

     

       11
       11
       +
         <input type="text" name="did">

     

       12
       12
       +
         </p>

     

       13
       13
       +
         <input type="submit" value="Submit">

     

       14
       14
       +
       </form>

     

       15
       15
       +
       {%- endblock %}