Creating a SHA hash and salt and the bytes have strange characters in them

Question

I have been working on some cryptography and I need to create a new SHA-2 (sha256) system in which I generate new salt and hash , so the hash will be based upon the user typed password + newly created salt as I understand it. However, as I have downloaded a sample project, of all the sha-1 and sha-2 code that I have played around with, i have never seen the chinese symbols and so I'm a little concerned and confused

This is the code ,

    // utilty function to convert byte[] to string        
    public static string GetString(byte[] bytes)
    {
        char[] chars = new char[bytes.Length / sizeof(char)];
        System.Buffer.BlockCopy(bytes, 0, chars, 0, bytes.Length);
        return new string(chars);
    }

incoming bytes do not have any strange characters so what is causing them?

screenshot

bytes parameter is byte[24] .... [0] = 20 , 1 = 101 etc.. just normal looking. So it seems to be occurring on this line System.Buffer.BlockCopy(bytes, 0, chars, 0, bytes.Length);

Answer 1

You just found some unicode characters. I far more often see--instead of unicode--UTF8 used, as so:

var toString = System.Text.Encoding.UTF8.GetString(yourByteArray);
var backToBytes = System.Text.Encoding.UTF8.GetBytes(toString);

EDIT

Here's an example console program that uses the AES encryption/decryption wrapper I coded after scouring the web for best-practice examples.

namespace Sandbox
{
    class Program
    {
        static void Main(string[] args)
        {
            var originString = "This is some example text";

            var originBytes = System.Text.Encoding.UTF8.GetBytes(originString);

            var aes = new AesCryptoServiceProvider {KeySize = 256};
            aes.GenerateIV();
            aes.GenerateKey();
            var vectorBytes = aes.IV;
            var keyBytes = aes.Key;

            //Not going to use these in the code, but here's how to get the values if you
            //Want to save them off.
            var vectorString = System.Text.Encoding.UTF8.GetString(vectorBytes);
            var keyString = System.Text.Encoding.UTF8.GetString(keyBytes);

            var encryptedBytes = EncryptionService.Encrypt(keyBytes, vectorBytes, originBytes);

            var encyptedString = System.Text.Encoding.UTF8.GetString(encryptedBytes);

            var decryptedBytes = EncryptionService.Decrypt(keyBytes, vectorBytes, encryptedBytes);

            var decryptedString = System.Text.Encoding.UTF8.GetString(decryptedBytes);

            Console.WriteLine($"Origin:\t\t {originString}");
            Console.WriteLine($"Vector:\t\t {vectorString}");
            Console.WriteLine($"Key:\t\t {keyString}");
            Console.WriteLine($"Encrypted:\t {encyptedString}");
            Console.WriteLine($"Decrypted:\t {decryptedString}");

            Console.ReadLine();

        }
    }

    public static class EncryptionService
    {
        public static byte[] Encrypt(byte[] key, byte[] vector, byte[] input)
        {
            if (key.Length == 0)
                throw new ArgumentException("Cannot encrypt with empty key");

            if (vector.Length == 0)
                throw new ArgumentException("Cannot encrypt with empty vector");

            if (input.Length == 0)
                throw new ArgumentException("Cannot encrypt empty input");

            var unencryptedBytes = input;

            using (AesCryptoServiceProvider aes = new AesCryptoServiceProvider { Key = key, IV = vector })
            using (ICryptoTransform encryptor = aes.CreateEncryptor())
            using (MemoryStream ms = new MemoryStream())
            using (CryptoStream writer = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
            {
                writer.Write(unencryptedBytes, 0, unencryptedBytes.Length);
                writer.FlushFinalBlock();
                var byteArray = ms.ToArray();

                if (byteArray.Length == 0)
                    throw new Exception("Attempted to encrypt but encryption resulted in a byte array of 0 length.");

                return byteArray;
            }
        }


        public static byte[] Decrypt(byte[] key, byte[] vector, byte[] encrypted)
        {
            if (key.Length == 0)
                throw new ArgumentException("Cannot encrypt with empty key");

            if (vector.Length == 0)
                throw new ArgumentException("Cannot encrypt with empty vector");

            if (encrypted == null || encrypted.Length == 0)
                throw new ArgumentException("Cannot decrypt empty or null byte array");

            byte[] unencrypted;

            using (AesCryptoServiceProvider aes = new AesCryptoServiceProvider { Key = key, IV = vector })
            using (ICryptoTransform decryptor = aes.CreateDecryptor(key, vector))
            using (MemoryStream ms = new MemoryStream(encrypted))
            using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
            {
                var decrypted = new byte[encrypted.Length];
                var bytesRead = cs.Read(decrypted, 0, encrypted.Length);

                return decrypted.Take(bytesRead).ToArray();
            }

        }
    }
}