changeset 187:c983a0af6d4e

Add sha1sum. (No -c mode yet.) Slight tweaks to loopfiles() too.
author Rob Landley <rob@landley.net>
date Thu, 29 Nov 2007 18:32:20 -0600
parents 25447caf1b4b
children 6a12feedd893
files lib/lib.c toys/Config.in toys/catv.c toys/sha1.c toys/sha1sum.c toys/toylist.h
diffstat 6 files changed, 179 insertions(+), 192 deletions(-) [+]
line wrap: on
line diff
--- a/lib/lib.c	Thu Nov 29 18:14:37 2007 -0600
+++ b/lib/lib.c	Thu Nov 29 18:32:20 2007 -0600
@@ -554,7 +554,7 @@
 	int fd;
 
 	// If no arguments, read from stdin.
-	if (!*argv) function(0, *argv);
+	if (!*argv) function(0, "-");
 	else do {
 		// Filename "-" means read from stdin.
 		// Inability to open a file prints a warning, but doesn't exit.
--- a/toys/Config.in	Thu Nov 29 18:14:37 2007 -0600
+++ b/toys/Config.in	Thu Nov 29 18:32:20 2007 -0600
@@ -269,6 +269,14 @@
 
 	  -f	Show final location, including normal files and multiple symlinks.
 
+config SHA1SUM
+	bool "sleep"
+	default y
+	help
+	  usage: sha1sum [file...]
+
+	  Calculate sha1 hash of files (or stdin).
+
 config SLEEP
 	bool "sleep"
 	default y
--- a/toys/catv.c	Thu Nov 29 18:14:37 2007 -0600
+++ b/toys/catv.c	Thu Nov 29 18:32:20 2007 -0600
@@ -12,7 +12,7 @@
 
 // Callback function for loopfiles()
 
-void do_catv(int fd, char *name)
+static void do_catv(int fd, char *name)
 {
 	for(;;) {
 		int i, len;
--- a/toys/sha1.c	Thu Nov 29 18:14:37 2007 -0600
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,190 +0,0 @@
-/*
- * Based on the public domain SHA-1 in C by Steve Reid <steve@edmweb.com>
- * from http://www.mirrors.wiretapped.net/security/cryptography/hashes/sha1/
- */
-
-/* #define LITTLE_ENDIAN * This should be #define'd if true. */
-/* #define SHA1HANDSOFF * Copies data before messing with it. */
-#define	LITTLE_ENDIAN
-
-#include <stdio.h>
-#include <string.h>
-#include <inttypes.h>
-
-struct sha1 {
-	uint32_t state[5];
-	uint32_t oldstate[5];
-	uint64_t count;
-	union {
-		unsigned char c[64];
-		uint32_t i[16];
-	} buffer;
-};
-
-void sha1_init(struct sha1 *this);
-void sha1_transform(struct sha1 *this);
-void sha1_update(struct sha1 *this, unsigned char *data, unsigned int len);
-void sha1_final(struct sha1 *this, unsigned char digest[20]);
-
-#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
-
-/* blk0() and blk() perform the initial expand. */
-/* I got the idea of expanding during the round function from SSLeay */
-#ifdef LITTLE_ENDIAN
-#define blk0(i) (block[i] = (rol(block[i],24)&0xFF00FF00) \
-	|(rol(block[i],8)&0x00FF00FF))
-#else
-#define blk0(i) block[i]
-#endif
-#define blk(i) (block[i&15] = rol(block[(i+13)&15]^block[(i+8)&15] \
-	^block[(i+2)&15]^block[i&15],1))
-
-static const uint32_t rconsts[]={0x5A827999,0x6ED9EBA1,0x8F1BBCDC,0xCA62C1D6};
-
-void printy(unsigned char *this)
-{
-	int i;
-
-	for (i = 0; i < 20; i++) printf("%02x", this[i]);
-	xputc('\n');
-}
-
-/* Hash a single 512-bit block. This is the core of the algorithm. */
-
-void sha1_transform(struct sha1 *this)
-{
-	int i, j, k, count;
-	uint32_t *block = this->buffer.i;
-	uint32_t *rot[5], *temp;
-
-	/* Copy context->state[] to working vars */
-	for (i=0; i<5; i++) {
-		this->oldstate[i] = this->state[i];
-		rot[i] = this->state + i;
-	}
-	/* 4 rounds of 20 operations each. */
-	for (i=count=0; i<4; i++) {
-		for (j=0; j<20; j++) {
-			uint32_t work;
-
-			work = *rot[2] ^ *rot[3];
-			if (!i) work = (work & *rot[1]) ^ *rot[3];
-			else {
-				if (i==2)
-					work = ((*rot[1]|*rot[2])&*rot[3])|(*rot[1]&*rot[2]);
-				else work ^= *rot[1];
-			}
-			if (!i && j<16) work += blk0(count);
-			else work += blk(count);
-			*rot[4] += work + rol(*rot[0],5) + rconsts[i];
-			*rot[1] = rol(*rot[1],30);
-
-			// Rotate by one for next time.
-			temp = rot[4];
-			for (k=4; k; k--) rot[k] = rot[k-1];
-			*rot = temp;
-			count++;
-		}
-	}
-	/* Add the previous values of state[] */
-	for (i=0; i<5; i++) this->state[i] += this->oldstate[i];
-}
-
-
-/* SHA1Init - Initialize new context */
-
-void sha1_init(struct sha1 *this)
-{
-	/* SHA1 initialization constants */
-	this->state[0] = 0x67452301;
-	this->state[1] = 0xEFCDAB89;
-	this->state[2] = 0x98BADCFE;
-	this->state[3] = 0x10325476;
-	this->state[4] = 0xC3D2E1F0;
-	this->count = 0;
-}
-
-/* Run your data through this function. */
-
-void sha1_update(struct sha1 *this, unsigned char *data, unsigned int len)
-{
-	unsigned int i, j;
-
-	j = this->count & 63;
-	this->count += len;
-
-	// Enough data to process a frame?
-	if ((j + len) > 63) {
-		i = 64-j;
-		memcpy(this->buffer.c + j, data, i);
-		sha1_transform(this);
-		for ( ; i + 63 < len; i += 64) {
-			memcpy(this->buffer.c, data + i, 64);
-			sha1_transform(this);
-		}
-		j = 0;
-	} else i = 0;
-	// Grab remaining chunk
-	memcpy(this->buffer.c + j, data + i, len - i);
-}
-
-/* Add padding and return the message digest. */
-
-void sha1_final(struct sha1 *this, unsigned char digest[20])
-{
-	uint64_t count = this->count << 3;
-	unsigned int i;
-	unsigned char buf;
-
-	// End the message by appending a "1" bit to the data, ending with the
-	// message size (in bits, big endian), and adding enough zero bits in
-	// between to pad to the end of the next 64-byte frame.  Since our input
-	// up to now has been in whole bytes, we can deal with bytes here too.
-
-	buf = 0x80;
-	do {
-		sha1_update(this, &buf, 1);
-		buf = 0;
-	} while ((this->count & 63) != 56);
-	for (i = 0; i < 8; i++)
-	  this->buffer.c[56+i] = count >> (8*(7-i));
-	sha1_transform(this);
-
-	for (i = 0; i < 20; i++) {
-		digest[i] = (unsigned char)
-		 ((this->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
-	}
-	/* Wipe variables */
-	memset(this, 0, sizeof(struct sha1));
-}
-
-
-/*************************************************************/
-
-
-int main(int argc, char** argv)
-{
-	int i, j;
-	struct sha1 this;
-	unsigned char digest[20], buffer[16384];
-	FILE* file;
-
-	if (argc < 2) {
-		file = stdin;
-	}
-	else {
-		if (!(file = fopen(argv[1], "rb"))) {
-			fputs("Unable to open file.", stderr);
-			exit(-1);
-		}
-	}
-	sha1_init(&this);
-	while (!feof(file)) {  /* note: what if ferror(file) */
-		i = fread(buffer, 1, 16384, file);
-		sha1_update(&this, buffer, i);
-	}
-	sha1_final(&this, digest);
-	fclose(file);
-	printy(digest);
-	exit(0);
-}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/toys/sha1sum.c	Thu Nov 29 18:32:20 2007 -0600
@@ -0,0 +1,168 @@
+/*
+ * Copyright 2007 Rob Landley <rob@landley.net>
+ *
+ * Based on the public domain SHA-1 in C by Steve Reid <steve@edmweb.com>
+ * from http://www.mirrors.wiretapped.net/security/cryptography/hashes/sha1/
+ */
+
+#include <toys.h>
+
+struct sha1 {
+	uint32_t state[5];
+	uint32_t oldstate[5];
+	uint64_t count;
+	union {
+		unsigned char c[64];
+		uint32_t i[16];
+	} buffer;
+};
+
+void sha1_init(struct sha1 *this);
+void sha1_transform(struct sha1 *this);
+void sha1_update(struct sha1 *this, char *data, unsigned int len);
+void sha1_final(struct sha1 *this, char digest[20]);
+
+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+
+/* blk0() and blk() perform the initial expand. */
+/* The idea of expanding during the round function comes from SSLeay */
+#if 1
+#define blk0(i) (block[i] = (rol(block[i],24)&0xFF00FF00) \
+	|(rol(block[i],8)&0x00FF00FF))
+#else	// big endian?
+#define blk0(i) block[i]
+#endif
+#define blk(i) (block[i&15] = rol(block[(i+13)&15]^block[(i+8)&15] \
+	^block[(i+2)&15]^block[i&15],1))
+
+static const uint32_t rconsts[]={0x5A827999,0x6ED9EBA1,0x8F1BBCDC,0xCA62C1D6};
+
+/* Hash a single 512-bit block. This is the core of the algorithm. */
+
+void sha1_transform(struct sha1 *this)
+{
+	int i, j, k, count;
+	uint32_t *block = this->buffer.i;
+	uint32_t *rot[5], *temp;
+
+	/* Copy context->state[] to working vars */
+	for (i=0; i<5; i++) {
+		this->oldstate[i] = this->state[i];
+		rot[i] = this->state + i;
+	}
+	/* 4 rounds of 20 operations each. */
+	for (i=count=0; i<4; i++) {
+		for (j=0; j<20; j++) {
+			uint32_t work;
+
+			work = *rot[2] ^ *rot[3];
+			if (!i) work = (work & *rot[1]) ^ *rot[3];
+			else {
+				if (i==2)
+					work = ((*rot[1]|*rot[2])&*rot[3])|(*rot[1]&*rot[2]);
+				else work ^= *rot[1];
+			}
+			if (!i && j<16) work += blk0(count);
+			else work += blk(count);
+			*rot[4] += work + rol(*rot[0],5) + rconsts[i];
+			*rot[1] = rol(*rot[1],30);
+
+			// Rotate by one for next time.
+			temp = rot[4];
+			for (k=4; k; k--) rot[k] = rot[k-1];
+			*rot = temp;
+			count++;
+		}
+	}
+	/* Add the previous values of state[] */
+	for (i=0; i<5; i++) this->state[i] += this->oldstate[i];
+}
+
+
+/* SHA1Init - Initialize new context */
+
+void sha1_init(struct sha1 *this)
+{
+	/* SHA1 initialization constants */
+	this->state[0] = 0x67452301;
+	this->state[1] = 0xEFCDAB89;
+	this->state[2] = 0x98BADCFE;
+	this->state[3] = 0x10325476;
+	this->state[4] = 0xC3D2E1F0;
+	this->count = 0;
+}
+
+/* Run your data through this function. */
+
+void sha1_update(struct sha1 *this, char *data, unsigned int len)
+{
+	unsigned int i, j;
+
+	j = this->count & 63;
+	this->count += len;
+
+	// Enough data to process a frame?
+	if ((j + len) > 63) {
+		i = 64-j;
+		memcpy(this->buffer.c + j, data, i);
+		sha1_transform(this);
+		for ( ; i + 63 < len; i += 64) {
+			memcpy(this->buffer.c, data + i, 64);
+			sha1_transform(this);
+		}
+		j = 0;
+	} else i = 0;
+	// Grab remaining chunk
+	memcpy(this->buffer.c + j, data + i, len - i);
+}
+
+/* Add padding and return the message digest. */
+
+void sha1_final(struct sha1 *this, char digest[20])
+{
+	uint64_t count = this->count << 3;
+	unsigned int i;
+	char buf;
+
+	// End the message by appending a "1" bit to the data, ending with the
+	// message size (in bits, big endian), and adding enough zero bits in
+	// between to pad to the end of the next 64-byte frame.  Since our input
+	// up to now has been in whole bytes, we can deal with bytes here too.
+
+	buf = 0x80;
+	do {
+		sha1_update(this, &buf, 1);
+		buf = 0;
+	} while ((this->count & 63) != 56);
+	for (i = 0; i < 8; i++)
+	  this->buffer.c[56+i] = count >> (8*(7-i));
+	sha1_transform(this);
+
+	for (i = 0; i < 20; i++)
+		digest[i] = this->state[i>>2] >> ((3-(i & 3)) * 8);
+	/* Wipe variables */
+	memset(this, 0, sizeof(struct sha1));
+}
+
+// Callback for loopfiles()
+
+static void do_sha1(int fd, char *name)
+{
+	struct sha1 this;
+	int len;
+
+	sha1_init(&this);
+	for (;;) {
+		len = read(fd, toybuf, sizeof(toybuf));
+		if (len<1) break;
+		sha1_update(&this, toybuf, len);
+	}
+	sha1_final(&this, toybuf);
+	for (len = 0; len < 20; len++) printf("%02x", toybuf[len]);
+	printf("  %s\n", name);
+}
+
+void sha1sum_main(void)
+{
+	loopfiles(toys.optargs, do_sha1);
+}
--- a/toys/toylist.h	Thu Nov 29 18:14:37 2007 -0600
+++ b/toys/toylist.h	Thu Nov 29 18:32:20 2007 -0600
@@ -124,6 +124,7 @@
 USE_PWD(NEWTOY(pwd, NULL, TOYFLAG_BIN))
 USE_READLINK(NEWTOY(readlink, "<1f", TOYFLAG_BIN))
 USE_TOYSH(OLDTOY(sh, toysh, "c:i", TOYFLAG_BIN))
+USE_SHA1SUM(NEWTOY(sha1sum, NULL, TOYFLAG_USR|TOYFLAG_BIN))
 USE_SLEEP(NEWTOY(sleep, "<1", TOYFLAG_BIN))
 USE_SYNC(NEWTOY(sync, NULL, TOYFLAG_BIN))
 USE_TOUCH(NEWTOY(touch, "l#t:r:mca", TOYFLAG_BIN))