How to Encrypt Windows Identity value?

Question

I'm using

 x = System.Security.Principal.WindowsIdentity.GetCurrent().User.Value;

which outputs the users windows identity. Here is an example of what the output looks like:

S-5-2-51-37518325-1542148351-9136563645-5621

I'm currently sending this to a .txt file and reading it but as you can probably tell anyone with a bit of experience can access the text file so how would I scramble these values to the point they are no longer able get traced back to their original numbers.

Answer 1

I use this class:

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

public class Crypto
{
    private static readonly byte[] Salt =
        { 0x26, 0xdc, 0xff, 0x00, 0xad, 0xed, 0x7a, 0xee, 0xc5, 0xfe, 0x07, 0xaf, 0x4d, 0x08, 0x22, 0x3c };

    /// <summary>
    /// Cifra una cadena texto con el algoritmo de Rijndael.
    /// </summary>
    /// <param name="text">Texto a cifrar.</param>
    /// <param name="password">Clave de cifrado</param>
    /// <returns>Texto cifrado.</returns>
    public static string Encrypt(string text, string password)
    {
        using (var rijndael = RijndaelCreate(password))
        using (var memoryStream = new MemoryStream())
        using (var cryptoStream = new CryptoStream(memoryStream, rijndael.CreateEncryptor(), CryptoStreamMode.Write))
        {
            // Obtener la representación en bytes de la información a cifrar
            var plainMessageBytes = UTF8Encoding.UTF8.GetBytes(text);

            // Cifrar los datos enviándolos al flujo de cifrado
            cryptoStream.Write(plainMessageBytes, 0, plainMessageBytes.Length);
            cryptoStream.FlushFinalBlock();

            // Obtener los datos datos cifrados como bytes
            var cipherMessageBytes = memoryStream.ToArray();
            return Convert.ToBase64String(cipherMessageBytes);
        }
    }

    /// <summary>
    /// Cifra una cadena texto con el algoritmo de Rijndael.
    /// </summary>
    /// <param name="text">Texto a cifrar.</param>
    /// <param name="key">Clave del cifrado para Rijndael</param>
    /// <param name="iv">Vector de inicio para Rijndael</param>
    /// <returns>Texto cifrado.</returns>
    public static string Encrypt(string text, byte[] key, byte[] iv)
    {
        using (var rijndael = RijndaelCreate())
        using (var memoryStream = new MemoryStream())
        using (var cryptoStream = new CryptoStream(memoryStream, rijndael.CreateEncryptor(key, iv), CryptoStreamMode.Write))
        {
            // Obtener la representación en bytes de la información a cifrar
            var plainMessageBytes = UTF8Encoding.UTF8.GetBytes(text);

            // Cifrar los datos enviándolos al flujo de cifrado
            cryptoStream.Write(plainMessageBytes, 0, plainMessageBytes.Length);
            cryptoStream.FlushFinalBlock();

            // Obtener los datos datos cifrados como bytes
            var cipherMessageBytes = memoryStream.ToArray();
            return Convert.ToBase64String(cipherMessageBytes);
        }
    }

    /// <summary>
    /// Descifra una cadena texto con el algoritmo de Rijndael.
    /// </summary>
    /// <param name="encrypted">Mensaje cifrado.</param>
    /// <param name="password">Clave de cifrado</param>
    /// <returns>Texto descifrado.</returns>
    public static string Decrypt(string encrypted, string password)
    {
        var cipherTextBytes = Convert.FromBase64String(encrypted);

        using (var rijndael = RijndaelCreate(password))
        using (var memoryStream = new MemoryStream(cipherTextBytes))
        using (var cryptoStream = new CryptoStream(memoryStream, rijndael.CreateDecryptor(), CryptoStreamMode.Read))
        {
            var plainTextBytes = new byte[cipherTextBytes.Length];
            var decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
            return Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);
        }
    }

    /// <summary>
    /// Descifra una cadena texto con el algoritmo de Rijndael.
    /// </summary>
    /// <param name="encrypted">Mensaje cifrado.</param>
    /// <param name="key">Clave del cifrado para Rijndael</param>
    /// <param name="iv">Vector de inicio para Rijndael</param>
    /// <returns>Texto descifrado.</returns>
    public static string Decrypt(string encrypted, byte[] key, byte[] iv)
    {
        var cipherTextBytes = Convert.FromBase64String(encrypted);

        using (var rijndael = RijndaelCreate())
        using (var memoryStream = new MemoryStream(cipherTextBytes))
        using (var cryptoStream = new CryptoStream(memoryStream, rijndael.CreateDecryptor(key, iv), CryptoStreamMode.Read))
        {
            var plainTextBytes = new byte[cipherTextBytes.Length];
            var decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
            return Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);
        }
    }

    /// <summary>
    /// Cifra una cadena texto con el algoritmo de Rijndael y lo almacena en un archivo.
    /// </summary>
    /// <param name="text">Texto a cifrar.</param>
    /// <param name="filename">Ruta al archivo.</param>
    /// <param name="key">Clave del cifrado para Rijndael</param>
    /// <param name="iv">Vector de inicio para Rijndael</param>
    public static void EncryptToFile(string text, string filename, byte[] key, byte[] iv)
    {
        using (var rijndael = RijndaelCreate())
        using (var fileStream = File.Open(filename, FileMode.OpenOrCreate))
        using (var cryptoStream = new CryptoStream(fileStream, rijndael.CreateEncryptor(key, iv), CryptoStreamMode.Write))
        using (StreamWriter streamWriter = new StreamWriter(cryptoStream))
        {
            streamWriter.WriteLine(text);
        }
    }

    /// <summary>
    /// Cifra una cadena texto con el algoritmo de Rijndael y lo almacena en un archivo.
    /// </summary>
    /// <param name="text">Texto a cifrar.</param>
    /// <param name="filename">Ruta al archivo.</param>
    /// <param name="password">Clave de cifrado</param>
    public static void EncryptToFile(string text, string filename, string password)
    {
        using (var rijndael = RijndaelCreate(password))
        using (var fileStream = File.Open(filename, FileMode.OpenOrCreate))
        using (var cryptoStream = new CryptoStream(fileStream, rijndael.CreateEncryptor(), CryptoStreamMode.Write))
        using (StreamWriter streamWriter = new StreamWriter(cryptoStream))
        {
            streamWriter.WriteLine(text);
        }
    }

    /// <summary>
    /// Descifra el contenido de un archivo con el algoritmo de Rijndael y lo retorna como una 
    /// cadena de texto plano.
    /// </summary>
    /// <param name="filename">Ruta al archivo.</param>
    /// <param name="key">Clave del cifrado para Rijndael</param>
    /// <param name="iv">Vector de inicio para Rijndael</param>
    /// <returns>Texto descifrado.</returns>
    public static string DecryptFromFile(string filename, byte[] key, byte[] iv)
    {
        using (var rijndael = RijndaelCreate())
        using (var fileStream = File.Open(filename, FileMode.OpenOrCreate))
        using (var cryptoStream = new CryptoStream(fileStream, rijndael.CreateDecryptor(key, iv), CryptoStreamMode.Read))
        using (var streamReader = new StreamReader(cryptoStream))
        {
            return streamReader.ReadLine();
        }
    }

    /// <summary>
    /// Descifra el contenido de un archivo con el algoritmo de Rijndael y lo retorna como una 
    /// cadena de texto plano.
    /// </summary>
    /// <param name="filename">Ruta al archivo.</param>
    /// <param name="password">Clave de cifrado</param>
    /// <returns>Texto descifrado.</returns>
    public static string DecryptFromFile(string filename, string password)
    {
        using (var rijndael = RijndaelCreate(password))
        using (var fileStream = File.Open(filename, FileMode.OpenOrCreate))
        using (var cryptoStream = new CryptoStream(fileStream, rijndael.CreateDecryptor(), CryptoStreamMode.Read))
        using (var streamReader = new StreamReader(cryptoStream))
        {
            return streamReader.ReadLine();
        }
    }

    private static RijndaelManaged RijndaelCreate(string password = null)
    {
        var rijndael = new RijndaelManaged();

        if (!string.IsNullOrEmpty(password))
        {
            Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(password, Salt);
            rijndael.Key = pdb.GetBytes(32);
            rijndael.IV = pdb.GetBytes(16);
        }

        return rijndael;
    }
}

Example:

var textToEncrypt = "Some content to encrypt";
var encoded = Crypto.Encrypt(textToEncrypt, "Some-Key-To-Encrypt");
var decoded = Crypto.Decrypt(encoded, "Some-Key-To-Encrypt")

Answer 2

My solution:

Create two strings first called:

 string HWID;
 string encodedData = String.Empty;

Then make your "HWID" equal some form of windows hardware/identity.

 HWID = System.Security.Principal.WindowsIdentity.GetCurrent().User.Value;
       

Underneath it you will want to encrypt using this:

 byte[] data_byte = Encoding.UTF8.GetBytes(HWID);
            encodedData = HttpUtility.UrlEncode(Convert.ToBase64String(data_byte));

And to see your if it worked just type:

Console.WriteLine(encodedData);

Please let me know if there is any ways that are either more efficient or not risk exposure? thanks :)