Added an sha1 class...

author: Mike Buland <eichlan@xagasoft.com> 2006-10-31 05:41:13 +0000
committer: Mike Buland <eichlan@xagasoft.com> 2006-10-31 05:41:13 +0000
commit: a67fdaa1ef1e3a5eea88d19e327c05330998e8aa (patch)
tree: 71897d87312461153c893993ed0582aaa08a9399 /src/sha1.cpp
parent: 58cccdbe67f6e1966116b3d2f4c83d77863daadc (diff)
download: libbu++-a67fdaa1ef1e3a5eea88d19e327c05330998e8aa.tar.gz
libbu++-a67fdaa1ef1e3a5eea88d19e327c05330998e8aa.tar.bz2
libbu++-a67fdaa1ef1e3a5eea88d19e327c05330998e8aa.tar.xz
libbu++-a67fdaa1ef1e3a5eea88d19e327c05330998e8aa.zip
1 files changed, 161 insertions, 0 deletions
diff --git a/src/sha1.cpp b/src/sha1.cpp
new file mode 100644
index 0000000..8270c3b
--- /dev/null
+++ b/src/sha1.cpp
@@ -0,0 +1,161 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "sha1.h"
+Sha1::Sha1() :
+        H0( 0x67452301 ),
+        H1( 0xefcdab89 ),
+        H2( 0x98badcfe ),
+        H3( 0x10325476 ),
+        H4( 0xc3d2e1f0 ),
+        unprocessedBytes( 0 ),
+        size( 0 )
+{
+}
+Sha1::~Sha1()
+{
+}
+void Sha1::process()
+{
+        int t;
+        uint32_t a, b, c, d, e, K, f, W[80];
+        // starting values
+        a = H0;
+        b = H1;
+        c = H2;
+        d = H3;
+        e = H4;
+        // copy and expand the message block
+        for( t = 0; t < 16; t++ ) W[t] = (bytes[t*4] << 24)
+                                                                        +(bytes[t*4 + 1] << 16)
+                                                                        +(bytes[t*4 + 2] << 8)
+                                                                        + bytes[t*4 + 3];
+        for(; t< 80; t++ ) W[t] = lrot( W[t-3]^W[t-8]^W[t-14]^W[t-16], 1 );
+        
+        /* main loop */
+        uint32_t temp;
+        for( t = 0; t < 80; t++ )
+        {
+                if( t < 20 ) {
+                        K = 0x5a827999;
+                        f = (b & c) | ((~b) & d);
+                } else if( t < 40 ) {
+                        K = 0x6ed9eba1;
+                        f = b ^ c ^ d;
+                } else if( t < 60 ) {
+                        K = 0x8f1bbcdc;
+                        f = (b & c) | (b & d) | (c & d);
+                } else {
+                        K = 0xca62c1d6;
+                        f = b ^ c ^ d;
+                }
+                temp = lrot(a,5) + f + e + W[t] + K;
+                e = d;
+                d = c;
+                c = lrot(b,30);
+                b = a;
+                a = temp;
+                //printf( "t=%d %08x %08x %08x %08x %08x\n",t,a,b,c,d,e );
+        }
+        /* add variables */
+        H0 += a;
+        H1 += b;
+        H2 += c;
+        H3 += d;
+        H4 += e;
+        //printf( "Current: %08x %08x %08x %08x %08x\n",H0,H1,H2,H3,H4 );
+        /* all bytes have been processed */
+        unprocessedBytes = 0;
+}
+void Sha1::update( const char* data, int num )
+{
+        // add these bytes to the running total
+        size += num;
+        // repeat until all data is processed
+        while( num > 0 )
+        {
+                // number of bytes required to complete block
+                int needed = 64 - unprocessedBytes;
+                // number of bytes to copy (use smaller of two)
+                int toCopy = (num < needed) ? num : needed;
+                // Copy the bytes
+                memcpy( bytes + unprocessedBytes, data, toCopy );
+                // Bytes have been copied
+                num -= toCopy;
+                data += toCopy;
+                unprocessedBytes += toCopy;
+                
+                // there is a full block
+                if( unprocessedBytes == 64 ) process();
+        }
+}
+unsigned char* Sha1::getDigest()
+{
+        // save the message size
+        uint32_t totalBitsL = size << 3;
+        uint32_t totalBitsH = size >> 29;
+        // add 0x80 to the message
+        update( "\x80", 1 );
+        
+        unsigned char footer[64] = {
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        // block has no room for 8-byte filesize, so finish it
+        if( unprocessedBytes > 56 )
+                update( (char*)footer, 64 - unprocessedBytes);
+        // how many zeros do we need
+        int neededZeros = 56 - unprocessedBytes;
+        // store file size (in bits) in big-endian format
+        toBigEndian( totalBitsH, footer + neededZeros );
+        toBigEndian( totalBitsL, footer + neededZeros + 4 );
+        // finish the final block
+        update( (char*)footer, neededZeros + 8 );
+        // allocate memory for the digest bytes
+        unsigned char* digest = new unsigned char[20];
+        // copy the digest bytes
+        toBigEndian( H0, digest );
+        toBigEndian( H1, digest + 4 );
+        toBigEndian( H2, digest + 8 );
+        toBigEndian( H3, digest + 12 );
+        toBigEndian( H4, digest + 16 );
+        // return the digest
+        return digest;
+}
+uint32_t Sha1::lrot( uint32_t x, int bits )
+{
+        return (x<<bits) | (x>>(32 - bits));
+};
+void Sha1::toBigEndian( uint32_t num, unsigned char* byte )
+{
+        byte[0] = (unsigned char)(num>>24);
+        byte[1] = (unsigned char)(num>>16);
+        byte[2] = (unsigned char)(num>>8);
+        byte[3] = (unsigned char)num;
+}
author	Mike Buland <eichlan@xagasoft.com>	2006-10-31 05:41:13 +0000
committer	Mike Buland <eichlan@xagasoft.com>	2006-10-31 05:41:13 +0000
commit	a67fdaa1ef1e3a5eea88d19e327c05330998e8aa (patch)
tree	71897d87312461153c893993ed0582aaa08a9399 /src/sha1.cpp
parent	58cccdbe67f6e1966116b3d2f4c83d77863daadc (diff)
download	libbu++-a67fdaa1ef1e3a5eea88d19e327c05330998e8aa.tar.gz libbu++-a67fdaa1ef1e3a5eea88d19e327c05330998e8aa.tar.bz2 libbu++-a67fdaa1ef1e3a5eea88d19e327c05330998e8aa.tar.xz libbu++-a67fdaa1ef1e3a5eea88d19e327c05330998e8aa.zip

diff --git a/src/sha1.cpp b/src/sha1.cpp new file mode 100644 index 0000000..8270c3b --- /dev/null +++ b/src/sha1.cpp
@@ -0,0 +1,161 @@
	1	#include <stdio.h>
	2	#include <string.h>
	3	#include <stdlib.h>
	4
	5	#include "sha1.h"
	6
	7	Sha1::Sha1() :
	8	H0( 0x67452301 ),
	9	H1( 0xefcdab89 ),
	10	H2( 0x98badcfe ),
	11	H3( 0x10325476 ),
	12	H4( 0xc3d2e1f0 ),
	13	unprocessedBytes( 0 ),
	14	size( 0 )
	15	{
	16	}
	17
	18	Sha1::~Sha1()
	19	{
	20	}
	21
	22	void Sha1::process()
	23	{
	24	int t;
	25	uint32_t a, b, c, d, e, K, f, W[80];
	26
	27	// starting values
	28	a = H0;
	29	b = H1;
	30	c = H2;
	31	d = H3;
	32	e = H4;
	33
	34	// copy and expand the message block
	35	for( t = 0; t < 16; t++ ) W[t] = (bytes[t*4] << 24)
	36	+(bytes[t*4 + 1] << 16)
	37	+(bytes[t*4 + 2] << 8)
	38	+ bytes[t*4 + 3];
	39	for(; t< 80; t++ ) W[t] = lrot( W[t-3]^W[t-8]^W[t-14]^W[t-16], 1 );
	40
	41	/* main loop */
	42	uint32_t temp;
	43	for( t = 0; t < 80; t++ )
	44	{
	45	if( t < 20 ) {
	46	K = 0x5a827999;
	47	f = (b & c) \| ((~b) & d);
	48	} else if( t < 40 ) {
	49	K = 0x6ed9eba1;
	50	f = b ^ c ^ d;
	51	} else if( t < 60 ) {
	52	K = 0x8f1bbcdc;
	53	f = (b & c) \| (b & d) \| (c & d);
	54	} else {
	55	K = 0xca62c1d6;
	56	f = b ^ c ^ d;
	57	}
	58	temp = lrot(a,5) + f + e + W[t] + K;
	59	e = d;
	60	d = c;
	61	c = lrot(b,30);
	62	b = a;
	63	a = temp;
	64	//printf( "t=%d %08x %08x %08x %08x %08x\n",t,a,b,c,d,e );
	65	}
	66
	67	/* add variables */
	68	H0 += a;
	69	H1 += b;
	70	H2 += c;
	71	H3 += d;
	72	H4 += e;
	73
	74	//printf( "Current: %08x %08x %08x %08x %08x\n",H0,H1,H2,H3,H4 );
	75	/* all bytes have been processed */
	76	unprocessedBytes = 0;
	77	}
	78
	79	void Sha1::update( const char* data, int num )
	80	{
	81	// add these bytes to the running total
	82	size += num;
	83
	84	// repeat until all data is processed
	85	while( num > 0 )
	86	{
	87	// number of bytes required to complete block
	88	int needed = 64 - unprocessedBytes;
	89
	90	// number of bytes to copy (use smaller of two)
	91	int toCopy = (num < needed) ? num : needed;
	92
	93	// Copy the bytes
	94	memcpy( bytes + unprocessedBytes, data, toCopy );
	95
	96	// Bytes have been copied
	97	num -= toCopy;
	98	data += toCopy;
	99	unprocessedBytes += toCopy;
	100
	101	// there is a full block
	102	if( unprocessedBytes == 64 ) process();
	103	}
	104	}
	105
	106	unsigned char* Sha1::getDigest()
	107	{
	108	// save the message size
	109	uint32_t totalBitsL = size << 3;
	110	uint32_t totalBitsH = size >> 29;
	111
	112	// add 0x80 to the message
	113	update( "\x80", 1 );
	114
	115	unsigned char footer[64] = {
	116	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	117	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	118	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	119	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
	120
	121	// block has no room for 8-byte filesize, so finish it
	122	if( unprocessedBytes > 56 )
	123	update( (char*)footer, 64 - unprocessedBytes);
	124
	125	// how many zeros do we need
	126	int neededZeros = 56 - unprocessedBytes;
	127
	128	// store file size (in bits) in big-endian format
	129	toBigEndian( totalBitsH, footer + neededZeros );
	130	toBigEndian( totalBitsL, footer + neededZeros + 4 );
	131
	132	// finish the final block
	133	update( (char*)footer, neededZeros + 8 );
	134
	135	// allocate memory for the digest bytes
	136	unsigned char* digest = new unsigned char[20];
	137
	138	// copy the digest bytes
	139	toBigEndian( H0, digest );
	140	toBigEndian( H1, digest + 4 );
	141	toBigEndian( H2, digest + 8 );
	142	toBigEndian( H3, digest + 12 );
	143	toBigEndian( H4, digest + 16 );
	144
	145	// return the digest
	146	return digest;
	147	}
	148
	149	uint32_t Sha1::lrot( uint32_t x, int bits )
	150	{
	151	return (x<<bits) \| (x>>(32 - bits));
	152	};
	153
	154	void Sha1::toBigEndian( uint32_t num, unsigned char* byte )
	155	{
	156	byte[0] = (unsigned char)(num>>24);
	157	byte[1] = (unsigned char)(num>>16);
	158	byte[2] = (unsigned char)(num>>8);
	159	byte[3] = (unsigned char)num;
	160	}
	161