formats.go

package signing_key

import (
	"fmt"
	"io"
)

type Format string

type formatter interface {
	encode(key *Key) ([]byte, error)
	decode(data []byte) (*Key, error)
	decodeAll(data []byte) ([]*Key, error)
}

var formats = make(map[Format]formatter)

func mustRegisterFormat(format Format, formatter formatter) {
	if _, ok := formats[format]; ok {
		panic("format already registered")
	}
	formats[format] = formatter
}

// Encode encodes the key in the given format, ready for writing to a file.
func (k *Key) Encode(format Format) ([]byte, error) {
	k.PrivateKey.Public()

	if f, ok := formats[format]; ok {
		return f.encode(k)
	}
	return nil, fmt.Errorf("unknown format: %s", format)
}

// DecodeRawKey attempts to decode the given key in any of the supported formats. Expects a file's contents as input.
func DecodeRawKey(key []byte) (*Key, error) {
	for _, f := range formats {
		k, err := f.decode(key)
		if err == nil {
			return k, nil
		}
	}
	return nil, fmt.Errorf("key is not in a known format")
}

// DecodeKey attempts to decode the given key in any of the supported formats. Expects a file's contents as input.
func DecodeKey(key io.Reader) (*Key, error) {
	b, err := io.ReadAll(key)
	if err != nil {
		return nil, err
	}
	return DecodeRawKey(b)
}

// DecodeKeyWith attempts to decode the given key in the given format. Expects a file's contents as input.
func DecodeKeyWith(key io.Reader, format Format) (*Key, error) {
	b, err := io.ReadAll(key)
	if err != nil {
		return nil, err
	}
	return DecodeRawKeyWith(b, format)
}

// DecodeRawKeyWith attempts to decode the given key in the given format. Expects a file's contents as input.
func DecodeRawKeyWith(key []byte, format Format) (*Key, error) {
	if f, ok := formats[format]; ok {
		return f.decode(key)
	}
	return nil, fmt.Errorf("unknown format: %s", format)
}

// DecodeAllKeys attempts to decode all keys in the given file. All contained keys must be in the same format.
func DecodeAllKeys(keys io.Reader) ([]*Key, error) {
	b, err := io.ReadAll(keys)
	if err != nil {
		return nil, err
	}
	return DecodeAllRawKeys(b)
}

// DecodeAllRawKeys attempts to decode all keys in the given file. All contained keys must be in the same format.
func DecodeAllRawKeys(keys []byte) ([]*Key, error) {
	for _, f := range formats {
		ks, err := f.decodeAll(keys)
		if err == nil {
			return ks, nil
		}
	}
	return nil, fmt.Errorf("keys are not in a known format")
}

// DecodeAllKeysWith attempts to decode all keys in the given file with the given format.
func DecodeAllKeysWith(keys io.Reader, format Format) ([]*Key, error) {
	b, err := io.ReadAll(keys)
	if err != nil {
		return nil, err
	}
	return DecodeAllRawKeysWith(b, format)
}

// DecodeAllRawKeysWith attempts to decode all keys in the given file with the given format.
func DecodeAllRawKeysWith(keys []byte, format Format) ([]*Key, error) {
	if f, ok := formats[format]; ok {
		return f.decodeAll(keys)
	}
	return nil, fmt.Errorf("unknown format: %s", format)
}