Example #1
0
        public void HashTestFromWiki()
        {
            //GOST("") = 981E5F3CA30C841487830F84FB433E13AC1101569B9C13584AC483234CD656C0
            byte[] data = Encoding.UTF8.GetBytes("");
            byte[] hash = Gost2001KeyContainer.ComputeHash(data);

            var hexString = HexEncoding.ToString(hash);

            Assert.AreEqual("981E5F3CA30C841487830F84FB433E13AC1101569B9C13584AC483234CD656C0", hexString);


            //GOST("a") = E74C52DD282183BF37AF0079C9F78055715A103F17E3133CEFF1AACF2F403011
            data = Encoding.UTF8.GetBytes("a");
            hash = Gost2001KeyContainer.ComputeHash(data);

            hexString = HexEncoding.ToString(hash);
            Assert.AreEqual("E74C52DD282183BF37AF0079C9F78055715A103F17E3133CEFF1AACF2F403011", hexString);


            //GOST("abc") = B285056DBF18D7392D7677369524DD14747459ED8143997E163B2986F92FD42C
            data = Encoding.UTF8.GetBytes("abc");
            hash = Gost2001KeyContainer.ComputeHash(data);

            hexString = HexEncoding.ToString(hash);
            Assert.AreEqual("B285056DBF18D7392D7677369524DD14747459ED8143997E163B2986F92FD42C", hexString);


            //GOST("message digest") = BC6041DD2AA401EBFA6E9886734174FEBDB4729AA972D60F549AC39B29721BA0
            data = Encoding.UTF8.GetBytes("message digest");
            hash = Gost2001KeyContainer.ComputeHash(data);

            hexString = HexEncoding.ToString(hash);
            Assert.AreEqual("BC6041DD2AA401EBFA6E9886734174FEBDB4729AA972D60F549AC39B29721BA0", hexString);
        }
Example #2
0
 public void ExportPublicKey()
 {
     using (GostCryptFacade keyContainer = Gost2001KeyContainer.Open(Container, ContainerPassword))
     {
         byte[] key = keyContainer.ExportPublicKey();
         CollectionAssert.IsNotEmpty(key);
     }
 }
Example #3
0
 /// <summary>
 ///     Проверка подписи.
 /// </summary>
 /// <param name="request">Данные.</param>
 /// <returns>True - провека прошла успешно, иначе False.</returns>
 public bool VerifySignature(VerifySignatureRequest request)
 {
     log.Debug("VerifySignature: {0}", request);
     byte[] signatureValue = Convert.FromBase64String(request.Signature);
     byte[] dataValue      = Encoding.UTF8.GetBytes(request.Data);
     byte[] publicKeyValue = Convert.FromBase64String(request.PublicKey);
     return(Gost2001KeyContainer.VerifySignature(signatureValue, dataValue, publicKeyValue));
 }
Example #4
0
        /// <summary>
        ///     Проверка подписи.
        /// </summary>
        /// <param name="request">Данные.</param>
        /// <returns>True - провека прошла успешно, иначе False.</returns>
        public bool VerifyCertificate(VerifySignatureCertRequest request)
        {
            log.Debug("VerifySignatureSert: {0}", request);
            byte[] signatureValue   = Convert.FromBase64String(request.Signature);
            byte[] dataValue        = Encoding.UTF8.GetBytes(request.Data);
            byte[] certificateValue = Convert.FromBase64String(request.Certificate);

            return(Gost2001KeyContainer.VerifyCertificate(signatureValue, dataValue, certificateValue));
        }
Example #5
0
        public void ComputeHash()
        {
            byte[] data = GetRandomData();

            byte[] hash = Gost2001KeyContainer.ComputeHash(data);

            const int HashLength = 32;

            Assert.AreEqual(HashLength, hash.Length);
        }
Example #6
0
 /// <summary>
 ///     Подсчет хэша.
 /// </summary>
 /// <param name="data">Данные.</param>
 /// <returns>Хэш.</returns>
 public string ComputeHash(string data)
 {
     log.Debug("ComputeHash: data: {0}", data);
     if (data == null)
     {
         throw new WebFaultException(HttpStatusCode.BadRequest);
     }
     byte[] dataValue = Encoding.UTF8.GetBytes(data);
     return(Convert.ToBase64String(Gost2001KeyContainer.ComputeHash(dataValue)));
 }
Example #7
0
        public void GetCertificatePublicKey()
        {
            using (GostCryptFacade keyContainer = Gost2001KeyContainer.Open(ContainerSert, ContainerPassword))
            {
                var certificateRawData = keyContainer.ExportCertificateData();
                var publicKeyFromCert  = Gost2001KeyContainer.GetCertificatePublicKey(certificateRawData);

                var containerKey = keyContainer.ExportPublicKey();

                Assert.AreEqual(containerKey, publicKeyFromCert);
            }
        }
Example #8
0
        /// <summary>
        ///     Подпись хэша.
        /// </summary>
        /// <param name="hash">Хэш.</param>
        /// <returns>Подпись хэша.</returns>
        public string SignHash(string hash)
        {
            if (string.IsNullOrWhiteSpace(hash))
            {
                throw new WebFaultException(HttpStatusCode.BadRequest);
            }

            log.Debug("SignHash: hash: {0}, keyNumber: {1}", hash, KeyNumber.Signature);
            byte[] hashValue = Convert.FromBase64String(hash);
            using (GostCryptFacade keyContainer = Gost2001KeyContainer.Open(Container, ContainerPassword))
            {
                byte[] signature = keyContainer.SignHash(hashValue, KeyNumber.Signature);
                return(Convert.ToBase64String(signature));
            }
        }
Example #9
0
        public void SignHash()
        {
            byte[] data = GetRandomData();

            byte[] signature;
            byte[] hash = Gost2001KeyContainer.ComputeHash(data);

            using (GostCryptFacade keyContainer = Gost2001KeyContainer.Open(Container, ContainerPassword))
            {
                signature = keyContainer.SignHash(hash, KeyNumber.Signature);
            }

            byte[] publicKey = Gost2001KeyContainer.ExportPublicKey(Container);
            bool   result    = Gost2001KeyContainer.VerifySignature(signature, data, publicKey);

            Assert.IsTrue(result);
        }
Example #10
0
        public void SignCertigicateSignature()
        {
            byte[] data = GetRandomData();

            byte[] signature, certificateRawData;
            byte[] hash = Gost2001KeyContainer.ComputeHash(data);


            using (GostCryptFacade keyContainer = Gost2001KeyContainer.Open(ContainerSert, ContainerPassword))
            {
                signature          = keyContainer.SignHash(hash, KeyNumber.Signature);
                certificateRawData = keyContainer.ExportCertificateData();
            }

            bool result = Gost2001KeyContainer.VerifyCertificate(signature, data, certificateRawData);

            Assert.IsTrue(result);
        }
Example #11
0
 public void ExportCertificate()
 {
     byte[] certificate = Gost2001KeyContainer.ExportCertificateData(ContainerSert);
     CollectionAssert.IsNotEmpty(certificate);
 }
Example #12
0
        public void Exist_KeyContainerExist_True()
        {
            bool exist = Gost2001KeyContainer.Exist(Container);

            Assert.IsTrue(exist);
        }
Example #13
0
        public void Exist_KeyContainerAbsent_False()
        {
            bool exist = Gost2001KeyContainer.Exist(Guid.NewGuid().ToString());

            Assert.IsFalse(exist);
        }
Example #14
0
        public void CreateKeyContainer()
        {
            const string NewContainer = "Infotecs_FD80A40E-BC07-4D58-BB8E-4B6BE802CC34";

            Gost2001KeyContainer.Create(NewContainer, KeyNumber.Signature);
        }
Example #15
0
 /// <summary>
 ///     Экспорт открытого ключа.
 /// </summary>
 /// <returns>Открытый ключ.</returns>
 public string ExportPublicKey()
 {
     log.Debug("ExportPublicKey: keyContainerName: {0}", Container);
     return(Convert.ToBase64String(Gost2001KeyContainer.ExportPublicKey(Container)));
 }
Example #16
0
 /// <summary>
 ///     Экспорт сертификата из контейнера.
 /// </summary>
 public string ExportCertificate()
 {
     log.Debug("ExportCertificateData: keyContainerName: {0}", Container);
     return(Convert.ToBase64String(Gost2001KeyContainer.ExportCertificateData(Container)));
 }