From b8d9fbf5e3120dde1a95ca7d873117f4e911b86c Mon Sep 17 00:00:00 2001 From: Ronnie Sahlberg Date: Sat, 4 Jan 2025 14:20:28 +1000 Subject: [PATCH] Add CHAP SHA3-256 support Signed-off-by: Ronnie Sahlberg --- README.md | 2 +- include/iscsi.h | 2 - include/sha3.h | 49 ++++++++++++ lib/Makefile.am | 2 +- lib/init.c | 2 - lib/login.c | 28 +++++++ lib/sha3.c | 193 ++++++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 272 insertions(+), 6 deletions(-) create mode 100644 include/sha3.h create mode 100644 lib/sha3.c diff --git a/README.md b/README.md index a12bc44..4a3c9be 100644 --- a/README.md +++ b/README.md @@ -47,7 +47,7 @@ target_user= target_password= header_digest= data_digest= -auth= +auth= Transport: iser diff --git a/include/iscsi.h b/include/iscsi.h index e2104cc..375a7d8 100644 --- a/include/iscsi.h +++ b/include/iscsi.h @@ -187,9 +187,7 @@ enum iscsi_chap_auth { ISCSI_CHAP_MD5 = 5, ISCSI_CHAP_SHA_1 = 6, ISCSI_CHAP_SHA_256 = 7, -#if 0 ISCSI_CHAP_SHA3_256 = 8, -#endif }; EXTERN enum iscsi_chap_auth diff --git a/include/sha3.h b/include/sha3.h new file mode 100644 index 0000000..d429a60 --- /dev/null +++ b/include/sha3.h @@ -0,0 +1,49 @@ +// sha3.h +// 19-Nov-11 Markku-Juhani O. Saarinen + +// From https://github.com/mjosaarinen/tiny_sha3 + +#ifndef SHA3_H +#define SHA3_H + +#include +#include + +#ifndef KECCAKF_ROUNDS +#define KECCAKF_ROUNDS 24 +#endif + +#ifndef ROTL64 +#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y)))) +#endif + +// state context +typedef struct { + union { // state: + uint8_t b[200]; // 8-bit bytes + uint64_t q[25]; // 64-bit words + } st; + int pt, rsiz, mdlen; // these don't overflow +} sha3_ctx_t; + +// Compression function. +void sha3_keccakf(uint64_t st[25]); + +// OpenSSL - like interfece +int sha3_init(sha3_ctx_t *c, int mdlen); // mdlen = hash output in bytes +int sha3_update(sha3_ctx_t *c, const void *data, size_t len); +int sha3_final(void *md, sha3_ctx_t *c); // digest goes to md + +// compute a sha3 hash (md) of given byte length from "in" +void *sha3(const void *in, size_t inlen, void *md, int mdlen); + +// SHAKE128 and SHAKE256 extensible-output functions +#define shake128_init(c) sha3_init(c, 16) +#define shake256_init(c) sha3_init(c, 32) +#define shake_update sha3_update + +void shake_xof(sha3_ctx_t *c); +void shake_out(sha3_ctx_t *c, void *out, size_t len); + +#endif + diff --git a/lib/Makefile.am b/lib/Makefile.am index d63894f..c277041 100644 --- a/lib/Makefile.am +++ b/lib/Makefile.am @@ -6,7 +6,7 @@ libiscsipriv_la_SOURCES = \ connect.c crc32c.c discovery.c init.c \ login.c nop.c pdu.c iscsi-command.c \ scsi-lowlevel.c socket.c sync.c task_mgmt.c \ - logging.c utils.c sha1.c sha224-256.c + logging.c utils.c sha1.c sha224-256.c sha3.c if TARGET_OS_IS_WIN32 libiscsipriv_la_SOURCES += ../win32/win32_compat.c diff --git a/lib/init.c b/lib/init.c index e8dc44d..7dc5348 100644 --- a/lib/init.c +++ b/lib/init.c @@ -630,10 +630,8 @@ iscsi_parse_url(struct iscsi_context *iscsi, const char *url, int full) iscsi->chap_auth = ISCSI_CHAP_SHA_1; } else if (!strcmp(value, "sha-256")) { iscsi->chap_auth = ISCSI_CHAP_SHA_256; -#if 0 } else if (!strcmp(value, "sha3-256")) { iscsi->chap_auth = ISCSI_CHAP_SHA3_256; -#endif } else { iscsi_set_error(iscsi, "Invalid argument for auth: %s", value); diff --git a/lib/login.c b/lib/login.c index 589efd6..cd91429 100644 --- a/lib/login.c +++ b/lib/login.c @@ -45,6 +45,7 @@ #include "scsi-lowlevel.h" #include "md5.h" #include "sha.h" +#include "sha3.h" #ifdef HAVE_LIBGNUTLS #include @@ -808,6 +809,29 @@ static void compute_chap_r_sha1(struct iscsi_context *iscsi, int chap_i, SHA1Result(&ctx, digest); } +static void compute_chap_r_sha3_256(struct iscsi_context *iscsi, int chap_i, + unsigned char *passwd, + unsigned char *chap_c, + unsigned char *digest) +{ + unsigned char *strp; + unsigned char c; + sha3_ctx_t ctx; + + sha3_init(&ctx, 32); + c = chap_i; + sha3_update(&ctx, &c, 1); + sha3_update(&ctx, passwd, strlen((char *)passwd)); + + strp = chap_c; + while (*strp != 0) { + c = (h2i(strp[0]) << 4) | h2i(strp[1]); + strp += 2; + sha3_update(&ctx, &c, 1); + } + sha3_final(digest, &ctx); +} + static void compute_chap_r_sha256(struct iscsi_context *iscsi, int chap_i, unsigned char *passwd, unsigned char *chap_c, @@ -843,6 +867,8 @@ static void compute_chap_r(struct iscsi_context *iscsi, int chap_i, return compute_chap_r_sha1(iscsi, chap_i, passwd, chap_c, digest); case ISCSI_CHAP_SHA_256: return compute_chap_r_sha256(iscsi, chap_i, passwd, chap_c, digest); + case ISCSI_CHAP_SHA3_256: + return compute_chap_r_sha3_256(iscsi, chap_i, passwd, chap_c, digest); } } @@ -873,6 +899,7 @@ iscsi_login_add_chap_response(struct iscsi_context *iscsi, struct iscsi_pdu *pdu chap_r_size = 20; break; case ISCSI_CHAP_SHA_256: + case ISCSI_CHAP_SHA3_256: chap_r_size = 32; break; } @@ -1424,6 +1451,7 @@ iscsi_process_login_reply(struct iscsi_context *iscsi, struct iscsi_pdu *pdu, chap_r_size = 20; break; case ISCSI_CHAP_SHA_256: + case ISCSI_CHAP_SHA3_256: chap_r_size = 32; break; } diff --git a/lib/sha3.c b/lib/sha3.c new file mode 100644 index 0000000..13930da --- /dev/null +++ b/lib/sha3.c @@ -0,0 +1,193 @@ +// sha3.c +// 19-Nov-11 Markku-Juhani O. Saarinen + +// Revised 07-Aug-15 to match with official release of FIPS PUB 202 "SHA3" +// Revised 03-Sep-15 for portability + OpenSSL - style API + +// From https://github.com/mjosaarinen/tiny_sha3 + +#include "sha3.h" + +// update the state with given number of rounds + +void sha3_keccakf(uint64_t st[25]) +{ + // constants + const uint64_t keccakf_rndc[24] = { + 0x0000000000000001, 0x0000000000008082, 0x800000000000808a, + 0x8000000080008000, 0x000000000000808b, 0x0000000080000001, + 0x8000000080008081, 0x8000000000008009, 0x000000000000008a, + 0x0000000000000088, 0x0000000080008009, 0x000000008000000a, + 0x000000008000808b, 0x800000000000008b, 0x8000000000008089, + 0x8000000000008003, 0x8000000000008002, 0x8000000000000080, + 0x000000000000800a, 0x800000008000000a, 0x8000000080008081, + 0x8000000000008080, 0x0000000080000001, 0x8000000080008008 + }; + const int keccakf_rotc[24] = { + 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 2, 14, + 27, 41, 56, 8, 25, 43, 62, 18, 39, 61, 20, 44 + }; + const int keccakf_piln[24] = { + 10, 7, 11, 17, 18, 3, 5, 16, 8, 21, 24, 4, + 15, 23, 19, 13, 12, 2, 20, 14, 22, 9, 6, 1 + }; + + // variables + int i, j, r; + uint64_t t, bc[5]; + +#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__ + uint8_t *v; + + // endianess conversion. this is redundant on little-endian targets + for (i = 0; i < 25; i++) { + v = (uint8_t *) &st[i]; + st[i] = ((uint64_t) v[0]) | (((uint64_t) v[1]) << 8) | + (((uint64_t) v[2]) << 16) | (((uint64_t) v[3]) << 24) | + (((uint64_t) v[4]) << 32) | (((uint64_t) v[5]) << 40) | + (((uint64_t) v[6]) << 48) | (((uint64_t) v[7]) << 56); + } +#endif + + // actual iteration + for (r = 0; r < KECCAKF_ROUNDS; r++) { + + // Theta + for (i = 0; i < 5; i++) + bc[i] = st[i] ^ st[i + 5] ^ st[i + 10] ^ st[i + 15] ^ st[i + 20]; + + for (i = 0; i < 5; i++) { + t = bc[(i + 4) % 5] ^ ROTL64(bc[(i + 1) % 5], 1); + for (j = 0; j < 25; j += 5) + st[j + i] ^= t; + } + + // Rho Pi + t = st[1]; + for (i = 0; i < 24; i++) { + j = keccakf_piln[i]; + bc[0] = st[j]; + st[j] = ROTL64(t, keccakf_rotc[i]); + t = bc[0]; + } + + // Chi + for (j = 0; j < 25; j += 5) { + for (i = 0; i < 5; i++) + bc[i] = st[j + i]; + for (i = 0; i < 5; i++) + st[j + i] ^= (~bc[(i + 1) % 5]) & bc[(i + 2) % 5]; + } + + // Iota + st[0] ^= keccakf_rndc[r]; + } + +#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__ + // endianess conversion. this is redundant on little-endian targets + for (i = 0; i < 25; i++) { + v = (uint8_t *) &st[i]; + t = st[i]; + v[0] = t & 0xFF; + v[1] = (t >> 8) & 0xFF; + v[2] = (t >> 16) & 0xFF; + v[3] = (t >> 24) & 0xFF; + v[4] = (t >> 32) & 0xFF; + v[5] = (t >> 40) & 0xFF; + v[6] = (t >> 48) & 0xFF; + v[7] = (t >> 56) & 0xFF; + } +#endif +} + +// Initialize the context for SHA3 + +int sha3_init(sha3_ctx_t *c, int mdlen) +{ + int i; + + for (i = 0; i < 25; i++) + c->st.q[i] = 0; + c->mdlen = mdlen; + c->rsiz = 200 - 2 * mdlen; + c->pt = 0; + + return 1; +} + +// update state with more data + +int sha3_update(sha3_ctx_t *c, const void *data, size_t len) +{ + size_t i; + int j; + + j = c->pt; + for (i = 0; i < len; i++) { + c->st.b[j++] ^= ((const uint8_t *) data)[i]; + if (j >= c->rsiz) { + sha3_keccakf(c->st.q); + j = 0; + } + } + c->pt = j; + + return 1; +} + +// finalize and output a hash + +int sha3_final(void *md, sha3_ctx_t *c) +{ + int i; + + c->st.b[c->pt] ^= 0x06; + c->st.b[c->rsiz - 1] ^= 0x80; + sha3_keccakf(c->st.q); + + for (i = 0; i < c->mdlen; i++) { + ((uint8_t *) md)[i] = c->st.b[i]; + } + + return 1; +} + +// compute a SHA-3 hash (md) of given byte length from "in" + +void *sha3(const void *in, size_t inlen, void *md, int mdlen) +{ + sha3_ctx_t sha3; + + sha3_init(&sha3, mdlen); + sha3_update(&sha3, in, inlen); + sha3_final(md, &sha3); + + return md; +} + +// SHAKE128 and SHAKE256 extensible-output functionality + +void shake_xof(sha3_ctx_t *c) +{ + c->st.b[c->pt] ^= 0x1F; + c->st.b[c->rsiz - 1] ^= 0x80; + sha3_keccakf(c->st.q); + c->pt = 0; +} + +void shake_out(sha3_ctx_t *c, void *out, size_t len) +{ + size_t i; + int j; + + j = c->pt; + for (i = 0; i < len; i++) { + if (j >= c->rsiz) { + sha3_keccakf(c->st.q); + j = 0; + } + ((uint8_t *) out)[i] = c->st.b[j++]; + } + c->pt = j; +} +