Move sha1.hpp and base64.hpp to util/

src/util/CMakeLists.txt

@@ -1,8 +1,10 @@
 set(UTIL_SRCS
+	${CMAKE_CURRENT_SOURCE_DIR}/base64.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/directiontables.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/numeric.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/pointedthing.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/serialize.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/sha1.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/string.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/timetaker.cpp
 	PARENT_SCOPE)

src/util/base64.cpp

@@ -0,0 +1,131 @@
+/*
+base64.cpp and base64.h
+
+Copyright (C) 2004-2008 René Nyffenegger
+
+This source code is provided 'as-is', without any express or implied
+warranty. In no event will the author be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this source code must not be misrepresented; you must not
+   claim that you wrote the original source code. If you use this source code
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original source code.
+
+3. This notice may not be removed or altered from any source distribution.
+
+René Nyffenegger rene.nyffenegger@adp-gmbh.ch
+
+*/
+
+#include "base64.h"
+#include <iostream>
+
+static const std::string base64_chars =
+		"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+		"abcdefghijklmnopqrstuvwxyz"
+		"0123456789+/";
+
+
+static inline bool is_base64(unsigned char c) {
+	return (isalnum(c) || (c == '+') || (c == '/'));
+}
+
+bool base64_is_valid(std::string const& s)
+{
+	for(size_t i=0; i<s.size(); i++)
+		if(!is_base64(s[i])) return false;
+	return true;
+}
+
+std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
+	std::string ret;
+	int i = 0;
+	int j = 0;
+	unsigned char char_array_3[3];
+	unsigned char char_array_4[4];
+
+	while (in_len--) {
+		char_array_3[i++] = *(bytes_to_encode++);
+		if (i == 3) {
+			char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+			char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+			char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+			char_array_4[3] = char_array_3[2] & 0x3f;
+
+			for(i = 0; (i <4) ; i++)
+				ret += base64_chars[char_array_4[i]];
+			i = 0;
+		}
+	}
+
+	if (i)
+	{
+		for(j = i; j < 3; j++)
+			char_array_3[j] = '\0';
+
+		char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+		char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+		char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+		char_array_4[3] = char_array_3[2] & 0x3f;
+
+		for (j = 0; (j < i + 1); j++)
+			ret += base64_chars[char_array_4[j]];
+
+	// Don't pad it with =
+		/*while((i++ < 3))
+			ret += '=';*/
+
+	}
+
+	return ret;
+
+}
+
+std::string base64_decode(std::string const& encoded_string) {
+	int in_len = encoded_string.size();
+	int i = 0;
+	int j = 0;
+	int in_ = 0;
+	unsigned char char_array_4[4], char_array_3[3];
+	std::string ret;
+
+	while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
+		char_array_4[i++] = encoded_string[in_]; in_++;
+		if (i ==4) {
+			for (i = 0; i <4; i++)
+				char_array_4[i] = base64_chars.find(char_array_4[i]);
+
+			char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+			char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+			char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+			for (i = 0; (i < 3); i++)
+				ret += char_array_3[i];
+			i = 0;
+		}
+	}
+
+	if (i) {
+		for (j = i; j <4; j++)
+			char_array_4[j] = 0;
+
+		for (j = 0; j <4; j++)
+			char_array_4[j] = base64_chars.find(char_array_4[j]);
+
+		char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+		char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+		char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+		for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
+	}
+
+	return ret;
+}

src/util/base64.h

@@ -0,0 +1,10 @@
+#ifndef BASE64_HEADER
+#define BASE64_HEADER
+
+#include <string>
+
+bool base64_is_valid(std::string const& s);
+std::string base64_encode(unsigned char const* , unsigned int len);
+std::string base64_decode(std::string const& s);
+
+#endif // BASE64_HEADER

src/util/sha1.cpp

@@ -0,0 +1,207 @@
+/* sha1.cpp
+
+Copyright (c) 2005 Michael D. Leonhard
+
+http://tamale.net/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include "sha1.h"
+
+// print out memory in hexadecimal
+void SHA1::hexPrinter( unsigned char* c, int l )
+{
+	assert( c );
+	assert( l > 0 );
+	while( l > 0 )
+	{
+		printf( " %02x", *c );
+		l--;
+		c++;
+	}
+}
+
+// circular left bit rotation.  MSB wraps around to LSB
+Uint32 SHA1::lrot( Uint32 x, int bits )
+{
+	return (x<<bits) | (x>>(32 - bits));
+};
+
+// Save a 32-bit unsigned integer to memory, in big-endian order
+void SHA1::storeBigEndianUint32( unsigned char* byte, Uint32 num )
+{
+	assert( byte );
+	byte[0] = (unsigned char)(num>>24);
+	byte[1] = (unsigned char)(num>>16);
+	byte[2] = (unsigned char)(num>>8);
+	byte[3] = (unsigned char)num;
+}
+
+
+// Constructor *******************************************************
+SHA1::SHA1()
+{
+	// make sure that the data type is the right size
+	assert( sizeof( Uint32 ) * 5 == 20 );
+	
+	// initialize
+	H0 = 0x67452301;
+	H1 = 0xefcdab89;
+	H2 = 0x98badcfe;
+	H3 = 0x10325476;
+	H4 = 0xc3d2e1f0;
+	unprocessedBytes = 0;
+	size = 0;
+}
+
+// Destructor ********************************************************
+SHA1::~SHA1()
+{
+	// erase data
+	H0 = H1 = H2 = H3 = H4 = 0;
+	for( int c = 0; c < 64; c++ ) bytes[c] = 0;
+	unprocessedBytes = size = 0;
+}
+
+// process ***********************************************************
+void SHA1::process()
+{
+	assert( unprocessedBytes == 64 );
+	//printf( "process: " ); hexPrinter( bytes, 64 ); printf( "\n" );
+	int t;
+	Uint32 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 temp;
+	for( t = 0; t < 80; t++ )
+	{
+		if( t < 20 ) {
+			K = 0x5a827999;
+			f = (b & c) | ((b ^ 0xFFFFFFFF) & d);//TODO: try using ~
+		} 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;
+}
+
+// addBytes **********************************************************
+void SHA1::addBytes( const char* data, int num )
+{
+	assert( data );
+	assert( num >= 0 );
+	// 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;
+		assert( needed > 0 );
+		// 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();
+	}
+}
+
+// digest ************************************************************
+unsigned char* SHA1::getDigest()
+{
+	// save the message size
+	Uint32 totalBitsL = size << 3;
+	Uint32 totalBitsH = size >> 29;
+	// add 0x80 to the message
+	addBytes( "\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 )
+		addBytes( (char*)footer, 64 - unprocessedBytes);
+	assert( unprocessedBytes <= 56 );
+	// how many zeros do we need
+	int neededZeros = 56 - unprocessedBytes;
+	// store file size (in bits) in big-endian format
+	storeBigEndianUint32( footer + neededZeros    , totalBitsH );
+	storeBigEndianUint32( footer + neededZeros + 4, totalBitsL );
+	// finish the final block
+	addBytes( (char*)footer, neededZeros + 8 );
+	// allocate memory for the digest bytes
+	unsigned char* digest = (unsigned char*)malloc( 20 );
+	// copy the digest bytes
+	storeBigEndianUint32( digest, H0 );
+	storeBigEndianUint32( digest + 4, H1 );
+	storeBigEndianUint32( digest + 8, H2 );
+	storeBigEndianUint32( digest + 12, H3 );
+	storeBigEndianUint32( digest + 16, H4 );
+	// return the digest
+	return digest;
+}

src/util/sha1.h

@@ -0,0 +1,51 @@
+/* sha1.h
+
+Copyright (c) 2005 Michael D. Leonhard
+
+http://tamale.net/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+
+#ifndef SHA1_HEADER
+typedef unsigned int Uint32;
+
+class SHA1
+{
+	private:
+		// fields
+		Uint32 H0, H1, H2, H3, H4;
+		unsigned char bytes[64];
+		int unprocessedBytes;
+		Uint32 size;
+		void process();
+	public:
+		SHA1();
+		~SHA1();
+		void addBytes( const char* data, int num );
+		unsigned char* getDigest();
+		// utility methods
+		static Uint32 lrot( Uint32 x, int bits );
+		static void storeBigEndianUint32( unsigned char* byte, Uint32 num );
+		static void hexPrinter( unsigned char* c, int l );
+};
+
+#define SHA1_HEADER
+#endif

src/util/string.cpp

@@ -22,8 +22,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "numeric.h"
 #include "log.h"
 
-#include "../sha1.h"
-#include "../base64.h"
+#include "sha1.h"
+#include "base64.h"
 #include "../hex.h"
 #include "../porting.h"