Move sources to src and build objs in obj.

src/Serializer.cpp

@@ -0,0 +1,235 @@
+#include "Serializer.h"
+#include "key.h"
+#include <cassert>
+#include <openssl/ripemd.h>
+#include <openssl/sha.h>
+
+int Serializer::add16(uint16 i)
+{
+	int ret=mData.size();
+	mData.push_back((unsigned char)(i>>8));
+	mData.push_back((unsigned char)(i&0xff));
+	return ret;
+}
+
+int Serializer::add32(uint32 i)
+{
+	int ret=mData.size();
+	mData.push_back((unsigned char)(i>>24));
+	mData.push_back((unsigned char)((i>>16)&0xff));
+	mData.push_back((unsigned char)((i>>8)&0xff));
+	mData.push_back((unsigned char)(i&0xff));
+	return ret;
+}
+
+int Serializer::add64(uint64 i)
+{
+	int ret=mData.size();
+	mData.push_back((unsigned char)(i>>56));
+	mData.push_back((unsigned char)((i>>48)&0xff));
+	mData.push_back((unsigned char)((i>>40)&0xff));
+	mData.push_back((unsigned char)((i>>32)&0xff));
+	mData.push_back((unsigned char)((i>>24)&0xff));
+	mData.push_back((unsigned char)((i>>16)&0xff));
+	mData.push_back((unsigned char)((i>>8)&0xff));
+	mData.push_back((unsigned char)(i&0xff));
+	return ret;
+}
+
+int Serializer::add160(const uint160& i)
+{
+	int ret=mData.size();
+	mData.insert(mData.end(), i.begin(), i.end());
+	return ret;
+}
+
+int Serializer::add256(const uint256& i)
+{
+	int ret=mData.size();
+	mData.insert(mData.end(), i.begin(), i.end());
+	return ret;
+}
+
+int Serializer::addRaw(const std::vector<unsigned char> &vector)
+{
+	int ret=mData.size();
+	mData.insert(mData.end(), vector.begin(), vector.end());
+	return ret;
+}
+
+int Serializer::addRaw(const void *ptr, int len)
+{
+	int ret=mData.size();
+	mData.insert(mData.end(), (const char *) ptr, ((const char *)ptr)+len);
+	return ret;
+}
+
+bool Serializer::get16(uint16& o, int offset) const
+{
+	if((offset+2)>mData.size()) return false;
+	o=mData.at(offset++);
+	o<<=8; o|=mData.at(offset);
+	return true;
+}
+
+bool Serializer::get32(uint32& o, int offset) const
+{
+	if((offset+4)>mData.size()) return false;
+	o=mData.at(offset++);
+	o<<=8; o|=mData.at(offset++); o<<=8; o|=mData.at(offset++);
+	o<<=8; o|=mData.at(offset);
+	return true;
+}
+
+bool Serializer::get64(uint64& o, int offset) const
+{
+	if((offset+8)>mData.size()) return false;
+	o=mData.at(offset++);
+	o<<=8; o|=mData.at(offset++); o<<=8; o|=mData.at(offset++);
+	o<<=8; o|=mData.at(offset++); o<<=8; o|=mData.at(offset++);
+	o<<=8; o|=mData.at(offset++); o<<=8; o|=mData.at(offset++);
+	o<<=8; o|=mData.at(offset);
+	return true;
+}
+
+bool Serializer::get160(uint160& o, int offset) const
+{
+	if((offset+20)>mData.size()) return false;
+	memcpy(&o, &(mData.front())+offset, 20);
+	return true;
+}
+
+bool Serializer::get256(uint256& o, int offset) const
+{
+	if((offset+32)>mData.size()) return false;
+	memcpy(&o, &(mData.front())+offset, 32);
+	return true;
+}
+
+uint256 Serializer::get256(int offset) const
+{
+	uint256 ret;
+	if((offset+32)>mData.size()) return ret;
+	memcpy(&ret, &(mData.front())+offset, 32);
+	return ret;
+}
+
+int Serializer::add8(unsigned char byte)
+{
+	int ret=mData.size();
+	mData.push_back(byte);
+	return ret;
+}
+
+bool Serializer::get8(int& byte, int offset) const
+{
+	if(offset>=mData.size()) return false;
+	byte=mData[offset];
+	return true;
+}
+
+bool Serializer::chop(int bytes)
+{
+	if(bytes>mData.size()) return false;
+	mData.resize(mData.size()-bytes);
+	return true;
+}
+
+int Serializer::removeLastByte()
+{
+	int size=mData.size()-1;
+	if(size<0)
+	{
+		assert(false);
+		return -1;
+	}
+	int ret=mData[size];
+	mData.resize(size);
+	return ret;
+}
+
+bool Serializer::getRaw(std::vector<unsigned char>& o, int offset, int length) const
+{
+	if((offset+length)>mData.size()) return false;
+	o.assign(mData.begin()+offset, mData.begin()+offset+length);
+	return true;
+}
+
+std::vector<unsigned char> Serializer::getRaw(int offset, int length) const
+{
+	std::vector<unsigned char> o;
+	if((offset+length)>mData.size()) return o;
+	o.assign(mData.begin()+offset, mData.begin()+offset+length);
+	return o;
+}
+
+uint160 Serializer::getRIPEMD160(int size) const
+{
+	uint160 ret;
+	if((size<0)||(size>mData.size())) size=mData.size();
+	RIPEMD160(&(mData.front()), size, (unsigned char *) &ret);
+	return ret;
+}
+
+uint256 Serializer::getSHA256(int size) const
+{
+	uint256 ret;
+	if((size<0)||(size>mData.size())) size=mData.size();
+	SHA256(&(mData.front()), size, (unsigned char *) &ret);
+	return ret;
+}
+
+uint256 Serializer::getSHA512Half(int size) const
+{
+	return getSHA512Half(mData, size);
+}
+
+uint256 Serializer::getSHA512Half(const std::vector<unsigned char>& data, int size)
+{
+	uint256 j[2];
+	if((size<0)||(size>data.size())) size=data.size();
+	SHA512(&(data.front()), size, (unsigned char *) j);
+	return j[0];
+}
+
+uint256 Serializer::getSHA512Half(const unsigned char *data, int len)
+{
+	uint256 j[2];
+	SHA512(data, len, (unsigned char *) j);
+	return j[0];
+}
+
+bool Serializer::checkSignature(int pubkeyOffset, int signatureOffset) const
+{
+	std::vector<unsigned char> pubkey, signature;
+	if(!getRaw(pubkey, pubkeyOffset, 65)) return false;
+	if(!getRaw(signature, signatureOffset, 72)) return false;
+
+	CKey pubCKey;
+	if(!pubCKey.SetPubKey(pubkey)) return false;
+	return pubCKey.Verify(getSHA512Half(signatureOffset), signature);	
+}
+
+bool Serializer::checkSignature(const std::vector<unsigned char> &signature, CKey& key) const
+{
+	return key.Verify(getSHA512Half(), signature);	
+}
+
+bool Serializer::makeSignature(std::vector<unsigned char> &signature, CKey& key) const
+{
+	return key.Sign(getSHA512Half(), signature);
+}
+
+bool Serializer::addSignature(CKey& key)
+{
+	std::vector<unsigned char> signature;
+	if(!key.Sign(getSHA512Half(), signature)) return false;
+	assert(signature.size()==72);
+	addRaw(signature);
+	return true;
+}
+
+void Serializer::TestSerializer()
+{
+	Serializer s(64);
+}