-
Notifications
You must be signed in to change notification settings - Fork 0
/
hashing.go
201 lines (153 loc) · 4.65 KB
/
hashing.go
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
package hashing
import (
"crypto/md5"
"crypto/sha1"
"crypto/sha256"
"fmt"
"hash"
"hash/crc32"
"reflect"
"golang.org/x/crypto/sha3"
)
/**
* Has hashing functions that produce byte array hashes.
* (no support for blake2b)
* @author rnojiri
**/
// Algorithm - the algorithm constant type
type Algorithm string
const (
// SHA256 - constant
SHA256 Algorithm = "sha256"
// SHA1 - constant
SHA1 Algorithm = "sha1"
// MD5 - constant
MD5 Algorithm = "md5"
// CRC32 - constant
CRC32 Algorithm = "crc32"
// SHAKE128 - constant
SHAKE128 Algorithm = "shake128"
// SHAKE256 - constant
SHAKE256 Algorithm = "shake256"
// BLAKE2B384 - constant
// BLAKE2B384 Algorithm = "blake2b384"
// BLAKE2B256 - constant
// BLAKE2B256 Algorithm = "blake2b256"
// BLAKE2B512 - constant
// BLAKE2B512 Algorithm = "blake2b512"
)
// GenerateByteArray - generates a new byte array based on the given parameters
func GenerateByteArray(parameters ...interface{}) ([]byte, error) {
if len(parameters) == 0 {
return nil, nil
}
result := []byte{}
for _, p := range parameters {
bytes, err := getByteArray(reflect.ValueOf(p))
if err != nil {
return nil, err
}
result = append(result, bytes...)
}
return result, nil
}
// generateHash - the main process
func generateHash(h hash.Hash, parameters ...interface{}) ([]byte, error) {
byteArray, err := GenerateByteArray(parameters...)
if err != nil {
return nil, err
}
_, err = h.Write(byteArray)
if err != nil {
return nil, err
}
return h.Sum(nil), nil
}
// generateShakeHash - the main process for shake hash
func generateShakeHash(h sha3.ShakeHash, outputSize int, parameters ...interface{}) ([]byte, error) {
byteArray, err := GenerateByteArray(parameters...)
if err != nil {
return nil, err
}
_, err = h.Write(byteArray)
if err != nil {
return nil, err
}
output := make([]byte, outputSize)
_, err = h.Read(output)
if err != nil {
return nil, err
}
return output, nil
}
// GenerateSHA256 - generates a sha256 hash based on the specified parameters
func GenerateSHA256(parameters ...interface{}) ([]byte, error) {
return generateHash(sha256.New(), parameters...)
}
// GenerateCRC32 - generates a sha256 hash based on the specified parameters
func GenerateCRC32(parameters ...interface{}) ([]byte, error) {
return generateHash(crc32.NewIEEE(), parameters...)
}
// GenerateMD5 - generates a md5 hash based on the specified parameters
func GenerateMD5(parameters ...interface{}) ([]byte, error) {
return generateHash(md5.New(), parameters...)
}
// GenerateSHA1 - generates a sha1 hash based on the specified parameters
func GenerateSHA1(parameters ...interface{}) ([]byte, error) {
return generateHash(sha1.New(), parameters...)
}
// GenerateSHAKE128 - generates a shake128 hash based on the specified parameters
func GenerateSHAKE128(outputSize int, parameters ...interface{}) ([]byte, error) {
return generateShakeHash(sha3.NewShake128(), outputSize, parameters...)
}
// GenerateSHAKE256 - generates a shake256 hash based on the specified parameters
func GenerateSHAKE256(outputSize int, parameters ...interface{}) ([]byte, error) {
return generateShakeHash(sha3.NewShake256(), outputSize, parameters...)
}
// GenerateBlake2b - generates a blacke2b hash based on the specified parameters
// func GenerateBlake2b(blakeAlgorithm Algorithm, parameters ...interface{}) ([]byte, error) {
// var h hash.Hash
// var err error
// switch blakeAlgorithm {
// case BLAKE2B256:
// h, err = blake2b.New256(nil)
// case BLAKE2B512:
// h, err = blake2b.New512(nil)
// case BLAKE2B384:
// h, err = blake2b.New384(nil)
// default:
// err = fmt.Errorf("available sizes: 256, 384 and 512")
// }
// if err != nil {
// return nil, err
// }
// return generateHash(h, parameters...)
// }
// Generate - generates the hash using the selected algorithm
func Generate(algorithm Algorithm, parameters ...interface{}) ([]byte, error) {
switch algorithm {
case SHA256:
return GenerateSHA256(parameters...)
case SHA1:
return GenerateSHA1(parameters...)
case MD5:
return GenerateMD5(parameters...)
case CRC32:
return GenerateCRC32(parameters...)
// case BLAKE2B256, BLAKE2B384, BLAKE2B512:
// return GenerateBlake2b(algorithm, parameters)
default:
return nil, fmt.Errorf("no algorithm named %s", algorithm)
}
}
// GenerateSHAKE - generates the shake hash using the selected algorithm
func GenerateSHAKE(algorithm Algorithm, outputSize int, parameters ...interface{}) ([]byte, error) {
switch algorithm {
case SHAKE128:
return GenerateSHAKE128(outputSize, parameters...)
case SHAKE256:
return GenerateSHAKE256(outputSize, parameters...)
default:
return nil, fmt.Errorf("no algorithm named %s", algorithm)
}
}