ed25519.go

package jwt

import (
"crypto"
"crypto/ed25519"
"crypto/rand"
"errors"
)

var (
ErrEd25519Verification=errors.New("ed25519: verification error")
)

// SigningMethodEd25519 implements the EdDSA family.
// Expects ed25519.PrivateKey for signing and ed25519.PublicKey for verification
typeSigningMethodEd25519struct{}

// Specific instance for EdDSA
var (
SigningMethodEdDSA*SigningMethodEd25519
)

funcinit() {
SigningMethodEdDSA=&SigningMethodEd25519{}
RegisterSigningMethod(SigningMethodEdDSA.Alg(), func() SigningMethod {
returnSigningMethodEdDSA
 })
}

func (m*SigningMethodEd25519) Alg() string {
return"EdDSA"
}

// Verify implements token verification for the SigningMethod.
// For this verify method, key must be an ed25519.PublicKey
func (m*SigningMethodEd25519) Verify(signingStringstring, sig []byte, keyinterface{}) error {
vared25519Key ed25519.PublicKey
varokbool

ifed25519Key, ok=key.(ed25519.PublicKey); !ok {
returnnewError("Ed25519 verify expects ed25519.PublicKey", ErrInvalidKeyType)
 }

iflen(ed25519Key) !=ed25519.PublicKeySize {
returnErrInvalidKey
 }

// Verify the signature
if!ed25519.Verify(ed25519Key, []byte(signingString), sig) {
returnErrEd25519Verification
 }

returnnil
}

// Sign implements token signing for the SigningMethod.
// For this signing method, key must be an ed25519.PrivateKey
func (m*SigningMethodEd25519) Sign(signingStringstring, keyinterface{}) ([]byte, error) {
vared25519Key crypto.Signer
varokbool

ifed25519Key, ok=key.(crypto.Signer); !ok {
returnnil, newError("Ed25519 sign expects crypto.Signer", ErrInvalidKeyType)
 }

if_, ok:=ed25519Key.Public().(ed25519.PublicKey); !ok {
returnnil, ErrInvalidKey
 }

// Sign the string and return the result. ed25519 performs a two-pass hash
// as part of its algorithm. Therefore, we need to pass a non-prehashed
// message into the Sign function, as indicated by crypto.Hash(0)
sig, err:=ed25519Key.Sign(rand.Reader, []byte(signingString), crypto.Hash(0))
iferr!=nil {
returnnil, err
 }

returnsig, nil
}