+CVS

+bin/*.exe

+lib/*.a

+lib/*.so

+lib/*.dylib

+obj/*.d

+obj/*.o

+sudo: true

+dist: xenial

+services:

+- docker

+env:

+ global:

+ - IMAGE_TAG=dexonfoundation/bls-go-alpine

+ - DOCKER_USER=spiderpowadeploy

+ - secure: mqNCngWukyjE3UARxaPjqS0xgC1dsnWfmPhpH2mq7nR6S2cGfJ3xBfyiTS//Clz//7sAL+Tp62r3fxyMjDogrSHZUUssCAwf17RM6vnALqaVbc3wXcTNudiDB5cVKe9C9gZqn1Ivd+qbmtuCezSrOG5Xih1gh4bPTyiFvU1sp9C2icMHkJZkjsP0QqCbHlQrMeECSIPlEGIOXUUSp+WmrZAdi2rHezKeZxuaT73RX1+N/+1RfWXo2MR4ydQU3eALl5s5UA9JweQO+MYIVr8EEpGNqJRYUyURx/5G/Sy2v6Z3imUvXZv1J5aplW/UDls92Olla1JHuvFW6ptRO+PHITNwvEkhxPFj+HcOpqEuSISsdk9rkHUrM0wEYPv6A4vQPUjMHrLQs2tQShVCelM1HtNvDDjttKMmVyRLusFP9eS7uvmmXu2l6efJjsMSFkY5WKbu2U0MQ1j708KH9k2WunU6sjJ+b74PkkZVtkQMIqgTokC0IOqbbrnwh4I9PpVpHAQrewRimMH+lDHk+HlMUCWk7/IcIFUl+mh6RzW2vkZTTr2ctSBI6QzK5smdPmqQpp2lqkGv/hQCBp5ICzFSkU6Djqe3hG8ta3+/Zhi10fPU2HcHDi+gR79CG8dvy+iOeTS2csXZx+YoN2BVkfu9AnrjZ9Kjkf9BMay4CehBUWE=

+language: cpp

+compiler:

+- gcc

+- clang

+addons:

+ apt:

+ packages:

+ - libgmp-dev

+install:

+- git clone --depth 1 https://github.com/dexon-foundation/mcl.git $TRAVIS_BUILD_DIR/../mcl

+script:

+- make -j3

+- make test_ci DISABLE_THREAD_TEST=1

+- make test_go

+- env LD_LIBRARY_PATH=../mcl/lib bin/bls_c384_test.exe

+- make clean && make -C ../mcl clean

+- make -j3 MCL_USE_OPENSSL=0

+- make test_ci DISABLE_THREAD_TEST=1 MCL_USE_OPENSSL=0

+- docker build --tag "$IMAGE_TAG" . -f images/bls-go-alpine/Dockerfile --no-cache

+before_deploy:

+- echo "$DOCKER_PASS" | docker login -u "$DOCKER_USER" --password-stdin

+- git_commit="$(git rev-parse --short HEAD)"

+- docker tag "$IMAGE_TAG" "${IMAGE_TAG}:${git_commit}"

+- docker tag "$IMAGE_TAG" "${IMAGE_TAG}:latest"

+deploy:

+ provider: script

+ script: docker push "${IMAGE_TAG}:latest" && docker push "${IMAGE_TAG}:${git_commit}"

+ on:

+ branch: dev

+ condition: "$CC = gcc"

+cmake_minimum_required (VERSION 2.6)

+project(bls CXX ASM)

+

+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)

+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)

+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)

+

+set(LIBS mcl gmp)

+

+include_directories(include/)

+

+add_library(bls_c256 SHARED src/bls_c256.cpp)

+add_library(bls_c384 SHARED src/bls_c384.cpp)

+add_library(bls_c384_256 SHARED src/bls_c384_256.cpp)

+target_link_libraries(bls_c256 ${LIBS})

+target_link_libraries(bls_c384 ${LIBS})

+target_link_libraries(bls_c384_256 ${LIBS})

+

+file(GLOB BLS_HEADERS include/bls/bls.h include/bls/bls.hpp)

+

+install(TARGETS bls_c256 DESTINATION lib)

+install(TARGETS bls_c384 DESTINATION lib)

+install(TARGETS bls_c384_256 DESTINATION lib)

+install(FILES ${BLS_HEADERS} DESTINATION include/bls)

+

+set(TEST_LIBS pthread gmpxx)

+

+add_executable(bls_c256_test test/bls_c256_test.cpp)

+target_link_libraries(bls_c256_test bls_c256 ${TEST_LIBS})

+add_executable(bls_c384_test test/bls_c384_test.cpp)

+target_link_libraries(bls_c384_test bls_c384 ${TEST_LIBS})

+add_executable(bls_c384_256_test test/bls_c384_256_test.cpp)

+target_link_libraries(bls_c384_256_test bls_c384_256 ${TEST_LIBS})

+ifeq ($(findstring MINGW64,$(shell uname -s)),MINGW64)

+ # cgo accepts not '/c/path' but 'c:/path'

+ PWD=$(shell pwd|sed s'@^/\([a-z]\)@\1:@')

+else

+ PWD=$(shell pwd)

+endif

+MCL_DIR?=$(PWD)/../mcl

+include $(MCL_DIR)/common.mk

+LIB_DIR=lib

+OBJ_DIR=obj

+EXE_DIR=bin

+CFLAGS += -std=c++11

+LDFLAGS += -lpthread

+

+SRC_SRC=bls_c256.cpp bls_c384.cpp bls_c384_256.cpp

+TEST_SRC=bls256_test.cpp bls384_test.cpp bls384_256_test.cpp bls_c256_test.cpp bls_c384_test.cpp bls_c384_256_test.cpp

+SAMPLE_SRC=bls256_smpl.cpp bls384_smpl.cpp

+

+CFLAGS+=-I$(MCL_DIR)/include

+ifneq ($(MCL_MAX_BIT_SIZE),)

+ CFLAGS+=-DMCL_MAX_BIT_SIZE=$(MCL_MAX_BIT_SIZE)

+endif

+ifeq ($(DISABLE_THREAD_TEST),1)

+ CFLAGS+=-DDISABLE_THREAD_TEST

+endif

+ifeq ($(BLS_SWAP_G),1)

+ CFLAGS+=-DBLS_SWAP_G

+endif

+

+BLS256_LIB=$(LIB_DIR)/libbls256.a

+BLS384_LIB=$(LIB_DIR)/libbls384.a

+BLS384_256_LIB=$(LIB_DIR)/libbls384_256.a

+BLS256_SNAME=bls256

+BLS384_SNAME=bls384

+BLS384_256_SNAME=bls384_256

+BLS256_SLIB=$(LIB_DIR)/lib$(BLS256_SNAME).$(LIB_SUF)

+BLS384_SLIB=$(LIB_DIR)/lib$(BLS384_SNAME).$(LIB_SUF)

+BLS384_256_SLIB=$(LIB_DIR)/lib$(BLS384_256_SNAME).$(LIB_SUF)

+all: $(BLS256_LIB) $(BLS256_SLIB) $(BLS384_LIB) $(BLS384_SLIB) $(BLS384_256_LIB) $(BLS384_256_SLIB)

+

+MCL_LIB=$(MCL_DIR)/lib/libmcl.a

+

+$(MCL_LIB):

+ $(MAKE) -C $(MCL_DIR)

+

+$(BLS256_LIB): $(OBJ_DIR)/bls_c256.o $(MCL_LIB)

+ $(AR) $@ $<

+$(BLS384_LIB): $(OBJ_DIR)/bls_c384.o $(MCL_LIB)

+ $(AR) $@ $<

+$(BLS384_256_LIB): $(OBJ_DIR)/bls_c384_256.o $(MCL_LIB)

+ $(AR) $@ $<

+

+ifneq ($(findstring $(OS),mac/mingw64),)

+ COMMON_LIB=$(GMP_LIB) $(OPENSSL_LIB) -lstdc++

+ BLS256_SLIB_LDFLAGS+=$(COMMON_LIB)

+ BLS384_SLIB_LDFLAGS+=$(COMMON_LIB)

+ BLS384_256_SLIB_LDFLAGS+=$(COMMON_LIB)

+endif

+ifeq ($(OS),mingw64)

+ CFLAGS+=-I$(MCL_DIR)

+ BLS256_SLIB_LDFLAGS+=-Wl,--out-implib,$(LIB_DIR)/lib$(BLS256_SNAME).a

+ BLS384_SLIB_LDFLAGS+=-Wl,--out-implib,$(LIB_DIR)/lib$(BLS384_SNAME).a

+ BLS384_256_SLIB_LDFLAGS+=-Wl,--out-implib,$(LIB_DIR)/lib$(BLS384_256_SNAME).a

+endif

+$(BLS256_SLIB): $(OBJ_DIR)/bls_c256.o $(MCL_LIB)

+ $(PRE)$(CXX) -shared -o $@ $< -L$(MCL_DIR)/lib -lmcl $(BLS256_SLIB_LDFLAGS) $(LDFLAGS)

+$(BLS384_SLIB): $(OBJ_DIR)/bls_c384.o $(MCL_LIB)

+ $(PRE)$(CXX) -shared -o $@ $< -L$(MCL_DIR)/lib -lmcl $(BLS384_SLIB_LDFLAGS) $(LDFLAGS)

+$(BLS384_256_SLIB): $(OBJ_DIR)/bls_c384_256.o $(MCL_LIB)

+ $(PRE)$(CXX) -shared -o $@ $< -L$(MCL_DIR)/lib -lmcl $(BLS384_256_SLIB_LDFLAGS) $(LDFLAGS)

+

+VPATH=test sample src

+

+.SUFFIXES: .cpp .d .exe

+

+$(OBJ_DIR)/%.o: %.cpp

+ $(PRE)$(CXX) $(CFLAGS) -c $< -o $@ -MMD -MP -MF $(@:.o=.d)

+

+$(EXE_DIR)/%384_256_test.exe: $(OBJ_DIR)/%384_256_test.o $(BLS384_256_LIB) $(MCL_LIB)

+ $(PRE)$(CXX) $< -o $@ $(BLS384_256_LIB) -L$(MCL_DIR)/lib -lmcl $(LDFLAGS)

+

+$(EXE_DIR)/%384_test.exe: $(OBJ_DIR)/%384_test.o $(BLS384_LIB) $(MCL_LIB)

+ $(PRE)$(CXX) $< -o $@ $(BLS384_LIB) -L$(MCL_DIR)/lib -lmcl $(LDFLAGS)

+

+$(EXE_DIR)/%256_test.exe: $(OBJ_DIR)/%256_test.o $(BLS256_LIB) $(MCL_LIB)

+ $(PRE)$(CXX) $< -o $@ $(BLS256_LIB) -L$(MCL_DIR)/lib -lmcl $(LDFLAGS)

+

+# sample exe links libbls256.a

+$(EXE_DIR)/%.exe: $(OBJ_DIR)/%.o $(BLS256_LIB) $(MCL_LIB)

+ $(PRE)$(CXX) $< -o $@ $(BLS256_LIB) -L$(MCL_DIR)/lib -lmcl $(LDFLAGS)

+ifeq ($(OS),mac)

+ install_name_tool bin/bls_smpl.exe -change lib/libmcl.dylib $(MCL_DIR)/lib/libmcl.dylib

+endif

+

+SAMPLE_EXE=$(addprefix $(EXE_DIR)/,$(SAMPLE_SRC:.cpp=.exe))

+sample: $(SAMPLE_EXE)

+

+TEST_EXE=$(addprefix $(EXE_DIR)/,$(TEST_SRC:.cpp=.exe))

+ifeq ($(OS),mac)

+ LIBPATH_KEY=DYLD_LIBRARY_PATH

+else

+ LIBPATH_KEY=LD_LIBRARY_PATH

+endif

+test_ci: $(TEST_EXE)

+ @sh -ec 'for i in $(TEST_EXE); do echo $$i; env PATH=$$PATH:../mcl/lib $(LIBPATH_KEY)=../mcl/lib LSAN_OPTIONS=verbosity=1 log_threads=1 $$i; done'

+ $(MAKE) sample_test

+

+test: $(TEST_EXE)

+ @echo test $(TEST_EXE)

+ @sh -ec 'for i in $(TEST_EXE); do env PATH=$$PATH:../mcl/lib $(LIBPATH_KEY)=../mcl/lib $$i|grep "ctest:name"; done' > result.txt

+ @grep -v "ng=0, exception=0" result.txt; if [ $$? -eq 1 ]; then echo "all unit tests succeed"; else exit 1; fi

+ $(MAKE) sample_test

+

+sample_test: $(EXE_DIR)/bls_smpl.exe

+ env PATH=$$PATH:../mcl/lib $(LIBPATH_KEY)=../mcl/lib python bls_smpl.py

+

+# PATH is for mingw, LD_LIBRARY_PATH is for linux, DYLD_LIBRARY_PATH is for mac

+COMMON_LIB_PATH="../../../lib:../../../../mcl/lib"

+PATH_VAL=$$PATH:$(COMMON_LIB_PATH) LD_LIBRARY_PATH=$(COMMON_LIB_PATH) DYLD_LIBRARY_PATH=$(COMMON_LIB_PATH)

+test_go256: ffi/go/bls/bls.go ffi/go/bls/bls_test.go $(BLS256_LIB)

+ cd ffi/go/bls && env PATH=$(PATH_VAL) go test -tags bn256 .

+test_go384: ffi/go/bls/bls.go ffi/go/bls/bls_test.go $(BLS384_LIB)

+ cd ffi/go/bls && env PATH=$(PATH_VAL) go test -tags bn384 .

+test_go384_256: ffi/go/bls/bls.go ffi/go/bls/bls_test.go $(BLS384_256_LIB)

+ cd ffi/go/bls && env PATH=$(PATH_VAL) go test -tags bn384_256 .

+

+test_go:

+ $(MAKE) test_go256

+ $(MAKE) test_go384

+ $(MAKE) test_go384_256

+

+EMCC_OPT=-I./include -I./src -I../mcl/include -I./ -Wall -Wextra

+EMCC_OPT+=-O3 -DNDEBUG

+EMCC_OPT+=-s WASM=1 -s NO_EXIT_RUNTIME=1 -s MODULARIZE=1 #-s ASSERTIONS=1

+EMCC_OPT+=-DCYBOZU_MINIMUM_EXCEPTION

+EMCC_OPT+=-s ABORTING_MALLOC=0

+EMCC_OPT+=-DMCLBN_FP_UNIT_SIZE=6

+JS_DEP=src/bls_c384.cpp ../mcl/src/fp.cpp Makefile

+

+../bls-wasm/bls_c.js: $(JS_DEP)

+ emcc -o $@ src/bls_c384.cpp ../mcl/src/fp.cpp $(EMCC_OPT) -DMCL_MAX_BIT_SIZE=384 -DMCL_USE_WEB_CRYPTO_API -s DISABLE_EXCEPTION_CATCHING=1 -DCYBOZU_DONT_USE_EXCEPTION -DCYBOZU_DONT_USE_STRING -DMCL_DONT_USE_CSPRNG -fno-exceptions -MD -MP -MF obj/bls_c384.d

+

+bls-wasm:

+ $(MAKE) ../bls-wasm/bls_c.js

+

+clean:

+ $(RM) $(OBJ_DIR)/*.d $(OBJ_DIR)/*.o $(EXE_DIR)/*.exe $(GEN_EXE) $(ASM_SRC) $(ASM_OBJ) $(LLVM_SRC) $(BLS256_LIB) $(BLS256_SLIB) $(BLS384_LIB) $(BLS384_SLIB) $(BLS384_256_LIB) $(BLS384_256_SLIB)

+

+ALL_SRC=$(SRC_SRC) $(TEST_SRC) $(SAMPLE_SRC)

+DEPEND_FILE=$(addprefix $(OBJ_DIR)/, $(ALL_SRC:.cpp=.d))

+-include $(DEPEND_FILE)

+

+PREFIX?=/usr/local

+install: lib/libbls256.a lib/libbls256.$(LIB_SUF) lib/libbls384.a lib/libbls384.$(LIB_SUF) lib/libbls384_256.a lib/libbls384_256.$(LIB_SUF)

+ $(MKDIR) $(PREFIX)/include/bls

+ cp -a include/bls/ $(PREFIX)/include/

+ $(MKDIR) $(PREFIX)/lib

+ cp -a lib/libbls256.a lib/libbls256.$(LIB_SUF) lib/libbls384.a lib/libbls384.$(LIB_SUF) lib/libbls384_256.a lib/libbls384_256.$(LIB_SUF) $(PREFIX)/lib/

+

+.PHONY: test bls-wasm

+

+# don't remove these files automatically

+.SECONDARY: $(addprefix $(OBJ_DIR)/, $(ALL_SRC:.cpp=.o))

+

+Microsoft Visual Studio Solution File, Format Version 12.00

+# Visual Studio 2013

+VisualStudioVersion = 12.0.40629.0

+MinimumVisualStudioVersion = 10.0.40219.1

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bls_test", "test\proj\bls_test\bls_test.vcxproj", "{51266DE6-B57B-4AE3-B85C-282F170E1728}"

+ ProjectSection(ProjectDependencies) = postProject

+ {1DBB979A-C212-45CD-9563-446A96F87F71} = {1DBB979A-C212-45CD-9563-446A96F87F71}

+ EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bls", "src\proj\bls.vcxproj", "{1DBB979A-C212-45CD-9563-446A96F87F71}"

+EndProject

+Global

+ GlobalSection(SolutionConfigurationPlatforms) = preSolution

+ Debug|x64 = Debug|x64

+ Release|x64 = Release|x64

+ EndGlobalSection

+ GlobalSection(ProjectConfigurationPlatforms) = postSolution

+ {51266DE6-B57B-4AE3-B85C-282F170E1728}.Debug|x64.ActiveCfg = Debug|x64

+ {51266DE6-B57B-4AE3-B85C-282F170E1728}.Debug|x64.Build.0 = Debug|x64

+ {51266DE6-B57B-4AE3-B85C-282F170E1728}.Release|x64.ActiveCfg = Release|x64

+ {51266DE6-B57B-4AE3-B85C-282F170E1728}.Release|x64.Build.0 = Release|x64

+ {1DBB979A-C212-45CD-9563-446A96F87F71}.Debug|x64.ActiveCfg = Debug|x64

+ {1DBB979A-C212-45CD-9563-446A96F87F71}.Debug|x64.Build.0 = Debug|x64

+ {1DBB979A-C212-45CD-9563-446A96F87F71}.Release|x64.ActiveCfg = Release|x64

+ {1DBB979A-C212-45CD-9563-446A96F87F71}.Release|x64.Build.0 = Release|x64

+ EndGlobalSection

+ GlobalSection(SolutionProperties) = preSolution

+ HideSolutionNode = FALSE

+ EndGlobalSection

+EndGlobal

+import os, sys, subprocess

+

+EXE='bin/bls_smpl.exe'

+

+def init():

+ subprocess.check_call([EXE, "init"])

+

+def sign(m, i=0):

+ subprocess.check_call([EXE, "sign", "-m", m, "-id", str(i)])

+

+def verify(m, i=0):

+ subprocess.check_call([EXE, "verify", "-m", m, "-id", str(i)])

+

+def share(n, k):

+ subprocess.check_call([EXE, "share", "-n", str(n), "-k", str(k)])

+

+def recover(ids):

+ cmd = [EXE, "recover", "-ids"]

+ for i in ids:

+ cmd.append(str(i))

+ subprocess.check_call(cmd)

+

+def main():

+ m = "hello bls threshold signature"

+ n = 10

+ ids = [1, 5, 3, 7]

+ k = len(ids)

+ init()

+ sign(m)

+ verify(m)

+ share(n, k)

+ for i in ids:

+ sign(m, i)

+ verify(m, i)

+ subprocess.check_call(["rm", "sample/sign.txt"])

+ recover(ids)

+ verify(m)

+

+if __name__ == '__main__':

+ main()

+<?xml version="1.0" encoding="utf-8"?>

+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+ <ImportGroup Label="PropertySheets" />

+ <PropertyGroup Label="UserMacros" />

+ <PropertyGroup>

+ <OutDir>$(SolutionDir)bin\</OutDir>

+ </PropertyGroup>

+ <ItemDefinitionGroup>

+ <ClCompile>

+ <AdditionalIncludeDirectories>$(SolutionDir)../cybozulib/include;$(SolutionDir)../cybozulib_ext/include;$(SolutionDir)include;$(SolutionDir)../mcl/include</AdditionalIncludeDirectories>

+ </ClCompile>

+ </ItemDefinitionGroup>

+ <ItemDefinitionGroup>

+ <ClCompile>

+ <WarningLevel>Level4</WarningLevel>

+ <RuntimeLibrary>MultiThreaded</RuntimeLibrary>

+ <PrecompiledHeaderFile />

+ <PrecompiledHeaderOutputFile />

+ <PreprocessorDefinitions>_MBCS;%(PreprocessorDefinitions);NOMINMAX;BLS_MAX_OP_UNIT_SIZE=6</PreprocessorDefinitions>

+ </ClCompile>

+ <Link>

+ <AdditionalLibraryDirectories>$(SolutionDir)../cybozulib_ext/lib;$(SolutionDir)../mcl/lib;$(SolutionDir)lib</AdditionalLibraryDirectories>

+ </Link>

+ </ItemDefinitionGroup>

+ <ItemGroup />

+</Project>

+<?xml version="1.0" encoding="utf-8"?>

+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+ <ImportGroup Label="PropertySheets" />

+ <PropertyGroup Label="UserMacros" />

+ <PropertyGroup>

+ <TargetName>$(ProjectName)d</TargetName>

+ </PropertyGroup>

+ <ItemDefinitionGroup>

+ <ClCompile>

+ <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>

+ </ClCompile>

+ </ItemDefinitionGroup>

+ <ItemGroup />

+</Project> \ No newline at end of file

+<?xml version="1.0" encoding="utf-8"?>

+<configuration>

+ <startup>

+ <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.2"/>

+ </startup>

+</configuration>

+using System.Reflection;

+using System.Runtime.CompilerServices;

+using System.Runtime.InteropServices;

+

+// アセンブリ�関�る一般情報�以下�属性セットを����制御�れ��。

+// アセンブリ�関連付�られ��る情報を変更�る���

+// �れら�属性値を変更������。

+[assembly: AssemblyTitle("bls256")]

+[assembly: AssemblyDescription("")]

+[assembly: AssemblyConfiguration("")]

+[assembly: AssemblyCompany("")]

+[assembly: AssemblyProduct("bls256")]

+[assembly: AssemblyCopyright("Copyright © 2017")]

+[assembly: AssemblyTrademark("")]

+[assembly: AssemblyCulture("")]

+

+// ComVisible を false �設定�る����型���アセンブリ内� COM コン�ー�ント�ら

+// �照��能��り��。COM �ら��アセンブリ内�型�アクセス�る場���

+// ��型� ComVisible 属性を true �設定������。

+[assembly: ComVisible(false)]

+

+// ��プロジェクト� COM �公開�れる場��次� GUID � typelib � ID ��り��

+[assembly: Guid("e9d06b1b-ea22-4ef4-ba4b-422f7625966c")]

+

+// アセンブリ��ージョン情報�次� 4 ��値�構��れ����:

+//

+// メジャー �ージョン

+// マイナー �ージョン

+// ビルド番�

+// Revision

+//

+// ����値を指定�る��下�よ�� '*' を使��ビルド�よ�リビジョン番�を

+// 既定値��る�������:

+// [assembly: AssemblyVersion("1.0.*")]

+[assembly: AssemblyVersion("1.0.0.0")]

+[assembly: AssemblyFileVersion("1.0.0.0")]

+þ½Ž¿using System;

+using System.Text;

+using System.Runtime.InteropServices;

+

+namespace mcl

+{

+ class BLS

+ {

+ public const int BN254 = 0;

+ public const int BLS12_381 = 5;

+

+ const int IoEcComp = 512; // fixed byte representation

+ public const int FR_UNIT_SIZE = 4;

+ public const int FP_UNIT_SIZE = 6; // 4 if bls256.dll is used

+ public const int COMPILED_TIME_VAR = FR_UNIT_SIZE * 10 + FP_UNIT_SIZE;

+

+ public const int ID_UNIT_SIZE = FR_UNIT_SIZE;

+ public const int SECRETKEY_UNIT_SIZE = FR_UNIT_SIZE;

+ public const int PUBLICKEY_UNIT_SIZE = FP_UNIT_SIZE * 3 * 2;

+ public const int SIGNATURE_UNIT_SIZE = FP_UNIT_SIZE * 3;

+

+ public const int ID_SERIALIZE_SIZE = FR_UNIT_SIZE * 8;

+ public const int SECRETKEY_SERIALIZE_SIZE = FR_UNIT_SIZE * 8;

+ public const int PUBLICKEY_SERIALIZE_SIZE = FP_UNIT_SIZE * 8 * 2;

+ public const int SIGNATURE_SERIALIZE_SIZE = FP_UNIT_SIZE * 8;

+

+ public const string dllName = FP_UNIT_SIZE == 4 ? "bls256.dll" : "bls384_256.dll";

+ [DllImport(dllName)]

+ public static extern int blsInit(int curveType, int compiledTimeVar);

+

+ [DllImport(dllName)] public static extern void blsIdSetInt(ref Id id, int x);

+ [DllImport(dllName)] public static extern int blsIdSetDecStr(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ [DllImport(dllName)] public static extern int blsIdSetHexStr(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ [DllImport(dllName)] public static extern ulong blsIdGetDecStr([Out]StringBuilder buf, ulong maxBufSize, in Id id);

+ [DllImport(dllName)] public static extern ulong blsIdGetHexStr([Out]StringBuilder buf, ulong maxBufSize, in Id id);

+

+ [DllImport(dllName)] public static extern ulong blsIdSerialize([Out]byte[] buf, ulong maxBufSize, in Id id);

+ [DllImport(dllName)] public static extern ulong blsSecretKeySerialize([Out]byte[] buf, ulong maxBufSize, in SecretKey sec);

+ [DllImport(dllName)] public static extern ulong blsPublicKeySerialize([Out]byte[] buf, ulong maxBufSize, in PublicKey pub);

+ [DllImport(dllName)] public static extern ulong blsSignatureSerialize([Out]byte[] buf, ulong maxBufSize, in Signature sig);

+ [DllImport(dllName)] public static extern ulong blsIdDeserialize(ref Id id, [In]byte[] buf, ulong bufSize);

+ [DllImport(dllName)] public static extern ulong blsSecretKeyDeserialize(ref SecretKey sec, [In]byte[] buf, ulong bufSize);

+ [DllImport(dllName)] public static extern ulong blsPublicKeyDeserialize(ref PublicKey pub, [In]byte[] buf, ulong bufSize);

+ [DllImport(dllName)] public static extern ulong blsSignatureDeserialize(ref Signature sig, [In]byte[] buf, ulong bufSize);

+

+ [DllImport(dllName)] public static extern int blsIdIsEqual(in Id lhs, in Id rhs);

+ [DllImport(dllName)] public static extern int blsSecretKeyIsEqual(in SecretKey lhs, in SecretKey rhs);

+ [DllImport(dllName)] public static extern int blsPublicKeyIsEqual(in PublicKey lhs, in PublicKey rhs);

+ [DllImport(dllName)] public static extern int blsSignatureIsEqual(in Signature lhs, in Signature rhs);

+ // add

+ [DllImport(dllName)] public static extern void blsSecretKeyAdd(ref SecretKey sec, in SecretKey rhs);

+ [DllImport(dllName)] public static extern void blsPublicKeyAdd(ref PublicKey pub, in PublicKey rhs);

+ [DllImport(dllName)] public static extern void blsSignatureAdd(ref Signature sig, in Signature rhs);

+ // hash buf and set

+ [DllImport(dllName)] public static extern int blsHashToSecretKey(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ /*

+ set secretKey if system has /dev/urandom or CryptGenRandom

+ return 0 if success else -1

+ */

+ [DllImport(dllName)] public static extern int blsSecretKeySetByCSPRNG(ref SecretKey sec);

+

+ [DllImport(dllName)] public static extern void blsGetPublicKey(ref PublicKey pub, in SecretKey sec);

+ [DllImport(dllName)] public static extern void blsGetPop(ref Signature sig, in SecretKey sec);

+

+ // return 0 if success

+ [DllImport(dllName)] public static extern int blsSecretKeyShare(ref SecretKey sec, in SecretKey msk, ulong k, in Id id);

+ [DllImport(dllName)] public static extern int blsPublicKeyShare(ref PublicKey pub, in PublicKey mpk, ulong k, in Id id);

+

+

+ [DllImport(dllName)] public static extern int blsSecretKeyRecover(ref SecretKey sec, in SecretKey secVec, in Id idVec, ulong n);

+ [DllImport(dllName)] public static extern int blsPublicKeyRecover(ref PublicKey pub, in PublicKey pubVec, in Id idVec, ulong n);

+ [DllImport(dllName)] public static extern int blsSignatureRecover(ref Signature sig, in Signature sigVec, in Id idVec, ulong n);

+

+ [DllImport(dllName)] public static extern void blsSign(ref Signature sig, in SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string m, ulong size);

+

+ // return 1 if valid

+ [DllImport(dllName)] public static extern int blsVerify(in Signature sig, in PublicKey pub, [In][MarshalAs(UnmanagedType.LPStr)] string m, ulong size);

+ [DllImport(dllName)] public static extern int blsVerifyPop(in Signature sig, in PublicKey pub);

+

+ //////////////////////////////////////////////////////////////////////////

+ // the following apis will be removed

+

+ // mask buf with (1 << (bitLen(r) - 1)) - 1 if buf >= r

+ [DllImport(dllName)] public static extern int blsIdSetLittleEndian(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ /*

+ return written byte size if success else 0

+ */

+ [DllImport(dllName)] public static extern ulong blsIdGetLittleEndian([Out]StringBuilder buf, ulong maxBufSize, in Id id);

+

+ // return 0 if success

+ // mask buf with (1 << (bitLen(r) - 1)) - 1 if buf >= r

+ [DllImport(dllName)] public static extern int blsSecretKeySetLittleEndian(ref SecretKey sec, [In]byte[] buf, ulong bufSize);

+ [DllImport(dllName)] public static extern int blsSecretKeySetDecStr(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ [DllImport(dllName)] public static extern int blsSecretKeySetHexStr(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ /*

+ return written byte size if success else 0

+ */

+ [DllImport(dllName)] public static extern ulong blsSecretKeyGetLittleEndian([Out]byte[] buf, ulong maxBufSize, in SecretKey sec);

+ /*

+ return strlen(buf) if success else 0

+ buf is '\0' terminated

+ */

+ [DllImport(dllName)] public static extern ulong blsSecretKeyGetDecStr([Out]StringBuilder buf, ulong maxBufSize, in SecretKey sec);

+ [DllImport(dllName)] public static extern ulong blsSecretKeyGetHexStr([Out]StringBuilder buf, ulong maxBufSize, in SecretKey sec);

+ [DllImport(dllName)] public static extern int blsPublicKeySetHexStr(ref PublicKey pub, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ [DllImport(dllName)] public static extern ulong blsPublicKeyGetHexStr([Out]StringBuilder buf, ulong maxBufSize, in PublicKey pub);

+ [DllImport(dllName)] public static extern int blsSignatureSetHexStr(ref Signature sig, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ [DllImport(dllName)] public static extern ulong blsSignatureGetHexStr([Out]StringBuilder buf, ulong maxBufSize, in Signature sig);

+

+ public static void Init(int curveType = BN254) {

+ if (!System.Environment.Is64BitProcess) {

+ throw new PlatformNotSupportedException("not 64-bit system");

+ }

+ int err = blsInit(curveType, COMPILED_TIME_VAR);

+ if (err != 0) {

+ throw new ArgumentException("blsInit");

+ }

+ }

+ [StructLayout(LayoutKind.Sequential)]

+ public unsafe struct Id

+ {

+ private fixed ulong v[ID_UNIT_SIZE];

+ public byte[] Serialize() {

+ byte[] buf = new byte[ID_SERIALIZE_SIZE];

+ ulong n = blsIdSerialize(buf, (ulong)buf.Length, this);

+ if (n == 0) {

+ throw new ArithmeticException("blsIdSerialize");

+ }

+ return buf;

+ }

+ public void Deserialize(byte[] buf) {

+ ulong n = blsIdDeserialize(ref this, buf, (ulong)buf.Length);

+ if (n == 0) {

+ throw new ArithmeticException("blsIdDeserialize");

+ }

+ }

+ public bool IsEqual(in Id rhs) {

+ return blsIdIsEqual(this, rhs) != 0;

+ }

+ public void SetDecStr(string s) {

+ if (blsIdSetDecStr(ref this, s, (ulong)s.Length) != 0) {

+ throw new ArgumentException("blsIdSetDecSt:" + s);

+ }

+ }

+ public void SetHexStr(string s) {

+ if (blsIdSetHexStr(ref this, s, (ulong)s.Length) != 0) {

+ throw new ArgumentException("blsIdSetHexStr:" + s);

+ }

+ }

+ public void SetInt(int x) {

+ blsIdSetInt(ref this, x);

+ }

+ public string GetDecStr() {

+ StringBuilder sb = new StringBuilder(1024);

+ ulong size = blsIdGetDecStr(sb, (ulong)sb.Capacity, this);

+ if (size == 0) {

+ throw new ArgumentException("blsIdGetDecStr");

+ }

+ return sb.ToString(0, (int)size);

+ }

+ public string GetHexStr() {

+ StringBuilder sb = new StringBuilder(1024);

+ ulong size = blsIdGetHexStr(sb, (ulong)sb.Capacity, this);

+ if (size == 0) {

+ throw new ArgumentException("blsIdGetHexStr");

+ }

+ return sb.ToString(0, (int)size);

+ }

+ }

+ [StructLayout(LayoutKind.Sequential)]

+ public unsafe struct SecretKey

+ {

+ private fixed ulong v[SECRETKEY_UNIT_SIZE];

+ public byte[] Serialize() {

+ byte[] buf = new byte[SECRETKEY_SERIALIZE_SIZE];

+ ulong n = blsSecretKeySerialize(buf, (ulong)buf.Length, this);

+ if (n == 0) {

+ throw new ArithmeticException("blsSecretKeySerialize");

+ }

+ return buf;

+ }

+ public void Deserialize(byte[] buf) {

+ ulong n = blsSecretKeyDeserialize(ref this, buf, (ulong)buf.Length);

+ if (n == 0) {

+ throw new ArithmeticException("blsSecretKeyDeserialize");

+ }

+ }

+ public bool IsEqual(in SecretKey rhs) {

+ return blsSecretKeyIsEqual(this, rhs) != 0;

+ }

+ public void SetHexStr(string s) {

+ if (blsSecretKeySetHexStr(ref this, s, (ulong)s.Length) != 0) {

+ throw new ArgumentException("blsSecretKeySetHexStr:" + s);

+ }

+ }

+ public string GetHexStr() {

+ StringBuilder sb = new StringBuilder(1024);

+ ulong size = blsSecretKeyGetHexStr(sb, (ulong)sb.Capacity, this);

+ if (size == 0) {

+ throw new ArgumentException("mclBnFr_getStr");

+ }

+ return sb.ToString(0, (int)size);

+ }

+ public void Add(in SecretKey rhs) {

+ blsSecretKeyAdd(ref this, rhs);

+ }

+ public void SetByCSPRNG() {

+ blsSecretKeySetByCSPRNG(ref this);

+ }

+ public void SetHashOf(string s) {

+ if (blsHashToSecretKey(ref this, s, (ulong)s.Length) != 0) {

+ throw new ArgumentException("blsHashToSecretKey");

+ }

+ }

+ public PublicKey GetPublicKey() {

+ PublicKey pub;

+ blsGetPublicKey(ref pub, this);

+ return pub;

+ }

+ public Signature Sign(string m) {

+ Signature sig;

+ blsSign(ref sig, this, m, (ulong)m.Length);

+ return sig;

+ }

+ public Signature GetPop() {

+ Signature sig;

+ blsGetPop(ref sig, this);

+ return sig;

+ }

+ }

+ // secretKey = sum_{i=0}^{msk.Length - 1} msk[i] * id^i

+ public static SecretKey ShareSecretKey(in SecretKey[] msk, in Id id) {

+ SecretKey sec;

+ if (blsSecretKeyShare(ref sec, msk[0], (ulong)msk.Length, id) != 0) {

+ throw new ArgumentException("GetSecretKeyForId:" + id.ToString());

+ }

+ return sec;

+ }

+ public static SecretKey RecoverSecretKey(in SecretKey[] secVec, in Id[] idVec) {

+ SecretKey sec;

+ if (blsSecretKeyRecover(ref sec, secVec[0], idVec[0], (ulong)secVec.Length) != 0) {

+ throw new ArgumentException("Recover");

+ }

+ return sec;

+ }

+ [StructLayout(LayoutKind.Sequential)]

+ public unsafe struct PublicKey

+ {

+ private fixed ulong v[PUBLICKEY_UNIT_SIZE];

+ public byte[] Serialize() {

+ byte[] buf = new byte[PUBLICKEY_SERIALIZE_SIZE];

+ ulong n = blsPublicKeySerialize(buf, (ulong)buf.Length, this);

+ if (n == 0) {

+ throw new ArithmeticException("blsPublicKeySerialize");

+ }

+ return buf;

+ }

+ public void Deserialize(byte[] buf) {

+ ulong n = blsPublicKeyDeserialize(ref this, buf, (ulong)buf.Length);

+ if (n == 0) {

+ throw new ArithmeticException("blsPublicKeyDeserialize");

+ }

+ }

+ public bool IsEqual(in PublicKey rhs) {

+ return blsPublicKeyIsEqual(this, rhs) != 0;

+ }

+ public void SetStr(string s) {

+ if (blsPublicKeySetHexStr(ref this, s, (ulong)s.Length) != 0) {

+ throw new ArgumentException("blsPublicKeySetStr:" + s);

+ }

+ }

+ public string GetHexStr() {

+ StringBuilder sb = new StringBuilder(1024);

+ ulong size = blsPublicKeyGetHexStr(sb, (ulong)sb.Capacity, this);

+ if (size == 0) {

+ throw new ArgumentException("blsPublicKeyGetStr");

+ }

+ return sb.ToString(0, (int)size);

+ }

+ public void Add(in PublicKey rhs) {

+ blsPublicKeyAdd(ref this, rhs);

+ }

+ public bool Verify(in Signature sig, string m) {

+ return blsVerify(sig, this, m, (ulong)m.Length) == 1;

+ }

+ public bool VerifyPop(in Signature pop) {

+ return blsVerifyPop(pop, this) == 1;

+ }

+ }

+ // publicKey = sum_{i=0}^{mpk.Length - 1} mpk[i] * id^i

+ public static PublicKey SharePublicKey(in PublicKey[] mpk, in Id id) {

+ PublicKey pub;

+ if (blsPublicKeyShare(ref pub, mpk[0], (ulong)mpk.Length, id) != 0) {

+ throw new ArgumentException("GetPublicKeyForId:" + id.ToString());

+ }

+ return pub;

+ }

+ public static PublicKey RecoverPublicKey(in PublicKey[] pubVec, in Id[] idVec) {

+ PublicKey pub;

+ if (blsPublicKeyRecover(ref pub, pubVec[0], idVec[0], (ulong)pubVec.Length) != 0) {

+ throw new ArgumentException("Recover");

+ }

+ return pub;

+ }

+ [StructLayout(LayoutKind.Sequential)]

+ public unsafe struct Signature

+ {

+ private fixed ulong v[SIGNATURE_UNIT_SIZE];

+ public byte[] Serialize() {

+ byte[] buf = new byte[SIGNATURE_SERIALIZE_SIZE];

+ ulong n = blsSignatureSerialize(buf, (ulong)buf.Length, this);

+ if (n == 0) {

+ throw new ArithmeticException("blsSignatureSerialize");

+ }

+ return buf;

+ }

+ public void Deserialize(byte[] buf) {

+ ulong n = blsSignatureDeserialize(ref this, buf, (ulong)buf.Length);

+ if (n == 0) {

+ throw new ArithmeticException("blsSignatureDeserialize");

+ }

+ }

+ public bool IsEqual(in Signature rhs) {

+ return blsSignatureIsEqual(this, rhs) != 0;

+ }

+ public void SetStr(string s) {

+ if (blsSignatureSetHexStr(ref this, s, (ulong)s.Length) != 0) {

+ throw new ArgumentException("blsSignatureSetStr:" + s);

+ }

+ }

+ public string GetHexStr() {

+ StringBuilder sb = new StringBuilder(1024);

+ ulong size = blsSignatureGetHexStr(sb, (ulong)sb.Capacity, this);

+ if (size == 0) {

+ throw new ArgumentException("blsSignatureGetStr");

+ }

+ return sb.ToString(0, (int)size);

+ }

+ public void Add(in Signature rhs) {

+ blsSignatureAdd(ref this, rhs);

+ }

+ }

+ public static Signature RecoverSign(in Signature[] sigVec, in Id[] idVec) {

+ Signature sig;

+ if (blsSignatureRecover(ref sig, sigVec[0], idVec[0], (ulong)sigVec.Length) != 0) {

+ throw new ArgumentException("Recover");

+ }

+ return sig;

+ }

+ }

+}

+<?xml version="1.0" encoding="utf-8"?>

+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+ <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />

+ <PropertyGroup>

+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

+ <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>

+ <ProjectGuid>{E9D06B1B-EA22-4EF4-BA4B-422F7625966D}</ProjectGuid>

+ <OutputType>Exe</OutputType>

+ <AppDesignerFolder>Properties</AppDesignerFolder>

+ <RootNamespace>bls</RootNamespace>

+ <AssemblyName>bls</AssemblyName>

+ <TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>

+ <FileAlignment>512</FileAlignment>

+ <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>

+ <PublishUrl>publish\</PublishUrl>

+ <Install>true</Install>

+ <InstallFrom>Disk</InstallFrom>

+ <UpdateEnabled>false</UpdateEnabled>

+ <UpdateMode>Foreground</UpdateMode>

+ <UpdateInterval>7</UpdateInterval>

+ <UpdateIntervalUnits>Days</UpdateIntervalUnits>

+ <UpdatePeriodically>false</UpdatePeriodically>

+ <UpdateRequired>false</UpdateRequired>

+ <MapFileExtensions>true</MapFileExtensions>

+ <ApplicationRevision>0</ApplicationRevision>

+ <ApplicationVersion>1.0.0.%2a</ApplicationVersion>

+ <IsWebBootstrapper>false</IsWebBootstrapper>

+ <UseApplicationTrust>false</UseApplicationTrust>

+ <BootstrapperEnabled>true</BootstrapperEnabled>

+ <TargetFrameworkProfile />

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">

+ <DebugSymbols>true</DebugSymbols>

+ <OutputPath>..\..\bin\</OutputPath>

+ <DefineConstants>DEBUG;TRACE</DefineConstants>

+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>

+ <DebugType>full</DebugType>

+ <PlatformTarget>x64</PlatformTarget>

+ <ErrorReport>prompt</ErrorReport>

+ <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>

+ <LangVersion>7.2</LangVersion>

+ <Prefer32Bit>false</Prefer32Bit>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">

+ <OutputPath>..\..\bin\</OutputPath>

+ <DefineConstants>TRACE</DefineConstants>

+ <Optimize>true</Optimize>

+ <DebugType>pdbonly</DebugType>

+ <PlatformTarget>x64</PlatformTarget>

+ <ErrorReport>prompt</ErrorReport>

+ <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>

+ <Prefer32Bit>false</Prefer32Bit>

+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>

+ <LangVersion>7.2</LangVersion>

+ </PropertyGroup>

+ <PropertyGroup>

+ <NoWin32Manifest>true</NoWin32Manifest>

+ </PropertyGroup>

+ <ItemGroup>

+ <Reference Include="System" />

+ <Reference Include="System.Core" />

+ <Reference Include="System.Xml.Linq" />

+ <Reference Include="System.Data.DataSetExtensions" />

+ <Reference Include="Microsoft.CSharp" />

+ <Reference Include="System.Data" />

+ <Reference Include="System.Net.Http" />

+ <Reference Include="System.Xml" />

+ </ItemGroup>

+ <ItemGroup>

+ <Compile Include="bls.cs" />

+ <Compile Include="bls_test.cs" />

+ <Compile Include="Properties\AssemblyInfo.cs" />

+ </ItemGroup>

+ <ItemGroup>

+ <None Include="App.config" />

+ </ItemGroup>

+ <ItemGroup>

+ <BootstrapperPackage Include=".NETFramework,Version=v4.5.2">

+ <Visible>False</Visible>

+ <ProductName>Microsoft .NET Framework 4.5.2 %28x86 �よ� x64%29</ProductName>

+ <Install>true</Install>

+ </BootstrapperPackage>

+ <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">

+ <Visible>False</Visible>

+ <ProductName>.NET Framework 3.5 SP1</ProductName>

+ <Install>false</Install>

+ </BootstrapperPackage>

+ </ItemGroup>

+ <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

+ <!-- To modify your build process, add your task inside one of the targets below and uncomment it.

+ Other similar extension points exist, see Microsoft.Common.targets.

+ <Target Name="BeforeBuild">

+ </Target>

+ <Target Name="AfterBuild">

+ </Target>

+ -->

+</Project> \ No newline at end of file

+

+Microsoft Visual Studio Solution File, Format Version 12.00

+# Visual Studio 15

+VisualStudioVersion = 15.0.28307.539

+MinimumVisualStudioVersion = 10.0.40219.1

+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "bls", "bls.csproj", "{E9D06B1B-EA22-4EF4-BA4B-422F7625966D}"

+EndProject

+Global

+ GlobalSection(SolutionConfigurationPlatforms) = preSolution

+ Debug|x64 = Debug|x64

+ Release|x64 = Release|x64

+ EndGlobalSection

+ GlobalSection(ProjectConfigurationPlatforms) = postSolution

+ {E9D06B1B-EA22-4EF4-BA4B-422F7625966D}.Debug|x64.ActiveCfg = Debug|x64

+ {E9D06B1B-EA22-4EF4-BA4B-422F7625966D}.Debug|x64.Build.0 = Debug|x64

+ {E9D06B1B-EA22-4EF4-BA4B-422F7625966D}.Release|x64.ActiveCfg = Release|x64

+ {E9D06B1B-EA22-4EF4-BA4B-422F7625966D}.Release|x64.Build.0 = Release|x64

+ EndGlobalSection

+ GlobalSection(SolutionProperties) = preSolution

+ HideSolutionNode = FALSE

+ EndGlobalSection

+ GlobalSection(ExtensibilityGlobals) = postSolution

+ SolutionGuid = {1935C301-6478-4F82-9587-6A66B531E327}

+ EndGlobalSection

+EndGlobal

+þ½Ž¿using System;

+using System.Text;

+using System.Runtime.InteropServices;

+

+namespace mcl {

+ class BLS256 {

+ const int IoEcComp = 512; // fixed byte representation

+ public const int MCLBN_FR_UNIT_SIZE = 4;

+ public const int MCLBN_FP_UNIT_SIZE = 4;

+ public const int MCLBN_COMPILED_TIME_VAR = MCLBN_FR_UNIT_SIZE * 10 + MCLBN_FP_UNIT_SIZE;

+ [DllImport("bls256.dll")]

+ public static extern int blsInit(int curve, int compiledTimeVar);

+

+ [DllImport("bls256.dll")] public static extern void blsIdSetInt(ref Id id, int x);

+ [DllImport("bls256.dll")] public static extern int blsIdSetDecStr(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ [DllImport("bls256.dll")] public static extern int blsIdSetHexStr(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ [DllImport("bls256.dll")] public static extern ulong blsIdGetDecStr([Out]StringBuilder buf, ulong maxBufSize, ref Id id);

+ [DllImport("bls256.dll")] public static extern ulong blsIdGetHexStr([Out]StringBuilder buf, ulong maxBufSize, ref Id id);

+

+

+ [DllImport("bls256.dll")] public static extern ulong blsIdSerialize([Out]StringBuilder buf, ulong maxBufSize, ref Id id);

+ [DllImport("bls256.dll")] public static extern ulong blsSecretKeySerialize([Out]StringBuilder buf, ulong maxBufSize, ref SecretKey sec);

+ [DllImport("bls256.dll")] public static extern ulong blsPublicKeySerialize([Out]StringBuilder buf, ulong maxBufSize, ref PublicKey pub);

+ [DllImport("bls256.dll")] public static extern ulong blsSignatureSerialize([Out]StringBuilder buf, ulong maxBufSize, ref Signature sig);

+

+ [DllImport("bls256.dll")] public static extern int blsIdDeserialize(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ [DllImport("bls256.dll")] public static extern int blsSecretKeyDeserialize(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ [DllImport("bls256.dll")] public static extern int blsPublicKeyDeserialize(ref PublicKey pub, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ [DllImport("bls256.dll")] public static extern int blsSignatureDeserialize(ref Signature sig, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+

+ [DllImport("bls256.dll")] public static extern int blsIdIsEqual(ref Id lhs, ref Id rhs);

+ [DllImport("bls256.dll")] public static extern int blsSecretKeyIsEqual(ref SecretKey lhs, ref SecretKey rhs);

+ [DllImport("bls256.dll")] public static extern int blsPublicKeyIsEqual(ref PublicKey lhs, ref PublicKey rhs);

+ [DllImport("bls256.dll")] public static extern int blsSignatureIsEqual(ref Signature lhs, ref Signature rhs);

+

+ // add

+ [DllImport("bls256.dll")] public static extern void blsSecretKeyAdd(ref SecretKey sec, ref SecretKey rhs);

+ [DllImport("bls256.dll")] public static extern void blsPublicKeyAdd(ref PublicKey pub, ref PublicKey rhs);

+ [DllImport("bls256.dll")] public static extern void blsSignatureAdd(ref Signature sig, ref Signature rhs);

+

+ // hash buf and set

+ [DllImport("bls256.dll")] public static extern int blsHashToSecretKey(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ /*

+ set secretKey if system has /dev/urandom or CryptGenRandom

+ return 0 if success else -1

+ */

+ [DllImport("bls256.dll")] public static extern int blsSecretKeySetByCSPRNG(ref SecretKey sec);

+

+ [DllImport("bls256.dll")] public static extern void blsGetPublicKey(ref PublicKey pub, ref SecretKey sec);

+ [DllImport("bls256.dll")] public static extern void blsGetPop(ref Signature sig, ref SecretKey sec);

+

+ // return 0 if success

+ [DllImport("bls256.dll")] public static extern int blsSecretKeyShare(ref SecretKey sec, ref SecretKey msk, ulong k, ref Id id);

+ [DllImport("bls256.dll")] public static extern int blsPublicKeyShare(ref PublicKey pub, ref PublicKey mpk, ulong k, ref Id id);

+

+

+ [DllImport("bls256.dll")] public static extern int blsSecretKeyRecover(ref SecretKey sec, ref SecretKey secVec, ref Id idVec, ulong n);

+ [DllImport("bls256.dll")] public static extern int blsPublicKeyRecover(ref PublicKey pub, ref PublicKey pubVec, ref Id idVec, ulong n);

+ [DllImport("bls256.dll")] public static extern int blsSignatureRecover(ref Signature sig, ref Signature sigVec, ref Id idVec, ulong n);

+

+ [DllImport("bls256.dll")] public static extern void blsSign(ref Signature sig, ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string m, ulong size);

+

+ // return 1 if valid

+ [DllImport("bls256.dll")] public static extern int blsVerify(ref Signature sig, ref PublicKey pub, [In][MarshalAs(UnmanagedType.LPStr)] string m, ulong size);

+ [DllImport("bls256.dll")] public static extern int blsVerifyPop(ref Signature sig, ref PublicKey pub);

+

+ //////////////////////////////////////////////////////////////////////////

+ // the following apis will be removed

+

+ // mask buf with (1 << (bitLen(r) - 1)) - 1 if buf >= r

+ [DllImport("bls256.dll")] public static extern int blsIdSetLittleEndian(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ /*

+ return written byte size if success else 0

+ */

+ [DllImport("bls256.dll")] public static extern ulong blsIdGetLittleEndian([Out]StringBuilder buf, ulong maxBufSize, ref Id id);

+

+ // return 0 if success

+ // mask buf with (1 << (bitLen(r) - 1)) - 1 if buf >= r

+ [DllImport("bls256.dll")] public static extern int blsSecretKeySetLittleEndian(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ [DllImport("bls256.dll")] public static extern int blsSecretKeySetDecStr(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ [DllImport("bls256.dll")] public static extern int blsSecretKeySetHexStr(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ /*

+ return written byte size if success else 0

+ */

+ [DllImport("bls256.dll")] public static extern ulong blsSecretKeyGetLittleEndian([Out]StringBuilder buf, ulong maxBufSize, ref SecretKey sec);

+ /*

+ return strlen(buf) if success else 0

+ buf is '\0' terminated

+ */

+ [DllImport("bls256.dll")] public static extern ulong blsSecretKeyGetDecStr([Out]StringBuilder buf, ulong maxBufSize, ref SecretKey sec);

+ [DllImport("bls256.dll")] public static extern ulong blsSecretKeyGetHexStr([Out]StringBuilder buf, ulong maxBufSize, ref SecretKey sec);

+ [DllImport("bls256.dll")] public static extern int blsPublicKeySetHexStr(ref PublicKey pub, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ [DllImport("bls256.dll")] public static extern ulong blsPublicKeyGetHexStr([Out]StringBuilder buf, ulong maxBufSize, ref PublicKey pub);

+ [DllImport("bls256.dll")] public static extern int blsSignatureSetHexStr(ref Signature sig, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);

+ [DllImport("bls256.dll")] public static extern ulong blsSignatureGetHexStr([Out]StringBuilder buf, ulong maxBufSize, ref Signature sig);

+

+ public static void Init()

+ {

+ const int CurveFp254BNb = 0;

+ if (!System.Environment.Is64BitProcess) {

+ throw new PlatformNotSupportedException("not 64-bit system");

+ }

+ int err = blsInit(CurveFp254BNb, MCLBN_COMPILED_TIME_VAR);

+ if (err != 0) {

+ throw new ArgumentException("blsInit");

+ }

+ }

+

+ public struct Id {

+ private ulong v0, v1, v2, v3;

+ public bool IsEqual(Id rhs)

+ {

+ return blsIdIsEqual(ref this, ref rhs) != 0;

+ }

+ public void SetDecStr(String s)

+ {

+ if (blsIdSetDecStr(ref this, s, (ulong)s.Length) != 0) {

+ throw new ArgumentException("blsIdSetDecSt:" + s);

+ }

+ }

+ public void SetHexStr(String s)

+ {

+ if (blsIdSetHexStr(ref this, s, (ulong)s.Length) != 0) {

+ throw new ArgumentException("blsIdSetHexStr:" + s);

+ }

+ }

+ public void SetInt(int x)

+ {

+ blsIdSetInt(ref this, x);

+ }

+ public string GetDecStr()

+ {

+ StringBuilder sb = new StringBuilder(1024);

+ ulong size = blsIdGetDecStr(sb, (ulong)sb.Capacity, ref this);

+ if (size == 0) {

+ throw new ArgumentException("blsIdGetDecStr");

+ }

+ return sb.ToString(0, (int)size);

+ }

+ public string GetHexStr()

+ {

+ StringBuilder sb = new StringBuilder(1024);

+ ulong size = blsIdGetHexStr(sb, (ulong)sb.Capacity, ref this);

+ if (size == 0) {

+ throw new ArgumentException("blsIdGetHexStr");

+ }

+ return sb.ToString(0, (int)size);

+ }

+ }

+ public struct SecretKey {

+ private ulong v0, v1, v2, v3;

+ public bool IsEqual(SecretKey rhs)

+ {

+ return blsSecretKeyIsEqual(ref this, ref rhs) != 0;

+ }

+ public void SetHexStr(String s)

+ {

+ if (blsSecretKeySetHexStr(ref this, s, (ulong)s.Length) != 0) {

+ throw new ArgumentException("blsSecretKeySetHexStr:" + s);

+ }

+ }

+ public string GetHexStr()

+ {

+ StringBuilder sb = new StringBuilder(1024);

+ ulong size = blsSecretKeyGetHexStr(sb, (ulong)sb.Capacity, ref this);

+ if (size == 0) {

+ throw new ArgumentException("mclBnFr_getStr");

+ }

+ return sb.ToString(0, (int)size);

+ }

+ public void Add(SecretKey rhs)

+ {

+ blsSecretKeyAdd(ref this, ref rhs);

+ }

+ public void SetByCSPRNG()

+ {

+ blsSecretKeySetByCSPRNG(ref this);

+ }

+ public void SetHashOf(string s)

+ {

+ if (blsHashToSecretKey(ref this, s, (ulong)s.Length) != 0) {

+ throw new ArgumentException("blsHashToSecretKey");

+ }

+ }

+ public PublicKey GetPublicKey()

+ {

+ PublicKey pub = new PublicKey();

+ blsGetPublicKey(ref pub, ref this);

+ return pub;

+ }

+ public Signature Signature(String m)

+ {

+ Signature Signature = new Signature();

+ blsSign(ref Signature, ref this, m, (ulong)m.Length);

+ return Signature;

+ }

+ }

+ // secretKey = sum_{i=0}^{msk.Length - 1} msk[i] * id^i

+ public static SecretKey ShareSecretKey(SecretKey[] msk, Id id)

+ {

+ SecretKey sec = new SecretKey();

+ if (blsSecretKeyShare(ref sec, ref msk[0], (ulong)msk.Length, ref id) != 0) {

+ throw new ArgumentException("GetSecretKeyForId:" + id.ToString());

+ }

+ return sec;

+ }

+ public static SecretKey RecoverSecretKey(SecretKey[] secs, Id[] ids)

+ {

+ SecretKey sec = new SecretKey();

+ if (blsSecretKeyRecover(ref sec, ref secs[0], ref ids[0], (ulong)secs.Length) != 0) {

+ throw new ArgumentException("Recover");

+ }

+ return sec;

+ }

+ public struct PublicKey {

+ private ulong v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11;

+ private ulong v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23;

+ public bool IsEqual(PublicKey rhs)

+ {

+ return blsPublicKeyIsEqual(ref this, ref rhs) != 0;

+ }

+ public void SetStr(String s)

+ {

+ if (blsPublicKeySetHexStr(ref this, s, (ulong)s.Length) != 0) {

+ throw new ArgumentException("blsPublicKeySetStr:" + s);

+ }

+ }

+ public string GetHexStr()

+ {

+ StringBuilder sb = new StringBuilder(1024);

+ ulong size = blsPublicKeyGetHexStr(sb, (ulong)sb.Capacity, ref this);

+ if (size == 0) {

+ throw new ArgumentException("blsPublicKeyGetStr");

+ }

+ return sb.ToString(0, (int)size);

+ }

+ public void Add(PublicKey rhs)

+ {

+ blsPublicKeyAdd(ref this, ref rhs);

+ }

+ public bool Verify(Signature Signature, string m)

+ {

+ return blsVerify(ref Signature, ref this, m, (ulong)m.Length) == 1;

+ }

+ }

+ // publicKey = sum_{i=0}^{mpk.Length - 1} mpk[i] * id^i

+ public static PublicKey SharePublicKey(PublicKey[] mpk, Id id)

+ {

+ PublicKey pub = new PublicKey();

+ if (blsPublicKeyShare(ref pub, ref mpk[0], (ulong)mpk.Length, ref id) != 0) {

+ throw new ArgumentException("GetPublicKeyForId:" + id.ToString());

+ }

+ return pub;

+ }

+ public static PublicKey RecoverPublicKey(PublicKey[] pubs, Id[] ids)

+ {

+ PublicKey pub = new PublicKey();

+ if (blsPublicKeyRecover(ref pub, ref pubs[0], ref ids[0], (ulong)pubs.Length) != 0) {

+ throw new ArgumentException("Recover");

+ }

+ return pub;

+ }

+ public struct Signature {

+ private ulong v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11;

+ public bool IsEqual(Signature rhs)

+ {

+ return blsSignatureIsEqual(ref this, ref rhs) != 0;

+ }

+ public void SetStr(String s)

+ {

+ if (blsSignatureSetHexStr(ref this, s, (ulong)s.Length) != 0) {

+ throw new ArgumentException("blsSignatureSetStr:" + s);

+ }

+ }

+ public string GetHexStr()

+ {

+ StringBuilder sb = new StringBuilder(1024);

+ ulong size = blsSignatureGetHexStr(sb, (ulong)sb.Capacity, ref this);

+ if (size == 0) {

+ throw new ArgumentException("blsSignatureGetStr");

+ }

+ return sb.ToString(0, (int)size);

+ }

+ public void Add(Signature rhs)

+ {

+ blsSignatureAdd(ref this, ref rhs);

+ }

+ }

+ public static Signature RecoverSign(Signature[] signs, Id[] ids)

+ {

+ Signature Signature = new Signature();

+ if (blsSignatureRecover(ref Signature, ref signs[0], ref ids[0], (ulong)signs.Length) != 0) {

+ throw new ArgumentException("Recover");

+ }

+ return Signature;

+ }

+ }

+}

+<?xml version="1.0" encoding="utf-8"?>

+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+ <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />

+ <PropertyGroup>

+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

+ <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>

+ <ProjectGuid>{E9D06B1B-EA22-4EF4-BA4B-422F7625966C}</ProjectGuid>

+ <OutputType>Exe</OutputType>

+ <AppDesignerFolder>Properties</AppDesignerFolder>

+ <RootNamespace>bls256</RootNamespace>

+ <AssemblyName>bls256</AssemblyName>

+ <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>

+ <FileAlignment>512</FileAlignment>

+ <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">

+ <DebugSymbols>true</DebugSymbols>

+ <OutputPath>..\..\bin\</OutputPath>

+ <DefineConstants>DEBUG;TRACE</DefineConstants>

+ <AllowUnsafeBlocks>false</AllowUnsafeBlocks>

+ <DebugType>full</DebugType>

+ <PlatformTarget>x64</PlatformTarget>

+ <ErrorReport>prompt</ErrorReport>

+ <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>

+ </PropertyGroup>

+ <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">

+ <OutputPath>..\..\bin\</OutputPath>

+ <DefineConstants>TRACE</DefineConstants>

+ <Optimize>true</Optimize>

+ <DebugType>pdbonly</DebugType>

+ <PlatformTarget>x64</PlatformTarget>

+ <ErrorReport>prompt</ErrorReport>

+ <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>

+ <Prefer32Bit>true</Prefer32Bit>

+ </PropertyGroup>

+ <ItemGroup>

+ <Reference Include="System" />

+ <Reference Include="System.Core" />

+ <Reference Include="System.Xml.Linq" />

+ <Reference Include="System.Data.DataSetExtensions" />

+ <Reference Include="Microsoft.CSharp" />

+ <Reference Include="System.Data" />

+ <Reference Include="System.Net.Http" />

+ <Reference Include="System.Xml" />

+ </ItemGroup>

+ <ItemGroup>

+ <Compile Include="bls256.cs" />

+ <Compile Include="bls256_test.cs" />

+ <Compile Include="Properties\AssemblyInfo.cs" />

+ </ItemGroup>

+ <ItemGroup>

+ <None Include="App.config" />

+ </ItemGroup>

+ <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

+ <!-- To modify your build process, add your task inside one of the targets below and uncomment it.

+ Other similar extension points exist, see Microsoft.Common.targets.

+ <Target Name="BeforeBuild">

+ </Target>

+ <Target Name="AfterBuild">

+ </Target>

+ -->

+</Project> \ No newline at end of file

+

+Microsoft Visual Studio Solution File, Format Version 12.00

+# Visual Studio 14

+VisualStudioVersion = 14.0.25420.1

+MinimumVisualStudioVersion = 10.0.40219.1

+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBD}") = "bls256", "bls256.csproj", "{E9D06B1B-EA22-4EF4-BA4B-422F7625966C}"

+EndProject

+Global

+ GlobalSection(SolutionConfigurationPlatforms) = preSolution

+ Debug|x64 = Debug|x64

+ Release|x64 = Release|x64

+ EndGlobalSection

+ GlobalSection(ProjectConfigurationPlatforms) = postSolution

+ {E9D06B1B-EA22-4EF4-BA4B-422F7625966C}.Debug|x64.ActiveCfg = Debug|x64

+ {E9D06B1B-EA22-4EF4-BA4B-422F7625966C}.Debug|x64.Build.0 = Debug|x64

+ {E9D06B1B-EA22-4EF4-BA4B-422F7625966C}.Release|x64.ActiveCfg = Release|x64

+ {E9D06B1B-EA22-4EF4-BA4B-422F7625966C}.Release|x64.Build.0 = Release|x64

+ EndGlobalSection

+ GlobalSection(SolutionProperties) = preSolution

+ HideSolutionNode = FALSE

+ EndGlobalSection

+EndGlobal

+using System;

+

+namespace mcl {

+ using static BLS256;

+ class BLS256Test {

+ static int err = 0;

+ static void assert(string msg, bool b)

+ {

+ if (b) return;

+ Console.WriteLine("ERR {0}", msg);

+ err++;

+ }

+ static void TestId()

+ {

+ Console.WriteLine("TestId");

+ Id id = new Id();

+ id.SetDecStr("255");

+ assert("GetStr(10)", id.GetDecStr() == "255");

+ assert("GetStr(16)", id.GetHexStr() == "ff");

+ }

+ static void TestSecretKey()

+ {

+ Console.WriteLine("TestSecretKey");

+ SecretKey sec = new SecretKey();

+ sec.SetHexStr("ff");

+ assert("GetHexStr()", sec.GetHexStr() == "ff");

+ {

+ SecretKey sec2 = new SecretKey();

+ sec.SetHexStr("321");

+ sec2.SetHexStr("4000");

+ sec.Add(sec2);

+ assert("sec.Add", sec.GetHexStr() == "4321");

+ sec.SetByCSPRNG();

+ Console.WriteLine("sec.Init={0}", sec.GetHexStr());

+ }

+ }

+ static void TestPublicKey()

+ {

+ Console.WriteLine("TestPublicKey");

+ SecretKey sec = new SecretKey();

+ sec.SetByCSPRNG();

+ PublicKey pub = sec.GetPublicKey();

+ String s = pub.GetHexStr();

+ Console.WriteLine("pub={0}", s);

+ PublicKey pub2 = new PublicKey();

+ pub2.SetStr(s);

+ assert("pub.SetStr", pub.IsEqual(pub2));

+ }

+ static void TestSign()

+ {

+ Console.WriteLine("TestSign");

+ SecretKey sec = new SecretKey();

+ sec.SetByCSPRNG();

+ PublicKey pub = sec.GetPublicKey();

+ String m = "abc";

+ Signature sig = sec.Signature(m);

+ assert("verify", pub.Verify(sig, m));

+ assert("not verify", !pub.Verify(sig, m + "a"));

+ }

+ static void TestSharing()

+ {

+ Console.WriteLine("TestSharing");

+ int k = 5;

+ SecretKey[] msk = new SecretKey[k];

+ PublicKey[] mpk = new PublicKey[k];

+ // make master secretkey

+ for (int i = 0; i < k; i++) {

+ msk[i].SetByCSPRNG();

+ mpk[i] = msk[i].GetPublicKey();

+ }

+ int n = 30;

+ Id[] ids = new Id[n];

+ SecretKey[] secs = new SecretKey[n];

+ PublicKey[] pubs = new PublicKey[n];

+ for (int i = 0; i < n; i++) {

+ ids[i].SetInt(i * i + 123);

+ secs[i] = ShareSecretKey(msk, ids[i]);

+ pubs[i] = SharePublicKey(mpk, ids[i]);

+ assert("share publicKey", secs[i].GetPublicKey().IsEqual(pubs[i]));

+ }

+ string m = "doremi";

+ for (int i = 0; i < n; i++) {

+ Signature Signature = secs[i].Signature(m);

+ assert("Signature.Verify", pubs[i].Verify(Signature, m));

+ }

+ {

+ int[] idxTbl = { 0, 2, 5, 8, 10 };

+ assert("idxTbl.Length=k", idxTbl.Length == k);

+ Id[] subIds = new Id[k];

+ SecretKey[] subSecs = new SecretKey[k];

+ PublicKey[] subPubs = new PublicKey[k];

+ Signature[] subSigns = new Signature[k];

+ for (int i = 0; i < k; i++) {

+ int idx = idxTbl[i];

+ subIds[i] = ids[idx];

+ subSecs[i] = secs[idx];

+ subPubs[i] = pubs[idx];

+ subSigns[i] = secs[idx].Signature(m);

+ }

+ SecretKey sec = RecoverSecretKey(subSecs, subIds);

+ PublicKey pub = RecoverPublicKey(subPubs, subIds);

+ assert("check pub", pub.IsEqual(sec.GetPublicKey()));

+ Signature Signature = RecoverSign(subSigns, subIds);

+ assert("Signature.verify", pub.Verify(Signature, m));

+ }

+ }

+ static void Main(string[] args)

+ {

+ try {

+ Init();

+ TestId();

+ TestSecretKey();

+ TestPublicKey();

+ TestSign();

+ TestSharing();

+ if (err == 0) {

+ Console.WriteLine("all tests succeed");

+ } else {

+ Console.WriteLine("err={0}", err);

+ }

+ } catch (Exception e) {

+ Console.WriteLine("ERR={0}", e);

+ }

+ }

+ }

+}

+using System;

+

+namespace mcl

+{

+ using static BLS;

+ class BLSTest

+ {

+ static int err = 0;

+ static void assert(string msg, bool b) {

+ if (b) return;

+ Console.WriteLine("ERR {0}", msg);

+ err++;

+ }

+ static void TestId() {

+ Console.WriteLine("TestId");

+ Id id1;

+ id1.SetDecStr("255");

+ assert("GetStr(10)", id1.GetDecStr() == "255");

+ assert("GetStr(16)", id1.GetHexStr() == "ff");

+ Id id2;

+ id2.SetInt(255);

+ assert("IsEqual", id1.IsEqual(id2));

+ }

+ static void TestSecretKey() {

+ Console.WriteLine("TestSecretKey");

+ SecretKey sec;

+ sec.SetHexStr("ff");

+ assert("GetHexStr()", sec.GetHexStr() == "ff");

+ {

+ SecretKey sec2;

+ sec.SetHexStr("321");

+ sec2.SetHexStr("4000");

+ sec.Add(sec2);

+ assert("sec.Add", sec.GetHexStr() == "4321");

+ sec.SetByCSPRNG();

+ Console.WriteLine("sec.Init={0}", sec.GetHexStr());

+ }

+ {

+ SecretKey sec2;

+ byte[] buf = sec.Serialize();

+ sec2.Deserialize(buf);

+ assert("serialize", sec2.IsEqual(sec));

+ }

+ }

+ static void TestPublicKey() {

+ Console.WriteLine("TestPublicKey");

+ SecretKey sec;

+ sec.SetByCSPRNG();

+ PublicKey pub = sec.GetPublicKey();

+ string s = pub.GetHexStr();

+ Console.WriteLine("pub={0}", s);

+ {

+ PublicKey pub2;

+ pub2.SetStr(s);

+ assert("pub.SetStr", pub.IsEqual(pub2));

+ }

+ {

+ PublicKey pub2;

+ byte[] buf = pub.Serialize();

+ pub2.Deserialize(buf);

+ assert("serialize", pub2.IsEqual(pub));

+ }

+ }

+ static void TestSign() {

+ Console.WriteLine("TestSign");

+ SecretKey sec;

+ sec.SetByCSPRNG();

+ PublicKey pub = sec.GetPublicKey();

+ string m = "abc";

+ Signature sig = sec.Sign(m);

+ Console.WriteLine("sig={0}", sig.GetHexStr());

+ assert("verify", pub.Verify(sig, m));

+ assert("not verify", !pub.Verify(sig, m + "a"));

+ {

+ Signature sig2;

+ byte[] buf = sig.Serialize();

+ sig2.Deserialize(buf);

+ assert("serialize", sig2.IsEqual(sig));

+ }

+ }

+ static void TestSharing() {

+ Console.WriteLine("TestSharing");

+ int k = 5;

+ SecretKey[] msk = new SecretKey[k];

+ PublicKey[] mpk = new PublicKey[k];

+ // make master secretkey

+ for (int i = 0; i < k; i++) {

+ msk[i].SetByCSPRNG();

+ mpk[i] = msk[i].GetPublicKey();

+ }

+ int n = 30;

+ Id[] ids = new Id[n];

+ SecretKey[] secs = new SecretKey[n];

+ PublicKey[] pubs = new PublicKey[n];

+ for (int i = 0; i < n; i++) {

+ ids[i].SetInt(i * i + 123);

+ secs[i] = ShareSecretKey(msk, ids[i]);

+ pubs[i] = SharePublicKey(mpk, ids[i]);

+ assert("share publicKey", secs[i].GetPublicKey().IsEqual(pubs[i]));

+ }

+ string m = "doremi";

+ for (int i = 0; i < n; i++) {

+ Signature Signature = secs[i].Sign(m);

+ assert("Signature.Verify", pubs[i].Verify(Signature, m));

+ }

+ {

+ int[] idxTbl = { 0, 2, 5, 8, 10 };

+ assert("idxTbl.Length=k", idxTbl.Length == k);

+ Id[] subIds = new Id[k];

+ SecretKey[] subSecs = new SecretKey[k];

+ PublicKey[] subPubs = new PublicKey[k];

+ Signature[] subSigns = new Signature[k];

+ for (int i = 0; i < k; i++) {

+ int idx = idxTbl[i];

+ subIds[i] = ids[idx];

+ subSecs[i] = secs[idx];

+ subPubs[i] = pubs[idx];

+ subSigns[i] = secs[idx].Sign(m);

+ }

+ SecretKey sec = RecoverSecretKey(subSecs, subIds);

+ PublicKey pub = RecoverPublicKey(subPubs, subIds);

+ assert("check pub", pub.IsEqual(sec.GetPublicKey()));

+ Signature Signature = RecoverSign(subSigns, subIds);

+ assert("Signature.verify", pub.Verify(Signature, m));

+ }

+ }

+ static void TestAggregate() {

+ Console.WriteLine("TestAggregate");

+ const int n = 10;

+ const string m = "abc";

+ SecretKey[] secVec = new SecretKey[n];

+ PublicKey[] pubVec = new PublicKey[n];

+ Signature[] popVec = new Signature[n];

+ Signature[] sigVec = new Signature[n];

+ for (int i = 0; i < n; i++) {

+ secVec[i].SetByCSPRNG();

+ pubVec[i] = secVec[i].GetPublicKey();

+ popVec[i] = secVec[i].GetPop();

+ sigVec[i] = secVec[i].Sign(m);

+ }

+ SecretKey secAgg;

+ PublicKey pubAgg;

+ Signature sigAgg;

+ for (int i = 0; i < n; i++) {

+ secAgg.Add(secVec[i]);

+ assert("verify pop", pubVec[i].VerifyPop(popVec[i]));

+ pubAgg.Add(pubVec[i]);

+ sigAgg.Add(sigVec[i]);

+ }

+ assert("aggregate sec", secAgg.Sign(m).IsEqual(sigAgg));

+ assert("aggregate", pubAgg.Verify(sigAgg, m));

+ }

+ static void Main(string[] args) {

+ try {

+ int[] curveTypeTbl = { BN254, BLS12_381 };

+ foreach (int curveType in curveTypeTbl) {

+ Console.WriteLine("curveType={0}", curveType);

+ Init(curveType);

+ TestId();

+ TestSecretKey();

+ TestPublicKey();

+ TestSign();

+ TestSharing();

+ TestAggregate();

+ if (err == 0) {

+ Console.WriteLine("all tests succeed");

+ } else {

+ Console.WriteLine("err={0}", err);

+ }

+ }

+ } catch (Exception e) {

+ Console.WriteLine("ERR={0}", e);

+ }

+ }

+ }

+}

+# BLS署��C#�インディング

+

+# 必�環境

+

+* Visual Studio 2017(x64) or later

+* C# 7.2 or later

+* .NET Framework 4.5.2 or later

+

+# DLL�ビルド方法

+

+Visual Studio 2017�64bit用コマンドプロンプトを開��

+```

+md work

+cd work

+git clone https://github.com/herumi/cybozulib_ext

+git clone https://github.com/herumi/mcl

+git clone https://github.com/herumi/bls

+cd bls

+mklib dll

+```

+`bls/bin/*.dll`�作��れる。

+

+# サンプル�ビルド方法

+

+bls/ffi/cs/bls.slnを開��実行�る。

+

+* 注� bls256.sln�����使��������。

+

+# クラス�API

+

+## API

+

+* `Init(int curveType = BN254);`

+ * ライブラリを曲線curveType��期化�る。

+ * curveType = BN254 or BLS12_381

+* `SecretKey ShareSecretKey(in SecretKey[] msk, in Id id);`

+ * マスター秘密��列msk�対�るid�秘密�を生�(共有)�る。

+* `SecretKey RecoverSecretKey(in SecretKey[] secVec, in Id[] idVec);`

+ * 秘密�secVec�ID idVec�ペア�ら秘密�を復元�る。

+* `PublicKey SharePublicKey(in PublicKey[] mpk, in Id id);`

+ * マスター公開��列mpk�対�るid�公開�を生�(共有)�る。

+* `PublicKey RecoverPublicKey(in PublicKey[] pubVec, in Id[] idVec);`

+ * 公開�pubVec�ID idVec�ペア�ら公開�を復元�る。

+* `Signature RecoverSign(in Signature[] sigVec, in Id[] idVec);`

+ * 署�sigVec�ID idVec�ペア�ら署�を復元�る。

+

+## Id

+

+識別�クラス

+

+* `byte[] Serialize();`

+ * Idをシリアライズ�る。

+* `void Deserialize(byte[] buf);`

+ * �イト列buf�らIdをデシリアライズ�る。

+* `bool IsEqual(in Id rhs);`

+ * �値判定。

+* `void SetDecStr(string s);`

+ * 10進数文字列を設定�る。

+* `void SetHexStr(string s);`

+ * 16進数文字列を設定�る。

+* `void SetInt(int x);`

+ * 整数xを設定�る。

+* `string GetDecStr();`

+ * 10進数表記を�得�る。

+* `string GetHexStr();`

+ * 16進数表記を�得�る。

+

+## SecretKey

+

+* `byte[] Serialize();`

+ * Idをシリアライズ�る。

+* `void Deserialize(byte[] buf);`

+ * �イト列buf�らSecretKeyをデシリアライズ�る。

+* `bool IsEqual(in SecretKey rhs);`

+ * �値判定。

+* `void SetHexStr(string s);`

+ * 16進数文字列を設定�る。

+* `string GetHexStr();`

+ * 16進数表記を�得�る。

+* `void Add(in SecretKey rhs);`

+ * 秘密�rhsを加算�る。

+* `void SetByCSPRNG();`

+ * 暗�学的乱数�設定�る。

+* `void SetHashOf(string s);`

+ * 文字列s��ッシュ値を設定�る。

+* `PublicKey GetPublicKey();`

+ * 対応�る公開�を�得�る。

+* `Signature Sign(string m);`

+ * 文字列m�署�を生��る。

+* `Signature GetPop();`

+ * 自身�秘密��よる署�(Proof Of Posession)を生��る。

+

+## PublicKey

+

+* `byte[] Serialize();`

+ * PublicKeyをシリアライズ�る。

+* `void Deserialize(byte[] buf);`

+ * �イト列buf�らPublicKeyをデシリアライズ�る。

+* `bool IsEqual(in PublicKey rhs);`

+ * �値判定。

+* `void Add(in PublicKey rhs);`

+ * 公開�rhsを加算�る。

+* `void SetHexStr(string s);`

+ * 16進数文字列を設定�る。

+* `string GetHexStr();`

+ * 16進数表記を�得�る。

+* `bool Verify(in Signature sig, string m);`

+ * 文字列m�対�る署�sig�正当性を確��る。

+* `bool VerifyPop(in Signature pop);`

+ * PoP�正当性を確��る。

+

+## Signature

+

+* `byte[] Serialize();`

+ * Signatureをシリアライズ�る。

+* `void Deserialize(byte[] buf);`

+ * �イト列buf�らSignatureをデシリアライズ�る。

+* `bool IsEqual(in Signature rhs);`

+ * �値判定。

+* `void Add(in Signature rhs);`

+ * 署�rhsを加算�る。

+* `void SetHexStr(string s);`

+ * 16進数文字列を設定�る。

+* `string GetHexStr();`

+ * 16進数表記を�得�る。

+

+## 使�方

+

+### 最�サンプル

+

+```

+using static BLS;

+

+Init(BN254); // ライブラリ�期化

+SecretKey sec;

+sec.SetByCSPRNG(); // 秘密���期化

+PublicKey pub = sec.GetPublicKey(); // 公開���得

+string m = "abc";

+Signature sig = sec.Sign(m); // 署��作�

+if (pub.Verify(sig, m))) {

+ // 署��確�

+}

+```

+

+### 集約署�

+```

+Init(BN254); // ライブラリ�期化

+const int n = 10;

+const string m = "abc";

+SecretKey[] secVec = new SecretKey[n];

+PublicKey[] pubVec = new PublicKey[n];

+Signature[] popVec = new Signature[n];

+Signature[] sigVec = new Signature[n];

+

+for (int i = 0; i < n; i++) {

+ secVec[i].SetByCSPRNG(); // 秘密���期化

+ pubVec[i] = secVec[i].GetPublicKey(); // 公開���得

+ popVec[i] = secVec[i].GetPop(); // 所有(PoP)�証明

+ sigVec[i] = secVec[i].Sign(m); // 署�

+}

+

+SecretKey secAgg;

+PublicKey pubAgg;

+Signature sigAgg;

+for (int i = 0; i < n; i++) {

+ // PoP�確�

+ if (pubVec[i].VerifyPop(popVec[i]))) {

+ // エラー

+ return;

+ }

+ pubAgg.Add(pubVec[i]); // 公開��集約

+ sigAgg.Add(sigVec[i]); // 署��集約

+}

+if (pubAgg.Verify(sigAgg, m)) {

+ // 署��確�

+}

+```

+

+# ライセンス

+

+modified new BSD License

+http://opensource.org/licenses/BSD-3-Clause

+

+# 著者

+

+(C)2019 光�滋生 MITSUNARI Shigeo(herumi@nifty.com) All rights reserved.

+本コンテンツ�著作権��よ�本コンテンツ中�出��る商標権�団体��ロゴ�製��

+サービス����れ�れ��権利�有者�帰属���

+# C# binding of BLS threshold signature library

+

+# Installation Requirements

+

+* Visual Studio 2017 or later

+* C# 7.2 or later

+* .NET Framework 4.5.2 or later

+

+# How to build

+

+```

+md work

+cd work

+git clone https://github.com/herumi/cybozulib_ext

+git clone https://github.com/herumi/mcl

+git clone https://github.com/herumi/bls

+cd bls

+mklib dll

+```

+bls/bin/*.dll are created

+

+# How to build a sample

+

+Open bls/ffi/cs/bls.sln and exec it.

+

+* Remark. bls256 is obsolete. Please use bls.sln.

+

+# class and API

+

+## API

+

+* `Init(int curveType = BN254);`

+ * initialize this library with a curve `curveType`.

+ * curveType = BN254 or BLS12_381

+* `SecretKey ShareSecretKey(in SecretKey[] msk, in Id id);`

+ * generate the shared secret key from a sequence of master secret keys msk and Id.

+* `SecretKey RecoverSecretKey(in SecretKey[] secVec, in Id[] idVec);`

+ * recover the secret key from a sequence of secret keys secVec and idVec.

+* `PublicKey SharePublicKey(in PublicKey[] mpk, in Id id);`

+ * generate the shared public key from a sequence of master public keys mpk and Id.

+* `PublicKey RecoverPublicKey(in PublicKey[] pubVec, in Id[] idVec);`

+ * recover the public key from a sequence of public keys pubVec and idVec.

+* `Signature RecoverSign(in Signature[] sigVec, in Id[] idVec);`

+ * recover the signature from a sequence of signatures siVec and idVec.

+

+## Id

+

+Identifier class

+

+* `byte[] Serialize();`

+ * serialize Id

+* `void Deserialize(byte[] buf);`

+ * deserialize from byte[] buf

+* `bool IsEqual(in Id rhs);`

+ * equality

+* `void SetDecStr(string s);`

+ * set by a decimal string s

+* `void SetHexStr(string s);`

+ * set by a hexadecimal string s

+* `void SetInt(int x);`

+ * set an integer x

+* `string GetDecStr();`

+ * get a decimal string

+* `string GetHexStr();`

+ * get a hexadecimal string

+

+## SecretKey

+

+* `byte[] Serialize();`

+ * serialize SecretKey

+* `void Deserialize(byte[] buf);`

+ * deserialize from byte[] buf

+* `bool IsEqual(in SecretKey rhs);`

+ * equality

+* `string GetDecStr();`

+ * get a decimal string

+* `string GetHexStr();`

+ * get a hexadecimal string

+* `void Add(in SecretKey rhs);`

+ * add a secret key rhs

+* `void SetByCSPRNG();`

+ * set a secret key by cryptographically secure pseudo random number generator

+* `void SetHashOf(string s);`

+ * set a secret key by a hash of string s

+* `PublicKey GetPublicKey();`

+ * get the corresponding public key to a secret key

+* `Signature Sign(string m);`

+ * sign a string m

+* `Signature GetPop();`

+ * get a PoP (Proof Of Posession) for a secret key

+

+## PublicKey

+

+* `byte[] Serialize();`

+ * serialize PublicKey

+* `void Deserialize(byte[] buf);`

+ * deserialize from byte[] buf

+* `bool IsEqual(in PublicKey rhs);`

+ * equality

+* `void Add(in PublicKey rhs);`

+ * add a public key rhs

+* `string GetDecStr();`

+ * get a decimal string

+* `string GetHexStr();`

+ * get a hexadecimal string

+* `bool Verify(in Signature sig, string m);`

+ * verify the validness of the sig with m

+* `bool VerifyPop(in Signature pop);`

+ * verify the validness of PoP

+

+## Signature

+

+* `byte[] Serialize();`

+ * serialize Signature

+* `void Deserialize(byte[] buf);`

+ * deserialize from byte[] buf

+* `bool IsEqual(in Signature rhs);`

+ * equality

+* `void Add(in Signature rhs);`

+ * add a signature key rhs

+* `string GetDecStr();`

+ * get a decimal string

+* `string GetHexStr();`

+ * get a hexadecimal string

+

+## How to use

+

+### A minimum sample

+

+```

+using static BLS;

+

+Init(BN254); // init library

+SecretKey sec;

+sec.SetByCSPRNG(); // init secret key

+PublicKey pub = sec.GetPublicKey(); // get public key

+string m = "abc";

+Signature sig = sec.Sign(m); // create signature

+if (pub.Verify(sig, m))) {

+ // signature is verified

+}

+```

+

+### Aggregate signature

+```

+Init(BN254); // init library

+const int n = 10;

+const string m = "abc";

+SecretKey[] secVec = new SecretKey[n];

+PublicKey[] pubVec = new PublicKey[n];

+Signature[] popVec = new Signature[n];

+Signature[] sigVec = new Signature[n];

+

+for (int i = 0; i < n; i++) {

+ secVec[i].SetByCSPRNG(); // init secret key

+ pubVec[i] = secVec[i].GetPublicKey(); // get public key

+ popVec[i] = secVec[i].GetPop(); // get a proof of Possesion (PoP)

+ sigVec[i] = secVec[i].Sign(m); // create signature

+}

+

+SecretKey secAgg;

+PublicKey pubAgg;

+Signature sigAgg;

+for (int i = 0; i < n; i++) {

+ // verify PoP

+ if (pubVec[i].VerifyPop(popVec[i]))) {

+ // error

+ return;

+ }

+ pubAgg.Add(pubVec[i]); // aggregate public key

+ sigAgg.Add(sigVec[i]); // aggregate signature

+}

+if (pubAgg.Verify(sigAgg, m)) {

+ // aggregated signature is verified

+}

+```

+

+# License

+

+modified new BSD License

+http://opensource.org/licenses/BSD-3-Clause

+

+# Author

+

+(C)2019 MITSUNARI Shigeo(herumi@nifty.com) All rights reserved.

+package bls

+

+/*

+#cgo bn256 CFLAGS:-DMCLBN_FP_UNIT_SIZE=4

+#cgo bn256 LDFLAGS:${SRCDIR}/../../../lib/libbls256.a

+#cgo bn384 CFLAGS:-DMCLBN_FP_UNIT_SIZE=6

+#cgo bn384 LDFLAGS:${SRCDIR}/../../../lib/libbls384.a

+#cgo bn384_256 CFLAGS:-DMCLBN_FP_UNIT_SIZE=6 -DMCLBN_FR_UNIT_SIZE=4

+#cgo bn384_256 LDFLAGS:${SRCDIR}/../../../lib/libbls384_256.a

+#cgo !bn256,!bn384,!bn384_256 CFLAGS:-DMCLBN_FP_UNIT_SIZE=6

+#cgo !bn256,!bn384,!bn384_256 LDFLAGS:${SRCDIR}/../../../lib/libbls384.a

+#cgo CFLAGS:-I${SRCDIR}/../../../include -I${SRCDIR}/../../../../mcl/include

+#cgo LDFLAGS:${SRCDIR}/../../../../mcl/lib/libmcl.a -lgmpxx -lgmp

+#cgo static LDFLAGS:-static

+typedef unsigned int (*ReadRandFunc)(void *, void *, unsigned int);

+int wrapReadRandCgo(void *self, void *buf, unsigned int n);

+#include <bls/bls.h>

+*/

+import "C"

+import "fmt"

+import "unsafe"

+import "io"

+import "encoding/json"

+

+// Init --

+// call this function before calling all the other operations

+// this function is not thread safe

+func Init(curve int) error {

+ err := C.blsInit(C.int(curve), C.MCLBN_COMPILED_TIME_VAR)

+ if err != 0 {

+ return fmt.Errorf("ERR Init curve=%d", curve)

+ }

+ return nil

+}

+

+// ID --

+type ID struct {

+ v Fr

+}

+

+// getPointer --

+func (id *ID) getPointer() (p *C.blsId) {

+ // #nosec

+ return (*C.blsId)(unsafe.Pointer(id))

+}

+

+// GetLittleEndian --

+func (id *ID) GetLittleEndian() []byte {

+ return id.v.Serialize()

+}

+

+// SetLittleEndian --

+func (id *ID) SetLittleEndian(buf []byte) error {

+ return id.v.SetLittleEndian(buf)

+}

+

+// GetHexString --

+func (id *ID) GetHexString() string {

+ return id.v.GetString(16)

+}

+

+// GetDecString --

+func (id *ID) GetDecString() string {

+ return id.v.GetString(10)

+}

+

+// SetHexString --

+func (id *ID) SetHexString(s string) error {

+ return id.v.SetString(s, 16)

+}

+

+// SetDecString --

+func (id *ID) SetDecString(s string) error {

+ return id.v.SetString(s, 10)

+}

+

+// IsEqual --

+func (id *ID) IsEqual(rhs *ID) bool {

+ if id == nil || rhs == nil {

+ return false

+ }

+ return id.v.IsEqual(&rhs.v)

+}

+

+// MarshalJSON implements json.Marshaller.

+func (id *ID) MarshalJSON() ([]byte, error) {

+ return json.Marshal(&struct {

+ ID []byte `json:"id"`

+ }{

+ id.GetLittleEndian(),

+ })

+}

+

+// UnmarshalJSON implements json.Unmarshaller.

+func (id *ID) UnmarshalJSON(data []byte) error {

+ aux := &struct {

+ ID []byte `json:"id"`

+ }{}

+ if err := json.Unmarshal(data, &aux); err != nil {

+ return err

+ }

+ if err := id.SetLittleEndian(aux.ID); err != nil {

+ return err

+ }

+ return nil

+}

+

+// SecretKey --

+type SecretKey struct {

+ v Fr

+}

+

+// getPointer --

+func (sec *SecretKey) getPointer() (p *C.blsSecretKey) {

+ // #nosec

+ return (*C.blsSecretKey)(unsafe.Pointer(sec))

+}

+

+// GetLittleEndian --

+func (sec *SecretKey) GetLittleEndian() []byte {

+ return sec.v.Serialize()

+}

+

+// SetLittleEndian --

+func (sec *SecretKey) SetLittleEndian(buf []byte) error {

+ return sec.v.SetLittleEndian(buf)

+}

+

+// SerializeToHexStr --

+func (sec *SecretKey) SerializeToHexStr() string {

+ return sec.v.GetString(IoSerializeHexStr)

+}

+

+// DeserializeHexStr --

+func (sec *SecretKey) DeserializeHexStr(s string) error {

+ return sec.v.SetString(s, IoSerializeHexStr)

+}

+

+// GetHexString --

+func (sec *SecretKey) GetHexString() string {

+ return sec.v.GetString(16)

+}

+

+// GetDecString --

+func (sec *SecretKey) GetDecString() string {

+ return sec.v.GetString(10)

+}

+

+// SetHexString --

+func (sec *SecretKey) SetHexString(s string) error {

+ return sec.v.SetString(s, 16)

+}

+

+// SetDecString --

+func (sec *SecretKey) SetDecString(s string) error {

+ return sec.v.SetString(s, 10)

+}

+

+// IsEqual --

+func (sec *SecretKey) IsEqual(rhs *SecretKey) bool {

+ if sec == nil || rhs == nil {

+ return false

+ }

+ return sec.v.IsEqual(&rhs.v)

+}

+

+// SetByCSPRNG --

+func (sec *SecretKey) SetByCSPRNG() {

+ sec.v.SetByCSPRNG()

+}

+

+// Add --

+func (sec *SecretKey) Add(rhs *SecretKey) {

+ FrAdd(&sec.v, &sec.v, &rhs.v)

+}

+

+// GetMasterSecretKey --

+func (sec *SecretKey) GetMasterSecretKey(k int) (msk []SecretKey) {

+ msk = make([]SecretKey, k)

+ msk[0] = *sec

+ for i := 1; i < k; i++ {

+ msk[i].SetByCSPRNG()

+ }

+ return msk

+}

+

+// MarshalJSON implements json.Marshaller.

+func (sec *SecretKey) MarshalJSON() ([]byte, error) {

+ return json.Marshal(&struct {

+ SecretKey []byte `json:"secret_key"`

+ }{

+ sec.GetLittleEndian(),

+ })

+}

+

+// UnmarshalJSON implements json.Unmarshaller.

+func (sec *SecretKey) UnmarshalJSON(data []byte) error {

+ aux := &struct {

+ SecretKey []byte `json:"secret_key"`

+ }{}

+ if err := json.Unmarshal(data, &aux); err != nil {

+ return err

+ }

+ if err := sec.SetLittleEndian(aux.SecretKey); err != nil {

+ return err

+ }

+ return nil

+}

+

+// GetMasterPublicKey --

+func GetMasterPublicKey(msk []SecretKey) (mpk []PublicKey) {

+ n := len(msk)

+ mpk = make([]PublicKey, n)

+ for i := 0; i < n; i++ {

+ mpk[i] = *msk[i].GetPublicKey()

+ }

+ return mpk

+}

+

+// Set --

+func (sec *SecretKey) Set(msk []SecretKey, id *ID) error {

+ // #nosec

+ return FrEvaluatePolynomial(&sec.v, *(*[]Fr)(unsafe.Pointer(&msk)), &id.v)

+}

+

+// Recover --

+func (sec *SecretKey) Recover(secVec []SecretKey, idVec []ID) error {

+ // #nosec

+ return FrLagrangeInterpolation(&sec.v, *(*[]Fr)(unsafe.Pointer(&idVec)), *(*[]Fr)(unsafe.Pointer(&secVec)))

+}

+

+// GetPop --

+func (sec *SecretKey) GetPop() (sign *Sign) {

+ sign = new(Sign)

+ C.blsGetPop(sign.getPointer(), sec.getPointer())

+ return sign

+}

+

+// PublicKey --

+type PublicKey struct {

+ v G2

+}

+

+// getPointer --

+func (pub *PublicKey) getPointer() (p *C.blsPublicKey) {

+ // #nosec

+ return (*C.blsPublicKey)(unsafe.Pointer(pub))

+}

+

+// Serialize --

+func (pub *PublicKey) Serialize() []byte {

+ return pub.v.Serialize()

+}

+

+// Deserialize --

+func (pub *PublicKey) Deserialize(buf []byte) error {

+ return pub.v.Deserialize(buf)

+}

+

+// SerializeToHexStr --

+func (pub *PublicKey) SerializeToHexStr() string {

+ return pub.v.GetString(IoSerializeHexStr)

+}

+

+// DeserializeHexStr --

+func (pub *PublicKey) DeserializeHexStr(s string) error {

+ return pub.v.SetString(s, IoSerializeHexStr)

+}

+

+// GetHexString --

+func (pub *PublicKey) GetHexString() string {

+ return pub.v.GetString(16)

+}

+

+// SetHexString --

+func (pub *PublicKey) SetHexString(s string) error {

+ return pub.v.SetString(s, 16)

+}

+

+// IsEqual --

+func (pub *PublicKey) IsEqual(rhs *PublicKey) bool {

+ if pub == nil || rhs == nil {

+ return false

+ }

+ return pub.v.IsEqual(&rhs.v)

+}

+

+// Add --

+func (pub *PublicKey) Add(rhs *PublicKey) {

+ G2Add(&pub.v, &pub.v, &rhs.v)

+}

+

+// Set --

+func (pub *PublicKey) Set(mpk []PublicKey, id *ID) error {

+ // #nosec

+ return G2EvaluatePolynomial(&pub.v, *(*[]G2)(unsafe.Pointer(&mpk)), &id.v)

+}

+

+// Recover --

+func (pub *PublicKey) Recover(pubVec []PublicKey, idVec []ID) error {

+ // #nosec

+ return G2LagrangeInterpolation(&pub.v, *(*[]Fr)(unsafe.Pointer(&idVec)), *(*[]G2)(unsafe.Pointer(&pubVec)))

+}

+

+// MarshalJSON implements json.Marshaller.

+func (pub *PublicKey) MarshalJSON() ([]byte, error) {

+ return json.Marshal(&struct {

+ PublicKey []byte `json:"public_key"`

+ }{

+ pub.Serialize(),

+ })

+}

+

+// UnmarshalJSON implements json.Unmarshaller.

+func (pub *PublicKey) UnmarshalJSON(data []byte) error {

+ aux := &struct {

+ PublicKey []byte `json:"public_key"`

+ }{}

+ if err := json.Unmarshal(data, &aux); err != nil {

+ return err

+ }

+ if err := pub.Deserialize(aux.PublicKey); err != nil {

+ return err

+ }

+ return nil

+}

+

+// Sign --

+type Sign struct {

+ v G1

+}

+

+// getPointer --

+func (sign *Sign) getPointer() (p *C.blsSignature) {

+ // #nosec

+ return (*C.blsSignature)(unsafe.Pointer(sign))

+}

+

+// Serialize --

+func (sign *Sign) Serialize() []byte {

+ return sign.v.Serialize()

+}

+

+// Deserialize --

+func (sign *Sign) Deserialize(buf []byte) error {

+ return sign.v.Deserialize(buf)

+}

+

+// SerializeToHexStr --

+func (sign *Sign) SerializeToHexStr() string {

+ return sign.v.GetString(IoSerializeHexStr)

+}

+

+// DeserializeHexStr --

+func (sign *Sign) DeserializeHexStr(s string) error {

+ return sign.v.SetString(s, IoSerializeHexStr)

+}

+

+// GetHexString --

+func (sign *Sign) GetHexString() string {

+ return sign.v.GetString(16)

+}

+

+// SetHexString --

+func (sign *Sign) SetHexString(s string) error {

+ return sign.v.SetString(s, 16)

+}

+

+// IsEqual --

+func (sign *Sign) IsEqual(rhs *Sign) bool {

+ if sign == nil || rhs == nil {

+ return false

+ }

+ return sign.v.IsEqual(&rhs.v)

+}

+

+// GetPublicKey --

+func (sec *SecretKey) GetPublicKey() (pub *PublicKey) {

+ pub = new(PublicKey)

+ C.blsGetPublicKey(pub.getPointer(), sec.getPointer())

+ return pub

+}

+

+// Sign -- Constant Time version

+func (sec *SecretKey) Sign(m string) (sign *Sign) {

+ sign = new(Sign)

+ buf := []byte(m)

+ // #nosec

+ C.blsSign(sign.getPointer(), sec.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf)))

+ return sign

+}

+

+// Add --

+func (sign *Sign) Add(rhs *Sign) {

+ C.blsSignatureAdd(sign.getPointer(), rhs.getPointer())

+}

+

+// Recover --

+func (sign *Sign) Recover(signVec []Sign, idVec []ID) error {

+ // #nosec

+ return G1LagrangeInterpolation(&sign.v, *(*[]Fr)(unsafe.Pointer(&idVec)), *(*[]G1)(unsafe.Pointer(&signVec)))

+}

+

+// Verify --

+func (sign *Sign) Verify(pub *PublicKey, m string) bool {

+ buf := []byte(m)

+ // #nosec

+ return C.blsVerify(sign.getPointer(), pub.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf))) == 1

+}

+

+// VerifyPop --

+func (sign *Sign) VerifyPop(pub *PublicKey) bool {

+ if pub.getPointer() == nil {

+ return false

+ }

+ return C.blsVerifyPop(sign.getPointer(), pub.getPointer()) == 1

+}

+

+// MarshalJSON implements json.Marshaller.

+func (sign *Sign) MarshalJSON() ([]byte, error) {

+ return json.Marshal(&struct {

+ Sign []byte `json:"sign"`

+ }{

+ sign.Serialize(),

+ })

+}

+

+// UnmarshalJSON implements json.Unmarshaller.

+func (sign *Sign) UnmarshalJSON(data []byte) error {

+ aux := &struct {

+ Sign []byte `json:"sign"`

+ }{}

+ if err := json.Unmarshal(data, &aux); err != nil {

+ return err

+ }

+ if err := sign.Deserialize(aux.Sign); err != nil {

+ return err

+ }

+ return nil

+}

+

+// DHKeyExchange --

+func DHKeyExchange(sec *SecretKey, pub *PublicKey) (out PublicKey) {

+ C.blsDHKeyExchange(out.getPointer(), sec.getPointer(), pub.getPointer())

+ return out

+}

+

+// HashAndMapToSignature --

+func HashAndMapToSignature(buf []byte) *Sign {

+ sig := new(Sign)

+ err := sig.v.HashAndMapTo(buf)

+ if err == nil {

+ return sig

+ } else {

+ return nil

+ }

+}

+

+// VerifyPairing --

+func VerifyPairing(X *Sign, Y *Sign, pub *PublicKey) bool {

+ if X.getPointer() == nil || Y.getPointer() == nil || pub.getPointer() == nil {

+ return false

+ }

+ return C.blsVerifyPairing(X.getPointer(), Y.getPointer(), pub.getPointer()) == 1

+}

+

+// SignHash --

+func (sec *SecretKey) SignHash(hash []byte) (sign *Sign) {

+ sign = new(Sign)

+ // #nosec

+ err := C.blsSignHash(sign.getPointer(), sec.getPointer(), unsafe.Pointer(&hash[0]), C.size_t(len(hash)))

+ if err == 0 {

+ return sign

+ } else {

+ return nil

+ }

+}

+

+// VerifyHash --

+func (sign *Sign) VerifyHash(pub *PublicKey, hash []byte) bool {

+ if pub.getPointer() == nil {

+ return false

+ }

+ // #nosec

+ return C.blsVerifyHash(sign.getPointer(), pub.getPointer(), unsafe.Pointer(&hash[0]), C.size_t(len(hash))) == 1

+}

+

+func Min(x, y int) int {

+ if x < y {

+ return x

+ }

+ return y

+}

+

+// VerifyAggregateHashes --

+func (sign *Sign) VerifyAggregateHashes(pubVec []PublicKey, hash [][]byte) bool {

+ hashByte := GetOpUnitSize() * 8

+ n := len(hash)

+ h := make([]byte, n*hashByte)

+ for i := 0; i < n; i++ {

+ hn := len(hash[i])

+ copy(h[i*hashByte:(i+1)*hashByte], hash[i][0:Min(hn, hashByte)])

+ }

+ if pubVec[0].getPointer() == nil {

+ return false

+ }

+ return C.blsVerifyAggregatedHashes(sign.getPointer(), pubVec[0].getPointer(), unsafe.Pointer(&h[0]), C.size_t(hashByte), C.size_t(n)) == 1

+}

+

+///

+

+var s_randReader io.Reader

+

+func createSlice(buf *C.char, n C.uint) []byte {

+ size := int(n)

+ return (*[1 << 30]byte)(unsafe.Pointer(buf))[:size:size]

+}

+

+// this function can't be put in callback.go

+//export wrapReadRandGo

+func wrapReadRandGo(buf *C.char, n C.uint) C.uint {

+ slice := createSlice(buf, n)

+ ret, err := s_randReader.Read(slice)

+ if ret == int(n) && err == nil {

+ return n

+ }

+ return 0

+}

+

+// SetRandFunc --

+func SetRandFunc(randReader io.Reader) {

+ s_randReader = randReader

+ if randReader != nil {

+ C.blsSetRandFunc(nil, C.ReadRandFunc(unsafe.Pointer(C.wrapReadRandCgo)))

+ } else {

+ // use default random generator

+ C.blsSetRandFunc(nil, C.ReadRandFunc(unsafe.Pointer(nil)))

+ }

+}

+package bls

+

+/*

+// exported from bls.go

+unsigned int wrapReadRandGo(void *buf, unsigned int n);

+int wrapReadRandCgo(void *self, void *buf, unsigned int n)

+{

+ (void)self;

+ return wrapReadRandGo(buf, n);

+}

+*/

+import "C"

+// This is a dummy source file which forces cgo to use the C++ linker instead

+// of the default C linker. We can therefore eliminate non-portable linker

+// flags such as -lstdc++, which is likely to break on FreeBSD and OpenBSD.

+package bls

+

+/*

+#cgo bn256 CFLAGS:-DMCLBN_FP_UNIT_SIZE=4

+#cgo bn384 CFLAGS:-DMCLBN_FP_UNIT_SIZE=6

+#cgo bn384_256 CFLAGS:-DMCLBN_FP_UNIT_SIZE=6 -DMCLBN_FR_UNIT_SIZE=4

+#cgo !bn256,!bn384,!bn384_256 CFLAGS:-DMCLBN_FP_UNIT_SIZE=6

+#include <mcl/bn.h>

+*/

+import "C"

+import "fmt"

+import "unsafe"

+

+// CurveFp254BNb -- 254 bit curve

+const CurveFp254BNb = C.mclBn_CurveFp254BNb

+

+// CurveFp382_1 -- 382 bit curve 1

+const CurveFp382_1 = C.mclBn_CurveFp382_1

+

+// CurveFp382_2 -- 382 bit curve 2

+const CurveFp382_2 = C.mclBn_CurveFp382_2

+

+// BLS12_381

+const BLS12_381 = C.MCL_BLS12_381

+

+// IoSerializeHexStr

+const IoSerializeHexStr = C.MCLBN_IO_SERIALIZE_HEX_STR

+

+// GetFrUnitSize() --

+func GetFrUnitSize() int {

+ return int(C.MCLBN_FR_UNIT_SIZE)

+}

+

+// GetFpUnitSize() --

+// same as GetMaxOpUnitSize()

+func GetFpUnitSize() int {

+ return int(C.MCLBN_FP_UNIT_SIZE)

+}

+

+// GetMaxOpUnitSize --

+func GetMaxOpUnitSize() int {

+ return int(C.MCLBN_FP_UNIT_SIZE)

+}

+

+// GetOpUnitSize --

+// the length of Fr is GetOpUnitSize() * 8 bytes

+func GetOpUnitSize() int {

+ return int(C.mclBn_getOpUnitSize())

+}

+

+// GetCurveOrder --

+// return the order of G1

+func GetCurveOrder() string {

+ buf := make([]byte, 1024)

+ // #nosec

+ n := C.mclBn_getCurveOrder((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)))

+ if n == 0 {

+ panic("implementation err. size of buf is small")

+ }

+ return string(buf[:n])

+}

+

+// GetFieldOrder --

+// return the characteristic of the field where a curve is defined

+func GetFieldOrder() string {

+ buf := make([]byte, 1024)

+ // #nosec

+ n := C.mclBn_getFieldOrder((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)))

+ if n == 0 {

+ panic("implementation err. size of buf is small")

+ }

+ return string(buf[:n])

+}

+

+// Fr --

+type Fr struct {

+ v C.mclBnFr

+}

+

+// getPointer --

+func (x *Fr) getPointer() (p *C.mclBnFr) {

+ // #nosec

+ return (*C.mclBnFr)(unsafe.Pointer(x))

+}

+

+// Clear --

+func (x *Fr) Clear() {

+ // #nosec

+ C.mclBnFr_clear(x.getPointer())

+}

+

+// SetInt64 --

+func (x *Fr) SetInt64(v int64) {

+ // #nosec

+ C.mclBnFr_setInt(x.getPointer(), C.int64_t(v))

+}

+

+// SetString --

+func (x *Fr) SetString(s string, base int) error {

+ buf := []byte(s)

+ // #nosec

+ err := C.mclBnFr_setStr(x.getPointer(), (*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)), C.int(base))

+ if err != 0 {

+ return fmt.Errorf("err mclBnFr_setStr %x", err)

+ }

+ return nil

+}

+

+// Deserialize --

+func (x *Fr) Deserialize(buf []byte) error {

+ // #nosec

+ err := C.mclBnFr_deserialize(x.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf)))

+ if err == 0 {

+ return fmt.Errorf("err mclBnFr_deserialize %x", buf)

+ }

+ return nil

+}

+

+// SetLittleEndian --

+func (x *Fr) SetLittleEndian(buf []byte) error {

+ // #nosec

+ err := C.mclBnFr_setLittleEndian(x.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf)))

+ if err != 0 {

+ return fmt.Errorf("err mclBnFr_setLittleEndian %x", err)

+ }

+ return nil

+}

+

+// IsEqual --

+func (x *Fr) IsEqual(rhs *Fr) bool {

+ return C.mclBnFr_isEqual(x.getPointer(), rhs.getPointer()) == 1

+}

+

+// IsZero --

+func (x *Fr) IsZero() bool {

+ return C.mclBnFr_isZero(x.getPointer()) == 1

+}

+

+// IsOne --

+func (x *Fr) IsOne() bool {

+ return C.mclBnFr_isOne(x.getPointer()) == 1

+}

+

+// SetByCSPRNG --

+func (x *Fr) SetByCSPRNG() {

+ err := C.mclBnFr_setByCSPRNG(x.getPointer())

+ if err != 0 {

+ panic("err mclBnFr_setByCSPRNG")

+ }

+}

+

+// SetHashOf --

+func (x *Fr) SetHashOf(buf []byte) bool {

+ // #nosec

+ return C.mclBnFr_setHashOf(x.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf))) == 0

+}

+

+// GetString --

+func (x *Fr) GetString(base int) string {

+ buf := make([]byte, 2048)

+ // #nosec

+ n := C.mclBnFr_getStr((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)), x.getPointer(), C.int(base))

+ if n == 0 {

+ panic("err mclBnFr_getStr")

+ }

+ return string(buf[:n])

+}

+

+// Serialize --

+func (x *Fr) Serialize() []byte {

+ buf := make([]byte, 2048)

+ // #nosec

+ n := C.mclBnFr_serialize(unsafe.Pointer(&buf[0]), C.size_t(len(buf)), x.getPointer())

+ if n == 0 {

+ panic("err mclBnFr_serialize")

+ }

+ return buf[:n]

+}

+

+// FrNeg --

+func FrNeg(out *Fr, x *Fr) {

+ C.mclBnFr_neg(out.getPointer(), x.getPointer())

+}

+

+// FrInv --

+func FrInv(out *Fr, x *Fr) {

+ C.mclBnFr_inv(out.getPointer(), x.getPointer())

+}

+

+// FrAdd --

+func FrAdd(out *Fr, x *Fr, y *Fr) {

+ C.mclBnFr_add(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// FrSub --

+func FrSub(out *Fr, x *Fr, y *Fr) {

+ C.mclBnFr_sub(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// FrMul --

+func FrMul(out *Fr, x *Fr, y *Fr) {

+ C.mclBnFr_mul(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// FrDiv --

+func FrDiv(out *Fr, x *Fr, y *Fr) {

+ C.mclBnFr_div(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// G1 --

+type G1 struct {

+ v C.mclBnG1

+}

+

+// getPointer --

+func (x *G1) getPointer() (p *C.mclBnG1) {

+ // #nosec

+ return (*C.mclBnG1)(unsafe.Pointer(x))

+}

+

+// Clear --

+func (x *G1) Clear() {

+ // #nosec

+ C.mclBnG1_clear(x.getPointer())

+}

+

+// SetString --

+func (x *G1) SetString(s string, base int) error {

+ buf := []byte(s)

+ // #nosec

+ err := C.mclBnG1_setStr(x.getPointer(), (*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)), C.int(base))

+ if err != 0 {

+ return fmt.Errorf("err mclBnG1_setStr %x", err)

+ }

+ return nil

+}

+

+// Deserialize --

+func (x *G1) Deserialize(buf []byte) error {

+ // #nosec

+ err := C.mclBnG1_deserialize(x.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf)))

+ if err == 0 {

+ return fmt.Errorf("err mclBnG1_deserialize %x", buf)

+ }

+ return nil

+}

+

+// IsEqual --

+func (x *G1) IsEqual(rhs *G1) bool {

+ return C.mclBnG1_isEqual(x.getPointer(), rhs.getPointer()) == 1

+}

+

+// IsZero --

+func (x *G1) IsZero() bool {

+ return C.mclBnG1_isZero(x.getPointer()) == 1

+}

+

+// HashAndMapTo --

+func (x *G1) HashAndMapTo(buf []byte) error {

+ // #nosec

+ err := C.mclBnG1_hashAndMapTo(x.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf)))

+ if err != 0 {

+ return fmt.Errorf("err mclBnG1_hashAndMapTo %x", err)

+ }

+ return nil

+}

+

+// GetString --

+func (x *G1) GetString(base int) string {

+ buf := make([]byte, 2048)

+ // #nosec

+ n := C.mclBnG1_getStr((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)), x.getPointer(), C.int(base))

+ if n == 0 {

+ panic("err mclBnG1_getStr")

+ }

+ return string(buf[:n])

+}

+

+// Serialize --

+func (x *G1) Serialize() []byte {

+ buf := make([]byte, 2048)

+ // #nosec

+ n := C.mclBnG1_serialize(unsafe.Pointer(&buf[0]), C.size_t(len(buf)), x.getPointer())

+ if n == 0 {

+ panic("err mclBnG1_serialize")

+ }

+ return buf[:n]

+}

+

+// G1Neg --

+func G1Neg(out *G1, x *G1) {

+ C.mclBnG1_neg(out.getPointer(), x.getPointer())

+}

+

+// G1Dbl --

+func G1Dbl(out *G1, x *G1) {

+ C.mclBnG1_dbl(out.getPointer(), x.getPointer())

+}

+

+// G1Add --

+func G1Add(out *G1, x *G1, y *G1) {

+ C.mclBnG1_add(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// G1Sub --

+func G1Sub(out *G1, x *G1, y *G1) {

+ C.mclBnG1_sub(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// G1Mul --

+func G1Mul(out *G1, x *G1, y *Fr) {

+ C.mclBnG1_mul(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// G1MulCT -- constant time (depending on bit lengh of y)

+func G1MulCT(out *G1, x *G1, y *Fr) {

+ C.mclBnG1_mulCT(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// G2 --

+type G2 struct {

+ v C.mclBnG2

+}

+

+// getPointer --

+func (x *G2) getPointer() (p *C.mclBnG2) {

+ // #nosec

+ return (*C.mclBnG2)(unsafe.Pointer(x))

+}

+

+// Clear --

+func (x *G2) Clear() {

+ // #nosec

+ C.mclBnG2_clear(x.getPointer())

+}

+

+// SetString --

+func (x *G2) SetString(s string, base int) error {

+ buf := []byte(s)

+ // #nosec

+ err := C.mclBnG2_setStr(x.getPointer(), (*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)), C.int(base))

+ if err != 0 {

+ return fmt.Errorf("err mclBnG2_setStr %x", err)

+ }

+ return nil

+}

+

+// Deserialize --

+func (x *G2) Deserialize(buf []byte) error {

+ // #nosec

+ err := C.mclBnG2_deserialize(x.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf)))

+ if err == 0 {

+ return fmt.Errorf("err mclBnG2_deserialize %x", buf)

+ }

+ return nil

+}

+

+// IsEqual --

+func (x *G2) IsEqual(rhs *G2) bool {

+ return C.mclBnG2_isEqual(x.getPointer(), rhs.getPointer()) == 1

+}

+

+// IsZero --

+func (x *G2) IsZero() bool {

+ return C.mclBnG2_isZero(x.getPointer()) == 1

+}

+

+// HashAndMapTo --

+func (x *G2) HashAndMapTo(buf []byte) error {

+ // #nosec

+ err := C.mclBnG2_hashAndMapTo(x.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf)))

+ if err != 0 {

+ return fmt.Errorf("err mclBnG2_hashAndMapTo %x", err)

+ }

+ return nil

+}

+

+// GetString --

+func (x *G2) GetString(base int) string {

+ buf := make([]byte, 2048)

+ // #nosec

+ n := C.mclBnG2_getStr((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)), x.getPointer(), C.int(base))

+ if n == 0 {

+ panic("err mclBnG2_getStr")

+ }

+ return string(buf[:n])

+}

+

+// Serialize --

+func (x *G2) Serialize() []byte {

+ buf := make([]byte, 2048)

+ // #nosec

+ n := C.mclBnG2_serialize(unsafe.Pointer(&buf[0]), C.size_t(len(buf)), x.getPointer())

+ if n == 0 {

+ panic("err mclBnG2_serialize")

+ }

+ return buf[:n]

+}

+

+// G2Neg --

+func G2Neg(out *G2, x *G2) {

+ C.mclBnG2_neg(out.getPointer(), x.getPointer())

+}

+

+// G2Dbl --

+func G2Dbl(out *G2, x *G2) {

+ C.mclBnG2_dbl(out.getPointer(), x.getPointer())

+}

+

+// G2Add --

+func G2Add(out *G2, x *G2, y *G2) {

+ C.mclBnG2_add(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// G2Sub --

+func G2Sub(out *G2, x *G2, y *G2) {

+ C.mclBnG2_sub(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// G2Mul --

+func G2Mul(out *G2, x *G2, y *Fr) {

+ C.mclBnG2_mul(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// GT --

+type GT struct {

+ v C.mclBnGT

+}

+

+// getPointer --

+func (x *GT) getPointer() (p *C.mclBnGT) {

+ // #nosec

+ return (*C.mclBnGT)(unsafe.Pointer(x))

+}

+

+// Clear --

+func (x *GT) Clear() {

+ // #nosec

+ C.mclBnGT_clear(x.getPointer())

+}

+

+// SetInt64 --

+func (x *GT) SetInt64(v int64) {

+ // #nosec

+ C.mclBnGT_setInt(x.getPointer(), C.int64_t(v))

+}

+

+// SetString --

+func (x *GT) SetString(s string, base int) error {

+ buf := []byte(s)

+ // #nosec

+ err := C.mclBnGT_setStr(x.getPointer(), (*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)), C.int(base))

+ if err != 0 {

+ return fmt.Errorf("err mclBnGT_setStr %x", err)

+ }

+ return nil

+}

+

+// Deserialize --

+func (x *GT) Deserialize(buf []byte) error {

+ // #nosec

+ err := C.mclBnGT_deserialize(x.getPointer(), unsafe.Pointer(&buf[0]), C.size_t(len(buf)))

+ if err == 0 {

+ return fmt.Errorf("err mclBnGT_deserialize %x", buf)

+ }

+ return nil

+}

+

+// IsEqual --

+func (x *GT) IsEqual(rhs *GT) bool {

+ return C.mclBnGT_isEqual(x.getPointer(), rhs.getPointer()) == 1

+}

+

+// IsZero --

+func (x *GT) IsZero() bool {

+ return C.mclBnGT_isZero(x.getPointer()) == 1

+}

+

+// IsOne --

+func (x *GT) IsOne() bool {

+ return C.mclBnGT_isOne(x.getPointer()) == 1

+}

+

+// GetString --

+func (x *GT) GetString(base int) string {

+ buf := make([]byte, 2048)

+ // #nosec

+ n := C.mclBnGT_getStr((*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf)), x.getPointer(), C.int(base))

+ if n == 0 {

+ panic("err mclBnGT_getStr")

+ }

+ return string(buf[:n])

+}

+

+// Serialize --

+func (x *GT) Serialize() []byte {

+ buf := make([]byte, 2048)

+ // #nosec

+ n := C.mclBnGT_serialize(unsafe.Pointer(&buf[0]), C.size_t(len(buf)), x.getPointer())

+ if n == 0 {

+ panic("err mclBnGT_serialize")

+ }

+ return buf[:n]

+}

+

+// GTNeg --

+func GTNeg(out *GT, x *GT) {

+ C.mclBnGT_neg(out.getPointer(), x.getPointer())

+}

+

+// GTInv --

+func GTInv(out *GT, x *GT) {

+ C.mclBnGT_inv(out.getPointer(), x.getPointer())

+}

+

+// GTAdd --

+func GTAdd(out *GT, x *GT, y *GT) {

+ C.mclBnGT_add(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// GTSub --

+func GTSub(out *GT, x *GT, y *GT) {

+ C.mclBnGT_sub(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// GTMul --

+func GTMul(out *GT, x *GT, y *GT) {

+ C.mclBnGT_mul(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// GTDiv --

+func GTDiv(out *GT, x *GT, y *GT) {

+ C.mclBnGT_div(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// GTPow --

+func GTPow(out *GT, x *GT, y *Fr) {

+ C.mclBnGT_pow(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// Pairing --

+func Pairing(out *GT, x *G1, y *G2) {

+ C.mclBn_pairing(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// FinalExp --

+func FinalExp(out *GT, x *GT) {

+ C.mclBn_finalExp(out.getPointer(), x.getPointer())

+}

+

+// MillerLoop --

+func MillerLoop(out *GT, x *G1, y *G2) {

+ C.mclBn_millerLoop(out.getPointer(), x.getPointer(), y.getPointer())

+}

+

+// GetUint64NumToPrecompute --

+func GetUint64NumToPrecompute() int {

+ return int(C.mclBn_getUint64NumToPrecompute())

+}

+

+// PrecomputeG2 --

+func PrecomputeG2(Qbuf []uint64, Q *G2) {

+ // #nosec

+ C.mclBn_precomputeG2((*C.uint64_t)(unsafe.Pointer(&Qbuf[0])), Q.getPointer())

+}

+

+// PrecomputedMillerLoop --

+func PrecomputedMillerLoop(out *GT, P *G1, Qbuf []uint64) {

+ // #nosec

+ C.mclBn_precomputedMillerLoop(out.getPointer(), P.getPointer(), (*C.uint64_t)(unsafe.Pointer(&Qbuf[0])))

+}

+

+// PrecomputedMillerLoop2 --

+func PrecomputedMillerLoop2(out *GT, P1 *G1, Q1buf []uint64, P2 *G1, Q2buf []uint64) {

+ // #nosec

+ C.mclBn_precomputedMillerLoop2(out.getPointer(), P1.getPointer(), (*C.uint64_t)(unsafe.Pointer(&Q1buf[0])), P1.getPointer(), (*C.uint64_t)(unsafe.Pointer(&Q1buf[0])))

+}

+

+// FrEvaluatePolynomial -- y = c[0] + c[1] * x + c[2] * x^2 + ...

+func FrEvaluatePolynomial(y *Fr, c []Fr, x *Fr) error {

+ // #nosec

+ err := C.mclBn_FrEvaluatePolynomial(y.getPointer(), (*C.mclBnFr)(unsafe.Pointer(&c[0])), (C.size_t)(len(c)), x.getPointer())

+ if err != 0 {

+ return fmt.Errorf("err mclBn_FrEvaluatePolynomial")

+ }

+ return nil

+}

+

+// G1EvaluatePolynomial -- y = c[0] + c[1] * x + c[2] * x^2 + ...

+func G1EvaluatePolynomial(y *G1, c []G1, x *Fr) error {

+ // #nosec

+ err := C.mclBn_G1EvaluatePolynomial(y.getPointer(), (*C.mclBnG1)(unsafe.Pointer(&c[0])), (C.size_t)(len(c)), x.getPointer())

+ if err != 0 {

+ return fmt.Errorf("err mclBn_G1EvaluatePolynomial")

+ }

+ return nil

+}

+

+// G2EvaluatePolynomial -- y = c[0] + c[1] * x + c[2] * x^2 + ...

+func G2EvaluatePolynomial(y *G2, c []G2, x *Fr) error {

+ // #nosec

+ err := C.mclBn_G2EvaluatePolynomial(y.getPointer(), (*C.mclBnG2)(unsafe.Pointer(&c[0])), (C.size_t)(len(c)), x.getPointer())

+ if err != 0 {

+ return fmt.Errorf("err mclBn_G2EvaluatePolynomial")

+ }

+ return nil

+}

+

+// FrLagrangeInterpolation --

+func FrLagrangeInterpolation(out *Fr, xVec []Fr, yVec []Fr) error {

+ if len(xVec) != len(yVec) {

+ return fmt.Errorf("err FrLagrangeInterpolation:bad size")

+ }

+ // #nosec

+ err := C.mclBn_FrLagrangeInterpolation(out.getPointer(), (*C.mclBnFr)(unsafe.Pointer(&xVec[0])), (*C.mclBnFr)(unsafe.Pointer(&yVec[0])), (C.size_t)(len(xVec)))

+ if err != 0 {

+ return fmt.Errorf("err FrLagrangeInterpolation")

+ }

+ return nil

+}

+

+// G1LagrangeInterpolation --

+func G1LagrangeInterpolation(out *G1, xVec []Fr, yVec []G1) error {

+ if len(xVec) != len(yVec) {

+ return fmt.Errorf("err G1LagrangeInterpolation:bad size")

+ }

+ // #nosec

+ err := C.mclBn_G1LagrangeInterpolation(out.getPointer(), (*C.mclBnFr)(unsafe.Pointer(&xVec[0])), (*C.mclBnG1)(unsafe.Pointer(&yVec[0])), (C.size_t)(len(xVec)))

+ if err != 0 {

+ return fmt.Errorf("err G1LagrangeInterpolation")

+ }

+ return nil

+}

+

+// G2LagrangeInterpolation --

+func G2LagrangeInterpolation(out *G2, xVec []Fr, yVec []G2) error {

+ if len(xVec) != len(yVec) {

+ return fmt.Errorf("err G2LagrangeInterpolation:bad size")

+ }

+ // #nosec

+ err := C.mclBn_G2LagrangeInterpolation(out.getPointer(), (*C.mclBnFr)(unsafe.Pointer(&xVec[0])), (*C.mclBnG2)(unsafe.Pointer(&yVec[0])), (C.size_t)(len(xVec)))

+ if err != 0 {

+ return fmt.Errorf("err G2LagrangeInterpolation")

+ }

+ return nil

+}

+FROM golang:alpine

+MAINTAINER Jimmy Hu <jimmy.hu@dexon.org>

+

+# Install dependencies

+RUN apk add --update-cache build-base gmp-dev openssl-dev git

+

+# Build bls library

+RUN mkdir work ; cd work

+RUN git clone --depth 1 git://github.com/dexon-foundation/mcl.git

+RUN mkdir bls

+COPY . bls/

+RUN cd bls ; make clean && make test_go DOCKER=alpine -j && cp lib/* /usr/lib/

+#pragma once

+/**

+ @file

+ @brief C interface of bls.hpp

+ @author MITSUNARI Shigeo(@herumi)

+ @license modified new BSD license

+ http://opensource.org/licenses/BSD-3-Clause

+*/

+#include <mcl/bn.h>

+

+#ifdef BLS_SWAP_G

+ /*

+ error if BLS_SWAP_G is inconsistently used between library and exe

+ */

+ #undef MCLBN_COMPILED_TIME_VAR

+ #define MCLBN_COMPILED_TIME_VAR ((MCLBN_FR_UNIT_SIZE) * 10 + (MCLBN_FP_UNIT_SIZE) + 100)

+#endif

+

+#ifdef _MSC_VER

+ #ifdef BLS_DONT_EXPORT

+ #define BLS_DLL_API

+ #else

+ #ifdef BLS_DLL_EXPORT

+ #define BLS_DLL_API __declspec(dllexport)

+ #else

+ #define BLS_DLL_API __declspec(dllimport)

+ #endif

+ #endif

+ #ifndef BLS_NO_AUTOLINK

+ #if MCLBN_FP_UNIT_SIZE == 4

+ #pragma comment(lib, "bls256.lib")

+ #elif (MCLBN_FP_UNIT_SIZE == 6) && (MCLBN_FR_UNIT_SIZE == 4)

+ #pragma comment(lib, "bls384_256.lib")

+ #elif (MCLBN_FP_UNIT_SIZE == 6) && (MCLBN_FR_UNIT_SIZE == 6)

+ #pragma comment(lib, "bls384.lib")

+ #endif

+ #endif

+#elif defined(__EMSCRIPTEN__) && !defined(BLS_DONT_EXPORT)

+ #define BLS_DLL_API __attribute__((used))

+#elif defined(__wasm__) && !defined(BLS_DONT_EXPORT)

+ #define BLS_DLL_API __attribute__((visibility("default")))

+#else

+ #define BLS_DLL_API

+#endif

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+typedef struct {

+ mclBnFr v;

+} blsId;

+

+typedef struct {

+ mclBnFr v;

+} blsSecretKey;

+

+typedef struct {

+#ifdef BLS_SWAP_G

+ mclBnG1 v;

+#else

+ mclBnG2 v;

+#endif

+} blsPublicKey;

+

+typedef struct {

+#ifdef BLS_SWAP_G

+ mclBnG2 v;

+#else

+ mclBnG1 v;

+#endif

+} blsSignature;

+

+/*

+ initialize this library

+ call this once before using the other functions

+ @param curve [in] enum value defined in mcl/bn.h

+ @param compiledTimeVar [in] specify MCLBN_COMPILED_TIME_VAR,

+ which macro is used to make sure that the values

+ are the same when the library is built and used

+ @return 0 if success

+ @note blsInit() is thread safe and serialized if it is called simultaneously

+ but don't call it while using other functions.

+*/

+BLS_DLL_API int blsInit(int curve, int compiledTimeVar);

+

+BLS_DLL_API void blsIdSetInt(blsId *id, int x);

+

+// sec = buf & (1 << bitLen(r)) - 1

+// if (sec >= r) sec &= (1 << (bitLen(r) - 1)) - 1

+// always return 0

+BLS_DLL_API int blsSecretKeySetLittleEndian(blsSecretKey *sec, const void *buf, mclSize bufSize);

+// return 0 if success (bufSize <= 64) else -1

+// set (buf mod r) to sec

+BLS_DLL_API int blsSecretKeySetLittleEndianMod(blsSecretKey *sec, const void *buf, mclSize bufSize);

+

+BLS_DLL_API void blsGetPublicKey(blsPublicKey *pub, const blsSecretKey *sec);

+

+// calculate the has of m and sign the hash

+BLS_DLL_API void blsSign(blsSignature *sig, const blsSecretKey *sec, const void *m, mclSize size);

+

+// return 1 if valid

+BLS_DLL_API int blsVerify(const blsSignature *sig, const blsPublicKey *pub, const void *m, mclSize size);

+

+// return written byte size if success else 0

+BLS_DLL_API mclSize blsIdSerialize(void *buf, mclSize maxBufSize, const blsId *id);

+BLS_DLL_API mclSize blsSecretKeySerialize(void *buf, mclSize maxBufSize, const blsSecretKey *sec);

+BLS_DLL_API mclSize blsPublicKeySerialize(void *buf, mclSize maxBufSize, const blsPublicKey *pub);

+BLS_DLL_API mclSize blsSignatureSerialize(void *buf, mclSize maxBufSize, const blsSignature *sig);

+

+// return read byte size if success else 0

+BLS_DLL_API mclSize blsIdDeserialize(blsId *id, const void *buf, mclSize bufSize);

+BLS_DLL_API mclSize blsSecretKeyDeserialize(blsSecretKey *sec, const void *buf, mclSize bufSize);

+BLS_DLL_API mclSize blsPublicKeyDeserialize(blsPublicKey *pub, const void *buf, mclSize bufSize);

+BLS_DLL_API mclSize blsSignatureDeserialize(blsSignature *sig, const void *buf, mclSize bufSize);

+

+// return 1 if same else 0

+BLS_DLL_API int blsIdIsEqual(const blsId *lhs, const blsId *rhs);

+BLS_DLL_API int blsSecretKeyIsEqual(const blsSecretKey *lhs, const blsSecretKey *rhs);

+BLS_DLL_API int blsPublicKeyIsEqual(const blsPublicKey *lhs, const blsPublicKey *rhs);

+BLS_DLL_API int blsSignatureIsEqual(const blsSignature *lhs, const blsSignature *rhs);

+

+// return 0 if success

+BLS_DLL_API int blsSecretKeyShare(blsSecretKey *sec, const blsSecretKey* msk, mclSize k, const blsId *id);

+BLS_DLL_API int blsPublicKeyShare(blsPublicKey *pub, const blsPublicKey *mpk, mclSize k, const blsId *id);

+

+BLS_DLL_API int blsSecretKeyRecover(blsSecretKey *sec, const blsSecretKey *secVec, const blsId *idVec, mclSize n);

+BLS_DLL_API int blsPublicKeyRecover(blsPublicKey *pub, const blsPublicKey *pubVec, const blsId *idVec, mclSize n);

+BLS_DLL_API int blsSignatureRecover(blsSignature *sig, const blsSignature *sigVec, const blsId *idVec, mclSize n);

+

+// add

+BLS_DLL_API void blsSecretKeyAdd(blsSecretKey *sec, const blsSecretKey *rhs);

+BLS_DLL_API void blsPublicKeyAdd(blsPublicKey *pub, const blsPublicKey *rhs);

+BLS_DLL_API void blsSignatureAdd(blsSignature *sig, const blsSignature *rhs);

+

+/*

+ verify whether a point of an elliptic curve has order r

+ This api affetcs setStr(), deserialize() for G2 on BN or G1/G2 on BLS12

+ @param doVerify [in] does not verify if zero(default 1)

+ Signature = G1, PublicKey = G2

+*/

+BLS_DLL_API void blsSignatureVerifyOrder(int doVerify);

+BLS_DLL_API void blsPublicKeyVerifyOrder(int doVerify);

+// deserialize under VerifyOrder(true) = deserialize under VerifyOrder(false) + IsValidOrder

+BLS_DLL_API int blsSignatureIsValidOrder(const blsSignature *sig);

+BLS_DLL_API int blsPublicKeyIsValidOrder(const blsPublicKey *pub);

+

+#ifndef BLS_MINIMUM_API

+

+/*

+ verify X == sY by checking e(X, sQ) = e(Y, Q)

+ @param X [in]

+ @param Y [in]

+ @param pub [in] pub = sQ

+ @return 1 if e(X, pub) = e(Y, Q) else 0

+*/

+BLS_DLL_API int blsVerifyPairing(const blsSignature *X, const blsSignature *Y, const blsPublicKey *pub);

+

+/*

+ sign the hash

+ use the low (bitSize of r) - 1 bit of h

+ return 0 if success else -1

+ NOTE : return false if h is zero or c1 or -c1 value for BN254. see hashTest() in test/bls_test.hpp

+*/

+BLS_DLL_API int blsSignHash(blsSignature *sig, const blsSecretKey *sec, const void *h, mclSize size);

+// return 1 if valid

+BLS_DLL_API int blsVerifyHash(const blsSignature *sig, const blsPublicKey *pub, const void *h, mclSize size);

+

+/*

+ verify aggSig with pubVec[0, n) and hVec[0, n)

+ e(aggSig, Q) = prod_i e(hVec[i], pubVec[i])

+ return 1 if valid

+ @note do not check duplication of hVec

+*/

+BLS_DLL_API int blsVerifyAggregatedHashes(const blsSignature *aggSig, const blsPublicKey *pubVec, const void *hVec, size_t sizeofHash, mclSize n);

+

+// sub

+BLS_DLL_API void blsSecretKeySub(blsSecretKey *sec, const blsSecretKey *rhs);

+BLS_DLL_API void blsPublicKeySub(blsPublicKey *pub, const blsPublicKey *rhs);

+BLS_DLL_API void blsSignatureSub(blsSignature *sig, const blsSignature *rhs);

+

+// not thread safe version (old blsInit)

+BLS_DLL_API int blsInitNotThreadSafe(int curve, int compiledTimeVar);

+

+BLS_DLL_API mclSize blsGetOpUnitSize(void);

+// return strlen(buf) if success else 0

+BLS_DLL_API int blsGetCurveOrder(char *buf, mclSize maxBufSize);

+BLS_DLL_API int blsGetFieldOrder(char *buf, mclSize maxBufSize);

+

+// return bytes for serialized G1(=Fp)

+BLS_DLL_API int blsGetG1ByteSize(void);

+

+// return bytes for serialized Fr

+BLS_DLL_API int blsGetFrByteSize(void);

+

+#ifdef BLS_SWAP_G

+// get a generator of G1

+BLS_DLL_API void blsGetGeneratorOfG1(blsPublicKey *pub);

+#else

+// get a generator of G2

+BLS_DLL_API void blsGetGeneratorOfG2(blsPublicKey *pub);

+#endif

+

+// return 0 if success

+BLS_DLL_API int blsIdSetDecStr(blsId *id, const char *buf, mclSize bufSize);

+BLS_DLL_API int blsIdSetHexStr(blsId *id, const char *buf, mclSize bufSize);

+

+/*

+ return strlen(buf) if success else 0

+ buf is '\0' terminated

+*/

+BLS_DLL_API mclSize blsIdGetDecStr(char *buf, mclSize maxBufSize, const blsId *id);

+BLS_DLL_API mclSize blsIdGetHexStr(char *buf, mclSize maxBufSize, const blsId *id);

+

+// hash buf and set

+BLS_DLL_API int blsHashToSecretKey(blsSecretKey *sec, const void *buf, mclSize bufSize);

+#ifndef MCL_DONT_USE_CSPRNG

+/*

+ set secretKey if system has /dev/urandom or CryptGenRandom

+ return 0 if success else -1

+*/

+BLS_DLL_API int blsSecretKeySetByCSPRNG(blsSecretKey *sec);

+/*

+ set user-defined random function for setByCSPRNG

+ @param self [in] user-defined pointer

+ @param readFunc [in] user-defined function,

+ which writes random bufSize bytes to buf and returns bufSize if success else returns 0

+ @note if self == 0 and readFunc == 0 then set default random function

+ @note not threadsafe

+*/

+BLS_DLL_API void blsSetRandFunc(void *self, unsigned int (*readFunc)(void *self, void *buf, unsigned int bufSize));

+#endif

+

+BLS_DLL_API void blsGetPop(blsSignature *sig, const blsSecretKey *sec);

+

+BLS_DLL_API int blsVerifyPop(const blsSignature *sig, const blsPublicKey *pub);

+//////////////////////////////////////////////////////////////////////////

+// the following apis will be removed

+

+// mask buf with (1 << (bitLen(r) - 1)) - 1 if buf >= r

+BLS_DLL_API int blsIdSetLittleEndian(blsId *id, const void *buf, mclSize bufSize);

+/*

+ return written byte size if success else 0

+*/

+BLS_DLL_API mclSize blsIdGetLittleEndian(void *buf, mclSize maxBufSize, const blsId *id);

+

+// return 0 if success

+BLS_DLL_API int blsSecretKeySetDecStr(blsSecretKey *sec, const char *buf, mclSize bufSize);

+BLS_DLL_API int blsSecretKeySetHexStr(blsSecretKey *sec, const char *buf, mclSize bufSize);

+/*

+ return written byte size if success else 0

+*/

+BLS_DLL_API mclSize blsSecretKeyGetLittleEndian(void *buf, mclSize maxBufSize, const blsSecretKey *sec);

+/*

+ return strlen(buf) if success else 0

+ buf is '\0' terminated

+*/

+BLS_DLL_API mclSize blsSecretKeyGetDecStr(char *buf, mclSize maxBufSize, const blsSecretKey *sec);

+BLS_DLL_API mclSize blsSecretKeyGetHexStr(char *buf, mclSize maxBufSize, const blsSecretKey *sec);

+BLS_DLL_API int blsPublicKeySetHexStr(blsPublicKey *pub, const char *buf, mclSize bufSize);

+BLS_DLL_API mclSize blsPublicKeyGetHexStr(char *buf, mclSize maxBufSize, const blsPublicKey *pub);

+BLS_DLL_API int blsSignatureSetHexStr(blsSignature *sig, const char *buf, mclSize bufSize);

+BLS_DLL_API mclSize blsSignatureGetHexStr(char *buf, mclSize maxBufSize, const blsSignature *sig);

+

+/*

+ Diffie Hellman key exchange

+ out = sec * pub

+*/

+BLS_DLL_API void blsDHKeyExchange(blsPublicKey *out, const blsSecretKey *sec, const blsPublicKey *pub);

+

+#endif // BLS_MINIMUM_API

+

+#ifdef __cplusplus

+}

+#endif

+#pragma once

+/**

+ @file

+ @brief BLS threshold signature on BN curve

+ @author MITSUNARI Shigeo(@herumi)

+ @license modified new BSD license

+ http://opensource.org/licenses/BSD-3-Clause

+*/

+#include <bls/bls.h>

+#include <stdexcept>

+#include <vector>

+#include <string>

+#include <iosfwd>

+#include <stdint.h>

+

+namespace bls {

+

+// same value with IoMode of mcl/op.hpp

+enum {

+ IoBin = 2, // binary number

+ IoDec = 10, // decimal number

+ IoHex = 16, // hexadecimal number

+ IoPrefix = 128, // append '0b'(bin) or '0x'(hex)

+ IoSerialize = 512,

+ IoFixedByteSeq = IoSerialize // fixed byte representation

+};

+

+/*

+ BLS signature

+ e : G2 x G1 -> Fp12

+ Q in G2 ; fixed global parameter

+ H : {str} -> G1

+ s : secret key

+ sQ ; public key

+ s H(m) ; signature of m

+ verify ; e(sQ, H(m)) = e(Q, s H(m))

+*/

+

+/*

+ initialize this library

+ call this once before using the other method

+ @param curve [in] type of curve

+ @param compiledTimevar [in] use the default value

+ @note init() is not thread safe

+*/

+inline void init(int curve = mclBn_CurveFp254BNb, int compiledTimeVar = MCLBN_COMPILED_TIME_VAR)

+{

+ if (blsInit(curve, compiledTimeVar) != 0) throw std::invalid_argument("blsInit");

+}

+inline size_t getOpUnitSize() { return blsGetOpUnitSize(); }

+

+inline void getCurveOrder(std::string& str)

+{

+ str.resize(1024);

+ mclSize n = blsGetCurveOrder(&str[0], str.size());

+ if (n == 0) throw std::runtime_error("blsGetCurveOrder");

+ str.resize(n);

+}

+inline void getFieldOrder(std::string& str)

+{

+ str.resize(1024);

+ mclSize n = blsGetFieldOrder(&str[0], str.size());

+ if (n == 0) throw std::runtime_error("blsGetFieldOrder");

+ str.resize(n);

+}

+inline int getG1ByteSize() { return blsGetG1ByteSize(); }

+inline int getFrByteSize() { return blsGetFrByteSize(); }

+

+namespace local {

+/*

+ the value of secretKey and Id must be less than

+ r = 0x2523648240000001ba344d8000000007ff9f800000000010a10000000000000d

+ sizeof(uint64_t) * keySize byte

+*/

+const size_t keySize = MCLBN_FP_UNIT_SIZE;

+}

+

+class SecretKey;

+class PublicKey;

+class Signature;

+class Id;

+

+typedef std::vector<SecretKey> SecretKeyVec;

+typedef std::vector<PublicKey> PublicKeyVec;

+typedef std::vector<Signature> SignatureVec;

+typedef std::vector<Id> IdVec;

+

+class Id {

+ blsId self_;

+ friend class PublicKey;

+ friend class SecretKey;

+ friend class Signature;

+public:

+ Id(unsigned int id = 0)

+ {

+ blsIdSetInt(&self_, id);

+ }

+ bool operator==(const Id& rhs) const

+ {

+ return blsIdIsEqual(&self_, &rhs.self_) == 1;

+ }

+ bool operator!=(const Id& rhs) const { return !(*this == rhs); }

+ friend std::ostream& operator<<(std::ostream& os, const Id& id)

+ {

+ std::string str;

+ id.getStr(str, 16|IoPrefix);

+ return os << str;

+ }

+ friend std::istream& operator>>(std::istream& is, Id& id)

+ {

+ std::string str;

+ is >> str;

+ id.setStr(str, 16);

+ return is;

+ }

+ void getStr(std::string& str, int ioMode = 0) const

+ {

+ str.resize(1024);

+ size_t n = mclBnFr_getStr(&str[0], str.size(), &self_.v, ioMode);

+ if (n == 0) throw std::runtime_error("mclBnFr_getStr");

+ str.resize(n);

+ }

+ void setStr(const std::string& str, int ioMode = 0)

+ {

+ int ret = mclBnFr_setStr(&self_.v, str.c_str(), str.size(), ioMode);

+ if (ret != 0) throw std::runtime_error("mclBnFr_setStr");

+ }

+ bool isZero() const

+ {

+ return mclBnFr_isZero(&self_.v) == 1;

+ }

+ /*

+ set p[0, .., keySize)

+ @note the value must be less than r

+ */

+ void set(const uint64_t *p)

+ {

+ setLittleEndian(p, local::keySize * sizeof(uint64_t));

+ }

+ // bufSize is truncted/zero extended to keySize

+ void setLittleEndian(const void *buf, size_t bufSize)

+ {

+ mclBnFr_setLittleEndian(&self_.v, buf, bufSize);

+ }

+};

+

+/*

+ s ; secret key

+*/

+class SecretKey {

+ blsSecretKey self_;

+public:

+ bool operator==(const SecretKey& rhs) const

+ {

+ return blsSecretKeyIsEqual(&self_, &rhs.self_) == 1;

+ }

+ bool operator!=(const SecretKey& rhs) const { return !(*this == rhs); }

+ friend std::ostream& operator<<(std::ostream& os, const SecretKey& sec)

+ {

+ std::string str;

+ sec.getStr(str, 16|IoPrefix);

+ return os << str;

+ }

+ friend std::istream& operator>>(std::istream& is, SecretKey& sec)

+ {

+ std::string str;

+ is >> str;

+ sec.setStr(str);

+ return is;

+ }

+ void getStr(std::string& str, int ioMode = 0) const

+ {

+ str.resize(1024);

+ size_t n = mclBnFr_getStr(&str[0], str.size(), &self_.v, ioMode);

+ if (n == 0) throw std::runtime_error("mclBnFr_getStr");

+ str.resize(n);

+ }

+ void setStr(const std::string& str, int ioMode = 0)

+ {

+ int ret = mclBnFr_setStr(&self_.v, str.c_str(), str.size(), ioMode);

+ if (ret != 0) throw std::runtime_error("mclBnFr_setStr");

+ }

+ /*

+ initialize secretKey with random number

+ */

+ void init()

+ {

+ int ret = blsSecretKeySetByCSPRNG(&self_);

+ if (ret != 0) throw std::runtime_error("blsSecretKeySetByCSPRNG");

+ }

+ /*

+ set secretKey with p[0, .., keySize) and set id = 0

+ @note the value must be less than r

+ */

+ void set(const uint64_t *p)

+ {

+ setLittleEndian(p, local::keySize * sizeof(uint64_t));

+ }

+ // bufSize is truncted/zero extended to keySize

+ void setLittleEndian(const void *buf, size_t bufSize)

+ {

+ mclBnFr_setLittleEndian(&self_.v, buf, bufSize);

+ }

+ // set hash of buf

+ void setHashOf(const void *buf, size_t bufSize)

+ {

+ int ret = mclBnFr_setHashOf(&self_.v, buf, bufSize);

+ if (ret != 0) throw std::runtime_error("mclBnFr_setHashOf");

+ }

+ void getPublicKey(PublicKey& pub) const;

+ // constant time sign

+ // sign hash(m)

+ void sign(Signature& sig, const void *m, size_t size) const;

+ void sign(Signature& sig, const std::string& m) const

+ {

+ sign(sig, m.c_str(), m.size());

+ }

+ // sign hashed value

+ void signHash(Signature& sig, const void *h, size_t size) const;

+ void signHash(Signature& sig, const std::string& h) const

+ {

+ signHash(sig, h.c_str(), h.size());

+ }

+ /*

+ make Pop(Proof of Possesion)

+ pop = prv.sign(pub)

+ */

+ void getPop(Signature& pop) const;

+ /*

+ make [s_0, ..., s_{k-1}] to prepare k-out-of-n secret sharing

+ */

+ void getMasterSecretKey(SecretKeyVec& msk, size_t k) const

+ {

+ if (k <= 1) throw std::invalid_argument("getMasterSecretKey");

+ msk.resize(k);

+ msk[0] = *this;

+ for (size_t i = 1; i < k; i++) {

+ msk[i].init();

+ }

+ }

+ /*

+ set a secret key for id > 0 from msk

+ */

+ void set(const SecretKeyVec& msk, const Id& id)

+ {

+ set(msk.data(), msk.size(), id);

+ }

+ /*

+ recover secretKey from k secVec

+ */

+ void recover(const SecretKeyVec& secVec, const IdVec& idVec)

+ {

+ if (secVec.size() != idVec.size()) throw std::invalid_argument("SecretKey:recover");

+ recover(secVec.data(), idVec.data(), idVec.size());

+ }

+ /*

+ add secret key

+ */

+ void add(const SecretKey& rhs);

+

+ // the following methods are for C api

+ /*

+ the size of msk must be k

+ */

+ void set(const SecretKey *msk, size_t k, const Id& id)

+ {

+ int ret = blsSecretKeyShare(&self_, &msk->self_, k, &id.self_);

+ if (ret != 0) throw std::runtime_error("blsSecretKeyShare");

+ }

+ void recover(const SecretKey *secVec, const Id *idVec, size_t n)

+ {

+ int ret = blsSecretKeyRecover(&self_, &secVec->self_, &idVec->self_, n);

+ if (ret != 0) throw std::runtime_error("blsSecretKeyRecover:same id");

+ }

+};

+

+/*

+ sQ ; public key

+*/

+class PublicKey {

+ blsPublicKey self_;

+ friend class SecretKey;

+ friend class Signature;

+public:

+ bool operator==(const PublicKey& rhs) const

+ {

+ return blsPublicKeyIsEqual(&self_, &rhs.self_) == 1;

+ }

+ bool operator!=(const PublicKey& rhs) const { return !(*this == rhs); }

+ friend std::ostream& operator<<(std::ostream& os, const PublicKey& pub)

+ {

+ std::string str;

+ pub.getStr(str, 16|IoPrefix);

+ return os << str;

+ }

+ friend std::istream& operator>>(std::istream& is, PublicKey& pub)

+ {

+ std::string str;

+ is >> str;

+ if (str != "0") {

+ // 1 <x.a> <x.b> <y.a> <y.b>

+ std::string t;

+#ifdef BLS_SWAP_G

+ const int elemNum = 2;

+#else

+ const int elemNum = 4;

+#endif

+ for (int i = 0; i < elemNum; i++) {

+ is >> t;

+ str += ' ';

+ str += t;

+ }

+ }

+ pub.setStr(str, 16);

+ return is;

+ }

+ void getStr(std::string& str, int ioMode = 0) const

+ {

+ str.resize(1024);

+#ifdef BLS_SWAP_G

+ size_t n = mclBnG1_getStr(&str[0], str.size(), &self_.v, ioMode);

+#else

+ size_t n = mclBnG2_getStr(&str[0], str.size(), &self_.v, ioMode);

+#endif

+ if (n == 0) throw std::runtime_error("PublicKey:getStr");

+ str.resize(n);

+ }

+ void setStr(const std::string& str, int ioMode = 0)

+ {

+#ifdef BLS_SWAP_G

+ int ret = mclBnG1_setStr(&self_.v, str.c_str(), str.size(), ioMode);

+#else

+ int ret = mclBnG2_setStr(&self_.v, str.c_str(), str.size(), ioMode);

+#endif

+ if (ret != 0) throw std::runtime_error("PublicKey:setStr");

+ }

+ /*

+ set public for id from mpk

+ */

+ void set(const PublicKeyVec& mpk, const Id& id)

+ {

+ set(mpk.data(), mpk.size(), id);

+ }

+ /*

+ recover publicKey from k pubVec

+ */

+ void recover(const PublicKeyVec& pubVec, const IdVec& idVec)

+ {

+ if (pubVec.size() != idVec.size()) throw std::invalid_argument("PublicKey:recover");

+ recover(pubVec.data(), idVec.data(), idVec.size());

+ }

+ /*

+ add public key

+ */

+ void add(const PublicKey& rhs)

+ {

+ blsPublicKeyAdd(&self_, &rhs.self_);

+ }

+

+ // the following methods are for C api

+ void set(const PublicKey *mpk, size_t k, const Id& id)

+ {

+ int ret = blsPublicKeyShare(&self_, &mpk->self_, k, &id.self_);

+ if (ret != 0) throw std::runtime_error("blsPublicKeyShare");

+ }

+ void recover(const PublicKey *pubVec, const Id *idVec, size_t n)

+ {

+ int ret = blsPublicKeyRecover(&self_, &pubVec->self_, &idVec->self_, n);

+ if (ret != 0) throw std::runtime_error("blsPublicKeyRecover");

+ }

+};

+

+/*

+ s H(m) ; signature

+*/

+class Signature {

+ blsSignature self_;

+ friend class SecretKey;

+public:

+ bool operator==(const Signature& rhs) const

+ {

+ return blsSignatureIsEqual(&self_, &rhs.self_) == 1;

+ }

+ bool operator!=(const Signature& rhs) const { return !(*this == rhs); }

+ friend std::ostream& operator<<(std::ostream& os, const Signature& sig)

+ {

+ std::string str;

+ sig.getStr(str, 16|IoPrefix);

+ return os << str;

+ }

+ friend std::istream& operator>>(std::istream& is, Signature& sig)

+ {

+ std::string str;

+ is >> str;

+ if (str != "0") {

+ // 1 <x> <y>

+ std::string t;

+#ifdef BLS_SWAP_G

+ const int elemNum = 4;

+#else

+ const int elemNum = 2;

+#endif

+ for (int i = 0; i < elemNum; i++) {

+ is >> t;

+ str += ' ';

+ str += t;

+ }

+ }

+ sig.setStr(str, 16);

+ return is;

+ }

+ void getStr(std::string& str, int ioMode = 0) const

+ {

+ str.resize(1024);

+#ifdef BLS_SWAP_G

+ size_t n = mclBnG2_getStr(&str[0], str.size(), &self_.v, ioMode);

+#else

+ size_t n = mclBnG1_getStr(&str[0], str.size(), &self_.v, ioMode);

+#endif

+ if (n == 0) throw std::runtime_error("Signature:tgetStr");

+ str.resize(n);

+ }

+ void setStr(const std::string& str, int ioMode = 0)

+ {

+#ifdef BLS_SWAP_G

+ int ret = mclBnG2_setStr(&self_.v, str.c_str(), str.size(), ioMode);

+#else

+ int ret = mclBnG1_setStr(&self_.v, str.c_str(), str.size(), ioMode);

+#endif

+ if (ret != 0) throw std::runtime_error("Signature:setStr");

+ }

+ bool verify(const PublicKey& pub, const void *m, size_t size) const

+ {

+ return blsVerify(&self_, &pub.self_, m, size) == 1;

+ }

+ bool verify(const PublicKey& pub, const std::string& m) const

+ {

+ return verify(pub, m.c_str(), m.size());

+ }

+ bool verifyHash(const PublicKey& pub, const void *h, size_t size) const

+ {

+ return blsVerifyHash(&self_, &pub.self_, h, size) == 1;

+ }

+ bool verifyHash(const PublicKey& pub, const std::string& h) const

+ {

+ return verifyHash(pub, h.c_str(), h.size());

+ }

+ bool verifyAggregatedHashes(const PublicKey *pubVec, const void *hVec, size_t sizeofHash, size_t n) const

+ {

+ return blsVerifyAggregatedHashes(&self_, &pubVec[0].self_, hVec, sizeofHash, n) == 1;

+ }

+ /*

+ verify self(pop) with pub

+ */

+ bool verify(const PublicKey& pub) const

+ {

+ std::string str;

+ pub.getStr(str);

+ return verify(pub, str);

+ }

+ /*

+ recover sig from k sigVec

+ */

+ void recover(const SignatureVec& sigVec, const IdVec& idVec)

+ {

+ if (sigVec.size() != idVec.size()) throw std::invalid_argument("Signature:recover");

+ recover(sigVec.data(), idVec.data(), idVec.size());

+ }

+ /*

+ add signature

+ */

+ void add(const Signature& rhs)

+ {

+ blsSignatureAdd(&self_, &rhs.self_);

+ }

+

+ // the following methods are for C api

+ void recover(const Signature* sigVec, const Id *idVec, size_t n)

+ {

+ int ret = blsSignatureRecover(&self_, &sigVec->self_, &idVec->self_, n);

+ if (ret != 0) throw std::runtime_error("blsSignatureRecover:same id");

+ }

+};

+

+/*

+ make master public key [s_0 Q, ..., s_{k-1} Q] from msk

+*/

+inline void getMasterPublicKey(PublicKeyVec& mpk, const SecretKeyVec& msk)

+{

+ const size_t n = msk.size();

+ mpk.resize(n);

+ for (size_t i = 0; i < n; i++) {

+ msk[i].getPublicKey(mpk[i]);

+ }

+}

+

+inline void SecretKey::getPublicKey(PublicKey& pub) const

+{

+ blsGetPublicKey(&pub.self_, &self_);

+}

+inline void SecretKey::sign(Signature& sig, const void *m, size_t size) const

+{

+ blsSign(&sig.self_, &self_, m, size);

+}

+inline void SecretKey::signHash(Signature& sig, const void *h, size_t size) const

+{

+ if (blsSignHash(&sig.self_, &self_, h, size) != 0) throw std::runtime_error("bad h");

+}

+inline void SecretKey::getPop(Signature& pop) const

+{

+ PublicKey pub;

+ getPublicKey(pub);

+ std::string m;

+ pub.getStr(m);

+ sign(pop, m);

+}

+

+/*

+ make pop from msk and mpk

+*/

+inline void getPopVec(SignatureVec& popVec, const SecretKeyVec& msk)

+{

+ const size_t n = msk.size();

+ popVec.resize(n);

+ for (size_t i = 0; i < n; i++) {

+ msk[i].getPop(popVec[i]);

+ }

+}

+

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

+

+} //bls

+@echo off

+if "%1"=="-s" (

+ echo use static lib

+ set CFLAGS=%CFLAGS% /DMCLBN_NO_AUTOLINK /DBLS_DONT_EXPORT

+) else if "%1"=="-d" (

+ echo use dynamic lib

+) else (

+ echo "mk (-s|-d) <source file>"

+ goto exit

+)

+set CFLAGS=%CFLAGS% -I../mcl/include

+set SRC=%2

+set EXE=%SRC:.cpp=.exe%

+set EXE=%EXE:.c=.exe%

+set EXE=%EXE:test\=bin\%

+set EXE=%EXE:sample\=bin\%

+echo cl %CFLAGS% %2 /Fe:%EXE% /link %LDFLAGS%

+cl %CFLAGS% %2 /Fe:%EXE% /link %LDFLAGS%

+

+:exit

+rem @echo off

+

+call setvar.bat dll

+echo make bls384.dll

+cl /c %CFLAGS% /DBLS_NO_AUTOLINK /Foobj/bls_c.obj src/bls_c.cpp

+cl /c %CFLAGS% /DBLS_NO_AUTOLINK /Foobj/fp.obj ../mcl/src/fp.cpp

+lib /OUT:lib/bls384.lib /nodefaultlib obj/bls_c.obj obj/fp.obj %LDFLAGS%

+cl /LD /MT obj/bls_c.obj obj/fp.obj %CFLAGS% /link /out:bin/bls384.dll %LDFLAGS%

+@echo off

+call ..\mcl\setvar.bat

+if "%1"=="dll" (

+ echo make dynamic library DLL

+) else (

+ echo make static library LIB

+)

+call setvar.bat

+

+if "%1"=="dll" (

+ cl /c %CFLAGS% /Foobj/bls_c256.obj src/bls_c256.cpp /DBLS_NO_AUTOLINK

+ cl /c %CFLAGS% /Foobj/bls_c384.obj src/bls_c384.cpp /DBLS_NO_AUTOLINK

+ cl /c %CFLAGS% /Foobj/bls_c384_256.obj src/bls_c384_256.cpp /DBLS_NO_AUTOLINK

+ cl /c %CFLAGS% /Foobj/fp.obj ../mcl/src/fp.cpp

+ link /nologo /DLL /OUT:bin\bls256.dll obj\bls_c256.obj obj\fp.obj %LDFLAGS% /implib:lib\bls256.lib

+ link /nologo /DLL /OUT:bin\bls384.dll obj\bls_c384.obj obj\fp.obj %LDFLAGS% /implib:lib\bls384.lib

+ link /nologo /DLL /OUT:bin\bls384_256.dll obj\bls_c384_256.obj obj\fp.obj %LDFLAGS% /implib:lib\bls384_256.lib

+) else (

+ cl /c %CFLAGS% /Foobj/bls_c256.obj src/bls_c256.cpp

+ cl /c %CFLAGS% /Foobj/bls_c384.obj src/bls_c384.cpp

+ cl /c %CFLAGS% /Foobj/bls_c384_256.obj src/bls_c384_256.cpp

+ cl /c %CFLAGS% /Foobj/fp.obj ../mcl/src/fp.cpp /DMCLBN_DONT_EXPORT

+ lib /OUT:lib/bls256.lib /nodefaultlib obj/bls_c256.obj obj/fp.obj %LDFLAGS%

+ lib /OUT:lib/bls384.lib /nodefaultlib obj/bls_c384.obj obj/fp.obj %LDFLAGS%

+ lib /OUT:lib/bls384_256.lib /nodefaultlib obj/bls_c384_256.obj obj/fp.obj %LDFLAGS%

+)

+[](https://travis-ci.com/dexon-foundation/bls)

+

+# BLS threshold signature

+

+An implementation of BLS threshold signature

+

+# Installation Requirements

+

+Create a working directory (e.g., work) and clone the following repositories.

+```

+mkdir work

+cd work

+git clone git://github.com/dexon-foundation/mcl.git

+git clone git://github.com/dexon-foundation/bls.git

+git clone git://github.com/herumi/cybozulib_ext ; for only Windows

+```

+

+# News

+* (Break backward compatibility) The suffix `_dy` of library name is removed and bls\*.a requires libmcl.so set LD_LIBRARY_PATH to the directory.

+* -tags option for Go bindings

+ * -tags bn256

+ * -tags bn384\_256

+ * -tags bn384 ; default mode

+* Support swap of G1 and G2

+ * `make BLS_SWAP_G=1` then G1 is assigned to PublicKey and G2 is assigned to Signature.

+ * golang binding does not support this feature yet.

+* Build option without GMP

+ * `make MCL_USE_GMP=0`

+* Build option without OpenSSL

+ * `make MCL_USE_OPENSSL=0`

+* Build option to specify `mcl` directory

+ * `make MCL_DIR=<mcl directory>`

+

+* (old) libbls.a for C++ interface(bls/bls.hpp) is removed

+Link `lib/libbls256.a` or `lib/libbls384.a` to use `bls/bls.hpp` according to MCLBN_FP_UNIT_SIZE = 4 or 6.

+

+# Build and test for Linux

+To make and test, run

+```

+cd bls

+make test

+```

+To make sample programs, run

+```

+make sample_test

+```

+

+# Build and test for Windows

+1) make static library and use it

+```

+mklib

+mk -s test\bls_c384_test.cpp

+bin\bls_c384_test.exe

+```

+

+2) make dynamic library and use it

+```

+mklib dll

+mk -d test\bls_c384_test.cpp

+bin\bls_c384_test.exe

+```

+

+# Library

+* libbls256.a/libbls256.so ; for BN254 compiled with MCLBN_FP_UNIT_SIZE=4

+* libbls384.a/libbls384.so ; for BN254/BN381_1/BLS12_381 compiled with MCLBN_FP_UNIT_SIZE=6

+* libbls384_256.a/libbls384_256.so ; for BN254/BLS12_381 compiled with MCLBN_FP_UNIT_SIZE=6 and MCLBN_FR_UNIT_SIZE=4

+

+See `mcl/include/curve_type.h` for curve parameter

+

+# API

+

+## Basic API

+

+BLS signature

+```

+e : G2 x G1 -> Fp12 ; optimal ate pairing over BN curve

+Q in G2 ; fixed global parameter

+H : {str} -> G1

+s in Fr: secret key