Browse Source

List sysadmin workshop contents

master
Siroco 7 months ago
commit
c5cb7076b8
12 changed files with 742 additions and 0 deletions
  1. +216
    -0
      DOCKER/index.md
  2. BIN
      DROPBEAR/Dropbear_LUKS.pdf
  3. +113
    -0
      DROPBEAR/index.md
  4. BIN
      GIT/git_basic.pdf
  5. +41
    -0
      GIT/index.md
  6. +203
    -0
      SSH/index.md
  7. +79
    -0
      TMUX/index.md
  8. BIN
      TMUX/tmux_simple.pdf
  9. +12
    -0
      TOR/docker-tor/Dockerfile
  10. BIN
      TOR/docker-tor/docker_torproxy.pdf
  11. +5
    -0
      TOR/docker-tor/torrc.default
  12. +73
    -0
      TOR/index.md

+ 216
- 0
DOCKER/index.md View File

@ -0,0 +1,216 @@
---
title: Docker
---
# Qué es Docker
https://docs.docker.com/engine/
Docker es un sistema open source para la gestión de contenedores, es decir, encapsula aplicaciones con las necesidades básicas en un proceso y las aisla del resto del sistema.
Es un sistema mucho menos pesado que usar KVM o LXC para construir espacios aislados para las aplicaciones y a la vez, los contenedores son reutilizables, lo que quiere decir, que si tienes que instalar muchas veces lo mismo, te ahorras mucho tiempo y espacio.
Por ejemplo, si quieres instalar un Wordpress, deberías primero instalarte un sistema operativo, por ejemplo, una Debian, luego instalar una base de datos, por ejemplo MariaDB, luego instalar un servidor web, por ejemplo NGINX y finalmente, instalar Wordpress. Como mínimo una instalación de un Wordpress con todo el sistema puedo llegar a ocuparte ~1GB, pero, en el fondo, Wordpress no requiere todo el sistema de Debian para funcionar.
Además, si quisieras aprovechar esa Debian para otros servicios, cualquier fallo de seguirdad afectaria a todo el sistema y no solo al Wordpress atacado.
Por otro lado, es una manera muy sencilla para aprender a configurar servicios en servidores compartidos o desarrollar aplicaciones. Puedes tener diversas versiones de lo que haces en tu ordenador local y publicarlas luego en el servidor sabiendo que todo funcionará igual que en tu máquina local.
Una de las críticas a Docker sobre seguridad es que sus plantillas están gestionadas por la comunidad de Docker ( https://hub.docker.com/ ) y debes confiar que el contenido ahí publicado no tiene código malicioso y que la comunidad que mantiene esa imágen está pendiente de ella. La solución en entornos donde la seguridad es un factor importante, es posible construir tus propias imagenes de Docker en tu propio servidor, llamado en Registry en el mundo de Docker, y así evitar ese problema.
# Ejercicio práctico
Vamos a instalar Docker en un servidor junto con la herramienta llamada Docker Compose y como ejercicio, vamos a configurar un Wordpress usando estas herramientas.
Puedes instalarte tu propio Docker en tu ordenador, es lo más recomendable para aprender a usarlo.
# Pasos previos
## Install Docker-ce
La instalación de Docker está muy documentada en su página oficial.
https://docs.docker.com/engine/install/debian/
O la gente de Digital Ocean tienen también un manual bastante sencillo de entender:
https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-debian-10
Sigue los pasos para tu distribución. En el caso de Debian hay que desintalar cualquier aplicación vinculada a Docker del repositorio de Debian y luego configurar el repositorio oficial. Está todo documentado en la web.
## Uso de Docker
Si has llegado a instalarlo correctamente, deberías poder hacer este comando:
```
$ docker -v
```
La lista de comando los puedes obtener aquí https://docs.docker.com/engine/reference/commandline/docker/
Si has usado Virsh o KVM, verás que los comandos son bastantes similares.
```
$ docker ps # Muestra los contenedores activos
$ docker images --all # Muestra todas las imagenes descargadas
$ docker volume ls # Muestra los volumenes, o espacios de datos que usan los contenedores
$ docker network ls # Muestra las redes vinculadas a los contenedores
$ docker search <container> # Busca en el respositorio Hub de Docker oficial imagenes disponibles para la descarga
$ docker run <container> # Este comando es más largo y lo explico despues, pero con run arrancamos el container
$ docker rmi <nombre_imagen> # Borra la imagen descargada
$ docker system prune # Borra los volumenes, imagenes, configuración de red no utilizadas
```
## Buscando imagenes docker
Si hacemos una búsqueda en las docker images disponibles en [Hub(https://hub.docker.com) veremos que hay imagenes oficiales de muchos servicios, poer ejemplo Wordpress o MariaDB y MySQL
```
$ docker search wordpress
$ docker search mysql
```
## comandos útiles de docker
### arrancar un docker
Ejecutando un `docker run` descargaremos la imagen y la arrancamos, podemo a su vez añadirle parámetros a este arranque, por ejemplo el caso de MySQL.
Es la manera más rápida de arrancar una imágen de docker.
```
$ docker run --name db -e MYSQL_ROOT_PASSWORD=UnPasswordCualquiera -d mysql
```
Las variables disponibles para cada imagen, la puedes encontrar en la documentación en HUB [https://hub.docker.com/]
### listar contenedores activos
Para listar los contendores activos
```
$ docker ps
```
### revisar logs
Para revisar los logs, puedes usar el comando
```
$ docker logs -f <ID_Container>
```
### parar containers
Y encontrar si alguna cosa no funciona.
Para parar los container:
```
$ docker stop <ID_CONTAINER>
```
### listado de todos los contenedores
Y para revisar que está parado:
```
$ docker ps --all
```
### borrado de contenedores
Si lo queremos borrar:
```
$ docker rm <ID_CONTAINER>
```
# Docker Compose
Esto lo que hace es "componer" un docker a nuestro gusto, sin tener que ejecutar a mano uno por uno los comandos explicados antes.
## Configurar un fichero para Docker Compose
https://docs.docker.com/compose/install/
Creamos un directrio en nuestra home y creamos el siguiente fichero **docker-compose.yml**:
Este ejemplo muestra el usado para Wordpress.
```
version: '3'
services:
wp:
image: wordpress:php7.1-apache
ports:
- "8000:80"
environment:
WORDPRESS_DB_PASSWORD: secret_passw
links:
- "mysql:db"
volumes:
- ./html:/var/www/html/
mysql:
image: "mysql:5.7"
environment:
MYSQL_ROOT_PASSWORD: secret_passw
volumes:
- ./database:/var/lib/mysql
```
Y lo arrancamos de la siguiente manera:
```
$ docker-compose up -d
```
# Anexo: Como vincular ese Wordpress a un servicio .ONION para acceder a través de Tor
## Torsocks
Instala **torsocks** en tu sistema
```
# apt install torsocks
```
Configura el fichero **/etc/tor/torrc** añadiendo al final de fichero las siguientes lineas:
```
HiddenServiceDir /var/lib/tor/hidden_service/
HiddenServicePort 80 127.0.0.1:8000
```
Y reinicia **torsocks**
```
# systemctl restart tor
```
## ¿Esto que hace?
Por un lado, instalamos **torsocks** para conectarnos a la red de tor y con la configuración de HiddenService lo que estamos configurando es que cualquiera que accede a nuestra máquina a través de **Tor** por el puerto 80 (el puerto HTTP) podrá acceder a lo que nuestra máquina local (127.0.0.1) ofrezca en el puerto 8000, en nuestro caso, el docker que muestra Wordpress
## ¿Y que dirección tiene mi máquina en la red de **Tor?
Accede a _/var/lib/tor/hidden_service_ y encontraras un fichero llamado **hostname**, en ese fichero encontraras la dirección .onion a la que hay que acceder.
```
$ cat /var/lib/tor/hidden_service/hostname
e4spc5bweldxqdwiskjge3ei6c3flvjnafggl45rcuc7es7b6rw7afyd.onion
```
Si abrimos un Tor Browser y escribmos esta dirección, veremos nuestros Wordpress disponible a través de la red de Tor
Más información [https://www.torproject.org/docs/hidden-services.html.en]
# References
* https://buddy.works/guides/wordpress-docker-kubernetes-part-1

BIN
DROPBEAR/Dropbear_LUKS.pdf View File


+ 113
- 0
DROPBEAR/index.md View File

@ -0,0 +1,113 @@
---
title: Uso de Dropbear en initramfs para desencriptar volumenes LUKS en remoto
---
# Instalación
En entornos _Debian GNU/Linux_
En nuestra máquina remota:
$ sudo apt instal dropbear dropbear-initramfs
Y en nuestra máquina local:
$ ssh-keygen -t rsa -f ~/.ssh/id_diskluks
Usamos algoritmo RSA por la compatibilidad con dropbear, por lo menos, en la versión de Debian estable no nos permite usar algoritmos como ed25519 o similares.
# Copiamos nuestra clave pública
Como si de un acceso a una máquina remota por SSH, debemos configurar un fichero de claves autorizadas
En la máquina remota:
$ sudo vim /etc/dropbear-initramfs/authorzied_keys
Y ahí pegamos nuestra clave pública,
en nuestro caso podemos acceder a ella en nuestra máquina local:
$ cat ~/.ssh/id_diskluks
Guardamos el fichero actualizado de authorized_keys y ahora configuramos los parámetros para el acceso cuando la máquina aún no ha arrancado
# Configurar red en el arranque de Dropbear
Como el sistema no está levantado, hay que configurar la red de nuestra interfaz para poder acceder a la consola de busybox en remoto
Editamos el fichero en la maquina remota:
$ sudo vim /etc/initramfs-tools/initramfs.conf
Y bajo la linea _DEVICE=_ añadimos una linea nueva con la configuración de IP estática que será accesible desde la maquina local.
Imaginemos que tengo el servidor en una LAN con la dirección 192.168.1.0/24 y tenemos asociado un DCHP y otras cosas hasta la ip 192.168.1.200/24.
En nuestro caso, vamos a asignarle la dirección 192.168.1.201/24 porque sabemos que no va estar ocupada.
Esto depende de cada red
Añadimos esta linea así:
IP=192.168.1.201:255.255.255.0:192.168.1.1::enp6s0
Donde tenemos _IP:Netmask:Gateway::Interfaz_
Y guardamos el fichero.
Para que estos cambios queden realizado, hay que actualizar el sistema de arranca de nuestro sistema.
$ sudo update-initramfs -u
Y nuestro Dropbear ya se iniciará al cargar el sistema justo antes de desencriptar los discos remotos
# Configurar SSH en la maquina local
Seguramente queramos tener almacenada la configuración para acceder a nuestro disco en la máquina local.
Editamos nuestro fichero local ~/.ssh/config
```
Host LuksRemote
Hostname 192.168.1.201
User root
IdentityFile ~/.ssh/id_diskluks
UserKnownHostsFile ~/.ssh/known_hosts.initramfs
```
Usamos la opción _UserKnownHostsFile_ para evitar colisionar con el fingerprint de otra maquina en la misma IP. Si por ejemplo, hemos configurado en la misma IP donde suele estar conectada esa máquina remota, tendremos un error de fingerprint porque tenemos almacenado en nuestro fichero de _knownhosts_ la anterior signatura digital.
Ahora, reiniciamos el servidor y probamos
# Desencriptar disco Luks en Remoto
Si tenemos acceso al servidor, podemos mirar que en el arranque nos indica la IP de conexión y si hemos tenido algun fallo durante la configuración de Dropbear.
Si todo está bien,
desde nuestra máquina local podemos probar el acceso remoto:
$ ssh LuksRemote
Y esto nos abre una sessión directamente en la consola de BusyBox
Aquí, para montar las unidades LUKS hay que usar el siguiente comando:
$ cryptroot-unlock
Nos pedirá la passfrase de nuestra unidad LUKS y arrancará si todo eso correcto.
# Comando cryptroot-unlock en remoto
Para no tener que recordar el comando en BusyBox lo podemos añadir directamente en el fichero config de _dropbear_initramfs_
En la máquina remota:
$ sudo vim /etc/dropbear-initramfs/config
En la variable __DROPBEAR_OPTIONS__ escribimos
DROPBEAR_OPTIONS='-c cryptroot-unlock'
# Fuentes
* https://wiki.debian.org/RescueInitramfs
* https://dev.to/j6s/decrypting-boot-drives-remotely-using-dropbear-2hdf

BIN
GIT/git_basic.pdf View File


+ 41
- 0
GIT/index.md View File

@ -0,0 +1,41 @@
---
title: GIT Basics
---
# Comandos básicos
Iniciar un repositorio:
git init
Añadir un archivo al indice:
git add <archivo>
Commit de los ADDs,RMs o cambios de los ficheros indexados:
git commit -am "Comentario de los cambios"
Eliminar un fichero del indice y del árbol de archivos
git rm <archivo>
Eliminar solo del indice
git rm --cached <archivo>
Pushear contenido al servidor a la rama MASTER
git push -u origin master
Descargar novedades del repo
git pull
Clonar un repositorio
git clone <repositorio.git>
Añadir un submodulo de otro repositorio
git submodule add <repositorio.git> path/destino/submodulo

+ 203
- 0
SSH/index.md View File

@ -0,0 +1,203 @@
---
title: SSH (Secure SHell)
---
# SSH JumpProxy
## Situation
Access to Computer B using as bastion Computer A via SSH
* You are only access to Computer A using SSH
* Computer B is accessible via Computer A using SSH
## Steps
Configure your .ssh/config
```
Host computerA
HostName <IP or host adress Computer A>
... (configure here other options to access Computer A)
Host computerB
Hostname <IP o host address of Computer B via Computer A, like lan adress, ....>
ProxyJump computerA # Use Computer A for access Computer B
... (other options like IndentyFile, Port, User, ...)
```
Then
$ ssh computerB
And welcome to Computer B usign Computer A as bastion
# Setup redirect HTTP port over SSH
## Situation
Computer A
* Has access to Internet
* Has access to Computer B
* SSH is installed
Computer B
* Doesn't have access to Internet
* OpenSSH Server is installed
## Steps
_ssh_ into Computer B from Computer A
$ sudo ssh -R <selected port>:us.archive.ubuntu.com:80 user@computerb.host
Edit Computer B's /etc/apt/apt.conf to include the following lines:
$ sudo vim /etc/apt/apt.conf
```
Acquire::http::Proxy "http://localhost:<selected port>";
Acquire::https::Proxy "https://localhost:<selected port>";
```
Run your _apt-get update_ or install or upgrade on Computer B and it should work.
## A few notes:
You HAVE to keep the original session of ssh from Computer A to Computer B active while using Computer B to access apt-get repositories.
You DON'T have to use the same ssh connection to utilize the tunnel (meaning if you have multiple ssh connection into Computer B, they should all work)
# SSH over TOR
## Install on GNU/Linux Debian derivated
$ sudo apt install openssh-client
For network checks
$ sudo apt install net-tools curl netcat
If you haven't installed yet
$ sudo apt install tor torsocks
on others use **apk**, ....
## Check Tor Connections
Check if default __Tor Socks v5__ port is open:
$ nc -zv 127.0.0.1 9050
For check your IP over tor:
$ torsocks curl https://api.ipify.org
If not work, check **tor** is running
$ sudo systemctl status tor
If is _inactive_:
$ sudo systemctl restart tor
And recheck status or system logs.
$ sudo journalctl -xe
If is active, check your **torsocks** config:
$ sudo gedit /etc/tor/torsocks.conf
_TorAddress_ and _TorPort_ may be the same in **torrc** config
$ sudo gedit /etc/tor/torrc
If not, configure **torsocks** correctly
## Create a pair ssh keys
Generate our keys using ed25519 algothrim:
> In public-key cryptography, Edwards-curve Digital Signature Algorithm (EdDSA) is a digital signature scheme using a variant of Schnorr signature based on twisted Edwards curves.[1] It is designed to be faster than existing digital signature schemes without sacrificing security. It was developed by a team including Daniel J. Bernstein, Niels Duif, Tanja Lange, Peter Schwabe, and Bo-Yin Yang.[2] The reference implementation is public domain software.[3]
> https://en.wikipedia.org/wiki/EdDSA
On terminal:
$ ssh-keygen -t ed25519 -f .ssh/id_sysadmin
## Config client
Example:
$ cat .ssh/config
If not exists
nano .ssh/config
and paste:
```ssh
Host *
VisualHostKey yes
Compression yes
Host *.onion
ProxyCommand /bin/nc -xlocalhost:9050 -X5 %h %p
```
The First affect all our ssh connections.
* **VisualHostKey** show fingerprint like a ascii image
* **Compression** option that requests compression of all data being transferred over an SSH connection
Second one affect our **ssh tor services** using onion domain
* **ProxyCommand** avoid use **torsocks** everytime we use **ssh** command proxify all our connections via **netcat (nc)** connection. **Tor** is running a __Socksv5__ on localhost:9050. You can reconfigure this on your __torrc__ config file. Instead, you can use __.onion__ via torsocks:
$ torsocks ssh -l\<user\> -p\<port\> \<my_big_onion_v3_adress\>.onion
For our specific testbed:
```ssh
Host sysadmin
Hostname <our_beatiful_big_long_onion_v3_address>.onion
ProxyCommand /bin/nc -xlocalhost:9050 -X5 %h %p
Port 22
User root
IdentityFile /home/<my_user_or_other_path>/.ssh/id_sysadmin
```
* **Host** declare a custom hostname for ssh connection. Now we can use __sysadmin__ instead of large onion address.
* **Hostname** original hostname aliased
* **ProxyCoomand** why we use a custom hostname we need to reconfigure here our __proxycommand__ option
* **Port** port ...
* **User** user diferent from our local user
* **IdentityFile** where is our private ssh key pre-generated
More info:
$ man ssh
$ man ssh_config
$ man nc
$ man torsocks
## Configure Server
Copy your public key to your **.ssh/authorized_keys** user file.
If is _root_ :
$ nano /root/.ssh/authorized_keys
## Connect to server
$ ssh sysadmin
# Next steps (future)
* Install **Monkeysphere** : GPG for SSH connections

+ 79
- 0
TMUX/index.md View File

@ -0,0 +1,79 @@
# Básicos con TMUX
## Instalación
apt install tmux
## Fuera del terminal
Nueva terminal
tmux
Nueva terminal con nombre de sesion
tmux new -s hugo
Unirse al terminal
tmux a
Unirse a un terminal concreto
tmux a -t hugo
Listar sesiones
tmux ls
Apagar sesion
tmux kill-session -t hugo
La ejecución de comando se realiza a través de Ctrl+b
Es configurable a través de los ficheros de config tmux.conf en el $HOME
Revisar más documentación:
man tmux
## Dentro del terminal
Antes de todos los comandos primero hay que pulsar Ctrl+b
* Listar sesiones [s]
* Nueva sesion [:new hugo2]
* Nombre de la sesion [$]
* Salir sin cerrar [d]
Ventanas
* Nueva ventana [c]
* Listar ventanas [w]
* Cerrar ventana [&]
Paneles
* Dividir en horizontal [%]
* Dividir en vertial ["]
* Cambiar de panel [o]
* Cambiar el orden [O]
* Cerrarlo [x]
Útiles
* Reloj [t]
* Shortcuts [?]
* Linea de comandos [:]
## Otras referencias
https://gist.github.com/henrik/1967800
## Visualizar un archivo markdown
sudo apt install grip
grip README.md
Abre en el navegador http://localhost:6419

BIN
TMUX/tmux_simple.pdf View File


+ 12
- 0
TOR/docker-tor/Dockerfile View File

@ -0,0 +1,12 @@
FROM alpine:latest
RUN apk update && apk add \
tor \
--update-cache --repository http://dl-3.alpinelinux.org/alpine/edge/testing/ \
&& rm -rf /var/cache/apk/*
EXPOSE 9050
COPY torrc.default /etc/tor/torrc.default
RUN chown -R tor /etc/tor
USER tor
ENTRYPOINT [ "tor" ]
VOLUME /var/lib/tor/hidden_service
CMD [ "-f", "/etc/tor/torrc.default" ]

BIN
TOR/docker-tor/docker_torproxy.pdf View File


+ 5
- 0
TOR/docker-tor/torrc.default View File

@ -0,0 +1,5 @@
SocksPort 0.0.0.0:9100 # Bind to this address:port too.
#HiddenServiceDir /var/lib/tor/hidden_service/
#HiddenServicePort 80 127.0.0.1:80

+ 73
- 0
TOR/index.md View File

@ -0,0 +1,73 @@
---
title: Dockerize Tor Service
---
# Pre
* Install Docker
* Run Docker over non-root user without sudo
# Edit config
Edit **torrc.default** using **vim** or **nano**:
$ vim torrc.default
Change basic config:
```sh
SocksPort 0.0.0.0:9100 # Bind to this address:port too.
# Hidden Service - Redirecto to service IP on Docker Network
# HiddenServiceDir /var/lib/tor/hidden_service/
# HiddenServicePort 80 127.0.0.1:80
```
# Check Dockerfile
```sh
FROM alpine:latest
RUN apk update && apk add \
tor \
--update-cache --repository http://dl-3.alpinelinux.org/alpine/edge/testing/ \
&& rm -rf /var/cache/apk/*
EXPOSE 9050
COPY torrc.default /etc/tor/torrc.default
RUN chown -R tor /etc/tor
USER tor
VOLUME /var/lib/tor
ENTRYPOINT [ "tor" ]
CMD [ "-f", "/etc/tor/torrc.default" ]
```
# Build image
$ docker build -t piperrak/torproxy
# Run image
$ docker run -d --restart always -p 9051:9100 --name torproxy piperrak/torproxy
# Check image is running
$ docker ps
or
$ docker ps --all
# Check image is proxing
Your public IP:
$ curl -L http://ifconfig.me
Your torified IP:
$ curl --socks5 http://localhost:9051 -L http://ifconfig.me
# Linkography
* https://sachsenhofer.io/setup-tor-docker-container/
* https://phoenixnap.com/kb/docker-volumes

Loading…
Cancel
Save