Add CHAP SHA3-256 support

Signed-off-by: Ronnie Sahlberg <ronniesahlberg@gmail.com>

README.md

@@ -47,7 +47,7 @@ target_user=<account>
 target_password=<password>
 header_digest=<crc32c|none>
 data_digest=<crc32c|none>
-auth=<md5|sha1|sha256>
+auth=<md5|sha1|sha-256|sha3-256>
 Transport:
 iser
 

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

include/sha3.h

@@ -0,0 +1,49 @@
+// sha3.h
+// 19-Nov-11  Markku-Juhani O. Saarinen <mjos@iki.fi>
+
+// From https://github.com/mjosaarinen/tiny_sha3
+
+#ifndef SHA3_H
+#define SHA3_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#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
+

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

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);

lib/login.c

@@ -45,6 +45,7 @@
 #include "scsi-lowlevel.h"
 #include "md5.h"
 #include "sha.h"
+#include "sha3.h"
 
 #ifdef HAVE_LIBGNUTLS
 #include <gnutls/crypto.h>
@@ -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;
                         }

lib/sha3.c

@@ -0,0 +1,193 @@
+// sha3.c
+// 19-Nov-11  Markku-Juhani O. Saarinen <mjos@iki.fi>
+
+// 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;
+}
+