#include <cstdlib>
#include <stdio.h>
#include <windows.h>

/* ///////////////////////////////////////////////////////////////
/*
/*  Funcion Split con strtok
/*  By Octalh
/*  www.aztekmindz.org | octalh@gmail.com
/*  USO: cmd("CADENA-DE-TEXTO","SEPARADOR",TROZO_DECEADO)
/*  Ejemplo: char* msj = cmd("salu2-desde-aztekmindz","-",2);
/*  msj es igual a: "aztekmindz"
/*  Los trozos se cuentan desde el "0".
/*
*/ ///////////////////////////////////////////////////////////////

using namespace std;

int cc( char* strc, char sep ){
   int cc = 0;
   while( *strc ){
      if((char)*strc == (int)sep){
         cc++;
      }
      strc++;
   }
   return cc;
}

char *cmd(char *str2,char *sep, int prt){
      static char salida[100];
      char str[100];
      strcpy(str,str2);
      int cuantas = cc( str,sep[0]);
      char *test[100];
      test[0] = strtok(str, sep);
      if (prt == 0){
           if(cuantas != 0){
              sprintf(salida,"%s",test[0]);
           }else{
              sprintf(salida,"ERROR");
           }

      }else{
         if (cuantas+1 > prt ){
             for(int i = 1; i < prt+1; i++){
                test[i] = strtok (NULL, sep);
                sprintf(salida,"%s",test[i]);
             }
         }else{
             sprintf(salida,"ERROR");
         }
      }
return salida;
}

int main(int argc, char *argv[])
{  

    char* msj = cmd("A-B-C-D-E","-",2);
    printf("%s \n",msj);
    system("PAUSE");
    return EXIT_SUCCESS;
}

#include <cstdlib>
#include <iostream>
#include <windows.h>

using namespace std;

int main(int argc, char *argv[])
{
keybd_event(VK_MENU, 0×38, 0, 0);
keybd_event(VK_RETURN, 0×1c, 0, 0);
keybd_event(VK_RETURN, 0X1c, KEYEVENTF_KEYUP, 0);
keybd_event(VK_MENU, 0×38, KEYEVENTF_KEYUP, 0);
int binary, count;
HWND CurrentWin;
CurrentWin = GetForegroundWindow();
HANDLE consol;
consol = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(consol,FOREGROUND_GREEN);
SetConsoleTitle("Matrix");
while(1)
{
binary = rand();
cout << binary;
SetForegroundWindow(CurrentWin);
count = rand()%200;
if(count<51)
{
cout << " ";
}
}
return 0;
}

#include <ntddk.h>

NTSTATUS  PsLookupProcessByProcessId(LONG ProcessId,LONG *Process);

void FakePid(HANDLE ParentID,HANDLE ProcessID,BOOLEAN C)
{
    LONG   Proc;
    PCHAR   N;

    PsLookupProcessByProcessId((LONG)ProcessID,&amp;Proc);
    if (C)
    {
     N=(PCHAR)Proc+0×174;
     if (N[0]==‘a’ &amp;&amp; N[1]==‘b’ &amp;&amp; N[2]==‘c’)
     {
    *(LONG*)(Proc+0×84)=12345;
     }
    }
    return;
}

void Salir(PDRIVER_OBJECT DriverObject)
{
    PsSetCreateProcessNotifyRoutine(&amp;FakePid,TRUE);
    return;
}

NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING rp)
{
    DriverObject->DriverUnload=Salir;
    PsSetCreateProcessNotifyRoutine(&amp;FakePid,FALSE);
    return STATUS_SUCCESS;
}

#include <cstdlib>
#include <windows.h>
#include <psapi.h>
#include <iostream>

/*
/* Matar procesos C++
/*  By Octalh
/* www.aztekmindz.org
/*
*/

using namespace std;

BOOL tproceso(int pid) {
        int ret=1;
        HANDLE pHandle;

        if ((pHandle = OpenProcess(PROCESS_ALL_ACCESS,FALSE,pid)) != NULL)
                if(!TerminateProcess(pHandle,0)) {
                        ret=0;
                        CloseHandle(pHandle);
                        return TRUE;
                }

}

int main(int argc, char *argv[])
{
    int pid;
    cout << "\n\n\t Matar Procesos";
    cout << "\n\t Pid del Proceso:";
    cin >> pid;
    if (tproceso(pid)) {
        printf("\n\n\t Ok proceso [%d] terminado con exito. \n\n",pid);
    } else {
        printf("\n\n\t Error al terminar el proceso [%d] \n\n",pid);
    }
    system("PAUSE");
    return EXIT_SUCCESS;
}

#include <cstdlib>
#include <windows.h>
#include <psapi.h>
#include <stdio.h>

/*
/* Listar procesos C++
/*  By Octalh
/* www.aztekmindz.org
/*
*/

using namespace std;

void procesos(){

DWORD Procesos[200], PN, cProcesos;
unsigned int i;
TCHAR procsnombre[200] = TEXT("");
       if ( !EnumProcesses( Procesos, sizeof(Procesos), &amp;PN ) )
               return;
               cProcesos = PN / sizeof(DWORD);
                      for ( i = 0; i < cProcesos; i++ ) {
                              HANDLE hProcesos = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, Procesos[i] );
                                    if (NULL != hProcesos ){
                                              GetModuleBaseName( hProcesos, NULL, procsnombre, sizeof(procsnombre)/sizeof(TCHAR) );
                                    }
                                    printf(TEXT("  %s, PID = %u \n"), procsnombre, Procesos[i]);
                                    CloseHandle( hProcesos );
                      }

     }

int main(int argc, char *argv[])
{
    procesos();
    system("PAUSE");
    return EXIT_SUCCESS;
}

#include <cstdlib>
#include <stdio.h>
#include <wininet.h>
using namespace std;
/*
/* Ejemplo Subir / Descargar archivos via FTP C++
/* By Octalh [octalh@gmail.com]
/* www.aztekmindz.org
*/

int SubirFTP(char *servidor, char *usuario, char *password,
int puerto, char *ALocal, char *ARemoto){
    HINTERNET Peticion;
    Peticion =InternetOpen("Internet Explorer",0,NULL,NULL,0);
    if(Peticion==NULL){
         return 1;
    }else {
       HINTERNET Conectar;
       Conectar = InternetConnect(Peticion,servidor,puerto,
       usuario,password,INTERNET_SERVICE_FTP,0,0);
       if(Conectar==NULL){
            InternetCloseHandle(Conectar);
            return 1;
       }else{
          if(FtpPutFile(Conectar,ALocal,ARemoto,FTP_TRANSFER_TYPE_BINARY,0)==FALSE){
             return 1;
          }

          return 0;
          InternetCloseHandle(Peticion);
          InternetCloseHandle(Conectar);

       }

    }

}

int BajarFTP(){
}

int main(int argc, char *argv[])
{
    if (SubirFTP("Servidorftp.com", "usuario","password",21,"local.txt","remoto.txt")==0){
        printf("\n Archivo Subido Con Exito. \n\n");
        }else{
        printf("\n Error al Subir el Archivo. \n\n");
        }
    system("PAUSE");
    return EXIT_SUCCESS;
}

if(FtpGetFile(Conectar,ARemoto,ALocal,FTP_TRANSFER_TYPE_BINARY,0)==FALSE){
             return 1;
          }

#include <cstdlib>
#include <windows.h>
#include <stdio.h>
#include <conio.h>
using namespace std;

/*
/*    Codigo fuente de ejemplo Mutex
/*    Elaborado para www.aztekmindz.org by Octalh
/*    [ octalh@gmail.com ]
*/

int main(int argc, char *argv[])
{

        CreateMutex(0,0,"-+- Mutex AzTeK-MiNdZ -+-"); //Creamos el Mutex
        if(GetLastError() == ERROR_ALREADY_EXISTS){ // Si ya existe…
                ExitProcess(0); // Cerramos aplicacion
        } else { // De lo contrario…
            // Ejecutamos resto del Programa
        printf("\n  << MUTEX [ www.aztekmindz.org ] >>\n\n");
        printf("\n \t Esta aplicacion solo se puede ejecutar una sola ves. \n\n");
        getch();
        return EXIT_SUCCESS;
    }
}

/*
[ Programa ]
Ocultar procesos al administrador de tareas (Task Manager) Sin inyeccion.
By Octalh
Testeado en Windows XP SP2
octalh@gmail.com
www.aztekmindz.org
*/

using namespace std;

LVITEM ItemLista, *_ItemLista;
char item[512], subitem[512];
char *_item, *_subitem;
unsigned long pid;
HANDLE HProceso;
char ExeProc[50]; //Proceso a ocultar

BOOL CALLBACK PrOcultar(HWND hwnd,LPARAM lParam)
{
   char HLista[150] = "";
   char HAdminT[150] = "";

   GetWindowText(hwnd,HAdminT,149);
   GetClassName(hwnd,HLista,249);

   if (strstr(HAdminT,"Procesos") &amp;&amp; strstr(HLista,"SysListView32") !=NULL)
   /* Si encontramos la columna "Procesos" en el Taskmanager y la clase "SysListView32"
      de la listvew
   */
   {
      int count=(int)SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0); // Contamos los Items listados
      int i;
      GetWindowThreadProcessId(hwnd, &amp;pid); //Obtenemos el Pid de cada Proceso listado como Item
      HProceso=OpenProcess(PROCESS_VM_OPERATION|PROCESS_VM_READ|
                      PROCESS_VM_WRITE|PROCESS_QUERY_INFORMATION, FALSE, pid);
                      // Obtenemos el Hndle del proceso como Item de la Listvew

      _ItemLista=(LVITEM*)VirtualAllocEx(HProceso, NULL, sizeof(LVITEM),
                                MEM_COMMIT, PAGE_READWRITE); // Asiganos permisos de lectura y escritura al Listvew
      _item=(char*)VirtualAllocEx(HProceso, NULL, 512, MEM_COMMIT,
                               PAGE_READWRITE);
      _subitem=(char*)VirtualAllocEx(HProceso, NULL, 512, MEM_COMMIT,
                           PAGE_READWRITE); // Asiganos Lectura y Escritura en la region asiganda

      ItemLista.cchTextMax=512;
      for(i=0; i<count; i++) { // Contamos cada Item en un Bucle
           ItemLista.iSubItem=0;
           ItemLista.pszText=_item;
           WriteProcessMemory(HProceso, _ItemLista, &amp;ItemLista, sizeof(LVITEM), NULL);
           SendMessage(hwnd, LVM_GETITEMTEXT, (WPARAM)i, (LPARAM)_ItemLista); // Obtenemos el nombre de cada Item (Proceso)
           ItemLista.iSubItem=1; // Posicion de la columna en el listview
           ItemLista.pszText=_subitem;
           WriteProcessMemory(HProceso, _ItemLista, &amp;ItemLista, sizeof(LVITEM), NULL);
           SendMessage(hwnd, LVM_GETITEMTEXT, (WPARAM)i, (LPARAM)_ItemLista);
           ReadProcessMemory(HProceso, _item, item, 512, NULL);
           ReadProcessMemory(HProceso, _subitem, subitem, 512, NULL);

          if (strstr(item,ExeProc) != NULL)  SendMessage(hwnd, LVM_DELETEITEM, (WPARAM)i, (LPARAM)_ItemLista);
          // Si exise el Proceso a Ocultar, eliminamos el Item de la Listvew
      }
      VirtualFreeEx(HProceso, _ItemLista, 0, MEM_RELEASE); // Libreamos…
      VirtualFreeEx(HProceso, _item, 0, MEM_RELEASE);
      VirtualFreeEx(HProceso, _subitem, 0, MEM_RELEASE);
      return FALSE;
   }

return TRUE;
}

int main(){
   HWND fwindow;
   printf("%s","\n\n      Ocultar Procesos al Task Manager \n");
   printf("%s","\n                << By Octalh >>\n\n");
   printf("%s","     [ www.aztekmindz.org | octalh@gmail.com ]\n \n");
   printf("     Escribe el proceso que deseas ocultar: ");
   gets(ExeProc);
   printf("\n\n     Ocultando Proceso: [ %s ]",ExeProc);

   for(;;)
   {
      EnumChildWindows(FindWindow(0,"Administrador de tareas de Windows"),PrOcultar,0);
   }

   return 0;
}

#include <cstdlib>
#include <stdio.h>
#include <winsock2.h> // Referencia a la librería

using namespace std;

WSADATA wsadata; //Declaramos WSADATA

struct hostent *host;
//Declaramos estructura hostent donde almacenaremos la IP que nos devuelva gethostbyname

SOCKADDR_IN conexloc;
/*Declaramos una estructura SOCKADDR_IN para no tener que definir una IP y un puerto
en cada paquete que enviemos. De esa forma todo viajara encapsulado utilizando la estructura
SOCKADDR_IN.
*/

SOCKET locsock; // Declaramos el descriptor de fichero que nos de el socket

char Buffer[1023]; // Declaramos el tamaño del Buffer

int WSAInicio() { //declaramos procedimiento
         int wasa = WSAStartup(MAKEWORD(2,0),&amp;wsadata); //Indicamos versión 2.0 del socket
         if (wasa != 0) { // Si existen errores…
     printf("%s","Error iniciando WSAStartup \n"); //Mostramos un mensaje
                WSACleanup(); //Limpiamos WSADATA
                return 1; // Retornamos 1 dado que la funcion fallo
         }
         return 0; // Si se inicio todo bien retornamos 0
}

int definirsocket() {
         locsock = socket(AF_INET/* IP V4 */, SOCK_STREAM, 0); // Indicamos que usaremos un socket Stream(TCP)
         if (locsock == INVALID_SOCKET) { // Si existen errores…
         printf("%s","Error definiendo socket \n"); //Mostramos un mensaje
                WSACleanup(); //Limpiamos WSADATA
                return 1; // Retornamos 1 dado que la funcion fallo
         }
         return 0; // Si se inicio todo bien retornamos 0
}

int estructsocket() { // Definimos procedimiento
     conexloc.sin_family = AF_INET; // Ordenación de Maquina
      /*
         Definimos la version 4 de IP
      */
     conexloc.sin_addr.s_addr = INADDR_ANY;
     /*
         Definimos IP local
     */
     conexloc.sin_port = htons(9999);
     /* Definimos puerto (9999) por el que escuchara el socket utilizando un “short de máquina a short de la red” (htons)
        Esto lo hacemos para ordenar la forma en la que enviaremos y recibiremos los datos por el puerto del socket, mas información buscar en google “Big-Endian”.
     */

         if (bind(locsock, (sockaddr*)&amp;conexloc, sizeof(conexloc)) == SOCKET_ERROR) { // Si existen errores…
         /* Una ves creado el socket asociamos el descriptor de ficher "locsock" a un puerto, para eso utilizamos la función "bind"
            Después asignamos la dirección IP pasándola como puntero a "sockaddr".
         */
                printf("%s","Error definiendo socket \n"); //Mostramos un mensaje
                WSACleanup(); //Limpiamos WSADATA
                return 1; // Retornamos 1 dado que la funcion fallo
         }  else {
             if (listen(locsock, 5) == SOCKET_ERROR) { // Si existen errores…
             /* La función listen sirve para poner el socket en escucha por un puerto determinado, en nuestro caso el puerto 9999
                que fue definido al socket en la función "bind", utilizando el descriptor de fichero "locsock" que "socket()" nos dio
                El ultimo numero es la cantidad de conexiones que podemos tener como máximo en la cola de espera.
             */
                       printf("%s","Error Al ponerse en escucha \n"); //Mostramos un mensaje
                   WSACleanup(); //Limpiamos WSADATA
                           return 1; // Retornamos 1 dado que la función fallo
                 } else {
                     printf("%s","Esperando conexiones por puerto 9999 \n"); //Mostramos un mensaje
                     return 0; // Si se inicio todo bien retornamos 0
                    }

     }
}

void conexion(){

     int conm; //Declaramos variable para definir longitud de la estructura "sockaddr"
     conm=sizeof(struct sockaddr); // definimos longitud de "sockaddr"
     locsock=accept(locsock,(sockaddr*)&amp;conexloc,&amp;conm); // Conexion establecida
     /* Aceptamos la conexión con la funcion "accept" utilizando el descriptor de fichero "locsock" para transmitir los datos entre ambas computadoras
        mediante nuestra estructura "SOCKADDR_IN" definida anteriormente en "conexloc"
     */
     printf("%s","Conexion establecida \n"); //Mostramos un mensaje
         while (conm!=0){ //mientras estemos conectados..
                conm=recv(locsock,Buffer,sizeof(Buffer),0); //recibimos los datos que envíe
                /* La función "recv" se encarga de recibir los datos a través del descriptor de fichero "locsock"
                   Buffer es donde se va almacenar la información recibida y posteriormente con "sizeof" medimos la longitud total del buffer recibido
                   Dado que "recv" devuelve un valor de cero en caso de existir un error se utiliza un bucle while para verificar
                   que seguimos conectados con el equipo remoto
                */
                if (conm>0){  //si seguimos conectados al cliente
                printf("Datos recibidos:%s",Buffer); //imprimimos los datos recibidos
                }
         }

     }

void sockets(){ // Procedimiento que iniciara el socket secuencialmente.
        if((WSAInicio()) == 0) { // Si se inicio WSAInicio sin errores…
           if((definirsocket()) == 0) { // Si se inicio definirsocket sin errores…
              if((estructsocket()) == 0) { // Si se inicio estructsocket sin errores…
                 conexion(); // Iniciamos el procedimiento "conexion"
              }
           }
        }
     }

int main(int argc, char *argv[])
{
    sockets(); // Iniciamos el Socket
}