Bonjour,

J'ai fait un serveur maison, j'ai configuré le pare-feu (WEB, SSH, MAIL, MYSQL) je crois que c'est tout.

J'ai aussi configuré SSH pour n'avoir que la possibilité de se connecter par clés privée et pas par mot de passe.

Jusque là je ne vois pas où il pourrait y avoir de failles.

Pour finir j'ai mis tous les dossiers en "0700"(sauf exception), puis les fichiers en "0500"(lecture et exécution), ainsi que le nom du groupe et de l'utilisateur à "www-data".

Mais je me suis posé une question, est-ce que n'importe qui pourrait modifier ces droits en utilisant Apache par le biais de PHP ou autre, et dans ce cas il pourrait tout modifier et tout casser

Et si vous avez d'autre suggestions de sécurisation je suis preneur.

Bien à vous,

Un jeune sécuritarisme, pour ses super projets WEB

Ajout :

1 - Quand je dit "que n'importe qui pourrait modifier ces droits" je parle des applications, mais si il y a un autre moyen, ça serait sympathique de m'en faire part.

-
Edité par Accraugaming 23 juin 2019 à 13:28:53

Si tes applications tournent avec les droits root et sont piratables, il aura tous les droits.

Si elles tournent avec des droits restreints, il aura des droits restreints tant qu'il n'utilisera pas une autre faille pour faire une élévation de privilèges.

En gros, tu ne risques pas grand chose si tu a s laissé la conf par défaut d'apache et que tes applis web sont pas truffées de formulaires non testés.

Pourquoi rendre le serveur SQL accessible dans le firewall ?

Bonjour,

Désoler du retard, mais j'ai beaucoup de bouleau en ce moment.

Je me suis trompé je n'ai pas MySQL,

J'ai activé :

Loopback

ICMP (Je ne sais pas ce que c'est)

SSH

HTTP

HTTPS

et SMTP au cas où, pour l'envoie de mail par PHP ou en cas de connexion SSH ou autre.

Je pense avoir le strict minimum.

En gros ça donne ça (les # sont des commentaires) :

#! /bin/sh
### BEGIN INIT INFO
# Provides:          PersonalFirewall
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Personal Firewall
# Description:       Init the firewall rules
### END INIT INFO

# programme iptables IPV4 et IPV6
IPT=/sbin/iptables
IP6T=/sbin/ip6tables

# Les IPs
#IP_TRUSTED=xx.xx.xx.xx

do_start() {
    # Efface toutes les regles en cours. -F toutes. -X utilisateurs
    $IPT -t filter -F
    $IPT -t filter -X
    $IPT -t nat -F
    $IPT -t nat -X
    $IPT -t mangle -F
    $IPT -t mangle -X
    $IP6T -t filter -F
    $IP6T -t filter -X
    $IP6T -t mangle -F
    $IP6T -t mangle -X

    # strategie (-P) par defaut : bloc tout l'entrant le forward et autorise le sortant
    $IPT -t filter -P INPUT DROP
    $IPT -t filter -P FORWARD DROP
    $IPT -t filter -P OUTPUT ACCEPT
    $IP6T -t filter -P INPUT DROP
    $IP6T -t filter -P FORWARD DROP
    $IP6T -t filter -P OUTPUT ACCEPT

    # Loopback
    $IPT -t filter -A INPUT -i lo -j ACCEPT
    $IPT -t filter -A OUTPUT -o lo -j ACCEPT
    $IP6T -t filter -A INPUT -i lo -j ACCEPT
    $IP6T -t filter -A OUTPUT -o lo -j ACCEPT

    # Permettre a une connexion ouverte de recevoir du trafic en entree
    $IPT -t filter -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
    $IP6T -t filter -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

    # ICMP
    $IPT -t filter -A INPUT -p icmp -j ACCEPT

    # DNS:53
##    $IPT -t filter -A INPUT -p tcp --dport 53 -j ACCEPT
##    $IPT -t filter -A INPUT -p udp --dport 53 -j ACCEPT
##    $IP6T -t filter -A INPUT -p tcp --dport 53 -j ACCEPT
##    $IP6T -t filter -A INPUT -p udp --dport 53 -j ACCEPT

    # SSH:22
    # ATTENTION, indiques bien ton port personnalisé si tu l'as changé
    $IPT -t filter -A INPUT -p tcp --dport SECRET -j ACCEPT
    $IP6T -t filter -A INPUT -p tcp --dport SECRET -j ACCEPT

    # HTTP:80
    $IPT -t filter -A INPUT -p tcp --dport 80 -j ACCEPT
    $IP6T -t filter -A INPUT -p tcp --dport 80 -j ACCEPT

    # HTTPS:443
    $IPT -t filter -A INPUT -p tcp --dport 443 -j ACCEPT
    $IP6T -t filter -A INPUT -p tcp --dport 443 -j ACCEPT

    # SMPT:25/587/465
    $IPT -t filter -A INPUT -p tcp --dport 25 -j ACCEPT
    $IP6T -t filter -A INPUT -p tcp --dport 25 -j ACCEPT
    $IPT -t filter -A INPUT -p tcp --dport 587 -j ACCEPT
    $IP6T -t filter -A INPUT -p tcp --dport 587 -j ACCEPT
#    $IPT -t filter -A INPUT -p tcp --dport 465 -j ACCEPT
#    $IP6T -t filter -A INPUT -p tcp --dport 465 -j ACCEPT

    # POP3:110/995
#    $IPT -t filter -A INPUT -p tcp --dport 110 -j ACCEPT
#    $IP6T -t filter -A INPUT -p tcp --dport 110 -j ACCEPT
#    $IPT -t filter -A INPUT -p tcp --dport 995 -j ACCEPT
#    $IP6T -t filter -A INPUT -p tcp --dport 995 -j ACCEPT

    # IMAP / SIEVE : 143/993/4190
#    $IPT -t filter -A INPUT -p tcp --dport 143 -j ACCEPT
#    $IP6T -t filter -A INPUT -p tcp --dport 143 -j ACCEPT
##    $IPT -t filter -A INPUT -p tcp --dport 993 -j ACCEPT
##    $IP6T -t filter -A INPUT -p tcp --dport 993 -j ACCEPT
##    $IPT -t filter -A INPUT -p tcp --dport 4190 -j ACCEPT
##    $IP6T -t filter -A INPUT -p tcp --dport 4190 -j ACCEPT

    # accepte tout d'une ip en TCP
#    $IPT -t filter -A INPUT -p tcp -s $IP_TRUSTED -j ACCEPT

    echo "firewall started [OK]"
}

# fonction qui arrete le firewall
do_stop() {

    # Efface toutes les regles
    $IPT -t filter -F
    $IPT -t filter -X
    $IPT -t nat -F
    $IPT -t nat -X
    $IPT -t mangle -F
    $IPT -t mangle -X
    $IP6T -t filter -F
    $IP6T -t filter -X
    $IP6T -t mangle -F
    $IP6T -t mangle -X

    # remet la strategie
    $IPT -t filter -P INPUT ACCEPT
    $IPT -t filter -P OUTPUT ACCEPT
    $IPT -t filter -P FORWARD ACCEPT
    $IP6T -t filter -P INPUT ACCEPT
    $IP6T -t filter -P OUTPUT ACCEPT
    $IP6T -t filter -P FORWARD ACCEPT

    #
    echo "firewall stopped [OK]"
}

# fonction status firewall
do_status() {

    # affiche les regles en cours
    clear
    echo Status IPV4
    echo -----------------------------------------------
    $IPT -L -n -v
    echo
    echo -----------------------------------------------
    echo
    echo status IPV6
    echo -----------------------------------------------
    $IP6T -L -n -v
    echo
}




case "$1" in
    start)
        do_start
        exit 0
    ;;

    stop)
        do_stop
        exit 0
    ;;

    restart)
        do_stop
        do_start
        exit 0
    ;;

    status)
        do_status
        exit 0
    ;;

    *)
        echo "Usage: /etc/init.d/firewall {start|stop|restart|status}"
        exit 1
    ;;

esac

Merci pour votre aide.

OUBLI :

- J'ai le serveur de base Ubuntu 18.04, avec Apache2, MySQL et SSH, je ne rajoute rien pour éviter des problèmes.

- Je suis en train de mettre en place un SSL auto signé. Est-ce qu'il y a des précautions à prendre ? pour info j'utilise ce tutoriel : https://doc.ubuntu-fr.org/tutoriel/securiser_apache2_avec_ssl

Juste que je ne vais pas utiliser "Cerbot" je n'ai pas confiance, je vais partir sur "Openssl" : https://www.remipoignon.fr/generez-un-certificat-ssl-auto-signe-pour-passer-en-https/ est-ce une bonne idée ?

AJOUT

- J'ai activé le mod SSL et j'ai utilisé le fichier par défaut (/etc/apache2/sites-available/000-default.conf)

- J'avais oublié le coup des mise à jour Apache qui peut remplacer "000-default.conf", je vais donc le nommer autrement.

J'ai rajouté à la suite le port 443 avec les ligne par défaut d'apache (ce sont les deux ligne de clès SSL par défaut, puis-je les utiliser sans problèmes ?) :

SSLEngine on

SSLCertificateFile      /etc/ssl/certs/ssl-cert-snakeoil.pem
SSLCertificateKeyFile /etc/ssl/private/ssl-cert-snakeoil.key

<FilesMatch "\.(cgi|shtml|phtml|php)$">
  SSLOptions +StdEnvVars
</FilesMatch>
<Directory /usr/lib/cgi-bin>
  SSLOptions +StdEnvVars
</Directory>

-
Edité par Accraugaming 28 juin 2019 à 13:59:02

Bonsoir,  

Juste à titre d'information, il existe l'outil iptables-persistent qui évite de créer un service perso. Pour l'installer :  

apt install iptables-persistent

Ensuite il suffit de mettre en place tes règles puis de lancer les commandes suivantes pour les rendre persistantes :  

iptables-save > /etc/iptables/rules.v4
ip6tables-save >/ etc/iptables/rules.v6

Pour gérer le service :  

systemctl status netfilter-persistent

Sinon pour renforcer la sécurité tu peux utiliser l'outil fail2ban. Pour faire simple il analyse les logs (ex : logs apache, logs ssh, ..) et utilise iptables pour bloquer les tentatives d'attaques.  

-
Edité par mika83 2 juillet 2019 à 23:33:15

Bonjour,

Merci beaucoup pour cette aide.

J'essaie d'installer le moins de logiciel possible, donc je pense que "iptables-persistent" n'est pas nécessaire, mais c'est à retenir.

J'ai déjà entendu parler de "fail2ban", j'essaierais d'en apprendre un peu plus par la suite.

Je garderais ça dans mes favoris

QUESTION :

- (DNS et PHP) Je me posais une question (Changer l'IP du serveur à utiliser, dynamiquement avec PHP),

j'ai un nom de domaine "truc.fr" qui pointe vers une adresse du genre 96.125.12.55,

mais cela serait juste une simple application temporaire(salle d'attente) pour pouvoir être rediriger vers une autre adresse IP Publique ou Locale.

Serait il possible en vérifiant si "192.168.1.39?exist" de changer l'adresse IP du serveur utilisé (86.59.102.5,publique ou 192.168.1.39,locale) tout en restant sur le nom de domaine "truc.fr"

En gros, si le serveur est en local on reste sur truc.fr avec l'adresse 192.168.1.39 et si le serveur local ne répond pas alors on reste sur truc.fr, mais avec l'adresse 86.59.102.5.

En espérant avoir était assez clair.

-
Edité par Accraugaming 3 juillet 2019 à 10:25:20

J'imagine que l'adresse IP publique 96.125.12.55 est ta box internet qui route les flux WEB et SSH vers ton serveur local 192.168.1.39. Si c'est bien le cas et que tu as une autre machine chez toi tu peux faire de la répartition de charge avec Apache. Fait un routage de ta box 96.125.12.55 vers cette machine. Celle dernière se chargera de faire le load balancing vers 86.59.102.5 et 192.168.1.39 .  

Voici une définition récupéré sur comment ça marche :

 L'équilibrage de charge(parfois appelérépartition de chargeou en anglaisload balancing) consiste à distribuer une tâche à un pool de machines ou de périphériques afin :

• de lisser le trafic réseau, c'est-à-dire de répartir la charge globale vers différents équipements ;
• de s'assurer de la disponibilité des équipements, en n'envoyant des données qu'aux équipements en mesure de répondre, voire à ceux offrant le meilleur temps de réponse.

Ce type de mécanisme s'appuie sur un élément, appelé répartiteur de charge (en anglais load balancer) chargé de distribuer le travail entre différentes machines.

---

Si par contre tu veux juste tester ton application dans ton LAN en attendant de le mettre en production, tu peux assigner localement le domaine truc.fr à l'adresse IP 192.168.1.39 . Par exemple sous Linux tu édites le fichier /etc/hosts de ton poste de travail en y ajoutant l'entrée suivante :  

192.168.1.39    truc.fr

Une fois les tests terminés tu supprimes la ligne. Sinon tu peux aussi gérer un serveur DNS pour ton LAN, mais c'est costaud pour pas grand chose  .  

-
Edité par mika83 3 juillet 2019 à 19:45:54