1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
package objectid
import (
"crypto/sha1" //#nosec gosec
"crypto/sha256"
"hash"
)
// maxObjectIDSize MUST be >= the largest supported algorithm size.
const maxObjectIDSize = sha256.Size
// Algorithm identifies the hash algorithm used for Git object IDs.
type Algorithm uint8
const (
AlgorithmUnknown Algorithm = iota
AlgorithmSHA1
AlgorithmSHA256
)
type algorithmDetails struct {
name string
size int
packHashID uint32
sum func([]byte) ObjectID
new func() hash.Hash
}
//nolint:gochecknoglobals
var algorithmTable = [...]algorithmDetails{
AlgorithmUnknown: {},
AlgorithmSHA1: {
name: "sha1",
size: sha1.Size,
packHashID: 1,
sum: func(data []byte) ObjectID {
sum := sha1.Sum(data) //#nosec G401
var id ObjectID
copy(id.data[:], sum[:])
id.algo = AlgorithmSHA1
return id
},
new: sha1.New,
},
AlgorithmSHA256: {
name: "sha256",
size: sha256.Size,
packHashID: 2,
sum: func(data []byte) ObjectID {
sum := sha256.Sum256(data)
var id ObjectID
copy(id.data[:], sum[:])
id.algo = AlgorithmSHA256
return id
},
new: sha256.New,
},
}
var (
//nolint:gochecknoglobals
algorithmByName = map[string]Algorithm{}
//nolint:gochecknoglobals
supportedAlgorithms []Algorithm
)
func init() { //nolint:gochecknoinits
for algo := Algorithm(0); int(algo) < len(algorithmTable); algo++ {
info := algorithmTable[algo]
if info.name == "" {
continue
}
algorithmByName[info.name] = algo
supportedAlgorithms = append(supportedAlgorithms, algo)
}
}
// SupportedAlgorithms returns all object ID algorithms supported by furgit.
// Do not mutate.
func SupportedAlgorithms() []Algorithm {
return supportedAlgorithms
}
// ParseAlgorithm parses a canonical algorithm name (e.g. "sha1", "sha256").
func ParseAlgorithm(s string) (Algorithm, bool) {
algo, ok := algorithmByName[s]
return algo, ok
}
// Size returns the hash size in bytes.
func (algo Algorithm) Size() int {
return algo.info().size
}
// String returns the canonical algorithm name.
func (algo Algorithm) String() string {
inf := algo.info()
if inf.name == "" {
return "unknown"
}
return inf.name
}
// HexLen returns the encoded hexadecimal length.
func (algo Algorithm) HexLen() int {
return algo.Size() * 2
}
// PackHashID returns the Git pack/rev hash-id encoding for this algorithm.
//
// Unknown algorithms return 0.
func (algo Algorithm) PackHashID() uint32 {
return algo.info().packHashID
}
// Sum computes an object ID from raw data using the selected algorithm.
func (algo Algorithm) Sum(data []byte) ObjectID {
return algo.info().sum(data)
}
// New returns a new hash.Hash for this algorithm.
func (algo Algorithm) New() (hash.Hash, error) {
newFn := algo.info().new
if newFn == nil {
return nil, ErrInvalidAlgorithm
}
return newFn(), nil
}
func (algo Algorithm) info() algorithmDetails {
return algorithmTable[algo]
}
|
