Diferència entre revisions de la pàgina «Manual técnico»

De Wiket
Salta a la navegació Salta a la cerca
 
(Hi ha 21 revisions intermèdies del mateix usuari que no es mostren)
Línia 1: Línia 1:
 +
==Esquema==
 +
Para empezar, vamos a presentar un esquema de los servicios utilizados en el proyecto que se ha llevado a cabo.
 +
[[Fitxer:Esquema.jpg|600px|center]]
 
== Hardware ==
 
== Hardware ==
  
Línia 50: Línia 53:
 
'''Breve explicación:''' la diferencia entre IP pública y privada es que la privada es la ip de cada dispositivo conectado a nuestra red, mientras que la pública es es el identificador de nuestra red desde el exterior, es decir, la de nuestro router de casa, que es el que es visible desde fuera.
 
'''Breve explicación:''' la diferencia entre IP pública y privada es que la privada es la ip de cada dispositivo conectado a nuestra red, mientras que la pública es es el identificador de nuestra red desde el exterior, es decir, la de nuestro router de casa, que es el que es visible desde fuera.
 
Para poder sincronizar la IP privada de nuestra raspberry con la IP pública de nuestro router y así llevar a cabo el servicio DNS, debemos introducirnos en nuestro router, poniendo en el navegador ''192.168.1.1''.<br>
 
Para poder sincronizar la IP privada de nuestra raspberry con la IP pública de nuestro router y así llevar a cabo el servicio DNS, debemos introducirnos en nuestro router, poniendo en el navegador ''192.168.1.1''.<br>
−
[[Fitxer:Puertos.PNG|500px|center]]
+
[[Fitxer:Puertos.PNG|600px|center]]
 +
Aquí vemos como hemos abierto los puertos 22 ''SSH'' y 80 ''HTTP'' para poder conectarnos remotamente con el programa '''PUTTY''' que es PuTTY es un cliente SSH, Telnet, rlogin, y TCP raw con licencia libre. A partir de ahora y gracias a esto, podemos conectarnos remotamente y desde cualquier red a nuestra Raspberry, que es lo que queríamos desde un principio.
 +
Ahora bien, para hacer el servicio DNS , debemos tener un servicio de Hosting donde asociaremos nuestra página web. El servicio Hosting lo hemos contratado de forma gratuita mediante la página [http://www.freenom.com/es/index.html Freenom]. Una vez registrados, debemos crear nuestro dominio:
 +
[[Fitxer:Freenom.PNG|600px|center]]<br>
 +
Pulsamos en manage domain para  configurar nuestro propio dominio.
 +
[[Fitxer:Dns.PNG|700px|center]]<br>
 +
Para finalizar, somos debemos introducir la URL de nuestro dominio y nos redirigirá directamente a nuestra página web.
  
 
== Instalación de la instancia LAMP ==
 
== Instalación de la instancia LAMP ==
Línia 143: Línia 152:
 
Extraremos el archivo comprimido.
 
Extraremos el archivo comprimido.
 
  tar xzvf latest.tar.gz
 
  tar xzvf latest.tar.gz
−
Creamos el archivo .htaccess y configuramos los permisos escribiendo:
+
Creamos el archivo '''.htaccess''' y configuramos los permisos escribiendo:
 
  touch wordpress/wordpress/.htaccess
 
  touch wordpress/wordpress/.htaccess
 
  chmod 660 wordpress/wordpress/.htaccess
 
  chmod 660 wordpress/wordpress/.htaccess
Línia 157: Línia 166:
  
 
==== Configurar el directorio Wordpress ====
 
==== Configurar el directorio Wordpress ====
−
Vamos a ajustar los permisos y la autoridad de Wordpress
+
Vamos a ajustar los permisos y la autoridad de Wordpress.
 
Empezaremos asignando la propiedad de los archivos en nuestro documento raíz a nuestro usuario.  
 
Empezaremos asignando la propiedad de los archivos en nuestro documento raíz a nuestro usuario.  
 
  sudo chown -R david:www-data /var/www/html
 
  sudo chown -R david:www-data /var/www/html
−
Le damos al grupo cceso de escritura a la carpeta wp-content, para poder hacer cambios en los temas y plugins.
+
Le damos al grupo acceso de escritura a la carpeta wp-content, para poder hacer cambios en los temas y plugins.
 
  sudo chmod g+w /var/www/html/wp-content
 
  sudo chmod g+w /var/www/html/wp-content
 
Tambié damos acceso al servidor web al contenido de los dos directorios:
 
Tambié damos acceso al servidor web al contenido de los dos directorios:
Línia 177: Línia 186:
 
[[Instalación de Wordpress en imágenes]]
 
[[Instalación de Wordpress en imágenes]]
  
−
== Snort en Ubuntu 16.04 ==
+
== Suricata IDS ==
 +
Suricata es un sistema de detección de intrusos gratuito y de código abierto. Es capaz de la detección de instrusión en tiempo real (IDS), prevención de intrusiones en línea (IPS). En este caso utilizaremos estas dos vertientes.
 +
Inspecciona el tráfica de la red usando reglas, y es lo que veremos más adelante.
 +
Empezaremos con la instalación de suricata
 +
=== Instalación de Suricata ===
  
−
Esta guía esta hecha para explicar detalladamente la instalación de Snort como un IDS (Intrusion Detection System), que es basa en la detección de accesos no autorizados a nuestro servidor o red.
+
Instalamos las dependencias de Suricata:
−
Utilizaremos software adicional para mejorar la funcionalidad de Snort, en nuestrop caso Snorby, que es una interfaz gráfica basada en web para ver y borrar eventos Snort.
+
  sudo apt-get -y install libpcre3 libpcre3-dbg libpcre3-dev \
−
Instalamos snort:
+
        build-essential autoconf automake libtool libpcap-dev libnet1-dev \
−
  sudo apt-get install snort
+
        libyaml-0-2 libyaml-dev zlib1g zlib1g-dev libmagic-dev libcap-ng-dev \
−
Nos pide que indiquemos la interfaz de red que debe escuchar Snort, en nuestro caso es '''wlan0'''. También hay que poner el rango de IP
+
        libjansson-dev pkg-config
−
Para empezar, instalamos las herramientas necesarias para construir el software. El paquete que mostraremos en el siguiente comando instala las herramientas:
 
−
sudo apt-get install -y build-essential git
 
−
A continuación, instalamos los requisitos de snort que están disponibles en los repositorios de Ubuntu:
 
−
sudo apt-get install -y libpcap-dev libpcre3-dev libdumbnet-dev
 
−
Para mantener ordenados los paquetes que vamos a instalar, vamos a crear una carpeta donde los ubicaremos todos.
 
−
mkdir snort_src
 
−
cd /snort_src
 
  
−
A continuación vamos a descargar el archivo fuente de Snort, compilarlo y después instalarlo:
+
Una vez hecho esto, ya podemos instalar suricata:
−
  wget https://snort.org/downloads/snort/snort-2.9.8.2.tar.gz
+
  sudo apt-get install suricata
  
−
El Snort DAQ (biblioteca de adquisición de datos) tiene algunos requisitos previos que deben instalarse:
+
Ahora entramos en ''/etc/suricata/rules/'' y creamos el archivo ''sshddos.rules'', que es el archivo donde mostramos la información que tiene la regla para llevara cabo la detección de IP's que quieren entrar a nuestro sistema.
−
sudo apt-get install -y bison flex
+
Una vez creado, ponemos el código del archivo, que es el siguiente:
−
Descargamos e instalamos la última versión de DAQ (biblioteca de adquisición de datos).
 
−
wget https://www.snort.org/downloads/snort/daq-2.0.6.tar.gz
 
−
tar -xvzf daq-2.0.6.tar.gz
 
−
cd daq-2.0.6
 
−
./configure
 
−
make
 
−
sudo make install
 
  
−
A continuación ejecutamos un comando para actualizr las bibliotecas compartidas, es importante hacerlo porque si no se hace saltará un error cuando ejecutemos Snort).
+
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN LibSSH Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"libssh";    within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000000; rev:1;)
−
  sudo ldconfig
+
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN JSCH Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"JSCH"; within:20;  reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000001; rev:1;)
−
Colocamos un enlace simbólico al binario de Snort en / usr / sbin:
+
  drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN MEDUSA Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"MEDUSA";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000002; rev:1;)
−
  sudo ln -s /usr/local/bin/snort /usr/sbin/snort
+
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN LYGhost Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"LYGhost";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000003; rev:1;)
 +
  drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN Paramiko Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"paramiko";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000004; rev:1;)
 +
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN ssh2js0 Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"ssh2js0";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000005; rev:1;)
 +
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN vngx-jsch Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"vngx-jsch";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000006; rev:1;)
 +
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN ZGrab Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"ZGrab";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000007; rev:1;)
 +
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN Granados Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"Granados";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000008; rev:1;)
 +
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN Erlang Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"Erlang";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000012; rev:1;)
 +
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN Renci Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"Renci";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000013; rev:1;)
 +
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN Twisted Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"Twisted";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000014; rev:1;)
  
−
Como no queremos que Snort se ejecute como root, debemos crear una cuenta y un grupo sin privilegios para que se ejecute el daemon (snort:snort). También crearemos una cantidad de archivos y directorios requeridos por Snort, y estableceremos permisos en esos archivos. Snort tendrá los siguientes directorios: las configuraciones y los archivos de reglas en /etc/snortAlertas se escribirán en /var/log/snortreglas compiladas (reglas .so) se almacenarán en/usr/local/lib/snort_dynamicrules
+
#drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN PuTTY Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"PuTTY"; nocase;  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000009; rev:1;)
−
Creamos usuario y grupo:
+
  #drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN OpenSSH-keyscan Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-";  content:"OpenSSH-keyscan"; within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000010; rev:1;)
−
  sudo groupadd snort
+
  #drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN OpenSSH Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"OpenSSH"; within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000011; rev:1;)
−
sudo useradd snort -r -s /sbin/nologin -c SNORT_IDS -g snort
 
−
Creamos los directorios de Snort:
 
−
sudo mkdir /etc/snort
 
−
sudo mkdir /etc/snort/rules
 
−
sudo mkdir /etc/snort/rules/iplists
 
−
sudo mkdir /etc/snort/preproc_rules
 
−
sudo mkdir /usr/local/lib/snort_dynamicrules
 
−
sudo mkdir /etc/snort/so_rules
 
−
Ahora creamos unos archivos y directorios que necesita Snort, y le daremos permisos.
 
−
sudo touch /etc/snort/rules/iplists/black_list.rules
 
−
sudo touch /etc/snort/rules/iplists/white_list.rules
 
−
sudo touch /etc/snort/rules/local.rules
 
−
  sudo touch /etc/snort/sid-msg.map
 
−
Creamos nuestros propios directorios:
 
−
  sudo mkdir /var/log/snort
 
−
sudo mkdir /var/log/snort/archived_logs
 
−
Y para finalizar ajustamos los permisos:
 
−
sudo chmod -R 5775 /etc/snort
 
−
sudo chmod -R 5775 /var/log/snort
 
−
sudo chmod -R 5775 /var/log/snort/archived_logs
 
−
sudo chmod -R 5775 /etc/snort/so_rules
 
−
sudo chmod -R 5775 /usr/local/lib/snort_dynamicrules
 
  
−
También queremos cambiar la propiedad de los archivos que creamos anteriormente para asegurarnos de que Snort pueda acceder a los archivos que usa:
+
Con el archivo de la regla ya configurado, debemos activarlo en el archivo de configuración de suricata, ubicado en /etc/suricata/suricata.yaml
−
sudo chown -R snort:snort /etc/snort
 
−
sudo chown -R snort:snort /var/log/snort
 
−
sudo chown -R snort:snort /usr/local/lib/snort_dynamicrules
 
  
−
Snort necesita unos archivos de configuración y los prepocesadores dinámicos copiados del paquete de archivos fuente en /etc/snort. Con el siguiente comando vamos a copiar estos archivos y los preprocesadores:
+
sudo nano /etc/suricata/suricata.yaml
−
  cd /snort_src/snort-2.9.11.1/etc/
+
Debemos agregar el archivo creado anteriormente, ''sshddos.rules'', y comentar los demás para activarlo.
−
  sudo cp *.conf* /etc/snort
+
rules-files:
−
sudo cp *.map /etc/snort
+
  -sshddos.rules
−
  sudo cp *.dtd /etc/snort
+
En este mismo archivo, vamosa introducir la IP de nuestra Raspberry en address-groups:
−
  cd /snort_src/snort-2.9.11.1/src/dynamic- preprocessors/build/usr/local/lib/snort_dynamicpreprocessor/
+
  vars:
−
  sudo cp * /usr/local/lib/snort_dynamicpreprocessor/
+
  # Holds the address group vars that would be passed in a Signature.
 +
  # These would be retrieved during the Signature address parsing stage.
 +
  address-groups:
 +
    ''HOME_NET: "[192.168.1.118/32]"''
 +
=== Prueba Suricata IDS ===
 +
A continuación, cogemos una máquina desde la que vamos a hacer el intento de ataque, en este caso una Kali Linux, e introducimos el siguiente comando, que lo que hace es hacer un ataque por diccionario para ver si puede averiguar el usuario y la contraseña de la Raspberry para poder conectarse.
 +
  hydra -l pi -P sshattack.txt 82.213.168.191 ssh
 +
El archivo sshattack,txt sirve para generar contraseñas aleatorias, en el que deberemos introducir la password correcta para poder hacer la prueba.<br>
 +
Ahora en nuestra raspberry, para evitar el ataque desde la máquina Kali Lunix, hay que ejecutar los siguientes comandos ''IPTables'':
 +
  sudo iptables -I INPUT -j NFQUEUE
 +
  sudo iptables -I OUTPUT -j NFQUEUE
 +
Y finalmente ejecutamos Suricata:
 +
  sudo suricata -c /etc/suricata/suricata.yaml -q 0
 +
Con estos comandos ejecutándose, será imposible conseguir el usuario y la contraseña de la máquina, tal y como queremos demostrar.

Revisió de 20:30, 11 juny 2018

Esquema

Para empezar, vamos a presentar un esquema de los servicios utilizados en el proyecto que se ha llevado a cabo.

Esquema.jpg

Hardware

1 Raspberry Pi 3 Model B 1 Micro SD 16GB
RaspberryPi.jpg MicroSD.png

Instalación OS

Montadas ya la Raspberry, debemos instalar un sistema operativo en ella para así poder llevar a cabo el proyecto. En mi caso, el sistema operativo elegido ha sido Linux, y para ser más específico, he escogido la distribución de Ubuntu, con la versión 16.04. Para empezar, descargamos la imagen: Descarga de Ubuntu 16.04

Con la imagen ya descargada, el siguiente paso es descargar algún programa para poder grabar la imagen que acabamos de descargar. El programa que he utilizado ha sido Etcher. Descarga de Etcher

Cómo utilizar Etcher
Abrimos el programa en nuestro equipo, agregamos la imagen seleccionada y y pulsamos Flash.

Etcher.jpg

Servicio SSH

SSH o Secure shell es un protocolo de administración remota que permite a los usuarios controlar y modificar sus servidores remotos a través de internet. Después de este pequeño resumen, el servicio SSH lo habilitaremos en nuestra Raspberry para poder administarla desde el otro ordenador, por comodidad del administrador. Utiliza el puerto 22 por defecto.

Habilitamos el servicio SSH con el siguiente comando: 

sudo systemctl enable ssh

Cuando ya lo tenemos activado, debemos iniciarlo para poder conectarnos: 

sudo service ssh start

Servicio DNS

El sistema de nombres de dominio​ (DNS, por sus siglas en inglés, Domain Name System) es un sistema que asigna nombres a direcciones IP. Ahora explicaremos cómo lo hemos utilizado: En primer lugar, debemos asignar una IP estática a nuestra Raspberry Pi. El archivo que lleva esta configuración es /etc/network/interfaces, el código que debemos emplear es el siguiente: 

auto wlanX
iface wlanX inet static
address 192.168.1.ZZ
gateway 192.168.1.1
netmask 255.255.255.0
wpa-ssid el_nombre_tu_red_wifi
wpa-psk la_contraseña_de_tu_wifi

Dónde wlanX hace referencia a la tarjeta de red que se utiliza.

A continuación, cómo en nuestro caso la Raspberry estará ubicada siempre en el mismo sitio (en casa), debemos conectar de alguna manera la IP privada (la configurada en el archivo anterior), con la IP pública, que es la IP del router y con la que haremos el servicio DNS.
Breve explicación: la diferencia entre IP pública y privada es que la privada es la ip de cada dispositivo conectado a nuestra red, mientras que la pública es es el identificador de nuestra red desde el exterior, es decir, la de nuestro router de casa, que es el que es visible desde fuera. Para poder sincronizar la IP privada de nuestra raspberry con la IP pública de nuestro router y así llevar a cabo el servicio DNS, debemos introducirnos en nuestro router, poniendo en el navegador 192.168.1.1.

Puertos.PNG

Aquí vemos como hemos abierto los puertos 22 SSH y 80 HTTP para poder conectarnos remotamente con el programa PUTTY que es PuTTY es un cliente SSH, Telnet, rlogin, y TCP raw con licencia libre. A partir de ahora y gracias a esto, podemos conectarnos remotamente y desde cualquier red a nuestra Raspberry, que es lo que queríamos desde un principio. Ahora bien, para hacer el servicio DNS , debemos tener un servicio de Hosting donde asociaremos nuestra página web. El servicio Hosting lo hemos contratado de forma gratuita mediante la página Freenom. Una vez registrados, debemos crear nuestro dominio:

Freenom.PNG


Pulsamos en manage domain para configurar nuestro propio dominio.

Dns.PNG


Para finalizar, somos debemos introducir la URL de nuestro dominio y nos redirigirá directamente a nuestra página web.

Instalación de la instancia LAMP

La instancia LAMP (acrónimo en inglés que significa Linux operating system, Apache HTTP Server, MySQL y PHP), es un grupo de software que se instala junto para permitir los servicios webs, en nuestro caso la página web que es la finalidad de este proyecto.

Con el primer paquete ya adquirido, el instalar Linux, que hemos hecho anteriormente agregando imagen con la distribución de Ubuntu 16.04, pasaremos al paso 2.

Instalación de Apache

Apache es un servidor web HTTP de código abierto para plataformas Unix, donde pertenece Linux. Es usado principalmente para enviar páginas web.

Actualizamos lista de paquetes disponibles y sus versiones con el siguiente comando: 

sudo apt-get update

A continuación, instalamos el paquete de apache: 

sudo apt-get install apache2

Una vez hecho esto, reiniciamos el servicio de apache para implementar los cambios: 

sudo systemctl restart apache2

Instalación de Mysql

Una vez tenemos el servidor web en funcionamiento, es momento de instalar Mysql, que es el sistema de gestión de base de datos. Su función es organizar y proporcionar el acceso a bases de datos donde nuestro servicio puede almacenar información.
Con el siguiente comando instalamos el paquete de Mysql y los paquetes de ayudar que conlleva: 

sudo apt-get install mysql-server

Instalación de PHP

A continuación instalaremos el siguiente paquete, PHP.
PHP es el componente que procesará el código para mostrar el contenido dinámico. Puede ejecutar scripts, conectarse a nuestras bases de datos MySQL para obtener información y entregar el contenido procesado a nuestro servidor web para que se muestre.
El comando para instalar PHP y los paquetes de ayuda es el siguiente: 

sudo apt-get install php libapache2-mod-php php-mcrypt php-mysql

Conclusión de LAMP

Una vez instalado al completo LAMP, vamos a instalar wordpress, donde crearemos la página web con su base de datos y sus usuarios.

Instalación de Wordpress

Lo primero que haremos es crear la base de datos y el usuario para el uso de Wordpress.
Para empezar, accederemos a la cuenta MySQL root con el siguiente comando: 

mysql -u root -p

El sistema nos pedirá la password que del usuario root de MySQL que se configuró cuando se instaló el software.

A continuación creamos la base de datos que utilizará Wordpress.
El comando es: 

CREATE DATABASE wordpress DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci;

Donde wordpress hace referencia al nombre de la base de datos.

Seguidamente crearemos la cuenta de usuario que será utilizado para operar con nuestra base de datos.
El comando para hacer lo propio es: 

GRANT ALL ON wordpress.* TO 'wordpressuser'@'localhost' IDENTIFIED BY 'password';

Donde wordpress es el nombre de la base de datos, wordpressuser hace referencia al nombre de usuario, localhost es el nombre de nuestro dominio y password hace referencia a la contraseña que queremos asignarle a ese usuario.

Con la base de datos y el usuario creados, debemos refrescar los privilegios para que se reconozcan los cambios, con el siguiente comando. 

FLUSH PRIVILEGES;

Un comando imprescindible es el de salir de mysql, se realiza escribiendo; 

EXIT;

Instalar extensiones adicionales para PHP

Con la instancia LAMP instalamos el paquete principal de PHP y ahora vamos a instalar algunas de sus extensiones más populares. 

sudo apt-get update
sudo apt-get install php-curl php-gd php-mbstring php-mcrypt php-xml php-xmlrpc

Ahora reiniciamos Apache para que reconozca las nuevas extensiones: 

sudo systemctl restart apache2

Ajustar configuración de Apache

A continuación, es necesario crear ajustes menores para la configuración de Apache. Inicialmente, el uso de los archivos .htaccess está deshabilitado. Wordpress y sus plugins usan estos archivos para ediciones dentro del directorio, parar comunicarse con el servidor web.

Habilitar sobre-escritura por .htaccess

Abrimos el archivos de configuración de Apache: 

sudo nano /etc/apache2/apache2.conf

Ahora permitimos los archivos .htaccess, debemos hacer que la directiva AllowOverride apunte a nuestro documento raíz. Agregamos el siguiente bloque al final del archivo: 

<Directory /var/www/html/>
   AllowOverride All
</Directory>

Habilitar el módulo de re escritura

Habilitamos este módulo para utilizar la función de enlaces permanentes de Wordpress: 

sudo a2enmod rewrite

Descargar Wordpress

Ahora que el software ya está configurado en el servidor, es momento de descargar y configurar Wordpress. Para empezar creamos una carpeta donde descargaremos la versión comprimida. 

mkdir wordpress

A continuación descargamos la versión comprimida: 

curl -O https://wordpress.org/latest.tar.gz

Extraremos el archivo comprimido. 

tar xzvf latest.tar.gz

Creamos el archivo .htaccess y configuramos los permisos escribiendo: 

touch wordpress/wordpress/.htaccess
chmod 660 wordpress/wordpress/.htaccess

Ahora copiamos el archivo de configuración donde Wordpress lo pueda leer: 

cp wordpress/wordpress/wp-config-sample.php 
wordpress/wordpress/wp-config.php

También creamos el directorio upgrade, para que no haya conflictos a la hora de actualizar el software: 

mkdir wordpress/wordpress/wp-content/upgrade

Para terminar vamos a copiar el contenido del directorio en nuestro documento raíz. Usamos -a para indicar que copie también los archivos ocultos, ya que .htaccess es uno de ellos. 

sudo cp -a wordpress/wordpress/. /var/www/html

Configurar el directorio Wordpress

Vamos a ajustar los permisos y la autoridad de Wordpress. Empezaremos asignando la propiedad de los archivos en nuestro documento raíz a nuestro usuario. 

sudo chown -R david:www-data /var/www/html

Le damos al grupo acceso de escritura a la carpeta wp-content, para poder hacer cambios en los temas y plugins. 

sudo chmod g+w /var/www/html/wp-content

Tambié damos acceso al servidor web al contenido de los dos directorios: 

sudo chmod -R g+w /var/www/html/wp-content/themes
sudo chmod -R g+w /var/www/html/wp-content/plugins

A continuación, vamos a configurar el método que Wordpress usará para escribir en el sistema de archivos.

Entramos en el archivo de configuración con: 

sudo nano /var/www/html/wp-config.php

Ahora configuramos los parámetros en los que hace referencia a nuestra base de datos wordpress, a nuestro usuario wordpressuser y a la contraseña password. Guardamos y ya podremos configurar gráficamente nuestro Wordpress, que es el siguiente apartado.

Instalación a través de la interfaz web

Vamos a enseñar como se configura Wordpress desde la interfaz gráfica: Instalación de Wordpress en imágenes

Suricata IDS

Suricata es un sistema de detección de intrusos gratuito y de código abierto. Es capaz de la detección de instrusión en tiempo real (IDS), prevención de intrusiones en línea (IPS). En este caso utilizaremos estas dos vertientes. Inspecciona el tráfica de la red usando reglas, y es lo que veremos más adelante. Empezaremos con la instalación de suricata

Instalación de Suricata

Instalamos las dependencias de Suricata: 

sudo apt-get -y install libpcre3 libpcre3-dbg libpcre3-dev \
       build-essential autoconf automake libtool libpcap-dev libnet1-dev \
       libyaml-0-2 libyaml-dev zlib1g zlib1g-dev libmagic-dev libcap-ng-dev \
       libjansson-dev pkg-config

Una vez hecho esto, ya podemos instalar suricata: 

sudo apt-get install suricata

Ahora entramos en /etc/suricata/rules/ y creamos el archivo sshddos.rules, que es el archivo donde mostramos la información que tiene la regla para llevara cabo la detección de IP's que quieren entrar a nuestro sistema. Una vez creado, ponemos el código del archivo, que es el siguiente: 

drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN LibSSH Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"libssh";     within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000000; rev:1;)
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN JSCH Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"JSCH"; within:20;  reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000001; rev:1;)
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN MEDUSA Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"MEDUSA";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000002; rev:1;)
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN LYGhost Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"LYGhost";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000003; rev:1;)
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN Paramiko Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"paramiko";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000004; rev:1;)
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN ssh2js0 Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"ssh2js0";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000005; rev:1;)
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN vngx-jsch Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"vngx-jsch";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000006; rev:1;)
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN ZGrab Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"ZGrab";   within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000007; rev:1;)
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN Granados Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"Granados";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000008; rev:1;)
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN Erlang Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"Erlang";   within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000012; rev:1;)
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN Renci Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"Renci";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000013; rev:1;)
drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN Twisted Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"Twisted";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000014; rev:1;)

#drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN PuTTY Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"PuTTY"; nocase;  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000009; rev:1;)
#drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN OpenSSH-keyscan Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-";  content:"OpenSSH-keyscan"; within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000010; rev:1;)
#drop ssh any any -> $HOME_NET 22 (msg:"SERIALIZINGME SCAN OpenSSH Based SSH Connections Not Allowed"; flow:established,to_server; content:"SSH-"; content:"OpenSSH";  within:20; reference:url,www.serializing.me/2015/08/12/ssh-brute-force-and-suricata/; classtype:attempted-admin; sid:5000011; rev:1;)

Con el archivo de la regla ya configurado, debemos activarlo en el archivo de configuración de suricata, ubicado en /etc/suricata/suricata.yaml 

sudo nano /etc/suricata/suricata.yaml

Debemos agregar el archivo creado anteriormente, sshddos.rules, y comentar los demás para activarlo. 

rules-files:
 -sshddos.rules

En este mismo archivo, vamosa introducir la IP de nuestra Raspberry en address-groups: 

vars:
 # Holds the address group vars that would be passed in a Signature.
 # These would be retrieved during the Signature address parsing stage.
 address-groups:
   HOME_NET: "[192.168.1.118/32]"

Prueba Suricata IDS

A continuación, cogemos una máquina desde la que vamos a hacer el intento de ataque, en este caso una Kali Linux, e introducimos el siguiente comando, que lo que hace es hacer un ataque por diccionario para ver si puede averiguar el usuario y la contraseña de la Raspberry para poder conectarse. 

hydra -l pi -P sshattack.txt 82.213.168.191 ssh

El archivo sshattack,txt sirve para generar contraseñas aleatorias, en el que deberemos introducir la password correcta para poder hacer la prueba.
Ahora en nuestra raspberry, para evitar el ataque desde la máquina Kali Lunix, hay que ejecutar los siguientes comandos IPTables: 

sudo iptables -I INPUT -j NFQUEUE
sudo iptables -I OUTPUT -j NFQUEUE

Y finalmente ejecutamos Suricata: 

sudo suricata -c /etc/suricata/suricata.yaml -q 0

Con estos comandos ejecutándose, será imposible conseguir el usuario y la contraseña de la máquina, tal y como queremos demostrar.

Obtingut de «https://wiket.esteveterradas.cat/index.php?title=Manual_técnico&oldid=4355»