Signature

using System;
using System.Collections;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.Sec;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Digests;
using Org.BouncyCastle.Crypto.Operators;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Math;
using Org.BouncyCastle.OpenSsl;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.Utilities.Encoders;
using Org.BouncyCastle.X509;
using RestSharp;

namespace MonoTest
{
    class Program
    {
        //private static string PROVIDER_NAME   = BouncyCastleProvider.PROVIDER_NAME;
        private static string EC_PARAMS_NAME = "secp256k1";
        private static string SIGNATURE_NAME = "SHA-256withECDSA";
        private static string ALG_KEY_NAME = "ECDSA";
        private static string ALG_KEY_ID_NAME = "SHA1";
        static void Main(string[] args)
        {
            String privateKeyEncoded =
                "asd";

            var privKeySolo = "asd";
            String url = "/personal/auth/request";
            String permissions = "ps";
            String time = DateTimeOffset.Now.ToUnixTimeSeconds().ToString();
            String message = time + permissions + url;

            var pemReader = new PemReader(new StringReader(privateKeyEncoded));
            var oid = pemReader.ReadPemObject();
            var keyPair = (AsymmetricCipherKeyPair)pemReader.ReadObject();
            //keyPair.Content
            
            //var privateKey = keyPair.Private;


            //byte[] pkcs8EncodedBytes = Base64.Decode(privKeySolo);
            //var privateKey = PrivateKeyFactory.CreateKey(pkcs8EncodedBytes);

            //var privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(keyPair.Private);
            //var obj = privateKeyInfo.ParsePrivateKey();

            //var ttt=new Pkcs8EncryptedPrivateKeyInfo(privateKeyInfo)
            //var info=ttt.Build(new Asn1CipherBuilderWithKey(privateKeyInfo.PrivateKeyAlgorithm.Algorithm, 256, new SecureRandom()));
            //var pkcs = new Pkcs8EncryptedPrivateKeyInfo(keyPair.Content);
            //var privateKey = PrivateKeyFactory.CreateKey(privateKeyInfo.GetEncoded());
            //var privateKey11 = PrivateKeyFactory.CreateKey(pkcs12.GetEncryptedData());

            //var bts122 = privateKeyInfo.GetEncoded();
            //var pkcs1 = new Pkcs8EncryptedPrivateKeyInfo(bts122);
            //var privateKey1 = PrivateKeyFactory.CreateKey(pkcs1.GetEncryptedData());

            var privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(keyPair.Private);
            var bts123 = privateKeyInfo.GetDerEncoded();
            var privateKey = PrivateKeyFactory.CreateKey(bts123);

            //var btsA = privateKeyInfo.GetDerEncoded();
            //var privateKeyA = PrivateKeyFactory.CreateKey(btsA);
            //PrivateKeyInfo privateKeyInfoA = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyA);
            //var privateKeyA1 = PrivateKeyFactory.CreateKey(privateKeyInfoA.GetDerEncoded());


            byte[] msgBytes, signature, sign;
            string signAsBase64 = GetSignature(message, privateKey, out msgBytes, out signature, out sign);
            var tmPubStr =
                "asd";
            var tmpPub = PublicKeyFactory.CreateKey(Convert.FromBase64String(tmPubStr));
            ISigner signerV = SignerUtilities.GetSigner(SIGNATURE_NAME);

            signerV.Init(false, tmpPub);
            signerV.BlockUpdate(msgBytes, 0, msgBytes.Length);

            var valid = signerV.VerifySignature(signature);
            var valid1 = signerV.VerifySignature(sign);

            var keyId = "asd";

            var client = new RestClient("https://api.monobank.ua/");

            var request = new RestRequest(Method.GET);
            request.AddHeader("X-Key-Id", keyId);
            request.AddHeader("X-Permissions", permissions);
            request.AddHeader("X-Time", time);
            request.AddHeader("X-Sign", signAsBase64.ToLowerInvariant());
            request.AddHeader("X-Request-Id", "sdsdsfsdfsf");
            request.Resource = url;
            var response = client.Execute(request);
            
            SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(tmpPub);

            SubjectPublicKeyInfo publicKeyInfo2 = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(tmpPub);
            var publicKey2 = PublicKeyFactory.CreateKey(publicKeyInfo2.GetEncoded());
            SubjectPublicKeyInfo publicKeyInfo21 = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey2);

            var bts1 = publicKeyInfo.GetDerEncoded();
            var publicKey1 = PublicKeyFactory.CreateKey(bts1);
            SubjectPublicKeyInfo publicKeyInfo1 = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey1);
            var bts = publicKeyInfo1.PublicKeyData.GetBytes();

            var publicKey11 = PublicKeyFactory.CreateKey(bts1);
            var publicKeyInfo12 = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey11);


            var hash = HashAlgorithm.Create(ALG_KEY_ID_NAME);
            var hashIdPKInfo = hash.ComputeHash(publicKeyInfo.GetEncoded());
            var hashIdPKInfo1 = hash.ComputeHash(publicKeyInfo1.GetEncoded());

            var hashIdPKInfoDer = hash.ComputeHash(publicKeyInfo.GetDerEncoded());
            var hashIdPKInfo1Der = hash.ComputeHash(publicKeyInfo1.GetDerEncoded());

            var hashIdPK = hash.ComputeHash(publicKeyInfo2.GetEncoded());
            var hashIdPK1 = hash.ComputeHash(publicKeyInfo12.GetEncoded());

            var hashIdPKDer = hash.ComputeHash(publicKeyInfo2.GetDerEncoded());
            var hashIdPK1Der = hash.ComputeHash(publicKeyInfo12.GetDerEncoded());

            var ee = hash.ComputeHash(bts);
            var ee1 = hash.ComputeHash(bts1);
            var ee2 = hash.ComputeHash(publicKeyInfo.PublicKeyData.GetBytes());

            Console.WriteLine(BitArrayToString(hashIdPKInfo));
            Console.WriteLine(BitArrayToString(hashIdPKInfo1));
            Console.WriteLine(BitArrayToString(hashIdPKInfoDer));
            Console.WriteLine(BitArrayToString(hashIdPKInfo1Der));
            Console.WriteLine(BitArrayToString(hashIdPK));
            Console.WriteLine(BitArrayToString(hashIdPK1));
            Console.WriteLine(BitArrayToString(hashIdPKDer));
            Console.WriteLine(BitArrayToString(hashIdPK1Der));
            Console.WriteLine(BitArrayToString(ee));
            Console.WriteLine(BitArrayToString(ee1));
            Console.WriteLine(BitArrayToString(ee2));

            
            ///** Получить Public Key */
            String spki = Base64.ToBase64String(publicKeyInfo.GetEncoded());
            Console.WriteLine(spki);
            Console.WriteLine(tmPubStr);
        }

        private static string GetSignature(string message, AsymmetricKeyParameter privateKey, out byte[] msgBytes, out byte[] signature, out byte[] sign)
        {
            ISigner signer = SignerUtilities.GetSigner(SIGNATURE_NAME);

            signer.Init(true, privateKey);
            msgBytes = Encoding.UTF8.GetBytes(message);
            var ttttt = Encoding.Unicode.GetBytes(message);
            var msgBytes2 = Encoding.ASCII.GetBytes(message);
            signer.BlockUpdate(msgBytes, 0, msgBytes.Length);

            signature = signer.GenerateSignature();
            int EC_POINT_LEN = 32;
            Asn1Sequence sequence = Asn1Sequence.GetInstance(Asn1Object.FromByteArray(signature));
            IEnumerator objects = sequence.GetEnumerator();
            objects.MoveNext();
            byte[] r = ((DerInteger)objects.Current).Value.ToByteArray();
            objects.MoveNext();
            byte[] s = ((DerInteger)objects.Current).Value.ToByteArray();

            sign = new byte[EC_POINT_LEN * 2];
            int offSet = r.Length - EC_POINT_LEN;
            if (offSet < 0)
            {
                Array.Copy(r, 0, sign, -offSet, r.Length);
            }
            else
            {
                Array.Copy(r, offSet, sign, 0, EC_POINT_LEN);
            }

            offSet = s.Length - EC_POINT_LEN;
            if (offSet < 0)
            {
                Array.Copy(s, 0, sign, EC_POINT_LEN - offSet, s.Length);
            }
            else
            {
                Array.Copy(s, offSet, sign, EC_POINT_LEN, EC_POINT_LEN);
            }

            return Convert.ToBase64String(sign);
        }

        public static string BitArrayToString(byte[] ba)
        {
            return BitConverter.ToString(ba).Replace("-", string.Empty);
        }
    }
}