mirror of https://github.com/go-gitea/gitea
Abstract hash function usage (#28138)
Refactor Hash interfaces and centralize hash function. This will allow easier introduction of different hash function later on. This forms the "no-op" part of the SHA256 enablement patch.pull/28392/head^2
Adam Majer
12 months ago
committed by
GitHub
parent
064f05204c
commit
cbf923e87b
@ -0,0 +1,103 @@ |
|||||||
|
// Copyright 2023 The Gitea Authors. All rights reserved.
|
||||||
|
// SPDX-License-Identifier: MIT
|
||||||
|
|
||||||
|
package git |
||||||
|
|
||||||
|
import ( |
||||||
|
"crypto/sha1" |
||||||
|
"fmt" |
||||||
|
"regexp" |
||||||
|
"strings" |
||||||
|
) |
||||||
|
|
||||||
|
type ObjectFormatID int |
||||||
|
|
||||||
|
const ( |
||||||
|
Sha1 ObjectFormatID = iota |
||||||
|
) |
||||||
|
|
||||||
|
// sha1Pattern can be used to determine if a string is an valid sha
|
||||||
|
var sha1Pattern = regexp.MustCompile(`^[0-9a-f]{4,40}$`) |
||||||
|
|
||||||
|
type ObjectFormat interface { |
||||||
|
ID() ObjectFormatID |
||||||
|
String() string |
||||||
|
|
||||||
|
// Empty is the hash of empty git
|
||||||
|
Empty() ObjectID |
||||||
|
// EmptyTree is the hash of an empty tree
|
||||||
|
EmptyTree() ObjectID |
||||||
|
// FullLength is the length of the hash's hex string
|
||||||
|
FullLength() int |
||||||
|
|
||||||
|
IsValid(input string) bool |
||||||
|
MustID(b []byte) ObjectID |
||||||
|
MustIDFromString(s string) ObjectID |
||||||
|
NewID(b []byte) (ObjectID, error) |
||||||
|
NewIDFromString(s string) (ObjectID, error) |
||||||
|
NewEmptyID() ObjectID |
||||||
|
|
||||||
|
NewHasher() HasherInterface |
||||||
|
} |
||||||
|
|
||||||
|
/* SHA1 Type */ |
||||||
|
type Sha1ObjectFormat struct{} |
||||||
|
|
||||||
|
func (*Sha1ObjectFormat) ID() ObjectFormatID { return Sha1 } |
||||||
|
func (*Sha1ObjectFormat) String() string { return "sha1" } |
||||||
|
func (*Sha1ObjectFormat) Empty() ObjectID { return &Sha1Hash{} } |
||||||
|
func (*Sha1ObjectFormat) EmptyTree() ObjectID { |
||||||
|
return &Sha1Hash{ |
||||||
|
0x4b, 0x82, 0x5d, 0xc6, 0x42, 0xcb, 0x6e, 0xb9, 0xa0, 0x60, |
||||||
|
0xe5, 0x4b, 0xf8, 0xd6, 0x92, 0x88, 0xfb, 0xee, 0x49, 0x04, |
||||||
|
} |
||||||
|
} |
||||||
|
func (*Sha1ObjectFormat) FullLength() int { return 40 } |
||||||
|
func (*Sha1ObjectFormat) IsValid(input string) bool { |
||||||
|
return sha1Pattern.MatchString(input) |
||||||
|
} |
||||||
|
|
||||||
|
func (*Sha1ObjectFormat) MustID(b []byte) ObjectID { |
||||||
|
var id Sha1Hash |
||||||
|
copy(id[0:20], b) |
||||||
|
return &id |
||||||
|
} |
||||||
|
|
||||||
|
func (h *Sha1ObjectFormat) MustIDFromString(s string) ObjectID { |
||||||
|
return MustIDFromString(h, s) |
||||||
|
} |
||||||
|
|
||||||
|
func (h *Sha1ObjectFormat) NewID(b []byte) (ObjectID, error) { |
||||||
|
return IDFromRaw(h, b) |
||||||
|
} |
||||||
|
|
||||||
|
func (h *Sha1ObjectFormat) NewIDFromString(s string) (ObjectID, error) { |
||||||
|
return genericIDFromString(h, s) |
||||||
|
} |
||||||
|
|
||||||
|
func (*Sha1ObjectFormat) NewEmptyID() ObjectID { |
||||||
|
return NewSha1() |
||||||
|
} |
||||||
|
|
||||||
|
func (h *Sha1ObjectFormat) NewHasher() HasherInterface { |
||||||
|
return &Sha1Hasher{sha1.New()} |
||||||
|
} |
||||||
|
|
||||||
|
// utils
|
||||||
|
func ObjectFormatFromID(id ObjectFormatID) ObjectFormat { |
||||||
|
switch id { |
||||||
|
case Sha1: |
||||||
|
return &Sha1ObjectFormat{} |
||||||
|
} |
||||||
|
|
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
func ObjectFormatFromString(hash string) (ObjectFormat, error) { |
||||||
|
switch strings.ToLower(hash) { |
||||||
|
case "sha1": |
||||||
|
return &Sha1ObjectFormat{}, nil |
||||||
|
} |
||||||
|
|
||||||
|
return nil, fmt.Errorf("unknown hash type: %s", hash) |
||||||
|
} |
||||||
@ -0,0 +1,143 @@ |
|||||||
|
// Copyright 2023 The Gitea Authors. All rights reserved.
|
||||||
|
// SPDX-License-Identifier: MIT
|
||||||
|
|
||||||
|
package git |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"encoding/hex" |
||||||
|
"errors" |
||||||
|
"fmt" |
||||||
|
"hash" |
||||||
|
"strconv" |
||||||
|
"strings" |
||||||
|
) |
||||||
|
|
||||||
|
type ObjectID interface { |
||||||
|
String() string |
||||||
|
IsZero() bool |
||||||
|
RawValue() []byte |
||||||
|
Type() ObjectFormat |
||||||
|
} |
||||||
|
|
||||||
|
/* SHA1 */ |
||||||
|
type Sha1Hash [20]byte |
||||||
|
|
||||||
|
func (h *Sha1Hash) String() string { |
||||||
|
return hex.EncodeToString(h[:]) |
||||||
|
} |
||||||
|
|
||||||
|
func (h *Sha1Hash) IsZero() bool { |
||||||
|
empty := Sha1Hash{} |
||||||
|
return bytes.Equal(empty[:], h[:]) |
||||||
|
} |
||||||
|
func (h *Sha1Hash) RawValue() []byte { return h[:] } |
||||||
|
func (*Sha1Hash) Type() ObjectFormat { return &Sha1ObjectFormat{} } |
||||||
|
|
||||||
|
func NewSha1() *Sha1Hash { |
||||||
|
return &Sha1Hash{} |
||||||
|
} |
||||||
|
|
||||||
|
// generic implementations
|
||||||
|
func NewHash(hash string) (ObjectID, error) { |
||||||
|
hash = strings.ToLower(hash) |
||||||
|
switch hash { |
||||||
|
case "sha1": |
||||||
|
return &Sha1Hash{}, nil |
||||||
|
} |
||||||
|
|
||||||
|
return nil, errors.New("unsupported hash type") |
||||||
|
} |
||||||
|
|
||||||
|
func IDFromRaw(h ObjectFormat, b []byte) (ObjectID, error) { |
||||||
|
if len(b) != h.FullLength()/2 { |
||||||
|
return h.Empty(), fmt.Errorf("length must be %d: %v", h.FullLength(), b) |
||||||
|
} |
||||||
|
return h.MustID(b), nil |
||||||
|
} |
||||||
|
|
||||||
|
func MustIDFromString(h ObjectFormat, s string) ObjectID { |
||||||
|
b, _ := hex.DecodeString(s) |
||||||
|
return h.MustID(b) |
||||||
|
} |
||||||
|
|
||||||
|
func genericIDFromString(h ObjectFormat, s string) (ObjectID, error) { |
||||||
|
s = strings.TrimSpace(s) |
||||||
|
if len(s) != h.FullLength() { |
||||||
|
return h.Empty(), fmt.Errorf("length must be %d: %s", h.FullLength(), s) |
||||||
|
} |
||||||
|
b, err := hex.DecodeString(s) |
||||||
|
if err != nil { |
||||||
|
return h.Empty(), err |
||||||
|
} |
||||||
|
return h.NewID(b) |
||||||
|
} |
||||||
|
|
||||||
|
// utils
|
||||||
|
func IDFromString(hexHash string) (ObjectID, error) { |
||||||
|
switch len(hexHash) { |
||||||
|
case 40: |
||||||
|
hashType := Sha1ObjectFormat{} |
||||||
|
h, err := hashType.NewIDFromString(hexHash) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
return h, nil |
||||||
|
} |
||||||
|
|
||||||
|
return nil, fmt.Errorf("invalid hash hex string: '%s' len: %d", hexHash, len(hexHash)) |
||||||
|
} |
||||||
|
|
||||||
|
func IsEmptyCommitID(commitID string) bool { |
||||||
|
if commitID == "" { |
||||||
|
return true |
||||||
|
} |
||||||
|
|
||||||
|
id, err := IDFromString(commitID) |
||||||
|
if err != nil { |
||||||
|
return false |
||||||
|
} |
||||||
|
|
||||||
|
return id.IsZero() |
||||||
|
} |
||||||
|
|
||||||
|
// HashInterface is a struct that will generate a Hash
|
||||||
|
type HasherInterface interface { |
||||||
|
hash.Hash |
||||||
|
|
||||||
|
HashSum() ObjectID |
||||||
|
} |
||||||
|
|
||||||
|
type Sha1Hasher struct { |
||||||
|
hash.Hash |
||||||
|
} |
||||||
|
|
||||||
|
// ComputeBlobHash compute the hash for a given blob content
|
||||||
|
func ComputeBlobHash(hashType ObjectFormat, content []byte) ObjectID { |
||||||
|
return ComputeHash(hashType, ObjectBlob, content) |
||||||
|
} |
||||||
|
|
||||||
|
// ComputeHash compute the hash for a given ObjectType and content
|
||||||
|
func ComputeHash(hashType ObjectFormat, t ObjectType, content []byte) ObjectID { |
||||||
|
h := hashType.NewHasher() |
||||||
|
_, _ = h.Write(t.Bytes()) |
||||||
|
_, _ = h.Write([]byte(" ")) |
||||||
|
_, _ = h.Write([]byte(strconv.FormatInt(int64(len(content)), 10))) |
||||||
|
_, _ = h.Write([]byte{0}) |
||||||
|
return h.HashSum() |
||||||
|
} |
||||||
|
|
||||||
|
// Sum generates a SHA1 for the provided hash
|
||||||
|
func (h *Sha1Hasher) HashSum() ObjectID { |
||||||
|
var sha1 Sha1Hash |
||||||
|
copy(sha1[:], h.Hash.Sum(nil)) |
||||||
|
return &sha1 |
||||||
|
} |
||||||
|
|
||||||
|
type ErrInvalidSHA struct { |
||||||
|
SHA string |
||||||
|
} |
||||||
|
|
||||||
|
func (err ErrInvalidSHA) Error() string { |
||||||
|
return fmt.Sprintf("invalid sha: %s", err.SHA) |
||||||
|
} |
||||||
@ -0,0 +1,28 @@ |
|||||||
|
// Copyright 2023 The Gitea Authors. All rights reserved.
|
||||||
|
// SPDX-License-Identifier: MIT
|
||||||
|
//go:build gogit
|
||||||
|
|
||||||
|
package git |
||||||
|
|
||||||
|
import ( |
||||||
|
"github.com/go-git/go-git/v5/plumbing" |
||||||
|
"github.com/go-git/go-git/v5/plumbing/hash" |
||||||
|
) |
||||||
|
|
||||||
|
func ParseGogitHash(h plumbing.Hash) ObjectID { |
||||||
|
switch hash.Size { |
||||||
|
case 20: |
||||||
|
return ObjectFormatFromID(Sha1).MustID(h[:]) |
||||||
|
} |
||||||
|
|
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
func ParseGogitHashArray(objectIDs []plumbing.Hash) []ObjectID { |
||||||
|
ret := make([]ObjectID, len(objectIDs)) |
||||||
|
for i, h := range objectIDs { |
||||||
|
ret[i] = ParseGogitHash(h) |
||||||
|
} |
||||||
|
|
||||||
|
return ret |
||||||
|
} |
||||||
@ -0,0 +1,21 @@ |
|||||||
|
// Copyright 2022 The Gitea Authors. All rights reserved.
|
||||||
|
// SPDX-License-Identifier: MIT
|
||||||
|
|
||||||
|
package git |
||||||
|
|
||||||
|
import ( |
||||||
|
"testing" |
||||||
|
|
||||||
|
"github.com/stretchr/testify/assert" |
||||||
|
) |
||||||
|
|
||||||
|
func TestIsValidSHAPattern(t *testing.T) { |
||||||
|
h := NewSha1().Type() |
||||||
|
assert.True(t, h.IsValid("fee1")) |
||||||
|
assert.True(t, h.IsValid("abc000")) |
||||||
|
assert.True(t, h.IsValid("9023902390239023902390239023902390239023")) |
||||||
|
assert.False(t, h.IsValid("90239023902390239023902390239023902390239023")) |
||||||
|
assert.False(t, h.IsValid("abc")) |
||||||
|
assert.False(t, h.IsValid("123g")) |
||||||
|
assert.False(t, h.IsValid("some random text")) |
||||||
|
} |
||||||
@ -1,72 +0,0 @@ |
|||||||
// Copyright 2015 The Gogs Authors. All rights reserved.
|
|
||||||
// Copyright 2019 The Gitea Authors. All rights reserved.
|
|
||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
package git |
|
||||||
|
|
||||||
import ( |
|
||||||
"encoding/hex" |
|
||||||
"fmt" |
|
||||||
"regexp" |
|
||||||
"strings" |
|
||||||
) |
|
||||||
|
|
||||||
// EmptySHA defines empty git SHA (undefined, non-existent)
|
|
||||||
const EmptySHA = "0000000000000000000000000000000000000000" |
|
||||||
|
|
||||||
// EmptyTreeSHA is the SHA of an empty tree, the root of all git repositories
|
|
||||||
const EmptyTreeSHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904" |
|
||||||
|
|
||||||
// SHAFullLength is the full length of a git SHA
|
|
||||||
const SHAFullLength = 40 |
|
||||||
|
|
||||||
// SHAPattern can be used to determine if a string is an valid sha
|
|
||||||
var shaPattern = regexp.MustCompile(`^[0-9a-f]{4,40}$`) |
|
||||||
|
|
||||||
// IsValidSHAPattern will check if the provided string matches the SHA Pattern
|
|
||||||
func IsValidSHAPattern(sha string) bool { |
|
||||||
return shaPattern.MatchString(sha) |
|
||||||
} |
|
||||||
|
|
||||||
type ErrInvalidSHA struct { |
|
||||||
SHA string |
|
||||||
} |
|
||||||
|
|
||||||
func (err ErrInvalidSHA) Error() string { |
|
||||||
return fmt.Sprintf("invalid sha: %s", err.SHA) |
|
||||||
} |
|
||||||
|
|
||||||
// MustID always creates a new SHA1 from a [20]byte array with no validation of input.
|
|
||||||
func MustID(b []byte) SHA1 { |
|
||||||
var id SHA1 |
|
||||||
copy(id[:], b) |
|
||||||
return id |
|
||||||
} |
|
||||||
|
|
||||||
// NewID creates a new SHA1 from a [20]byte array.
|
|
||||||
func NewID(b []byte) (SHA1, error) { |
|
||||||
if len(b) != 20 { |
|
||||||
return SHA1{}, fmt.Errorf("Length must be 20: %v", b) |
|
||||||
} |
|
||||||
return MustID(b), nil |
|
||||||
} |
|
||||||
|
|
||||||
// MustIDFromString always creates a new sha from a ID with no validation of input.
|
|
||||||
func MustIDFromString(s string) SHA1 { |
|
||||||
b, _ := hex.DecodeString(s) |
|
||||||
return MustID(b) |
|
||||||
} |
|
||||||
|
|
||||||
// NewIDFromString creates a new SHA1 from a ID string of length 40.
|
|
||||||
func NewIDFromString(s string) (SHA1, error) { |
|
||||||
var id SHA1 |
|
||||||
s = strings.TrimSpace(s) |
|
||||||
if len(s) != SHAFullLength { |
|
||||||
return id, fmt.Errorf("Length must be 40: %s", s) |
|
||||||
} |
|
||||||
b, err := hex.DecodeString(s) |
|
||||||
if err != nil { |
|
||||||
return id, err |
|
||||||
} |
|
||||||
return NewID(b) |
|
||||||
} |
|
||||||
@ -1,19 +0,0 @@ |
|||||||
// Copyright 2015 The Gogs Authors. All rights reserved.
|
|
||||||
// Copyright 2019 The Gitea Authors. All rights reserved.
|
|
||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
//go:build gogit
|
|
||||||
|
|
||||||
package git |
|
||||||
|
|
||||||
import ( |
|
||||||
"github.com/go-git/go-git/v5/plumbing" |
|
||||||
) |
|
||||||
|
|
||||||
// SHA1 a git commit name
|
|
||||||
type SHA1 = plumbing.Hash |
|
||||||
|
|
||||||
// ComputeBlobHash compute the hash for a given blob content
|
|
||||||
func ComputeBlobHash(content []byte) SHA1 { |
|
||||||
return plumbing.ComputeHash(plumbing.BlobObject, content) |
|
||||||
} |
|
||||||
@ -1,61 +0,0 @@ |
|||||||
// Copyright 2015 The Gogs Authors. All rights reserved.
|
|
||||||
// Copyright 2019 The Gitea Authors. All rights reserved.
|
|
||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
//go:build !gogit
|
|
||||||
|
|
||||||
package git |
|
||||||
|
|
||||||
import ( |
|
||||||
"crypto/sha1" |
|
||||||
"encoding/hex" |
|
||||||
"hash" |
|
||||||
"strconv" |
|
||||||
) |
|
||||||
|
|
||||||
// SHA1 a git commit name
|
|
||||||
type SHA1 [20]byte |
|
||||||
|
|
||||||
// String returns a string representation of the SHA
|
|
||||||
func (s SHA1) String() string { |
|
||||||
return hex.EncodeToString(s[:]) |
|
||||||
} |
|
||||||
|
|
||||||
// IsZero returns whether this SHA1 is all zeroes
|
|
||||||
func (s SHA1) IsZero() bool { |
|
||||||
var empty SHA1 |
|
||||||
return s == empty |
|
||||||
} |
|
||||||
|
|
||||||
// ComputeBlobHash compute the hash for a given blob content
|
|
||||||
func ComputeBlobHash(content []byte) SHA1 { |
|
||||||
return ComputeHash(ObjectBlob, content) |
|
||||||
} |
|
||||||
|
|
||||||
// ComputeHash compute the hash for a given ObjectType and content
|
|
||||||
func ComputeHash(t ObjectType, content []byte) SHA1 { |
|
||||||
h := NewHasher(t, int64(len(content))) |
|
||||||
_, _ = h.Write(content) |
|
||||||
return h.Sum() |
|
||||||
} |
|
||||||
|
|
||||||
// Hasher is a struct that will generate a SHA1
|
|
||||||
type Hasher struct { |
|
||||||
hash.Hash |
|
||||||
} |
|
||||||
|
|
||||||
// NewHasher takes an object type and size and creates a hasher to generate a SHA
|
|
||||||
func NewHasher(t ObjectType, size int64) Hasher { |
|
||||||
h := Hasher{sha1.New()} |
|
||||||
_, _ = h.Write(t.Bytes()) |
|
||||||
_, _ = h.Write([]byte(" ")) |
|
||||||
_, _ = h.Write([]byte(strconv.FormatInt(size, 10))) |
|
||||||
_, _ = h.Write([]byte{0}) |
|
||||||
return h |
|
||||||
} |
|
||||||
|
|
||||||
// Sum generates a SHA1 for the provided hash
|
|
||||||
func (h Hasher) Sum() (sha1 SHA1) { |
|
||||||
copy(sha1[:], h.Hash.Sum(nil)) |
|
||||||
return sha1 |
|
||||||
} |
|
||||||
@ -1,20 +0,0 @@ |
|||||||
// Copyright 2022 The Gitea Authors. All rights reserved.
|
|
||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
package git |
|
||||||
|
|
||||||
import ( |
|
||||||
"testing" |
|
||||||
|
|
||||||
"github.com/stretchr/testify/assert" |
|
||||||
) |
|
||||||
|
|
||||||
func TestIsValidSHAPattern(t *testing.T) { |
|
||||||
assert.True(t, IsValidSHAPattern("fee1")) |
|
||||||
assert.True(t, IsValidSHAPattern("abc000")) |
|
||||||
assert.True(t, IsValidSHAPattern("9023902390239023902390239023902390239023")) |
|
||||||
assert.False(t, IsValidSHAPattern("90239023902390239023902390239023902390239023")) |
|
||||||
assert.False(t, IsValidSHAPattern("abc")) |
|
||||||
assert.False(t, IsValidSHAPattern("123g")) |
|
||||||
assert.False(t, IsValidSHAPattern("some random text")) |
|
||||||
} |
|
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue