Hice un programa que lo ejemplifica (pongo todo le código al final), pero como dijo Jack el Destripador, vámonos por partes.
Al principio debo importar la librería System.Security.Cryptography para que todo esto funcione. Por eso al principio del programa lo incluyo con el using:
using System.Security.Cryptography;
Pero esto no basta para que funcione. Para que tu programa pueda hacer uso de las clases y objetos de esta librería, se tiene que incluir al proyecto una referencia al framework que contiene lo de seguridad. En su proyecto, hagan clic derecho en la ventana de su solución donde dice referencias, como se ve en esta imagen:
Del menú contextual que aparece, seleccionen Agregar referencia... y aparece una ventana con todas las referencias, que por default están apareciendo las referencias de NET Framework. Allí pon una tache en la que dice System.Security como se ve en la siguiente imagen:
El método encriptar toma una cadena (textoNormal) y un arreglo de bytes opcional (entropia) para agregar aleatoriedad al proceso de encriptación. Convierte el texto a bytes y utiliza el método ProtectedData.Protect para encriptar los datos. El resultado es un arreglo de bytes que representa el texto encriptado. Éste es el código simplificado:
snippetfile1.txt
560 B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/// <summary>
/// Función que encripta un texto
/// </summary>
/// <param name="textoNormal">cadena que se desea encriptar</param>
/// <param name="entropia">arreglo de bytes que añaden aleatoriedad a la función</param>
/// <returns></returns>
public static byte[] encriptar(string textoNormal, byte[] entropia = null)
{
// Creo arreglo de bytes del texto normal
byte[] bytesNormal = Encoding.UTF8.GetBytes(textoNormal);
// Devuelvo el texto encriptado
return ProtectedData.Protect(bytesNormal, entropia, DataProtectionScope.CurrentUser);
}El método desecriptar toma un arreglo de bytes (bytesEncriptados) y un arreglo de bytes opcional (entropia). Desencripta los datos utilizando el método ProtectedData.Unprotect y convierte los bytes resultantes de nuevo a una cadena utilizando la codificación UTF-8.
snippetfile1.txt
783 B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/// <summary>
/// Desencripta un arreglo de bytes que han sido encriptados
/// </summary>
/// <param name="bytesEncriptados">bytes de datos encriptados</param>
/// <param name="entropia">arreglo de bytes que añaden aleatoriedad a la función</param>
/// <returns>cadena con el texto original</returns>
public static string desencriptar(byte[] bytesEncriptados, byte[] entropia = null)
{
// Desencripto el arreglo de bytes y lo almaceno en otro
byte[] bytesNormales = ProtectedData.Unprotect(bytesEncriptados, entropia,
DataProtectionScope.CurrentUser);
// Devuelvo el arreglo convertido a cadena
return Encoding.UTF8.GetString(bytesNormales);
}Y hacer clic en el botón solo agarra el texto que está en la caja de texto, lo encripte, muestra el arreglo de bytes encriptados en una etiqueta, desencripta el arreglo de bytes y muestra el resultado en otra etiqueta.
Pero antes de mostrar el código, ¿qué hace ProtectedData.Protect? Ésta función permite tomar información y convertirla en una forma que es difícil de entender para cualquier persona que no tenga la clave adecuada para descifrarla.
Al usarlo le proporcionas la información que deseas cifrar (por ejemplo, una contraseña) y, opcionalmente, también puedes proporcionar algo llamado "entropía". La entropía es como agregar un toque adicional de aleatoriedad para hacer que el cifrado sea aún más seguro. Y la función devuelve los datos cifrados, que luego puedes almacenar de forma segura en tu aplicación o base de datos.
Y ProtectedData.Unprotect es una función en C# que hace el proceso inverso de lo que hace ProtectedData.Protect. Es decir, toma datos cifrados (información que ha sido previamente encriptada) y los descifra para devolverlos a su forma original o legible.
Ahora sí, aquí va el código completo:
Form1.cs
2.66 KiB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Security.Cryptography;
using System.Collections;
using System.Security.Cryptography.Xml;
namespace Encripcion
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void btnSalir_Click(object sender, EventArgs e)
{
Application.Exit();
}
/// <summary>
/// Función que encripta un texto
/// </summary>
/// <param name="textoNormal">cadena que se desea encriptar</param>
/// <param name="entropia">arreglo de bytes que añaden aleatoriedad a la función</param>
/// <returns></returns>
public static byte[] encriptar(string textoNormal, byte[] entropia = null)
{
// Creo arreglo de bytes del texto normal
byte[] bytesNormal = Encoding.UTF8.GetBytes(textoNormal);
// Devuelvo el texto encriptado
return ProtectedData.Protect(bytesNormal, entropia, DataProtectionScope.CurrentUser);
}
/// <summary>
/// Desencripta un arreglo de bytes que han sido encriptados
/// </summary>
/// <param name="bytesEncriptados">bytes de datos encriptados</param>
/// <param name="entropia">arreglo de bytes que añaden aleatoriedad a la función</param>
/// <returns>cadena con el texto original</returns>
public static string desencriptar(byte[] bytesEncriptados, byte[] entropia = null)
{
// Desencripto el arreglo de bytes y lo almaceno en otro
byte[] bytesNormales = ProtectedData.Unprotect(bytesEncriptados, entropia,
DataProtectionScope.CurrentUser);
// Devuelvo el arreglo convertido a cadena
return Encoding.UTF8.GetString(bytesNormales);
}
private void btnEncriptar_Click(object sender, EventArgs e)
{
// Éste es el texto a encriptar
string textoOriginal = txtTextoOrig.Text;
// Obtengo el arreglo de bytes encriptados
byte[] resultadoEncriptado = encriptar(textoOriginal);
// Muestro los bytes encriptados
lblEncript.Text = "";
for (int i=0;i < resultadoEncriptado.Length; i++)
{
lblEncript.Text = lblEncript.Text + " " + resultadoEncriptado[i];
}
// Desecripto los datos y los pongo en la etiqueta
lblNormal.Text = desencriptar(resultadoEncriptado);
}
}
}Espero que les haya sido de utilidad. ¡Saludos!
P.D. La imagen de encripción al principio del post fue tomada de este sitio: https://www.pcworld.com/article/540005/what-is-encryption.html
