sync with OpenBSD -current

lib/libcrypto/whrlpool/wp_dgst.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: wp_dgst.c,v 1.7 2023/09/04 08:43:41 tb Exp $ */
+/* $OpenBSD: wp_dgst.c,v 1.8 2024/03/29 00:16:22 jsing Exp $ */
 /**
  * The Whirlpool hashing function.
  *
@@ -58,92 +58,88 @@
 
 #include "wp_local.h"
 
-int WHIRLPOOL_Init(WHIRLPOOL_CTX *c)
-	{
-	memset (c,0,sizeof(*c));
-	return(1);
-	}
+int
+WHIRLPOOL_Init(WHIRLPOOL_CTX *c)
+{
+	memset (c, 0, sizeof(*c));
+	return (1);
+}
 
-int WHIRLPOOL_Update	(WHIRLPOOL_CTX *c,const void *_inp,size_t bytes)
-	{
+int
+WHIRLPOOL_Update(WHIRLPOOL_CTX *c, const void *_inp, size_t bytes)
+{
 	/* Well, largest suitable chunk size actually is
 	 * (1<<(sizeof(size_t)*8-3))-64, but below number
 	 * is large enough for not to care about excessive
 	 * calls to WHIRLPOOL_BitUpdate... */
-	size_t chunk = ((size_t)1)<<(sizeof(size_t)*8-4);
+	size_t chunk = ((size_t)1) << (sizeof(size_t)*8 - 4);
 	const unsigned char *inp = _inp;
 
-	while (bytes>=chunk)
-		{
-		WHIRLPOOL_BitUpdate(c,inp,chunk*8);
+	while (bytes >= chunk) {
+		WHIRLPOOL_BitUpdate(c, inp, chunk*8);
 		bytes -= chunk;
-		inp   += chunk;
-		}
-	if (bytes)
-		WHIRLPOOL_BitUpdate(c,inp,bytes*8);
-
-	return(1);
+		inp += chunk;
 	}
+	if (bytes)
+		WHIRLPOOL_BitUpdate(c, inp, bytes*8);
 
-void WHIRLPOOL_BitUpdate(WHIRLPOOL_CTX *c,const void *_inp,size_t bits)
-	{
+	return (1);
+}
+
+void
+WHIRLPOOL_BitUpdate(WHIRLPOOL_CTX *c, const void *_inp, size_t bits)
+{
 	size_t		n;
 	unsigned int	bitoff = c->bitoff,
-			bitrem = bitoff%8,
-			inpgap = (8-(unsigned int)bits%8)&7;
-	const unsigned char *inp=_inp;
+	    bitrem = bitoff % 8,
+	    inpgap = (8 - (unsigned int)bits % 8)&7;
+	const unsigned char *inp = _inp;
 
 	/* This 256-bit increment procedure relies on the size_t
 	 * being natural size of CPU register, so that we don't
 	 * have to mask the value in order to detect overflows. */
 	c->bitlen[0] += bits;
 	if (c->bitlen[0] < bits)	/* overflow */
-		{
+	{
 		n = 1;
-		do  { 	c->bitlen[n]++;
-		    } while(c->bitlen[n]==0
-		   	    && ++n<(WHIRLPOOL_COUNTER/sizeof(size_t)));
-		}
+		do {
+			c->bitlen[n]++;
+		} while (c->bitlen[n]==0 &&
+		    ++n < (WHIRLPOOL_COUNTER/sizeof(size_t)));
+	}
 
 #ifndef OPENSSL_SMALL_FOOTPRINT
-	reconsider:
+reconsider:
 	if (inpgap==0 && bitrem==0)	/* byte-oriented loop */
-		{
-		while (bits)
-			{
-			if (bitoff==0 && (n=bits/WHIRLPOOL_BBLOCK))
-				{
-				whirlpool_block(c,inp,n);
-				inp  += n*WHIRLPOOL_BBLOCK/8;
+	{
+		while (bits) {
+			if (bitoff == 0 && (n = bits/WHIRLPOOL_BBLOCK)) {
+				whirlpool_block(c, inp, n);
+				inp += n*WHIRLPOOL_BBLOCK/8;
 				bits %= WHIRLPOOL_BBLOCK;
-				}
-			else
-				{
+			} else {
 				unsigned int byteoff = bitoff/8;
 
 				bitrem = WHIRLPOOL_BBLOCK - bitoff;/* re-use bitrem */
-				if (bits >= bitrem)
-					{
+				if (bits >= bitrem) {
 					bits -= bitrem;
 					bitrem /= 8;
-					memcpy(c->data+byteoff,inp,bitrem);
-					inp  += bitrem;
-					whirlpool_block(c,c->data,1);
+					memcpy(c->data + byteoff, inp, bitrem);
+					inp += bitrem;
+					whirlpool_block(c, c->data, 1);
 					bitoff = 0;
-					}
-				else
-					{
-					memcpy(c->data+byteoff,inp,bits/8);
+				} else {
+					memcpy(c->data + byteoff, inp, bits/8);
 					bitoff += (unsigned int)bits;
 					bits = 0;
-					}
-				c->bitoff = bitoff;
 				}
+				c->bitoff = bitoff;
 			}
 		}
+	}
 	else				/* bit-oriented loop */
 #endif
-		{
+	{
 		/*
 			   inp
 			   |
@@ -156,113 +152,116 @@ void WHIRLPOOL_BitUpdate(WHIRLPOOL_CTX *c,const void *_inp,size_t bits)
 			|
 			c->bitoff/8
 		*/
-		while (bits)
-			{
-			unsigned int	byteoff	= bitoff/8;
+		while (bits) {
+			unsigned int	byteoff = bitoff/8;
 			unsigned char	b;
 
 #ifndef OPENSSL_SMALL_FOOTPRINT
-			if (bitrem==inpgap)
-				{
-				c->data[byteoff++] |= inp[0] & (0xff>>inpgap);
-				inpgap = 8-inpgap;
+			if (bitrem == inpgap) {
+				c->data[byteoff++] |= inp[0] & (0xff >> inpgap);
+				inpgap = 8 - inpgap;
 				bitoff += inpgap;  bitrem = 0;	/* bitoff%8 */
 				bits   -= inpgap;  inpgap = 0;	/* bits%8   */
 				inp++;
-				if (bitoff==WHIRLPOOL_BBLOCK)
-					{
-					whirlpool_block(c,c->data,1);
+				if (bitoff == WHIRLPOOL_BBLOCK) {
+					whirlpool_block(c, c->data, 1);
 					bitoff = 0;
-					}
+				}
 				c->bitoff = bitoff;
 				goto reconsider;
-				}
-			else
+			} else
 #endif
-			if (bits>=8)
-				{
-				b  = ((inp[0]<<inpgap) | (inp[1]>>(8-inpgap)));
+			if (bits >= 8) {
+				b = ((inp[0]<<inpgap) | (inp[1]>>(8 - inpgap)));
 				b &= 0xff;
-				if (bitrem)	c->data[byteoff++] |= b>>bitrem;
-				else		c->data[byteoff++]  = b;
+				if (bitrem)
+					c->data[byteoff++] |= b >> bitrem;
+				else
+					c->data[byteoff++] = b;
 				bitoff += 8;
-				bits   -= 8;
+				bits -= 8;
 				inp++;
-				if (bitoff>=WHIRLPOOL_BBLOCK)
-					{
-					whirlpool_block(c,c->data,1);
-					byteoff  = 0;
+				if (bitoff >= WHIRLPOOL_BBLOCK) {
+					whirlpool_block(c, c->data, 1);
+					byteoff = 0;
 					bitoff  %= WHIRLPOOL_BBLOCK;
-					}
-				if (bitrem)	c->data[byteoff] = b<<(8-bitrem);
 				}
-			else	/* remaining less than 8 bits */
-				{
-				b = (inp[0]<<inpgap)&0xff;
-				if (bitrem)	c->data[byteoff++] |= b>>bitrem;
-				else		c->data[byteoff++]  = b;
-				bitoff += (unsigned int)bits;
-				if (bitoff==WHIRLPOOL_BBLOCK)
-					{
-					whirlpool_block(c,c->data,1);
-					byteoff  = 0;
-			        	bitoff  %= WHIRLPOOL_BBLOCK;
-					}
-				if (bitrem)	c->data[byteoff] = b<<(8-bitrem);
-				bits = 0;
-				}
-			c->bitoff = bitoff;
+				if (bitrem)
+					c->data[byteoff] = b << (8 - bitrem);
 			}
+			else	/* remaining less than 8 bits */
+			{
+				b = (inp[0]<<inpgap)&0xff;
+				if (bitrem)
+					c->data[byteoff++] |= b >> bitrem;
+				else
+					c->data[byteoff++] = b;
+				bitoff += (unsigned int)bits;
+				if (bitoff == WHIRLPOOL_BBLOCK) {
+					whirlpool_block(c, c->data, 1);
+					byteoff = 0;
+					bitoff  %= WHIRLPOOL_BBLOCK;
+				}
+				if (bitrem)
+					c->data[byteoff] = b << (8 - bitrem);
+				bits = 0;
+			}
+			c->bitoff = bitoff;
 		}
 	}
+}
 
-int WHIRLPOOL_Final	(unsigned char *md,WHIRLPOOL_CTX *c)
-	{
-	unsigned int	bitoff  = c->bitoff,
-			byteoff = bitoff/8;
-	size_t		i,j,v;
+int
+WHIRLPOOL_Final(unsigned char *md, WHIRLPOOL_CTX *c)
+{
+	unsigned int	bitoff = c->bitoff,
+	    byteoff = bitoff/8;
+	size_t		i, j, v;
 	unsigned char  *p;
 
 	bitoff %= 8;
-	if (bitoff)	c->data[byteoff] |= 0x80>>bitoff;
-	else		c->data[byteoff]  = 0x80;
+	if (bitoff)
+		c->data[byteoff] |= 0x80 >> bitoff;
+	else
+		c->data[byteoff] = 0x80;
 	byteoff++;
 
 	/* pad with zeros */
-	if (byteoff > (WHIRLPOOL_BBLOCK/8-WHIRLPOOL_COUNTER))
-		{
-		if (byteoff<WHIRLPOOL_BBLOCK/8)
-			memset(&c->data[byteoff],0,WHIRLPOOL_BBLOCK/8-byteoff);
-		whirlpool_block(c,c->data,1);
+	if (byteoff > (WHIRLPOOL_BBLOCK/8 - WHIRLPOOL_COUNTER)) {
+		if (byteoff < WHIRLPOOL_BBLOCK/8)
+			memset(&c->data[byteoff], 0, WHIRLPOOL_BBLOCK/8 - byteoff);
+		whirlpool_block(c, c->data, 1);
 		byteoff = 0;
-		}
-	if (byteoff < (WHIRLPOOL_BBLOCK/8-WHIRLPOOL_COUNTER))
-		memset(&c->data[byteoff],0,
-			(WHIRLPOOL_BBLOCK/8-WHIRLPOOL_COUNTER)-byteoff);
+	}
+	if (byteoff < (WHIRLPOOL_BBLOCK/8 - WHIRLPOOL_COUNTER))
+		memset(&c->data[byteoff], 0,
+		    (WHIRLPOOL_BBLOCK/8 - WHIRLPOOL_COUNTER) - byteoff);
 	/* smash 256-bit c->bitlen in big-endian order */
 	p = &c->data[WHIRLPOOL_BBLOCK/8-1];	/* last byte in c->data */
-	for(i=0;i<WHIRLPOOL_COUNTER/sizeof(size_t);i++)
-		for(v=c->bitlen[i],j=0;j<sizeof(size_t);j++,v>>=8)
+	for (i = 0; i < WHIRLPOOL_COUNTER/sizeof(size_t); i++)
+		for (v = c->bitlen[i], j = 0; j < sizeof(size_t); j++, v >>= 8)
 			*p-- = (unsigned char)(v&0xff);
 
-	whirlpool_block(c,c->data,1);
+	whirlpool_block(c, c->data, 1);
 
 	if (md)	{
-		memcpy(md,c->H.c,WHIRLPOOL_DIGEST_LENGTH);
-		memset(c,0,sizeof(*c));
-		return(1);
-		}
-	return(0);
+		memcpy(md, c->H.c, WHIRLPOOL_DIGEST_LENGTH);
+		memset(c, 0, sizeof(*c));
+		return (1);
 	}
+	return (0);
+}
 
-unsigned char *WHIRLPOOL(const void *inp, size_t bytes,unsigned char *md)
-	{
+unsigned char *
+WHIRLPOOL(const void *inp, size_t bytes, unsigned char *md)
+{
 	WHIRLPOOL_CTX ctx;
 	static unsigned char m[WHIRLPOOL_DIGEST_LENGTH];
 
-	if (md == NULL) md=m;
+	if (md == NULL)
+		md = m;
 	WHIRLPOOL_Init(&ctx);
-	WHIRLPOOL_Update(&ctx,inp,bytes);
-	WHIRLPOOL_Final(md,&ctx);
-	return(md);
-	}
+	WHIRLPOOL_Update(&ctx, inp, bytes);
+	WHIRLPOOL_Final(md, &ctx);
+	return (md);
+}