Bitcoin Forum

public static class ECDSA
{

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_start", CallingConvention = CallingConvention.Cdecl)]
        private static extern void StartCrypto();

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_stop", CallingConvention = CallingConvention.Cdecl)]
        private static extern void StopCrypto();

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_verify", CallingConvention = CallingConvention.Cdecl)]
        public static extern int VerifySignature(byte[] msg, int msglen, byte[] sig, int siglen, byte[] pubkey, int pubkeylen);

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_sign", CallingConvention = CallingConvention.Cdecl)]
        public static extern int SignMessage(byte[] msg, int msglen, byte[] sig, ref int siglen, byte[] seckey, ref int nonce);

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_sign_compact", CallingConvention = CallingConvention.Cdecl)]
        public static extern int SignCompact(byte[] msg, int msglen, byte[] sig64, byte[] seckey, ref int nonce, ref int recid);

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_recover_compact", CallingConvention = CallingConvention.Cdecl)]
        public static extern int RecoverCompact(byte[] msg, int msglen, byte[] sig64, byte[] pubkey, ref int pubkeylen, int compressed, int recid);

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_seckey_verify", CallingConvention = CallingConvention.Cdecl)]
        public static extern int VerifySecretKey(byte[] seckey);

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_pubkey_verify", CallingConvention = CallingConvention.Cdecl)]
        public static extern int VerifyPublicKey(byte[] pubkey, int pubkeylen);

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_pubkey_create", CallingConvention = CallingConvention.Cdecl)]
        public static extern int PublicKeyFromSecretKey(byte[] pubkey, ref int pubkeylen, byte[] seckey, int compressed);

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_pubkey_decompress", CallingConvention = CallingConvention.Cdecl)]
        public static extern int DecompressPublicKey(byte[] pubkey, ref int pubkeylen);

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_pubkey_compress", CallingConvention = CallingConvention.Cdecl)]
        public static extern int CompressPublicKey(byte[] pubkey, ref int pubkeylen);

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_privkey_export", CallingConvention = CallingConvention.Cdecl)]
        public static extern int ExportPrivateKey(byte[] seckey, byte[] privkey, ref int privkeylen, int compressed);

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_privkey_import", CallingConvention = CallingConvention.Cdecl)]
        public static extern int ImportPrivateKey(byte[] seckey, byte[] privkey, int privkeylen);

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_privkey_tweak_add", CallingConvention = CallingConvention.Cdecl)]
        public static extern int PrivateKeyTweakAdd(byte[] seckey, byte[] tweak);

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_pubkey_tweak_add", CallingConvention = CallingConvention.Cdecl)]
        public static extern int PublicKeyTweakAdd(byte[] pubkey, int pubkeylen, byte[] tweak);

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_privkey_tweak_mul", CallingConvention = CallingConvention.Cdecl)]
        public static extern int PrivateKeyTweakMul(byte[] seckey, byte[] tweak);

        [DllImport("secp256k1.dll", EntryPoint = "secp256k1_ecdsa_pubkey_tweak_mul", CallingConvention = CallingConvention.Cdecl)]
        public static extern int PublicKeyTweakMul(byte[] pubkey, int pubkeylen, byte[] tweak);

}

/// <summary>Signs a message and returns the signature.  Returns null on failure.</summary>
/// <param name="message">The message to sign.  This data is not hashed.  For use with bitcoins, you probably want to double-SHA256 hash this before calling this method.</param>
/// <param name="privateKey">The private key to use to sign the message.</param>
public unsafe static byte[] Sign(byte[] message, byte[] privateKey)
{
	if (message == null || privateKey == null)
	{
		throw new ArgumentNullException();
	}
	if (privateKey.Length != 32)
	{
		throw new ArgumentOutOfRangeException(Signatures.PrivateKeyLengthError);
	}
	if (message.Length != 32)
	{
		throw new ArgumentOutOfRangeException(Signatures.MessageLengthError);
	}
	int messageptr_3D_cp_1 = 0;
	int keyptr_46_cp_1 = 0;
	byte[] nonce = new byte[32];
	byte[] nonceptr_59_cp_0 = nonce;
	int nonceptr_59_cp_1 = 0;
	byte[] signature = new byte[72];
	byte[] signatureptr_6A_cp_0 = signature;
	int signatureptr_6A_cp_1 = 0;
	int signaturelen = signature.Length;
	byte[] privateKey2;
	for (int x = 0; x < 1000; x++)
	{
		Signatures.Randoms.Value.GetBytes(nonce);
		int result = <Module>.secp256k1_ecdsa_sign((byte*)(&message[messageptr_3D_cp_1]), message.Length, ref signatureptr_6A_cp_0[signatureptr_6A_cp_1], &signaturelen, (byte*)(&privateKey[keyptr_46_cp_1]), ref nonceptr_59_cp_0[nonceptr_59_cp_1]);
		if (result == 1)
		{
			if (signaturelen == signature.Length)
			{
				privateKey2 = signature;
			}
			else
			{
				byte[] smallsignature = new byte[signaturelen];
				Array.Copy(signature, 0, smallsignature, 0, signaturelen);
				privateKey2 = smallsignature;
			}
			return privateKey2;
		}
	}
	privateKey2 = null;
	return privateKey2;
}

/// <summary>Verifies that a signature is valid.</summary>
/// <param name="message">The message to verify.  This data is not hashed.  For use with bitcoins, you probably want to double-SHA256 hash this before calling this method.</param>
/// <param name="signature">The signature to test for validity. This must not be a compact key (Use RecoverKeyFromCompact instead).</param>
/// <param name="publicKey">The public key used to create the signature.</param>
public unsafe static Signatures.VerifyResult Verify(byte[] message, byte[] signature, byte[] publicKey)
{
	if (message == null || signature == null || publicKey == null)
	{
		throw new ArgumentNullException();
	}
	if (message.Length != 32)
	{
		throw new ArgumentOutOfRangeException(Signatures.MessageLengthError);
	}
	int messageptr_27_cp_1 = 0;
	int signatureptr_30_cp_1 = 0;
	int keyptr_39_cp_1 = 0;
	int result = <Module>.secp256k1_ecdsa_verify((byte*)(&message[messageptr_27_cp_1]), message.Length, (byte*)(&signature[signatureptr_30_cp_1]), signature.Length, (byte*)(&publicKey[keyptr_39_cp_1]), publicKey.Length);
	int signature2 = result;
	Signatures.VerifyResult message2;
	if (signature2 != -2)
	{
		if (signature2 != -1)
		{
			if (signature2 != 0)
			{
				if (signature2 != 1)
				{
					message2 = Signatures.VerifyResult.Error;
				}
				else
				{
					message2 = Signatures.VerifyResult.Verified;
				}
			}
			else
			{
				message2 = Signatures.VerifyResult.SignatureFailed;
			}
		}
		else
		{
			message2 = Signatures.VerifyResult.InvalidPublicKey;
		}
	}
	else
	{
		message2 = Signatures.VerifyResult.InvalidSignature;
	}
	return message2;
}