all: use error wrap when possible

sapk · sapk · commit 7527590b58de · 2023-03-01T22:38:27.000+01:00
diff --git a/acme/acme.go b/acme/acme.go
@@ -373,7 +373,7 @@ func (c *Client) authorize(ctx context.Context, typ, val string) (*Authorization
 
 	var v wireAuthz
 	if err := json.NewDecoder(res.Body).Decode(&v); err != nil {
-		return nil, fmt.Errorf("acme: invalid response: %v", err)
+		return nil, fmt.Errorf("acme: invalid response: %w", err)
 	}
 	if v.Status != StatusPending && v.Status != StatusValid {
 		return nil, fmt.Errorf("acme: unexpected status: %s", v.Status)
@@ -397,7 +397,7 @@ func (c *Client) GetAuthorization(ctx context.Context, url string) (*Authorizati
 	defer res.Body.Close()
 	var v wireAuthz
 	if err := json.NewDecoder(res.Body).Decode(&v); err != nil {
-		return nil, fmt.Errorf("acme: invalid response: %v", err)
+		return nil, fmt.Errorf("acme: invalid response: %w", err)
 	}
 	return v.authorization(url), nil
 }
@@ -500,7 +500,7 @@ func (c *Client) GetChallenge(ctx context.Context, url string) (*Challenge, erro
 	defer res.Body.Close()
 	v := wireChallenge{URI: url}
 	if err := json.NewDecoder(res.Body).Decode(&v); err != nil {
-		return nil, fmt.Errorf("acme: invalid response: %v", err)
+		return nil, fmt.Errorf("acme: invalid response: %w", err)
 	}
 	return v.challenge(), nil
 }
@@ -525,7 +525,7 @@ func (c *Client) Accept(ctx context.Context, chal *Challenge) (*Challenge, error
 
 	var v wireChallenge
 	if err := json.NewDecoder(res.Body).Decode(&v); err != nil {
-		return nil, fmt.Errorf("acme: invalid response: %v", err)
+		return nil, fmt.Errorf("acme: invalid response: %w", err)
 	}
 	return v.challenge(), nil
 }
diff --git a/acme/autocert/internal/acmetest/ca.go b/acme/autocert/internal/acmetest/ca.go
@@ -467,7 +467,7 @@ func (ca *CAServer) handle(w http.ResponseWriter, r *http.Request) {
 func (ca *CAServer) storedOrder(i string) (*order, error) {
 	idx, err := strconv.Atoi(i)
 	if err != nil {
-		return nil, fmt.Errorf("storedOrder: %v", err)
+		return nil, fmt.Errorf("storedOrder: %w", err)
 	}
 	if idx < 0 {
 		return nil, fmt.Errorf("storedOrder: invalid order index %d", idx)
@@ -485,7 +485,7 @@ func (ca *CAServer) storedOrder(i string) (*order, error) {
 func (ca *CAServer) storedAuthz(i string) (*authorization, error) {
 	idx, err := strconv.Atoi(i)
 	if err != nil {
-		return nil, fmt.Errorf("storedAuthz: %v", err)
+		return nil, fmt.Errorf("storedAuthz: %w", err)
 	}
 	if idx < 0 {
 		return nil, fmt.Errorf("storedAuthz: invalid authz index %d", idx)
@@ -700,7 +700,7 @@ func (ca *CAServer) verifyALPNChallenge(a *authorization) error {
 	}
 
 	if err := crt.VerifyHostname(a.domain); err != nil {
-		return fmt.Errorf("verifyALPNChallenge: VerifyHostname: %v", err)
+		return fmt.Errorf("verifyALPNChallenge: VerifyHostname: %w", err)
 	}
 	// See RFC 8737, Section 6.1.
 	oid := asn1.ObjectIdentifier{1, 3, 6, 1, 5, 5, 7, 1, 31}
diff --git a/acme/internal/acmeprobe/prober.go b/acme/internal/acmeprobe/prober.go
@@ -301,7 +301,7 @@ func (p *prober) fulfill(ctx context.Context, z *acme.Authorization) error {
 func (p *prober) runTLSALPN01(ctx context.Context, z *acme.Authorization, chal *acme.Challenge) error {
 	tokenCert, err := p.client.TLSALPN01ChallengeCert(chal.Token, z.Identifier.Value)
 	if err != nil {
-		return fmt.Errorf("TLSALPN01ChallengeCert: %v", err)
+		return fmt.Errorf("TLSALPN01ChallengeCert: %w", err)
 	}
 	s := &http.Server{
 		Addr: p.localAddr,
@@ -321,7 +321,7 @@ func (p *prober) runTLSALPN01(ctx context.Context, z *acme.Authorization, chal *
 	defer s.Close()
 
 	if _, err := p.client.Accept(ctx, chal); err != nil {
-		return fmt.Errorf("Accept(%q): %v", chal.URI, err)
+		return fmt.Errorf("Accept(%q): %w", chal.URI, err)
 	}
 	_, zerr := p.client.WaitAuthorization(ctx, z.URI)
 	return zerr
@@ -330,7 +330,7 @@ func (p *prober) runTLSALPN01(ctx context.Context, z *acme.Authorization, chal *
 func (p *prober) runHTTP01(ctx context.Context, z *acme.Authorization, chal *acme.Challenge) error {
 	body, err := p.client.HTTP01ChallengeResponse(chal.Token)
 	if err != nil {
-		return fmt.Errorf("HTTP01ChallengeResponse: %v", err)
+		return fmt.Errorf("HTTP01ChallengeResponse: %w", err)
 	}
 	s := &http.Server{
 		Addr: p.localAddr,
@@ -347,7 +347,7 @@ func (p *prober) runHTTP01(ctx context.Context, z *acme.Authorization, chal *acm
 	defer s.Close()
 
 	if _, err := p.client.Accept(ctx, chal); err != nil {
-		return fmt.Errorf("Accept(%q): %v", chal.URI, err)
+		return fmt.Errorf("Accept(%q): %w", chal.URI, err)
 	}
 	_, zerr := p.client.WaitAuthorization(ctx, z.URI)
 	return zerr
@@ -356,7 +356,7 @@ func (p *prober) runHTTP01(ctx context.Context, z *acme.Authorization, chal *acm
 func (p *prober) runDNS01(ctx context.Context, z *acme.Authorization, chal *acme.Challenge) error {
 	token, err := p.client.DNS01ChallengeRecord(chal.Token)
 	if err != nil {
-		return fmt.Errorf("DNS01ChallengeRecord: %v", err)
+		return fmt.Errorf("DNS01ChallengeRecord: %w", err)
 	}
 
 	name := fmt.Sprintf("_acme-challenge.%s", z.Identifier.Value)
@@ -365,11 +365,11 @@ func (p *prober) runDNS01(ctx context.Context, z *acme.Authorization, chal *acme
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 	if err := cmd.Run(); err != nil {
-		return fmt.Errorf("%s: %v", p.dnsScript, err)
+		return fmt.Errorf("%s: %w", p.dnsScript, err)
 	}
 
 	if _, err := p.client.Accept(ctx, chal); err != nil {
-		return fmt.Errorf("Accept(%q): %v", chal.URI, err)
+		return fmt.Errorf("Accept(%q): %w", chal.URI, err)
 	}
 	_, zerr := p.client.WaitAuthorization(ctx, z.URI)
 	return zerr
@@ -389,7 +389,7 @@ func checkCert(derChain [][]byte, id []acme.AuthzID) error {
 	for i, b := range derChain {
 		crt, err := x509.ParseCertificate(b)
 		if err != nil {
-			return fmt.Errorf("%d: ParseCertificate: %v", i, err)
+			return fmt.Errorf("%d: ParseCertificate: %w", i, err)
 		}
 		log.Printf("%d: serial: 0x%s", i, crt.SerialNumber)
 		log.Printf("%d: subject: %s", i, crt.Subject)
diff --git a/acme/rfc8555.go b/acme/rfc8555.go
@@ -60,7 +60,7 @@ func (c *Client) registerRFC(ctx context.Context, acct *Account, prompt func(tos
 	if acct.ExternalAccountBinding != nil {
 		eabJWS, err := c.encodeExternalAccountBinding(acct.ExternalAccountBinding)
 		if err != nil {
-			return nil, fmt.Errorf("acme: failed to encode external account binding: %v", err)
+			return nil, fmt.Errorf("acme: failed to encode external account binding: %w", err)
 		}
 		req.ExternalAccountBinding = eabJWS
 	}
@@ -140,7 +140,7 @@ func responseAccount(res *http.Response) (*Account, error) {
 		Orders  string
 	}
 	if err := json.NewDecoder(res.Body).Decode(&v); err != nil {
-		return nil, fmt.Errorf("acme: invalid account response: %v", err)
+		return nil, fmt.Errorf("acme: invalid account response: %w", err)
 	}
 	return &Account{
 		URI:       res.Header.Get("Location"),
@@ -307,7 +307,7 @@ func responseOrder(res *http.Response) (*Order, error) {
 		Certificate    string
 	}
 	if err := json.NewDecoder(res.Body).Decode(&v); err != nil {
-		return nil, fmt.Errorf("acme: error reading order: %v", err)
+		return nil, fmt.Errorf("acme: error reading order: %w", err)
 	}
 	o := &Order{
 		URI:         res.Header.Get("Location"),
@@ -391,7 +391,7 @@ func (c *Client) fetchCertRFC(ctx context.Context, url string, bundle bool) ([][
 	const max = maxCertChainSize + maxCertChainSize/33
 	b, err := io.ReadAll(io.LimitReader(res.Body, max+1))
 	if err != nil {
-		return nil, fmt.Errorf("acme: fetch cert response stream: %v", err)
+		return nil, fmt.Errorf("acme: fetch cert response stream: %w", err)
 	}
 	if len(b) > max {
 		return nil, errors.New("acme: certificate chain is too big")
@@ -469,7 +469,7 @@ func (c *Client) ListCertAlternates(ctx context.Context, url string) ([]string,
 	// We don't need the body but we need to discard it so we don't end up
 	// preventing keep-alive
 	if _, err := io.Copy(io.Discard, res.Body); err != nil {
-		return nil, fmt.Errorf("acme: cert alternates response stream: %v", err)
+		return nil, fmt.Errorf("acme: cert alternates response stream: %w", err)
 	}
 	alts := linkHeader(res.Header, "alternate")
 	return alts, nil
diff --git a/ssh/agent/client.go b/ssh/agent/client.go
@@ -240,7 +240,7 @@ type Key struct {
 }
 
 func clientErr(err error) error {
-	return fmt.Errorf("agent: client error: %v", err)
+	return fmt.Errorf("agent: client error: %w", err)
 }
 
 // String returns the storage form of an agent key with the format, base64
@@ -269,7 +269,7 @@ func (k *Key) Marshal() []byte {
 func (k *Key) Verify(data []byte, sig *ssh.Signature) error {
 	pubKey, err := ssh.ParsePublicKey(k.Blob)
 	if err != nil {
-		return fmt.Errorf("agent: bad public key: %v", err)
+		return fmt.Errorf("agent: bad public key: %w", err)
 	}
 	return pubKey.Verify(data, sig)
 }
diff --git a/ssh/agent/server.go b/ssh/agent/server.go
@@ -387,7 +387,7 @@ func parseRSACert(req []byte) (*AddedKey, error) {
 		N    *big.Int
 	}
 	if err := ssh.Unmarshal(cert.Key.Marshal(), &rsaPub); err != nil {
-		return nil, fmt.Errorf("agent: Unmarshal failed to parse public key: %v", err)
+		return nil, fmt.Errorf("agent: Unmarshal failed to parse public key: %w", err)
 	}
 
 	if rsaPub.E.BitLen() > 30 {
@@ -431,7 +431,7 @@ func parseDSACert(req []byte) (*AddedKey, error) {
 		P, Q, G, Y *big.Int
 	}
 	if err := ssh.Unmarshal(cert.Key.Marshal(), &w); err != nil {
-		return nil, fmt.Errorf("agent: Unmarshal failed to parse public key: %v", err)
+		return nil, fmt.Errorf("agent: Unmarshal failed to parse public key: %w", err)
 	}
 
 	priv := &dsa.PrivateKey{
diff --git a/ssh/client.go b/ssh/client.go
@@ -82,7 +82,7 @@ func NewClientConn(c net.Conn, addr string, config *ClientConfig) (Conn, <-chan
 
 	if err := conn.clientHandshake(addr, &fullConf); err != nil {
 		c.Close()
-		return nil, nil, nil, fmt.Errorf("ssh: handshake failed: %v", err)
+		return nil, nil, nil, fmt.Errorf("ssh: handshake failed: %w", err)
 	}
 	conn.mux = newMux(conn.transport)
 	return conn, conn.mux.incomingChannels, conn.mux.incomingRequests, nil
diff --git a/ssh/keys.go b/ssh/keys.go
@@ -1139,7 +1139,7 @@ func ParseRawPrivateKeyWithPassphrase(pemBytes, passphrase []byte) (interface{},
 		if err == x509.IncorrectPasswordError {
 			return nil, err
 		}
-		return nil, fmt.Errorf("ssh: cannot decode encrypted private keys: %v", err)
+		return nil, fmt.Errorf("ssh: cannot decode encrypted private keys: %w", err)
 	}
 
 	switch block.Type {
@@ -1277,7 +1277,7 @@ func parseOpenSSHPrivateKey(key []byte, decrypt openSSHDecryptFunc) (crypto.Priv
 		if err, ok := err.(*PassphraseMissingError); ok {
 			pub, errPub := ParsePublicKey(w.PubKey)
 			if errPub != nil {
-				return nil, fmt.Errorf("ssh: failed to parse embedded public key: %v", errPub)
+				return nil, fmt.Errorf("ssh: failed to parse embedded public key: %w", errPub)
 			}
 			err.PublicKey = pub
 		}
diff --git a/ssh/knownhosts/knownhosts.go b/ssh/knownhosts/knownhosts.go
@@ -333,15 +333,15 @@ func (db *hostKeyDB) check(address string, remote net.Addr, remoteKey ssh.Public
 
 	host, port, err := net.SplitHostPort(remote.String())
 	if err != nil {
-		return fmt.Errorf("knownhosts: SplitHostPort(%s): %v", remote, err)
+		return fmt.Errorf("knownhosts: SplitHostPort(%s): %w", remote, err)
 	}
 
 	hostToCheck := addr{host, port}
 	if address != "" {
 		// Give preference to the hostname if available.
 		host, port, err := net.SplitHostPort(address)
 		if err != nil {
-			return fmt.Errorf("knownhosts: SplitHostPort(%s): %v", address, err)
+			return fmt.Errorf("knownhosts: SplitHostPort(%s): %w", address, err)
 		}
 
 		hostToCheck = addr{host, port}
@@ -402,7 +402,7 @@ func (db *hostKeyDB) Read(r io.Reader, filename string) error {
 		}
 
 		if err := db.parseLine(line, filename, lineNum); err != nil {
-			return fmt.Errorf("knownhosts: %s:%d: %v", filename, lineNum, err)
+			return fmt.Errorf("knownhosts: %s:%d: %w", filename, lineNum, err)
 		}
 	}
 	return scanner.Err()
diff --git a/ssh/server.go b/ssh/server.go
@@ -309,7 +309,7 @@ func checkSourceAddress(addr net.Addr, sourceAddrs string) error {
 		} else {
 			_, ipNet, err := net.ParseCIDR(sourceAddr)
 			if err != nil {
-				return fmt.Errorf("ssh: error parsing source-address restriction %q: %v", sourceAddr, err)
+				return fmt.Errorf("ssh: error parsing source-address restriction %q: %w", sourceAddr, err)
 			}
 
 			if ipNet.Contains(tcpAddr.IP) {
diff --git a/ssh/tcpip.go b/ssh/tcpip.go
@@ -81,7 +81,7 @@ func (c *Client) autoPortListenWorkaround(laddr *net.TCPAddr) (net.Listener, err
 			return sshListener, err
 		}
 	}
-	return nil, fmt.Errorf("ssh: listen on random port failed after %d tries: %v", tries, err)
+	return nil, fmt.Errorf("ssh: listen on random port failed after %d tries: %w", tries, err)
 }
 
 // RFC 4254 7.1

Original file line number	Diff line number	Diff line change
`@@ -373,7 +373,7 @@ func (c Client) authorize(ctx context.Context, typ, val string) (Authorization`
`373`	`373`
`374`	`374`	`var v wireAuthz`
`375`	`375`	`if err := json.NewDecoder(res.Body).Decode(&v); err != nil {`
`376`		`- return nil, fmt.Errorf("acme: invalid response: %v", err)`
	`376`	`+ return nil, fmt.Errorf("acme: invalid response: %w", err)`
`377`	`377`	`}`
`378`	`378`	`if v.Status != StatusPending && v.Status != StatusValid {`
`379`	`379`	`return nil, fmt.Errorf("acme: unexpected status: %s", v.Status)`
`@@ -397,7 +397,7 @@ func (c Client) GetAuthorization(ctx context.Context, url string) (Authorizati`
`397`	`397`	`defer res.Body.Close()`
`398`	`398`	`var v wireAuthz`
`399`	`399`	`if err := json.NewDecoder(res.Body).Decode(&v); err != nil {`
`400`		`- return nil, fmt.Errorf("acme: invalid response: %v", err)`
	`400`	`+ return nil, fmt.Errorf("acme: invalid response: %w", err)`
`401`	`401`	`}`
`402`	`402`	`return v.authorization(url), nil`
`403`	`403`	`}`
`@@ -500,7 +500,7 @@ func (c Client) GetChallenge(ctx context.Context, url string) (Challenge, erro`
`500`	`500`	`defer res.Body.Close()`
`501`	`501`	`v := wireChallenge{URI: url}`
`502`	`502`	`if err := json.NewDecoder(res.Body).Decode(&v); err != nil {`
`503`		`- return nil, fmt.Errorf("acme: invalid response: %v", err)`
	`503`	`+ return nil, fmt.Errorf("acme: invalid response: %w", err)`
`504`	`504`	`}`
`505`	`505`	`return v.challenge(), nil`
`506`	`506`	`}`
`@@ -525,7 +525,7 @@ func (c Client) Accept(ctx context.Context, chal Challenge) (*Challenge, error`
`525`	`525`
`526`	`526`	`var v wireChallenge`
`527`	`527`	`if err := json.NewDecoder(res.Body).Decode(&v); err != nil {`
`528`		`- return nil, fmt.Errorf("acme: invalid response: %v", err)`
	`528`	`+ return nil, fmt.Errorf("acme: invalid response: %w", err)`
`529`	`529`	`}`
`530`	`530`	`return v.challenge(), nil`
`531`	`531`	`}`
Original file line number	Diff line number	Diff line change
`@@ -467,7 +467,7 @@ func (ca CAServer) handle(w http.ResponseWriter, r http.Request) {`
`467`	`467`	`func (ca CAServer) storedOrder(i string) (order, error) {`
`468`	`468`	`idx, err := strconv.Atoi(i)`
`469`	`469`	`if err != nil {`
`470`		`- return nil, fmt.Errorf("storedOrder: %v", err)`
	`470`	`+ return nil, fmt.Errorf("storedOrder: %w", err)`
`471`	`471`	`}`
`472`	`472`	`if idx < 0 {`
`473`	`473`	`return nil, fmt.Errorf("storedOrder: invalid order index %d", idx)`
`@@ -485,7 +485,7 @@ func (ca CAServer) storedOrder(i string) (order, error) {`
`485`	`485`	`func (ca CAServer) storedAuthz(i string) (authorization, error) {`
`486`	`486`	`idx, err := strconv.Atoi(i)`
`487`	`487`	`if err != nil {`
`488`		`- return nil, fmt.Errorf("storedAuthz: %v", err)`
	`488`	`+ return nil, fmt.Errorf("storedAuthz: %w", err)`
`489`	`489`	`}`
`490`	`490`	`if idx < 0 {`
`491`	`491`	`return nil, fmt.Errorf("storedAuthz: invalid authz index %d", idx)`
`@@ -700,7 +700,7 @@ func (ca CAServer) verifyALPNChallenge(a authorization) error {`
`700`	`700`	`}`
`701`	`701`
`702`	`702`	`if err := crt.VerifyHostname(a.domain); err != nil {`
`703`		`- return fmt.Errorf("verifyALPNChallenge: VerifyHostname: %v", err)`
	`703`	`+ return fmt.Errorf("verifyALPNChallenge: VerifyHostname: %w", err)`
`704`	`704`	`}`
`705`	`705`	`// See RFC 8737, Section 6.1.`
`706`	`706`	`oid := asn1.ObjectIdentifier{1, 3, 6, 1, 5, 5, 7, 1, 31}`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ func (c Client) registerRFC(ctx context.Context, acct Account, prompt func(tos`
`60`	`60`	`if acct.ExternalAccountBinding != nil {`
`61`	`61`	`eabJWS, err := c.encodeExternalAccountBinding(acct.ExternalAccountBinding)`
`62`	`62`	`if err != nil {`
`63`		`- return nil, fmt.Errorf("acme: failed to encode external account binding: %v", err)`
	`63`	`+ return nil, fmt.Errorf("acme: failed to encode external account binding: %w", err)`
`64`	`64`	`}`
`65`	`65`	`req.ExternalAccountBinding = eabJWS`
`66`	`66`	`}`
`@@ -140,7 +140,7 @@ func responseAccount(res http.Response) (Account, error) {`
`140`	`140`	`Orders string`
`141`	`141`	`}`
`142`	`142`	`if err := json.NewDecoder(res.Body).Decode(&v); err != nil {`
`143`		`- return nil, fmt.Errorf("acme: invalid account response: %v", err)`
	`143`	`+ return nil, fmt.Errorf("acme: invalid account response: %w", err)`
`144`	`144`	`}`
`145`	`145`	`return &Account{`
`146`	`146`	`URI: res.Header.Get("Location"),`
`@@ -307,7 +307,7 @@ func responseOrder(res http.Response) (Order, error) {`
`307`	`307`	`Certificate string`
`308`	`308`	`}`
`309`	`309`	`if err := json.NewDecoder(res.Body).Decode(&v); err != nil {`
`310`		`- return nil, fmt.Errorf("acme: error reading order: %v", err)`
	`310`	`+ return nil, fmt.Errorf("acme: error reading order: %w", err)`
`311`	`311`	`}`
`312`	`312`	`o := &Order{`
`313`	`313`	`URI: res.Header.Get("Location"),`
`@@ -391,7 +391,7 @@ func (c *Client) fetchCertRFC(ctx context.Context, url string, bundle bool) ([][`
`391`	`391`	`const max = maxCertChainSize + maxCertChainSize/33`
`392`	`392`	`b, err := io.ReadAll(io.LimitReader(res.Body, max+1))`
`393`	`393`	`if err != nil {`
`394`		`- return nil, fmt.Errorf("acme: fetch cert response stream: %v", err)`
	`394`	`+ return nil, fmt.Errorf("acme: fetch cert response stream: %w", err)`
`395`	`395`	`}`
`396`	`396`	`if len(b) > max {`
`397`	`397`	`return nil, errors.New("acme: certificate chain is too big")`
`@@ -469,7 +469,7 @@ func (c *Client) ListCertAlternates(ctx context.Context, url string) ([]string,`
`469`	`469`	`// We don't need the body but we need to discard it so we don't end up`
`470`	`470`	`// preventing keep-alive`
`471`	`471`	`if _, err := io.Copy(io.Discard, res.Body); err != nil {`
`472`		`- return nil, fmt.Errorf("acme: cert alternates response stream: %v", err)`
	`472`	`+ return nil, fmt.Errorf("acme: cert alternates response stream: %w", err)`
`473`	`473`	`}`
`474`	`474`	`alts := linkHeader(res.Header, "alternate")`
`475`	`475`	`return alts, nil`
Original file line number	Diff line number	Diff line change
`@@ -240,7 +240,7 @@ type Key struct {`
`240`	`240`	`}`
`241`	`241`
`242`	`242`	`func clientErr(err error) error {`
`243`		`- return fmt.Errorf("agent: client error: %v", err)`
	`243`	`+ return fmt.Errorf("agent: client error: %w", err)`
`244`	`244`	`}`
`245`	`245`
`246`	`246`	`// String returns the storage form of an agent key with the format, base64`
`@@ -269,7 +269,7 @@ func (k *Key) Marshal() []byte {`
`269`	`269`	`func (k Key) Verify(data []byte, sig ssh.Signature) error {`
`270`	`270`	`pubKey, err := ssh.ParsePublicKey(k.Blob)`
`271`	`271`	`if err != nil {`
`272`		`- return fmt.Errorf("agent: bad public key: %v", err)`
	`272`	`+ return fmt.Errorf("agent: bad public key: %w", err)`
`273`	`273`	`}`
`274`	`274`	`return pubKey.Verify(data, sig)`
`275`	`275`	`}`
Original file line number	Diff line number	Diff line change
`@@ -387,7 +387,7 @@ func parseRSACert(req []byte) (*AddedKey, error) {`
`387`	`387`	`N *big.Int`
`388`	`388`	`}`
`389`	`389`	`if err := ssh.Unmarshal(cert.Key.Marshal(), &rsaPub); err != nil {`
`390`		`- return nil, fmt.Errorf("agent: Unmarshal failed to parse public key: %v", err)`
	`390`	`+ return nil, fmt.Errorf("agent: Unmarshal failed to parse public key: %w", err)`
`391`	`391`	`}`
`392`	`392`
`393`	`393`	`if rsaPub.E.BitLen() > 30 {`
`@@ -431,7 +431,7 @@ func parseDSACert(req []byte) (*AddedKey, error) {`
`431`	`431`	`P, Q, G, Y *big.Int`
`432`	`432`	`}`
`433`	`433`	`if err := ssh.Unmarshal(cert.Key.Marshal(), &w); err != nil {`
`434`		`- return nil, fmt.Errorf("agent: Unmarshal failed to parse public key: %v", err)`
	`434`	`+ return nil, fmt.Errorf("agent: Unmarshal failed to parse public key: %w", err)`
`435`	`435`	`}`
`436`	`436`
`437`	`437`	`priv := &dsa.PrivateKey{`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ func NewClientConn(c net.Conn, addr string, config *ClientConfig) (Conn, <-chan`
`82`	`82`
`83`	`83`	`if err := conn.clientHandshake(addr, &fullConf); err != nil {`
`84`	`84`	`c.Close()`
`85`		`- return nil, nil, nil, fmt.Errorf("ssh: handshake failed: %v", err)`
	`85`	`+ return nil, nil, nil, fmt.Errorf("ssh: handshake failed: %w", err)`
`86`	`86`	`}`
`87`	`87`	`conn.mux = newMux(conn.transport)`
`88`	`88`	`return conn, conn.mux.incomingChannels, conn.mux.incomingRequests, nil`
Original file line number	Diff line number	Diff line change
`@@ -1139,7 +1139,7 @@ func ParseRawPrivateKeyWithPassphrase(pemBytes, passphrase []byte) (interface{},`
`1139`	`1139`	`if err == x509.IncorrectPasswordError {`
`1140`	`1140`	`return nil, err`
`1141`	`1141`	`}`
`1142`		`- return nil, fmt.Errorf("ssh: cannot decode encrypted private keys: %v", err)`
	`1142`	`+ return nil, fmt.Errorf("ssh: cannot decode encrypted private keys: %w", err)`
`1143`	`1143`	`}`
`1144`	`1144`
`1145`	`1145`	`switch block.Type {`
`@@ -1277,7 +1277,7 @@ func parseOpenSSHPrivateKey(key []byte, decrypt openSSHDecryptFunc) (crypto.Priv`
`1277`	`1277`	`if err, ok := err.(*PassphraseMissingError); ok {`
`1278`	`1278`	`pub, errPub := ParsePublicKey(w.PubKey)`
`1279`	`1279`	`if errPub != nil {`
`1280`		`- return nil, fmt.Errorf("ssh: failed to parse embedded public key: %v", errPub)`
	`1280`	`+ return nil, fmt.Errorf("ssh: failed to parse embedded public key: %w", errPub)`
`1281`	`1281`	`}`
`1282`	`1282`	`err.PublicKey = pub`
`1283`	`1283`	`}`
Original file line number	Diff line number	Diff line change
`@@ -333,15 +333,15 @@ func (db *hostKeyDB) check(address string, remote net.Addr, remoteKey ssh.Public`
`333`	`333`
`334`	`334`	`host, port, err := net.SplitHostPort(remote.String())`
`335`	`335`	`if err != nil {`
`336`		`- return fmt.Errorf("knownhosts: SplitHostPort(%s): %v", remote, err)`
	`336`	`+ return fmt.Errorf("knownhosts: SplitHostPort(%s): %w", remote, err)`
`337`	`337`	`}`
`338`	`338`
`339`	`339`	`hostToCheck := addr{host, port}`
`340`	`340`	`if address != "" {`
`341`	`341`	`// Give preference to the hostname if available.`
`342`	`342`	`host, port, err := net.SplitHostPort(address)`
`343`	`343`	`if err != nil {`
`344`		`- return fmt.Errorf("knownhosts: SplitHostPort(%s): %v", address, err)`
	`344`	`+ return fmt.Errorf("knownhosts: SplitHostPort(%s): %w", address, err)`
`345`	`345`	`}`
`346`	`346`
`347`	`347`	`hostToCheck = addr{host, port}`
`@@ -402,7 +402,7 @@ func (db *hostKeyDB) Read(r io.Reader, filename string) error {`
`402`	`402`	`}`
`403`	`403`
`404`	`404`	`if err := db.parseLine(line, filename, lineNum); err != nil {`
`405`		`- return fmt.Errorf("knownhosts: %s:%d: %v", filename, lineNum, err)`
	`405`	`+ return fmt.Errorf("knownhosts: %s:%d: %w", filename, lineNum, err)`
`406`	`406`	`}`
`407`	`407`	`}`
`408`	`408`	`return scanner.Err()`
Original file line number	Diff line number	Diff line change
`@@ -309,7 +309,7 @@ func checkSourceAddress(addr net.Addr, sourceAddrs string) error {`
`309`	`309`	`} else {`
`310`	`310`	`_, ipNet, err := net.ParseCIDR(sourceAddr)`
`311`	`311`	`if err != nil {`
`312`		`- return fmt.Errorf("ssh: error parsing source-address restriction %q: %v", sourceAddr, err)`
	`312`	`+ return fmt.Errorf("ssh: error parsing source-address restriction %q: %w", sourceAddr, err)`
`313`	`313`	`}`
`314`	`314`
`315`	`315`	`if ipNet.Contains(tcpAddr.IP) {`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ func (c Client) autoPortListenWorkaround(laddr net.TCPAddr) (net.Listener, err`
`81`	`81`	`return sshListener, err`
`82`	`82`	`}`
`83`	`83`	`}`
`84`		`- return nil, fmt.Errorf("ssh: listen on random port failed after %d tries: %v", tries, err)`
	`84`	`+ return nil, fmt.Errorf("ssh: listen on random port failed after %d tries: %w", tries, err)`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`// RFC 4254 7.1`