From 4854a50087865b7f4f4147a43e9ff21c26df7e1f Mon Sep 17 00:00:00 2001 From: MITSUNARI Shigeo Date: Mon, 29 May 2017 07:02:38 +0900 Subject: Sign to Signature --- include/bls/bls.hpp | 42 ++++++++++----------- include/bls/bls_if.h | 2 +- sample/bls_smpl.cpp | 14 +++---- sample/bls_tool.cpp | 2 +- src/bls.cpp | 38 +++++++++---------- src/bls_if.cpp | 20 +++++----- test/bls_if_test.cpp | 4 +- test/bls_test.cpp | 104 +++++++++++++++++++++++++-------------------------- 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 SecretKeyVec; typedef std::vector PublicKeyVec; -typedef std::vector SignVec; +typedef std::vector SignatureVec; typedef std::vector 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 friend struct WrapArray; impl::PublicKey& getInner() { return *reinterpret_cast(self_); } const impl::PublicKey& getInner() const { return *reinterpret_cast(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 friend struct WrapArray; - impl::Sign& getInner() { return *reinterpret_cast(self_); } - const impl::Sign& getInner() const { return *reinterpret_cast(self_); } + impl::Signature& getInner() { return *reinterpret_cast(self_); } + const impl::Signature& getInner() const { return *reinterpret_cast(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 signW(signVec, n); + WrapArray signW(sigVec, n); WrapArray 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(sig, (const char *)buf, bufSize, bls::IoFixedByteSeq); + return setStrT(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(sig, (char *)buf, maxBufSize, bls::IoFixedByteSeq); + return getStrT(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); } -- cgit v1.2.3