---
# System prepended metadata

title: SR06 projet sécu

---

# SR06 projet sécu

## Sécuriser une application

- [ ] installer le package php-codesniffer sur serveur web
```
sudo apt-get install php-pear
sudo bash -c "command pear channel-update pear.php.net && command pear upgrade PEAR"
sudo pear install PHP_CodeSniffer
command -v phpcs
```

- [ ] page web php avec et sans protection
-> Scripts php, ça écho la sortie plutôt que connexion sur bdd

**unprotected.php**
```php
<?php
$offset = $argv[1]; // Attention, aucune validation!
$query  = "SELECT id, name FROM products ORDER BY name LIMIT 20 OFFSET $offset;";
echo $query
?>
```

**protected.php**
```php
<?php
$offset = $argv[1];
settype($offset, 'integer');
$query  = sprintf("SELECT id, name FROM products ORDER BY name LIMIT 20 OFFSET %d;", $offset);
echo $query
?>
```
- [ ] lancer script phpcs sur fichiers php

```
phpcs ./unprotected.php
phpcs ./protected.php
```

- [ ] Question : 
:::info
Pourquoi est-il préférable de ne pas laisser le logiciel php-codesniffer sur la machine hébergeant le serveur Apache ?
:::
==TODO: verifier si c'est ça==
Réponse:
:::success
il augmente la surface d'attaque, il pourrait être utilisé pour corrompre les pages php / executer des scripts php dans le cas où un utilisateur mal intentionné arriverait à se connecter à la machine serveur.
:::

## Protection de l'infrastructure réseau

- ClientA (CA) dans LAN/intnet0
- ServeurA (SA) dans DMZ/intnet2
- Routeur Linux (R ) dans:
    -  LAN/intnet0
    -  DMZ/intnet2
    -  Internet/intnet1
- ClientB (CB) dans Internet/intnet1
- ServeurB (SB) dans Internet/intnet1
- DNS (D) dans DMZ/intnet2


![](https://i.imgur.com/d5SU751.png)

### Création des VM et des réseaux

- [ ] cloner 6 vms
- [ ] toutes les vm sur vmbr2
- [ ] configurer ssh/nom sur toutes les vms
- [ ] CA sur intnet0
- [ ] SA sur intnet2
- [ ] D sur intnet2
- [ ] R sur intnet0,intnet1,intnet2
- [ ] CB sur intnet1
- [ ] SB sur intnet1
- [ ] Plans d'adressage différents ? (pour le routage)
- [ ] installer apache sur SA, SB
- [ ] check R peut ping SA,SB,CA,CB
- [ ] check SA peut pas ping CA,CB
- [ ] check CB peut ping SB


**Site web entreprise A**
```php
<!DOCTYPE html>
<html>
<header>
    <title>entrepriseA</title>
    <meta charset="utf-8">
</header>
<body>
<?php
    echo "Site de l'entreprise A";
?>
</body>
</html>
```

**Site web entreprise B**
```php
<!DOCTYPE html>
<html>
<header>
    <title>entrepriseB</title>
    <meta charset="utf-8">
</header>
<body>
<?php
    echo "Site de l'entreprise B ";
?>
</body>
</html>
```
### Configuration du routage et du filtrage

Configurer le routage et filtrage sur router linux

**Routage**

- [ ] configurer les interfaces en suivant le TD pour donner des addresses IP et configurer l'adresse du routeur

/etc/network/interfaces
```
-> SUR UBUNTU
network:
    version: 2
    renderer: networkd
    ethernets:
        [INTERFACE]:
            dhcp4: no
            dhcp6: no
            addresses: [[IP MACHINE SUR LE RESEAU]/32]
            routes:
            -to:  [IP RESEAU SA]/24
            via: [IP ROUTEUR SUR MEME RESEAU QUE MACHINE]
            scope: link
            -to:  [IP RESEAU SB]/24
            via: [IP ROUTEUR SUR MEME RESEAU QUE MACHINE]
            scope: link
```

- [ ] configurer le routeur
règles:

/etc/network/interfaces
```bash
network:
    version: 2
    renderer: networkd
    ethernets:
        [INTERFACE intnet0]:
            dhcp4: no
            dhcp6: no
            addresses: [[IP ROUTEUR INTNET0]/32]
        [INTERFACE intnet1]:
            dhcp4: no
            dhcp6: no
            addresses: [[IP ROUTEUR INTNET1]/32]
        [INTERFACE intnet2]:
            dhcp4: no
            dhcp6: no
            addresses: [[IP ROUTEUR INTNET2]/32]
```
:::warning
A priori, si on doit pouvoir avoir un accès internet avec intnet1, il faut activer le dhcp sur intnet1 et ne pas spécifier d'adresse IP

MAIS ça pose problème pour le NAT ensuite, puisqu'il faut spécifier l'IP sur Intnet1 pour
:::

/etc/sysctl.conf
```
décommenter:

net.ipv4.ip_forward=1
```

```
sysctl -p
```



--- 
c faux, pas besoin de NAT/PAT mais je garde au cas où
```
- [ ] sur routeur : NAT
` ``
iptables -tnat -A POSTROUTING -s [RESEAU intnet0]/24 -j SNAT --to-source [IP ROUTEUR intnet1]
`` `
- [ ] sur routeur : PAT
` ``
iptables -t nat -A PREROUTING -p tcp -d [IP ROUTEUR intnet1] --dport 443 -j DNAT --to-destination [IP SA intnet2]:443
iptables -t nat -A PREROUTING -p tcp -d [IP ROUTEUR intnet1] --dport 80 -j DNAT --to-destination [IP SA intnet2]:80
`` `
```
---

**Filtrage**
https://doc.ubuntu-fr.org/iptables
- [ ] CA peut contacter SA,SB
- [ ] CB peut contacter SA,SB
- [ ] R,SA,SB,CB ne peuvent pas contacter CA
- [ ] SA ne peut pas initier de connexion // doit être réflexive (on autorise en sortie uniquement les réponses)
```bash
iptables -A INPUT -p tcp -i eth0 --dport 80 -j ACCEPT
```
:::info
-A ajoute une règle à INPUT (traffic entrant) / OUTPUT sortant
-p protocole tcp
-i interface eth0
-dport port destination 80(http)
-j ACCEPT accepte le traffic / DROP pour refuser
:::

pour les connexions déjà ouvertes:
```
iptables -A INPUT -m conntrack --ctstate ESTABLISHED -j ACCEPT
```

## Installation d'un serveur ssh et d'un DNS

- [ ] Ajouter un serveur DNS dans la DMZ, doit permettre de trouver l'adresse du serveur web à partir du nom

https://www.supinfo.com/articles/single/3498-installer-configurer-serveur-dns-linux
https://doc.ubuntu-fr.org/bind9

```bash
sudo apt-get install bind9
```
dans /etc/bind/named.conf.local
```bash
zone "srsix.lan" IN {
    type master;
    file "/etc/bind/db.srsix.lan";
};
```

```
sudo cp /etc/bind/db.local /etc/bind/db.srsix.lan
```
- Changer localhost par le FQDN de votre serveur (srsix.lan.), en laissant le point "." supplémentaire à la fin.
- Changer 127.0.0.1 par l'adresse IP du serveur de **nom** et root.localhost par une adresse email valide, mais avec un point "." à la place de l'arobase "@". Laisser également le point à la fin.
- Créer un enregistrement de type hôte A pour le serveur de nom ns.srsix.lan

/etc/bind/db.srsix.lan
```
;
; BIND data file for local loopback interface
;
$TTL    604800
@       IN      SOA     ns.srsix.lan admin.srsix.lan (
                              1         ; Serial
                         604800         ; Refresh
                          86400         ; Retry
                        2419200         ; Expire
                         604800 )       ; Negative Cache TTL
;
@       IN      NS      ns.srsix.lan.
ns      IN      A       [IP MACHINE DNS]
www     IN      A       [IP SERVEUR WEB]
```
```
sudo service bind9 restart
```

---

- [ ] Ajouter un ? serveur ssh ?, utiliser la PKI du projet précédent pour faire des certificats
https://www.digitalocean.com/community/tutorials/how-to-create-an-ssh-ca-to-validate-hosts-and-clients-with-ubuntu


**Clé serveur**
Principe: prendre la clé du serveur, la signer avec le CA serveur, mettre le certificat obtenu sur le serveur, et configurer sshd du serveur pour utiliser le certif, et configurer le client pour qu'il reconnaisse le certificat

1/ Récupérer clé privée/pub serveur_ca: server_ca.pub et server_ca à partir de la PKI

2/ Signer la clé publique du serveur (la créer au préalable si elle est pas dans /etc/ssh/ ou la récupérer si signature faite sur une autre machine )
```bash
ssh-keygen -s server_ca -I host_auth_server -h -n auth.example.com -V +52w /etc/ssh/ssh_host_rsa_key.pub
```
:::info
note:
-s cle privee utilisee pour signer
-I est le nom de l hôte
-h pour dire host key
-n le nom associe au certificat (il faut un nom de domaine)
-V duree ici 52 weeks
la cle publique a signer
:::

resultat:
ssh_host_rsa_key-cert.pub dans le meme fichier que .pub (il faut le mettre dans /etc/ssh/ du serveur si fait depuis un autre PC)

3/ Configurer le sshd du serveur pour qu'il utilise le certificat
```
sudo nano /etc/ssh/sshd_config
```

et placer la ligne suivante
```
HostCertificate /etc/ssh/ssh_host_rsa_key-cert.pub
```

et finalement
```
sudo service ssh restart
```

4/ configurer le client 

il faut ajouter un élément dans le .ssh/known_hosts du client
@cert-authority [nom de domaine] [clé rsa pub du CA]

**Clé client**
la même mais à l'envers : on configure le serveur pour qu'il reconnaisse l'autorité de certif, et on signe des certificats clients

0/ clé client_ca et client_ca.pub

1/ configuration du serveur
suffit de prendre la clé publique du client_ca, de la mettre dans /etc/ssh/ du serveur et de modifier /etc/ssh/sshd_config

et ajouter:
```
TrustedUserCAKeys /etc/ssh/users_ca.pub
```

et finalement
```
sudo service ssh restart
```

2/ signer clé client

Prendre la clé publique rsa d'un client (~/.ssh/id_rsa.pub) et la signer avec la clé privée du CA:
```
ssh-keygen -s users_ca -I user_username -n username -V +52w id_rsa.pub
```
là le -I c'est pour la gestion des clés, mais le -n très important, c'est l'utilisateur sur lequel le client pourra se connecter avec la clé sur le serveur. 

-n michel permettra aux gens avec le certificat de se connecter à l'utilisateur michel

ensuite il faut placer le id_rsa-cert.pub dans le ~/.ssh/ de la machine client






