Initial test files for lot49 / bls testing

.gitignore

@@ -0,0 +1,29 @@
+CMakeCache.txt
+CMakeFiles
+cmake_install.cmake
+Makefile
+build/*
+
+main
+.o
+obj/
+src/*.o
+
+.vscode
+
+.dirstamp
+.libs
+.*.swp
+*.*~*
+*.bak
+*.rej
+*.orig
+*.pyc
+*.o
+*.o-*
+*.patch
+*.a
+*.pb.cc
+*.pb.h
+
+**/.DS_Store

CMakeLists.txt

@@ -0,0 +1,21 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 3.1.0 FATAL_ERROR)
+project (Lot49)
+
+# The version number.
+set (Lot49_VERSION_MAJOR 0)
+set (Lot49_VERSION_MINOR 1)
+set (CMAKE_CXX_STANDARD 11)
+
+include_directories(
+  ${INCLUDE_DIRECTORIES}
+  ${CMAKE_CURRENT_SOURCE_DIR}/bls-signatures/src
+  ${CMAKE_CURRENT_SOURCE_DIR}/bls-signatures/contrib/relic/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/bls-signatures/build/contrib/relic/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/bls-signatures/contrib/catch  
+  )
+
+add_library(bls STATIC IMPORTED)
+set_target_properties(bls PROPERTIES IMPORTED_LOCATION ${CMAKE_CURRENT_SOURCE_DIR}/bls-signatures/build/libbls.a)
+
+add_executable(lot49 lot49.cpp)
+target_link_libraries(lot49 bls)

lot49.cpp

@@ -0,0 +1,156 @@
+
+#include "bls.hpp"
+
+using namespace std;
+
+int main(int argc, char* argv[]) 
+{
+    cout << "start." << endl;
+    //
+    // Creating keys and signatures
+    //
+
+    // Example seed, used to generate private key. Always use
+    // a secure RNG with sufficient entropy to generate a seed.
+    uint8_t seed[] = {0, 50, 6, 244, 24, 199, 1, 25, 52, 88, 192,
+                      19, 18, 12, 89, 6, 220, 18, 102, 58, 209,
+                      82, 12, 62, 89, 110, 182, 9, 44, 20, 254, 22};
+
+    bls::PrivateKey sk = bls::PrivateKey::FromSeed(seed, sizeof(seed));
+    bls::PublicKey pk = sk.GetPublicKey();
+
+    uint8_t msg[] = {100, 2, 254, 88, 90, 45, 23};
+
+    bls::Signature sig = sk.Sign(msg, sizeof(msg));
+
+    //
+    // Serializing keys and signatures to bytes
+    //
+
+    uint8_t skBytes[bls::PrivateKey::PRIVATE_KEY_SIZE]; // 32 byte array
+    uint8_t pkBytes[bls::PublicKey::PUBLIC_KEY_SIZE];   // 48 byte array
+    uint8_t sigBytes[bls::Signature::SIGNATURE_SIZE];   // 96 byte array
+
+    sk.Serialize(skBytes);   // 32 bytes
+    pk.Serialize(pkBytes);   // 48 bytes
+    sig.Serialize(sigBytes); // 96 bytes
+
+    //
+    // Loading keys and signatures from bytes
+    //
+
+    // Takes array of 32 bytes
+    sk = bls::PrivateKey::FromBytes(skBytes);
+
+    // Takes array of 48 bytes
+    pk = bls::PublicKey::FromBytes(pkBytes);
+
+    // Takes array of 96 bytes
+    sig = bls::Signature::FromBytes(sigBytes);
+
+    //
+    // Verifying signatures
+    //
+
+    // Add information required for verification, to sig object
+    sig.SetAggregationInfo(bls::AggregationInfo::FromMsg(pk, msg, sizeof(msg)));
+
+    bool ok = sig.Verify();
+
+    //
+    // Aggregate signatures for a single message
+    //
+
+    {
+        // Generate some more private keys
+        seed[0] = 1;
+        bls::PrivateKey sk1 = bls::PrivateKey::FromSeed(seed, sizeof(seed));
+        seed[0] = 2;
+        bls::PrivateKey sk2 = bls::PrivateKey::FromSeed(seed, sizeof(seed));
+
+        // Generate first sig
+        bls::PublicKey pk1 = sk1.GetPublicKey();
+        bls::Signature sig1 = sk1.Sign(msg, sizeof(msg));
+
+        // Generate second sig
+        bls::PublicKey pk2 = sk2.GetPublicKey();
+        bls::Signature sig2 = sk2.Sign(msg, sizeof(msg));
+
+        // Aggregate signatures together
+        vector<bls::Signature> sigs = {sig1, sig2};
+        bls::Signature aggSig = bls::Signature::AggregateSigs(sigs);
+
+        // For same message, public keys can be aggregated into one.
+        // The signature can be verified the same as a single signature,
+        // using this public key.
+        vector<bls::PublicKey> pubKeys = {pk1, pk2};
+
+        bls::PublicKey aggPubKey = bls::PublicKey::Aggregate(pubKeys);
+    }
+
+    //
+    // Aggregate signatures for different messages
+    //
+
+    // Generate one more key and message
+    seed[0] = 1;
+    bls::PrivateKey sk1 = bls::PrivateKey::FromSeed(seed, sizeof(seed));
+    bls::PublicKey pk1 = sk1.GetPublicKey();
+
+    seed[0] = 2;
+    bls::PrivateKey sk2 = bls::PrivateKey::FromSeed(seed, sizeof(seed));
+    bls::PublicKey pk2 = sk2.GetPublicKey();
+
+    seed[0] = 3;
+    bls::PrivateKey sk3 = bls::PrivateKey::FromSeed(seed, sizeof(seed));
+    bls::PublicKey pk3 = sk3.GetPublicKey();
+    uint8_t msg2[] = {100, 2, 254, 88, 90, 45, 23};
+
+    // Generate the signatures, assuming we have 3 private keys
+    bls::Signature sig1 = sk1.Sign(msg, sizeof(msg));
+    bls::Signature sig2 = sk2.Sign(msg, sizeof(msg));
+    bls::Signature sig3 = sk3.Sign(msg2, sizeof(msg2));
+
+    // They can be noninteractively combined by anyone
+    // Aggregation below can also be done by the verifier, to
+    // make batch verification more efficient
+    vector<bls::Signature> sigsL = {sig1, sig2};
+    bls::Signature aggSigL = bls::Signature::AggregateSigs(sigsL);
+
+    // Arbitrary trees of aggregates
+    vector<bls::Signature> sigsFinal = {aggSigL, sig3};
+    bls::Signature aggSigFinal = bls::Signature::AggregateSigs(sigsFinal);
+
+    // Serialize the final signature
+    aggSigFinal.Serialize(sigBytes);
+
+    //
+    // Verify aggregate signature for different messages
+    //
+
+    // Deserialize aggregate signature
+    aggSigFinal = bls::Signature::FromBytes(sigBytes);
+
+    // Create aggregation information (or deserialize it)
+    bls::AggregationInfo a1 = bls::AggregationInfo::FromMsg(pk1, msg, sizeof(msg));
+    bls::AggregationInfo a2 = bls::AggregationInfo::FromMsg(pk2, msg, sizeof(msg));
+    bls::AggregationInfo a3 = bls::AggregationInfo::FromMsg(pk3, msg2, sizeof(msg2));
+    vector<bls::AggregationInfo> infos = {a1, a2};
+    bls::AggregationInfo a1a2 = bls::AggregationInfo::MergeInfos(infos);
+    vector<bls::AggregationInfo> infos2 = {a1a2, a3};
+    bls::AggregationInfo aFinal = bls::AggregationInfo::MergeInfos(infos2);
+
+    // Verify final signature using the aggregation info
+    aggSigFinal.SetAggregationInfo(aFinal);
+    ok = aggSigFinal.Verify();
+
+    // If you previously verified a signature, you can also divide
+    // the aggregate signature by the signature you already verified.
+    ok = aggSigL.Verify();
+    vector<bls::Signature> cache = {aggSigL};
+    aggSigFinal = aggSigFinal.DivideBy(cache);
+
+    // Final verification is now more efficient
+    ok = aggSigFinal.Verify();
+    cout << "done." << endl;
+}