Mettre à jour Kaspersky sous Kwartz

Kaspersky est largement utilisé dans les réseaux pédagogiques de l’académie de Lille et quoique gourmand en ressources mémoire il s’avère très efficace en terme de sécurité. Mais attention pourtant, faire une installation par défaut et laisser chaque postes de vos salles pupitres récupérer sa propre version de mise à jour quotidienne des définitions de virus, risque de sérieusement encombrer la bande passante de votre établissement. Heureusement Kasperky offre la possibilité de récupérer ces définitions de virus localement ou depuis un partage réseau …

Et qui d’autre de mieux placé que votre serveur Kwartz pour récupérer cette mise à jour ? humm ?! Bien évidemment ce script est aisément transposable sous d’autres systèmes Linux !

Commençons …

Alors soyons clair, je ne vais pas ici vous faire un cour détaillé sur le shell bash, je vais juste vous donner les quelques pistes pour mieux comprendre ce script et le configurer par vous même selon vos préférences et les spécifications de votre établissement.

Avant de vous lancer dans l’écriture du script jeter un oeil à l’article écrire en shell sous Windows histoire d’éviter les écueils

#!/bin/bash
############################################################
# SCRIPT DE MISE A JOUR DES DEFINITIONS DE VIRUS KASPERSKY #
############################################################

Explications : La première ligne « prévient » le système que le langage utilisé est en bash et détermine la localisation de son interpréteur.
La suite c’est juste une fioriture, histoire de mettre un titre à votre script

Répertoires de stockage

#PARAMETRES DE CONFIGURATION (personnalisables)
#---------------------------------------------
#    =>CHEMINS ET FICHIERS
#        //Répertoires d'exécution
 path="/home/kwartz/Programmes/KASPERSKY/"; #Repertoire racine ( contient le script )
 cpath=${path}"cache/"; #Repertoire de stockage des archives téléchargés
 dpath=${path}"definitions/"; #Repertoire de stockage des fichiers de dépôt des définitions
 lpath=${path}"logs/"; #Repertoire de stockage des fichiers de journalisation du script
#        //Liste des fichiers à nettoyer dans le repertoire de dépôt des définitions
#          (séparés par des espaces - recommandation : ne pas modifier)
 old_files=" avc cfg dll dt ini klb lst mhk vnd set txt xml ";

Explications : Ces éléments de configuration sont personnalisables, j’ai opté pour une installation du script dans le partage Programmes du serveur Kwartz puisque le script sera exécuté par l’utilisateur winadmin.  Il est « seul » à posséder les droits en écritures dans ce répertoire, ce qui évite qu’un petit malin vienne vous supprimer vos fichiers.

Miroir mon beau miroir …

#    =>MIROIRS ET CONFIG DE CHARGEMENT
miror[0]="http://dnl-eu8.kaspersky-labs.com/zips/"; #Miroir France
miror[1]="http://dnl-eu9.kaspersky-labs.com/zips/"; #Miroir France
miror[2]="http://dnl-eu7.kaspersky-labs.com/zips/"; #Miroir Belgique
miror[3]="http://dnl-eu5.kaspersky-labs.com/zips/"; #Miroir Belgique
miror[4]="http://dnl-eu6.kaspersky-labs.com/zips/"; #Miroir Belgique
miror[5]="http://dnl-us9.kaspersky-labs.com/zips/"; #Miroir Etats-Unis
miror[6]="http://dnl-us5.kaspersky-labs.com/zips/"; #Miroir Etats-Unis
miror[7]="http://dnl-eu10.kaspersky-labs.com/zips/";#Miroir Estonie
#miror[8]="http://dnl-pr1.kaspersky-labs.com/zips/";#Miroir Russie
#        //Liste des archives à récupérer sur le site de Kaspersky (recommandation : ne pas modifier)
archives[0]="av-i386-cumul.zip";
archives[1]="av-i386-weekly.zip";
archives[2]="av-i386-daily.zip";
#        //Configuration du téléchargement
attempt=2; #tentative par miroir (defaut 2)
waiting=10; #temps d'attente avant d'annuler une tentative sans réponse
            #( defaut 10 secondes / mettre à 30 pour une connexion lente type 56ko/s)

Explications : Dans la première partie on renseigne tous les miroirs de téléchargements où le script ira chercher les archives contenant les définitions de virus (miror[n]). Vous pouvez changer l’ordre des priorités en changeant la numérotation, attention cela dit à démarrer de 0, qu’ils se suivent et à ne pas mettre plusieurs fois le même numéro. Pour désactiver un miroir, il suffit de commenter la ligne en ajoutant un « # » (Cf. l.10 : #miror[8] …). Il est également possible d’ajouter vos propres miroirs.

Les variables archives[n] sont les trois archives de définitions récupérés par le script, il est recommandé de ne pas modifier ces paramètres.

attempt correspond au nombre de tentatives effectué par miroir en cas d’échec

waiting est le temps d’attente sans réponses avant de considérer en échec une tentative de connexion au miroir

Numéro de version et temporisation

#    =>VERSION D'EXECUTION DU SCRIPT (!!ne pas modifier!!)
     version=$(date +%d-%m-%Y);
     time=$(date +%Hh%M);
#        //Jour du mois pour effectuer la mise à jour cumulative
monthly_day="01";
#        //Jour de la semaine pour effectuer la mise à jour hebdomadaire
weekly_day="0";

Explications : version et time servent à nommer les fichiers et renseigner la journalisation, ne changez pas ces paramètres …
En revanche monthly_day permet de choisir le jour du mois pour faire la mise à jour cumulatives (jour à 2 chiffres => le 01 par defaut).

De même weekly_day permet de définir le jour de la semaine quand faire la Maj hebdomadaire (0:dimanche , 1:lundi, …, 6:samedi => 0 par defaut)

Journalisation des mises à jour

#    =>FICHIERS DE LOG ( Récupération des infos de mise à jour)
#        //Nom des fichiers
suffix="upddef.log" #suffixe des fichiers de log
detail="${version}_${time}_${suffix}"; #nom du fichier inclus l'heure et la date
log="${version}_${suffix}"; #nom du fichier inclus la date
#        //Texte de séparation des éléments des blocs d'informations
#          (doit toujours commencer par un # ou simplement un retour chariot: \r)
separator="#---------------------------------#\r";
#        //Entête des fichiers de log
header="#\tMISE A JOUR DES DEFINITIONS DE KASPERSKY DU ${version}\t#\r\r";
#        //Durée de conservation des logs (en jours)
cache="3";

#    =>MAIL
#        //Envoie du fichier de log par mail (defaut : `true` mettre à `false` si vous ne souhaitez pas envoyer le fichier de log par mail)
sendmail=true;
#        //destinataires du mail ( separés par des espaces ex: " winadmin gates.bill steve.jobs tovald.linus@tux.fr " les mails vers les comptes exterieurs ne fonctionneront que si votre smtp kwartz est configuré  )
to=" winadmin ";
<pre>

Explications : Cette fonctionnalité va vous permettre de journaliser les mises à jour dans un fichier texte et le cas échéant d’identifier les problèmes

Le gros morceau qui va bien

#################################################################################################################################

#ETAPE 1 : ENVOIE PAR MAIL DU LOG DE LA VEILLE (facultatif)
#-----------------------------------------------------------------------------
yesterday=$(date -d "-1 day" +%d-%m-%Y);
if ${sendmail}  && [ -e ${lpath}${yesterday}_${suffix} ]  && ! [ -e ${cpath}${version}_mail.cache ]
then cat ${lpath}${yesterday}_${suffix} | mail -s "mise à jour de kaspersky ${yesterday}" ${to}
touch ${cpath}${version}_mail.cache;
fi

#ETAPE 2 : TEST D'ECRITURE ET CREATION DE L'ARBORESCENCE DES REPERTOIRES
#--------------------------------------------------------------------------------------------------------
if ! [ -e ${path} ]; then echo "ATTENTION - Le dossier ${path} n'existe pas - FIN D'EXECUTION DU SCRIPT"; exit; fi #Test d'existance du dossier racine (echec=> arrêt du script)
if ! [ -w  ${path} ]; then echo "ATTENTION - Le dossier ${path} n'est pas inscriptible - FIN D'EXECUTION DU SCRIPT "; exit; fi #Test d'écriture du dossier racine (echec=> arrêt du script)
[ -e ${cpath} ] || mkdir ${cpath}; #Création du répertoire de stockage des archives téléchargés
if ! [ -w  ${cpath} ]; then echo "ATTENTION - Le dossier ${cpath} n'est pas inscriptible - FIN D'EXECUTION DU SCRIPT"; exit; fi #Test d'écriture du dossier de cache (echec=> arrêt du script)
[ -e ${dpath} ] || mkdir ${dpath}; #Création du répertoire des fichiers de définitions
if ! [ -w ${dpath} ]; then echo "ATTENTION - Le dossier ${dpath} n'est pas inscriptible - FIN D'EXECUTION DU SCRIPT"; exit; fi #Test d'écriture du dossier de définitions (echec=> arrêt du script)
[ -e ${lpath} ] || mkdir ${lpath}; #Création du répertoire de log
if ! [ -w  ${lpath} ]; then echo "ATTENTION - Le dossier ${lpath} n'est pas inscriptible - FIN D'EXECUTION DU SCRIPT"; exit; fi #Test d'écriture du dossier de log (echec=> arrêt du script)

#ETAPE 3 : INITIALISATION DES FICHIERS DE LOG
#----------------------------------------------------------------
#Detail
touch ${lpath}${detail}; #Création du fichier de détail
echo -e "${header} ${time}\r"  > ${lpath}${detail}; #Entête du fichier de détail
#Log Global
if (!(test -e ${lpath}${log})) then touch ${lpath}${log}; echo -e "${header}\r"  > ${lpath}${log}; fi #Si le fichier de log n'existe pas on le crée, et on inscrit l'entête
if (!(test -w ${lpath}${log})) then echo "ATTENTION - Le fichier de log n'est pas inscriptible - FIN D'EXECUTION DU SCRIPT "; exit; fi #Si le fichier de log n'est pas incriptible, on arrête l'exécution du script

#ETAPE 4 : NETTOYAGE  (Ne met pas en échec l'exécution du script)
#------------------------------------------------------------------------------
echo -e ${separator} >> ${lpath}${detail}
echo -e "\tNETTOYAGE\r\r" >> ${lpath}${detail}
#Nettoyage des anciens fichiers de définitions ( Une fois par mois lors du chargement du Cumul, puisque les fichiers inclus au Cumul sont necessaires pour toute éventuelle nouvelle installation de Kaspersky sur un client )
if [ "$(date +%d)" != "${monthly_day}" ] || [ -e "${cpath}${version}_cleaning-definitions.cache" ]
then echo -e "Pas de nettoyage des définitions programmé\r" >> ${lpath}${detail};
else
echo -e "\t\tPurge des anciennes définitions\r" >> ${lpath}${detail}
for old_file in ${old_files}
do
rm ${dpath}*.${old_file} && echo -e "fichiers ${old_file} effacés dans ${dpath}\r" >> ${lpath}${detail} || echo -e "aucun fichier ${old_file} a effacer dans ${dpath}\r" >> ${lpath}${detail};
done
touch "${cpath}${version}_cleaning-definitions.cache";
fi
#Nettoyage des anciens fichiers d'archives et possibles téléchargements incomplets
echo -e "\t\tPurge des archives\r" >> ${lpath}${detail}
i=0
while [ $i -lt ${#archives[*]} ]
do
rm ${cpath}${archives[$i]}* && echo -e "tous les anciens fichiers d'archives de type ${archives[$i]} ont été supprimés dans ${cpath}\r" >> ${lpath}${detail} || echo -e "pas de fichiers d'archives de type ${archives[$i]} a supprimer\r" >> ${lpath}${detail};
((i++));
done
#Nettoyage des anciens fichiers log et des anciens fichiers de cache
limit=$(date -d "$cache days ago" +%y-%m-%d);
buffer=$(date -d "$limit -7 days" +%y-%m-%d); #Le tampon sert a effacer tous les fichiers une semaine avant le cache (=>sécurité supplémentaire)
while [ $buffer != ${limit} ]
do
rm -f ${lpath}$(date -d "${buffer}" +%d-%m-%Y)*.log;
rm -f ${cpath}$(date -d "${buffer}" +%d-%m-%Y)*.cache;
buffer=$(date -d "$buffer +1 day" +%y-%m-%d);
done
#ETAPE 5 : CHARGEMENT ET DECOMPRESSION DES ARCHIVES  (CUMUL, WEEKLY, DAILY)
#-----------------------------------------------------------------------------------------------------------
echo -e ${separator} >> ${lpath}${detail}
echo -e "\tCHARGEMENT ET DECOMPRESSION DES ARCHIVES\r\r" >> ${lpath}${detail}

#    =>TEST DES ARCHIVES A RECUPERER
#        //DEFINITIONS CUMULATIVES (Cumul)
if [ "$(date +%d)" != "${monthly_day}" ]
then echo -e "Pas de mise à jour mensuel aujourd'hui\r" >> ${lpath}${detail};
unset archives[0]; #Annulation de la récupération de l'archive de Cumul
else
if [ -e "${cpath}${version}_${archives[0]}.cache" ]
then echo -e "Mise à jour mensuel déjà récupérée aujourd'hui\r" >> ${lpath}${detail};
unset archives[0]; #Annulation de la récupération de l'archive de Cumul
fi
fi
#        //DEFINITIONS HEBDOMADAIRE(Weekly)
if [ "$(date +%w)" != "${weekly_day}" ]
then echo -e "Pas de mise à jour hebdomadaire aujourd'hui\r" >> ${lpath}${detail};
unset archives[1]; #Annulation de la récupération de l'archive de Weekly
else
if [ -e "${cpath}${version}_${archives[1]}.cache" ]
then echo -e "Mise à jour hebdomadaire déjà récupérée aujourd'hui\r" >> ${lpath}${detail};
unset archives[1]; #Annulation de la récupération de l'archive de Weekly
fi
fi

#    =>TRAITEMENT DES ARCHIVES A RECUPERER
for archive in ${archives[@]} #Traitement de chaque archive de définition
do
echo -e "\r\tTraitement des définitions de ${archive}\r">> ${lpath}${detail}
#        //CHARGEMENT
i=0;
while [ $i -lt ${#miror[*]} ] #Test de chaque miroir de téléchargement
do
if wget -t ${attempt} -T ${waiting} -P${cpath} ${miror[$i]}${archive} #Test de chargement de l'archive de définitions
then echo -e "Chargement du dernier fichier ${archive} sur ${miror[$i]}: réussi\r" >> ${lpath}${detail}; i=${#miror[*]}; dl=true; #Chargement réussi
else
echo -e "chargement du fichier ${archive} sur ${miror[$i]} : échec\r" >> ${lpath}${detail}; ((i++));# Si la tentative de chargement renvoie un échec on test sur le miroir suivant
fi #Fin de test de chargement de l'archive de définitions
done #Fin de test de chaque miroir de téléchargement
if [ -z "${dl}" ]
then echo -e "Impossible de charger le fichier de définition ${archive}\r" >> ${lpath}${detail}; #Toutes les tentatives sur tous les miroirs ont échoué
fi
#        //DECOMPRESSION
if ${dl} && unzip -o -q -d ${dpath} ${cpath}${archive} #Test de décompression de l'archive chargé et écrasement des anciennes versions de définitions
then touch ${cpath}${version}_${archive}.cache ;
echo -e "décompression du dernier fichier ${archive} dans ${dpath} : réussi\r" >> ${lpath}${detail}; dzip=true;#Décompression Réussie
else
echo -e "impossible de décompresser le dernier fichier ${archive} dans ${dpath}\r" >> ${lpath}${detail}; ((i++));#Problème de décompression on passe au miroir suivant
fi #Fin de test de décompression de l'archive chargé
done #Fin de traitement de chaque archive de définition

#ETAPE 6 : ECRITURE DU RESULTAT DE MISE A JOUR DANS LE FICHIER DE LOG
#-------------------------------------------------------------------------------------------------
#Resultat de la mise à jour
echo -e ${separator} >> ${lpath}${log}
if ${dl} && ${dzip}
then echo -e "Mise à jour du ${version} à ${time} : ok\r" >> ${lpath}${log};
else
echo -e "Mise à jour du ${version} à ${time} : échec\r" >> ${lpath}${log};
fi
exit;

Amateur de scripts et autres boucles, régale toi. Faire un descriptif exhaustif du script serait bien inutile et pas vraiment digne d’intérêt. Il est en plus déjà largement commentés.
Enfin sans être parfait il est toutefois fonctionnel puisque testé en conditions réelles.

La p’tite touche qui ferait plaisir…

#############################################################
# par Jordy  Manner
# (cherche un emploi - contact : http://www.milkcreation.fr )
#############################################################

Facultatif mais si vous faites tourner le script soyez sympa de le rajouter, ça mange pas de pain et ça sauvera un informaticien pâtophobe !

Pour terminer vous pouvez télécharger le script update.sh

Quand à l’installation du script via un cron sur Kwartz, elle est largement détaillé dans les procédures d’installations de Kaspersky sur les sites des BAIP et de la CANTE :

http://baip.fr/nicolas/kaspersky/

http://www3.ac-lille.fr/crid-systeme/download/antivirus/kaspersky-kwartz.pdf

La procédure est la même sauf que vous n’avez qu’un script à installer au lieu de trois.

You can leave a response, or trackback from your own site.

Leave a Reply