forked from decalage2/exefilter
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Fichier.py
621 lines (565 loc) · 30.6 KB
/
Fichier.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
#!/usr/bin/python
# -*- coding: iso-8859-1 -*-
"""
Fichier - ExeFilter
Module qui contient la classe L{Fichier.Fichier}, pour representer un fichier a
analyser.
Ce fichier fait partie du projet ExeFilter.
URL du projet: U{http://www.decalage.info/exefilter}
@organization: DGA/CELAR
@author: U{Philippe Lagadec<mailto:philippe.lagadec(a)laposte.net>}
@author: U{Arnaud Kerréneur<mailto:arnaud.kerreneur(a)dga.defense.gouv.fr>}
@contact: U{Philippe Lagadec<mailto:philippe.lagadec(a)laposte.net>}
@copyright: DGA/CELAR 2004-2008
@copyright: NATO/NC3A 2008-2010 (PL changes after ExeFilter v1.1.0)
@license: CeCILL (open-source compatible GPL) - cf. code source ou fichier LICENCE.txt joint
@version: 1.05
@status: beta
"""
#==============================================================================
__docformat__ = 'epytext en'
__date__ = "2010-04-20"
__version__ = "1.05"
#------------------------------------------------------------------------------
# LICENCE pour le projet ExeFilter:
# Copyright DGA/CELAR 2004-2008
# Copyright NATO/NC3A 2008-2010 (PL changes after ExeFilter v1.1.0)
# Auteurs:
# - Philippe Lagadec (PL) - philippe.lagadec(a)laposte.net
# - Arnaud Kerréneur (AK) - arnaud.kerreneur(a)dga.defense.gouv.fr
# - Tanguy Vinceleux (TV) - tanguy.vinceleux(a)dga.defense.gouv.fr
#
# Ce logiciel est régi par la licence CeCILL soumise au droit français et
# respectant les principes de diffusion des logiciels libres. Vous pouvez
# utiliser, modifier et/ou redistribuer ce programme sous les conditions
# de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA
# sur le site "http://www.cecill.info". Une copie de cette licence est jointe
# dans les fichiers Licence_CeCILL_V2-fr.html et Licence_CeCILL_V2-en.html.
#
# En contrepartie de l'accessibilité au code source et des droits de copie,
# de modification et de redistribution accordés par cette licence, il n'est
# offert aux utilisateurs qu'une garantie limitée. Pour les mêmes raisons,
# seule une responsabilité restreinte pèse sur l'auteur du programme, le
# titulaire des droits patrimoniaux et les concédants successifs.
#
# A cet égard l'attention de l'utilisateur est attirée sur les risques
# associés au chargement, à l'utilisation, à la modification et/ou au
# développement et à la reproduction du logiciel par l'utilisateur étant
# donné sa spécificité de logiciel libre, qui peut le rendre complexe à
# manipuler et qui le réserve donc à des développeurs et des professionnels
# avertis possédant des connaissances informatiques approfondies. Les
# utilisateurs sont donc invités à charger et tester l'adéquation du
# logiciel à leurs besoins dans des conditions permettant d'assurer la
# sécurité de leurs systèmes et ou de leurs données et, plus généralement,
# à l'utiliser et l'exploiter dans les mêmes conditions de sécurité.
#
# Le fait que vous puissiez accéder à cet en-tête signifie que vous avez
# pris connaissance de la licence CeCILL, et que vous en avez accepté les
# termes.
#------------------------------------------------------------------------------
# HISTORIQUE:
# 24/10/2004 v0.01 PL: - 1ère version
# 22/12/2004 PL: - séparation dans un module indépendant
# 2004-2007 PL,AK: - nombreuses évolutions
# - contributions de Y. Bidan
# 12/01/2007 v1.00 PL: - version 1.00 officielle
# 2007-09-20 v1.01 PL: - licence CeCILL
# 2007-10-10 PL: - ajout support antivirus ClamAV (clamd)
# 2007-10-22 PL: - ajout support antivirus F-Prot 6 (fpscan)
# 2007-10-28 PL: - ajout Fichier.remplacer_copie_temp()
# 2008-03-24 v1.02 PL: - ajout de _() pour traduction gettext des chaines
# 2010-02-07 v1.03 PL: - removed path module import
# 2010-02-23 v1.04 PL: - updated pyclamd import
# 2010-04-20 v1.05 PL: - added force_extension param to Fichier.__init__
#------------------------------------------------------------------------------
# A FAIRE:
# + antivirus_*: ne pas renvoyer None
# + antivirus_clamd: verif rapport en cas de detection virus
# + antivirus_fpcmd: ajouter codes supérieurs à 8 ? (cf. doc sur site F-Prot)
# + corriger journalisation et debug
# + vérifier que tous les cas d'exceptions sont bien gérés
# EVOLUTIONS ENVISAGEES:
# - portabilité à améliorer: gérer F-Prot sous Linux/BSD
# => classe générique antivirus ? Voire possibilité de combiner plusieurs
# antivirus ?
# ? séparer nettoyer() en sous-fonctions pour améliorer la lisibilité ?
# ? optimiser lire_debut() pour ne lire qu'une fois le buffer ? (cf. notes)
# ? antivirus: paramètres pour choisir si on scanne systématiquement tous
# les fichiers pour avoir des stats précises du nombre de virus, dans ce cas
# il faudrait le faire avant les filtres de nettoyage (mauvais pour les
# performances), et si on veut scanner tous les types de fichier (option
# "-collect" pour F-Prot) ou bien laisser décider l'antivirus s'il veut
# scanner (option "-type", meilleures perfos mais risque de rater des
# fichiers COM infectés renommés comme eicar.txt => risque acceptable ?)
# ? antivirus: prendre en compte un antivirus local "on-access" qui peut
# empecher l'acces a un fichier (en lecture et/ou en ecriture), au lieu de
# lancer un antivirus en ligne de commande. => Situation typique sous Windows.
#------------------------------------------------------------------------------
#=== IMPORTS ==================================================================
# modules standards Python
import traceback, sys, zipfile, socket, os, os.path
import subprocess
# modules du projet:
from commun import *
import Resultat, Journal, Rapport, Politique
# module pyclamd pour utiliser l'antivirus ClamAV (daemon clamd)
try:
import thirdparty.pyclamd.pyclamd as pyclamd
except:
raise ImportError, "missing pyclamd module: "\
"see http://www.decalage.info/en/python/pyclamd"
#=== CONSTANTES ===============================================================
TAILLE_BUFFER_DEBUT = 4096 # taille du buffer pour l'analyse du début de fichier
# codes retournés par F-Prot 6 / fpscan (champ de bits):
# (http://www.f-prot.com/support/windows/fpwin_faq/fpscan.html)
# 0: All clean.
# 1: At least one virus-infected object was found and remains.
# 2: At least one suspicious object was found and remains.
# 4: Scanning was aborted by user before it finished; nothing
# found so far.
# 8: Some imposed restrictions were reached causing the scanner
# to skip files (maximum depth of directories, maximum depth
# of archives, exclusion list, etc).
# 16: Some platform error occurred e.g. I/O errors, insufficient
# privileges, out of memory, etc.
# 32: Internal engine error occurred (whatever the engine fails
# at).
# 64: At least one object was not scanned (encrypted file,
# unsupported/unknown compression method, corrupted or invalid
# file).
# 128: At least one object was disinfected.
# NOTE: on considere le resultat "desinfection" comme un virus detecte:
FPSCAN_INFECTION = 1 + 2 + 128
FPSCAN_ERROR = 4 + 8 + 16 + 32 + 64
#=== CLASSES ==================================================================
#------------------------------------------------------------------------------
# classe FICHIER
#-------------------
class Fichier:
"""
classe stockant les informations sur un fichier a analyser.
Un objet Fichier correspond à un fichier à nettoyer.
Attributs d'un objet Fichier:
- chemin: objet L{path} correspondant au chemin relatif du fichier dans son conteneur.
- chemin_complet: chemin complet du fichier (incluant le(s) conteneur(s)), objet L{path}.
- nom: chaîne (unicode) correspondant au nom du fichier, sans son chemin.
- extension: chaîne (unicode) correspondant à l'extension du fichier, convertie en minuscules.
- conteneur: conteneur qui contient le fichier.
- resultat_fichier: objet L{Resultat} qui liste les résultats des filtres appliqués sur le fichier.
"""
def __init__(self, nom_fichier, conteneur, force_extension=None):
"""Constructeur de la classe Fichier.
@param nom_fichier : nom du fichier, chemin relatif par rapport à la racine du conteneur.
@type nom_fichier : str, unicode
@param conteneur : objet Conteneur qui contient le fichier
@type conteneur : L{Conteneur.Conteneur}
@param force_extension: if set, force filename extension to a specific value
(used to control which filters are applied)
Note: force_extension may be "" or must start with a dot
@type force_extension: str, unicode
"""
# on vérifie si le nom de fichier fourni est bien un chemin relatif par
# rapport au conteneur:
if chemin_relatif_incorrect(nom_fichier):
debug(_(u"chemin relatif incorrect: %s") % nom_fichier)
raise ValueError, _(u"Nom de fichier non relatif ou incorrect")
self.chemin = path(nom_fichier)
# on construit le chemin absolu à partir de celui du conteneur:
if conteneur.chemin_complet == "":
# le fichier est dans le conteneur racine: chemin direct
self.chemin_complet = self.chemin
else:
self.chemin_complet = conteneur.chemin_complet / self.chemin
self.nom = self.chemin.name
# on extrait l'extension du fichier, convertie en minuscules
# pour permettre une comparaison correcte:
# unless force_extension is used
if force_extension is not None:
# check if it starts with a dot or if it's empty:
assert force_extension.startswith('.') or force_extension==''
self.extension = force_extension
else:
self.extension = self.chemin.ext.lower()
self.buffer_debut = ""
self.fich_ouvert = None
self._copie_temp = None # chemin vers une copie temporaire du fichier
self.conteneur = conteneur # conteneur du fichier
self.resultat_fichier = Resultat.Resultat(fichier=self)
def copie_temp (self):
"""copie le fichier vers un répertoire temporaire si cela n'a
pas déjà été fait, grâce au conteneur, et retourne le chemin
de la copie."""
if self._copie_temp != None:
# deja fait
return self._copie_temp
else:
self._copie_temp = self.conteneur.copie_temp(self)
return self._copie_temp
def rejeter (self):
"""lorsqu'un fichier doit être rejeté, supprime la copie
temporaire du fichier si elle existe."""
try:
if self._copie_temp != None and self._copie_temp.exists():
self._copie_temp.remove()
except:
#TODO: mieux gerer exception ?
Journal.exception(_(u'Impossible de supprimer un fichier temporaire: %s') % self._copie_temp)
def remplacer_copie_temp (self, nouveau_fichier):
"""
Pour remplacer la copie temporaire du fichier par une nouvelle
version nettoyee. Les deux fichiers doivent etre sur le meme disque
pour permettre un simple renommage.
Doit etre utilise par tout filtre qui modifie un fichier.
"""
# on modifie la date du nouveau fichier pour correspondre à
# celle d'origine:
date_fich = os.path.getmtime(self._copie_temp)
os.utime(nouveau_fichier, (date_fich, date_fich))
# on remplace la copie temporaire du fichier d'origine par
# la version nettoyée:
# NOTE: sous Windows on est obligé d'effacer d'abord le fichier
# d'origine, alors que sous Unix il serait simplement écrasé
self._copie_temp.remove()
os.rename(nouveau_fichier, self._copie_temp)
def lire_debut (self):
"""lit le début du fichier et retourne le résultat dans une chaîne.
Le nombre d'octets lus est fixé par la constante TAILLE_BUFFER_DEBUT."""
# on crée d'abord une copie temporaire du fichier, car celui-ci
# peut être dans un conteneur
self.copie_temp()
# puis on lit le début du fichier dans le buffer.
# NOTE: le mode 'rb' est nécessaire pour lire en mode binaire,
# sinon on lit en mode texte et les fins de lignes peuvent
# être converties, ce qui modifie le fichier.
# NOTE: on relit à chaque appel le début du fichier, car un autre
# filtre peut l'avoir modifié depuis la 1ère lecture.
# On pourrait améliorer un peu les perfos en utilisant un
# flag qui indique si le fichier a été effectivement modifié.
f = file(self._copie_temp, 'rb')
self.buffer_debut = f.read(TAILLE_BUFFER_DEBUT)
f.close()
return self.buffer_debut
def nettoyer (self, politique):
"""Nettoie un fichier, en appelant le(s) filtre(s) correspondant au
format du fichier, puis en effectuant une analyse antivirus.
@param politique: politique de filtrage à appliquer, objet L{Politique.Politique}
ou None. Si None, la politique par défaut sera appliquée.
@type politique: objet L{Politique.Politique}
@return: le résultat global des filtres appliqués.
@rtype : objet L{Resultat<Resultat.Resultat>}
"""
# si une politique est fournie on récupère son dictionnaire de filtres,
# sinon on récupère celle du module Politique:
# (la différence est subtile ;-)
if politique:
dico_filtres = politique.dico_filtres
else:
dico_filtres = Politique.dico_filtres
# on dresse une liste des formats reconnus, pour la journalisation:
formats_reconnus = []
# si le fichier est chiffré dans son conteneur, on ne peut pas l'analyser:
if self.conteneur.est_chiffre(self):
self.resultat_fichier.ajouter(Resultat.Resultat(
Resultat.REFUSE,[
_(u"%s : Le fichier est chiffré, il ne peut être analysé.")
% self.conteneur.type], self))
# sinon on teste si l'extension est reconnue par un des filtres:
elif self.extension in dico_filtres:
# il existe au moins un filtre pour cette extension
# on récupère la liste des filtres concernés
# dans dico_filtres[fichier.extension]:
for filtre in dico_filtres[self.extension]:
format_reconnu = False
# si le format est autorisé, on appelle le filtre:
if filtre.parametres['format_autorise'].valeur == True:
# on appelle d'abord le filtre pour analyser le
# contenu du fichier:
try:
format_reconnu = filtre.reconnait_format(self)
except:
format_reconnu = False
erreur = str(sys.exc_info()[1])
msg = _(u"%s : Erreur lors de l'analyse du format (%s)") % \
(filtre.nom, erreur)
resultat_filtre = Resultat.Resultat(
Resultat.ERREUR_ANALYSE, msg, self)
self.resultat_fichier.ajouter(resultat_filtre)
# on ajoute l'exception au journal technique:
Journal.info2(msg, exc_info=True)
# et on fait une pause pour la lire si mode debug:
debug_pause()
if format_reconnu:
# contenu reconnu
Journal.info2(filtre.nom + _(u" : Reconnu"))
# on ajoute ce format à la liste:
formats_reconnus.append(filtre.nom)
# on appelle le filtre pour nettoyer,
# et on récupère le résultat de ce filtre:
try:
resultat_filtre = filtre.nettoyer(self)
except zipfile.BadZipfile:
# si on obtient cette exception, c'est que le module zipfile ne
# supporte pas le format de ce fichier zip.
erreur = str(sys.exc_info()[1])
#msg = _(u"Le format de l'archive zip est incorrect ou non supporté, ") \
# + _(u"le fichier ne peut être analysé. (%s)") % erreur
#resultat_filtre = Resultat.Resultat(
# Resultat.ERREUR_ANALYSE, msg, self)
#Journal.info2(msg, exc_info=True)
resultat_filtre = filtre.resultat_format_incorrect(self, erreur)
except:
erreur = str(sys.exc_info()[1])
msg = _(u"%s : Erreur lors du nettoyage (%s)") % \
(filtre.nom, erreur)
resultat_filtre = Resultat.Resultat(
Resultat.ERREUR_ANALYSE,msg, self)
# on ajoute l'exception au journal technique:
Journal.info2(msg, exc_info=True)
# et on fait une pause pour la lire si mode debug:
debug_pause()
# on ajoute ce résultat à la liste des
# autres filtres pour ce fichier:
self.resultat_fichier.ajouter(resultat_filtre)
for r in resultat_filtre.raison:
Journal.info2(r)
# Conteneur: c'est le filtre qui doit gérer:
# if filtre.format_conteneur:
# # on crée un objet conteneur
# conteneur = filtre.conteneur(self.chemin, "", self.dico_filtres, self)
# # on nettoie ce conteneur, et on récupère
# # les résultats de chaque fichier (liste)
# liste_resultats = conteneur.nettoyer()
# # on ajoute cette liste au résultat
# self.resultat_fichier.resultats_conteneur = liste_resultats
# liste_resultat.append(liste_resultat2) # à compléter
else:
# sinon le format n'est pas reconnu, on
# met à jour le résultat:
resultat_filtre = Resultat.Resultat(
Resultat.FORMAT_INCORRECT,[filtre.nom \
+ _(u" : Format de fichier non reconnu ou non autorisé")], self)
self.resultat_fichier.ajouter(resultat_filtre)
else:
# le fichier a une extension non autorisée:
# Faut-il ajouter une raison ?
pass
# On appelle l'antivirus après tous les filtres, si le fichier
# n'est pas déjà refusé, pour économiser son analyse qui prend du temps:
# (cela peut poser problème si on veut obtenir des stats précises
# de virus, et d'un autre côté quand un fichier est nettoyé il ne
# devrait plus contenir de code, donc plus de virus... Mais c'est tout
# de même utile pour détecter certains exploits qui se cachent dans des
# données normalement non exécutables)
if not self.resultat_fichier.est_refuse():
resultat_antivirus = self.antivirus(politique)
# on ajoute le résultat que si qqch de suspect a été détecté:
if resultat_antivirus:
self.resultat_fichier.ajouter(resultat_antivirus)
# tous les filtres sont passés, on regarde le code du résultat final:
# on affiche les détails du résultat:
#print self.resultat_fichier.details()
# on journalise le résultat:
if len(formats_reconnus):
formats = u", ".join(formats_reconnus) + u" -> "
else:
formats = u""
evt_journal = u"%s : %s%s" % (self.chemin_complet, formats,
self.resultat_fichier.details() )
if self.resultat_fichier.est_refuse():
# si c'est un refus, log de niveau WARNING:
Journal.warning(evt_journal)
else:
# sinon, log de niveau INFO:
Journal.info(evt_journal)
# on ajoute le résultat au rapport:
Rapport.ajouter_resultat(self.resultat_fichier)
def antivirus (self, politique):
"""
Analyse le fichier grâce à un ou plusieurs antivirus.
@param politique: politique de filtrage à appliquer, objet L{Politique.Politique}
ou None. Si None, la politique par défaut sera appliquée.
@type politique: objet L{Politique.Politique}
@return: le résultat de l'analyse, ou None si le fichier est sain.
@rtype : objet L{Resultat<Resultat.Resultat>} ou None
"""
# on commence avec un resultat vide:
resultat = Resultat.Resultat(fichier=self)
if politique.parametres['antivirus_fpcmd'].valeur:
res = self.antivirus_fpcmd(politique)
if res: resultat.ajouter(res)
if politique.parametres['antivirus_fpscan'].valeur:
res = self.antivirus_fpscan(politique)
if res: resultat.ajouter(res)
if politique.parametres['antivirus_clamd'].valeur:
res = self.antivirus_clamd(politique)
if res: resultat.ajouter(res)
return resultat
def antivirus_clamd (self, politique):
"""
Analyse le fichier grâce à l'antivirus ClamAV en mode daemon (clamd).
@param politique: politique de filtrage à appliquer, objet L{Politique.Politique}
ou None. Si None, la politique par défaut sera appliquée.
@type politique: objet L{Politique.Politique}
@return: le résultat de l'analyse, ou None si le fichier est sain.
@rtype : objet L{Resultat<Resultat.Resultat>} ou None
"""
if not pyclamd.use_socket:
# La connexion vers le service clamd n'est pas encore initialisee
serveur = politique.parametres['clamd_serveur'].valeur
port = politique.parametres['clamd_port'].valeur
Journal.info2(_(u'Connexion au serveur clamd %s:%d...') % (serveur, port))
try:
pyclamd.init_network_socket(serveur, port, timeout=180)
except pyclamd.ScanError:
Journal.exception(_(u"Connexion au service clamd (%s:%d) impossible.")
% (serveur, port))
raise
Journal.info2(pyclamd.version())
Journal.info2(_(u"Appel de clamd pour l'analyse antivirus..."))
# clamd a besoin du chemin absolu du fichier:
abspath = str_lat1(self.copie_temp().abspath())
Journal.debug(_(u'analyse de %s') % abspath)
try:
res = pyclamd.scan_file(abspath)
except socket.timeout:
return Resultat.Resultat(Resultat.ERREUR_ANALYSE,
"clamd: "+_(u"Temps dépassé lors de la vérification antivirus")
% self.nom, self)
except:
msg = "clamd: "+_(u"Erreur lors de la vérification antivirus")
Journal.exception(msg)
return Resultat.Resultat(Resultat.ERREUR_ANALYSE, msg, self)
if res == None:
# resultat OK, pas de virus
Journal.info2("clamd: "+_(u"Pas de virus détecté."))
# on retourne un objet Resultat vide
return Resultat.Resultat(fichier=self)
else:
# un virus a ete detecte
fichier = res.keys[0]
msg_virus = res[fichier]
Journal.debug("clamd: "+_(u'fichier=%s resultat=%s') %(fichier, msg_virus))
return Resultat.Resultat(Resultat.REFUSE,
"clamd: "+_(u"Virus détecté ou fichier suspect: %s") % msg_virus,
self)
def antivirus_fpscan (self, politique):
"""
Analyse le fichier grâce à l'antivirus F-Prot 6 (fpscan).
@param politique: politique de filtrage à appliquer, objet L{Politique.Politique}
ou None. Si None, la politique par défaut sera appliquée.
@type politique: objet L{Politique.Politique}
@return: le résultat de l'analyse, ou None si le fichier est sain.
@rtype : objet L{Resultat<Resultat.Resultat>} ou None
"""
if sys.platform == "win32":
# on récupère le chemin de F-Prot:
chemin_fprot = politique.parametres['fpscan_executable'].valeur
Journal.info2(_(u"Lancement de fpscan pour l'analyse antivirus..."))
# Options pour fpscan:
# -t: analyse des alternate data streams sur NTFS (par precaution)
# -v 0: pas d'affichage sauf si erreur ou infection
# /maxdepth=0: pour ne pas analyser l'interieur des archives
# /report: ne tente pas de desinfecter
# En mode debug on affiche tous les messages:
if mode_debug(): verbose = '2'
else: verbose = '0'
chemin_fichier = str_lat1(self.copie_temp())
## # si le chemin du fichier contient un espace il faut l'entourer de
## # guillemets: => seulement pour os.spawnv, pas pour popen.
## if ' ' in chemin_fichier and not chemin_fichier.startswith('"'):
## chemin_fichier = '"%s"' % chemin_fichier
# Note: avec popen, '-v 0' doit etre separe en 2: '-v', '2' sinon
# F-prot genere une erreur et renvoie un code 20.
args_fprot = [chemin_fprot, '-t', '-v', verbose, '/maxdepth=0', '/report',
chemin_fichier]
Journal.debug(' '.join(args_fprot))
# On lance F-Prot avec Popen_timer pour masquer son affichage
# et limiter le temps d'exécution:
if mode_debug():
# on cree un fichier rapport:
args_fprot += ['-o', 'fpscan_debug.txt']
# en mode debug on ne masque pas l'affichage:
## resultat_fprot = subprocess.call(args_fprot)
## resultat_fprot = os.spawnv(os.P_WAIT, chemin_fprot, args_fprot[1:])
resultat_fprot = Popen_timer(args_fprot, stdout=sys.stdout,
stderr=sys.stderr)
else:
resultat_fprot = Popen_timer(args_fprot)
Journal.debug(_(u'resultat F-Prot fpscan: %d') % resultat_fprot)
if resultat_fprot == 0:
Journal.info2(u"fpscan: "+_(u"Pas de virus détecté."))
resultat = None
# on teste en premier s'il y a eu un timeout:
elif resultat_fprot == EXIT_KILL_PTIMER:
resultat = Resultat.Resultat(Resultat.ERREUR_ANALYSE,
u"fpscan: "+_(u"Temps dépassé lors de la vérification antivirus"),
self)
elif resultat_fprot & FPSCAN_INFECTION:
resultat = Resultat.Resultat(Resultat.REFUSE,
u"fpscan: "+_(u"Virus détecté ou fichier suspect"),
self)
else:
resultat = Resultat.Resultat(Resultat.ERREUR_ANALYSE,
u"fpscan: "+_(u"Erreur lors de la vérification antivirus"),
self)
else:
# pour l'instant seul F-Prot sous Windows est supporté:
raise NotImplementedError, \
u"fpscan: "+_(u"Antivirus non supporte ou implemente pour ce systeme.")
return resultat
def antivirus_fpcmd (self, politique):
"""
Analyse le fichier grâce à l'antivirus F-Prot 3 (fpcmd).
@param politique: politique de filtrage à appliquer, objet L{Politique.Politique}
ou None. Si None, la politique par défaut sera appliquée.
@type politique: objet L{Politique.Politique}
@return: le résultat de l'analyse, ou None si le fichier est sain.
@rtype : objet L{Resultat<Resultat.Resultat>} ou None
"""
if sys.platform == "win32":
# on récupère le chemin de fpcmd:
chemin_fprot = politique.parametres['fpcmd_executable'].valeur
Journal.info2(_(u"Lancement de fpcmd pour l'analyse antivirus..."))
args_fprot = [chemin_fprot, '-nomem', '-noboot', '-nosub', '-silent',
'-old', '-collect', str_lat1(self.copie_temp())]
# A VOIR: l'option -type laisse F-Prot décider si un type de fichier doit
# être scanné, alors que -collect force F-Prot à tout scanner
# (risque de faux-positifs)
# On lance F-Prot avec Popen_timer pour masquer son affichage
# et limiter le temps d'exécution:
resultat_fprot = Popen_timer(args_fprot)
# codes retournés par F-Prot 3:
# 0 - Normal exit - nothing found
# 1 - Abnormal termination - unrecoverable error. This can mean any of
# the following:
# Internal error in the program.
# DOS version prior to 3.0 was used.
# ENGLISH.TX0, SIGN.DEF or MACRO.DEF corrupted or not present.
# 2 - Selftest failed - program has been modified.
# 3 - A Boot/File virus infection found.
# 4 - Virus found in memory.
# 5 - Program terminated with ^C or ESC.
# 6 - A virus was removed. This code is only meaningful if
# the program is used to scan just a single file.
# 7 - Insufficient memory to run the program.
# 8 - At least one suspicious file was found, but no infections.
if resultat_fprot == 0:
Journal.info2(u"fpcmd: "+_(u"Pas de virus détecté."))
resultat = None
elif resultat_fprot in [3, 4, 6, 8]:
resultat = Resultat.Resultat(Resultat.REFUSE,
u"fpcmd: "+_(u"Virus détecté ou fichier suspect"),
self)
elif resultat_fprot == EXIT_KILL_PTIMER:
resultat = Resultat.Resultat(Resultat.ERREUR_ANALYSE,
u"fpcmd: "+_(u"Temps dépassé lors de la vérification antivirus"),
self)
else:
resultat = Resultat.Resultat(Resultat.ERREUR_ANALYSE,
u"fpcmd: "+_(u"Erreur lors de la vérification antivirus"),
self)
else:
# pour l'instant seul F-Prot sous Windows est supporté:
raise NotImplementedError, \
u"fpcmd: "+_(u"Antivirus non supporte ou implemente pour ce systeme.")
return resultat