Archivo
Install Kubernetes Goat (ES)

En estos dos ultimos años estoy muy involucrado en proyectos revisando intraestructuras basadas en contenedores Docker y Kubernetes, en esta busqueda encontré con este genial proyecto que facilita el aprendizaje de vulnerabilidades en Kubernetes.
Kubernetes Goat está diseñado para ser un entorno de clúster intencionalmente vulnerable para aprender y practicar la seguridad de Kubernetes. Es un proyecto creado por Madhu Akula.
En este articulo, veremos como realizar la instalación sobre un equipo con Ubuntu 20.04 y VirtualBox. Kubernetes Goat necesita una instalación previa de Minikube el cual facilita tener un cluster local de Kubernetes.
A.- Instalar Minikube
1.- Descarga de Minikube
Podemos descargar la última versión o una versión específica de la página de versiones de Minikube. Una vez descargado, necesitamos hacerlo ejecutable y agregarlo a nuestra RUTA:
$ curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64 && chmod +x minikube && sudo mv minikube /usr/local/bin/
2.- Iniciar Minikube
Podemos iniciar Minikube con el comando de inicio de minikube, que inicia un clúster de un solo nodo con la última versión estable de Kubernetes.
$ minikube start

3.- Comprobar el estado
Con el comando de estado de minikube, mostramos el estado de Minikube:
$ minikube status

B.- Instalar Kubernetes Goat
1.- Descargar el proyecto
# git clone https://github.com/madhuakula/kubernetes-goat.git
# cd kubernetes-goat/
2.- Configurar la cuenta helm2 rbac e inicializar tiller
# kubectl apply -f scenarios/helm2-rbac/setup.yaml
# helm2 init –service-account tiller

3.- Desplegar Helm chart para verificar la configuración ,
implementación del escenario helm chart metadata-db
# helm2 install –name metadata-db scenarios/metadata-db/

4.- Desplegar los manifiestos de escenarios vulnerables
# kubectl apply -f scenarios/batch-check/job.yaml
# kubectl apply -f scenarios/build-code/deployment.yaml
# kubectl apply -f scenarios/cache-store/deployment.yaml
# kubectl apply -f scenarios/health-check/deployment.yaml
# kubectl apply -f scenarios/hunger-check/deployment.yaml
# kubectl apply -f scenarios/kubernetes-goat-home/deployment.yaml
# kubectl apply -f scenarios/poor-registry/deployment.yaml
# kubectl apply -f scenarios/system-monitor/deployment.yaml
# kubectl apply -f scenarios/hidden-in-layers/deployment.yaml

5.- Crear el forwardeo de puertos en los PODS para permitir el acceso local.
# bash access-kubernetes-goat.sh

6.- Igresar a Kubernetes Goat
Si todo salio bien , ahora podremos ingresar a la aplicación de la siguiente forma:
Ingresar a : http://127.0.0.1:1234/

Finalmente, Si desean practicar los escenarios pueden revizarlos aqui : https://madhuakula.com/kubernetes-goat/index.html
Espero les siva
Instalación de Cluster de Kubernetes con Vagrant
Como parte de las labores de despliegue de software, la automatizar los procesos de infraestructura como código, es vital, para las actividades de Pentesting / Ethical Hacking tener construir tus entornos y escenarios locales de prueba sirve infinitamente para poder realizar tus P.O.C.
Es así que aquí va el procedimiento para automatizar la instalacion de un Cluster de Kubernetes usando Vagrant en Centos 7, este es el Escenario.
Ubuntu 16.04.6 LTS
Vagrant 2.2.3
Este es Vagantfile
###########################################
# -*- mode: ruby -*-
# vi: set ft=ruby :
VAGRANTFILE_API_VERSION = «2»
##Variables de configuracion ###
INTERFASE_BRIDGE = «wlps01»
DIRECCION_IP_BRIDGE = «192.168.1.151»
MASCARA_RED = «255.255.255.0»
PUERTA_ENLACE = «192.168.1.1»
##Configuracion de la VM master
Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
config.vm.box = «centos/7»
config.disksize.size = ’50GB’
config.vm.network «public_network», bridge: INTERFASE_BRIDGE, ip: DIRECCION_IP_BRIDGE, netmask: MASCARA_RED, gateway: PUERTA_ENLACE
config.vm.hostname = «k8s-master»
config.vm.provider «virtualbox» do |v|
v.name = «k8s-master»
v.memory = 2048
v.cpus = 2
end
##Insertar llave SSH
config.ssh.insert_key = false
config.ssh.private_key_path = [‘~/.vagrant.d/insecure_private_key’, ‘~/.ssh/id_rsa’]
config.vm.provision «file», source: «~/.ssh/id_rsa.pub», destination: «~/.ssh/authorized_keys»
##Configuracion de SSH, SELINUX, IPTABLES, SWAP, FIREWALLD
config.vm.provision «shell», inline: <<-EOC
sudo sed -i -e «\\#PasswordAuthentication yes# s#PasswordAuthentication yes#PasswordAuthentication no#g» /etc/ssh/sshd_config
sudo sed -i -e «\\#PermitRootLogin prohibit-password# s#PermitRootLogin prohibit-password#PermitRootLogin yes#g» /etc/ssh/sshd_config
sudo sed -i -e «\\#SELINUX=enforcing# s#SELINUX=enforcing#SELINUX=disabled#g» /etc/selinux/config
sudo systemctl restart sshd.service
sudo setenforce 0
sudo modprobe br_netfilter
sudo echo ‘1’ > /proc/sys/net/bridge/bridge-nf-call-iptables
sudo sed -i ‘/swap/d’ /etc/fstab
sudo swapoff -a
sudo systemctl stop firewalld
sudo systemctl mask firewalld
echo «Instalacion de Docker»
sudo yum -y install vim yum-utils net-tools
sudo yum -y install epel-release
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
sudo yum-config-manager –add-repo=https://download.docker.com/linux/centos/docker-ce.repo
sudo yum install -y docker-ce
echo «Instalacion de Kubernetes»
sudo yum-config-manager –add-repo=http://www.silcom.com.pe/soft/kubernetes.repo
sudo yum-config-manager –enable Kubernetes
sudo yum install -y kubelet kubeadm kubectl
echo «Fin de Instalacion»
EOC
##Reinicio de la VM
config.vm.provision :reload
##Configuracion e inicio de servicio docker y kunernestes
config.vm.provision «shell», env: {«VARIP» => «192.168.1.151»}, inline: <<-EOC
sudo sed -i ‘1i $VARIP k8s-master k8s-master’ /etc/hosts
sudo systemctl start docker && systemctl enable docker
sudo systemctl start kubelet && systemctl enable kubelet
sudo sed -i ‘s/cgroup-driver=systemd/cgroup-driver=cgroupfs/g’ /usr/lib/systemd/system/kubelet.service.d/10-kubeadm.conf
sudo systemctl daemon-reload
sudo systemctl restart kubelet
echo «Inicializacion de Cluster»
sudo kubeadm init –apiserver-advertise-address=$VARIP –pod-network-cidr=10.244.0.0/16
sudo mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
echo «Fin de Inicializacion de Cluster»
echo «Desplegar el pod network»
sudo kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
echo «Pod network creado»
echo «FIN»
EOC
#Fin SSH
end
##############################################################3
Finalmente este es el video donde se muestra el despliegue :
Espero les sirva.
Saludos
@jroliva
búsqueda de vulnerabilidades mediante análisis de código fuente estático
Luego de terminar el año a full, regresar de unas pequeñas vacaciones me pongo al día con el blog ya que lo he tenido un poco descuidado. Como parte de las actividades en los proyectos de Ethical Hacking se tienen requerimientos para buscar vulnerabilidades en el código fuente de manera estática, es decir sin que la aplicación evaluada este ejecutándose, para realizar ello nos podemos ayudar en ciertas herramientas que pueden AYUDAR en realizar esto, y resalto AYUDAR por que ninguna herramienta va hacer el trabajo al 100% , siempre va ser necesario realizar un análisis posterior de los casos.
En este caso, vamos a aprender a instalar , configurar y usar Sonarqube es una herramienta que me a ayudado mucho en estas labores, este procedimiento se puede aplicar en Ubuntu 18.04.1 u otro derivado.
1.- Instalar java
sudo apt install openjdk-8-jdk openjdk-8-jre
2.- Crear directorio
mkdir sonarqube
2. -Descargar Sonarqube
Para ello es necesario ingresar a la pagina : https://www.sonarqube.org/downloads/
También es necesario descargar el escaner de : https://docs.sonarqube.org/display/SCAN/Analyzing+with+SonarQube+Scanner
Al descomprimir los archivos tendremos lo siguiente :
3.- Luego descargaremos un proyecto opensource como DVWA para analizarlo
Para esto descargaremos un viejo conocido como DVWA
4.- Ahora vamos a configurar el escaner
– Crear una carpeta «main» en la ruta sonar-scanner-3.2.0.1227-linux/bin
cd sonar-scanner-3.2.0.1227-linux/bin
mkdir main
– luego dentro de la carpeta «main» vamos a mover y descomprimir la carpeta de la aplicacion a analizar
mv DVWA-master.zip sonar-scanner-3.2.0.1227-linux/bin/main/
cd sonar-scanner-3.2.0.1227-linux/bin/main/
unzip DVWA-master.zip
– Ahora crear un archivo «sonar-project.properties» indicando la aplicación a evaluar de la siguiente forma
cd sonar-scanner-3.2.0.1227-linux/bin
vim sonar-project.properties
5.- Finalmente iniciamos el panel de sonar y luego escaner para iniciar el análisis
– Iniciar sonar
cd sonarqube/sonarqube-6.7.5/bin/linux-x86-64
./sonar.sh start
Sonar iniciara en el puerto 9000 del localhost de la siguiente forma
– Ahora iniciar el escaner
cd sonarqube/sonar-scanner-3.2.0.1227-linux/bin
./sonar-scanner
Como vemos el análisis del de las paginas se realizo correctamente.
6.- Análisis de resultados
Luego de que el escáner termine el análisis en el panel de sonar aparecerá un nuevo proyecto de la siguiente forma
Como vemos ahora tenemos un proyecto analizado, al ingresar veremos que tenemos catalogadas los bugs, vulnerabilidades, entre otros resultados.
Al ingresar a las vulnerabilidades, tendremos un listado de las mismas.
El siguiente paso es analizar cada una de las vulnerabilidades reportadas en el código para identificar la importancia de las mismas, su importancia en el modelo de negocio y por su puesto como poder corregirlas.
Espero que les sirva.
Saludos
Juan Oliva