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< 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< 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()