Ajouter X certificats au Magasin de certificats de Firefox

Problématique :
Pour éviter d’avoir le message suivant sur Firefox lorsque vous tentez d’accéder à un serveur HTTPS avec certificat auto-signé :

Demande Exception Firefox

Il est nécessaire d’effectuer une petite manipulation pour déclarer notre autorité de certification (CA) Windows dans le magasin de certificats de Firefox.

Pré-requis (à télécharger) :
NSPR
NSS

Il faut savoir qu’Internet Explorer et Chrome se basent sur les certificats définis dans les magasins Windows, contrairement à Firefox qui lui se base sur son propre magasin de certificats. Ceci signifie que si vous signez vous-même vos certificats dans votre entreprise via votre CA, vous aurez le message ci-dessus lorsque vous tenterez d’accéder à un serveur en https avec certificat SSL auto-signé par votre PKI Windows.

Pour éviter cela, Mozilla met à notre disposition un outil qui s’appelle certutil qui nous permet de mettre à jour le magasin de certificats avec ceux de notre PKI Windows.

Voici un script que j’ai fait pour mettre à jour à l’ouverture de session, le magasin de certificats de Firefox, des utilisateurs Windows (je ne m’étendrais pas ici sur la mise en place de la GPO elle-même.).

SET PATH=%PATH%;C:\mypathToNssLibrary\lib

IF NOT EXIST %APPDATA%\Mozilla GOTO:eof

IF NOT EXIST %USERPROFILE%\certificat-firefox.txt GOTO :DeployCert
GOTO:eof

:DeployCert
FOR /F "tokens=*" %%A IN ('dir /B %APPDATA%\Mozilla\Firefox\Profiles\*.default') DO C:\myPathToFirefoxCertutilexe\certutil.exe -A -n MyFirstCertificat -t "C,C,C" -d "%APPDATA%\Mozilla\Firefox\Profiles\%%A" -i "\\MyPathToMyCertificatFile\myfirstcertif.crt"
FOR /F "tokens=*" %%A IN ('dir /B %APPDATA%\Mozilla\Firefox\Profiles\*.default') DO C:\myPathToFirefoxCertutilexe\certutil.exe -A -n MySecondCertificat -t "C,C,C" -d "%APPDATA%\Mozilla\Firefox\Profiles\%%A" -i "\\MyPathToMyCertificatFile\mysecondcertif.crt"
FOR /F "tokens=*" %%A IN ('dir /B %APPDATA%\Mozilla\Firefox\Profiles\*.default') DO C:\myPathToFirefoxCertutilexe\certutil.exe -A -n MyThirdCertificat -t "C,C,C" -d "%APPDATA%\Mozilla\Firefox\Profiles\%%A" -i "\\MyPathToMyCertificatFile\mythirdcertif.cer"

copy /y NUL %USERPROFILE%\certificat-firefox.txt >NUL

Et voilà, en ouvrant votre navigateur et en vous dirigeant vers un site interne ayant un certificat auto-signé, plus besoin d’ajouter une exception, votre site est considéré comme valide car signé par une autorité faisant partie de la liste de Firefox. 🙂 Pas mal non?

1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
Loading...

[HowTo] Chiffrer votre disque dur externe

Depuis qu’un collègue m’a raconté qu’un de ses copains s’était fait cambriolé et volé tout son matériel informatique, je me suis dit qu’il était sans doute temps de mettre en oeuvre le chiffrement de mon disque dur externe.

Alors attention, il faut savoir que pour mettre en place le chiffrement de votre disque dur, il va falloir l’effacer entièrement pour mettre la couche LUKS pour chiffrer les données.

Voici la marche à suivre en émettant l’hypothèse que le disque externe est défini en tant que /dev/sdb

# cryptsetup luksFormat /dev/sdb1

WARNING!
========
This will overwrite data on /dev/sdb1 irrevocably.

Are you sure? (Type uppercase yes): YES
Enter LUKS passphrase:
Verify passphrase:
Command successful.

# cryptsetup luksOpen /dev/sdb1 discexterne
# mkfs.ext4 /dev/mapper/discexterne
# mkdir /mnt/discexterne
# mount /dev/mapper/discexterne /mnt/discexterne

Ensuite pour démonter le partage, faire la commande suivante :

# cd
# umount /mnt/discexterne
# cryptsetup luksClose discexterne

Etant donné que le disque est collé au cul d’un serveur NAS, je n’ai pas d’accès physique à celui-ci, du coup je n’ai pas mis le montage automatique via fstab et crypttab, mais c’est tout à fait possible (je vous laisse fouiller un petit peu sur Google, vous ne devriez pas perdre trop de temps là-dessus je pense) ^_^
Au redémarrage du serveur vous n’aurez donc plus qu’à effectuer les commandes suivantes :

# cryptsetup luksOpen /dev/sdb1 discexterne
# mount /dev/mapper/discexterne /mnt/discexterne

Petite précision, pensez à mettre un mot de passe fort car sinon le chiffrement ne sert à rien (et le notez pas sur un post-it sous le clavier hein…) 🙂

1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
Loading...

[HowTo] Sauvegarder base MySQL avec snapshot LVM

Aller aujourd’hui un petit script pour sauvegarder nos bases de données à chaud sans utiliser l’utilitaire mysqldump (malheureusement gourmand en ressources sur des bases de données MySQL conséquentes).

#!/bin/bash

## VARIABLES ##
USER="usermysql"
PASSWORD="mypassword"
TMPMOUNTPOINT="/snapshot"
VGNAME="vg02"
LVNAME="mysql"
SNAPNAME="snapmysql"

## Check if /backup/mysql.tar.gz exists on the remote server ##
ssh root@remote-server "if [ -e /backup/mysql.tar.gz ] ; then rm -Rf /backup/mysql.tar.gz ; fi"

## Check if temp mount point not used ##
[ `mount | grep "$TMPMOUNTPOINT" | wc -l` -ne 0 ] && exit 1

## FUNCTIONS ##
function log() {
        logger -p local7.info "$1"
}

## BACKUP PROCESS ##
log "Locking databases"
mysql -u$USER -p$PASSWORD << EOF
        FLUSH TABLES WITH READ LOCK;
        system lvcreate -l +100%FREE --snapshot -n $SNAPNAME /dev/$VGNAME/$LVNAME;
        UNLOCK TABLES;
        quit
EOF

log "Databases unlocked"

## TAR AND SEND THROUGH SSH ##
log "Backing up databases"
mount /dev/$VGNAME/$SNAPNAME $TMPMOUNTPOINT
cd $TMPMOUNTPOINT
tar cfvz - --exclude=debian-5.1.flag --exclude=mysql_upgrade_info --exclude=mysql --exclude=phpmyadmin * | ssh root@remote-server "cat > /backup/mysql.tar.gz"
cd
umount $TMPMOUNTPOINT
lvremove -f /dev/$VGNAME/$SNAPNAME
log "Databases backed up"

Les différentes étapes sont les suivantes :

– On vérifie que la sauvegarde n’existe pas déjà sur le serveur distant
– On verrouille les tables MySQL en lecture seule
– On créé un snapshot LVM
– On lève les verrous des tables
– On monte le snapshot sur le dossier /snapshot
– On fait une archive (avec tar) qu’on transfert directement via SSH au serveur distant
– On démonte le point de montage du snapshot
– On supprime le snapshot LVM

Cette astuce est utilisable sur tout système Linux ayant LVM et MySQL installé.

1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
Loading...

Astuces pour optimiser WordPress

Deuxième article du jour pour vous présenter quelques astuces afin d’améliorer les performances de votre site. Pour cela nous allons voir plusieurs choses :

  • Installation d’un plugin
  • Modification du fichier wp-config.php
  • Nettoyage de la base de données

Dans un premier temps voici le nom du plugin à installer : « External Files Optimizer. Il va vous permettre d’agréger l’appel aux différents fichiers externes.

Ensuite, voici une modification à apporter au fichier wp-config.php afin d’éviter que WordPress enregistre toutes les révisions de vos articles :

define('WP_POST_REVISIONS', false);

Et maintenant pour supprimer toutes les révisions déjà en base, connectez-vous à Phpmyadmin, ou avec la méthode que vous préférez afin de supprimer toutes les informations présentent dans la table « posts » :

DELETE
FROM wp_posts
WHERE post_type = 'revision';

Vous gagnerez je l’espère un petit peu en performance avec ces astuces. Et n’oubliez pas pour gagner en performance et en sécurité, pensez à mettre à jour votre site, vos plugins et votre thème. Si vous n’utilisez pas certains plugins ou thèmes, supprimez-les, cela ne sert à rien de les garder.

1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
Loading...

[Supervision] Script pour superviser la mémoire des Linux

Bonjour à tous,

Aujourd’hui je vous propose un script en Perl que j’ai fait afin de superviser la mémoire utilisée réellement sur un serveur Linux (ce script peut aussi bien être utilisé pour superviser des serveurs Debian, Ubuntu, RedHat, CentOS, etc.).

Pourquoi j’ai fait mon propre script? Tout simplement parce que lorsqu’on lance par exemple la commande « top », nous avons la mémoire globale « utilisée » (résultat de la plupart des scripts que j’ai pu trouvé). Cela veut dire qu’il compte aussi bien la mémoire utilisée pour les programmes, pour les buffers mais aussi pour le cache. Ces deux dernières peuvent être libérées si jamais l’OS ou une application en a vraiment besoin.

Vous allez voir, il est tout simple et créé une sortie pour le grapher sur Nagios/Centreon.

#! /usr/bin/perl -w

############################## check_snmp_memory_linux ##############
# Version : 1.0
# Date : Dec 04 2011
#####################################################################
#
# Help : ./check_snmp_memory_linux.pl -h
#

use strict;
use Net::SNMP;
use Getopt::Long;
use POSIX;

# SNMP Datas

my $memory_Total        = ".1.3.6.1.4.1.2021.4.5.0";
my $memory_Free         = ".1.3.6.1.4.1.2021.4.6.0";
my $memory_Buffered     = ".1.3.6.1.4.1.2021.4.14.0";
my $memory_Cached       = ".1.3.6.1.4.1.2021.4.15.0";

# Globals

my $version='1.0';

my $o_host      = undef;        # hostname
my $o_community = undef;        # community
my $o_port      = 161;          # port
my $o_help      = undef;        # wan't some help ?
my $o_version   = undef;        # print version
my $o_version2  = undef;        # use snmp v2c

my %ERRORS=('OK'=>0,'WARNING'=>1,'CRITICAL'=>2,'UNKNOWN'=>3,'DEPENDENT'=>4);

# Variable pour les valeurs de Mem

my $memUsed     = undef;
my $memFree     = undef;
my $memBuffered = undef;
my $memCached   = undef;
my $memTotal    = undef;
my $percentMem  = undef;

my $memUsedOctets = undef;
my $memUsedGOctets = undef;
my $memFreeOctets = undef;
my $memCachedOctets = undef;
my $memBufferedOctets = undef;
my $memTotalOctets = undef;
my $memTotalGOctets = undef;

my $resultat    = undef;
my $c_output    = undef;
my $c_status    = undef;

my $warn_value  = 95;
my $crit_value  = 98;

# Functions

sub p_version {
        print "check_snmp_memory_linux version : $version\n";
}

sub print_usage {
        print "Usage: $0 -H <host> -C <snmp_community> [-2] [-p <port>]\n\n";
}

sub help {
   print "\nSNMP Memory Linux Monitor for Nagios version ",$version,"\n";
   print_usage();
   print <<EOT;
-h, --help
        print this help message
-H, --hostname=HOST
        name or IP address of host to check
-C, --community=COMMUNITY NAME
        community name for the host's SNMP agent (implies SNMP v1 or v2c with option)
-2, --v2c
        Use snmp v2c
-P, --port=PORT
        SNMP port (Default 161)
-V, --version
        prints version number
EOT

}

sub check_options {
        Getopt::Long::Configure ("bundling");

        GetOptions(
                'h'     => \$o_help,            'help'          => \$o_help,
                'H:s'   => \$o_host,            'hostname:s'    => \$o_host,
                'p:i'   => \$o_port,            'port:i'        => \$o_port,
                'C:s'   => \$o_community,       'community:s'   => \$o_community,
                'V'     => \$o_version,         'version'       => \$o_version,
                '2'     => \$o_version2,        'v2c'           => \$o_version2
        );
        if ( defined ($o_help) ) {
                help();
                exit $ERRORS{"UNKNOWN"};
        };

        if ( defined($o_version) ) {
                p_version();
                exit $ERRORS{"UNKNOWN"};
        };

        if ( ! defined($o_host) ) { # check host and filter
                print "No host defined!\n";
                print_usage();
                exit $ERRORS{"UNKNOWN"};
        };

        # Check Snmp Information
        if ( ! defined($o_community) ) {
                print "No community defined!\n";
                print_usage();
                exit $ERRORS{"UNKNOWN"};
        }
}

########## MAIN #######

check_options();

# Connection to host
my ($session,$error);
if ( defined ($o_version2) ) {
        # SNMPv2 Login
        ($session, $error) = Net::SNMP->session(
                -hostname  => $o_host,
                -version   => 2,
                -community => $o_community,
                -port      => $o_port
        );
} else {
        # SNMPV1 login
        ($session, $error) = Net::SNMP->session(
                -hostname  => $o_host,
                -community => $o_community,
                -port      => $o_port
        );
}
if ( !defined($session) ) {
        printf("ERROR opening session: %s.\n", $error);
        exit $ERRORS{"UNKNOWN"};
}


$resultat       = $session->get_request($memory_Total);
$memTotal       = $resultat->{$memory_Total};

$resultat       = $session->get_request($memory_Free);
$memFree        = $resultat->{$memory_Free};

$resultat       = $session->get_request($memory_Buffered);
$memBuffered    = $resultat->{$memory_Buffered};

$resultat       = $session->get_request($memory_Cached);
$memCached      = $resultat->{$memory_Cached};

$memUsed = $memTotal - ( $memFree + $memBuffered + $memCached );

$memUsedOctets = $memUsed * 1024;
$memUsedGOctets = $memUsed / 1048576;
$memUsedGOctets = sprintf("%.2f", $memUsedGOctets);
$memTotalOctets = $memTotal * 1024;
$memTotalGOctets = $memTotal / 1048576;
$memTotalGOctets = sprintf("%.2f", $memTotalGOctets);
$memCachedOctets = $memCached * 1024;
$memBufferedOctets = $memBuffered * 1024;
$memFreeOctets = $memFree * 1024;
$percentMem = floor(( $memUsed / $memTotal ) * 100);

if ( $percentMem < $warn_value ) {
        $c_output       = "OK - La memoire est utilisee a ".$percentMem."%. Il y a ".$memUsedGOctets." Go d'utilisee sur ".$memTotalGOctets." Go. | Mem_Totale=".$
memTotalOctets."o; Mem_Used=".$memUsedOctets."o; Mem_Buffered=".$memBufferedOctets."o; Mem_Cached=".$memCachedOctets."o; Mem_Free=".$memFreeOctets."o";        $c_status       = "OK";
}
elsif ( ($percentMem >= $warn_value) && ($percentMem < $crit_value) ) {
        $c_output       = "WARNING - La memoire est utilisee a ".$percentMem."%. Il y a ".$memUsedGOctets." Go d'utilisee sur ".$memTotalGOctets." Go. | Mem_Total
e="
.$memTotalOctets."o; Mem_Used=".$memUsedOctets."o; Mem_Buffered=".$memBufferedOctets."o; Mem_Cached=".$memCachedOctets."o; Mem_Free=".$memFreeOctets."o";        $c_status       = "WARNING";
}
elsif ( $percentMem >= $crit_value ) {
        $c_output       = "CRITICAL - La memoire est utilisee a ".$percentMem."%. Il y a ".$memUsedGOctets." Go d'utilisee sur ".$memTotalGOctets." Go. | Mem_Tota
le="
.$memTotalOctets."o; Mem_Used=".$memUsedOctets."o; Mem_Buffered=".$memBufferedOctets."o; Mem_Cached=".$memCachedOctets."o; Mem_Free=".$memFreeOctets."o";
        $c_status       = "CRITICAL";
}

$session->close;
print "$c_output \n";
exit $ERRORS{$c_status};

Ce script permet de récupérer les mêmes valeurs que la commande suivante :

$ free -m

1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
Loading...

Astuces en vrac (4)

Aujourd’hui, un nouveau petit mémo concernant 2 requêtes SQL pour récupérer des informations intéressantes sur votre supervision. Et un autre pour contrôler la synchronisation de votre serveur de temps.

La première requête permet de récupérer l’adresse IP/Nom DNS et le nom de tous les serveurs supervisés par un poller. Pour cela, il suffit juste d’exécuter la requête suivante sur la base Centreon :

SELECT host_name AS Name, host_address AS Adresse
FROM `host`, `ns_host_relation`, `nagios_server`
WHERE ns_host_relation.host_host_id=host.host_id
AND ns_host_relation.nagios_server_id=nagios_server.id
AND nagios_server.name='mypoller'
ORDER BY host_name;

Continuer la lecture de Astuces en vrac (4) 

Interdire l’accès à Phpmyadmin depuis l’extérieur

Aujourd’hui, un petit mémo rapide pour configurer Phpmyadmin en interdisant son accès depuis l’extérieur ou depuis tout autre réseau que celui de votre LAN

Pour cela, il suffit juste de modifier le fichier /etc/apache2/conf.d/phpmyadmin.conf par les lignes 4, 5 et 6 :

<Directory /usr/share/phpmyadmin>
        Options FollowSymLinks
        DirectoryIndex index.php
        Order Deny,Allow
        Allow from 192.168.1.0/24
        Deny from All

        <IfModule mod_php5.c>
                AddType application/x-httpd-php .php

                php_flag magic_quotes_gpc Off
                php_flag track_vars On
                php_flag register_globals Off
                php_admin_flag allow_url_fopen Off
                php_value include_path .
                php_admin_value upload_tmp_dir /var/lib/phpmyadmin/tmp
                php_admin_value open_basedir /usr/share/phpmyadmin/:/etc/phpmyadmin/:/var/lib/phpmyadmin/
        </IfModule>

</Directory>

Cela signifie qu’on interdit tout autre personne que ceux du réseau local 192.168.1.0/24 à accéder à la page Phpmyadmin.

1 Star2 Stars3 Stars4 Stars5 Stars (3 votes, average: 3,67 out of 5)
Loading...

[HowTo] Installation d’un serveur DLNA sous Ubuntu Server avec Ushare

Bonjour à tous,

Aujourd’hui, je vais présenter l’installation d’un serveur DLNA sous Ubuntu Server (également disponible sous Debian bien sûr). Un serveur DLNA permet de partager du contenu numérique (intéressant pour le décodeur TV de votre Box Internet par exemple)

Installation du serveur :

$ apt-get install ushare

Continuer la lecture de [HowTo] Installation d’un serveur DLNA sous Ubuntu Server avec Ushare 

[HowTo] Surveillance de ses disques avec S.M.A.R.T.

Bonjour à tous,

Aujourd’hui, nous allons nous intéresser à la surveillance de nos précieux disques durs. Ils sont de plus en plus importants car ils contiennent un tas d’informations « vitales » : photos, videos, musiques, papiers, etc. Ca pourrait être sympa si nous pouvions connaitre l’état de santé de nos disques et être prévenu quand ils commencent à ne plus tourner rond 🙂

Pour surveiller cela, nous allons utiliser le démon S.M.A.R.T. Il faut installer :

$ apt-get install smartmontools

Continuer la lecture de [HowTo] Surveillance de ses disques avec S.M.A.R.T.