Buenas gente:

Hice un ejemplo con este código.

using System;
 
namespace Encriptar_variable_Consola_01
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Title = "Ocultar variable"; // Título de la pantalla.
 
            string variable = "Esto es una prueba.";
 
            Console.WriteLine(variable);
            Console.WriteLine("Otra prueba.");
 
            Console.ReadKey(); // Pulse cualquier tecla para salir.
        }
    }
}

Mirando el ejecutable en el editor hexadecimal. Si encuentra los valores de las variables como indica la captura.


Uso Visual Studio 2017 Community. No quiero usar técnica de obfuscación, no se si esta versión la incluye. Quiero saber si existe la manera de camuflar esas variables.

Mi idea era usar algo parecido a esto en XOR ^10 con otro programa que haré a parte.

    for (int i = 0; i < variable.Length; i++)
    {
        variable[i] = (byte)(variable[i] ^ 10);
    }

El código de ejemplo de una variable tipo array desordenarlo.

Luego copio y pego el resultado ya codificado en la variable que es el que estoy usando ahora. En este caso uso una variable tipo string.

Tengo que hacer de alguna manera, al ejecutar el programa, lea las variables codificadas y las vuelva a poner bien para que se lea en cristiano, luego lo guarda en otra variable y Console.WriteLine lo muestra.

Espero que se entienda lo que quiero decir o lo explico de otra manera.

¿Alguna ocurrencia?

Saludos.

Hola:

Es exactamente lo que explicó nuestro amigo forero aquí, pero en vez de un array, un string que no se como se hace.

https://foro.elhacker.net/net/modificar_el_array_de_byte-t462782.0.html;msg2102256#msg2102256

Saludos.

Gracias.

No quería tanto código, con una mini protección ya me vale.

Si tengo un array, hago este código y me basta.

    for (int i = 0; i < var1.Length; i++)
    {
        var1[i] = (byte)(var1[i] ^ 10);
    }

Solo tengo este string que dice:

string var1 = "Esto es una prueba.";
Console.WriteLine = var1;
 

Cuando usas el for arriba otra vez que es un XOR ^10, con usar el mismo, vuelve los valores como estaba.

Ahora la variable var1 en su interior lo transforma en "mjcgpow5yp4g0,xy43ph". Si vuelvo aplicar el for pero con la variable var1 igual a mjcgpow5yp4g0,xy43ph, al final dice "Esto es una prueba.".

El for de arriba mira un array, pero en este caso es un string, en el cual no se que hacer para que funcione en un string. Ahí está mi problema.

Saludos.

Buenas campeón:

Deja ver si capto lo que cuentas. Con el XOR ^10 me vale y solo quiero eso. Me da que usas la idea del Windows form y mi idea es en modo consola.

Saludos.

...y bueno, aprovechando que es sábado y Semana Santa y que por ello tengo un poco de tiempo libre...

No acostumbro a poner código, creo que todo el que reclama algo tiene que entender lo que sele dice y poner de su parte, pero bueno... Tampoco es plan que pongan en duda, lo que uno dice, porque (al menos yo) lo que uno dice debe decirlo con conocimiento, si no es mejor callarse, ó ante la duda preguntar...

El código parte de las líneas que tienes tú, yo simplemente he añadido la extensión de los métodos para los que te señalaba más arriba, corrigiendo en efecto, los pequeños detalles que se escapan cuando escribes al vuelo la idea... esto es, funciona perfectamente.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
 
namespace Encriptar_variable_Consola_01{
    using CustomExtensions;
    class Program{
        static void Main(string[] args){
            string Key = "QWERTYUIOP";
            string s = "En un lugar de 'La Mancha', de cuyo nombre no quiero acordarme.";
            string r, t;
 
            r = s.Code(Key);
            System.Console.WriteLine("El texto original {0} cifrado con la clave {1}, da por resultado {2}", s, Key, r);
            Console.WriteLine(); 
            t = r.Decode(Key);
            System.Console.WriteLine("...y vuelta atrás, el texto cifrado {0} con la clave {1}, nos devuelve al origen {2}", r, Key, t);
 
            Console.WriteLine();
            Console.ForegroundColor = ConsoleColor.Yellow;
            System.Console.WriteLine("Se comprueba que 's' = 't' {0} = {1}", s, t);
            Console.ForegroundColor = ConsoleColor.White;
 
 
 
 
 
            Console.WriteLine();  
            //Console.Title = "Ocultar variable"; // Título de la pantalla.
            Console.Title = "Ocultar variable".Code(Key) ;  
            //string variable = "Esto es una prueba.";
            string variable = "Esto es una prueba.".Code(Key) ;
            Console.WriteLine(variable);
            //Console.WriteLine("Otra prueba.");
            Console.WriteLine("Otra prueba.".Code(Key) );
 
            Console.WriteLine();
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Pulse una tecla y observa como cambia el título de la consola a su estado decodificado...");
            Console.ReadKey();
            Console.Title = Console.Title.Decode(Key);
 
            Console.WriteLine("Pulse cualquier tecla para salir.");
            Console.ReadKey(); 
        }
    }
}
 
 
namespace CustomExtensions{
    //Los métodos extendidos, deben ser definidos como una clase estática.
    public static class StringExtension    {        
        public static string Code(this String ElTexto, String LaClave){
            byte[] Cifrado = Encoding.UTF8.GetBytes(ElTexto);
            byte[] Key = Encoding.UTF8.GetBytes(Ampliar(LaClave, Cifrado.Length));
            byte k; 
 
            for (k=0; k< Cifrado.Length; k++){
                Cifrado[k] = (byte)(Cifrado[k] ^ Key[k]);
            }
 
            return Convert.ToBase64String(Cifrado);
        }
 
        public static string Decode(this string Cifrado, String LaClave){
            byte[] Cif = Convert.FromBase64String(Cifrado);             
            byte[] Key = Encoding.UTF8.GetBytes(Ampliar(LaClave, Cif.Length));
            byte k;
 
            for (k = 0; k < Cif.Length; k++){
                Cif[k] = (byte)(Cif[k] ^ Key[k]);
            }
            return Encoding.UTF8.GetString(Cif);
        }
 
        private static string Ampliar(string Key, int Minimo){
            int k, j, i;
 
            byte[] yeK = Encoding.UTF8.GetBytes(Key);
            k = yeK.Length; 
            j = (k-1);
            byte[] tmp= new byte[k];
 
            while (k < Minimo){
                k = (k * 2);
                Array.Resize(ref tmp, k); //redimensionar tmp(0 a k)
                //' El byte primero es la media de los extremos, luego entre el 2ª y el penúltimo, luego entre el 3º y el antepenúltimo... 
                //' el byte último es un xor entre los extremos, luego entre el 2ª y el penúltimo, luego entre el 3º y el antepenúltimo... 
                //' es muy simple, pero puede complicarse todo lo que quieras... y para lo que necesitas es suficiente.
                for (i = 0; i < j; i++) {
                    tmp[i] = (byte) ((yeK[i] + yeK[j-i] ) >> 1) ;
                    tmp[k-1-i] = (byte) (yeK[i] ^ yeK[j-i]);
                }
                //' Se puede complicar más con otras fases: 2,3,4 alterando la forma o la forma en que los índices se conjugan.
 
                yeK = tmp; //' asignamos un array al otro...
                j = (k - 1);
            }
            return Encoding.UTF8.GetString(yeK);
        }
    }
}
 

NOTAS:
A --- Yo tengo el VS-2010, puede que para una versión más actual, pueda requerir algún cambio, el propio entorno, ya te sugerirá si algo es obsoleto o incluso si no lo reconoce.... por ejemplo los métodos Getbytes, GetString, podrían estar desplazados respecto de UTF8.
B --- Nunca ha manejado una versión 'Comunity', solo versiones Enterprise y Profesional, por lo que ignoro las limitaciones de las versiones Comunity, supongo que para algo tan sencillo, no deba afectarle.
C --- Fíjate en el detalle de importar el namespace, concretamente en la línea: using CustomExtensions;
D --- Al final me he mantenido firme (al pseudocódigo que puse) y he dejado el cifrado con XOR, aparte de codificar con Base64.
E --- Para probarlo y entenderlo bien, ejecútalo paso a paso (tecla F11).
F --- He añadido bastante 'verbosidad', en main, para reflejar el uso de los métodos Code y Decode.
G --- p.d.: Personalmente acostumbro a abrir las llaves en la línea previa, por lo que no estando acostumbrado pueda dar la impresión de que 'falta algo'... cuestión de gustos, solamente...
H --- ...y por supuesto y para aclarar tus dudas: Es una aplicaicón de consola, la frase tuya:  Me da que usas la idea del Windows form y mi idea es en modo consola.[/i] es irrelevante, aunque yo pusiera en el ejemplo referencias a unos controles textbox, el pseudocódigo es adaptable a ambas situaciones...
I --- Para algo más elegante, incluso la clave (QWERTYUIOP), podría estar cifrada (y ser descifrada, por ejemplo con el nombre del programa, con lo que si alguien lo cambia, 'traducirá' a urliburli), o bien ser pasada como un argumento al programa.