Remove superfluous NULL checks. Add Andy's BN_FLG comment.
[openssl.git] / crypto / evp / m_sha3.c
1 /*
2  * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include <string.h>
12
13 #include <openssl/evp.h>
14 #include <openssl/objects.h>
15 #include "internal/evp_int.h"
16 #include "evp_locl.h"
17
18 size_t SHA3_absorb(uint64_t A[5][5], const unsigned char *inp, size_t len,
19                    size_t r);
20 void SHA3_squeeze(uint64_t A[5][5], unsigned char *out, size_t len, size_t r);
21
22 #define KECCAK1600_WIDTH 1600
23
24 typedef struct {
25     uint64_t A[5][5];
26     size_t block_size;          /* cached ctx->digest->block_size */
27     size_t md_size;             /* output length, variable in XOF */
28     size_t num;                 /* used bytes in below buffer */
29     unsigned char buf[KECCAK1600_WIDTH / 8 - 32];
30     unsigned char pad;
31 } KECCAK1600_CTX;
32
33 static int init(EVP_MD_CTX *evp_ctx, unsigned char pad)
34 {
35     KECCAK1600_CTX *ctx = evp_ctx->md_data;
36     size_t bsz = evp_ctx->digest->block_size;
37
38     if (bsz <= sizeof(ctx->buf)) {
39         memset(ctx->A, 0, sizeof(ctx->A));
40
41         ctx->num = 0;
42         ctx->block_size = bsz;
43         ctx->md_size = evp_ctx->digest->md_size;
44         ctx->pad = pad;
45
46         return 1;
47     }
48
49     return 0;
50 }
51
52 static int sha3_init(EVP_MD_CTX *evp_ctx)
53 {
54     return init(evp_ctx, '\x06');
55 }
56
57 static int shake_init(EVP_MD_CTX *evp_ctx)
58 {
59     return init(evp_ctx, '\x1f');
60 }
61
62 static int sha3_update(EVP_MD_CTX *evp_ctx, const void *_inp, size_t len)
63 {
64     KECCAK1600_CTX *ctx = evp_ctx->md_data;
65     const unsigned char *inp = _inp;
66     size_t bsz = ctx->block_size;
67     size_t num, rem;
68
69     if ((num = ctx->num) != 0) {      /* process intermediate buffer? */
70         rem = bsz - num;
71
72         if (len < rem) {
73             memcpy(ctx->buf + num, inp, len);
74             ctx->num += len;
75             return 1;
76         }
77         /*
78          * We have enough data to fill or overflow the intermediate
79          * buffer. So we append |rem| bytes and process the block,
80          * leaving the rest for later processing...
81          */
82         memcpy(ctx->buf + num, inp, rem);
83         inp += rem, len -= rem;
84         (void)SHA3_absorb(ctx->A, ctx->buf, bsz, bsz);
85         ctx->num = 0;
86         /* ctx->buf is processed, ctx->num is guaranteed to be zero */
87     }
88
89     if (len >= bsz)
90         rem = SHA3_absorb(ctx->A, inp, len, bsz);
91     else
92         rem = len;
93
94     if (rem) {
95         memcpy(ctx->buf, inp + len - rem, rem);
96         ctx->num = rem;
97     }
98
99     return 1;
100 }
101
102 static int sha3_final(EVP_MD_CTX *evp_ctx, unsigned char *md)
103 {
104     KECCAK1600_CTX *ctx = evp_ctx->md_data;
105     size_t bsz = ctx->block_size;
106     size_t num = ctx->num;
107
108     /*
109      * Pad the data with 10*1. Note that |num| can be |bsz - 1|
110      * in which case both byte operations below are performed on
111      * same byte...
112      */
113     memset(ctx->buf + num, 0, bsz - num);
114     ctx->buf[num] = ctx->pad;
115     ctx->buf[bsz - 1] |= 0x80;
116
117     (void)SHA3_absorb(ctx->A, ctx->buf, bsz, bsz);
118
119     SHA3_squeeze(ctx->A, md, ctx->md_size, bsz);
120
121     return 1;
122 }
123
124 static int shake_ctrl(EVP_MD_CTX *evp_ctx, int cmd, int p1, void *p2)
125 {
126     KECCAK1600_CTX *ctx = evp_ctx->md_data;
127
128     switch (cmd) {
129     case EVP_MD_CTRL_XOF_LEN:
130         ctx->md_size = p1;
131         return 1;
132     default:
133         return 0;
134     }
135 }
136
137 #define EVP_MD_SHA3(bitlen)                     \
138 const EVP_MD *EVP_sha3_##bitlen(void)           \
139 {                                               \
140     static const EVP_MD sha3_##bitlen##_md = {  \
141         NID_sha3_##bitlen,                      \
142         NID_RSA_SHA3_##bitlen,                  \
143         bitlen / 8,                             \
144         EVP_MD_FLAG_DIGALGID_ABSENT,            \
145         sha3_init,                              \
146         sha3_update,                            \
147         sha3_final,                             \
148         NULL,                                   \
149         NULL,                                   \
150         (KECCAK1600_WIDTH - bitlen * 2) / 8,    \
151         sizeof(KECCAK1600_CTX),                 \
152     };                                          \
153     return &sha3_##bitlen##_md;                 \
154 }
155
156 EVP_MD_SHA3(224)
157 EVP_MD_SHA3(256)
158 EVP_MD_SHA3(384)
159 EVP_MD_SHA3(512)
160
161 #define EVP_MD_SHAKE(bitlen)                    \
162 const EVP_MD *EVP_shake##bitlen(void)           \
163 {                                               \
164     static const EVP_MD shake##bitlen##_md = {  \
165         NID_shake##bitlen,                      \
166         0,                                      \
167         bitlen / 8,                             \
168         EVP_MD_FLAG_XOF,                        \
169         shake_init,                             \
170         sha3_update,                            \
171         sha3_final,                             \
172         NULL,                                   \
173         NULL,                                   \
174         (KECCAK1600_WIDTH - bitlen * 2) / 8,    \
175         sizeof(KECCAK1600_CTX),                 \
176         shake_ctrl                              \
177     };                                          \
178     return &shake##bitlen##_md;                 \
179 }
180
181 EVP_MD_SHAKE(128)
182 EVP_MD_SHAKE(256)