Tienda Wifi

Tienda Wifi
CiudadWireless es la tienda Wifi recomendada por elhacker.NET

Entradas Mensuales

Síguenos en:

Canal Oficial Telegram de elhacker.NET Grupo Facebook elhacker.NET Twitter elhacker.NET Canal Youtube elhacker.NET Comunidad Steam: Grupo elhacker.NET Mastodon

Suscripción

¿Quieres recibir las últimas novedades del blog en tu correo?

¡Suscríbete al feed!

Entradas populares

PostHeaderIcon Gestión contenedores: DockerFile y Docker Compose


Después ver una pequeña introducción a los contenedores docker y su funcionamiento con los comandos y las opciones básicas debemos pasar a un siguiente nivel de conocimientos A medida que avanzamos en el uso de los contenedores docker necesitamos aprender a utilizar nuevas herramientas y recursos que nos permitirán manejar de forma más ágil varios contenedores.



 

Docker Compose

Docker Compose permite definir las aplicaciones multicontenedor, conocidas como stacks, y ejecutarlas en un nodo individual o en un clúster. La herramienta recurre para ello a una consola de línea de comandos con el fin de gestionar el ciclo de vida completo de sus aplicaciones.  

Para poder operar una app multicontenedor en un clúster con Docker es necesario utilizar un enjambre (traducción de swarm), esto es, un clúster de Docker engine en swarm mode, así como la herramienta de Docker Compose. 



 Docker Compose es una herramienta que permite simplificar el uso de Docker. A partir de archivos YAML es mas sencillo crear contenedores, conectarlos, habilitar puertos, volúmenes, etc.

Con Compose puedes crear diferentes contenedores y al mismo tiempo, en cada contenedor, diferentes servicios, unirlos a un volúmen común, iniciarlos y apagarlos, etc. Es un componente fundamental para poder construir aplicaciones y microservicios.

En vez de utilizar Docker via una serie inmemorizable de comandos bash y scripts, Docker Compose te permite mediante archivos YAML para poder instruir al Docker Engine a realizar tareas, programaticamente. Y esta es la clave, la facilidad para dar una serie de instrucciones, y luego repetirlas en diferentes ambientes.

Usaremos un archivo docker-compose.yml para configurar los servicios de la aplicación. Los servicios son las partes de la aplicación (p.e. un servicio para el almacenamiento de los datos y otro para el front-end)

En un mismo host podemos tener varios entonos aislados. Compose usa nombres de proyecto para mantener a los entornos aislados. De forma predeterminada se usa el nombre del directorio desde donde se lanza la aplicación.

Parámetros docker-compose.yml

  • version ‘3’: Los archivos docker-compose.yml son versionados, lo que significa que es muy importante indicar la versión de las instrucciones que queremos darle. A medida de que Docker evoluciona, habrá nuevas versiones, pero de todos modos, siempre hay compatibilidad hacia atrás, al indicar la versión

  • build .”: Se utiliza para indicar donde está el Dockerfile que queremos utilizar para crear el contenedor. Al definier “.” automáticamente considerará el Dockerfile existente en directorio actual.

  • command: Una vez creado el contenedor, aqui lanzamos el comando que permite ejecutar Jekyll, en modo servidor. El comando “–host 0.0.0.0” sirve para mapear el contenedor al sistema operativo host

  • ports: mapeamos los puertos locales, por ejemplo 4000 (webserver jekyll) y 35729 (livereload) al servidor host. Esto permite que accediendo a Localhost:4000 podamos probar el sitio generador por Jekyll

  • volumes:  lo que hacemos es mapear el directorio local se mapee directamente con el /directoriox, lugar donde hemos creado la aplicación. De este modo, cualquier cambio en el directorio local en el host, se hará de inmediato en el contenedor.



Ejemplos:

version: '3' services: reverse-proxy: image: traefik:alpine command: --api --docker ports: - "80:80" - "8080:8080" volumes: - /var/run/docker.sock:/var/run/docker.sock

Al finalizar, es posible acceder a http://localhost:8080 y ver el panel de control (dashboard) de Traefik funcionando correctamente.

Otro ejemplo:

wordpress: image: wordpress links: - mariadb:mysql environment: - WORDPRESS_DB_PASSWORD=contraseña ports: - "80:80" volumes: - ./code:/code - ./html:/var/www/html mariadb: image: mariadb environment: - MYSQL_ROOT_PASSWORD=contraseña - MYSQL_DATABASE=wordpress volumes: - ./database:/var/lib/mysql

 Luego 

docker-compose up -d

  •  $ docker-compose up -d      Construye y lanza el entorno en modo dettached
  • $ docker-compose pull       Descarga las imágenes pero no inicia los contenedores
  • $ docker-compose rm [-fs]   Borra los contedores parados. Con -fs los detiene y fuerza su borrado


Ejemplos:


MetasPloit

docker run --rm -it -p 443:443 -v ~/.msf4:/root/.msf4 -v /tmp/msf:/tmp/data remnux/metasploit
Tenemos ya instalado:
 
msfconsole

 Kali Linux en un contenedor

docker pull kalilinux/kali-rolling

docker run -t -i kalilinux/kali-rolling /bin/bash

Sin abreviar: 

 docker run --tty --interactive kalilinux/kali-rolling /bin/bash


Recuerda actualizar  y actualizar metapaquetes:

apt-get update && apt-get install metasploit-framework


Listado completo metapaquetes KaliLinux

Distro Pentesting  

O podemos usar una imagen preparada para realizar pruebas de seguridad (principalmente de penetración), fue preparada por SZalek y es pública en el Hub de Docker. ( >https://hub.docker.com/r/szalek/pentest-tools/ )
 
 docker pull szalek/pentest-tools
Incluye algunas herramientas como:

  • searchsploit

    https://www.exploit-db.com/searchsploit/#installlinux
    searchsploit -u
    searchsploit -h
    searchsploit ProFTPD
    searchsploit afd windows local

  • sqlmap

    http://sqlmap.org/
    sqlmap -u {URL}.php?username=adrian --dbs
    sqlmap -u {URL}.php?username=adrian -D {DB_NAME}--tables
    sqlmap -u {URL}.php?username=adrian -T {TABLE-NAME} --columns
    sqlmap -u {URL}.php?username=adrian -T {TABLE_NAME} --dump


  • nmap

    nmap -sSV -Pn 127.0.0.1
    nmap -sT -sV -A -O -v 127.0.0.1
    nmap -n -sV -Pn 127.0.0.1
    nmap --script=mysql-enum 127.0.0.1

  • nikto

    https://cirt.net/Nikto2
    nikto -host {URL}/ -output /tmp/test.html
    nikto -host {URL}/ -output /tmp/test.csv



  • dnsenum

    https://github.com/fwaeytens/dnsenum
    dnsenum --help
    dnsenum {URL}



  • haveibeenpwned

    api form https://haveibeenpwned.com
    https://github.com/szalek/haveibeenpwned
    haveibeenpwned emails.txt
    haveibeenpwned test@example.com
    haveibeenpwned noexist@btbw.pl


  • Uniscan

-- uniscan -u http://www.example.com/ -qweds
 
  • WpScan

    project page: https://github.com/wpscanteam/wpscan
    wpscan
    wpscan --url www.example.com
    you can user official wpscan docker image (docker run -it --rm wpscanteam/wpscan -u https://yourblog.com [options])


  • sublist3r

    sublist3r {URL}

  • massdns

    massdns -r /home/massdns/lists/resolvers.txt -t AAAA domains.txt > results.txt

 
Ejemplos
 
para salir del contenedor, arrancarlo nuevamente y conectarlos a la shell.
 
# docker images
CONTAINER ID        IMAGE                  COMMAND             CREATED              STATUS              PORTS               NAMES
7f11c2dfa7ae        szalek/pentest-tools   "/bin/bash"         About a minute ago   Up About a minute                       happy_hugle

# docker start 7f11c2dfa7ae

# docker exec -it 7f11c2dfa7ae /bin/bash

 

Usando Tor y un proxy SOCKs en un contenedor Docker

Algo similar a descargarnos el Browser de Tor para nuestro sistema operativo, pero en este caso al ser un contenedor tendremos las ventajas de Docker, poder moverlo de un sitio a otro, 
 
# docker run --name tor -ti -p 9050:9050 jgamblin/tor

Despues simplemente en nuestro navegador favorito, sea Mozilla Firefox, pues se debe agregar el SOCK Proxy en Proferencias/General/Red. Indicamos nuestro ip ( 127.0.0.1 ) y el puerto 9050.


 Ejemplo configuración:
 

DockerFile

Creación de imágenes propias

  • Para construir una imagen, se crea un Dockerfile con las instrucciones que especifican lo que va a ir en el entorno, dentro del contenedor (redes, volúmenes, puertos al exterior, archivos que se incluyen.

  • Indica cómo y con qué construir la imagen.

  • Conseguimos que el build de la aplicación definida en el contenedor se comporte de la misma forma en cualquier lugar que se ejecute. Hacemos que sea repetible.

También tienes una extensión para Visual Studio Code para editar ficheros Docker y Docker Compose YAML




 El DockerFile nos permitirá definir las funciones básicas del contenedor.

Todo Dockerfile debe terminar en un comando CMD o en un ENTRYPOINT, pero en este caso, no lo utilizamos, ya que lanzaremos un comando directamente desde la receta de Docker Compose. Es decir, este Dockerfile se utiliza solamente para construir el contenedor y configurarlo. No es autoejecutable.

 FROM

FROM indica que Docker debe utiliza que la obtendrá de Docker Hub. La version Alpine de linux contiene recetas de imagenes Docker que ocupan muy poco espacio. 

 

  • Comandos RUN, CMD y ENTRYPOINT  


RUN

El comando RUN se ejecuta cuando se está construyendo una imagen personalizada para realizar una acción, creando una capa nueva. Este comando tiene el siguiente formato:

RUN comando

Cuando se ejecuta con esta sintaxis se pasa como parámetro a la Shell del sistema. Dependiendo del sistema operativo es:

  • · Linux — > bash (/bin/bash -c)
  • · Windows — > cmd (cmd/s/c)

Otra forma de utilizar este comando es:

RUN [“ejecutable”, “parametro1”, …]

Con esta forma no se invoca a la Shell del sistema por defecto, sino que se permite ejecutar programas que la imagen contenga. Una cosa a recordar, es que tenemos que poner los parámetros entre comillas. En el siguiente ejemplo con el comando Get-Service de powershell se recuperan todos los servicios Windows que se están ejecutando en la máquina.

RUN [“Powershell”, “Get-Services”, “*”]

Una cosa importante sobre este método, y es que podemos vernos en la situación que se quiere provocar un error y que la creación de la imagen se interrumpa cuando el comando que se está ejecutado produzca un error. Para conseguir este resultado se tiene que utilizar el parámetro -o pipefail (no todos los Shell lo soportan)

RUN [“/bin/bash”, “-c”, “set -o pipefail && wget –o https://misitio/”]

CMD

Este comando se encarga de pasar valores por defecto a un contenedor. Entre estos valores se pueden pasar ejecutables. Este comando tiene tres posibles formas de pasar los parámetros:

CMD [“ejecutable”, “parametro1”, “parametro2”, …]

Esta es la forma más recomendable.

CMD [“parametro1”, “parametro2”, ….]

Esta forma se utiliza para pasar parámetros al comando EntryPoint.

CMD Comando paametro1 parametro2

Ecomando se ejecuta en la Shell con los parámetros establecidos.

A diferencia del comando RUN, los comandos que se pasen por medio de este método se ejecutan una vez que el contenedor se ha inicializado, mientras que RUN se utiliza para crear la imagen de un contenedor.

ENTRYPOINT

Este comando se ejecuta cuando se quiere ejecutar un ejecutable en el contenedor en su arranque. Los ejemplos tipo de su uso, son cuando se quiere levantar un servidor web, una base de datos, etc ….

Este comando tiene dos sintaxis:

ENTRYPOINT [“comando”, “Parametro1”, “Parametro2”, …]

Esta es la forma recomendada.

ENTRYPOINT comando parametro1 parametro2

Con esta forma el comando se ejecuta en la Shell del contenedor.

Utilización de varios comandos de forma conjunta

Como se ha comentado anteriormente el comando CMD se puede utilizar para pasar parámetros al comando ENRYPOINT. Una posible forma de realizarlo es:

ENRYPOINT [“Powershell”, “Get-Services”]

CMD [“MySql]

En el ejemplo, se está invocando al comando Get-Services para recuperar información de los servicios Windows y como en el comando CMD se está indicando el servicio en concreto del que se quiere recuperar la información que en este caso es del servicio Windows de MySql.

Nota: cuando los comandos o parámetros son pasados entre corchetes siempre van entre comillas. Esto es porque el comando correspondiente lo interpreta como una cadena JSON.

Recordatorio Comandos básicos docker-compose

  • docker-compose up: da instrucciones a Docker para crear el contendor y ejecutarlo.

  • docker-compose down: apaga todo los servicios que levantó con docker-compose up.

  • docker-compose ps: permite ver los contenedores funcionando.

  • docker-compose exec: permite ejecutar un comando a uno de los servicios levantados de Docker-compose.

Copias de seguridad  de contenedores

Ya estén encendidos o apagados, podemos realizar respaldos de seguridad de los contenedores. Utilizando la opción “export” empaquetará el contenido, generando un fichero con extensión “.tar” de la siguiente manera:

docker export -o fichero-resultante.tar nombre-contenedor

o

docker export nombre-contenedor > fichero-resultante.tar

Restauración de copias de seguridad de contenedores

Hay que tener en cuenta, antes de nada, que no es posible restaurar el contenedor directamente, de forma automática. En cambio, sí podemos crear una imagen, a partir de un respaldo de un contenedor, mediante el parámetro “import” de la siguiente manera:

docker import fichero-backup.tar nombre-nueva-imagen

Copias de seguridad de imágenes

Aunque no tiene mucho sentido por que se bajan muy rápido, también tenemos la posibilidad de realizar copias de seguridad de imágenes. El proceso se realiza al utilizar el parámetro ‘save‘, que empaquetará el contenido y generará un fichero con extensión “tar“, así:

docker save nombre_imagen > imagen.tar

o

docker save -o imagen.tar nombre_imagen

Restaurar copias de seguridad de imágenes

Con el parámetro ‘load’, podemos restaurar copias de seguridad en formato ‘.tar’ y de esta manera recuperar la imagen.

docker load -i fichero.tar

Fuentes:

https://dockertips.com/comandos-run-cmd-y-entrypoint-en-el-dockerfile


0 comentarios :

Publicar un comentario

Los comentarios pueden ser revisados en cualquier momento por los moderadores.

Serán publicados aquellos que cumplan las siguientes condiciones:
- Comentario acorde al contenido del post.
- Prohibido mensajes de tipo SPAM.
- Evite incluir links innecesarios en su comentario.
- Contenidos ofensivos, amenazas e insultos no serán permitidos.

Debe saber que los comentarios de los lectores no reflejan necesariamente la opinión del STAFF.