Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
btwise
openssl
提交
66186aee
O
openssl
项目概览
btwise
/
openssl
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
O
openssl
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
66186aee
编写于
1月 21, 2015
作者:
M
Matt Caswell
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
Manually reformat aes_x86core.c and add it to the list of files skipped by
openssl-format-source Reviewed-by:
N
Tim Hudson
<
tjh@openssl.org
>
上级
1ab6c607
变更
2
隐藏空白更改
内联
并排
Showing
2 changed file
with
522 addition
and
515 deletion
+522
-515
crypto/aes/aes_x86core.c
crypto/aes/aes_x86core.c
+521
-514
util/openssl-format-source
util/openssl-format-source
+1
-1
未找到文件。
crypto/aes/aes_x86core.c
浏览文件 @
66186aee
...
...
@@ -31,7 +31,7 @@
* It is used as playground for cache-time attack mitigations and
* serves as reference C implementation for x86[_64] assembler.
*
*
<appro@fy.chalmers.se>
*
<appro@fy.chalmers.se>
*/
...
...
@@ -61,14 +61,14 @@
#if 1
static
void
prefetch256
(
const
void
*
table
)
{
volatile
unsigned
long
*
t
=
(
void
*
)
table
,
ret
;
unsigned
long
sum
;
int
i
;
volatile
unsigned
long
*
t
=
(
void
*
)
table
,
ret
;
unsigned
long
sum
;
int
i
;
/* 32 is common least cache-line size */
for
(
sum
=
0
,
i
=
0
;
i
<
256
/
sizeof
(
t
[
0
]);
i
+=
32
/
sizeof
(
t
[
0
]))
sum
^=
t
[
i
];
/* 32 is common least cache-line size */
for
(
sum
=
0
,
i
=
0
;
i
<
256
/
sizeof
(
t
[
0
]);
i
+=
32
/
sizeof
(
t
[
0
]))
sum
^=
t
[
i
];
ret
=
sum
;
ret
=
sum
;
}
#else
# define prefetch256(t)
...
...
@@ -79,30 +79,30 @@ static void prefetch256(const void *table)
#if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__)
typedef
unsigned
__int64
u64
;
#define U64(C)
C##UI64
#define U64(C)
C##UI64
#elif defined(__arch64__)
typedef
unsigned
long
u64
;
#define U64(C)
C##UL
#define U64(C)
C##UL
#else
typedef
unsigned
long
long
u64
;
#define U64(C)
C##ULL
#define U64(C)
C##ULL
#endif
#undef ROTATE
#if defined(_MSC_VER)
# define ROTATE(a,n)
_lrotl(a,n)
# define ROTATE(a,n)
_lrotl(a,n)
#elif defined(__ICC)
# define ROTATE(a,n)
_rotl(a,n)
# define ROTATE(a,n)
_rotl(a,n)
#elif defined(__GNUC__) && __GNUC__>=2
# if defined(__i386) || defined(__i386__) || defined(__x86_64) || defined(__x86_64__)
# define ROTATE(a,n)
({ register unsigned int ret;
\
asm (
\
"roll %1,%0"
\
: "=r"(ret)
\
: "I"(n), "0"(a)
\
: "cc");
\
ret;
\
})
# define ROTATE(a,n)
({ register unsigned int ret;
\
asm (
\
"roll %1,%0"
\
: "=r"(ret)
\
: "I"(n), "0"(a)
\
: "cc");
\
ret;
\
})
# endif
#endif
/*-
...
...
@@ -470,181 +470,183 @@ static const u32 rcon[] = {
* Expand the cipher key into the encryption key schedule.
*/
int
AES_set_encrypt_key
(
const
unsigned
char
*
userKey
,
const
int
bits
,
AES_KEY
*
key
)
{
AES_KEY
*
key
)
{
u32
*
rk
;
int
i
=
0
;
u32
temp
;
u32
*
rk
;
int
i
=
0
;
u32
temp
;
if
(
!
userKey
||
!
key
)
return
-
1
;
if
(
bits
!=
128
&&
bits
!=
192
&&
bits
!=
256
)
return
-
2
;
if
(
!
userKey
||
!
key
)
return
-
1
;
if
(
bits
!=
128
&&
bits
!=
192
&&
bits
!=
256
)
return
-
2
;
rk
=
key
->
rd_key
;
rk
=
key
->
rd_key
;
if
(
bits
==
128
)
key
->
rounds
=
10
;
else
if
(
bits
==
192
)
key
->
rounds
=
12
;
else
key
->
rounds
=
14
;
if
(
bits
==
128
)
key
->
rounds
=
10
;
else
if
(
bits
==
192
)
key
->
rounds
=
12
;
else
key
->
rounds
=
14
;
rk
[
0
]
=
GETU32
(
userKey
);
rk
[
1
]
=
GETU32
(
userKey
+
4
);
rk
[
2
]
=
GETU32
(
userKey
+
8
);
rk
[
3
]
=
GETU32
(
userKey
+
12
);
if
(
bits
==
128
)
{
while
(
1
)
{
temp
=
rk
[
3
];
rk
[
4
]
=
rk
[
0
]
^
(
Te4
[(
temp
>>
8
)
&
0xff
]
)
^
(
Te4
[(
temp
>>
16
)
&
0xff
]
<<
8
)
^
(
Te4
[(
temp
>>
24
)
]
<<
16
)
^
(
Te4
[(
temp
)
&
0xff
]
<<
24
)
^
rcon
[
i
];
rk
[
5
]
=
rk
[
1
]
^
rk
[
4
];
rk
[
6
]
=
rk
[
2
]
^
rk
[
5
];
rk
[
7
]
=
rk
[
3
]
^
rk
[
6
];
if
(
++
i
==
10
)
{
return
0
;
}
rk
+=
4
;
}
}
rk
[
4
]
=
GETU32
(
userKey
+
16
);
rk
[
5
]
=
GETU32
(
userKey
+
20
);
if
(
bits
==
192
)
{
while
(
1
)
{
temp
=
rk
[
5
];
rk
[
6
]
=
rk
[
0
]
^
(
Te4
[(
temp
>>
8
)
&
0xff
]
)
^
(
Te4
[(
temp
>>
16
)
&
0xff
]
<<
8
)
^
(
Te4
[(
temp
>>
24
)
]
<<
16
)
^
(
Te4
[(
temp
)
&
0xff
]
<<
24
)
^
rcon
[
i
];
rk
[
7
]
=
rk
[
1
]
^
rk
[
6
];
rk
[
8
]
=
rk
[
2
]
^
rk
[
7
];
rk
[
9
]
=
rk
[
3
]
^
rk
[
8
];
if
(
++
i
==
8
)
{
return
0
;
}
rk
[
10
]
=
rk
[
4
]
^
rk
[
9
];
rk
[
11
]
=
rk
[
5
]
^
rk
[
10
];
rk
+=
6
;
}
}
rk
[
6
]
=
GETU32
(
userKey
+
24
);
rk
[
7
]
=
GETU32
(
userKey
+
28
);
if
(
bits
==
256
)
{
while
(
1
)
{
temp
=
rk
[
7
];
rk
[
8
]
=
rk
[
0
]
^
(
Te4
[(
temp
>>
8
)
&
0xff
]
)
^
(
Te4
[(
temp
>>
16
)
&
0xff
]
<<
8
)
^
(
Te4
[(
temp
>>
24
)
]
<<
16
)
^
(
Te4
[(
temp
)
&
0xff
]
<<
24
)
^
rcon
[
i
];
rk
[
9
]
=
rk
[
1
]
^
rk
[
8
];
rk
[
10
]
=
rk
[
2
]
^
rk
[
9
];
rk
[
11
]
=
rk
[
3
]
^
rk
[
10
];
if
(
++
i
==
7
)
{
return
0
;
}
temp
=
rk
[
11
];
rk
[
12
]
=
rk
[
4
]
^
(
Te4
[(
temp
)
&
0xff
]
)
^
(
Te4
[(
temp
>>
8
)
&
0xff
]
<<
8
)
^
(
Te4
[(
temp
>>
16
)
&
0xff
]
<<
16
)
^
(
Te4
[(
temp
>>
24
)
]
<<
24
);
rk
[
13
]
=
rk
[
5
]
^
rk
[
12
];
rk
[
14
]
=
rk
[
6
]
^
rk
[
13
];
rk
[
15
]
=
rk
[
7
]
^
rk
[
14
];
rk
[
0
]
=
GETU32
(
userKey
);
rk
[
1
]
=
GETU32
(
userKey
+
4
);
rk
[
2
]
=
GETU32
(
userKey
+
8
);
rk
[
3
]
=
GETU32
(
userKey
+
12
);
if
(
bits
==
128
)
{
while
(
1
)
{
temp
=
rk
[
3
];
rk
[
4
]
=
rk
[
0
]
^
(
Te4
[(
temp
>>
8
)
&
0xff
]
)
^
(
Te4
[(
temp
>>
16
)
&
0xff
]
<<
8
)
^
(
Te4
[(
temp
>>
24
)
]
<<
16
)
^
(
Te4
[(
temp
)
&
0xff
]
<<
24
)
^
rcon
[
i
];
rk
[
5
]
=
rk
[
1
]
^
rk
[
4
];
rk
[
6
]
=
rk
[
2
]
^
rk
[
5
];
rk
[
7
]
=
rk
[
3
]
^
rk
[
6
];
if
(
++
i
==
10
)
{
return
0
;
}
rk
+=
4
;
}
}
rk
[
4
]
=
GETU32
(
userKey
+
16
);
rk
[
5
]
=
GETU32
(
userKey
+
20
);
if
(
bits
==
192
)
{
while
(
1
)
{
temp
=
rk
[
5
];
rk
[
6
]
=
rk
[
0
]
^
(
Te4
[(
temp
>>
8
)
&
0xff
]
)
^
(
Te4
[(
temp
>>
16
)
&
0xff
]
<<
8
)
^
(
Te4
[(
temp
>>
24
)
]
<<
16
)
^
(
Te4
[(
temp
)
&
0xff
]
<<
24
)
^
rcon
[
i
];
rk
[
7
]
=
rk
[
1
]
^
rk
[
6
];
rk
[
8
]
=
rk
[
2
]
^
rk
[
7
];
rk
[
9
]
=
rk
[
3
]
^
rk
[
8
];
if
(
++
i
==
8
)
{
return
0
;
}
rk
[
10
]
=
rk
[
4
]
^
rk
[
9
];
rk
[
11
]
=
rk
[
5
]
^
rk
[
10
];
rk
+=
6
;
}
}
rk
[
6
]
=
GETU32
(
userKey
+
24
);
rk
[
7
]
=
GETU32
(
userKey
+
28
);
if
(
bits
==
256
)
{
while
(
1
)
{
temp
=
rk
[
7
];
rk
[
8
]
=
rk
[
0
]
^
(
Te4
[(
temp
>>
8
)
&
0xff
]
)
^
(
Te4
[(
temp
>>
16
)
&
0xff
]
<<
8
)
^
(
Te4
[(
temp
>>
24
)
]
<<
16
)
^
(
Te4
[(
temp
)
&
0xff
]
<<
24
)
^
rcon
[
i
];
rk
[
9
]
=
rk
[
1
]
^
rk
[
8
];
rk
[
10
]
=
rk
[
2
]
^
rk
[
9
];
rk
[
11
]
=
rk
[
3
]
^
rk
[
10
];
if
(
++
i
==
7
)
{
return
0
;
}
temp
=
rk
[
11
];
rk
[
12
]
=
rk
[
4
]
^
(
Te4
[(
temp
)
&
0xff
]
)
^
(
Te4
[(
temp
>>
8
)
&
0xff
]
<<
8
)
^
(
Te4
[(
temp
>>
16
)
&
0xff
]
<<
16
)
^
(
Te4
[(
temp
>>
24
)
]
<<
24
);
rk
[
13
]
=
rk
[
5
]
^
rk
[
12
];
rk
[
14
]
=
rk
[
6
]
^
rk
[
13
];
rk
[
15
]
=
rk
[
7
]
^
rk
[
14
];
rk
+=
8
;
}
}
return
0
;
rk
+=
8
;
}
}
return
0
;
}
/**
* Expand the cipher key into the decryption key schedule.
*/
int
AES_set_decrypt_key
(
const
unsigned
char
*
userKey
,
const
int
bits
,
AES_KEY
*
key
)
{
AES_KEY
*
key
)
{
u32
*
rk
;
int
i
,
j
,
status
;
u32
temp
;
u32
*
rk
;
int
i
,
j
,
status
;
u32
temp
;
/* first, start with an encryption schedule */
status
=
AES_set_encrypt_key
(
userKey
,
bits
,
key
);
if
(
status
<
0
)
return
status
;
/* first, start with an encryption schedule */
status
=
AES_set_encrypt_key
(
userKey
,
bits
,
key
);
if
(
status
<
0
)
return
status
;
rk
=
key
->
rd_key
;
rk
=
key
->
rd_key
;
/* invert the order of the round keys: */
for
(
i
=
0
,
j
=
4
*
(
key
->
rounds
);
i
<
j
;
i
+=
4
,
j
-=
4
)
{
temp
=
rk
[
i
];
rk
[
i
]
=
rk
[
j
];
rk
[
j
]
=
temp
;
temp
=
rk
[
i
+
1
];
rk
[
i
+
1
]
=
rk
[
j
+
1
];
rk
[
j
+
1
]
=
temp
;
temp
=
rk
[
i
+
2
];
rk
[
i
+
2
]
=
rk
[
j
+
2
];
rk
[
j
+
2
]
=
temp
;
temp
=
rk
[
i
+
3
];
rk
[
i
+
3
]
=
rk
[
j
+
3
];
rk
[
j
+
3
]
=
temp
;
}
/* apply the inverse MixColumn transform to all round keys but the first and the last: */
for
(
i
=
1
;
i
<
(
key
->
rounds
);
i
++
)
{
rk
+=
4
;
/* invert the order of the round keys: */
for
(
i
=
0
,
j
=
4
*
(
key
->
rounds
);
i
<
j
;
i
+=
4
,
j
-=
4
)
{
temp
=
rk
[
i
];
rk
[
i
]
=
rk
[
j
];
rk
[
j
]
=
temp
;
temp
=
rk
[
i
+
1
];
rk
[
i
+
1
]
=
rk
[
j
+
1
];
rk
[
j
+
1
]
=
temp
;
temp
=
rk
[
i
+
2
];
rk
[
i
+
2
]
=
rk
[
j
+
2
];
rk
[
j
+
2
]
=
temp
;
temp
=
rk
[
i
+
3
];
rk
[
i
+
3
]
=
rk
[
j
+
3
];
rk
[
j
+
3
]
=
temp
;
}
/* apply the inverse MixColumn transform to all round keys but the first and the last: */
for
(
i
=
1
;
i
<
(
key
->
rounds
);
i
++
)
{
rk
+=
4
;
#if 1
for
(
j
=
0
;
j
<
4
;
j
++
)
{
u32
tp1
,
tp2
,
tp4
,
tp8
,
tp9
,
tpb
,
tpd
,
tpe
,
m
;
for
(
j
=
0
;
j
<
4
;
j
++
)
{
u32
tp1
,
tp2
,
tp4
,
tp8
,
tp9
,
tpb
,
tpd
,
tpe
,
m
;
tp1
=
rk
[
j
];
m
=
tp1
&
0x80808080
;
tp2
=
((
tp1
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
m
=
tp2
&
0x80808080
;
tp4
=
((
tp2
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
m
=
tp4
&
0x80808080
;
tp8
=
((
tp4
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
tp9
=
tp8
^
tp1
;
tpb
=
tp9
^
tp2
;
tpd
=
tp9
^
tp4
;
tpe
=
tp8
^
tp4
^
tp2
;
tp1
=
rk
[
j
];
m
=
tp1
&
0x80808080
;
tp2
=
((
tp1
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
m
=
tp2
&
0x80808080
;
tp4
=
((
tp2
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
m
=
tp4
&
0x80808080
;
tp8
=
((
tp4
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
tp9
=
tp8
^
tp1
;
tpb
=
tp9
^
tp2
;
tpd
=
tp9
^
tp4
;
tpe
=
tp8
^
tp4
^
tp2
;
#if defined(ROTATE)
rk
[
j
]
=
tpe
^
ROTATE
(
tpd
,
16
)
^
ROTATE
(
tp9
,
8
)
^
ROTATE
(
tpb
,
24
);
rk
[
j
]
=
tpe
^
ROTATE
(
tpd
,
16
)
^
ROTATE
(
tp9
,
8
)
^
ROTATE
(
tpb
,
24
);
#else
rk
[
j
]
=
tpe
^
(
tpd
>>
16
)
^
(
tpd
<<
16
)
^
(
tp9
>>
24
)
^
(
tp9
<<
8
)
^
(
tpb
>>
8
)
^
(
tpb
<<
24
);
rk
[
j
]
=
tpe
^
(
tpd
>>
16
)
^
(
tpd
<<
16
)
^
(
tp9
>>
24
)
^
(
tp9
<<
8
)
^
(
tpb
>>
8
)
^
(
tpb
<<
24
);
#endif
}
}
#else
rk
[
0
]
=
Td0
[
Te2
[(
rk
[
0
]
)
&
0xff
]
&
0xff
]
^
Td1
[
Te2
[(
rk
[
0
]
>>
8
)
&
0xff
]
&
0xff
]
^
Td2
[
Te2
[(
rk
[
0
]
>>
16
)
&
0xff
]
&
0xff
]
^
Td3
[
Te2
[(
rk
[
0
]
>>
24
)
]
&
0xff
];
rk
[
1
]
=
Td0
[
Te2
[(
rk
[
1
]
)
&
0xff
]
&
0xff
]
^
Td1
[
Te2
[(
rk
[
1
]
>>
8
)
&
0xff
]
&
0xff
]
^
Td2
[
Te2
[(
rk
[
1
]
>>
16
)
&
0xff
]
&
0xff
]
^
Td3
[
Te2
[(
rk
[
1
]
>>
24
)
]
&
0xff
];
rk
[
2
]
=
Td0
[
Te2
[(
rk
[
2
]
)
&
0xff
]
&
0xff
]
^
Td1
[
Te2
[(
rk
[
2
]
>>
8
)
&
0xff
]
&
0xff
]
^
Td2
[
Te2
[(
rk
[
2
]
>>
16
)
&
0xff
]
&
0xff
]
^
Td3
[
Te2
[(
rk
[
2
]
>>
24
)
]
&
0xff
];
rk
[
3
]
=
Td0
[
Te2
[(
rk
[
3
]
)
&
0xff
]
&
0xff
]
^
Td1
[
Te2
[(
rk
[
3
]
>>
8
)
&
0xff
]
&
0xff
]
^
Td2
[
Te2
[(
rk
[
3
]
>>
16
)
&
0xff
]
&
0xff
]
^
Td3
[
Te2
[(
rk
[
3
]
>>
24
)
]
&
0xff
];
rk
[
0
]
=
Td0
[
Te2
[(
rk
[
0
]
)
&
0xff
]
&
0xff
]
^
Td1
[
Te2
[(
rk
[
0
]
>>
8
)
&
0xff
]
&
0xff
]
^
Td2
[
Te2
[(
rk
[
0
]
>>
16
)
&
0xff
]
&
0xff
]
^
Td3
[
Te2
[(
rk
[
0
]
>>
24
)
]
&
0xff
];
rk
[
1
]
=
Td0
[
Te2
[(
rk
[
1
]
)
&
0xff
]
&
0xff
]
^
Td1
[
Te2
[(
rk
[
1
]
>>
8
)
&
0xff
]
&
0xff
]
^
Td2
[
Te2
[(
rk
[
1
]
>>
16
)
&
0xff
]
&
0xff
]
^
Td3
[
Te2
[(
rk
[
1
]
>>
24
)
]
&
0xff
];
rk
[
2
]
=
Td0
[
Te2
[(
rk
[
2
]
)
&
0xff
]
&
0xff
]
^
Td1
[
Te2
[(
rk
[
2
]
>>
8
)
&
0xff
]
&
0xff
]
^
Td2
[
Te2
[(
rk
[
2
]
>>
16
)
&
0xff
]
&
0xff
]
^
Td3
[
Te2
[(
rk
[
2
]
>>
24
)
]
&
0xff
];
rk
[
3
]
=
Td0
[
Te2
[(
rk
[
3
]
)
&
0xff
]
&
0xff
]
^
Td1
[
Te2
[(
rk
[
3
]
>>
8
)
&
0xff
]
&
0xff
]
^
Td2
[
Te2
[(
rk
[
3
]
>>
16
)
&
0xff
]
&
0xff
]
^
Td3
[
Te2
[(
rk
[
3
]
>>
24
)
]
&
0xff
];
#endif
}
return
0
;
}
return
0
;
}
/*
...
...
@@ -652,210 +654,212 @@ int AES_set_decrypt_key(const unsigned char *userKey, const int bits,
* in and out can overlap
*/
void
AES_encrypt
(
const
unsigned
char
*
in
,
unsigned
char
*
out
,
const
AES_KEY
*
key
)
{
const
AES_KEY
*
key
)
{
const
u32
*
rk
;
u32
s0
,
s1
,
s2
,
s3
,
t
[
4
];
int
r
;
const
u32
*
rk
;
u32
s0
,
s1
,
s2
,
s3
,
t
[
4
];
int
r
;
assert
(
in
&&
out
&&
key
);
rk
=
key
->
rd_key
;
assert
(
in
&&
out
&&
key
);
rk
=
key
->
rd_key
;
/*
* map byte array block to cipher state
* and add initial round key:
*/
s0
=
GETU32
(
in
)
^
rk
[
0
];
s1
=
GETU32
(
in
+
4
)
^
rk
[
1
];
s2
=
GETU32
(
in
+
8
)
^
rk
[
2
];
s3
=
GETU32
(
in
+
12
)
^
rk
[
3
];
/*
* map byte array block to cipher state
* and add initial round key:
*/
s0
=
GETU32
(
in
)
^
rk
[
0
];
s1
=
GETU32
(
in
+
4
)
^
rk
[
1
];
s2
=
GETU32
(
in
+
8
)
^
rk
[
2
];
s3
=
GETU32
(
in
+
12
)
^
rk
[
3
];
#if defined(AES_COMPACT_IN_OUTER_ROUNDS)
prefetch256
(
Te4
);
prefetch256
(
Te4
);
t
[
0
]
=
Te4
[(
s0
)
&
0xff
]
^
Te4
[(
s1
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s2
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s3
>>
24
)
]
<<
24
;
t
[
1
]
=
Te4
[(
s1
)
&
0xff
]
^
Te4
[(
s2
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s3
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s0
>>
24
)
]
<<
24
;
t
[
2
]
=
Te4
[(
s2
)
&
0xff
]
^
Te4
[(
s3
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s0
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s1
>>
24
)
]
<<
24
;
t
[
3
]
=
Te4
[(
s3
)
&
0xff
]
^
Te4
[(
s0
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s1
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s2
>>
24
)
]
<<
24
;
t
[
0
]
=
Te4
[(
s0
)
&
0xff
]
^
Te4
[(
s1
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s2
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s3
>>
24
)
]
<<
24
;
t
[
1
]
=
Te4
[(
s1
)
&
0xff
]
^
Te4
[(
s2
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s3
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s0
>>
24
)
]
<<
24
;
t
[
2
]
=
Te4
[(
s2
)
&
0xff
]
^
Te4
[(
s3
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s0
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s1
>>
24
)
]
<<
24
;
t
[
3
]
=
Te4
[(
s3
)
&
0xff
]
^
Te4
[(
s0
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s1
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s2
>>
24
)
]
<<
24
;
/* now do the linear transform using words */
{
int
i
;
u32
r0
,
r1
,
r2
;
/* now do the linear transform using words */
{
int
i
;
u32
r0
,
r1
,
r2
;
for
(
i
=
0
;
i
<
4
;
i
++
)
{
r0
=
t
[
i
];
r1
=
r0
&
0x80808080
;
r2
=
((
r0
&
0x7f7f7f7f
)
<<
1
)
^
((
r1
-
(
r1
>>
7
))
&
0x1b1b1b1b
);
for
(
i
=
0
;
i
<
4
;
i
++
)
{
r0
=
t
[
i
];
r1
=
r0
&
0x80808080
;
r2
=
((
r0
&
0x7f7f7f7f
)
<<
1
)
^
((
r1
-
(
r1
>>
7
))
&
0x1b1b1b1b
);
#if defined(ROTATE)
t
[
i
]
=
r2
^
ROTATE
(
r2
,
24
)
^
ROTATE
(
r0
,
24
)
^
ROTATE
(
r0
,
16
)
^
ROTATE
(
r0
,
8
);
t
[
i
]
=
r2
^
ROTATE
(
r2
,
24
)
^
ROTATE
(
r0
,
24
)
^
ROTATE
(
r0
,
16
)
^
ROTATE
(
r0
,
8
);
#else
t
[
i
]
=
r2
^
((
r2
^
r0
)
<<
24
)
^
((
r2
^
r0
)
>>
8
)
^
(
r0
<<
16
)
^
(
r0
>>
16
)
^
(
r0
<<
8
)
^
(
r0
>>
24
);
t
[
i
]
=
r2
^
((
r2
^
r0
)
<<
24
)
^
((
r2
^
r0
)
>>
8
)
^
(
r0
<<
16
)
^
(
r0
>>
16
)
^
(
r0
<<
8
)
^
(
r0
>>
24
);
#endif
t
[
i
]
^=
rk
[
4
+
i
];
}
}
t
[
i
]
^=
rk
[
4
+
i
];
}
}
#else
t
[
0
]
=
Te0
[(
s0
)
&
0xff
]
^
Te1
[(
s1
>>
8
)
&
0xff
]
^
Te2
[(
s2
>>
16
)
&
0xff
]
^
Te3
[(
s3
>>
24
)
]
^
rk
[
4
];
t
[
1
]
=
Te0
[(
s1
)
&
0xff
]
^
Te1
[(
s2
>>
8
)
&
0xff
]
^
Te2
[(
s3
>>
16
)
&
0xff
]
^
Te3
[(
s0
>>
24
)
]
^
rk
[
5
];
t
[
2
]
=
Te0
[(
s2
)
&
0xff
]
^
Te1
[(
s3
>>
8
)
&
0xff
]
^
Te2
[(
s0
>>
16
)
&
0xff
]
^
Te3
[(
s1
>>
24
)
]
^
rk
[
6
];
t
[
3
]
=
Te0
[(
s3
)
&
0xff
]
^
Te1
[(
s0
>>
8
)
&
0xff
]
^
Te2
[(
s1
>>
16
)
&
0xff
]
^
Te3
[(
s2
>>
24
)
]
^
rk
[
7
];
t
[
0
]
=
Te0
[(
s0
)
&
0xff
]
^
Te1
[(
s1
>>
8
)
&
0xff
]
^
Te2
[(
s2
>>
16
)
&
0xff
]
^
Te3
[(
s3
>>
24
)
]
^
rk
[
4
];
t
[
1
]
=
Te0
[(
s1
)
&
0xff
]
^
Te1
[(
s2
>>
8
)
&
0xff
]
^
Te2
[(
s3
>>
16
)
&
0xff
]
^
Te3
[(
s0
>>
24
)
]
^
rk
[
5
];
t
[
2
]
=
Te0
[(
s2
)
&
0xff
]
^
Te1
[(
s3
>>
8
)
&
0xff
]
^
Te2
[(
s0
>>
16
)
&
0xff
]
^
Te3
[(
s1
>>
24
)
]
^
rk
[
6
];
t
[
3
]
=
Te0
[(
s3
)
&
0xff
]
^
Te1
[(
s0
>>
8
)
&
0xff
]
^
Te2
[(
s1
>>
16
)
&
0xff
]
^
Te3
[(
s2
>>
24
)
]
^
rk
[
7
];
#endif
s0
=
t
[
0
];
s1
=
t
[
1
];
s2
=
t
[
2
];
s3
=
t
[
3
];
s0
=
t
[
0
];
s1
=
t
[
1
];
s2
=
t
[
2
];
s3
=
t
[
3
];
/*
* Nr - 2 full rounds:
*/
for
(
rk
+=
8
,
r
=
key
->
rounds
-
2
;
r
>
0
;
rk
+=
4
,
r
--
)
{
#if defined(AES_COMPACT_IN_INNER_ROUNDS)
t
[
0
]
=
Te4
[(
s0
)
&
0xff
]
^
Te4
[(
s1
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s2
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s3
>>
24
)
]
<<
24
;
t
[
1
]
=
Te4
[(
s1
)
&
0xff
]
^
Te4
[(
s2
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s3
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s0
>>
24
)
]
<<
24
;
t
[
2
]
=
Te4
[(
s2
)
&
0xff
]
^
Te4
[(
s3
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s0
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s1
>>
24
)
]
<<
24
;
t
[
3
]
=
Te4
[(
s3
)
&
0xff
]
^
Te4
[(
s0
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s1
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s2
>>
24
)
]
<<
24
;
t
[
0
]
=
Te4
[(
s0
)
&
0xff
]
^
Te4
[(
s1
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s2
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s3
>>
24
)
]
<<
24
;
t
[
1
]
=
Te4
[(
s1
)
&
0xff
]
^
Te4
[(
s2
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s3
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s0
>>
24
)
]
<<
24
;
t
[
2
]
=
Te4
[(
s2
)
&
0xff
]
^
Te4
[(
s3
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s0
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s1
>>
24
)
]
<<
24
;
t
[
3
]
=
Te4
[(
s3
)
&
0xff
]
^
Te4
[(
s0
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s1
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s2
>>
24
)
]
<<
24
;
/* now do the linear transform using words */
{
int
i
;
u32
r0
,
r1
,
r2
;
/* now do the linear transform using words */
{
int
i
;
u32
r0
,
r1
,
r2
;
for
(
i
=
0
;
i
<
4
;
i
++
)
{
r0
=
t
[
i
];
r1
=
r0
&
0x80808080
;
r2
=
((
r0
&
0x7f7f7f7f
)
<<
1
)
^
((
r1
-
(
r1
>>
7
))
&
0x1b1b1b1b
);
for
(
i
=
0
;
i
<
4
;
i
++
)
{
r0
=
t
[
i
];
r1
=
r0
&
0x80808080
;
r2
=
((
r0
&
0x7f7f7f7f
)
<<
1
)
^
((
r1
-
(
r1
>>
7
))
&
0x1b1b1b1b
);
#if defined(ROTATE)
t
[
i
]
=
r2
^
ROTATE
(
r2
,
24
)
^
ROTATE
(
r0
,
24
)
^
ROTATE
(
r0
,
16
)
^
ROTATE
(
r0
,
8
);
t
[
i
]
=
r2
^
ROTATE
(
r2
,
24
)
^
ROTATE
(
r0
,
24
)
^
ROTATE
(
r0
,
16
)
^
ROTATE
(
r0
,
8
);
#else
t
[
i
]
=
r2
^
((
r2
^
r0
)
<<
24
)
^
((
r2
^
r0
)
>>
8
)
^
(
r0
<<
16
)
^
(
r0
>>
16
)
^
(
r0
<<
8
)
^
(
r0
>>
24
);
t
[
i
]
=
r2
^
((
r2
^
r0
)
<<
24
)
^
((
r2
^
r0
)
>>
8
)
^
(
r0
<<
16
)
^
(
r0
>>
16
)
^
(
r0
<<
8
)
^
(
r0
>>
24
);
#endif
t
[
i
]
^=
rk
[
i
];
}
}
t
[
i
]
^=
rk
[
i
];
}
}
#else
t
[
0
]
=
Te0
[(
s0
)
&
0xff
]
^
Te1
[(
s1
>>
8
)
&
0xff
]
^
Te2
[(
s2
>>
16
)
&
0xff
]
^
Te3
[(
s3
>>
24
)
]
^
rk
[
0
];
t
[
1
]
=
Te0
[(
s1
)
&
0xff
]
^
Te1
[(
s2
>>
8
)
&
0xff
]
^
Te2
[(
s3
>>
16
)
&
0xff
]
^
Te3
[(
s0
>>
24
)
]
^
rk
[
1
];
t
[
2
]
=
Te0
[(
s2
)
&
0xff
]
^
Te1
[(
s3
>>
8
)
&
0xff
]
^
Te2
[(
s0
>>
16
)
&
0xff
]
^
Te3
[(
s1
>>
24
)
]
^
rk
[
2
];
t
[
3
]
=
Te0
[(
s3
)
&
0xff
]
^
Te1
[(
s0
>>
8
)
&
0xff
]
^
Te2
[(
s1
>>
16
)
&
0xff
]
^
Te3
[(
s2
>>
24
)
]
^
rk
[
3
];
t
[
0
]
=
Te0
[(
s0
)
&
0xff
]
^
Te1
[(
s1
>>
8
)
&
0xff
]
^
Te2
[(
s2
>>
16
)
&
0xff
]
^
Te3
[(
s3
>>
24
)
]
^
rk
[
0
];
t
[
1
]
=
Te0
[(
s1
)
&
0xff
]
^
Te1
[(
s2
>>
8
)
&
0xff
]
^
Te2
[(
s3
>>
16
)
&
0xff
]
^
Te3
[(
s0
>>
24
)
]
^
rk
[
1
];
t
[
2
]
=
Te0
[(
s2
)
&
0xff
]
^
Te1
[(
s3
>>
8
)
&
0xff
]
^
Te2
[(
s0
>>
16
)
&
0xff
]
^
Te3
[(
s1
>>
24
)
]
^
rk
[
2
];
t
[
3
]
=
Te0
[(
s3
)
&
0xff
]
^
Te1
[(
s0
>>
8
)
&
0xff
]
^
Te2
[(
s1
>>
16
)
&
0xff
]
^
Te3
[(
s2
>>
24
)
]
^
rk
[
3
];
#endif
s0
=
t
[
0
];
s1
=
t
[
1
];
s2
=
t
[
2
];
s3
=
t
[
3
];
s0
=
t
[
0
];
s1
=
t
[
1
];
s2
=
t
[
2
];
s3
=
t
[
3
];
}
/*
* apply last round and
* map cipher state to byte array block:
*/
* apply last round and
* map cipher state to byte array block:
*/
#if defined(AES_COMPACT_IN_OUTER_ROUNDS)
prefetch256
(
Te4
);
prefetch256
(
Te4
);
*
(
u32
*
)(
out
+
0
)
=
Te4
[(
s0
)
&
0xff
]
^
Te4
[(
s1
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s2
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s3
>>
24
)
]
<<
24
^
rk
[
0
];
*
(
u32
*
)(
out
+
4
)
=
Te4
[(
s1
)
&
0xff
]
^
Te4
[(
s2
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s3
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s0
>>
24
)
]
<<
24
^
rk
[
1
];
*
(
u32
*
)(
out
+
8
)
=
Te4
[(
s2
)
&
0xff
]
^
Te4
[(
s3
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s0
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s1
>>
24
)
]
<<
24
^
rk
[
2
];
*
(
u32
*
)(
out
+
12
)
=
Te4
[(
s3
)
&
0xff
]
^
Te4
[(
s0
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s1
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s2
>>
24
)
]
<<
24
^
rk
[
3
];
*
(
u32
*
)(
out
+
0
)
=
Te4
[(
s0
)
&
0xff
]
^
Te4
[(
s1
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s2
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s3
>>
24
)
]
<<
24
^
rk
[
0
];
*
(
u32
*
)(
out
+
4
)
=
Te4
[(
s1
)
&
0xff
]
^
Te4
[(
s2
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s3
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s0
>>
24
)
]
<<
24
^
rk
[
1
];
*
(
u32
*
)(
out
+
8
)
=
Te4
[(
s2
)
&
0xff
]
^
Te4
[(
s3
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s0
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s1
>>
24
)
]
<<
24
^
rk
[
2
];
*
(
u32
*
)(
out
+
12
)
=
Te4
[(
s3
)
&
0xff
]
^
Te4
[(
s0
>>
8
)
&
0xff
]
<<
8
^
Te4
[(
s1
>>
16
)
&
0xff
]
<<
16
^
Te4
[(
s2
>>
24
)
]
<<
24
^
rk
[
3
];
#else
*
(
u32
*
)(
out
+
0
)
=
(
Te2
[(
s0
)
&
0xff
]
&
0x000000ffU
)
^
(
Te3
[(
s1
>>
8
)
&
0xff
]
&
0x0000ff00U
)
^
(
Te0
[(
s2
>>
16
)
&
0xff
]
&
0x00ff0000U
)
^
(
Te1
[(
s3
>>
24
)
]
&
0xff000000U
)
^
rk
[
0
];
*
(
u32
*
)(
out
+
4
)
=
(
Te2
[(
s1
)
&
0xff
]
&
0x000000ffU
)
^
(
Te3
[(
s2
>>
8
)
&
0xff
]
&
0x0000ff00U
)
^
(
Te0
[(
s3
>>
16
)
&
0xff
]
&
0x00ff0000U
)
^
(
Te1
[(
s0
>>
24
)
]
&
0xff000000U
)
^
rk
[
1
];
*
(
u32
*
)(
out
+
8
)
=
(
Te2
[(
s2
)
&
0xff
]
&
0x000000ffU
)
^
(
Te3
[(
s3
>>
8
)
&
0xff
]
&
0x0000ff00U
)
^
(
Te0
[(
s0
>>
16
)
&
0xff
]
&
0x00ff0000U
)
^
(
Te1
[(
s1
>>
24
)
]
&
0xff000000U
)
^
rk
[
2
];
*
(
u32
*
)(
out
+
12
)
=
(
Te2
[(
s3
)
&
0xff
]
&
0x000000ffU
)
^
(
Te3
[(
s0
>>
8
)
&
0xff
]
&
0x0000ff00U
)
^
(
Te0
[(
s1
>>
16
)
&
0xff
]
&
0x00ff0000U
)
^
(
Te1
[(
s2
>>
24
)
]
&
0xff000000U
)
^
rk
[
3
];
*
(
u32
*
)(
out
+
0
)
=
(
Te2
[(
s0
)
&
0xff
]
&
0x000000ffU
)
^
(
Te3
[(
s1
>>
8
)
&
0xff
]
&
0x0000ff00U
)
^
(
Te0
[(
s2
>>
16
)
&
0xff
]
&
0x00ff0000U
)
^
(
Te1
[(
s3
>>
24
)
]
&
0xff000000U
)
^
rk
[
0
];
*
(
u32
*
)(
out
+
4
)
=
(
Te2
[(
s1
)
&
0xff
]
&
0x000000ffU
)
^
(
Te3
[(
s2
>>
8
)
&
0xff
]
&
0x0000ff00U
)
^
(
Te0
[(
s3
>>
16
)
&
0xff
]
&
0x00ff0000U
)
^
(
Te1
[(
s0
>>
24
)
]
&
0xff000000U
)
^
rk
[
1
];
*
(
u32
*
)(
out
+
8
)
=
(
Te2
[(
s2
)
&
0xff
]
&
0x000000ffU
)
^
(
Te3
[(
s3
>>
8
)
&
0xff
]
&
0x0000ff00U
)
^
(
Te0
[(
s0
>>
16
)
&
0xff
]
&
0x00ff0000U
)
^
(
Te1
[(
s1
>>
24
)
]
&
0xff000000U
)
^
rk
[
2
];
*
(
u32
*
)(
out
+
12
)
=
(
Te2
[(
s3
)
&
0xff
]
&
0x000000ffU
)
^
(
Te3
[(
s0
>>
8
)
&
0xff
]
&
0x0000ff00U
)
^
(
Te0
[(
s1
>>
16
)
&
0xff
]
&
0x00ff0000U
)
^
(
Te1
[(
s2
>>
24
)
]
&
0xff000000U
)
^
rk
[
3
];
#endif
}
...
...
@@ -864,202 +868,205 @@ void AES_encrypt(const unsigned char *in, unsigned char *out,
* in and out can overlap
*/
void
AES_decrypt
(
const
unsigned
char
*
in
,
unsigned
char
*
out
,
const
AES_KEY
*
key
)
{
const
AES_KEY
*
key
)
{
const
u32
*
rk
;
u32
s0
,
s1
,
s2
,
s3
,
t
[
4
];
int
r
;
const
u32
*
rk
;
u32
s0
,
s1
,
s2
,
s3
,
t
[
4
];
int
r
;
assert
(
in
&&
out
&&
key
);
rk
=
key
->
rd_key
;
assert
(
in
&&
out
&&
key
);
rk
=
key
->
rd_key
;
/*
* map byte array block to cipher state
* and add initial round key:
*/
s0
=
GETU32
(
in
)
^
rk
[
0
];
s1
=
GETU32
(
in
+
4
)
^
rk
[
1
];
s2
=
GETU32
(
in
+
8
)
^
rk
[
2
];
s3
=
GETU32
(
in
+
12
)
^
rk
[
3
];
/*
* map byte array block to cipher state
* and add initial round key:
*/
s0
=
GETU32
(
in
)
^
rk
[
0
];
s1
=
GETU32
(
in
+
4
)
^
rk
[
1
];
s2
=
GETU32
(
in
+
8
)
^
rk
[
2
];
s3
=
GETU32
(
in
+
12
)
^
rk
[
3
];
#if defined(AES_COMPACT_IN_OUTER_ROUNDS)
prefetch256
(
Td4
);
prefetch256
(
Td4
);
t
[
0
]
=
Td4
[(
s0
)
&
0xff
]
^
Td4
[(
s3
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s2
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s1
>>
24
)
]
<<
24
;
t
[
1
]
=
Td4
[(
s1
)
&
0xff
]
^
Td4
[(
s0
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s3
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s2
>>
24
)
]
<<
24
;
t
[
2
]
=
Td4
[(
s2
)
&
0xff
]
^
Td4
[(
s1
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s0
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s3
>>
24
)
]
<<
24
;
t
[
3
]
=
Td4
[(
s3
)
&
0xff
]
^
Td4
[(
s2
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s1
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s0
>>
24
)
]
<<
24
;
t
[
0
]
=
Td4
[(
s0
)
&
0xff
]
^
Td4
[(
s3
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s2
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s1
>>
24
)
]
<<
24
;
t
[
1
]
=
Td4
[(
s1
)
&
0xff
]
^
Td4
[(
s0
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s3
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s2
>>
24
)
]
<<
24
;
t
[
2
]
=
Td4
[(
s2
)
&
0xff
]
^
Td4
[(
s1
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s0
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s3
>>
24
)
]
<<
24
;
t
[
3
]
=
Td4
[(
s3
)
&
0xff
]
^
Td4
[(
s2
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s1
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s0
>>
24
)
]
<<
24
;
/* now do the linear transform using words */
{
int
i
;
u32
tp1
,
tp2
,
tp4
,
tp8
,
tp9
,
tpb
,
tpd
,
tpe
,
m
;
/* now do the linear transform using words */
{
int
i
;
u32
tp1
,
tp2
,
tp4
,
tp8
,
tp9
,
tpb
,
tpd
,
tpe
,
m
;
for
(
i
=
0
;
i
<
4
;
i
++
)
{
tp1
=
t
[
i
];
m
=
tp1
&
0x80808080
;
tp2
=
((
tp1
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
m
=
tp2
&
0x80808080
;
tp4
=
((
tp2
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
m
=
tp4
&
0x80808080
;
tp8
=
((
tp4
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
tp9
=
tp8
^
tp1
;
tpb
=
tp9
^
tp2
;
tpd
=
tp9
^
tp4
;
tpe
=
tp8
^
tp4
^
tp2
;
for
(
i
=
0
;
i
<
4
;
i
++
)
{
tp1
=
t
[
i
];
m
=
tp1
&
0x80808080
;
tp2
=
((
tp1
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
m
=
tp2
&
0x80808080
;
tp4
=
((
tp2
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
m
=
tp4
&
0x80808080
;
tp8
=
((
tp4
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
tp9
=
tp8
^
tp1
;
tpb
=
tp9
^
tp2
;
tpd
=
tp9
^
tp4
;
tpe
=
tp8
^
tp4
^
tp2
;
#if defined(ROTATE)
t
[
i
]
=
tpe
^
ROTATE
(
tpd
,
16
)
^
ROTATE
(
tp9
,
8
)
^
ROTATE
(
tpb
,
24
);
t
[
i
]
=
tpe
^
ROTATE
(
tpd
,
16
)
^
ROTATE
(
tp9
,
8
)
^
ROTATE
(
tpb
,
24
);
#else
t
[
i
]
=
tpe
^
(
tpd
>>
16
)
^
(
tpd
<<
16
)
^
(
tp9
>>
24
)
^
(
tp9
<<
8
)
^
(
tpb
>>
8
)
^
(
tpb
<<
24
);
t
[
i
]
=
tpe
^
(
tpd
>>
16
)
^
(
tpd
<<
16
)
^
(
tp9
>>
24
)
^
(
tp9
<<
8
)
^
(
tpb
>>
8
)
^
(
tpb
<<
24
);
#endif
t
[
i
]
^=
rk
[
4
+
i
];
}
}
t
[
i
]
^=
rk
[
4
+
i
];
}
}
#else
t
[
0
]
=
Td0
[(
s0
)
&
0xff
]
^
Td1
[(
s3
>>
8
)
&
0xff
]
^
Td2
[(
s2
>>
16
)
&
0xff
]
^
Td3
[(
s1
>>
24
)
]
^
rk
[
4
];
t
[
1
]
=
Td0
[(
s1
)
&
0xff
]
^
Td1
[(
s0
>>
8
)
&
0xff
]
^
Td2
[(
s3
>>
16
)
&
0xff
]
^
Td3
[(
s2
>>
24
)
]
^
rk
[
5
];
t
[
2
]
=
Td0
[(
s2
)
&
0xff
]
^
Td1
[(
s1
>>
8
)
&
0xff
]
^
Td2
[(
s0
>>
16
)
&
0xff
]
^
Td3
[(
s3
>>
24
)
]
^
rk
[
6
];
t
[
3
]
=
Td0
[(
s3
)
&
0xff
]
^
Td1
[(
s2
>>
8
)
&
0xff
]
^
Td2
[(
s1
>>
16
)
&
0xff
]
^
Td3
[(
s0
>>
24
)
]
^
rk
[
7
];
t
[
0
]
=
Td0
[(
s0
)
&
0xff
]
^
Td1
[(
s3
>>
8
)
&
0xff
]
^
Td2
[(
s2
>>
16
)
&
0xff
]
^
Td3
[(
s1
>>
24
)
]
^
rk
[
4
];
t
[
1
]
=
Td0
[(
s1
)
&
0xff
]
^
Td1
[(
s0
>>
8
)
&
0xff
]
^
Td2
[(
s3
>>
16
)
&
0xff
]
^
Td3
[(
s2
>>
24
)
]
^
rk
[
5
];
t
[
2
]
=
Td0
[(
s2
)
&
0xff
]
^
Td1
[(
s1
>>
8
)
&
0xff
]
^
Td2
[(
s0
>>
16
)
&
0xff
]
^
Td3
[(
s3
>>
24
)
]
^
rk
[
6
];
t
[
3
]
=
Td0
[(
s3
)
&
0xff
]
^
Td1
[(
s2
>>
8
)
&
0xff
]
^
Td2
[(
s1
>>
16
)
&
0xff
]
^
Td3
[(
s0
>>
24
)
]
^
rk
[
7
];
#endif
s0
=
t
[
0
];
s1
=
t
[
1
];
s2
=
t
[
2
];
s3
=
t
[
3
];
s0
=
t
[
0
];
s1
=
t
[
1
];
s2
=
t
[
2
];
s3
=
t
[
3
];
/*
* Nr - 2 full rounds:
*/
for
(
rk
+=
8
,
r
=
key
->
rounds
-
2
;
r
>
0
;
rk
+=
4
,
r
--
)
{
#if defined(AES_COMPACT_IN_INNER_ROUNDS)
t
[
0
]
=
Td4
[(
s0
)
&
0xff
]
^
Td4
[(
s3
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s2
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s1
>>
24
)
]
<<
24
;
t
[
1
]
=
Td4
[(
s1
)
&
0xff
]
^
Td4
[(
s0
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s3
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s2
>>
24
)
]
<<
24
;
t
[
2
]
=
Td4
[(
s2
)
&
0xff
]
^
Td4
[(
s1
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s0
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s3
>>
24
)
]
<<
24
;
t
[
3
]
=
Td4
[(
s3
)
&
0xff
]
^
Td4
[(
s2
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s1
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s0
>>
24
)
]
<<
24
;
t
[
0
]
=
Td4
[(
s0
)
&
0xff
]
^
Td4
[(
s3
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s2
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s1
>>
24
)
]
<<
24
;
t
[
1
]
=
Td4
[(
s1
)
&
0xff
]
^
Td4
[(
s0
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s3
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s2
>>
24
)
]
<<
24
;
t
[
2
]
=
Td4
[(
s2
)
&
0xff
]
^
Td4
[(
s1
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s0
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s3
>>
24
)
]
<<
24
;
t
[
3
]
=
Td4
[(
s3
)
&
0xff
]
^
Td4
[(
s2
>>
8
)
&
0xff
]
<<
8
^
Td4
[(
s1
>>
16
)
&
0xff
]
<<
16
^
Td4
[(
s0
>>
24
)
]
<<
24
;
/* now do the linear transform using words */
{
int
i
;
u32
tp1
,
tp2
,
tp4
,
tp8
,
tp9
,
tpb
,
tpd
,
tpe
,
m
;
/* now do the linear transform using words */
{
int
i
;
u32
tp1
,
tp2
,
tp4
,
tp8
,
tp9
,
tpb
,
tpd
,
tpe
,
m
;
for
(
i
=
0
;
i
<
4
;
i
++
)
{
tp1
=
t
[
i
];
m
=
tp1
&
0x80808080
;
tp2
=
((
tp1
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
m
=
tp2
&
0x80808080
;
tp4
=
((
tp2
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
m
=
tp4
&
0x80808080
;
tp8
=
((
tp4
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
tp9
=
tp8
^
tp1
;
tpb
=
tp9
^
tp2
;
tpd
=
tp9
^
tp4
;
tpe
=
tp8
^
tp4
^
tp2
;
for
(
i
=
0
;
i
<
4
;
i
++
)
{
tp1
=
t
[
i
];
m
=
tp1
&
0x80808080
;
tp2
=
((
tp1
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
m
=
tp2
&
0x80808080
;
tp4
=
((
tp2
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
m
=
tp4
&
0x80808080
;
tp8
=
((
tp4
&
0x7f7f7f7f
)
<<
1
)
^
((
m
-
(
m
>>
7
))
&
0x1b1b1b1b
);
tp9
=
tp8
^
tp1
;
tpb
=
tp9
^
tp2
;
tpd
=
tp9
^
tp4
;
tpe
=
tp8
^
tp4
^
tp2
;
#if defined(ROTATE)
t
[
i
]
=
tpe
^
ROTATE
(
tpd
,
16
)
^
ROTATE
(
tp9
,
8
)
^
ROTATE
(
tpb
,
24
);
t
[
i
]
=
tpe
^
ROTATE
(
tpd
,
16
)
^
ROTATE
(
tp9
,
8
)
^
ROTATE
(
tpb
,
24
);
#else
t
[
i
]
=
tpe
^
(
tpd
>>
16
)
^
(
tpd
<<
16
)
^
(
tp9
>>
24
)
^
(
tp9
<<
8
)
^
(
tpb
>>
8
)
^
(
tpb
<<
24
);
t
[
i
]
=
tpe
^
(
tpd
>>
16
)
^
(
tpd
<<
16
)
^
(
tp9
>>
24
)
^
(
tp9
<<
8
)
^
(
tpb
>>
8
)
^
(
tpb
<<
24
);
#endif
t
[
i
]
^=
rk
[
i
];
}
}
t
[
i
]
^=
rk
[
i
];
}
}
#else
t
[
0
]
=
Td0
[(
s0
)
&
0xff
]
^
Td1
[(
s3
>>
8
)
&
0xff
]
^
Td2
[(
s2
>>
16
)
&
0xff
]
^
Td3
[(
s1
>>
24
)
]
^
rk
[
0
];
t
[
1
]
=
Td0
[(
s1
)
&
0xff
]
^
Td1
[(
s0
>>
8
)
&
0xff
]
^
Td2
[(
s3
>>
16
)
&
0xff
]
^
Td3
[(
s2
>>
24
)
]
^
rk
[
1
];
t
[
2
]
=
Td0
[(
s2
)
&
0xff
]
^
Td1
[(
s1
>>
8
)
&
0xff
]
^
Td2
[(
s0
>>
16
)
&
0xff
]
^
Td3
[(
s3
>>
24
)
]
^
rk
[
2
];
t
[
3
]
=
Td0
[(
s3
)
&
0xff
]
^
Td1
[(
s2
>>
8
)
&
0xff
]
^
Td2
[(
s1
>>
16
)
&
0xff
]
^
Td3
[(
s0
>>
24
)
]
^
rk
[
3
];
t
[
0
]
=
Td0
[(
s0
)
&
0xff
]
^
Td1
[(
s3
>>
8
)
&
0xff
]
^
Td2
[(
s2
>>
16
)
&
0xff
]
^
Td3
[(
s1
>>
24
)
]
^
rk
[
0
];
t
[
1
]
=
Td0
[(
s1
)
&
0xff
]
^
Td1
[(
s0
>>
8
)
&
0xff
]
^
Td2
[(
s3
>>
16
)
&
0xff
]
^
Td3
[(
s2
>>
24
)
]
^
rk
[
1
];
t
[
2
]
=
Td0
[(
s2
)
&
0xff
]
^
Td1
[(
s1
>>
8
)
&
0xff
]
^
Td2
[(
s0
>>
16
)
&
0xff
]
^
Td3
[(
s3
>>
24
)
]
^
rk
[
2
];
t
[
3
]
=
Td0
[(
s3
)
&
0xff
]
^
Td1
[(
s2
>>
8
)
&
0xff
]
^
Td2
[(
s1
>>
16
)
&
0xff
]
^
Td3
[(
s0
>>
24
)
]
^
rk
[
3
];
#endif
s0
=
t
[
0
];
s1
=
t
[
1
];
s2
=
t
[
2
];
s3
=
t
[
3
];
s0
=
t
[
0
];
s1
=
t
[
1
];
s2
=
t
[
2
];
s3
=
t
[
3
];
}
/*
* apply last round and
* map cipher state to byte array block:
*/
prefetch256
(
Td4
);
* apply last round and
* map cipher state to byte array block:
*/
prefetch256
(
Td4
);
*
(
u32
*
)(
out
+
0
)
=
(
Td4
[(
s0
)
&
0xff
])
^
(
Td4
[(
s3
>>
8
)
&
0xff
]
<<
8
)
^
(
Td4
[(
s2
>>
16
)
&
0xff
]
<<
16
)
^
(
Td4
[(
s1
>>
24
)
]
<<
24
)
^
rk
[
0
];
*
(
u32
*
)(
out
+
4
)
=
(
Td4
[(
s1
)
&
0xff
])
^
(
Td4
[(
s0
>>
8
)
&
0xff
]
<<
8
)
^
(
Td4
[(
s3
>>
16
)
&
0xff
]
<<
16
)
^
(
Td4
[(
s2
>>
24
)
]
<<
24
)
^
rk
[
1
];
*
(
u32
*
)(
out
+
8
)
=
(
Td4
[(
s2
)
&
0xff
])
^
(
Td4
[(
s1
>>
8
)
&
0xff
]
<<
8
)
^
(
Td4
[(
s0
>>
16
)
&
0xff
]
<<
16
)
^
(
Td4
[(
s3
>>
24
)
]
<<
24
)
^
rk
[
2
];
*
(
u32
*
)(
out
+
12
)
=
(
Td4
[(
s3
)
&
0xff
])
^
(
Td4
[(
s2
>>
8
)
&
0xff
]
<<
8
)
^
(
Td4
[(
s1
>>
16
)
&
0xff
]
<<
16
)
^
(
Td4
[(
s0
>>
24
)
]
<<
24
)
^
rk
[
3
];
*
(
u32
*
)(
out
+
0
)
=
(
Td4
[(
s0
)
&
0xff
])
^
(
Td4
[(
s3
>>
8
)
&
0xff
]
<<
8
)
^
(
Td4
[(
s2
>>
16
)
&
0xff
]
<<
16
)
^
(
Td4
[(
s1
>>
24
)
]
<<
24
)
^
rk
[
0
];
*
(
u32
*
)(
out
+
4
)
=
(
Td4
[(
s1
)
&
0xff
])
^
(
Td4
[(
s0
>>
8
)
&
0xff
]
<<
8
)
^
(
Td4
[(
s3
>>
16
)
&
0xff
]
<<
16
)
^
(
Td4
[(
s2
>>
24
)
]
<<
24
)
^
rk
[
1
];
*
(
u32
*
)(
out
+
8
)
=
(
Td4
[(
s2
)
&
0xff
])
^
(
Td4
[(
s1
>>
8
)
&
0xff
]
<<
8
)
^
(
Td4
[(
s0
>>
16
)
&
0xff
]
<<
16
)
^
(
Td4
[(
s3
>>
24
)
]
<<
24
)
^
rk
[
2
];
*
(
u32
*
)(
out
+
12
)
=
(
Td4
[(
s3
)
&
0xff
])
^
(
Td4
[(
s2
>>
8
)
&
0xff
]
<<
8
)
^
(
Td4
[(
s1
>>
16
)
&
0xff
]
<<
16
)
^
(
Td4
[(
s0
>>
24
)
]
<<
24
)
^
rk
[
3
];
}
util/openssl-format-source
浏览文件 @
66186aee
...
...
@@ -88,7 +88,7 @@ do
case
`
basename
$j
`
in
# the list of files that indent is unable to handle correctly
# that we simply leave alone for manual formatting now
obj_dat.h|aes_core.c
)
obj_dat.h|aes_core.c
|aes_x86core.c
)
echo
"skipping
$j
"
;;
*
)
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录