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)