C# binding for BLS12_381

5 files changed, 594 insertions, 0 deletions

diff --git a/ffi/cs/bls.cs b/ffi/cs/bls.cs
new file mode 100644
index 0000000..417550a
--- /dev/null
+++ b/ffi/cs/bls.cs
@@ -0,0 +1,305 @@
+����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 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]StringBuilder buf, ulong maxBufSize, in Id id);
+        [DllImport(dllName)] public static extern ulong blsSecretKeySerialize([Out]StringBuilder buf, ulong maxBufSize, in SecretKey sec);
+		[DllImport(dllName)] public static extern ulong blsPublicKeySerialize([Out]StringBuilder buf, ulong maxBufSize, in PublicKey pub);
+		[DllImport(dllName)] public static extern ulong blsSignatureSerialize([Out]StringBuilder buf, ulong maxBufSize, in Signature sig);
+        [DllImport(dllName)] public static extern int blsIdDeserialize(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+        [DllImport(dllName)] public static extern int blsSecretKeyDeserialize(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+		[DllImport(dllName)] public static extern int blsPublicKeyDeserialize(ref PublicKey pub, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+		[DllImport(dllName)] public static extern int blsSignatureDeserialize(ref Signature sig, [In][MarshalAs(UnmanagedType.LPStr)] string 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][MarshalAs(UnmanagedType.LPStr)] string 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]StringBuilder 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 bool IsEqual(in Id rhs)
+			{
+                return blsIdIsEqual(this, rhs) != 0;
+            }
+			public void SetDecStr(in String s)
+			{
+				if (blsIdSetDecStr(ref this, s, (ulong)s.Length) != 0) {
+					throw new ArgumentException("blsIdSetDecSt:" + s);
+				}
+			}
+			public void SetHexStr(in 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 bool IsEqual(in SecretKey rhs)
+			{
+				return blsSecretKeyIsEqual(this, rhs) != 0;
+			}
+			public void SetHexStr(in 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(in 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, this);
+				return pub;
+			}
+			public Signature Signature(String m)
+			{
+				Signature Signature = new Signature();
+				blsSign(ref Signature, this, m, (ulong)m.Length);
+				return Signature;
+			}
+        }
+		// secretKey = sum_{i=0}^{msk.Length - 1} msk[i] * id^i
+		public static SecretKey ShareSecretKey(in SecretKey[] msk, in Id id)
+		{
+			SecretKey sec = new SecretKey();
+			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[] secs, in Id[] ids)
+		{
+			SecretKey sec = new SecretKey();
+			if (blsSecretKeyRecover(ref sec, secs[0], ids[0], (ulong)secs.Length) != 0) {
+				throw new ArgumentException("Recover");
+			}
+			return sec;
+		}
+        [StructLayout(LayoutKind.Sequential)]
+        public unsafe struct PublicKey {
+            private fixed ulong v[PUBLICKEY_UNIT_SIZE];
+            public bool IsEqual(in PublicKey rhs)
+			{
+				return blsPublicKeyIsEqual(this, rhs) != 0;
+			}
+			public void SetStr(in 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, in string m)
+			{
+				return blsVerify(sig, this, m, (ulong)m.Length) == 1;
+			}
+		}
+		// publicKey = sum_{i=0}^{mpk.Length - 1} mpk[i] * id^i
+		public static PublicKey SharePublicKey(in PublicKey[] mpk, in Id id)
+		{
+			PublicKey pub = new PublicKey();
+			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[] pubs, in Id[] ids)
+		{
+			PublicKey pub = new PublicKey();
+			if (blsPublicKeyRecover(ref pub, pubs[0], ids[0], (ulong)pubs.Length) != 0) {
+				throw new ArgumentException("Recover");
+			}
+			return pub;
+		}
+        [StructLayout(LayoutKind.Sequential)]
+        public unsafe struct Signature {
+            private fixed ulong v[SIGNATURE_UNIT_SIZE];
+            public bool IsEqual(in Signature rhs)
+			{
+				return blsSignatureIsEqual(this, rhs) != 0;
+			}
+			public void SetStr(in 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[] signs, in Id[] ids)
+		{
+			Signature Signature = new Signature();
+			if (blsSignatureRecover(ref Signature, signs[0], ids[0], (ulong)signs.Length) != 0) {
+				throw new ArgumentException("Recover");
+			}
+			return Signature;
+		}
+    }
+}
diff --git a/ffi/cs/bls.csproj b/ffi/cs/bls.csproj
new file mode 100644
index 0000000..f2cbee1
--- /dev/null
+++ b/ffi/cs/bls.csproj
@@ -0,0 +1,96 @@
+<?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.0</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>

+  </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
diff --git a/ffi/cs/bls.sln b/ffi/cs/bls.sln
new file mode 100644
index 0000000..786a341
--- /dev/null
+++ b/ffi/cs/bls.sln
@@ -0,0 +1,25 @@
+

+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

diff --git a/ffi/cs/bls_test.cs b/ffi/cs/bls_test.cs
new file mode 100644
index 0000000..f443c7e
--- /dev/null
+++ b/ffi/cs/bls_test.cs
@@ -0,0 +1,137 @@
+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 = new Id();
+			id1.SetDecStr("255");
+			assert("GetStr(10)", id1.GetDecStr() == "255");
+			assert("GetStr(16)", id1.GetHexStr() == "ff");
+            Id id2 = new Id();
+            id2.SetInt(255);
+            assert("IsEqual", id1.IsEqual(id2));
+		}
+        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);
+            Console.WriteLine("sig={0}", sig.GetHexStr());
+			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 {
+                int[] curveTypeTbl = { BN254, BLS12_381 };
+                foreach (int curveType in curveTypeTbl) {
+                    Console.WriteLine("curveType={0}", curveType);
+                    Init(curveType);
+                    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);
+			}
+		}
+	}
+}
diff --git a/ffi/cs/readme.md b/ffi/cs/readme.md
new file mode 100644
index 0000000..70e87c1
--- /dev/null
+++ b/ffi/cs/readme.md
@@ -0,0 +1,31 @@
+# BLS threshold signature for C#
+
+# 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
+```
+
+# Remark
+bls256 is obsolete. Please use bls.sln.
+
+# License
+
+modified new BSD License
+http://opensource.org/licenses/BSD-3-Clause
+
+# Author
+
+MITSUNARI Shigeo(herumi@nifty.com)