static size_t crypto_hashblocks_sha256()

in pq-crypto/kyber_90s_r2/sha2_c.c [135:291]

• 142 lines of code
• 2 McCabe index (conditional complexity)

static size_t crypto_hashblocks_sha256(uint8_t *statebytes,
                                       const uint8_t *in, size_t inlen) {
	uint32_t state[8];
	uint32_t a;
	uint32_t b;
	uint32_t c;
	uint32_t d;
	uint32_t e;
	uint32_t f;
	uint32_t g;
	uint32_t h;

	a = load_bigendian_32(statebytes + 0);
	state[0] = a;
	b = load_bigendian_32(statebytes + 4);
	state[1] = b;
	c = load_bigendian_32(statebytes + 8);
	state[2] = c;
	d = load_bigendian_32(statebytes + 12);
	state[3] = d;
	e = load_bigendian_32(statebytes + 16);
	state[4] = e;
	f = load_bigendian_32(statebytes + 20);
	state[5] = f;
	g = load_bigendian_32(statebytes + 24);
	state[6] = g;
	h = load_bigendian_32(statebytes + 28);
	state[7] = h;

	while (inlen >= 64) {
		uint32_t w0  = load_bigendian_32(in + 0);
		uint32_t w1  = load_bigendian_32(in + 4);
		uint32_t w2  = load_bigendian_32(in + 8);
		uint32_t w3  = load_bigendian_32(in + 12);
		uint32_t w4  = load_bigendian_32(in + 16);
		uint32_t w5  = load_bigendian_32(in + 20);
		uint32_t w6  = load_bigendian_32(in + 24);
		uint32_t w7  = load_bigendian_32(in + 28);
		uint32_t w8  = load_bigendian_32(in + 32);
		uint32_t w9  = load_bigendian_32(in + 36);
		uint32_t w10 = load_bigendian_32(in + 40);
		uint32_t w11 = load_bigendian_32(in + 44);
		uint32_t w12 = load_bigendian_32(in + 48);
		uint32_t w13 = load_bigendian_32(in + 52);
		uint32_t w14 = load_bigendian_32(in + 56);
		uint32_t w15 = load_bigendian_32(in + 60);

		uint32_t T1;
		uint32_t T2;

		F_32(w0, 0x428a2f98)
		F_32(w1, 0x71374491)
		F_32(w2, 0xb5c0fbcf)
		F_32(w3, 0xe9b5dba5)
		F_32(w4, 0x3956c25b)
		F_32(w5, 0x59f111f1)
		F_32(w6, 0x923f82a4)
		F_32(w7, 0xab1c5ed5)
		F_32(w8, 0xd807aa98)
		F_32(w9, 0x12835b01)
		F_32(w10, 0x243185be)
		F_32(w11, 0x550c7dc3)
		F_32(w12, 0x72be5d74)
		F_32(w13, 0x80deb1fe)
		F_32(w14, 0x9bdc06a7)
		F_32(w15, 0xc19bf174)

		EXPAND_32

		F_32(w0, 0xe49b69c1)
		F_32(w1, 0xefbe4786)
		F_32(w2, 0x0fc19dc6)
		F_32(w3, 0x240ca1cc)
		F_32(w4, 0x2de92c6f)
		F_32(w5, 0x4a7484aa)
		F_32(w6, 0x5cb0a9dc)
		F_32(w7, 0x76f988da)
		F_32(w8, 0x983e5152)
		F_32(w9, 0xa831c66d)
		F_32(w10, 0xb00327c8)
		F_32(w11, 0xbf597fc7)
		F_32(w12, 0xc6e00bf3)
		F_32(w13, 0xd5a79147)
		F_32(w14, 0x06ca6351)
		F_32(w15, 0x14292967)

		EXPAND_32

		F_32(w0, 0x27b70a85)
		F_32(w1, 0x2e1b2138)
		F_32(w2, 0x4d2c6dfc)
		F_32(w3, 0x53380d13)
		F_32(w4, 0x650a7354)
		F_32(w5, 0x766a0abb)
		F_32(w6, 0x81c2c92e)
		F_32(w7, 0x92722c85)
		F_32(w8, 0xa2bfe8a1)
		F_32(w9, 0xa81a664b)
		F_32(w10, 0xc24b8b70)
		F_32(w11, 0xc76c51a3)
		F_32(w12, 0xd192e819)
		F_32(w13, 0xd6990624)
		F_32(w14, 0xf40e3585)
		F_32(w15, 0x106aa070)

		EXPAND_32

		F_32(w0, 0x19a4c116)
		F_32(w1, 0x1e376c08)
		F_32(w2, 0x2748774c)
		F_32(w3, 0x34b0bcb5)
		F_32(w4, 0x391c0cb3)
		F_32(w5, 0x4ed8aa4a)
		F_32(w6, 0x5b9cca4f)
		F_32(w7, 0x682e6ff3)
		F_32(w8, 0x748f82ee)
		F_32(w9, 0x78a5636f)
		F_32(w10, 0x84c87814)
		F_32(w11, 0x8cc70208)
		F_32(w12, 0x90befffa)
		F_32(w13, 0xa4506ceb)
		F_32(w14, 0xbef9a3f7)
		F_32(w15, 0xc67178f2)

		a += state[0];
		b += state[1];
		c += state[2];
		d += state[3];
		e += state[4];
		f += state[5];
		g += state[6];
		h += state[7];

		state[0] = a;
		state[1] = b;
		state[2] = c;
		state[3] = d;
		state[4] = e;
		state[5] = f;
		state[6] = g;
		state[7] = h;

		in += 64;
		inlen -= 64;
	}

	store_bigendian_32(statebytes + 0, state[0]);
	store_bigendian_32(statebytes + 4, state[1]);
	store_bigendian_32(statebytes + 8, state[2]);
	store_bigendian_32(statebytes + 12, state[3]);
	store_bigendian_32(statebytes + 16, state[4]);
	store_bigendian_32(statebytes + 20, state[5]);
	store_bigendian_32(statebytes + 24, state[6]);
	store_bigendian_32(statebytes + 28, state[7]);

	return inlen;
}