ssi

README

github.com/nuts-foundation/go-did

A library to parse and generate W3C DID Documents and W3C Verifiable Credentials.

Example usage

Note on parsing: in earlier versions, DID documents, credentials and presentations were parsed using UnmarshalJSON. Now, ParseDocument(), ParseVerifiableCredential() and ParseVerifiablePresentation() should be used instead: they better support VCs and VPs in JWT format.

Parsing a DID document

didDoc, err := did.ParseDocument(didDocJson)
if err != nil {
    panic(err)
}
// do something with didDoc

Creating a DID document

Creation of a simple DID Document which is its own controller and contains an AssertionMethod.

didID, err := did.ParseDID("did:example:123")

// Empty did document:
doc := &did.Document{
    Context:            []did.URI{did.DIDContextV1URI()},
    ID:                 *didID,
}

// Add an assertionMethod
keyID, _ := did.ParseDIDURL("did:example:123#key-1")

keyPair, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
verificationMethod, err := did.NewVerificationMethod(*keyID, did.JsonWebKey2020, did.DID{}, keyPair.Public())

// This adds the method to the VerificationMethod list and stores a reference to the assertion list
doc.AddAssertionMethod(verificationMethod)

didJson, _ := json.MarshalIndent(doc, "", "  ")
fmt.Println(string(didJson))

Outputs:

{
  "assertionMethod": [
    "did:example:123#key-1"
  ],
  "@context": "https://www.w3.org/ns/did/v1",
  "controller": "did:example:123",
  "id": "did:example:123",
  "verificationMethod": [
    {
      "controller": "did:example:123",
      "id": "did:example:123#key-1",
      "publicKeyJwk": {
        "crv": "P-256",
        "kty": "EC",
        "x": "UANQ8pgvJT33JbrnwMiu1L1JCGQFOEm1ThaNAJcFrWA=",
        "y": "UWm6q5n1iXyeCJLMGDInN40bkkKr8KkoTWDqJBZQXRo="
      },
      "type": "JsonWebKey2020"
    }
  ]
}

Parsing Verifiable Credentials and Verifiable Presentations

The library supports parsing of Verifiable Credentials and Verifiable Presentations in JSON-LD, and JWT proof format. Use ParseVerifiableCredential(raw string) and ParseVerifiablePresentation(raw string).

Supported key types

• JsonWebKey2020
• Ed25519VerificationKey2018
• EcdsaSecp256k1VerificationKey2019 (pass build tag to enable: -tags=jwx_es256k)

Installation

go get github.com/nuts-foundation/go-did

Testing

go test ./... -tags=jwx_es256k

State of the library

We keep the API stable, breaking changes will only be introduced in new major versions.

Documentation

Index

• Constants
• type KeyType
• type ProofType
• type URI
  • func MustParseURI(input string) URI
  • func ParseURI(input string) (*URI, error)
  • func (v URI) MarshalJSON() ([]byte, error)
  • func (v URI) MarshalText() ([]byte, error)
  • func (v URI) String() string
  • func (v *URI) UnmarshalJSON(bytes []byte) error

Constants

const ECDSASECP256K1VerificationKey2019 = KeyType("EcdsaSecp256k1VerificationKey2019")

ECDSASECP256K1VerificationKey2019 is the EcdsaSecp256k1VerificationKey2019 verification key type as specified here: https://w3c-ccg.github.io/lds-ecdsa-secp256k1-2019/

const ED25519VerificationKey2018 = KeyType("Ed25519VerificationKey2018")

ED25519VerificationKey2018 is the Ed25519VerificationKey2018 verification key type as specified here: https://w3c-ccg.github.io/

const ED25519VerificationKey2020 = KeyType("Ed25519VerificationKey2020")

ED25519VerificationKey2020 is the Ed25519VerificationKey2020 verification key type as specified here: https://www.w3.org/TR/vc-di-eddsa/#ed25519verificationkey2020

const JsonWebKey2020 = KeyType("JsonWebKey2020")

JsonWebKey2020 is a VerificationMethod type. https://w3c-ccg.github.io/lds-jws2020/

const JsonWebSignature2020 = ProofType("JsonWebSignature2020")

JsonWebSignature2020 is a Proof type. https://w3c-ccg.github.io/lds-jws2020

const RSAVerificationKey2018 = KeyType("RsaVerificationKey2018")

RSAVerificationKey2018 is the RsaVerificationKey2018 verification key type as specified here: https://w3c-ccg.github.io/lds-rsa2018/

Types

type KeyType

type KeyType string

type ProofType

type ProofType string

type URI

type URI struct {
	url.URL
}

URI is a wrapper around url.URL to add json marshalling

func MustParseURI

func MustParseURI(input string) URI

func ParseURI

func ParseURI(input string) (*URI, error)

ParseURI parses a raw URI. If it can't be parsed, an error is returned.

func (URI) MarshalJSON

func (v URI) MarshalJSON() ([]byte, error)

func (URI) MarshalText

func (v URI) MarshalText() ([]byte, error)

MarshalText implements encoding.TextMarshaler

func (URI) String

func (v URI) String() string

func (*URI) UnmarshalJSON

func (v *URI) UnmarshalJSON(bytes []byte) error