XMLHASH-TEST | C# Online Compiler

XMLHASH-TEST by George

using System;
using System.Linq;
using System.Xml.Linq;
using System.Xml;
using System.Text;
using System.Security.Cryptography;

					
public class Program
{
	public void Main()
	{
		// params: { pCode: '123', pName: 'Michael', pUniqueIdentifier: '1234', pAmount: '10' }

		var result = createXmlRequest("123", "Michael", "1234", "10");
        var query = result.Descendants().Where(x => x.Name.LocalName == "InitiateAsyncTransaction_Request");

		string xml = string.Empty;
		foreach (var xElem in query)
		{
			Console.WriteLine("Number of elements:{0}", query.Count());
			//Console.WriteLine(xElem.ToString());
			xml = xElem.ToString();
		}

		string hashKey = Hash.GetHash(xml, HashType.SHA256);
		Console.WriteLine("Hashkey:{0}", hashKey);
		Console.WriteLine();
		Console.WriteLine(xml);
	}
	
	private XElement createXmlRequest(string pCode, string pName, string pUniqueIdentifier, string pAmount)
    {
            XNamespace ns = "http://schema.inteliscape.com/message/v1";
            XNamespace ns1 = "http://schema.inteliscape.com/paymentengine/integration/v1";
            XNamespace ns2 = "http://schema.inteliscape.com/common/v1";
            XNamespace xsi = "http://www.w3.org/2001/XMLSchema-instance";

            XElement message =
                new XElement(ns + "Message",
                    new XAttribute(XNamespace.Xmlns + "xsi", "http://www.w3.org/2001/XMLSchema-instance"),
                    new XAttribute(XNamespace.Xmlns + "xsd", "http://www.w3.org/2001/XMLSchema"),
                    new XAttribute("xmlns", "http://schema.inteliscape.com/message/v1"),

                    new XElement(ns + "Version", 1),
                    new XElement(ns + "Header",
                        new XElement(ns + "Details",
                            new XElement(ns + "Source", "CeGG.Demo.PaymentEngine.Client"),
                            new XElement(ns + "Destination", "PaymentEngine"),
                            new XElement(ns + "Command", "PE_InitiateAsyncTransaction"),
                            new XElement(ns + "Qualifier", "Request")
                            ),
                        new XElement(ns + "Sender",
                            new XElement(ns + "SenderId", "DEMO-DITS-PE"),
                            new XElement(ns + "Authentication",
                // TODO: NEED TO FIND OUT HOW TO ENCRYPT THE "<Body>...</Body>" USING "SHA256" AUTHENTICATION METHOD.Hashing:
                // TODO: HASHING: SenderID + Shared Secret + Command Type + Body: 
                // TODO: EXAMPLE: DEMO-DITS-PEqwertyPE_InitiateAsyncTransaction<InitiateAsyncTransaction><data></data></InitiateAsyncTransaction>
                                new XElement(ns + "Method", "SHA256"),
                                new XElement(ns + "Value", "7LnPeLEnFgCZ0ml1+gytc6CtAwzm4p6VCvqCz0r4JjU="), 
                                new XElement(ns + "HashMode", "Advance")
                                )
                            )
                        ),
                    new XElement(ns + "Errors"),
                    new XElement(ns + "Body",
                        new XElement(ns1 + "InitiateAsyncTransaction_Request",
                            new XAttribute(XNamespace.Xmlns + "xsi", "http://www.w3.org/2001/XMLSchema-instance"),
                            new XAttribute(XNamespace.Xmlns + "xsd", "http://www.w3.org/2001/XMLSchema"),
                            new XAttribute("xmlns", "http://schema.inteliscape.com/paymentengine/integration/v1"),

                            new XElement(ns1 + "CreateToken", false),
                            new XElement(ns1 + "Info",
                                new XElement(ns1 + "Citizen",
                                    new XElement(ns1 + "Individual",
                                        new XElement(ns2 + "Code", pCode), // "123"
                                        new XElement(ns2 + "Name", pName), // "Michael"
                                        new XElement(ns2 + "UniqueIdentifier", pUniqueIdentifier) // "1234"
                                        )
                                    ),
                                new XElement(ns1 + "Representative", new XAttribute(xsi + "nil", true)),
                                new XElement(ns1 + "PaymentMethodCode", "PM-0005"),
                                new XElement(ns1 + "Amount", pAmount), // "10"
                                new XElement(ns1 + "CurrencyIsoAlphaCode", "EUR"),
                                new XElement(ns1 + "LanguageCode", "en"),
                                new XElement(ns1 + "ClientTransactionNo", "262c1a20-0f07-45e3-827c-c50d26aa02ee"),
                                new XElement(ns1 + "IpAddress", "127.0.0.1")
                                )
                            )
                        )
                    );

            //Console.WriteLine(message);

            return message;
    }
}

public enum HashType
{
	MD5,
	SHA1,
	SHA256,
	SHA512
}

public class Hash
{
        public static string GetHash(string text, HashType hashType)
        {
            string hashString;
            switch (hashType)
            {
                case HashType.MD5:
                    hashString = GetMD5(text);
                    break;
                case HashType.SHA1:
                    hashString = GetSHA1(text);
                    break;
                case HashType.SHA256:
                    hashString = GetSHA256(text);
                    break;
                case HashType.SHA512:
                    hashString = GetSHA512(text);
                    break;
                default:
                    hashString = "Invalid Hash Type";
                    break;
            }
            return hashString;
        }

        public static bool CheckHash(string original, string hashString, HashType hashType)
        {
            string originalHash = GetHash(original, hashType);
            return (originalHash == hashString);
        }

        private static string GetMD5(string text)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] hashValue;
            byte[] message = UE.GetBytes(text);

            MD5 hashString = new MD5CryptoServiceProvider();
            string hex = "";

            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }

        private static string GetSHA1(string text)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] hashValue;
            byte[] message = UE.GetBytes(text);

            SHA1Managed hashString = new SHA1Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }

        private static string GetSHA256(string text)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] hashValue;
            byte[] message = UE.GetBytes(text);

            SHA256Managed hashString = new SHA256Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }

        private static string GetSHA512(string text)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] hashValue;
            byte[] message = UE.GetBytes(text);

            SHA512Managed hashString = new SHA512Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
}

​x
 
using System;
using System.Linq;
using System.Xml.Linq;
using System.Xml;
using System.Text;
using System.Security.Cryptography;
​
                    
public class Program
{
    public void Main()
    {
        // params: { pCode: '123', pName: 'Michael', pUniqueIdentifier: '1234', pAmount: '10' }
​
        var result = createXmlRequest("123", "Michael", "1234", "10");
        var query = result.Descendants().Where(x => x.Name.LocalName == "InitiateAsyncTransaction_Request");
​
        string xml = string.Empty;
        foreach (var xElem in query)
        {
            Console.WriteLine("Number of elements:{0}", query.Count());
            //Console.WriteLine(xElem.ToString());
            xml = xElem.ToString();
        }
​
        string hashKey = Hash.GetHash(xml, HashType.SHA256);
        Console.WriteLine("Hashkey:{0}", hashKey);
        Console.WriteLine();
        Console.WriteLine(xml);
    }
    
    private XElement createXmlRequest(string pCode, string pName, string pUniqueIdentifier, string pAmount)
    {
            XNamespace ns = "http://schema.inteliscape.com/message/v1";
            XNamespace ns1 = "http://schema.inteliscape.com/paymentengine/integration/v1";
            XNamespace ns2 = "http://schema.inteliscape.com/common/v1";
            XNamespace xsi = "http://www.w3.org/2001/XMLSchema-instance";
​
            XElement message =
                new XElement(ns + "Message",
                    new XAttribute(XNamespace.Xmlns + "xsi", "http://www.w3.org/2001/XMLSchema-instance"),
                    new XAttribute(XNamespace.Xmlns + "xsd", "http://www.w3.org/2001/XMLSchema"),
                    new XAttribute("xmlns", "http://schema.inteliscape.com/message/v1"),
​
                    new XElement(ns + "Version", 1),
                    new XElement(ns + "Header",
                        new XElement(ns + "Details",
                            new XElement(ns + "Source", "CeGG.Demo.PaymentEngine.Client"),
                            new XElement(ns + "Destination", "PaymentEngine"),
                            new XElement(ns + "Command", "PE_InitiateAsyncTransaction"),
                            new XElement(ns + "Qualifier", "Request")
                            ),
                        new XElement(ns + "Sender",
                            new XElement(ns + "SenderId", "DEMO-DITS-PE"),
                            new XElement(ns + "Authentication",
                // TODO: NEED TO FIND OUT HOW TO ENCRYPT THE "<Body>...</Body>" USING "SHA256" AUTHENTICATION METHOD.Hashing:
                // TODO: HASHING: SenderID + Shared Secret + Command Type + Body: 
                // TODO: EXAMPLE: DEMO-DITS-PEqwertyPE_InitiateAsyncTransaction<InitiateAsyncTransaction><data></data></InitiateAsyncTransaction>
                                new XElement(ns + "Method", "SHA256"),
                                new XElement(ns + "Value", "7LnPeLEnFgCZ0ml1+gytc6CtAwzm4p6VCvqCz0r4JjU="), 
                                new XElement(ns + "HashMode", "Advance")
                                )
                            )
                        ),
                    new XElement(ns + "Errors"),
                    new XElement(ns + "Body",
                        new XElement(ns1 + "InitiateAsyncTransaction_Request",
                            new XAttribute(XNamespace.Xmlns + "xsi", "http://www.w3.org/2001/XMLSchema-instance"),
                            new XAttribute(XNamespace.Xmlns + "xsd", "http://www.w3.org/2001/XMLSchema"),
                            new XAttribute("xmlns", "http://schema.inteliscape.com/paymentengine/integration/v1"),
​
                            new XElement(ns1 + "CreateToken", false),
                            new XElement(ns1 + "Info",
                                new XElement(ns1 + "Citizen",
                                    new XElement(ns1 + "Individual",
                                        new XElement(ns2 + "Code", pCode), // "123"
                                        new XElement(ns2 + "Name", pName), // "Michael"
                                        new XElement(ns2 + "UniqueIdentifier", pUniqueIdentifier) // "1234"
                                        )
                                    ),
                                new XElement(ns1 + "Representative", new XAttribute(xsi + "nil", true)),
                                new XElement(ns1 + "PaymentMethodCode", "PM-0005"),
                                new XElement(ns1 + "Amount", pAmount), // "10"
                                new XElement(ns1 + "CurrencyIsoAlphaCode", "EUR"),
                                new XElement(ns1 + "LanguageCode", "en"),
                                new XElement(ns1 + "ClientTransactionNo", "262c1a20-0f07-45e3-827c-c50d26aa02ee"),
                                new XElement(ns1 + "IpAddress", "127.0.0.1")
                                )
                            )
                        )
                    );
​
            //Console.WriteLine(message);
​
            return message;
    }
}
​
public enum HashType
{
    MD5,
    SHA1,
    SHA256,
    SHA512
}
​
public class Hash
{
        public static string GetHash(string text, HashType hashType)
        {
            string hashString;
            switch (hashType)
            {
                case HashType.MD5:
                    hashString = GetMD5(text);
                    break;
                case HashType.SHA1:
                    hashString = GetSHA1(text);
                    break;
                case HashType.SHA256:
                    hashString = GetSHA256(text);
                    break;
                case HashType.SHA512:
                    hashString = GetSHA512(text);
                    break;
                default:
                    hashString = "Invalid Hash Type";
                    break;
            }
            return hashString;
        }
​
        public static bool CheckHash(string original, string hashString, HashType hashType)
        {
            string originalHash = GetHash(original, hashType);
            return (originalHash == hashString);
        }
​
        private static string GetMD5(string text)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] hashValue;
            byte[] message = UE.GetBytes(text);
​
            MD5 hashString = new MD5CryptoServiceProvider();
            string hex = "";
​
            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
​
        private static string GetSHA1(string text)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] hashValue;
            byte[] message = UE.GetBytes(text);
​
            SHA1Managed hashString = new SHA1Managed();
            string hex = "";
​
            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
​
        private static string GetSHA256(string text)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] hashValue;
            byte[] message = UE.GetBytes(text);
​
            SHA256Managed hashString = new SHA256Managed();
            string hex = "";
​
            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
​
        private static string GetSHA512(string text)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] hashValue;
            byte[] message = UE.GetBytes(text);
​
            SHA512Managed hashString = new SHA512Managed();
            string hex = "";
​
            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
}
​

View IL Code