Mensajes

Buenas, tengo una pequeña duda sobre como funcionan los routers uniendo redes, imaginad que tengo algo así:



(La imagen la he sacado de google)

Sé que PC0 no puede saber la dirección MAC de un equipo que no esté dentro de su red local (es decir solo puede saber la dirección MAC de PC1 y de su router, y así con el resto de subredes. El caso es, cuando PC0 hace una petición a PC2, tengo entendido que el router detecta que está fuera de su red (por el nombre de red) y le "pasa la pelota" al siguiente router (el que está al lado suyo) entonces, del paquete tcp/ip "quita" la dirección MAC de PC0 y pone la dirección MAC de el mismo (del primer router) antes de pasarselo al siguiente router, ¿Es esto correcto?

Gracias.

Buenas, hace un tiempo me di cuenta que existian grupos de telegram para prácticamente cualquier distribución GNU/Linux y ninguno para sistemas *BSD, así que he creado un grupo para ello, ahora mismo no somos muchos (15 personas) pero somos activos, dejo el enlace de invitación del grupo:

https://t.me/sistemasbsd

Chequea la tarjeta de red físicamente por si tuviera un WOL,  en las antiguas (que además yo he tenido) así era, llevaban un cablecito que colocar a la placa base y lo mismo Kali incluye su controlador (de chiripas), cosa que FreeBSD no por ser cosa demasiado obsoleta...

Antes de nada, gracias por responder, le he estado dando más vueltas al asunto, he abierto la torre y me he dado cuenta de que realmente no incluye una tarjeta ethernet dedicada, sino que forma parte de la placa base.

Ahora he conseguido instalar FreeBSD 11 en la máquina, cuando arranco el equipo, la tarjeta de red está apagada y hasta que no arranca el sistema operativo no se enciende, en cambio, si una vez encendida reinicio la máquina, no se apaga en ningún momento, si desenchufo la torre y vuelvo a enchufarla y encenderla, otra vez está la tarjeta apagada hasta que arranca el sistema operativo, es como si le faltase "algo" a la tarjeta que tanto freebsd ya instalado o linux tienen.

También he entrado en BIOS para ver si existe alguna opción WOL pero no, no tiene nada parecido. Lo único relacionado con la tarjeta de red que he encontrado en la BIOS es la opción de bootear desde ethernet, dicha opción está deshabilitada.

Realmente ahora no tengo mucho problema por que al arrancar freebsd ya instalado, funciona, pero me da mucha curiosidad, es algo raro.

Me pasa algo muy extraño con un ordenador viejo que tengo para hacer pruebas, es una torre con una tarjeta de red ethernet, el caso es el siguiente:

- Arranco el ordenador, con un cable RJ45 conectado entre el equipo y el router (de ONO), se deberían encender una luz tanto en el socket de la tarjeta de red del equipo como en el router indicanto que hay enlace entre ambos, pero no es así, no se enciende, como si el cable estuviese roto.

- Booteo FreeBSD 11 y cuando llega al paso de configurar la red, le digo DHCP y no funciona, evidentemente, si ni siquiera existe enlace entre router y equipo, normal que no obtenga DHCP.

- Booteo un linux live (Kali para ser más precisos) cuando termina de arrancar el live y me pide usuario y contraseña, mágicamente se enciende la luz tanto en el router como en la tarjeta de red, teniendo internet normalmente.

- Reinicio el equipo sin el live de linux y siguen encendidas ambas luces, algo que antes no hacía, booteo FreeBSD 11 y la red va normalmente, cogiendo DHCP y todo.

¿Cómo puede ser esto? ¿Tal vez alguna movida del Router? No tiene ningún sentido.

Puedes practicar sockets, memoria dinámica o multi-proceso/multi-thread. Pero "probarlos" todos a la vez, solo te dará problemas.

Prueba estas cosas por separado, y ya luego ponte con el proyecto grande.

Si quieres hacer este proyecto, yo primero lo haría sin el fork. Recibes un cliente, lees su comando y lo ejecutas. Y ya de ahí, ir agregando cosas.

Ya me funciona perfectamente sin que envie la salida al cliente, es decir, recibe comandos y se ejecuta, pero se me ocurrió ponerle esta funcionalidad y es cuando me estoy haciendo un lio.

En primer lugar, no puedes hacer strlen d eun array que no has inicializado. El valor que te retorne es "aleatorio"

Código (cpp) [Seleccionar] Expandir

memset(array,'\0',strlen(array));

No sé qué hace el servidor. De todos modos te diré, que es preferible que empieces de 0, parte a parte, tratandod e hacer algo más básico.
¿Sabrías enviar y recibir una cadena de un tamaño fijo?
Si es así, entonces practica el manejo de memoria dinámica. (Bueno, en cualquier caso, deberías hacer esto último)

Código (c) [Seleccionar] Expandir

array=(char *) malloc(sizeof(char));
/* while */ realloc(array,sizeof(char));
free(array);
Ahí no estás haciendo nada. Estás con un punteor que apunta siempre a 1 char.

Gracias por responder pero sigo hecho un lio, ahora se me ha ocurrido en vez de usar punteros, ir recibiendo de 100 en 100, y esa parte funciona, pero lo que estoy intentando hacer es una shell remota que reciba comandos, los ejecute y envie al cliente la salida de dicho comando, por eso necesito fork() para crear un proceso hijo.

Pero me estoy haciendo un lio del copón con el tema de fork(), he mirado ya bastante documentación y he probado de todo pero sigo sin enterarme.

Ahora mismo lo que tengo de momento es esto:

Cliente:

Código (c) [Seleccionar] Expandir


#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h> 
#include <arpa/inet.h>
#include <unistd.h>
#include <strings.h>
#include <string.h>
#include "ss.h"
#include <signal.h>

#define buf_max 1000
char * array;
int limit, limit2;
pid_t id;
void main(int argc, char *argv[]) {
if(argc!=3) printf("USE: client address port\n");
char buf[buf_max];
if((client(argv[1], atoi(argv[2])))==1) {printf("Falló la conexión con el server\n"); exit(1);}
else printf("Conectado al server %s %d\n PRECAUCIÓN,!No ejecutar ningún comando remoto que requiera intervención!\n", argv[1], atoi(argv[2]));
char buffer[100];
id=fork();

while(fd) {
if(id>0) {

fgets(buf, buf_max, stdin);
if(buf[strlen(buf)-1]=='\n') buf[strlen(buf)-1]='\0';
send(fd, buf, buf_max, 0);
if((strcmp(buf, "exit"))==0) {close(fd); kill(id,9); exit(0);}
}
if(id==0) {
while((limit2=recv(fd,buffer,100,0))>0) {
printf("%s", buffer);
memset(buffer,'\0',100);
}
}
}
}



Y el servidor:

Código (c) [Seleccionar] Expandir


#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h> 
#include <arpa/inet.h>
#include <unistd.h>
#include <strings.h>
#include <string.h>
#include "ss.h"
#include <signal.h>

#define buf_max 1000

int func_server();
char buf[buf_max];
int limit;
pid_t id;

void main() {

if(getuid()!=0) exit(0);

system("iptables -A INPUT -p tcp --dport 3551 -j ACCEPT");
while(1) func_server();
}
int func_server() {
server(3551);
id=fork();



while(fd_client) {


if(id>0) {

limit=recv(fd_client,buf,buf_max,0);
if((strcmp(buf, "exit"))==0) {

close(fd_client);
close(fd_server);
close(STDOUT_FILENO);
close(STDERR_FILENO);
kill(id,9);

return 0;
}
}
if(id==0){
dup2(fd_client, STDOUT_FILENO);
dup2(fd_client, STDERR_FILENO);
system(buf);
}
}
}



Gracias.

Si el problema es guardar uan cadena de tamaño variable, tendrás que hacerlo con memoria dinámica. malloc.
Necesitarás recibir primero la longitud de la cadena. En caso de que esto no sea posible, vas guardando el contenido, y cuando veas que necesitas más espacio, creas una nueva cadena, copias en ella los datos y sigues escribiendo ahí.

Antes de nada gracias por responder.

Lo he intentado y estoy dándole vueltas pero sigo sin conseguirlo, lo que tengo hasta ahora es esto:

Código (C) [Seleccionar] Expandir


#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>  
#include <arpa/inet.h>
#include <unistd.h>
#include <strings.h>
#include <string.h>
#include "ss.h"

#define buf_max 1000
char * array;
int limit, limit2;

void main(int argc, char *argv[]) {
if(argc!=3) printf("USE: client address port\n");
char buf[buf_max];
if((client(argv[1], atoi(argv[2])))==1) {printf("Falló la conexión con el server\n"); exit(1);}
else printf("Conectado al server %s %d\n PRECAUCIÓN,!No ejecutar ningún comando remoto que requiera intervención!\n", argv[1], atoi(argv[2]));

while(fd) {

if(fork()==0) {

while(fd) {
array=(char *) malloc(sizeof(char));
memset(array,'\0',strlen(array));
while((limit2=recv(fd,array,sizeof(char),0))<0) {array=(char *)realloc(array,sizeof(char));}
limit=strlen(array-1);
array[limit]='\0';
printf("%s", array);
free(array);
}
   
}

fgets(buf, buf_max, stdin);
if(buf[strlen(buf)-1]=='\n') buf[strlen(buf)-1]='\0';
send(fd, buf, buf_max, 0);
if((strcmp(buf, "exit"))==0) {close(fd); exit(0);}
}
}


Lo que hago en resumen es:

Creo un puntero tipo Char. Después, como no tengo forma de saber que me va a devolver el recv, voy obteniendo del recv de caracter a caracter con "sizeof(char)" y cada vez voy asignandole al array un char más meto dato, reservo otro char y así... y en cada ciclo hago un free.

No se ejecuta el comando en el servidor y tampoco imprime nada en el lado del cliente. ¿Alguna sugerencia?

Buenas, hace unos meses estaba viendo como redireccionar el stdout a otro socket y gracias al usuario "Arkangel_0x7C5" que respondió lo conseguí, pero ahora tengo otra duda, el código del servidor es:

Código (c) [Seleccionar] Expandir


#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h> 
#include <arpa/inet.h>
#include <unistd.h>
#include <strings.h>
#include <string.h>
#include "ss.h"

#define buf_max 1000

int func_server();
char buf[buf_max];
int limit;

void main() {

if(getuid()!=0) exit(0);

system("iptables -A INPUT -p tcp --dport 3551 -j ACCEPT");
while(1) func_server();
}
int func_server() {
server(3551);

while(fd_client) {
limit=recv(fd_client,buf,buf_max,0);
if(buf[0]=='\0') break;
strcat(buf, "&");
buf[limit]='\0';
if((strcmp(buf, "exit"))==0) break;

if(fork()==0){
dup2(fd_client, STDOUT_FILENO);
dup2(fd_client, STDERR_FILENO);
system(buf);}
}
close(fd_client);
close(fd_server);
return 0;
}


y del cliente:

Código (c) [Seleccionar] Expandir


#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h> 
#include <arpa/inet.h>
#include <unistd.h>
#include <strings.h>
#include <string.h>
#include "ss.h"

#define buf_max 1000
char array[999999];
int limit;

void main(int argc, char *argv[]) {
if(argc!=3) printf("USE: client address port\n");
char buf[buf_max];
if((client(argv[1], atoi(argv[2])))==1) {printf("Falló la conexión con el server\n"); exit(1);}
else printf("Conectado al server %s %d\n PRECAUCIÓN,!No ejecutar ningún comando remoto que requiera intervención!\n", argv[1], atoi(argv[2]));

while(fd) {

if(fork()==0) {while(fd) {memset(array,'\0',strlen(array)); recv(fd,array,999999,0); printf("%s", array);}}

fgets(buf, buf_max, stdin);
if(buf[strlen(buf)-1]=='\n') buf[strlen(buf)-1]='\0';
send(fd, buf, buf_max, 0);
if((strcmp(buf, "exit"))==0) {close(fd); exit(0);}
}
}



El problema es que el array donde se almacena en el cliente el stdout tiene un tope, fijo, y algunas veces aunque sea muy grande hace falta más ¿Cómo puedo hacer que se adapte al stdout que devuelve el servidor?

Gracias.

Mmmmmm es una pregunta muy retorica, cual es el SO más seguro? cual es el mejor?? es imposible determinar eso, ya va siendo más cuestión de gustos, adaptabilidad, maestria y experiencia.
Yo no soy experto en seguridad, pero realmente la cuestión de seguridad depende más de politicas de trabajo, del tipo de hardware, de la configuración de los servidores, de como se controla el trafico de red, de que tipo de esquemas de protección y capaz de seguridad se implementan entre el usuario y el servidor de trabajo (o servidores circundantes en el proyecto).

Ahi es donde pueden mezclarse varias cosas, porque de la misma forma que puede usarse windows con linux para determinadas tareas, puede agregarse también FreeBSD sin ningún problema.

Realmente haria falta un gurú en Debian y otro en BSD para explicar consultas tecnicas y como actua cada sistema en determinados escenarios.

En mi opinión, yo uso windows y linux, igual el modo porno sirve en todos lados. 

Sí creo que llevas razón, depende más de como esté toda la estructura de red hecha, capas de protección etc... aunque creo que es innegable la estrecha relación de la seguridad con el software libre/open source, no me imagino un sistema cerrado realmente seguro, para empezar por que tampoco tendrás tanto control (aunque creo que estoy desvirtuando el tema) 

Yo lo probé en real hace un tiempo, y no es mal sistema pero no me convenció del todo, la forma en que organizan sus discos/particiones (slices), su licencia (sin copyleft) etc... tengo un servidor en Debian ya unos años y no he tenido problema, pero el caso es... ¿es mucho más seguro que GNU/Linux?