[she] change api of Deserialize ; return read bytes if succeed else 0

7 files changed, 211 insertions, 80 deletions

diff --git a/include/mcl/ec.hpp b/include/mcl/ec.hpp
index 66ccffc..7054557 100644
--- a/include/mcl/ec.hpp
+++ b/include/mcl/ec.hpp
@@ -776,6 +776,52 @@ public:
 		std::istringstream is(str);
 		readStream(is, ioMode);
 	}
+	// return written bytes if sucess else 0
+	size_t serialize(void *buf, size_t maxBufSize) const
+	{
+		if (!isFixedSizeByteSeq()) return 0;
+		const size_t n = Fp::getByteSize();
+		if (maxBufSize < n) return 0;
+		if (isZero()) {
+			memset(buf, 0, n);
+		} else {
+			char *p = reinterpret_cast<char*>(buf);
+			EcT P(*this);
+			P.normalize();
+			if (P.x.serialize(p, maxBufSize) == 0) return 0;
+			if (P.y.isOdd()) {
+				p[n - 1] |= 0x80;
+			}
+		}
+		return n;
+	}
+	// return positive read bytes if sucess else 0
+	size_t deserialize(const void *buf, size_t bufSize)
+	{
+		// QQQ : remove duplicated code
+#ifdef MCL_EC_USE_AFFINE
+		inf_ = false;
+#else
+		z = 1;
+#endif
+		if (!isFixedSizeByteSeq()) return 0;
+		const size_t n = sizeof(Fp);
+		if (bufSize < n) return 0;
+		char p[n];
+		memcpy(p, buf, n);
+		if (fp::isZeroArray(p, n)) {
+			clear();
+			return n;
+		}
+		bool isYodd = (p[n - 1] >> 7) != 0;
+		p[n - 1] &= 0x7f;
+		if (x.deserialize(p, n) == 0) return 0;
+		getYfromX(y, x, isYodd);
+		if (verifyOrder_ && !isValidOrder()) {
+			return 0;
+		}
+		return n;
+	}
 	// deplicated
 	static void setCompressedExpression(bool compressedExpression = true)
 	{
diff --git a/include/mcl/fp.hpp b/include/mcl/fp.hpp
index ce040fd..c8f7231 100644
--- a/include/mcl/fp.hpp
+++ b/include/mcl/fp.hpp
@@ -223,6 +223,26 @@ public:
 		std::istringstream is(str);
 		readStream(is, ioMode);
 	}
+	// return written bytes if sucess else 0
+	size_t serialize(void *buf, size_t maxBufSize) const
+	{
+		const size_t n = getByteSize();
+		if (n > maxBufSize) return 0;
+		fp::Block b;
+		getBlock(b);
+		fp::copyUnitToByteAsLE(reinterpret_cast<uint8_t*>(buf), b.p, n);
+		return n;
+	}
+	// return positive read bytes if sucess else 0
+	size_t deserialize(const void *buf, size_t bufSize)
+	{
+		const size_t n = getByteSize();
+		if (bufSize < n) return 0;
+		fp::copyByteToUnitAsLE(v_, reinterpret_cast<const uint8_t*>(buf), n);
+		if (fp::isGreaterOrEqualArray(v_, op_.p, op_.N)) return 0;
+		toMont();
+		return n;
+	}
 	/*
 		throw exception if x >= p
 	*/
diff --git a/include/mcl/fp_tower.hpp b/include/mcl/fp_tower.hpp
index 5f6fc67..e31afec 100644
--- a/include/mcl/fp_tower.hpp
+++ b/include/mcl/fp_tower.hpp
@@ -10,6 +10,58 @@
 
 namespace mcl {
 
+namespace local {
+
+template<class T1, class T2>
+size_t serialize2(void *buf, size_t maxBufSize, const T1& p1, const T2& p2)
+{
+	char *p = reinterpret_cast<char*>(buf);
+	const size_t n1 = p1.serialize(p, maxBufSize);
+	if (n1 == 0) return 0;
+	p += n1; maxBufSize -= n1;
+	const size_t n2 = p2.serialize(p, maxBufSize);
+	if (n2 == 0) return 0;
+	return n1 + n2;
+}
+
+template<class T1, class T2, class T3>
+size_t serialize3(void *buf, size_t maxBufSize, const T1& p1, const T2& p2, const T3& p3)
+{
+	char *p = reinterpret_cast<char*>(buf);
+	const size_t n1 = serialize2(buf, maxBufSize, p1, p2);
+	if (n1 == 0) return 0;
+	p += n1; maxBufSize -= n1;
+	const size_t n2 = p3.serialize(p, maxBufSize);
+	if (n2 == 0) return 0;
+	return n1 + n2;
+}
+
+template<class T1, class T2>
+size_t deserialize2(T1& p1, T2& p2, const void *buf, size_t bufSize)
+{
+	const char *p = reinterpret_cast<const char*>(buf);
+	const size_t n1 = p1.deserialize(p, bufSize);
+	if (n1 == 0) return 0;
+	p += n1; bufSize -= n1;
+	const size_t n2 = p2.deserialize(p, bufSize);
+	if (n2 == 0) return 0;
+	return n1 + n2;
+}
+
+template<class T1, class T2, class T3>
+size_t deserialize3(T1& p1, T2& p2, T3& p3, const void *buf, size_t bufSize)
+{
+	const char *p = reinterpret_cast<const char*>(buf);
+	const size_t n1 = deserialize2(p1, p2, p, bufSize);
+	if (n1 == 0) return 0;
+	p += n1; bufSize -= n1;
+	const size_t n2 = p3.deserialize(p, bufSize);
+	if (n2 == 0) return 0;
+	return n1 + n2;
+}
+
+} // local
+
 template<class Fp>
 class FpDblT {
 	typedef fp::Unit Unit;
@@ -217,6 +269,16 @@ public:
 	{
 		return os << self.getStr(fp::detectIoMode(Fp::BaseFp::getIoMode(), os));
 	}
+	// return written bytes if sucess else 0
+	size_t serialize(void *buf, size_t maxBufSize) const
+	{
+		return local::serialize2(buf, maxBufSize, a, b);
+	}
+	// return positive read bytes if sucess else 0
+	size_t deserialize(const void *buf, size_t bufSize)
+	{
+		return local::deserialize2(a, b, buf, bufSize);
+	}
 	bool isZero() const { return a.isZero() && b.isZero(); }
 	bool isOne() const { return a.isOne() && b.isZero(); }
 	bool operator==(const Fp2T& rhs) const { return a == rhs.a && b == rhs.b; }
@@ -725,6 +787,16 @@ struct Fp6T : public fp::Operator<Fp6T<Fp> > {
 	{
 		return os << self.getStr(fp::detectIoMode(Fp::BaseFp::getIoMode(), os));
 	}
+	// return written bytes if sucess else 0
+	size_t serialize(void *buf, size_t maxBufSize) const
+	{
+		return local::serialize3(buf, maxBufSize, a, b, c);
+	}
+	// return positive read bytes if sucess else 0
+	size_t deserialize(const void *buf, size_t bufSize)
+	{
+		return local::deserialize3(a, b, c, buf, bufSize);
+	}
 	static void add(Fp6T& z, const Fp6T& x, const Fp6T& y)
 	{
 		Fp2::add(z.a, x.a, y.a);
@@ -1130,6 +1202,16 @@ struct Fp12T : public fp::Operator<Fp12T<Fp> > {
 	{
 		return os << self.getStr(fp::detectIoMode(Fp::BaseFp::getIoMode(), os));
 	}
+	// return written bytes if sucess else 0
+	size_t serialize(void *buf, size_t maxBufSize) const
+	{
+		return local::serialize2(buf, maxBufSize, a, b);
+	}
+	// return positive read bytes if sucess else 0
+	size_t deserialize(const void *buf, size_t bufSize)
+	{
+		return local::deserialize2(a, b, buf, bufSize);
+	}
 };
 
 /*
diff --git a/include/mcl/she.h b/include/mcl/she.h
index adfa494..a36f415 100644
--- a/include/mcl/she.h
+++ b/include/mcl/she.h
@@ -77,12 +77,12 @@ MCLSHE_DLL_API size_t sheCipherTextG1Serialize(void *buf, size_t maxBufSize, con
 MCLSHE_DLL_API size_t sheCipherTextG2Serialize(void *buf, size_t maxBufSize, const sheCipherTextG2 *c);
 MCLSHE_DLL_API size_t sheCipherTextGTSerialize(void *buf, size_t maxBufSize, const sheCipherTextGT *c);
 
-// return 0 if success
-MCLSHE_DLL_API int sheSecretKeyDeserialize(sheSecretKey* sec, const void *buf, size_t bufSize);
-MCLSHE_DLL_API int shePublicKeyDeserialize(shePublicKey* pub, const void *buf, size_t bufSize);
-MCLSHE_DLL_API int sheCipherTextG1Deserialize(sheCipherTextG1* c, const void *buf, size_t bufSize);
-MCLSHE_DLL_API int sheCipherTextG2Deserialize(sheCipherTextG2* c, const void *buf, size_t bufSize);
-MCLSHE_DLL_API int sheCipherTextGTDeserialize(sheCipherTextGT* c, const void *buf, size_t bufSize);
+// return read byte size if sucess else 0
+MCLSHE_DLL_API size_t sheSecretKeyDeserialize(sheSecretKey* sec, const void *buf, size_t bufSize);
+MCLSHE_DLL_API size_t shePublicKeyDeserialize(shePublicKey* pub, const void *buf, size_t bufSize);
+MCLSHE_DLL_API size_t sheCipherTextG1Deserialize(sheCipherTextG1* c, const void *buf, size_t bufSize);
+MCLSHE_DLL_API size_t sheCipherTextG2Deserialize(sheCipherTextG2* c, const void *buf, size_t bufSize);
+MCLSHE_DLL_API size_t sheCipherTextGTDeserialize(sheCipherTextGT* c, const void *buf, size_t bufSize);
 
 /*
 	set secretKey if system has /dev/urandom or CryptGenRandom
diff --git a/include/mcl/she.hpp b/include/mcl/she.hpp
index cf7416e..3f45dc7 100644
--- a/include/mcl/she.hpp
+++ b/include/mcl/she.hpp
@@ -433,15 +433,11 @@ private:
 		bool operator!=(const CipherTextAT& rhs) const { return !operator==(rhs); }
 		size_t serialize(void *buf, size_t maxBufSize) const
 		{
-			std::string s1 = S_.getStr(mcl::IoFixedSizeByteSeq);
-			std::string s2 = T_.getStr(mcl::IoFixedSizeByteSeq);
-			if (maxBufSize < s1.size() + s2.size()) {
-				throw  cybozu::Exception("she:CipherTextAT:serialize");
-			}
-			char *p = (char *)buf;
-			memcpy(p, s1.c_str(), s1.size());
-			memcpy(p + s1.size(), s2.c_str(), s2.size());
-			return s1.size() + s2.size();
+			return mcl::local::serialize2(buf, maxBufSize, S_, T_);
+		}
+		size_t deserialize(const void *buf, size_t bufSize)
+		{
+			return mcl::local::deserialize2(S_, T_, buf, bufSize);
 		}
 	};
 	/*
@@ -677,15 +673,11 @@ public:
 		bool operator!=(const SecretKey& rhs) const { return !operator==(rhs); }
 		size_t serialize(void *buf, size_t maxBufSize) const
 		{
-			std::string s1 = x_.getStr(mcl::IoFixedSizeByteSeq);
-			std::string s2 = y_.getStr(mcl::IoFixedSizeByteSeq);
-			if (maxBufSize < s1.size() + s2.size()) {
-				throw  cybozu::Exception("she:SecretKey:serialize");
-			}
-			char *p = (char *)buf;
-			memcpy(p, s1.c_str(), s1.size());
-			memcpy(p + s1.size(), s2.c_str(), s2.size());
-			return s1.size() + s2.size();
+			return mcl::local::serialize2(buf, maxBufSize, x_, y_);
+		}
+		size_t deserialize(const void *buf, size_t bufSize)
+		{
+			return mcl::local::deserialize2(x_, y_, buf, bufSize);
 		}
 	};
 
@@ -931,15 +923,11 @@ public:
 		bool operator!=(const PublicKey& rhs) const { return !operator==(rhs); }
 		size_t serialize(void *buf, size_t maxBufSize) const
 		{
-			std::string s1 = xP_.getStr(mcl::IoFixedSizeByteSeq);
-			std::string s2 = yQ_.getStr(mcl::IoFixedSizeByteSeq);
-			if (maxBufSize < s1.size() + s2.size()) {
-				throw  cybozu::Exception("she:PublicKey:serialize");
-			}
-			char *p = (char *)buf;
-			memcpy(p, s1.c_str(), s1.size());
-			memcpy(p + s1.size(), s2.c_str(), s2.size());
-			return s1.size() + s2.size();
+			return mcl::local::serialize2(buf, maxBufSize, xP_, yQ_);
+		}
+		size_t deserialize(const void *buf, size_t bufSize)
+		{
+			return mcl::local::deserialize2(xP_, yQ_, buf, bufSize);
 		}
 	};
 
@@ -1204,21 +1192,23 @@ public:
 		bool operator!=(const CipherTextGT& rhs) const { return !operator==(rhs); }
 		size_t serialize(void *buf, size_t maxBufSize) const
 		{
-			std::string s[4];
-			size_t totalSize = 0;
-			for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(s); i++) {
-				g_[i].getStr(s[i], mcl::IoFixedSizeByteSeq);
-				totalSize += s[i].size();
-			}
-			if (maxBufSize < totalSize) {
-				throw cybozu::Exception("she:CipherTextGT:serialize");
-			}
-			char *p = (char *)buf;
-			for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(s); i++) {
-				memcpy(p, s[i].c_str(), s[i].size());
-				p += s[i].size();
-			}
-			return totalSize;
+			char *p = reinterpret_cast<char*>(buf);
+			const size_t n1 = mcl::local::serialize2(p, maxBufSize, g_[0], g_[1]);
+			if (n1 == 0) return 0;
+			p += n1; maxBufSize -= n1;
+			const size_t n2 = mcl::local::serialize2(p, maxBufSize, g_[2], g_[3]);
+			if (n2 == 0) return 0;
+			return n1 + n2;
+		}
+		size_t deserialize(const void *buf, size_t bufSize)
+		{
+			const char *p = reinterpret_cast<const char*>(buf);
+			const size_t n1 = mcl::local::deserialize2(g_[0], g_[1], p, bufSize);
+			if (n1 == 0) return 0;
+			p += n1; bufSize -= n1;
+			const size_t n2 = mcl::local::deserialize2(g_[2], g_[3], p, bufSize);
+			if (n2 == 0) return 0;
+			return n1 + n2;
 		}
 	};
 
diff --git a/src/she_c_impl.hpp b/src/she_c_impl.hpp
index 14df1e5..7542904 100644
--- a/src/she_c_impl.hpp
+++ b/src/she_c_impl.hpp
@@ -114,46 +114,39 @@ size_t sheCipherTextGTSerialize(void *buf, size_t maxBufSize, const sheCipherTex
 	return serialize(buf, maxBufSize, c);
 }
 
-int sheSecretKeyDeserialize(sheSecretKey* sec, const void *buf, size_t bufSize)
+template<class T>
+size_t deserialize(T *x, const void *buf, size_t bufSize)
+	try
+{
+	return cast(x)->deserialize(buf, bufSize);
+} catch (std::exception& e) {
+	fprintf(stderr, "err %s\n", e.what());
+	return 0;
+}
+
+size_t sheSecretKeyDeserialize(sheSecretKey* sec, const void *buf, size_t bufSize)
 {
-	const char *p = (const char *)buf;
-	if (mclBnFr_deserialize(&sec->x, p, bufSize)) return -1;
-	const size_t size = Fr::getByteSize();
-	return mclBnFr_deserialize(&sec->y, p + size, bufSize - size);
+	return deserialize(sec, buf, bufSize);
 }
 
-int shePublicKeyDeserialize(shePublicKey* sec, const void *buf, size_t bufSize)
+size_t shePublicKeyDeserialize(shePublicKey* pub, const void *buf, size_t bufSize)
 {
-	const char *p = (const char *)buf;
-	if (mclBnG1_deserialize(&sec->xP, p, bufSize)) return -1;
-	const size_t size = Fr::getByteSize();
-	return mclBnG2_deserialize(&sec->yQ, p + size, bufSize - size);
+	return deserialize(pub, buf, bufSize);
 }
 
-int sheCipherTextG1Deserialize(sheCipherTextG1* c, const void *buf, size_t bufSize)
+size_t sheCipherTextG1Deserialize(sheCipherTextG1* c, const void *buf, size_t bufSize)
 {
-	const char *p = (const char *)buf;
-	if (mclBnG1_deserialize(&c->S, p, bufSize)) return -1;
-	const size_t size = Fr::getByteSize();
-	return mclBnG1_deserialize(&c->T, p + size, bufSize - size);
+	return deserialize(c, buf, bufSize);
 }
 
-int sheCipherTextG2Deserialize(sheCipherTextG2* c, const void *buf, size_t bufSize)
+size_t sheCipherTextG2Deserialize(sheCipherTextG2* c, const void *buf, size_t bufSize)
 {
-	const char *p = (const char *)buf;
-	if (mclBnG2_deserialize(&c->S, p, bufSize)) return -1;
-	const size_t size = Fr::getByteSize() * 2;
-	return mclBnG2_deserialize(&c->T, p + size, bufSize - size);
+	return deserialize(c, buf, bufSize);
 }
 
-int sheCipherTextGTDeserialize(sheCipherTextGT* c, const void *buf, size_t bufSize)
+size_t sheCipherTextGTDeserialize(sheCipherTextGT* c, const void *buf, size_t bufSize)
 {
-	const char *p = (const char *)buf;
-	const size_t size = Fr::getByteSize() * 12;
-	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(c->g); i++) {
-		if (mclBnGT_deserialize(&c->g[i], p + size * i, bufSize - size * i)) return -1;
-	}
-	return 0;
+	return deserialize(c, buf, bufSize);
 }
 
 int sheSecretKeySetByCSPRNG(sheSecretKey *sec)
diff --git a/test/she_c_test.hpp b/test/she_c_test.hpp
index d83349a..b3a6f6f 100644
--- a/test/she_c_test.hpp
+++ b/test/she_c_test.hpp
@@ -157,7 +157,7 @@ CYBOZU_TEST_AUTO(serialize)
 	n1 = sheSecretKeySerialize(buf1, sizeof(buf1), &sec1);
 	CYBOZU_TEST_EQUAL(n1, size);
 	r = sheSecretKeyDeserialize(&sec2, buf1, n1);
-	CYBOZU_TEST_ASSERT(r == 0);
+	CYBOZU_TEST_EQUAL(r, n1);
 	n2 = sheSecretKeySerialize(buf2, sizeof(buf2), &sec2);
 	CYBOZU_TEST_EQUAL(n2, size);
 	CYBOZU_TEST_EQUAL_ARRAY(buf1, buf2, n2);
@@ -166,7 +166,7 @@ CYBOZU_TEST_AUTO(serialize)
 	n1 = shePublicKeySerialize(buf1, sizeof(buf1), &pub1);
 	CYBOZU_TEST_EQUAL(n1, size);
 	r = shePublicKeyDeserialize(&pub2, buf1, n1);
-	CYBOZU_TEST_ASSERT(r == 0);
+	CYBOZU_TEST_EQUAL(r, n1);
 	n2 = shePublicKeySerialize(buf2, sizeof(buf2), &pub2);
 	CYBOZU_TEST_EQUAL(n2, size);
 	CYBOZU_TEST_EQUAL_ARRAY(buf1, buf2, n2);
@@ -183,7 +183,7 @@ CYBOZU_TEST_AUTO(serialize)
 	n1 = sheCipherTextG1Serialize(buf1, sizeof(buf1), &c11);
 	CYBOZU_TEST_EQUAL(n1, size);
 	r = sheCipherTextG1Deserialize(&c12, buf1, n1);
-	CYBOZU_TEST_ASSERT(r == 0);
+	CYBOZU_TEST_EQUAL(r, n1);
 	n2 = sheCipherTextG1Serialize(buf2, sizeof(buf2), &c12);
 	CYBOZU_TEST_EQUAL(n2, size);
 	CYBOZU_TEST_EQUAL_ARRAY(buf1, buf2, n2);
@@ -192,7 +192,7 @@ CYBOZU_TEST_AUTO(serialize)
 	n1 = sheCipherTextG2Serialize(buf1, sizeof(buf1), &c21);
 	CYBOZU_TEST_EQUAL(n1, size);
 	r = sheCipherTextG2Deserialize(&c22, buf1, n1);
-	CYBOZU_TEST_ASSERT(r == 0);
+	CYBOZU_TEST_EQUAL(r, n1);
 	n2 = sheCipherTextG2Serialize(buf2, sizeof(buf2), &c22);
 	CYBOZU_TEST_EQUAL(n2, size);
 	CYBOZU_TEST_EQUAL_ARRAY(buf1, buf2, n2);
@@ -201,7 +201,7 @@ CYBOZU_TEST_AUTO(serialize)
 	n1 = sheCipherTextGTSerialize(buf1, sizeof(buf1), &ct1);
 	CYBOZU_TEST_EQUAL(n1, size);
 	r = sheCipherTextGTDeserialize(&ct2, buf1, n1);
-	CYBOZU_TEST_ASSERT(r == 0);
+	CYBOZU_TEST_EQUAL(r, n1);
 	n2 = sheCipherTextGTSerialize(buf2, sizeof(buf2), &ct2);
 	CYBOZU_TEST_EQUAL(n2, size);
 	CYBOZU_TEST_EQUAL_ARRAY(buf1, buf2, n2);