Open platform to collect and prioritize feedback
use http challenge instead of tls-sni (#244)
Guilherme Oenning38017a56f4bc
diff --git a/Gopkg.lock b/Gopkg.lockindex 40fffb45d..16fe711a3 100644--- a/Gopkg.lock+++ b/Gopkg.lock@@ -22,7 +22,11 @@[[projects]]branch = "master"name = "github.com/golang/freetype"- packages = [".","raster","truetype"]+ packages = [+ ".",+ "raster",+ "truetype"+ ]revision = "e2365dfdc4a05e4b8299a783240d4a7d5a65d4e4"[[projects]]@@ -46,18 +50,40 @@[[projects]]branch = "master"name = "github.com/lib/pq"- packages = [".","oid"]+ packages = [+ ".",+ "oid"+ ]revision = "23da1db4f16d9658a86ae9b717c245fc078f10f1"[[projects]]name = "github.com/mattes/migrate"- packages = [".","database","database/postgres","source","source/file"]+ packages = [+ ".",+ "database",+ "database/postgres",+ "source",+ "source/file"+ ]revision = "035c07716cd373d88456ec4d701402df52584cb4"version = "v3.0.1"[[projects]]name = "github.com/onsi/gomega"- packages = [".","format","internal/assertion","internal/asyncassertion","internal/oraclematcher","internal/testingtsupport","matchers","matchers/support/goraph/bipartitegraph","matchers/support/goraph/edge","matchers/support/goraph/node","matchers/support/goraph/util","types"]+ packages = [+ ".",+ "format",+ "internal/assertion",+ "internal/asyncassertion",+ "internal/oraclematcher",+ "internal/testingtsupport",+ "matchers",+ "matchers/support/goraph/bipartitegraph",+ "matchers/support/goraph/edge",+ "matchers/support/goraph/node",+ "matchers/support/goraph/util",+ "types"+ ]revision = "334b8f472b3af5d541c5642701c1e29e2126f486"version = "v1.1.0"@@ -70,30 +96,58 @@[[projects]]branch = "master"name = "golang.org/x/crypto"- packages = ["acme","acme/autocert"]- revision = "2509b142fb2b797aa7587dad548f113b2c0f20ce"+ packages = [+ "acme",+ "acme/autocert"+ ]+ revision = "13931e22f9e72ea58bb73048bc752b48c6d4d4ac"[[projects]]branch = "master"name = "golang.org/x/image"- packages = ["font","math/fixed"]+ packages = [+ "font",+ "math/fixed"+ ]revision = "e20db36d77bd0cb36cea8fe49d5c37d82d21591f"[[projects]]branch = "master"name = "golang.org/x/net"- packages = ["context","context/ctxhttp"]+ packages = [+ "context",+ "context/ctxhttp"+ ]revision = "8351a756f30f1297fe94bbf4b767ec589c6ea6d0"[[projects]]branch = "master"name = "golang.org/x/oauth2"- packages = [".","facebook","github","google","internal","jws","jwt"]+ packages = [+ ".",+ "facebook",+ "github",+ "google",+ "internal",+ "jws",+ "jwt"+ ]revision = "13449ad91cb26cb47661c1b080790392170385fd"[[projects]]name = "google.golang.org/appengine"- packages = [".","internal","internal/app_identity","internal/base","internal/datastore","internal/log","internal/modules","internal/remote_api","internal/urlfetch","urlfetch"]+ packages = [+ ".",+ "internal",+ "internal/app_identity",+ "internal/base",+ "internal/datastore",+ "internal/log",+ "internal/modules",+ "internal/remote_api",+ "internal/urlfetch",+ "urlfetch"+ ]revision = "150dc57a1b433e64154302bdc40b6bb8aefa313a"version = "v1.0.0"diff --git a/app/pkg/web/engine.go b/app/pkg/web/engine.goindex 80866d148..a9af3128a 100644--- a/app/pkg/web/engine.go+++ b/app/pkg/web/engine.go@@ -71,7 +71,9 @@ func (e *Engine) Start(address string) {server.TLSConfig = &tls.Config{GetCertificate: certManager.GetCertificate,}+e.logger.Infof("https (auto ssl) server started on %s", address)+ go certManager.StartHTTPServer()err = server.ListenAndServeTLS("", "")} else if certFile == "" && keyFile == "" {e.logger.Infof("http server started on %s", address)diff --git a/app/pkg/web/ssl.go b/app/pkg/web/ssl.goindex de9fe9bae..fd81b7787 100644--- a/app/pkg/web/ssl.go+++ b/app/pkg/web/ssl.go@@ -3,6 +3,7 @@ package webimport ("crypto/tls""crypto/x509"+ "net/http""golang.org/x/crypto/acme/autocert")@@ -50,3 +51,8 @@ func (m *CertificateManager) GetCertificate(hello *tls.ClientHelloInfo) (*tls.Ce}return m.autossl.GetCertificate(hello)}++//StartHTTPServer creates a new HTTP server on port 80 that is used for the ACME HTTP Challenge+func (m *CertificateManager) StartHTTPServer() {+ http.ListenAndServe(":80", m.autossl.HTTPHandler(nil))+}diff --git a/vendor/golang.org/x/crypto/acme/acme_test.go b/vendor/golang.org/x/crypto/acme/acme_test.goindex b44af5959..89f2efaa5 100644--- a/vendor/golang.org/x/crypto/acme/acme_test.go+++ b/vendor/golang.org/x/crypto/acme/acme_test.go@@ -946,7 +946,7 @@ func TestNonce_add(t *testing.T) {c.addNonce(http.Header{"Replay-Nonce": {}})c.addNonce(http.Header{"Replay-Nonce": {"nonce"}})- nonces := map[string]struct{}{"nonce": struct{}{}}+ nonces := map[string]struct{}{"nonce": {}}if !reflect.DeepEqual(c.nonces, nonces) {t.Errorf("c.nonces = %q; want %q", c.nonces, nonces)}diff --git a/vendor/golang.org/x/crypto/acme/autocert/autocert.go b/vendor/golang.org/x/crypto/acme/autocert/autocert.goindex 94edba986..453e72291 100644--- a/vendor/golang.org/x/crypto/acme/autocert/autocert.go+++ b/vendor/golang.org/x/crypto/acme/autocert/autocert.go@@ -24,7 +24,9 @@ import ("fmt""io"mathrand "math/rand"+ "net""net/http"+ "path""strconv""strings""sync"@@ -80,8 +82,9 @@ func defaultHostPolicy(context.Context, string) error {}// Manager is a stateful certificate manager built on top of acme.Client.-// It obtains and refreshes certificates automatically,-// as well as providing them to a TLS server via tls.Config.+// It obtains and refreshes certificates automatically using "tls-sni-01",+// "tls-sni-02" and "http-01" challenge types, as well as providing them+// to a TLS server via tls.Config.//// You must specify a cache implementation, such as DirCache,// to reuse obtained certificates across program restarts.@@ -150,15 +153,26 @@ type Manager struct {stateMu sync.Mutexstate map[string]*certState // keyed by domain name- // tokenCert is keyed by token domain name, which matches server name- // of ClientHello. Keys always have ".acme.invalid" suffix.- tokenCertMu sync.RWMutex- tokenCert map[string]*tls.Certificate-// renewal tracks the set of domains currently running renewal timers.// It is keyed by domain name.renewalMu sync.Mutexrenewal map[string]*domainRenewal++ // tokensMu guards the rest of the fields: tryHTTP01, certTokens and httpTokens.+ tokensMu sync.RWMutex+ // tryHTTP01 indicates whether the Manager should try "http-01" challenge type+ // during the authorization flow.+ tryHTTP01 bool+ // httpTokens contains response body values for http-01 challenges+ // and is keyed by the URL path at which a challenge response is expected+ // to be provisioned.+ // The entries are stored for the duration of the authorization flow.+ httpTokens map[string][]byte+ // certTokens contains temporary certificates for tls-sni challenges+ // and is keyed by token domain name, which matches server name of ClientHello.+ // Keys always have ".acme.invalid" suffix.+ // The entries are stored for the duration of the authorization flow.+ certTokens map[string]*tls.Certificate}// GetCertificate implements the tls.Config.GetCertificate hook.@@ -185,14 +199,16 @@ func (m *Manager) GetCertificate(hello *tls.ClientHelloInfo) (*tls.Certificate,return nil, errors.New("acme/autocert: server name contains invalid character")}+ // In the worst-case scenario, the timeout needs to account for caching, host policy,+ // domain ownership verification and certificate issuance.ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)defer cancel()// check whether this is a token cert requested for TLS-SNI challengeif strings.HasSuffix(name, ".acme.invalid") {- m.tokenCertMu.RLock()- defer m.tokenCertMu.RUnlock()- if cert := m.tokenCert[name]; cert != nil {+ m.tokensMu.RLock()+ defer m.tokensMu.RUnlock()+ if cert := m.certTokens[name]; cert != nil {return cert, nil}if cert, err := m.cacheGet(ctx, name); err == nil {@@ -224,6 +240,68 @@ func (m *Manager) GetCertificate(hello *tls.ClientHelloInfo) (*tls.Certificate,return cert, nil}+// HTTPHandler configures the Manager to provision ACME "http-01" challenge responses.+// It returns an http.Handler that responds to the challenges and must be+// running on port 80. If it receives a request that is not an ACME challenge,+// it delegates the request to the optional fallback handler.+//+// If fallback is nil, the returned handler redirects all GET and HEAD requests+// to the default TLS port 443 with 302 Found status code, preserving the original+// request path and query. It responds with 400 Bad Request to all other HTTP methods.+// The fallback is not protected by the optional HostPolicy.+//+// Because the fallback handler is run with unencrypted port 80 requests,+// the fallback should not serve TLS-only requests.+//+// If HTTPHandler is never called, the Manager will only use TLS SNI+// challenges for domain verification.+func (m *Manager) HTTPHandler(fallback http.Handler) http.Handler {+ m.tokensMu.Lock()+ defer m.tokensMu.Unlock()+ m.tryHTTP01 = true++ if fallback == nil {+ fallback = http.HandlerFunc(handleHTTPRedirect)+ }+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if !strings.HasPrefix(r.URL.Path, "/.well-known/acme-challenge/") {+ fallback.ServeHTTP(w, r)+ return+ }+ // A reasonable context timeout for cache and host policy only,+ // because we don't wait for a new certificate issuance here.+ ctx, cancel := context.WithTimeout(r.Context(), time.Minute)+ defer cancel()+ if err := m.hostPolicy()(ctx, r.Host); err != nil {+ http.Error(w, err.Error(), http.StatusForbidden)+ return+ }+ data, err := m.httpToken(ctx, r.URL.Path)+ if err != nil {+ http.Error(w, err.Error(), http.StatusNotFound)+ return+ }+ w.Write(data)+ })+}++func handleHTTPRedirect(w http.ResponseWriter, r *http.Request) {+ if r.Method != "GET" && r.Method != "HEAD" {+ http.Error(w, "Use HTTPS", http.StatusBadRequest)+ return+ }+ target := "https://" + stripPort(r.Host) + r.URL.RequestURI()+ http.Redirect(w, r, target, http.StatusFound)+}++func stripPort(hostport string) string {+ host, _, err := net.SplitHostPort(hostport)+ if err != nil {+ return hostport+ }+ return net.JoinHostPort(host, "443")+}+// cert returns an existing certificate either from m.state or cache.// If a certificate is found in cache but not in m.state, the latter will be filled// with the cached value.@@ -442,13 +520,14 @@ func (m *Manager) certState(domain string) (*certState, error) {// authorizedCert starts the domain ownership verification process and requests a new cert upon success.// The key argument is the certificate private key.func (m *Manager) authorizedCert(ctx context.Context, key crypto.Signer, domain string) (der [][]byte, leaf *x509.Certificate, err error) {- if err := m.verify(ctx, domain); err != nil {- return nil, nil, err- }client, err := m.acmeClient(ctx)if err != nil {return nil, nil, err}++ if err := m.verify(ctx, client, domain); err != nil {+ return nil, nil, err+ }csr, err := certRequest(key, domain)if err != nil {return nil, nil, err@@ -464,98 +543,171 @@ func (m *Manager) authorizedCert(ctx context.Context, key crypto.Signer, domainreturn der, leaf, nil}-// verify starts a new identifier (domain) authorization flow.-// It prepares a challenge response and then blocks until the authorization-// is marked as "completed" by the CA (either succeeded or failed).-//-// verify returns nil iff the verification was successful.-func (m *Manager) verify(ctx context.Context, domain string) error {- client, err := m.acmeClient(ctx)- if err != nil {- return err- }-- // start domain authorization and get the challenge- authz, err := client.Authorize(ctx, domain)- if err != nil {- return err- }- // maybe don't need to at all- if authz.Status == acme.StatusValid {- return nil- }+// verify runs the identifier (domain) authorization flow+// using each applicable ACME challenge type.+func (m *Manager) verify(ctx context.Context, client *acme.Client, domain string) error {+ // The list of challenge types we'll try to fulfill+ // in this specific order.+ challengeTypes := []string{"tls-sni-02", "tls-sni-01"}+ m.tokensMu.RLock()+ if m.tryHTTP01 {+ challengeTypes = append(challengeTypes, "http-01")+ }+ m.tokensMu.RUnlock()++ var nextTyp int // challengeType index of the next challenge type to try+ for {+ // Start domain authorization and get the challenge.+ authz, err := client.Authorize(ctx, domain)+ if err != nil {+ return err+ }+ // No point in accepting challenges if the authorization status+ // is in a final state.+ switch authz.Status {+ case acme.StatusValid:+ return nil // already authorized+ case acme.StatusInvalid:+ return fmt.Errorf("acme/autocert: invalid authorization %q", authz.URI)+ }- // pick a challenge: prefer tls-sni-02 over tls-sni-01- // TODO: consider authz.Combinations- var chal *acme.Challenge- for _, c := range authz.Challenges {- if c.Type == "tls-sni-02" {- chal = c- break+ // Pick the next preferred challenge.+ var chal *acme.Challenge+ for chal == nil && nextTyp < len(challengeTypes) {+ chal = pickChallenge(challengeTypes[nextTyp], authz.Challenges)+ nextTyp++}- if c.Type == "tls-sni-01" {- chal = c+ if chal == nil {+ return fmt.Errorf("acme/autocert: unable to authorize %q; tried %q", domain, challengeTypes)+ }+ cleanup, err := m.fulfill(ctx, client, chal)+ if err != nil {+ continue+ }+ defer cleanup()+ if _, err := client.Accept(ctx, chal); err != nil {+ continue+ }++ // A challenge is fulfilled and accepted: wait for the CA to validate.+ if _, err := client.WaitAuthorization(ctx, authz.URI); err == nil {+ return nil}}- if chal == nil {- return errors.New("acme/autocert: no supported challenge type found")- }+}- // create a token cert for the challenge response- var (- cert tls.Certificate- name string- )+// fulfill provisions a response to the challenge chal.+// The cleanup is non-nil only if provisioning succeeded.+func (m *Manager) fulfill(ctx context.Context, client *acme.Client, chal *acme.Challenge) (cleanup func(), err error) {switch chal.Type {case "tls-sni-01":- cert, name, err = client.TLSSNI01ChallengeCert(chal.Token)+ cert, name, err := client.TLSSNI01ChallengeCert(chal.Token)+ if err != nil {+ return nil, err+ }+ m.putCertToken(ctx, name, &cert)+ return func() { go m.deleteCertToken(name) }, nilcase "tls-sni-02":- cert, name, err = client.TLSSNI02ChallengeCert(chal.Token)- default:- err = fmt.Errorf("acme/autocert: unknown challenge type %q", chal.Type)- }- if err != nil {- return err+ cert, name, err := client.TLSSNI02ChallengeCert(chal.Token)+ if err != nil {+ return nil, err+ }+ m.putCertToken(ctx, name, &cert)+ return func() { go m.deleteCertToken(name) }, nil+ case "http-01":+ resp, err := client.HTTP01ChallengeResponse(chal.Token)+ if err != nil {+ return nil, err+ }+ p := client.HTTP01ChallengePath(chal.Token)+ m.putHTTPToken(ctx, p, resp)+ return func() { go m.deleteHTTPToken(p) }, nil}- m.putTokenCert(ctx, name, &cert)- defer func() {- // verification has ended at this point- // don't need token cert anymore- go m.deleteTokenCert(name)- }()+ return nil, fmt.Errorf("acme/autocert: unknown challenge type %q", chal.Type)+}- // ready to fulfill the challenge- if _, err := client.Accept(ctx, chal); err != nil {- return err+func pickChallenge(typ string, chal []*acme.Challenge) *acme.Challenge {+ for _, c := range chal {+ if c.Type == typ {+ return c+ }}- // wait for the CA to validate- _, err = client.WaitAuthorization(ctx, authz.URI)- return err+ return nil}-// putTokenCert stores the cert under the named key in both m.tokenCert map+// putCertToken stores the cert under the named key in both m.certTokens map// and m.Cache.-func (m *Manager) putTokenCert(ctx context.Context, name string, cert *tls.Certificate) {- m.tokenCertMu.Lock()- defer m.tokenCertMu.Unlock()- if m.tokenCert == nil {- m.tokenCert = make(map[string]*tls.Certificate)+func (m *Manager) putCertToken(ctx context.Context, name string, cert *tls.Certificate) {+ m.tokensMu.Lock()+ defer m.tokensMu.Unlock()+ if m.certTokens == nil {+ m.certTokens = make(map[string]*tls.Certificate)}- m.tokenCert[name] = cert+ m.certTokens[name] = certm.cachePut(ctx, name, cert)}-// deleteTokenCert removes the token certificate for the specified domain name-// from both m.tokenCert map and m.Cache.-func (m *Manager) deleteTokenCert(name string) {- m.tokenCertMu.Lock()- defer m.tokenCertMu.Unlock()- delete(m.tokenCert, name)+// deleteCertToken removes the token certificate for the specified domain name+// from both m.certTokens map and m.Cache.+func (m *Manager) deleteCertToken(name string) {+ m.tokensMu.Lock()+ defer m.tokensMu.Unlock()+ delete(m.certTokens, name)if m.Cache != nil {m.Cache.Delete(context.Background(), name)}}+// httpToken retrieves an existing http-01 token value from an in-memory map+// or the optional cache.+func (m *Manager) httpToken(ctx context.Context, tokenPath string) ([]byte, error) {+ m.tokensMu.RLock()+ defer m.tokensMu.RUnlock()+ if v, ok := m.httpTokens[tokenPath]; ok {+ return v, nil+ }+ if m.Cache == nil {+ return nil, fmt.Errorf("acme/autocert: no token at %q", tokenPath)+ }+ return m.Cache.Get(ctx, httpTokenCacheKey(tokenPath))+}++// putHTTPToken stores an http-01 token value using tokenPath as key+// in both in-memory map and the optional Cache.+//+// It ignores any error returned from Cache.Put.+func (m *Manager) putHTTPToken(ctx context.Context, tokenPath, val string) {+ m.tokensMu.Lock()+ defer m.tokensMu.Unlock()+ if m.httpTokens == nil {+ m.httpTokens = make(map[string][]byte)+ }+ b := []byte(val)+ m.httpTokens[tokenPath] = b+ if m.Cache != nil {+ m.Cache.Put(ctx, httpTokenCacheKey(tokenPath), b)+ }+}++// deleteHTTPToken removes an http-01 token value from both in-memory map+// and the optional Cache, ignoring any error returned from the latter.+//+// If m.Cache is non-nil, it blocks until Cache.Delete returns without a timeout.+func (m *Manager) deleteHTTPToken(tokenPath string) {+ m.tokensMu.Lock()+ defer m.tokensMu.Unlock()+ delete(m.httpTokens, tokenPath)+ if m.Cache != nil {+ m.Cache.Delete(context.Background(), httpTokenCacheKey(tokenPath))+ }+}++// httpTokenCacheKey returns a key at which an http-01 token value may be stored+// in the Manager's optional Cache.+func httpTokenCacheKey(tokenPath string) string {+ return "http-01-" + path.Base(tokenPath)+}+// renew starts a cert renewal timer loop, one per domain.//// The loop is scheduled in two cases:diff --git a/vendor/golang.org/x/crypto/acme/autocert/autocert_test.go b/vendor/golang.org/x/crypto/acme/autocert/autocert_test.goindex 43a62011a..2da1912e9 100644--- a/vendor/golang.org/x/crypto/acme/autocert/autocert_test.go+++ b/vendor/golang.org/x/crypto/acme/autocert/autocert_test.go@@ -23,6 +23,7 @@ import ("net/http""net/http/httptest""reflect"+ "strings""sync""testing""time"@@ -48,6 +49,16 @@ var authzTmpl = template.Must(template.New("authz").Parse(`{"uri": "{{.}}/challenge/2","type": "tls-sni-02","token": "token-02"+ },+ {+ "uri": "{{.}}/challenge/dns-01",+ "type": "dns-01",+ "token": "token-dns-01"+ },+ {+ "uri": "{{.}}/challenge/http-01",+ "type": "http-01",+ "token": "token-http-01"}]}`))@@ -419,6 +430,146 @@ func testGetCertificate(t *testing.T, man *Manager, domain string, hello *tls.Cl}+func TestVerifyHTTP01(t *testing.T) {+ var (+ http01 http.Handler++ authzCount int // num. of created authorizations+ didAcceptHTTP01 bool+ )++ verifyHTTPToken := func() {+ r := httptest.NewRequest("GET", "/.well-known/acme-challenge/token-http-01", nil)+ w := httptest.NewRecorder()+ http01.ServeHTTP(w, r)+ if w.Code != http.StatusOK {+ t.Errorf("http token: w.Code = %d; want %d", w.Code, http.StatusOK)+ }+ if v := string(w.Body.Bytes()); !strings.HasPrefix(v, "token-http-01.") {+ t.Errorf("http token value = %q; want 'token-http-01.' prefix", v)+ }+ }++ // ACME CA server stub, only the needed bits.+ // TODO: Merge this with startACMEServerStub, making it a configurable CA for testing.+ var ca *httptest.Server+ ca = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Replay-Nonce", "nonce")+ if r.Method == "HEAD" {+ // a nonce request+ return+ }++ switch r.URL.Path {+ // Discovery.+ case "/":+ if err := discoTmpl.Execute(w, ca.URL); err != nil {+ t.Errorf("discoTmpl: %v", err)+ }+ // Client key registration.+ case "/new-reg":+ w.Write([]byte("{}"))+ // New domain authorization.+ case "/new-authz":+ authzCount+++ w.Header().Set("Location", fmt.Sprintf("%s/authz/%d", ca.URL, authzCount))+ w.WriteHeader(http.StatusCreated)+ if err := authzTmpl.Execute(w, ca.URL); err != nil {+ t.Errorf("authzTmpl: %v", err)+ }+ // Accept tls-sni-02.+ case "/challenge/2":+ w.Write([]byte("{}"))+ // Reject tls-sni-01.+ case "/challenge/1":+ http.Error(w, "won't accept tls-sni-01", http.StatusBadRequest)+ // Should not accept dns-01.+ case "/challenge/dns-01":+ t.Errorf("dns-01 challenge was accepted")+ http.Error(w, "won't accept dns-01", http.StatusBadRequest)+ // Accept http-01.+ case "/challenge/http-01":+ didAcceptHTTP01 = true+ verifyHTTPToken()+ w.Write([]byte("{}"))+ // Authorization statuses.+ // Make tls-sni-xxx invalid.+ case "/authz/1", "/authz/2":+ w.Write([]byte(`{"status": "invalid"}`))+ case "/authz/3", "/authz/4":+ w.Write([]byte(`{"status": "valid"}`))+ default:+ http.NotFound(w, r)+ t.Errorf("unrecognized r.URL.Path: %s", r.URL.Path)+ }+ }))+ defer ca.Close()++ key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)+ if err != nil {+ t.Fatal(err)+ }+ m := &Manager{+ Client: &acme.Client{+ Key: key,+ DirectoryURL: ca.URL,+ },+ }+ http01 = m.HTTPHandler(nil)+ if err := m.verify(context.Background(), m.Client, "example.org"); err != nil {+ t.Errorf("m.verify: %v", err)+ }+ // Only tls-sni-01, tls-sni-02 and http-01 must be accepted+ // The dns-01 challenge is unsupported.+ if authzCount != 3 {+ t.Errorf("authzCount = %d; want 3", authzCount)+ }+ if !didAcceptHTTP01 {+ t.Error("did not accept http-01 challenge")+ }+}++func TestHTTPHandlerDefaultFallback(t *testing.T) {+ tt := []struct {+ method, url string+ wantCode int+ wantLocation string+ }{+ {"GET", "http://example.org", 302, "https://example.org/"},+ {"GET", "http://example.org/foo", 302, "https://example.org/foo"},+ {"GET", "http://example.org/foo/bar/", 302, "https://example.org/foo/bar/"},+ {"GET", "http://example.org/?a=b", 302, "https://example.org/?a=b"},+ {"GET", "http://example.org/foo?a=b", 302, "https://example.org/foo?a=b"},+ {"GET", "http://example.org:80/foo?a=b", 302, "https://example.org:443/foo?a=b"},+ {"GET", "http://example.org:80/foo%20bar", 302, "https://example.org:443/foo%20bar"},+ {"GET", "http://[2602:d1:xxxx::c60a]:1234", 302, "https://[2602:d1:xxxx::c60a]:443/"},+ {"GET", "http://[2602:d1:xxxx::c60a]", 302, "https://[2602:d1:xxxx::c60a]/"},+ {"GET", "http://[2602:d1:xxxx::c60a]/foo?a=b", 302, "https://[2602:d1:xxxx::c60a]/foo?a=b"},+ {"HEAD", "http://example.org", 302, "https://example.org/"},+ {"HEAD", "http://example.org/foo", 302, "https://example.org/foo"},+ {"HEAD", "http://example.org/foo/bar/", 302, "https://example.org/foo/bar/"},+ {"HEAD", "http://example.org/?a=b", 302, "https://example.org/?a=b"},+ {"HEAD", "http://example.org/foo?a=b", 302, "https://example.org/foo?a=b"},+ {"POST", "http://example.org", 400, ""},+ {"PUT", "http://example.org", 400, ""},+ {"GET", "http://example.org/.well-known/acme-challenge/x", 404, ""},+ }+ var m Manager+ h := m.HTTPHandler(nil)+ for i, test := range tt {+ r := httptest.NewRequest(test.method, test.url, nil)+ w := httptest.NewRecorder()+ h.ServeHTTP(w, r)+ if w.Code != test.wantCode {+ t.Errorf("%d: w.Code = %d; want %d", i, w.Code, test.wantCode)+ t.Errorf("%d: body: %s", i, w.Body.Bytes())+ }+ if v := w.Header().Get("Location"); v != test.wantLocation {+ t.Errorf("%d: Location = %q; want %q", i, v, test.wantLocation)+ }+ }+}+func TestAccountKeyCache(t *testing.T) {m := Manager{Cache: newMemCache()}ctx := context.Background()diff --git a/vendor/golang.org/x/crypto/acme/autocert/example_test.go b/vendor/golang.org/x/crypto/acme/autocert/example_test.goindex 71d61eb1c..552a62549 100644--- a/vendor/golang.org/x/crypto/acme/autocert/example_test.go+++ b/vendor/golang.org/x/crypto/acme/autocert/example_test.go@@ -22,11 +22,12 @@ func ExampleNewListener() {}func ExampleManager() {- m := autocert.Manager{+ m := &autocert.Manager{Cache: autocert.DirCache("secret-dir"),Prompt: autocert.AcceptTOS,HostPolicy: autocert.HostWhitelist("example.org"),}+ go http.ListenAndServe(":http", m.HTTPHandler(nil))s := &http.Server{Addr: ":https",TLSConfig: &tls.Config{GetCertificate: m.GetCertificate},diff --git a/vendor/golang.org/x/crypto/argon2/argon2.go b/vendor/golang.org/x/crypto/argon2/argon2.gonew file mode 100644index 000000000..71cf8c556--- /dev/null+++ b/vendor/golang.org/x/crypto/argon2/argon2.go@@ -0,0 +1,228 @@+// Copyright 2017 The Go Authors. All rights reserved.+// Use of this source code is governed by a BSD-style+// license that can be found in the LICENSE file.++// Package argon2 implements the key derivation function Argon2.+// Argon2 was selected as the winner of the Password Hashing Competition and can+// be used to derive cryptographic keys from passwords.+// Argon2 is specfifed at https://github.com/P-H-C/phc-winner-argon2/blob/master/argon2-specs.pdf+package argon2++import (+ "encoding/binary"+ "sync"++ "golang.org/x/crypto/blake2b"+)++// The Argon2 version implemented by this package.+const Version = 0x13++const (+ argon2d = iota+ argon2i+ argon2id+)++// Key derives a key from the password, salt, and cost parameters using Argon2i+// returning a byte slice of length keyLen that can be used as cryptographic key.+// The CPU cost and parallism degree must be greater than zero.+//+// For example, you can get a derived key for e.g. AES-256 (which needs a 32-byte key) by doing:+// `key := argon2.Key([]byte("some password"), salt, 4, 32*1024, 4, 32)`+//+// The recommended parameters for interactive logins as of 2017 are time=4, memory=32*1024.+// The number of threads can be adjusted to the numbers of available CPUs.+// The time parameter specifies the number of passes over the memory and the memory+// parameter specifies the size of the memory in KiB. For example memory=32*1024 sets the+// memory cost to ~32 MB.+// The cost parameters should be increased as memory latency and CPU parallelism increases.+// Remember to get a good random salt.+func Key(password, salt []byte, time, memory uint32, threads uint8, keyLen uint32) []byte {+ return deriveKey(argon2i, password, salt, nil, nil, time, memory, threads, keyLen)+}++func deriveKey(mode int, password, salt, secret, data []byte, time, memory uint32, threads uint8, keyLen uint32) []byte {+ if time < 1 {+ panic("argon2: number of rounds too small")+ }+ if threads < 1 {+ panic("argon2: parallelism degree too low")+ }+ h0 := initHash(password, salt, secret, data, time, memory, uint32(threads), keyLen, mode)++ memory = memory / (syncPoints * uint32(threads)) * (syncPoints * uint32(threads))+ if memory < 2*syncPoints*uint32(threads) {+ memory = 2 * syncPoints * uint32(threads)+ }+ B := initBlocks(&h0, memory, uint32(threads))+ processBlocks(B, time, memory, uint32(threads), mode)+ return extractKey(B, memory, uint32(threads), keyLen)+}++const (+ blockLength = 128+ syncPoints = 4+)++type block [blockLength]uint64++func initHash(password, salt, key, data []byte, time, memory, threads, keyLen uint32, mode int) [blake2b.Size + 8]byte {+ var (+ h0 [blake2b.Size + 8]byte+ params [24]byte+ tmp [4]byte+ )++ b2, _ := blake2b.New512(nil)+ binary.LittleEndian.PutUint32(params[0:4], threads)+ binary.LittleEndian.PutUint32(params[4:8], keyLen)+ binary.LittleEndian.PutUint32(params[8:12], memory)+ binary.LittleEndian.PutUint32(params[12:16], time)+ binary.LittleEndian.PutUint32(params[16:20], uint32(Version))+ binary.LittleEndian.PutUint32(params[20:24], uint32(mode))+ b2.Write(params[:])+ binary.LittleEndian.PutUint32(tmp[:], uint32(len(password)))+ b2.Write(tmp[:])+ b2.Write(password)+ binary.LittleEndian.PutUint32(tmp[:], uint32(len(salt)))+ b2.Write(tmp[:])+ b2.Write(salt)+ binary.LittleEndian.PutUint32(tmp[:], uint32(len(key)))+ b2.Write(tmp[:])+ b2.Write(key)+ binary.LittleEndian.PutUint32(tmp[:], uint32(len(data)))+ b2.Write(tmp[:])+ b2.Write(data)+ b2.Sum(h0[:0])+ return h0+}++func initBlocks(h0 *[blake2b.Size + 8]byte, memory, threads uint32) []block {+ var block0 [1024]byte+ B := make([]block, memory)+ for lane := uint32(0); lane < threads; lane++ {+ j := lane * (memory / threads)+ binary.LittleEndian.PutUint32(h0[blake2b.Size+4:], lane)++ binary.LittleEndian.PutUint32(h0[blake2b.Size:], 0)+ blake2bHash(block0[:], h0[:])+ for i := range B[j+0] {+ B[j+0][i] = binary.LittleEndian.Uint64(block0[i*8:])+ }++ binary.LittleEndian.PutUint32(h0[blake2b.Size:], 1)+ blake2bHash(block0[:], h0[:])+ for i := range B[j+1] {+ B[j+1][i] = binary.LittleEndian.Uint64(block0[i*8:])+ }+ }+ return B+}++func processBlocks(B []block, time, memory, threads uint32, mode int) {+ lanes := memory / threads+ segments := lanes / syncPoints++ processSegment := func(n, slice, lane uint32, wg *sync.WaitGroup) {+ var addresses, in, zero block+ if mode == argon2i || (mode == argon2id && n == 0 && slice < syncPoints/2) {+ in[0] = uint64(n)+ in[1] = uint64(lane)+ in[2] = uint64(slice)+ in[3] = uint64(memory)+ in[4] = uint64(time)+ in[5] = uint64(mode)+ }++ index := uint32(0)+ if n == 0 && slice == 0 {+ index = 2 // we have already generated the first two blocks+ if mode == argon2i || mode == argon2id {+ in[6]+++ processBlock(&addresses, &in, &zero)+ processBlock(&addresses, &addresses, &zero)+ }+ }++ offset := lane*lanes + slice*segments + index+ var random uint64+ for index < segments {+ prev := offset - 1+ if index == 0 && slice == 0 {+ prev += lanes // last block in lane+ }+ if mode == argon2i || (mode == argon2id && n == 0 && slice < syncPoints/2) {+ if index%blockLength == 0 {+ in[6]+++ processBlock(&addresses, &in, &zero)+ processBlock(&addresses, &addresses, &zero)+ }+ random = addresses[index%blockLength]+ } else {+ random = B[prev][0]+ }+ newOffset := indexAlpha(random, lanes, segments, threads, n, slice, lane, index)+ processBlockXOR(&B[offset], &B[prev], &B[newOffset])+ index, offset = index+1, offset+1+ }+ wg.Done()+ }++ for n := uint32(0); n < time; n++ {+ for slice := uint32(0); slice < syncPoints; slice++ {+ var wg sync.WaitGroup+ for lane := uint32(0); lane < threads; lane++ {+ wg.Add(1)+ go processSegment(n, slice, lane, &wg)+ }+ wg.Wait()+ }+ }++}++func extractKey(B []block, memory, threads, keyLen uint32) []byte {+ lanes := memory / threads+ for lane := uint32(0); lane < threads-1; lane++ {+ for i, v := range B[(lane*lanes)+lanes-1] {+ B[memory-1][i] ^= v+ }+ }++ var block [1024]byte+ for i, v := range B[memory-1] {+ binary.LittleEndian.PutUint64(block[i*8:], v)+ }+ key := make([]byte, keyLen)+ blake2bHash(key, block[:])+ return key+}++func indexAlpha(rand uint64, lanes, segments, threads, n, slice, lane, index uint32) uint32 {+ refLane := uint32(rand>>32) % threads+ if n == 0 && slice == 0 {+ refLane = lane+ }+ m, s := 3*segments, ((slice+1)%syncPoints)*segments+ if lane == refLane {+ m += index+ }+ if n == 0 {+ m, s = slice*segments, 0+ if slice == 0 || lane == refLane {+ m += index+ }+ }+ if index == 0 || lane == refLane {+ m--+ }+ return phi(rand, uint64(m), uint64(s), refLane, lanes)+}++func phi(rand, m, s uint64, lane, lanes uint32) uint32 {+ p := rand & 0xFFFFFFFF+ p = (p * p) >> 32+ p = (p * m) >> 32+ return lane*lanes + uint32((s+m-(p+1))%uint64(lanes))+}diff --git a/vendor/golang.org/x/crypto/argon2/argon2_test.go b/vendor/golang.org/x/crypto/argon2/argon2_test.gonew file mode 100644index 000000000..775b97a40--- /dev/null+++ b/vendor/golang.org/x/crypto/argon2/argon2_test.go@@ -0,0 +1,233 @@+// Copyright 2017 The Go Authors. All rights reserved.+// Use of this source code is governed by a BSD-style+// license that can be found in the LICENSE file.++package argon2++import (+ "bytes"+ "encoding/hex"+ "testing"+)++var (+ genKatPassword = []byte{+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,+ }+ genKatSalt = []byte{0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}+ genKatSecret = []byte{0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03}+ genKatAAD = []byte{0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04}+)++func TestArgon2(t *testing.T) {+ defer func(sse4 bool) { useSSE4 = sse4 }(useSSE4)++ if useSSE4 {+ t.Log("SSE4.1 version")+ testArgon2i(t)+ testArgon2d(t)+ testArgon2id(t)+ useSSE4 = false+ }+ t.Log("generic version")+ testArgon2i(t)+ testArgon2d(t)+ testArgon2id(t)+}++func testArgon2d(t *testing.T) {+ want := []byte{+ 0x51, 0x2b, 0x39, 0x1b, 0x6f, 0x11, 0x62, 0x97,+ 0x53, 0x71, 0xd3, 0x09, 0x19, 0x73, 0x42, 0x94,+ 0xf8, 0x68, 0xe3, 0xbe, 0x39, 0x84, 0xf3, 0xc1,+ 0xa1, 0x3a, 0x4d, 0xb9, 0xfa, 0xbe, 0x4a, 0xcb,+ }+ hash := deriveKey(argon2d, genKatPassword, genKatSalt, genKatSecret, genKatAAD, 3, 32, 4, 32)+ if !bytes.Equal(hash, want) {+ t.Errorf("derived key does not match - got: %s , want: %s", hex.EncodeToString(hash), hex.EncodeToString(want))+ }+}++func testArgon2i(t *testing.T) {+ want := []byte{+ 0xc8, 0x14, 0xd9, 0xd1, 0xdc, 0x7f, 0x37, 0xaa,+ 0x13, 0xf0, 0xd7, 0x7f, 0x24, 0x94, 0xbd, 0xa1,+ 0xc8, 0xde, 0x6b, 0x01, 0x6d, 0xd3, 0x88, 0xd2,+ 0x99, 0x52, 0xa4, 0xc4, 0x67, 0x2b, 0x6c, 0xe8,+ }+ hash := deriveKey(argon2i, genKatPassword, genKatSalt, genKatSecret, genKatAAD, 3, 32, 4, 32)+ if !bytes.Equal(hash, want) {+ t.Errorf("derived key does not match - got: %s , want: %s", hex.EncodeToString(hash), hex.EncodeToString(want))+ }+}++func testArgon2id(t *testing.T) {+ want := []byte{+ 0x0d, 0x64, 0x0d, 0xf5, 0x8d, 0x78, 0x76, 0x6c,+ 0x08, 0xc0, 0x37, 0xa3, 0x4a, 0x8b, 0x53, 0xc9,+ 0xd0, 0x1e, 0xf0, 0x45, 0x2d, 0x75, 0xb6, 0x5e,+ 0xb5, 0x25, 0x20, 0xe9, 0x6b, 0x01, 0xe6, 0x59,+ }+ hash := deriveKey(argon2id, genKatPassword, genKatSalt, genKatSecret, genKatAAD, 3, 32, 4, 32)+ if !bytes.Equal(hash, want) {+ t.Errorf("derived key does not match - got: %s , want: %s", hex.EncodeToString(hash), hex.EncodeToString(want))+ }+}++func TestVectors(t *testing.T) {+ password, salt := []byte("password"), []byte("somesalt")+ for i, v := range testVectors {+ want, err := hex.DecodeString(v.hash)+ if err != nil {+ t.Fatalf("Test %d: failed to decode hash: %v", i, err)+ }+ hash := deriveKey(v.mode, password, salt, nil, nil, v.time, v.memory, v.threads, uint32(len(want)))+ if !bytes.Equal(hash, want) {+ t.Errorf("Test %d - got: %s want: %s", i, hex.EncodeToString(hash), hex.EncodeToString(want))+ }+ }+}++func benchmarkArgon2(mode int, time, memory uint32, threads uint8, keyLen uint32, b *testing.B) {+ password := []byte("password")+ salt := []byte("choosing random salts is hard")+ b.ReportAllocs()+ for i := 0; i < b.N; i++ {+ deriveKey(mode, password, salt, nil, nil, time, memory, threads, keyLen)+ }+}++func BenchmarkArgon2i(b *testing.B) {+ b.Run(" Time: 3 Memory: 32 MB, Threads: 1", func(b *testing.B) { benchmarkArgon2(argon2i, 3, 32*1024, 1, 32, b) })+ b.Run(" Time: 4 Memory: 32 MB, Threads: 1", func(b *testing.B) { benchmarkArgon2(argon2i, 4, 32*1024, 1, 32, b) })+ b.Run(" Time: 5 Memory: 32 MB, Threads: 1", func(b *testing.B) { benchmarkArgon2(argon2i, 5, 32*1024, 1, 32, b) })+ b.Run(" Time: 3 Memory: 64 MB, Threads: 4", func(b *testing.B) { benchmarkArgon2(argon2i, 3, 64*1024, 4, 32, b) })+ b.Run(" Time: 4 Memory: 64 MB, Threads: 4", func(b *testing.B) { benchmarkArgon2(argon2i, 4, 64*1024, 4, 32, b) })+ b.Run(" Time: 5 Memory: 64 MB, Threads: 4", func(b *testing.B) { benchmarkArgon2(argon2i, 5, 64*1024, 4, 32, b) })+}++func BenchmarkArgon2d(b *testing.B) {+ b.Run(" Time: 3, Memory: 32 MB, Threads: 1", func(b *testing.B) { benchmarkArgon2(argon2d, 3, 32*1024, 1, 32, b) })+ b.Run(" Time: 4, Memory: 32 MB, Threads: 1", func(b *testing.B) { benchmarkArgon2(argon2d, 4, 32*1024, 1, 32, b) })+ b.Run(" Time: 5, Memory: 32 MB, Threads: 1", func(b *testing.B) { benchmarkArgon2(argon2d, 5, 32*1024, 1, 32, b) })+ b.Run(" Time: 3, Memory: 64 MB, Threads: 4", func(b *testing.B) { benchmarkArgon2(argon2d, 3, 64*1024, 4, 32, b) })+ b.Run(" Time: 4, Memory: 64 MB, Threads: 4", func(b *testing.B) { benchmarkArgon2(argon2d, 4, 64*1024, 4, 32, b) })+ b.Run(" Time: 5, Memory: 64 MB, Threads: 4", func(b *testing.B) { benchmarkArgon2(argon2d, 5, 64*1024, 4, 32, b) })+}++func BenchmarkArgon2id(b *testing.B) {+ b.Run(" Time: 3, Memory: 32 MB, Threads: 1", func(b *testing.B) { benchmarkArgon2(argon2id, 3, 32*1024, 1, 32, b) })+ b.Run(" Time: 4, Memory: 32 MB, Threads: 1", func(b *testing.B) { benchmarkArgon2(argon2id, 4, 32*1024, 1, 32, b) })+ b.Run(" Time: 5, Memory: 32 MB, Threads: 1", func(b *testing.B) { benchmarkArgon2(argon2id, 5, 32*1024, 1, 32, b) })+ b.Run(" Time: 3, Memory: 64 MB, Threads: 4", func(b *testing.B) { benchmarkArgon2(argon2id, 3, 64*1024, 4, 32, b) })+ b.Run(" Time: 4, Memory: 64 MB, Threads: 4", func(b *testing.B) { benchmarkArgon2(argon2id, 4, 64*1024, 4, 32, b) })+ b.Run(" Time: 5, Memory: 64 MB, Threads: 4", func(b *testing.B) { benchmarkArgon2(argon2id, 5, 64*1024, 4, 32, b) })+}++// Generated with the CLI of https://github.com/P-H-C/phc-winner-argon2/blob/master/argon2-specs.pdf+var testVectors = []struct {+ mode int+ time, memory uint32+ threads uint8+ hash string+}{+ {+ mode: argon2i, time: 1, memory: 64, threads: 1,+ hash: "b9c401d1844a67d50eae3967dc28870b22e508092e861a37",+ },+ {+ mode: argon2d, time: 1, memory: 64, threads: 1,+ hash: "8727405fd07c32c78d64f547f24150d3f2e703a89f981a19",+ },+ {+ mode: argon2id, time: 1, memory: 64, threads: 1,+ hash: "655ad15eac652dc59f7170a7332bf49b8469be1fdb9c28bb",+ },+ {+ mode: argon2i, time: 2, memory: 64, threads: 1,+ hash: "8cf3d8f76a6617afe35fac48eb0b7433a9a670ca4a07ed64",+ },+ {+ mode: argon2d, time: 2, memory: 64, threads: 1,+ hash: "3be9ec79a69b75d3752acb59a1fbb8b295a46529c48fbb75",+ },+ {+ mode: argon2id, time: 2, memory: 64, threads: 1,+ hash: "068d62b26455936aa6ebe60060b0a65870dbfa3ddf8d41f7",+ },+ {+ mode: argon2i, time: 2, memory: 64, threads: 2,+ hash: "2089f3e78a799720f80af806553128f29b132cafe40d059f",+ },+ {+ mode: argon2d, time: 2, memory: 64, threads: 2,+ hash: "68e2462c98b8bc6bb60ec68db418ae2c9ed24fc6748a40e9",+ },+ {+ mode: argon2id, time: 2, memory: 64, threads: 2,+ hash: "350ac37222f436ccb5c0972f1ebd3bf6b958bf2071841362",+ },+ {+ mode: argon2i, time: 3, memory: 256, threads: 2,+ hash: "f5bbf5d4c3836af13193053155b73ec7476a6a2eb93fd5e6",+ },+ {+ mode: argon2d, time: 3, memory: 256, threads: 2,+ hash: "f4f0669218eaf3641f39cc97efb915721102f4b128211ef2",+ },+ {+ mode: argon2id, time: 3, memory: 256, threads: 2,+ hash: "4668d30ac4187e6878eedeacf0fd83c5a0a30db2cc16ef0b",+ },+ {+ mode: argon2i, time: 4, memory: 4096, threads: 4,+ hash: "a11f7b7f3f93f02ad4bddb59ab62d121e278369288a0d0e7",+ },+ {+ mode: argon2d, time: 4, memory: 4096, threads: 4,+ hash: "935598181aa8dc2b720914aa6435ac8d3e3a4210c5b0fb2d",+ },+ {+ mode: argon2id, time: 4, memory: 4096, threads: 4,+ hash: "145db9733a9f4ee43edf33c509be96b934d505a4efb33c5a",+ },+ {+ mode: argon2i, time: 4, memory: 1024, threads: 8,+ hash: "0cdd3956aa35e6b475a7b0c63488822f774f15b43f6e6e17",+ },+ {+ mode: argon2d, time: 4, memory: 1024, threads: 8,+ hash: "83604fc2ad0589b9d055578f4d3cc55bc616df3578a896e9",+ },+ {+ mode: argon2id, time: 4, memory: 1024, threads: 8,+ hash: "8dafa8e004f8ea96bf7c0f93eecf67a6047476143d15577f",+ },+ {+ mode: argon2i, time: 2, memory: 64, threads: 3,+ hash: "5cab452fe6b8479c8661def8cd703b611a3905a6d5477fe6",+ },+ {+ mode: argon2d, time: 2, memory: 64, threads: 3,+ hash: "22474a423bda2ccd36ec9afd5119e5c8949798cadf659f51",+ },+ {+ mode: argon2id, time: 2, memory: 64, threads: 3,+ hash: "4a15b31aec7c2590b87d1f520be7d96f56658172deaa3079",+ },+ {+ mode: argon2i, time: 3, memory: 1024, threads: 6,+ hash: "d236b29c2b2a09babee842b0dec6aa1e83ccbdea8023dced",+ },+ {+ mode: argon2d, time: 3, memory: 1024, threads: 6,+ hash: "a3351b0319a53229152023d9206902f4ef59661cdca89481",+ },+ {+ mode: argon2id, time: 3, memory: 1024, threads: 6,+ hash: "1640b932f4b60e272f5d2207b9a9c626ffa1bd88d2349016",+ },+}diff --git a/vendor/golang.org/x/crypto/argon2/blake2b.go b/vendor/golang.org/x/crypto/argon2/blake2b.gonew file mode 100644index 000000000..10f46948d--- /dev/null+++ b/vendor/golang.org/x/crypto/argon2/blake2b.go@@ -0,0 +1,53 @@+// Copyright 2017 The Go Authors. All rights reserved.+// Use of this source code is governed by a BSD-style+// license that can be found in the LICENSE file.++package argon2++import (+ "encoding/binary"+ "hash"++ "golang.org/x/crypto/blake2b"+)++// blake2bHash computes an arbitrary long hash value of in+// and writes the hash to out.+func blake2bHash(out []byte, in []byte) {+ var b2 hash.Hash+ if n := len(out); n < blake2b.Size {+ b2, _ = blake2b.New(n, nil)+ } else {+ b2, _ = blake2b.New512(nil)+ }++ var buffer [blake2b.Size]byte+ binary.LittleEndian.PutUint32(buffer[:4], uint32(len(out)))+ b2.Write(buffer[:4])+ b2.Write(in)++ if len(out) <= blake2b.Size {+ b2.Sum(out[:0])+ return+ }++ outLen := len(out)+ b2.Sum(buffer[:0])+ b2.Reset()+ copy(out, buffer[:32])+ out = out[32:]+ for len(out) > blake2b.Size {+ b2.Write(buffer[:])+ b2.Sum(buffer[:0])+ copy(out, buffer[:32])+ out = out[32:]+ b2.Reset()+ }++ if outLen%blake2b.Size > 0 { // outLen > 64+ r := ((outLen + 31) / 32) - 2 // ⌈τ /32⌉-2+ b2, _ = blake2b.New(outLen-32*r, nil)+ }+ b2.Write(buffer[:])+ b2.Sum(out[:0])+}diff --git a/vendor/golang.org/x/crypto/argon2/blamka_amd64.go b/vendor/golang.org/x/crypto/argon2/blamka_amd64.gonew file mode 100644index 000000000..583ac4be2--- /dev/null+++ b/vendor/golang.org/x/crypto/argon2/blamka_amd64.go@@ -0,0 +1,59 @@+// Copyright 2017 The Go Authors. All rights reserved.+// Use of this source code is governed by a BSD-style+// license that can be found in the LICENSE file.++package argon2++func init() {+ useSSE4 = supportsSSE4()+}++//go:noescape+func supportsSSE4() bool++//go:noescape+func mixBlocksSSE2(out, a, b, c *block)++//go:noescape+func xorBlocksSSE2(out, a, b, c *block)++//go:noescape+func blamkaSSE4(b *block)++func processBlockSSE(out, in1, in2 *block, xor bool) {+ var t block+ mixBlocksSSE2(&t, in1, in2, &t)+ if useSSE4 {+ blamkaSSE4(&t)+ } else {+ for i := 0; i < blockLength; i += 16 {+ blamkaGeneric(+ &t[i+0], &t[i+1], &t[i+2], &t[i+3],+ &t[i+4], &t[i+5], &t[i+6], &t[i+7],+ &t[i+8], &t[i+9], &t[i+10], &t[i+11],+ &t[i+12], &t[i+13], &t[i+14], &t[i+15],+ )+ }+ for i := 0; i < blockLength/8; i += 2 {+ blamkaGeneric(+ &t[i], &t[i+1], &t[16+i], &t[16+i+1],+ &t[32+i], &t[32+i+1], &t[48+i], &t[48+i+1],+ &t[64+i], &t[64+i+1], &t[80+i], &t[80+i+1],+ &t[96+i], &t[96+i+1], &t[112+i], &t[112+i+1],+ )+ }+ }+ if xor {+ xorBlocksSSE2(out, in1, in2, &t)+ } else {+ mixBlocksSSE2(out, in1, in2, &t)+ }+}++func processBlock(out, in1, in2 *block) {+ processBlockSSE(out, in1, in2, false)+}++func processBlockXOR(out, in1, in2 *block) {+ processBlockSSE(out, in1, in2, true)+}diff --git a/vendor/golang.org/x/crypto/argon2/blamka_amd64.s b/vendor/golang.org/x/crypto/argon2/blamka_amd64.snew file mode 100644index 000000000..8a83f7c73--- /dev/null+++ b/vendor/golang.org/x/crypto/argon2/blamka_amd64.s@@ -0,0 +1,252 @@+// Copyright 2017 The Go Authors. All rights reserved.+// Use of this source code is governed by a BSD-style+// license that can be found in the LICENSE file.++// +build amd64,!gccgo,!appengine++#include "textflag.h"++DATA ·c40<>+0x00(SB)/8, $0x0201000706050403+DATA ·c40<>+0x08(SB)/8, $0x0a09080f0e0d0c0b+GLOBL ·c40<>(SB), (NOPTR+RODATA), $16++DATA ·c48<>+0x00(SB)/8, $0x0100070605040302+DATA ·c48<>+0x08(SB)/8, $0x09080f0e0d0c0b0a+GLOBL ·c48<>(SB), (NOPTR+RODATA), $16++#define SHUFFLE(v2, v3, v4, v5, v6, v7, t1, t2) \+ MOVO v4, t1; \+ MOVO v5, v4; \+ MOVO t1, v5; \+ MOVO v6, t1; \+ PUNPCKLQDQ v6, t2; \+ PUNPCKHQDQ v7, v6; \+ PUNPCKHQDQ t2, v6; \+ PUNPCKLQDQ v7, t2; \+ MOVO t1, v7; \+ MOVO v2, t1; \+ PUNPCKHQDQ t2, v7; \+ PUNPCKLQDQ v3, t2; \+ PUNPCKHQDQ t2, v2; \+ PUNPCKLQDQ t1, t2; \+ PUNPCKHQDQ t2, v3++#define SHUFFLE_INV(v2, v3, v4, v5, v6, v7, t1, t2) \+ MOVO v4, t1; \+ MOVO v5, v4; \+ MOVO t1, v5; \+ MOVO v2, t1; \+ PUNPCKLQDQ v2, t2; \+ PUNPCKHQDQ v3, v2; \+ PUNPCKHQDQ t2, v2; \+ PUNPCKLQDQ v3, t2; \+ MOVO t1, v3; \+ MOVO v6, t1; \+ PUNPCKHQDQ t2, v3; \+ PUNPCKLQDQ v7, t2; \+ PUNPCKHQDQ t2, v6; \+ PUNPCKLQDQ t1, t2; \+ PUNPCKHQDQ t2, v7++#define HALF_ROUND(v0, v1, v2, v3, v4, v5, v6, v7, t0, c40, c48) \+ MOVO v0, t0; \+ PMULULQ v2, t0; \+ PADDQ v2, v0; \+ PADDQ t0, v0; \+ PADDQ t0, v0; \+ PXOR v0, v6; \+ PSHUFD $0xB1, v6, v6; \+ MOVO v4, t0; \+ PMULULQ v6, t0; \+ PADDQ v6, v4; \+ PADDQ t0, v4; \+ PADDQ t0, v4; \+ PXOR v4, v2; \+ PSHUFB c40, v2; \+ MOVO v0, t0; \+ PMULULQ v2, t0; \+ PADDQ v2, v0; \+ PADDQ t0, v0; \+ PADDQ t0, v0; \+ PXOR v0, v6; \+ PSHUFB c48, v6; \+ MOVO v4, t0; \+ PMULULQ v6, t0; \+ PADDQ v6, v4; \+ PADDQ t0, v4; \+ PADDQ t0, v4; \+ PXOR v4, v2; \+ MOVO v2, t0; \+ PADDQ v2, t0; \+ PSRLQ $63, v2; \+ PXOR t0, v2; \+ MOVO v1, t0; \+ PMULULQ v3, t0; \+ PADDQ v3, v1; \+ PADDQ t0, v1; \+ PADDQ t0, v1; \+ PXOR v1, v7; \+ PSHUFD $0xB1, v7, v7; \+ MOVO v5, t0; \+ PMULULQ v7, t0; \+ PADDQ v7, v5; \+ PADDQ t0, v5; \+ PADDQ t0, v5; \+ PXOR v5, v3; \+ PSHUFB c40, v3; \+ MOVO v1, t0; \+ PMULULQ v3, t0; \+ PADDQ v3, v1; \+ PADDQ t0, v1; \+ PADDQ t0, v1; \+ PXOR v1, v7; \+ PSHUFB c48, v7; \+ MOVO v5, t0; \+ PMULULQ v7, t0; \+ PADDQ v7, v5; \+ PADDQ t0, v5; \+ PADDQ t0, v5; \+ PXOR v5, v3; \+ MOVO v3, t0; \+ PADDQ v3, t0; \+ PSRLQ $63, v3; \+ PXOR t0, v3++#define LOAD_MSG_0(block, off) \+ MOVOU 8*(off+0)(block), X0; \+ MOVOU 8*(off+2)(block), X1; \+ MOVOU 8*(off+4)(block), X2; \+ MOVOU 8*(off+6)(block), X3; \+ MOVOU 8*(off+8)(block), X4; \+ MOVOU 8*(off+10)(block), X5; \+ MOVOU 8*(off+12)(block), X6; \+ MOVOU 8*(off+14)(block), X7++#define STORE_MSG_0(block, off) \+ MOVOU X0, 8*(off+0)(block); \+ MOVOU X1, 8*(off+2)(block); \+ MOVOU X2, 8*(off+4)(block); \+ MOVOU X3, 8*(off+6)(block); \+ MOVOU X4, 8*(off+8)(block); \+ MOVOU X5, 8*(off+10)(block); \+ MOVOU X6, 8*(off+12)(block); \+ MOVOU X7, 8*(off+14)(block)++#define LOAD_MSG_1(block, off) \+ MOVOU 8*off+0*8(block), X0; \+ MOVOU 8*off+16*8(block), X1; \+ MOVOU 8*off+32*8(block), X2; \+ MOVOU 8*off+48*8(block), X3; \+ MOVOU 8*off+64*8(block), X4; \+ MOVOU 8*off+80*8(block), X5; \+ MOVOU 8*off+96*8(block), X6; \+ MOVOU 8*off+112*8(block), X7++#define STORE_MSG_1(block, off) \+ MOVOU X0, 8*off+0*8(block); \+ MOVOU X1, 8*off+16*8(block); \+ MOVOU X2, 8*off+32*8(block); \+ MOVOU X3, 8*off+48*8(block); \+ MOVOU X4, 8*off+64*8(block); \+ MOVOU X5, 8*off+80*8(block); \+ MOVOU X6, 8*off+96*8(block); \+ MOVOU X7, 8*off+112*8(block)++#define BLAMKA_ROUND_0(block, off, t0, t1, c40, c48) \+ LOAD_MSG_0(block, off); \+ HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, t0, c40, c48); \+ SHUFFLE(X2, X3, X4, X5, X6, X7, t0, t1); \+ HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, t0, c40, c48); \+ SHUFFLE_INV(X2, X3, X4, X5, X6, X7, t0, t1); \+ STORE_MSG_0(block, off)++#define BLAMKA_ROUND_1(block, off, t0, t1, c40, c48) \+ LOAD_MSG_1(block, off); \+ HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, t0, c40, c48); \+ SHUFFLE(X2, X3, X4, X5, X6, X7, t0, t1); \+ HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, t0, c40, c48); \+ SHUFFLE_INV(X2, X3, X4, X5, X6, X7, t0, t1); \+ STORE_MSG_1(block, off)++// func blamkaSSE4(b *block)+TEXT ·blamkaSSE4(SB), 4, $0-8+ MOVQ b+0(FP), AX++ MOVOU ·c40<>(SB), X10+ MOVOU ·c48<>(SB), X11++ BLAMKA_ROUND_0(AX, 0, X8, X9, X10, X11)+ BLAMKA_ROUND_0(AX, 16, X8, X9, X10, X11)+ BLAMKA_ROUND_0(AX, 32, X8, X9, X10, X11)+ BLAMKA_ROUND_0(AX, 48, X8, X9, X10, X11)+ BLAMKA_ROUND_0(AX, 64, X8, X9, X10, X11)+ BLAMKA_ROUND_0(AX, 80, X8, X9, X10, X11)+ BLAMKA_ROUND_0(AX, 96, X8, X9, X10, X11)+ BLAMKA_ROUND_0(AX, 112, X8, X9, X10, X11)++ BLAMKA_ROUND_1(AX, 0, X8, X9, X10, X11)+ BLAMKA_ROUND_1(AX, 2, X8, X9, X10, X11)+ BLAMKA_ROUND_1(AX, 4, X8, X9, X10, X11)+ BLAMKA_ROUND_1(AX, 6, X8, X9, X10, X11)+ BLAMKA_ROUND_1(AX, 8, X8, X9, X10, X11)+ BLAMKA_ROUND_1(AX, 10, X8, X9, X10, X11)+ BLAMKA_ROUND_1(AX, 12, X8, X9, X10, X11)+ BLAMKA_ROUND_1(AX, 14, X8, X9, X10, X11)+ RET++// func mixBlocksSSE2(out, a, b, c *block)+TEXT ·mixBlocksSSE2(SB), 4, $0-32+ MOVQ out+0(FP), DX+ MOVQ a+8(FP), AX+ MOVQ b+16(FP), BX+ MOVQ a+24(FP), CX+ MOVQ $128, BP++loop:+ MOVOU 0(AX), X0+ MOVOU 0(BX), X1+ MOVOU 0(CX), X2+ PXOR X1, X0+ PXOR X2, X0+ MOVOU X0, 0(DX)+ ADDQ $16, AX+ ADDQ $16, BX+ ADDQ $16, CX+ ADDQ $16, DX+ SUBQ $2, BP+ JA loop+ RET++// func xorBlocksSSE2(out, a, b, c *block)+TEXT ·xorBlocksSSE2(SB), 4, $0-32+ MOVQ out+0(FP), DX+ MOVQ a+8(FP), AX+ MOVQ b+16(FP), BX+ MOVQ a+24(FP), CX+ MOVQ $128, BP++loop:+ MOVOU 0(AX), X0+ MOVOU 0(BX), X1+ MOVOU 0(CX), X2+ MOVOU 0(DX), X3+ PXOR X1, X0+ PXOR X2, X0+ PXOR X3, X0+ MOVOU X0, 0(DX)+ ADDQ $16, AX+ ADDQ $16, BX+ ADDQ $16, CX+ ADDQ $16, DX+ SUBQ $2, BP+ JA loop+ RET++// func supportsSSE4() bool+TEXT ·supportsSSE4(SB), 4, $0-1+ MOVL $1, AX+ CPUID+ SHRL $19, CX // Bit 19 indicates SSE4 support+ ANDL $1, CX // CX != 0 if support SSE4+ MOVB CX, ret+0(FP)+ RETdiff --git a/vendor/golang.org/x/crypto/argon2/blamka_generic.go b/vendor/golang.org/x/crypto/argon2/blamka_generic.gonew file mode 100644index 000000000..a481b2243--- /dev/null+++ b/vendor/golang.org/x/crypto/argon2/blamka_generic.go@@ -0,0 +1,163 @@+// Copyright 2017 The Go Authors. All rights reserved.+// Use of this source code is governed by a BSD-style+// license that can be found in the LICENSE file.++package argon2++var useSSE4 bool++func processBlockGeneric(out, in1, in2 *block, xor bool) {+ var t block+ for i := range t {+ t[i] = in1[i] ^ in2[i]+ }+ for i := 0; i < blockLength; i += 16 {+ blamkaGeneric(+ &t[i+0], &t[i+1], &t[i+2], &t[i+3],+ &t[i+4], &t[i+5], &t[i+6], &t[i+7],+ &t[i+8], &t[i+9], &t[i+10], &t[i+11],+ &t[i+12], &t[i+13], &t[i+14], &t[i+15],+ )+ }+ for i := 0; i < blockLength/8; i += 2 {+ blamkaGeneric(+ &t[i], &t[i+1], &t[16+i], &t[16+i+1],+ &t[32+i], &t[32+i+1], &t[48+i], &t[48+i+1],+ &t[64+i], &t[64+i+1], &t[80+i], &t[80+i+1],+ &t[96+i], &t[96+i+1], &t[112+i], &t[112+i+1],+ )+ }+ if xor {+ for i := range t {+ out[i] ^= in1[i] ^ in2[i] ^ t[i]+ }+ } else {+ for i := range t {+ out[i] = in1[i] ^ in2[i] ^ t[i]+ }+ }+}++func blamkaGeneric(t00, t01, t02, t03, t04, t05, t06, t07, t08, t09, t10, t11, t12, t13, t14, t15 *uint64) {+ v00, v01, v02, v03 := *t00, *t01, *t02, *t03+ v04, v05, v06, v07 := *t04, *t05, *t06, *t07+ v08, v09, v10, v11 := *t08, *t09, *t10, *t11+ v12, v13, v14, v15 := *t12, *t13, *t14, *t15++ v00 += v04 + 2*uint64(uint32(v00))*uint64(uint32(v04))+ v12 ^= v00+ v12 = v12>>32 | v12<<32+ v08 += v12 + 2*uint64(uint32(v08))*uint64(uint32(v12))+ v04 ^= v08+ v04 = v04>>24 | v04<<40++ v00 += v04 + 2*uint64(uint32(v00))*uint64(uint32(v04))+ v12 ^= v00+ v12 = v12>>16 | v12<<48+ v08 += v12 + 2*uint64(uint32(v08))*uint64(uint32(v12))+ v04 ^= v08+ v04 = v04>>63 | v04<<1++ v01 += v05 + 2*uint64(uint32(v01))*uint64(uint32(v05))+ v13 ^= v01+ v13 = v13>>32 | v13<<32+ v09 += v13 + 2*uint64(uint32(v09))*uint64(uint32(v13))+ v05 ^= v09+ v05 = v05>>24 | v05<<40++ v01 += v05 + 2*uint64(uint32(v01))*uint64(uint32(v05))+ v13 ^= v01+ v13 = v13>>16 | v13<<48+ v09 += v13 + 2*uint64(uint32(v09))*uint64(uint32(v13))+ v05 ^= v09+ v05 = v05>>63 | v05<<1++ v02 += v06 + 2*uint64(uint32(v02))*uint64(uint32(v06))+ v14 ^= v02+ v14 = v14>>32 | v14<<32+ v10 += v14 + 2*uint64(uint32(v10))*uint64(uint32(v14))+ v06 ^= v10+ v06 = v06>>24 | v06<<40++ v02 += v06 + 2*uint64(uint32(v02))*uint64(uint32(v06))+ v14 ^= v02+ v14 = v14>>16 | v14<<48+ v10 += v14 + 2*uint64(uint32(v10))*uint64(uint32(v14))+ v06 ^= v10+ v06 = v06>>63 | v06<<1++ v03 += v07 + 2*uint64(uint32(v03))*uint64(uint32(v07))+ v15 ^= v03+ v15 = v15>>32 | v15<<32+ v11 += v15 + 2*uint64(uint32(v11))*uint64(uint32(v15))+ v07 ^= v11+ v07 = v07>>24 | v07<<40++ v03 += v07 + 2*uint64(uint32(v03))*uint64(uint32(v07))+ v15 ^= v03+ v15 = v15>>16 | v15<<48+ v11 += v15 + 2*uint64(uint32(v11))*uint64(uint32(v15))+ v07 ^= v11+ v07 = v07>>63 | v07<<1++ v00 += v05 + 2*uint64(uint32(v00))*uint64(uint32(v05))+ v15 ^= v00+ v15 = v15>>32 | v15<<32+ v10 += v15 + 2*uint64(uint32(v10))*uint64(uint32(v15))+ v05 ^= v10+ v05 = v05>>24 | v05<<40++ v00 += v05 + 2*uint64(uint32(v00))*uint64(uint32(v05))+ v15 ^= v00+ v15 = v15>>16 | v15<<48+ v10 += v15 + 2*uint64(uint32(v10))*uint64(uint32(v15))+ v05 ^= v10+ v05 = v05>>63 | v05<<1++ v01 += v06 + 2*uint64(uint32(v01))*uint64(uint32(v06))+ v12 ^= v01+ v12 = v12>>32 | v12<<32+ v11 += v12 + 2*uint64(uint32(v11))*uint64(uint32(v12))+ v06 ^= v11+ v06 = v06>>24 | v06<<40++ v01 += v06 + 2*uint64(uint32(v01))*uint64(uint32(v06))+ v12 ^= v01+ v12 = v12>>16 | v12<<48+ v11 += v12 + 2*uint64(uint32(v11))*uint64(uint32(v12))+ v06 ^= v11+ v06 = v06>>63 | v06<<1++ v02 += v07 + 2*uint64(uint32(v02))*uint64(uint32(v07))+ v13 ^= v02+ v13 = v13>>32 | v13<<32+ v08 += v13 + 2*uint64(uint32(v08))*uint64(uint32(v13))+ v07 ^= v08+ v07 = v07>>24 | v07<<40++ v02 += v07 + 2*uint64(uint32(v02))*uint64(uint32(v07))+ v13 ^= v02+ v13 = v13>>16 | v13<<48+ v08 += v13 + 2*uint64(uint32(v08))*uint64(uint32(v13))+ v07 ^= v08+ v07 = v07>>63 | v07<<1++ v03 += v04 + 2*uint64(uint32(v03))*uint64(uint32(v04))+ v14 ^= v03+ v14 = v14>>32 | v14<<32+ v09 += v14 + 2*uint64(uint32(v09))*uint64(uint32(v14))+ v04 ^= v09+ v04 = v04>>24 | v04<<40++ v03 += v04 + 2*uint64(uint32(v03))*uint64(uint32(v04))+ v14 ^= v03+ v14 = v14>>16 | v14<<48+ v09 += v14 + 2*uint64(uint32(v09))*uint64(uint32(v14))+ v04 ^= v09+ v04 = v04>>63 | v04<<1++ *t00, *t01, *t02, *t03 = v00, v01, v02, v03+ *t04, *t05, *t06, *t07 = v04, v05, v06, v07+ *t08, *t09, *t10, *t11 = v08, v09, v10, v11+ *t12, *t13, *t14, *t15 = v12, v13, v14, v15+}diff --git a/vendor/golang.org/x/crypto/argon2/blamka_ref.go b/vendor/golang.org/x/crypto/argon2/blamka_ref.gonew file mode 100644index 000000000..baf7b551d--- /dev/null+++ b/vendor/golang.org/x/crypto/argon2/blamka_ref.go@@ -0,0 +1,15 @@+// Copyright 2017 The Go Authors. All rights reserved.+// Use of this source code is governed by a BSD-style+// license that can be found in the LICENSE file.++// +build !amd64 appengine gccgo++package argon2++func processBlock(out, in1, in2 *block) {+ processBlockGeneric(out, in1, in2, false)+}++func processBlockXOR(out, in1, in2 *block) {+ processBlockGeneric(out, in1, in2, true)+}diff --git a/vendor/golang.org/x/crypto/bcrypt/bcrypt.go b/vendor/golang.org/x/crypto/bcrypt/bcrypt.goindex 202fa8aff..aeb73f81a 100644--- a/vendor/golang.org/x/crypto/bcrypt/bcrypt.go+++ b/vendor/golang.org/x/crypto/bcrypt/bcrypt.go@@ -241,11 +241,11 @@ func (p *hashed) Hash() []byte {n = 3}arr[n] = '$'- n += 1+ n++copy(arr[n:], []byte(fmt.Sprintf("%02d", p.cost)))n += 2arr[n] = '$'- n += 1+ n++copy(arr[n:], p.salt)n += encodedSaltSizecopy(arr[n:], p.hash)diff --git a/vendor/golang.org/x/crypto/blake2b/blake2b.go b/vendor/golang.org/x/crypto/blake2b/blake2b.goindex 7f0a86e44..6dedb8946 100644--- a/vendor/golang.org/x/crypto/blake2b/blake2b.go+++ b/vendor/golang.org/x/crypto/blake2b/blake2b.go@@ -39,7 +39,10 @@ var (useSSE4 bool)-var errKeySize = errors.New("blake2b: invalid key size")+var (+ errKeySize = errors.New("blake2b: invalid key size")+ errHashSize = errors.New("blake2b: invalid hash size")+)var iv = [8]uint64{0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1,@@ -83,7 +86,18 @@ func New384(key []byte) (hash.Hash, error) { return newDigest(Size384, key) }// key turns the hash into a MAC. The key must between zero and 64 bytes long.func New256(key []byte) (hash.Hash, error) { return newDigest(Size256, key) }+// New returns a new hash.Hash computing the BLAKE2b checksum with a custom length.+// A non-nil key turns the hash into a MAC. The key must between zero and 64 bytes long.+// The hash size can be a value between 1 and 64 but it is highly recommended to use+// values equal or greater than:+// - 32 if BLAKE2b is used as a hash function (The key is zero bytes long).+// - 16 if BLAKE2b is used as a MAC function (The key is at least 16 bytes long).+func New(size int, key []byte) (hash.Hash, error) { return newDigest(size, key) }+func newDigest(hashSize int, key []byte) (*digest, error) {+ if hashSize < 1 || hashSize > Size {+ return nil, errHashSize+ }if len(key) > Size {return nil, errKeySize}diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s_test.go b/vendor/golang.org/x/crypto/blake2s/blake2s_test.goindex 938fef375..cfeb18bb4 100644--- a/vendor/golang.org/x/crypto/blake2s/blake2s_test.go+++ b/vendor/golang.org/x/crypto/blake2s/blake2s_test.go@@ -185,7 +185,7 @@ func testHashes2X(t *testing.T) {if n, err := h.Read(result[:]); err != nil {t.Fatalf("#unknown length: error from Read: %v", err)} else if n != len(result) {- t.Fatalf("#unknown length: Read returned %d bytes, want %d: %v", n, len(result))+ t.Fatalf("#unknown length: Read returned %d bytes, want %d", n, len(result))}const expected = "2a9a6977d915a2c4dd07dbcafe1918bf1682e56d9c8e567ecd19bfd7cd93528833c764d12b34a5e2a219c9fd463dab45e972c5574d73f45de5b2e23af72530d8"diff --git a/vendor/golang.org/x/crypto/bn256/bn256.go b/vendor/golang.org/x/crypto/bn256/bn256.goindex 014f8b355..f88f3fc3b 100644--- a/vendor/golang.org/x/crypto/bn256/bn256.go+++ b/vendor/golang.org/x/crypto/bn256/bn256.go@@ -2,7 +2,7 @@// Use of this source code is governed by a BSD-style// license that can be found in the LICENSE file.-// Package bn256 implements a particular bilinear group at the 128-bit security level.+// Package bn256 implements a particular bilinear group.//// Bilinear groups are the basis of many of the new cryptographic protocols// that have been proposed over the past decade. They consist of a triplet of@@ -14,6 +14,10 @@// Barreto-Naehrig curve as described in// http://cryptojedi.org/papers/dclxvi-20100714.pdf. Its output is compatible// with the implementation described in that paper.+//+// (This package previously claimed to operate at a 128-bit security level.+// However, recent improvements in attacks mean that is no longer true. See+// https://moderncrypto.org/mail-archive/curves/2016/000740.html.)package bn256 // import "golang.org/x/crypto/bn256"import (@@ -49,8 +53,8 @@ func RandomG1(r io.Reader) (*big.Int, *G1, error) {return k, new(G1).ScalarBaseMult(k), nil}-func (g *G1) String() string {- return "bn256.G1" + g.p.String()+func (e *G1) String() string {+ return "bn256.G1" + e.p.String()}// ScalarBaseMult sets e to g*k where g is the generator of the group and@@ -92,11 +96,11 @@ func (e *G1) Neg(a *G1) *G1 {}// Marshal converts n to a byte slice.-func (n *G1) Marshal() []byte {- n.p.MakeAffine(nil)+func (e *G1) Marshal() []byte {+ e.p.MakeAffine(nil)- xBytes := new(big.Int).Mod(n.p.x, p).Bytes()- yBytes := new(big.Int).Mod(n.p.y, p).Bytes()+ xBytes := new(big.Int).Mod(e.p.x, p).Bytes()+ yBytes := new(big.Int).Mod(e.p.y, p).Bytes()// Each value is a 256-bit number.const numBytes = 256 / 8@@ -166,8 +170,8 @@ func RandomG2(r io.Reader) (*big.Int, *G2, error) {return k, new(G2).ScalarBaseMult(k), nil}-func (g *G2) String() string {- return "bn256.G2" + g.p.String()+func (e *G2) String() string {+ return "bn256.G2" + e.p.String()}// ScalarBaseMult sets e to g*k where g is the generator of the group anddiff --git a/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_generic.go b/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_generic.goindex f7e4bfb1c..4ac014f52 100644--- a/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_generic.go+++ b/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_generic.go@@ -7,7 +7,7 @@ package chacha20poly1305import ("encoding/binary"- "golang.org/x/crypto/chacha20poly1305/internal/chacha20"+ "golang.org/x/crypto/internal/chacha20""golang.org/x/crypto/poly1305")diff --git a/vendor/golang.org/x/crypto/ed25519/ed25519.go b/vendor/golang.org/x/crypto/ed25519/ed25519.goindex 16cd38546..4f26b49b6 100644--- a/vendor/golang.org/x/crypto/ed25519/ed25519.go+++ b/vendor/golang.org/x/crypto/ed25519/ed25519.go@@ -6,7 +6,7 @@// https://ed25519.cr.yp.to/.//// These functions are also compatible with the “Ed25519” function defined in-// https://tools.ietf.org/html/draft-irtf-cfrg-eddsa-05.+// RFC 8032.package ed25519// This code is a port of the public domain, “ref10” implementation of ed25519diff --git a/vendor/golang.org/x/crypto/chacha20poly1305/internal/chacha20/chacha_generic.go b/vendor/golang.org/x/crypto/internal/chacha20/chacha_generic.gosimilarity index 100%rename from vendor/golang.org/x/crypto/chacha20poly1305/internal/chacha20/chacha_generic.gorename to vendor/golang.org/x/crypto/internal/chacha20/chacha_generic.godiff --git a/vendor/golang.org/x/crypto/chacha20poly1305/internal/chacha20/chacha_test.go b/vendor/golang.org/x/crypto/internal/chacha20/chacha_test.gosimilarity index 100%rename from vendor/golang.org/x/crypto/chacha20poly1305/internal/chacha20/chacha_test.gorename to vendor/golang.org/x/crypto/internal/chacha20/chacha_test.godiff --git a/vendor/golang.org/x/crypto/nacl/auth/auth.go b/vendor/golang.org/x/crypto/nacl/auth/auth.goindex 0835d3bf9..ec1d6ebe4 100644--- a/vendor/golang.org/x/crypto/nacl/auth/auth.go+++ b/vendor/golang.org/x/crypto/nacl/auth/auth.go@@ -47,7 +47,7 @@ func Sum(m []byte, key *[KeySize]byte) *[Size]byte {// Verify checks that digest is a valid authenticator of message m under the// given secret key. Verify does not leak timing information.-func Verify(digest []byte, m []byte, key *[32]byte) bool {+func Verify(digest []byte, m []byte, key *[KeySize]byte) bool {if len(digest) != Size {return false}diff --git a/vendor/golang.org/x/crypto/ocsp/ocsp.go b/vendor/golang.org/x/crypto/ocsp/ocsp.goindex 5e73146d7..589dfd35f 100644--- a/vendor/golang.org/x/crypto/ocsp/ocsp.go+++ b/vendor/golang.org/x/crypto/ocsp/ocsp.go@@ -760,7 +760,7 @@ func CreateResponse(issuer, responderCert *x509.Certificate, template Response,}if template.Certificate != nil {response.Certificates = []asn1.RawValue{- asn1.RawValue{FullBytes: template.Certificate.Raw},+ {FullBytes: template.Certificate.Raw},}}responseDER, err := asn1.Marshal(response)diff --git a/vendor/golang.org/x/crypto/ocsp/ocsp_test.go b/vendor/golang.org/x/crypto/ocsp/ocsp_test.goindex df674b374..70b19764f 100644--- a/vendor/golang.org/x/crypto/ocsp/ocsp_test.go+++ b/vendor/golang.org/x/crypto/ocsp/ocsp_test.go@@ -43,11 +43,11 @@ func TestOCSPDecode(t *testing.T) {}if !reflect.DeepEqual(resp.ThisUpdate, expected.ThisUpdate) {- t.Errorf("resp.ThisUpdate: got %d, want %d", resp.ThisUpdate, expected.ThisUpdate)+ t.Errorf("resp.ThisUpdate: got %v, want %v", resp.ThisUpdate, expected.ThisUpdate)}if !reflect.DeepEqual(resp.NextUpdate, expected.NextUpdate) {- t.Errorf("resp.NextUpdate: got %d, want %d", resp.NextUpdate, expected.NextUpdate)+ t.Errorf("resp.NextUpdate: got %v, want %v", resp.NextUpdate, expected.NextUpdate)}if resp.Status != expected.Status {@@ -218,7 +218,7 @@ func TestOCSPResponse(t *testing.T) {extensionBytes, _ := hex.DecodeString(ocspExtensionValueHex)extensions := []pkix.Extension{- pkix.Extension{+ {Id: ocspExtensionOID,Critical: false,Value: extensionBytes,@@ -268,15 +268,15 @@ func TestOCSPResponse(t *testing.T) {}if !reflect.DeepEqual(resp.ThisUpdate, template.ThisUpdate) {- t.Errorf("resp.ThisUpdate: got %d, want %d", resp.ThisUpdate, template.ThisUpdate)+ t.Errorf("resp.ThisUpdate: got %v, want %v", resp.ThisUpdate, template.ThisUpdate)}if !reflect.DeepEqual(resp.NextUpdate, template.NextUpdate) {- t.Errorf("resp.NextUpdate: got %d, want %d", resp.NextUpdate, template.NextUpdate)+ t.Errorf("resp.NextUpdate: got %v, want %v", resp.NextUpdate, template.NextUpdate)}if !reflect.DeepEqual(resp.RevokedAt, template.RevokedAt) {- t.Errorf("resp.RevokedAt: got %d, want %d", resp.RevokedAt, template.RevokedAt)+ t.Errorf("resp.RevokedAt: got %v, want %v", resp.RevokedAt, template.RevokedAt)}if !reflect.DeepEqual(resp.Extensions, template.ExtraExtensions) {diff --git a/vendor/golang.org/x/crypto/openpgp/keys.go b/vendor/golang.org/x/crypto/openpgp/keys.goindex 68b14c6ae..744e293fe 100644--- a/vendor/golang.org/x/crypto/openpgp/keys.go+++ b/vendor/golang.org/x/crypto/openpgp/keys.go@@ -325,9 +325,8 @@ func ReadEntity(packets *packet.Reader) (*Entity, error) {if e.PrivateKey, ok = p.(*packet.PrivateKey); !ok {packets.Unread(p)return nil, errors.StructuralError("first packet was not a public/private key")- } else {- e.PrimaryKey = &e.PrivateKey.PublicKey}+ e.PrimaryKey = &e.PrivateKey.PublicKey}if !e.PrimaryKey.PubKeyAlgo.CanSign() {diff --git a/vendor/golang.org/x/crypto/pbkdf2/pbkdf2_test.go b/vendor/golang.org/x/crypto/pbkdf2/pbkdf2_test.goindex 137924061..f83cb6922 100644--- a/vendor/golang.org/x/crypto/pbkdf2/pbkdf2_test.go+++ b/vendor/golang.org/x/crypto/pbkdf2/pbkdf2_test.go@@ -155,3 +155,22 @@ func TestWithHMACSHA1(t *testing.T) {func TestWithHMACSHA256(t *testing.T) {testHash(t, sha256.New, "SHA256", sha256TestVectors)}++var sink uint8++func benchmark(b *testing.B, h func() hash.Hash) {+ password := make([]byte, h().Size())+ salt := make([]byte, 8)+ for i := 0; i < b.N; i++ {+ password = Key(password, salt, 4096, len(password), h)+ }+ sink += password[0]+}++func BenchmarkHMACSHA1(b *testing.B) {+ benchmark(b, sha1.New)+}++func BenchmarkHMACSHA256(b *testing.B) {+ benchmark(b, sha256.New)+}diff --git a/vendor/golang.org/x/crypto/pkcs12/internal/rc2/rc2.go b/vendor/golang.org/x/crypto/pkcs12/internal/rc2/rc2.goindex 8c7090258..7499e3fb6 100644--- a/vendor/golang.org/x/crypto/pkcs12/internal/rc2/rc2.go+++ b/vendor/golang.org/x/crypto/pkcs12/internal/rc2/rc2.go@@ -122,7 +122,6 @@ func (c *rc2Cipher) Encrypt(dst, src []byte) {r3 = r3 + c.k[r2&63]for j <= 40 {-// mix r0r0 = r0 + c.k[j] + (r3 & r2) + ((^r3) & r1)r0 = rotl16(r0, 1)@@ -151,7 +150,6 @@ func (c *rc2Cipher) Encrypt(dst, src []byte) {r3 = r3 + c.k[r2&63]for j <= 60 {-// mix r0r0 = r0 + c.k[j] + (r3 & r2) + ((^r3) & r1)r0 = rotl16(r0, 1)@@ -244,7 +242,6 @@ func (c *rc2Cipher) Decrypt(dst, src []byte) {r0 = r0 - c.k[r3&63]for j >= 0 {-// unmix r3r3 = rotl16(r3, 16-5)r3 = r3 - c.k[j] - (r2 & r1) - ((^r2) & r0)diff --git a/vendor/golang.org/x/crypto/pkcs12/internal/rc2/rc2_test.go b/vendor/golang.org/x/crypto/pkcs12/internal/rc2/rc2_test.goindex 8a49dfaf3..51a7efe50 100644--- a/vendor/golang.org/x/crypto/pkcs12/internal/rc2/rc2_test.go+++ b/vendor/golang.org/x/crypto/pkcs12/internal/rc2/rc2_test.go@@ -11,7 +11,6 @@ import ()func TestEncryptDecrypt(t *testing.T) {-// TODO(dgryski): add the rest of the test vectors from the RFCvar tests = []struct {key stringdiff --git a/vendor/golang.org/x/crypto/sha3/sha3_test.go b/vendor/golang.org/x/crypto/sha3/sha3_test.goindex 312e8f907..2c8719b44 100644--- a/vendor/golang.org/x/crypto/sha3/sha3_test.go+++ b/vendor/golang.org/x/crypto/sha3/sha3_test.go@@ -202,7 +202,7 @@ func TestSqueezing(t *testing.T) {d1 := newShakeHash()d1.Write([]byte(testString))var multiple []byte- for _ = range ref {+ for range ref {one := make([]byte, 1)d1.Read(one)multiple = append(multiple, one...)diff --git a/vendor/golang.org/x/crypto/ssh/agent/client.go b/vendor/golang.org/x/crypto/ssh/agent/client.goindex dce7682fa..acb5ad80e 100644--- a/vendor/golang.org/x/crypto/ssh/agent/client.go+++ b/vendor/golang.org/x/crypto/ssh/agent/client.go@@ -98,7 +98,7 @@ const (agentAddIdentity = 17agentRemoveIdentity = 18agentRemoveAllIdentities = 19- agentAddIdConstrained = 25+ agentAddIDConstrained = 25// 3.3 Key-type independent requests from client to agentagentAddSmartcardKey = 20@@ -515,7 +515,7 @@ func (c *client) insertKey(s interface{}, comment string, constraints []byte) er// if constraints are present then the message type needs to be changed.if len(constraints) != 0 {- req[0] = agentAddIdConstrained+ req[0] = agentAddIDConstrained}resp, err := c.call(req)@@ -577,11 +577,11 @@ func (c *client) Add(key AddedKey) error {constraints = append(constraints, agentConstrainConfirm)}- if cert := key.Certificate; cert == nil {+ cert := key.Certificate+ if cert == nil {return c.insertKey(key.PrivateKey, key.Comment, constraints)- } else {- return c.insertCert(key.PrivateKey, cert, key.Comment, constraints)}+ return c.insertCert(key.PrivateKey, cert, key.Comment, constraints)}func (c *client) insertCert(s interface{}, cert *ssh.Certificate, comment string, constraints []byte) error {@@ -633,7 +633,7 @@ func (c *client) insertCert(s interface{}, cert *ssh.Certificate, comment string// if constraints are present then the message type needs to be changed.if len(constraints) != 0 {- req[0] = agentAddIdConstrained+ req[0] = agentAddIDConstrained}signer, err := ssh.NewSignerFromKey(s)diff --git a/vendor/golang.org/x/crypto/ssh/agent/server.go b/vendor/golang.org/x/crypto/ssh/agent/server.goindex 321e48a26..2e4692cbd 100644--- a/vendor/golang.org/x/crypto/ssh/agent/server.go+++ b/vendor/golang.org/x/crypto/ssh/agent/server.go@@ -148,7 +148,7 @@ func (s *server) processRequest(data []byte) (interface{}, error) {}return rep, nil- case agentAddIdConstrained, agentAddIdentity:+ case agentAddIDConstrained, agentAddIdentity:return nil, s.insertIdentity(data)}diff --git a/vendor/golang.org/x/crypto/ssh/benchmark_test.go b/vendor/golang.org/x/crypto/ssh/benchmark_test.goindex d9f7eb9b6..20c330773 100644--- a/vendor/golang.org/x/crypto/ssh/benchmark_test.go+++ b/vendor/golang.org/x/crypto/ssh/benchmark_test.go@@ -40,7 +40,8 @@ func sshPipe() (Conn, *server, error) {}clientConf := ClientConfig{- User: "user",+ User: "user",+ HostKeyCallback: InsecureIgnoreHostKey(),}serverConf := ServerConfig{NoClientAuth: true,diff --git a/vendor/golang.org/x/crypto/ssh/certs.go b/vendor/golang.org/x/crypto/ssh/certs.goindex b1f022078..cfc8ead1b 100644--- a/vendor/golang.org/x/crypto/ssh/certs.go+++ b/vendor/golang.org/x/crypto/ssh/certs.go@@ -340,10 +340,10 @@ func (c *CertChecker) Authenticate(conn ConnMetadata, pubKey PublicKey) (*Permis// the signature of the certificate.func (c *CertChecker) CheckCert(principal string, cert *Certificate) error {if c.IsRevoked != nil && c.IsRevoked(cert) {- return fmt.Errorf("ssh: certicate serial %d revoked", cert.Serial)+ return fmt.Errorf("ssh: certificate serial %d revoked", cert.Serial)}- for opt, _ := range cert.CriticalOptions {+ for opt := range cert.CriticalOptions {// sourceAddressCriticalOption will be enforced by// serverAuthenticateif opt == sourceAddressCriticalOption {diff --git a/vendor/golang.org/x/crypto/ssh/certs_test.go b/vendor/golang.org/x/crypto/ssh/certs_test.goindex 0200531f4..c8e7cf585 100644--- a/vendor/golang.org/x/crypto/ssh/certs_test.go+++ b/vendor/golang.org/x/crypto/ssh/certs_test.go@@ -6,10 +6,15 @@ package sshimport ("bytes"+ "crypto/ecdsa"+ "crypto/elliptic""crypto/rand"+ "net""reflect""testing""time"++ "golang.org/x/crypto/ssh/testdata")// Cert generated by ssh-keygen 6.0p1 Debian-4.@@ -220,3 +225,111 @@ func TestHostKeyCert(t *testing.T) {}}}++func TestCertTypes(t *testing.T) {+ var testVars = []struct {+ name string+ keys func() Signer+ }{+ {+ name: CertAlgoECDSA256v01,+ keys: func() Signer {+ s, _ := ParsePrivateKey(testdata.PEMBytes["ecdsap256"])+ return s+ },+ },+ {+ name: CertAlgoECDSA384v01,+ keys: func() Signer {+ s, _ := ParsePrivateKey(testdata.PEMBytes["ecdsap384"])+ return s+ },+ },+ {+ name: CertAlgoECDSA521v01,+ keys: func() Signer {+ s, _ := ParsePrivateKey(testdata.PEMBytes["ecdsap521"])+ return s+ },+ },+ {+ name: CertAlgoED25519v01,+ keys: func() Signer {+ s, _ := ParsePrivateKey(testdata.PEMBytes["ed25519"])+ return s+ },+ },+ {+ name: CertAlgoRSAv01,+ keys: func() Signer {+ s, _ := ParsePrivateKey(testdata.PEMBytes["rsa"])+ return s+ },+ },+ {+ name: CertAlgoDSAv01,+ keys: func() Signer {+ s, _ := ParsePrivateKey(testdata.PEMBytes["dsa"])+ return s+ },+ },+ }++ k, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)+ if err != nil {+ t.Fatalf("error generating host key: %v", err)+ }++ signer, err := NewSignerFromKey(k)+ if err != nil {+ t.Fatalf("error generating signer for ssh listener: %v", err)+ }++ conf := &ServerConfig{+ PublicKeyCallback: func(c ConnMetadata, k PublicKey) (*Permissions, error) {+ return new(Permissions), nil+ },+ }+ conf.AddHostKey(signer)++ for _, m := range testVars {+ t.Run(m.name, func(t *testing.T) {++ c1, c2, err := netPipe()+ if err != nil {+ t.Fatalf("netPipe: %v", err)+ }+ defer c1.Close()+ defer c2.Close()++ go NewServerConn(c1, conf)++ priv := m.keys()+ if err != nil {+ t.Fatalf("error generating ssh pubkey: %v", err)+ }++ cert := &Certificate{+ CertType: UserCert,+ Key: priv.PublicKey(),+ }+ cert.SignCert(rand.Reader, priv)++ certSigner, err := NewCertSigner(cert, priv)+ if err != nil {+ t.Fatalf("error generating cert signer: %v", err)+ }++ config := &ClientConfig{+ User: "user",+ HostKeyCallback: func(h string, r net.Addr, k PublicKey) error { return nil },+ Auth: []AuthMethod{PublicKeys(certSigner)},+ }++ _, _, _, err = NewClientConn(c2, "", config)+ if err != nil {+ t.Fatalf("error connecting: %v", err)+ }+ })+ }+}diff --git a/vendor/golang.org/x/crypto/ssh/channel.go b/vendor/golang.org/x/crypto/ssh/channel.goindex 195530ea0..c0834c00d 100644--- a/vendor/golang.org/x/crypto/ssh/channel.go+++ b/vendor/golang.org/x/crypto/ssh/channel.go@@ -205,32 +205,32 @@ type channel struct {// writePacket sends a packet. If the packet is a channel close, it updates// sentClose. This method takes the lock c.writeMu.-func (c *channel) writePacket(packet []byte) error {- c.writeMu.Lock()- if c.sentClose {- c.writeMu.Unlock()+func (ch *channel) writePacket(packet []byte) error {+ ch.writeMu.Lock()+ if ch.sentClose {+ ch.writeMu.Unlock()return io.EOF}- c.sentClose = (packet[0] == msgChannelClose)- err := c.mux.conn.writePacket(packet)- c.writeMu.Unlock()+ ch.sentClose = (packet[0] == msgChannelClose)+ err := ch.mux.conn.writePacket(packet)+ ch.writeMu.Unlock()return err}-func (c *channel) sendMessage(msg interface{}) error {+func (ch *channel) sendMessage(msg interface{}) error {if debugMux {- log.Printf("send(%d): %#v", c.mux.chanList.offset, msg)+ log.Printf("send(%d): %#v", ch.mux.chanList.offset, msg)}p := Marshal(msg)- binary.BigEndian.PutUint32(p[1:], c.remoteId)- return c.writePacket(p)+ binary.BigEndian.PutUint32(p[1:], ch.remoteId)+ return ch.writePacket(p)}// WriteExtended writes data to a specific extended stream. These streams are// used, for example, for stderr.-func (c *channel) WriteExtended(data []byte, extendedCode uint32) (n int, err error) {- if c.sentEOF {+func (ch *channel) WriteExtended(data []byte, extendedCode uint32) (n int, err error) {+ if ch.sentEOF {return 0, io.EOF}// 1 byte message type, 4 bytes remoteId, 4 bytes data length@@ -241,16 +241,16 @@ func (c *channel) WriteExtended(data []byte, extendedCode uint32) (n int, err eropCode = msgChannelExtendedData}- c.writeMu.Lock()- packet := c.packetPool[extendedCode]+ ch.writeMu.Lock()+ packet := ch.packetPool[extendedCode]// We don't remove the buffer from packetPool, so// WriteExtended calls from different goroutines will be// flagged as errors by the race detector.- c.writeMu.Unlock()+ ch.writeMu.Unlock()for len(data) > 0 {- space := min(c.maxRemotePayload, len(data))- if space, err = c.remoteWin.reserve(space); err != nil {+ space := min(ch.maxRemotePayload, len(data))+ if space, err = ch.remoteWin.reserve(space); err != nil {return n, err}if want := headerLength + space; uint32(cap(packet)) < want {@@ -262,13 +262,13 @@ func (c *channel) WriteExtended(data []byte, extendedCode uint32) (n int, err ertodo := data[:space]packet[0] = opCode- binary.BigEndian.PutUint32(packet[1:], c.remoteId)+ binary.BigEndian.PutUint32(packet[1:], ch.remoteId)if extendedCode > 0 {binary.BigEndian.PutUint32(packet[5:], uint32(extendedCode))}binary.BigEndian.PutUint32(packet[headerLength-4:], uint32(len(todo)))copy(packet[headerLength:], todo)- if err = c.writePacket(packet); err != nil {+ if err = ch.writePacket(packet); err != nil {return n, err}@@ -276,14 +276,14 @@ func (c *channel) WriteExtended(data []byte, extendedCode uint32) (n int, err erdata = data[len(todo):]}- c.writeMu.Lock()- c.packetPool[extendedCode] = packet- c.writeMu.Unlock()+ ch.writeMu.Lock()+ ch.packetPool[extendedCode] = packet+ ch.writeMu.Unlock()return n, err}-func (c *channel) handleData(packet []byte) error {+func (ch *channel) handleData(packet []byte) error {headerLen := 9isExtendedData := packet[0] == msgChannelExtendedDataif isExtendedData {@@ -303,7 +303,7 @@ func (c *channel) handleData(packet []byte) error {if length == 0 {return nil}- if length > c.maxIncomingPayload {+ if length > ch.maxIncomingPayload {// TODO(hanwen): should send Disconnect?return errors.New("ssh: incoming packet exceeds maximum payload size")}@@ -313,21 +313,21 @@ func (c *channel) handleData(packet []byte) error {return errors.New("ssh: wrong packet length")}- c.windowMu.Lock()- if c.myWindow < length {- c.windowMu.Unlock()+ ch.windowMu.Lock()+ if ch.myWindow < length {+ ch.windowMu.Unlock()// TODO(hanwen): should send Disconnect with reason?return errors.New("ssh: remote side wrote too much")}- c.myWindow -= length- c.windowMu.Unlock()+ ch.myWindow -= length+ ch.windowMu.Unlock()if extended == 1 {- c.extPending.write(data)+ ch.extPending.write(data)} else if extended > 0 {// discard other extended data.} else {- c.pending.write(data)+ ch.pending.write(data)}return nil}@@ -384,31 +384,31 @@ func (c *channel) close() {// responseMessageReceived is called when a success or failure message is// received on a channel to check that such a message is reasonable for the// given channel.-func (c *channel) responseMessageReceived() error {- if c.direction == channelInbound {+func (ch *channel) responseMessageReceived() error {+ if ch.direction == channelInbound {return errors.New("ssh: channel response message received on inbound channel")}- if c.decided {+ if ch.decided {return errors.New("ssh: duplicate response received for channel")}- c.decided = true+ ch.decided = truereturn nil}-func (c *channel) handlePacket(packet []byte) error {+func (ch *channel) handlePacket(packet []byte) error {switch packet[0] {case msgChannelData, msgChannelExtendedData:- return c.handleData(packet)+ return ch.handleData(packet)case msgChannelClose:- c.sendMessage(channelCloseMsg{PeersId: c.remoteId})- c.mux.chanList.remove(c.localId)- c.close()+ ch.sendMessage(channelCloseMsg{PeersID: ch.remoteId})+ ch.mux.chanList.remove(ch.localId)+ ch.close()return nilcase msgChannelEOF:// RFC 4254 is mute on how EOF affects dataExt messages but// it is logical to signal EOF at the same time.- c.extPending.eof()- c.pending.eof()+ ch.extPending.eof()+ ch.pending.eof()return nil}@@ -419,24 +419,24 @@ func (c *channel) handlePacket(packet []byte) error {switch msg := decoded.(type) {case *channelOpenFailureMsg:- if err := c.responseMessageReceived(); err != nil {+ if err := ch.responseMessageReceived(); err != nil {return err}- c.mux.chanList.remove(msg.PeersId)- c.msg <- msg+ ch.mux.chanList.remove(msg.PeersID)+ ch.msg <- msgcase *channelOpenConfirmMsg:- if err := c.responseMessageReceived(); err != nil {+ if err := ch.responseMessageReceived(); err != nil {return err}if msg.MaxPacketSize < minPacketLength || msg.MaxPacketSize > 1<<31 {return fmt.Errorf("ssh: invalid MaxPacketSize %d from peer", msg.MaxPacketSize)}- c.remoteId = msg.MyId- c.maxRemotePayload = msg.MaxPacketSize- c.remoteWin.add(msg.MyWindow)- c.msg <- msg+ ch.remoteId = msg.MyID+ ch.maxRemotePayload = msg.MaxPacketSize+ ch.remoteWin.add(msg.MyWindow)+ ch.msg <- msgcase *windowAdjustMsg:- if !c.remoteWin.add(msg.AdditionalBytes) {+ if !ch.remoteWin.add(msg.AdditionalBytes) {return fmt.Errorf("ssh: invalid window update for %d bytes", msg.AdditionalBytes)}case *channelRequestMsg:@@ -444,12 +444,12 @@ func (c *channel) handlePacket(packet []byte) error {Type: msg.Request,WantReply: msg.WantReply,Payload: msg.RequestSpecificData,- ch: c,+ ch: ch,}- c.incomingRequests <- &req+ ch.incomingRequests <- &reqdefault:- c.msg <- msg+ ch.msg <- msg}return nil}@@ -488,23 +488,23 @@ func (e *extChannel) Read(data []byte) (n int, err error) {return e.ch.ReadExtended(data, e.code)}-func (c *channel) Accept() (Channel, <-chan *Request, error) {- if c.decided {+func (ch *channel) Accept() (Channel, <-chan *Request, error) {+ if ch.decided {return nil, nil, errDecidedAlready}- c.maxIncomingPayload = channelMaxPacket+ ch.maxIncomingPayload = channelMaxPacketconfirm := channelOpenConfirmMsg{- PeersId: c.remoteId,- MyId: c.localId,- MyWindow: c.myWindow,- MaxPacketSize: c.maxIncomingPayload,+ PeersID: ch.remoteId,+ MyID: ch.localId,+ MyWindow: ch.myWindow,+ MaxPacketSize: ch.maxIncomingPayload,}- c.decided = true- if err := c.sendMessage(confirm); err != nil {+ ch.decided = true+ if err := ch.sendMessage(confirm); err != nil {return nil, nil, err}- return c, c.incomingRequests, nil+ return ch, ch.incomingRequests, nil}func (ch *channel) Reject(reason RejectionReason, message string) error {@@ -512,7 +512,7 @@ func (ch *channel) Reject(reason RejectionReason, message string) error {return errDecidedAlready}reject := channelOpenFailureMsg{- PeersId: ch.remoteId,+ PeersID: ch.remoteId,Reason: reason,Message: message,Language: "en",@@ -541,7 +541,7 @@ func (ch *channel) CloseWrite() error {}ch.sentEOF = truereturn ch.sendMessage(channelEOFMsg{- PeersId: ch.remoteId})+ PeersID: ch.remoteId})}func (ch *channel) Close() error {@@ -550,7 +550,7 @@ func (ch *channel) Close() error {}return ch.sendMessage(channelCloseMsg{- PeersId: ch.remoteId})+ PeersID: ch.remoteId})}// Extended returns an io.ReadWriter that sends and receives data on the given,@@ -577,7 +577,7 @@ func (ch *channel) SendRequest(name string, wantReply bool, payload []byte) (boo}msg := channelRequestMsg{- PeersId: ch.remoteId,+ PeersID: ch.remoteId,Request: name,WantReply: wantReply,RequestSpecificData: payload,@@ -614,11 +614,11 @@ func (ch *channel) ackRequest(ok bool) error {var msg interface{}if !ok {msg = channelRequestFailureMsg{- PeersId: ch.remoteId,+ PeersID: ch.remoteId,}} else {msg = channelRequestSuccessMsg{- PeersId: ch.remoteId,+ PeersID: ch.remoteId,}}return ch.sendMessage(msg)diff --git a/vendor/golang.org/x/crypto/ssh/cipher.go b/vendor/golang.org/x/crypto/ssh/cipher.goindex 22bb30ccd..e67c5e0aa 100644--- a/vendor/golang.org/x/crypto/ssh/cipher.go+++ b/vendor/golang.org/x/crypto/ssh/cipher.go@@ -304,7 +304,7 @@ type gcmCipher struct {buf []byte}-func newGCMCipher(iv, key, macKey []byte) (packetCipher, error) {+func newGCMCipher(iv, key []byte) (packetCipher, error) {c, err := aes.NewCipher(key)if err != nil {return nil, err@@ -372,7 +372,7 @@ func (c *gcmCipher) readPacket(seqNum uint32, r io.Reader) ([]byte, error) {}length := binary.BigEndian.Uint32(c.prefix[:])if length > maxPacket {- return nil, errors.New("ssh: max packet length exceeded.")+ return nil, errors.New("ssh: max packet length exceeded")}if cap(c.buf) < int(length+gcmTagSize) {@@ -548,11 +548,11 @@ func (c *cbcCipher) readPacketLeaky(seqNum uint32, r io.Reader) ([]byte, error)c.packetData = c.packetData[:entirePacketSize]}- if n, err := io.ReadFull(r, c.packetData[firstBlockLength:]); err != nil {+ n, err := io.ReadFull(r, c.packetData[firstBlockLength:])+ if err != nil {return nil, err- } else {- c.oracleCamouflage -= uint32(n)}+ c.oracleCamouflage -= uint32(n)remainingCrypted := c.packetData[firstBlockLength:macStart]c.decrypter.CryptBlocks(remainingCrypted, remainingCrypted)diff --git a/vendor/golang.org/x/crypto/ssh/cipher_test.go b/vendor/golang.org/x/crypto/ssh/cipher_test.goindex 5cfa17a62..6a35d8708 100644--- a/vendor/golang.org/x/crypto/ssh/cipher_test.go+++ b/vendor/golang.org/x/crypto/ssh/cipher_test.go@@ -21,47 +21,48 @@ func TestDefaultCiphersExist(t *testing.T) {}func TestPacketCiphers(t *testing.T) {- // Still test aes128cbc cipher although it's commented out.- cipherModes[aes128cbcID] = &streamCipherMode{16, aes.BlockSize, 0, nil}- defer delete(cipherModes, aes128cbcID)-+ defaultMac := "hmac-sha2-256"+ defaultCipher := "aes128-ctr"for cipher := range cipherModes {- for mac := range macModes {- kr := &kexResult{Hash: crypto.SHA1}- algs := directionAlgorithms{- Cipher: cipher,- MAC: mac,- Compression: "none",- }- client, err := newPacketCipher(clientKeys, algs, kr)- if err != nil {- t.Errorf("newPacketCipher(client, %q, %q): %v", cipher, mac, err)- continue- }- server, err := newPacketCipher(clientKeys, algs, kr)- if err != nil {- t.Errorf("newPacketCipher(client, %q, %q): %v", cipher, mac, err)- continue- }-- want := "bla bla"- input := []byte(want)- buf := &bytes.Buffer{}- if err := client.writePacket(0, buf, rand.Reader, input); err != nil {- t.Errorf("writePacket(%q, %q): %v", cipher, mac, err)- continue- }-- packet, err := server.readPacket(0, buf)- if err != nil {- t.Errorf("readPacket(%q, %q): %v", cipher, mac, err)- continue- }-- if string(packet) != want {- t.Errorf("roundtrip(%q, %q): got %q, want %q", cipher, mac, packet, want)- }- }+ t.Run("cipher="+cipher,+ func(t *testing.T) { testPacketCipher(t, cipher, defaultMac) })+ }+ for mac := range macModes {+ t.Run("mac="+mac,+ func(t *testing.T) { testPacketCipher(t, defaultCipher, mac) })+ }+}++func testPacketCipher(t *testing.T, cipher, mac string) {+ kr := &kexResult{Hash: crypto.SHA1}+ algs := directionAlgorithms{+ Cipher: cipher,+ MAC: mac,+ Compression: "none",+ }+ client, err := newPacketCipher(clientKeys, algs, kr)+ if err != nil {+ t.Fatalf("newPacketCipher(client, %q, %q): %v", cipher, mac, err)+ }+ server, err := newPacketCipher(clientKeys, algs, kr)+ if err != nil {+ t.Fatalf("newPacketCipher(client, %q, %q): %v", cipher, mac, err)+ }++ want := "bla bla"+ input := []byte(want)+ buf := &bytes.Buffer{}+ if err := client.writePacket(0, buf, rand.Reader, input); err != nil {+ t.Fatalf("writePacket(%q, %q): %v", cipher, mac, err)+ }++ packet, err := server.readPacket(0, buf)+ if err != nil {+ t.Fatalf("readPacket(%q, %q): %v", cipher, mac, err)+ }++ if string(packet) != want {+ t.Errorf("roundtrip(%q, %q): got %q, want %q", cipher, mac, packet, want)}}diff --git a/vendor/golang.org/x/crypto/ssh/client.go b/vendor/golang.org/x/crypto/ssh/client.goindex a7e3263bc..6fd199455 100644--- a/vendor/golang.org/x/crypto/ssh/client.go+++ b/vendor/golang.org/x/crypto/ssh/client.go@@ -9,6 +9,7 @@ import ("errors""fmt""net"+ "os""sync""time")@@ -187,6 +188,10 @@ func Dial(network, addr string, config *ClientConfig) (*Client, error) {// net.Conn underlying the the SSH connection.type HostKeyCallback func(hostname string, remote net.Addr, key PublicKey) error+// BannerCallback is the function type used for treat the banner sent by+// the server. A BannerCallback receives the message sent by the remote server.+type BannerCallback func(message string) error+// A ClientConfig structure is used to configure a Client. It must not be// modified after having been passed to an SSH function.type ClientConfig struct {@@ -209,6 +214,12 @@ type ClientConfig struct {// FixedHostKey can be used for simplistic host key checks.HostKeyCallback HostKeyCallback+ // BannerCallback is called during the SSH dance to display a custom+ // server's message. The client configuration can supply this callback to+ // handle it as wished. The function BannerDisplayStderr can be used for+ // simplistic display on Stderr.+ BannerCallback BannerCallback+// ClientVersion contains the version identification string that will// be used for the connection. If empty, a reasonable default is used.ClientVersion string@@ -255,3 +266,13 @@ func FixedHostKey(key PublicKey) HostKeyCallback {hk := &fixedHostKey{key}return hk.check}++// BannerDisplayStderr returns a function that can be used for+// ClientConfig.BannerCallback to display banners on os.Stderr.+func BannerDisplayStderr() BannerCallback {+ return func(banner string) error {+ _, err := os.Stderr.WriteString(banner)++ return err+ }+}diff --git a/vendor/golang.org/x/crypto/ssh/client_auth.go b/vendor/golang.org/x/crypto/ssh/client_auth.goindex 3acd8d498..a1252cb9b 100644--- a/vendor/golang.org/x/crypto/ssh/client_auth.go+++ b/vendor/golang.org/x/crypto/ssh/client_auth.go@@ -283,7 +283,9 @@ func confirmKeyAck(key PublicKey, c packetConn) (bool, error) {}switch packet[0] {case msgUserAuthBanner:- // TODO(gpaul): add callback to present the banner to the user+ if err := handleBannerResponse(c, packet); err != nil {+ return false, err+ }case msgUserAuthPubKeyOk:var msg userAuthPubKeyOkMsgif err := Unmarshal(packet, &msg); err != nil {@@ -325,7 +327,9 @@ func handleAuthResponse(c packetConn) (bool, []string, error) {switch packet[0] {case msgUserAuthBanner:- // TODO: add callback to present the banner to the user+ if err := handleBannerResponse(c, packet); err != nil {+ return false, nil, err+ }case msgUserAuthFailure:var msg userAuthFailureMsgif err := Unmarshal(packet, &msg); err != nil {@@ -340,6 +344,24 @@ func handleAuthResponse(c packetConn) (bool, []string, error) {}}+func handleBannerResponse(c packetConn, packet []byte) error {+ var msg userAuthBannerMsg+ if err := Unmarshal(packet, &msg); err != nil {+ return err+ }++ transport, ok := c.(*handshakeTransport)+ if !ok {+ return nil+ }++ if transport.bannerCallback != nil {+ return transport.bannerCallback(msg.Message)+ }++ return nil+}+// KeyboardInteractiveChallenge should print questions, optionally// disabling echoing (e.g. for passwords), and return all the answers.// Challenge may be called multiple times in a single session. After@@ -385,7 +407,9 @@ func (cb KeyboardInteractiveChallenge) auth(session []byte, user string, c packe// like handleAuthResponse, but with less options.switch packet[0] {case msgUserAuthBanner:- // TODO: Print banners during userauth.+ if err := handleBannerResponse(c, packet); err != nil {+ return false, nil, err+ }continuecase msgUserAuthInfoRequest:// OKdiff --git a/vendor/golang.org/x/crypto/ssh/client_test.go b/vendor/golang.org/x/crypto/ssh/client_test.goindex ccf56074d..81f9599e1 100644--- a/vendor/golang.org/x/crypto/ssh/client_test.go+++ b/vendor/golang.org/x/crypto/ssh/client_test.go@@ -5,41 +5,77 @@package sshimport (- "net""strings""testing")-func testClientVersion(t *testing.T, config *ClientConfig, expected string) {- clientConn, serverConn := net.Pipe()- defer clientConn.Close()- receivedVersion := make(chan string, 1)- config.HostKeyCallback = InsecureIgnoreHostKey()- go func() {- version, err := readVersion(serverConn)- if err != nil {- receivedVersion <- ""- } else {- receivedVersion <- string(version)- }- serverConn.Close()- }()- NewClientConn(clientConn, "", config)- actual := <-receivedVersion- if actual != expected {- t.Fatalf("got %s; want %s", actual, expected)+func TestClientVersion(t *testing.T) {+ for _, tt := range []struct {+ name string+ version string+ multiLine string+ wantErr bool+ }{+ {+ name: "default version",+ version: packageVersion,+ },+ {+ name: "custom version",+ version: "SSH-2.0-CustomClientVersionString",+ },+ {+ name: "good multi line version",+ version: packageVersion,+ multiLine: strings.Repeat("ignored\r\n", 20),+ },+ {+ name: "bad multi line version",+ version: packageVersion,+ multiLine: "bad multi line version",+ wantErr: true,+ },+ {+ name: "long multi line version",+ version: packageVersion,+ multiLine: strings.Repeat("long multi line version\r\n", 50)[:256],+ wantErr: true,+ },+ } {+ t.Run(tt.name, func(t *testing.T) {+ c1, c2, err := netPipe()+ if err != nil {+ t.Fatalf("netPipe: %v", err)+ }+ defer c1.Close()+ defer c2.Close()+ go func() {+ if tt.multiLine != "" {+ c1.Write([]byte(tt.multiLine))+ }+ NewClientConn(c1, "", &ClientConfig{+ ClientVersion: tt.version,+ HostKeyCallback: InsecureIgnoreHostKey(),+ })+ c1.Close()+ }()+ conf := &ServerConfig{NoClientAuth: true}+ conf.AddHostKey(testSigners["rsa"])+ conn, _, _, err := NewServerConn(c2, conf)+ if err == nil == tt.wantErr {+ t.Fatalf("got err %v; wantErr %t", err, tt.wantErr)+ }+ if tt.wantErr {+ // Don't verify the version on an expected error.+ return+ }+ if got := string(conn.ClientVersion()); got != tt.version {+ t.Fatalf("got %q; want %q", got, tt.version)+ }+ })}}-func TestCustomClientVersion(t *testing.T) {- version := "Test-Client-Version-0.0"- testClientVersion(t, &ClientConfig{ClientVersion: version}, version)-}--func TestDefaultClientVersion(t *testing.T) {- testClientVersion(t, &ClientConfig{}, packageVersion)-}-func TestHostKeyCheck(t *testing.T) {for _, tt := range []struct {name string@@ -79,3 +115,52 @@ func TestHostKeyCheck(t *testing.T) {}}}++func TestBannerCallback(t *testing.T) {+ c1, c2, err := netPipe()+ if err != nil {+ t.Fatalf("netPipe: %v", err)+ }+ defer c1.Close()+ defer c2.Close()++ serverConf := &ServerConfig{+ PasswordCallback: func(conn ConnMetadata, password []byte) (*Permissions, error) {+ return &Permissions{}, nil+ },+ BannerCallback: func(conn ConnMetadata) string {+ return "Hello World"+ },+ }+ serverConf.AddHostKey(testSigners["rsa"])+ go NewServerConn(c1, serverConf)++ var receivedBanner string+ var bannerCount int+ clientConf := ClientConfig{+ Auth: []AuthMethod{+ Password("123"),+ },+ User: "user",+ HostKeyCallback: InsecureIgnoreHostKey(),+ BannerCallback: func(message string) error {+ bannerCount+++ receivedBanner = message+ return nil+ },+ }++ _, _, _, err = NewClientConn(c2, "", &clientConf)+ if err != nil {+ t.Fatal(err)+ }++ if bannerCount != 1 {+ t.Errorf("got %d banners; want 1", bannerCount)+ }++ expected := "Hello World"+ if receivedBanner != expected {+ t.Fatalf("got %s; want %s", receivedBanner, expected)+ }+}diff --git a/vendor/golang.org/x/crypto/ssh/common.go b/vendor/golang.org/x/crypto/ssh/common.goindex dc39e4d23..135b4edd7 100644--- a/vendor/golang.org/x/crypto/ssh/common.go+++ b/vendor/golang.org/x/crypto/ssh/common.go@@ -242,7 +242,7 @@ func (c *Config) SetDefaults() {// buildDataSignedForAuth returns the data that is signed in order to prove// possession of a private key. See RFC 4252, section 7.-func buildDataSignedForAuth(sessionId []byte, req userAuthRequestMsg, algo, pubKey []byte) []byte {+func buildDataSignedForAuth(sessionID []byte, req userAuthRequestMsg, algo, pubKey []byte) []byte {data := struct {Session []byteType byte@@ -253,7 +253,7 @@ func buildDataSignedForAuth(sessionId []byte, req userAuthRequestMsg, algo, pubKAlgo []bytePubKey []byte}{- sessionId,+ sessionID,msgUserAuthRequest,req.User,req.Service,diff --git a/vendor/golang.org/x/crypto/ssh/handshake.go b/vendor/golang.org/x/crypto/ssh/handshake.goindex 932ce8393..4f7912ecd 100644--- a/vendor/golang.org/x/crypto/ssh/handshake.go+++ b/vendor/golang.org/x/crypto/ssh/handshake.go@@ -78,6 +78,11 @@ type handshakeTransport struct {dialAddress stringremoteAddr net.Addr+ // bannerCallback is non-empty if we are the client and it has been set in+ // ClientConfig. In that case it is called during the user authentication+ // dance to handle a custom server's message.+ bannerCallback BannerCallback+// Algorithms agreed in the last key exchange.algorithms *algorithms@@ -120,6 +125,7 @@ func newClientTransport(conn keyingTransport, clientVersion, serverVersion []bytt.dialAddress = dialAddrt.remoteAddr = addrt.hostKeyCallback = config.HostKeyCallback+ t.bannerCallback = config.BannerCallbackif config.HostKeyAlgorithms != nil {t.hostKeyAlgorithms = config.HostKeyAlgorithms} else {diff --git a/vendor/golang.org/x/crypto/ssh/kex.go b/vendor/golang.org/x/crypto/ssh/kex.goindex f91c2770e..f34bcc013 100644--- a/vendor/golang.org/x/crypto/ssh/kex.go+++ b/vendor/golang.org/x/crypto/ssh/kex.go@@ -119,7 +119,7 @@ func (group *dhGroup) Client(c packetConn, randSource io.Reader, magics *handshareturn nil, err}- kInt, err := group.diffieHellman(kexDHReply.Y, x)+ ki, err := group.diffieHellman(kexDHReply.Y, x)if err != nil {return nil, err}@@ -129,8 +129,8 @@ func (group *dhGroup) Client(c packetConn, randSource io.Reader, magics *handshawriteString(h, kexDHReply.HostKey)writeInt(h, X)writeInt(h, kexDHReply.Y)- K := make([]byte, intLength(kInt))- marshalInt(K, kInt)+ K := make([]byte, intLength(ki))+ marshalInt(K, ki)h.Write(K)return &kexResult{@@ -164,7 +164,7 @@ func (group *dhGroup) Server(c packetConn, randSource io.Reader, magics *handsha}Y := new(big.Int).Exp(group.g, y, group.p)- kInt, err := group.diffieHellman(kexDHInit.X, y)+ ki, err := group.diffieHellman(kexDHInit.X, y)if err != nil {return nil, err}@@ -177,8 +177,8 @@ func (group *dhGroup) Server(c packetConn, randSource io.Reader, magics *handshawriteInt(h, kexDHInit.X)writeInt(h, Y)- K := make([]byte, intLength(kInt))- marshalInt(K, kInt)+ K := make([]byte, intLength(ki))+ marshalInt(K, ki)h.Write(K)H := h.Sum(nil)@@ -462,9 +462,9 @@ func (kex *curve25519sha256) Client(c packetConn, rand io.Reader, magics *handshwriteString(h, kp.pub[:])writeString(h, reply.EphemeralPubKey)- kInt := new(big.Int).SetBytes(secret[:])- K := make([]byte, intLength(kInt))- marshalInt(K, kInt)+ ki := new(big.Int).SetBytes(secret[:])+ K := make([]byte, intLength(ki))+ marshalInt(K, ki)h.Write(K)return &kexResult{@@ -510,9 +510,9 @@ func (kex *curve25519sha256) Server(c packetConn, rand io.Reader, magics *handshwriteString(h, kexInit.ClientPubKey)writeString(h, kp.pub[:])- kInt := new(big.Int).SetBytes(secret[:])- K := make([]byte, intLength(kInt))- marshalInt(K, kInt)+ ki := new(big.Int).SetBytes(secret[:])+ K := make([]byte, intLength(ki))+ marshalInt(K, ki)h.Write(K)H := h.Sum(nil)diff --git a/vendor/golang.org/x/crypto/ssh/keys.go b/vendor/golang.org/x/crypto/ssh/keys.goindex b682c1741..dadf41ab7 100644--- a/vendor/golang.org/x/crypto/ssh/keys.go+++ b/vendor/golang.org/x/crypto/ssh/keys.go@@ -363,7 +363,7 @@ func (r *rsaPublicKey) CryptoPublicKey() crypto.PublicKey {type dsaPublicKey dsa.PublicKey-func (r *dsaPublicKey) Type() string {+func (k *dsaPublicKey) Type() string {return "ssh-dss"}@@ -481,12 +481,12 @@ func (k *dsaPrivateKey) Sign(rand io.Reader, data []byte) (*Signature, error) {type ecdsaPublicKey ecdsa.PublicKey-func (key *ecdsaPublicKey) Type() string {- return "ecdsa-sha2-" + key.nistID()+func (k *ecdsaPublicKey) Type() string {+ return "ecdsa-sha2-" + k.nistID()}-func (key *ecdsaPublicKey) nistID() string {- switch key.Params().BitSize {+func (k *ecdsaPublicKey) nistID() string {+ switch k.Params().BitSize {case 256:return "nistp256"case 384:@@ -499,7 +499,7 @@ func (key *ecdsaPublicKey) nistID() string {type ed25519PublicKey ed25519.PublicKey-func (key ed25519PublicKey) Type() string {+func (k ed25519PublicKey) Type() string {return KeyAlgoED25519}@@ -518,23 +518,23 @@ func parseED25519(in []byte) (out PublicKey, rest []byte, err error) {return (ed25519PublicKey)(key), w.Rest, nil}-func (key ed25519PublicKey) Marshal() []byte {+func (k ed25519PublicKey) Marshal() []byte {w := struct {Name stringKeyBytes []byte}{KeyAlgoED25519,- []byte(key),+ []byte(k),}return Marshal(&w)}-func (key ed25519PublicKey) Verify(b []byte, sig *Signature) error {- if sig.Format != key.Type() {- return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, key.Type())+func (k ed25519PublicKey) Verify(b []byte, sig *Signature) error {+ if sig.Format != k.Type() {+ return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, k.Type())}- edKey := (ed25519.PublicKey)(key)+ edKey := (ed25519.PublicKey)(k)if ok := ed25519.Verify(edKey, b, sig.Blob); !ok {return errors.New("ssh: signature did not verify")}@@ -595,9 +595,9 @@ func parseECDSA(in []byte) (out PublicKey, rest []byte, err error) {return (*ecdsaPublicKey)(key), w.Rest, nil}-func (key *ecdsaPublicKey) Marshal() []byte {+func (k *ecdsaPublicKey) Marshal() []byte {// See RFC 5656, section 3.1.- keyBytes := elliptic.Marshal(key.Curve, key.X, key.Y)+ keyBytes := elliptic.Marshal(k.Curve, k.X, k.Y)// ECDSA publickey struct layout should match the struct used by// parseECDSACert in the x/crypto/ssh/agent package.w := struct {@@ -605,20 +605,20 @@ func (key *ecdsaPublicKey) Marshal() []byte {ID stringKey []byte}{- key.Type(),- key.nistID(),+ k.Type(),+ k.nistID(),keyBytes,}return Marshal(&w)}-func (key *ecdsaPublicKey) Verify(data []byte, sig *Signature) error {- if sig.Format != key.Type() {- return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, key.Type())+func (k *ecdsaPublicKey) Verify(data []byte, sig *Signature) error {+ if sig.Format != k.Type() {+ return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, k.Type())}- h := ecHash(key.Curve).New()+ h := ecHash(k.Curve).New()h.Write(data)digest := h.Sum(nil)@@ -635,7 +635,7 @@ func (key *ecdsaPublicKey) Verify(data []byte, sig *Signature) error {return err}- if ecdsa.Verify((*ecdsa.PublicKey)(key), digest, ecSig.R, ecSig.S) {+ if ecdsa.Verify((*ecdsa.PublicKey)(k), digest, ecSig.R, ecSig.S) {return nil}return errors.New("ssh: signature did not verify")@@ -758,7 +758,7 @@ func NewPublicKey(key interface{}) (PublicKey, error) {return (*rsaPublicKey)(key), nilcase *ecdsa.PublicKey:if !supportedEllipticCurve(key.Curve) {- return nil, errors.New("ssh: only P-256, P-384 and P-521 EC keys are supported.")+ return nil, errors.New("ssh: only P-256, P-384 and P-521 EC keys are supported")}return (*ecdsaPublicKey)(key), nilcase *dsa.PublicKey:diff --git a/vendor/golang.org/x/crypto/ssh/knownhosts/knownhosts.go b/vendor/golang.org/x/crypto/ssh/knownhosts/knownhosts.goindex ea92b2983..448fc07f8 100644--- a/vendor/golang.org/x/crypto/ssh/knownhosts/knownhosts.go+++ b/vendor/golang.org/x/crypto/ssh/knownhosts/knownhosts.go@@ -108,8 +108,8 @@ func wildcardMatch(pat []byte, str []byte) bool {}}-func (l *hostPattern) match(a addr) bool {- return wildcardMatch([]byte(l.addr.host), []byte(a.host)) && l.addr.port == a.port+func (p *hostPattern) match(a addr) bool {+ return wildcardMatch([]byte(p.addr.host), []byte(a.host)) && p.addr.port == a.port}type keyDBLine struct {diff --git a/vendor/golang.org/x/crypto/ssh/messages.go b/vendor/golang.org/x/crypto/ssh/messages.goindex e6ecd3afa..08d281173 100644--- a/vendor/golang.org/x/crypto/ssh/messages.go+++ b/vendor/golang.org/x/crypto/ssh/messages.go@@ -23,10 +23,6 @@ const (msgUnimplemented = 3msgDebug = 4msgNewKeys = 21-- // Standard authentication messages- msgUserAuthSuccess = 52- msgUserAuthBanner = 53)// SSH messages:@@ -137,6 +133,18 @@ type userAuthFailureMsg struct {PartialSuccess bool}+// See RFC 4252, section 5.1+const msgUserAuthSuccess = 52++// See RFC 4252, section 5.4+const msgUserAuthBanner = 53++type userAuthBannerMsg struct {+ Message string `sshtype:"53"`+ // unused, but required to allow message parsing+ Language string+}+// See RFC 4256, section 3.2const msgUserAuthInfoRequest = 60const msgUserAuthInfoResponse = 61@@ -154,7 +162,7 @@ const msgChannelOpen = 90type channelOpenMsg struct {ChanType string `sshtype:"90"`- PeersId uint32+ PeersID uint32PeersWindow uint32MaxPacketSize uint32TypeSpecificData []byte `ssh:"rest"`@@ -165,7 +173,7 @@ const msgChannelData = 94// Used for debug print outs of packets.type channelDataMsg struct {- PeersId uint32 `sshtype:"94"`+ PeersID uint32 `sshtype:"94"`Length uint32Rest []byte `ssh:"rest"`}@@ -174,8 +182,8 @@ type channelDataMsg struct {const msgChannelOpenConfirm = 91type channelOpenConfirmMsg struct {- PeersId uint32 `sshtype:"91"`- MyId uint32+ PeersID uint32 `sshtype:"91"`+ MyID uint32MyWindow uint32MaxPacketSize uint32TypeSpecificData []byte `ssh:"rest"`@@ -185,7 +193,7 @@ type channelOpenConfirmMsg struct {const msgChannelOpenFailure = 92type channelOpenFailureMsg struct {- PeersId uint32 `sshtype:"92"`+ PeersID uint32 `sshtype:"92"`Reason RejectionReasonMessage stringLanguage string@@ -194,7 +202,7 @@ type channelOpenFailureMsg struct {const msgChannelRequest = 98type channelRequestMsg struct {- PeersId uint32 `sshtype:"98"`+ PeersID uint32 `sshtype:"98"`Request stringWantReply boolRequestSpecificData []byte `ssh:"rest"`@@ -204,28 +212,28 @@ type channelRequestMsg struct {const msgChannelSuccess = 99type channelRequestSuccessMsg struct {- PeersId uint32 `sshtype:"99"`+ PeersID uint32 `sshtype:"99"`}// See RFC 4254, section 5.4.const msgChannelFailure = 100type channelRequestFailureMsg struct {- PeersId uint32 `sshtype:"100"`+ PeersID uint32 `sshtype:"100"`}// See RFC 4254, section 5.3const msgChannelClose = 97type channelCloseMsg struct {- PeersId uint32 `sshtype:"97"`+ PeersID uint32 `sshtype:"97"`}// See RFC 4254, section 5.3const msgChannelEOF = 96type channelEOFMsg struct {- PeersId uint32 `sshtype:"96"`+ PeersID uint32 `sshtype:"96"`}// See RFC 4254, section 4@@ -255,7 +263,7 @@ type globalRequestFailureMsg struct {const msgChannelWindowAdjust = 93type windowAdjustMsg struct {- PeersId uint32 `sshtype:"93"`+ PeersID uint32 `sshtype:"93"`AdditionalBytes uint32}diff --git a/vendor/golang.org/x/crypto/ssh/mux.go b/vendor/golang.org/x/crypto/ssh/mux.goindex 27a527c10..f19016270 100644--- a/vendor/golang.org/x/crypto/ssh/mux.go+++ b/vendor/golang.org/x/crypto/ssh/mux.go@@ -278,7 +278,7 @@ func (m *mux) handleChannelOpen(packet []byte) error {if msg.MaxPacketSize < minPacketLength || msg.MaxPacketSize > 1<<31 {failMsg := channelOpenFailureMsg{- PeersId: msg.PeersId,+ PeersID: msg.PeersID,Reason: ConnectionFailed,Message: "invalid request",Language: "en_US.UTF-8",@@ -287,7 +287,7 @@ func (m *mux) handleChannelOpen(packet []byte) error {}c := m.newChannel(msg.ChanType, channelInbound, msg.TypeSpecificData)- c.remoteId = msg.PeersId+ c.remoteId = msg.PeersIDc.maxRemotePayload = msg.MaxPacketSizec.remoteWin.add(msg.PeersWindow)m.incomingChannels <- c@@ -313,7 +313,7 @@ func (m *mux) openChannel(chanType string, extra []byte) (*channel, error) {PeersWindow: ch.myWindow,MaxPacketSize: ch.maxIncomingPayload,TypeSpecificData: extra,- PeersId: ch.localId,+ PeersID: ch.localId,}if err := m.sendMessage(open); err != nil {return nil, errdiff --git a/vendor/golang.org/x/crypto/ssh/server.go b/vendor/golang.org/x/crypto/ssh/server.goindex 8a78b7ca0..b83d47388 100644--- a/vendor/golang.org/x/crypto/ssh/server.go+++ b/vendor/golang.org/x/crypto/ssh/server.go@@ -95,6 +95,10 @@ type ServerConfig struct {// Note that RFC 4253 section 4.2 requires that this string start with// "SSH-2.0-".ServerVersion string++ // BannerCallback, if present, is called and the return string is sent to+ // the client after key exchange completed but before authentication.+ BannerCallback func(conn ConnMetadata) string}// AddHostKey adds a private key as a host key. If an existing host@@ -252,7 +256,7 @@ func (s *connection) serverHandshake(config *ServerConfig) (*Permissions, error)func isAcceptableAlgo(algo string) bool {switch algo {case KeyAlgoRSA, KeyAlgoDSA, KeyAlgoECDSA256, KeyAlgoECDSA384, KeyAlgoECDSA521, KeyAlgoED25519,- CertAlgoRSAv01, CertAlgoDSAv01, CertAlgoECDSA256v01, CertAlgoECDSA384v01, CertAlgoECDSA521v01:+ CertAlgoRSAv01, CertAlgoDSAv01, CertAlgoECDSA256v01, CertAlgoECDSA384v01, CertAlgoECDSA521v01, CertAlgoED25519v01:return true}return false@@ -312,6 +316,7 @@ func (s *connection) serverAuthenticate(config *ServerConfig) (*Permissions, errauthFailures := 0var authErrs []error+ var displayedBanner booluserAuthLoop:for {@@ -343,6 +348,20 @@ userAuthLoop:}s.user = userAuthReq.User++ if !displayedBanner && config.BannerCallback != nil {+ displayedBanner = true+ msg := config.BannerCallback(s)+ if msg != "" {+ bannerMsg := &userAuthBannerMsg{+ Message: msg,+ }+ if err := s.transport.writePacket(Marshal(bannerMsg)); err != nil {+ return nil, err+ }+ }+ }+perms = nilauthErr := errors.New("no auth passed yet")diff --git a/vendor/golang.org/x/crypto/ssh/session.go b/vendor/golang.org/x/crypto/ssh/session.goindex cc06e03f5..d3321f6b7 100644--- a/vendor/golang.org/x/crypto/ssh/session.go+++ b/vendor/golang.org/x/crypto/ssh/session.go@@ -406,7 +406,7 @@ func (s *Session) Wait() error {s.stdinPipeWriter.Close()}var copyError error- for _ = range s.copyFuncs {+ for range s.copyFuncs {if err := <-s.errors; err != nil && copyError == nil {copyError = err}diff --git a/vendor/golang.org/x/crypto/ssh/terminal/terminal.go b/vendor/golang.org/x/crypto/ssh/terminal/terminal.goindex 18379a935..9a887598f 100644--- a/vendor/golang.org/x/crypto/ssh/terminal/terminal.go+++ b/vendor/golang.org/x/crypto/ssh/terminal/terminal.go@@ -617,7 +617,7 @@ func writeWithCRLF(w io.Writer, buf []byte) (n int, err error) {if _, err = w.Write(crlf); err != nil {return n, err}- n += 1+ n++buf = buf[1:]}}diff --git a/vendor/golang.org/x/crypto/ssh/terminal/util.go b/vendor/golang.org/x/crypto/ssh/terminal/util.goindex e7404ff49..02dad484e 100644--- a/vendor/golang.org/x/crypto/ssh/terminal/util.go+++ b/vendor/golang.org/x/crypto/ssh/terminal/util.go@@ -17,44 +17,41 @@package terminal // import "golang.org/x/crypto/ssh/terminal"import (- "syscall"- "unsafe"-"golang.org/x/sys/unix")// State contains the state of a terminal.type State struct {- termios syscall.Termios+ termios unix.Termios}// IsTerminal returns true if the given file descriptor is a terminal.func IsTerminal(fd int) bool {- var termios syscall.Termios- _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)- return err == 0+ _, err := unix.IoctlGetTermios(fd, ioctlReadTermios)+ return err == nil}// MakeRaw put the terminal connected to the given file descriptor into raw// mode and returns the previous state of the terminal so that it can be// restored.func MakeRaw(fd int) (*State, error) {- var oldState State- if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlReadTermios, uintptr(unsafe.Pointer(&oldState.termios)), 0, 0, 0); err != 0 {+ termios, err := unix.IoctlGetTermios(fd, ioctlReadTermios)+ if err != nil {return nil, err}- newState := oldState.termios+ oldState := State{termios: *termios}+// This attempts to replicate the behaviour documented for cfmakeraw in// the termios(3) manpage.- newState.Iflag &^= syscall.IGNBRK | syscall.BRKINT | syscall.PARMRK | syscall.ISTRIP | syscall.INLCR | syscall.IGNCR | syscall.ICRNL | syscall.IXON- newState.Oflag &^= syscall.OPOST- newState.Lflag &^= syscall.ECHO | syscall.ECHONL | syscall.ICANON | syscall.ISIG | syscall.IEXTEN- newState.Cflag &^= syscall.CSIZE | syscall.PARENB- newState.Cflag |= syscall.CS8- newState.Cc[unix.VMIN] = 1- newState.Cc[unix.VTIME] = 0- if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlWriteTermios, uintptr(unsafe.Pointer(&newState)), 0, 0, 0); err != 0 {+ termios.Iflag &^= unix.IGNBRK | unix.BRKINT | unix.PARMRK | unix.ISTRIP | unix.INLCR | unix.IGNCR | unix.ICRNL | unix.IXON+ termios.Oflag &^= unix.OPOST+ termios.Lflag &^= unix.ECHO | unix.ECHONL | unix.ICANON | unix.ISIG | unix.IEXTEN+ termios.Cflag &^= unix.CSIZE | unix.PARENB+ termios.Cflag |= unix.CS8+ termios.Cc[unix.VMIN] = 1+ termios.Cc[unix.VTIME] = 0+ if err := unix.IoctlSetTermios(fd, ioctlWriteTermios, termios); err != nil {return nil, err}@@ -64,59 +61,55 @@ func MakeRaw(fd int) (*State, error) {// GetState returns the current state of a terminal which may be useful to// restore the terminal after a signal.func GetState(fd int) (*State, error) {- var oldState State- if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlReadTermios, uintptr(unsafe.Pointer(&oldState.termios)), 0, 0, 0); err != 0 {+ termios, err := unix.IoctlGetTermios(fd, ioctlReadTermios)+ if err != nil {return nil, err}- return &oldState, nil+ return &State{termios: *termios}, nil}// Restore restores the terminal connected to the given file descriptor to a// previous state.func Restore(fd int, state *State) error {- if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlWriteTermios, uintptr(unsafe.Pointer(&state.termios)), 0, 0, 0); err != 0 {- return err- }- return nil+ return unix.IoctlSetTermios(fd, ioctlWriteTermios, &state.termios)}// GetSize returns the dimensions of the given terminal.func GetSize(fd int) (width, height int, err error) {- var dimensions [4]uint16-- if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(syscall.TIOCGWINSZ), uintptr(unsafe.Pointer(&dimensions)), 0, 0, 0); err != 0 {+ ws, err := unix.IoctlGetWinsize(fd, unix.TIOCGWINSZ)+ if err != nil {return -1, -1, err}- return int(dimensions[1]), int(dimensions[0]), nil+ return int(ws.Col), int(ws.Row), nil}// passwordReader is an io.Reader that reads from a specific file descriptor.type passwordReader intfunc (r passwordReader) Read(buf []byte) (int, error) {- return syscall.Read(int(r), buf)+ return unix.Read(int(r), buf)}// ReadPassword reads a line of input from a terminal without local echo. This// is commonly used for inputting passwords and other sensitive data. The slice// returned does not include the \n.func ReadPassword(fd int) ([]byte, error) {- var oldState syscall.Termios- if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlReadTermios, uintptr(unsafe.Pointer(&oldState)), 0, 0, 0); err != 0 {+ termios, err := unix.IoctlGetTermios(fd, ioctlReadTermios)+ if err != nil {return nil, err}- newState := oldState- newState.Lflag &^= syscall.ECHO- newState.Lflag |= syscall.ICANON | syscall.ISIG- newState.Iflag |= syscall.ICRNL- if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlWriteTermios, uintptr(unsafe.Pointer(&newState)), 0, 0, 0); err != 0 {+ newState := *termios+ newState.Lflag &^= unix.ECHO+ newState.Lflag |= unix.ICANON | unix.ISIG+ newState.Iflag |= unix.ICRNL+ if err := unix.IoctlSetTermios(fd, ioctlWriteTermios, &newState); err != nil {return nil, err}defer func() {- syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlWriteTermios, uintptr(unsafe.Pointer(&oldState)), 0, 0, 0)+ unix.IoctlSetTermios(fd, ioctlWriteTermios, termios)}()return readPasswordLine(passwordReader(fd))diff --git a/vendor/golang.org/x/crypto/ssh/terminal/util_windows.go b/vendor/golang.org/x/crypto/ssh/terminal/util_windows.goindex 60979ccd0..92944f3b4 100644--- a/vendor/golang.org/x/crypto/ssh/terminal/util_windows.go+++ b/vendor/golang.org/x/crypto/ssh/terminal/util_windows.go@@ -17,6 +17,8 @@package terminalimport (+ "os"+"golang.org/x/sys/windows")@@ -71,13 +73,6 @@ func GetSize(fd int) (width, height int, err error) {return int(info.Size.X), int(info.Size.Y), nil}-// passwordReader is an io.Reader that reads from a specific Windows HANDLE.-type passwordReader int--func (r passwordReader) Read(buf []byte) (int, error) {- return windows.Read(windows.Handle(r), buf)-}-// ReadPassword reads a line of input from a terminal without local echo. This// is commonly used for inputting passwords and other sensitive data. The slice// returned does not include the \n.@@ -98,5 +93,5 @@ func ReadPassword(fd int) ([]byte, error) {windows.SetConsoleMode(windows.Handle(fd), old)}()- return readPasswordLine(passwordReader(fd))+ return readPasswordLine(os.NewFile(uintptr(fd), "stdin"))}diff --git a/vendor/golang.org/x/crypto/ssh/test/banner_test.go b/vendor/golang.org/x/crypto/ssh/test/banner_test.gonew file mode 100644index 000000000..d3b21ac76--- /dev/null+++ b/vendor/golang.org/x/crypto/ssh/test/banner_test.go@@ -0,0 +1,32 @@+// Copyright 2014 The Go Authors. All rights reserved.+// Use of this source code is governed by a BSD-style+// license that can be found in the LICENSE file.++// +build darwin dragonfly freebsd linux netbsd openbsd++package test++import (+ "testing"+)++func TestBannerCallbackAgainstOpenSSH(t *testing.T) {+ server := newServer(t)+ defer server.Shutdown()++ clientConf := clientConfig()++ var receivedBanner string+ clientConf.BannerCallback = func(message string) error {+ receivedBanner = message+ return nil+ }++ conn := server.Dial(clientConf)+ defer conn.Close()++ expected := "Server Banner"+ if receivedBanner != expected {+ t.Fatalf("got %v; want %v", receivedBanner, expected)+ }+}diff --git a/vendor/golang.org/x/crypto/ssh/test/doc.go b/vendor/golang.org/x/crypto/ssh/test/doc.goindex 3f9b3346d..198f0ca1e 100644--- a/vendor/golang.org/x/crypto/ssh/test/doc.go+++ b/vendor/golang.org/x/crypto/ssh/test/doc.go@@ -2,6 +2,6 @@// Use of this source code is governed by a BSD-style// license that can be found in the LICENSE file.-// This package contains integration tests for the+// Package test contains integration tests for the// golang.org/x/crypto/ssh package.package test // import "golang.org/x/crypto/ssh/test"diff --git a/vendor/golang.org/x/crypto/ssh/test/session_test.go b/vendor/golang.org/x/crypto/ssh/test/session_test.goindex 8238d9d90..9e702effa 100644--- a/vendor/golang.org/x/crypto/ssh/test/session_test.go+++ b/vendor/golang.org/x/crypto/ssh/test/session_test.go@@ -333,21 +333,22 @@ func TestCiphers(t *testing.T) {cipherOrder = append(cipherOrder, "aes128-cbc", "3des-cbc")for _, ciph := range cipherOrder {- server := newServer(t)- defer server.Shutdown()- conf := clientConfig()- conf.Ciphers = []string{ciph}- // Don't fail if sshd doesn't have the cipher.- conf.Ciphers = append(conf.Ciphers, cipherOrder...)- conn, err := server.TryDial(conf)- if err == nil {- conn.Close()- } else {- t.Fatalf("failed for cipher %q", ciph)- }+ t.Run(ciph, func(t *testing.T) {+ server := newServer(t)+ defer server.Shutdown()+ conf := clientConfig()+ conf.Ciphers = []string{ciph}+ // Don't fail if sshd doesn't have the cipher.+ conf.Ciphers = append(conf.Ciphers, cipherOrder...)+ conn, err := server.TryDial(conf)+ if err == nil {+ conn.Close()+ } else {+ t.Fatalf("failed for cipher %q", ciph)+ }+ })}}-func TestMACs(t *testing.T) {var config ssh.Configconfig.SetDefaults()diff --git a/vendor/golang.org/x/crypto/ssh/test/test_unix_test.go b/vendor/golang.org/x/crypto/ssh/test/test_unix_test.goindex e673536a8..15b879d35 100644--- a/vendor/golang.org/x/crypto/ssh/test/test_unix_test.go+++ b/vendor/golang.org/x/crypto/ssh/test/test_unix_test.go@@ -25,8 +25,9 @@ import ("golang.org/x/crypto/ssh/testdata")-const sshd_config = `+const sshdConfig = `Protocol 2+Banner {{.Dir}}/bannerHostKey {{.Dir}}/id_rsaHostKey {{.Dir}}/id_dsaHostKey {{.Dir}}/id_ecdsa@@ -50,7 +51,7 @@ HostbasedAuthentication noPubkeyAcceptedKeyTypes=*`-var configTmpl = template.Must(template.New("").Parse(sshd_config))+var configTmpl = template.Must(template.New("").Parse(sshdConfig))type server struct {t *testing.T@@ -256,6 +257,8 @@ func newServer(t *testing.T) *server {}f.Close()+ writeFile(filepath.Join(dir, "banner"), []byte("Server Banner"))+for k, v := range testdata.PEMBytes {filename := "id_" + kwriteFile(filepath.Join(dir, filename), v)@@ -268,7 +271,7 @@ func newServer(t *testing.T) *server {}var authkeys bytes.Buffer- for k, _ := range testdata.PEMBytes {+ for k := range testdata.PEMBytes {authkeys.Write(ssh.MarshalAuthorizedKey(testPublicKeys[k]))}writeFile(filepath.Join(dir, "authorized_keys"), authkeys.Bytes())diff --git a/vendor/golang.org/x/crypto/ssh/testdata/keys.go b/vendor/golang.org/x/crypto/ssh/testdata/keys.goindex 3b3d26c5b..521b6be97 100644--- a/vendor/golang.org/x/crypto/ssh/testdata/keys.go+++ b/vendor/golang.org/x/crypto/ssh/testdata/keys.go@@ -23,6 +23,27 @@ MHcCAQEEINGWx0zo6fhJ/0EAfrPzVFyFC9s18lBt3cRoEDhS3ARooAoGCCqGSM49AwEHoUQDQgAEi9Hdw6KvZcWxfg2IDhA7UkpDtzzt6ZqJXSsFdLd+Kx4S3Sx4cVO+6/ZOXRnPmNAlLUqjShUsUBBngG0u2fqEqA==-----END EC PRIVATE KEY-----+`),+ "ecdsap256": []byte(`-----BEGIN EC PRIVATE KEY-----+MHcCAQEEIAPCE25zK0PQSnsgVcEbM1mbKTASH4pqb5QJajplDwDZoAoGCCqGSM49+AwEHoUQDQgAEWy8TxGcIHRh5XGpO4dFVfDjeNY+VkgubQrf/eyFJZHxAn1SKraXU+qJUjTKj1z622OxYtJ5P7s9CfAEVsTzLCzg==+-----END EC PRIVATE KEY-----+`),+ "ecdsap384": []byte(`-----BEGIN EC PRIVATE KEY-----+MIGkAgEBBDBWfSnMuNKq8J9rQLzzEkx3KAoEohSXqhE/4CdjEYtoU2i22HW80DDS+qQhYNHRAduygBwYFK4EEACKhZANiAAQWaDMAd0HUd8ZiXCX7mYDDnC54gwH/nG43+VhCUEYmF7HMZm/B9Yn3GjFk3qYEDEvuF/52+NvUKBKKaLbh32AWxMv0ibcoba4cz+hL9+hWYhUD9XIUlzMWiZ2y6eBE9PdRI=+-----END EC PRIVATE KEY-----+`),+ "ecdsap521": []byte(`-----BEGIN EC PRIVATE KEY-----+MIHcAgEBBEIBrkYpQcy8KTVHNiAkjlFZwee90224Bu6wz94R4OBo+Ts0eoAQG7SF+iaygEDMUbx6kTgXTBcKZ0jrWPKakayNZ/kigBwYFK4EEACOhgYkDgYYABADFuvLV+UoaCDGHcw5uNfdRIsvaLKuWSpLsl48eWGZAwdNG432GDVKduO+pceuE+8XzcyJb++uMv+D2b11Q/LQUcHJwE6fqbm8m3EtDKPsoKs0u/XUJb0JsH4J8lkZzbUTjvGYamn+FFlRjzoB3Oxu8UQgb+MWPedtH9XYBbg9biz4jJLkXQ==+-----END EC PRIVATE KEY-----`),"rsa": []byte(`-----BEGIN RSA PRIVATE KEY-----MIICXAIBAAKBgQC8A6FGHDiWCSREAXCq6yBfNVr0xCVG2CzvktFNRpue+RXrGs/2diff --git a/vendor/golang.org/x/crypto/ssh/transport.go b/vendor/golang.org/x/crypto/ssh/transport.goindex f9780e0ae..82da0d75c 100644--- a/vendor/golang.org/x/crypto/ssh/transport.go+++ b/vendor/golang.org/x/crypto/ssh/transport.go@@ -6,6 +6,7 @@ package sshimport ("bufio"+ "bytes""errors""io""log"@@ -76,17 +77,17 @@ type connectionState struct {// both directions are triggered by reading and writing a msgNewKey packet// respectively.func (t *transport) prepareKeyChange(algs *algorithms, kexResult *kexResult) error {- if ciph, err := newPacketCipher(t.reader.dir, algs.r, kexResult); err != nil {+ ciph, err := newPacketCipher(t.reader.dir, algs.r, kexResult)+ if err != nil {return err- } else {- t.reader.pendingKeyChange <- ciph}+ t.reader.pendingKeyChange <- ciph- if ciph, err := newPacketCipher(t.writer.dir, algs.w, kexResult); err != nil {+ ciph, err = newPacketCipher(t.writer.dir, algs.w, kexResult)+ if err != nil {return err- } else {- t.writer.pendingKeyChange <- ciph}+ t.writer.pendingKeyChange <- ciphreturn nil}@@ -139,7 +140,7 @@ func (s *connectionState) readPacket(r *bufio.Reader) ([]byte, error) {case cipher := <-s.pendingKeyChange:s.packetCipher = cipherdefault:- return nil, errors.New("ssh: got bogus newkeys message.")+ return nil, errors.New("ssh: got bogus newkeys message")}case msgDisconnect:@@ -254,7 +255,7 @@ func newPacketCipher(d direction, algs directionAlgorithms, kex *kexResult) (paciv, key, macKey := generateKeys(d, algs, kex)if algs.Cipher == gcmCipherID {- return newGCMCipher(iv, key, macKey)+ return newGCMCipher(iv, key)}if algs.Cipher == aes128cbcID {@@ -342,7 +343,7 @@ func readVersion(r io.Reader) ([]byte, error) {var ok boolvar buf [1]byte- for len(versionString) < maxVersionStringBytes {+ for length := 0; length < maxVersionStringBytes; length++ {_, err := io.ReadFull(r, buf[:])if err != nil {return nil, err@@ -350,6 +351,13 @@ func readVersion(r io.Reader) ([]byte, error) {// The RFC says that the version should be terminated with \r\n// but several SSH servers actually only send a \n.if buf[0] == '\n' {+ if !bytes.HasPrefix(versionString, []byte("SSH-")) {+ // RFC 4253 says we need to ignore all version string lines+ // except the one containing the SSH version (provided that+ // all the lines do not exceed 255 bytes in total).+ versionString = versionString[:0]+ continue+ }ok = truebreak}diff --git a/vendor/golang.org/x/crypto/ssh/transport_test.go b/vendor/golang.org/x/crypto/ssh/transport_test.goindex 92d83abf9..8445e1e56 100644--- a/vendor/golang.org/x/crypto/ssh/transport_test.go+++ b/vendor/golang.org/x/crypto/ssh/transport_test.go@@ -13,11 +13,13 @@ import ()func TestReadVersion(t *testing.T) {- longversion := strings.Repeat("SSH-2.0-bla", 50)[:253]+ longVersion := strings.Repeat("SSH-2.0-bla", 50)[:253]+ multiLineVersion := strings.Repeat("ignored\r\n", 20) + "SSH-2.0-bla\r\n"cases := map[string]string{"SSH-2.0-bla\r\n": "SSH-2.0-bla","SSH-2.0-bla\n": "SSH-2.0-bla",- longversion + "\r\n": longversion,+ multiLineVersion: "SSH-2.0-bla",+ longVersion + "\r\n": longVersion,}for in, want := range cases {@@ -33,9 +35,11 @@ func TestReadVersion(t *testing.T) {}func TestReadVersionError(t *testing.T) {- longversion := strings.Repeat("SSH-2.0-bla", 50)[:253]+ longVersion := strings.Repeat("SSH-2.0-bla", 50)[:253]+ multiLineVersion := strings.Repeat("ignored\r\n", 50) + "SSH-2.0-bla\r\n"cases := []string{- longversion + "too-long\r\n",+ longVersion + "too-long\r\n",+ multiLineVersion,}for _, in := range cases {if _, err := readVersion(bytes.NewBufferString(in)); err == nil {@@ -60,7 +64,7 @@ func TestExchangeVersionsBasic(t *testing.T) {func TestExchangeVersions(t *testing.T) {cases := []string{"not\x000allowed",- "not allowed\n",+ "not allowed\x01\r\n",}for _, c := range cases {buf := bytes.NewBufferString("SSH-2.0-bla\r\n")diff --git a/vendor/golang.org/x/crypto/tea/cipher.go b/vendor/golang.org/x/crypto/tea/cipher.goindex 9c13d12a2..ce223b2c2 100644--- a/vendor/golang.org/x/crypto/tea/cipher.go+++ b/vendor/golang.org/x/crypto/tea/cipher.go@@ -5,7 +5,6 @@// Package tea implements the TEA algorithm, as defined in Needham and// Wheeler's 1994 technical report, “TEA, a Tiny Encryption Algorithm”. See// http://www.cix.co.uk/~klockstone/tea.pdf for details.-package teaimport (diff --git a/vendor/golang.org/x/crypto/xtea/cipher.go b/vendor/golang.org/x/crypto/xtea/cipher.goindex 108b42635..66ea0df16 100644--- a/vendor/golang.org/x/crypto/xtea/cipher.go+++ b/vendor/golang.org/x/crypto/xtea/cipher.go@@ -69,7 +69,7 @@ func initCipher(c *Cipher, key []byte) {// Precalculate the tableconst delta = 0x9E3779B9- var sum uint32 = 0+ var sum uint32// Two rounds of XTEA applied per loopfor i := 0; i < numRounds; {