iniciada migración

main
Roberto Rodríguez 1 year ago
parent a89679741f
commit 4a43f4959b

1
.gitignore vendored

@ -1 +1,2 @@
resources/ resources/
public/

@ -2,7 +2,7 @@
baseurl = "http://localhost" baseurl = "http://localhost"
languageCode = "es-es" languageCode = "es-es"
paginate = 5 paginate = 5
title = "admichin" title = "admichin 🐈"
# Theme i18n support # Theme i18n support
# Available values: en, fr, id, ja, ko, pt-br, zh-cn, zh-tw, es, de, nl, it, th, el, uk, ar # Available values: en, fr, id, ja, ko, pt-br, zh-cn, zh-tw, es, de, nl, it, th, el, uk, ar

@ -8,8 +8,8 @@ since = 2023
customText = "" customText = ""
[dateFormat] [dateFormat]
published = "Jan 02, 2006" published = "02 Jan, 2006"
lastUpdated = "Jan 02, 2006 15:04 MST" lastUpdated = "02 Jan, 2006 15:04 MST"
[sidebar] [sidebar]
emoji = "🌴" emoji = "🌴"

Binary file not shown.

After

Width:  |  Height:  |  Size: 22 KiB

@ -0,0 +1,35 @@
---
title: "Carga del fichero preseed.cfg desde red"
date: 2022-10-06T08:21:57+02:00
draft: False
tags: ["Debian","preseed"]
---
## Configuración del servidor
Para la instalación desatendida cargando el `preseed` desde red, es necesario una máquina que haga el rol de servidor, teniendo un servidor `apache2` instalado. Para preparar dicha máquina seguimos los siguientes pasos:
1. Instalamos el servidor apache en la máquina:
```bash
$ apt upgrade && apt install apache2
```
2. copiamos el fichero `preseed.cfg` previamente configurado al directorio `/var/www/html`
Tras este paso, el servidor ya está configurado y ofreciendo la configuración a la red.
## Utilización desde el cliente
Para aplicar la configuración del fichero `preseed`, iniciamos la instalación de una imagen de debian sin modificar. Para utilizarla tenemos dos opciones:
1. Utilizando línea de comandos:
1. Pulsamos la tecla ESC para abrir la línea de comandos
2. Introducimos el siguiente comando para acceder al fichero, donde `IP servidor` es la ip de la máquina que tiene el servidor apache:
```bash
boot: auto url=[IP servidor]/preseed.cfg
```
2. Utilizando las opciones avanzadas:
1. Accedemos a opciones avanzadas en el menú, seguido de instalación automatizada.
2. Introducimos la ip del servidor con apache de la siguiente manera:
```
http://[IP servidor]/preseed.cfg
```
Tras esto, la instalación desatendida comenzará.

@ -0,0 +1,4 @@
---
title: Instalación de Debian desatendida
description: Artículos subidos a la página por orden de fecha
---

Binary file not shown.

After

Width:  |  Height:  |  Size: 6.8 KiB

@ -0,0 +1,55 @@
---
title: "Creación Imagen"
date: 2022-10-06T7:00:09+02:00
draft: false
tags: ["Debian","preseed"]
---
## Descomprimimos la imagen
Vamos a utilizar la versión de debian que contiene software privativo, para, por ejemplo, tener disponibles más drivers en caso de que fueran necesarios. Tenemos que seguir los siguientes pasos:
1. Descargamos la imagen de la página de debian:
```shell
$ wget https://cdimage.debian.org/cdimage/unofficial/non-free/cd-including-firmware/current/amd64/iso-cd/firmware-11.5.0-amd64-netinst.iso
```
2. Descomprimimos la imagen utilizando `xorriso` en el directorio `isofiles/`:
```shell
$ xorriso -osirrox on -indev firmware-11.5.0-amd64-netinst.iso -extract / isofiles/
```
## Introducimos el preseed
1. copiamos el fichero `preseed.cfg` a la raíz de la imagen:
```shell
$ sudo cp preseed.cfg isofiles/preseed.cfg
```
2. Editamos el fichero `txt.cfg` (encargado del contenido del menú inicial de instalación) para añadir una opción que utilice el `preseed` además de que cargue el idioma español:
```shell
$ sudo nano isofiles/isolinux/txt.cfg
```
```shell
label install
menu label ^Install
kernel /install.amd/vmlinuz
append vga=788 initrd=/install.amd/initrd.gz --- quiet
label unattended-gnome
menu label ^Instalacion Debian Desatendida Preseed
kernel /install.amd/gtk/vmlinuz
append vga=788 initrd=/install.amd/gtk/initrd.gz preseed/file=/cdrom/preseed.cfg locale=es_ES console-setup/ask_detect=false keyboard-configuration/xkb-keymap=e>
```
## Volvemos a generar la imagen
1. Como hemos alterado los ficheros que contiene la imagen, tenemos que generar un nuevo fichero `md5sum.txt`:
```shell
$ cd isofiles/
$ chmod a+w md5sum.txt
$ md5sum `find -follow -type f` > md5sum.txt
$ chmod a-w md5sum.txt
$ cd .
```
2. Por último cambiamos los permisos de `isolinux` y creamos la imagen nueva:
```shell
$ chmod a+w isofiles/isolinux/isolinux.bin
$ genisoimage -r -J -b isolinux/isolinux.bin -c isolinux/boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table -o debian-preseed.iso isofiles
```

Binary file not shown.

After

Width:  |  Height:  |  Size: 11 KiB

@ -0,0 +1,76 @@
---
title: "Instalación basada en preseed/PXE/TFTP"
date: 2022-10-06T11:14:21+02:00
draft: false
tags: ["Debian","preseed"]
---
Para esta instalación, al igual que la anterior, es necesario que una máquina haga el rol de servidor, además en este caso tiene que tener un servidor DHCP. Para configurarla vamos a seguir los siguientes pasos. La máquina tiene que tener una red aislada sin DHCP en la que se va a conectar con los clientes
## Instalación de dnsmasq
1. Instalamos el paquete dnsmasq, encargado tanto del DHCP como del servidor TFTP
```shell
$ apt install dnsmasq
```
2. configuramos el contenido del fichero /etc/dnsmasq.conf/:
```shell
dhcp-range=192.168.100.50,192.168.100.150,255.255.255.0,12h
dhcp-boot=pxelinux.0
enable-tftp
tftp-root=/srv/tftp
```
3. En el paso anterior especificamos que se utilizara el directorio /srv/tftp/ como raíz para la transmisión por pxe; vamos a crearlo:
```shell
$ mkdir /srv/tftp/
```
4. Reiniciamos el servicio para que los cambios tengan efecto
```shell
$ systemctl restart dnsmasq
```
## Descarga de la imagen
Para instalar utilizando PXE/TFTP tenemos que utilizar una imagen de debian especial llamada netboot. Esta imagen se encuentra en la siguiente dirección: http://ftp.debian.org/debian/dists/bullseye/main/installer-amd64/current/images/netboot/netboot.tar.gz.
1. Nos desplazamos al directorio /srv/tftp/, descargamos la imagen y la descomprimimos:
```shell
$ wget http://ftp.debian.org/debian/dists/bullseye/main/installer-amd64/current/images/netboot/netboot.tar.gz
$ tar -zxf netboot.tar.gz && rm netboot.tar.gz
```
Tras este paso, el servidor ya está ofreciendo la imagen de debian a la red.
## Reglas nftables
dado que el cliente solo está conectado al servidor, no tiene ninguna conexión a internet. Por lo que el servidor, además, tiene que hacer SNAT. Para ello vamos a activar el bit de forwarding y a aplicar las siguientes reglas de nftables:
```shell
$ nft add table nat
$ nft add chain nat postrouting { type nat hook postrouting priority 100 \; }
$ nft add rule ip nat postrouting oifname "eth0" ip saddr 192.168.100.0/24 counter masquerade
$ nft list ruleset > /etc/nftables.conf
```
Si la configuración no ha persistido tras un reinicio, podemos recuperarla con:
```shell
$ nft -f /etc/nftables.conf
```
## Fichero Preseed
Para añadir el fichero preseed, tenemos dos opciones. Añadirlo a los ficheros que se están distribuyendo a través de `PXE`, o utilizar un `servidor apache`, realizándose de la misma manera que en el paso anterior.
Para utilizar el fichero `preseed.cfg` modificamos el fichero `txt.cfg` para que utilice el que estamos ofreciendo en el servidor apache:
```shell
label install
menu label ^Install
kernel debian-installer/amd64/linux
append vga=788 initrd=debian-installer/amd64/initrd.gz --- quiet
label unattended-gnome
menu label ^Instalacion Debian Desatendida Preseed
kernel debian-installer/amd64/linux
append vga=788 initrd=debian-installer/amd64/initrd.gz preseed/url=192.168.100.5/preseed.txt locale=es_ES console-setup/ask_detect=false keyboard-configuration/xkb-keymap=e>
```
# Lado del cliente
La instalación desde el lado del cliente es muy similar al paso anterior. Antes de empezar, hay que añadirle una tarjeta de red que esté en la red del DHCP, y hacer que sea una opción de arranque. Una vez hecho esto, el cliente iniciará la imagen en red, y desde ahí, podemos seguir los pasos que ya sabemos para utilizar el fichero preseed.cfg

Binary file not shown.

After

Width:  |  Height:  |  Size: 40 KiB

@ -0,0 +1,193 @@
---
title: "Poblar un directorio LDAP desde un fichero CSV"
date: 2023-02-22T12:11:48+01:00
draft: false
image: featured.png
categories:
- documentación
- Administración de Sistemas Operativos
tags:
- LDAP
- csv
- OpenStack
---
En alfa creo el siguiente fichero CSV:
```csv
Belen,Nazareth,belennazareth@gmail.com,nazareth,ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQC73j7AidXdLgiu5wJw7YgJuvOHyb6U8c04MuQyehYnMknMR8mTnWZr20npVHJ8VHYHDy8RlgbkMMBFgeVCgXJ+Im3A6Efp6HC4yj2SM+73hr1EKCLdRPzCzdtDSUtkqU9k+x2RdF3T6qD6H4Cg/nT8Sg3Qenqds4XORfDWOvntxFja2D0OhZv1MLPUD9pEj+a8D4erfiPx/gKW/Rtu89une+uiwVgK60B5CxnC8XXnXmPO3NhrgyQhVgzQZ658cUbLooxQURVlo1gnOmcqX5h+svUKN1SDbzTyy7HKSk7bbLHEhk7qDh7jSzcf80GLU0li8vXc2to8NpC00EOQ9POPivESz23gMNY8ooDtNU3Ll/xYvhtvXrJNTbuBiuVLzuopMvrQi6LVsQEWmPJzBiJ2qt8JW1KRLcnWRL4AezbxAPXuRYVnYBS3it6L0J4AZjZg63BkIIrfU7GYzrKb+z5mqUgDJhIZ4d5av+OAxPSSzNeVnyWEnWrI0k9kf9qmqhU= nazare@ThousandSunny
Antonio,Marchan,antoniomarchan@gmail.com,anthony,ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQC9kx67eVF+Eh5epqZvQfjOLamYck9lVB9w1e/JO9Nzx7Utxm0ikD4ZCuhANc42RRkbH/2xICo138IpxJtfnbf4ObmaxVpo65lweLw5e8w132v6IXHkCAU5jTdyJS08Gi5I/nEqq/ywEMWJ939zEu0Dfdi/1IDlqBjGPpeomCJCDOkZWHfFyuiHrpgbWniwjRBcQiXjlp7w76/k0K+1Xw5JQz2F/YuTHzEGXqVo7x2T32IprzONXprVd9cn5qItFES5DMHOv62t++3zAOZbLNTs+cFuZmfTkT4YQUoHPkqXCzQmM6hnSAihOQjNKZWy+zSOiTkL22tdd9q4jhUZu4VutNeEFKt4VDlLH1uEV0FCJjb5Fw2gzb62D9sjdsjNa8EZD2IcrjKrIJv83Ca7AyeED5egoFSAMfW1iFIse8pG4olOOv4FyeWtSgjgv9A+URiwkRqFd371lw6Xj0gdEokqO9sBYlcy3gfwT4BZCSlM3AMOjFCMP5kU1Z8uTowg9NM= antonio@debian
```
Creo el siguiente fichero ldif `openssh-lpk.ldif`:
```ldif
dn: cn=openssh-lpk,cn=schema,cn=config
objectClass: olcSchemaConfig
cn: openssh-lpk
olcAttributeTypes: ( 1.3.6.1.4.1.24552.500.1.1.1.13 NAME 'sshPublicKey'
DESC 'MANDATORY: OpenSSH Public key'
EQUALITY octetStringMatch
SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )
olcObjectClasses: ( 1.3.6.1.4.1.24552.500.1.1.2.0 NAME 'ldapPublicKey' SUP top AUXILIARY
DESC 'MANDATORY: OpenSSH LPK objectclass'
MAY ( sshPublicKey $ uid )
)
```
Ahora, creo un entorno virtual:
```bash
apt install python3-venv -y
python3 -m venv entorno_ldap
source entorno_ldap/bin/activate
pip install ldap3
```
Y el siguiente programa `ldap_csv.py`:
```python
#!/usr/bin/env python
import ldap3
from ldap3 import Connection, ALL
from getpass import getpass
from sys import exit
### VARIABLES
# Shell que se le asigna a los usuarios
shell = '/bin/bash'
# Ruta absoluta del directorio que contiene los directorios personales de los usuarios. Terminado en "/"
home_dir = '/home/ldap/'
# El valor inicial para los UID que se asignan al insertar usuarios.
uid_number = 500
# El GID que se le asigna a los usuarios. Si no se manda al anadir el usuario da error.
gid = 500
### VARIABLES
# Leemos el fichero .csv de los usuarios y guardamos cada linea en una lista.
with open('usuarios.csv', 'r') as usuarios:
usuarios = usuarios.readlines()
### Parametros para la conexion
ldap_ip = 'ldap://alfa.roberto.gonzalonazareno.org:389'
dominio_base = 'dc=roberto,dc=gonzalonazareno,dc=org'
user_admin = 'admin'
contrasena = getpass('Contrasena: ')
# Intenta realizar la conexion.
conn = Connection(ldap_ip, 'cn={},{}'.format(user_admin, dominio_base),contrasena)
# conn.bind() devuelve "True" si se ha establecido la conexion y "False" en caso contrario.
# Si no se establece la conexion imprime por pantalla un error de conexion.
if not conn.bind():
print('No se ha podido conectar con ldap')
if conn.result['description'] == 'invalidCredentials':
print('Credenciales no validas.')
# Termina el script.
exit(0)
# Recorre la lista de usuarios
for user in usuarios:
# Separa los valores del usuario usando como delimitador ",", y asigna cada valor a la variable correspondiente.
user = user.split(',')
cn = user[0]
sn = user[1]
mail = user[2]
uid = user[3]
ssh = user[4]
#Anade el usuario.
conn.add(
'uid={},ou=Personas,{}'.format(uid, dominio_base),
object_class =
[
'inetOrgPerson',
'posixAccount',
'ldapPublicKey'
],
attributes =
{
'cn': cn,
'sn': sn,
'mail': mail,
'uid': uid,
'uidNumber': str(uid_number),
'gidNumber': str(gid),
'homeDirectory': '{}{}'.format(home_dir,uid),
'loginShell': shell,
'sshPublicKey': str(ssh)
})
if conn.result['description'] == 'entryAlreadyExists':
print('El usuario {} ya existe.'.format(uid))
# Aumenta el contador para asignar un UID diferente a cada usuario (cada vez que ejecutemos el script debemos asegurarnos de ante mano que no existe dicho uid en el directorio ldap, o se solaparian los datos)
uid_number += 1
#Cierra la conexion.
conn.unbind()
```
Los ejecuto
```bash
python3 ldap_csv.py
```
Tras eso, podemos realizar un `ldapsearch` para comprobar que se han añadido los usuarios correctamente:
```bash
ldapsearch -x -D "cn=admin,dc=roberto,dc=gonzalonazareno,dc=org" -b "dc=roberto,dc=gonzalonazareno,dc=org" -W
```
![image-2021033016442](https://i.imgur.com/BZDGSdR.png)
Editamos el fichero `/etc/ldap/ldap.conf`
```bash
BASE dc=roberto,dc=gonzalonazareno,dc=org
URI ldap://roberto.antonio.gonzalonazareno.org
```
en el fichero `/etc/pam.d/common-session` añadimos la siguiente linea al final:
```bash
session required pam_mkhomedir.so
```
Ahora creo el siguiente script para encontrar las claves públicas del árbol de LDAP en `/opt/buscarclave.sh` y le damos permiso de ejecución:
```bash
#!/bin/bash
ldapsearch -x -u -LLL -o ldif-wrap=no '(&(objectClass=posixAccount)(uid='"$1"'))' 'sshPublicKey' | sed -n 's/^[ \t]*sshPublicKey::[ \t]*\(.*\)/\1/p' | base64 -d
```
Y le pongo permisos 755:
```bash
chmod 755 /opt/buscarclave.sh
```
Ahora compruebo que funciona:
![clave](https://i.imgur.com/zz3brvp.png)
ahora edito el fichero `/etc/ssh/sshd_config` y reinicio el servicio sshd:
```bash
AuthorizedKeysCommand /opt/buscarclave.sh
AuthorizedKeysCommandUser nobody
```
Ahora tras eso, Antonio puede conectarse con su usuario:
![image-2021033016593](https://i.imgur.com/fZ4nDBJ.jpg)

Binary file not shown.

After

Width:  |  Height:  |  Size: 83 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 63 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 214 KiB

@ -0,0 +1,235 @@
---
title: "Ansible: Escenario router-nat"
date: 2022-10-18T13:49:56+02:00
draft: false
tags: ["ansible","vagrant"]
---
Creación del siguiente escenario con un cliente y un router-nat utilizando **vagrant** y **ansible**
![escenario](escenario.png)
## Vagrant
Según el esquema de red que tenemos que replicar, vamos a crear una **red muy aislada** entre las dos máquinas. También, el router tendrá un **bridge** que será su puerta de enlace predeterminada. En el caso del cliente, esta configuración se hará más adelante. El `Vagrantfile` queda de la siguiente manera:
{{< highlight ruby "linenos=table">}}
config.vm.define :router do |router|
router.vm.box = "debian/bullseye64"
router.vm.hostname = "router"
router.vm.synced_folder ".", "/vagrant", disabled: true
router.vm.network :public_network,
:dev => "br0",
:mode => "bridge",
:type => "bridge",
use_dhcp_assigned_default_route: true
router.vm.network :private_network,
:libvirt__network_name => "red-muy-aislada",
:libvirt__dhcp_enabled => false,
:ip => "192.168.0.1",
:libvirt__forward_mode => "veryisolated"
end
config.vm.define :cliente do |cliente|
cliente.vm.box = "debian/bullseye64"
cliente.vm.hostname = "cliente"
cliente.vm.synced_folder ".", "/vagrant", disabled: true
cliente.vm.network :private_network,
:libvirt__network_name => "red-muy-aislada",
:libvirt__dhcp_enabled => false,
:ip => "192.168.0.2",
:libvirt__forward_mode => "veryisolated"
end
end
{{< / highlight >}}
Creamos las máquinas virtuales:
```bash
vagrant up
```
## Ansible
Ahora nos movemos al directorio donde se va a encontrar el **playbook** (`ansible/`). empezamos por el fichero `hosts`;
### hosts
El fichero `hosts` contiene la información de las máquinas en las que vamos a realizar el despliegue, pero antes de crearlo necesitamos conseguir las direcciones IPs que tienen asignadas en la interfaz **eth0** (la de Vagrant). Para ello usamos el siguiente comando:
{{< highlight bash "hl_lines=2" >}}
$ vagrant ssh cliente -c "hostname -I | cut -d' ' -f1" 2>/dev/null
192.168.121.77
{{< / highlight >}}
{{< highlight bash "hl_lines=6" >}}
$ vagrant ssh router -c "hostname -I | cut -d' ' -f1" 2>/dev/null
==> router: You assigned a static IP ending in ".1" to this machine.
==> router: This is very often used by the router and can cause the
==> router: network to not work properly. If the network doesn't work
==> router: properly, try changing this IP.
192.168.121.146
{{< / highlight >}}
Nos aparece una alerta ya que el router tiene una dirección IP acabada en ".1", Lo ignoramos ya que la máquina es el **router de la red**. Con la salida de ambos comandos tenemos las IPs de las máquinas y, añadiendo además las **rutas de las claves privadas**, podemos crear el fichero:
{{< highlight yaml "linenos=table,hl_lines=6 10" >}}
all:
children:
maquinas:
hosts:
cliente:
ansible_ssh_host: 192.168.121.77
ansible_ssh_user: vagrant
ansible_ssh_private_key_file: ../.vagrant/machines/cliente/libvirt/private_key
router:
ansible_ssh_host: 192.168.121.146
ansible_ssh_user: vagrant
ansible_ssh_private_key_file: ../.vagrant/machines/router/libvirt/private_key
{{< / highlight >}}
Ahora podemos crear las máquinas con `vagrant up`:
![vagrant](vagrant.png)
### site.yaml
Tras eso creamos el fichero que contiene la información de asignación de roles, que deben ser de la siguiente manera:
* **common**: Estas tareas se deben ejecutar en todos los nodos: actualizar los paquetes y añadir tu clave pública a la máquinas para poder acceder a ellas con ssh. ¿Existe algún módulo de ansible que te permita copiar claves públicas?.
* **router**: Todas las tareas necesarias para configurar router cómo router-nat y que salga a internet por eth1. Las configuraciones deben ser permanentes. ¿Existe algún módulo de ansible que te permita ejecutar sysctl?.
* **cliente**: Todas las tareas necesarias para que las máquinas conectadas a la red privada salgan a internet por eth1.
* **web**: Las tareas necesarias para instalar y configurar un servidor web con una página estática en la máquina cliente.
{{< highlight yaml "linenos=table" >}}
- hosts: all
become: true
roles:
- role: common
- hosts: router
become: true
roles:
- role: router
- hosts: cliente
become: true
roles:
- role: web
- role: cliente
{{< / highlight >}}
### Roles
Para realizar el despliegue indicado tenemos que crear los roles. Las tareas de los roles, están contenidas en una estructura de carpetas dentro de la carpeta rol, siendo de la siguiente manera:
```bash
rolejemplo
├── defaults
├── files
├── handlers
├── library
├── tasks
├── templates
└── vars
```
conteniendo las tareas que realizará. Empezaremos por **common**:
#### Common
Este rol es bastante sencillo ya que solo cuenta con un fichero `tasks/main.yaml` que contiene la instrucción para comprobar que el sistema está actualizado:
{{< highlight yaml "linenos=table" >}}
- name: Comprueba que el sistema esta actualizado
apt: update_cache=yes upgrade=yes
- name: Introduce la clave publica desde un fichero
authorized_key:
user: vagrant
state: present
key: "{{ lookup('file', '/home/roberto/.ssh/id_rsa.pub') }}"
{{< / highlight >}}
#### Router
Todas las tareas necesarias para configurar router cómo router-nat y que salga a internet por eth1. Las configuraciones deben ser permanentes. El contenido de `tasks/main.yaml` es el siguiente:
{{< highlight yaml "linenos=table" >}}
- name: Cambia el bit de forward a 1
ansible.posix.sysctl:
name: net.ipv4.ip_forward
value: '1'
sysctl_set: yes
state: present
reload: yes
- name: Configuracion de DNAT
iptables:
chain: PREROUTING
in_interface: eth1
destination_port: 80
jump: DNAT
protocol: tcp
table: nat
to_destination: 10.0.0.2:80
become: yes
- name: Configuracion de SNAT
iptables:
chain: POSTROUTING
destination: 10.0.0.0/8
jump: MASQUERADE
out_interface: eth1
table: nat
become: yes
{{< / highlight >}}
#### Web
Las tareas necesarias para instalar y configurar un servidor web con una página estática en la máquina cliente. El contenido de `tasks/main.yaml` es el siguiente:
{{< highlight yaml "linenos=table" >}}
- name: "ensure apache2 is installed"
apt:
pkg: apache2
- name: copy template index
template:
src: index.j2
dest: /var/www/html/index.html
owner: www-data
group: www-data
mode: 0644
- name: "Copiar fichero al servidor remoto"
copy:
src: fichero.html
dest: /var/www/html/fichero.html
owner: www-data
group: www-data
mode: '0644'
- name: "Copiar fichero de configuración y reiniciar el servicio"
copy:
src: etc/apache2/ports.conf
dest: /etc/apache2/ports.conf
owner: root
group: root
mode: '0644'
notify: restart apache2
{{< / highlight >}}
En esta tarea si que se utilizan otros ficheros, pero al no tener una configuración crucial, no vamos a modificarlos. Su contenido se encuentra en github.
#### Cliente
Todas las tareas necesarias para que las máquinas conectadas a la red privada salgan a internet por eth1. El contenido de `tasks/main.yaml` es el siguiente:
{{< highlight yaml "linenos=table" >}}
- name: cambiar la ruta por defecto
shell: ip route delete default && ip route add default via 10.0.0.1 && echo "post-up route add -net 10.0.0.0 netmask 255.0.0.0 gw 10.0.0.0 dev eth1" >> /etc/network/interfaces
{{< / highlight >}}
---
Finalmente, podemos ejecutar el playbook con `ansible-playbook site.yaml`:
![ansible](ansible.png)

Binary file not shown.

After

Width:  |  Height:  |  Size: 70 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 273 KiB

@ -0,0 +1,346 @@
---
title: "Administración de Bases de Datos - Auditoria"
date: 2023-02-21T08:27:43+01:00
draft: false
image: featured.png
categories:
- documentación
- Administración de Bases de Datos
tags:
- Auditoría
- Oracle
- Postgres
- MongoDB
---
### 1. Activa desde SQL*Plus la auditoría de los intentos de acceso exitosos al sistema. Comprueba su funcionamiento
Para activar la auditoría y que los datos se almacenen en la base de datos, ejecutamos el siguiente comando:
```sql
ALTER SYSTEM SET audit_trail=db scope=spfile;
```
Para comprobar que se ha activado correctamente, ejecutamos el siguiente comando:
```sql
SELECT name, value FROM v$parameter WHERE name like 'audit_trail';
```
![audit_trail](https://i.imgur.com/juhQKXU.png)
Para activar la auditoría de los intentos de acceso exitosos al sistema, ejecutamos el siguiente comando:
```sql
AUDIT CREATE SESSION WHENEVER SUCCESSFUL;
```
Ahora, tras acceder a la base de datos con el usuario restaurante (de una práctica anterior), haciendo la siguiente consulta, puedo ver que se ha almacenado la información del acceso:
```sql
SELECT OS_USERNAME, USERNAME, EXTENDED_TIMESTAMP, ACTION_NAME FROM DBA_AUDIT_SESSION;
```
![auditoria](https://i.imgur.com/Y0qJUmC.png)
### 2. Realiza un procedimiento en PL/SQL que te muestre los accesos fallidos junto con el motivo de los mismos, transformando el código de error almacenado en un mensaje de texto comprensible. Contempla todos los motivos posibles para que un acceso sea fallido
Primero, para vaciar la tabla de auditoría, ejecuto el siguiente comando:
```sql
TRUNCATE table sys.AUD$;
```
Ahora creo una sesión de auditoría para los accesos fallidos:
```sql
AUDIT CREATE SESSION WHENEVER NOT SUCCESSFUL;
```
He obtenido el significado de los códigos de error de la siguiente página: <http://johanlouwers.blogspot.com/2013/01/oracle-database-login-audit.html>
| Código | Significado |
|:-:|---|
|00911|El nombre de usuario o la contraseña contiene un carácter no válido|
|00988|Falta la contraseña o no es válida|
|01004|Inicio de sesión denegado|
|01005|Contraseña nula|
|01017|Contraseña / usuario no válidos|
|01031|Sin privilegios|
|01045|El usuario no tiene el privilegio CREATE SESSION|
|01918|No existe el user ID|
|01920|No existe el rol|
|09911|Contraseña incorrecta|
|28000|La cuenta está bloqueada|
|28001|La contraseña ha caducado|
|28002|La contraseña caducará pronto, se debe cambiar ahora|
|28003|La contraseña no es lo suficientemente compleja|
|28007|La contraseña no se puede reutilizar|
|28008|Contraseña antigua no válida|
|28009|La conexión a sys se debe realizar desde sysdba o sysoper|
|28011|La cuenta va a caducar pronto, se debe cambiar la contraseña|
|28221|La contraseña original no ha sido suministrada|
Ahora, creo el procedimiento en PL/SQL:
```sql
CREATE OR REPLACE PROCEDURE accesosFallidos
IS
CURSOR c_accesos IS
SELECT USERNAME, EXTENDED_TIMESTAMP, ACTION_NAME, RETURNCODE
FROM DBA_AUDIT_SESSION
WHERE RETURNCODE <> 0;
begin
for i in c_accesos loop
dbms_output.put_line('HORA: ' || i.EXTENDED_TIMESTAMP);
dbms_output.put_line(CHR(9)||'-USUARIO: ' || i.USERNAME);
case i.RETURNCODE
when 00911 then
dbms_output.put_line(CHR(9)||'-El nombre de usuario o la contrasena contiene un caracter no valido');
when 00988 then
dbms_output.put_line(CHR(9)||'-Falta la contrasena o no es valida');
when 01004 then
dbms_output.put_line(CHR(9)||'-Inicio de sesion denegado');
when 01005 then
dbms_output.put_line(CHR(9)||'-contrasena nula');
when 01017 then
dbms_output.put_line(CHR(9)||'-contrasena / usuario no validos');
when 01031 then
dbms_output.put_line(CHR(9)||'-Sin privilegios');
when 01045 then
dbms_output.put_line(CHR(9)||'-El usuario no tiene el privilegio CREATE SESSION');
when 01918 then
dbms_output.put_line(CHR(9)||'-No existe el user ID');
when 01920 then
dbms_output.put_line(CHR(9)||'-No existe el rol');
when 09911 then
dbms_output.put_line(CHR(9)||'-contrasena incorrecta');
when 28000 then
dbms_output.put_line(CHR(9)||'-La cuenta esta bloqueada');
when 28001 then
dbms_output.put_line(CHR(9)||'-La contrasena ha caducado');
when 28002 then
dbms_output.put_line(CHR(9)||'-La contrasena caducara pronto, se debe cambiar ahora');
when 28003 then
dbms_output.put_line(CHR(9)||'-La contrasena no es lo suficientemente compleja');
when 28007 then
dbms_output.put_line(CHR(9)||'-La contrasena no se puede reutilizar');
when 28008 then
dbms_output.put_line(CHR(9)||'-contrasena antigua no valida');
when 28009 then
dbms_output.put_line(CHR(9)||'-La conexión a sys se debe realizar desde sysdba o sysoper');
when 28011 then
dbms_output.put_line(CHR(9)||'-La cuenta va a caducar pronto, se debe cambiar la contrasena');
when 28221 then
dbms_output.put_line(CHR(9)||'-La contrasena original no ha sido suministrada');
end case;
end loop;
end;
/
```
Compruebo que funciona correctamente:
![accesosFallidos](https://i.imgur.com/FGHbSQV.png)
### 3. Activa la auditoría de las operaciones DML realizadas por SCOTT. Comprueba su funcionamiento
Activo la auditoría de las operaciones DML realizadas por SCOTT:
```sql
AUDIT INSERT TABLE, UPDATE TABLE, DELETE TABLE BY SCOTT BY ACCESS;
```
Ahora inserto un empleado en la tabla emp:
```sql
INSERT INTO emp VALUES (9999, 'Roberto', 'Director', 7839, TO_DATE('21/02/2023', 'DD/MM/YYYY'), 5000, 0, 10);
```
Y se ve reflectado en la tabla de auditoría:
```sql
SELECT USERNAME, OBJ_NAME, ACTION_NAME, EXTENDED_TIMESTAMP FROM DBA_AUDIT_OBJECT;
```
![auditoriaDML](https://i.imgur.com/33VAXWP.png)
### 4. Realiza una auditoría de grano fino para almacenar información sobre la inserción de empleados con sueldo superior a 2000 en la tabla emp de scott
La auditoría de grano fino (FGA) es como una versión extendida de la auditoría estándar. Registra los cambios en datos muy concretos a nivel de columna.
Para realizar la auditoría de grano fino, primero tengo que crear una política de auditoría:
```sql
BEGIN
DBMS_FGA.ADD_POLICY (
OBJECT_SCHEMA => 'SCOTT',
OBJECT_NAME => 'EMP',
POLICY_NAME => 'SALARIO_MAYOR_2000',
AUDIT_CONDITION => 'SAL < 2000',
STATEMENT_TYPES => 'INSERT'
);
END;
/
```
Ahora inserto varios empleados:
```sql
INSERT INTO emp VALUES (2222, 'Bill Gates', 'Director', 7839, TO_DATE('21/02/2023', 'DD/MM/YYYY'), 1000, 0, 10);
INSERT INTO emp VALUES (3333, 'Steve Jobs', 'Director', 7839, TO_DATE('21/02/2023', 'DD/MM/YYYY'), 5000, 0, 10);
```
![auditoriaGranoFino](https://i.imgur.com/rqLZNLq.png)
Y compruebo que aparece en la tabla de auditoría:
```sql
SELECT DB_USER, OBJECT_NAME, SQL_TEXT, EXTENDED_TIMESTAMP FROM DBA_FGA_AUDIT_TRAIL WHERE POLICY_NAME='SALARIO_MAYOR_2000';
```
![auditoriaGranoFino](https://i.imgur.com/EseLG8U.png)
### 5. Explica la diferencia entre auditar una operación by access o by session ilustrándolo con ejemplos
Las operaciones by access se auditan por cada acceso a la base de datos, mientras que las operaciones by session se auditan por cada sesión de usuario. Por ejemplo, si un usuario realiza 10 accesos a la base de datos, se auditarán 10 operaciones by access, mientras que si realiza 10 accesos en una misma sesión, se auditarán 1 operación by session.
La sintaxis es la siguiente:
```sql
AUDIT [operación] [tabla] BY [usuario] BY {ACCESS | SESSION};
```
### 6. Documenta las diferencias entre los valores db y db, extended del parámetro audit_trail de ORACLE. Demuéstralas poniendo un ejemplo de la información sobre una operación concreta recopilada con cada uno de ellos
Ambos parámetros indican que la auditoría está activada. La diferencia es que el parámetro db guarda la información en la tabla de auditoría, mientras que el parámetro db, extended guarda la información en la tabla de auditoría y en el archivo de alerta.
Para cambiar el parámetro, utilizo el siguiente comando:
```sql
ALTER SYSTEM SET audit_trail = db, extended SCOPE = SPFILE;
```
Reinicio la base de datos y compruebo que el parámetro se ha cambiado correctamente, con la consulta del ejercicio 1:
![auditTrail](https://i.imgur.com/sIytDAc.png)
### 7. Averigua si en Postgres se pueden realizar los cuatro primeros apartados. Si es así, documenta el proceso adecuadamente
#### Ejercicio 1
En postgres no se puede realizar el ejercicio 1, ya que se registran los inicios de sesión fallidos en el archivo de log, pero no los exitosos.
#### Ejercicio 2
No se puede realizar un procedimiento ya que los accesos fallidos no está registrado en la base de datos, sino en el archivo de log, sin embargo, en el propio archivo de log, se encuentran explicados con palabras y en español, el objetivo final del procedimiento:
![accesosFallidos](https://i.imgur.com/n9IuvtS.png)
#### Ejercicio 3
Para realizar la auditoría voy a usar **Trigger 91plus**, una herramienta creada por la comunidad que permite auditar las operaciones DML en postgres.
Para instalarla, primero tengo que descargar de github el siguiente fichero
```bash
wget https://raw.githubusercontent.com/2ndQuadrant/audit-trigger/master/audit.sql
```
Y luego lo instalo:
```sql
\i audit.sql
```
![instalacionTrigger](https://i.imgur.com/yYJq9ye.png)
No puede realizar auditorías de todo lo que realiza un usuario, sino de tablas. Por lo que voy a especificar las tablas del usuario scott que quiero auditar:
```sql
SELECT audit.audit_table('scott.emp');
SELECT audit.audit_table('scott.dept');
```
### 8. Averigua si en MySQL se pueden realizar los apartados 1, 3 y 4. Si es así, documenta el proceso adecuadamente
#### Ejercicio 1
Para obtener los datos de los inicios de sesión, edito el fichero `/etc/mysql/mariadb.conf.d/50-server.cnf`:
```bash
general_log_file = /var/log/mysql/mysql.log
general_log = 1
log_error = /var/log/mysql/error.log
```
Cambio el propietario del directorio de los logs y reinicio el servicio:
```bash
chown -R mysql:mysql /var/log/mysql
systemctl restart mariadb.service
```
Ahora, tras varios inicios de sesión, compruebo el fichero de logs `/var/log/mysql/mysql.log`:
![mysqlLog](https://i.imgur.com/fpOjaLH.png)
#### Ejercicio 3
Para realizar la auditoría voy a instalar el plugin `server_audit`:
```sql
INSTALL SONAME 'server_audit';
```
Ahora edito el fichero `/etc/mysql/mariadb.conf.d/50-server.cnf` y reinicio mariadb:
```bash
[server]
server_audit_events=CONNECT,QUERY,TABLE
server_audit_logging=ON
server_audit_incl_users=scott
```
Tras insertar un nuevo empleado, compruebo el fichero de log `/var/lib/mysql/server_audit.log`:
![mysqlLog](https://i.imgur.com/GAOO4Kz.png)
### 9. Averigua las posibilidades que ofrece MongoDB para auditar los cambios que va sufriendo un documento. Demuestra su funcionamiento
Para realizar las auditorías, es necesario instalar la versión Enterprise. La documentación de instalación oficial se encuentra en el siguiente enlace [https://www.mongodb.com/docs/manual/tutorial/install-mongodb-enterprise-on-debian/](https://www.mongodb.com/docs/manual/tutorial/install-mongodb-enterprise-on-debian/). Una vez instalado podemos hacer lo siguiente:
- Habilitar las auditorías en el syslog desde la consola:
```bash
mongod --dbpath /var/lib/mongodb/ --auditDestination syslog
```
- Habilitar las auditorías en un fichero JSON desde la consola:
```bash
mongod --dbpath /var/lib/mongodb/ --auditDestination file --auditFormat JSON --auditPath /var/lib/mongodb/auditLog.json
```
- Habilitar las auditorías en un fichero BSON desde la consola:
```bash
mongod --dbpath /var/lib/mongodb/ --auditDestination file --auditFormat BSON --auditPath /var/lib/mongodb/auditLog.bson
```
- Habilitar las auditorías en la consola desde la consola:
```bash
mongod --dbpath /var/lib/mongodb/ --auditDestination console
```
He utilizado la salida por consola y preferencia de formato ya que se trata también de un json.
```bash
mongod --dbpath /var/lib/mongodb/ --auditDestination console | jq
```
![mongoAudit](https://i.imgur.com/DNdM1aZ.png)
### 10. Averigua si en MongoDB se pueden auditar los accesos a una colección concreta. Demuestra su funcionamiento

Binary file not shown.

After

Width:  |  Height:  |  Size: 51 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 45 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 24 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 19 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 197 KiB

@ -0,0 +1,128 @@
---
title: "Compilación de un programa en C utilizando un Makefile"
date: 2022-10-16T23:46:57+02:00
draft: False
---
**Enunciado:** Elige el programa escrito en C que prefieras y comprueba en las fuentes que exista un fichero Makefile o Configure. Deberás compilar desde las fuentes.
Realiza los pasos necesarios para compilarlo e instálalo en tu equipo en un directorio que no interfiera con tu sistema de paquetes (/opt, /usr/local, etc.)
La corrección se hará en clase y deberás ser capaz de explicar qué son todos los ficheros que se hayan instalado y realizar una desinstalación limpia.
El programa elegido es `htop`, ya que está escrito en **C**. De momento no tiene ninguno de los ficheros requeridos, pero ejecutando el script `autogen.sh` se crea el fichero configure.
## Instalación
Para obtener las fuentes ejecutamos el siguiente comando:
```bash
apt source htop
```
ó
```bash
wget http://deb.debian.org/debian/pool/main/h/htop/htop_3.0.5.orig.tar.gz
tar -xvf htop_3.0.5.orig.tar.gz
```
### Configure
De momento el fichero no existe. Ejecutamos `autogen.sh`. Necesitaremos además el paquete `autoconf`:
```bash
sudo apt install autoconf
```
```bash
./autogen.sh
```
![ejecucion script autogen](autogen.png)
Podemos comprobar que se ha generado el fichero **configure**:
![ls del directorio de htop](ls-directorio.png)
Podemos ejecutar el fichero configure directamente. Sin embargo, de cara a una desinstalación más sencilla y a poder tener más localizados los ficheros instalados, vamos a cambiar la ruta que hay por defecto, al directorio `opt`. Se hace añadiendo la siguiente opción:
```bash
sudo mkdir /opt/htop
./configure --prefix=/opt/htop/
```
![salida de la ejecución de configure](configure.png)
En el caso de que se de algún error en la salida del comando, hay que instalar las **dependencias** indicadas, y repetir el paso anterior.
```bash
sudo apt install libncurses*
```
### Makefile
Para poder ejecutar `make` necesitamos el paquete `build-essential`, que contiene las utilidades esenciales para compilar un paquete en Debian.
```bash
sudo apt install build-essential
```
Para instalar el paquete ejecutamos:
```bash
sudo make install
sudo make clean
```
Para generar el fichero `.deb` es **necesario** que el paquete descargado sea con `apt source`, o la versión específica de debian.
o bien, para generar el fichero .deb:
instalamos las siguientes dependencias:
```bash
sudo apt install libnl-3-dev libnl-genl-3-dev libsensors-dev pkg-config debhelper-compat
# o bien con apt-get build-dep
sudo apt-get build-dep htop
```
```bash
make
dpkg-buildpackage -b
make clean
sudo dpkg -i ../htop_3.0.5-7_amd64.deb
```
![ejecucion de comando make](make.png)
El paquete ya está instalado. Podemos comprobar los ficheros creados en `/opt`:
![tree del directorio htop](tree-htop.png)
Entre los ficheros que aparecen, los más importantes son el propio **binario** de htop, y el **manual**.
Para poder utilizar el comando la terminal tenemos que añadirlo al **PATH**. Para hacerlo, añadimos la siguiente línea al fichero `.bashrc`:
```bash
export PATH="/opt/htop/bin:$PATH"
```
### Manual
Ya que lo hemos instalado en un directorio personal, no se ha creado el manual. Para hacerlo tenemos que crear un enlace simbólico:
```bash
sudo mkdir /usr/local/man/man1
sudo ln -s /opt/htop/share/man/man1/* /usr/local/man/man1/
```
## Desinstalación
Para desinstalar el paquete vamos a utilizar otra vez el comando make, esta vez con la opción `uninstall`:
```bash
sudo make uninstall
```
![ejecucion de make uninstall](desinstalar.png)
Tras eso, comprobamos si queda algo en la ubicación de la instalación:
![estructura residual](estructura.png)
la estructura de carpetas no se ha borrado, la borramos de manera manual.
Por último, hay que eliminar la línea de `.bashrc` que añade la ruta al `PATH` y eliminar el enlace simbólico:
```bash
sudo rm /usr/local/man/man1/htop.1
```

Binary file not shown.

After

Width:  |  Height:  |  Size: 122 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 46 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 22 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 395 KiB

@ -0,0 +1,405 @@
---
title: "Sistema de copias de seguridad"
date: 2023-03-07T02:15:04+01:00
draft: false
image: featured.png
categories:
- documentación
- Administración de Sistemas Operativos
tags:
- bacula
- copia de seguridad
- OpenStack
---
## Enunciado
Implementar un sistema de copias de seguridad para las instancias del cloud, teniendo en cuenta las siguientes características:
* Selecciona una aplicación para realizar el proceso: bacula, amanda, shell script con tar, rsync, dar, afio, etc.
* Utiliza una de las instancias como servidor de copias de seguridad, añadiéndole un volumen y almacenando localmente las copias de seguridad que consideres adecuadas en él.
* El proceso debe realizarse de forma completamente automática
* Selecciona qué información es necesaria guardar (listado de paquetes, ficheros de configuración, documentos, datos, etc.)
* Realiza semanalmente una copia completa
* Realiza diariamente una copia incremental o diferencial (decidir cual es más adecuada)
* Implementa una planificación del almacenamiento de copias de seguridad para una ejecución prevista de varios años, detallando qué copias completas se almacenarán de forma permanente y cuales se irán borrando
* Selecciona un directorio de datos "críticos" que deberá almacenarse cifrado en la copia de seguridad, bien encargándote de hacer la copia manualmente o incluyendo la contraseña de cifrado en el sistema
* Incluye en la copia los datos de las nuevas aplicaciones que se vayan instalando durante el resto del curso
* Utiliza una ubicación secundaria para almacenar las copias de seguridad. Solicita acceso o la instalación de las aplicaciones que sean precisas.
La corrección consistirá tanto en la restauración puntual de un fichero en cualquier fecha como la restauración completa de una de las instancias la última semana de curso.
---
El escenario es el siguiente_
![escenario](https://fp.josedomingo.org/sri2223/4_iaas/img/os.drawio.png)
| Máquina | IPs | tipo |
| :-: | :-: | :-: |
| alfa | 172.22.200.218, 172.16.0.1, 192.168.0.1 | Debian |
| bravo | 172.16.0.200 | Rocky Linux |
| charlie | 192.168.0.2 | Contenedor ubuntu |
| delta | 192.168.0.3 | Contenedor ubuntu |
### Preparaciones previas
Y he decidido hacer las copias de seguridad desde alfa, ya que tiene conexión directa con las otras instancias. Para ello, voy a utilizar **bacula**, junto con su interfaz web **baculum**, tras ver las características de las distintas herramientas.
Antes de la instalación, compruebo que en alfa en total se han usado en disco 4.5 GB y en bravo 1.9 GB. Como charlie y delta son contenedores, el espacio ya se ha contado en alfa. Teniendo en cuenta el espacio usado, con un disco de 30 GB debería ser suficiente para guardar las copias de seguridad, tanto incrementales como completas.
Al disco le he instalado XFS por sus características de tolerancia a fallos, y lo he añadido a `/etc/fstab` para que se monte automáticamente al iniciar el sistema.
Creo la carpeta `/bacula` en la que va a estar montado permanentemente el disco, y le cambio el propietario y los permisos:
```bash
mkdir -p /bacula
chown -R bacula:bacula /bacula/
chmod 755 -R /bacula
```
Ahora, añado la siguiente línea al fichero `/etc/fstab`:
```bash
UUID=5f086e6b-6937-460b-93ab-1a65a9e12544 /bacula xfs defaults 0 1
```
## Instalación de bacula
Primero instalo los paquetes de bacula
```bash
apt install bacula bacula-common-mysql bacula-director-mysql
```
Durante la instalacion de `bacula-director-mysql` pregunta lo siguiente, le doy a yes e introduzco la contraseña de la base de datos.
![bacula-director-mysql](https://i.imgur.com/R9BRtUi.png)
Ahora instalo baculum, primero añado los repositorios:
```bash
wget -qO - http://www.bacula.org/downloads/baculum/baculum.pub | apt-key add -
echo "deb http://www.bacula.org/downloads/baculum/stable/debian buster main
deb-src http://www.bacula.org/downloads/baculum/stable/debian buster main" > /etc/apt/sources.list.d/baculum.list
```
Primero instalo los paquetes de la api
```bash
apt update
apt-get install apache2 baculum-common baculum-api baculum-api-apache2
a2enmod rewrite
a2ensite baculum-api
systemctl restart apache2
```
Y ahora los paquetes de la interfaz web
```bash
apt-get install baculum-common baculum-web baculum-web-apache2
a2enmod rewrite
a2ensite baculum-web
systemctl restart apache2
```
#### Configuración de la api
Primero accedo a http://172.22.200.218:9096/ , introduzco el usuario y contraseña por defecto (admin/admin) y configuro la api:
![configuracion api](https://i.imgur.com/PnRV17i.png)
Ahora, para permitir el acceso a la consola de bacula, edito el fichero `nano /etc/sudoers.d/baculum-api` y añado las siguiente líneas:
```bash
Defaults:www-data !requiretty
www-data ALL = (root) NOPASSWD: /usr/sbin/bconsole
www-data ALL = (root) NOPASSWD: /usr/sbin/bdirjson
www-data ALL = (root) NOPASSWD: /usr/sbin/bsdjson
www-data ALL = (root) NOPASSWD: /usr/sbin/bfdjson
www-data ALL = (root) NOPASSWD: /usr/sbin/bbconsjson
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl start bacula-dir
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl stop bacula-dir
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl restart bacula-dir
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl start bacula-sd
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl stop bacula-sd
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl restart bacula-sd
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl start bacula-fd
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl stop bacula-fd
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl restart bacula-fd
```
![sudoers](https://i.imgur.com/H6QUnsE.png)
![confuracionapi2](https://i.imgur.com/5bNs8rG.png)
![confuracionapi3](https://i.imgur.com/OygLekr.png)
![confuracionapi4](https://i.imgur.com/57Vn21e.png)
Ahora creamos un usuario y una contraseña para la api
![confuracionapi5](https://i.imgur.com/dKYQjql.png)
Configuramos, ahora si, baculum en http://172.22.200.218:9095/
![confbaculum](https://i.imgur.com/mcdrvnm.png)
y utilizamos las credenciales de la api en la configuración:
![confbaculum2](https://i.imgur.com/YnQYUAz.png)
![confbaculum3](https://i.imgur.com/fbTDdCT.png)
## Configuración del servidor en alfa
### Selecciona qué información es necesaria guardar
En todas las instancias voy a guardar el contenido de /home, /etc, /var, /opt, /usr/share (menos los archivos temporales de var). Además de esto, en diferentes instancias voy a guardar lo siguiente:
| Instancia | Servicios | Localización |
| --- | --- | --- |
| alfa | bacula | /var/log |
| bravo | httpd | /var/www, /etc/httpd |
| charlie | dns | /var/chache/bind, /etc/bind |
| delta | correo | /etc/postfix |
Cada día voy a hacer copias incrementales, cada semana se realizará una completa, al igual que cada mes.
Teniendo en cuenta esto, voy a configurar alfa utilizando los ficheros de configuración (por facilidad respecto a la interfaz web). Primero edito el fichero `/etc/bacula/bacula-dir.conf`, cambiando su contenido por el siguiente (es un fichero en mi github debido a la longitud del mismo):
[bacula-dir.conf](https://github.com/robertorodriguez98/bacula/blob/main/alfa/bacula-dir.conf)
compruebo que no hay errores en el fichero de configuración:
```bash
bacula-dir -t -c /etc/bacula/bacula-dir.conf
```
Y tras eso, modifico el fichero `/etc/bacula/bacula-sd.conf`,que contiene la configuración referente a los dispositivos de almacenamiento, cambiando su contenido por el siguiente (es un fichero en mi github debido a la longitud del mismo):
[bacula-sd.conf](https://github.com/robertorodriguez98/bacula/blob/main/alfa/bacula-sd.conf)
Al igual que antes, compruebo que no hay errores en el fichero de configuración:
```bash
bacula-sd -t -c /etc/bacula/bacula-sd.conf
```
y reinicio los servicios:
```bash
systemctl restart bacula-sd.service
systemctl enable bacula-sd.service
systemctl restart bacula-director.service
systemctl enable bacula-director.service
```
## Preparación de los clientes
### Alfa
Alfa va a ser a la vez cliente y servidor, por lo que voy a instalar el cliente también en alfa:
```bash
apt install bacula-client
systemctl enable bacula-fd.service
```
Ahora modifico el fichero `/etc/bacula/bacula-fd.conf`:
```bash
Director {
Name = alfa-dir
Password = "bacula"
}
Director {
Name = alfa-mon
Password = "bacula"
Monitor = yes
}
FileDaemon { # this is me
Name = alfa-fd
FDport = 9102 # where we listen for the director
WorkingDirectory = /var/lib/bacula
Pid Directory = /run/bacula
Maximum Concurrent Jobs = 20
Plugin Directory = /usr/lib/bacula
FDAddress = 10.0.0.247
}
# Send all messages except skipped files back to Director
Messages {
Name = Standard
director = alfa-dir = all, !skipped, !restored
}
```
Y reinicio el servicio:
```bash
systemctl restart bacula-fd.service
```
### Bravo
Instalo el cliente
```bash
sudo dnf install bacula-client
```
Y edito el fichero `/etc/bacula/bacula-fd.conf` y añado las siguientes líneas:
```bash
Director {
Name = alfa-dir
Password = "bacula"
}
Director {
Name = alfa-mon
Password = "bacula"
Monitor = yes
}
FileDaemon {
Name = bravo-fd
FDport = 9102
WorkingDirectory = /var/lib/bacula
Pid Directory = /run/bacula
Maximum Concurrent Jobs = 20
Plugin Directory = /usr/lib/bacula
FDAddress = 172.16.0.200
}
Messages {
Name = Standard
director = alfa-dir = all, !skipped, !restored
}
```
```bash
firewall-cmd --permanent --add-port=22/tcp
firewall-cmd --permanent --add-port=80/tcp
firewall-cmd --permanent --add-port=9101/tcp
firewall-cmd --permanent --add-port=9102/tcp
firewall-cmd --permanent --add-port=9103/tcp
firewall-cmd --reload
```
### Charlie y delta
La configuración en charlie y delta es similar, por eso la pongo junta:
```bash
sudo apt install bacula-client
```
Y edito el fichero `/etc/bacula/bacula-fd.conf`:
```bash
Director {
Name = alfa-dir
Password = "bacula"
}
Director {
Name = alfa-mon
Password = "bacula"
Monitor = yes
}
FileDaemon { # this is me
Name = delta-fd
FDport = 9102 # where we listen for the director
WorkingDirectory = /var/lib/bacula
Pid Directory = /run/bacula
Maximum Concurrent Jobs = 20
Plugin Directory = /usr/lib/bacula
FDAddress = 192.168.0.3
}
# Send all messages except skipped files back to Director
Messages {
Name = Standard
director = alfa-dir = all, !skipped, !restored
}
```
Y reinicio el servicio:
```bash
systemctl restart bacula-fd.service
```
Ahora, con todos los cliente configurados, reinicio los servicios de bacula en alfa:
```bash
systemctl restart bacula-fd.service
systemctl restart bacula-sd.service
systemctl restart bacula-director.service
```
y hago una prueba de conexión usando la consola de bácula y la interfaz web:
```bash
bconsole
```
![bconsole](https://i.imgur.com/PCa4pzo.png)
![web](https://i.imgur.com/EWP7PH0.png)
## Nodos de almacenamiento
Ahora voy a crear los nodos de almacenamiento con bconsole
```bash
bconsole
```
![bconsole](https://i.imgur.com/pkpErri.png)
También se puede hacer desde la interfaz web:
![web](https://i.imgur.com/DKz9aUK.png)
Realizo la misma configuración para vol-semanal y vol-mensual.
Podemos ver que se han creado los volúmenes:
![web](https://i.imgur.com/WOVsDgp.png)
## Restauración
Voy a realizar la restauración por medio de la interfaz web. Para ello utilizo la opción de Perform restore y sigo los siguientes pasos:
![web](https://i.imgur.com/WpBBp3u.png)
![web2](https://i.imgur.com/g4kd0Ri.png)
![web3](https://i.imgur.com/SYrgbek.png)
![web4](https://i.imgur.com/0Z7Z7Zg.png)
Selecciono qué quiero copiar y donde:
![web5](https://i.imgur.com/rgz94GM.png)
![web6](https://i.imgur.com/DlrJT2c.png)
y que reemplace los ficheros más antiguos:
![web7](https://i.imgur.com/Y38EHgZ.png)
Cuando acabe puedo ver que se ha ejecutado con éxito:
![web8](https://i.imgur.com/6Gok1iW.png)

Binary file not shown.

After

Width:  |  Height:  |  Size: 407 KiB

@ -0,0 +1,243 @@
---
title: "Cortafuegos I: De nodo con iptables"
date: 2023-02-15T23:46:36+01:00
draft: false
---
Enunciado: [https://fp.josedomingo.org/seguridadgs/u03/ejercicio1.html](https://fp.josedomingo.org/seguridadgs/u03/ejercicio1.html)
## Preparación
**Limpiamos las reglas previas**
```bash
iptables -F
iptables -t nat -F
iptables -Z
iptables -t nat -Z
```
**Acceso por SSH**
Antes de añadir la política por defecto voy a añadir reglas para permitir el acceso por ssh
```bash
iptables -A INPUT -s 172.22.0.0/16 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -d 172.22.0.0/16 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
```
Estas reglas sirve para acceder desde la misma red, además añado las siguientes para acceder a través de la VPN
```bash
iptables -A INPUT -s 172.29.0.0/16 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -d 172.29.0.0/16 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
```
Ahora añado las **políticas por defecto**
```bash
iptables -P INPUT DROP
iptables -P OUTPUT DROP
```
Ahora pruebo que se han aplicado, por ejemplo, haciendo un ping:
![ping](https://i.imgur.com/GgWurZe.png)
**Permitimos tráfico por la interfaz de loopback**
```bash
iptables -A INPUT -i lo -p icmp -j ACCEPT
iptables -A OUTPUT -o lo -p icmp -j ACCEPT
```
**Peticiones y respuestas del protocolo ICMP**
```bash
iptables -A INPUT -i ens3 -p icmp --icmp-type echo-reply -j ACCEPT
iptables -A OUTPUT -o ens3 -p icmp --icmp-type echo-request -j ACCEPT
```
Pruebo que funciona haciendo un ping
![ping2](https://i.imgur.com/eTTjjEV.png)
**Consultas y respuestas DNS**
```bash
iptables -A OUTPUT -o ens3 -p udp --dport 53 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -i ens3 -p udp --sport 53 -m state --state ESTABLISHED -j ACCEPT
```
Pruebo que funciona haciendo una consulta DNS
![dns](https://i.imgur.com/Ep1vuVz.png)
**Tráfico HTTP**
```bash
iptables -A OUTPUT -o ens3 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -i ens3 -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT
```
Pruebo que funciona haciendo una consulta HTTP
![http](https://i.imgur.com/aB17haB.png)
**Tráfico HTTPS**
```bash
iptables -A OUTPUT -o ens3 -p tcp --dport 443 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -i ens3 -p tcp --sport 443 -m state --state ESTABLISHED -j ACCEPT
```
Pruebo que funciona haciendo una consulta HTTPS
![https](https://i.imgur.com/BzyJeje.png)
**Tráfico HTTP/HTTPs**
Los dos puntos anteriores se pueden resumir en una sola regla
```bash
iptables -A OUTPUT -o ens3 -p tcp -m multiport --dports 80,443 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -i ens3 -p tcp -m multiport --sports 80,443 -m state --state ESTABLISHED -j ACCEPT
```
**Acceso al servidor web**
```bash
iptables -A INPUT -i ens3 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -o ens3 -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT
```
Pruebo que funciona haciendo una consulta HTTP desde el exterior
![web](https://i.imgur.com/1TbKhY2.png)
## Ejercicios
### 1. Permite poder hacer conexiones ssh al exterior
Para esto uso las reglas de ssh citas anteriormente:
```bash
iptables -A INPUT -s 172.22.0.0/16 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -d 172.22.0.0/16 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
```
Estas reglas sirve para acceder desde la misma red, además añado las siguientes para acceder a través de la VPN
```bash
iptables -A INPUT -s 172.29.0.0/16 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -d 172.29.0.0/16 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
```
![ssh1](https://i.imgur.com/8h6tmFh.png)
![ssh2](https://i.imgur.com/xhNYful.png)
### 2. Deniega el acceso a tu servidor web desde una ip concreta
Como ya he creado en la preparación una regla que permite el acceso al servidor web, para que el bloque funcione tengo que añadir la regla antes, ya que el orden es importante en iptables. Para ello, primero miro la posición de la regla que permite el acceso al servidor web
```bash
iptables -L -n -v --line-numbers
```
![iptables](https://i.imgur.com/VLs4Xd7.png)
La regla que permite el acceso está en la dirección 8; ahora creo la regla con la ip de mi máqunina:
```bash
iptables -I INPUT 8 -s 172.29.0.42 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j DROP
```
![iptables2](https://i.imgur.com/T361Yz0.png)
Ahora compruebo que no puedo acceder al servidor web desde mi máquina
![web](https://i.imgur.com/9xydTG9.png)
### 3. Permite hacer consultas DNS sólo al servidor 192.168.202.2. Comprueba que no puedes hacer un dig @1.1.1.1
Primero borro las reglas de DNS que he creado anteriormente
```bash
iptables -D OUTPUT -o ens3 -p udp --dport 53 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -D INPUT -i ens3 -p udp --sport 53 -m state --state ESTABLISHED -j ACCEPT
```
Y ahora añado las reglas nuevas, permitiendo solo el servidor 192.168.202.2:
```bash
iptables -A OUTPUT -d 192.168.202.2 -p udp --dport 53 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -s 192.168.202.2 -p udp --sport 53 -m state --state ESTABLISHED -j ACCEPT
```
Ahora compruebo que no puedo hacer un `dig@1.1.1.1 www.josedomingo.org`:
![dns](https://i.imgur.com/May5Dwa.png)
Y si que puedo usando el dns, `dig@192.168.202.2 www.josedomingo.org`:
![dns2](https://i.imgur.com/1O9FXoM.png)
### 4. No permitir el acceso al servidor web de www.josedomingo.org, Tienes que utilizar la ip. ¿Puedes acceder a fp.josedomingo.org?
Al igual que en el ejercicio 2, primero miro la posición de la regla que permite el acceso al servidor web
![iptables](https://i.imgur.com/HbcTZPw.png)
Está en el lugar 5. Ahora creo la regla con la ip de josedomingo.org:
```bash
iptables -I OUTPUT 5 -d 37.187.119.60 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j DROP
```
Compruebo que se ha creado correctamente:
![iptables2](https://i.imgur.com/Xp4mGZu.png)
Ahora compruebo que no puedo acceder al servidor web de josedomingo.org
![web](https://i.imgur.com/POagTDZ.png)
y si que puedo acceder a portquiz.net:
![web2](https://i.imgur.com/f0SccEm.png)
### 5. Permite mandar un correo usando nuestro servidor de correo: babuino-smtp. Para probarlo ejecuta un telnet babuino-smtp.gonzalonazareno.org 25
Para hacerlo utilizo la ip de babuino:
```bash
iptables -A OUTPUT -d 192.168.203.3 -p tcp --dport 25 -j ACCEPT
iptables -A INPUT -s 192.168.203.3 -p tcp --sport 25 -j ACCEPT
```
![smtp](https://i.imgur.com/tBoRNWu.png)
### 6. Instala un servidor mariadb, y permite los accesos desde la ip de tu cliente. Comprueba que desde otro cliente no se puede acceder
Instalo MariaDB:
```bash
apt install mariadb-server
```
Configuro el acceso remoto, editando el fichero `/etc/mysql/mariadb.conf.d/50-server.cnf`:
```bash
bind-address = 0.0.0.0
```
Tras eso, reinicio el servicio y añado la regla para permitir el acceso desde mi cliente:
```bash
sudo iptables -A INPUT -s 172.29.0.42 -p tcp --dport 3306 -j ACCEPT
sudo iptables -A OUTPUT -d 172.29.0.42 -p tcp --sport 3306 -j ACCEPT
```
Ahora, en la siguiente captura, realizo una conexión con la base de datos desde el cliente, tras eso, desconecto la VPN para dejar de tener la IP que está autorizada, y vuelvo a intentar acceder, pero no puedo:
![mariadb](https://i.imgur.com/1Z8hCqe.png)

Binary file not shown.

After

Width:  |  Height:  |  Size: 459 KiB

@ -0,0 +1,327 @@
---
title: "Cortafuegos II: Perimetral con nftables"
date: 2023-02-17T11:58:43+01:00
draft: false
---
- [Enunciado](#enunciado)
- [Preparación](#preparación)
- [SSH al cortafuegos](#ssh-al-cortafuegos)
- [Política por defecto](#política-por-defecto)
- [Activar el bit de forward](#activar-el-bit-de-forward)
- [SNAT](#snat)
- [SSH desde el cortafuego a la LAN](#ssh-desde-el-cortafuego-a-la-lan)
- [Tráfico para la interfaz loopback](#tráfico-para-la-interfaz-loopback)
- [Peticiones y respuestas protocolo ICMP](#peticiones-y-respuestas-protocolo-icmp)
- [Reglas forward](#reglas-forward)
- [ping desde la LAN](#ping-desde-la-lan)
- [Consultas y respuestas DNS desde la LAN](#consultas-y-respuestas-dns-desde-la-lan)
- [Permitimos la navegación web desde la LAN](#permitimos-la-navegación-web-desde-la-lan)
- [Permitimos el acceso a nuestro servidor web de la LAN desde el exterior](#permitimos-el-acceso-a-nuestro-servidor-web-de-la-lan-desde-el-exterior)
- [Reglas del enunciado](#reglas-del-enunciado)
- [Permite poder hacer conexiones ssh al exterior desde la máquina cortafuegos](#permite-poder-hacer-conexiones-ssh-al-exterior-desde-la-máquina-cortafuegos)
- [Permite hacer consultas DNS desde la máquina cortafuegos sólo al servidor 192.168.202.2. Comprueba que no puedes hacer un dig @1.1.1.1.](#permite-hacer-consultas-dns-desde-la-máquina-cortafuegos-sólo-al-servidor-1921682022-comprueba-que-no-puedes-hacer-un-dig-1111)
- [Permite que la máquina cortafuegos pueda navegar por internet.](#permite-que-la-máquina-cortafuegos-pueda-navegar-por-internet)
- [Los equipos de la red local deben poder tener conexión al exterior.](#los-equipos-de-la-red-local-deben-poder-tener-conexión-al-exterior)
- [Permitimos el ssh desde el cortafuego a la LAN](#permitimos-el-ssh-desde-el-cortafuego-a-la-lan)
- [Permitimos hacer ping desde la LAN a la máquina cortafuegos](#permitimos-hacer-ping-desde-la-lan-a-la-máquina-cortafuegos)
- [Permite realizar conexiones ssh desde los equipos de la LAN](#permite-realizar-conexiones-ssh-desde-los-equipos-de-la-lan)
- [Instala un servidor de correos en la máquina de la LAN. Permite el acceso desde el exterior y desde el cortafuego al servidor de correos. Para probarlo puedes ejecutar un telnet al puerto 25 tcp](#instala-un-servidor-de-correos-en-la-máquina-de-la-lan-permite-el-acceso-desde-el-exterior-y-desde-el-cortafuego-al-servidor-de-correos-para-probarlo-puedes-ejecutar-un-telnet-al-puerto-25-tcp)
- [Permite poder hacer conexiones ssh desde exterior a la LAN](#permite-poder-hacer-conexiones-ssh-desde-exterior-a-la-lan)
- [Modifica la regla anterior, para que al acceder desde el exterior por ssh tengamos que conectar al puerto 2222, aunque el servidor ssh este configurado para acceder por el puerto 22](#modifica-la-regla-anterior-para-que-al-acceder-desde-el-exterior-por-ssh-tengamos-que-conectar-al-puerto-2222-aunque-el-servidor-ssh-este-configurado-para-acceder-por-el-puerto-22)
- [Permite hacer consultas DNS desde la LAN sólo al servidor 192.168.202.2. Comprueba que no puedes hacer un dig @1.1.1.1](#permite-hacer-consultas-dns-desde-la-lan-sólo-al-servidor-1921682022-comprueba-que-no-puedes-hacer-un-dig-1111)
- [Permite que los equipos de la LAN puedan navegar por internet.](#permite-que-los-equipos-de-la-lan-puedan-navegar-por-internet)
## Enunciado
Realiza con nftables el ejercicio de la página [https://fp.josedomingo.org/seguridadgs/u03/perimetral_iptables.html](https://fp.josedomingo.org/seguridadgs/u03/perimetral_iptables.html) documentando las pruebas de funcionamiento realizadas.
Debes añadir después las reglas necesarias para que se permitan las siguientes operaciones:
## Preparación
El escenario es el siguiente
![escenario](https://i.imgur.com/ynMPcoB.png)
Instalo nftables en el cortafuegos
```bash
sudo apt update
sudo apt install nftables
```
Creo las tablas de filter y nat
```bash
sudo nft add table inet filter
sudo nft add table inet nat
```
creo las cadenas de filter
```bash
sudo nft add chain inet filter input { type filter hook input priority 0 \; counter \; policy accept \; }
sudo nft add chain inet filter output { type filter hook output priority 0 \; counter \; policy accept \; }
sudo nft add chain inet filter forward { type filter hook forward priority 0 \; counter \; policy accept \; }
```
creo las cadenas de nat
```bash
sudo nft add chain inet nat prerouting { type nat hook prerouting priority 0 \; }
sudo nft add chain inet nat postrouting { type nat hook postrouting priority 100 \; }
```
### SSH al cortafuegos
Ahora acepto el tráfico ssh entrante al router-fw
```bash
sudo nft add rule inet filter input ip saddr 172.22.0.0/16 tcp dport 22 ct state new,established counter accept
sudo nft add rule inet filter output ip daddr 172.22.0.0/16 tcp sport 22 ct state established counter accept
```
y entrante desde la VPN
```bash
sudo nft add rule inet filter input ip saddr 172.29.0.0/16 tcp dport 22 ct state new,established counter accept
sudo nft add rule inet filter output ip daddr 172.29.0.0/16 tcp sport 22 ct state established counter accept
```
### Política por defecto
Y pongo la política por defecto a drop:
```bash
sudo nft chain inet filter input { policy drop \; }
sudo nft chain inet filter output { policy drop \; }
```
Ahora compruebo que puedo hacer ssh
![ssh](https://i.imgur.com/T2NL5kC.png)
![ssh2](https://i.imgur.com/7o6qhGY.png)
### Activar el bit de forward
En el cortafuegos, activo el bit de forwarding
![bitforward](https://i.imgur.com/Ooq3yo9.png)
### SNAT
```bash
sudo nft add rule inet nat postrouting oifname "ens3" ip saddr 192.168.100.0/24 counter masquerade
```
![snat](https://i.imgur.com/bWXZJ8j.png)
### SSH desde el cortafuego a la LAN
```bash
sudo nft add rule inet filter output oifname "ens4" ip daddr 192.168.100.0/24 tcp dport 22 ct state new,established counter accept
sudo nft add rule inet filter input iifname "ens4" ip saddr 192.168.100.0/24 tcp sport 22 ct state established counter accept
```
![ssh3](https://i.imgur.com/WRuODxe.png)
### Tráfico para la interfaz loopback
```bash
sudo nft add rule inet filter output oifname "lo" counter accept
sudo nft add rule inet filter input iifname "lo" counter accept
```
![loopback](https://i.imgur.com/fEVtFCW.png)
### Peticiones y respuestas protocolo ICMP
Desde el cortafuegos a internet
```bash
sudo nft add rule inet filter input iifname "ens3" icmp type echo-request counter accept
sudo nft add rule inet filter output oifname "ens3" icmp type echo-reply counter accept
```
Ahora desde mi portátil hago un ping al cortafuegos:
![icmp](https://i.imgur.com/vO8QNUq.png)
### Reglas forward
#### ping desde la LAN
Desde el cortafuegos a la LAN
```bash
sudo nft add rule inet filter input iifname "ens4" icmp type echo-reply counter accept
sudo nft add rule inet filter output oifname "ens4" icmp type echo-request counter accept
```
![icmp](https://i.imgur.com/oeg8xx6.png)
#### Consultas y respuestas DNS desde la LAN
```bash
sudo nft add rule inet filter forward iifname "ens4" oifname "ens3" ip saddr 192.168.100.0/24 udp dport 53 ct state new,established counter accept
sudo nft add rule inet filter forward iifname "ens3" oifname "ens4" ip daddr 192.168.100.0/24 udp sport 53 ct state established counter accept
```
![dns](https://i.imgur.com/vnJEfIP.png)
#### Permitimos la navegación web desde la LAN
```bash
sudo nft add rule inet filter output oifname "ens3" ip protocol tcp tcp dport { 80,443 } ct state new,established counter accept
sudo nft add rule inet filter input iifname "ens3" ip protocol tcp tcp sport { 80,443 } ct state established counter accept
```
![web](https://i.imgur.com/s4Yw8Cl.png)
#### Permitimos el acceso a nuestro servidor web de la LAN desde el exterior
```bash
sudo nft add rule inet filter forward iifname "ens3" oifname "ens4" ip daddr 192.168.100.0/24 tcp dport 80 ct state new,established counter accept
sudo nft add rule inet filter forward iifname "ens4" oifname "ens3" ip saddr 192.168.100.0/24 tcp sport 80 ct state established counter accept
```
```bash
sudo nft add rule inet nat prerouting iifname "ens3" tcp dport 80 counter dnat ip to 192.168.100.10
```
![web2](https://i.imgur.com/C69ZdJ8.png)
## Reglas del enunciado
### Permite poder hacer conexiones ssh al exterior desde la máquina cortafuegos
```bash
sudo nft add rule inet filter output oifname "ens3" tcp dport 22 ct state new,established counter accept
sudo nft add rule inet filter input iifname "ens3" tcp sport 22 ct state established counter accept
```
Ahora pruebo accediendo a otra máquina desde el cortafuegos por ssh
![ssh](https://i.imgur.com/YsoD8Cx.png)
### Permite hacer consultas DNS desde la máquina cortafuegos sólo al servidor 192.168.202.2. Comprueba que no puedes hacer un dig @1.1.1.1.
Creo la regla
```bash
sudo nft add rule inet filter output ip daddr 192.168.202.2 udp dport 53 ct state new,established counter accept
sudo nft add rule inet filter input ip saddr 192.168.202.2 udp sport 53 ct state established counter accept
```
Compruebo que no puedo hacer un dig @1.1.1.1 y si uno con @192.168.202.2
![dns](https://i.imgur.com/XKHU64n.png)
### Permite que la máquina cortafuegos pueda navegar por internet.
```bash
sudo nft add rule inet filter output oifname "ens3" ip protocol tcp tcp dport { 80,443 } ct state new,established counter accept
sudo nft add rule inet filter input iifname "ens3" ip protocol tcp tcp sport { 80,443 } ct state established counter accept
```
Compruebo que puedo navegar por internet
![web](https://i.imgur.com/dXNkvJz.png)
### Los equipos de la red local deben poder tener conexión al exterior.
Este paso lo realicé en la preparación en el siguiente apartado: [Reglas forward](#reglas-forward)
### Permitimos el ssh desde el cortafuego a la LAN
Este paso lo realicé en la preparación en el siguiente apartado: [SSH desde el cortafuego a la LAN](#ssh-desde-el-cortafuego-a-la-lan)
Pruebo que funciona (usando mi clave privada)
![ssh2](https://i.imgur.com/JdG9dTH.png)
### Permitimos hacer ping desde la LAN a la máquina cortafuegos
```bash
sudo nft add rule inet filter input iifname "ens4" icmp type echo-request counter accept
sudo nft add rule inet filter output oifname "ens4" icmp type echo-reply counter accept
```
Compruebo que funciona
![icmp](https://i.imgur.com/reyRJ34.png)
### Permite realizar conexiones ssh desde los equipos de la LAN
```bash
sudo nft add rule inet filter forward iifname "ens4" oifname "ens3" ip saddr 192.168.100.0/24 tcp dport 22 ct state new,established counter accept
sudo nft add rule inet filter forward iifname "ens3" oifname "ens4" ip daddr 192.168.100.0/24 tcp sport 22 ct state established counter accept
```
Ahora, tras copiar mi clave privada a la máquina LAN, accedo a alfa por ssh
![ssh3](https://i.imgur.com/eZ9IVZf.png)
### Instala un servidor de correos en la máquina de la LAN. Permite el acceso desde el exterior y desde el cortafuego al servidor de correos. Para probarlo puedes ejecutar un telnet al puerto 25 tcp
### Permite poder hacer conexiones ssh desde exterior a la LAN
```bash
sudo nft add rule inet filter forward iifname "ens3" oifname "ens4" ip daddr 192.168.100.0/24 tcp dport 22 ct state new,established counter accept
sudo nft add rule inet filter forward iifname "ens4" oifname "ens3" ip saddr 192.168.100.0/24 tcp sport 22 ct state established counter accept
sudo nft add rule inet nat prerouting iifname "ens3" tcp dport 22 counter dnat ip to 192.168.100.10
```
Compruebo que al acceder a la IP del firewall entro en la maquina LAN
![ssh4](https://i.imgur.com/VzI01Oo.png)
### Modifica la regla anterior, para que al acceder desde el exterior por ssh tengamos que conectar al puerto 2222, aunque el servidor ssh este configurado para acceder por el puerto 22
```bash
sudo nft add rule inet nat prerouting iifname "ens3" tcp dport 2222 counter dnat ip to 192.168.100.10:22
```
Ahora entro usando el puerto 2222
![ssh5](https://i.imgur.com/Mm45WLy.png)
### Permite hacer consultas DNS desde la LAN sólo al servidor 192.168.202.2. Comprueba que no puedes hacer un dig @1.1.1.1
Como ya tengo una regla para las consultas dns desde la lan,busco los handles que tiene para borrarla
```bash
sudo nft -a list ruleset
```
![dns2](https://i.imgur.com/IH9k9GK.png)
son el 22 y el 23. Ahora los borro:
```bash
sudo nft delete rule inet filter forward handle 22
sudo nft delete rule inet filter forward handle 23
```
Ahora añado las reglas para la LAN
```bash
sudo nft add rule inet filter forward iifname "ens4" oifname "ens3" ip saddr 192.168.100.0/24 ip daddr 192.168.202.2 udp dport 53 ct state new,established counter accept
sudo nft add rule inet filter forward iifname "ens3" oifname "ens4" ip saddr 192.168.202.2 ip daddr 192.168.100.0/24 udp sport 53 ct state established counter accept
```
![dns3](https://i.imgur.com/1zmmeCt.png)
### Permite que los equipos de la LAN puedan navegar por internet.
Este paso lo realicé en la preparación en el siguiente apartado: [Permite que los equipos de la LAN puedan navegar por internet.](#permite-que-los-equipos-de-la-lan-puedan-navegar-por-internet)
Compruebo que funciona
![web2](https://i.imgur.com/wyT7DEF.png )

Binary file not shown.

After

Width:  |  Height:  |  Size: 467 KiB

@ -0,0 +1,308 @@
---
title: "Cortafuegos III: perimetral sobre escenario"
date: 2023-03-02T23:19:45+01:00
draft: false
image: featured.png
categories:
- documentación
- Seguridad y Alta Disponibilidad
tags:
- Cortafuegos
- iptables
---
El escenario es el siguiente
![Escenario](https://i.imgur.com/LLToqTl.png)
Y las interfaces de alfa son las siguientes:
- ens3: Salida a internet
- ens8: DMZ
- br-intra: LAN
## Enunciado
Sobre el escenario creado en el módulo de servicios con las máquinas Alfa (Router), Bravo (DMZ), Charlie y Delta (LAN) y empleando iptables o nftables, configura un cortafuegos perimetral en la máquina Alfa de forma que el escenario siga funcionando completamente teniendo en cuenta los siguientes puntos:
## Política por defecto DROP para las cadenas INPUT, FORWARD y OUTPUT.
Antes de añadir la política por defecto voy a añadir reglas para permitir el acceso por ssh
```bash
iptables -A INPUT -s 172.22.0.0/16 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -d 172.22.0.0/16 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
```
Estas reglas sirve para acceder desde la misma red, además añado las siguientes para acceder a través de la VPN
```bash
iptables -A INPUT -s 172.29.0.0/16 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -d 172.29.0.0/16 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
```
Y permito el acceso al resto de máquinas
```bash
iptables -A OUTPUT -d 192.168.0.0/24 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -s 192.168.0.0/24 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
iptables -A OUTPUT -d 172.16.0.0/16 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -s 172.16.0.0/16 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
```
(Este paso lo ejecuto después de crear las reglas ssh)
```bash
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
```
## El cortafuego debe cumplir al menos estas reglas:
### La máquina Alfa tiene un servidor ssh escuchando por el puerto 22, pero al acceder desde el exterior habrá que conectar al puerto 2222.
### Desde Delta y Bravo se debe permitir la conexión ssh por el puerto 22 a la máquina Alfa
de alfa a charlie/delta
```bash
sudo iptables -A OUTPUT -o br-intra -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
sudo iptables -A INPUT -i br-intra -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
```
Prueba antes y después de crear la regla
![Escenario](https://i.imgur.com/oiiVuK8.png)
de alfa a bravo
```bash
sudo iptables -A OUTPUT -o ens8 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
sudo iptables -A INPUT -i ens8 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
```
![Escenario](https://i.imgur.com/2rAyLZy.png)
### La máquina Alfa debe tener permitido el tráfico para la interfaz loopback
```bash
iptables -A INPUT -i lo -p icmp -j ACCEPT
iptables -A OUTPUT -o lo -p icmp -j ACCEPT
```
Pruebo que funciona, antes y después de aplicar la regla:
![loopback](https://i.imgur.com/7RfdzSj.png)
### A la máquina Alfa se le puede hacer ping desde la DMZ, pero desde la LAN se le debe rechazar la conexión (REJECT) y desde el exterior se rechazará de manera silenciosa.
```bash
iptables -A INPUT -s 172.16.0.200/16 -p icmp -m icmp --icmp-type echo-request -j ACCEPT
iptables -A OUTPUT -d 172.16.0.200/16 -p icmp -m icmp --icmp-type echo-reply -j ACCEPT
```
Ahora el reject a la LAN
```bash
iptables -A INPUT -s 192.168.1.0/24 -p icmp -m icmp --icmp-type echo-request -j REJECT
iptables -A OUTPUT -d 192.168.1.0/24 -p icmp -m icmp --icmp-type echo-reply -j REJECT
```
ping desde bravo:
![ping desde bravo](https://i.imgur.com/utA5CGz.png)
ping desde charlie:
![ping desde charlie](https://i.imgur.com/g6Z7xSD.png)
### La máquina Alfa puede hacer ping a la LAN, la DMZ y al exterior.
```bash
iptables -A OUTPUT -p icmp -m icmp --icmp-type echo-request -j ACCEPT
iptables -A INPUT -p icmp -m icmp --icmp-type echo-reply -j ACCEPT
```
A la LAN:
![ping a la LAN](https://i.imgur.com/PrsN5x0.png)
A la DMZ:
![ping a la DMZ](https://i.imgur.com/PealPbe.png)
Al exterior:
![ping al exterior](https://i.imgur.com/e5iIex8.png)
### Desde la máquina Bravo se puede hacer ping y conexión ssh a las máquinas de la LAN.
```bash
iptables -A FORWARD -s 172.16.0.200/32 -d 192.168.0.0/24 -p icmp -m icmp --icmp-type echo-request -j ACCEPT
iptables -A FORWARD -d 172.16.0.200/32 -s 192.168.0.0/24 -p icmp -m icmp --icmp-type echo-reply -j ACCEPT
iptables -A FORWARD -s 172.16.0.200/32 -d 192.168.0.0/24 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -d 172.16.0.200/32 -s 192.168.0.0/24 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
```
Prueba de ping desde bravo a charlie:
![ping desde bravo a charlie](https://i.imgur.com/qLycsbI.png)
Prueba de ssh desde bravo a charlie:
![ssh desde bravo a charlie](https://i.imgur.com/XZF4qGQ.png)
### Desde cualquier máquina de la LAN se puede conectar por ssh a la máquina Bravo.
```bash
iptables -A FORWARD -s 192.168.0.0/24 -d 172.16.0.200/32 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -s 172.16.0.200/32 -d 192.168.0.0/24 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
```
Pruebo a acceder desde charlie:
![ssh desde charlie a bravo](https://i.imgur.com/2rykuVx.png)
### Configura la máquina Alfa para que las máquinas de LAN y DMZ puedan acceder al exterior
DMZ a exterior:
```bash
iptables -t nat -A POSTROUTING -s 172.16.0.0/16 -o ens3 -j MASQUERADE
iptables -A FORWARD -i ens8 -o ens3 -p icmp -m icmp --icmp-type echo-request -j ACCEPT
iptables -A FORWARD -i ens3 -o ens8 -p icmp -m icmp --icmp-type echo-reply -j ACCEPT
```
LAN a exterior:
```bash
iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -o ens3 -j MASQUERADE
iptables -A FORWARD -i br-intra -o ens3 -p icmp -m icmp --icmp-type echo-request -j ACCEPT
iptables -A FORWARD -i ens3 -o br-intra -p icmp -m icmp --icmp-type echo-reply -j ACCEPT
```
Prueba de ping desde bravo a google:
![ping desde bravo a google](https://i.imgur.com/IbX1h7r.png)
Prueba de ping desde charlie a google:
![ping desde charlie a google](https://i.imgur.com/g7GKV9E.png)
### Las máquinas de la LAN pueden hacer ping al exterior y navegar
El ping lo he configurado en el punto anterior. Ahora la navegación:
```bash
iptables -A FORWARD -i br-intra -o ens3 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens3 -o br-intra -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT
iptables -A FORWARD -i br-intra -o ens3 -p tcp --dport 443 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens3 -o br-intra -p tcp --sport 443 -m state --state ESTABLISHED -j ACCEPT
```
Prueba de navegación desde charlie (no tengo el comando curl, asi que uso nc):
![navegación desde charlie](https://i.imgur.com/ZLljVQQ.png)
### La máquina Bravo puede navegar
```bash
iptables -A FORWARD -i ens8 -o ens3 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens3 -o ens8 -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens8 -o ens3 -p tcp --dport 443 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens3 -o ens8 -p tcp --sport 443 -m state --state ESTABLISHED -j ACCEPT
```
Prueba de navegación desde bravo:
![navegación desde bravo](https://i.imgur.com/qXEvqkP.png)
### Configura la máquina Alfa para que los servicios web y ftp sean accesibles desde el exterior
```bash
iptables -t nat -A PREROUTING -p tcp -i ens3 --dport 80 -j DNAT --to 172.16.0.200
iptables -A FORWARD -i ens3 -o ens8 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens8 -o ens3 -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT
iptables -t nat -A PREROUTING -p tcp -i ens3 --dport 21 -j DNAT --to 172.16.0.200
iptables -A FORWARD -i ens3 -o ens8 -p tcp --dport 21 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens8 -o ens3 -p tcp --sport 21 -m state --state ESTABLISHED -j ACCEPT
```
Prueba de navegación desde el exterior (La página es de un taller de Django):
![navegación desde el exterior](https://i.imgur.com/U2EgQqy.png)
### El servidor web y el servidor ftp deben ser accesibles desde la LAN y desde el exterior
```bash
iptables -A FORWARD -i br-intra -o ens8 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens8 -o br-intra -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT
iptables -A FORWARD -i br-intra -o ens8 -p tcp --dport 21 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens8 -o br-intra -p tcp --sport 21 -m state --state ESTABLISHED -j ACCEPT
```
Prueba de navegación desde charlie, sale un error porque estoy usando el comando nc, pero aun asi se ve que responde rocky con wsgi, que es lo que hay desplegado en bravo:
![navegación desde charlie](https://i.imgur.com/J9C1mcC.png)
### El servidor de correos sólo debe ser accesible desde la LAN
```bash
iptables -A FORWARD -i br-intra -o ens8 -p tcp --dport 25 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens8 -o br-intra -p tcp --sport 25 -m state --state ESTABLISHED -j ACCEPT
```
### En la máquina Charlie instala un servidor mysql si no lo tiene aún. A este servidor se puede acceder desde la DMZ, pero no desde el exterior.
### Evita ataques DoS por ICMP Flood, limitando el número de peticiones por segundo desde una misma IP.
El ping está bloqueado desde el exterior y desde la LAN, por lo que voy a evitar los ataques desde la DMZ, limitando a 1 peticion por segundo(primero hay que borrar la regla anterior):
```bash
iptables -A INPUT -i ens8 -p icmp -m state --state NEW --icmp-type echo-request -m limit --limit 1/s --limit-burst 1 -j ACCEPT
```
![ping desde la DMZ](https://i.imgur.com/L2N9GIc.png)
En la captura se ve como el 100% de los paquetes han sido rechazados
### Evita ataques DoS por SYN Flood.
```bash
iptables -t raw -D PREROUTING -p tcp -m tcp --syn -j CT --notrack
iptables -D INPUT -p tcp -m tcp -m conntrack --ctstate INVALID,UNTRACKED -j SYNPROXY --sack-perm --timestamp --wscale 7 --mss 1460
iptables -D INPUT -m conntrack --ctstate INVALID -j DROP
```
### Evita que realicen escaneos de puertos a Alfa.
```bash
iptables -N antiscan
iptables -A antiscan -j DROP
```
## Debemos implementar que el cortafuegos funcione después de un reinicio de la máquina.
Para hacer la instalación persistente, he utilizado el paquete iptables-persistent
```bash
apt install iptables-persistent
```
Para que funcione, tras crear todas las reglas, ejecuto el siguiente comando:
```bash
sudo iptables-save > /etc/iptables/rules.v4
```
Tras ejecutar eso, las reglas son persistentes. El fichero tiene el siguiente contenido:
![iptables-save](https://i.imgur.com/KbSN5IX.png)

Binary file not shown.

After

Width:  |  Height:  |  Size: 233 KiB

@ -0,0 +1,386 @@
---
title: "Despliegue de aplicaciones python sobre django"
date: 2023-01-23T08:47:22+01:00
draft: false
---
## Tarea 1 Entorno de desarrollo
He elegido como entorno de desarrollo la máquina bravo.
Primero creamos un entorno virtual de python3 e instalamos las dependencias necesarias para que funcione el proyecto.
```bash
python3 -m venv django
source django/bin/activate
pip install django
```
Ahora descargamos el proyecto de github:
```bash
git clone https://github.com/robertorodriguez98/django_tutorial
```
### Configuración de django
Comprobamos que vamos a trabajar con una base de datos sqlite. Para ello tenemos que consultar el fichero settings.py. En este caso la base de datos se llama db.sqlite3.
```bash
(django)$ cd django_tutorial
(django)$ cat django_tutorial/settings.py | egrep -A 5 'DATABASES';
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}
```
Para poder acceder desde la dirección www.roberto.gonzalonazareno.org, tenemos que modificar el fichero `django_tutorial/settings.py` y añadir la dirección a la lista de hosts permitidos de la siguiente manera:.
```python
ALLOWED_HOSTS = ['www.roberto.gonzalonazareno.org']
```
Ahora creamos la base de datos:
```bash
(django)$ python manage.py migrate
```
Y el usuario administrador:
```bash
(django)$ python3 manage.py createsuperuser
```
Ahora ejecutamos el servidor web de desarrollo:
```bash
(django)$ python3 manage.py runserver 0.0.0.0:8000
```
Y accedemos a la zona de administración, en este caso en la dirección [www.roberto.gonzalonazareno.org:8000/admin](www.roberto.gonzalonazareno.org:8000/admin) y añadimos dos preguntas con sus posibles respuestas.
![Zona de administración](https://i.imgur.com/DZW2zzb.png)
* Comprueba en el navegador que la aplicación está funcionando, accede a la url /polls.
![Página principal](https://i.imgur.com/p4ZeXNj.png)
![Página de votación1](https://i.imgur.com/Bq4Tpml.png)
![Página de votación2](https://i.imgur.com/DWNxLFr.png)
### Configuración del servidor web
En bravo, el servidor web apache2 ya está instalado y configurado para servir páginas web estáticas. Para servir páginas web dinámicas, tenemos que instalar el módulo wsgi.
```bash
sudo dnf install python3-mod_wsgi
```
Ahora, para que el entorno sea similar al de producción, movemos el proyecto y el entorno virtual a la ruta `/var/www/html/django_tutorial` y `/var/www/html/django` respectivamente.
```bash
sudo mv django_tutorial /var/www/html/
sudo mv django /var/www/html/
```
Creamos el contenido estático de la aplicación:
```bash
sudo python3 manage.py collectstatic
```
Editamos el fichero `/var/www/html/django_tutorial/django_tutorial/settings.py` y modificamos las siguientes líneas:
```python
ALLOWED_HOSTS = ['*']
STATIC_ROOT = '/var/www/html/django_tutorial/static/'
```
Ahora configuraremos el servidor apache para que sirva la aplicación django. Para ello, tenemos que crear un fichero de configuración en la ruta `/etc/httpd/sites-available/django.conf` con el siguiente contenido:
```apache
<VirtualHost python.roberto.gonzalonazareno.org:80>
ServerName python.roberto.gonzalonazareno.org
DocumentRoot /var/www/html/django_tutorial
Alias /static/ /var/www/html/django_tutorial/static/
WSGIDaemonProcess django_tutorial python-path=/var/www/html/django_tutorial:/var/www/html/django/lib/python3.9/site-packages
WSGIProcessGroup django_tutorial
WSGIScriptAlias / /var/www/html/django_tutorial/django_tutorial/wsgi.py
ErrorLog /var/log/httpd/django_tutorial_error.log
CustomLog /var/log/httpd/django_tutorial_access.log combined
</VirtualHost>
```
Para que funcione la configuración tenemos que activar el sitio web y reiniciar el servidor web:
```bash
sudo ln -s /etc/httpd/sites-available/django.conf /etc/httpd/sites-enabled/django.conf
sudo systemctl restart httpd
```
Ahora podemos acceder a la aplicación desde la dirección [python.roberto.gonzalonazareno.org](http://python.roberto.gonzalonazareno.org).
## Tarea 2: Entorno de producción
Vamos a realizar el despliegue de nuestra aplicación en un entorno de producción, para ello vamos a utilizar nuestro VPS, sigue los siguientes pasos:
### Instalación de django y base de datos
Clonamos el repositorio:
```bash
git clone https://github.com/robertorodriguez98/django_tutorial
```
Creamos el entorno virtual:
```bash
python3 -m venv django
source django/bin/activate
cd django_tutorial
pip install -r requirements.txt
```
Instalamos el módulo que permite que python trabaje con mysql:
```bash
sudo apt install libmariadb-dev
pip install mysqlclient
```
Tras crear un usuario y la base de datos, configuramos la aplicación para trabajar con mysql, para ello modifica la configuración de la base de datos en el archivo `settings.py`:
```python
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'django',
'USER': 'djadmin',
'PASSWORD': 'djadmin',
'HOST': 'localhost',
'PORT': '',
}
}
```
Creamos la copia de seguridad de la aplicación en bravo:
```bash
sudo python manage.py dumpdata > /home/roberto/basedatos.json
```
y la restauramos en el VPS:
```bash
(django)$ python manage.py migrate
(django)$ python manage.py loaddata basedatos.json
Installed 57 object(s) from 1 fixture(s)
```
Finalmente generamos el contenido estático:
```bash
(django)$ python manage.py collectstatic
```
### Configuración de nginx
Instalamos uwsgi:
```bash
pip install uwsgi
```
Podemos comprobar que funciona correctamente:
```bash
uwsgi --http :8080 --chdir /home/calcetines/django_tutorial --wsgi-file django_tutorial/wsgi.py --process 4 --threads 2 --master
```
Creamos el fichero de configuración de uwsgi en `/home/calcetines/django/servidor.ini`:
```bash
[uwsgi]
http = :8080
chdir = /home/calcetines/django_tutorial
wsgi-file = django_tutorial/wsgi.py
processes = 4
threads = 2
```
Ahora crearemos la unidad de systemd para que se ejecute uwsgi como servicio en el fichero `/etc/systemd/system/uwsgi-django.service`:
```bash
[Unit]
Description=uwsgi-django
After=network.target
[Install]
WantedBy=multi-user.target
[Service]
User=www-data
Group=www-data
Restart=always
ExecStart=/home/calcetines/django/bin/uwsgi /home/calcetines/django/servidor.ini
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s TERM $MAINPID
WorkingDirectory=/home/calcetines/django_tutorial
Environment=PYTHONPATH='/home/calcetines/django_tutorial:/home/calcetines/django/lib/python3.9/site-packages'
PrivateTmp=true
```
activamos el servicio:
```bash
systemctl enable uwsgi-django.service
systemctl start uwsgi-django.service
```
Ahora configuramos nginx como proxy inverso añadiendo la siguiente configuración en el fichero `/etc/nginx/sites-available/django`:
```bash
server {
listen 80;
server_name python.admichin.es;
if ($host ~ ^[^.]+\.admichin\.es$) {
return 301 https://$host$request_uri;
} # managed by Certbot
}
server {
listen 443 ssl;
server_name python.admichin.es;
access_log /var/log/nginx/example.com_access.log combined;
error_log /var/log/nginx/example.com_error.log error;
ssl_certificate /etc/letsencrypt/live/admichin.es-0001/fullchain.pem; # managed by Certbot
ssl_certificate_key /etc/letsencrypt/live/admichin.es-0001/privkey.pem; # managed by Certbot
location /static/ {
root /home/calcetines/django_tutorial;
}
location / {
proxy_pass http://localhost:8080/;
include proxy_params;
proxy_redirect off;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
}
```
Desactivamos el modo debug en el fichero `settings.py`:
```python
DEBUG = False
```
Finalmente accedemos a la página web en [python.admichin.es](https://python.admichin.es) y comprobamos que funciona correctamente.
![base](https://i.imgur.com/ULmiDVn.png)
![admin](https://i.imgur.com/c77oBhu.png)
![polls](https://i.imgur.com/TnfrXlx.png)
## Tarea 3: Modificación de nuestra aplicación
### En el entorno de desarrollo
Vamos a hacer las siguientes modificaciones:
* Modificamos el fichero `django_tutorial/polls/templates/polls/index.html` para que aparezca nuestro nombre.
* Modificamos la imagen de fondo que se ve la aplicación. Para hacerlo debemos modificar el fichero `django_tutorial/polls/static/polls/css/style.css` y cambiar la siguiente línea, estando la imagen en la carpeta `django_tutorial/polls/static/polls/images`:
```css
background: white url("images/gundam.jpg");
```
Ahora vamos a crear una nueva tabla en la base de datos para almacenar las categorías de las preguntas. Para ello sigue los siguientes pasos:
* Se Añade un nuevo modelo al fichero `django_tutorial/polls/models.py`:
```python
class Categoria(models.Model):
Abr = models.CharField(max_length=4)
Nombre = models.CharField(max_length=50)
def __str__(self):
return self.Abr+" - "+self.Nombre
```
* Se crea una nueva migración.
```bash
(django)$ sudo python manage.py makemigrations --name tabla_categoria
Migrations for 'polls':
polls/migrations/0002_tabla_categoria.py
- Create model Categoria
```
* Se realiza la migración.
```bash
(django)$ sudo python manage.py migrate
Operations to perform:
Apply all migrations: admin, auth, contenttypes, polls, sessions
Running migrations:
Applying polls.0002_tabla_categoria... OK
```
* Se añade el nuevo modelo al sitio de administración de django modificando el fichero `django_tutorial/polls/admin.py`:
```python
from .models import Choice, Question, Categoria
[...]
admin.site.register(Categoria)
```
Para que los cambios se trasladen al entorno de producción debemos realizar los siguientes pasos:
```bash
(django)$ sudo python manage.py
(django)$ sudo python manage.py dumpdata > basedatos2.json
(django)$ sudo python manage.py collectstatic # este no hace falta para el entorno de producción
(django)$ git push
```
### En el entorno de producción
* Se realiza la migración.
```bash
(django)$ git pull
(django)$ sudo python manage.py migrate
(django)$ sudo python manage.py loaddata basedatos2.json
(django)$ sudo python manage.py collectstatic
```
Podemos comprobar que se han producido los cambios:
![base](https://i.imgur.com/nSoCgbk.png)
![admin](https://i.imgur.com/s5iUxOB.png)
![polls](https://i.imgur.com/UrEhNQj.png)

Binary file not shown.

After

Width:  |  Height:  |  Size: 53 KiB

@ -0,0 +1,112 @@
---
title: "Despliegue de aplicaciones de java usando tomcat"
date: 2023-01-24T02:45:29+01:00
draft: false
---
## Tarea 1 Desarrollo y despliegue de una aplicación Java simple
De forma similar a lo que hemos hecho en el Taller 1, desplegamos de forma manual la aplicación Java que encontramos en el repositorio [https://github.com/josedom24/rock-paper-scissors](https://github.com/josedom24/rock-paper-scissors)
Una vez tenemos la carpeta, vamos a compilarla con el siguiente comando:
```bash
mvn package
```
Una vez compilada, vamos a desplegarla en el servidor Tomcat. Para ello, copiamos el fichero war que se ha generado en la carpeta target en la carpeta webapps del servidor Tomcat. Una vez copiado, reiniciamos el servidor Tomcat.
```bash
cp roshambo.war /var/lib/tomcat9/webapps/
systemctl restart tomcat9
```
![rock-paper-scissors](https://i.imgur.com/OpvZ5tu.png)
## Tarea 2 Despliegue de un CMS Java
### Instalación de OpenCMS
Para instalar OpenCMS, vamos a descargar el fichero war de la página de descargas de OpenCMS. Una vez descargado, lo copiamos en la carpeta webapps de Tomcat.
```bash
scp -r opencms.war debian@172.22.200.19:/home/debian/
```
```bash
cp opencms.war /var/lib/tomcat9/webapps/
systemctl restart tomcat9
```
Instalamos la base de datos MariaDB y creamos la base de datos opencms.
```bash
apt install mariadb-server
sudo mysql -u root -p
CREATE DATABASE opencms;
CREATE USER 'java'@'localhost' IDENTIFIED BY 'java';
grant all privileges on opencms. * to 'java'@'localhost' with grant option;
flush privileges;
```
Una vez instalado, accedemos a la aplicación con la url [http://172.22.200.19:8080/opencms/setup](http://172.22.200.19:8080/opencms/setup)
Seguimos los pasos de la instalación, indicando la base de datos que hemos creado y el usuario java/java.
![opencms](https://i.imgur.com/f96vUjU.png)
![opencms2](https://i.imgur.com/xlAvYTT.png)
![opencms3](https://i.imgur.com/e6qvEXP.png)
## Tarea 3 Acceso a las aplicaciones
Instalamos nginx para realizar un proxy inverso para acceder a las aplicaciones.
```bash
apt install nginx
```
Y creamos el siguiente virtualhost en `/etc/nginx/sites-available/opencms.conf`:
```bash
server {
listen 80;
listen [::]:80;
index index.html index.htm index.nginx-debian.html;
server_name java.roberto.org;
location / {
return 301 http://$host/opencms/;
}
location /opencms/ {
proxy_pass http://localhost:8080;
include proxy_params;
}
location /game/ {
proxy_pass http://localhost:8080/roshambo/;
include proxy_params;
}
}
```
Y lo activamos:
```bash
sudo ln -s /etc/nginx/sites-available/opencms.conf /etc/nginx/sites-enabled/
sudo systemctl restart nginx
```
Una vez hecho podemos acceder a las aplicaciones con las siguientes urls:
piedra papel tijera -> [http://java.roberto.org/game/](http://java.roberto.org/game/)
![piedra](https://i.imgur.com/C9svFA4.png)
opencms -> [http://java.roberto.org/](http://java.roberto.org/)
![opencms5](https://i.imgur.com/QAkYCko.png)

Binary file not shown.

After

Width:  |  Height:  |  Size: 13 KiB

@ -0,0 +1,21 @@
---
title: "Implantación de aplicaciones web PHP en docker"
date: 2023-02-06T13:41:58+01:00
draft: true
---
Imaginemos que el equipo de desarrollo de nuestra empresa ha desarrollado una aplicación PHP que se llama BookMedik (https://github.com/evilnapsis/bookmedik).
Queremos crear una imagen Docker para implantar dicha aplicación.
## Tarea 1: Creación de una imagen docker con una aplicación web desde una imagen base
```bash
docker run -d --name bd_mariadb -v bookmedik_vol:/var/lib/mysql --network red_bookmedik -e MARIADB_ROOT_PASSWORD=root -e MARIADB_DATABASE=bookmedik -e MARIADB_USER=bookmedik -e MARIADB_PASSWORD=bookmedik mariadb
```
* Entrega la url del repositorio GitHub donde tengas los ficheros necesarios para hacer la construcción de la imagen.
* Entrega una captura de pantalla donde se vea la imagen en el registro de tu entorno de desarrollo.

Binary file not shown.

After

Width:  |  Height:  |  Size: 11 KiB

@ -0,0 +1,45 @@
---
title: "Ejemplo MarkDown"
date: 2022-09-29T12:23:20+02:00
draft: no
tags: ["Markdown"]
categories: ["Implantación de Aplicaciones Web"]
---
# Introducción a Markdown
## Implantación de Aplicaciones Web
Este **fichero** está alojado en [github](https://www.github.com); que es una *forja* (plataforma de desarrollo colaborativo) para alojar proyectos utilizando el sistema de *control de versiones Git*:
Un ejemplo del uso de git es: `git status`.
Por ejemplo, para subir un repositorio local a github hay que usar los siguientes comandos:
```
git init
git add .
git commit -m "primer commit"
git remote add origin git@github.com:usuario/repositorio.git
git push -u origin main
```
---
GitHub ofre las siguientes características:
* Seguimiento de errores
* Búsqueda rápida
* potente comunidad de desarrolladores
* posibilidad de importación en git
Los lenguajes de programación más usados en github son:
1. JavaScript
2. Python
3. Java
4. TypeScript
[fichero con más información](/otrofichero.md)
### Top repositorios github
| Nombre | Enlace |
| ---- | ---- |
| Google ZX | [enlace](https://github.com/google/zx) |
| Papers We Love | [enlace](https://github.com/papers-we-love/papers-we-love) |
| Textual | [enlace](https://github.com/willmcgugan/textual) |
![octogato](https://avatars.githubusercontent.com/u/583231?v=4)

@ -0,0 +1,16 @@
---
title: "Escenario ansible y vagrant"
date: 2022-10-13T09:09:04+02:00
draft: true
---
Para hacer el `SNAT` aplicamos la siguiente regla de iptables:
```bash
sudo iptables -t nat -A POSTROUTING -s 10.0.0.0/8 -o eth1 -j MASQUERADE
sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -i eth1 -j DNAT --to 10.0.0.0:80
iptables -t nat -A PREROUTING -p tcp --dport 80 -i ens4 -j DNAT --to 10.0.0.2:80
```
```bash
sudo ip route delete default
sudo ip route add default via 192.168.0.1
```

@ -0,0 +1,6 @@
---
title: HLC
description: Talleres y prácticas de la asignatura HLC
---
En esta sección están los talleres y prácticas de la asignatura HLC

@ -0,0 +1,6 @@
---
title: "Taller1"
date: 2022-10-24T13:48:41+02:00
draft: true
---

Binary file not shown.

After

Width:  |  Height:  |  Size: 546 KiB

@ -0,0 +1,348 @@
---
title: "Informática forense"
date: 2023-02-08T18:50:12+01:00
draft: false
---
La informática forense es el conjunto de técnicas que nos permite obtener la máxima información posible tras un incidente o delito informático.
En esta práctica, realizarás la fase de toma de evidencias y análisis de las mismas sobre una máquina Linux y otra Windows. Supondremos que pillamos al delincuente in fraganti y las máquinas se encontraban encendidas. Opcionalmente, podéis realizar el análisis de un dispositivo Android.
Sobre cada una de las máquinas debes realizar un volcado de memoria y otro de disco duro, tomando las medidas necesarias para certificar posteriormente la cadena de custodia.
Debes tratar de obtener las siguientes informaciones (Tabla de contenidos)
- [Apartado A. Máquina Windows](#apartado-a-máquina-windows)
- [Volcado de memoria](#volcado-de-memoria)
- [1. Procesos en ejecución](#1-procesos-en-ejecución)
- [2. Servicios en ejecución](#2-servicios-en-ejecución)
- [3. Puertos abiertos](#3-puertos-abiertos)
- [4. Conexiones establecidas por la máquina](#4-conexiones-establecidas-por-la-máquina)
- [5. Sesiones de usuario establecidas remotamente](#5-sesiones-de-usuario-establecidas-remotamente)
- [6. Ficheros transferidos recientemente por NetBios](#6-ficheros-transferidos-recientemente-por-netbios)
- [7. Contenido de la caché DNS](#7-contenido-de-la-caché-dns)
- [8. Variables de entorno](#8-variables-de-entorno)
- [Volcado del registro](#volcado-del-registro)
- [10. Redes wifi utilizadas recientemente](#10-redes-wifi-utilizadas-recientemente)
- [11. Configuración del firewall de nodo](#11-configuración-del-firewall-de-nodo)
- [12. Programas que se ejecutan en el Inicio](#12-programas-que-se-ejecutan-en-el-inicio)
- [13. Asociación de extensiones de ficheros y aplicaciones](#13-asociación-de-extensiones-de-ficheros-y-aplicaciones)
- [Volcado de disco](#volcado-de-disco)
- [9. Dispositivos USB conectados](#9-dispositivos-usb-conectados)
- [14. Aplicaciones usadas recientemente](#14-aplicaciones-usadas-recientemente)
- [15. Ficheros abiertos recientemente](#15-ficheros-abiertos-recientemente)
- [16. Software Instalado](#16-software-instalado)
- [18. Cuentas de Usuario](#18-cuentas-de-usuario)
- [19. Historial de navegación y descargas, cookies](#19-historial-de-navegación-y-descargas-cookies)
- [21. Archivos con extensión cambiada](#21--archivos-con-extensión-cambiada)
- [22. Archivos eliminados](#22--archivos-eliminados)
- [23. Archivos Ocultos](#23--archivos-ocultos)
- [24. Archivos que contienen una cadena determinada](#24--archivos-que-contienen-una-cadena-determinada)
- [25. Búsqueda de imágenes por ubicación](#25--búsqueda-de-imágenes-por-ubicación)
- [26. Búsqueda de archivos por autor](#26--búsqueda-de-archivos-por-autor)
- [Apartado B) Máquina Linux](#apartado-b-máquina-linux)
- [Volcado de memoria](#volcado-de-memoria-1)
- [1. Procesos en ejecución](#1-procesos-en-ejecución-1)
- [2. Servicios en ejecución](#2-servicios-en-ejecución-1)
- [3. Puertos abiertos](#3-puertos-abiertos-1)
- [4. Conexiones establecidas por la máquina](#4-conexiones-establecidas-por-la-máquina-1)
- [5. Sesiones de usuario establecidas remotamente](#5-sesiones-de-usuario-establecidas-remotamente-1)
- [7. Contenido de la caché DNS](#7-contenido-de-la-caché-dns-1)
- [8. Variables de entorno](#8-variables-de-entorno-1)
- [Volcado de disco](#volcado-de-disco-1)
## Apartado A. Máquina Windows
### Volcado de memoria
Para realizar el volcado de memoria he usado la herramienta **FTK Imager**, que permite realizar volcados de disco y memoria. Para ello hago lo siguiente. Utilizo las siguientes opciones:
![ftk4](https://i.imgur.com/tD6w8MG.png)
Ahora, para analizar los datos, utilizo **Volatility** en mi máquina debian; para ello, especifico el fichero que he creado con FTK Imager al utilizar los comandos.
#### 1. Procesos en ejecución
Uso el comando `pslist` para ver los procesos en ejecución:
```bash
python vol.py -f "/media/roberto/usb/memdump.mem" windows.pslist.PsList
```
![vol1](https://i.imgur.com/tMhTGFN.png)
#### 2. Servicios en ejecución
Uso el comando `getservicesids` para ver los servicios en ejecución:
```bash
python vol.py -f "/media/roberto/usb/memdump.mem" windows.getservicesids.GetServiceSIDs
```
![vol2](https://i.imgur.com/BZjmc2d.png)
#### 3. Puertos abiertos
Uso el comando `netstat` para ver los puertos abiertos:
```bash
python vol.py -f "/media/roberto/usb/memdump.mem" windows.netstat.NetStat
```
![vol3](https://i.imgur.com/DnH0We9.png)
#### 4. Conexiones establecidas por la máquina
Uso el comando `netscan` para ver las conexiones establecidas por la máquina:
```bash
python vol.py -f "/media/roberto/usb/memdump.mem" windows.netscan.NetScan
```
![vol4](https://i.imgur.com/7ZrLSg4.png)
#### 5. Sesiones de usuario establecidas remotamente
Uso el comando `sessions` para ver las sesiones de usuario establecidas remotamente:
```bash
python vol.py -f "/media/roberto/usb/memdump.mem" windows.sessions.Sessions
```
![vol5](https://i.imgur.com/YcTjn7U.png)
#### 6. Ficheros transferidos recientemente por NetBios
#### 7. Contenido de la caché DNS
#### 8. Variables de entorno
Para ver las variables de entorno, uso el comando `envars`:
```bash
python vol.py -f "/media/roberto/usb/memdump.mem" windows.envars.Envars
```
![vol6](https://i.imgur.com/IUSyeJ2.png)
### Volcado del registro
Para realizar el volcado de registro he usado también la herramienta **FTK Imager**. Utilizo la opción `Obtain system files`:
![ftk5](https://i.imgur.com/JUcvnmy.png)
Una vez finalizado el volcado, utilizo el programa **Registry Viewer** para analizar los datos obtenidos.
#### 10. Redes wifi utilizadas recientemente
Para ver las redes wifi usadas recientemente, abro el archivo `software`, y ahí sigo la siguiente ruta: `Microsoft/Windows NT/CurrentVersion/NetworkList/Profiles`:
![reg1](https://i.imgur.com/RFzUv61.png)
#### 11. Configuración del firewall de nodo
Para ver la configuración del firewall de nodo, abro el archivo `system`, y ahí sigo la siguiente ruta: `ControlSet001/Services/SharedAccess/Parameters/FirewallPolicy/FirewallRules`:
![reg2](https://i.imgur.com/4b7ZsO1.png)
#### 12. Programas que se ejecutan en el Inicio
Para ver los programas que se ejecutan en el inicio, abro el archivo `software`, y ahí sigo la siguiente ruta: `Microsoft/Windows/CurrentVersion/Run`:
![reg3](https://i.imgur.com/6MsrP73.png)
#### 13. Asociación de extensiones de ficheros y aplicaciones
No he podido encontrar en la aplicación **Registry Viewer** los registros, pero usando regedit en la máquina, se encuentran en la siguiente localización: `Computer\HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\FileExts`:
![reg4](https://i.imgur.com/Ig5FCUk.png)
### Volcado de disco
Para realizar el volcado de disco he usado la herramienta FTK Imager también:
![ftk1](https://i.imgur.com/tUwr02N.png)
Selecciono **RAW** como tipo de imagen:
![ftk2](https://i.imgur.com/GWoxYEU.png)
Y, como indica la ayuda, en Fragment size pongo 0, además de indicar la ruta y el nombre del fichero:
![ftk3](https://i.imgur.com/cTgXwqp.png)
El resto de los pasos del proceso los dejo con los valores por defecto.
Ahora, para analizar los datos, utilizo Autopsy; para ello, abro el fichero que he creado con FTK Imager, indicamos el direcorio del fichero , y en tipo, selecciono **Disk image or VM file**:
![autopsy1](https://i.imgur.com/JHCRjQ2.png)
Tras finalizar la configuración, empezará a analizar el volcado de disco. Este proceso tarda bastante tiempo en completarse. Una vez acabado podemos analizar los datos obtenidos.
#### 9. Dispositivos USB conectados
Para ver los dispositivos USB conectados, utilizo la opción `USB Device Attached`:
![autopsy8](https://i.imgur.com/1XfoSfH.png)
#### 14. Aplicaciones usadas recientemente
Para ver las aplicaciones usadas recientemente, utilizo la opción `User Activity` del disco duro:
![autopsy9](https://i.imgur.com/vthHo40.png)
#### 15. Ficheros abiertos recientemente
![autopsy9](https://i.imgur.com/ZQtfblE.png)
#### 16. Software Instalado
Para ver el software instalado, utilizo la opción `Installed Programs`:
![autopsy10](https://i.imgur.com/xsFb4yR.png)
#### 18. Cuentas de Usuario
Para ver las cuentas de usuario, utilizo la opción `OS Accounts`:
![autopsy11](https://i.imgur.com/A1Ha5e6.png)
#### 19. Historial de navegación y descargas, cookies
Para ver el historial de navegación, utilizo la opción `Web History`:
![autopsy12](https://i.imgur.com/1EN0RI4.png)
Para ver las cookies utilizo la opción `Web Cookies`:
![autopsy13](https://i.imgur.com/rDaxg3p.png)
Para ver el historial de descargas, utilizo la opción `Web Downloads`:
![autopsy14](https://i.imgur.com/A6x55kE.png)
#### 21. Archivos con extensión cambiada
Los archivos con extensión cambiada aparecen en la sección `Analysis Results/Extension Mismatch Detected`:
![autopsy2](https://i.imgur.com/hmLGaGi.png)
#### 22. Archivos eliminados
Los archivos eliminados aparecen en la sección `Recycle Bin`:
![autopsy3](https://i.imgur.com/XmQIyKC.png)
#### 23. Archivos Ocultos
En la opción para explorar el sistema de archivos, se pueden distinguir los archivos ocultos porque en los metadatos, aparece la etiqueta: `Hidden`:
![autopsy4](https://i.imgur.com/OcIKUYP.png)
#### 24. Archivos que contienen una cadena determinada
Para buscar archivos que contengan una cadena determinada, utilizo la opción `Keyword Search`:
![autopsy5](https://i.imgur.com/B9ezFRy.png)
#### 25. Búsqueda de imágenes por ubicación
Para buscar imágenes por ubicación, utilizo la opción `Geolocation`:
![autopsy6](https://i.imgur.com/G9nTp6h.png)
#### 26. Búsqueda de archivos por autor
Para buscar archivos por autor, utilizo la opción `Metadata`:
![autopsy7](https://i.imgur.com/XcQPTmy.png)
## Apartado B) Máquina Linux
Intenta realizar las mismas operaciones en una máquina Linux para aquellos apartados que tengan sentido y no se realicen de manera idéntica a Windows.
### Volcado de memoria
He realizado el volcado de memoria con **Lime**, que es una herramienta que se utiliza para realizar volcados de memoria en Linux. Para ello, he usado el comando de la siguiente manera (he instalado Lime meadiante su repositorio en github):
```bash
insmod lime-4.19.0-23-amd64.ko "path=/mnt/linux/memorialinux.mem format=lime"
```
Es importante que para realizar el volcado, hay que iniciar el sistema de forma insegura, ya que si no, no permite utilizar el comando.
No he sido capaz de realizar el análisis utilizando volatility, ya que es necesario instalar plugins para interpretar el volcado de memoria, y no los reconoce, por lo que voy a usar los comandos en lugar de trabajar sobre el volcado.
#### 1. Procesos en ejecución
Para ver los procesos en ejecución, utilizo el comando `ps aux`:
![ps1](https://i.imgur.com/I6H5Egn.png)
#### 2. Servicios en ejecución
Para ver los servicios en ejecución, utilizo el comando `systemctl`:
```bash
systemctl list-units --type=service --state=running
```
![systemctl1](https://i.imgur.com/lh2yFCl.png)
#### 3. Puertos abiertos
Para ver los puertos abiertos, utilizo el comando `netstat`, que se encuentra en el paquete `net-tools`:
```bash
apt install net-tools
netstat -tulpn
```
![netstat1](https://i.imgur.com/QmwsCnY.png)
#### 4. Conexiones establecidas por la máquina
Las sesiones se pueden observar en el comando netstat utilizado anteriormente.
#### 5. Sesiones de usuario establecidas remotamente
Para ver las sesiones de usuario establecidas remotamente, utilizo el comando `who`:
```bash
who -a
```
![who1](https://i.imgur.com/m6c6R6z.png)
#### 7. Contenido de la caché DNS
En debian, la caché dns está deshabilitada por defecto. Para habilitarla, voy a instalar el paquete **nscd** (demonio de caché para servicio de nombres), y leer el fichero que genera. El fichero tiene un formato binario, por lo que voy a usar el comando `strings` para ver su contenido:
```bash
strings /var/cache/nscd/hosts
```
![nscd1](https://i.imgur.com/4rfJMeG.png)
#### 8. Variables de entorno
Para ver las variables de entorno, utilizo el comando `env`:
![env1](https://i.imgur.com/O4fIJRT.png)
### Volcado de disco
El volcado de disco en linux lo he realizado con el comando dd, que se utiliza para copiar archivos y volúmenes. Para ello, he usado el comando de la siguiente manera:
```bash
dd if=/dev/vda2 of=/mnt/linux/volcado_linux.001 bs=64K
```
![dd1](https://i.imgur.com/6P6cdSJ.png)
Es imporate que, durante el análisis de la imagen en Autopsy, el tiempo es mucho mayor, y que es de hecho la última fase, cuando ya se encuentra al 100% la que toma más tiempo.
Los apartados rellativos al análisis usando autopsy, o se realizan exactamente igual que en Windows, o no tienen sentido en Linux, por lo que no los están documentados aquí.

Binary file not shown.

After

Width:  |  Height:  |  Size: 516 KiB

@ -0,0 +1,159 @@
---
title: "Integridad, firmas y autenticación"
date: 2023-01-30T09:16:26+01:00
draft: false
---
## Tarea 1: Firmas electrónicas
1. **Manda un documento y la firma electrónica del mismo a un compañero. Verifica la firma que tu has recibido.**
```bash
echo "DOCUMENTO CIFRADO SECRETO" > documento_rober.txt\n
gpg --output firmarober.sig --detach-sig documento_rober.txt
```
Envío los ficheros por correo.
2. **¿Qué significa el mensaje que aparece en el momento de verificar la firma?**
![Firma](https://i.imgur.com/dOFJJTl.png)
Significa que, aunque el fichero está firmado por esa firma, no se puede asegurar que la firma pertenezca a la persona que dice ser.
3. **Vamos a crear un anillo de confianza entre los miembros de nuestra clase, para ello.**
* Tu clave pública debe estar en un servidor de claves
* Escribe tu fingerprint en un papel y dárselo a tu compañero, para que puede descargarse tu clave pública.
* Te debes bajar al menos tres claves públicas de compañeros. Firma estas claves.
* Tu te debes asegurar que tu clave pública es firmada por al menos tres compañeros de la clase.
* Una vez que firmes una clave se la tendrás que devolver a su dueño, para que otra persona se la firme.
* Cuando tengas las tres firmas sube la clave al servidor de claves y rellena tus datos en la tabla Claves públicas PGP 2020-2021
* Asegurate que te vuelves a bajar las claves públicas de tus compañeros que tengan las tres firmas.
4. **Muestra las firmas que tiene tu clave pública.**
Listamos las firmas con el comando `gpg --list-sigs`
![Firmas](https://i.imgur.com/LnWbJLH.png)
5. **Comprueba que ya puedes verificar sin “problemas” una firma recibida por una persona en la que confías.**
Como se puede ver en la imagen anterior, nuestra firma está verificada por **Antonio**, y viceversa. Por lo que podemos verificar sin problemas un documento firmado por **Antonio**.
![Verificación](https://i.imgur.com/LnLceFT.png)
6. **Comprueba que puedes verificar con confianza una firma de una persona en las que no confías, pero sin embargo si confía otra persona en la que tu tienes confianza total.**
Ahora, vamos a utilizar un fichero firmado por **María Jesús**, en la que no confiamos directamente, pero en la que sí tiene confianza plena **Antonio**:
![Verificación 2](https://i.imgur.com/dzHItTJ.png)
## Tarea 3: Integridad de ficheros
Para validar el contenido de la imagen CD, solo asegúrese de usar la herramienta apropiada para sumas de verificación. Para cada versión publicada existen archivos de suma de comprobación con algoritmos fuertes (SHA256 y SHA512); debería usar las herramientas sha256sum o sha512sum para trabajar con ellos.
1. **Verifica que el contenido del hash que has utilizado no ha sido manipulado, usando la firma digital que encontrarás en el repositorio. Puedes encontrar una guía para realizarlo en este artículo: How to verify an authenticity of downloaded Debian ISO images**
```bash
wget https://cdimage.debian.org/debian-cd/current/amd64/iso-cd/debian-11.6.0-amd64-netinst.iso
wget https://cdimage.debian.org/debian-cd/current/amd64/iso-cd/SHA256SUMS
sha256sum -c SHA256SUMS 2> /dev/null | grep netinst
```
![Verificación de hash](https://i.imgur.com/aAHo0GB.png)
## Tarea 4: Integridad y autenticidad
Busca información sobre **apt secure** y responde las siguientes preguntas:
1. **¿Qué software utiliza apt secure para realizar la criptografía asimétrica?**
Utiliza **GnuPG** para realizar la criptografía asimétrica.
2. **¿Para que sirve el comando apt-key? ¿Qué muestra el comando apt-key list?**
El comando `apt-key` sirve para administrar las claves de los repositorios de paquetes. El comando `apt-key list` muestra las claves de los repositorios de paquetes.
3. **En que fichero se guarda el anillo de claves que guarda la herramienta apt-key?**
El anillo de claves se guarda en el fichero `/etc/apt/trusted.gpg`.
4. **¿Qué contiene el archivo Release de un repositorio de paquetes?. ¿Y el archivo Release.gpg?. Puedes ver estos archivos en el repositorio http://ftp.debian.org/debian/dists/Debian10.1/. Estos archivos se descargan cuando hacemos un apt update.**
El archivo `Release` contiene la lista de paquetes que contiene el repositorio de paquetes. El archivo `Release.gpg` contiene la firma digital del archivo `Release`.
5. **Explica el proceso por el cual el sistema nos asegura que los ficheros que estamos descargando son legítimos.**
El sistema nos asegura que los ficheros que estamos descargando son legítimos mediante la verificación de la firma digital del fichero `Release` que se encuentra en el repositorio de paquetes.
6. **añade de forma correcta el repositorio de virtualbox añadiendo la clave pública de virtualbox como se indica en la documentación.**
Se hace con los siguientes comandos:
```bash
echo "deb https://download.virtualbox.org/virtualbox/debian buster contrib" >> /etc/apt/sources.list
wget -q https://www.virtualbox.org/download/oracle\_vbox\_2016.asc -O- | apt-key add -
wget -q https://www.virtualbox.org/download/oracle\_vbox.asc -O- | apt-key add -
```
Tras esto, se puede instalar virtualbox con el comando `apt install virtualbox`.
## Tarea 5: Autentificación: ejemplo SSH
1. **Explica los pasos que se producen entre el cliente y el servidor para que el protocolo cifre la información que se transmite? ¿Para qué se utiliza la criptografía simétrica? ¿Y la asimétrica?**
Los pasos que se producen entre el cliente y el servidor para que el protocolo cifre la información que se transmite son los siguientes:
* Se lleva a cabo un 'handshake' (apretón de manos) encriptado para que el cliente pueda verificar que se está comunicando con el servidor correcto
* La capa de transporte de la conexión entre el cliente y la máquina remota es encriptada mediante un código simétrico
* El cliente se autentica ante el servidor.
* El cliente remoto interactua con la máquina remota sobre la conexión encriptada.
La criptografía simétrica se utiliza para encriptar la información que se transmite entre el cliente y el servidor. La criptografía asimétrica se utiliza para autentificar al cliente y al servidor.
2. **Explica los dos métodos principales de autentificación: por contraseña y utilizando un par de claves públicas y privadas.**
Los dos métodos principales de autentificación son:
* Por contraseña: el cliente envía la contraseña al servidor para que este pueda autentificar al cliente.
* Por par de claves públicas y privadas: el cliente envía su clave pública al servidor para que este pueda autentificar al cliente. El cliente envía su clave privada al servidor para que este pueda autentificar al cliente.
3. **En el cliente para que sirve el contenido que se guarda en el fichero ~/.ssh/know_hosts?**
El contenido que se guarda en el fichero ~/.ssh/know_hosts sirve para que el cliente pueda autentificar al servidor.
4. **¿Qué significa este mensaje que aparece la primera vez que nos conectamos a un servidor?**
```bash
$ ssh debian@172.22.200.74
The authenticity of host '172.22.200.74 (172.22.200.74)' can't be established.
ECDSA key fingerprint is SHA256:7ZoNZPCbQTnDso1meVSNoKszn38ZwUI4i6saebbfL4M.
Are you sure you want to continue connecting (yes/no)?
```
Implica que la conexión es nueva y que el cliente no tiene guardada la clave pública del servidor. Por lo tanto, el cliente no puede autentificar al servidor. El cliente pregunta al usuario si quiere continuar con la conexión.
5. **En ocasiones cuando estamos trabajando en el cloud, y reutilizamos una ip flotante nos aparece este mensaje:**
```bash
$ ssh debian@172.22.200.74
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!
Someone could be eavesdropping on you right now (man-in-the-middle attack)!
It is also possible that a host key has just been changed.
The fingerprint for the ECDSA key sent by the remote host is
SHA256:W05RrybmcnJxD3fbwJOgSNNWATkVftsQl7EzfeKJgNc.
Please contact your system administrator.
Add correct host key in /home/jose/.ssh/known_hosts to get rid of this message.
Offending ECDSA key in /home/jose/.ssh/known_hosts:103
remove with:
ssh-keygen -f "/home/jose/.ssh/known_hosts" -R "172.22.200.74"
ECDSA host key for 172.22.200.74 has changed and you have requested strict checking.
```
Significa que la clave pública que teníamos asociada a esa dirección IP ha cambiado. Por lo tanto, el cliente no puede autentificar al servidor. Por lo que podría implicar que se está suplantando su identidad. Si aún así queremos continuar, hay que ejecutar el comando `ssh-keygen -f "/home/jose/.ssh/known_hosts" -R "172.22.200.74"`
6. **¿Qué guardamos y para qué sirve el fichero en el servidor ~/.ssh/authorized_keys?**
En ese fichero se guardan las claves públicas de los clientes que pueden acceder al servidor. Sirve para que el servidor pueda autentificar a los clientes.

Binary file not shown.

After

Width:  |  Height:  |  Size: 257 KiB

@ -0,0 +1,322 @@
---
title: "Introducción a OpenLDAP"
date: 2023-01-25T13:47:32+01:00
draft: false
---
El protocolo **LDAP** es muy utilizado actualmente por empresa que apuestan por el software libre al utilizar distribuciones de Linux para ejercer las funciones propias de un **directorio activo** en el que se gestionarán las credenciales y permisos de los trabajadores y estaciones de trabajo en redes LAN corporativas en conexiones cliente/servidor.
Realiza la instalación y configuración básica de OpenLDAP en alfa,utilizando como base el nombre DNS asignado. Deberás crear un usuario llamado prueba y configurar una máquina cliente basada en Debian y Rocky para que pueda validarse en servidor ldap configurado anteriormente con el usuario prueba.
## Servidor
### Instalación de OpenLDAP
Instalaremos OpenLDAP en el servidor alfa, para ello ejecutaremos los siguientes comandos:
```bash
apt update
apt install slapd
```
Durante la instalación nos pedirá que introduzcamos la contraseña de administrador del directorio:
![Instalación de OpenLDAP](https://i.imgur.com/NaNjKFA.png)
Una vez instalado con el comando `netstat -tulpn` comprobaremos que el servicio está escuchando en el puerto 389:
![Instalación de OpenLDAP](https://i.imgur.com/KGi2Vz6.png)
Ahora, utilizando el binario `ldapsearch` incluido en el paquete `ldap-utils` podemos buscar sobre el directorio:
```bash
ldapsearch -x -b "dc=roberto,dc=gonzalonazareno,dc=org"
```
![ldapsearch1](https://i.imgur.com/FgmXMPY.png)
### Configuración de OpenLDAP
![esquemaLDAP](https://i.imgur.com/qRgLvAz.png)
Para lograr una mejor estructura, la información suele organizarse en forma de **ramas** de las que cuelgan objetos similares (por ejemplo, una rama para usuarios y otra para grupos). Organizar de esta manera la estructura nos aporta también una mayor agilidad en las búsquedas, así como una gestión más eficiente sobre los permisos. Cada rama se denomina **organizational unit** (OU) y cada objeto que cuelga de ella se denomina **entry**.
ara definir dichos objetos, haremos uso de un fichero con extensión `.ldif`, en este caso he creado el fichero `unidades.ldif` con el siguiente contenido:
```ldif
dn: ou=Personas,dc=roberto,dc=gonzalonazareno,dc=org
objectClass: organizationalUnit
ou: Personas
dn: ou=Grupos,dc=roberto,dc=gonzalonazareno,dc=org
objectClass: organizationalUnit
ou: Grupos
```
Para activar el fichero de configuración, ejecutaremos el siguiente comando:
```bash
ldapadd -x -D "cn=admin,dc=roberto,dc=gonzalonazareno,dc=org" -f unidades.ldif -W
```
![ldapadd](https://i.imgur.com/QlLeqHB.png)
Ahora, podemos comprobar que se ha creado las ramas `Personas` y `Grupos`:
```bash
ldapsearch -x -b "dc=roberto,dc=gonzalonazareno,dc=org"
```
![ldapsearch2](https://i.imgur.com/ypKuRlq.png)
Podemos borrar los objetos creados con el comando `ldapdelete`:
```bash
ldapdelete -x -D 'cn=admin,dc=roberto,dc=gonzalonazareno,dc=org' -W ou=Personas,dc=roberto,dc=gonzalonazareno,dc=org
ldapdelete -x -D 'cn=admin,dc=roberto,dc=gonzalonazareno,dc=org' -W ou=Grupos,dc=roberto,dc=gonzalonazareno,dc=org
```
Ahora vamos a crear un grupo llamado prueba en el fichero `grupos.ldif`:
```ldif
dn: cn=prueba,ou=Grupos,dc=roberto,dc=gonzalonazareno,dc=org
objectClass: posixGroup
gidNumber: 2001
cn: prueba
```
Para activar el fichero de configuración, ejecutaremos el siguiente comando:
```bash
ldapadd -x -D 'cn=admin,dc=roberto,dc=gonzalonazareno,dc=org' -W -f grupos.ldif
```
Ejecutando el comando `ldapsearch` podemos comprobar que se ha creado el grupo:
![ldapadd2](https://i.imgur.com/MZxmh26.png)
### Creación del usuario
Ahora vamos a crear un usuario llamado *prueba*. Antes de crearlo, vamos a ejecutar el comando `slappasswd` para crear una contraseña cifrada para el usuario:
![slappasswd](https://i.imgur.com/RrnHM66.png)
Ahora, vamos a crear el usuario en el fichero `usuarios.ldif`:
```ldif
dn: uid=prueba,ou=Personas,dc=roberto,dc=gonzalonazareno,dc=org
objectClass: posixAccount
objectClass: inetOrgPerson
objectClass: person
cn: prueba
uid: prueba
uidNumber: 2001
gidNumber: 2001
homeDirectory: /nfs/prueba
loginShell: /bin/bash
userPassword: {SSHA}sDPbVb9gQ37YaNSg5nPyIe776dmlU2bq
sn: prueba
mail: prueba@gmail.com
givenName: prueba
```
Para activar el fichero de configuración, ejecutaremos el siguiente comando:
```bash
ldapadd -x -D 'cn=admin,dc=roberto,dc=gonzalonazareno,dc=org' -W -f usuarios.ldif
```
Ejecutando el comando `ldapsearch` podemos comprobar que se ha creado el usuario:
![ldapadd3](https://i.imgur.com/9pq9gxy.png)
### Configuración de NFS
Ahora vamos a configurar el servidor NFS para que pueda compartir el directorio `/nfs` con los clientes.
Primero vamos a crear el directorio `/nfs/prueba` y le vamos a dar permisos al usuario `prueba`:
```bash
mkdir /nfs/prueba
chown 2001:2001 /nfs/prueba
```
Ahora vamos a editar el fichero `/etc/exports` y añadir la siguiente línea, que permite que el usuario `prueba` pueda acceder al directorio `/nfs/prueba`:
```bash
/nfs *(rw,fsid=0,subtree_check)
```
Ahora vamos a reiniciar el servicio NFS:
```bash
systemctl restart nfs-server
```
### Configuración final del servidor LDAP
Ahora vamos a configurar el servidor LDAP para que sea capaz de resolver nombres de grupos y de usuarios, consultar información a un directorio LDAP, identificarse o cachear la resolución de nombres.
Para ello, instalamos los siguientes paquetes:
```bash
apt install libpam-ldapd nscd libnss-ldap
```
Durante la instalación, dejamos los valores por defecto menos en las siguientes preguntas:
![ldapinstall](https://i.imgur.com/9xawQHF.png)
![ldapinstall2](https://i.imgur.com/mnPntoB.png)
Como se indica al final de la instalación, vamos a editar el fichero `/etc/nsswitch.conf` y añadir las siguientes líneas:
```bash
passwd: files ldap
group: files ldap
shadow: files ldap
gshadow: files ldap
hosts: files dns mymachines
networks: files
protocols: db files
services: db files
ethers: db files
rpc: db files
netgroup: nis
```
Reiniciamos el servicio `nscd`:
```bash
systemctl restart nscd
```
Ahora con el comando `id prueba` podemos comprobar que se resuelven los nombres:
![id](https://i.imgur.com/ucsbVhG.png)
Finalmente podemos iniciar sesión con el comando `login prueba`:
![login](https://i.imgur.com/zxXslPM.png)
## Cliente Ubuntu
Instalamos el siguiente paquete:
```bash
apt install ldap-utils
```
Ahora vamos a editar el fichero `/etc/ldap/ldap.conf` y añadir las siguientes líneas:
```bash
BASE dc=roberto,dc=gonzalonazareno,dc=org
URI ldap://alfa.roberto.gonzalonazareno.org
```
Después de esto, con el siguiente comando comprobamos que funciona correctamente:
```bash
ldapsearch -x -b "dc=roberto,dc=gonzalonazareno,dc=org"
```
![ldapsearch](https://i.imgur.com/FKUMW0Q.png)
Ahora vamos a instalar los paquetes para las resoluciones:
```bash
apt install libnss-ldap libpam-ldapd nscd
```
La instalación es similar a la del sevidor, dejando valores por defecto y cambiando los mismos, además de añadir un usuario sin privilegios.
Como se indica al final de la instalación, vamos a editar el fichero `/etc/nsswitch.conf` y añadir las siguientes líneas:
```bash
passwd: files systemd ldap
group: files systemd ldap
shadow: files ldap
gshadow: files ldap
hosts: files dns
networks: files
protocols: db files
services: db files
ethers: db files
rpc: db files
netgroup: nis
```
Reiniciamos el servicio `nscd`:
```bash
systemctl restart nscd
```
### NFS
Ahora vamos a instalar el paquete `nfs-common`:
```bash
apt install nfs-common
```
Activamos el servicio
```bash
systemctl start nfs-client.target & systemctl enable nfs-client.target
```
Ahora vamos a crear los directorios que vamos a montar:
```bash
mkdir -p /home/nfs/prueba
chown 2001:2001 /home/nfs/prueba
```
Ahora vamos a montar la carpeta mediante NFS. Primero, cargamos el módulo
```bash
modprobe nfs
```
Con la siguiente línea se carga automáticamente:
```bash
echo NFS | tee -a /etc/modules
```
Y vamos a hacer un montaje mediante SystemD a través del fichero `/etc/systemd/system/home-nfs.mount`:
```bash
[Unit]
Description=script de montaje NFS
Requires=network-online.target
After=network-online.target
[Mount]
What=192.168.0.1:/nfs
Where=/home/nfs
Options=_netdev,auto
Type=nfs
[Install]
WantedBy=multi-user.target
```
Y lo activamos:
```bash
systemctl daemon-reload
systemctl start home-nfs.mount
systemctl enable home-nfs.mount
```
Tras esto, ya podremos entrar correctamente con `login prueba`. Podemos comprobar como los ficheros creados en el servidor se ven reflejados en el cliente:
![nfs](https://i.imgur.com/J1lCNBZ.png)

@ -0,0 +1,91 @@
---
title: "Recolección centralizada de logs de sistema, mediante Journald"
date: 2023-01-15T23:39:03+01:00
draft: false
---
El escenario de OpenStack es el siguiente:
![escenario](https://i.imgur.com/I7aSQqg.png)
## Enunciado
Implementa en tu escenario de trabajo de Openstack, un sistema de recolección de log mediante journald. Para ello debes, implementar un sistema de recolección de log mediante el paquete systemd-journal-remote, o similares.
## Preparación
En cada instancia, voy a instalar el paquete `systemd-journal-remote`; en alfa, charlie y delta ejecuto el siguiente comando:
```bash
apt install systemd-journal-remote
```
en bravo, ejecuto el siguiente comando:
```bash
sudo dnf install systemd-journal-remote
```
## Configuración
He elegido el servidor alfa como servidor de logs, por lo que en él, voy a configurar el servicio. No voy a usar https ni autenticación, por lo que en el fichero `/lib/systemd/system/systemd-journal-remote.service` voy a modificar la siguientes línea:
```bash
ExecStart=/lib/systemd/systemd-journal-remote --listen-http=-3 --output=/var/log/journal/remote/
```
Ahora inicio el servicio y lo habilito para que se inicie en el arranque:
```bash
sudo systemctl enable --now systemd-journal-remote.socket
sudo systemctl enable --now systemd-journal-remote.service
sudo systemctl status systemd-journal-remote.socket
sudo systemctl status systemd-journal-remote.service
```
![status](https://i.imgur.com/nKnk0fe.png)
## Configuración de los clientes
Para ello, en cada uno crearé un usuario llamado `systemd-journal-upload` configurado de la siguiente manera:
**en charlie y delta**
```bash
sudo adduser --system --home /run/systemd --no-create-home --disabled-login --group systemd-journal-upload
```
**en bravo**
```bash
sudo adduser --system --home-dir /run/systemd --no-create-home --user-group systemd-journal-upload
```
Ahora modifico en el fichero `/etc/systemd/journal-upload.conf` la siguiente línea:
```bash
URL=http://alfa.roberto.gonzalonazareno.org:19532
```
Ahora reinicio el servicio en todas las máquinas:
```bash
sudo systemctl restart systemd-journal-upload.service
```
## Comprobación
En el servidor alfa, voy a comprobar que se están recibiendo los logs de los clientes
![logs](https://i.imgur.com/4HNPxgv.png)
Para ver los logs de los clientes, en el servidor alfa, ejecuto el siguiente comando (en este caso, el de delta):
```bash
sudo journalctl --file /var/log/journal/remote/remote-192.168.0.3.journal
```
![logs](https://i.imgur.com/qnJuI9g.png)
En un ejemplo anterior: [Ejemplo completo: Desplegando y accediendo a la aplicación Temperaturas](https://github.com/josedom24/curso_kubernetes_ies/blob/main/modulo6/temperaturas.md) habíamos desplegado una aplicación formada por dos microservicios que nos permitía visualizar las temperaturas de municipios.

@ -0,0 +1,90 @@
---
title: "Paquetes"
date: 2022-10-13T13:05:20+02:00
draft: true
---
```mermaid
graph LR;
A[OldOldStable]-->B[OldStable];
B-->C[Stable<br>Main]
C-->D[Testing]
D-->E[Unstable]
E-->F[Experimental]
```
graph LR;
A[OldOldStable]-->B[OldStable];
B-->C[Stable<br>Main]
C-->D[Testing]
D-->E[Unstable]
E-->F[Experimental]
/etc/apt/preferences
## COMANDOS USADOS:
```bash
apt policy mdadm
sudo apt-listbugs -s all list mdadm
sudo apt install --simulate mdadm
dpkg --print-architecture
dpkg --print-foreign-architectures
sudo dpkg --add-architecture arm64
# primero simulamos la instalación
sudo apt install --simulate mdadm/bullseye-backports
# luego instalamos
sudo apt install -t bullseye-backports mdadm
sudo apt install mdadm/bullseye-backports
# o modificando el fichero de preferencia
# para borrarlo
sudo apt remove mdadm
sudo apt purge mdadm
sudo apt install mdadm=4.21~bpo11+1 --install-recommends # para instalar las recomendaciones
sudo apt policy beep
sudo apt install beep:i386
sudo apt-rdepends mdadm
# paquete necesario
apt policy signing-party
apt install signing-party
apt-rdepends -d mdadm >> graficomdadm.dot
springgraph < graficomdadm.dot > graficomdadm.png
```
Configuración del fichero debconf:
```bash
sudo dpkg-reconfigure debconf
sudo dpkg-reconfigure mdadm
sudo dpkg-reconfigure keyboard-configuration --frontend dialog --priority critical
# con el siguiente comando vemos las opciones configuradas con debconf
sudo debconf-show mdadm
# para saber si un paquete utiliza debconf vemos la dependencia inversa
apt show keyboard-configuration
```
las arquitecturas están en la página de debian
/etc/apt/preferences
getselections
dpkg --info mdadm
apt clean
![pruebagif](pruebagif.gif)
## KERNEL
```bash
sudo apt-source install linuxsource=5.19.11-1
sudo apt install --simulate build-essential flex bison openssl libssl-deb dkms libncurses-dev ncurses-dev qtbase5-deb libelf-dev
```

@ -0,0 +1,39 @@
{"version": 2, "width": 80, "height": 24, "timestamp": 1666077470, "env": {"SHELL": "/usr/bin/zsh", "TERM": "xterm-256color"}}
[0.10372, "o", "\u001b[1m\u001b[7m%\u001b[27m\u001b[1m\u001b[0m \r \r"]
[0.104712, "o", "\u001b]2;roberto@portatil:~/Documentos/pagina/paginahugo\u0007"]
[0.104852, "o", "\u001b]1;..na/paginahugo\u0007"]
[0.161549, "o", "\r\u001b[0m\u001b[27m\u001b[24m\u001b[J\u001b[35mroberto\u001b[00m\u001b[36m@\u001b[00m\u001b[33mportatil\u001b[00m\u001b[31m:\u001b[00m\u001b[36m~/Documentos/pagina/paginahugo\u001b[00m\u001b[31m|\u001b[00m\u001b[00m\u001b[32mmaster\u001b[33m⚡\u001b[00m\u001b[00m \u001b[36m⇒\u001b[00m \u001b[K"]
[0.161825, "o", "\u001b[?1h\u001b="]
[0.162187, "o", "\u001b[?2004h"]
[2.730012, "o", "c"]
[2.812931, "o", "\bcd"]
[5.048077, "o", " "]
[6.021707, "o", "."]
[6.750301, "o", "\b \b"]
[6.867881, "o", "\b"]
[7.331493, "o", "\b\bc \b"]
[7.466409, "o", "\b \b"]
[8.249759, "o", "h"]
[8.665092, "o", "\b \b"]
[8.775805, "o", "g"]
[8.861579, "o", "\bgi"]
[8.992507, "o", "t"]
[9.088893, "o", " "]
[9.230292, "o", "s"]
[9.459303, "o", "t"]
[9.532512, "o", "a"]
[9.645597, "o", "t"]
[9.729271, "o", "u"]
[9.900108, "o", "s"]
[10.025077, "o", "\u001b[?1l\u001b>"]
[10.025921, "o", "\u001b[?2004l\r\r\n"]
[10.026521, "o", "\u001b]2;git status\u0007\u001b]1;git\u0007"]
[10.049277, "o", "En la rama master\r\n"]
[10.049663, "o", "Tu rama está actualizada con 'origin/master'.\r\n\r\nCambios no rastreados para el commit:\r\n (usa \"git add <archivo>...\" para actualizar lo que será confirmado)\r\n (usa \"git restore <archivo>...\" para descartar los cambios en el directorio de trabajo)\r\n (confirmar o descartar el contenido sin seguimiento o modificado en los sub-módulos)\r\n"]
[10.050028, "o", "\t\u001b[31mmodificado: config/_default/config.toml\u001b[m\r\n\t\u001b[31mmodificado: content/posts/paquetes/index.md\u001b[m\r\n\t\u001b[31mmodificado: \"content/posts/snort/Introducci\\303\\263n/index.md\"\u001b[m\r\n\t\u001b[31mmodificado: go.mod\u001b[m\r\n\t\u001b[31mmodificado: themes/blowfish\u001b[m (contenido no rastreado)\r\n\r\nArchivos sin seguimiento:\r\n (usa \"git add <archivo>...\" para incluirlo a lo que se será confirmado)\r\n\t\u001b[31mcontent/posts/paquetes/pruebagif.gif\u001b[m\r\n\t\u001b[31m\"content/posts/snort/Introducci\\303\\263n/estructuraregla.png\"\u001b[m\r\n\t\u001b[31m\"content/posts/snort/Introducci\\303\\263n/featured.jpg\"\u001b[m\r\n\t\u001b[31m\"content/posts/snort/Introducci\\303\\263n/instalacion.png\"\u001b[m\r\n\t\u001b[31m\"content/posts/snort/Introducci\\303\\263n/pruebainstalacion.png\"\u001b[m\r\n\t\u001b[31m\"content/posts/snort/Introducci\\303\\263n/pruebaping.png\"\u001b[m\r\n\t\u001b[31m\"content/posts/snort/Introducci\\303\\263n/rutasreglas.png\"\u001b[m\r\n\t\u001b[31m\"content/posts/snort/Introducci\\303\\263n/snorter1.png\"\u001b[m\r\n\t\u001b[31mgo.sum\u001b[m\r\n\t\u001b[31mresources/_gen/images/posts/paquetes/\u001b[m\r\n\t\u001b[31m\"resources/_gen/images/posts/snor"]
[10.050072, "o", "t/Introducci\\303\\263n/\"\u001b[m\r\n\r\nsin cambios agregados al commit (usa \"git add\" y/o \"git commit -a\")\r\n"]
[10.050882, "o", "\u001b[1m\u001b[7m%\u001b[27m\u001b[1m\u001b[0m \r \r"]
[10.051147, "o", "\u001b]2;roberto@portatil:~/Documentos/pagina/paginahugo\u0007\u001b]1;..na/paginahugo\u0007"]
[10.127412, "o", "\r\u001b[0m\u001b[27m\u001b[24m\u001b[J\u001b[35mroberto\u001b[00m\u001b[36m@\u001b[00m\u001b[33mportatil\u001b[00m\u001b[31m:\u001b[00m\u001b[36m~/Documentos/pagina/paginahugo\u001b[00m\u001b[31m|\u001b[00m\u001b[00m\u001b[32mmaster\u001b[33m⚡\u001b[00m\u001b[00m \u001b[36m⇒\u001b[00m \u001b[K\u001b[?1h\u001b=\u001b[?2004h"]
[12.494557, "o", "\u001b[?2004l"]
[12.495666, "o", "\r\r\n"]

Binary file not shown.

After

Width:  |  Height:  |  Size: 232 KiB

@ -0,0 +1,6 @@
---
title: Práctica 1 ABD
description: Artículos subidos a la página por orden de fecha
---
Parte individual Roberto Rodríguez Márquez

Binary file not shown.

After

Width:  |  Height:  |  Size: 63 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 148 KiB

@ -0,0 +1,45 @@
---
title: "Aplicacion web MySQL"
date: 2022-10-31T01:05:11+01:00
draft: false
---
## Instalación
instalamos php:
```bash
apt install apache2 libapache2-mod-php php php-mysql
apt install php-zip php-gd php-mbstring phpmyadmin -y
```
## Configuración
En la instalación de phpmyadmin elegimos como servidor **apache2**, después, cuando nos pregunta por una contraseña, le damos a Sí, e introducimos una contraseña para phpmyadmin dos veces
Una vez instalado, para poder acceder con un usuario concreto, tenemos que hacer lo siguiente:
Entramos en el directorio de phpmyadmin y copiamos un fichero de ejemplo para utilizarlo como configuración:
```bash
cd /usr/share/phpmyadmin/
cp config.sample.inc.php config.inc.php
```
en el fichero `config.inc.php` tenemos que añadir a `blowfish_secret` una cadena de 30 caracteres, y tenemos que descomentar las lineas de `controluser`y `controlpass` y añadirles las credenciales.
![fichero_conf](fichero_conf.png)
Una vez realizada la configuración, reiniciamos el servicio:
```bash
systemctl reload apache2
```
## Prueba
y podemos acceder a la página de administración en `http://IPmaquina/phpmyadmin/`:
![login](login.png)
![home](home.png)
![tablas](tablas.png)

Binary file not shown.

After

Width:  |  Height:  |  Size: 34 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 131 KiB

@ -0,0 +1,95 @@
---
title: "Aplicacion web Oracle"
date: 2022-10-30T17:08:54+01:00
draft: false
---
Aplicación web Oracle programada en python.
## Preparación
Antes de crear el fichero que va a ser la aplicación, vamos a crear un **Entorno virtual** (Venv) de python para contener ahí los módulos que nos descarguemos
```bash
mkdir aplicacion_web_oracle && cd aplicacion_web_oracle
python3 -m venv /home/roberto/aplicacion_web_oracle
source bin/activate
```
Ahora vamos a descargar los módulos necesarios:
```bash
pip install cx_oracle
pip install flask
```
Ahora, usando **flask**, se ha escrito la siguiente aplicación sencilla, que permite, al introducirle el nombre de un empleado en la dirección `/emp/`, mostrar los datos de dicho empleado. Es importante que, cuando se define **pool** se introduzcan los mismo datos que en el acceso remoto a oracle, ya que esta aplicación se ha creado desde una máquina distina a la de oracle.
```python
import os
import sys
import cx_Oracle
from flask import Flask
def init_session(connection, requestedTag_ignored):
cursor = connection.cursor()
cursor.execute("""
ALTER SESSION SET
TIME_ZONE = 'UTC'
NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI'""")
# start_pool(): starts the connection pool
def start_pool():
pool_min = 4
pool_max = 4
pool_inc = 0
pool_gmd = cx_Oracle.SPOOL_ATTRVAL_WAIT
print("Connecting to", "192.168.122.105:1521/ORCLCDB")
pool = cx_Oracle.SessionPool(user="roberto",
password="roberto",
dsn="192.168.122.105:1521/ORCLCDB",
min=pool_min,
max=pool_max,
increment=pool_inc,
threaded=True,
getmode=pool_gmd,
sessionCallback=init_session)
return pool
app = Flask(__name__)
@app.route('/')
def index():
return "Entra en /emp/nombreempleado para ver los datos del empleado"
# Show the username for a given id
@app.route('/emp/<string:name>')
def show_username(name):
connection = pool.acquire()
cursor = connection.cursor()
cursor.execute("select * from emp where ename = (:name)", [name])
r = cursor.fetchone()
r = str(r)
return (r)
################################################################################
#
# Initialization is done once at startup time
#
if __name__ == '__main__':
# Start a pool of connections
pool = start_pool()
# Start a webserver
app.run(port=int(os.environ.get('PORT', '8080')))
```
![prueba1](prueba1.png)
![prueba2](prueba2.png)

Binary file not shown.

After

Width:  |  Height:  |  Size: 12 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 11 KiB

@ -0,0 +1,90 @@
---
title: "Conexiones desde clientes a servidores con bases de datos"
date: 2022-10-30T11:54:47+01:00
draft: false
---
Vamos a realizar conexiones desde los clientes de BBDD a sus respectivos servidores.
## Oracle
En el lado del servidor, tiene que estar activo oracle (`startup`), también como se ha hecho en la instalación tiene que estar activado el listener
```bash
lsnrctl start
```
y el firewall tiene que permitir el puerto `1521`
```bash
firewall-cmd --permanent --add-port=1521/tcp
firewall-cmd --reload
```
Para conectarnos de manera remota a oracle, tenemos que descargar en el lado del cliente **instantclient**, del siguiente [enlace](https://www.oracle.com/es/database/technologies/instant-client/linux-x86-64-downloads.html). En él hay varios enlaces de descarga. Los que nos interesan son:
* https://download.oracle.com/otn_software/linux/instantclient/218000/oracle-instantclient-basic-21.8.0.0.0-1.el8.x86_64.rpm
* https://download.oracle.com/otn_software/linux/instantclient/218000/oracle-instantclient-devel-21.8.0.0.0-1.el8.x86_64.rpm
* https://download.oracle.com/otn_software/linux/instantclient/218000/oracle-instantclient-sqlplus-21.8.0.0.0-1.el8.x86_64.rpm
En mi caso, el cliente es debian, así que tenemos que instalar los paquetes usando alien:
```bash
sudo alien -i --scripts oracle-instantclient-*
```
Una vez instalados, podemos acceder al servidor con `sqlplus`, donde la sintaxis es
```bash
sqlplus [USUARIO]/[CONTRASEÑA]@[IP:PUERTO]/[NOMBREBD]
```
```bash
sqlplus roberto/roberto@192.168.122.105:1521/ORCLCDB
```
![oracle](oracle.png)
En la captura se puede ver una consulta de prueba para comprobar que se ha accedido a la base de datos correctamente.
## MariaDB
Para conectarnos tenemos que instalar el paquete `mariadb-client`:
```bash
sudo apt install mariadb-client
```
Una vez instalado, ya podemos acceder al servidor. El comando tiene la siguiente sintaxis:
```bash
mariadb --host FULLY_QUALIFIED_DOMAIN_NAME --port TCP_PORT \
--user DATABASE_USER --password \
--ssl-verify-server-cert \
--ssl-ca PATH_TO_PEM_FILE
```
Lo utilizamos con las opciones de nuestro servidor:
```bash
mariadb --host 192.168.122.78 --port 3306 \
--user remoto --password
```
![mariadb](mariadb.png)
## PostgreSQL
Para conectarnos tenemos que instalar el paquete `postgresql-client`
```bash
sudo apt install postgresql-client
```
Y nos conectamos al servidor usando el comando `psql`:
```bash
psql --host 192.168.122.78 --user roberto -d scott
```
![postgre](postgre.png)

Binary file not shown.

After

Width:  |  Height:  |  Size: 53 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 35 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 28 KiB

@ -0,0 +1,259 @@
---
title: "Instalación de MariaDB y PostgreSQL en Debian"
date: 2022-10-26T09:32:09+02:00
draft: false
---
## MariaDB
El paquete de MariaDB se encuentra en los repositorios de Debian, por lo que podemos instalarlo directamente con apt:
```bash
sudo apt update
sudo apt install mariadb-server -y
```
Entramos en la base de datos como root:
```bash
mysql -u root -p
```
### Configuración para acceso remoto
Para poder acceder remotamente tenemos que modificar el archivo de configuración `/etc/mysql/mariadb.conf.d/50-server.cnf`, buscando la línea de **bind-address** y poniendo lo siguiente:
```bash
bind-address = 0.0.0.0
```
A continuación reiniciamos el servicio de mariadb:
```bash
systemctl restart mariadb.service
```
Dentro de mariadb, tenemos que crear un usuario para el acceso remoto (el `%` es un comodín para indicar que se pueda acceder desde cualquier dirección):
```sql
GRANT ALL PRIVILEGES ON *.* TO 'remoto'@'%'
IDENTIFIED BY 'remoto' WITH GRANT OPTION;
```
### Creación de usuario
Creamos un usuario con todos los privilegios:
```bash
GRANT ALL PRIVILEGES ON *.* TO 'roberto'@'localhost'
IDENTIFIED BY 'roberto' WITH GRANT OPTION;
```
Ahora podemos entrar con el usuario roberto:
```bash
mysql -u roberto -p
```
### Creación de tablas
Vamos a crear el esquema scott en mysql:
```sql
create database scott;
use scott;
```
```sql
CREATE TABLE IF NOT EXISTS `dept` (
`DEPTNO` int(11) DEFAULT NULL,
`DNAME` varchar(14) DEFAULT NULL,
`LOC` varchar(13) DEFAULT NULL
);
INSERT INTO `dept` (`DEPTNO`, `DNAME`, `LOC`) VALUES
(10, 'ACCOUNTING', 'NEW YORK'),
(20, 'RESEARCH', 'DALLAS'),
(30, 'SALES', 'CHICAGO'),
(40, 'OPERATIONS', 'BOSTON');
CREATE TABLE IF NOT EXISTS `emp` (
`EMPNO` int(11) NOT NULL,
`ENAME` varchar(10) DEFAULT NULL,
`JOB` varchar(9) DEFAULT NULL,
`MGR` int(11) DEFAULT NULL,
`HIREDATE` date DEFAULT NULL,
`SAL` int(11) DEFAULT NULL,
`COMM` int(11) DEFAULT NULL,
`DEPTNO` int(11) DEFAULT NULL
);
INSERT INTO `emp` (`EMPNO`, `ENAME`, `JOB`, `MGR`, `HIREDATE`, `SAL`, `COMM`, `DEPTNO`) VALUES
(7369, 'SMITH', 'CLERK', 7902, '1980-12-17', 800, NULL, 20),
(7499, 'ALLEN', 'SALESMAN', 7698, '1981-02-20', 1600, 300, 30),
(7521, 'WARD', 'SALESMAN', 7698, '1981-02-22', 1250, 500, 30),
(7566, 'JONES', 'MANAGER', 7839, '1981-04-02', 2975, NULL, 20),
(7654, 'MARTIN', 'SALESMAN', 7698, '1981-09-28', 1250, 1400, 30),
(7698, 'BLAKE', 'MANAGER', 7839, '1981-05-01', 2850, NULL, 30),
(7782, 'CLARK', 'MANAGER', 7839, '1981-06-09', 2450, NULL, 10),
(7788, 'SCOTT', 'ANALYST', 7566, '1982-12-09', 3000, NULL, 20),
(7839, 'KING', 'PRESIDENT', NULL, '1981-11-17', 5000, NULL, 10),
(7844, 'TURNER', 'SALESMAN', 7698, '1980-09-08', 1500, 0, 30),
(7876, 'ADAMS', 'CLERK', 7788, '1983-01-12', 1100, NULL, 20),
(7900, 'JAMES', 'CLERK', 7698, '1981-12-03', 950, NULL, 30),
(7902, 'FORD', 'ANALYST', 7566, '1981-12-03', 3000, NULL, 20),
(7934, 'MILLER', 'CLERK', 7782, '1982-01-23', 1300, NULL, 10);
```
## PostgreSQL
El paquete de PostgreSQL se encuentra en los repositorios de Debian, por lo que podemos instalarlo directamente con apt:
```bash
sudo apt install postgreSQL
```
Accedemos al usuario postgres:
```bash
su postgres
```
### Configuración para acceso remoto
Para poder acceder remotamente tenemos que modificar el archivo de configuración `/etc/postgresql/13/main/postgresql.conf`, buscando la línea de **listen_addresses** y poniendo lo siguiente:
```bash
listen_addresses = '*'
```
También, al final del fichero `/etc/postgresql/13/main/pg_hba.conf` tenemos que añadir las siguientes líneas:
```bash
host all all 0.0.0.0/0 md5
host all all ::/0 md5
```
Reiniciamos el servicio para que los cambios tengan efecto:
```bash
systemctl restart postgresql.service
```
Ahora vamos a crear un usuario con contraseña para acceder desde fuera con el siguiente comando dentro de `psql`:
```sql
create user roberto with superuser password 'roberto';
```
### Creación de tablas
Creamos la base de datos y accedemos a `psql`
```bash
createdb scott
psql
```
Dentro del intérprete de comandos añadimos el esquema scott:
```sql
\c scott
create table dept (
deptno integer,
dname text,
loc text,
constraint pk_dept primary key (deptno)
);
create table emp (
empno integer,
ename text,
job text,
mgr integer,
hiredate date,
sal integer,
comm integer,
deptno integer,
constraint pk_emp primary key (empno),
constraint fk_mgr foreign key (mgr) references emp (empno),
constraint fk_deptno foreign key (deptno) references dept (deptno)
);
insert into dept (deptno, dname, loc)
values (10, 'ACCOUNTING', 'NEW YORK'),
(20, 'RESEARCH', 'DALLAS'),
(30, 'SALES', 'CHICAGO'),
(40, 'OPERATIONS', 'BOSTON');
insert into emp (empno, ename, job, mgr, hiredate, sal, comm, deptno)
values (7369, 'SMITH', 'CLERK', 7902, '1980-12-17', 800, NULL, 20),
(7499, 'ALLEN', 'SALESMAN', 7698, '1981-02-20', 1600, 300, 30),
(7521, 'WARD', 'SALESMAN', 7698, '1981-02-22', 1250, 500, 30),
(7566, 'JONES', 'MANAGER', 7839, '1981-04-02', 2975, NULL, 20),
(7654, 'MARTIN', 'SALESMAN', 7698, '1981-09-28', 1250, 1400, 30),
(7698, 'BLAKE', 'MANAGER', 7839, '1981-05-01', 2850, NULL, 30),
(7782, 'CLARK', 'MANAGER', 7839, '1981-06-09', 2450, NULL, 10),
(7788, 'SCOTT', 'ANALYST', 7566, '1982-12-09', 3000, NULL, 20),
(7839, 'KING', 'PRESIDENT', NULL, '1981-11-17', 5000, NULL, 10),
(7844, 'TURNER', 'SALESMAN', 7698, '1981-09-08', 1500, 0, 30),
(7876, 'ADAMS', 'CLERK', 7788, '1983-01-12', 1100, NULL, 20),
(7900, 'JAMES', 'CLERK', 7698, '1981-12-03', 950, NULL, 30),
(7902, 'FORD', 'ANALYST', 7566, '1981-12-03', 3000, NULL, 20),
(7934, 'MILLER', 'CLERK', 7782, '1982-01-23', 1300, NULL, 10);
```
## MongoDB
Como indica la [documentación oficial](https://www.mongodb.com/docs/v6.0/tutorial/install-mongodb-on-debian/), Primero tenemos que añadir la clave a nuestros repositorios:
```bash
sudo apt install gnupg gnupg2 gnupg1
wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -
```
Ahora añadimos el repositorio de mongo a los repositorios de debian:
```bash
echo "deb http://repo.mongodb.org/apt/debian buster/mongodb-org/6.0 main" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
```
Y ahora, con los repositorios ya añadidos, instalamos mongodb:
```bash
sudo apt update
sudo apt install -y mongodb-org
```
Una vez instalado, iniciamos el servicio y activamos el inicio automático:
```bash
sudo systemctl start mongod
sudo systemctl enable mongod
```
### Configuración de acceso remoto
Tenemos que editar el fichero `/etc/mongod.conf` y comentar la línea `bindIP`:
```bash
# bindIp: 127.0.0.1
```
y reiniciamos el servicio
```bash
sudo systemctl restart mongod
```
### Creación de documentos
En este caso voy a insertar los datos de mi [proyecto de MongoDB](https://github.com/robertorodriguez98/proyectoMongoDB/)
```bash
mongoimport --db=yugioh --collection=prankkids --jsonArray --type json --file=prankkids.json
```
Podemos hacer una consulta para comprobar que se ha creado correctamente:
```sql
use yugioh
db.prankkids.find({"card_sets.set_name":"Hidden Summoners"}).count()
```
![mongo](mongo.sql)

Binary file not shown.

After

Width:  |  Height:  |  Size: 99 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 15 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 126 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 46 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 123 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 19 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 15 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 88 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 3.5 MiB

@ -0,0 +1,196 @@
---
title: "Instalación Oracle 19c en Rocky linux 8"
date: 2022-10-26T08:33:15+02:00
draft: false
tags: ["oracle","rocky"]
---
Se va a realizar la instalación de Oracle 19c en Rocky linux 8, debido a su mayor compatibilidad con el programa y menor número de fallos que con Debian 11.
## Pasos previos
Los siguientes pasos se deben ejecutar como usuario **root**.
Actualizamos el sistema:
```bash
dnf makecache
dnf update -y
```
Si al ejecutarlo se actualiza el **kernel**, deberíamos reiniciar la máquina.
como indica la [documentación](https://docs.oracle.com/en/database/oracle/oracle-database/19/ladbi/running-rpm-packages-to-install-oracle-database.html#GUID-BB7C11E3-D385-4A2F-9EAF-75F4F0AACF02), instalamos los requisitos previos. Sin embargo, al no estar en centos 7, tenemos que instalar manualmente unos paquetes
```bash
dnf install -y bc binutils compat-openssl10 elfutils-libelf glibc glibc-devel ksh libaio libXrender libX11 libXau libXi libXtst libgcc libnsl libstdc++ libxcb libibverbs make policycoreutils policycoreutils-python-utils smartmontools sysstat libnsl2 net-tools nfs-utils unzip
dnf install -y http://mirror.centos.org/centos/7/os/x86_64/Packages/compat-libcap1-1.10-7.el7.x86_64.rpm
dnf install -y http://mirror.centos.org/centos/7/os/x86_64/Packages/compat-libstdc++-33-3.2.3-72.el7.x86_64.rpm
```
Después descargamos los requisitos previos y los instalamos:
```bash
curl -o oracle-database-preinstall-19c-1.0-1.el7.x86_64.rpm https://yum.oracle.com/repo/OracleLinux/OL7/latest/x86_64/getPackage/oracle-database-preinstall-19c-1.0-1.el7.x86_64.rpm
yum -y localinstall oracle-database-preinstall-19c-1.0-1.el7.x86_64.rpm
```
Configuramos el firewall
```bash
firewall-cmd --permanent --add-port=1521/tcp
firewall-cmd --reload
```
configuramos el **target mode** de SELinux a permisivo:
```bash
sed -i 's/^SELINUX=.*/SELINUX=permissive/g' /etc/selinux/config
setenforce permissive
```
## Instalación
Ahora descargamos el paquete rpm de la [página oficial de oracle](https://www.oracle.com/es/database/technologies/oracle19c-linux-downloads.html):
![descarga](descarga.png)
```bash
yum -y localinstall oracle-database-ee-19c-1.0-1.x86_64.rpm
```
![instalacion](instalacion.png)
Como nos indica al final de la instalación, creamos la base de datos de pruebas ejecutando el siguiente script:
```bash
/etc/init.d/oracledb_ORCLCDB-19c configure
```
![script](script.png)
Tras la ejecución, tenemos que iniciar sesión con el usuario **oracle** que se ha creado durante la misma, Y añadirle las siguientes variables al fichero `.bash_profile`
{{< highlight bash "linenos=table" >}}
umask 022
export ORACLE_SID=ORCLCDB
export ORACLE_BASE=/opt/oracle/oradata
export ORACLE_HOME=/opt/oracle/product/19c/dbhome_1
export PATH=$PATH:$ORACLE_HOME/bin
{{< / highlight >}}
Recargamos el fichero para que las variables tengan efecto:
```bash
source ~/.bash_profile
```
Tras este paso ya está instalado **oracle**, Ahora sigue crear la base de datos. Primero activamos el listener:
```bash
lsnrctl start
```
Para facilitar la utilización de `sqlplus` vamos a instalar el paquete `rlwrap`, que permite que utilicemos el cursor, tanto para desplazarnos por las líneas como para rescatar comandos.
```bash
dnf install epel-release
dnf install rlwrap -y
```
ahora creamos el siguiente alias en `~/.bashrc`:
```bash
alias sqlplus='rlwrap sqlplus'
```
## Configuración
Primero nos conectamos a la base de datos como **sysdba**:
```bash
sqlplus / as sysdba
```
y podemos comprobar la versión de oracle con la siguiente consulta:
```sql
SELECT instance_name, host_name, version, startup_time FROM v$instance;
```
![versionora](versionora.png)
### Creación de usuario con privilegios
Vamos a crear un usuario para poder acceder a la base de datos sin utilizar el **sysdba**, con los siguientes comandos. Antes de crear el usuario, tenemos que activar `_ORACLE_SCRIPT` para que se puedan ejecutar sin errores los siguientes comandos:
```sql
alter session set "_ORACLE_SCRIPT"=true;
CREATE USER roberto IDENTIFIED BY roberto;
GRANT ALL PRIVILEGES TO roberto;
```
Una vez creado el usuario podemos conectarnos con él utilizando el siguiente comando:
```bash
sqlplus roberto/roberto
```
## Creación de tablas
Vamos a introducir a modo de prueba, el esquema **scott**:
```sql
CREATE TABLE DEPT
(
DEPTNO NUMBER(2),
DNAME VARCHAR2(14),
LOC VARCHAR2(13),
CONSTRAINT PK_DEPT PRIMARY KEY (DEPTNO)
);
CREATE TABLE EMP
(
EMPNO NUMBER(4),
ENAME VARCHAR2(10),
JOB VARCHAR2(9),
MGR NUMBER(4),
HIREDATE DATE,
SAL NUMBER(7, 2),
COMM NUMBER(7, 2),
DEPTNO NUMBER(2),
CONSTRAINT FK_DEPTNO FOREIGN KEY (DEPTNO) REFERENCES DEPT (DEPTNO),
CONSTRAINT PK_EMP PRIMARY KEY (EMPNO)
);
INSERT INTO DEPT VALUES (10, 'ACCOUNTING', 'NEW YORK');
INSERT INTO DEPT VALUES (20, 'RESEARCH', 'DALLAS');
INSERT INTO DEPT VALUES (30, 'SALES', 'CHICAGO');
INSERT INTO DEPT VALUES (40, 'OPERATIONS', 'BOSTON');
INSERT INTO EMP VALUES(7369, 'SMITH', 'CLERK', 7902,TO_DATE('17-DIC-1980', 'DD-MON-YYYY'), 800, NULL, 20);
INSERT INTO EMP VALUES(7499, 'ALLEN', 'SALESMAN', 7698,TO_DATE('20-FEB-1981', 'DD-MON-YYYY'), 1600, 300, 30);
INSERT INTO EMP VALUES(7521, 'WARD', 'SALESMAN', 7698,TO_DATE('22-FEB-1981', 'DD-MON-YYYY'), 1250, 500, 30);
INSERT INTO EMP VALUES(7566, 'JONES', 'MANAGER', 7839,TO_DATE('2-ABR-1981', 'DD-MON-YYYY'), 2975, NULL, 20);
INSERT INTO EMP VALUES(7654, 'MARTIN', 'SALESMAN', 7698,TO_DATE('28-SEP-1981', 'DD-MON-YYYY'), 1250, 1400, 30);
INSERT INTO EMP VALUES(7698, 'BLAKE', 'MANAGER', 7839,TO_DATE('1-MAY-1981', 'DD-MON-YYYY'), 2850, NULL, 30);
INSERT INTO EMP VALUES(7782, 'CLARK', 'MANAGER', 7839,TO_DATE('9-JUN-1981', 'DD-MON-YYYY'), 2450, NULL, 10);
INSERT INTO EMP VALUES(7788, 'SCOTT', 'ANALYST', 7566,TO_DATE('09-DIC-1982', 'DD-MON-YYYY'), 3000, NULL, 20);
INSERT INTO EMP VALUES(7839, 'KING', 'PRESIDENT', NULL,TO_DATE('17-NOV-1981', 'DD-MON-YYYY'), 5000, NULL, 10);
INSERT INTO EMP VALUES(7844, 'TURNER', 'SALESMAN', 7698,TO_DATE('8-SEP-1981', 'DD-MON-YYYY'), 1500, 0, 30);
INSERT INTO EMP VALUES(7876, 'ADAMS', 'CLERK', 7788,TO_DATE('12-ENE-1983', 'DD-MON-YYYY'), 1100, NULL, 20);
INSERT INTO EMP VALUES(7900, 'JAMES', 'CLERK', 7698,TO_DATE('3-DIC-1981', 'DD-MON-YYYY'), 950, NULL, 30);
INSERT INTO EMP VALUES(7902, 'FORD', 'ANALYST', 7566,TO_DATE('3-DIC-1981', 'DD-MON-YYYY'), 3000, NULL, 20);
INSERT INTO EMP VALUES(7934, 'MILLER', 'CLERK', 7782,TO_DATE('23-ENE-1982', 'DD-MON-YYYY'), 1300, NULL, 10);
COMMIT;
```
Las tablas se crean sin errores y se introducen los valores. Podemos realizar una consulta sencilla:
```sql
SELECT ename
FROM emp
WHERE deptno = (SELECT deptno
FROM dept
WHERE dname = 'SALES');
```
![consulta](consulta.png)

Binary file not shown.

After

Width:  |  Height:  |  Size: 84 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 85 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 13 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 16 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 16 KiB

@ -0,0 +1,10 @@
---
title: "Prueba: Introducción a la implantación de aplicaciones web"
date: 2022-10-10T12:54:33+02:00
draft: true
---
# Prueba: Introducción a la implantación de aplicaciones web
Roberto Rodríguez Márquez
![foto](foto.jpg)

Binary file not shown.

After

Width:  |  Height:  |  Size: 62 KiB

@ -0,0 +1,10 @@
---
title: "Primer post"
date: 2022-09-28T01:21:03+02:00
draft: true
---
# Hola buenos dias este es mi primer post tal
Lista de cosas
* primera cosa
* segunda cosa

Binary file not shown.

After

Width:  |  Height:  |  Size: 109 KiB

@ -0,0 +1,490 @@
---
title: "Práctica: Servidor de correos"
date: 2023-02-07T01:57:14+01:00
draft: false
---
## Gestión de correo desde el servidor
### Tarea 1
Documenta una prueba de funcionamiento, donde envíes desde tu servidor local al exterior. Muestra el log donde se vea el envío. Muestra el correo que has recibido. Muestra el registro SPF.
Creo las siguientes entradas en el DNS de mi dominio:
![MX](https://i.imgur.com/izykpPC.png)
Donde hay un registro MX que apunta a mail.admichin.es, que a su vez es un registro A que apunta a la IP de mi servidor. Además, hay un registro SPF que apunta a la ip de la máquina.
Además, configuro resolución inversa en la configuración de la VPS:
![Reverse](https://i.imgur.com/Q8x5DC1.png)
Ahora, en la VPS instalo los siguientes paquetes:
```bash
apt update
apt install postfix bsd-mailx -y
```
Durante la configuración, selecciono **Internet Site** y **admichin.es**.
Envío un correo a mi cuenta personal:
```bash
mail robertorodriguezmarquez98@gmail.com
Subject: Prueba de funcionamiento
Hola buenos días
Cc:
```
Vemos el log de postfix:
```bash
tail /var/log/mail.log
```
![Log](https://i.imgur.com/lii209w.png)
Y el correo recibido:
![Correo](https://i.imgur.com/FWNO7aB.png)
### Tarea 2
Documenta una prueba de funcionamiento, donde envíes un correo desde el exterior (gmail, hotmail,…) a tu servidor local. Muestra el log donde se vea el envío. Muestra cómo has leído el correo. Muestra el registro MX de tu dominio.
Ahora envío un correo desde mi cuenta personal a mi servidor:
![Correo](https://i.imgur.com/FWNO7aB.png)
Y compruebo que el correo ha llegado a mi servidor:
![Correo](https://i.imgur.com/JWSTUmj.png)
![Correo](https://i.imgur.com/D0xKQDi.png)
Y el log de postfix:
![Log](https://i.imgur.com/pAWEPrP.png)
## Uso de alias y redirecciones
### Tarea 3
**Usos de alias y redirecciones**. Vamos a comprobar como los procesos del servidor pueden mandar correos para informar sobre su estado. Por ejemplo cada vez que se ejecuta una tarea cron podemos enviar un correo informando del resultado. Normalmente estos correos se mandan al usuario `root` del servidor, para ello:
```bash
crontab -e
```
E indico donde se envía el correo:
```bash
MAILTO=root
```
Puedes poner alguna tarea en el cron para ver como se mandan correo.
Posteriormente usando alias y redirecciones podemos hacer llegar esos correos a nuestro correo personal.
Configura el cron para enviar correo al usuario root. Comprueba que están llegando esos correos al root. Crea un nuevo alias para que se manden a un usuario sin privilegios. Comprueban que llegan a ese usuario. Por último crea una redirección para enviar esos correo a tu correo personal (gmail,hotmail,…).
Voy a crear un script que muestre la fecha y el espacio en el disco. Lo guardo en `/root/script-espacio.sh`:
```bash
#!/bin/bash
echo "##################################"
echo "Fecha y hora: $(date)"
echo "##################################"
echo "Espacio en el disco:"
df -h
```
Ahora creamos la tarea de cron para que se ejecute cada 5 minutos:
```bash
crontab -e
```
Y añadimos las siguientes líneas:
```bash
MAILTO = root
*/5 * * * * /root/script-espacio.sh
```
Cuando pasan 5 minutos, recibimos el correo:
![Correo](https://i.imgur.com/XVtl86N.png)
Ahora voy a crear un alias para que se envíen los correos a un usuario sin privilegios (en este caso, calcetines), editando el fichero `/etc/aliases`:
```bash
root: calcetines
```
Y ejecuto el comando `newaliases` para que se actualicen los alias.
Ahora, cuando pasen 5 minutos, recibimos el correo en el usuario sin privilegios:
![Correo](https://i.imgur.com/aogu98o.png)
Ahora voy a crear una redirección para que se envíen los correos a mi correo personal, editando el fichero `/home/calcetines/.forward`:
```bash
robertorodriguezmarquez98@gmail.com
```
Y ahora, cuando pasen 5 minutos, recibimos el correo en mi correo personal:
![Correo](https://i.imgur.com/UdaG5gg.png)
## Para asegurar el envío
### Tarea 4
Configura de manera adecuada DKIM es tu sistema de correos. Comprueba el registro DKIM en la página https://mxtoolbox.com/dkim.aspx. Configura postfix para que firme los correos que envía. Manda un correo y comprueba la verificación de las firmas en ellos.
}
Voy a instalar el paquete `opendkim`:
```bash
apt install opendkim opendkim-tools -y
```
En el fichero `/etc/opendkim.conf`, edito las siguientes líneas:
```bash
Domain admichin.es
Selector default
KeyFile /etc/opendkim/keys/admichin.es/default.private
#Socket local:/run/opendkim/opendkim.sock
Socket local:/var/spool/postfix/opendkim/opendkim.sock
PidFile /run/opendkim/opendkim.pid
TrustAnchorFile /usr/share/dns/root.key
```
Ahora añado el socket en el fichero `/etc/default/opendkim`.
Tras eso, en el fichero `/etc/postfix/main.cf`, añado las siguientes líneas:
```bash
milter_default_action = accept
milter_protocol = 6
smtpd_milters = local:opendkim/opendkim.sock
non_smtpd_milters = $smtpd_milters
```
Ahora genero los ficheros de claves:
```bash
mkdir /etc/opendkim/keys/admichin.es
cd /etc/opendkim/keys/admichin.es
opendkim-genkey -b 2048 -d admichin.es -D /etc/opendkim/keys/admichin.es -s default -v
```
Ahora, utilizando el contenido de `/etc/opendkim/keys/admichin.es/default.txt`, añado un registro TXT en el dominio `admichin.es`:
![Registro](https://i.imgur.com/rWLIaWm.png)
Reinicio los servicios:
```bash
systemctl restart opendkim postfix
```
Ahora, cuando envío un correo, se añade la firma DKIM:
![Correo](https://i.imgur.com/SjhdRvn.png)
Finalmente, compruebo la verificación de la firma en la página **mxtoolbox**:
![Verificación](https://i.imgur.com/leht5mi.png)
## Para luchar contra el spam
## Gestión de correos desde un cliente
### Tarea 8
Configura el buzón de los usuarios de tipo Maildir. Envía un correo a tu usuario y comprueba que el correo se ha guardado en el buzón Maildir del usuario del sistema correspondiente. Recuerda que ese tipo de buzón no se puede leer con la utilidad mail.
Voy a cambiar el tipo de buzón de los usuarios, editando el fichero `/etc/postfix/main.cf`:
```bash
home_mailbox = Maildir/
```
Ahora instalamos el cliente mutt para poder leer los correos:
```bash
apt install mutt -y
systemctl restart postfix
```
Tengo que hacer la siguiente configuración en cada usuario:
```bash
nano ~/.muttrc
```
```bash
set mbox_type=Maildir
set mbox="~/Maildir"
set folder="~/Maildir"
set spoolfile="~/Maildir"
set record="+.Sent"
set postponed="+.Drafts"
set mask="!^\\.[^.]"
```
Podemos ver el contenido del directorio `Maildir`:
![Directorio](https://i.imgur.com/xJmTIsK.png)
Ahora, cuando envío un correo, se guarda en el buzón Maildir del usuario del sistema correspondiente, y lo podemos leer con mutt:
![Correo](https://i.imgur.com/mCg6V9I.png)
### Tarea 9
Instala configura dovecot para ofrecer el protocolo IMAP. Configura dovecot de manera adecuada para ofrecer autentificación y cifrado.
Instalo dovecot:
```bash
apt install dovecot-imapd -y
```
Modifico el fichero `/etc/dovecot/conf.d/10-ssl.conf` para añadir el certificado que generamos con certbot al crear la página, modificando las siguientes líneas:
```bash
ssl_cert = </etc/letsencrypt/live/admichin.es-0001/fullchain.pem
ssl_key = </etc/letsencrypt/live/admichin.es-0001/privkey.pem
```
Ahora cambiamos la localización de los mailbox en el fichero `/etc/dovecot/conf.d/10-mail.conf`:
```bash
mail_location = maildir:~/Maildir
```
### Tarea 10
Instala un webmail (roundcube, horde, rainloop) para gestionar el correo del equipo mediante una interfaz web. Muestra la configuración necesaria y cómo eres capaz de leer los correos que recibe tu usuario.
Voy a instalar **roundcube** utilizando docker:
```bash
apt install docker.io -y
```
Creo una entrada de tipo CNAME con el nombre webmail:
![CNAME](https://i.imgur.com/dLpPCex.png)
Ahora vamos a crear la configuración en un directorio que montaremos posteriormente por medio de bind mount en el docker;
```bash
mkdir /root/cuboredondo
nano -cl /root/cuboredondo/custom.inc.php
```
```php
<?php
$config['mail_domain'] = array(
'mail.admichin.es' => 'admichin.es'
);
?>
```
Ahora creo el contenedor de docker:
```bash
docker run -d --name docker-cuboredondo \
-v /root/cuboredondo/:/var/roundcube/config/ \
-e ROUNDCUBEMAIL_DEFAULT_HOST=ssl://mail.admichin.es \
-e ROUNDCUBEMAIL_SMTP_SERVER=ssl://mail.admichin.es \
-e ROUNDCUBEMAIL_SMTP_PORT=465 \
-e ROUNDCUBEMAIL_DEFAULT_PORT=993 \
-p 8001:80 \
roundcube/roundcubemail
```
o en una sola linea:
```bash
docker run -d --name docker-cuboredondo -v /root/cuboredondo/:/var/roundcube/config/ -e ROUNDCUBEMAIL_DEFAULT_HOST=ssl://mail.admichin.es -e ROUNDCUBEMAIL_SMTP_SERVER=ssl://mail.admichin.es -e ROUNDCUBEMAIL_SMTP_PORT=465 -e ROUNDCUBEMAIL_DEFAULT_PORT=993 -p 8001:80 roundcube/roundcubemail
```
Ahora creo el virtualhost para el dominio en `/etc/nginx/sites-available/webmail.admichin.es`:
```bash
server {
listen 80;
listen [::]:80;
server_name webmail.admichin.es;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
ssl on;
ssl_certificate /etc/letsencrypt/live/admichin.es-0001/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/admichin.es-0001/privkey.pem;
index index.html index.php index.htm index.nginx-debian.html;
server_name webmail.admichin.es;
location / {
proxy_pass http://localhost:8001;
include proxy_params;
}
}
```
Ahora activo el sitio y reinicio nginx:
```bash
ln -s /etc/nginx/sites-available/webmail.admichin.es /etc/nginx/sites-enabled/
systemctl restart nginx
```
Ahora podemos acceder a la instancia de roundcube desde el navegador:
![Roundcube](https://i.imgur.com/CEWcKuI.png)
Como se puede ver acabo de recibir el correo del ejercicio de la tarea del cron. Ahora un correo enviado desde fuera:
![Correo enviado desde fuera](https://i.imgur.com/bqHtnNH.png)
### Tarea 11
Configura de manera adecuada postfix para que podamos mandar un correo desde un cliente remoto. La conexión entre cliente y servidor debe estar autentificada con SASL usando dovecor y además debe estar cifrada. Para cifrar esta comunicación puedes usar dos opciones:
* **ESMTP + STARTTLS**: Usando el puerto 567/tcp enviamos de forma segura el correo al servidor.
* **SMTPS**: Utiliza un puerto no estándar (465) para SMTPS (Simple Mail Transfer Protocol Secure). No es una extensión de smtp. Es muy parecido a HTTPS.
Elige una de las opciones anterior para realizar el cifrado. Y muestra la configuración de un cliente de correo (evolution, thunderbird, …) y muestra como puedes enviar los correos.
Usaré los mismos certificados que he generado antes para cifrar los emails que envío y recibo. Para ello, modifico la configuración de postfix en `/etc/postfix/main.cf`:
```bash
smtpd_tls_cert_file = /etc/letsencrypt/live/admichin.es-0001/fullchain.pem
smtpd_tls_key_file = /etc/letsencrypt/live/admichin.es-0001/privkey.pem
smtpd_sasl_auth_enable = yes
smtpd_sasl_type = dovecot
smtpd_sasl_path = private/auth
smtpd_sasl_authenticated_header = yes
broken_sasl_auth_clients = yes
```
Ahora edito `/etc/postfix/master.cf`:
```bash
submission inet n - y - - smtpd
-o content_filter=spamassassin
-o syslog_name=postfix/submission
-o smtpd_tls_security_level=encrypt
-o smtpd_sasl_auth_enable=yes
-o smtpd_tls_auth_only=yes
-o smtpd_reject_unlisted_recipient=no
-o smtpd_client_restrictions=$mua_client_restrictions
-o smtpd_helo_restrictions=$mua_helo_restrictions
-o smtpd_sender_restrictions=$mua_sender_restrictions
-o smtpd_recipient_restrictions=
-o smtpd_relay_restrictions=permit_sasl_authenticated,reject
-o milter_macro_daemon_name=ORIGINATING
smtps inet n - y - - smtpd
-o syslog_name=postfix/smtps
-o smtpd_tls_wrappermode=yes
-o smtpd_sasl_auth_enable=yes
-o smtpd_reject_unlisted_recipient=no
-o smtpd_client_restrictions=$mua_client_restrictions
-o smtpd_helo_restrictions=$mua_helo_restrictions
-o smtpd_sender_restrictions=$mua_sender_restrictions
-o smtpd_recipient_restrictions=
-o smtpd_relay_restrictions=permit_sasl_authenticated,reject
-o milter_macro_daemon_name=ORIGINATING
```
Le indico a dovecot como debe realizar la auntentificación en el fichero `/etc/dovecot/conf.d/10-master.conf`:
```bash
service auth {
...
# Postfix smtp-auth
unix_listener /var/spool/postfix/private/auth {
mode = 0666
}
...
}
```
Ahora hay que abrir los puertos 465 y 993 en la vps. Tras eso, reiniciamos el servicio:
```bash
systemctl restart postfix dovecot
```
Ahora configuramos el cliente de correo **evolution**:
![Configuración de evolution](https://i.imgur.com/pdVsGVt.png)
![Configuración de evolution](https://i.imgur.com/Asvo17x.png)
Tras configurarlo probamos la recepción de un correo:
![Correo recibido](https://i.imgur.com/4g08tu3.png)
Y el envío:
![Correo enviado](https://i.imgur.com/ZBCNpp7.png)
![Correo enviado](https://i.imgur.com/jbV8Ojo.png)
### Tarea 12
Configura el cliente webmail para el envío de correo. Realiza una prueba de envío con el webmail.
Esta tarea consiste en poder enviar correos desde el cliente roundcube, y se han realizado las configuraciones necesarias en la tarea 10. Ahora solo queda probarlo:
![Correo enviado desde roundcube](https://i.imgur.com/CGQ8zuf.png)
![Correo enviado desde roundcube](https://i.imgur.com/miQ63i6.png)
## Comprobación final
### Tarea 13
Prueba de envío de correo. En esta [página](https://www.mail-tester.com/) tenemos una herramienta completa y fácil de usar a la que podemos enviar un correo para que verifique y puntúe el correo que enviamos. Captura la pantalla y muestra la puntuación que has sacado.
Enviamos un correo para comprobar la puntuación:
![Correo enviado para comprobar la puntuación](https://i.imgur.com/pt2pp6m.png)
![Correo enviado para comprobar la puntuación](https://i.imgur.com/X5klV3K.png)

Binary file not shown.

After

Width:  |  Height:  |  Size: 41 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 25 KiB

@ -0,0 +1,95 @@
---
title: "Snort: Instalación y primeros pasos"
date: 2022-10-10T12:54:33+02:00
draft: false
tags: ["debian","snort"]
---
**Enunciado:**
1. Instalación
2. Configuración Red
3. Reglas def
4. Reglas propias
5. Opciones reglas
6. Demo uso
7. Alertas
8. Acciones
## Instalación
El paquete de **Snort** se encuentra en los repositorios de debian, por lo que podemos instalarlo directamente con apt:
```bash
sudo apt update
sudo apt install snort
```
con `snort -V` podemos comprobar que se ha instalado correctamente:
![pruebainstalacion](pruebainstalacion.png)
### Configuración de la red
Tras instalarlo, iniciará la configuración de la red. En la configuración que se abre, podemos seleccionar la ip/rango de ips de la máquina, aunque más adelante modificando el fichero de configuración, podemos elegir que utilice solo una interfaz de red o todas (la opción por defecto).
![instalacion](instalacion.png)
Para modificar las opciones tras la instalación tenemos que modificar el fichero `/etc/snort/snort.debian.conf` (al tratarse de una instalación en debian, se carga el contenido de este fichero antes que la propia configuración de snort). Concretamente nos interesan las siguientes líneas:
DEBIAN_SNORT_STARTUP="boot"
DEBIAN_SNORT_HOME_NET="10.0.0.0/8"
DEBIAN_SNORT_OPTIONS=""
DEBIAN_SNORT_INTERFACE="enp7s0"
DEBIAN_SNORT_SEND_STATS="false"
DEBIAN_SNORT_STATS_RCPT="root"
DEBIAN_SNORT_STATS_THRESHOLD="1"
Como el propio fichero indica, después de modificarlo tenemos que ejecutar el siguiente comando para que la configuración se actualice:
```bash
sudo dpkg-reconfigure snort
```
Tras la ejecución del comando, reconfiguramos Snort, decidiendo cuando se ejecuta, las interfaces e ips, si activamos el modo promiscuo, y por último si queremos que se cree una tarea de cron para mandar correos diariamente con el resultado del log.
## Reglas
Para configurar los grupos de reglas que queremos activar, tenemos que editar el fichero de configuración `/etc/snort/snort.conf`:
![rutasreglas](rutasreglas.png)
En la instalación que se realiza de los repositorios de debian, están incluidas las reglas de la comunidad. En el caso de que queramos utilizar una set de reglas concreta, habría que descomentar el set específico. También se puede observar en la imagen como el fichero de reglas personalizadas está activo (`local.rules`).
### Reglas propias
De momento el fichero de reglas propias está vacío. Las reglas se construyen de la siguiente manera:
![estructura](estructuraregla.png)
Como podemos ver, La regla consta de dos partes principales, la **cabecera**, que contiene información relacionada con la red, y las **opciones**, que contienen detalles de invenstigación de paquetes. La regla que se muestra a continuación, sirve para detectar que se está realizando un ping a la máquina:
alert icmp any any -> $HOME_NET any (msg:"Ping detectado";sid:1000001;rev:1)
vamos a analizar la regla:
|Estructura|Valor|Descripción|
|---|---|---|
|Action|alert|le dice a snort que hacer cuando la regla salta|
|Protocol|icmp|Protocolo a ser analizado (TCP, UDP, ICMP, IP)|
|Source IP|any|Direcciones IP de origen|
|Source Port|any|Puertos de origen|
|Direction|->|Operador de dirección. Determina la dirección del tráfico|
|Destination IP|$HOME_NET|Direcciones IP de destino|
|Destination Port|any|Puertos de destino|
|Message|msg:"Ping detectado"|Mensaje a mostrar cuando aplique la regla|
|Rule ID|sid:1000001| ID único de la regla|
|Revision info|rev:1|Información de revisión|
### Demo de la regla
Una vez hemos añadido al regla al fichero de `local.rules`, ya podemos probar la regla. Vamos a ejecutar snort en modo consola para que muestre el resultado en pantalla (`-A console`):
```shell
sudo snort -A console -q -c /etc/snort/snort.conf -i enp1s0
```
![pruebaping](pruebaping.png)
MHicxeRVZ6cSE6usNUu2HNRbI

Binary file not shown.

After

Width:  |  Height:  |  Size: 12 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 31 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 40 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 109 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 26 KiB

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save