Sign to Signature

8 files changed, 113 insertions, 113 deletions

diff --git a/include/bls/bls.hpp b/include/bls/bls.hpp
index bd74f39..ddfbf50 100644
--- a/include/bls/bls.hpp
+++ b/include/bls/bls.hpp
@@ -39,7 +39,7 @@ namespace impl {
 
 struct SecretKey;
 struct PublicKey;
-struct Sign;
+struct Signature;
 struct Id;
 
 } // bls::impl
@@ -69,7 +69,7 @@ void getFieldOrder(std::string& str);
 
 class SecretKey;
 class PublicKey;
-class Sign;
+class Signature;
 class Id;
 
 /*
@@ -81,7 +81,7 @@ const size_t keySize = BLS_MAX_OP_UNIT_SIZE;
 
 typedef std::vector<SecretKey> SecretKeyVec;
 typedef std::vector<PublicKey> PublicKeyVec;
-typedef std::vector<Sign> SignVec;
+typedef std::vector<Signature> SignatureVec;
 typedef std::vector<Id> IdVec;
 
 class Id {
@@ -138,12 +138,12 @@ public:
 	void setLittleEndian(const void *buf, size_t bufSize);
 	void getPublicKey(PublicKey& pub) const;
 	// constant time sign
-	void sign(Sign& sign, const std::string& m) const;
+	void sign(Signature& sig, const std::string& m) const;
 	/*
 		make Pop(Proof of Possesion)
 		pop = prv.sign(pub)
 	*/
-	void getPop(Sign& pop) const;
+	void getPop(Signature& pop) const;
 	/*
 		make [s_0, ..., s_{k-1}] to prepare k-out-of-n secret sharing
 	*/
@@ -178,7 +178,7 @@ public:
 class PublicKey {
 	uint64_t self_[BLS_MAX_OP_UNIT_SIZE * 2 * 3];
 	friend class SecretKey;
-	friend class Sign;
+	friend class Signature;
 	template<class T, class G> friend struct WrapArray;
 	impl::PublicKey& getInner() { return *reinterpret_cast<impl::PublicKey*>(self_); }
 	const impl::PublicKey& getInner() const { return *reinterpret_cast<const impl::PublicKey*>(self_); }
@@ -212,20 +212,20 @@ public:
 };
 
 /*
-	s H(m) ; sign
+	s H(m) ; signature
 */
-class Sign {
+class Signature {
 	uint64_t self_[BLS_MAX_OP_UNIT_SIZE * 3];
 	friend class SecretKey;
 	template<class T, class G> friend struct WrapArray;
-	impl::Sign& getInner() { return *reinterpret_cast<impl::Sign*>(self_); }
-	const impl::Sign& getInner() const { return *reinterpret_cast<const impl::Sign*>(self_); }
+	impl::Signature& getInner() { return *reinterpret_cast<impl::Signature*>(self_); }
+	const impl::Signature& getInner() const { return *reinterpret_cast<const impl::Signature*>(self_); }
 public:
-	Sign() : self_() {}
-	bool operator==(const Sign& rhs) const;
-	bool operator!=(const Sign& rhs) const { return !(*this == rhs); }
-	friend std::ostream& operator<<(std::ostream& os, const Sign& s);
-	friend std::istream& operator>>(std::istream& is, Sign& s);
+	Signature() : self_() {}
+	bool operator==(const Signature& rhs) const;
+	bool operator!=(const Signature& rhs) const { return !(*this == rhs); }
+	friend std::ostream& operator<<(std::ostream& os, const Signature& s);
+	friend std::istream& operator>>(std::istream& is, Signature& s);
 	void getStr(std::string& str, int ioMode = 0) const;
 	void setStr(const std::string& str, int ioMode = 0);
 	bool verify(const PublicKey& pub, const std::string& m) const;
@@ -234,16 +234,16 @@ public:
 	*/
 	bool verify(const PublicKey& pub) const;
 	/*
-		recover sign from k signVec
+		recover sig from k sigVec
 	*/
-	void recover(const SignVec& signVec, const IdVec& idVec);
+	void recover(const SignatureVec& sigVec, const IdVec& idVec);
 	/*
 		add signature
 	*/
-	void add(const Sign& rhs);
+	void add(const Signature& rhs);
 
 	// the following methods are for C api
-	void recover(const Sign* signVec, const Id *idVec, size_t n);
+	void recover(const Signature* sigVec, const Id *idVec, size_t n);
 };
 
 /*
@@ -261,7 +261,7 @@ inline void getMasterPublicKey(PublicKeyVec& mpk, const SecretKeyVec& msk)
 /*
 	make pop from msk and mpk
 */
-inline void getPopVec(SignVec& popVec, const SecretKeyVec& msk)
+inline void getPopVec(SignatureVec& popVec, const SecretKeyVec& msk)
 {
 	const size_t n = msk.size();
 	popVec.resize(n);
@@ -270,7 +270,7 @@ inline void getPopVec(SignVec& popVec, const SecretKeyVec& msk)
 	}
 }
 
-inline Sign operator+(const Sign& a, const Sign& b) { Sign r(a); r.add(b); return r; }
+inline Signature operator+(const Signature& a, const Signature& b) { Signature r(a); r.add(b); return r; }
 inline PublicKey operator+(const PublicKey& a, const PublicKey& b) { PublicKey r(a); r.add(b); return r; }
 inline SecretKey operator+(const SecretKey& a, const SecretKey& b) { SecretKey r(a); r.add(b); return r; }
 
diff --git a/include/bls/bls_if.h b/include/bls/bls_if.h
index 9293069..be1467c 100644
--- a/include/bls/bls_if.h
+++ b/include/bls/bls_if.h
@@ -150,7 +150,7 @@ BLS_DLL_API int blsSignatureSetHexStr(blsSignature *sig, const char *buf, size_t
 BLS_DLL_API size_t blsSignatureGetHexStr(char *buf, size_t maxBufSize, const blsSignature *sig);
 BLS_DLL_API void blsSignatureAdd(blsSignature *sig, const blsSignature *rhs);
 // return 0 if success
-BLS_DLL_API int blsSignatureRecover(blsSignature *sig, const blsSignature *signVec, const blsId *idVec, size_t n);
+BLS_DLL_API int blsSignatureRecover(blsSignature *sig, const blsSignature *sigVec, const blsId *idVec, size_t n);
 BLS_DLL_API int blsVerify(const blsSignature *sig, const blsPublicKey *pub, const char *m, size_t size);
 
 BLS_DLL_API int blsVerifyPop(const blsSignature *sig, const blsPublicKey *pub);
diff --git a/sample/bls_smpl.cpp b/sample/bls_smpl.cpp
index a91616c..5e0c70c 100644
--- a/sample/bls_smpl.cpp
+++ b/sample/bls_smpl.cpp
@@ -53,7 +53,7 @@ int sign(const std::string& m, int id)
 	printf("sign message `%s` by id=%d\n", m.c_str(), id);
 	bls::SecretKey sec;
 	load(sec, secFile, id);
-	bls::Sign s;
+	bls::Signature s;
 	sec.sign(s, m);
 	save(signFile, s, id);
 	return 0;
@@ -64,7 +64,7 @@ int verify(const std::string& m, int id)
 	printf("verify message `%s` by id=%d\n", m.c_str(), id);
 	bls::PublicKey pub;
 	load(pub, pubFile, id);
-	bls::Sign s;
+	bls::Signature s;
 	load(s, signFile, id);
 	if (s.verify(pub, m)) {
 		puts("verify ok");
@@ -105,12 +105,12 @@ int recover(const bls::IdVec& ids)
 		std::cout << ' ' << ids[i];
 	}
 	printf("\n");
-	bls::SignVec signVec(ids.size());
-	for (size_t i = 0; i < signVec.size(); i++) {
-		load(signVec[i], signFile, ids[i]);
+	bls::SignatureVec sigVec(ids.size());
+	for (size_t i = 0; i < sigVec.size(); i++) {
+		load(sigVec[i], signFile, ids[i]);
 	}
-	bls::Sign s;
-	s.recover(signVec, ids);
+	bls::Signature s;
+	s.recover(sigVec, ids);
 	save(signFile, s);
 	return 0;
 }
diff --git a/sample/bls_tool.cpp b/sample/bls_tool.cpp
index dfa3a07..5683c5e 100644
--- a/sample/bls_tool.cpp
+++ b/sample/bls_tool.cpp
@@ -112,7 +112,7 @@ void recover_sig()
 	size_t k;
 	read(k);
 	if (g_verbose) fprintf(stderr, "k:%d\n", (int)k);
-	bls::SignVec sVec(k);
+	bls::SignatureVec sVec(k);
 	bls::IdVec idVec(k);
 	for (size_t i = 0; i < k; i++) {
 		read(idVec[i]);
diff --git a/src/bls.cpp b/src/bls.cpp
index 70bbfa3..c4a3e69 100644
--- a/src/bls.cpp
+++ b/src/bls.cpp
@@ -98,7 +98,7 @@ struct SecretKey {
 	const Fr& get() const { return s; }
 };
 
-struct Sign {
+struct Signature {
 	G1 sHm; // s Hash(m)
 	const G1& get() const { return sHm; }
 };
@@ -190,7 +190,7 @@ void init(int curve, int maxUnitSize)
 	assert(sizeof(Id) == sizeof(impl::Id));
 	assert(sizeof(SecretKey) == sizeof(impl::SecretKey));
 	assert(sizeof(PublicKey) == sizeof(impl::PublicKey));
-	assert(sizeof(Sign) == sizeof(impl::Sign));
+	assert(sizeof(Signature) == sizeof(impl::Signature));
 	static G2 Q;
 	if (curve == bls::CurveFp254BNb) {
 		Q.set(
@@ -263,30 +263,30 @@ void Id::setLittleEndian(const void *buf, size_t bufSize)
 	getInner().v.setArrayMask((const char *)buf, bufSize);
 }
 
-bool Sign::operator==(const Sign& rhs) const
+bool Signature::operator==(const Signature& rhs) const
 {
 	return getInner().sHm == rhs.getInner().sHm;
 }
 
-std::ostream& operator<<(std::ostream& os, const Sign& s)
+std::ostream& operator<<(std::ostream& os, const Signature& s)
 {
 	return writeAsHex(os, s.getInner().sHm);
 }
 
-std::istream& operator>>(std::istream& os, Sign& s)
+std::istream& operator>>(std::istream& os, Signature& s)
 {
 	return os >> s.getInner().sHm;
 }
-void Sign::getStr(std::string& str, int ioMode) const
+void Signature::getStr(std::string& str, int ioMode) const
 {
 	getInner().sHm.getStr(str, ioMode);
 }
-void Sign::setStr(const std::string& str, int ioMode)
+void Signature::setStr(const std::string& str, int ioMode)
 {
 	getInner().sHm.setStr(str, ioMode);
 }
 
-bool Sign::verify(const PublicKey& pub, const std::string& m) const
+bool Signature::verify(const PublicKey& pub, const std::string& m) const
 {
 	G1 Hm;
 	HashAndMapToG1(Hm, m); // Hm = Hash(m)
@@ -312,27 +312,27 @@ bool Sign::verify(const PublicKey& pub, const std::string& m) const
 #endif
 }
 
-bool Sign::verify(const PublicKey& pub) const
+bool Signature::verify(const PublicKey& pub) const
 {
 	std::string str;
 	pub.getInner().sQ.getStr(str);
 	return verify(pub, str);
 }
 
-void Sign::recover(const SignVec& signVec, const IdVec& idVec)
+void Signature::recover(const SignatureVec& sigVec, const IdVec& idVec)
 {
-	if (signVec.size() != idVec.size()) throw cybozu::Exception("Sign:recover:bad size") << signVec.size() << idVec.size();
-	recover(signVec.data(), idVec.data(), signVec.size());
+	if (sigVec.size() != idVec.size()) throw cybozu::Exception("Signature:recover:bad size") << sigVec.size() << idVec.size();
+	recover(sigVec.data(), idVec.data(), sigVec.size());
 }
 
-void Sign::recover(const Sign* signVec, const Id *idVec, size_t n)
+void Signature::recover(const Signature* sigVec, const Id *idVec, size_t n)
 {
-	WrapArray<Sign, G1> signW(signVec, n);
+	WrapArray<Signature, G1> signW(sigVec, n);
 	WrapArray<Id, Fr> idW(idVec, n);
 	LagrangeInterpolation(getInner().sHm, signW, idW);
 }
 
-void Sign::add(const Sign& rhs)
+void Signature::add(const Signature& rhs)
 {
 	getInner().sHm += rhs.getInner().sHm;
 }
@@ -425,15 +425,15 @@ void SecretKey::getPublicKey(PublicKey& pub) const
 	G2::mul(pub.getInner().sQ, getQ(), getInner().s);
 }
 
-void SecretKey::sign(Sign& sign, const std::string& m) const
+void SecretKey::sign(Signature& sig, const std::string& m) const
 {
 	G1 Hm;
 	HashAndMapToG1(Hm, m);
-//	G1::mul(sign.getInner().sHm, Hm, getInner().s);
-	G1::mulCT(sign.getInner().sHm, Hm, getInner().s);
+//	G1::mul(sig.getInner().sHm, Hm, getInner().s);
+	G1::mulCT(sig.getInner().sHm, Hm, getInner().s);
 }
 
-void SecretKey::getPop(Sign& pop) const
+void SecretKey::getPop(Signature& pop) const
 {
 	PublicKey pub;
 	getPublicKey(pub);
diff --git a/src/bls_if.cpp b/src/bls_if.cpp
index 6213a4f..48f16b5 100644
--- a/src/bls_if.cpp
+++ b/src/bls_if.cpp
@@ -170,7 +170,7 @@ void blsGetPublicKey(blsPublicKey *pub, const blsSecretKey *sec)
 }
 void blsSign(blsSignature *sig, const blsSecretKey *sec, const char *m, size_t size)
 {
-	((const bls::SecretKey*)sec)->sign(*(bls::Sign*)sig, std::string(m, size));
+	((const bls::SecretKey*)sec)->sign(*(bls::Signature*)sig, std::string(m, size));
 }
 int blsSecretKeyShare(blsSecretKey *sec, const blsSecretKey* msk, size_t k, const blsId *id)
 	try
@@ -194,7 +194,7 @@ int blsSecretKeyRecover(blsSecretKey *sec, const blsSecretKey *secVec, const bls
 
 void blsGetPop(blsSignature *sig, const blsSecretKey *sec)
 {
-	((const bls::SecretKey*)sec)->getPop(*(bls::Sign*)sig);
+	((const bls::SecretKey*)sec)->getPop(*(bls::Signature*)sig);
 }
 
 int blsPublicKeyIsSame(const blsPublicKey *lhs, const blsPublicKey *rhs)
@@ -259,11 +259,11 @@ int blsPublicKeyRecover(blsPublicKey *pub, const blsPublicKey *pubVec, const bls
 
 int blsSignatureIsSame(const blsSignature *lhs, const blsSignature *rhs)
 {
-	return *(const bls::Sign*)lhs == *(const bls::Sign*)rhs ? 1 : 0;
+	return *(const bls::Signature*)lhs == *(const bls::Signature*)rhs ? 1 : 0;
 }
 int blsSignatureDeserialize(blsSignature *sig, const void *buf, size_t bufSize)
 {
-	return setStrT<bls::Sign, blsSignature>(sig, (const char *)buf, bufSize, bls::IoFixedByteSeq);
+	return setStrT<bls::Signature, blsSignature>(sig, (const char *)buf, bufSize, bls::IoFixedByteSeq);
 }
 int blsSignatureSetHexStr(blsSignature *sig, const char *buf, size_t bufSize)
 	try
@@ -292,16 +292,16 @@ size_t blsSignatureGetHexStr(char *buf, size_t maxBufSize, const blsSignature *s
 }
 size_t blsSignatureSerialize(void *buf, size_t maxBufSize, const blsSignature *sig)
 {
-	return getStrT<bls::Sign, blsSignature>(sig, (char *)buf, maxBufSize, bls::IoFixedByteSeq);
+	return getStrT<bls::Signature, blsSignature>(sig, (char *)buf, maxBufSize, bls::IoFixedByteSeq);
 }
 void blsSignatureAdd(blsSignature *sig, const blsSignature *rhs)
 {
-	((bls::Sign*)sig)->add(*(const bls::Sign*)rhs);
+	((bls::Signature*)sig)->add(*(const bls::Signature*)rhs);
 }
-int blsSignatureRecover(blsSignature *sig, const blsSignature *signVec, const blsId *idVec, size_t n)
+int blsSignatureRecover(blsSignature *sig, const blsSignature *sigVec, const blsId *idVec, size_t n)
 	try
 {
-	((bls::Sign*)sig)->recover((const bls::Sign*)signVec, (const bls::Id*)idVec, n);
+	((bls::Signature*)sig)->recover((const bls::Signature*)sigVec, (const bls::Id*)idVec, n);
 	return 0;
 } catch (std::exception& e) {
 	fprintf(stderr, "err blsSignatureRecover %s\n", e.what());
@@ -310,11 +310,11 @@ int blsSignatureRecover(blsSignature *sig, const blsSignature *signVec, const bl
 
 int blsVerify(const blsSignature *sig, const blsPublicKey *pub, const char *m, size_t size)
 {
-	return ((const bls::Sign*)sig)->verify(*(const bls::PublicKey*)pub, std::string(m, size));
+	return ((const bls::Signature*)sig)->verify(*(const bls::PublicKey*)pub, std::string(m, size));
 }
 
 int blsVerifyPop(const blsSignature *sig, const blsPublicKey *pub)
 {
-	return ((const bls::Sign*)sig)->verify(*(const bls::PublicKey*)pub);
+	return ((const bls::Signature*)sig)->verify(*(const bls::PublicKey*)pub);
 }
 
diff --git a/test/bls_if_test.cpp b/test/bls_if_test.cpp
index 317afee..3c75b8b 100644
--- a/test/bls_if_test.cpp
+++ b/test/bls_if_test.cpp
@@ -26,11 +26,11 @@ void bls_ifDataTest()
 	const size_t fpSize = blsGetOpUnitSize() * sizeof(uint64_t);
 	blsSecretKey sec1, sec2;
 	blsSecretKeySetByCSPRNG(&sec1);
-	char buf[BLS_MAX_OP_UNIT_SIZE * sizeof(uint64_t) * 2];
+	char buf[1024];
 	size_t n;
 	int ret;
 	n = blsSecretKeyGetHexStr(buf, sizeof(buf), &sec1);
-	CYBOZU_TEST_EQUAL(n, fpSize * 2);
+	CYBOZU_TEST_ASSERT(0 < n && n <= fpSize * 2);
 	ret = blsSecretKeySetHexStr(&sec2, buf, n);
 	CYBOZU_TEST_EQUAL(ret, 0);
 	CYBOZU_TEST_ASSERT(blsSecretKeyIsSame(&sec1, &sec2));
diff --git a/test/bls_test.cpp b/test/bls_test.cpp
index fc49f6e..f23aad3 100644
--- a/test/bls_test.cpp
+++ b/test/bls_test.cpp
@@ -83,13 +83,13 @@ void blsTest()
 	for (int i = 0; i < 5; i++) {
 		std::string m = "hello";
 		m += char('0' + i);
-		bls::Sign s;
-		sec.sign(s, m);
-		CYBOZU_TEST_ASSERT(s.verify(pub, m));
-		CYBOZU_TEST_ASSERT(!s.verify(pub, m + "a"));
-		streamTest(s);
-		CYBOZU_BENCH_C("sign", 100, sec.sign, s, m);
-		CYBOZU_BENCH_C("verify", 100, s.verify, pub, m);
+		bls::Signature sig;
+		sec.sign(sig, m);
+		CYBOZU_TEST_ASSERT(sig.verify(pub, m));
+		CYBOZU_TEST_ASSERT(!sig.verify(pub, m + "a"));
+		streamTest(sig);
+		CYBOZU_BENCH_C("sign", 100, sec.sign, sig, m);
+		CYBOZU_BENCH_C("verify", 100, sig.verify, pub, m);
 	}
 }
 
@@ -100,11 +100,11 @@ void k_of_nTest()
 	const int k = 3;
 	bls::SecretKey sec0;
 	sec0.init();
-	bls::Sign s0;
-	sec0.sign(s0, m);
+	bls::Signature sig0;
+	sec0.sign(sig0, m);
 	bls::PublicKey pub0;
 	sec0.getPublicKey(pub0);
-	CYBOZU_TEST_ASSERT(s0.verify(pub0, m));
+	CYBOZU_TEST_ASSERT(sig0.verify(pub0, m));
 
 	bls::SecretKeyVec msk;
 	sec0.getMasterSecretKey(msk, k);
@@ -121,14 +121,14 @@ void k_of_nTest()
 		CYBOZU_TEST_EQUAL(allPrvVec[i], p);
 	}
 
-	bls::SignVec allSignVec(n);
+	bls::SignatureVec allSigVec(n);
 	for (int i = 0; i < n; i++) {
 		CYBOZU_TEST_ASSERT(allPrvVec[i] != sec0);
-		allPrvVec[i].sign(allSignVec[i], m);
+		allPrvVec[i].sign(allSigVec[i], m);
 		bls::PublicKey pub;
 		allPrvVec[i].getPublicKey(pub);
 		CYBOZU_TEST_ASSERT(pub != pub0);
-		CYBOZU_TEST_ASSERT(allSignVec[i].verify(pub, m));
+		CYBOZU_TEST_ASSERT(allSigVec[i].verify(pub, m));
 	}
 
 	/*
@@ -195,54 +195,54 @@ void k_of_nTest()
 		3-out-of-n
 		can recover
 	*/
-	bls::SignVec signVec(3);
+	bls::SignatureVec sigVec(3);
 	idVec.resize(3);
 	for (int a = 0; a < n; a++) {
-		signVec[0] = allSignVec[a];
+		sigVec[0] = allSigVec[a];
 		idVec[0] = allIdVec[a];
 		for (int b = a + 1; b < n; b++) {
-			signVec[1] = allSignVec[b];
+			sigVec[1] = allSigVec[b];
 			idVec[1] = allIdVec[b];
 			for (int c = b + 1; c < n; c++) {
-				signVec[2] = allSignVec[c];
+				sigVec[2] = allSigVec[c];
 				idVec[2] = allIdVec[c];
-				bls::Sign s;
-				s.recover(signVec, idVec);
-				CYBOZU_TEST_EQUAL(s, s0);
+				bls::Signature sig;
+				sig.recover(sigVec, idVec);
+				CYBOZU_TEST_EQUAL(sig, sig0);
 			}
 		}
 	}
 	{
-		signVec[0] = allSignVec[1]; idVec[0] = allIdVec[1];
-		signVec[1] = allSignVec[4]; idVec[1] = allIdVec[4];
-		signVec[2] = allSignVec[3]; idVec[2] = allIdVec[3];
-		bls::Sign s;
-		CYBOZU_BENCH_C("s.recover", 100, s.recover, signVec, idVec);
+		sigVec[0] = allSigVec[1]; idVec[0] = allIdVec[1];
+		sigVec[1] = allSigVec[4]; idVec[1] = allIdVec[4];
+		sigVec[2] = allSigVec[3]; idVec[2] = allIdVec[3];
+		bls::Signature sig;
+		CYBOZU_BENCH_C("sig.recover", 100, sig.recover, sigVec, idVec);
 	}
 	{
 		/*
 			n-out-of-n
 			can recover
 		*/
-		bls::Sign s;
-		s.recover(allSignVec, allIdVec);
-		CYBOZU_TEST_EQUAL(s, s0);
+		bls::Signature sig;
+		sig.recover(allSigVec, allIdVec);
+		CYBOZU_TEST_EQUAL(sig, sig0);
 	}
 	/*
 		2-out-of-n
 		can't recover
 	*/
-	signVec.resize(2);
+	sigVec.resize(2);
 	idVec.resize(2);
 	for (int a = 0; a < n; a++) {
-		signVec[0] = allSignVec[a];
+		sigVec[0] = allSigVec[a];
 		idVec[0] = allIdVec[a];
 		for (int b = a + 1; b < n; b++) {
-			signVec[1] = allSignVec[b];
+			sigVec[1] = allSigVec[b];
 			idVec[1] = allIdVec[b];
-			bls::Sign s;
-			s.recover(signVec, idVec);
-			CYBOZU_TEST_ASSERT(s != s0);
+			bls::Signature sig;
+			sig.recover(sigVec, idVec);
+			CYBOZU_TEST_ASSERT(sig != sig0);
 		}
 	}
 	// share and recover publicKey
@@ -272,16 +272,16 @@ void popTest()
 	sec0.init();
 	bls::PublicKey pub0;
 	sec0.getPublicKey(pub0);
-	bls::Sign s0;
-	sec0.sign(s0, m);
-	CYBOZU_TEST_ASSERT(s0.verify(pub0, m));
+	bls::Signature sig0;
+	sec0.sign(sig0, m);
+	CYBOZU_TEST_ASSERT(sig0.verify(pub0, m));
 
 	bls::SecretKeyVec msk;
 	sec0.getMasterSecretKey(msk, k);
 
 	bls::PublicKeyVec mpk;
 	bls::getMasterPublicKey(mpk, msk);
-	bls::SignVec  popVec;
+	bls::SignatureVec  popVec;
 	bls::getPopVec(popVec, msk);
 
 	for (size_t i = 0; i < popVec.size(); i++) {
@@ -293,7 +293,7 @@ void popTest()
 	};
 	bls::SecretKeyVec secVec(n);
 	bls::PublicKeyVec pubVec(n);
-	bls::SignVec sVec(n);
+	bls::SignatureVec sVec(n);
 	for (size_t i = 0; i < n; i++) {
 		int id = idTbl[i];
 		secVec[i].set(msk, id);
@@ -302,7 +302,7 @@ void popTest()
 		pub.set(mpk, id);
 		CYBOZU_TEST_EQUAL(pubVec[i], pub);
 
-		bls::Sign pop;
+		bls::Signature pop;
 		secVec[i].getPop(pop);
 		CYBOZU_TEST_ASSERT(pop.verify(pubVec[i]));
 
@@ -318,12 +318,12 @@ void popTest()
 	bls::SecretKey sec;
 	sec.recover(secVec, idVec);
 	CYBOZU_TEST_EQUAL(sec, sec0);
-	bls::Sign s;
-	s.recover(sVec, idVec);
-	CYBOZU_TEST_EQUAL(s, s0);
-	bls::Sign s2;
-	s2.recover(sVec.data(), idVec.data(), sVec.size());
-	CYBOZU_TEST_EQUAL(s, s2);
+	bls::Signature sig;
+	sig.recover(sVec, idVec);
+	CYBOZU_TEST_EQUAL(sig, sig0);
+	bls::Signature sig2;
+	sig2.recover(sVec.data(), idVec.data(), sVec.size());
+	CYBOZU_TEST_EQUAL(sig, sig2);
 }
 
 void addTest()
@@ -338,10 +338,10 @@ void addTest()
 	sec2.getPublicKey(pub2);
 
 	const std::string m = "doremi";
-	bls::Sign s1, s2;
-	sec1.sign(s1, m);
-	sec2.sign(s2, m);
-	CYBOZU_TEST_ASSERT((s1 + s2).verify(pub1 + pub2, m));
+	bls::Signature sig1, sig2;
+	sec1.sign(sig1, m);
+	sec2.sign(sig2, m);
+	CYBOZU_TEST_ASSERT((sig1 + sig2).verify(pub1 + pub2, m));
 }
 
 void dataTest()
@@ -367,12 +367,12 @@ void dataTest()
 		CYBOZU_TEST_EQUAL(pub, pub2);
 	}
 	std::string m = "abc";
-	bls::Sign sign;
+	bls::Signature sign;
 	sec.sign(sign, m);
 	sign.getStr(str, bls::IoFixedByteSeq);
 	{
 		CYBOZU_TEST_EQUAL(str.size(), size);
-		bls::Sign sign2;
+		bls::Signature sign2;
 		sign2.setStr(str, bls::IoFixedByteSeq);
 		CYBOZU_TEST_EQUAL(sign, sign2);
 	}