all: remove dependency on deprecated github.com/pkg/errors (#834)

* all: remove dependency on deprecated github.com/pkg/errors

$ pkgerrors -fix ./...
$ goimports -w .

Signed-off-by: Koichi Shiraishi <zchee.io@gmail.com>

* all: fix missing convert

Signed-off-by: Koichi Shiraishi <zchee.io@gmail.com>

* pkg/types/hashedrekord: fix lint sugggestion

Signed-off-by: Koichi Shiraishi <zchee.io@gmail.com>

* go.mod: go mod tidy

Signed-off-by: Koichi Shiraishi <zchee.io@gmail.com>

* pkg/types/hashedrekord: fix unconverted by pkgerrors

Signed-off-by: Koichi Shiraishi <zchee.io@gmail.com>

cmd/rekor-cli/app/log_info.go

@@ -21,11 +21,11 @@ import (
 	"crypto/x509"
 	"encoding/hex"
 	"encoding/pem"
+	"errors"
 	"fmt"
 	"time"
 
 	"github.com/go-openapi/swag"
-	"github.com/pkg/errors"
 	rclient "github.com/sigstore/rekor/pkg/generated/client"
 	"github.com/sigstore/rekor/pkg/generated/models"
 	"github.com/spf13/cobra"
@@ -118,7 +118,7 @@ func verifyInactiveTrees(rekorClient *rclient.Rekor, serverURL string, inactiveS
 		signedTreeHead := swag.StringValue(shard.SignedTreeHead)
 		treeID := swag.StringValue(shard.TreeID)
 		if err := verifyTree(rekorClient, signedTreeHead, serverURL, treeID); err != nil {
-			return errors.Wrapf(err, "verifying inactive shard with ID %s", treeID)
+			return fmt.Errorf("verifying inactive shard with ID %s: %w", treeID, err)
 		}
 	}
 	log.CliLogger.Infof("Successfully validated inactive shards")

cmd/rekor-cli/app/pflags.go

@@ -29,7 +29,6 @@ import (
 	"github.com/spf13/pflag"
 
 	validator "github.com/go-playground/validator/v10"
-	"github.com/pkg/errors"
 )
 
 type FlagType string
@@ -116,7 +115,7 @@ func NewFlagValue(flagType FlagType, defaultVal string) pflag.Value {
 	val := valFunc()
 	if defaultVal != "" {
 		if err := val.Set(defaultVal); err != nil {
-			log.Fatal(errors.Wrap(err, "initializing flag"))
+			log.Fatal(fmt.Errorf("initializing flag: %w", err))
 		}
 	}
 	return val

cmd/rekor-cli/app/upload.go

@@ -32,7 +32,6 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 
-	"github.com/pkg/errors"
 	"github.com/sigstore/rekor/cmd/rekor-cli/app/format"
 	"github.com/sigstore/rekor/pkg/client"
 	genclient "github.com/sigstore/rekor/pkg/generated/client"
@@ -140,7 +139,7 @@ var uploadCmd = &cobra.Command{
 
 		// verify log entry
 		if verified, err := verifyLogEntry(ctx, rekorClient, logEntry); err != nil || !verified {
-			return nil, errors.Wrap(err, "unable to verify entry was added to log")
+			return nil, fmt.Errorf("unable to verify entry was added to log: %w", err)
 		}
 
 		return &uploadCmdOutput{

cmd/rekor-server/app/watch.go

@@ -21,6 +21,7 @@ import (
 	"crypto/x509"
 	"encoding/json"
 	"encoding/pem"
+	"errors"
 	"flag"
 	"fmt"
 	"os"
@@ -29,7 +30,6 @@ import (
 	_ "gocloud.dev/blob/fileblob" // fileblob
 	_ "gocloud.dev/blob/gcsblob"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"gocloud.dev/blob"
@@ -133,11 +133,11 @@ func init() {
 func doCheck(c *genclient.Rekor, pub crypto.PublicKey) (*SignedAndUnsignedLogRoot, error) {
 	li, err := c.Tlog.GetLogInfo(nil)
 	if err != nil {
-		return nil, errors.Wrap(err, "getting log info")
+		return nil, fmt.Errorf("getting log info: %w", err)
 	}
 	sth := util.SignedCheckpoint{}
 	if err := sth.UnmarshalText([]byte(*li.Payload.SignedTreeHead)); err != nil {
-		return nil, errors.Wrap(err, "unmarshalling tree head")
+		return nil, fmt.Errorf("unmarshalling tree head: %w", err)
 	}
 
 	verifier, err := signature.LoadVerifier(pub, crypto.SHA256)
@@ -146,7 +146,7 @@ func doCheck(c *genclient.Rekor, pub crypto.PublicKey) (*SignedAndUnsignedLogRoo
 	}
 
 	if !sth.Verify(verifier) {
-		return nil, errors.Wrap(err, "signed tree head failed verification")
+		return nil, fmt.Errorf("signed tree head failed verification: %w", err)
 	}
 
 	return &SignedAndUnsignedLogRoot{

go.mod

@@ -29,7 +29,6 @@ require (
 	github.com/mediocregopher/radix/v4 v4.1.0
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/mitchellh/mapstructure v1.5.0
-	github.com/pkg/errors v0.9.1
 	github.com/prometheus/client_golang v1.12.2
 	github.com/rs/cors v1.8.2
 	github.com/sassoftware/relic v0.0.0-20210427151427-dfb082b79b74

pkg/api/api.go

@@ -25,7 +25,6 @@ import (
 
 	"github.com/google/trillian"
 	radix "github.com/mediocregopher/radix/v4"
-	"github.com/pkg/errors"
 	"github.com/spf13/viper"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
@@ -68,23 +67,23 @@ func NewAPI(treeID uint) (*API, error) {
 	ctx := context.Background()
 	tConn, err := dial(ctx, logRPCServer)
 	if err != nil {
-		return nil, errors.Wrap(err, "dial")
+		return nil, fmt.Errorf("dial: %w", err)
 	}
 	logAdminClient := trillian.NewTrillianAdminClient(tConn)
 	logClient := trillian.NewTrillianLogClient(tConn)
 
 	shardingConfig := viper.GetString("trillian_log_server.sharding_config")
 	ranges, err := sharding.NewLogRanges(ctx, logClient, shardingConfig, treeID)
 	if err != nil {
-		return nil, errors.Wrap(err, "unable get sharding details from sharding config")
+		return nil, fmt.Errorf("unable get sharding details from sharding config: %w", err)
 	}
 
 	tid := int64(treeID)
 	if tid == 0 {
 		log.Logger.Info("No tree ID specified, attempting to create a new tree")
 		t, err := createAndInitTree(ctx, logAdminClient, logClient)
 		if err != nil {
-			return nil, errors.Wrap(err, "create and init tree")
+			return nil, fmt.Errorf("create and init tree: %w", err)
 		}
 		tid = t.TreeId
 	}
@@ -93,15 +92,15 @@ func NewAPI(treeID uint) (*API, error) {
 
 	rekorSigner, err := signer.New(ctx, viper.GetString("rekor_server.signer"))
 	if err != nil {
-		return nil, errors.Wrap(err, "getting new signer")
+		return nil, fmt.Errorf("getting new signer: %w", err)
 	}
 	pk, err := rekorSigner.PublicKey(options.WithContext(ctx))
 	if err != nil {
-		return nil, errors.Wrap(err, "getting public key")
+		return nil, fmt.Errorf("getting public key: %w", err)
 	}
 	b, err := x509.MarshalPKIXPublicKey(pk)
 	if err != nil {
-		return nil, errors.Wrap(err, "marshalling public key")
+		return nil, fmt.Errorf("marshalling public key: %w", err)
 	}
 	pubkeyHashBytes := sha256.Sum256(b)
 

pkg/api/trillian_client.go

@@ -21,7 +21,6 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/pkg/errors"
 	"github.com/sigstore/rekor/pkg/log"
 	"github.com/sigstore/rekor/pkg/sharding"
 	"github.com/transparency-dev/merkle/proof"
@@ -327,11 +326,11 @@ func createAndInitTree(ctx context.Context, adminClient trillian.TrillianAdminCl
 		},
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "create tree")
+		return nil, fmt.Errorf("create tree: %w", err)
 	}
 
 	if err := client.InitLog(ctx, t, logClient); err != nil {
-		return nil, errors.Wrap(err, "init log")
+		return nil, fmt.Errorf("init log: %w", err)
 	}
 	log.Logger.Infof("Created new tree with ID: %v", t.TreeId)
 	return t, nil

pkg/sharding/ranges.go

@@ -18,6 +18,7 @@ package sharding
 import (
 	"context"
 	"encoding/base64"
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"strconv"
@@ -26,7 +27,6 @@ import (
 	"github.com/ghodss/yaml"
 	"github.com/google/trillian"
 	"github.com/google/trillian/types"
-	"github.com/pkg/errors"
 	"github.com/sigstore/rekor/pkg/log"
 )
 
@@ -55,12 +55,12 @@ func NewLogRanges(ctx context.Context, logClient trillian.TrillianLogClient, pat
 	// otherwise, try to read contents of the sharding config
 	ranges, err := logRangesFromPath(path)
 	if err != nil {
-		return LogRanges{}, errors.Wrap(err, "log ranges from path")
+		return LogRanges{}, fmt.Errorf("log ranges from path: %w", err)
 	}
 	for i, r := range ranges {
 		r, err := updateRange(ctx, logClient, r)
 		if err != nil {
-			return LogRanges{}, errors.Wrapf(err, "updating range for tree id %d", r.TreeID)
+			return LogRanges{}, fmt.Errorf("updating range for tree id %d: %w", r.TreeID, err)
 		}
 		ranges[i] = r
 	}
@@ -93,7 +93,7 @@ func updateRange(ctx context.Context, logClient trillian.TrillianLogClient, r Lo
 	if r.TreeLength == 0 {
 		resp, err := logClient.GetLatestSignedLogRoot(ctx, &trillian.GetLatestSignedLogRootRequest{LogId: r.TreeID})
 		if err != nil {
-			return LogRange{}, errors.Wrapf(err, "getting signed log root for tree %d", r.TreeID)
+			return LogRange{}, fmt.Errorf("getting signed log root for tree %d: %w", r.TreeID, err)
 		}
 		var root types.LogRootV1
 		if err := root.UnmarshalBinary(resp.SignedLogRoot.LogRoot); err != nil {

pkg/types/alpine/alpine.go

@@ -17,8 +17,9 @@ package alpine
 
 import (
 	"context"
+	"errors"
+	"fmt"
 
-	"github.com/pkg/errors"
 	"github.com/sigstore/rekor/pkg/generated/models"
 	"github.com/sigstore/rekor/pkg/types"
 )
@@ -63,7 +64,7 @@ func (bat *BaseAlpineType) CreateProposedEntry(ctx context.Context, version stri
 	}
 	ei, err := bat.VersionedUnmarshal(nil, version)
 	if err != nil {
-		return nil, errors.Wrap(err, "fetching Intoto version implementation")
+		return nil, fmt.Errorf("fetching Intoto version implementation: %w", err)
 	}
 	return ei.CreateFromArtifactProperties(ctx, props)
 }

pkg/types/alpine/apk.go

@@ -25,12 +25,12 @@ import (
 	"crypto/sha256"
 	"encoding/hex"
 	"encoding/pem"
+	"errors"
 	"fmt"
 	"hash"
 	"io"
 	"strings"
 
-	"github.com/pkg/errors"
 	"github.com/sigstore/sigstore/pkg/signature"
 	"github.com/sigstore/sigstore/pkg/signature/options"
 	"gopkg.in/ini.v1"
@@ -94,7 +94,7 @@ func (p *Package) Unmarshal(pkgReader io.Reader) error {
 	sha1BufReader := newSHA1Reader(bufReader)
 	gzipReader, err := gzip.NewReader(sha1BufReader)
 	if err != nil {
-		return errors.Wrap(err, "create gzip reader")
+		return fmt.Errorf("create gzip reader: %w", err)
 	}
 	defer func() {
 		_ = gzipReader.Close()
@@ -108,7 +108,7 @@ func (p *Package) Unmarshal(pkgReader io.Reader) error {
 	sigBuf := bytes.Buffer{}
 	// #nosec G110
 	if _, err := io.Copy(&sigBuf, gzipReader); err != nil {
-		return errors.Wrap(err, "reading signature.tar.gz")
+		return fmt.Errorf("reading signature.tar.gz: %w", err)
 	}
 
 	// the SHA1 sum used in the signature is over the entire file control.tar.gz so we need to
@@ -119,14 +119,14 @@ func (p *Package) Unmarshal(pkgReader io.Reader) error {
 
 	// we reset the reader since we've found the end of signature.tar.gz
 	if err := gzipReader.Reset(sha1BufReader); err != nil && err != io.EOF {
-		return errors.Wrap(err, "resetting to control.tar.gz")
+		return fmt.Errorf("resetting to control.tar.gz: %w", err)
 	}
 	gzipReader.Multistream(false)
 
 	controlTar := bytes.Buffer{}
 	// #nosec G110
 	if _, err = io.Copy(&controlTar, gzipReader); err != nil {
-		return errors.Wrap(err, "reading control.tar.gz")
+		return fmt.Errorf("reading control.tar.gz: %w", err)
 	}
 
 	// signature uses sha1 digest hardcoded in abuild-sign tool
@@ -145,13 +145,13 @@ func (p *Package) Unmarshal(pkgReader io.Reader) error {
 			}
 			break
 		} else if err != nil {
-			return errors.Wrap(err, "getting next entry in tar archive")
+			return fmt.Errorf("getting next entry in tar archive: %w", err)
 		}
 
 		if strings.HasPrefix(header.Name, ".SIGN") && pkg.Signature == nil {
 			sigBytes := make([]byte, header.Size)
 			if _, err = sigReader.Read(sigBytes); err != nil && err != io.EOF {
-				return errors.Wrap(err, "reading signature")
+				return fmt.Errorf("reading signature: %w", err)
 			}
 			// we're not sure whether this is PEM encoded or not, so handle both cases
 			block, _ := pem.Decode(sigBytes)
@@ -172,22 +172,22 @@ func (p *Package) Unmarshal(pkgReader io.Reader) error {
 			}
 			break
 		} else if err != nil {
-			return errors.Wrap(err, "getting next entry in tar archive")
+			return fmt.Errorf("getting next entry in tar archive: %w", err)
 		}
 
 		if header.Name == ".PKGINFO" {
 			pkginfoContent := make([]byte, header.Size)
 			if _, err = ctlReader.Read(pkginfoContent); err != nil && err != io.EOF {
-				return errors.Wrap(err, "reading .PKGINFO")
+				return fmt.Errorf("reading .PKGINFO: %w", err)
 			}
 
 			pkg.Pkginfo, err = parsePkginfo(pkginfoContent)
 			if err != nil {
-				return errors.Wrap(err, "parsing .PKGINFO")
+				return fmt.Errorf("parsing .PKGINFO: %w", err)
 			}
 			pkg.Datahash, err = hex.DecodeString(pkg.Pkginfo["datahash"])
 			if err != nil {
-				return errors.Wrap(err, "parsing datahash")
+				return fmt.Errorf("parsing datahash: %w", err)
 			}
 		}
 	}
@@ -196,7 +196,7 @@ func (p *Package) Unmarshal(pkgReader io.Reader) error {
 	// datahash value from .PKGINFO is sha256 sum of data.tar.gz
 	sha256 := sha256.New()
 	if _, err := io.Copy(sha256, bufReader); err != nil {
-		return errors.Wrap(err, "computing SHA256 sum of data.tar.gz")
+		return fmt.Errorf("computing SHA256 sum of data.tar.gz: %w", err)
 	}
 	computedSum := sha256.Sum(nil)
 

pkg/types/hashedrekord/hashedrekord.go

@@ -17,9 +17,9 @@ package hashedrekord
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
-	"github.com/pkg/errors"
 	"github.com/sigstore/rekor/pkg/generated/models"
 	"github.com/sigstore/rekor/pkg/types"
 )
@@ -52,7 +52,7 @@ func (rt BaseRekordType) UnmarshalEntry(pe models.ProposedEntry) (types.EntryImp
 
 	rekord, ok := pe.(*models.Hashedrekord)
 	if !ok {
-		return nil, errors.New(fmt.Sprintf("%s, %s", "cannot unmarshal non-hashed Rekord types", pe.Kind()))
+		return nil, fmt.Errorf("cannot unmarshal non-hashed Rekord types: %s", pe.Kind())
 	}
 
 	return rt.VersionedUnmarshal(rekord, *rekord.APIVersion)
@@ -64,7 +64,7 @@ func (rt *BaseRekordType) CreateProposedEntry(ctx context.Context, version strin
 	}
 	ei, err := rt.VersionedUnmarshal(nil, version)
 	if err != nil {
-		return nil, errors.Wrap(err, "fetching hashed Rekord version implementation")
+		return nil, fmt.Errorf("fetching hashed Rekord version implementation: %w", err)
 	}
 
 	return ei.CreateFromArtifactProperties(ctx, props)

pkg/types/hashedrekord/v0.0.1/entry.go

@@ -21,6 +21,7 @@ import (
 	"crypto/sha256"
 	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"path/filepath"
@@ -29,7 +30,6 @@ import (
 	"github.com/asaskevich/govalidator"
 	"github.com/go-openapi/strfmt"
 	"github.com/go-openapi/swag"
-	"github.com/pkg/errors"
 
 	"github.com/sigstore/rekor/pkg/generated/models"
 	"github.com/sigstore/rekor/pkg/log"
@@ -177,7 +177,7 @@ func (v *V001Entry) validate() (pki.Signature, pki.PublicKey, error) {
 		return nil, nil, err
 	}
 	if err := sigObj.Verify(nil, keyObj, options.WithDigest(decoded)); err != nil {
-		return nil, nil, types.ValidationError(errors.Wrap(err, "verifying signature"))
+		return nil, nil, types.ValidationError(fmt.Errorf("verifying signature: %w", err))
 	}
 
 	return sigObj, keyObj, nil