sync with OpenBSD -current
This commit is contained in:
parent
cc5edceac3
commit
6278c437f5
GPG key ID:
F42C07F07E2E35B7
76 changed files with 1108 additions and 2495 deletions
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: sm3.c,v 1.6 2023/07/08 06:36:55 jsing Exp $ */
|
||||
/* $OpenBSD: sm3.c,v 1.17 2024/03/28 12:09:09 jsing Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2018, Ribose Inc
|
||||
*
|
||||
|
|
@ -15,42 +15,21 @@
|
|||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef OPENSSL_NO_SM3
|
||||
|
||||
#include <openssl/sm3.h>
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <openssl/opensslconf.h>
|
||||
|
||||
#define DATA_ORDER_IS_BIG_ENDIAN
|
||||
#include <openssl/sm3.h>
|
||||
|
||||
#define HASH_LONG SM3_WORD
|
||||
#define HASH_CTX SM3_CTX
|
||||
#define HASH_CBLOCK SM3_CBLOCK
|
||||
#define HASH_UPDATE SM3_Update
|
||||
#define HASH_TRANSFORM SM3_Transform
|
||||
#define HASH_FINAL SM3_Final
|
||||
#define HASH_MAKE_STRING(c, s) do { \
|
||||
unsigned long ll; \
|
||||
ll = (c)->A; HOST_l2c(ll, (s)); \
|
||||
ll = (c)->B; HOST_l2c(ll, (s)); \
|
||||
ll = (c)->C; HOST_l2c(ll, (s)); \
|
||||
ll = (c)->D; HOST_l2c(ll, (s)); \
|
||||
ll = (c)->E; HOST_l2c(ll, (s)); \
|
||||
ll = (c)->F; HOST_l2c(ll, (s)); \
|
||||
ll = (c)->G; HOST_l2c(ll, (s)); \
|
||||
ll = (c)->H; HOST_l2c(ll, (s)); \
|
||||
} while (0)
|
||||
#define HASH_BLOCK_DATA_ORDER SM3_block_data_order
|
||||
#include "crypto_internal.h"
|
||||
|
||||
void SM3_block_data_order(SM3_CTX *c, const void *p, size_t num);
|
||||
void SM3_transform(SM3_CTX *c, const unsigned char *data);
|
||||
/* Ensure that SM3_WORD and uint32_t are equivalent size. */
|
||||
CTASSERT(sizeof(SM3_WORD) == sizeof(uint32_t));
|
||||
|
||||
#include "md32_common.h"
|
||||
#ifndef OPENSSL_NO_SM3
|
||||
|
||||
#define P0(X) (X ^ ROTATE(X, 9) ^ ROTATE(X, 17))
|
||||
#define P1(X) (X ^ ROTATE(X, 15) ^ ROTATE(X, 23))
|
||||
#define P0(X) (X ^ crypto_rol_u32(X, 9) ^ crypto_rol_u32(X, 17))
|
||||
#define P1(X) (X ^ crypto_rol_u32(X, 15) ^ crypto_rol_u32(X, 23))
|
||||
|
||||
#define FF0(X, Y, Z) (X ^ Y ^ Z)
|
||||
#define GG0(X, Y, Z) (X ^ Y ^ Z)
|
||||
|
|
@ -59,17 +38,17 @@ void SM3_transform(SM3_CTX *c, const unsigned char *data);
|
|||
#define GG1(X, Y, Z) ((Z ^ (X & (Y ^ Z))))
|
||||
|
||||
#define EXPAND(W0, W7, W13, W3, W10) \
|
||||
(P1(W0 ^ W7 ^ ROTATE(W13, 15)) ^ ROTATE(W3, 7) ^ W10)
|
||||
(P1(W0 ^ W7 ^ crypto_rol_u32(W13, 15)) ^ crypto_rol_u32(W3, 7) ^ W10)
|
||||
|
||||
#define ROUND(A, B, C, D, E, F, G, H, TJ, Wi, Wj, FF, GG) do { \
|
||||
const SM3_WORD A12 = ROTATE(A, 12); \
|
||||
const SM3_WORD A12 = crypto_rol_u32(A, 12); \
|
||||
const SM3_WORD A12_SM = A12 + E + TJ; \
|
||||
const SM3_WORD SS1 = ROTATE(A12_SM, 7); \
|
||||
const SM3_WORD SS1 = crypto_rol_u32(A12_SM, 7); \
|
||||
const SM3_WORD TT1 = FF(A, B, C) + D + (SS1 ^ A12) + (Wj); \
|
||||
const SM3_WORD TT2 = GG(E, F, G) + H + SS1 + Wi; \
|
||||
B = ROTATE(B, 9); \
|
||||
B = crypto_rol_u32(B, 9); \
|
||||
D = TT1; \
|
||||
F = ROTATE(F, 19); \
|
||||
F = crypto_rol_u32(F, 19); \
|
||||
H = P0(TT2); \
|
||||
} while(0)
|
||||
|
||||
|
|
@ -79,38 +58,11 @@ void SM3_transform(SM3_CTX *c, const unsigned char *data);
|
|||
#define R2(A, B, C, D, E, F, G, H, TJ, Wi, Wj) \
|
||||
ROUND(A, B, C, D, E, F, G, H, TJ, Wi, Wj, FF1, GG1)
|
||||
|
||||
#define SM3_A 0x7380166fUL
|
||||
#define SM3_B 0x4914b2b9UL
|
||||
#define SM3_C 0x172442d7UL
|
||||
#define SM3_D 0xda8a0600UL
|
||||
#define SM3_E 0xa96f30bcUL
|
||||
#define SM3_F 0x163138aaUL
|
||||
#define SM3_G 0xe38dee4dUL
|
||||
#define SM3_H 0xb0fb0e4eUL
|
||||
|
||||
LCRYPTO_ALIAS(SM3_Update);
|
||||
LCRYPTO_ALIAS(SM3_Final);
|
||||
|
||||
int
|
||||
SM3_Init(SM3_CTX *c)
|
||||
static void
|
||||
sm3_block_data_order(SM3_CTX *ctx, const void *_in, size_t num)
|
||||
{
|
||||
memset(c, 0, sizeof(*c));
|
||||
c->A = SM3_A;
|
||||
c->B = SM3_B;
|
||||
c->C = SM3_C;
|
||||
c->D = SM3_D;
|
||||
c->E = SM3_E;
|
||||
c->F = SM3_F;
|
||||
c->G = SM3_G;
|
||||
c->H = SM3_H;
|
||||
return 1;
|
||||
}
|
||||
LCRYPTO_ALIAS(SM3_Init);
|
||||
|
||||
void
|
||||
SM3_block_data_order(SM3_CTX *ctx, const void *p, size_t num)
|
||||
{
|
||||
const unsigned char *data = p;
|
||||
const uint8_t *in = _in;
|
||||
const SM3_WORD *in32;
|
||||
SM3_WORD A, B, C, D, E, F, G, H;
|
||||
SM3_WORD W00, W01, W02, W03, W04, W05, W06, W07;
|
||||
SM3_WORD W08, W09, W10, W11, W12, W13, W14, W15;
|
||||
|
|
@ -129,22 +81,45 @@ SM3_block_data_order(SM3_CTX *ctx, const void *p, size_t num)
|
|||
* We have to load all message bytes immediately since SM3 reads
|
||||
* them slightly out of order.
|
||||
*/
|
||||
HOST_c2l(data, W00);
|
||||
HOST_c2l(data, W01);
|
||||
HOST_c2l(data, W02);
|
||||
HOST_c2l(data, W03);
|
||||
HOST_c2l(data, W04);
|
||||
HOST_c2l(data, W05);
|
||||
HOST_c2l(data, W06);
|
||||
HOST_c2l(data, W07);
|
||||
HOST_c2l(data, W08);
|
||||
HOST_c2l(data, W09);
|
||||
HOST_c2l(data, W10);
|
||||
HOST_c2l(data, W11);
|
||||
HOST_c2l(data, W12);
|
||||
HOST_c2l(data, W13);
|
||||
HOST_c2l(data, W14);
|
||||
HOST_c2l(data, W15);
|
||||
if ((uintptr_t)in % 4 == 0) {
|
||||
/* Input is 32 bit aligned. */
|
||||
in32 = (const SM3_WORD *)in;
|
||||
W00 = be32toh(in32[0]);
|
||||
W01 = be32toh(in32[1]);
|
||||
W02 = be32toh(in32[2]);
|
||||
W03 = be32toh(in32[3]);
|
||||
W04 = be32toh(in32[4]);
|
||||
W05 = be32toh(in32[5]);
|
||||
W06 = be32toh(in32[6]);
|
||||
W07 = be32toh(in32[7]);
|
||||
W08 = be32toh(in32[8]);
|
||||
W09 = be32toh(in32[9]);
|
||||
W10 = be32toh(in32[10]);
|
||||
W11 = be32toh(in32[11]);
|
||||
W12 = be32toh(in32[12]);
|
||||
W13 = be32toh(in32[13]);
|
||||
W14 = be32toh(in32[14]);
|
||||
W15 = be32toh(in32[15]);
|
||||
} else {
|
||||
/* Input is not 32 bit aligned. */
|
||||
W00 = crypto_load_be32toh(&in[0 * 4]);
|
||||
W01 = crypto_load_be32toh(&in[1 * 4]);
|
||||
W02 = crypto_load_be32toh(&in[2 * 4]);
|
||||
W03 = crypto_load_be32toh(&in[3 * 4]);
|
||||
W04 = crypto_load_be32toh(&in[4 * 4]);
|
||||
W05 = crypto_load_be32toh(&in[5 * 4]);
|
||||
W06 = crypto_load_be32toh(&in[6 * 4]);
|
||||
W07 = crypto_load_be32toh(&in[7 * 4]);
|
||||
W08 = crypto_load_be32toh(&in[8 * 4]);
|
||||
W09 = crypto_load_be32toh(&in[9 * 4]);
|
||||
W10 = crypto_load_be32toh(&in[10 * 4]);
|
||||
W11 = crypto_load_be32toh(&in[11 * 4]);
|
||||
W12 = crypto_load_be32toh(&in[12 * 4]);
|
||||
W13 = crypto_load_be32toh(&in[13 * 4]);
|
||||
W14 = crypto_load_be32toh(&in[14 * 4]);
|
||||
W15 = crypto_load_be32toh(&in[15 * 4]);
|
||||
}
|
||||
in += SM3_CBLOCK;
|
||||
|
||||
R1(A, B, C, D, E, F, G, H, 0x79cc4519, W00, W00 ^ W04);
|
||||
W00 = EXPAND(W00, W07, W13, W03, W10);
|
||||
|
|
@ -274,4 +249,113 @@ SM3_block_data_order(SM3_CTX *ctx, const void *p, size_t num)
|
|||
}
|
||||
}
|
||||
|
||||
int
|
||||
SM3_Init(SM3_CTX *c)
|
||||
{
|
||||
memset(c, 0, sizeof(*c));
|
||||
|
||||
c->A = 0x7380166fUL;
|
||||
c->B = 0x4914b2b9UL;
|
||||
c->C = 0x172442d7UL;
|
||||
c->D = 0xda8a0600UL;
|
||||
c->E = 0xa96f30bcUL;
|
||||
c->F = 0x163138aaUL;
|
||||
c->G = 0xe38dee4dUL;
|
||||
c->H = 0xb0fb0e4eUL;
|
||||
|
||||
return 1;
|
||||
}
|
||||
LCRYPTO_ALIAS(SM3_Init);
|
||||
|
||||
int
|
||||
SM3_Update(SM3_CTX *c, const void *data_, size_t len)
|
||||
{
|
||||
const unsigned char *data = data_;
|
||||
unsigned char *p;
|
||||
SM3_WORD l;
|
||||
size_t n;
|
||||
|
||||
if (len == 0)
|
||||
return 1;
|
||||
|
||||
l = (c->Nl + (((SM3_WORD)len) << 3))&0xffffffffUL;
|
||||
/* 95-05-24 eay Fixed a bug with the overflow handling, thanks to
|
||||
* Wei Dai <weidai@eskimo.com> for pointing it out. */
|
||||
if (l < c->Nl) /* overflow */
|
||||
c->Nh++;
|
||||
c->Nh+=(SM3_WORD)(len>>29); /* might cause compiler warning on 16-bit */
|
||||
c->Nl = l;
|
||||
|
||||
n = c->num;
|
||||
if (n != 0) {
|
||||
p = (unsigned char *)c->data;
|
||||
|
||||
if (len >= SM3_CBLOCK || len + n >= SM3_CBLOCK) {
|
||||
memcpy(p + n, data, SM3_CBLOCK - n);
|
||||
sm3_block_data_order(c, p, 1);
|
||||
n = SM3_CBLOCK - n;
|
||||
data += n;
|
||||
len -= n;
|
||||
c->num = 0;
|
||||
memset(p, 0, SM3_CBLOCK); /* keep it zeroed */
|
||||
} else {
|
||||
memcpy(p + n, data, len);
|
||||
c->num += (unsigned int)len;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
n = len / SM3_CBLOCK;
|
||||
if (n > 0) {
|
||||
sm3_block_data_order(c, data, n);
|
||||
n *= SM3_CBLOCK;
|
||||
data += n;
|
||||
len -= n;
|
||||
}
|
||||
|
||||
if (len != 0) {
|
||||
p = (unsigned char *)c->data;
|
||||
c->num = (unsigned int)len;
|
||||
memcpy(p, data, len);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
LCRYPTO_ALIAS(SM3_Update);
|
||||
|
||||
int
|
||||
SM3_Final(unsigned char *md, SM3_CTX *c)
|
||||
{
|
||||
unsigned char *p = (unsigned char *)c->data;
|
||||
size_t n = c->num;
|
||||
|
||||
p[n] = 0x80; /* there is always room for one */
|
||||
n++;
|
||||
|
||||
if (n > (SM3_CBLOCK - 8)) {
|
||||
memset(p + n, 0, SM3_CBLOCK - n);
|
||||
n = 0;
|
||||
sm3_block_data_order(c, p, 1);
|
||||
}
|
||||
|
||||
memset(p + n, 0, SM3_CBLOCK - 8 - n);
|
||||
c->data[SM3_LBLOCK - 2] = htobe32(c->Nh);
|
||||
c->data[SM3_LBLOCK - 1] = htobe32(c->Nl);
|
||||
|
||||
sm3_block_data_order(c, p, 1);
|
||||
c->num = 0;
|
||||
memset(p, 0, SM3_CBLOCK);
|
||||
|
||||
crypto_store_htobe32(&md[0 * 4], c->A);
|
||||
crypto_store_htobe32(&md[1 * 4], c->B);
|
||||
crypto_store_htobe32(&md[2 * 4], c->C);
|
||||
crypto_store_htobe32(&md[3 * 4], c->D);
|
||||
crypto_store_htobe32(&md[4 * 4], c->E);
|
||||
crypto_store_htobe32(&md[5 * 4], c->F);
|
||||
crypto_store_htobe32(&md[6 * 4], c->G);
|
||||
crypto_store_htobe32(&md[7 * 4], c->H);
|
||||
|
||||
return 1;
|
||||
}
|
||||
LCRYPTO_ALIAS(SM3_Final);
|
||||
|
||||
#endif /* !OPENSSL_NO_SM3 */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue