Example #1
0
 public void TestSHA1()
 {
     byte[] data = new byte[256];
     byte[] result;
     var shaM = new SHA1Managed();
     result = shaM.ComputeHash(data);
 }
Example #2
0
        public static bool CompareCode(string regcode)
        {
            if (regcode == null || regcode == "")
            {
                return false;
            }
            try
            {
                string toolcode = GetDiskVolumeSerialNumber() + GetCpuSerialNumber();
                string pubkey = "<RSAKeyValue><Modulus>xe3teTUwLgmbiwFJwWEQnshhKxgcasglGsfNVFTk0hdqKc9i7wb+gG7HOdPZLh65QyBcFfzdlrawwVkiPEL5kNTX1q3JW5J49mTVZqWd3w49reaLd8StHRYJdyGAL4ZovBhSTThETi+zYvgQ5SvCGkM6/xXOz+lkMaEgeFcjQQs=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";
                string prikey = "<RSAKeyValue><Modulus>xe3teTUwLgmbiwFJwWEQnshhKxgcasglGsfNVFTk0hdqKc9i7wb+gG7HOdPZLh65QyBcFfzdlrawwVkiPEL5kNTX1q3JW5J49mTVZqWd3w49reaLd8StHRYJdyGAL4ZovBhSTThETi+zYvgQ5SvCGkM6/xXOz+lkMaEgeFcjQQs=</Modulus><Exponent>AQAB</Exponent><P>5flMAd7IrUTx92yomBdJBPDzp1Kclpaw4uXB1Ht+YXqwLW/9icI6mcv7d2O0kuVLSWj8DPZJol9V8AtvHkC3oQ==</P><Q>3FRA9UWcFrVPvGR5bewcL7YqkCMZlybV/t6nCH+gyMfbEvgk+p04F+j8WiHDykWj+BahjScjwyF5SGADbrfJKw==</Q><DP>b4WOU1XbERNfF3JM67xW/5ttPNX185zN2Ko8bbMZXWImr1IgrD5RNqXRo1rphVbGRKoxmIOSv7flr8uLrisKIQ==</DP><DQ>otSZlSq2qomgvgg7PaOLSS+F0TQ/i1emO0/tffhkqT4ah7BgE97xP6puJWZivjAteAGxrxHH+kPY0EY1AzRMNQ==</DQ><InverseQ>Sxyz0fEf5m7GrzAngLDRP/i+QDikJFfM6qPyr3Ub6Y5RRsFbeOWY1tX3jmV31zv4cgJ6donH7W2dSBPi67sSsw==</InverseQ><D>nVqofsIgSZltxTcC8fA/DFz1kxMaFHKFvSK3RKIxQC1JQ3ASkUEYN/baAElB0f6u/oTNcNWVPOqE31IDe7ErQelVc4D26RgFd5V7dSsF3nVz00s4mq1qUBnCBLPIrdb0rcQZ8FUQTsd96qW8Foave4tm8vspbM65iVUBBVdSYYE=</D></RSAKeyValue>";

                using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
                {

                    rsa.FromXmlString(pubkey);

                    RSAPKCS1SignatureDeformatter f = new RSAPKCS1SignatureDeformatter(rsa);

                    f.SetHashAlgorithm("SHA1");

                    SHA1Managed sha = new SHA1Managed();

                    byte[] name = sha.ComputeHash(ASCIIEncoding.ASCII.GetBytes(toolcode));
                    byte[] key = Convert.FromBase64String(regcode);

                    return f.VerifySignature(name, key);
                }
            }
            catch
            {
                return false;
            }
        }
Example #3
0
        ///
        /// 图片解密
        ///
        /// 源文件
        /// 保存文件
        /// 密钥
        public static byte[] DecryptFile2(byte[] data, string keyStr)
        {
            byte[] inputByteArray;

            //通过des解密
            DESCryptoServiceProvider des = new DESCryptoServiceProvider();
            inputByteArray = data;
            byte[] keyByteArray = Encoding.Default.GetBytes(keyStr);
            //定义哈希变量
            SHA1 ha = new SHA1Managed();
            //计算指定字节组指定区域哈希值
            byte[] hb = ha.ComputeHash(keyByteArray);
            //加密密钥数组
            byte[] sKey = new byte[8];
            //加密变量
            byte[] sIV = new byte[8];
            for (int i = 0; i < 8; i++)
            sKey[i] = hb[i];
            for (int i = 8; i < 16; i++)
                sIV[i - 8] = hb[i];
            //获取加密密钥
            des.Key = sKey;
            //加密变量
            des.IV = sIV;
            MemoryStream ms = new MemoryStream();
            CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
            cs.Write(inputByteArray, 0, inputByteArray.Length);
            cs.FlushFinalBlock();
            inputByteArray = ms.ToArray();
            cs.Close();
            ms.Close();
            return inputByteArray;
        }
Example #4
0
 /// <summary>
 /// 加密字符串
 /// </summary>
 /// <param name="inputStr">输入字符串</param>
 /// <param name="keyStr">密码,可以为“”</param>
 /// <returns>输出加密后字符串</returns>
 public string EncryptString(string inputStr, string keyStr)
 {
     DESCryptoServiceProvider des = new DESCryptoServiceProvider();
     if (keyStr == "")
         keyStr = key;
     byte[] inputByteArray = Encoding.Default.GetBytes(inputStr);
     byte[] keyByteArray = Encoding.Default.GetBytes(keyStr);
     SHA1 ha = new SHA1Managed();
     byte[] hb = ha.ComputeHash(keyByteArray);
     sKey = new byte[8];
     sIV = new byte[8];
     for (int i = 0; i < 8; i++)
         sKey[i] = hb[i];
     for (int i = 8; i < 16; i++)
         sIV[i - 8] = hb[i];
     des.Key = sKey;
     des.IV = sIV;
     MemoryStream ms = new MemoryStream();
     CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
     cs.Write(inputByteArray, 0, inputByteArray.Length);
     cs.FlushFinalBlock();
     StringBuilder ret = new StringBuilder();
     foreach (byte b in ms.ToArray())
     {
         ret.AppendFormat("{0:X2}", b);
     }
     cs.Close();
     ms.Close();
     return ret.ToString();
 }
Example #5
0
    public static string EncodePassword(string value)
    {
        string encodedpasswordstring = "";

        byte[] encodedpassword;
        byte[] sha1hash;

        System.Security.Cryptography.SHA1Managed hash = new System.Security.Cryptography.SHA1Managed();

        // get the byte representation of the password
        encodedpassword = Encoding.ASCII.GetBytes(value);

        // Compute the SHA1 hash of the password.
        sha1hash = hash.ComputeHash(encodedpassword);

        // String builder to create the final Hex encoded hash string
        StringBuilder hashedkey = new StringBuilder(sha1hash.Length);


        // Convert to Hex encoded string
        foreach (byte b in sha1hash)
        {
            // This generates the hex encoded string in lower case. Use "X2" to get hash string in upper-case.
            hashedkey.Append(b.ToString("x2"));
        }

        encodedpasswordstring = hashedkey.ToString();  // Final Hex encoded SHA1 hash string

        return(encodedpasswordstring);
    }
Example #6
0
        public void AddFile(DeduplicatorState state, FileInfo sourceFile, string destinationPath)
        {
            if (state.DestinationToFileHash.ContainsKey(destinationPath))
            {
                // File has already been added.
                return;
            }

            // Read the source file.
            var memory = new MemoryStream();
            using (var stream = new BufferedStream(new FileStream(sourceFile.FullName, FileMode.Open, FileAccess.Read, FileShare.None), 1200000))
            {
                stream.CopyTo(memory);
            }

            // Hash the memory stream.
            var sha1 = new SHA1Managed();
            memory.Seek(0, SeekOrigin.Begin);
            var hashBytes = sha1.ComputeHash(memory);
            var hashString = BitConverter.ToString(hashBytes).Replace("-", "").ToLowerInvariant();
            memory.Seek(0, SeekOrigin.Begin);

            // Add to the file hash -> source map if not already present.
            if (!state.FileHashToSource.ContainsKey(hashString))
            {
                state.FileHashToSource.Add(hashString, memory);
            }
            else
            {
                memory.Dispose();
            }

            state.DestinationToFileHash.Add(destinationPath, hashString);
        }
Example #7
0
        private String CreateWsseHeader()
        {
            // HTTPリクエスト毎に生成するセキュリティ・トークン(ランダム文字列)
            byte[] b_nonce = new byte[8];
            Random rand = new Random();
            rand.NextBytes( b_nonce );

            // nonce 生成時の日
            string created = DateTime.Now.ToUniversalTime().ToString( "o" );
            byte[] b_created = Encoding.UTF8.GetBytes( created );

            byte[] b_password = Encoding.UTF8.GetBytes( Password );
            SHA1Managed sh1 = new SHA1Managed();
            sh1.Initialize();

            // Join
            byte[] origin = new byte[b_nonce.Length + b_created.Length + b_password.Length];
            Array.Copy( b_nonce, 0, origin, 0, b_nonce.Length );
            Array.Copy( b_created, 0, origin, b_nonce.Length, b_created.Length );
            Array.Copy( b_password, 0, origin, b_nonce.Length + b_created.Length, b_password.Length );

            // Create Hash Value
            byte[] passwordDigest = sh1.ComputeHash( origin );

            string header = String.Format(
                "UsernameToken Username=\"{0}\", PasswordDigest=\"{1}\", Nonce=\"{2}\", Created=\"{3}\"",
                Username, Convert.ToBase64String( passwordDigest ), Convert.ToBase64String( b_nonce ), created );

            return header;
        }
        public static TapeRecord ReadRecord(Stream file)
        {
            ReadAndVerifySignature(file, ReadableHeaderStart, "Start");
            var dataLength = ReadReadableInt64(file);
            ReadAndVerifySignature(file, ReadableHeaderEnd, "Header-End");

            var data = new byte[dataLength];
            file.Read(data, 0, (int) dataLength);

            ReadAndVerifySignature(file, ReadableFooterStart, "Footer-Start");

            ReadReadableInt64(file); //length verified
            var recVersion = ReadReadableInt64(file);
            var hash = ReadReadableHash(file);
            using (var managed = new SHA1Managed())
            {

                var computed = managed.ComputeHash(data);

                if (!computed.SequenceEqual(hash))
                    throw new InvalidOperationException("Hash corrupted");
            }
            ReadAndVerifySignature(file, ReadableFooterEnd, "End");

            return new TapeRecord(recVersion, data);
        }
Example #9
0
        public int CreateServerKeyExchangeSign(SecurityParameters sparams, byte[] params_buffer, int params_offset, int params_length, byte[] sign_buffer, int sign_offset)
        {
            byte[] hash;
            using (SHA1Managed sha1 = new SHA1Managed ()) {
                sha1.Initialize ();
                sha1.TransformBlock (sparams.ClientRandom, 0, sparams.ClientRandom.Length, sparams.ClientRandom, 0);
                sha1.TransformBlock (sparams.ServerRandom, 0, sparams.ServerRandom.Length, sparams.ServerRandom, 0);
                sha1.TransformBlock (params_buffer, params_offset, params_length, params_buffer, params_offset);
                sha1.TransformFinalBlock (Utility.EmptyByteArray, 0, 0);
                hash = sha1.Hash;
            }

            // 署名
            byte[] sign = _ecdsa.SignHash (hash);

            // DER形式に変換
            // TODO: 400bit以上の署名サイズに対応させる
            byte der_len = (byte)(sign.Length + 6);
            byte int_len = (byte)(sign.Length >> 1);
            sign_buffer[sign_offset + 0] = 0x30;
            sign_buffer[sign_offset + 1] = (byte)(der_len - 2);
            sign_buffer[sign_offset + 2] = 0x02;
            sign_buffer[sign_offset + 3] = int_len;
            Buffer.BlockCopy (sign, 0, sign_buffer, sign_offset + 4, int_len);
            sign_offset += int_len + 4;
            sign_buffer[sign_offset + 0] = 0x02;
            sign_buffer[sign_offset + 1] = int_len;
            Buffer.BlockCopy (sign, int_len, sign_buffer, sign_offset + 2, int_len);

            return der_len;
        }
Example #10
0
        public static AESKeyData GenerateKeyDataFromNonces(byte[] serverNonce, byte[] newNonce) {
            using (SHA1 hash = new SHA1Managed()) {
                var nonces = new byte[48];

                newNonce.CopyTo(nonces, 0);
                serverNonce.CopyTo(nonces, 32);
                byte[] hash1 = hash.ComputeHash(nonces);

                serverNonce.CopyTo(nonces, 0);
                newNonce.CopyTo(nonces, 16);
                byte[] hash2 = hash.ComputeHash(nonces);

                nonces = new byte[64];
                newNonce.CopyTo(nonces, 0);
                newNonce.CopyTo(nonces, 32);
                byte[] hash3 = hash.ComputeHash(nonces);

                using (var keyBuffer = new MemoryStream(32))
                using (var ivBuffer = new MemoryStream(32)) {
                    keyBuffer.Write(hash1, 0, hash1.Length);
                    keyBuffer.Write(hash2, 0, 12);

                    ivBuffer.Write(hash2, 12, 8);
                    ivBuffer.Write(hash3, 0, hash3.Length);
                    ivBuffer.Write(newNonce, 0, 4);

                    return new AESKeyData(keyBuffer.ToArray(), ivBuffer.ToArray());
                }
            }
        }
Example #11
0
 public static string GetHash(byte[] bytes)
 {
     using (var sha1 = new SHA1Managed())
     {
         return string.Join("", sha1.ComputeHash(bytes).Select(b => b.ToString("x2")));
     }
 }
Example #12
0
 /// <summary>
 /// Performs an SHA1 hash of an input byte array
 /// </summary>
 public static byte[] SHAHash( byte[] input )
 {
     using ( var sha = new SHA1Managed() )
     {
         return sha.ComputeHash( input );
     }
 }
Example #13
0
 public string GenerateSHA1Hash(string str)
 {
     SHA1Managed sha1 = new SHA1Managed();
     var hash = sha1.ComputeHash(StringToAscii(str));
     string hex = BitConverter.ToString(hash);
     return hex.Replace("-", "").ToLower();
 }
        public byte[] CreateSha1(byte[] value)
        {
            var sha1 = new SHA1Managed();
            sha1.ComputeHash(value);

            return sha1.Hash;
        }
        private static string GetSha1(string value)
        {
            var data = Encoding.ASCII.GetBytes(value);
            var hashData = new SHA1Managed().ComputeHash(data);

            return hashData.Aggregate(string.Empty, (current, b) => current + b.ToString("X2"));
        }
Example #16
0
 static void Main(string[] args)
 {
     if (args.Length != 1)
     {
         Console.WriteLine("You need to specify a filename as a single argument");
     }
     else
     {
         string file = args[0];
         if (File.Exists(file) == false)
         {
             Console.WriteLine("Argument is not a valid filename");
         }
         else
         {
             FileStream fs = new FileStream(@file, FileMode.Open);
             using (SHA1Managed sha1 = new SHA1Managed())
             {
                 byte[] hash = sha1.ComputeHash(fs);
                 StringBuilder sb = new StringBuilder(hash.Length);
                 foreach (byte b in hash)
                 {
                     sb.AppendFormat("{0:X2}", b);
                 }
                 Console.WriteLine(sb.ToString());
             }
         }
     }
 }
		public override string Transform(string key)
		{
			SHA1Managed sh = new SHA1Managed();
			byte[] data = sh.ComputeHash(Encoding.Unicode.GetBytes(key));

			return Convert.ToBase64String(data, Base64FormattingOptions.None);
		}
Example #18
0
 internal static string CalculateSHA1(string text)
 {
     SHA1Managed s = new SHA1Managed();
     UTF8Encoding enc = new UTF8Encoding();
     s.ComputeHash(enc.GetBytes(text.ToCharArray()));
     return BitConverter.ToString(s.Hash).Replace("-", "");
 }
Example #19
0
File: DB.cs Project: cpbuck12/Db
 }/*
 private string Hash(byte[] buffer)
 {
     SHA1Managed sha1 = new SHA1Managed();
     byte[] hashBytes = sha1.ComputeHash(buffer);
     return BufferToString(hashBytes);
 }
 private string Hash(FileStream stream)
 {
     SHA1Managed sha1 = new SHA1Managed();
     byte[] hashBytes = sha1.ComputeHash(stream);
     return BufferToString(hashBytes);
 }
 // TODO: refactor, this is a copy/paste from ObjectForScripting
 private string Hash(FileInfo fileInfo)
 {
     SHA1Managed sha1 = new SHA1Managed();
     FileStream inFile = new FileStream(fileInfo.FullName, FileMode.Open, FileAccess.Read);
     return Hash(inFile);
 }*/
 private string FileHash(byte[] buffer)
 {
     MemoryStream ms = new MemoryStream(buffer,false);
     SHA1Managed sha1 = new SHA1Managed();
     return string.Concat(from b in sha1.ComputeHash(ms)
                          select b.ToString("X2"));
 }
Example #20
0
 public string GenerateSha1Hash(string str)
 {
     SHA1Managed sha1 = new SHA1Managed();
     var hash = sha1.ComputeHash(System.Text.Encoding.ASCII.GetBytes(str));
     string hex = BitConverter.ToString(hash);
     return hex.Replace("-", "").ToLower();
 }
Example #21
0
        private string HashValues(string Value1, string Value2, string HashingAlgorithm)
        {
            string sHashingAlgorithm = "";
            if (String.IsNullOrEmpty(HashingAlgorithm))
                sHashingAlgorithm = "SHA-1";
            else
                sHashingAlgorithm = HashingAlgorithm;

            byte[] arrByte;

            if (sHashingAlgorithm == "SHA-1")
            {
                SHA1Managed hash = new SHA1Managed();
                arrByte = hash.ComputeHash(ASCIIEncoding.ASCII.GetBytes(Value1 + Value2));
            }
            else
            {
                SHA256Managed hash = new SHA256Managed();
                arrByte = hash.ComputeHash(ASCIIEncoding.ASCII.GetBytes(Value1 + Value2));
            }

            string s = "";
            for (int i = 0; i < arrByte.Length; i++)
            {
                s += arrByte[i].ToString("x2");
            }
            return s;
        }
Example #22
0
        public bool CompareStringToHash(string s, string hash)
        {
            var hashData = Convert.FromBase64String(hash);
            // First, pluck the four-byte salt off of the end of the hash
            var saltData = new byte[SaltSize];
            Array.Copy(hashData, hashData.Length - saltData.Length, saltData, 0, saltData.Length);

            var passwordData = Encoding.UTF8.GetBytes(s);

            // Append the salt to the end of the original
            var saltedPasswordData = new byte[passwordData.Length + saltData.Length];
            Array.Copy(passwordData, 0, saltedPasswordData, 0, passwordData.Length);
            Array.Copy(saltData, 0, saltedPasswordData, passwordData.Length, saltData.Length);

            // Create a new SHA-1 instance and compute the hash
            var sha = new SHA1Managed();
            var newHashData = sha.ComputeHash(saltedPasswordData);

            // Add salt bytes onto end of the original hash for storage
            var newHashSaltData = new byte[newHashData.Length + saltData.Length];
            Array.Copy(newHashData, 0, newHashSaltData, 0, newHashData.Length);
            Array.Copy(saltData, 0, newHashSaltData, newHashData.Length, saltData.Length);
            // Compare and return
            return (Convert.ToBase64String(hashData).Equals(Convert.ToBase64String(newHashSaltData)));
        }
Example #23
0
 /// <summary>
 /// Computes hash for password
 /// </summary>
 /// <param name="password">Password to encrypt</param>
 /// <returns>Encrypted password</returns>
 public static string ComputeHash(string password)
 {
     SHA1Managed sha = new SHA1Managed();
       byte[] data = Encoding.Unicode.GetBytes(password);
       string hash = Convert.ToBase64String(sha.ComputeHash(data));
       return hash;
 }
Example #24
0
        public static SeekableCryptoStream CreateUltraSecureStream(string pswd, int seglen, Stream btr)
        {
            SHA1 mt = new SHA1Managed();
            byte[] hash = mt.ComputeHash(Encoding.UTF8.GetBytes(pswd));
            List<char> tlist = new List<char>(pswd.ToCharArray());
            tlist.Reverse();
            string reversed = new string(tlist.ToArray());
            //Create stream 0
            Aes rdale = new AesManaged();

            Rfc2898DeriveBytes derivitive = new Rfc2898DeriveBytes(reversed + pswd + hash[5].ToString(), hash);
            rdale.Key = derivitive.GetBytes(32);
            derivitive = new Rfc2898DeriveBytes(hash, Encoding.Unicode.GetBytes(pswd), 16);
            rdale.IV = derivitive.GetBytes(16);
            SeekableCryptoStream mstr = new SeekableCryptoStream(new SegmentReader(btr, rdale, seglen));
            //Create stream 1
            Aes secondale = new AesManaged();
            derivitive = new Rfc2898DeriveBytes(pswd + reversed + hash[2].ToString(), Encoding.BigEndianUnicode.GetBytes(pswd));
            secondale.Key = derivitive.GetBytes(32);
            derivitive = new Rfc2898DeriveBytes(hash, Encoding.Unicode.GetBytes(pswd), 16);
            secondale.IV = derivitive.GetBytes(16);
            //No clue why this has to be less than 16384, but it does....
            Console.WriteLine("WARNING: Insecure test algorithm. Uncomment line below to secure it");
           //TODO: DOESN't work with 2 for some reason....
            mstr = new SeekableCryptoStream(new SegmentReader(mstr, rdale, seglen));
            return mstr;
        }
Example #25
0
 public static Hash FromFile(string path)
 {
     SHA1 sha = new SHA1Managed();
     byte[] arr = FileUtils.GetAllBytes(path);
     byte[] result = sha.ComputeHash(arr);
     return new Hash(result);
 }
        static void GenKey(string baseName, out byte[] desKey, out byte[] desIV)
        {
            byte[] secretBytes = { 6, 29, 66, 6, 2, 68, 4, 7, 70 };

            byte[] baseNameBytes = new ASCIIEncoding().GetBytes(baseName);

            byte[] hashBytes = new byte[secretBytes.Length + baseNameBytes.Length];

            // copy secret byte to start of hash array
            for (int i = 0; i < secretBytes.Length; i++)
            {
                hashBytes[i] = secretBytes[i];
            }

            // copy filename byte to end of hash array
            for (int i = 0; i < baseNameBytes.Length; i++)
            {
                hashBytes[i + secretBytes.Length] = baseNameBytes[i];
            }

            SHA1Managed sha = new SHA1Managed();

            // run the sha1 hash
            byte[] hashResult = sha.ComputeHash(hashBytes);

            desKey = new byte[8];
            desIV = new byte[8];

            for (int i = 0; i < 8; i++)
            {
                desKey[i] = hashResult[i];
                desIV[i] = hashResult[8 + i];
            }
        }
Example #27
0
 public bool EncryptFile(string filePath, string savePath, string keyStr)
 {
     DESCryptoServiceProvider des = new DESCryptoServiceProvider();
     if (keyStr == "")
         keyStr = key;
     FileStream fs = File.OpenRead(filePath);
     byte[] inputByteArray = new byte[fs.Length];
     fs.Read(inputByteArray, 0, (int)fs.Length);
     fs.Close();
     byte[] keyByteArray = Encoding.Default.GetBytes(keyStr);
     SHA1 ha = new SHA1Managed();
     byte[] hb = ha.ComputeHash(keyByteArray);
     sKey = new byte[8];
     sIV = new byte[8];
     for (int i = 0; i < 8; i++)
         sKey[i] = hb[i];
     for (int i = 8; i < 16; i++)
         sIV[i - 8] = hb[i];
     des.Key = sKey;
     des.IV = sIV;
     MemoryStream ms = new MemoryStream();
     CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
     cs.Write(inputByteArray, 0, inputByteArray.Length);
     cs.FlushFinalBlock();
     fs = File.OpenWrite(savePath);
     foreach (byte b in ms.ToArray())
     {
         fs.WriteByte(b);
     }
     fs.Close();
     cs.Close();
     ms.Close();
     return true;
 }
Example #28
0
 public static string SHA1(string stringToHash)
 {
     System.Security.Cryptography.SHA1Managed sha1Obj = new System.Security.Cryptography.SHA1Managed();
     byte[] bytesToHash = System.Text.Encoding.UTF8.GetBytes(stringToHash);
     bytesToHash = sha1Obj.ComputeHash(bytesToHash);
     return(BitConverter.ToString(bytesToHash).Replace("-", "").ToUpper());
 }
 public virtual string GenerateId(string handle)
 {
     var sha = new SHA1Managed();
     var handleBytes = Encoding.UTF8.GetBytes(handle);
     var hashBytes = sha.ComputeHash(handleBytes);
     return BitConverter.ToString(hashBytes, 0, 9).Replace("-", "");
 }
Example #30
0
 /// <summary>
 /// Empaqquete un DIscoInfo
 /// </summary>
 /// <param name="info">DicoInfo</param>
 /// <returns>Ampaquetage</returns>
 public static string DiscoInfoToVersion(DiscoInfo info)
 {
     StringBuilder builder = new StringBuilder(256);
     DiscoIdentity[] identities = info.GetIdentities();
     string[] ids = new string[identities.Length];
     for (int i = 0; i < identities.Length; i++)
     {
         ids[i] = string.Format("{0}/{1}", identities[i].Category, identities[i].Type);
     }
     Array.Sort(ids);
     foreach (string id in ids)
     {
         builder.AppendFormat("{0}<", id);
     }
     DiscoFeature[] features = info.GetFeatures();
     string[] feas = new string[features.Length];
     for (int i = 0; i < features.Length; i++)
     {
         feas[i] = features[i].Var;
     }
     Array.Sort(feas);
     foreach (string fea in feas)
     {
         builder.AppendFormat("{0}<", fea);
     }
     SHA1Managed sha1 = new SHA1Managed();
     byte[] hash = sha1.ComputeHash(Encoding.Unicode.GetBytes(builder.ToString()));
     return Convert.ToBase64String(hash);
 }
Example #31
0
 /// <summary>
 /// SHA1非对称加密.用于密码加密,使用SHA1Managed类产生长度为160位哈希值.
 /// </summary>
 /// <param name="text">传入一个任意长字符串.</param>
 /// <returns>返回长度为28字节的字符串.</returns>
 public static string GetSHA1(string text)
 {
     byte[] byteSHA1 = System.Text.Encoding.UTF8.GetBytes(text);
     var sha1 = new SHA1Managed();
     byte[] result = sha1.ComputeHash(byteSHA1);
     return Convert.ToBase64String(result);
 }
Example #32
0
        public WardenRandom(byte[] seed)
        {
            Data1 = new byte[0x14];
            Data2 = new byte[0x14];
            Data3 = new byte[0x14];

            int length1 = (int)seed.Length >> 1;
            int length2 = seed.Length - length1;

            byte[] seed1 = new byte[length1];
            byte[] seed2 = new byte[length2];

            for (int i = 0; i < length1; i++)
                seed1[i] = seed[i];
            for (int i = 0; i < length2; i++)
                seed2[i] = seed[i + length1];

            SHA1 sha = new SHA1Managed();
            Data2 = sha.ComputeHash(seed1);
            Data3 = sha.ComputeHash(seed2);

            sha.Initialize();
            sha.TransformBlock(Data2, 0, Data2.Length, Data2, 0);
            sha.TransformBlock(Data1, 0, Data1.Length, Data1, 0);
            sha.TransformFinalBlock(Data3, 0, Data3.Length);

            Data1 = sha.Hash;

            sha.Initialize();
        }
Example #33
0
        // Seeds PRNG with first 32 bits of hashed input from tf_randomSeed textbox
        private void glitchSpeak_Click(object sender, RoutedEventArgs e)
        {
            HashAlgorithm hasher = new System.Security.Cryptography.SHA1Managed();
            var           bytes  = hasher.ComputeHash(Encoding.Unicode.GetBytes(tf_randomSeed.Text));
            var           hash   = string.Join("", bytes.Select(x => x.ToString("x2")).ToArray());

            rand = new Random(Convert.ToInt32(hash.Substring(0, 8), 16));
        }
 //password hashing
 private string GetHash()
 {
     using (var hash = new System.Security.Cryptography.SHA1Managed())
     {
         var hashbytes = System.Text.Encoding.UTF8.GetBytes(Password);
         return(Convert.ToBase64String(hash.ComputeHash(hashbytes)));
     }
 }
Example #35
0
 public static string computeSHA1Hash(string val)
 {
     if (val.Equals(""))
     {
         return("");
     }
     byte[] data = System.Text.Encoding.UTF8.GetBytes(val);
     System.Security.Cryptography.SHA1 sha = new System.Security.Cryptography.SHA1Managed();
     byte[] res = sha.ComputeHash(data);
     return(System.BitConverter.ToString(res).Replace("-", "").ToUpper());
 }
Example #36
0
        public static void Check(out bool isValid, out bool expired, out int siteQty)
        {
            siteQty = 0;
            isValid = false;
            expired = true;
            HiContext    current        = HiContext.Current;
            XmlDocument  xmlDocument    = HiCache.Get("FileCache_CommercialLicenser") as XmlDocument;
            SiteSettings masterSettings = SettingsManager.GetMasterSettings(true);

            if (xmlDocument == null)
            {
                string text = (current.Context != null) ? current.Context.Request.MapPath("~/config/Certificates.cer") : System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, "config\\Certificates.cer");
                if (!System.IO.File.Exists(text))
                {
                    return;
                }
                xmlDocument = new XmlDocument();
                xmlDocument.LoadXml(System.IO.File.ReadAllText(text));
                HiCache.Max("FileCache_CommercialLicenser", xmlDocument, new CacheDependency(text));
            }
            XmlNode xmlNode  = xmlDocument.DocumentElement.SelectSingleNode("//Host");
            XmlNode xmlNode2 = xmlDocument.DocumentElement.SelectSingleNode("//LicenseDate");
            XmlNode xmlNode3 = xmlDocument.DocumentElement.SelectSingleNode("//Expires");
            XmlNode xmlNode4 = xmlDocument.DocumentElement.SelectSingleNode("//SiteQty");
            XmlNode xmlNode5 = xmlDocument.DocumentElement.SelectSingleNode("//Signature");
            //if (string.Compare(xmlNode.InnerText, masterSettings.SiteUrl, true, System.Globalization.CultureInfo.InvariantCulture) == 0)
            //{

            //}

            string s = string.Format(System.Globalization.CultureInfo.InvariantCulture, "Host={0}&Expires={1}&SiteQty={2}&LicenseDate={3}", new object[]
            {
                masterSettings.SiteUrl,
                xmlNode3.InnerText,
                xmlNode4.InnerText,
                xmlNode2.InnerText
            });

            using (System.Security.Cryptography.RSACryptoServiceProvider rSACryptoServiceProvider = new System.Security.Cryptography.RSACryptoServiceProvider())
            {
                rSACryptoServiceProvider.FromXmlString(LicenseHelper.GetPublicKey());
                System.Security.Cryptography.RSAPKCS1SignatureDeformatter rSAPKCS1SignatureDeformatter = new System.Security.Cryptography.RSAPKCS1SignatureDeformatter(rSACryptoServiceProvider);
                rSAPKCS1SignatureDeformatter.SetHashAlgorithm("SHA1");
                byte[] rgbSignature = System.Convert.FromBase64String(xmlNode5.InnerText);
                byte[] rgbHash      = new System.Security.Cryptography.SHA1Managed().ComputeHash(System.Text.Encoding.UTF8.GetBytes(s));
                isValid = rSAPKCS1SignatureDeformatter.VerifySignature(rgbHash, rgbSignature);
                isValid = true;
            }
            expired = (System.DateTime.Now > System.DateTime.Parse(xmlNode3.InnerText));
            if (isValid && !expired)
            {
                int.TryParse(xmlNode4.InnerText, out siteQty);
            }
        }
Example #37
0
    public static string Hash(string strToEncrypt)
    {
        System.Text.UTF8Encoding ue = new System.Text.UTF8Encoding();
        byte[] bytes = ue.GetBytes(strToEncrypt);
        // encrypt bytes
        var sha1 = new System.Security.Cryptography.SHA1Managed();

        byte[] hashBytes = sha1.ComputeHash(bytes);
        var    sHash     = System.Convert.ToBase64String(hashBytes);

        return(sHash);
    }
Example #38
0
 public static string SHA1file(byte[] buffer)
 {
     try
     {
         System.Security.Cryptography.SHA1Managed Sha1 = new System.Security.Cryptography.SHA1Managed();
         byte[] retVal = Sha1.ComputeHash(buffer);
         return(System.Convert.ToBase64String(retVal));
     }
     catch (Exception ex)
     {
         throw new Exception("SHA1file() fail, error:" + ex.Message);
     }
 }
Example #39
0
        public static string SHA1(string input)
        {
            System.Security.Cryptography.SHA1Managed sha1 = new System.Security.Cryptography.SHA1Managed();
            byte[] hash = sha1.ComputeHash(Encoding.UTF8.GetBytes(input));
            sha1.Dispose();
            StringBuilder sb = new StringBuilder(hash.Length * 2);

            foreach (byte b in hash) // can be "x2" if you want lowercase
            {
                sb.Append(b.ToString("x2"));
            }
            return(sb.ToString());
        }
Example #40
0
    private ResmgrNative()
    {
        //初始化本地URL
#if UNITY_ANDROID && !UNITY_EDITOR
        localurl = Application.streamingAssetsPath;
        //Android 比较特别
#else
        localurl = "file://" + Application.streamingAssetsPath;
        //此url 在 windows 及 WP IOS  可以使用
#endif
        cacheurl = System.IO.Path.Combine(Application.persistentDataPath, "vercache");

        sha1      = new System.Security.Cryptography.SHA1Managed();
        taskState = new TaskState();
    }
Example #41
0
    public string Encrypt(string password)
    {
        var sha1           = new System.Security.Cryptography.SHA1Managed();
        var plaintextBytes = Encoding.UTF8.GetBytes(password);
        var hashBytes      = sha1.ComputeHash(plaintextBytes);

        var sb = new StringBuilder();

        foreach (var hashByte in hashBytes)
        {
            sb.AppendFormat("{0:x2}", hashByte);
        }

        return(sb.ToString().ToUpper());
    }
Example #42
0
 public static string SHA1file(string file)
 {
     try
     {
         FileStream fs = new FileStream(file, FileMode.Open);
         System.Security.Cryptography.SHA1Managed Sha1 = new System.Security.Cryptography.SHA1Managed();
         byte[] retVal = Sha1.ComputeHash(fs);
         fs.Close();
         return(System.Convert.ToBase64String(retVal));
     }
     catch (Exception ex)
     {
         throw new Exception("SHA1file() fail, error:" + ex.Message);
     }
 }
Example #43
0
        /// <summary>
        /// 获取字符串的Hash字符
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string ToHashText(this string str)
        {
            if (String.IsNullOrEmpty(str))
            {
                return(String.Empty);
            }

            using (var sha1 = new System.Security.Cryptography.SHA1Managed())
            {
                byte[] textData = System.Text.Encoding.UTF8.GetBytes(str);

                byte[] hash = sha1.ComputeHash(textData);

                return(BitConverter.ToString(hash).Replace("-", String.Empty));
            }
        }
Example #44
0
        private string HashFiles(IEnumerable <VstsFile> files)
        {
            StringBuilder builder = new StringBuilder();

            foreach (var f in files.OrderBy(f => f.Path))
            {
                builder.Append(f.Blob.Id);
                builder.Append(f.Path);
            }
            var bytes  = Encoding.UTF8.GetBytes(builder.ToString());
            var hasher = new System.Security.Cryptography.SHA1Managed();
            var hash   = hasher.ComputeHash(bytes);

            //really we want to encode as base36
            return(System.BitConverter.ToString(hash).Replace("-", "").ToLower());
        }
Example #45
0
        public byte[] GetPublicKeyToken()
        {
            if (public_key == null || public_key_token != null)
            {
                return(public_key_token);
            }

            HashAlgorithm ha = new System.Security.Cryptography.SHA1Managed();

            byte[] hash = ha.ComputeHash(public_key);
            // we need the last 8 bytes in reverse order
            public_key_token = new byte[8];
            Buffer.BlockCopy(hash, hash.Length - 8, public_key_token, 0, 8);
            Array.Reverse(public_key_token, 0, 8);
            return(public_key_token);
        }
Example #46
0
        internal static string getSha1Hash(string text)
        {
            if (String.IsNullOrEmpty(text))
            {
                return(String.Empty);
            }

            using (var sha1 = new System.Security.Cryptography.SHA1Managed())
            {
                byte[] textData = Encoding.UTF8.GetBytes(text);

                byte[] hash = sha1.ComputeHash(textData);

                return(BitConverter.ToString(hash).Replace("-", String.Empty));
            }
        }
        public static string GetSHA1Hash(string str)
        {
            Encoder enc = System.Text.Encoding.Unicode.GetEncoder();

            byte[] unicodeText = new byte[str.Length * 2];
            enc.GetBytes(str.ToCharArray(), 0, str.Length, unicodeText, 0, true);

            System.Security.Cryptography.SHA1 sha = new System.Security.Cryptography.SHA1Managed();

            byte[] result = sha.ComputeHash(unicodeText);

            StringBuilder sb = new StringBuilder();

            for (int i = 0; i < result.Length; i++)
            {
                sb.Append(result[i].ToString());
            }
            return(sb.ToString());
        }
        private unsafe static void SHATransform(uint *expandedBuffer, uint *state, byte *block)
        {
            uint num  = *state;
            uint num2 = state[1];
            uint num3 = state[2];
            uint num4 = state[3];
            uint num5 = state[4];

            Utils.DWORDFromBigEndian(expandedBuffer, 16, block);
            SHA1Managed.SHAExpand(expandedBuffer);
            int i;

            for (i = 0; i < 20; i += 5)
            {
                num5 += (num << 5 | num >> 27) + (num4 ^ (num2 & (num3 ^ num4))) + expandedBuffer[i] + 1518500249U;
                num2  = (num2 << 30 | num2 >> 2);
                num4 += (num5 << 5 | num5 >> 27) + (num3 ^ (num & (num2 ^ num3))) + expandedBuffer[i + 1] + 1518500249U;
                num   = (num << 30 | num >> 2);
                num3 += (num4 << 5 | num4 >> 27) + (num2 ^ (num5 & (num ^ num2))) + expandedBuffer[i + 2] + 1518500249U;
                num5  = (num5 << 30 | num5 >> 2);
                num2 += (num3 << 5 | num3 >> 27) + (num ^ (num4 & (num5 ^ num))) + expandedBuffer[i + 3] + 1518500249U;
                num4  = (num4 << 30 | num4 >> 2);
                num  += (num2 << 5 | num2 >> 27) + (num5 ^ (num3 & (num4 ^ num5))) + expandedBuffer[i + 4] + 1518500249U;
                num3  = (num3 << 30 | num3 >> 2);
            }
            while (i < 40)
            {
                num5 += (num << 5 | num >> 27) + (num2 ^ num3 ^ num4) + expandedBuffer[i] + 1859775393U;
                num2  = (num2 << 30 | num2 >> 2);
                num4 += (num5 << 5 | num5 >> 27) + (num ^ num2 ^ num3) + expandedBuffer[i + 1] + 1859775393U;
                num   = (num << 30 | num >> 2);
                num3 += (num4 << 5 | num4 >> 27) + (num5 ^ num ^ num2) + expandedBuffer[i + 2] + 1859775393U;
                num5  = (num5 << 30 | num5 >> 2);
                num2 += (num3 << 5 | num3 >> 27) + (num4 ^ num5 ^ num) + expandedBuffer[i + 3] + 1859775393U;
                num4  = (num4 << 30 | num4 >> 2);
                num  += (num2 << 5 | num2 >> 27) + (num3 ^ num4 ^ num5) + expandedBuffer[i + 4] + 1859775393U;
                num3  = (num3 << 30 | num3 >> 2);
                i    += 5;
            }
            while (i < 60)
            {
                num5 += (num << 5 | num >> 27) + ((num2 & num3) | (num4 & (num2 | num3))) + expandedBuffer[i] + 2400959708U;
                num2  = (num2 << 30 | num2 >> 2);
                num4 += (num5 << 5 | num5 >> 27) + ((num & num2) | (num3 & (num | num2))) + expandedBuffer[i + 1] + 2400959708U;
                num   = (num << 30 | num >> 2);
                num3 += (num4 << 5 | num4 >> 27) + ((num5 & num) | (num2 & (num5 | num))) + expandedBuffer[i + 2] + 2400959708U;
                num5  = (num5 << 30 | num5 >> 2);
                num2 += (num3 << 5 | num3 >> 27) + ((num4 & num5) | (num & (num4 | num5))) + expandedBuffer[i + 3] + 2400959708U;
                num4  = (num4 << 30 | num4 >> 2);
                num  += (num2 << 5 | num2 >> 27) + ((num3 & num4) | (num5 & (num3 | num4))) + expandedBuffer[i + 4] + 2400959708U;
                num3  = (num3 << 30 | num3 >> 2);
                i    += 5;
            }
            while (i < 80)
            {
                num5 += (num << 5 | num >> 27) + (num2 ^ num3 ^ num4) + expandedBuffer[i] + 3395469782U;
                num2  = (num2 << 30 | num2 >> 2);
                num4 += (num5 << 5 | num5 >> 27) + (num ^ num2 ^ num3) + expandedBuffer[i + 1] + 3395469782U;
                num   = (num << 30 | num >> 2);
                num3 += (num4 << 5 | num4 >> 27) + (num5 ^ num ^ num2) + expandedBuffer[i + 2] + 3395469782U;
                num5  = (num5 << 30 | num5 >> 2);
                num2 += (num3 << 5 | num3 >> 27) + (num4 ^ num5 ^ num) + expandedBuffer[i + 3] + 3395469782U;
                num4  = (num4 << 30 | num4 >> 2);
                num  += (num2 << 5 | num2 >> 27) + (num3 ^ num4 ^ num5) + expandedBuffer[i + 4] + 3395469782U;
                num3  = (num3 << 30 | num3 >> 2);
                i    += 5;
            }
            *state += num;
            state[1] += num2;
            state[2] += num3;
            state[3] += num4;
            state[4] += num5;
        }
Example #49
0
 public static string GetHashSHA1(Stream data)
 {
     System.Security.Cryptography.SHA1Managed sha = new System.Security.Cryptography.SHA1Managed();
     byte[] result = sha.ComputeHash(data);
     return(Convert.ToBase64String(result));
 }
Example #50
0
 // Получить код хеш устройства С:
 public static byte[] HashHardvare()
 {
     System.Security.Cryptography.SHA1 sha = new System.Security.Cryptography.SHA1Managed();
     return(sha.ComputeHash(HardwareKey()));
 }
Example #51
0
        /// <summary>
        /// Gets SHA1 hash of a byte array
        /// </summary>
        /// <param name="buffer">Byte array</param>
        /// <returns>SHA1 hash as string</returns>
        public static string SHA1(byte[] buffer)
        {
            SHA1 sha1 = new SHA1CryptoServiceProvider();

            return(BitConverter.ToString(sha1.ComputeHash(buffer)).Replace("-", ""));
        }
Example #52
0
        protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken token)
        {
            if (!request.Headers.Contains("Signature") && !request.Headers.Contains("SignatureCertChainUrl"))
            {
                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest));
            }

            var signatureCertChainUrl = request.Headers.GetValues("SignatureCertChainUrl").First().Replace("/../", "/");

            if (string.IsNullOrWhiteSpace(signatureCertChainUrl))
            {
                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest));
            }

            var certUrl = new Uri(signatureCertChainUrl);

            if (!((certUrl.Port == 443 && certUrl.IsDefaultPort) &&
                  certUrl.Scheme.Equals(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) &&
                  certUrl.Host.Equals("s3.amazonaws.com", StringComparison.OrdinalIgnoreCase) &&
                  certUrl.AbsolutePath.StartsWith("/echo.api/")))
            {
                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest));
            }


            // download the certificate
            using (var web = new System.Net.WebClient())
            {
                var certificate = web.DownloadData(certUrl);
                var cert        = new X509Certificate2(certificate);

                var expiryDate    = DateTime.MinValue;
                var effectiveDate = DateTime.MinValue;

                if (DateTime.TryParse(cert.GetExpirationDateString(), out expiryDate) &&
                    expiryDate < DateTime.UtcNow && DateTime.TryParse(cert.GetEffectiveDateString(), out effectiveDate) && effectiveDate < DateTime.UtcNow)
                {
                    throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest));
                }
                if (!cert.Subject.Contains("CN=echo-api.amazon.com"))
                {
                    throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest));
                }


                var signatureString = request.Headers.GetValues("Signature").First();

                byte[] signature = Convert.FromBase64String(signatureString);


                using (var sha1 = new System.Security.Cryptography.SHA1Managed())
                {
                    var body = await request.Content.ReadAsStringAsync();

                    var data = sha1.ComputeHash(Encoding.UTF8.GetBytes(body));

                    var rsa = (RSACryptoServiceProvider)cert.PublicKey.Key;

                    if (!rsa.VerifyHash(data, CryptoConfig.MapNameToOID("SHA1"), signature))
                    {
                        throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest));
                    }
                }
            }

            return(await base.SendAsync(request, token));
        }
Example #53
0
        private string step_3(string filename) //Core validation
        {
            string[] SUPPORTED_TRANSFORMS =
            {
                "http://www.w3.org/TR/2001/REC-xml-c14n-20010315",
                "http://www.w3.org/2000/09/xmldsig#base64",
            };
            string[] SUPPORTED_DIGEST_METHOD =
            {
                "http://www.w3.org/2001/04/xmlenc#sha512 ",
                "http://www.w3.org/2001/04/xmldsig-more#sha384",
                "http://www.w3.org/2001/04/xmlenc#sha256",
                "http://www.w3.org/2001/04/xmldsig-more#sha224",
                "http://www.w3.org/2000/09/xmldsig#sha1",
            };

            XmlDocument xades = new XmlDocument();

            xades.Load(filename);
            var namespaceId = new XmlNamespaceManager(xades.NameTable);

            namespaceId.AddNamespace("ds", "http://www.w3.org/2000/09/xmldsig#");
            namespaceId.AddNamespace("xades", "http://uri.etsi.org/01903/v1.3.2#");



            //check ds:SignedInfo and ds:Manifest
            XmlNode     signedInfoN       = xades.SelectSingleNode(@"//ds:SignedInfo", namespaceId);
            XmlNodeList referenceElements = signedInfoN.SelectNodes(@"//ds:Reference", namespaceId);

            //Reference in SignedInfo
            foreach (XmlNode reference in referenceElements)
            {
                String ReferenceURI = reference.Attributes.GetNamedItem("URI").Value;
                ReferenceURI = ReferenceURI.Substring(1);
                XmlNode digestMethod          = reference.SelectSingleNode("ds:DigestMethod", namespaceId);
                String  digestMethodAlgorithm = digestMethod.Attributes.GetNamedItem("Algorithm").Value;
                string  dsDigestValue         = reference.SelectSingleNode("ds:DigestValue", namespaceId).InnerText;

                if (ReferenceURI.StartsWith("ManifestObject"))
                {
                    //get Manifest XML and check DigestValue
                    string               manifestXML = xades.SelectSingleNode("//ds:Manifest[@Id='" + ReferenceURI + "']", namespaceId).OuterXml;
                    MemoryStream         sManifest   = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(manifestXML));
                    XmlDsigC14NTransform t           = new XmlDsigC14NTransform();
                    t.LoadInput(sManifest);
                    HashAlgorithm hash = null;

                    switch (digestMethodAlgorithm)
                    {
                    case "http://www.w3.org/2000/09/xmldsig#sha1":
                        hash = new System.Security.Cryptography.SHA1Managed();
                        break;

                    case "http://www.w3.org/2001/04/xmlenc#sha256":
                        hash = new System.Security.Cryptography.SHA256Managed();
                        break;

                    case "http://www.w3.org/2001/04/xmldsig-more#sha384":
                        hash = new System.Security.Cryptography.SHA384Managed();
                        break;

                    case "http://www.w3.org/2001/04/xmlenc#sha512":
                        hash = new System.Security.Cryptography.SHA512Managed();
                        break;
                    }

                    if (hash == null)
                    {
                        return("nesprávny hashovací algoritmus " + digestMethodAlgorithm);
                    }

                    byte[] digest = t.GetDigestedOutput(hash);
                    string result = Convert.ToBase64String(digest);

                    Console.WriteLine("-");
                    Console.WriteLine("Overenie hodnoty podpisu");
                    Console.WriteLine(result);
                    Console.WriteLine(dsDigestValue);
                    Console.WriteLine("-");

                    if (!result.Equals(dsDigestValue))
                    {
                        return("hodnoty DigestValue s výpočtom Manifest sa nezhodujú");
                    }
                }
            }

            //signed info kanonikalizovat

            XmlNode checkData = xades.SelectSingleNode(@"//ds:KeyInfo/ds:X509Data/ds:X509Certificate", namespaceId);

            if (checkData == null)
            {
                return("neobsahuje element ds:X509Data");
            }

            byte[]  signatureCertificate   = Convert.FromBase64String(xades.SelectSingleNode(@"//ds:KeyInfo/ds:X509Data/ds:X509Certificate", namespaceId).InnerText);
            byte[]  signature              = Convert.FromBase64String(xades.SelectSingleNode(@"//ds:SignatureValue", namespaceId).InnerText);
            XmlNode signedInfoNnn          = xades.SelectSingleNode(@"//ds:SignedInfo", namespaceId);
            string  signedInfoTransformAlg = xades.SelectSingleNode(@"//ds:SignedInfo/ds:CanonicalizationMethod", namespaceId).Attributes.GetNamedItem("Algorithm").Value;
            string  signedInfoSignatureAlg = xades.SelectSingleNode(@"//ds:SignedInfo/ds:SignatureMethod", namespaceId).Attributes.GetNamedItem("Algorithm").Value;

            XmlDsigC14NTransform t1  = new XmlDsigC14NTransform(false);
            XmlDocument          pom = new XmlDocument();

            pom.LoadXml(signedInfoNnn.OuterXml);
            t1.LoadInput(pom);
            byte[] data = ((MemoryStream)t1.GetOutput()).ToArray();

            string errMsg = "";
            bool   res    = this.verifySign(signatureCertificate, signature, data, signedInfoSignatureAlg, out errMsg);

            if (!res)
            {
                Console.WriteLine("Error " + errMsg);
                return(errMsg);
            }


            //check Id in ds:Signature
            XmlNode dsSignatureId = xades.SelectSingleNode("//ds:Signature", namespaceId).Attributes["Id"];

            if (dsSignatureId == null)
            {
                return("ds:Signature nemá atribút Id");
            }
            //check namespace in ds:Signature
            XmlNode dsSignatureXmlns = xades.SelectSingleNode("//ds:Signature", namespaceId).Attributes["xmlns:ds"];

            if (dsSignatureXmlns == null)
            {
                return("ds:Signature nemá špecifikovaný namespace xmlns:ds");
            }



            //check SignatureValue Id
            XmlNode dsSignatureValueId = xades.SelectSingleNode("//ds:SignatureValue", namespaceId).Attributes["Id"];

            if (dsSignatureValueId == null)
            {
                return("ds:SignatureValue nemá atribút Id");
            }



            //check reference in ds:SignedInfo
            XmlNode     signedInfo  = xades.SelectSingleNode("//ds:SignedInfo", namespaceId);
            XmlNodeList dsKeyInfoId = signedInfo.SelectNodes("//ds:Reference", namespaceId);

            if (dsKeyInfoId.Count < 1)
            {
                return("ds:SignedInfo neobsahuje ds:Reference");
            }
            String        KeyInfo             = "";
            String        SignatureProperties = "";
            String        SignedProperties    = "";
            List <string> Manifest            = new List <string>();

            //get URI
            foreach (XmlNode ReferenceList in dsKeyInfoId)
            {
                if (ReferenceList.Attributes["Id"] == null)
                {
                    continue;
                }
                else if (ReferenceList.Attributes["Id"] != null)
                {
                    if (ReferenceList.Attributes["Type"].Value.Contains("Object"))
                    {
                        KeyInfo = ReferenceList.Attributes["URI"].Value;
                        KeyInfo = KeyInfo.Substring(1);
                    }
                    else if (ReferenceList.Attributes["Type"].Value.Contains("SignatureProperties"))
                    {
                        SignatureProperties = ReferenceList.Attributes["URI"].Value;
                        SignatureProperties = SignatureProperties.Substring(1);
                    }
                    else if (ReferenceList.Attributes["Type"].Value.Contains("SignedProperties"))
                    {
                        SignedProperties = ReferenceList.Attributes["URI"].Value;
                        SignedProperties = SignedProperties.Substring(1);
                    }
                    else if (ReferenceList.Attributes["Type"].Value.Contains("Manifest"))
                    {
                        String tmp = ReferenceList.Attributes["URI"].Value;
                        tmp = tmp.Substring(1);
                        Manifest.Add(tmp);
                    }
                }
            }
            //check if exist ds:KeyInfo, ds:SignatureProperties, xades:SignedProperties
            XmlNode ElementKeyInfo             = xades.SelectSingleNode("//ds:KeyInfo", namespaceId);
            XmlNode ElementSignatureProperties = xades.SelectSingleNode("//ds:SignatureProperties", namespaceId);
            XmlNode ElementSignedProperties    = xades.SelectSingleNode("//xades:SignedProperties", namespaceId);

            if (ElementKeyInfo.Attributes["Id"] == null)
            {
                return("ds:Keyinfo nemá atribút Id");
            }
            if (!ElementKeyInfo.Attributes["Id"].Value.Equals(KeyInfo))
            {
                return("ds:Keyinfo, nezhoduje sa Id s URI");
            }

            if (ElementSignatureProperties.Attributes["Id"] == null)
            {
                return("ds:SignatureProperties nemá atribút Id");
            }
            if (!ElementSignatureProperties.Attributes["Id"].Value.Equals(SignatureProperties))
            {
                return("ds:SignatureProperties, nezhoduje sa Id s URI");
            }

            if (ElementSignedProperties.Attributes["Id"] == null)
            {
                return("xades:SignedProperties nemá atribút Id");
            }
            if (!ElementSignedProperties.Attributes["Id"].Value.Equals(SignedProperties))
            {
                return("xades:SignedProperties, nezhoduje sa Id s URI");
            }

            //check if exist ds:Manifest
            XmlNodeList ElementManifest = xades.SelectNodes("//ds:Manifest", namespaceId);
            bool        flag            = false;

            foreach (XmlNode OneManifest in ElementManifest)
            {
                foreach (String ManifestURI in Manifest)
                {
                    if (OneManifest.Attributes["Id"] == null || !OneManifest.Attributes["Id"].Value.Equals(ManifestURI))
                    {
                        flag = true;
                    }
                }
            }
            if (!flag)
            {
                return("ds:Manifest nemá atribút Id alebo sa nezhoduje Id s URI");
            }



            //check ds:KeyInfo Id
            if (ElementKeyInfo.Attributes["Id"] == null)
            {
                return("element ds:KeyInfo nemá atribút Id");
            }
            //check ds:KeyInfo elements
            XmlNode X509Data = ElementKeyInfo.SelectSingleNode("//ds:X509Data", namespaceId);

            if (X509Data == null)
            {
                return("ds:KeyInfo neobsahuje element ds:X509Data");
            }
            if (X509Data.ChildNodes.Count < 3)
            {
                return(" chýbajú podelementy pre ds:X509Data");
            }
            //check ds:KeyInfo values
            XmlNodeList elemList = X509Data.ChildNodes;

            byte[] bytes;
            var    cert = new X509Certificate2();
            String IssuerSerialFirst  = "";
            String IssuerSerialSecond = "";
            String SubjectName        = "";

            for (int i = 0; i < elemList.Count; i++)
            {
                switch (elemList[i].Name)
                {
                case "ds:X509Certificate":
                    bytes = Convert.FromBase64String(elemList[i].InnerText);
                    cert  = new X509Certificate2(bytes);
                    break;

                case "ds:X509IssuerSerial":
                    if (elemList[i].HasChildNodes)
                    {
                        IssuerSerialFirst  = elemList[i].FirstChild.InnerText;
                        IssuerSerialSecond = elemList[i].LastChild.InnerText;
                    }
                    break;

                case "ds:X509SubjectName":
                    SubjectName = elemList[i].InnerText;
                    break;
                }
            }
            BigInteger hex = BigInteger.Parse(cert.SerialNumber, NumberStyles.AllowHexSpecifier);

            if (!cert.Subject.Equals(SubjectName))
            {
                return("hodnota ds:X509SubjectName sa nezhoduje s príslušnou hodnotou v certifikáte");
            }
            if (!cert.Issuer.Equals(IssuerSerialFirst))
            {
                return("hodnota ds:X509IssuerName sa nezhoduje s príslušnou hodnotou v certifikáte");
            }
            if (!hex.ToString().Equals(IssuerSerialSecond))
            {
                return("hodnota ds:X509SerialNumber sa nezhoduje s príslušnou hodnotou v certifikáte");
            }



            //check ds:SignatureProperties Id
            if (ElementSignatureProperties.Attributes["Id"] == null)
            {
                return("element ds:SignatureProperties nema atribut Id");
            }
            //check ds:SignatureProperties numbers of elements
            XmlNodeList elemListSignatureProperties = ElementSignatureProperties.ChildNodes;

            if (elemListSignatureProperties.Count < 2)
            {
                return("ds:SignatureProperties neobsahuje dva elementy");
            }
            //check ds:SignatureProperties elements
            for (int i = 0; i < elemListSignatureProperties.Count; i++)
            {
                if (elemListSignatureProperties[i].FirstChild.Name.Equals("xzep:SignatureVersion") ||
                    elemListSignatureProperties[i].FirstChild.Name.Equals("xzep:ProductInfos"))
                {
                    String tmpTargetValue = elemListSignatureProperties[i].Attributes["Target"].Value;
                    tmpTargetValue = tmpTargetValue.Substring(1);
                    if (!tmpTargetValue.Equals(dsSignatureId.Value))
                    {
                        return("atribút Target v elemente ds:SignatureProperty nie je nastavený na element ds:Signature");
                    }
                }
            }



            //check Manifest and Manifest references
            String ManifestReferenceUri  = "";
            String algorithmDigestMethod = "";
            String algorithmTransforms   = "";
            String digestValue           = "";
            bool   flag1 = false;



            for (int i = 0; i < ElementManifest.Count; i++)
            {
                //check ds:Manifest Id
                if (ElementManifest[i].Attributes["Id"] == null)
                {
                    return("jeden z elementov ds:Manifest nemá atribút Id");
                }
                //check number of reference, ds:Object
                XmlNodeList ManifestChildNodes = ElementManifest[i].ChildNodes;
                if (ManifestChildNodes.Count > 1 || ManifestChildNodes.Count < 1)
                {
                    return("ds:Manifest neobsahuje práve jedenu referenciu");
                }
                if (!ManifestChildNodes[0].Attributes["Type"].Value.Contains("Object"))
                {
                    return("nezhoduje sa Type v ds:Manifest");
                }
                //check value attribute Type
                if (ManifestChildNodes[0].Attributes["Type"].Value.Equals("http://www.w3.org/2000/09/xmldsig#Object"))
                {
                    //check supported ds:Transforms and ds:DigestMethod
                    XmlNodeList ReferenceElementsChild = ManifestChildNodes[0].ChildNodes;
                    for (int l = 0; l < ReferenceElementsChild.Count; l++)
                    {
                        if (ReferenceElementsChild[l].Name.Equals("ds:Transforms"))
                        {
                            algorithmTransforms = ReferenceElementsChild[l].FirstChild.Attributes["Algorithm"].Value;
                            if (!SUPPORTED_TRANSFORMS.Contains(algorithmTransforms))
                            {
                                return("ds:Transforms neobsahuje podporovaný algoritmus pre daný element podľa profilu XAdES_ZEP");
                            }
                        }
                        if (ReferenceElementsChild[l].Name.Equals("ds:DigestMethod"))
                        {
                            algorithmDigestMethod = ReferenceElementsChild[l].Attributes["Algorithm"].Value;
                            if (!SUPPORTED_DIGEST_METHOD.Contains(algorithmDigestMethod))
                            {
                                return("ds:DigestMethod neobsahuje podporovaný algoritmus pre daný element podľa profilu XAdES_ZEP");
                            }
                        }
                        if (ReferenceElementsChild[l].Name.Equals("ds:DigestValue"))
                        {
                            digestValue = ReferenceElementsChild[l].InnerText;
                        }
                    }
                    ManifestReferenceUri = ManifestChildNodes[0].Attributes["URI"].Value;
                    ManifestReferenceUri = ManifestReferenceUri.Substring(1);

                    //check values ds:Manifest and ds:Object
                    XmlNodeList ObjectElement = xades.SelectNodes("//ds:Object", namespaceId);
                    for (int j = 0; j < ObjectElement.Count; j++)
                    {
                        if (ObjectElement[j].Attributes["Id"] == null)
                        {
                            continue;
                        }
                        if (ObjectElement[j].Attributes["Id"].Value.Equals(ManifestReferenceUri))
                        {
                            flag1 = true;

                            XmlDsigC14NTransform t     = new XmlDsigC14NTransform();
                            XmlDocument          myDoc = new XmlDocument();
                            myDoc.LoadXml(ObjectElement[i].OuterXml);
                            t.LoadInput(myDoc);
                            Stream s = (Stream)t.GetOutput(typeof(Stream));
                            byte[] hash;
                            string base64String = "";
                            switch (algorithmDigestMethod)
                            {
                            case "http://www.w3.org/2001/04/xmldsig#sha1":
                                SHA1 sha1 = SHA1.Create();
                                hash         = sha1.ComputeHash(s);
                                base64String = Convert.ToBase64String(hash);
                                break;

                            case "http://www.w3.org/2001/04/xmlenc#sha256":
                                SHA256 sha256 = SHA256.Create();
                                hash         = sha256.ComputeHash(s);
                                base64String = Convert.ToBase64String(hash);
                                break;

                            case "http://www.w3.org/2001/04/xmldsig-more#sha384":
                                SHA384 sha384 = SHA384.Create();
                                hash         = sha384.ComputeHash(s);
                                base64String = Convert.ToBase64String(hash);
                                break;

                            case "http://www.w3.org/2001/04/xmlenc#sha512":
                                SHA512 sha512 = SHA512.Create();
                                hash         = sha512.ComputeHash(s);
                                base64String = Convert.ToBase64String(hash);
                                break;
                            }
                            Console.WriteLine("-");
                            Console.WriteLine("Overenie hodnoty ds:DigestValue");
                            Console.WriteLine("First " + base64String);
                            Console.WriteLine("Second " + digestValue);
                            Console.WriteLine("-");
                        }
                    }
                    if (!flag1)
                    {
                        return("odkaz z ds:Manifest na ds:Object sa nezhoduje");
                    }
                    flag1 = false;
                }
                else
                {
                    return("ds:Reference, hodnota atribútu Type sa neoverila voči profilu XADES_ZEP");
                }
            }


            return("OK");
        }