# Laboratorio

Para poder entender mejoras en que consisten las inyección SQL, lo llevaremos a la practica con un laboratorio de prueba. Para lo cual, utilizaremos un contenedor Docker en el que instalaremos Apache, PHP y MySQL.

Antes de comenzar, es recomendable actualizar el sistema para asegurarse de que todo esté al día. Abrimos una terminal y ejecutamos los siguientes comandos:

```bash
sudo apt update && sudo apt upgrade -y
```

## Instalación de `Docker` y `docker-compose`

Instalamos Docker con el siguiente comando:

```bash
sudo apt install docker.io -y
```

Una vez que la instalación esté completa, verificamos que Docker se haya instalado correctamente ejecutando el siguiente comando:

```bash
sudo docker --version
```

Deberíamos ver algo como:

```bash
Docker version 26.1.5+dfsg1, build a72d7cd
```

Si queremos asegurarnos de que Docker se inicie automáticamente al arrancar el sistema, habilitamos el servicio de Docker:

```bash
sudo systemctl enable docker
sudo systemctl start docker
```

Verificamos que Docker esté funcionando correctamente con:

```bash
sudo systemctl status docker
```

Instalamos `docker-compose`

```bash
sudo curl -L "https://github.com/docker/compose/releases/download/$(curl -s https://api.github.com/repos/docker/compose/releases/latest | jq -r .tag_name)/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
```

Asignamos permisos de ejecución al binario.

```bash
sudo chmod +x /usr/local/bin/docker-compose
```

Verficamos la instalación de `docker-compose` con el siguiente comando:

```bash
sudo docker-compose --version
```

Deberíamos ver algo como:

```bash
Docker Compose version v2.32.1
```

## Creación de las carpetas necesarias

Creamos el directorio para el laboratorio.

```bash
mkdir sqli_lab
cd sqli_lab
```

### Archivo `Dockerfile`

```bash
vim Dockerfile
```

Dentro de este archivo, colocamos lo siguiente:

```c
FROM ubuntu:20.04

ARG DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y \
    apache2 \
    mysql-server \
    php \
    php-mysqli \
    php-mbstring \
    php-xml \
    php-curl \
    php-zip \
    && apt-get clean

RUN a2enmod php7.4
RUN service apache2 restart

WORKDIR /var/www/html

EXPOSE 80

COPY ./app /var/www/html/

RUN service mysql start && \
    mysql -e "CREATE DATABASE app_db;" && \
    mysql -e "CREATE USER 'bob'@'localhost' IDENTIFIED BY 'Password123!';" && \
    mysql -e "GRANT ALL PRIVILEGES ON app_db.* TO 'bob'@'localhost';" && \
    mysql -e "FLUSH PRIVILEGES;"

CMD service mysql start && apache2ctl -D FOREGROUND
```

### Archivo docker-compose.yml

```bash
vim docker-compose.yml
```

```yml
version: '3.7'

services:
  app:
    build: .
    container_name: apache-php-mysql-container
    volumes:
      - ./app:/var/www/html # Volumen de la aplicación
    ports:
      - "80:80"  # Mapea el puerto 80 del contenedor al puerto 80 de la máquina
    environment:
      MYSQL_ROOT_PASSWORD: MySuperSecretPa$$word24 # Contraseña de root para MySQL
      MYSQL_DATABASE: app_db  # Base de datos a crear
      MYSQL_USER: bob  # Nombre de usuario para MySQL
      MYSQL_PASSWORD: Password123!  # Contraseña del usuario
```

Creamos la carpeta `app` para colocar los archivos de la aplicación.

```bash
mkdir app
```

Ahora, para construir y ejecutar el contenedor, usamos el siguiente comando:

```bash
docker-compose up --build -d
```

* `--build` asegura que el contenedor se construya desde el `Dockerfile`.
* `-d` ejecuta los contenedores en segundo plano.

#### Accedemos al contenedor

```bash
docker exec -it sqli_lab bash
```

#### Accedemos a la base de datos

### Tabla `users`

```sql
CREATE TABLE users(
	id INT(11) AUTO_INCREMENT NOT NULL PRIMARY KEY,
	name VARCHAR(255) NOT NULL,
	username VARCHAR(255) NOT NULL,
	password VARCHAR(255) NOT NULL
);
```

### Tabla `posts`

```sql
CREATE TABLE posts (
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    content TEXT NOT NULL,
    author VARCHAR(100),
    publication_date DATE
);
```

Poblamos las tablas con algunos datos de prueba.

```sql
INSERT INTO users(name, username, password) VALUES('Admin', 'admin', 'admin12345$$');
INSERT INTO users(name, username, password) VALUES('Dean', 'dean', 'MyStrongp4assw0rd!..');
INSERT INTO users(name, username, password) VALUES('Sam', 'sam', 'ThisIsMySecretPa$$word123');

INSERT INTO posts (title, content, author, publication_date)
VALUES
('Benefits of Running Daily', 'Running daily improves cardiovascular health, boosts energy, and reduces stress.', 'David', '2024-12-01'),
('10 Tips for Beginner Runners', 'Start slow, wear proper shoes, and listen to your body.', 'Maria', '2024-12-05'),
('The Best Running Routes in Your City', 'Explore parks, tracks, and safe trails to enjoy your runs.', 'Ian', '2024-12-10'),
('How to Avoid Injuries While Running', 'Perform proper warm-ups and stretches after running to prevent injuries.', 'Ana', '2024-12-15');
```

> Es importante aclarar, que para este ejemplo y con fines prácticos guardaremos la contraseña en texto plano.

De esta forma, tenemos listo nuestro laboratorio.

En los siguientes artículos, creamos los scripts php correspondientes para las explicaciones.
