grafana/1001-vendor-patch-removed-backend-crypto.patch

patch removed backend crypto

the `Makefile` removed a few files containing (unused) crypto
algorithms from the vendor tarball, which are not used in Grafana.
This patch removes all references to the deleted files.

diff --git a/vendor/golang.org/x/crypto/openpgp/elgamal/elgamal.go b/vendor/golang.org/x/crypto/openpgp/elgamal/elgamal.go
new file mode 100644
index 0000000000..871e612a61
--- /dev/null
+++ b/vendor/golang.org/x/crypto/openpgp/elgamal/elgamal.go
@@ -0,0 +1,25 @@
+package elgamal
+
+import (
+	"io"
+	"math/big"
+)
+
+// PublicKey represents an ElGamal public key.
+type PublicKey struct {
+	G, P, Y *big.Int
+}
+
+// PrivateKey represents an ElGamal private key.
+type PrivateKey struct {
+	PublicKey
+	X *big.Int
+}
+
+func Encrypt(random io.Reader, pub *PublicKey, msg []byte) (c1, c2 *big.Int, err error) {
+	panic("ElGamal encryption not available")
+}
+
+func Decrypt(priv *PrivateKey, c1, c2 *big.Int) (msg []byte, err error) {
+	panic("ElGamal encryption not available")
+}
diff --git a/vendor/github.com/prometheus/exporter-toolkit/web/handler.go b/vendor/github.com/prometheus/exporter-toolkit/web/handler.go
index c607a16..11dbc3c 100644
--- a/vendor/github.com/prometheus/exporter-toolkit/web/handler.go
+++ b/vendor/github.com/prometheus/exporter-toolkit/web/handler.go
@@ -16,14 +16,11 @@
 package web
 
 import (
-	"encoding/hex"
 	"fmt"
 	"net/http"
-	"strings"
 	"sync"
 
 	"github.com/go-kit/log"
-	"golang.org/x/crypto/bcrypt"
 )
 
 // extraHTTPHeaders is a map of HTTP headers that can be added to HTTP
@@ -37,22 +34,6 @@ var extraHTTPHeaders = map[string][]string{
 	"Content-Security-Policy":   nil,
 }
 
-func validateUsers(configPath string) error {
-	c, err := getConfig(configPath)
-	if err != nil {
-		return err
-	}
-
-	for _, p := range c.Users {
-		_, err = bcrypt.Cost([]byte(p))
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
 // validateHeaderConfig checks that the provided header configuration is correct.
 // It does not check the validity of all the values, only the ones which are
 // well-defined enumerations.
@@ -84,60 +65,3 @@ type webHandler struct {
 	// only once in parallel as this is CPU intensive.
 	bcryptMtx sync.Mutex
 }
-
-func (u *webHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	c, err := getConfig(u.tlsConfigPath)
-	if err != nil {
-		u.logger.Log("msg", "Unable to parse configuration", "err", err)
-		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-		return
-	}
-
-	// Configure http headers.
-	for k, v := range c.HTTPConfig.Header {
-		w.Header().Set(k, v)
-	}
-
-	if len(c.Users) == 0 {
-		u.handler.ServeHTTP(w, r)
-		return
-	}
-
-	user, pass, auth := r.BasicAuth()
-	if auth {
-		hashedPassword, validUser := c.Users[user]
-
-		if !validUser {
-			// The user is not found. Use a fixed password hash to
-			// prevent user enumeration by timing requests.
-			// This is a bcrypt-hashed version of "fakepassword".
-			hashedPassword = "$2y$10$QOauhQNbBCuQDKes6eFzPeMqBSjb7Mr5DUmpZ/VcEd00UAV/LDeSi"
-		}
-
-		cacheKey := strings.Join(
-			[]string{
-				hex.EncodeToString([]byte(user)),
-				hex.EncodeToString([]byte(hashedPassword)),
-				hex.EncodeToString([]byte(pass)),
-			}, ":")
-		authOk, ok := u.cache.get(cacheKey)
-
-		if !ok {
-			// This user, hashedPassword, password is not cached.
-			u.bcryptMtx.Lock()
-			err := bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(pass))
-			u.bcryptMtx.Unlock()
-
-			authOk = validUser && err == nil
-			u.cache.set(cacheKey, authOk)
-		}
-
-		if authOk && validUser {
-			u.handler.ServeHTTP(w, r)
-			return
-		}
-	}
-
-	w.Header().Set("WWW-Authenticate", "Basic")
-	http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
-}
diff --git a/vendor/github.com/prometheus/exporter-toolkit/web/tls_config.go b/vendor/github.com/prometheus/exporter-toolkit/web/tls_config.go
index 61383bc..7f71298 100644
--- a/vendor/github.com/prometheus/exporter-toolkit/web/tls_config.go
+++ b/vendor/github.com/prometheus/exporter-toolkit/web/tls_config.go
@@ -18,16 +18,10 @@ import (
 	"crypto/x509"
 	"errors"
 	"fmt"
-	"net"
-	"net/http"
 	"os"
 	"path/filepath"
 
-	"github.com/coreos/go-systemd/v22/activation"
-	"github.com/go-kit/log"
-	"github.com/go-kit/log/level"
 	config_util "github.com/prometheus/common/config"
-	"golang.org/x/sync/errgroup"
 	"gopkg.in/yaml.v2"
 )
 
@@ -263,132 +257,16 @@ func ConfigToTLSConfig(c *TLSConfig) (*tls.Config, error) {
 
 // ServeMultiple starts the server on the given listeners. The FlagConfig is
 // also passed on to Serve.
-func ServeMultiple(listeners []net.Listener, server *http.Server, flags *FlagConfig, logger log.Logger) error {
-	errs := new(errgroup.Group)
-	for _, l := range listeners {
-		l := l
-		errs.Go(func() error {
-			return Serve(l, server, flags, logger)
-		})
-	}
-	return errs.Wait()
-}
 
 // ListenAndServe starts the server on addresses given in WebListenAddresses in
 // the FlagConfig or instead uses systemd socket activated listeners if
 // WebSystemdSocket in the FlagConfig is true. The FlagConfig is also passed on
 // to ServeMultiple.
-func ListenAndServe(server *http.Server, flags *FlagConfig, logger log.Logger) error {
-	if flags.WebSystemdSocket == nil && (flags.WebListenAddresses == nil || len(*flags.WebListenAddresses) == 0) {
-		return ErrNoListeners
-	}
-
-	if flags.WebSystemdSocket != nil && *flags.WebSystemdSocket {
-		level.Info(logger).Log("msg", "Listening on systemd activated listeners instead of port listeners.")
-		listeners, err := activation.Listeners()
-		if err != nil {
-			return err
-		}
-		if len(listeners) < 1 {
-			return errors.New("no socket activation file descriptors found")
-		}
-		return ServeMultiple(listeners, server, flags, logger)
-	}
-
-	listeners := make([]net.Listener, 0, len(*flags.WebListenAddresses))
-	for _, address := range *flags.WebListenAddresses {
-		listener, err := net.Listen("tcp", address)
-		if err != nil {
-			return err
-		}
-		defer listener.Close()
-		listeners = append(listeners, listener)
-	}
-	return ServeMultiple(listeners, server, flags, logger)
-}
 
 // Server starts the server on the given listener. Based on the file path
 // WebConfigFile in the FlagConfig, TLS or basic auth could be enabled.
-func Serve(l net.Listener, server *http.Server, flags *FlagConfig, logger log.Logger) error {
-	level.Info(logger).Log("msg", "Listening on", "address", l.Addr().String())
-	tlsConfigPath := *flags.WebConfigFile
-	if tlsConfigPath == "" {
-		level.Info(logger).Log("msg", "TLS is disabled.", "http2", false, "address", l.Addr().String())
-		return server.Serve(l)
-	}
-
-	if err := validateUsers(tlsConfigPath); err != nil {
-		return err
-	}
-
-	// Setup basic authentication.
-	var handler http.Handler = http.DefaultServeMux
-	if server.Handler != nil {
-		handler = server.Handler
-	}
-
-	c, err := getConfig(tlsConfigPath)
-	if err != nil {
-		return err
-	}
-
-	server.Handler = &webHandler{
-		tlsConfigPath: tlsConfigPath,
-		logger:        logger,
-		handler:       handler,
-		cache:         newCache(),
-	}
-
-	config, err := ConfigToTLSConfig(&c.TLSConfig)
-	switch err {
-	case nil:
-		if !c.HTTPConfig.HTTP2 {
-			server.TLSNextProto = make(map[string]func(*http.Server, *tls.Conn, http.Handler))
-		}
-		// Valid TLS config.
-		level.Info(logger).Log("msg", "TLS is enabled.", "http2", c.HTTPConfig.HTTP2, "address", l.Addr().String())
-	case errNoTLSConfig:
-		// No TLS config, back to plain HTTP.
-		level.Info(logger).Log("msg", "TLS is disabled.", "http2", false, "address", l.Addr().String())
-		return server.Serve(l)
-	default:
-		// Invalid TLS config.
-		return err
-	}
-
-	server.TLSConfig = config
-
-	// Set the GetConfigForClient method of the HTTPS server so that the config
-	// and certs are reloaded on new connections.
-	server.TLSConfig.GetConfigForClient = func(*tls.ClientHelloInfo) (*tls.Config, error) {
-		config, err := getTLSConfig(tlsConfigPath)
-		if err != nil {
-			return nil, err
-		}
-		config.NextProtos = server.TLSConfig.NextProtos
-		return config, nil
-	}
-	return server.ServeTLS(l, "", "")
-}
 
 // Validate configuration file by reading the configuration and the certificates.
-func Validate(tlsConfigPath string) error {
-	if tlsConfigPath == "" {
-		return nil
-	}
-	if err := validateUsers(tlsConfigPath); err != nil {
-		return err
-	}
-	c, err := getConfig(tlsConfigPath)
-	if err != nil {
-		return err
-	}
-	_, err = ConfigToTLSConfig(&c.TLSConfig)
-	if err == errNoTLSConfig {
-		return nil
-	}
-	return err
-}
 
 type Cipher uint16
 
@@ -472,11 +350,3 @@ func (tv *TLSVersion) MarshalYAML() (interface{}, error) {
 	}
 	return fmt.Sprintf("%v", tv), nil
 }
-
-// Listen starts the server on the given address. Based on the file
-// tlsConfigPath, TLS or basic auth could be enabled.
-//
-// Deprecated: Use ListenAndServe instead.
-func Listen(server *http.Server, flags *FlagConfig, logger log.Logger) error {
-	return ListenAndServe(server, flags, logger)
-}
diff --git a/vendor/github.com/ProtonMail/go-crypto/openpgp/internal/algorithm/cipher.go b/vendor/github.com/ProtonMail/go-crypto/openpgp/internal/algorithm/cipher.go
index 5760cff..0c87736 100644
--- a/vendor/github.com/ProtonMail/go-crypto/openpgp/internal/algorithm/cipher.go
+++ b/vendor/github.com/ProtonMail/go-crypto/openpgp/internal/algorithm/cipher.go
@@ -8,8 +8,6 @@ import (
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/des"
-
-	"golang.org/x/crypto/cast5"
 )
 
 // Cipher is an official symmetric key cipher algorithm. See RFC 4880,
@@ -38,7 +36,6 @@ const (
 // http://www.iana.org/assignments/pgp-parameters/pgp-parameters.xhtml#pgp-parameters-13
 var CipherById = map[uint8]Cipher{
 	TripleDES.Id(): TripleDES,
-	CAST5.Id():     CAST5,
 	AES128.Id():    AES128,
 	AES192.Id():    AES192,
 	AES256.Id():    AES256,
@@ -53,7 +50,6 @@ func (sk CipherFunction) Id() uint8 {
 
 var keySizeByID = map[uint8]int{
 	TripleDES.Id(): 24,
-	CAST5.Id():     cast5.KeySize,
 	AES128.Id():    16,
 	AES192.Id():    24,
 	AES256.Id():    32,
@@ -65,7 +61,7 @@ func (cipher CipherFunction) KeySize() int {
 	case TripleDES:
 		return 24
 	case CAST5:
-		return cast5.KeySize
+		panic("cast5 cipher not available")
 	case AES128:
 		return 16
 	case AES192:
@@ -82,7 +78,7 @@ func (cipher CipherFunction) BlockSize() int {
 	case TripleDES:
 		return des.BlockSize
 	case CAST5:
-		return 8
+		panic("cast5 cipher not available")
 	case AES128, AES192, AES256:
 		return 16
 	}
@@ -96,7 +92,7 @@ func (cipher CipherFunction) New(key []byte) (block cipher.Block) {
 	case TripleDES:
 		block, err = des.NewTripleDESCipher(key)
 	case CAST5:
-		block, err = cast5.NewCipher(key)
+		panic("cast5 cipher not available")
 	case AES128, AES192, AES256:
 		block, err = aes.NewCipher(key)
 	}
diff --git a/vendor/github.com/ProtonMail/go-crypto/openpgp/s2k/s2k.go b/vendor/github.com/ProtonMail/go-crypto/openpgp/s2k/s2k.go
index a436959..420df86 100644
--- a/vendor/github.com/ProtonMail/go-crypto/openpgp/s2k/s2k.go
+++ b/vendor/github.com/ProtonMail/go-crypto/openpgp/s2k/s2k.go
@@ -15,7 +15,6 @@ import (
 
 	"github.com/ProtonMail/go-crypto/openpgp/errors"
 	"github.com/ProtonMail/go-crypto/openpgp/internal/algorithm"
-	"golang.org/x/crypto/argon2"
 )
 
 type Mode uint8
@@ -27,7 +26,6 @@ const (
 	SimpleS2K         Mode = 0
 	SaltedS2K         Mode = 1
 	IteratedSaltedS2K Mode = 3
-	Argon2S2K         Mode = 4
 	GnuS2K            Mode = 101
 )
 
@@ -87,10 +85,10 @@ func decodeCount(c uint8) int {
 // encodeMemory converts the Argon2 "memory" in the range parallelism*8 to
 // 2**31, inclusive, to an encoded memory. The return value is the
 // octet that is actually stored in the GPG file. encodeMemory panics
-// if is not in the above range 
+// if is not in the above range
 // See OpenPGP crypto refresh Section 3.7.1.4.
 func encodeMemory(memory uint32, parallelism uint8) uint8 {
-	if memory < (8 * uint32(parallelism)) || memory > uint32(2147483648) {
+	if memory < (8*uint32(parallelism)) || memory > uint32(2147483648) {
 		panic("Memory argument memory is outside the required range")
 	}
 
@@ -174,33 +172,20 @@ func Iterated(out []byte, h hash.Hash, in []byte, salt []byte, count int) {
 
 // Argon2 writes to out the key derived from the password (in) with the Argon2
 // function (the crypto refresh, section 3.7.1.4)
-func Argon2(out []byte, in []byte, salt []byte, passes uint8, paralellism uint8, memoryExp uint8) {
-	key := argon2.IDKey(in, salt, uint32(passes), decodeMemory(memoryExp), paralellism, uint32(len(out)))
-	copy(out[:], key)
-}
 
 // Generate generates valid parameters from given configuration.
 // It will enforce the Iterated and Salted or Argon2 S2K method.
 func Generate(rand io.Reader, c *Config) (*Params, error) {
 	var params *Params
-	if c != nil && c.Mode() == Argon2S2K {
-		// handle Argon2 case
-		argonConfig := c.Argon2()
-		params = &Params{
-			mode:        Argon2S2K,
-			passes:      argonConfig.Passes(),
-			parallelism: argonConfig.Parallelism(),
-			memoryExp:   argonConfig.EncodedMemory(),
-		}
-	} else if c != nil && c.PassphraseIsHighEntropy && c.Mode() == SaltedS2K { // Allow SaltedS2K if PassphraseIsHighEntropy
+	if c != nil && c.PassphraseIsHighEntropy && c.Mode() == SaltedS2K { // Allow SaltedS2K if PassphraseIsHighEntropy
 		hashId, ok := algorithm.HashToHashId(c.hash())
 		if !ok {
 			return nil, errors.UnsupportedError("no such hash")
 		}
 
 		params = &Params{
-			mode:      SaltedS2K,
-			hashId:    hashId,
+			mode:   SaltedS2K,
+			hashId: hashId,
 		}
 	} else { // Enforce IteratedSaltedS2K method otherwise
 		hashId, ok := algorithm.HashToHashId(c.hash())
@@ -211,7 +196,7 @@ func Generate(rand io.Reader, c *Config) (*Params, error) {
 			c.S2KMode = IteratedSaltedS2K
 		}
 		params = &Params{
-			mode:      IteratedSaltedS2K, 
+			mode:      IteratedSaltedS2K,
 			hashId:    hashId,
 			countByte: c.EncodedCount(),
 		}
@@ -274,16 +259,6 @@ func ParseIntoParams(r io.Reader) (params *Params, err error) {
 		copy(params.salt(), buf[1:9])
 		params.countByte = buf[9]
 		return params, nil
-	case Argon2S2K:
-		_, err = io.ReadFull(r, buf[:Argon2SaltSize+3])
-		if err != nil {
-			return nil, err
-		}
-		copy(params.salt(), buf[:Argon2SaltSize])
-		params.passes = buf[Argon2SaltSize]
-		params.parallelism = buf[Argon2SaltSize+1]
-		params.memoryExp = buf[Argon2SaltSize+2]
-		return params, nil
 	case GnuS2K:
 		// This is a GNU extension. See
 		// https://git.gnupg.org/cgi-bin/gitweb.cgi?p=gnupg.git;a=blob;f=doc/DETAILS;h=fe55ae16ab4e26d8356dc574c9e8bc935e71aef1;hb=23191d7851eae2217ecdac6484349849a24fd94a#l1109
@@ -306,9 +281,10 @@ func (params *Params) Dummy() bool {
 
 func (params *Params) salt() []byte {
 	switch params.mode {
-		case SaltedS2K, IteratedSaltedS2K: return params.saltBytes[:8]
-		case Argon2S2K: return params.saltBytes[:Argon2SaltSize]
-		default: return nil
+	case SaltedS2K, IteratedSaltedS2K:
+		return params.saltBytes[:8]
+	default:
+		return nil
 	}
 }
 
@@ -317,15 +293,13 @@ func (params *Params) Function() (f func(out, in []byte), err error) {
 		return nil, errors.ErrDummyPrivateKey("dummy key found")
 	}
 	var hashObj crypto.Hash
-	if params.mode != Argon2S2K {
-		var ok bool
-		hashObj, ok = algorithm.HashIdToHashWithSha1(params.hashId)
-		if !ok {
-			return nil, errors.UnsupportedError("hash for S2K function: " + strconv.Itoa(int(params.hashId)))
-		}
-		if !hashObj.Available() {
-			return nil, errors.UnsupportedError("hash not available: " + strconv.Itoa(int(hashObj)))
-		}
+	var ok bool
+	hashObj, ok = algorithm.HashIdToHashWithSha1(params.hashId)
+	if !ok {
+		return nil, errors.UnsupportedError("hash for S2K function: " + strconv.Itoa(int(params.hashId)))
+	}
+	if !hashObj.Available() {
+		return nil, errors.UnsupportedError("hash not available: " + strconv.Itoa(int(hashObj)))
 	}
 
 	switch params.mode {
@@ -346,11 +320,6 @@ func (params *Params) Function() (f func(out, in []byte), err error) {
 			Iterated(out, hashObj.New(), in, params.salt(), decodeCount(params.countByte))
 		}
 
-		return f, nil
-	case Argon2S2K:
-		f := func(out, in []byte) {
-			Argon2(out, in, params.salt(), params.passes, params.parallelism, params.memoryExp)
-		}
 		return f, nil
 	}
 
@@ -361,10 +330,8 @@ func (params *Params) Serialize(w io.Writer) (err error) {
 	if _, err = w.Write([]byte{uint8(params.mode)}); err != nil {
 		return
 	}
-	if params.mode != Argon2S2K {
-		if _, err = w.Write([]byte{params.hashId}); err != nil {
-			return
-		}
+	if _, err = w.Write([]byte{params.hashId}); err != nil {
+		return
 	}
 	if params.Dummy() {
 		_, err = w.Write(append([]byte("GNU"), 1))
@@ -377,9 +344,6 @@ func (params *Params) Serialize(w io.Writer) (err error) {
 		if params.mode == IteratedSaltedS2K {
 			_, err = w.Write([]byte{params.countByte})
 		}
-		if params.mode == Argon2S2K {
-			_, err = w.Write([]byte{params.passes, params.parallelism, params.memoryExp})
-		}
 	}
 	return
 }
diff --git a/vendor/github.com/ProtonMail/go-crypto/openpgp/packet/symmetrically_encrypted_aead.go b/vendor/github.com/ProtonMail/go-crypto/openpgp/packet/symmetrically_encrypted_aead.go
index e96252c..42ddccf 100644
--- a/vendor/github.com/ProtonMail/go-crypto/openpgp/packet/symmetrically_encrypted_aead.go
+++ b/vendor/github.com/ProtonMail/go-crypto/openpgp/packet/symmetrically_encrypted_aead.go
@@ -5,12 +5,9 @@
 package packet
 
 import (
-	"crypto/cipher"
-	"crypto/sha256"
 	"io"
 
 	"github.com/ProtonMail/go-crypto/openpgp/errors"
-	"golang.org/x/crypto/hkdf"
 )
 
 // parseAead parses a V2 SEIPD packet (AEAD) as specified in
@@ -62,95 +59,11 @@ func (se *SymmetricallyEncrypted) associatedData() []byte {
 // decryptAead decrypts a V2 SEIPD packet (AEAD) as specified in
 // https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-07.html#section-5.13.2
 func (se *SymmetricallyEncrypted) decryptAead(inputKey []byte) (io.ReadCloser, error) {
-	aead, nonce := getSymmetricallyEncryptedAeadInstance(se.Cipher, se.Mode, inputKey, se.Salt[:], se.associatedData())
-
-	// Carry the first tagLen bytes
-	tagLen := se.Mode.TagLength()
-	peekedBytes := make([]byte, tagLen)
-	n, err := io.ReadFull(se.Contents, peekedBytes)
-	if n < tagLen || (err != nil && err != io.EOF) {
-		return nil, errors.StructuralError("not enough data to decrypt:" + err.Error())
-	}
-
-	return &aeadDecrypter{
-		aeadCrypter: aeadCrypter{
-			aead:           aead,
-			chunkSize:      decodeAEADChunkSize(se.ChunkSizeByte),
-			initialNonce:   nonce,
-			associatedData: se.associatedData(),
-			chunkIndex:     make([]byte, 8),
-			packetTag:      packetTypeSymmetricallyEncryptedIntegrityProtected,
-		},
-		reader:      se.Contents,
-		peekedBytes: peekedBytes,
-	}, nil
+	panic("hkdf cipher not available")
 }
 
 // serializeSymmetricallyEncryptedAead encrypts to a writer a V2 SEIPD packet (AEAD) as specified in
 // https://www.ietf.org/archive/id/draft-ietf-openpgp-crypto-refresh-07.html#section-5.13.2
 func serializeSymmetricallyEncryptedAead(ciphertext io.WriteCloser, cipherSuite CipherSuite, chunkSizeByte byte, rand io.Reader, inputKey []byte) (Contents io.WriteCloser, err error) {
-	// cipherFunc must have block size 16 to use AEAD
-	if cipherSuite.Cipher.blockSize() != 16 {
-		return nil, errors.InvalidArgumentError("invalid aead cipher function")
-	}
-
-	if cipherSuite.Cipher.KeySize() != len(inputKey) {
-		return nil, errors.InvalidArgumentError("error in aead serialization: bad key length")
-	}
-
-	// Data for en/decryption: tag, version, cipher, aead mode, chunk size
-	prefix := []byte{
-		0xD2,
-		symmetricallyEncryptedVersionAead,
-		byte(cipherSuite.Cipher),
-		byte(cipherSuite.Mode),
-		chunkSizeByte,
-	}
-
-	// Write header (that correspond to prefix except first byte)
-	n, err := ciphertext.Write(prefix[1:])
-	if err != nil || n < 4 {
-		return nil, err
-	}
-
-	// Random salt
-	salt := make([]byte, aeadSaltSize)
-	if _, err := rand.Read(salt); err != nil {
-		return nil, err
-	}
-
-	if _, err := ciphertext.Write(salt); err != nil {
-		return nil, err
-	}
-
-	aead, nonce := getSymmetricallyEncryptedAeadInstance(cipherSuite.Cipher, cipherSuite.Mode, inputKey, salt, prefix)
-
-	return &aeadEncrypter{
-		aeadCrypter: aeadCrypter{
-			aead:           aead,
-			chunkSize:      decodeAEADChunkSize(chunkSizeByte),
-			associatedData: prefix,
-			chunkIndex:     make([]byte, 8),
-			initialNonce:   nonce,
-			packetTag:      packetTypeSymmetricallyEncryptedIntegrityProtected,
-		},
-		writer: ciphertext,
-	}, nil
-}
-
-func getSymmetricallyEncryptedAeadInstance(c CipherFunction, mode AEADMode, inputKey, salt, associatedData []byte) (aead cipher.AEAD, nonce []byte) {
-	hkdfReader := hkdf.New(sha256.New, inputKey, salt, associatedData)
-
-	encryptionKey := make([]byte, c.KeySize())
-	_, _ = readFull(hkdfReader, encryptionKey)
-
-	// Last 64 bits of nonce are the counter
-	nonce = make([]byte, mode.IvLength()-8)
-
-	_, _ = readFull(hkdfReader, nonce)
-
-	blockCipher := c.new(encryptionKey)
-	aead = mode.new(blockCipher)
-
-	return
+	panic("hkdf cipher not available")
 }
diff --git a/vendor/github.com/ProtonMail/go-crypto/openpgp/read.go b/vendor/github.com/ProtonMail/go-crypto/openpgp/read.go
index 8499c73..eaffe19 100644
--- a/vendor/github.com/ProtonMail/go-crypto/openpgp/read.go
+++ b/vendor/github.com/ProtonMail/go-crypto/openpgp/read.go
@@ -17,7 +17,6 @@ import (
 	"github.com/ProtonMail/go-crypto/openpgp/errors"
 	"github.com/ProtonMail/go-crypto/openpgp/internal/algorithm"
 	"github.com/ProtonMail/go-crypto/openpgp/packet"
-	_ "golang.org/x/crypto/sha3"
 )
 
 // SignatureType is the armor type for a PGP signature.
diff --git a/vendor/github.com/google/s2a-go/internal/record/internal/aeadcrypter/chachapoly.go b/vendor/github.com/google/s2a-go/internal/record/internal/aeadcrypter/chachapoly.go
index 214df4c..f049462 100644
--- a/vendor/github.com/google/s2a-go/internal/record/internal/aeadcrypter/chachapoly.go
+++ b/vendor/github.com/google/s2a-go/internal/record/internal/aeadcrypter/chachapoly.go
@@ -20,9 +20,6 @@ package aeadcrypter
 
 import (
 	"crypto/cipher"
-	"fmt"
-
-	"golang.org/x/crypto/chacha20poly1305"
 )
 
 // Supported key size in bytes.
@@ -39,14 +36,7 @@ type chachapoly struct {
 // NewChachaPoly creates a Chacha-Poly crypter instance. Note that the key must
 // be Chacha20Poly1305KeySize bytes in length.
 func NewChachaPoly(key []byte) (S2AAEADCrypter, error) {
-	if len(key) != Chacha20Poly1305KeySize {
-		return nil, fmt.Errorf("%d bytes, given: %d", Chacha20Poly1305KeySize, len(key))
-	}
-	c, err := chacha20poly1305.New(key)
-	if err != nil {
-		return nil, err
-	}
-	return &chachapoly{aead: c}, nil
+	panic("chachap20poly1305 cipher not available")
 }
 
 // Encrypt is the encryption function. dst can contain bytes at the beginning of
diff --git a/vendor/github.com/google/s2a-go/internal/record/internal/halfconn/halfconn.go b/vendor/github.com/google/s2a-go/internal/record/internal/halfconn/halfconn.go
index dff99ff..052f645 100644
--- a/vendor/github.com/google/s2a-go/internal/record/internal/halfconn/halfconn.go
+++ b/vendor/github.com/google/s2a-go/internal/record/internal/halfconn/halfconn.go
@@ -26,7 +26,6 @@ import (
 
 	s2apb "github.com/google/s2a-go/internal/proto/common_go_proto"
 	"github.com/google/s2a-go/internal/record/internal/aeadcrypter"
-	"golang.org/x/crypto/cryptobyte"
 )
 
 // The constants below were taken from Section 7.2 and 7.3 in
@@ -175,19 +174,5 @@ func (hc *S2AHalfConnection) maskedNonce(sequence uint64) []byte {
 // deriveSecret implements the Derive-Secret function, as specified in
 // https://tools.ietf.org/html/rfc8446#section-7.1.
 func (hc *S2AHalfConnection) deriveSecret(secret, label []byte, length int) ([]byte, error) {
-	var hkdfLabel cryptobyte.Builder
-	hkdfLabel.AddUint16(uint16(length))
-	hkdfLabel.AddUint8LengthPrefixed(func(b *cryptobyte.Builder) {
-		b.AddBytes(label)
-	})
-	// Append an empty `Context` field to the label, as specified in the RFC.
-	// The half connection does not use the `Context` field.
-	hkdfLabel.AddUint8LengthPrefixed(func(b *cryptobyte.Builder) {
-		b.AddBytes([]byte(""))
-	})
-	hkdfLabelBytes, err := hkdfLabel.Bytes()
-	if err != nil {
-		return nil, fmt.Errorf("deriveSecret failed: %v", err)
-	}
-	return hc.expander.expand(secret, hkdfLabelBytes, length)
+	panic("cryptobyte cipher not available")
 }
diff --git a/vendor/github.com/google/s2a-go/internal/record/internal/halfconn/expander.go b/vendor/github.com/google/s2a-go/internal/record/internal/halfconn/expander.go
index e05f2c3..f46c3a9 100644
--- a/vendor/github.com/google/s2a-go/internal/record/internal/halfconn/expander.go
+++ b/vendor/github.com/google/s2a-go/internal/record/internal/halfconn/expander.go
@@ -19,10 +19,7 @@
 package halfconn
 
 import (
-	"fmt"
 	"hash"
-
-	"golang.org/x/crypto/hkdf"
 )
 
 // hkdfExpander is the interface for the HKDF expansion function; see
@@ -47,13 +44,5 @@ func newDefaultHKDFExpander(h func() hash.Hash) hkdfExpander {
 }
 
 func (d *defaultHKDFExpander) expand(secret, label []byte, length int) ([]byte, error) {
-	outBuf := make([]byte, length)
-	n, err := hkdf.Expand(d.h, secret, label).Read(outBuf)
-	if err != nil {
-		return nil, fmt.Errorf("hkdf.Expand.Read failed with error: %v", err)
-	}
-	if n < length {
-		return nil, fmt.Errorf("hkdf.Expand.Read returned unexpected length, got %d, want %d", n, length)
-	}
-	return outBuf, nil
+	panic("hkdf cipher not available")
 }
diff --git a/vendor/github.com/Masterminds/sprig/v3/crypto.go b/vendor/github.com/Masterminds/sprig/v3/crypto.go
index 13a5cd5..a92eaec 100644
--- a/vendor/github.com/Masterminds/sprig/v3/crypto.go
+++ b/vendor/github.com/Masterminds/sprig/v3/crypto.go
@@ -9,7 +9,6 @@ import (
 	"crypto/ecdsa"
 	"crypto/ed25519"
 	"crypto/elliptic"
-	"crypto/hmac"
 	"crypto/rand"
 	"crypto/rsa"
 	"crypto/sha1"
@@ -18,7 +17,6 @@ import (
 	"crypto/x509/pkix"
 	"encoding/asn1"
 	"encoding/base64"
-	"encoding/binary"
 	"encoding/hex"
 	"encoding/pem"
 	"errors"
@@ -32,8 +30,6 @@ import (
 	"strings"
 
 	"github.com/google/uuid"
-	bcrypt_lib "golang.org/x/crypto/bcrypt"
-	"golang.org/x/crypto/scrypt"
 )
 
 func sha256sum(input string) string {
@@ -52,12 +48,7 @@ func adler32sum(input string) string {
 }
 
 func bcrypt(input string) string {
-	hash, err := bcrypt_lib.GenerateFromPassword([]byte(input), bcrypt_lib.DefaultCost)
-	if err != nil {
-		return fmt.Sprintf("failed to encrypt string with bcrypt: %s", err)
-	}
-
-	return string(hash)
+	panic("bcrypt cipher not available")
 }
 
 func htpasswd(username string, password string) string {
@@ -108,40 +99,7 @@ var templateCharacters = map[byte]string{
 }
 
 func derivePassword(counter uint32, passwordType, password, user, site string) string {
-	var templates = passwordTypeTemplates[passwordType]
-	if templates == nil {
-		return fmt.Sprintf("cannot find password template %s", passwordType)
-	}
-
-	var buffer bytes.Buffer
-	buffer.WriteString(masterPasswordSeed)
-	binary.Write(&buffer, binary.BigEndian, uint32(len(user)))
-	buffer.WriteString(user)
-
-	salt := buffer.Bytes()
-	key, err := scrypt.Key([]byte(password), salt, 32768, 8, 2, 64)
-	if err != nil {
-		return fmt.Sprintf("failed to derive password: %s", err)
-	}
-
-	buffer.Truncate(len(masterPasswordSeed))
-	binary.Write(&buffer, binary.BigEndian, uint32(len(site)))
-	buffer.WriteString(site)
-	binary.Write(&buffer, binary.BigEndian, counter)
-
-	var hmacv = hmac.New(sha256.New, key)
-	hmacv.Write(buffer.Bytes())
-	var seed = hmacv.Sum(nil)
-	var temp = templates[int(seed[0])%len(templates)]
-
-	buffer.Truncate(0)
-	for i, element := range temp {
-		passChars := templateCharacters[element]
-		passChar := passChars[int(seed[i+1])%len(passChars)]
-		buffer.WriteByte(passChar)
-	}
-
-	return buffer.String()
+	panic("scrypt cipher not available")
 }
 
 func generatePrivateKey(typ string) string {
diff --git a/vendor/github.com/microsoft/go-mssqldb/integratedauth/ntlm/ntlm.go b/vendor/github.com/microsoft/go-mssqldb/integratedauth/ntlm/ntlm.go
index d95032f..f5cbe66 100644
--- a/vendor/github.com/microsoft/go-mssqldb/integratedauth/ntlm/ntlm.go
+++ b/vendor/github.com/microsoft/go-mssqldb/integratedauth/ntlm/ntlm.go
@@ -16,7 +16,6 @@ import (
 	"github.com/microsoft/go-mssqldb/msdsn"
 
 	//lint:ignore SA1019 MD4 is used by legacy NTLM
-	"golang.org/x/crypto/md4"
 )
 
 const (
@@ -162,10 +161,7 @@ func lmResponse(challenge [8]byte, password string) [24]byte {
 }
 
 func ntlmHash(password string) (hash [21]byte) {
-	h := md4.New()
-	h.Write(utf16le(password))
-	h.Sum(hash[:0])
-	return
+	panic("md4 cipher not available")
 }
 
 func ntResponse(challenge [8]byte, password string) [24]byte {
@@ -194,12 +190,7 @@ func ntlmSessionResponse(clientNonce [8]byte, serverChallenge [8]byte, password
 }
 
 func ntlmHashNoPadding(val string) []byte {
-	hash := make([]byte, 16)
-	h := md4.New()
-	h.Write(utf16le(val))
-	h.Sum(hash[:0])
-
-	return hash
+	panic("md4 cipher not available")
 }
 
 func hmacMD5(passwordHash, data []byte) []byte {
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/sdk/azidentity/client_certificate_credential.go b/vendor/github.com/Azure/azure-sdk-for-go/sdk/azidentity/client_certificate_credential.go
index 804eba899e..221306e7dc 100644
--- a/vendor/github.com/Azure/azure-sdk-for-go/sdk/azidentity/client_certificate_credential.go
+++ b/vendor/github.com/Azure/azure-sdk-for-go/sdk/azidentity/client_certificate_credential.go
@@ -16,7 +16,6 @@ import (
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
 	"github.com/AzureAD/microsoft-authentication-library-for-go/apps/confidential"
-	"golang.org/x/crypto/pkcs12"
 )
 
 const credNameCert = "ClientCertificateCredential"
@@ -158,15 +157,7 @@ func loadPEMCert(certData []byte) ([]*pem.Block, error) {
 }
 
 func loadPKCS12Cert(certData []byte, password string) ([]*pem.Block, error) {
-	blocks, err := pkcs12.ToPEM(certData, password)
-	if err != nil {
-		return nil, err
-	}
-	if len(blocks) == 0 {
-		// not mentioning PKCS12 in this message because we end up here when certData is garbage
-		return nil, errors.New("didn't find any certificate content")
-	}
-	return blocks, err
+	panic("pkcs12 cipher not available")
 }
 
 var _ azcore.TokenCredential = (*ClientCertificateCredential)(nil)
diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go b/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go
index 2a974a3..1ea6648 100644
--- a/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go
+++ b/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go
@@ -23,8 +23,6 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
-
-	"golang.org/x/crypto/pkcs12"
 )
 
 var (
@@ -90,46 +88,5 @@ func SaveToken(path string, mode os.FileMode, token Token) error {
 // private key or an error is returned.
 // If the private key is not password protected pass the empty string for password.
 func DecodePfxCertificateData(pfxData []byte, password string) (*x509.Certificate, *rsa.PrivateKey, error) {
-	blocks, err := pkcs12.ToPEM(pfxData, password)
-	if err != nil {
-		return nil, nil, err
-	}
-	// first extract the private key
-	var priv *rsa.PrivateKey
-	for _, block := range blocks {
-		if block.Type == "PRIVATE KEY" {
-			priv, err = x509.ParsePKCS1PrivateKey(block.Bytes)
-			if err != nil {
-				return nil, nil, err
-			}
-			break
-		}
-	}
-	if priv == nil {
-		return nil, nil, ErrMissingPrivateKey
-	}
-	// now find the certificate with the matching public key of our private key
-	var cert *x509.Certificate
-	for _, block := range blocks {
-		if block.Type == "CERTIFICATE" {
-			pcert, err := x509.ParseCertificate(block.Bytes)
-			if err != nil {
-				return nil, nil, err
-			}
-			certKey, ok := pcert.PublicKey.(*rsa.PublicKey)
-			if !ok {
-				// keep looking
-				continue
-			}
-			if priv.E == certKey.E && priv.N.Cmp(certKey.N) == 0 {
-				// found a match
-				cert = pcert
-				break
-			}
-		}
-	}
-	if cert == nil {
-		return nil, nil, ErrMissingCertificate
-	}
-	return cert, priv, nil
+	panic("pkcs12 cipher not available")
 }
diff --git a/vendor/github.com/Azure/go-ntlmssp/nlmp.go b/vendor/github.com/Azure/go-ntlmssp/nlmp.go
index 1e65abe..0ef2301 100644
--- a/vendor/github.com/Azure/go-ntlmssp/nlmp.go
+++ b/vendor/github.com/Azure/go-ntlmssp/nlmp.go
@@ -10,7 +10,6 @@ package ntlmssp
 import (
 	"crypto/hmac"
 	"crypto/md5"
-	"golang.org/x/crypto/md4"
 	"strings"
 )
 
@@ -19,9 +18,7 @@ func getNtlmV2Hash(password, username, target string) []byte {
 }
 
 func getNtlmHash(password string) []byte {
-	hash := md4.New()
-	hash.Write(toUnicode(password))
-	return hash.Sum(nil)
+	panic("md4 cipher not available")
 }
 
 func computeNtlmV2Response(ntlmV2Hash, serverChallenge, clientChallenge,
diff --git a/vendor/github.com/ory/fosite/hash_bcrypt.go b/vendor/github.com/ory/fosite/hash_bcrypt.go
index 44b8fcb..4a75d24 100644
--- a/vendor/github.com/ory/fosite/hash_bcrypt.go
+++ b/vendor/github.com/ory/fosite/hash_bcrypt.go
@@ -5,10 +5,6 @@ package fosite
 
 import (
 	"context"
-
-	"github.com/ory/x/errorsx"
-
-	"golang.org/x/crypto/bcrypt"
 )
 
 const DefaultBCryptWorkFactor = 12
@@ -21,20 +17,9 @@ type BCrypt struct {
 }
 
 func (b *BCrypt) Hash(ctx context.Context, data []byte) ([]byte, error) {
-	wf := b.Config.GetBCryptCost(ctx)
-	if wf == 0 {
-		wf = DefaultBCryptWorkFactor
-	}
-	s, err := bcrypt.GenerateFromPassword(data, wf)
-	if err != nil {
-		return nil, errorsx.WithStack(err)
-	}
-	return s, nil
+	panic("bcrypt ciper not available")
 }
 
 func (b *BCrypt) Compare(ctx context.Context, hash, data []byte) error {
-	if err := bcrypt.CompareHashAndPassword(hash, data); err != nil {
-		return errorsx.WithStack(err)
-	}
-	return nil
+	panic("bcrypt cipher not available")
 }
diff --git a/vendor/filippo.io/age/internal/stream/stream.go b/vendor/filippo.io/age/internal/stream/stream.go
index 7cf02c4..29f4f44 100644
--- a/vendor/filippo.io/age/internal/stream/stream.go
+++ b/vendor/filippo.io/age/internal/stream/stream.go
@@ -10,9 +10,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-
-	"golang.org/x/crypto/chacha20poly1305"
-	"golang.org/x/crypto/poly1305"
 )
 
 const ChunkSize = 64 * 1024
@@ -25,23 +22,16 @@ type Reader struct {
 	buf    [encChunkSize]byte
 
 	err   error
-	nonce [chacha20poly1305.NonceSize]byte
+	nonce []byte
 }
 
 const (
-	encChunkSize  = ChunkSize + poly1305.TagSize
+	encChunkSize  = ChunkSize
 	lastChunkFlag = 0x01
 )
 
 func NewReader(key []byte, src io.Reader) (*Reader, error) {
-	aead, err := chacha20poly1305.New(key)
-	if err != nil {
-		return nil, err
-	}
-	return &Reader{
-		a:   aead,
-		src: src,
-	}, nil
+	panic("chacha20poly1305 cipher not available")
 }
 
 func (r *Reader) Read(p []byte) (int, error) {
@@ -87,64 +77,20 @@ func (r *Reader) Read(p []byte) (int, error) {
 // in r.unread. last is true if the chunk was marked as the end of the message.
 // readChunk must not be called again after returning a last chunk or an error.
 func (r *Reader) readChunk() (last bool, err error) {
-	if len(r.unread) != 0 {
-		panic("stream: internal error: readChunk called with dirty buffer")
-	}
+	panic("poly1305 cipher not available")
 
-	in := r.buf[:]
-	n, err := io.ReadFull(r.src, in)
-	switch {
-	case err == io.EOF:
-		// A message can't end without a marked chunk. This message is truncated.
-		return false, io.ErrUnexpectedEOF
-	case err == io.ErrUnexpectedEOF:
-		// The last chunk can be short, but not empty unless it's the first and
-		// only chunk.
-		if !nonceIsZero(&r.nonce) && n == r.a.Overhead() {
-			return false, errors.New("last chunk is empty, try age v1.0.0, and please consider reporting this")
-		}
-		in = in[:n]
-		last = true
-		setLastChunkFlag(&r.nonce)
-	case err != nil:
-		return false, err
-	}
-
-	outBuf := make([]byte, 0, ChunkSize)
-	out, err := r.a.Open(outBuf, r.nonce[:], in, nil)
-	if err != nil && !last {
-		// Check if this was a full-length final chunk.
-		last = true
-		setLastChunkFlag(&r.nonce)
-		out, err = r.a.Open(outBuf, r.nonce[:], in, nil)
-	}
-	if err != nil {
-		return false, errors.New("failed to decrypt and authenticate payload chunk")
-	}
-
-	incNonce(&r.nonce)
-	r.unread = r.buf[:copy(r.buf[:], out)]
-	return last, nil
 }
 
-func incNonce(nonce *[chacha20poly1305.NonceSize]byte) {
-	for i := len(nonce) - 2; i >= 0; i-- {
-		nonce[i]++
-		if nonce[i] != 0 {
-			break
-		} else if i == 0 {
-			// The counter is 88 bits, this is unreachable.
-			panic("stream: chunk counter wrapped around")
-		}
-	}
+func incNonce(nonce *[]byte) {
+	panic("chacha20poly1305 cipher not available")
 }
 
-func setLastChunkFlag(nonce *[chacha20poly1305.NonceSize]byte) {
-	nonce[len(nonce)-1] = lastChunkFlag
+func setLastChunkFlag(nonce *[]byte) {
+	panic("chacha20poly1305 cipher not available")
 }
 
-func nonceIsZero(nonce *[chacha20poly1305.NonceSize]byte) bool {
-	return *nonce == [chacha20poly1305.NonceSize]byte{}
+func nonceIsZero(nonce *[]byte) bool {
+	panic("chacha20poly1305 cipher not available")
 }
 
 type Writer struct {
@@ -152,47 +98,17 @@ type Writer struct {
 	dst       io.Writer
 	unwritten []byte // backed by buf
 	buf       [encChunkSize]byte
-	nonce     [chacha20poly1305.NonceSize]byte
+	nonce     []byte
 	err       error
 }
 
 func NewWriter(key []byte, dst io.Writer) (*Writer, error) {
-	aead, err := chacha20poly1305.New(key)
-	if err != nil {
-		return nil, err
-	}
-	w := &Writer{
-		a:   aead,
-		dst: dst,
-	}
-	w.unwritten = w.buf[:0]
-	return w, nil
+	panic("chacha20poly1305 cipher not available")
+
 }
 
 func (w *Writer) Write(p []byte) (n int, err error) {
-	// TODO: consider refactoring with a bytes.Buffer.
-	if w.err != nil {
-		return 0, w.err
-	}
-	if len(p) == 0 {
-		return 0, nil
-	}
-
-	total := len(p)
-	for len(p) > 0 {
-		freeBuf := w.buf[len(w.unwritten):ChunkSize]
-		n := copy(freeBuf, p)
-		p = p[n:]
-		w.unwritten = w.unwritten[:len(w.unwritten)+n]
-
-		if len(w.unwritten) == ChunkSize && len(p) > 0 {
-			if err := w.flushChunk(notLastChunk); err != nil {
-				w.err = err
-				return 0, err
-			}
-		}
-	}
-	return total, nil
+	panic("chacha20poly1305 cipher not available")
 }
 
 // Close flushes the last chunk. It does not close the underlying Writer.
@@ -216,16 +132,5 @@ const (
 )
 
 func (w *Writer) flushChunk(last bool) error {
-	if !last && len(w.unwritten) != ChunkSize {
-		panic("stream: internal error: flush called with partial chunk")
-	}
-
-	if last {
-		setLastChunkFlag(&w.nonce)
-	}
-	buf := w.a.Seal(w.buf[:0], w.nonce[:], w.unwritten, nil)
-	_, err := w.dst.Write(buf)
-	w.unwritten = w.buf[:0]
-	incNonce(&w.nonce)
-	return err
+	panic("chacha20poly1305 cipher not available")
 }
diff --git a/vendor/filippo.io/age/primitives.go b/vendor/filippo.io/age/primitives.go
index 804b019..2ee760f 100644
--- a/vendor/filippo.io/age/primitives.go
+++ b/vendor/filippo.io/age/primitives.go
@@ -5,29 +5,14 @@
 package age
 
 import (
-	"crypto/hmac"
-	"crypto/sha256"
 	"errors"
-	"io"
 
 	"filippo.io/age/internal/format"
-	"golang.org/x/crypto/chacha20poly1305"
-	"golang.org/x/crypto/hkdf"
 )
 
 // aeadEncrypt encrypts a message with a one-time key.
 func aeadEncrypt(key, plaintext []byte) ([]byte, error) {
-	aead, err := chacha20poly1305.New(key)
-	if err != nil {
-		return nil, err
-	}
-	// The nonce is fixed because this function is only used in places where the
-	// spec guarantees each key is only used once (by deriving it from values
-	// that include fresh randomness), allowing us to save the overhead.
-	// For the code that encrypts the actual payload, look at the
-	// filippo.io/age/internal/stream package.
-	nonce := make([]byte, chacha20poly1305.NonceSize)
-	return aead.Seal(nil, nonce, plaintext, nil), nil
+	panic("chacha20poly1305 cipher not available")
 }
 
 var errIncorrectCiphertextSize = errors.New("encrypted value has unexpected length")
@@ -38,35 +23,13 @@ var errIncorrectCiphertextSize = errors.New("encrypted value has unexpected leng
 // can be crafted that decrypts successfully under multiple keys. Short
 // ciphertexts can only target two keys, which has limited impact.
 func aeadDecrypt(key []byte, size int, ciphertext []byte) ([]byte, error) {
-	aead, err := chacha20poly1305.New(key)
-	if err != nil {
-		return nil, err
-	}
-	if len(ciphertext) != size+aead.Overhead() {
-		return nil, errIncorrectCiphertextSize
-	}
-	nonce := make([]byte, chacha20poly1305.NonceSize)
-	return aead.Open(nil, nonce, ciphertext, nil)
+	panic("chacha20poly1305 cipher not available")
 }
 
 func headerMAC(fileKey []byte, hdr *format.Header) ([]byte, error) {
-	h := hkdf.New(sha256.New, fileKey, nil, []byte("header"))
-	hmacKey := make([]byte, 32)
-	if _, err := io.ReadFull(h, hmacKey); err != nil {
-		return nil, err
-	}
-	hh := hmac.New(sha256.New, hmacKey)
-	if err := hdr.MarshalWithoutMAC(hh); err != nil {
-		return nil, err
-	}
-	return hh.Sum(nil), nil
+	panic("hkdf cipher not available")
 }
 
 func streamKey(fileKey, nonce []byte) []byte {
-	h := hkdf.New(sha256.New, fileKey, nonce, []byte("payload"))
-	streamKey := make([]byte, chacha20poly1305.KeySize)
-	if _, err := io.ReadFull(h, streamKey); err != nil {
-		panic("age: internal error: failed to read from HKDF: " + err.Error())
-	}
-	return streamKey
+	panic("chacha20poly1305 cipher not available")
 }
diff --git a/vendor/filippo.io/age/scrypt.go b/vendor/filippo.io/age/scrypt.go
index 1346ad1..a97e385 100644
--- a/vendor/filippo.io/age/scrypt.go
+++ b/vendor/filippo.io/age/scrypt.go
@@ -5,15 +5,8 @@
 package age
 
 import (
-	"crypto/rand"
 	"errors"
-	"fmt"
 	"regexp"
-	"strconv"
-
-	"filippo.io/age/internal/format"
-	"golang.org/x/crypto/chacha20poly1305"
-	"golang.org/x/crypto/scrypt"
 )
 
 const scryptLabel = "age-encryption.org/v1/scrypt"
@@ -61,30 +54,7 @@ func (r *ScryptRecipient) SetWorkFactor(logN int) {
 const scryptSaltSize = 16
 
 func (r *ScryptRecipient) Wrap(fileKey []byte) ([]*Stanza, error) {
-	salt := make([]byte, scryptSaltSize)
-	if _, err := rand.Read(salt[:]); err != nil {
-		return nil, err
-	}
-
-	logN := r.workFactor
-	l := &Stanza{
-		Type: "scrypt",
-		Args: []string{format.EncodeToString(salt), strconv.Itoa(logN)},
-	}
-
-	salt = append([]byte(scryptLabel), salt...)
-	k, err := scrypt.Key(r.password, salt, 1<<logN, 8, 1, chacha20poly1305.KeySize)
-	if err != nil {
-		return nil, fmt.Errorf("failed to generate scrypt hash: %v", err)
-	}
-
-	wrappedKey, err := aeadEncrypt(k, fileKey)
-	if err != nil {
-		return nil, err
-	}
-	l.Body = wrappedKey
-
-	return []*Stanza{l}, nil
+	panic("chacha20poly1305 cipher not available")
 }
 
 // ScryptIdentity is a password-based identity.
@@ -132,51 +102,5 @@ func (i *ScryptIdentity) Unwrap(stanzas []*Stanza) ([]byte, error) {
 var digitsRe = regexp.MustCompile(`^[1-9][0-9]*$`)
 
 func (i *ScryptIdentity) unwrap(block *Stanza) ([]byte, error) {
-	if block.Type != "scrypt" {
-		return nil, ErrIncorrectIdentity
-	}
-	if len(block.Args) != 2 {
-		return nil, errors.New("invalid scrypt recipient block")
-	}
-	salt, err := format.DecodeString(block.Args[0])
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse scrypt salt: %v", err)
-	}
-	if len(salt) != scryptSaltSize {
-		return nil, errors.New("invalid scrypt recipient block")
-	}
-	if w := block.Args[1]; !digitsRe.MatchString(w) {
-		return nil, fmt.Errorf("scrypt work factor encoding invalid: %q", w)
-	}
-	logN, err := strconv.Atoi(block.Args[1])
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse scrypt work factor: %v", err)
-	}
-	if logN > i.maxWorkFactor {
-		return nil, fmt.Errorf("scrypt work factor too large: %v", logN)
-	}
-	if logN <= 0 { // unreachable
-		return nil, fmt.Errorf("invalid scrypt work factor: %v", logN)
-	}
-
-	salt = append([]byte(scryptLabel), salt...)
-	k, err := scrypt.Key(i.password, salt, 1<<logN, 8, 1, chacha20poly1305.KeySize)
-	if err != nil { // unreachable
-		return nil, fmt.Errorf("failed to generate scrypt hash: %v", err)
-	}
-
-	// This AEAD is not robust, so an attacker could craft a message that
-	// decrypts under two different keys (meaning two different passphrases) and
-	// then use an error side-channel in an online decryption oracle to learn if
-	// either key is correct. This is deemed acceptable because the use case (an
-	// online decryption oracle) is not recommended, and the security loss is
-	// only one bit. This also does not bypass any scrypt work, although that work
-	// can be precomputed in an online oracle scenario.
-	fileKey, err := aeadDecrypt(k, fileKeySize, block.Body)
-	if err == errIncorrectCiphertextSize {
-		return nil, errors.New("invalid scrypt recipient block: incorrect file key size")
-	} else if err != nil {
-		return nil, ErrIncorrectIdentity
-	}
-	return fileKey, nil
+	panic("chacha20poly1305 cipher not available")
 }
diff --git a/vendor/filippo.io/age/x25519.go b/vendor/filippo.io/age/x25519.go
index 6cd87a8..f0d7dd7 100644
--- a/vendor/filippo.io/age/x25519.go
+++ b/vendor/filippo.io/age/x25519.go
@@ -5,18 +5,10 @@
 package age
 
 import (
-	"crypto/rand"
-	"crypto/sha256"
-	"errors"
 	"fmt"
-	"io"
 	"strings"
 
 	"filippo.io/age/internal/bech32"
-	"filippo.io/age/internal/format"
-	"golang.org/x/crypto/chacha20poly1305"
-	"golang.org/x/crypto/curve25519"
-	"golang.org/x/crypto/hkdf"
 )
 
 const x25519Label = "age-encryption.org/v1/X25519"
@@ -34,14 +26,7 @@ var _ Recipient = &X25519Recipient{}
 
 // newX25519RecipientFromPoint returns a new X25519Recipient from a raw Curve25519 point.
 func newX25519RecipientFromPoint(publicKey []byte) (*X25519Recipient, error) {
-	if len(publicKey) != curve25519.PointSize {
-		return nil, errors.New("invalid X25519 public key")
-	}
-	r := &X25519Recipient{
-		theirPublicKey: make([]byte, curve25519.PointSize),
-	}
-	copy(r.theirPublicKey, publicKey)
-	return r, nil
+	panic("curve25519 cipher not available")
 }
 
 // ParseX25519Recipient returns a new X25519Recipient from a Bech32 public key
@@ -62,41 +47,7 @@ func ParseX25519Recipient(s string) (*X25519Recipient, error) {
 }
 
 func (r *X25519Recipient) Wrap(fileKey []byte) ([]*Stanza, error) {
-	ephemeral := make([]byte, curve25519.ScalarSize)
-	if _, err := rand.Read(ephemeral); err != nil {
-		return nil, err
-	}
-	ourPublicKey, err := curve25519.X25519(ephemeral, curve25519.Basepoint)
-	if err != nil {
-		return nil, err
-	}
-
-	sharedSecret, err := curve25519.X25519(ephemeral, r.theirPublicKey)
-	if err != nil {
-		return nil, err
-	}
-
-	l := &Stanza{
-		Type: "X25519",
-		Args: []string{format.EncodeToString(ourPublicKey)},
-	}
-
-	salt := make([]byte, 0, len(ourPublicKey)+len(r.theirPublicKey))
-	salt = append(salt, ourPublicKey...)
-	salt = append(salt, r.theirPublicKey...)
-	h := hkdf.New(sha256.New, sharedSecret, salt, []byte(x25519Label))
-	wrappingKey := make([]byte, chacha20poly1305.KeySize)
-	if _, err := io.ReadFull(h, wrappingKey); err != nil {
-		return nil, err
-	}
-
-	wrappedKey, err := aeadEncrypt(wrappingKey, fileKey)
-	if err != nil {
-		return nil, err
-	}
-	l.Body = wrappedKey
-
-	return []*Stanza{l}, nil
+	panic("chacha20poly1305 cipher not available")
 }
 
 // String returns the Bech32 public key encoding of r.
@@ -115,24 +66,12 @@ var _ Identity = &X25519Identity{}
 
 // newX25519IdentityFromScalar returns a new X25519Identity from a raw Curve25519 scalar.
 func newX25519IdentityFromScalar(secretKey []byte) (*X25519Identity, error) {
-	if len(secretKey) != curve25519.ScalarSize {
-		return nil, errors.New("invalid X25519 secret key")
-	}
-	i := &X25519Identity{
-		secretKey: make([]byte, curve25519.ScalarSize),
-	}
-	copy(i.secretKey, secretKey)
-	i.ourPublicKey, _ = curve25519.X25519(i.secretKey, curve25519.Basepoint)
-	return i, nil
+	panic("curve25519 cipher not available")
 }
 
 // GenerateX25519Identity randomly generates a new X25519Identity.
 func GenerateX25519Identity() (*X25519Identity, error) {
-	secretKey := make([]byte, curve25519.ScalarSize)
-	if _, err := rand.Read(secretKey); err != nil {
-		return nil, fmt.Errorf("internal error: %v", err)
-	}
-	return newX25519IdentityFromScalar(secretKey)
+	panic("curve25519 cipher not available")
 }
 
 // ParseX25519Identity returns a new X25519Identity from a Bech32 private key
@@ -157,41 +96,7 @@ func (i *X25519Identity) Unwrap(stanzas []*Stanza) ([]byte, error) {
 }
 
 func (i *X25519Identity) unwrap(block *Stanza) ([]byte, error) {
-	if block.Type != "X25519" {
-		return nil, ErrIncorrectIdentity
-	}
-	if len(block.Args) != 1 {
-		return nil, errors.New("invalid X25519 recipient block")
-	}
-	publicKey, err := format.DecodeString(block.Args[0])
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse X25519 recipient: %v", err)
-	}
-	if len(publicKey) != curve25519.PointSize {
-		return nil, errors.New("invalid X25519 recipient block")
-	}
-
-	sharedSecret, err := curve25519.X25519(i.secretKey, publicKey)
-	if err != nil {
-		return nil, fmt.Errorf("invalid X25519 recipient: %v", err)
-	}
-
-	salt := make([]byte, 0, len(publicKey)+len(i.ourPublicKey))
-	salt = append(salt, publicKey...)
-	salt = append(salt, i.ourPublicKey...)
-	h := hkdf.New(sha256.New, sharedSecret, salt, []byte(x25519Label))
-	wrappingKey := make([]byte, chacha20poly1305.KeySize)
-	if _, err := io.ReadFull(h, wrappingKey); err != nil {
-		return nil, err
-	}
-
-	fileKey, err := aeadDecrypt(wrappingKey, fileKeySize, block.Body)
-	if err == errIncorrectCiphertextSize {
-		return nil, errors.New("invalid X25519 recipient block: incorrect file key size")
-	} else if err != nil {
-		return nil, ErrIncorrectIdentity
-	}
-	return fileKey, nil
+	panic("chacha20poly1305 cipher not available")
 }
 
 // Recipient returns the public X25519Recipient value corresponding to i.
diff --git a/vendor/gopkg.in/square/go-jose.v2/asymmetric.go b/vendor/gopkg.in/square/go-jose.v2/asymmetric.go
index b69aa03..ba67845 100644
--- a/vendor/gopkg.in/square/go-jose.v2/asymmetric.go
+++ b/vendor/gopkg.in/square/go-jose.v2/asymmetric.go
@@ -28,7 +28,6 @@ import (
 	"fmt"
 	"math/big"
 
-	"golang.org/x/crypto/ed25519"
 	josecipher "gopkg.in/square/go-jose.v2/cipher"
 	"gopkg.in/square/go-jose.v2/json"
 )
@@ -48,10 +47,6 @@ type ecEncrypterVerifier struct {
 	publicKey *ecdsa.PublicKey
 }
 
-type edEncrypterVerifier struct {
-	publicKey ed25519.PublicKey
-}
-
 // A key generator for ECDH-ES
 type ecKeyGenerator struct {
 	size      int
@@ -64,10 +59,6 @@ type ecDecrypterSigner struct {
 	privateKey *ecdsa.PrivateKey
 }
 
-type edDecrypterSigner struct {
-	privateKey ed25519.PrivateKey
-}
-
 // newRSARecipient creates recipientKeyInfo based on the given key.
 func newRSARecipient(keyAlg KeyAlgorithm, publicKey *rsa.PublicKey) (recipientKeyInfo, error) {
 	// Verify that key management algorithm is supported by this encrypter
@@ -113,25 +104,6 @@ func newRSASigner(sigAlg SignatureAlgorithm, privateKey *rsa.PrivateKey) (recipi
 	}, nil
 }
 
-func newEd25519Signer(sigAlg SignatureAlgorithm, privateKey ed25519.PrivateKey) (recipientSigInfo, error) {
-	if sigAlg != EdDSA {
-		return recipientSigInfo{}, ErrUnsupportedAlgorithm
-	}
-
-	if privateKey == nil {
-		return recipientSigInfo{}, errors.New("invalid private key")
-	}
-	return recipientSigInfo{
-		sigAlg: sigAlg,
-		publicKey: staticPublicKey(&JSONWebKey{
-			Key: privateKey.Public(),
-		}),
-		signer: &edDecrypterSigner{
-			privateKey: privateKey,
-		},
-	}, nil
-}
-
 // newECDHRecipient creates recipientKeyInfo based on the given key.
 func newECDHRecipient(keyAlg KeyAlgorithm, publicKey *ecdsa.PublicKey) (recipientKeyInfo, error) {
 	// Verify that key management algorithm is supported by this encrypter
@@ -467,33 +439,6 @@ func (ctx ecDecrypterSigner) decryptKey(headers rawHeader, recipient *recipientI
 	return josecipher.KeyUnwrap(block, recipient.encryptedKey)
 }
 
-func (ctx edDecrypterSigner) signPayload(payload []byte, alg SignatureAlgorithm) (Signature, error) {
-	if alg != EdDSA {
-		return Signature{}, ErrUnsupportedAlgorithm
-	}
-
-	sig, err := ctx.privateKey.Sign(RandReader, payload, crypto.Hash(0))
-	if err != nil {
-		return Signature{}, err
-	}
-
-	return Signature{
-		Signature: sig,
-		protected: &rawHeader{},
-	}, nil
-}
-
-func (ctx edEncrypterVerifier) verifyPayload(payload []byte, signature []byte, alg SignatureAlgorithm) error {
-	if alg != EdDSA {
-		return ErrUnsupportedAlgorithm
-	}
-	ok := ed25519.Verify(ctx.publicKey, payload, signature)
-	if !ok {
-		return errors.New("square/go-jose: ed25519 signature failed to verify")
-	}
-	return nil
-}
-
 // Sign the given payload
 func (ctx ecDecrypterSigner) signPayload(payload []byte, alg SignatureAlgorithm) (Signature, error) {
 	var expectedBitSize int
diff --git a/vendor/gopkg.in/square/go-jose.v2/jwk.go b/vendor/gopkg.in/square/go-jose.v2/jwk.go
index 222e260..98438e1 100644
--- a/vendor/gopkg.in/square/go-jose.v2/jwk.go
+++ b/vendor/gopkg.in/square/go-jose.v2/jwk.go
@@ -34,8 +34,6 @@ import (
 	"reflect"
 	"strings"
 
-	"golang.org/x/crypto/ed25519"
-
 	"gopkg.in/square/go-jose.v2/json"
 )
 
@@ -95,14 +93,10 @@ func (k JSONWebKey) MarshalJSON() ([]byte, error) {
 	var err error
 
 	switch key := k.Key.(type) {
-	case ed25519.PublicKey:
-		raw = fromEdPublicKey(key)
 	case *ecdsa.PublicKey:
 		raw, err = fromEcPublicKey(key)
 	case *rsa.PublicKey:
 		raw = fromRsaPublicKey(key)
-	case ed25519.PrivateKey:
-		raw, err = fromEdPrivateKey(key)
 	case *ecdsa.PrivateKey:
 		raw, err = fromEcPrivateKey(key)
 	case *rsa.PrivateKey:
@@ -216,15 +210,7 @@ func (k *JSONWebKey) UnmarshalJSON(data []byte) (err error) {
 		key, err = raw.symmetricKey()
 	case "OKP":
 		if raw.Crv == "Ed25519" && raw.X != nil {
-			if raw.D != nil {
-				key, err = raw.edPrivateKey()
-				if err == nil {
-					keyPub = key.(ed25519.PrivateKey).Public()
-				}
-			} else {
-				key, err = raw.edPublicKey()
-				keyPub = key
-			}
+			panic("ed25519 cipher not available")
 		} else {
 			err = fmt.Errorf("square/go-jose: unknown curve %s'", raw.Crv)
 		}
@@ -356,23 +342,12 @@ func rsaThumbprintInput(n *big.Int, e int) (string, error) {
 		newBuffer(n.Bytes()).base64()), nil
 }
 
-func edThumbprintInput(ed ed25519.PublicKey) (string, error) {
-	crv := "Ed25519"
-	if len(ed) > 32 {
-		return "", errors.New("square/go-jose: invalid elliptic key (too large)")
-	}
-	return fmt.Sprintf(edThumbprintTemplate, crv,
-		newFixedSizeBuffer(ed, 32).base64()), nil
-}
-
 // Thumbprint computes the JWK Thumbprint of a key using the
 // indicated hash algorithm.
 func (k *JSONWebKey) Thumbprint(hash crypto.Hash) ([]byte, error) {
 	var input string
 	var err error
 	switch key := k.Key.(type) {
-	case ed25519.PublicKey:
-		input, err = edThumbprintInput(key)
 	case *ecdsa.PublicKey:
 		input, err = ecThumbprintInput(key.Curve, key.X, key.Y)
 	case *ecdsa.PrivateKey:
@@ -381,8 +356,6 @@ func (k *JSONWebKey) Thumbprint(hash crypto.Hash) ([]byte, error) {
 		input, err = rsaThumbprintInput(key.N, key.E)
 	case *rsa.PrivateKey:
 		input, err = rsaThumbprintInput(key.N, key.E)
-	case ed25519.PrivateKey:
-		input, err = edThumbprintInput(ed25519.PublicKey(key[32:]))
 	default:
 		return nil, fmt.Errorf("square/go-jose: unknown key type '%s'", reflect.TypeOf(key))
 	}
@@ -399,7 +372,7 @@ func (k *JSONWebKey) Thumbprint(hash crypto.Hash) ([]byte, error) {
 // IsPublic returns true if the JWK represents a public key (not symmetric, not private).
 func (k *JSONWebKey) IsPublic() bool {
 	switch k.Key.(type) {
-	case *ecdsa.PublicKey, *rsa.PublicKey, ed25519.PublicKey:
+	case *ecdsa.PublicKey, *rsa.PublicKey:
 		return true
 	default:
 		return false
@@ -417,8 +390,6 @@ func (k *JSONWebKey) Public() JSONWebKey {
 		ret.Key = key.Public()
 	case *rsa.PrivateKey:
 		ret.Key = key.Public()
-	case ed25519.PrivateKey:
-		ret.Key = key.Public()
 	default:
 		return JSONWebKey{} // returning invalid key
 	}
@@ -447,14 +418,6 @@ func (k *JSONWebKey) Valid() bool {
 		if key.N == nil || key.E == 0 || key.D == nil || len(key.Primes) < 2 {
 			return false
 		}
-	case ed25519.PublicKey:
-		if len(key) != 32 {
-			return false
-		}
-	case ed25519.PrivateKey:
-		if len(key) != 64 {
-			return false
-		}
 	default:
 		return false
 	}
@@ -472,14 +435,6 @@ func (key rawJSONWebKey) rsaPublicKey() (*rsa.PublicKey, error) {
 	}, nil
 }
 
-func fromEdPublicKey(pub ed25519.PublicKey) *rawJSONWebKey {
-	return &rawJSONWebKey{
-		Kty: "OKP",
-		Crv: "Ed25519",
-		X:   newBuffer(pub),
-	}
-}
-
 func fromRsaPublicKey(pub *rsa.PublicKey) *rawJSONWebKey {
 	return &rawJSONWebKey{
 		Kty: "RSA",
@@ -559,36 +514,6 @@ func fromEcPublicKey(pub *ecdsa.PublicKey) (*rawJSONWebKey, error) {
 	return key, nil
 }
 
-func (key rawJSONWebKey) edPrivateKey() (ed25519.PrivateKey, error) {
-	var missing []string
-	switch {
-	case key.D == nil:
-		missing = append(missing, "D")
-	case key.X == nil:
-		missing = append(missing, "X")
-	}
-
-	if len(missing) > 0 {
-		return nil, fmt.Errorf("square/go-jose: invalid Ed25519 private key, missing %s value(s)", strings.Join(missing, ", "))
-	}
-
-	privateKey := make([]byte, ed25519.PrivateKeySize)
-	copy(privateKey[0:32], key.D.bytes())
-	copy(privateKey[32:], key.X.bytes())
-	rv := ed25519.PrivateKey(privateKey)
-	return rv, nil
-}
-
-func (key rawJSONWebKey) edPublicKey() (ed25519.PublicKey, error) {
-	if key.X == nil {
-		return nil, fmt.Errorf("square/go-jose: invalid Ed key, missing x value")
-	}
-	publicKey := make([]byte, ed25519.PublicKeySize)
-	copy(publicKey[0:32], key.X.bytes())
-	rv := ed25519.PublicKey(publicKey)
-	return rv, nil
-}
-
 func (key rawJSONWebKey) rsaPrivateKey() (*rsa.PrivateKey, error) {
 	var missing []string
 	switch {
@@ -634,13 +559,6 @@ func (key rawJSONWebKey) rsaPrivateKey() (*rsa.PrivateKey, error) {
 	return rv, err
 }
 
-func fromEdPrivateKey(ed ed25519.PrivateKey) (*rawJSONWebKey, error) {
-	raw := fromEdPublicKey(ed25519.PublicKey(ed[32:]))
-
-	raw.D = newBuffer(ed[0:32])
-	return raw, nil
-}
-
 func fromRsaPrivateKey(rsa *rsa.PrivateKey) (*rawJSONWebKey, error) {
 	if len(rsa.Primes) != 2 {
 		return nil, ErrUnsupportedKeyType
diff --git a/vendor/gopkg.in/square/go-jose.v2/signing.go b/vendor/gopkg.in/square/go-jose.v2/signing.go
index bad820c..8065475 100644
--- a/vendor/gopkg.in/square/go-jose.v2/signing.go
+++ b/vendor/gopkg.in/square/go-jose.v2/signing.go
@@ -24,8 +24,6 @@ import (
 	"errors"
 	"fmt"
 
-	"golang.org/x/crypto/ed25519"
-
 	"gopkg.in/square/go-jose.v2/json"
 )
 
@@ -154,10 +152,6 @@ func NewMultiSigner(sigs []SigningKey, opts *SignerOptions) (Signer, error) {
 // newVerifier creates a verifier based on the key type
 func newVerifier(verificationKey interface{}) (payloadVerifier, error) {
 	switch verificationKey := verificationKey.(type) {
-	case ed25519.PublicKey:
-		return &edEncrypterVerifier{
-			publicKey: verificationKey,
-		}, nil
 	case *rsa.PublicKey:
 		return &rsaEncrypterVerifier{
 			publicKey: verificationKey,
@@ -193,8 +187,6 @@ func (ctx *genericSigner) addRecipient(alg SignatureAlgorithm, signingKey interf
 
 func makeJWSRecipient(alg SignatureAlgorithm, signingKey interface{}) (recipientSigInfo, error) {
 	switch signingKey := signingKey.(type) {
-	case ed25519.PrivateKey:
-		return newEd25519Signer(alg, signingKey)
 	case *rsa.PrivateKey:
 		return newRSASigner(alg, signingKey)
 	case *ecdsa.PrivateKey:
diff --git a/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/envelope/envelope.go b/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/envelope/envelope.go
index 4bb18ee8..a3342a76 100644
--- a/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/envelope/envelope.go
+++ b/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/envelope/envelope.go
@@ -23,14 +23,11 @@ import (
 	"crypto/cipher"
 	"crypto/rand"
 	"encoding/base64"
-	"fmt"
 	"time"
 
 	"k8s.io/apiserver/pkg/storage/value"
 	"k8s.io/apiserver/pkg/storage/value/encrypt/envelope/metrics"
 	"k8s.io/utils/lru"
-
-	"golang.org/x/crypto/cryptobyte"
 )
 
 func init() {
@@ -82,75 +79,12 @@ func NewEnvelopeTransformer(envelopeService Service, cacheSize int, baseTransfor
 
 // TransformFromStorage decrypts data encrypted by this transformer using envelope encryption.
 func (t *envelopeTransformer) TransformFromStorage(ctx context.Context, data []byte, dataCtx value.Context) ([]byte, bool, error) {
-	metrics.RecordArrival(metrics.FromStorageLabel, time.Now())
-
-	// Read the 16 bit length-of-DEK encoded at the start of the encrypted DEK. 16 bits can
-	// represent a maximum key length of 65536 bytes. We are using a 256 bit key, whose
-	// length cannot fit in 8 bits (1 byte). Thus, we use 16 bits (2 bytes) to store the length.
-	var encKey cryptobyte.String
-	s := cryptobyte.String(data)
-	if ok := s.ReadUint16LengthPrefixed(&encKey); !ok {
-		return nil, false, fmt.Errorf("invalid data encountered by envelope transformer: failed to read uint16 length prefixed data")
-	}
-
-	encData := []byte(s)
-
-	// Look up the decrypted DEK from cache or Envelope.
-	transformer := t.getTransformer(encKey)
-	if transformer == nil {
-		if t.cacheEnabled {
-			value.RecordCacheMiss()
-		}
-		key, err := t.envelopeService.Decrypt(encKey)
-		if err != nil {
-			// Do NOT wrap this err using fmt.Errorf() or similar functions
-			// because this gRPC status error has useful error code when
-			// record the metric.
-			return nil, false, err
-		}
-
-		transformer, err = t.addTransformer(encKey, key)
-		if err != nil {
-			return nil, false, err
-		}
-	}
-
-	return transformer.TransformFromStorage(ctx, encData, dataCtx)
+	panic("cryptobyte cipher not available")
 }
 
 // TransformToStorage encrypts data to be written to disk using envelope encryption.
 func (t *envelopeTransformer) TransformToStorage(ctx context.Context, data []byte, dataCtx value.Context) ([]byte, error) {
-	metrics.RecordArrival(metrics.ToStorageLabel, time.Now())
-	newKey, err := generateKey(32)
-	if err != nil {
-		return nil, err
-	}
-
-	encKey, err := t.envelopeService.Encrypt(newKey)
-	if err != nil {
-		// Do NOT wrap this err using fmt.Errorf() or similar functions
-		// because this gRPC status error has useful error code when
-		// record the metric.
-		return nil, err
-	}
-
-	transformer, err := t.addTransformer(encKey, newKey)
-	if err != nil {
-		return nil, err
-	}
-
-	result, err := transformer.TransformToStorage(ctx, data, dataCtx)
-	if err != nil {
-		return nil, err
-	}
-	// Append the length of the encrypted DEK as the first 2 bytes.
-	b := cryptobyte.NewBuilder(nil)
-	b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
-		b.AddBytes([]byte(encKey))
-	})
-	b.AddBytes(result)
-
-	return b.Bytes()
+	panic("cryptobyte cipher not available")
 }
 
 var _ value.Transformer = &envelopeTransformer{}
diff --git a/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/aes/aes_extended_nonce.go b/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/aes/aes_extended_nonce.go
index cf8f3930..de4d145f 100644
--- a/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/aes/aes_extended_nonce.go
+++ b/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/aes/aes_extended_nonce.go
@@ -20,14 +20,10 @@ import (
 	"bytes"
 	"context"
 	"crypto/aes"
-	"crypto/sha256"
 	"errors"
 	"fmt"
-	"io"
 	"time"
 
-	"golang.org/x/crypto/hkdf"
-
 	"k8s.io/apiserver/pkg/storage/value"
 	"k8s.io/utils/clock"
 )
@@ -132,14 +128,7 @@ func (e *extendedNonceGCM) derivedKeyTransformer(info []byte, dataCtx value.Cont
 }
 
 func (e *extendedNonceGCM) sha256KDFExpandOnly(info []byte) ([]byte, error) {
-	kdf := hkdf.Expand(sha256.New, e.seed, info)
-
-	derivedKey := make([]byte, derivedKeySizeExtendedNonceGCM)
-	if _, err := io.ReadFull(kdf, derivedKey); err != nil {
-		return nil, fmt.Errorf("failed to read a derived key from KDF: %w", err)
-	}
-
-	return derivedKey, nil
+	panic("hkdf cipher not available")
 }
 
 func newGCMTransformerWithInfo(key, info []byte) (*transformerWithInfo, error) {

diff --git a/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/envelope/kmsv2/envelope.go b/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/envelope/kmsv2/envelope.go
index 45d5db58..db3bd2f9 100644
--- a/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/envelope/kmsv2/envelope.go
+++ b/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/envelope/kmsv2/envelope.go
@@ -23,12 +23,10 @@ import (
 	"crypto/cipher"
 	"crypto/sha256"
 	"fmt"
-	"sort"
 	"time"
 	"unsafe"
 
 	"github.com/gogo/protobuf/proto"
-	"golang.org/x/crypto/cryptobyte"
 
 	utilerrors "k8s.io/apimachinery/pkg/util/errors"
 	"k8s.io/apimachinery/pkg/util/uuid"
@@ -418,41 +416,7 @@ func getRequestInfoFromContext(ctx context.Context) *genericapirequest.RequestIn
 //     a. annotation key
 //     b. annotation value
 func generateCacheKey(encryptedDEKSourceType kmstypes.EncryptedDEKSourceType, encryptedDEKSource []byte, keyID string, annotations map[string][]byte) ([]byte, error) {
-	// TODO(aramase): use sync pool buffer to avoid allocations
-	b := cryptobyte.NewBuilder(nil)
-	b.AddUint32(uint32(encryptedDEKSourceType))
-	b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
-		b.AddBytes(encryptedDEKSource)
-	})
-	b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
-		b.AddBytes(toBytes(keyID))
-	})
-	if len(annotations) == 0 {
-		return b.Bytes()
-	}
-
-	// add the length of annotations to the cache key
-	b.AddUint32(uint32(len(annotations)))
-
-	// Sort the annotations by key.
-	keys := make([]string, 0, len(annotations))
-	for k := range annotations {
-		k := k
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	for _, k := range keys {
-		// The maximum size of annotations is annotationsMaxSize (32 kB) so we can safely
-		// assume that the length of the key and value will fit in a uint16.
-		b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
-			b.AddBytes(toBytes(k))
-		})
-		b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
-			b.AddBytes(annotations[k])
-		})
-	}
-
-	return b.Bytes()
+	panic("cryptobyte cipher not available")
 }
 
 // toBytes performs unholy acts to avoid allocations

diff --git a/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/secretbox/secretbox.go b/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/secretbox/secretbox.go
index 9aec8acd..d0a19c71 100644
--- a/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/secretbox/secretbox.go
+++ b/vendor/k8s.io/apiserver/pkg/storage/value/encrypt/secretbox/secretbox.go
@@ -19,10 +19,6 @@ package secretbox
 
 import (
 	"context"
-	"crypto/rand"
-	"fmt"
-
-	"golang.org/x/crypto/nacl/secretbox"
 
 	"k8s.io/apiserver/pkg/storage/value"
 )
@@ -43,28 +39,9 @@ func NewSecretboxTransformer(key [32]byte) value.Transformer {
 }
 
 func (t *secretboxTransformer) TransformFromStorage(ctx context.Context, data []byte, dataCtx value.Context) ([]byte, bool, error) {
-	if len(data) < (secretbox.Overhead + nonceSize) {
-		return nil, false, fmt.Errorf("the stored data was shorter than the required size")
-	}
-	var nonce [nonceSize]byte
-	copy(nonce[:], data[:nonceSize])
-	data = data[nonceSize:]
-	out := make([]byte, 0, len(data)-secretbox.Overhead)
-	result, ok := secretbox.Open(out, data, &nonce, &t.key)
-	if !ok {
-		return nil, false, fmt.Errorf("output array was not large enough for encryption")
-	}
-	return result, false, nil
+	panic("nacl cipher not available")
 }
 
 func (t *secretboxTransformer) TransformToStorage(ctx context.Context, data []byte, dataCtx value.Context) ([]byte, error) {
-	var nonce [nonceSize]byte
-	n, err := rand.Read(nonce[:])
-	if err != nil {
-		return nil, err
-	}
-	if n != nonceSize {
-		return nil, fmt.Errorf("unable to read sufficient random bytes")
-	}
-	return secretbox.Seal(nonce[:], data, &nonce, &t.key), nil
+	panic("nacl cipher not available")
 }

diff --git a/vendor/k8s.io/apiserver/pkg/server/config.go b/vendor/k8s.io/apiserver/pkg/server/config.go
index d678f52d..da4abbae 100644
--- a/vendor/k8s.io/apiserver/pkg/server/config.go
+++ b/vendor/k8s.io/apiserver/pkg/server/config.go
@@ -18,8 +18,6 @@ package server
 
 import (
 	"context"
-	"crypto/sha256"
-	"encoding/base32"
 	"fmt"
 	"net"
 	"net/http"
@@ -34,7 +32,6 @@ import (
 
 	jsonpatch "github.com/evanphx/json-patch"
 	"github.com/google/uuid"
-	"golang.org/x/crypto/cryptobyte"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -374,29 +371,7 @@ func NewConfig(codecs serializer.CodecFactory) *Config {
 	defaultHealthChecks := []healthz.HealthChecker{healthz.PingHealthz, healthz.LogHealthz}
 	var id string
 	if utilfeature.DefaultFeatureGate.Enabled(genericfeatures.APIServerIdentity) {
-		hostname, err := hostnameFunc()
-		if err != nil {
-			klog.Fatalf("error getting hostname for apiserver identity: %v", err)
-		}
-
-		// Since the hash needs to be unique across each kube-apiserver and aggregated apiservers,
-		// the hash used for the identity should include both the hostname and the identity value.
-		// TODO: receive the identity value as a parameter once the apiserver identity lease controller
-		// post start hook is moved to generic apiserver.
-		b := cryptobyte.NewBuilder(nil)
-		b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
-			b.AddBytes([]byte(hostname))
-		})
-		b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
-			b.AddBytes([]byte("kube-apiserver"))
-		})
-		hashData, err := b.Bytes()
-		if err != nil {
-			klog.Fatalf("error building hash data for apiserver identity: %v", err)
-		}
-
-		hash := sha256.Sum256(hashData)
-		id = "apiserver-" + strings.ToLower(base32.StdEncoding.WithPadding(base32.NoPadding).EncodeToString(hash[:16]))
+		panic("cryptobyte cipher not available")
 	}
 	lifecycleSignals := newLifecycleSignals()