format_dendrite.go

package signing_key

import (
	"bytes"
	"crypto/ed25519"
	"encoding/pem"
	"fmt"
	"strings"
)

// FormatDendrite is the Dendrite (https://github.com/element-hq/dendrite) format for signing keys.
const FormatDendrite Format = "dendrite"

func init() {
	mustRegisterFormat(FormatDendrite, &dendriteFormatter{})
}

type dendriteFormatter struct{}

func (f *dendriteFormatter) encode(key *Key) ([]byte, error) {
	block := &pem.Block{
		Type: "MATRIX PRIVATE KEY",
		Headers: map[string]string{
			"Key-ID": fmt.Sprintf("ed25519:%s", key.KeyVersion),
		},
		Bytes: key.PrivateKey.Seed(),
	}
	b := pem.EncodeToMemory(block)
	return b, nil
}

func (f *dendriteFormatter) decode(data []byte) (*Key, error) {
	keys, err := f.decodeAll(data)
	if err != nil {
		return nil, err
	}
	if len(keys) != 1 {
		return nil, fmt.Errorf("format_dendrite: expected exactly one key, got %d", len(keys))
	}
	return keys[0], nil
}

func (f *dendriteFormatter) decodeAll(data []byte) ([]*Key, error) {
	keys := make([]*Key, 0)

	var block *pem.Block
	for {
		block, data = pem.Decode(data)
		if data == nil {
			return nil, fmt.Errorf("format_dendrite: no signing key found")
		}
		if block == nil && (len(keys) == 0 || len(data) > 0) {
			return nil, fmt.Errorf("format_dendrite: unable to read suitable block from PEM data")
		} else if block == nil && len(data) == 0 {
			break
		}
		if block == nil {
			break
		}
		if block.Type == "MATRIX PRIVATE KEY" {
			keyVersion := block.Headers["Key-ID"]
			if keyVersion == "" {
				return nil, fmt.Errorf("format_dendrite: key version not found")
			}
			if !strings.HasPrefix(keyVersion, "ed25519:") {
				return nil, fmt.Errorf("format_dendrite: unsupported key type (expected ed25519)")
			}

			_, priv, err := ed25519.GenerateKey(bytes.NewReader(block.Bytes))
			if err != nil {
				return nil, err
			}

			keyVersion = keyVersion[len("ed25519:"):]
			keys = append(keys, &Key{
				PrivateKey: priv,
				KeyVersion: keyVersion,
			})
		}
	}
	return keys, nil
}