Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
whqwjb
go-ethereum
提交
0a1da69f
G
go-ethereum
项目概览
whqwjb
/
go-ethereum
与 Fork 源项目一致
从无法访问的项目Fork
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
G
go-ethereum
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
前往新版Gitcode,体验更适合开发者的 AI 搜索 >>
提交
0a1da69f
编写于
2月 21, 2016
作者:
R
Ricardo Catalinas Jiménez
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
crypto/sha3: Delete old copied code
上级
f8d98f7f
变更
2
隐藏空白更改
内联
并排
Showing
2 changed file
with
0 addition
and
671 deletion
+0
-671
crypto/sha3/keccakf.go
crypto/sha3/keccakf.go
+0
-434
crypto/sha3/sha3.go
crypto/sha3/sha3.go
+0
-237
未找到文件。
crypto/sha3/keccakf.go
已删除
100644 → 0
浏览文件 @
f8d98f7f
// Copyright 2014 The Go Authors. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package
sha3
// rc stores the round constants for use in the ι step.
var
rc
=
[
24
]
uint64
{
0x0000000000000001
,
0x0000000000008082
,
0x800000000000808A
,
0x8000000080008000
,
0x000000000000808B
,
0x0000000080000001
,
0x8000000080008081
,
0x8000000000008009
,
0x000000000000008A
,
0x0000000000000088
,
0x0000000080008009
,
0x000000008000000A
,
0x000000008000808B
,
0x800000000000008B
,
0x8000000000008089
,
0x8000000000008003
,
0x8000000000008002
,
0x8000000000000080
,
0x000000000000800A
,
0x800000008000000A
,
0x8000000080008081
,
0x8000000000008080
,
0x0000000080000001
,
0x8000000080008008
,
}
// keccakF1600 applies the Keccak permutation to a 1600b-wide
// state represented as a slice of 25 uint64s.
func
keccakF1600
(
a
*
[
25
]
uint64
)
{
// Implementation translated from Keccak-inplace.c
// in the keccak reference code.
var
t
,
bc0
,
bc1
,
bc2
,
bc3
,
bc4
,
d0
,
d1
,
d2
,
d3
,
d4
uint64
for
i
:=
0
;
i
<
24
;
i
+=
4
{
// Combines the 5 steps in each round into 2 steps.
// Unrolls 4 rounds per loop and spreads some steps across rounds.
// Round 1
bc0
=
a
[
0
]
^
a
[
5
]
^
a
[
10
]
^
a
[
15
]
^
a
[
20
]
bc1
=
a
[
1
]
^
a
[
6
]
^
a
[
11
]
^
a
[
16
]
^
a
[
21
]
bc2
=
a
[
2
]
^
a
[
7
]
^
a
[
12
]
^
a
[
17
]
^
a
[
22
]
bc3
=
a
[
3
]
^
a
[
8
]
^
a
[
13
]
^
a
[
18
]
^
a
[
23
]
bc4
=
a
[
4
]
^
a
[
9
]
^
a
[
14
]
^
a
[
19
]
^
a
[
24
]
d0
=
bc4
^
(
bc1
<<
1
|
bc1
>>
63
)
d1
=
bc0
^
(
bc2
<<
1
|
bc2
>>
63
)
d2
=
bc1
^
(
bc3
<<
1
|
bc3
>>
63
)
d3
=
bc2
^
(
bc4
<<
1
|
bc4
>>
63
)
d4
=
bc3
^
(
bc0
<<
1
|
bc0
>>
63
)
bc0
=
a
[
0
]
^
d0
t
=
a
[
6
]
^
d1
bc1
=
t
<<
44
|
t
>>
(
64
-
44
)
t
=
a
[
12
]
^
d2
bc2
=
t
<<
43
|
t
>>
(
64
-
43
)
t
=
a
[
18
]
^
d3
bc3
=
t
<<
21
|
t
>>
(
64
-
21
)
t
=
a
[
24
]
^
d4
bc4
=
t
<<
14
|
t
>>
(
64
-
14
)
a
[
0
]
=
bc0
^
(
bc2
&^
bc1
)
^
rc
[
i
]
a
[
6
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
12
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
18
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
24
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
10
]
^
d0
bc2
=
t
<<
3
|
t
>>
(
64
-
3
)
t
=
a
[
16
]
^
d1
bc3
=
t
<<
45
|
t
>>
(
64
-
45
)
t
=
a
[
22
]
^
d2
bc4
=
t
<<
61
|
t
>>
(
64
-
61
)
t
=
a
[
3
]
^
d3
bc0
=
t
<<
28
|
t
>>
(
64
-
28
)
t
=
a
[
9
]
^
d4
bc1
=
t
<<
20
|
t
>>
(
64
-
20
)
a
[
10
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
16
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
22
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
3
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
9
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
20
]
^
d0
bc4
=
t
<<
18
|
t
>>
(
64
-
18
)
t
=
a
[
1
]
^
d1
bc0
=
t
<<
1
|
t
>>
(
64
-
1
)
t
=
a
[
7
]
^
d2
bc1
=
t
<<
6
|
t
>>
(
64
-
6
)
t
=
a
[
13
]
^
d3
bc2
=
t
<<
25
|
t
>>
(
64
-
25
)
t
=
a
[
19
]
^
d4
bc3
=
t
<<
8
|
t
>>
(
64
-
8
)
a
[
20
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
1
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
7
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
13
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
19
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
5
]
^
d0
bc1
=
t
<<
36
|
t
>>
(
64
-
36
)
t
=
a
[
11
]
^
d1
bc2
=
t
<<
10
|
t
>>
(
64
-
10
)
t
=
a
[
17
]
^
d2
bc3
=
t
<<
15
|
t
>>
(
64
-
15
)
t
=
a
[
23
]
^
d3
bc4
=
t
<<
56
|
t
>>
(
64
-
56
)
t
=
a
[
4
]
^
d4
bc0
=
t
<<
27
|
t
>>
(
64
-
27
)
a
[
5
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
11
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
17
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
23
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
4
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
15
]
^
d0
bc3
=
t
<<
41
|
t
>>
(
64
-
41
)
t
=
a
[
21
]
^
d1
bc4
=
t
<<
2
|
t
>>
(
64
-
2
)
t
=
a
[
2
]
^
d2
bc0
=
t
<<
62
|
t
>>
(
64
-
62
)
t
=
a
[
8
]
^
d3
bc1
=
t
<<
55
|
t
>>
(
64
-
55
)
t
=
a
[
14
]
^
d4
bc2
=
t
<<
39
|
t
>>
(
64
-
39
)
a
[
15
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
21
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
2
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
8
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
14
]
=
bc4
^
(
bc1
&^
bc0
)
// Round 2
bc0
=
a
[
0
]
^
a
[
5
]
^
a
[
10
]
^
a
[
15
]
^
a
[
20
]
bc1
=
a
[
1
]
^
a
[
6
]
^
a
[
11
]
^
a
[
16
]
^
a
[
21
]
bc2
=
a
[
2
]
^
a
[
7
]
^
a
[
12
]
^
a
[
17
]
^
a
[
22
]
bc3
=
a
[
3
]
^
a
[
8
]
^
a
[
13
]
^
a
[
18
]
^
a
[
23
]
bc4
=
a
[
4
]
^
a
[
9
]
^
a
[
14
]
^
a
[
19
]
^
a
[
24
]
d0
=
bc4
^
(
bc1
<<
1
|
bc1
>>
63
)
d1
=
bc0
^
(
bc2
<<
1
|
bc2
>>
63
)
d2
=
bc1
^
(
bc3
<<
1
|
bc3
>>
63
)
d3
=
bc2
^
(
bc4
<<
1
|
bc4
>>
63
)
d4
=
bc3
^
(
bc0
<<
1
|
bc0
>>
63
)
bc0
=
a
[
0
]
^
d0
t
=
a
[
16
]
^
d1
bc1
=
t
<<
44
|
t
>>
(
64
-
44
)
t
=
a
[
7
]
^
d2
bc2
=
t
<<
43
|
t
>>
(
64
-
43
)
t
=
a
[
23
]
^
d3
bc3
=
t
<<
21
|
t
>>
(
64
-
21
)
t
=
a
[
14
]
^
d4
bc4
=
t
<<
14
|
t
>>
(
64
-
14
)
a
[
0
]
=
bc0
^
(
bc2
&^
bc1
)
^
rc
[
i
+
1
]
a
[
16
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
7
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
23
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
14
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
20
]
^
d0
bc2
=
t
<<
3
|
t
>>
(
64
-
3
)
t
=
a
[
11
]
^
d1
bc3
=
t
<<
45
|
t
>>
(
64
-
45
)
t
=
a
[
2
]
^
d2
bc4
=
t
<<
61
|
t
>>
(
64
-
61
)
t
=
a
[
18
]
^
d3
bc0
=
t
<<
28
|
t
>>
(
64
-
28
)
t
=
a
[
9
]
^
d4
bc1
=
t
<<
20
|
t
>>
(
64
-
20
)
a
[
20
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
11
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
2
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
18
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
9
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
15
]
^
d0
bc4
=
t
<<
18
|
t
>>
(
64
-
18
)
t
=
a
[
6
]
^
d1
bc0
=
t
<<
1
|
t
>>
(
64
-
1
)
t
=
a
[
22
]
^
d2
bc1
=
t
<<
6
|
t
>>
(
64
-
6
)
t
=
a
[
13
]
^
d3
bc2
=
t
<<
25
|
t
>>
(
64
-
25
)
t
=
a
[
4
]
^
d4
bc3
=
t
<<
8
|
t
>>
(
64
-
8
)
a
[
15
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
6
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
22
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
13
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
4
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
10
]
^
d0
bc1
=
t
<<
36
|
t
>>
(
64
-
36
)
t
=
a
[
1
]
^
d1
bc2
=
t
<<
10
|
t
>>
(
64
-
10
)
t
=
a
[
17
]
^
d2
bc3
=
t
<<
15
|
t
>>
(
64
-
15
)
t
=
a
[
8
]
^
d3
bc4
=
t
<<
56
|
t
>>
(
64
-
56
)
t
=
a
[
24
]
^
d4
bc0
=
t
<<
27
|
t
>>
(
64
-
27
)
a
[
10
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
1
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
17
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
8
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
24
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
5
]
^
d0
bc3
=
t
<<
41
|
t
>>
(
64
-
41
)
t
=
a
[
21
]
^
d1
bc4
=
t
<<
2
|
t
>>
(
64
-
2
)
t
=
a
[
12
]
^
d2
bc0
=
t
<<
62
|
t
>>
(
64
-
62
)
t
=
a
[
3
]
^
d3
bc1
=
t
<<
55
|
t
>>
(
64
-
55
)
t
=
a
[
19
]
^
d4
bc2
=
t
<<
39
|
t
>>
(
64
-
39
)
a
[
5
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
21
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
12
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
3
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
19
]
=
bc4
^
(
bc1
&^
bc0
)
// Round 3
bc0
=
a
[
0
]
^
a
[
5
]
^
a
[
10
]
^
a
[
15
]
^
a
[
20
]
bc1
=
a
[
1
]
^
a
[
6
]
^
a
[
11
]
^
a
[
16
]
^
a
[
21
]
bc2
=
a
[
2
]
^
a
[
7
]
^
a
[
12
]
^
a
[
17
]
^
a
[
22
]
bc3
=
a
[
3
]
^
a
[
8
]
^
a
[
13
]
^
a
[
18
]
^
a
[
23
]
bc4
=
a
[
4
]
^
a
[
9
]
^
a
[
14
]
^
a
[
19
]
^
a
[
24
]
d0
=
bc4
^
(
bc1
<<
1
|
bc1
>>
63
)
d1
=
bc0
^
(
bc2
<<
1
|
bc2
>>
63
)
d2
=
bc1
^
(
bc3
<<
1
|
bc3
>>
63
)
d3
=
bc2
^
(
bc4
<<
1
|
bc4
>>
63
)
d4
=
bc3
^
(
bc0
<<
1
|
bc0
>>
63
)
bc0
=
a
[
0
]
^
d0
t
=
a
[
11
]
^
d1
bc1
=
t
<<
44
|
t
>>
(
64
-
44
)
t
=
a
[
22
]
^
d2
bc2
=
t
<<
43
|
t
>>
(
64
-
43
)
t
=
a
[
8
]
^
d3
bc3
=
t
<<
21
|
t
>>
(
64
-
21
)
t
=
a
[
19
]
^
d4
bc4
=
t
<<
14
|
t
>>
(
64
-
14
)
a
[
0
]
=
bc0
^
(
bc2
&^
bc1
)
^
rc
[
i
+
2
]
a
[
11
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
22
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
8
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
19
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
15
]
^
d0
bc2
=
t
<<
3
|
t
>>
(
64
-
3
)
t
=
a
[
1
]
^
d1
bc3
=
t
<<
45
|
t
>>
(
64
-
45
)
t
=
a
[
12
]
^
d2
bc4
=
t
<<
61
|
t
>>
(
64
-
61
)
t
=
a
[
23
]
^
d3
bc0
=
t
<<
28
|
t
>>
(
64
-
28
)
t
=
a
[
9
]
^
d4
bc1
=
t
<<
20
|
t
>>
(
64
-
20
)
a
[
15
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
1
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
12
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
23
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
9
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
5
]
^
d0
bc4
=
t
<<
18
|
t
>>
(
64
-
18
)
t
=
a
[
16
]
^
d1
bc0
=
t
<<
1
|
t
>>
(
64
-
1
)
t
=
a
[
2
]
^
d2
bc1
=
t
<<
6
|
t
>>
(
64
-
6
)
t
=
a
[
13
]
^
d3
bc2
=
t
<<
25
|
t
>>
(
64
-
25
)
t
=
a
[
24
]
^
d4
bc3
=
t
<<
8
|
t
>>
(
64
-
8
)
a
[
5
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
16
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
2
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
13
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
24
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
20
]
^
d0
bc1
=
t
<<
36
|
t
>>
(
64
-
36
)
t
=
a
[
6
]
^
d1
bc2
=
t
<<
10
|
t
>>
(
64
-
10
)
t
=
a
[
17
]
^
d2
bc3
=
t
<<
15
|
t
>>
(
64
-
15
)
t
=
a
[
3
]
^
d3
bc4
=
t
<<
56
|
t
>>
(
64
-
56
)
t
=
a
[
14
]
^
d4
bc0
=
t
<<
27
|
t
>>
(
64
-
27
)
a
[
20
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
6
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
17
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
3
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
14
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
10
]
^
d0
bc3
=
t
<<
41
|
t
>>
(
64
-
41
)
t
=
a
[
21
]
^
d1
bc4
=
t
<<
2
|
t
>>
(
64
-
2
)
t
=
a
[
7
]
^
d2
bc0
=
t
<<
62
|
t
>>
(
64
-
62
)
t
=
a
[
18
]
^
d3
bc1
=
t
<<
55
|
t
>>
(
64
-
55
)
t
=
a
[
4
]
^
d4
bc2
=
t
<<
39
|
t
>>
(
64
-
39
)
a
[
10
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
21
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
7
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
18
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
4
]
=
bc4
^
(
bc1
&^
bc0
)
// Round 4
bc0
=
a
[
0
]
^
a
[
5
]
^
a
[
10
]
^
a
[
15
]
^
a
[
20
]
bc1
=
a
[
1
]
^
a
[
6
]
^
a
[
11
]
^
a
[
16
]
^
a
[
21
]
bc2
=
a
[
2
]
^
a
[
7
]
^
a
[
12
]
^
a
[
17
]
^
a
[
22
]
bc3
=
a
[
3
]
^
a
[
8
]
^
a
[
13
]
^
a
[
18
]
^
a
[
23
]
bc4
=
a
[
4
]
^
a
[
9
]
^
a
[
14
]
^
a
[
19
]
^
a
[
24
]
d0
=
bc4
^
(
bc1
<<
1
|
bc1
>>
63
)
d1
=
bc0
^
(
bc2
<<
1
|
bc2
>>
63
)
d2
=
bc1
^
(
bc3
<<
1
|
bc3
>>
63
)
d3
=
bc2
^
(
bc4
<<
1
|
bc4
>>
63
)
d4
=
bc3
^
(
bc0
<<
1
|
bc0
>>
63
)
bc0
=
a
[
0
]
^
d0
t
=
a
[
1
]
^
d1
bc1
=
t
<<
44
|
t
>>
(
64
-
44
)
t
=
a
[
2
]
^
d2
bc2
=
t
<<
43
|
t
>>
(
64
-
43
)
t
=
a
[
3
]
^
d3
bc3
=
t
<<
21
|
t
>>
(
64
-
21
)
t
=
a
[
4
]
^
d4
bc4
=
t
<<
14
|
t
>>
(
64
-
14
)
a
[
0
]
=
bc0
^
(
bc2
&^
bc1
)
^
rc
[
i
+
3
]
a
[
1
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
2
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
3
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
4
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
5
]
^
d0
bc2
=
t
<<
3
|
t
>>
(
64
-
3
)
t
=
a
[
6
]
^
d1
bc3
=
t
<<
45
|
t
>>
(
64
-
45
)
t
=
a
[
7
]
^
d2
bc4
=
t
<<
61
|
t
>>
(
64
-
61
)
t
=
a
[
8
]
^
d3
bc0
=
t
<<
28
|
t
>>
(
64
-
28
)
t
=
a
[
9
]
^
d4
bc1
=
t
<<
20
|
t
>>
(
64
-
20
)
a
[
5
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
6
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
7
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
8
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
9
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
10
]
^
d0
bc4
=
t
<<
18
|
t
>>
(
64
-
18
)
t
=
a
[
11
]
^
d1
bc0
=
t
<<
1
|
t
>>
(
64
-
1
)
t
=
a
[
12
]
^
d2
bc1
=
t
<<
6
|
t
>>
(
64
-
6
)
t
=
a
[
13
]
^
d3
bc2
=
t
<<
25
|
t
>>
(
64
-
25
)
t
=
a
[
14
]
^
d4
bc3
=
t
<<
8
|
t
>>
(
64
-
8
)
a
[
10
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
11
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
12
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
13
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
14
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
15
]
^
d0
bc1
=
t
<<
36
|
t
>>
(
64
-
36
)
t
=
a
[
16
]
^
d1
bc2
=
t
<<
10
|
t
>>
(
64
-
10
)
t
=
a
[
17
]
^
d2
bc3
=
t
<<
15
|
t
>>
(
64
-
15
)
t
=
a
[
18
]
^
d3
bc4
=
t
<<
56
|
t
>>
(
64
-
56
)
t
=
a
[
19
]
^
d4
bc0
=
t
<<
27
|
t
>>
(
64
-
27
)
a
[
15
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
16
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
17
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
18
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
19
]
=
bc4
^
(
bc1
&^
bc0
)
t
=
a
[
20
]
^
d0
bc3
=
t
<<
41
|
t
>>
(
64
-
41
)
t
=
a
[
21
]
^
d1
bc4
=
t
<<
2
|
t
>>
(
64
-
2
)
t
=
a
[
22
]
^
d2
bc0
=
t
<<
62
|
t
>>
(
64
-
62
)
t
=
a
[
23
]
^
d3
bc1
=
t
<<
55
|
t
>>
(
64
-
55
)
t
=
a
[
24
]
^
d4
bc2
=
t
<<
39
|
t
>>
(
64
-
39
)
a
[
20
]
=
bc0
^
(
bc2
&^
bc1
)
a
[
21
]
=
bc1
^
(
bc3
&^
bc2
)
a
[
22
]
=
bc2
^
(
bc4
&^
bc3
)
a
[
23
]
=
bc3
^
(
bc0
&^
bc4
)
a
[
24
]
=
bc4
^
(
bc1
&^
bc0
)
}
}
crypto/sha3/sha3.go
已删除
100644 → 0
浏览文件 @
f8d98f7f
// Copyright 2013 The Go Authors. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Package sha3 implements the SHA3 hash algorithm (formerly called Keccak) chosen by NIST in 2012.
// This file provides a SHA3 implementation which implements the standard hash.Hash interface.
// Writing input data, including padding, and reading output data are computed in this file.
// Note that the current implementation can compute the hash of an integral number of bytes only.
// This is a consequence of the hash interface in which a buffer of bytes is passed in.
// The internals of the Keccak-f function are computed in keccakf.go.
// For the detailed specification, refer to the Keccak web site (http://keccak.noekeon.org/).
package
sha3
import
(
"encoding/binary"
"hash"
)
// laneSize is the size in bytes of each "lane" of the internal state of SHA3 (5 * 5 * 8).
// Note that changing this size would requires using a type other than uint64 to store each lane.
const
laneSize
=
8
// sliceSize represents the dimensions of the internal state, a square matrix of
// sliceSize ** 2 lanes. This is the size of both the "rows" and "columns" dimensions in the
// terminology of the SHA3 specification.
const
sliceSize
=
5
// numLanes represents the total number of lanes in the state.
const
numLanes
=
sliceSize
*
sliceSize
// stateSize is the size in bytes of the internal state of SHA3 (5 * 5 * WSize).
const
stateSize
=
laneSize
*
numLanes
// digest represents the partial evaluation of a checksum.
// Note that capacity, and not outputSize, is the critical security parameter, as SHA3 can output
// an arbitrary number of bytes for any given capacity. The Keccak proposal recommends that
// capacity = 2*outputSize to ensure that finding a collision of size outputSize requires
// O(2^{outputSize/2}) computations (the birthday lower bound). Future standards may modify the
// capacity/outputSize ratio to allow for more output with lower cryptographic security.
type
digest
struct
{
a
[
numLanes
]
uint64
// main state of the hash
outputSize
int
// desired output size in bytes
capacity
int
// number of bytes to leave untouched during squeeze/absorb
absorbed
int
// number of bytes absorbed thus far
}
// minInt returns the lesser of two integer arguments, to simplify the absorption routine.
func
minInt
(
v1
,
v2
int
)
int
{
if
v1
<=
v2
{
return
v1
}
return
v2
}
// rate returns the number of bytes of the internal state which can be absorbed or squeezed
// in between calls to the permutation function.
func
(
d
*
digest
)
rate
()
int
{
return
stateSize
-
d
.
capacity
}
// Reset clears the internal state by zeroing bytes in the state buffer.
// This can be skipped for a newly-created hash state; the default zero-allocated state is correct.
func
(
d
*
digest
)
Reset
()
{
d
.
absorbed
=
0
for
i
:=
range
d
.
a
{
d
.
a
[
i
]
=
0
}
}
// BlockSize, required by the hash.Hash interface, does not have a standard intepretation
// for a sponge-based construction like SHA3. We return the data rate: the number of bytes which
// can be absorbed per invocation of the permutation function. For Merkle-Damgård based hashes
// (ie SHA1, SHA2, MD5) the output size of the internal compression function is returned.
// We consider this to be roughly equivalent because it represents the number of bytes of output
// produced per cryptographic operation.
func
(
d
*
digest
)
BlockSize
()
int
{
return
d
.
rate
()
}
// Size returns the output size of the hash function in bytes.
func
(
d
*
digest
)
Size
()
int
{
return
d
.
outputSize
}
// unalignedAbsorb is a helper function for Write, which absorbs data that isn't aligned with an
// 8-byte lane. This requires shifting the individual bytes into position in a uint64.
func
(
d
*
digest
)
unalignedAbsorb
(
p
[]
byte
)
{
var
t
uint64
for
i
:=
len
(
p
)
-
1
;
i
>=
0
;
i
--
{
t
<<=
8
t
|=
uint64
(
p
[
i
])
}
offset
:=
(
d
.
absorbed
)
%
d
.
rate
()
t
<<=
8
*
uint
(
offset
%
laneSize
)
d
.
a
[
offset
/
laneSize
]
^=
t
d
.
absorbed
+=
len
(
p
)
}
// Write "absorbs" bytes into the state of the SHA3 hash, updating as needed when the sponge
// "fills up" with rate() bytes. Since lanes are stored internally as type uint64, this requires
// converting the incoming bytes into uint64s using a little endian interpretation. This
// implementation is optimized for large, aligned writes of multiples of 8 bytes (laneSize).
// Non-aligned or uneven numbers of bytes require shifting and are slower.
func
(
d
*
digest
)
Write
(
p
[]
byte
)
(
int
,
error
)
{
// An initial offset is needed if the we aren't absorbing to the first lane initially.
offset
:=
d
.
absorbed
%
d
.
rate
()
toWrite
:=
len
(
p
)
// The first lane may need to absorb unaligned and/or incomplete data.
if
(
offset
%
laneSize
!=
0
||
len
(
p
)
<
8
)
&&
len
(
p
)
>
0
{
toAbsorb
:=
minInt
(
laneSize
-
(
offset
%
laneSize
),
len
(
p
))
d
.
unalignedAbsorb
(
p
[
:
toAbsorb
])
p
=
p
[
toAbsorb
:
]
offset
=
(
d
.
absorbed
)
%
d
.
rate
()
// For every rate() bytes absorbed, the state must be permuted via the F Function.
if
(
d
.
absorbed
)
%
d
.
rate
()
==
0
{
keccakF1600
(
&
d
.
a
)
}
}
// This loop should absorb the bulk of the data into full, aligned lanes.
// It will call the update function as necessary.
for
len
(
p
)
>
7
{
firstLane
:=
offset
/
laneSize
lastLane
:=
minInt
(
d
.
rate
()
/
laneSize
,
firstLane
+
len
(
p
)
/
laneSize
)
// This inner loop absorbs input bytes into the state in groups of 8, converted to uint64s.
for
lane
:=
firstLane
;
lane
<
lastLane
;
lane
++
{
d
.
a
[
lane
]
^=
binary
.
LittleEndian
.
Uint64
(
p
[
:
laneSize
])
p
=
p
[
laneSize
:
]
}
d
.
absorbed
+=
(
lastLane
-
firstLane
)
*
laneSize
// For every rate() bytes absorbed, the state must be permuted via the F Function.
if
(
d
.
absorbed
)
%
d
.
rate
()
==
0
{
keccakF1600
(
&
d
.
a
)
}
offset
=
0
}
// If there are insufficient bytes to fill the final lane, an unaligned absorption.
// This should always start at a correct lane boundary though, or else it would be caught
// by the uneven opening lane case above.
if
len
(
p
)
>
0
{
d
.
unalignedAbsorb
(
p
)
}
return
toWrite
,
nil
}
// pad computes the SHA3 padding scheme based on the number of bytes absorbed.
// The padding is a 1 bit, followed by an arbitrary number of 0s and then a final 1 bit, such that
// the input bits plus padding bits are a multiple of rate(). Adding the padding simply requires
// xoring an opening and closing bit into the appropriate lanes.
func
(
d
*
digest
)
pad
()
{
offset
:=
d
.
absorbed
%
d
.
rate
()
// The opening pad bit must be shifted into position based on the number of bytes absorbed
padOpenLane
:=
offset
/
laneSize
d
.
a
[
padOpenLane
]
^=
0x0000000000000001
<<
uint
(
8
*
(
offset
%
laneSize
))
// The closing padding bit is always in the last position
padCloseLane
:=
(
d
.
rate
()
/
laneSize
)
-
1
d
.
a
[
padCloseLane
]
^=
0x8000000000000000
}
// finalize prepares the hash to output data by padding and one final permutation of the state.
func
(
d
*
digest
)
finalize
()
{
d
.
pad
()
keccakF1600
(
&
d
.
a
)
}
// squeeze outputs an arbitrary number of bytes from the hash state.
// Squeezing can require multiple calls to the F function (one per rate() bytes squeezed),
// although this is not the case for standard SHA3 parameters. This implementation only supports
// squeezing a single time, subsequent squeezes may lose alignment. Future implementations
// may wish to support multiple squeeze calls, for example to support use as a PRNG.
func
(
d
*
digest
)
squeeze
(
in
[]
byte
,
toSqueeze
int
)
[]
byte
{
// Because we read in blocks of laneSize, we need enough room to read
// an integral number of lanes
needed
:=
toSqueeze
+
(
laneSize
-
toSqueeze
%
laneSize
)
%
laneSize
if
cap
(
in
)
-
len
(
in
)
<
needed
{
newIn
:=
make
([]
byte
,
len
(
in
),
len
(
in
)
+
needed
)
copy
(
newIn
,
in
)
in
=
newIn
}
out
:=
in
[
len
(
in
)
:
len
(
in
)
+
needed
]
for
len
(
out
)
>
0
{
for
i
:=
0
;
i
<
d
.
rate
()
&&
len
(
out
)
>
0
;
i
+=
laneSize
{
binary
.
LittleEndian
.
PutUint64
(
out
[
:
],
d
.
a
[
i
/
laneSize
])
out
=
out
[
laneSize
:
]
}
if
len
(
out
)
>
0
{
keccakF1600
(
&
d
.
a
)
}
}
return
in
[
:
len
(
in
)
+
toSqueeze
]
// Re-slice in case we wrote extra data.
}
// Sum applies padding to the hash state and then squeezes out the desired nubmer of output bytes.
func
(
d
*
digest
)
Sum
(
in
[]
byte
)
[]
byte
{
// Make a copy of the original hash so that caller can keep writing and summing.
dup
:=
*
d
dup
.
finalize
()
return
dup
.
squeeze
(
in
,
dup
.
outputSize
)
}
// The NewKeccakX constructors enable initializing a hash in any of the four recommend sizes
// from the Keccak specification, all of which set capacity=2*outputSize. Note that the final
// NIST standard for SHA3 may specify different input/output lengths.
// The output size is indicated in bits but converted into bytes internally.
func
NewKeccak224
()
hash
.
Hash
{
return
&
digest
{
outputSize
:
224
/
8
,
capacity
:
2
*
224
/
8
}
}
func
NewKeccak256
()
hash
.
Hash
{
return
&
digest
{
outputSize
:
256
/
8
,
capacity
:
2
*
256
/
8
}
}
func
NewKeccak384
()
hash
.
Hash
{
return
&
digest
{
outputSize
:
384
/
8
,
capacity
:
2
*
384
/
8
}
}
func
NewKeccak512
()
hash
.
Hash
{
return
&
digest
{
outputSize
:
512
/
8
,
capacity
:
2
*
512
/
8
}
}
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录