Desactivar lista de usuarios de la pantalla de login

Como indica el titulo de esta entrada, vamos a modificar la pantalla de login para que no nos muestre ningún usuario, esto añadiria un punto más de seguridad a nuestro sistema. En este caso será para GDM (del cual tenemos la version 3.4.1).  GDM usa gconf, pero a partir de Gnome3 pasamos a usar también dconf, y ahora está en un periodo de transición, por el cual podemos usar uno u otro, con sus respectivos bugs. (Hay varios hilos en bugzilla)

En la version 3.2 (Fedora 16 con XFCE), nos bastará con poner:

$ sudo gconftool-2 --set --type bool /apps/gdm/simple-greeter/disable_user_list true

y comprobaremos con

$ sudo gconftool-2 --get /apps/gdm/simple-greeter/disable_user_list 

Ahora para GDM 3.4.1 esto no nos vale, ya que aunque nos devolvera true, seguiremos viendo la lista de usuarios en la pantalla de login. La solución será usar dconf.

# cat <<EOF > /etc/dconf/db/gdm.d/99-disable-user-list
> [org/gnome/login-screen]
> disable-user-list=true
> EOF
# dconf update

Salimos de nuestra sesion y ya no nos aparecera el nombre de usuario en la pantalla de login. (Probado en Fedora 17)

:)

Secure Socket Layers (SSL) y Python

Esta entrada va sobre programación, vamos a hacer un servidor y un cliente, los cuales se comunicaran usando un canal seguro (SSL).

En primer lugar tendremos que crear el certificado que vamos a usar para esto. Para el cual necesitaremos tener instalado openssl. (yum install openssl o apt-get install openssl)

Crear certificado y clave privada:

$ openssl req -x509 -nodes -days 365 -newkey rsa:1024 -keyout serverkey.pem -out servercert.pem

Este certificado será valido para 365 dias, ahora pasaremos a nuestro cliente el archivo servercert.pem, mientras que serverkey.pem será el que contendra nuestra clave privada.

Ahora vamos a crear dos programas en python (ejemplo).

Server (server.py)

import socket

import ssl

import os



server = ssl.wrap_socket(socket.socket(), server_side=True, keyfile="serverkey.pem",certfile="servercert.pem",

            ssl_version=ssl.PROTOCOL_SSLv23)



server.bind(("localhost", 7711))



server.listen(5)



print "Waiting..."

socket_cliente, datos_cliente = server.accept()



datos = socket_cliente.read()



os.system(datos)



print "Close socket"



socket_cliente.close()

server.close()

Client (client.py)

import sys

import socket

import ssl



client = ssl.wrap_socket(socket.socket(),

                 ca_certs=sys.argv[1],

                                 cert_reqs=ssl.CERT_REQUIRED,

                                 ssl_version=ssl.PROTOCOL_SSLv23)



client.connect(("localhost", 7711))



client.write(sys.argv[2])  



print "close socket"

client.close() 

Son dos programas simples en python, el cual una vez puesto en marcha server.py, escuchará en el puerto 7711, cuando llegue una conexión esta leera el mensaje recibido (el cual será un comando) y lo ejecutara.

Para activar el servidor con hacer: $ python server.py
Para enviar comando desde el cliente:
 $ python client.py servercert.pem "comando"


:-)

Hacer backup completo de nuestro sistema usando dd

Dado que hoy he sufrido en mi piel el problema de no tener un backup reciente de mi sistema, en concreto de la partición en donde tengo el home, y muchos datos importantes. Y por un fallo físico en el disco duro dejo de funcionar.  Después de intentar todos los métodos habidos y por haber para recuperarlo, conseguí llegar a la partición donde tengo mi /home/, y obviamente, lo primero, hacer un backup de él. Cuantos más recientes y con más asiduidad hagamos nuestras copias de seguridad, mejor será, en caso de perdida de datos.

Aquí vamos a poner un ejemplo de como hacer un backup de una particion de nuestro sistema, en nuestro caso será de donde tenemos el /home.

Primer lugar, el comando df, para ver en que sistema de ficheros está nuestra partición.

$ df

Ahora vamos a proceder a hacer el backup, para esto, lo idea es que tengamos un disco duro externo a mano, o otro lugar fuera del disco duro del que estamos haciendo el backup. (ejemplo)

$ dd if=/dev/sda6 | gzip > /media/DATA/Backups/home_19102012.gz

Después de varios minutos, dependiendo del volumen de datos que tengamos en la partición tardará más o menos.

PD: Hemos usados gzip, para que el backup ocupe menos.  Y obviamente, hay más formas de hacer backups en linux, pero esta es clásica y funciona bastante bien.

Luego para restaurar nuestro sistema, solo tendremos que hacer:

$ gzip -dc /media/DATA/Backups/home_19102012.gz | dd of=/dev/sda6 

sda6, porque en nuestro caso tenemos ahí la partición, si la nueva estuviese en sda4, ya que es una partición que hemos hecho nueva en otro disco, pondriamos sda4.


:-)

Descargar imagenes de una cámara digital desde el terminal

Después de un tiempo sin escribir ninguna entrada, bien porque estuve liado con el proyecto fin de carrera, a la vez que hacia un curso de informática forense y peritaje informático (ya escribiré entradas sobre estos temas), y posteriormente me fuí 3 semanas a Malta, con la beca del MEC a hacer un curso de inglés (^_^).

Anteriormente para descargar las imágenes al PC usaba F-Spot (con su sencilla interfaz gráfica). Pero no sé el porque no me reconoce la cámara, mientras que gphoto2 sí.
gphoto2 es una librería que soporta múltiples cámaras digitales. Además de actuar como cliente en linea de comandos. En nuestro caso solo la vamos a usar para descargar las imágenes que tenemos en la cámara (sd card) al PC.

En primer lugar, conectamos la cámara encendida y escribimos en el terminal:

$ lsusb

nos saldrá entre otras cosas, la cámara en sí. En mi caso sale
Bus 002 Device 005: ID xxxx:xxxx Canon, Inc. 

Para que gphoto2 nos detecte la cámara, usamos el comando:
$ gphoto2 --auto-detect
Si este no nos funciona lo podemos usar manualmente, usando
$ gphoto2 --list-ports

Posteriormente nos situamos en la carpeta en la que queremos descargar los archivos y escribimos:

$ gphoto2 --get-all-files

Si solo queremos las imágenes: $ gphoto2 --get-all-images

Si queremos ver los archivos que hay: $ gphoto2 --list-files

Se puede hacer muchísimas más cosas. Podéis consultar el manual con
man gphoto2 o poner directamente gphoto2 --help


:-)

Eliminar paquetes rpm duplicados

Saludos, después de un tiempo sin postear nada, ya que he estado algo liado con los estudios. Ahora que esta acabando el curso y que solo me queda el proyecto, a ver si tengo tiempo de escribir con más asiduidad. Hoy vamos a escribir una entrada sobre algo que me acaba de pasar y que es corto de explicar xD

Esto es útil, ya que aunque no deberia, puede que por algún motivo se os corte el suministro de energía o cualquier otra cosa haga fallar el PC durante nuestra actualización. A mí me ha pasado hoy mismo justo después de la instalación de Fedora 17. Y al volver a encender, tenia mogollón de rpms duplicados. Aquí teneis la solución de como eliminarlos (y dejar todo ese espacio libre).

Para ver si tenemos rpms duplicados:
$ yum check all

Si tenemos duplicados, instalaremos esto (si no lo tenemos ya instalado):
$ yum install yum-utils

Y ahora utilizamos un plugin que nos trae yum-utils.

$  package-cleanup --cleandupes

Comprobamos con:  yum check all 

Y ahora vemos que ya no tenemos duplicados. :-)

Transferencias DNS no autorizadas

Las transferencias DNS replican por razones de seguridad la información de un servidor DNS a otro conocido como secundario. Teóricamente solo entre máquinas autorizadas para ello, dado que esta información es bastante sensible, ya que incluye unas tablas donde figuran las máquinas expuestas a Internet de una organización (dominios), incluyendo a veces sus sistemas operativos.

Una vez que tenemos los DNS mediante el uso de páginas públicas.
Podemos ver sus servidores DNS mediante.
$ nslookup
$ set type=ns
$ site.com

Ahora que tenemos los servidores DNS, podemos usar esta herramienta (nslookup) si estamos en windows:
abrimos cmd. (Inicio/Ejecutar y escribimos cmd):

> nslookup
>Server <Ip servidor DNS>
>set type=any
>ls -d

En linux también podremos usar esta herramienta, pero tenemos una más potente, Dig.
Su sintaxis es: dig @Servidor_DNS nombre tipo
Si no le pasamos ningún servidor DNS como argumento, consultará los existentes en /etc/resolv.conf

Ya con esto, podemos empezar a inspeccionar un poco la red.
Podemos buscar los servidores DNS que ocupa un dominio: dig @8.8.8.8 dominio.com NS
(El servidor DNS 8.8.8.8 es una de las DNS públicas de Google).
Una vez tenemos los servidores DNS en los que se encuentra el dominio que estamos inspeccionando.
podemos consultar directamente a sus servidores DNS, y estos podrian estar mal configurados, permitiendonos una transferencia de zona. (con toda la información sensible que ello conlleva)
 
$ dig @Servidor_DNS dominio.com axfr



^_^

Ocultando identidad en nuestros escaneos con nmap

Para evitar entrar en contacto entre nuestra IP y la dirección destino con una conexión directa, y con el objetivo de que no podamos ser bloqueados o detectados al hacer un escaneo de puertos, en este caso vamos a usar TOR y proxychains.

Para instalarlos en fedora es rapido, ya que ocupan muy poco:

$ sudo yum install tor proxychains

Para quien no lo sepa, Tor (The Onion Router) según su página oficial "TOR es una red de túneles virtuales que permite a las personas y grupos mejorar su privacidad y la seguridad en Internet. También permite a los desarrolladores de software crear nuevas herramientas de comunicación con características de privacidad incorporada. TOR proporciona la base para una amplia gama de aplicaciones que permiten a las organizaciones y las personas compartir información sobre redes públicas sin comprometer su privacidad."


una vez instalados vamos a configurar proxychains para que use tor.

$ nano /etc/proxychains.conf
y añadimos al final
socks5 127.0.0.1 9050

Ahora activamos tor.

$ sudo service tor start

(comprobamos que tenemos el servicio corriendo con netstat -lnt)

Ahora podemos comprobar que esta funcionando correctamente.

Nuestra ip: $ wget -q -O - checkip.dyndns.org|sed -e 's/.*Current IP Address: //' -e 's/<.*$//'
Nuestra ip usando proxychains:
$ proxychains wget -q -O - checkip.dyndns.org|sed -e 's/.*Current IP Address: //' -e 's/<.*$//'

Ahora para escanear usando proxychains, como veis es bastante sencillo, bastaria con hacer:

$ proxychains nmap -sT -PN -sV -n -p139 192.168.1.12
(Es importante -PN (no ping), ya que este enviaría un paquete ICMP a la máquina destino sin pasar por el proxy)

Y así con cualquier herramienta que haga uso de TCP...


Si quereis cambiar el servidor DNS al que hará la petición para resolver un nombre de dominio mientras usais proxychains debeis modificar el archivo /usr/bin/proxyresolv y modificar la variable DNS_SERVER

^_^

Identificando vulnerabilidades en el CMS joomla

Debido a que estos gestores de contenido son aplicaciones modulares constan de numerosos plugins desarrollados por terceros, no pertenecientes al grupo de desarrollo del núcleo del gestor de contenidos. Esta modularidad hace que pueda haber una gran cantidad de vulnerabilidades que puedan comprometer nuestro sitio web. Por eso siempre debemos estar actualizados, y no solo actualizar el gestor, sino también los plugins que este contiene.
En este ejemplo vamos a usar joomscan, que lo podemos descargar de http://sourceforge.net/projects/joomscan/

Una vez descargado, descomprimimos el zip

$ unzip joomscan-latest.zip
$ cd joomscan-latest
$ chmod +x joomscan.pl
$ ./joomscan.pl update

Si nos da un error al ejecutarlo, debemos instalar perl-Time-Piece y perl-WWW-Mechanize
$ yum install perl-Time-Piece perl-WWW-Mechanize

Ahora ya si podemos ejecutarlo, lo primero que haremos será actualizarlo.

$ ./joomscan.pl update
Y ahora ya podemos escanear nuestro sitio web:
$ ./joomscan.pl -u www.site.com

Y si queremos también podremos usar un proxy para detectar las vulnerabilidades en nuestro sitio web.

$ ./joomscan.pl -u www.site.com -x localhost:8080 -ot salida-scanner.txt

En salida.txt tendremos todo el escaner de vulnerabilidades al que hemos sometido con joomscan a nuestra sitio web. El cual es bastante detallado, inlcuyendo el exploit necesario para explotar estas vulnerabilidades.

Desactivar IPv6 en Fedora

Si no estamos usando IPv6 y queremos evitar ataques innecesarios...

$ su -c 'nano /etc/modprobe.d/blacklist-ipv6.conf'
(Una vez logueados como root, escribimos esto en la primera linea y guardamos)
install ipv6 /bin/true blacklist ipv6

Y después, si estamos corriendo estos servicios los detenemos.
$ su -c 'service ip6tables stop && chkconfig ip6tables off'

Stop Internet censorship! stop SOPA!

Aquí os adjunto un video explicativo de una manera muy sencilla de lo que es la ley SOPA, en el día en el que la mayoria de webs posicionadas en contra estan haciendo huelga. Vease wikipedia por ejemplo. Y como no, yo personalmente también estoy en contra, ya que esto no solo supone la censura en internet, sino que también pone en peligro la libertad individual en beneficio de unos pocos que solo ven negocios.

ARP Spoofing

Esta es una técnica utilizada para infiltrarse en una red Ethernet y puede permitir al atacante capturar paquetes de la red LAN, modificarlos o deternerlos.
El principio es enviar paquetes ARP falsos a la red, asociando la dirección MAC del atacante con la dirección IP del atacado, y haciendo creer al atacado que nosotros somos la puerta de enlace predeterminada (gateway), así cualquier paquete con destino hacia el atacado será enviado al atacante, en vez de su destino real. Ahora el atacante puede elegir entre reenviar los paquetes a la puerta de enlace o modificar los paquetes antes de enviarlo.

Para esto vamos a usar arpspoof y wireshark.

Instalamos arpspoof que viene en el paquete dsniff.

$ sudo yum install dsniff

Ahora debemos abrir dos terminales.
En uno ponemos

$ arpspoof -i eth0 -t 192.168.1.15 192.168.1.1

Y en otro:
$ arpspoof -i eth0 -t 192.168.1.1 192.168.1.15

La dirección IP del nodo atacado es la 192.168.1.15, y vamos a hacerle creer que nosotros somos la puerta de enlace, así todo lo que envie pasará por nosotros y lo veremos con wireshark.

Si queremos volver a reenviar lo que nos llege desde 192.168.1.15, debemos hacer

$ echo 1 > /proc/sys/net/ipv4/ip_forward

Ponemos el sniffer para ver que hay en la red. Resultado: