// ****************************************************************
// ****************************************************************
// **                                                            **
// **                                                            **
// **               Criba de Eratóstenes en C#                   **
// **                       By Hendrix                           **
// **                                                            **
// **                                                            **
// ****************************************************************
// ****************************************************************
 
using System;
using System.Collections.Generic;
using System.Text;
 
namespace ConsoleApplication1
{
    class Program
    {
        public static int max;
 
        static void Main(string[] args)
        {
            int nume;
 
            Console.WriteLine("Introduce el numero hasta donde se va a buscar");
            max = Convert.ToInt32(Console.ReadLine());
 
            int[,] num = new int[max, 2];
            string primos = "";
 
            for (int i = 2; i < max; i++) //Rellenamos el array
            {
                num[i, 0] = i;
                num[i, 1] = 0;
            }
 
            for (int i = 2; i < max; i++)
            {
                if (num[i, 1] == 0)
                {
                    primos = primos + i.ToString() + ",";
                    for (int e = 1; e < max + 1; e++)
                    {
                        nume = num[i, 0];
                        nume = nume * e;
                        if (nume < max)
                        {
                            num[nume, 1] = 1;
                        }
                        else
                        {
                            break;
                        }
                    }
                }
            }
 
            primos = primos.Substring(0, primos.Length - 1);
            Console.WriteLine("Numeros primos encontrados: {0}", primos);
            Console.Read();
 
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
 
namespace ConsoleApplication1
{
    class Program
    {
        public static int contador = 0;
 
        public static bool IsNumeric(object Expression)
        {
            bool isNum;
            double retNum;
 
            isNum = Double.TryParse(Convert.ToString(Expression), System.Globalization.NumberStyles.Any,System.Globalization.NumberFormatInfo.InvariantInfo, out retNum );
            return isNum;
        }
 
        public static string Decompresor(string comprimido)
        {
            string decompres = "";
            string num = "";
            string caracter;
            int diferencia = 1;
            string sub;
            string suba;
            bool semaforo = false;
 
            for (int e = 0; e < comprimido.Length; e++)
            {
                if (IsNumeric(comprimido.Substring(e, 1)) == true)
                {
                    for (int j = 1; j < comprimido.Length; j++)
                    {
                        if (semaforo == true)
                        {
                            diferencia--;
                            if (diferencia != 0)
                            {
                                semaforo = false;
                                break;
                            }
                        }
 
                        string b;
                        bool a;
                        b = comprimido.Substring(e + j, 1);
                        a = IsNumeric(b);
                        if (a == false)
                        {
                            sub = comprimido.Substring(e);
                            num = "";
                            num = sub.Substring(0, j);
                            caracter = sub.Substring(j, 1);
                            diferencia = num.Length;
                            for (int m = 0; m < Convert.ToInt32(num); m++)
                            {
                                decompres = decompres + caracter;
                            }
                            semaforo = true;
                            break;
                        }
                    }
                }
                suba = comprimido.Substring(e, 1);
                if (IsNumeric(suba) == false)
                {
                    decompres = decompres + suba;
                }
            }
 
            return decompres;
 
        }
 
 
        public static string Compresor(string texto)
        {
            string res = "";
 
            for (int i=0;i<texto.Length-1;i++)
            {
                char a,b;
 
                a = Convert.ToChar(texto.Substring(i,1));
                b = Convert.ToChar(texto.Substring(i+1,1));
                if (a == b)
                {
                    contador++;
                }
                else
                {
                    if (contador != 0)
                    {
                        res = res + Convert.ToString(contador);
                        contador = 0;
                    }
                    res = res + a;
                }
 
            }
 
            res = res + texto.Substring(texto.Length - 1, 1);
 
            if (contador != 0)
            {
                res = res.Substring(0, res.Length - 1);
                res = res + Convert.ToString(contador);
                res = res + texto.Substring(texto.Length - 1, 1);
            }
 
 
            return res;
 
 
        }
 
        static void Main(string[] args)
        {
            string palabra;
            string resultado;
            string result;
 
            palabra = "heeeeeeeeeeeennnnnnnnnnnnddddddddrrrrrrriiiiixxxxxxxxxx";
 
 
            resultado = Compresor(palabra);
            result = Decompresor(resultado);
 
 
            Console.WriteLine("La palabra original es: {0} \nLa palabra comprimida es: {1}\nLa palabra descomprimida es: {2}\n\n",palabra, resultado,result);
            Console.WriteLine("Tamaño inicial: {0}\nTamaño Final: {1}", palabra.Length, resultado.Length);
            Console.Read();
 
 
        }
    }
}

Saludo("Hola desde C++");

'************************************************************************
'************************************************************************
'**                                                                    **
'**   Inyeccion Dll en VB a partir del codigo en C++ de MazarD         **
'**                                                                    **
'**                  Wrote on June 15, 2007 by Hendrix                 **
'**                                                                    **
'**                                                                    **
'**                         CopyLeft Licence                           **
'************************************************************************
'************************************************************************
 
 
 
Private Const PAGE_READWRITE As Long = &H4
Private Const MEM_RELEASE As Long = &H8000
Private Const MEM_COMMIT As Long = &H1000
Private Const STANDARD_RIGHTS_REQUIRED As Long = &HF0000
Private Const SYNCHRONIZE As Long = &H100000
Private Const PROCESS_ALL_ACCESS As Long = (STANDARD_RIGHTS_REQUIRED Or SYNCHRONIZE Or &HFFF)
Private Const INFINITE As Long = &HFFFFFF
 
Private Declare Function OpenProcess Lib "kernel32" (ByVal dwDesiredAccess As Long, ByVal bInheritHandle As Long, ByVal dwProcessId As Long) As Long
Private Declare Function GetProcAddress Lib "kernel32" (ByVal hModule As Long, ByVal lpProcName As String) As Long
Private Declare Function GetModuleHandle Lib "kernel32" Alias "GetModuleHandleA" (ByVal lpModuleName As String) As Long
Private Declare Function VirtualAllocEx Lib "kernel32" (ByVal hProcess As Long, ByVal lpAddress As Long, ByVal dwSize As Long, ByVal flAllocationType As Long, ByVal flProtect As Long) As Long
Private Declare Function WriteProcessMemory Lib "kernel32" (ByVal hProcess As Long, lpBaseAddress As Any, lpBuffer As Any, ByVal nSize As Long, lpNumberOfBytesWritten As Long) As Long
Private Declare Function CloseHandle Lib "kernel32" (ByVal hObject As Long) As Long
Private Declare Function CreateRemoteThread Lib "kernel32" (ByVal hProcess As Long, lpThreadAttributes As Long, ByVal dwStackSize As Long, lpStartAddress As Long, lpParameter As Any, ByVal dwCreationFlags As Long, lpThreadId As Long) As Long
Private Declare Function WaitForSingleObject Lib "kernel32" (ByVal hHandle As Long, ByVal dwMilliseconds As Long) As Long
 
 
Public Function Inyecta(RutaDll As String, Pid As Long) As Integer
Dim proc As Long
Dim nload As Long
Dim rems As Long
Dim longi As Long
Dim RemThread As Long
Dim Tid As Long
 
On Error GoTo Error
proc = OpenProcess(PROCESS_ALL_ACCESS, False, Pid)
nload = GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA")
rems = VirtualAllocEx(proc, 0, Len(RutaDll), MEM_COMMIT, PAGE_READWRITE)
WriteProcessMemory proc, ByVal rems, ByVal RutaDll, Len(RutaDll), longi
CreateRemoteThread proc, ByVal 0, 0, ByVal nload, ByVal rems, 0, Tid
WaitForSingleObject rems, INFINITE
CloseHandle proc
CloseHandle rems
Inyecta = 0
Exit Function
Error:
Inyecta = 1
End Function

Private Sub Form_Load()
Dim ruta As Long
Dim resultado As Integer
 
ruta = Shell("notepad.exe")
resultado = Inyecta("C:\ladll.dll", ruta)
 
If resultado = 0 Then
MsgBox "Dll Inyectada con éxito!!!", , "Información"
Else
MsgBox "A ocurrido un error", vbCritical, "Información"
End If
End
End Sub

using System;
using System.Collections.Generic;
using System.Text;
 
 
namespace ConsoleApplication2
{
    class Program
    {
        public static string carac = ",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,0,1,2,3,4,5,6,7,8,9";
 
 
 
        static void Main(string[] args)
        {
            string palabra = "";
            char o = ',';
            string[] c = carac.Split(o);
 
            for (int a = 0; a < 37; a++)
            {
                for (int b = 0; b < 37; b++)
                {
                    for (int d = 0; d < 37; d++)
                    {
                        for (int e = 0; e < 37; e++)
                        {
                            for (int f = 0; f < 37; f++)
                            {
                                for (int g = 0; g < 37; g++)
                                {
                                    for (int h = 0; h < 37; h++)
                                    {
                                        for (int i = 0; i < 37; i++)
                                        {
                                            for (int j = 0; j < 37; j++)
                                            {
                                                for (int k = 0; k < 37; k++)
                                                {
                                                    palabra = c[a] + c[b] + c[d] + c[e] + c[f] + c[g] + c[h] + c[i] + c[j] + c[k];
                                                    Console.WriteLine(palabra);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

/* Inyección de Dll escrito por Hendrix 
 * en base al codigo en C de MazarD por
 * CreateRemoteThread.
 * 
 * Fecha: 2-6-2007
 * 
 * Dll echa en Vc++
 */
 
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.ComponentModel;
using System.IO;
 
namespace ConsoleApplication1
{
    class Apis
    {
        [DllImport("kernel32.dll", EntryPoint = "OpenProcess")]
        public static extern IntPtr OpenProcess(uint dwDesiredAccess, bool bInheritHandle, uint dwProcessId);
 
        [DllImport("kernel32", CharSet = CharSet.Ansi)]
        public extern static int GetProcAddress(int hwnd, string procedureName);
 
        [DllImport("kernel32.dll", EntryPoint = "GetModuleHandle")]
        public static extern int GetModuleHandle(string lpModuleName);
 
        [DllImport("kernel32.dll", EntryPoint = "VirtualAllocEx")]
        public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
 
        [DllImport("kernel32")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool CloseHandle(IntPtr hObject);
 
        [DllImport("kernel32", EntryPoint = "CreateRemoteThread")]
        public static extern IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, uint lpThreadId);
 
        [DllImport("kernel32.dll",EntryPoint = "WriteProcessMemory")]
        public static extern IntPtr WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] buffer, uint size, IntPtr lpNumberOfBytesWritten); 
 
    }
 
 
 
    class Program
    {
        static int Main(string[] args)
        {
            uint pid;
            int load;
            uint tama;
            string ladll;
            string nom;
 
            const uint PROCESS_ALL_ACCESS = 0x000F0000 | 0x00100000 | 0xFFF;
            const uint MEM_COMMIT = 0x1000;
            const uint MEM_RESERVE = 0x2000;
            const uint PAGE_READWRITE = 0x40;
 
            try
            {
                Console.Write("Introduce el nombre del proceso (sin la extension): ");
                nom = Console.ReadLine();
                Console.Write("\nIntroduce la ruta de la dll a inyectar: ");
                ladll = Console.ReadLine();
 
                if (File.Exists(ladll) == false)
                {
                    Console.WriteLine("La ruta de la Dll no existe");
                    Console.Read();
                    return 0;
                }
 
                Byte[] dll = Encoding.ASCII.GetBytes(ladll);
                tama = Convert.ToUInt32(ladll.Length);
 
                Process[] nombre = Process.GetProcessesByName(nom);
                if (nombre.Length == 0)
                {
                    Console.WriteLine("El proceso no existe");
                    Console.Read();
                    return 0;
                }
                pid = Convert.ToUInt32(nombre[0].Id);
 
                IntPtr proc = Apis.OpenProcess(PROCESS_ALL_ACCESS, false, pid);
                load = Apis.GetProcAddress(Apis.GetModuleHandle("kernel32.dll"), "LoadLibraryA");
                IntPtr nLoad = new IntPtr(load);
                IntPtr rems = Apis.VirtualAllocEx(proc, IntPtr.Zero, Convert.ToUInt32(ladll.Length), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
                Apis.WriteProcessMemory(proc, rems, dll, tama, IntPtr.Zero);
                Apis.CreateRemoteThread(proc, IntPtr.Zero, 0, nLoad, rems, 0, 0);
                Apis.CloseHandle(proc);
                return 1;
            }
 
            catch
            {
                Console.WriteLine("\nUn error ha ocurrido.");
                Console.ReadLine();
                return 0;
            }
 
 
 
        }
    }
}

• Introducción
• ¿Qué es un Socket?
• Teoria sobre Sockets en C#
• Programando una aplicacion Cliente-Servidor
• Implementación del protocolo HTTP en C# mediante Sockets
• Despedida

using System.Net;
using System.Net.Sockets;

IPAddress direc = Dns.GetHostEntry("localhost").AddressList[0];

IPEndPoint Ep = new IPEndPoint(direccion, puerto);

IPEndPoint Ep = new IPEndPoint(direc, 12345);

Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

socket.Bind(Ep);
socket.Listen(100);

Socket handler = socket.Accept();

byte[] bytes = new byte[1024]; //Declaramos un array de bytes de longitud 1024
int count;
String data = ""; //Declaramos data, que sera donde se almacenaran los datos

do //Bucle Do/While
	{
        	count = handler.Receive(bytes); //Recibimos los datos enviados y lo guardamos en cout.
                data = System.Text.Encoding.ASCII.GetString(bytes, 0, count); //Lo codificamos a cadena (ya que se envian como bytes)
                if (data != "exit\n") //Mientras lo recibido no sea exit + \n (es decir, exit + Intro, ya que intro tambien se envia)
                {
                    Console.Write("Se a recibido: {0}", data); //Mostramos lo recibido pro pantalla
                }


        } while (data != "exit\n");  //Mientras lo recibido no sea exit + Intro se continua el bucle, si recibimos exit + intro, salimos del bucle

        Console.WriteLine("Se ha finalizado la conexión"); //Avisamos qde que se a terminado la transferencia de datos

        byte[] msg = System.Text.Encoding.ASCII.GetBytes("\n\nFinalizada conexion con la aplicacion"); //Codificamos de string a byte el siguiente mensage para que se pueda enviar al NetCat (Cliente)

        handler.Send(msg); //Enviamos el mensage al cliente
        handler.Shutdown(SocketShutdown.Both); //"Apagamos" los sockets
        handler.Close(); //Los cerramos

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            string cabecera = "GET /index.html HTTP/1.0\n\n"; //Cabecera para hacer la peticion del index.
            string respuesta;
            Byte[] SendBytes = Encoding.ASCII.GetBytes(cabecera);
            Byte[] RecvBytes = new Byte[255];
            int bytes;
            bool semaforo;
            string html = "";
            int e;

            semaforo = false;

            IPHostEntry address = Dns.GetHostEntry("www.web.com");

            IPEndPoint Ep = new IPEndPoint(address.AddressList[0], 80);

            Socket socket = new Socket(AddressFamily.InterNetwork,
                                         SocketType.Stream,
                                         ProtocolType.Tcp);

            try
            {

                socket.Connect(Ep); //Conectamos

                socket.Send(SendBytes,SendBytes.Length,SocketFlags.None); //Enviamos la cabecera

                bytes = socket.Receive(RecvBytes,RecvBytes.Length,SocketFlags.None); //Recibimos la respuesta en bloques de 255 bytes

                respuesta = Encoding.ASCII.GetString(RecvBytes, 0, bytes); //Codificamos la respuesta

                while (bytes > 0)
                {

                    bytes = socket.Receive(RecvBytes,
                                             RecvBytes.Length,
                                             SocketFlags.None);

                    respuesta = Encoding.ASCII.GetString(RecvBytes, 0, bytes);

                    if (semaforo == false) //Filtro de encabezamientos
                    {
                        e = respuesta.IndexOf("<html>");
                        if (e != -1)
                        {
                            semaforo = true;
                            html = respuesta.Substring(e);
                        }
                    }
                    else
                    {
                        html += respuesta;
                    }

                }

                string fileName = "C:\\index.html"; //Guardamos lo recibido en C:\Index.html
                StreamWriter writer = File.CreateText(fileName);

                writer.WriteLine(html);
                writer.Close();

                Console.WriteLine("Archivo guardado con exito");
                Console.Read();

            }
            catch (Exception error) //Si durante el procedimiento hay error salta aqui.
            {
                Console.WriteLine("Se produció el siguiente error: " + error);
                Console.Read();
            }
        }
    }
}

Documento bajo licencia CopyLeft