Nemcio/Gogs
1
0
Fork 0
mirror of https://github.com/gogs/gogs.git synced 2026-05-07 07:56:45 +02:00
Code Issues Packages Projects Releases Wiki Activity

chore: replace pkg/errors with cockroachdb/errors (#8098)

Browse Source 
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: unknwon <2946214+unknwon@users.noreply.github.com>
This commit is contained in:
Copilot
2026-01-22 08:20:53 -05:00
committed by GitHub
parent ae59787ff5
commit 4ee706b2bf
96 changed files with 605 additions and 564 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
internal/database/ssh_key.go
View File

@@ -4,7 +4,6 @@ import (
"context"
"encoding/base64"
"encoding/binary"
"errors"
"fmt"
"math/big"
"os"
@@ -14,6 +13,7 @@ import (
"sync"
"time"
"github.com/cockroachdb/errors"
"github.com/unknwon/com"
"golang.org/x/crypto/ssh"
log "unknwon.dev/clog/v2"
@@ -92,12 +92,12 @@ func (k *PublicKey) IsDeployKey() bool {
func extractTypeFromBase64Key(key string) (string, error) {
b, err := base64.StdEncoding.DecodeString(key)
if err != nil || len(b) < 4 {
return "", fmt.Errorf("invalid key format: %v", err)
return "", errors.Newf("invalid key format: %v", err)
}
keyLength := int(binary.BigEndian.Uint32(b))
if len(b) < 4+keyLength {
return "", fmt.Errorf("invalid key format: not enough length %d", keyLength)
return "", errors.Newf("invalid key format: not enough length %d", keyLength)
}
return string(b[4 : 4+keyLength]), nil
@@ -141,12 +141,12 @@ func parseKeyString(content string) (string, error) {
// If keyType is not given, extract it from content. If given, validate it.
t, err := extractTypeFromBase64Key(keyContent)
if err != nil {
return "", fmt.Errorf("extractTypeFromBase64Key: %v", err)
return "", errors.Newf("extractTypeFromBase64Key: %v", err)
}
if keyType == "" {
keyType = t
} else if keyType != t {
return "", fmt.Errorf("key type and content does not match: %s - %s", keyType, t)
return "", errors.Newf("key type and content does not match: %s - %s", keyType, t)
}
} else {
// Parse SSH2 file format.
@@ -166,7 +166,7 @@ func parseKeyString(content string) (string, error) {
t, err := extractTypeFromBase64Key(keyContent)
if err != nil {
return "", fmt.Errorf("extractTypeFromBase64Key: %v", err)
return "", errors.Newf("extractTypeFromBase64Key: %v", err)
}
keyType = t
}
@@ -178,12 +178,12 @@ func parseKeyString(content string) (string, error) {
func writeTmpKeyFile(content string) (string, error) {
tmpFile, err := os.CreateTemp(conf.SSH.KeyTestPath, "gogs_keytest")
if err != nil {
return "", fmt.Errorf("TempFile: %v", err)
return "", errors.Newf("TempFile: %v", err)
}
defer tmpFile.Close()
if _, err = tmpFile.WriteString(content); err != nil {
return "", fmt.Errorf("WriteString: %v", err)
return "", errors.Newf("WriteString: %v", err)
}
return tmpFile.Name(), nil
}
@@ -192,13 +192,13 @@ func writeTmpKeyFile(content string) (string, error) {
func SSHKeyGenParsePublicKey(key string) (string, int, error) {
tmpName, err := writeTmpKeyFile(key)
if err != nil {
return "", 0, fmt.Errorf("writeTmpKeyFile: %v", err)
return "", 0, errors.Newf("writeTmpKeyFile: %v", err)
}
defer os.Remove(tmpName)
stdout, stderr, err := process.Exec("SSHKeyGenParsePublicKey", conf.SSH.KeygenPath, "-lf", tmpName)
if err != nil {
return "", 0, fmt.Errorf("fail to parse public key: %s - %s", err, stderr)
return "", 0, errors.Newf("fail to parse public key: %s - %s", err, stderr)
}
if strings.Contains(stdout, "is not a public key file") {
return "", 0, ErrKeyUnableVerify{stdout}
@@ -206,7 +206,7 @@ func SSHKeyGenParsePublicKey(key string) (string, int, error) {
fields := strings.Split(stdout, " ")
if len(fields) < 4 {
return "", 0, fmt.Errorf("invalid public key line: %s", stdout)
return "", 0, errors.Newf("invalid public key line: %s", stdout)
}
keyType := strings.Trim(fields[len(fields)-1], "()\r\n")
@@ -217,7 +217,7 @@ func SSHKeyGenParsePublicKey(key string) (string, int, error) {
func SSHNativeParsePublicKey(keyLine string) (string, int, error) {
fields := strings.Fields(keyLine)
if len(fields) < 2 {
return "", 0, fmt.Errorf("not enough fields in public key line: %s", keyLine)
return "", 0, errors.Newf("not enough fields in public key line: %s", keyLine)
}
raw, err := base64.StdEncoding.DecodeString(fields[1])
@@ -230,7 +230,7 @@ func SSHNativeParsePublicKey(keyLine string) (string, int, error) {
if strings.Contains(err.Error(), "ssh: unknown key algorithm") {
return "", 0, ErrKeyUnableVerify{err.Error()}
}
return "", 0, fmt.Errorf("ParsePublicKey: %v", err)
return "", 0, errors.Newf("ParsePublicKey: %v", err)
}
// The ssh library can parse the key, so next we find out what key exactly we have.
@@ -265,7 +265,7 @@ func SSHNativeParsePublicKey(keyLine string) (string, int, error) {
case ssh.KeyAlgoED25519:
return "ed25519", 256, nil
}
return "", 0, fmt.Errorf("unsupported key length detection for type: %s", pkey.Type())
return "", 0, errors.Newf("unsupported key length detection for type: %s", pkey.Type())
}
// CheckPublicKeyString checks if the given public key string is recognized by SSH.
@@ -305,16 +305,16 @@ func CheckPublicKeyString(content string) (_ string, err error) {
keyType, length, err = SSHKeyGenParsePublicKey(content)
}
if err != nil {
return "", fmt.Errorf("%s: %v", fnName, err)
return "", errors.Newf("%s: %v", fnName, err)
}
log.Trace("Key info [native: %v]: %s-%d", conf.SSH.StartBuiltinServer, keyType, length)
if minLen, found := conf.SSH.MinimumKeySizes[keyType]; found && length >= minLen {
return content, nil
} else if found && length < minLen {
return "", fmt.Errorf("key length is not enough: got %d, needs %d", length, minLen)
return "", errors.Newf("key length is not enough: got %d, needs %d", length, minLen)
}
return "", fmt.Errorf("key type is not allowed: %s", keyType)
return "", errors.Newf("key type is not allowed: %s", keyType)
}
// appendAuthorizedKeysToFile appends new SSH keys' content to authorized_keys file.
@@ -378,7 +378,7 @@ func addKey(e Engine, key *PublicKey) (err error) {
stdout, stderr, err := process.Exec("AddPublicKey", conf.SSH.KeygenPath, "-lf", tmpPath)
if err != nil {
return fmt.Errorf("fail to parse public key: %s - %s", err, stderr)
return errors.Newf("fail to parse public key: %s - %s", err, stderr)
} else if len(stdout) < 2 {
return errors.New("not enough output for calculating fingerprint: " + stdout)
}
@@ -425,7 +425,7 @@ func AddPublicKey(ownerID int64, name, content string) (*PublicKey, error) {
Type: KeyTypeUser,
}
if err = addKey(sess, key); err != nil {
return nil, fmt.Errorf("addKey: %v", err)
return nil, errors.Newf("addKey: %v", err)
}
return key, sess.Commit()
@@ -486,7 +486,7 @@ func DeletePublicKey(doer *User, id int64) (err error) {
if IsErrKeyNotExist(err) {
return nil
}
return fmt.Errorf("GetPublicKeyByID: %v", err)
return errors.Newf("GetPublicKeyByID: %v", err)
}
// Check if user has access to delete this key.
@@ -671,13 +671,13 @@ func AddDeployKey(repoID int64, name, content string) (*DeployKey, error) {
// First time use this deploy key.
if !has {
if err = addKey(sess, pkey); err != nil {
return nil, fmt.Errorf("addKey: %v", err)
return nil, errors.Newf("addKey: %v", err)
}
}
key, err := addDeployKey(sess, pkey.ID, repoID, name, pkey.Fingerprint)
if err != nil {
return nil, fmt.Errorf("addDeployKey: %v", err)
return nil, errors.Newf("addDeployKey: %v", err)
}
return key, sess.Commit()
@@ -742,14 +742,14 @@ func DeleteDeployKey(doer *User, id int64) error {
if IsErrDeployKeyNotExist(err) {
return nil
}
return fmt.Errorf("GetDeployKeyByID: %v", err)
return errors.Newf("GetDeployKeyByID: %v", err)
}
// Check if user has access to delete this key.
if !doer.IsAdmin {
repo, err := GetRepositoryByID(key.RepoID)
if err != nil {
return fmt.Errorf("GetRepositoryByID: %v", err)
return errors.Newf("GetRepositoryByID: %v", err)
}
if !Handle.Permissions().Authorize(context.TODO(), doer.ID, repo.ID, AccessModeAdmin,
AccessModeOptions{
@@ -768,7 +768,7 @@ func DeleteDeployKey(doer *User, id int64) error {
}
if _, err = sess.ID(key.ID).Delete(new(DeployKey)); err != nil {
return fmt.Errorf("delete deploy key [%d]: %v", key.ID, err)
return errors.Newf("delete deploy key [%d]: %v", key.ID, err)
}
// Check if this is the last reference to same key content.