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
|
/* Copyright 2022 The ChromiumOS Authors
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "builtin/assert.h"
#include "builtin/endian.h"
#include "common.h"
#include "console.h"
#include "sha256.h"
#include "util.h"
#ifdef CONFIG_ZTEST
static uint8_t emulated_registers[3];
#define IT8XXX2_GCTRL_SHA1HASHCTRLR emulated_registers[0]
#define IT8XXX2_GCTRL_SHA1HBADDR emulated_registers[1]
#define IT8XXX2_GCTRL_SHA2HBADDR emulated_registers[2]
uint8_t it8xxx2_sha256_get_sha1hbaddr(void)
{
return IT8XXX2_GCTRL_SHA1HBADDR;
}
uint8_t it8xxx2_sha256_get_sha2hbaddr(void)
{
return IT8XXX2_GCTRL_SHA2HBADDR;
}
#else
#define IT8XXX2_GCTRL_SHA1HASHCTRLR REG8(0x00f0202d)
#define IT8XXX2_GCTRL_SHA1HBADDR REG8(0x00f0202e)
#define IT8XXX2_GCTRL_SHA2HBADDR REG8(0x00f0202f)
#endif
static const uint32_t sha256_h0[8] = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372,
0xa54ff53a, 0x510e527f, 0x9b05688c,
0x1f83d9ab, 0x5be0cd19 };
static const uint32_t sha256_k[64] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
};
void SHA256_init(struct sha256_ctx *ctx)
{
int i;
ctx->total_len = 0;
ctx->w_index = 0;
for (i = 0; i < ARRAY_SIZE(sha256_h0); i++)
ctx->h[i] = sha256_h0[i];
for (i = 0; i < ARRAY_SIZE(sha256_k); i++)
ctx->k[i] = sha256_k[i];
IT8XXX2_GCTRL_SHA1HBADDR = ((uint32_t)ctx >> 6) & 0xffc;
IT8XXX2_GCTRL_SHA2HBADDR = ((uint32_t)&ctx->k >> 6) & 0xffc;
}
static void SHA256_chip_calculation(struct sha256_ctx *ctx)
{
uint8_t hash_ctrl __unused;
uint32_t key;
key = irq_lock();
IT8XXX2_GCTRL_SHA1HASHCTRLR |= BIT(1);
hash_ctrl = IT8XXX2_GCTRL_SHA1HASHCTRLR;
ctx->w_index = 0;
irq_unlock(key);
}
void SHA256_update(struct sha256_ctx *ctx, const uint8_t *data, uint32_t len)
{
uint32_t rem_len = len, data_index = 0;
uint32_t *p = (uint32_t *)data;
/* Requires 4-byte alignment */
ASSERT(len % 4 == 0);
while (rem_len) {
uint32_t tmp, x = p[data_index++];
/*
* htobe32(x); manually inlining this saves several instructions
* when compared to a call to __bswapsi2, saving function call
* overhead and reloading of the mask constants (because there
* are registers to spare in this function). It's written as
* inline assembly to ensure that it won't get lowered to a
* __builtin_bswap32 that might not be inlined.
*
* x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF);
* x = (x << 16) | (x >> 16)
*/
if (IS_ENABLED(CONFIG_RISCV) &&
IS_ENABLED(CONFIG_LITTLE_ENDIAN)) {
__asm__(" slli %[scratch], %[x], 8\n"
" srli %[x], %[x], 8\n"
" and %[scratch], %[scratch], %[hi]\n"
" and %[x], %[x], %[lo]\n"
" or %[x], %[scratch], %[x]\n"
" slli %[scratch], %[x], 16\n"
" srli %[x], %[x], 16\n"
" or %[x], %[x], %[scratch]\n"
: [x] "+r"(x), [scratch] "=&r"(tmp)
: [hi] "r"(0xFF00FF00), [lo] "r"(0x00FF00FF));
} else {
x = htobe32(x);
}
ctx->w[ctx->w_index++] = x;
if (ctx->w_index >= 16) {
SHA256_chip_calculation(ctx);
}
rem_len -= 4;
}
ctx->total_len += len;
}
void SHA256_abort(struct sha256_ctx *ctx)
{
ARG_UNUSED(ctx);
}
uint8_t *SHA256_final(struct sha256_ctx *ctx)
{
int i;
memset(&ctx->w[ctx->w_index], 0, SHA256_BLOCK_SIZE - ctx->w_index * 4);
ctx->w[ctx->w_index] = 0x80000000;
if (ctx->w_index >= 14) {
SHA256_chip_calculation(ctx);
memset(&ctx->w[ctx->w_index], 0,
SHA256_BLOCK_SIZE - ctx->w_index * 4);
}
ctx->w[15] = ctx->total_len * 8;
SHA256_chip_calculation(ctx);
for (i = 0; i < 8; i++) {
ctx->h[i] = be32toh(ctx->h[i]);
}
return (uint8_t *)ctx->h;
}
|
