Sign to Signature

2 files changed, 29 insertions, 29 deletions

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);
 }