Catégorie : Linux

25 janvier 2016 /

Ufw (pour « Uncomplicated Firewall ») permet de gérer Netfilter, le pare-feu de Linux.
Il a été développé à l’origine par Caconical, mais maintenant il est disponible sur d’autres distributions comme Debian.

Par defaut, Ufw interdit tous les paquets entrants et autorise tous les paquets sortants. Il autorise également toutes les connexions en cours.
Il ne reste donc qu’à autoriser les paquets entrants suivants nos besoins.

Installation Ufw

apt-get install ufw

Activation d’Ufw

ufw enable

Autoriser un flux entrant (ici ssh)

ufw allow 22

Interdire un flux entrant (ici ssh)

ufw deny 22

Ufw possede des regles prédéfinies permettant d’autoriser des applications sans avoir a entrer manuellement le numéro de port.

Pour obtenir la liste des applications disponibles:

ufw app list

Ensuite pour autorisé une application

ufw allw SSH

Autoriser un flux entrant (règle complexe)

ufw allow from 2.5.8.3 to any port 22

Cette commande va autoriser les connexions ssh a partir de l’ip 2.5.8.3.

Interdire un flux entrant (règle complexe)

ufw deny from 2.5.8.3 to any port 22

Cette commande va interdire les connexions ssh a partir de l’ip 2.5.8.3.

Pour lister les règles en place avec numérotation :

ufw status numbered

Supprimer une règle (en se basant sur la numérotation (ici règle n°2):

ufw delete 2

18 janvier 2016 /

1 – Création d’un script de démarrage

On commence par écrire nos règles de démarrage d’iptables dans un fichier texte, ici /etc/iptables/start.sh :

#!/bin/sh

# Réinitialise les règles
iptables -t filter -F
iptables -t filter -X

# Bloque tout le trafic
iptables -t filter -P INPUT DROP
iptables -t filter -P FORWARD DROP
iptables -t filter -P OUTPUT DROP

# Autorise les connexions déjà établies et localhost
iptables -A INPUT -m state –state RELATED,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -m state –state RELATED,ESTABLISHED -j ACCEPT
iptables -t filter -A INPUT -i lo -j ACCEPT
iptables -t filter -A OUTPUT -o lo -j ACCEPT

# DNS entrée/sortie
iptables -t filter -A OUTPUT -p tcp –dport 53 -j ACCEPT
iptables -t filter -A OUTPUT -p udp –dport 53 -j ACCEPT
iptables -t filter -A INPUT -p tcp –dport 53 -j ACCEPT
iptables -t filter -A INPUT -p udp –dport 53 -j ACCEPT

# SSH
iptables -t filter -A INPUT -p tcp –dport 22 -j ACCEPT
iptables -t filter -A OUTPUT -p tcp –dport 22 -j ACCEPT

# HTTP/HTTPS
iptables -t filter -A OUTPUT -p tcp –dport 80 -j ACCEPT
iptables -t filter -A INPUT -p tcp –dport 80 -j ACCEPT
iptables -t filter -A OUTPUT -p tcp –dport 443 -j ACCEPT
iptables -t filter -A INPUT -p tcp –dport 443 -j ACCEPT

# Ping – ICMP
iptables -t filter -A OUTPUT -p icmp -j ACCEPT
iptables -t filter -A INPUT -p icmp -j ACCEPT

On oublie pas de rendre exécutable le script:

chmod +x /etc/iptables/start.sh

2 – Création d’un script d’arrêt

Puis nos règles d’arrêt iptables, ici /etc/iptables/stop.sh :

#!/bin/sh

# Flush all rules
iptables -F
iptables -X
iptables -t nat -F
iptables -t nat -X
iptables -t mangle -F
iptables -t mangle -X
iptables -P INPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -P OUTPUT ACCEPT

on rend le script exécutable:

chmod +x /etc/iptables/stop.sh

3 – Création d’un service

Il ne nous reste plus qu’a créé le service dans /etc/init.d/, dans l’exemple il porte le nom « iptables_service ».

#!/bin/sh

SERVICE_NAME=iptables_service
SERVICE_DIRECTORY=/etc/iptables/
SERVICE_STARTUP_SCRIPT=start.sh
SERVICE_SHUTDOWN_SCRIPT=stop.sh

## Functions ##
usage()
{
echo « ———————–« 
echo « Usage: $0 (stop|start|restart) »
echo « ———————–« 
}
service_start()
{
echo « Starting service ‘${SERVICE_NAME}’… »
OWD=`pwd`
cd ${SERVICE_DIRECTORY} ./${SERVICE_STARTUP_SCRIPT}
cd $OWD
echo « Service ‘${SERVICE_NAME}’ started successfully »
}
service_stop()
{
echo « Stopping service ‘${SERVICE_NAME}’… »
OWD=`pwd`
cd ${SERVICE_DIRECTORY} && ./${SERVICE_SHUTDOWN_SCRIPT}
cd $OWD
echo « Service ‘${SERVICE_NAME}’ stopped »
}

## Main ##
if [ -z $1 ]; then
usage
fi

case $1 in
stop)
service_stop
;;
start)
service_start
;;
restart)
service_stop
service_start
;;
*)
usage
esac
exit 0

On le rend exécutable:

chmod +x /etc/init.d/iptables_service

Maintenant, pour démarrer le service:

service iptables_service start

ou

/etc/init.d/iptables_service start

Le redémarrer:

service iptables_service restart

ou

/etc/init.d/iptables_service restart

L’arrêter:

service iptables_service stop

ou

/etc/init.d/iptables_service stop

11 janvier 2016 /

Pour utiliser apt-get derrière un proxy, il y a deux solutions:

Pour un usage ponctuel, il suffit d’exporter les paramètres du proxy que l’on souhaite utiliser dans la variable d’environnement http_proxy, sous la forme suivante :

export http_proxy=http://utilisateur:motdepasse@serveurproxy.com:port

utilisateur= Utilisateur pour se connecter au proxy (si nécessaire).
motdepasse=mot de passe associé à l’utilisateur du proxy (si nécessaire).
serveurproxy.com= l’adresse du proxy.
port= Port d’écoute du proxy.

Pour activer le proxy de façon pérenne, il faut créer un fichier /etc/apt/apt.conf.d/proxy puis d’y ajouter la ligne suivante :

Acquire::http::Proxy "http://utilisateur:motdepasse@example.com:port";

27 décembre 2015 /

Voici une petite astuce qui permet d’obtenir la liste des liens symboliques contenus dans un répertoire:

ls -F | grep @$ | awk -F@ '{print $1}'

La même chose mais cette fois de façon récursive:

find . -type l

25 décembre 2015 /

Quelle est la différence entre simple et double guillemets sur le shell? »

Du texte délimité par des guillemets est une pratique assez courante lorsque l’on pratique la ligne de commande, en particulier lorsqu’ils traitent avec des fichiers qui ont des espaces dans les noms.

Mais comment savoir si il faut utiliser des guillemets simples ou doubles? Jetons un petit coup d’œil à la différence entre les deux, et dans quel cas utiliser l’un ou l’autre.

La règle générale est que les guillemets doubles permettent la lecture des variables dans les citations, et des guillemets simples ne le font pas. Continue de lire.

Citations avec un texte simple

Si il faut juste traiter quelques mots de texte, il n’y a pas vraiment d’importance sur celle que vous utilisez, car le résultat sera le même.
Par exemple, ces deux commandes vont créer toutes les deux un répertoire nommé « Test 1 »:

mkdir "Test 1"
mkdir 'Test 1'

A noter que vous pouvez également utiliser mkdir Test \ 1 si vous le vouliez.

Les variables

La différence entre guillemets simples et doubles arrivent lorsque vous avez affaire à des variables.
Premièrement, nous allons assigner la variable:

test="Pour le test"

Maintenant, vous pouvez utiliser cette variable sur la ligne de commande, comme ceci, qui devrait tout simplement afficher Pour le test  sur la console:

echo $test

La différence entre guillemets doubles et simples devient plus clair lorsque vous utilisez des guillemets simples. Par exemple, si vous exécutez la commande suivante:

echo '$test'

Vous ne verrez pas la valeur de la variable s’afficher, mais ‘$test « . Cela est dû aux guillemets simples, il faudra donc que utiliser des guillemets doubles.

quote

La même chose fonctionne lorsque vous utilisez le caractère ` dans une commande.
Par exemple, imaginons que vous vouliez utiliser la commande pwd à l’intérieur d’une autre commande:

echo `pwd`/test

Si vous étiez dans mon dossier personnel, vous verriez sortie qui ressemblait à ceci:

/home/starmate/test

Imaginons maintenant,  que vous créez un dossier qui a un espace dans son nom, et que vous voulez utiliser la commande ln pour faire un lien symbolique dans votre répertoire personnel pointant dessus.

Généralement, on a besoin de spécifier le chemin complet lors de l’utilisation de ln, il est donc beaucoup plus facile à utiliser `pwd`.

Vous ce qui passe lorsque l’on utilise ln sans l’encadrer par des doubles guillemets:

ln –s `pwd`/test /home/starmate/lien1

ln

Au lieu de cela, vous aurez besoin d’entourer de guillemets:

ln –s "`pwd`/test" /home/starmate/lien1

Pour un exemple plus concret, supposons que nous avons plusieurs fichiers comme dans cet exemple, où tous les noms de fichiers ont des espaces en eux:

zip

La commande unzip ne supporte pas l’utilisation du signe étoile  (*) pour prendre tous les fichiers.
Vous aurez besoin d’utiliser une boucle « for » à la place. C’est là où les choses deviennent intéressantes:

for f in *.zip;do unzip $f;done

 

zip2

 

Put*1#! On dirait que cela n’a pas fonctionné.

A la place il faut utiliser des guillemets autour de la variable $f, comme ceci:

for f in *.zip;do unzip "$f";done

Maintenant, chaque fois la commande la boucle for s’exécute, elle va se créer une commande comme celle-ci:

unzip "test 1.zip"

Revoyons

Maintenant que nous avons passé en revue les exemples, nous allons juste rapidement en revue au cas où vous l’avez manqué:

Guillemets doubles

  • A utilisez lorsque vous souhaitez afficher des variables ($)ou si vous utilisez le signe ` dans une chaîne.
  • Tous les caractères sont interprétés comme des caractères réguliers sauf pour $ ou ` .

Guillemets simples

  • Tous les caractères entre guillemets simples sont interprétés comme un caractère de chaîne.

Ainsi se termine la leçon sur les guillemets.