aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/cryptonote_core/cryptonote_boost_serialization.h56
-rw-r--r--src/ringct/rctTypes.h48
-rw-r--r--src/serialization/crypto.h28
-rw-r--r--tests/unit_tests/serialization.cpp201
4 files changed, 305 insertions, 28 deletions
diff --git a/src/cryptonote_core/cryptonote_boost_serialization.h b/src/cryptonote_core/cryptonote_boost_serialization.h
index 79ceec5bc..6a6ff5a7d 100644
--- a/src/cryptonote_core/cryptonote_boost_serialization.h
+++ b/src/cryptonote_core/cryptonote_boost_serialization.h
@@ -40,6 +40,7 @@
#include "cryptonote_basic.h"
#include "common/unordered_containers_boost_serialization.h"
#include "crypto/crypto.h"
+#include "ringct/rctTypes.h"
//namespace cryptonote {
namespace boost
@@ -163,6 +164,61 @@ namespace boost
a & b.miner_tx;
a & b.tx_hashes;
}
+
+ template <class Archive>
+ inline void serialize(Archive &a, rct::key &x, const boost::serialization::version_type ver)
+ {
+ a & reinterpret_cast<char (&)[sizeof(rct::key)]>(x);
+ }
+
+ template <class Archive>
+ inline void serialize(Archive &a, rct::ctkey &x, const boost::serialization::version_type ver)
+ {
+ a & x.dest;
+ a & x.mask;
+ }
+
+ template <class Archive>
+ inline void serialize(Archive &a, rct::rangeSig &x, const boost::serialization::version_type ver)
+ {
+ a & x.asig;
+ a & x.Ci;
+ }
+
+ template <class Archive>
+ inline void serialize(Archive &a, rct::asnlSig &x, const boost::serialization::version_type ver)
+ {
+ a & x.L1;
+ a & x.s2;
+ a & x.s;
+ }
+
+ template <class Archive>
+ inline void serialize(Archive &a, rct::mgSig &x, const boost::serialization::version_type ver)
+ {
+ a & x.ss;
+ a & x.cc;
+ a & x.II;
+ }
+
+ template <class Archive>
+ inline void serialize(Archive &a, rct::ecdhTuple &x, const boost::serialization::version_type ver)
+ {
+ a & x.mask;
+ a & x.amount;
+ a & x.senderPk;
+ }
+
+ template <class Archive>
+ inline void serialize(Archive &a, rct::rctSig &x, const boost::serialization::version_type ver)
+ {
+ a & x.rangeSigs;
+ a & x.MG;
+ a & x.mixRing;
+ a & x.ecdhInfo;
+ a & x.outPk;
+ a & x.txnFee;
+ }
}
}
diff --git a/src/ringct/rctTypes.h b/src/ringct/rctTypes.h
index 01585235f..13e9fb6f2 100644
--- a/src/ringct/rctTypes.h
+++ b/src/ringct/rctTypes.h
@@ -48,6 +48,9 @@ extern "C" {
#include "crypto/crypto.h"
#include "serialization/serialization.h"
+#include "serialization/debug_archive.h"
+#include "serialization/binary_archive.h"
+#include "serialization/json_archive.h"
//Define this flag when debugging to get additional info on the console
@@ -309,4 +312,49 @@ namespace cryptonote {
template<typename T> std::ostream &print256(std::ostream &o, const T &v);
inline std::ostream &operator <<(std::ostream &o, const rct::key &v) { return print256(o, v); }
+
+BLOB_SERIALIZER(rct::key);
+BLOB_SERIALIZER(rct::key64);
+BLOB_SERIALIZER(rct::ctkey);
+BLOB_SERIALIZER(rct::asnlSig);
+
+VARIANT_TAG(debug_archive, rct::key, "rct::key");
+VARIANT_TAG(debug_archive, rct::key64, "rct::key64");
+VARIANT_TAG(debug_archive, rct::keyV, "rct::keyV");
+VARIANT_TAG(debug_archive, rct::keyM, "rct::keyM");
+VARIANT_TAG(debug_archive, rct::ctkey, "rct::ctkey");
+VARIANT_TAG(debug_archive, rct::ctkeyV, "rct::ctkeyV");
+VARIANT_TAG(debug_archive, rct::ctkeyM, "rct::ctkeyM");
+VARIANT_TAG(debug_archive, rct::ecdhTuple, "rct::ecdhTuple");
+VARIANT_TAG(debug_archive, rct::mgSig, "rct::mgSig");
+VARIANT_TAG(debug_archive, rct::rangeSig, "rct::rangeSig");
+VARIANT_TAG(debug_archive, rct::asnlSig, "rct::asnlSig");
+VARIANT_TAG(debug_archive, rct::rctSig, "rct::rctSig");
+
+VARIANT_TAG(binary_archive, rct::key, 0x90);
+VARIANT_TAG(binary_archive, rct::key64, 0x91);
+VARIANT_TAG(binary_archive, rct::keyV, 0x92);
+VARIANT_TAG(binary_archive, rct::keyM, 0x93);
+VARIANT_TAG(binary_archive, rct::ctkey, 0x94);
+VARIANT_TAG(binary_archive, rct::ctkeyV, 0x95);
+VARIANT_TAG(binary_archive, rct::ctkeyM, 0x96);
+VARIANT_TAG(binary_archive, rct::ecdhTuple, 0x97);
+VARIANT_TAG(binary_archive, rct::mgSig, 0x98);
+VARIANT_TAG(binary_archive, rct::rangeSig, 0x99);
+VARIANT_TAG(binary_archive, rct::asnlSig, 0x9a);
+VARIANT_TAG(binary_archive, rct::rctSig, 0x9b);
+
+VARIANT_TAG(json_archive, rct::key, "rct_key");
+VARIANT_TAG(json_archive, rct::key64, "rct_key64");
+VARIANT_TAG(json_archive, rct::keyV, "rct_keyV");
+VARIANT_TAG(json_archive, rct::keyM, "rct_keyM");
+VARIANT_TAG(json_archive, rct::ctkey, "rct_ctkey");
+VARIANT_TAG(json_archive, rct::ctkeyV, "rct_ctkeyV");
+VARIANT_TAG(json_archive, rct::ctkeyM, "rct_ctkeyM");
+VARIANT_TAG(json_archive, rct::ecdhTuple, "rct_ecdhTuple");
+VARIANT_TAG(json_archive, rct::mgSig, "rct_mgSig");
+VARIANT_TAG(json_archive, rct::rangeSig, "rct_rangeSig");
+VARIANT_TAG(json_archive, rct::asnlSig, "rct_asnlSig");
+VARIANT_TAG(json_archive, rct::rctSig, "rct_rctSig");
+
#endif /* RCTTYPES_H */
diff --git a/src/serialization/crypto.h b/src/serialization/crypto.h
index 9babe698d..9a7e89c49 100644
--- a/src/serialization/crypto.h
+++ b/src/serialization/crypto.h
@@ -37,7 +37,6 @@
#include "crypto/chacha8.h"
#include "crypto/crypto.h"
#include "crypto/hash.h"
-#include "ringct/rctTypes.h"
// read
template <template <bool> class Archive>
@@ -94,30 +93,3 @@ VARIANT_TAG(debug_archive, crypto::key_derivation, "key_derivation");
VARIANT_TAG(debug_archive, crypto::key_image, "key_image");
VARIANT_TAG(debug_archive, crypto::signature, "signature");
-BLOB_SERIALIZER(rct::key);
-BLOB_SERIALIZER(rct::key64);
-BLOB_SERIALIZER(rct::ctkey);
-BLOB_SERIALIZER(rct::ecdhTuple);
-BLOB_SERIALIZER(rct::asnlSig);
-
-VARIANT_TAG(debug_archive, rct::key, "rct::key");
-VARIANT_TAG(debug_archive, rct::key64, "rct::key64");
-VARIANT_TAG(debug_archive, rct::ctkey, "rct::ctkey");
-VARIANT_TAG(debug_archive, rct::ecdhTuple, "rct::ecdhTuple");
-VARIANT_TAG(debug_archive, rct::asnlSig, "rct::asnlSig");
-VARIANT_TAG(debug_archive, rct::rctSig, "rct::rctSig");
-
-VARIANT_TAG(binary_archive, rct::key, 0x90);
-VARIANT_TAG(binary_archive, rct::key64, 0x91);
-VARIANT_TAG(binary_archive, rct::ctkey, 0x92);
-VARIANT_TAG(binary_archive, rct::ecdhTuple, 0x93);
-VARIANT_TAG(binary_archive, rct::asnlSig, 0x94);
-VARIANT_TAG(binary_archive, rct::rctSig, 0x95);
-
-VARIANT_TAG(json_archive, rct::key, "rct_key");
-VARIANT_TAG(json_archive, rct::key64, "rct_key64");
-VARIANT_TAG(json_archive, rct::ctkey, "rct_ctkey");
-VARIANT_TAG(json_archive, rct::ecdhTuple, "rct_ecdhTuple");
-VARIANT_TAG(json_archive, rct::asnlSig, "rct_asnlSig");
-VARIANT_TAG(json_archive, rct::rctSig, "rct_rctSig");
-
diff --git a/tests/unit_tests/serialization.cpp b/tests/unit_tests/serialization.cpp
index b110a41ab..55a33c83f 100644
--- a/tests/unit_tests/serialization.cpp
+++ b/tests/unit_tests/serialization.cpp
@@ -36,6 +36,7 @@
#include <boost/foreach.hpp>
#include "cryptonote_core/cryptonote_basic.h"
#include "cryptonote_core/cryptonote_basic_impl.h"
+#include "ringct/rctSigs.h"
#include "serialization/serialization.h"
#include "serialization/binary_archive.h"
#include "serialization/json_archive.h"
@@ -442,3 +443,203 @@ TEST(Serialization, serializes_transacion_signatures_correctly)
blob.resize(blob.size() + sizeof(crypto::signature) / 2);
ASSERT_FALSE(serialization::parse_binary(blob, tx1));
}
+
+TEST(Serialization, serializes_ringct_types)
+{
+ string blob;
+ rct::key key0, key1;
+ rct::keyV keyv0, keyv1;
+ rct::keyM keym0, keym1;
+ rct::ctkey ctkey0, ctkey1;
+ rct::ctkeyV ctkeyv0, ctkeyv1;
+ rct::ctkeyM ctkeym0, ctkeym1;
+ rct::ecdhTuple ecdh0, ecdh1;
+ rct::asnlSig asnl0, asnl1;
+ rct::mgSig mg0, mg1;
+ rct::rangeSig rg0, rg1;
+ rct::rctSig s0, s1;
+ cryptonote::transaction tx0, tx1;
+
+ key0 = rct::skGen();
+ ASSERT_TRUE(serialization::dump_binary(key0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, key1));
+ ASSERT_TRUE(key0 == key1);
+
+ keyv0 = rct::skvGen(30);
+ for (size_t n = 0; n < keyv0.size(); ++n)
+ keyv0[n] = rct::skGen();
+ ASSERT_TRUE(serialization::dump_binary(keyv0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, keyv1));
+ ASSERT_TRUE(keyv0.size() == keyv1.size());
+ for (size_t n = 0; n < keyv0.size(); ++n)
+ {
+ ASSERT_TRUE(keyv0[n] == keyv1[n]);
+ }
+
+ keym0 = rct::keyMInit(9, 12);
+ for (size_t n = 0; n < keym0.size(); ++n)
+ for (size_t i = 0; i < keym0[n].size(); ++i)
+ keym0[n][i] = rct::skGen();
+ ASSERT_TRUE(serialization::dump_binary(keym0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, keym1));
+ ASSERT_TRUE(keym0.size() == keym1.size());
+ for (size_t n = 0; n < keym0.size(); ++n)
+ {
+ ASSERT_TRUE(keym0[n].size() == keym1[n].size());
+ for (size_t i = 0; i < keym0[n].size(); ++i)
+ {
+ ASSERT_TRUE(keym0[n][i] == keym1[n][i]);
+ }
+ }
+
+ rct::skpkGen(ctkey0.dest, ctkey0.mask);
+ ASSERT_TRUE(serialization::dump_binary(ctkey0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, ctkey1));
+ ASSERT_TRUE(!memcmp(&ctkey0, &ctkey1, sizeof(ctkey0)));
+
+ ctkeyv0 = std::vector<rct::ctkey>(14);
+ for (size_t n = 0; n < ctkeyv0.size(); ++n)
+ rct::skpkGen(ctkeyv0[n].dest, ctkeyv0[n].mask);
+ ASSERT_TRUE(serialization::dump_binary(ctkeyv0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, ctkeyv1));
+ ASSERT_TRUE(ctkeyv0.size() == ctkeyv1.size());
+ for (size_t n = 0; n < ctkeyv0.size(); ++n)
+ {
+ ASSERT_TRUE(!memcmp(&ctkeyv0[n], &ctkeyv1[n], sizeof(ctkeyv0[n])));
+ }
+
+ ctkeym0 = std::vector<rct::ctkeyV>(9);
+ for (size_t n = 0; n < ctkeym0.size(); ++n)
+ {
+ ctkeym0[n] = std::vector<rct::ctkey>(11);
+ for (size_t i = 0; i < ctkeym0[n].size(); ++i)
+ rct::skpkGen(ctkeym0[n][i].dest, ctkeym0[n][i].mask);
+ }
+ ASSERT_TRUE(serialization::dump_binary(ctkeym0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, ctkeym1));
+ ASSERT_TRUE(ctkeym0.size() == ctkeym1.size());
+ for (size_t n = 0; n < ctkeym0.size(); ++n)
+ {
+ ASSERT_TRUE(ctkeym0[n].size() == ctkeym1[n].size());
+ for (size_t i = 0; i < ctkeym0.size(); ++i)
+ {
+ ASSERT_TRUE(!memcmp(&ctkeym0[n][i], &ctkeym1[n][i], sizeof(ctkeym0[n][i])));
+ }
+ }
+
+ ecdh0.mask = rct::skGen();
+ ecdh0.amount = rct::skGen();
+ ecdh0.senderPk = rct::skGen();
+ ASSERT_TRUE(serialization::dump_binary(ecdh0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, ecdh1));
+ ASSERT_TRUE(!memcmp(&ecdh0, &ecdh1, sizeof(ecdh0)));
+
+ for (size_t n = 0; n < 64; ++n)
+ {
+ asnl0.L1[n] = rct::skGen();
+ asnl0.s2[n] = rct::skGen();
+ }
+ asnl0.s = rct::skGen();
+ ASSERT_TRUE(serialization::dump_binary(asnl0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, asnl1));
+ ASSERT_TRUE(!memcmp(&asnl0, &asnl1, sizeof(asnl0)));
+
+ // create a full rct signature to use its innards
+ rct::ctkeyV sc, pc;
+ rct::ctkey sctmp, pctmp;
+ tie(sctmp, pctmp) = rct::ctskpkGen(6000);
+ sc.push_back(sctmp);
+ pc.push_back(pctmp);
+ tie(sctmp, pctmp) = rct::ctskpkGen(7000);
+ sc.push_back(sctmp);
+ pc.push_back(pctmp);
+ vector<uint64_t> amounts;
+ //add output 500
+ amounts.push_back(500);
+ rct::keyV destinations;
+ rct::key Sk, Pk;
+ rct::skpkGen(Sk, Pk);
+ destinations.push_back(Pk);
+ //add output for 12500
+ amounts.push_back(12500);
+ rct::skpkGen(Sk, Pk);
+ destinations.push_back(Pk);
+ //compute rct data with mixin 500
+ s0 = rct::genRct(sc, pc, destinations, amounts, 3);
+
+ mg0 = s0.MG;
+ ASSERT_TRUE(serialization::dump_binary(mg0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, mg1));
+ ASSERT_TRUE(mg0.ss.size() == mg1.ss.size());
+ for (size_t n = 0; n < mg0.ss.size(); ++n)
+ {
+ ASSERT_TRUE(mg0.ss[n] == mg1.ss[n]);
+ }
+ ASSERT_TRUE(mg0.cc == mg1.cc);
+ ASSERT_TRUE(mg0.II.size() == mg1.II.size());
+ for (size_t n = 0; n < mg0.II.size(); ++n)
+ {
+ ASSERT_TRUE(mg0.II[n] == mg1.II[n]);
+ }
+
+ rg0 = s0.rangeSigs.front();
+ ASSERT_TRUE(serialization::dump_binary(rg0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, rg1));
+ ASSERT_TRUE(!memcmp(&rg0, &rg1, sizeof(rg0)));
+
+ ASSERT_TRUE(serialization::dump_binary(s0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, s1));
+ ASSERT_TRUE(s0.rangeSigs.size() == s1.rangeSigs.size());
+ for (size_t n = 0; n < s0.rangeSigs.size(); ++n)
+ {
+ ASSERT_TRUE(!memcmp(&s0.rangeSigs[n], &s1.rangeSigs[n], sizeof(s0.rangeSigs[n])));
+ }
+ ASSERT_TRUE(s0.MG.ss.size() == s1.MG.ss.size());
+ for (size_t n = 0; n < s0.MG.ss.size(); ++n)
+ {
+ ASSERT_TRUE(s0.MG.ss[n] == s1.MG.ss[n]);
+ }
+ ASSERT_TRUE(s0.MG.cc == s1.MG.cc);
+ ASSERT_TRUE(s0.MG.II.size() == s1.MG.II.size());
+ for (size_t n = 0; n < s0.MG.II.size(); ++n)
+ {
+ ASSERT_TRUE(s0.MG.II[n] == s1.MG.II[n]);
+ }
+ ASSERT_TRUE(s0.mixRing.size() == s1.mixRing.size());
+ for (size_t n = 0; n < s0.mixRing.size(); ++n)
+ {
+ ASSERT_TRUE(s0.mixRing[n].size() == s1.mixRing[n].size());
+ for (size_t i = 0; i < s0.mixRing[n].size(); ++i)
+ {
+ ASSERT_TRUE(!memcmp(&s0.mixRing[n][i], &s1.mixRing[n][i], sizeof(s0.mixRing[n][i])));
+ }
+ }
+ ASSERT_TRUE(s0.ecdhInfo.size() == s1.ecdhInfo.size());
+ for (size_t n = 0; n < s0.ecdhInfo.size(); ++n)
+ {
+ ASSERT_TRUE(!memcmp(&s0.ecdhInfo[n], &s1.ecdhInfo[n], sizeof(s0.ecdhInfo[n])));
+ }
+ ASSERT_TRUE(s0.outPk.size() == s1.outPk.size());
+ for (size_t n = 0; n < s0.outPk.size(); ++n)
+ {
+ ASSERT_TRUE(!memcmp(&s0.outPk[n], &s1.outPk[n], sizeof(s0.outPk[n])));
+ }
+
+ tx0.set_null();
+ tx0.version = 2;
+ cryptonote::txin_to_key txin_to_key1;
+ txin_to_key1.key_offsets.resize(2);
+ cryptonote::txin_to_key txin_to_key2;
+ txin_to_key2.key_offsets.resize(2);
+ tx0.vin.push_back(txin_to_key1);
+ tx0.vin.push_back(txin_to_key2);
+ tx0.vout.push_back(cryptonote::tx_out());
+ tx0.rct_signatures = s0;
+ ASSERT_EQ(tx0.rct_signatures.rangeSigs.size(), 2);
+ ASSERT_TRUE(serialization::dump_binary(tx0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, tx1));
+ ASSERT_EQ(tx1.rct_signatures.rangeSigs.size(), 2);
+ std::string blob2;
+ ASSERT_TRUE(serialization::dump_binary(tx1, blob2));
+ ASSERT_TRUE(blob == blob2);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-20 07:32:13 +0000