Ayer os enseñé a hacer uso del ttysnoop y ttysnoops para poder monitorizar sesiones de security shell (SSH). Uno de los puntos más molestos es que cada vez que hacemos uso del ttysnoop la aplicación nos consulta por el password de root. Y encima no podemos hacer uso de un script de "spawn/expect/send" para saltarnos este paso (ya lo he probado).
Parece ilógico, ¿verdad? Ya me he logueado como root para poder hacer uso de esta aplicación, ¿para qué voy a querer volverme a validar? Realmente lo que sucede es que
a nivel de código fuente, dentro del config.h, se define a root como el usuario snoop predeterminado. Tras analizar el código del ttysnoops, entendí que
esta solicitud de contraseña está puesta por mero capricho del programador.
En el bucle principal, a través del método authenticate, el programa crea un proceso hijo encargado de pedir al usuario la contraseña del usuario "snoop". A continuación he remarcado en rojo los valores de retorno y en verde el texto printado para solicitar el password del usuario. A primera vista el código asusta, pero veréis que es bastante inteligible.
311 void authenticate (int fd)
312 {
313 struct passwd *pw;
314
315 #ifdef SHADOW_PWD
316 struct spwd *spw;
317 #endif
318
319 int ret = 0;
320 char buff[16], *pwbuff;
321
322 if ((authpid = fork()) == 0) /* authentication child */
323 {
324 dup2 (fd, STDIN_FILENO);
325 dup2 (fd, STDOUT_FILENO);
326 dup2 (fd, STDERR_FILENO);
327 if (fd > STDERR_FILENO)
328 close (fd);
329
330 if ((pw = getpwnam(SNOOPUSER)) == NULL)
331 exit (1);
332
333 #ifdef SHADOW_PWD
334 if ((spw = getspnam(SNOOPUSER)) == NULL)
335 exit(1);
336 #endif
337
338 printf ("Connected to %s snoop server...\r\n", ptynam);
339 printf ("%s (ASCII %d) to suspend, %s (ASCII %d) to terminate.\r\n",
340 SC_STRING, SUSP_CHAR, TC_STRING, TERM_CHAR);
341 printf ("Snoop password:"); fflush (stdout);
342 if (inputs(buff, 16, stdin) == 0)
343 {
344 #ifndef SHADOW_PWD
345 if (strcmp(pw->pw_passwd, crypt(buff, pw->pw_passwd)) == 0)
346 #else
347 if (strcmp(spw->sp_pwdp, crypt(buff, spw->sp_pwdp)) == 0)
348 #endif
349 {
350 printf ("\r\nVerified OK... Snoop started.\r\n");
351 ret = 1;
352 }
353 else
354 printf ("\r\nPassword incorrect.\r\n");
355 }
356
357 fflush (stdout);
358 exit (ret);
359 }
360 }
En pocas palabras, el proceso ttyspoons crea un hijo para solicitar al usuario la contraseña de root. Este proceso verifica que el usuario root exista y que la contraseña sea válida para dicho usuario.
Ahora veamos el manejador del proceso padre, encargado de gestionar si la autenticación (realizada en el proceso hijo) ha sido correcta:
404 void sigchld (int sig)
405 {
406 int status, pid;
407 sig = sig;
408
409 if ((pid = wait(&status)) == authpid)
410 {
411 if (((status >> 8) & 0xff) == 1)
412 {
413 snoopfd = authfd;
414 fdmax = max(fdmax, snoopfd);
415 syslog (LOG_INFO, "snoop on %s (%s)", ttyname(STDIN_FILENO),
416 leafname(sockname));
417 }
418 else
419 close (authfd);
420
421 authpid = authfd = -1;
422 }
423 else if (pid == pgmpid)
424 raise (SIGHUP);
425
426 signal (SIGCHLD, sigchld);
427 }
Según el código de este manejador, para cumplir la verificación deberemos de hacer que el proceso hijo finalice con valor 1. Cualquier otro valor devolverá error de autenticación.
Visto esto, he modificado el método authenticate para que JAMAS DE LOS JAMASES se nos solicite la contraseña y que además la verificación del padre se pase de forma correcta:
357 void authenticate (int fd)
358 {
359 if ((authpid = fork()) == 0) /* authentication child */
360 {
361 dup2 (fd, STDIN_FILENO);
362 dup2 (fd, STDOUT_FILENO);
363 dup2 (fd, STDERR_FILENO);
364 if (fd > STDERR_FILENO)
365 close (fd);
366 exit(1);
367 }
368 }
Como veis el método ha adelgazado bastante... y encima funciona: Si eres root no te solicitará ninguna contraseña de usuario snoop, y si no eres root no podrás clonar ninguna terminal. Por cierto, si queréis recompilar las fuentes para Ubuntu o Debian, vais a tener que realizar
las siguientes modificaciones.
Entradas
