mirrors/coreutils
0
0
Fork 0
mirror of https://github.com/coreutils/coreutils.git synced 2024-11-25 02:45:15 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix commentary to match md5 better. Adjust to .h file changes.

Browse Source
This commit is contained in:
Paul Eggert 2006-01-12 07:17:25 +00:00
parent 3024d13d7e
commit 1834ba06ac
3 changed files with 56 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
lib/sha1.c
View File

@ -1,7 +1,8 @@
/* sha1.c - Functions to compute SHA1 message digest of files or
memory blocks according to the NIST specification FIPS-180-1.
Copyright (C) 2000, 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
Copyright (C) 2000, 2001, 2003, 2004, 2005, 2006 Free Software
Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
@ -35,9 +36,6 @@
# include "unlocked-io.h"
#endif
/* SWAP does an endian swap on architectures that are little-endian,
as SHA1 needs some data in a big-endian form. */
#ifdef WORDS_BIGENDIAN
# define SWAP(n) (n)
#else
@ -55,11 +53,9 @@
static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
/*
Takes a pointer to a 160 bit block of data (five 32 bit ints) and
intializes it to the start constants of the SHA1 algorithm. This
must be called before using hash in the call to sha1_hash.
*/
/* Take a pointer to a 160 bit block of data (five 32 bit ints) and
initialize it to the start constants of the SHA1 algorithm. This
must be called before using hash in the call to sha1_hash. */
void
sha1_init_ctx (struct sha1_ctx *ctx)
{
@ -100,23 +96,21 @@ sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf)
{
/* Take yet unprocessed bytes into account. */
uint32_t bytes = ctx->buflen;
size_t pad;
size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;
/* Now count remaining bytes. */
ctx->total[0] += bytes;
if (ctx->total[0] < bytes)
++ctx->total[1];
pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
memcpy (&ctx->buffer[bytes], fillbuf, pad);
/* Put the 64-bit file length in *bits* at the end of the buffer. */
*(uint32_t *) &ctx->buffer[bytes + pad + 4] = SWAP (ctx->total[0] << 3);
*(uint32_t *) &ctx->buffer[bytes + pad] = SWAP ((ctx->total[1] << 3) |
(ctx->total[0] >> 29));
ctx->buffer[size - 2] = SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 29));
ctx->buffer[size - 1] = SWAP (ctx->total[0] << 3);
memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
/* Process last bytes. */
sha1_process_block (ctx->buffer, bytes + pad + 8, ctx);
sha1_process_block (ctx->buffer, size * 4, ctx);
return sha1_read_ctx (ctx, resbuf);
}
@ -216,7 +210,7 @@ sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
size_t left_over = ctx->buflen;
size_t add = 128 - left_over > len ? len : 128 - left_over;
memcpy (&ctx->buffer[left_over], buffer, add);
memcpy (&((char *) ctx->buffer)[left_over], buffer, add);
ctx->buflen += add;
if (ctx->buflen > 64)
@ -225,7 +219,8 @@ sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
ctx->buflen &= 63;
/* The regions in the following copy operation cannot overlap. */
memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
memcpy (ctx->buffer,
&((char *) ctx->buffer)[(left_over + add) & ~63],
ctx->buflen);
}
@ -260,13 +255,13 @@ sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
{
size_t left_over = ctx->buflen;
memcpy (&ctx->buffer[left_over], buffer, len);
memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
left_over += len;
if (left_over >= 64)
{
sha1_process_block (ctx->buffer, 64, ctx);
left_over -= 64;
memcpy (ctx->buffer, &ctx->buffer[64], left_over);
memcpy (ctx->buffer, &ctx->buffer[16], left_over);
}
ctx->buflen = left_over;
}

45
lib/sha256.c
View File

@ -34,26 +34,20 @@
# include "unlocked-io.h"
#endif
/*
Not-swap is a macro that does an endian swap on architectures that are
big-endian, as SHA256 needs some data in a little-endian format
*/
#ifdef WORDS_BIGENDIAN
# define NOTSWAP(n) (n)
# define SWAP(n) (n)
#else
# define NOTSWAP(n) \
# define SWAP(n) \
(((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
#endif
#define BLOCKSIZE 4096
/* Ensure that BLOCKSIZE is a multiple of 64. */
#if BLOCKSIZE % 64 != 0
# error "invalid BLOCKSIZE"
#endif
/* This array contains the bytes used to pad the buffer to the next
64-byte boundary. */
64-byte boundary. */
static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
@ -104,8 +98,8 @@ sha256_read_ctx (const struct sha256_ctx *ctx, void *resbuf)
{
int i;
for ( i=0 ; i<8 ; i++ )
((uint32_t *) resbuf)[i] = NOTSWAP (ctx->state[i]);
for (i = 0; i < 8; i++)
((uint32_t *) resbuf)[i] = SWAP (ctx->state[i]);
return resbuf;
}
@ -115,8 +109,8 @@ sha224_read_ctx (const struct sha256_ctx *ctx, void *resbuf)
{
int i;
for ( i=0 ; i<7 ; i++ )
((uint32_t *) resbuf)[i] = NOTSWAP (ctx->state[i]);
for (i = 0; i < 7; i++)
((uint32_t *) resbuf)[i] = SWAP (ctx->state[i]);
return resbuf;
}
@ -131,23 +125,21 @@ sha256_conclude_ctx (struct sha256_ctx *ctx)
{
/* Take yet unprocessed bytes into account. */
uint32_t bytes = ctx->buflen;
size_t pad;
size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;
/* Now count remaining bytes. */
ctx->total[0] += bytes;
if (ctx->total[0] < bytes)
++ctx->total[1];
pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
memcpy (&ctx->buffer[bytes], fillbuf, pad);
/* Put the 64-bit file length in *bits* at the end of the buffer. */
*(uint32_t *) &ctx->buffer[bytes + pad + 4] = NOTSWAP (ctx->total[0] << 3);
*(uint32_t *) &ctx->buffer[bytes + pad] = NOTSWAP ((ctx->total[1] << 3) |
(ctx->total[0] >> 29));
ctx->buffer[size - 2] = SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 29));
ctx->buffer[size - 1] = SWAP (ctx->total[0] << 3);
memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
/* Process last bytes. */
sha256_process_block (ctx->buffer, bytes + pad + 8, ctx);
sha256_process_block (ctx->buffer, size * 4, ctx);
}
void *
@ -338,7 +330,7 @@ sha256_process_bytes (const void *buffer, size_t len, struct sha256_ctx *ctx)
size_t left_over = ctx->buflen;
size_t add = 128 - left_over > len ? len : 128 - left_over;
memcpy (&ctx->buffer[left_over], buffer, add);
memcpy (&((char *) ctx->buffer)[left_over], buffer, add);
ctx->buflen += add;
if (ctx->buflen > 64)
@ -347,7 +339,8 @@ sha256_process_bytes (const void *buffer, size_t len, struct sha256_ctx *ctx)
ctx->buflen &= 63;
/* The regions in the following copy operation cannot overlap. */
memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
memcpy (ctx->buffer,
&((char *) ctx->buffer)[(left_over + add) & ~63],
ctx->buflen);
}
@ -382,13 +375,13 @@ sha256_process_bytes (const void *buffer, size_t len, struct sha256_ctx *ctx)
{
size_t left_over = ctx->buflen;
memcpy (&ctx->buffer[left_over], buffer, len);
memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
left_over += len;
if (left_over >= 64)
{
sha256_process_block (ctx->buffer, 64, ctx);
left_over -= 64;
memcpy (ctx->buffer, &ctx->buffer[64], left_over);
memcpy (ctx->buffer, &ctx->buffer[16], left_over);
}
ctx->buflen = left_over;
}
@ -474,7 +467,7 @@ sha256_process_block (const void *buffer, size_t len, struct sha256_ctx *ctx)
/* FIXME: see sha1.c for a better implementation. */
for (t = 0; t < 16; t++)
{
x[t] = NOTSWAP (*words);
x[t] = SWAP (*words);
words++;
}

49
lib/sha512.c
View File

@ -34,28 +34,22 @@
# include "unlocked-io.h"
#endif
/*
Not-swap is a macro that does an endian swap on architectures that are
big-endian, as SHA512 needs some data in a little-endian format
*/
#ifdef WORDS_BIGENDIAN
# define NOTSWAP(n) (n)
# define SWAP(n) (n)
#else
# define NOTSWAP(n) \
# define SWAP(n) \
(((n) << 56) | (((n) & 0xff00) << 40) | (((n) & 0xff0000UL) << 24) \
| (((n) & 0xff000000UL) << 8) | (((n) >> 8) & 0xff000000UL) \
| (((n) >> 24) & 0xff0000UL) | (((n) >> 40) & 0xff00UL) | ((n) >> 56))
| (((n) & 0xff000000UL) << 8) | (((n) >> 8) & 0xff000000UL) \
| (((n) >> 24) & 0xff0000UL) | (((n) >> 40) & 0xff00UL) | ((n) >> 56))
#endif
#define BLOCKSIZE 4096
/* Ensure that BLOCKSIZE is a multiple of 128. */
#if BLOCKSIZE % 128 != 0
# error "invalid BLOCKSIZE"
#endif
/* This array contains the bytes used to pad the buffer to the next
64-byte boundary. */
128-byte boundary. */
static const unsigned char fillbuf[128] = { 0x80, 0 /* , 0, 0, ... */ };
@ -106,8 +100,8 @@ sha512_read_ctx (const struct sha512_ctx *ctx, void *resbuf)
{
int i;
for ( i=0 ; i<8 ; i++ )
((uint64_t *) resbuf)[i] = NOTSWAP (ctx->state[i]);
for (i = 0; i < 8; i++)
((uint64_t *) resbuf)[i] = SWAP (ctx->state[i]);
return resbuf;
}
@ -117,8 +111,8 @@ sha384_read_ctx (const struct sha512_ctx *ctx, void *resbuf)
{
int i;
for ( i=0 ; i<6 ; i++ )
((uint64_t *) resbuf)[i] = NOTSWAP (ctx->state[i]);
for (i = 0; i < 6; i++)
((uint64_t *) resbuf)[i] = SWAP (ctx->state[i]);
return resbuf;
}
@ -133,23 +127,21 @@ sha512_conclude_ctx (struct sha512_ctx *ctx)
{
/* Take yet unprocessed bytes into account. */
uint64_t bytes = ctx->buflen;
size_t pad;
size_t size = (bytes < 112) ? 128 / 8 : 128 * 2 / 8;
/* Now count remaining bytes. */
ctx->total[0] += bytes;
if (ctx->total[0] < bytes)
++ctx->total[1];
pad = bytes >= 112 ? 128 + 112 - bytes : 112 - bytes;
memcpy (&ctx->buffer[bytes], fillbuf, pad);
/* Put the 64-bit file length in *bits* at the end of the buffer. */
*(uint64_t *) &ctx->buffer[bytes + pad + 8] = NOTSWAP (ctx->total[0] << 3);
*(uint64_t *) &ctx->buffer[bytes + pad] = NOTSWAP ((ctx->total[1] << 3) |
(ctx->total[0] >> 61));
ctx->buffer[size - 2] = SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 61));
ctx->buffer[size - 1] = SWAP (ctx->total[0] << 3);
memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 8 - bytes);
/* Process last bytes. */
sha512_process_block (ctx->buffer, bytes + pad + 16, ctx);
sha512_process_block (ctx->buffer, size * 8, ctx);
}
void *
@ -340,7 +332,7 @@ sha512_process_bytes (const void *buffer, size_t len, struct sha512_ctx *ctx)
size_t left_over = ctx->buflen;
size_t add = 256 - left_over > len ? len : 256 - left_over;
memcpy (&ctx->buffer[left_over], buffer, add);
memcpy (&((char *) ctx->buffer)[left_over], buffer, add);
ctx->buflen += add;
if (ctx->buflen > 128)
@ -349,7 +341,8 @@ sha512_process_bytes (const void *buffer, size_t len, struct sha512_ctx *ctx)
ctx->buflen &= 127;
/* The regions in the following copy operation cannot overlap. */
memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~127],
memcpy (ctx->buffer,
&((char *) ctx->buffer)[(left_over + add) & ~127],
ctx->buflen);
}
@ -384,13 +377,13 @@ sha512_process_bytes (const void *buffer, size_t len, struct sha512_ctx *ctx)
{
size_t left_over = ctx->buflen;
memcpy (&ctx->buffer[left_over], buffer, len);
memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
left_over += len;
if (left_over >= 128)
{
sha512_process_block (ctx->buffer, 128, ctx);
left_over -= 128;
memcpy (ctx->buffer, &ctx->buffer[128], left_over);
memcpy (ctx->buffer, &ctx->buffer[16], left_over);
}
ctx->buflen = left_over;
}
@ -469,7 +462,7 @@ sha512_process_block (const void *buffer, size_t len, struct sha512_ctx *ctx)
/* FIXME: see sha1.c for a better implementation. */
for (t = 0; t < 16; t++)
{
x[t] = NOTSWAP (*words);
x[t] = SWAP (*words);
words++;
}