DotNetSignatre

gistfile1.txt

using System;
using System.Collections;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Asn1.CryptoPro;
using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.Sec;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Asn1.X9;
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.Collections;
using Org.BouncyCastle.Utilities.Encoders;
using Org.BouncyCastle.X509;
using RestSharp;
using Hex = Org.BouncyCastle.Utilities.Encoders.Hex;

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();
            var privateKey = keyPair.Private;

            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);

            SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(tmpPub);
            var bts1 = publicKeyInfo.GetDerEncoded();
            var publicKey1 = PublicKeyFactory.CreateKey(bts1);
            SubjectPublicKeyInfo publicKeyInfo1 = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey1);
            var bts = publicKeyInfo1.PublicKeyData.GetBytes();
            var hash = HashAlgorithm.Create(ALG_KEY_ID_NAME);
            var ee = hash.ComputeHash(bts);
            var keyId = BitArrayToString(ee).ToLowerInvariant();

            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);
            request.AddHeader("X-Request-Id", "sdsdsfsdfsf");
            request.Resource = url;
            var response = client.Execute(request);

            Console.WriteLine(BitArrayToString(ee));

            ///** Получить 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);

            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);
        }
    }
}