ed25519 开发

Author: FishGoddess

ed25519/ed25519.go

@@ -0,0 +1,36 @@
+// Copyright 2025 FishGoddess. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package ed25519
+
+import "crypto/ed25519"
+
+type PrivateKey struct {
+	key ed25519.PrivateKey
+}
+
+// Sign signs data.
+func (pk PrivateKey) Sign(data []byte, opts ...Option) []byte {
+	conf := newConfig().Apply(opts...)
+	sign := ed25519.Sign(pk.key, data)
+	sign = conf.encoding.Encode(sign)
+	return sign
+}
+
+type PublicKey struct {
+	key ed25519.PublicKey
+}
+
+// Verify verifies data with sign.
+func (pk PublicKey) Verify(data []byte, sign []byte, opts ...Option) error {
+	conf := newConfig().Apply(opts...)
+	verifyOpts := &ed25519.Options{Hash: conf.cryptoHash, Context: conf.context}
+
+	sign, err := conf.encoding.Decode(sign)
+	if err != nil {
+		return err
+	}
+
+	return ed25519.VerifyWithOptions(pk.key, data, sign, verifyOpts)
+}

ed25519/ed25519_test.go

@@ -0,0 +1,102 @@
+// Copyright 2025 FishGoddess. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package ed25519
+
+import (
+	"bytes"
+	"testing"
+)
+
+type signTestCase struct {
+	Data           []byte
+	SignData       []byte
+	SignDataHex    []byte
+	SignDataBase64 []byte
+}
+
+type testRandomReader struct{}
+
+func (testRandomReader) Read(p []byte) (n int, err error) {
+	for i := range p {
+		p[i] = 1
+	}
+
+	return len(p), nil
+}
+
+func newTestPrivateKey() PrivateKey {
+	reader := bytes.NewReader([]byte(``))
+
+	privateKey, err := ReadPrivateKey(reader)
+	if err != nil {
+		panic(err)
+	}
+
+	return privateKey
+}
+
+func newTestPublicKey() PublicKey {
+	reader := bytes.NewReader([]byte(``))
+
+	publicKey, err := ReadPublicKey(reader)
+	if err != nil {
+		panic(err)
+	}
+
+	return publicKey
+}
+
+// go test -v -cover -run=^TestSignVerify$
+func TestSignVerify(t *testing.T) {
+	privateKey := newTestPrivateKey()
+	publicKey := newTestPublicKey()
+
+	testCases := []signTestCase{
+		{
+			Data:           []byte(""),
+			SignData:       []byte(""),
+			SignDataHex:    []byte(""),
+			SignDataBase64: []byte(""),
+		},
+		{
+			Data:           []byte("123"),
+			SignData:       []byte(""),
+			SignDataHex:    []byte(""),
+			SignDataBase64: []byte(""),
+		},
+		{
+			Data:           []byte("你好，世界"),
+			SignData:       []byte(""),
+			SignDataHex:    []byte(""),
+			SignDataBase64: []byte(""),
+		},
+	}
+
+	for _, testCase := range testCases {
+		// None
+		sign := privateKey.Sign(testCase.Data)
+
+		err := publicKey.Verify(testCase.Data, sign)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		// Hex
+		sign = privateKey.Sign(testCase.Data, WithHex())
+
+		err = publicKey.Verify(testCase.Data, sign, WithHex())
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		// Base64
+		sign = privateKey.Sign(testCase.Data, WithBase64())
+
+		err = publicKey.Verify(testCase.Data, sign, WithBase64())
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+}

ed25519/key.go

@@ -0,0 +1,147 @@
+// Copyright 2025 FishGoddess. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package ed25519
+
+import (
+	"crypto/ed25519"
+	"io"
+	"os"
+)
+
+// GenerateKeys generates a private key and a public key.
+func GenerateKeys(opts ...KeyOption) (PrivateKey, PublicKey, error) {
+	conf := newKeyConfig().Apply(opts...)
+
+	var key ed25519.PrivateKey
+	var pkey ed25519.PublicKey
+	var err error
+
+	if len(conf.seed) > 0 {
+		key = ed25519.NewKeyFromSeed(conf.seed)
+		pkey = key.Public().(ed25519.PublicKey)
+	} else {
+		pkey, key, err = ed25519.GenerateKey(conf.random)
+	}
+
+	if err != nil {
+		return PrivateKey{}, PublicKey{}, err
+	}
+
+	privateKey := PrivateKey{key: key}
+	publicKey := PublicKey{key: pkey}
+	return privateKey, publicKey, nil
+}
+
+// WritePrivateKey writes the private key to the writer.
+func WritePrivateKey(writer io.Writer, privateKey PrivateKey, opts ...KeyOption) error {
+	conf := newKeyConfig().Apply(opts...)
+
+	data, err := conf.encodePrivateKey(privateKey.key)
+	if err != nil {
+		return err
+	}
+
+	_, err = writer.Write(data)
+	return err
+}
+
+// WritePublicKey writes the public key to the writer.
+func WritePublicKey(writer io.Writer, publicKey PublicKey, opts ...KeyOption) error {
+	conf := newKeyConfig().Apply(opts...)
+
+	data, err := conf.encodePublicKey(publicKey.key)
+	if err != nil {
+		return err
+	}
+
+	_, err = writer.Write(data)
+	return err
+}
+
+// ReadPrivateKey reads the private key from the reader.
+func ReadPrivateKey(reader io.Reader, opts ...KeyOption) (PrivateKey, error) {
+	conf := newKeyConfig().Apply(opts...)
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		return PrivateKey{}, err
+	}
+
+	key, err := conf.decodePrivateKey(data)
+	if err != nil {
+		return PrivateKey{}, err
+	}
+
+	privateKey := PrivateKey{key: key}
+	return privateKey, nil
+}
+
+// ReadPublicKey reads the public key from the reader.
+func ReadPublicKey(reader io.Reader, opts ...KeyOption) (PublicKey, error) {
+	conf := newKeyConfig().Apply(opts...)
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		return PublicKey{}, err
+	}
+
+	key, err := conf.decodePublicKey(data)
+	if err != nil {
+		return PublicKey{}, err
+	}
+
+	publicKey := PublicKey{key: key}
+	return publicKey, nil
+}
+
+func newFile(file string) (*os.File, error) {
+	flag := os.O_CREATE | os.O_WRONLY | os.O_EXCL
+	perm := os.FileMode(0644)
+	return os.OpenFile(file, flag, perm)
+}
+
+// StorePrivateKey stores the private key to the file.
+func StorePrivateKey(file string, privateKey PrivateKey, opts ...KeyOption) error {
+	f, err := newFile(file)
+	if err != nil {
+		return err
+	}
+
+	defer f.Close()
+	return WritePrivateKey(f, privateKey, opts...)
+}
+
+// StorePublicKey stores the public key to the file.
+func StorePublicKey(file string, publicKey PublicKey, opts ...KeyOption) error {
+	f, err := newFile(file)
+	if err != nil {
+		return err
+	}
+
+	defer f.Close()
+	return WritePublicKey(f, publicKey, opts...)
+}
+
+// LoadPrivateKey loads the private key from the file.
+func LoadPrivateKey(file string, opts ...KeyOption) (PrivateKey, error) {
+	f, err := os.Open(file)
+	if err != nil {
+		return PrivateKey{}, err
+	}
+
+	defer f.Close()
+	return ReadPrivateKey(f, opts...)
+}
+
+// LoadPublicKey loads the public key from the file.
+func LoadPublicKey(file string, opts ...KeyOption) (PublicKey, error) {
+	f, err := os.Open(file)
+	if err != nil {
+		return PublicKey{}, err
+	}
+
+	defer f.Close()
+	return ReadPublicKey(f, opts...)
+}