From 754bbf7a25a8dda49b5d08ef0d0443bbf5af0e36 Mon Sep 17 00:00:00 2001 From: Craig Jennings Date: Sun, 7 Apr 2024 13:41:34 -0500 Subject: new repository --- devdocs/go/crypto%2Fed25519%2Findex.html | 90 ++++++++++++++++++++++++++++++++ 1 file changed, 90 insertions(+) create mode 100644 devdocs/go/crypto%2Fed25519%2Findex.html (limited to 'devdocs/go/crypto%2Fed25519%2Findex.html') diff --git a/devdocs/go/crypto%2Fed25519%2Findex.html b/devdocs/go/crypto%2Fed25519%2Findex.html new file mode 100644 index 00000000..0a2ce4fa --- /dev/null +++ b/devdocs/go/crypto%2Fed25519%2Findex.html @@ -0,0 +1,90 @@ +

Package ed25519

Overview

Package ed25519 implements the Ed25519 signature algorithm. See https://ed25519.cr.yp.to/.

+

These functions are also compatible with the “Ed25519” function defined in RFC 8032. However, unlike RFC 8032's formulation, this package's private key representation includes a public key suffix to make multiple signing operations with the same key more efficient. This package refers to the RFC 8032 private key as the “seed”.

Example (Ed25519ctx) +

Code:

+pub, priv, err := GenerateKey(nil)
+if err != nil {
+    log.Fatal(err)
+}
+
+msg := []byte("The quick brown fox jumps over the lazy dog")
+
+sig, err := priv.Sign(nil, msg, &Options{
+    Context: "Example_ed25519ctx",
+})
+if err != nil {
+    log.Fatal(err)
+}
+
+if err := VerifyWithOptions(pub, msg, sig, &Options{
+    Context: "Example_ed25519ctx",
+}); err != nil {
+    log.Fatal("invalid signature")
+}
+

Index

Examples

Package (Ed25519ctx)

Package files

ed25519.go

Constants

const (
+    // PublicKeySize is the size, in bytes, of public keys as used in this package.
+    PublicKeySize = 32
+    // PrivateKeySize is the size, in bytes, of private keys as used in this package.
+    PrivateKeySize = 64
+    // SignatureSize is the size, in bytes, of signatures generated and verified by this package.
+    SignatureSize = 64
+    // SeedSize is the size, in bytes, of private key seeds. These are the private key representations used by RFC 8032.
+    SeedSize = 32
+)

func GenerateKey 1.13 

func GenerateKey(rand io.Reader) (PublicKey, PrivateKey, error)

GenerateKey generates a public/private key pair using entropy from rand. If rand is nil, crypto/rand.Reader will be used.

+

The output of this function is deterministic, and equivalent to reading SeedSize bytes from rand, and passing them to NewKeyFromSeed.

+

func Sign 1.13 

func Sign(privateKey PrivateKey, message []byte) []byte

Sign signs the message with privateKey and returns a signature. It will panic if len(privateKey) is not PrivateKeySize.

+

func Verify 1.13 

func Verify(publicKey PublicKey, message, sig []byte) bool

Verify reports whether sig is a valid signature of message by publicKey. It will panic if len(publicKey) is not PublicKeySize.

+

func VerifyWithOptions 1.20 

func VerifyWithOptions(publicKey PublicKey, message, sig []byte, opts *Options) error

VerifyWithOptions reports whether sig is a valid signature of message by publicKey. A valid signature is indicated by returning a nil error. It will panic if len(publicKey) is not PublicKeySize.

+

If opts.Hash is crypto.SHA512, the pre-hashed variant Ed25519ph is used and message is expected to be a SHA-512 hash, otherwise opts.Hash must be crypto.Hash(0) and the message must not be hashed, as Ed25519 performs two passes over messages to be signed.

+

type Options 1.20

Options can be used with PrivateKey.Sign or VerifyWithOptions to select Ed25519 variants.

+
type Options struct {
+    // Hash can be zero for regular Ed25519, or crypto.SHA512 for Ed25519ph.
+    Hash crypto.Hash
+
+    // Context, if not empty, selects Ed25519ctx or provides the context string
+    // for Ed25519ph. It can be at most 255 bytes in length.
+    Context string
+}
+

func (*Options) HashFunc 1.20 

func (o *Options) HashFunc() crypto.Hash

HashFunc returns o.Hash.

+

type PrivateKey 1.13

PrivateKey is the type of Ed25519 private keys. It implements crypto.Signer.

+
type PrivateKey []byte

func NewKeyFromSeed 1.13 

func NewKeyFromSeed(seed []byte) PrivateKey

NewKeyFromSeed calculates a private key from a seed. It will panic if len(seed) is not SeedSize. This function is provided for interoperability with RFC 8032. RFC 8032's private keys correspond to seeds in this package.

+

func (PrivateKey) Equal 1.15 

func (priv PrivateKey) Equal(x crypto.PrivateKey) bool

Equal reports whether priv and x have the same value.

+

func (PrivateKey) Public 1.13 

func (priv PrivateKey) Public() crypto.PublicKey

Public returns the PublicKey corresponding to priv.

+

func (PrivateKey) Seed 1.13 

func (priv PrivateKey) Seed() []byte

Seed returns the private key seed corresponding to priv. It is provided for interoperability with RFC 8032. RFC 8032's private keys correspond to seeds in this package.

+

func (PrivateKey) Sign 1.13 

func (priv PrivateKey) Sign(rand io.Reader, message []byte, opts crypto.SignerOpts) (signature []byte, err error)

Sign signs the given message with priv. rand is ignored and can be nil.

+

If opts.HashFunc() is crypto.SHA512, the pre-hashed variant Ed25519ph is used and message is expected to be a SHA-512 hash, otherwise opts.HashFunc() must be crypto.Hash(0) and the message must not be hashed, as Ed25519 performs two passes over messages to be signed.

+

A value of type Options can be used as opts, or crypto.Hash(0) or crypto.SHA512 directly to select plain Ed25519 or Ed25519ph, respectively.

+

type PublicKey 1.13

PublicKey is the type of Ed25519 public keys.

+
type PublicKey []byte

func (PublicKey) Equal 1.15 

func (pub PublicKey) Equal(x crypto.PublicKey) bool

Equal reports whether pub and x have the same value.

+

+ © Google, Inc.
Licensed under the Creative Commons Attribution License 3.0.
+ http://golang.org/pkg/crypto/ed25519/ +

+
-- cgit v1.2.3