Archives pour la catégorie Linux

Coupler Asterisk et Jabber

Ce script permet d’installer un serveur jabber et asterisk. Le serveur jabber peut être couplé au serveur Activedirectory de manière intuitive. J’ai également inclu certaines règles de filtrage au niveau d’iptables. Si jamais les régles ne vous conviennet pas, vous pouvez rebooter votre serveur et le filtrage sautera.

# !/bin/bash
 
# script d’installation du serveur de communication
# auteur : Seito
 
# date : 16 mars 2013
 
# version : 1
 
#la partie suivante est à adapter :
 
#Mise en place de l’adresse réseau :
 
rm /etc/network/interfaces
 
echo "auto lo" >> /etc/network/interfaces
 
echo "iface lo inet loopback" >> /etc/network/interfaces
 
echo "allow-hotplug eth0" >> /etc/network/interfaces
 
echo "iface eth0 inet static" >> /etc/network/interfaces
 
echo "address 172.16.1.4" >> /etc/network/interfaces
 
echo "netmask 255.255.252.0" >> /etc/network/interfaces
 
#Applications des droits
 
chown root :root /etc/network/interfaces
 
chmod 644 /etc/network/interfaces
 
# Insertion d’une nouvelle ligne de dépot
 
echo "deb http://ftp.us.debian.org/debian squeeze main non-free" >> /etc/apt/sources.list
 
# Recréation de la liste de dépôt
 
aptitude update
 
#Installation du jdk java
 
aptitude install -y sun-java6-jdk
 
cd /tmp/
 
#téléchargement du .deb pour openfire
 
wget http://www.igniterealtime.org/downloadServlet?filename=openfire/openfire_3.7.1_all.deb
 
#Installation :
 
dpkg -i downloadServlet\?filename\=openfire%2Fopenfire_3.7.1_all.deb
 
# Demarrage du deamon
 
/etc/init.d/openfire start
 
#Installation des prérequis pour Asterisk
 
aptitude install –y build-essential libxml12-dev ncurses-dev
 
#Rapatriement et extraction des sources :
 
wget http://downloads.asterisk.org/pub/telephony/asterisk/releases/asterisk-1.8.3.3.tar.gz
 
tar xvzf asterisk-1.8.3.3.tar.gz
 
cd asterisk-1.8.3.3/ && make && make install && make config && make samples
 
/etc/init.d/asterisk start
 
#Configuration du filtrage :
 
#Flush de la base de filtre
 
/sbin/iptables -F
 
/sbin/iptables -P INPUT DROP
 
/sbin/iptables -P OUTPUT ACCEPT
 
#Autorisation des reponses
 
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
 
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
 
#Autorisation Ping
 
iptables -A OUTPUT -p icmp -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
 
iptables -A INPUT -p icmp -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
 
iptables -A INPUT -p icmp -m limit --limit 5/s -j ACCEPT
 
#SSH
 
/sbin/iptables -A INPUT -i eth0 -p tcp --dport 22 -j ACCEPT
 
/sbin/iptables -A OUTPUT -o eth0 -p tcp --dport 22 -j ACCEPT
 
#Autoriser DNS
 
iptables -A OUTPUT --protocol udp --destination-port 53 -j ACCEPT
 
#Sortie web
 
iptables -A OUTPUT -p tcp -m multiport --dports 80,443 -j ACCEPT
 
#Autoriser sortie FTP
 
iptables -A OUTPUT -p tcp --dport 21 -j ACCEPT
 
iptables -A OUTPUT -p tcp --dport 20 -j ACCEPT
 
#Creation des regles pour la connexion sur le loopback
 
iptables -A OUTPUT -o lo -s 0.0.0.0/0 -d 0.0.0.0/0 -j ACCEPT
 
iptables -A INPUT -i lo -s 0.0.0.0/0 -d 0.0.0.0/0 -j ACCEPT
 
#Port d’administration jabber :
 
/sbin/iptables -A INPUT -i eth0 -p tcp --dport 9090 -j ACCEPT
 
/sbin/iptables -A OUTPUT -o eth0 -p tcp --dport 9090 -j ACCEPT
 
#Port jabber :
 
/sbin/iptables -A INPUT -i eth0 -p tcp --dport 5222 -j ACCEPT
 
/sbin/iptables -A OUTPUT -o eth0 -p tcp --dport 5222 -j ACCEPT
 
#Port Asterisk :
 
/sbin/iptables -A INPUT -i eth0 -p tcp --dport 5060 -j ACCEPT
 
/sbin/iptables -A OUTPUT -o eth0 -p tcp --dport 5060 -j ACCEPT
 
clear
 
echo "Serveur Jabber installé"
 
echo "Serveur Asterisk installé"
 
echo "Filtrage effectué "
 
echo "Have Fun ! ! !"

Puis vous devez vous connecter à l’interface de gestion http://ipserv:9090 (ipserv étant à remplacer par votre adresse IP ) . L’interface est vraiment trés bien faite et vous devriez trouver comment faire la jonction avec l’ad très facilement.

Pour la suite, vous pouvez ajouter des plugins tel que :

– Asterisk IM Openfire (permettant d’intégrer asterisk dans openfire)

– Email listener (permettant de pouvoir récupere les mails)

– Packet filter (permettant de filtrer les paquets envoyé)

– SIP phone (permettant d’ajouter le support des comptes sip)

Vous trouverez la listes des plugins ici : http://www.igniterealtime.org/projects/openfire/plugins.jsp

Créer un iso en shell

La manipulation est simple, elle est réalisée avec la commande dd qui copie bit à bit tout ce que vous voulez vers un fichier ou encore un périphérique.

dd if=/dev/cdrom of=nomfichier.iso

Puis une fois que vous avez finis, vous pouvez le monter comme suit :

mkdir /mnt/virtualcd && mount -t iso9660 nomfichier.iso /mnt/virtualcd -o loop

Puis pour vérifier le montage :

mount

Linux : Trouver des occurrences parmi plusieurs fichiers

Je ressors un petit script qui m’a permis de gagner beaucoup de temps dans beaucoup de situations ! Je vous en fait profiter :)
Il permet de trouver les occurrences d’un mot dans tous les fichiers d’un répertoire, de plus il indique quel fichier et la ligne ou trouver cette occurrence :) Et le tout en couleur !

#!/bin/bash
function search()
{
        find $DIRECTORY -name "*" -exec grep --color -Hn $PATTERN {} \;
}
 
if [ $1 ]; then
        if [ $2 ]; then
                DIRECTORY=$1
                PATTERN=$2
        else
                DIRECTORY="."
                PATTERN=$1
        fi
        search
else
echo "Usage : $0 [path] pattern"
echo "eg. $0 /home/user occurence"
fi

A vous de l’utiliser, pour faciliter la tâche de ceux qui débutent, voici comment le rendre accessible via une simple commande « findoccur » de votre shell :

1. Créez le fichier /bin/findoccur et coller le script ci-dessus dans ce fichier
2. Donnez les droits d’exécution aux utilisateurs : chmod a+x /bin/findoccur
3. Exécutez la commande findoccur et les paramètres qui vont bien :)

Tags: , ,

Linux : Convertir UNICODE UTF-16 en UTF-8

Voici une méthode simple et rapide pour convertir des fichiers UTF-16 issus du monde Windows :

Afin d’avoir plus d’informations sur le fichier, nous allons utiliser file :

file 20120513_chat.log
20120513_chat.log: Little-endian UTF-16 Unicode English text, with CRLF line terminators

Nous avons bien à faire à un fichier encodé en UTF-16 il va donc falloir le convertir en UTF-8 avec iconv :

iconv -f UTF-16 -t UTF-8 -o fichier_de_sortie.log 20120513_chat.log

Si on ré-exécute file avec le fichier obtenu :

file fichier_de_sortie.log
UTF-8 Unicode English text, with CRLF line terminators

Il est réencodé en UTF-8 et va permettre l’utilisation de grep :)

Tags: , , ,

Linux : détruire facilement des fichiers avec shred et wipe

Comme vous le savez sûrement, un fichier n’est jamais vraiment supprimé du système, il est très souvent possible de récupérer des fichiers qui ont été supprimé quelques heures/jours/mois voire années avant l’utilisation d’une application telle que foremost (Linux) ou EasyRecovery (Windows).

Deux commandes permettent de détruire simplement vos dossiers/fichiers sous linux afin d’éviter toute récupération possible de ces fichiers/dossiers

La commande shred (qui signifie déchiqueter) va permettre de détruire un fichier :

shred nom-du-fichier
#Avec plusieurs passes :
shred -n nombre_passes nom-du-fichier
#En supprimant le résultat à la fin :
shred -u nom-du-fichier

 

shred va simplement réécrire le fichier au nombre de passes désirées avec des caractères aléatoires

Attention, aucune confirmation ne sera demandée ;)

La seconde commande est wipe, qui va permettre de détruire des dossiers et en plus de manière récursive :

wipe -r chemin-du-dossier

  Il existe plusieurs options pour chacune de ces deux commandes, mais pour ça :

RTFM

Tags: , , , ,

Règles de routage simple pour iptables

Un petit billet dédié pour mon ami foireatout qui aurait besoin de connaître quelques commandes afin d’implémenter des règles pour bien débuter dans ce monde :) Les règle ci-dessous sont très loin d’exploiter toute la puissance de netfilter 😉

Pour faire court, iptables est un logiciel libre qui va permettre de gérer le framework netfilter qui implémente un pare-feu (à partir du noyau 2.4).

Pour notre exemple, notre machine est frontale et possède deux interfaces réseau : WAN (eth0) et LAN (eth1)

Sur l’interface WAN (eth0) plusieurs adresses IP publiques sont directement reliées :

eth0 => 91.xx.xx.80

eth0:0 => 91.xx.xx.82

eth0:1 => 91.xx.xx.83

eth0:2 => 91.xx.xx.84

L’adresse de notre interface LAN eth1 est 192.168.1.254 et notre réseau 192.168.1.0/24

Parmi les machines qui sont sur le LAN nous avons :

machine utilisation adresse ip ip publique à utiliser redirection de ports nat d’adresse ip
www serveur web 192.168.1.10 91.xx.xx.84 91.xx.xx.84
asterisk serveur sip 192.168.1.11 91.xx.xx.82 UDP : 10000-20000,5060
srvtse serveur TSE 192.168.1.12 91.xx.xx.80 TCP : 3389
srvmail Serveur mail 192.168.1.13 91.xx.xx.83 TCP : 25,110,143
admin Machine administration 192.168.1.20 91.xx.xx.80

Avant de commencer

Le travail ci-dessous va utiliser la table NAT qui permet d’effectuer de la traduction d’adresses réseau (le NAT) pour les paquets. Ensuite nous allons utiliser les chaines POSTROUTING, PREROUTING et les cibles SNAT, DNAT et MASQUERADE.

Chaine PREROUTING et cible DNAT

Dans la chaine PREROUTING (avant routage) on ne peut modifier que l’adresse de destination (et les numéros de ports au cas où ils seraient déja utilisés), d’ou l’utilisation de la cible DNAT (NAT de destination).

Chaine POSTROUTING et cible SNAT

Dans la chaine POSTROUTING (après routage) on ne peut modifier que l’adresse source, d’ou l’utilisation de la cible SNAT (NAT source).

Cible MASQUERADE

Cette cible permet de déterminer l’adresse IP de sortie pour chaque paquet, ce qui est moins performant car il va vérifier l’interface de sortie pour chaque connexion. MASQUERADE est utilisée dans le cas d’une adresse IP publique dynamique, dans le cas d’IP fixe nous préfèrerons utiliser la cible SNAT en spécifiant l’adresse IP de sortie.

Si déja vous êtes perdu(e) attaquez-vous à iptables-tutorial de Oskar Andreasson à cette adresse : http://www.inetdoc.net/guides/iptables-tutorial/

Simple passerelle

La machine admin a simplement besoin d’utiliser notre serveur en tant que passerelle :

iptables -t nat -A POSTROUTING -s 192.168.1.20/32 -o eth0 -j SNAT --to-source 91.xx.xx.80

ou en utilisant la cible MASQUERADE :

iptables -t nat -A POSTROUTING -s 192.168.1.20/32 -o eth0 -j MASQUERADE

Si toutefois vous deviez permettre à tout votre réseau 192.168.1.0/24 d’utiliser le serveur en passerelle, remplacez simplement 192.168.1.20/32 par 192.168.1.0/24

NAT d’adresse IP publique

La machine www doit avoir une IP publique nattée (91.xx.xx.84).

Les commandes suivantes sont pour permettre les connexions entrantes et la seconde les connexions sortantes

iptables -t nat -A PREROUTING -d 91.xx.xx.84/32 -i eth0 -j DNAT --to-destination 192.168.1.10
iptables -t nat -A POSTROUTING -s 192.168.1.10/32 -o eth0 -j SNAT --to-source 91.xx.xx.84

Redirection de ports

Le serveur TSE utilise l’IP publique 91.xx.xx.80 et on veut rediriger le port 3389 TCP :

iptables -t nat -A PREROUTING -d 91.xx.xx.80/32 -i eth0 -p tcp -m tcp --dport 3389 -j DNAT --to-destination 192.168.1.12:3389
iptables -t nat -A POSTROUTING -s 192.168.1.12/32 -o eth0 -j SNAT --to-source 91.xx.xx.80

Le serveur de mail utilise l’IP publique 91.xx.xx.83 et les ports TCP 25, 110 et 143 :

iptables -t nat -A PREROUTING -d 91.xx.xx.83/32 -i eth0 -p tcp -m tcp --dport 25 -j DNAT --to-destination 192.168.1.13:25
iptables -t nat -A PREROUTING -d 91.xx.xx.83/32 -i eth0 -p tcp -m tcp --dport 110-j DNAT --to-destination 192.168.1.13:110
iptables -t nat -A PREROUTING -d 91.xx.xx.83/32 -i eth0 -p tcp -m tcp --dport 143 -j DNAT --to-destination 192.168.1.13:143
iptables -t nat -A POSTROUTING -s 192.168.1.13/32 -o eth0 -j SNAT --to-source 91.xx.xx.83

Le serveur asterisk utilise l’IP publique 91.xx.xx.82 et on veut rediriger le port 5060 UDP :

iptables -t nat -A PREROUTING -d 91.xx.xx.82/32 -i eth0 -p udp -m udp --dport 5060 -j DNAT --to-destination 192.168.1.11:5060
iptables -t nat -A POSTROUTING -s 192.168.1.11/32 -o eth0 -j SNAT --to-source 91.xx.xx.82

Redirection d’une plage de ports

Le serveur asterisk utilise l’IP publique 91.xx.xx.82 et on veut rediriger la plage de ports 10000 à 20000 UDP :

iptables -t nat -A PREROUTING -d 91.xx.xx.82/32 -i eth0 -p udp -m udp --dport 10000:20000 -j DNAT --to-destination 192.168.1.11:10000-20000

Si vous ne l’avez pas déja fait avec une autre règle (cf. la dernière règle pour la redirection de ports), entrez cette commande :

iptables -t nat -A POSTROUTING -s 192.168.1.11/32 -o eth0 -j SNAT --to-source 91.xx.xx.82

Démarrage machine

Si vous redémarrez votre serveur sachez que les règles iptables ne seront pas restaurées automatiquement, des outils sont là pour vous aider :

iptables-backup et iptables-restore

Tags: , , ,

Modifier date de modification d’un fichier

Pour modifier la date de modification d’un fichier, utilisez la commande touch :

touch -t [[CC]AA]MMJJhhmm[.ss] à la place de la date actuelle

Exemple avec une modification le 26/07/2011 à 02h00 pour le fichier admin6.txt :

touch -t 201107260200 admin6.txt

Nagios : monitorer la HA netASQ en script shell

Sur les pare-feu NetASQ il y a la possibilité de les mettre en High availability (Haute Dispo).

Un moyen assez simple de le monitorer avec nagios est de chercker son numéro de série. Il est écrit en script shell et parse les arguments à l’aide de getops. (Voir article sur Comment passer proprement des arguments en script shell)

Il est très simple et utilise la commande smnpget et récupère le numéro de série.
On passe comme arguments au script adresse, communauté et numéro de série du primaire ce cette manière :
./check_netasq_ha -H hostadress -c community -s masterSerialNumber

Il retourne OK (0) si il récupère bien le bon S/N et CRITICAL (2) si il ne récupère pas ce S/N.

De cette manière il est facile de savoir si snmp si le pare-feu est en mode principal ou secondaire.

#!/usr/bin/env bash
hflag=
cflag=
sflag=
while getopts 'H:c:s:' OPTION
do
  case $OPTION in
  H)    hflag=1
                host="$OPTARG"
                ;;
  c)    cflag=1
                community="$OPTARG"
                ;;
  s)    sflag=1
                snumber="$OPTARG"
                ;;
  ?)    printf "Usage: %s: -H hostname -c community -s MasterSerialNumber \n" $(basename $0) >&2
                exit 2
                ;;
  esac
done
shift $(($OPTIND - 1))
if [ "$hflag" ] && [ "$cflag" ] && [ "$sflag" ]
then
  CHECK=$(snmpget -v1 -c $community $host 1.3.6.1.2.1.1.5.0 | awk '{print $4}' | sed -e "s/\"//2" | sed -e "s/\"//1")
        if [ $CHECK = $snumber ];
        then
                printf "HA OK : Primaire en production\n"
                exit 0
        else
                printf "HA CRITICAL : Secondaire en production\n"
                printf "SN actuel : $CHECK\n"
                printf "SN master : $snumber\n"
                exit 2
        fi
else
 printf "Argument error !\n"
 printf "Usage: %s: [-H hostname] [-c community] [-s MasterSerialNumber ]args\n" $(basename $0) >&2
 exit 3
fi

Vous pouvez l’ajouter à votre bibliothèque de scripts nagios :)

Il pourrait certainement être amélioré mais il déjà est pratique 😉

N’hésitez pas à ajouter des commentaires si vous avez des axes d’amélioration 😉

Tags: , ,

Passage propre d’arguments en script shell

Tout admin est ou a été confronté à réaliser des dizaines de script d’automatisation de tâche ou même de scripts lui facilitant des tâches quotidiennes. Dans ce billet je vais expliquer comment on va pouvoir passer des arguments de manière propre à un script shell de cette manière :

./script -h 192.168.10.24 -u admin -p password

oubliez les scripts sales comme celui-ci :

./script 192.168.10.24 admin password

Vous avez même la possibilité de créer un usage :

./script
Argument error, usage :
script: -h hostname -u username -p password [-c command]

Voici comment écrire un script rapidement :

#!/usr/bin/env bash
#Script exemple
#
aoption=
boption=
bval=
#Initialisation des paramètres et valeurs
 
while getopts 'ab:' OPTION
#a signifique c'est simplement une option
#b: signifique que cette option possède un paramètre
do
   case $OPTION in
   a)    aoption=1
          ;;
   b)    boption=1
         bval="$OPTARG"
#OPTARG est récupéré de la valeur passé après -b
          ;;
   ?)    printf "Usage : %s [-a ] [- b valeur] args\n" >&2
#Affichage du usage lorsque qu'aucun paramètre n'est passé
          exit 2
          ;;
   esac
done
shift $((OPTIND - 1))
if [ "$aoption" ]
then
   printf "Option -a spécifiée\n"
fi
if [ "$boption" ]
then
   printf 'Option -b spécifiée, valeur : "%s"' "$bval"
fi

Source : linux.com – Inspiré du Bash CookBook

Tags:

Installer un serveur OpenVPN

Aller zou ! Un petit billet histoire de se mettre en forme sur l’installation d’un serveur OpenVPN. Vous allez voir que c’est assez simple et rapide à mettre en place (j’ai mis au maximum 10 minutes)

Avant toute chose, assurez-vous que vos serveurs qui vont se « VPNer » doivent avoir la même heure pour les certificats, donc utilisez la commande ntpdate :)

Lisez la suite pour installer ce serveur :)

Lire le reste de cet article »

Tags: , ,