IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Affichage des résultats du sondage: Quel est votre logiciel antivirus préféré ?

Votants
58. Vous ne pouvez pas participer à ce sondage.
  • Avast

    2 3,45%
  • AVG

    6 10,34%
  • Avira

    0 0%
  • BitDefender

    4 6,90%
  • ESET

    2 3,45%
  • F-Secure

    4 6,90%
  • Kaspersky

    12 20,69%
  • Northon

    4 6,90%
  • Trend Micro

    4 6,90%
  • Autres

    20 34,48%
Windows Discussion :

Windows Defender offre le niveau de protection le plus décevant sous Windows 8/8.1


Sujet :

Windows

  1. #1
    Chroniqueur Actualités
    Avatar de Michael Guilloux
    Homme Profil pro
    Data Consultant
    Inscrit en
    Juillet 2013
    Messages
    2 875
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Data Consultant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2013
    Messages : 2 875
    Points : 86 930
    Points
    86 930
    Billets dans le blog
    2
    Par défaut Windows Defender offre le niveau de protection le plus décevant sous Windows 8/8.1
    Windows Defender offre le niveau de protection le plus décevant sous Windows 8/8.1
    D'après une évaluation des antivirus menée par AV-TEST

    Le niveau de protection offert par Windows Defender, contre les logiciels malveillants sous Windows 8 et 8.1, laisse beaucoup à désirer. C'est ce qui est ressorti du dernier rapport de AV-TEST.

    AV-TEST est une organisation spécialisée dans l'évaluation des logiciels de sécurité et antivirus. Elle produit régulièrement des rapports sur les différents logiciels antivirus sous les plateformes Windows, Mac et Android.

    Pour chaque plateforme, l'organisation évalue la façon dont différents logiciels antivirus défendent les machines contre les menaces bien connues et récentes. Ses évaluations prennent en compte bon nombre de logiciels antivirus dont ceux des firmes de sécurité les plus populaires tels qu'Avast, Kaspersky, AVG, F-Secure, Trend Micro, Bitdefender, Avira, Northon et ESET entre autres. Les évaluations comprennent à la fois des versions payantes et gratuites de logiciels antivirus.

    Le premier rapport d'AV-TEST, cette année, pour la plateforme de bureau de Microsoft datait de Janvier dernier et portait sur Windows 7, qui est encore largement utilisé. Après une première série de tests des logiciels antivirus sous Windows 8/8.1, menée en octobre 2014, AV-TEST a procédé à une nouvelle évaluation le mois dernier, dont les résultats ont été récemment publiés.

    Les logiciels antivirus sont évalués suivant 3 critères essentiels à savoir la protection, la performance et la facilité d'utilisation. Pour chaque critère, le nombre maximum de points à gagner est de six. Ce qui donne un score global de 18 points au plus.

    Windows Defender est gratuit. Le logiciel de protection antivirus de Windows a encore l'avantage d'être livré directement avec l'OS, ce qui signifie qu'il ne nécessite ni installation, ni inscription. Cependant, Windows Defender offre la protection la moins sure d'après l'évaluation d'AV-TEST avec une note de 0/6 pour ce critère.

    Ce score ne signifie pas cependant que le logiciel de Windows n'offre aucune protection, mais exprime plutôt son positionnement par rapport aux logiciels antivirus. AV-TEST note en effet que Windows Defender a été en mesure de protéger contre 77% des menaces entrantes. Même si c'est loin des 100%, cela signifie que plus des trois quarts des menaces de sécurité sont gérés par un logiciel gratuit qui se met à jour de temps en temps pour scanner votre PC.

    En somme, Windows Defender ne se trouve qu'au bas du tableau avec une note globale de 9,5 sur 18. Ce qui n'est pas du tout une surprise pour AV-TEST. L'organisation déclare en fait que, même si Windows Defender reçoit des mises à jour chaque semaine, il ne s'agit que d'une façade.

    Par ailleurs, il faut noter que le classement a été dominé par Internet Security 2015 de BitDefender, Internet Security 2015 de Kaspersky et 360 Antivirus (QVM) 5.0. Chacun de ces produits a obtenu la note globale maximale de 18 points.



    Source : AV-TEST

    Et vous ?

    Que pensez-vous de Windows Defender ?

    Quel est votre logiciel antivirus préféré ?
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  2. #2
    Expert éminent sénior
    Avatar de JML19
    Homme Profil pro
    Retraité : Electrotechnicien Electronicien Informaticien de la SNCF
    Inscrit en
    Décembre 2010
    Messages
    14 915
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Corrèze (Limousin)

    Informations professionnelles :
    Activité : Retraité : Electrotechnicien Electronicien Informaticien de la SNCF
    Secteur : Transports

    Informations forums :
    Inscription : Décembre 2010
    Messages : 14 915
    Points : 23 210
    Points
    23 210
    Billets dans le blog
    10
    Par défaut
    Bonjour

    Et Microsoft Security Essentials alors ?
    Vous pouvez utiliser les FAQ (ICI) ou les Tutoriels (ICI) et aussi accéder au blog (ICI)

  3. #3
    Membre éclairé Avatar de alves1993
    Homme Profil pro
    Développeur Java/Dart/Javascript/Android (FullStack)
    Inscrit en
    Décembre 2012
    Messages
    222
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Développeur Java/Dart/Javascript/Android (FullStack)
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Décembre 2012
    Messages : 222
    Points : 659
    Points
    659
    Par défaut
    Quand je pensai que j'étais vraiment en sécurité avec Windows Defender
    Un geek ne vieillit pas, il se met à jour.

    Pour plus d'informations sur Android regarder la faq Android.
    Ensuite les tutoriels Android sont disponibles ici
    Pour les mecs, qui n'arrivent pas toujours à digérer le Javascript, Dart peut-être une solution pour vous.

  4. #4
    Modérateur
    Avatar de sevyc64
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Janvier 2007
    Messages
    10 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 51
    Localisation : France, Pyrénées Atlantiques (Aquitaine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 191
    Points : 28 070
    Points
    28 070
    Par défaut
    MSE n'existe pas sous W8, c'est Windows Defender (qui est un antivirus complet sous W8) qui le remplace justement
    --- Sevyc64 ---

    Parce que le partage est notre force, la connaissance sera notre victoire

  5. #5
    Expert éminent sénior
    Avatar de JML19
    Homme Profil pro
    Retraité : Electrotechnicien Electronicien Informaticien de la SNCF
    Inscrit en
    Décembre 2010
    Messages
    14 915
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Corrèze (Limousin)

    Informations professionnelles :
    Activité : Retraité : Electrotechnicien Electronicien Informaticien de la SNCF
    Secteur : Transports

    Informations forums :
    Inscription : Décembre 2010
    Messages : 14 915
    Points : 23 210
    Points
    23 210
    Billets dans le blog
    10
    Par défaut
    Oui mais j'aurais aimé savoir ce que vaut MSE.
    Vous pouvez utiliser les FAQ (ICI) ou les Tutoriels (ICI) et aussi accéder au blog (ICI)

  6. #6
    Modérateur
    Avatar de sevyc64
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Janvier 2007
    Messages
    10 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 51
    Localisation : France, Pyrénées Atlantiques (Aquitaine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 191
    Points : 28 070
    Points
    28 070
    Par défaut
    Citation Envoyé par JML19 Voir le message
    Oui mais j'aurais aimé savoir ce que vaut MSE.

    pas guère mieux
    --- Sevyc64 ---

    Parce que le partage est notre force, la connaissance sera notre victoire

  7. #7
    Membre émérite
    Avatar de Voyvode
    Profil pro
    Inscrit en
    Mars 2007
    Messages
    476
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2007
    Messages : 476
    Points : 2 678
    Points
    2 678
    Par défaut
    Au lieu de se fier à des classements « guide Michelin », il serait plus intéressant de lire ce genre de chose : Antivirus software is falling behind the bad guys

    Cet article parle d’une étude faite durant le 4e trimestre 2014 par Damballa (une société basée à Atlanta, spécialisée dans l’analyse et la détection de failles zero-day) qui révèle qu’un antivirus peut mettre jusqu’à 6 mois pour intégrer un nouveau fichier vérolé dans sa base de connaissances.


    Pour résumer, ce joli tableau est un classement des antivirus mauvais à archinuls.

  8. #8
    Expert éminent sénior
    Avatar de JML19
    Homme Profil pro
    Retraité : Electrotechnicien Electronicien Informaticien de la SNCF
    Inscrit en
    Décembre 2010
    Messages
    14 915
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Corrèze (Limousin)

    Informations professionnelles :
    Activité : Retraité : Electrotechnicien Electronicien Informaticien de la SNCF
    Secteur : Transports

    Informations forums :
    Inscription : Décembre 2010
    Messages : 14 915
    Points : 23 210
    Points
    23 210
    Billets dans le blog
    10
    Par défaut
    Bonjour

    Il est bien évident que si un anti virus empêchait d'avoir des virus depuis le temps cela se saurait.

    Il arrive toujours après le virus.
    Vous pouvez utiliser les FAQ (ICI) ou les Tutoriels (ICI) et aussi accéder au blog (ICI)

  9. #9
    Modérateur
    Avatar de sevyc64
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Janvier 2007
    Messages
    10 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 51
    Localisation : France, Pyrénées Atlantiques (Aquitaine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 191
    Points : 28 070
    Points
    28 070
    Par défaut
    Citation Envoyé par Voïvode Voir le message
    Cet article parle d’une étude faite durant le 4e trimestre 2014 par Damballa (une société basée à Atlanta, spécialisée dans l’analyse et la détection de failles zero-day) qui révèle qu’un antivirus peut mettre jusqu’à 6 mois pour intégrer un nouveau fichier vérolé dans sa base de connaissances.
    Là encore ce critère n'est que très relatif. Personnellement, ça ne me gêne pas (et ne me choque pas) qu'un antivirus mettent 2 ans à intégrer une signature si le virus entre-temps n'est que très peu virulent et ne contamine que quelques machines par ans.
    Mais si le virus contamine des millions de machines par jour, là, oui ça va poser problème. Mais ce virus là sera intégré en quelques heures seulement dans les bases.



    Pour résumer, ce joli tableau est un classement des antivirus mauvais à archinuls.
    Et pourtant les meilleurs du marché, C'est dire pour les autres
    --- Sevyc64 ---

    Parce que le partage est notre force, la connaissance sera notre victoire

  10. #10
    Expert éminent Avatar de marsupial
    Homme Profil pro
    Retraité
    Inscrit en
    Mars 2014
    Messages
    1 760
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Autre

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Mars 2014
    Messages : 1 760
    Points : 7 185
    Points
    7 185
    Par défaut ntkernel dispose-t-il des mêmes fonctionnalités ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    Linux kernel & device driver programming
    Cross-Referenced Linux and Device Driver Code
    [ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
    Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
    
      1 /*
      2  * This is <linux/capability.h>
      3  *
      4  * Andrew G. Morgan <morgan@kernel.org>
      5  * Alexander Kjeldaas <astor@guardian.no>
      6  * with help from Aleph1, Roland Buresund and Andrew Main.
      7  *
      8  * See here for the libcap library ("POSIX draft" compliance):
      9  *
     10  * ftp://linux.kernel.org/pub/linux/lib...vs/kernel-2.6/
     11  */
     12 
     13 #ifndef _LINUX_CAPABILITY_H
     14 #define _LINUX_CAPABILITY_H
     15 
     16 #include <linux/types.h>
     17 
     18 struct task_struct;
     19 
     20 /* User-level do most of the mapping between kernel and user
     21    capabilities based on the version tag given by the kernel. The
     22    kernel might be somewhat backwards compatible, but don't bet on
     23    it. */
     24 
     25 /* Note, cap_t, is defined by POSIX (draft) to be an "opaque" pointer to
     26    a set of three capability sets.  The transposition of 3*the
     27    following structure to such a composite is better handled in a user
     28    library since the draft standard requires the use of malloc/free
     29    etc.. */
     30 
     31 #define _LINUX_CAPABILITY_VERSION_1  0x19980330
     32 #define _LINUX_CAPABILITY_U32S_1     1
     33 
     34 #define _LINUX_CAPABILITY_VERSION_2  0x20071026  /* deprecated - use v3 */
     35 #define _LINUX_CAPABILITY_U32S_2     2
     36 
     37 #define _LINUX_CAPABILITY_VERSION_3  0x20080522
     38 #define _LINUX_CAPABILITY_U32S_3     2
     39 
     40 typedef struct __user_cap_header_struct {
     41         __u32 version;
     42         int pid;
     43 } __user *cap_user_header_t;
     44 
     45 typedef struct __user_cap_data_struct {
     46         __u32 effective;
     47         __u32 permitted;
     48         __u32 inheritable;
     49 } __user *cap_user_data_t;
     50 
     51 
     52 #define XATTR_CAPS_SUFFIX "capability"
     53 #define XATTR_NAME_CAPS XATTR_SECURITY_PREFIX XATTR_CAPS_SUFFIX
     54 
     55 #define VFS_CAP_REVISION_MASK   0xFF000000
     56 #define VFS_CAP_REVISION_SHIFT  24
     57 #define VFS_CAP_FLAGS_MASK      ~VFS_CAP_REVISION_MASK
     58 #define VFS_CAP_FLAGS_EFFECTIVE 0x000001
     59 
     60 #define VFS_CAP_REVISION_1      0x01000000
     61 #define VFS_CAP_U32_1           1
     62 #define XATTR_CAPS_SZ_1         (sizeof(__le32)*(1 + 2*VFS_CAP_U32_1))
     63 
     64 #define VFS_CAP_REVISION_2      0x02000000
     65 #define VFS_CAP_U32_2           2
     66 #define XATTR_CAPS_SZ_2         (sizeof(__le32)*(1 + 2*VFS_CAP_U32_2))
     67 
     68 #define XATTR_CAPS_SZ           XATTR_CAPS_SZ_2
     69 #define VFS_CAP_U32             VFS_CAP_U32_2
     70 #define VFS_CAP_REVISION        VFS_CAP_REVISION_2
     71 
     72 struct vfs_cap_data {
     73         __le32 magic_etc;            /* Little endian */
     74         struct {
     75                 __le32 permitted;    /* Little endian */
     76                 __le32 inheritable;  /* Little endian */
     77         } data[VFS_CAP_U32];
     78 };
     79 
     80 #ifndef __KERNEL__
     81 
     82 /*
     83  * Backwardly compatible definition for source code - trapped in a
     84  * 32-bit world. If you find you need this, please consider using
     85  * libcap to untrap yourself...
     86  */
     87 #define _LINUX_CAPABILITY_VERSION  _LINUX_CAPABILITY_VERSION_1
     88 #define _LINUX_CAPABILITY_U32S     _LINUX_CAPABILITY_U32S_1
     89 
     90 #else
     91 
     92 #define _KERNEL_CAPABILITY_VERSION _LINUX_CAPABILITY_VERSION_3
     93 #define _KERNEL_CAPABILITY_U32S    _LINUX_CAPABILITY_U32S_3
     94 
     95 #ifdef CONFIG_SECURITY_FILE_CAPABILITIES
     96 extern int file_caps_enabled;
     97 #endif
     98 
     99 typedef struct kernel_cap_struct {
    100         __u32 cap[_KERNEL_CAPABILITY_U32S];
    101 } kernel_cap_t;
    102 
    103 /* exact same as vfs_cap_data but in cpu endian and always filled completely */
    104 struct cpu_vfs_cap_data {
    105         __u32 magic_etc;
    106         kernel_cap_t permitted;
    107         kernel_cap_t inheritable;
    108 };
    109 
    110 #define _USER_CAP_HEADER_SIZE  (sizeof(struct __user_cap_header_struct))
    111 #define _KERNEL_CAP_T_SIZE     (sizeof(kernel_cap_t))
    112 
    113 #endif
    114 
    115 
    116 /**
    117  ** POSIX-draft defined capabilities.
    118  **/
    119 
    120 /* In a system with the [_POSIX_CHOWN_RESTRICTED] option defined, this
    121    overrides the restriction of changing file ownership and group
    122    ownership. */
    123 
    124 #define CAP_CHOWN            0
    125 
    126 /* Override all DAC access, including ACL execute access if
    127    [_POSIX_ACL] is defined. Excluding DAC access covered by
    128    CAP_LINUX_IMMUTABLE. */
    129 
    130 #define CAP_DAC_OVERRIDE     1
    131 
    132 /* Overrides all DAC restrictions regarding read and search on files
    133    and directories, including ACL restrictions if [_POSIX_ACL] is
    134    defined. Excluding DAC access covered by CAP_LINUX_IMMUTABLE. */
    135 
    136 #define CAP_DAC_READ_SEARCH  2
    137 
    138 /* Overrides all restrictions about allowed operations on files, where
    139    file owner ID must be equal to the user ID, except where CAP_FSETID
    140    is applicable. It doesn't override MAC and DAC restrictions. */
    141 
    142 #define CAP_FOWNER           3
    143 
    144 /* Overrides the following restrictions that the effective user ID
    145    shall match the file owner ID when setting the S_ISUID and S_ISGID
    146    bits on that file; that the effective group ID (or one of the
    147    supplementary group IDs) shall match the file owner ID when setting
    148    the S_ISGID bit on that file; that the S_ISUID and S_ISGID bits are
    149    cleared on successful return from chown(2) (not implemented). */
    150 
    151 #define CAP_FSETID           4
    152 
    153 /* Overrides the restriction that the real or effective user ID of a
    154    process sending a signal must match the real or effective user ID
    155    of the process receiving the signal. */
    156 
    157 #define CAP_KILL             5
    158 
    159 /* Allows setgid(2) manipulation */
    160 /* Allows setgroups(2) */
    161 /* Allows forged gids on socket credentials passing. */
    162 
    163 #define CAP_SETGID           6
    164 
    165 /* Allows set*uid(2) manipulation (including fsuid). */
    166 /* Allows forged pids on socket credentials passing. */
    167 
    168 #define CAP_SETUID           7
    169 
    170 
    171 /**
    172  ** Linux-specific capabilities
    173  **/
    174 
    175 /* Without VFS support for capabilities:
    176  *   Transfer any capability in your permitted set to any pid,
    177  *   remove any capability in your permitted set from any pid
    178  * With VFS support for capabilities (neither of above, but)
    179  *   Add any capability from current's capability bounding set
    180  *       to the current process' inheritable set
    181  *   Allow taking bits out of capability bounding set
    182  *   Allow modification of the securebits for a process
    183  */
    184 
    185 #define CAP_SETPCAP          8
    186 
    187 /* Allow modification of S_IMMUTABLE and S_APPEND file attributes */
    188 
    189 #define CAP_LINUX_IMMUTABLE  9
    190 
    191 /* Allows binding to TCP/UDP sockets below 1024 */
    192 /* Allows binding to ATM VCIs below 32 */
    193 
    194 #define CAP_NET_BIND_SERVICE 10
    195 
    196 /* Allow broadcasting, listen to multicast */
    197 
    198 #define CAP_NET_BROADCAST    11
    199 
    200 /* Allow interface configuration */
    201 /* Allow administration of IP firewall, masquerading and accounting */
    202 /* Allow setting debug option on sockets */
    203 /* Allow modification of routing tables */
    204 /* Allow setting arbitrary process / process group ownership on
    205    sockets */
    206 /* Allow binding to any address for transparent proxying */
    207 /* Allow setting TOS (type of service) */
    208 /* Allow setting promiscuous mode */
    209 /* Allow clearing driver statistics */
    210 /* Allow multicasting */
    211 /* Allow read/write of device-specific registers */
    212 /* Allow activation of ATM control sockets */
    213 
    214 #define CAP_NET_ADMIN        12
    215 
    216 /* Allow use of RAW sockets */
    217 /* Allow use of PACKET sockets */
    218 
    219 #define CAP_NET_RAW          13
    220 
    221 /* Allow locking of shared memory segments */
    222 /* Allow mlock and mlockall (which doesn't really have anything to do
    223    with IPC) */
    224 
    225 #define CAP_IPC_LOCK         14
    226 
    227 /* Override IPC ownership checks */
    228 
    229 #define CAP_IPC_OWNER        15
    230 
    231 /* Insert and remove kernel modules - modify kernel without limit */
    232 #define CAP_SYS_MODULE       16
    233 
    234 /* Allow ioperm/iopl access */
    235 /* Allow sending USB messages to any device via /proc/bus/usb */
    236 
    237 #define CAP_SYS_RAWIO        17
    238 
    239 /* Allow use of chroot() */
    240 
    241 #define CAP_SYS_CHROOT       18
    242 
    243 /* Allow ptrace() of any process */
    244 
    245 #define CAP_SYS_PTRACE       19
    246 
    247 /* Allow configuration of process accounting */
    248 
    249 #define CAP_SYS_PACCT        20
    250 
    251 /* Allow configuration of the secure attention key */
    252 /* Allow administration of the random device */
    253 /* Allow examination and configuration of disk quotas */
    254 /* Allow configuring the kernel's syslog (printk behaviour) */
    255 /* Allow setting the domainname */
    256 /* Allow setting the hostname */
    257 /* Allow calling bdflush() */
    258 /* Allow mount() and umount(), setting up new smb connection */
    259 /* Allow some autofs root ioctls */
    260 /* Allow nfsservctl */
    261 /* Allow VM86_REQUEST_IRQ */
    262 /* Allow to read/write pci config on alpha */
    263 /* Allow irix_prctl on mips (setstacksize) */
    264 /* Allow flushing all cache on m68k (sys_cacheflush) */
    265 /* Allow removing semaphores */
    266 /* Used instead of CAP_CHOWN to "chown" IPC message queues, semaphores
    267    and shared memory */
    268 /* Allow locking/unlocking of shared memory segment */
    269 /* Allow turning swap on/off */
    270 /* Allow forged pids on socket credentials passing */
    271 /* Allow setting readahead and flushing buffers on block devices */
    272 /* Allow setting geometry in floppy driver */
    273 /* Allow turning DMA on/off in xd driver */
    274 /* Allow administration of md devices (mostly the above, but some
    275    extra ioctls) */
    276 /* Allow tuning the ide driver */
    277 /* Allow access to the nvram device */
    278 /* Allow administration of apm_bios, serial and bttv (TV) device */
    279 /* Allow manufacturer commands in isdn CAPI support driver */
    280 /* Allow reading non-standardized portions of pci configuration space */
    281 /* Allow DDI debug ioctl on sbpcd driver */
    282 /* Allow setting up serial ports */
    283 /* Allow sending raw qic-117 commands */
    284 /* Allow enabling/disabling tagged queuing on SCSI controllers and sending
    285    arbitrary SCSI commands */
    286 /* Allow setting encryption key on loopback filesystem */
    287 /* Allow setting zone reclaim policy */
    288 
    289 #define CAP_SYS_ADMIN        21
    290 
    291 /* Allow use of reboot() */
    292 
    293 #define CAP_SYS_BOOT         22
    294 
    295 /* Allow raising priority and setting priority on other (different
    296    UID) processes */
    297 /* Allow use of FIFO and round-robin (realtime) scheduling on own
    298    processes and setting the scheduling algorithm used by another
    299    process. */
    300 /* Allow setting cpu affinity on other processes */
    301 
    302 #define CAP_SYS_NICE         23
    303 
    304 /* Override resource limits. Set resource limits. */
    305 /* Override quota limits. */
    306 /* Override reserved space on ext2 filesystem */
    307 /* Modify data journaling mode on ext3 filesystem (uses journaling
    308    resources) */
    309 /* NOTE: ext2 honors fsuid when checking for resource overrides, so
    310    you can override using fsuid too */
    311 /* Override size restrictions on IPC message queues */
    312 /* Allow more than 64hz interrupts from the real-time clock */
    313 /* Override max number of consoles on console allocation */
    314 /* Override max number of keymaps */
    315 
    316 #define CAP_SYS_RESOURCE     24
    317 
    318 /* Allow manipulation of system clock */
    319 /* Allow irix_stime on mips */
    320 /* Allow setting the real-time clock */
    321 
    322 #define CAP_SYS_TIME         25
    323 
    324 /* Allow configuration of tty devices */
    325 /* Allow vhangup() of tty */
    326 
    327 #define CAP_SYS_TTY_CONFIG   26
    328 
    329 /* Allow the privileged aspects of mknod() */
    330 
    331 #define CAP_MKNOD            27
    332 
    333 /* Allow taking of leases on files */
    334 
    335 #define CAP_LEASE            28
    336 
    337 #define CAP_AUDIT_WRITE      29
    338 
    339 #define CAP_AUDIT_CONTROL    30
    340 
    341 #define CAP_SETFCAP          31
    342 
    343 /* Override MAC access.
    344    The base kernel enforces no MAC policy.
    345    An LSM may enforce a MAC policy, and if it does and it chooses
    346    to implement capability based overrides of that policy, this is
    347    the capability it should use to do so. */
    348 
    349 #define CAP_MAC_OVERRIDE     32
    350 
    351 /* Allow MAC configuration or state changes.
    352    The base kernel requires no MAC configuration.
    353    An LSM may enforce a MAC policy, and if it does and it chooses
    354    to implement capability based checks on modifications to that
    355    policy or the data required to maintain it, this is the
    356    capability it should use to do so. */
    357 
    358 #define CAP_MAC_ADMIN        33
    359 
    360 #define CAP_LAST_CAP         CAP_MAC_ADMIN
    361 
    362 #define cap_valid(x) ((x) >= 0 && (x) <= CAP_LAST_CAP)
    363 
    364 /*
    365  * Bit location of each capability (used by user-space library and kernel)
    366  */
    367 
    368 #define CAP_TO_INDEX(x)     ((x) >> 5)        /* 1 << 5 == bits in __u32 */
    369 #define CAP_TO_MASK(x)      (1 << ((x) & 31)) /* mask for indexed __u32 */
    370 
    371 #ifdef __KERNEL__
    372 
    373 /*
    374  * Internal kernel functions only
    375  */
    376 
    377 #define CAP_FOR_EACH_U32(__capi)  \
    378         for (__capi = 0; __capi < _KERNEL_CAPABILITY_U32S; ++__capi)
    379 
    380 /*
    381  * CAP_FS_MASK and CAP_NFSD_MASKS:
    382  *
    383  * The fs mask is all the privileges that fsuid==0 historically meant.
    384  * At one time in the past, that included CAP_MKNOD and CAP_LINUX_IMMUTABLE.
    385  *
    386  * It has never meant setting security.* and trusted.* xattrs.
    387  *
    388  * We could also define fsmask as follows:
    389  *   1. CAP_FS_MASK is the privilege to bypass all fs-related DAC permissions
    390  *   2. The security.* and trusted.* xattrs are fs-related MAC permissions
    391  */
    392 
    393 # define CAP_FS_MASK_B0     (CAP_TO_MASK(CAP_CHOWN)             \
    394                             | CAP_TO_MASK(CAP_MKNOD)            \
    395                             | CAP_TO_MASK(CAP_DAC_OVERRIDE)     \
    396                             | CAP_TO_MASK(CAP_DAC_READ_SEARCH)  \
    397                             | CAP_TO_MASK(CAP_FOWNER)           \
    398                             | CAP_TO_MASK(CAP_FSETID))
    399 
    400 # define CAP_FS_MASK_B1     (CAP_TO_MASK(CAP_MAC_OVERRIDE))
    401 
    402 #if _KERNEL_CAPABILITY_U32S != 2
    403 # error Fix up hand-coded capability macro initializers
    404 #else /* HAND-CODED capability initializers */
    405 
    406 # define CAP_EMPTY_SET    ((kernel_cap_t){{ 0, 0 }})
    407 # define CAP_FULL_SET     ((kernel_cap_t){{ ~0, ~0 }})
    408 # define CAP_INIT_EFF_SET ((kernel_cap_t){{ ~CAP_TO_MASK(CAP_SETPCAP), ~0 }})
    409 # define CAP_FS_SET       ((kernel_cap_t){{ CAP_FS_MASK_B0 \
    410                                     | CAP_TO_MASK(CAP_LINUX_IMMUTABLE), \
    411                                     CAP_FS_MASK_B1 } })
    412 # define CAP_NFSD_SET     ((kernel_cap_t){{ CAP_FS_MASK_B0 \
    413                                     | CAP_TO_MASK(CAP_SYS_RESOURCE), \
    414                                     CAP_FS_MASK_B1 } })
    415 
    416 #endif /* _KERNEL_CAPABILITY_U32S != 2 */
    417 
    418 #define CAP_INIT_INH_SET    CAP_EMPTY_SET
    419 
    420 # define cap_clear(c)         do { (c) = __cap_empty_set; } while (0)
    421 # define cap_set_full(c)      do { (c) = __cap_full_set; } while (0)
    422 # define cap_set_init_eff(c)  do { (c) = __cap_init_eff_set; } while (0)
    423 
    424 #define cap_raise(c, flag)  ((c).cap[CAP_TO_INDEX(flag)] |= CAP_TO_MASK(flag))
    425 #define cap_lower(c, flag)  ((c).cap[CAP_TO_INDEX(flag)] &= ~CAP_TO_MASK(flag))
    426 #define cap_raised(c, flag) ((c).cap[CAP_TO_INDEX(flag)] & CAP_TO_MASK(flag))
    427 
    428 #define CAP_BOP_ALL(c, a, b, OP)                                    \
    429 do {                                                                \
    430         unsigned __capi;                                            \
    431         CAP_FOR_EACH_U32(__capi) {                                  \
    432                 c.cap[__capi] = a.cap[__capi] OP b.cap[__capi];     \
    433         }                                                           \
    434 } while (0)
    435 
    436 #define CAP_UOP_ALL(c, a, OP)                                       \
    437 do {                                                                \
    438         unsigned __capi;                                            \
    439         CAP_FOR_EACH_U32(__capi) {                                  \
    440                 c.cap[__capi] = OP a.cap[__capi];                   \
    441         }                                                           \
    442 } while (0)
    443 
    444 static inline kernel_cap_t cap_combine(const kernel_cap_t a,
    445                                        const kernel_cap_t b)
    446 {
    447         kernel_cap_t dest;
    448         CAP_BOP_ALL(dest, a, b, |);
    449         return dest;
    450 }
    451 
    452 static inline kernel_cap_t cap_intersect(const kernel_cap_t a,
    453                                          const kernel_cap_t b)
    454 {
    455         kernel_cap_t dest;
    456         CAP_BOP_ALL(dest, a, b, &);
    457         return dest;
    458 }
    459 
    460 static inline kernel_cap_t cap_drop(const kernel_cap_t a,
    461                                     const kernel_cap_t drop)
    462 {
    463         kernel_cap_t dest;
    464         CAP_BOP_ALL(dest, a, drop, &~);
    465         return dest;
    466 }
    467 
    468 static inline kernel_cap_t cap_invert(const kernel_cap_t c)
    469 {
    470         kernel_cap_t dest;
    471         CAP_UOP_ALL(dest, c, ~);
    472         return dest;
    473 }
    474 
    475 static inline int cap_isclear(const kernel_cap_t a)
    476 {
    477         unsigned __capi;
    478         CAP_FOR_EACH_U32(__capi) {
    479                 if (a.cap[__capi] != 0)
    480                         return 0;
    481         }
    482         return 1;
    483 }
    484 
    485 /*
    486  * Check if "a" is a subset of "set".
    487  * return 1 if ALL of the capabilities in "a" are also in "set"
    488  *      cap_issubset(0101, 1111) will return 1
    489  * return 0 if ANY of the capabilities in "a" are not in "set"
    490  *      cap_issubset(1111, 0101) will return 0
    491  */
    492 static inline int cap_issubset(const kernel_cap_t a, const kernel_cap_t set)
    493 {
    494         kernel_cap_t dest;
    495         dest = cap_drop(a, set);
    496         return cap_isclear(dest);
    497 }
    498 
    499 /* Used to decide between falling back on the old suser() or fsuser(). */
    500 
    501 static inline int cap_is_fs_cap(int cap)
    502 {
    503         const kernel_cap_t __cap_fs_set = CAP_FS_SET;
    504         return !!(CAP_TO_MASK(cap) & __cap_fs_set.cap[CAP_TO_INDEX(cap)]);
    505 }
    506 
    507 static inline kernel_cap_t cap_drop_fs_set(const kernel_cap_t a)
    508 {
    509         const kernel_cap_t __cap_fs_set = CAP_FS_SET;
    510         return cap_drop(a, __cap_fs_set);
    511 }
    512 
    513 static inline kernel_cap_t cap_raise_fs_set(const kernel_cap_t a,
    514                                             const kernel_cap_t permitted)
    515 {
    516         const kernel_cap_t __cap_fs_set = CAP_FS_SET;
    517         return cap_combine(a,
    518                            cap_intersect(permitted, __cap_fs_set));
    519 }
    520 
    521 static inline kernel_cap_t cap_drop_nfsd_set(const kernel_cap_t a)
    522 {
    523         const kernel_cap_t __cap_fs_set = CAP_NFSD_SET;
    524         return cap_drop(a, __cap_fs_set);
    525 }
    526 
    527 static inline kernel_cap_t cap_raise_nfsd_set(const kernel_cap_t a,
    528                                               const kernel_cap_t permitted)
    529 {
    530         const kernel_cap_t __cap_nfsd_set = CAP_NFSD_SET;
    531         return cap_combine(a,
    532                            cap_intersect(permitted, __cap_nfsd_set));
    533 }
    534 
    535 extern const kernel_cap_t __cap_empty_set;
    536 extern const kernel_cap_t __cap_full_set;
    537 extern const kernel_cap_t __cap_init_eff_set;
    538 
    539 /**
    540  * has_capability - Determine if a task has a superior capability available
    541  * @t: The task in question
    542  * @cap: The capability to be tested for
    543  *
    544  * Return true if the specified task has the given superior capability
    545  * currently in effect, false if not.
    546  *
    547  * Note that this does not set PF_SUPERPRIV on the task.
    548  */
    549 #define has_capability(t, cap) (security_real_capable((t), (cap)) == 0)
    550 
    551 /**
    552  * has_capability_noaudit - Determine if a task has a superior capability available (unaudited)
    553  * @t: The task in question
    554  * @cap: The capability to be tested for
    555  *
    556  * Return true if the specified task has the given superior capability
    557  * currently in effect, false if not, but don't write an audit message for the
    558  * check.
    559  *
    560  * Note that this does not set PF_SUPERPRIV on the task.
    561  */
    562 #define has_capability_noaudit(t, cap) \
    563         (security_real_capable_noaudit((t), (cap)) == 0)
    564 
    565 extern int capable(int cap);
    566 
    567 /* audit system wants to get cap info from files as well */
    568 struct dentry;
    569 extern int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data *cpu_caps);
    570 
    571 #endif /* __KERNEL__ */
    572 
    573 #endif /* !_LINUX_CAPABILITY_H */
    574 
    
      This page was automatically generated by the LXR engine.
    ]
    Repeat after me
    Le monsieur lutte pour la défense des libertés individuelles et collectives

    Repeat after me...

  11. #11
    Membre extrêmement actif
    Profil pro
    Inscrit en
    Juin 2010
    Messages
    794
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2010
    Messages : 794
    Points : 987
    Points
    987
    Par défaut
    Citation Envoyé par marsupial Voir le message
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    Linux kernel & device driver programming
    Cross-Referenced Linux and Device Driver Code
    [ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
    Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
    
      1 /*
      2  * This is <linux/capability.h>
      3  *
      4  * Andrew G. Morgan <morgan@kernel.org>
      5  * Alexander Kjeldaas <astor@guardian.no>
      6  * with help from Aleph1, Roland Buresund and Andrew Main.
      7  *
      8  * See here for the libcap library ("POSIX draft" compliance):
      9  *
     10  * ftp://linux.kernel.org/pub/linux/lib...vs/kernel-2.6/
     11  */
     12 
     13 #ifndef _LINUX_CAPABILITY_H
     14 #define _LINUX_CAPABILITY_H
     15 
     16 #include <linux/types.h>
     17 
     18 struct task_struct;
     19 
     20 /* User-level do most of the mapping between kernel and user
     21    capabilities based on the version tag given by the kernel. The
     22    kernel might be somewhat backwards compatible, but don't bet on
     23    it. */
     24 
     25 /* Note, cap_t, is defined by POSIX (draft) to be an "opaque" pointer to
     26    a set of three capability sets.  The transposition of 3*the
     27    following structure to such a composite is better handled in a user
     28    library since the draft standard requires the use of malloc/free
     29    etc.. */
     30 
     31 #define _LINUX_CAPABILITY_VERSION_1  0x19980330
     32 #define _LINUX_CAPABILITY_U32S_1     1
     33 
     34 #define _LINUX_CAPABILITY_VERSION_2  0x20071026  /* deprecated - use v3 */
     35 #define _LINUX_CAPABILITY_U32S_2     2
     36 
     37 #define _LINUX_CAPABILITY_VERSION_3  0x20080522
     38 #define _LINUX_CAPABILITY_U32S_3     2
     39 
     40 typedef struct __user_cap_header_struct {
     41         __u32 version;
     42         int pid;
     43 } __user *cap_user_header_t;
     44 
     45 typedef struct __user_cap_data_struct {
     46         __u32 effective;
     47         __u32 permitted;
     48         __u32 inheritable;
     49 } __user *cap_user_data_t;
     50 
     51 
     52 #define XATTR_CAPS_SUFFIX "capability"
     53 #define XATTR_NAME_CAPS XATTR_SECURITY_PREFIX XATTR_CAPS_SUFFIX
     54 
     55 #define VFS_CAP_REVISION_MASK   0xFF000000
     56 #define VFS_CAP_REVISION_SHIFT  24
     57 #define VFS_CAP_FLAGS_MASK      ~VFS_CAP_REVISION_MASK
     58 #define VFS_CAP_FLAGS_EFFECTIVE 0x000001
     59 
     60 #define VFS_CAP_REVISION_1      0x01000000
     61 #define VFS_CAP_U32_1           1
     62 #define XATTR_CAPS_SZ_1         (sizeof(__le32)*(1 + 2*VFS_CAP_U32_1))
     63 
     64 #define VFS_CAP_REVISION_2      0x02000000
     65 #define VFS_CAP_U32_2           2
     66 #define XATTR_CAPS_SZ_2         (sizeof(__le32)*(1 + 2*VFS_CAP_U32_2))
     67 
     68 #define XATTR_CAPS_SZ           XATTR_CAPS_SZ_2
     69 #define VFS_CAP_U32             VFS_CAP_U32_2
     70 #define VFS_CAP_REVISION        VFS_CAP_REVISION_2
     71 
     72 struct vfs_cap_data {
     73         __le32 magic_etc;            /* Little endian */
     74         struct {
     75                 __le32 permitted;    /* Little endian */
     76                 __le32 inheritable;  /* Little endian */
     77         } data[VFS_CAP_U32];
     78 };
     79 
     80 #ifndef __KERNEL__
     81 
     82 /*
     83  * Backwardly compatible definition for source code - trapped in a
     84  * 32-bit world. If you find you need this, please consider using
     85  * libcap to untrap yourself...
     86  */
     87 #define _LINUX_CAPABILITY_VERSION  _LINUX_CAPABILITY_VERSION_1
     88 #define _LINUX_CAPABILITY_U32S     _LINUX_CAPABILITY_U32S_1
     89 
     90 #else
     91 
     92 #define _KERNEL_CAPABILITY_VERSION _LINUX_CAPABILITY_VERSION_3
     93 #define _KERNEL_CAPABILITY_U32S    _LINUX_CAPABILITY_U32S_3
     94 
     95 #ifdef CONFIG_SECURITY_FILE_CAPABILITIES
     96 extern int file_caps_enabled;
     97 #endif
     98 
     99 typedef struct kernel_cap_struct {
    100         __u32 cap[_KERNEL_CAPABILITY_U32S];
    101 } kernel_cap_t;
    102 
    103 /* exact same as vfs_cap_data but in cpu endian and always filled completely */
    104 struct cpu_vfs_cap_data {
    105         __u32 magic_etc;
    106         kernel_cap_t permitted;
    107         kernel_cap_t inheritable;
    108 };
    109 
    110 #define _USER_CAP_HEADER_SIZE  (sizeof(struct __user_cap_header_struct))
    111 #define _KERNEL_CAP_T_SIZE     (sizeof(kernel_cap_t))
    112 
    113 #endif
    114 
    115 
    116 /**
    117  ** POSIX-draft defined capabilities.
    118  **/
    119 
    120 /* In a system with the [_POSIX_CHOWN_RESTRICTED] option defined, this
    121    overrides the restriction of changing file ownership and group
    122    ownership. */
    123 
    124 #define CAP_CHOWN            0
    125 
    126 /* Override all DAC access, including ACL execute access if
    127    [_POSIX_ACL] is defined. Excluding DAC access covered by
    128    CAP_LINUX_IMMUTABLE. */
    129 
    130 #define CAP_DAC_OVERRIDE     1
    131 
    132 /* Overrides all DAC restrictions regarding read and search on files
    133    and directories, including ACL restrictions if [_POSIX_ACL] is
    134    defined. Excluding DAC access covered by CAP_LINUX_IMMUTABLE. */
    135 
    136 #define CAP_DAC_READ_SEARCH  2
    137 
    138 /* Overrides all restrictions about allowed operations on files, where
    139    file owner ID must be equal to the user ID, except where CAP_FSETID
    140    is applicable. It doesn't override MAC and DAC restrictions. */
    141 
    142 #define CAP_FOWNER           3
    143 
    144 /* Overrides the following restrictions that the effective user ID
    145    shall match the file owner ID when setting the S_ISUID and S_ISGID
    146    bits on that file; that the effective group ID (or one of the
    147    supplementary group IDs) shall match the file owner ID when setting
    148    the S_ISGID bit on that file; that the S_ISUID and S_ISGID bits are
    149    cleared on successful return from chown(2) (not implemented). */
    150 
    151 #define CAP_FSETID           4
    152 
    153 /* Overrides the restriction that the real or effective user ID of a
    154    process sending a signal must match the real or effective user ID
    155    of the process receiving the signal. */
    156 
    157 #define CAP_KILL             5
    158 
    159 /* Allows setgid(2) manipulation */
    160 /* Allows setgroups(2) */
    161 /* Allows forged gids on socket credentials passing. */
    162 
    163 #define CAP_SETGID           6
    164 
    165 /* Allows set*uid(2) manipulation (including fsuid). */
    166 /* Allows forged pids on socket credentials passing. */
    167 
    168 #define CAP_SETUID           7
    169 
    170 
    171 /**
    172  ** Linux-specific capabilities
    173  **/
    174 
    175 /* Without VFS support for capabilities:
    176  *   Transfer any capability in your permitted set to any pid,
    177  *   remove any capability in your permitted set from any pid
    178  * With VFS support for capabilities (neither of above, but)
    179  *   Add any capability from current's capability bounding set
    180  *       to the current process' inheritable set
    181  *   Allow taking bits out of capability bounding set
    182  *   Allow modification of the securebits for a process
    183  */
    184 
    185 #define CAP_SETPCAP          8
    186 
    187 /* Allow modification of S_IMMUTABLE and S_APPEND file attributes */
    188 
    189 #define CAP_LINUX_IMMUTABLE  9
    190 
    191 /* Allows binding to TCP/UDP sockets below 1024 */
    192 /* Allows binding to ATM VCIs below 32 */
    193 
    194 #define CAP_NET_BIND_SERVICE 10
    195 
    196 /* Allow broadcasting, listen to multicast */
    197 
    198 #define CAP_NET_BROADCAST    11
    199 
    200 /* Allow interface configuration */
    201 /* Allow administration of IP firewall, masquerading and accounting */
    202 /* Allow setting debug option on sockets */
    203 /* Allow modification of routing tables */
    204 /* Allow setting arbitrary process / process group ownership on
    205    sockets */
    206 /* Allow binding to any address for transparent proxying */
    207 /* Allow setting TOS (type of service) */
    208 /* Allow setting promiscuous mode */
    209 /* Allow clearing driver statistics */
    210 /* Allow multicasting */
    211 /* Allow read/write of device-specific registers */
    212 /* Allow activation of ATM control sockets */
    213 
    214 #define CAP_NET_ADMIN        12
    215 
    216 /* Allow use of RAW sockets */
    217 /* Allow use of PACKET sockets */
    218 
    219 #define CAP_NET_RAW          13
    220 
    221 /* Allow locking of shared memory segments */
    222 /* Allow mlock and mlockall (which doesn't really have anything to do
    223    with IPC) */
    224 
    225 #define CAP_IPC_LOCK         14
    226 
    227 /* Override IPC ownership checks */
    228 
    229 #define CAP_IPC_OWNER        15
    230 
    231 /* Insert and remove kernel modules - modify kernel without limit */
    232 #define CAP_SYS_MODULE       16
    233 
    234 /* Allow ioperm/iopl access */
    235 /* Allow sending USB messages to any device via /proc/bus/usb */
    236 
    237 #define CAP_SYS_RAWIO        17
    238 
    239 /* Allow use of chroot() */
    240 
    241 #define CAP_SYS_CHROOT       18
    242 
    243 /* Allow ptrace() of any process */
    244 
    245 #define CAP_SYS_PTRACE       19
    246 
    247 /* Allow configuration of process accounting */
    248 
    249 #define CAP_SYS_PACCT        20
    250 
    251 /* Allow configuration of the secure attention key */
    252 /* Allow administration of the random device */
    253 /* Allow examination and configuration of disk quotas */
    254 /* Allow configuring the kernel's syslog (printk behaviour) */
    255 /* Allow setting the domainname */
    256 /* Allow setting the hostname */
    257 /* Allow calling bdflush() */
    258 /* Allow mount() and umount(), setting up new smb connection */
    259 /* Allow some autofs root ioctls */
    260 /* Allow nfsservctl */
    261 /* Allow VM86_REQUEST_IRQ */
    262 /* Allow to read/write pci config on alpha */
    263 /* Allow irix_prctl on mips (setstacksize) */
    264 /* Allow flushing all cache on m68k (sys_cacheflush) */
    265 /* Allow removing semaphores */
    266 /* Used instead of CAP_CHOWN to "chown" IPC message queues, semaphores
    267    and shared memory */
    268 /* Allow locking/unlocking of shared memory segment */
    269 /* Allow turning swap on/off */
    270 /* Allow forged pids on socket credentials passing */
    271 /* Allow setting readahead and flushing buffers on block devices */
    272 /* Allow setting geometry in floppy driver */
    273 /* Allow turning DMA on/off in xd driver */
    274 /* Allow administration of md devices (mostly the above, but some
    275    extra ioctls) */
    276 /* Allow tuning the ide driver */
    277 /* Allow access to the nvram device */
    278 /* Allow administration of apm_bios, serial and bttv (TV) device */
    279 /* Allow manufacturer commands in isdn CAPI support driver */
    280 /* Allow reading non-standardized portions of pci configuration space */
    281 /* Allow DDI debug ioctl on sbpcd driver */
    282 /* Allow setting up serial ports */
    283 /* Allow sending raw qic-117 commands */
    284 /* Allow enabling/disabling tagged queuing on SCSI controllers and sending
    285    arbitrary SCSI commands */
    286 /* Allow setting encryption key on loopback filesystem */
    287 /* Allow setting zone reclaim policy */
    288 
    289 #define CAP_SYS_ADMIN        21
    290 
    291 /* Allow use of reboot() */
    292 
    293 #define CAP_SYS_BOOT         22
    294 
    295 /* Allow raising priority and setting priority on other (different
    296    UID) processes */
    297 /* Allow use of FIFO and round-robin (realtime) scheduling on own
    298    processes and setting the scheduling algorithm used by another
    299    process. */
    300 /* Allow setting cpu affinity on other processes */
    301 
    302 #define CAP_SYS_NICE         23
    303 
    304 /* Override resource limits. Set resource limits. */
    305 /* Override quota limits. */
    306 /* Override reserved space on ext2 filesystem */
    307 /* Modify data journaling mode on ext3 filesystem (uses journaling
    308    resources) */
    309 /* NOTE: ext2 honors fsuid when checking for resource overrides, so
    310    you can override using fsuid too */
    311 /* Override size restrictions on IPC message queues */
    312 /* Allow more than 64hz interrupts from the real-time clock */
    313 /* Override max number of consoles on console allocation */
    314 /* Override max number of keymaps */
    315 
    316 #define CAP_SYS_RESOURCE     24
    317 
    318 /* Allow manipulation of system clock */
    319 /* Allow irix_stime on mips */
    320 /* Allow setting the real-time clock */
    321 
    322 #define CAP_SYS_TIME         25
    323 
    324 /* Allow configuration of tty devices */
    325 /* Allow vhangup() of tty */
    326 
    327 #define CAP_SYS_TTY_CONFIG   26
    328 
    329 /* Allow the privileged aspects of mknod() */
    330 
    331 #define CAP_MKNOD            27
    332 
    333 /* Allow taking of leases on files */
    334 
    335 #define CAP_LEASE            28
    336 
    337 #define CAP_AUDIT_WRITE      29
    338 
    339 #define CAP_AUDIT_CONTROL    30
    340 
    341 #define CAP_SETFCAP          31
    342 
    343 /* Override MAC access.
    344    The base kernel enforces no MAC policy.
    345    An LSM may enforce a MAC policy, and if it does and it chooses
    346    to implement capability based overrides of that policy, this is
    347    the capability it should use to do so. */
    348 
    349 #define CAP_MAC_OVERRIDE     32
    350 
    351 /* Allow MAC configuration or state changes.
    352    The base kernel requires no MAC configuration.
    353    An LSM may enforce a MAC policy, and if it does and it chooses
    354    to implement capability based checks on modifications to that
    355    policy or the data required to maintain it, this is the
    356    capability it should use to do so. */
    357 
    358 #define CAP_MAC_ADMIN        33
    359 
    360 #define CAP_LAST_CAP         CAP_MAC_ADMIN
    361 
    362 #define cap_valid(x) ((x) >= 0 && (x) <= CAP_LAST_CAP)
    363 
    364 /*
    365  * Bit location of each capability (used by user-space library and kernel)
    366  */
    367 
    368 #define CAP_TO_INDEX(x)     ((x) >> 5)        /* 1 << 5 == bits in __u32 */
    369 #define CAP_TO_MASK(x)      (1 << ((x) & 31)) /* mask for indexed __u32 */
    370 
    371 #ifdef __KERNEL__
    372 
    373 /*
    374  * Internal kernel functions only
    375  */
    376 
    377 #define CAP_FOR_EACH_U32(__capi)  \
    378         for (__capi = 0; __capi < _KERNEL_CAPABILITY_U32S; ++__capi)
    379 
    380 /*
    381  * CAP_FS_MASK and CAP_NFSD_MASKS:
    382  *
    383  * The fs mask is all the privileges that fsuid==0 historically meant.
    384  * At one time in the past, that included CAP_MKNOD and CAP_LINUX_IMMUTABLE.
    385  *
    386  * It has never meant setting security.* and trusted.* xattrs.
    387  *
    388  * We could also define fsmask as follows:
    389  *   1. CAP_FS_MASK is the privilege to bypass all fs-related DAC permissions
    390  *   2. The security.* and trusted.* xattrs are fs-related MAC permissions
    391  */
    392 
    393 # define CAP_FS_MASK_B0     (CAP_TO_MASK(CAP_CHOWN)             \
    394                             | CAP_TO_MASK(CAP_MKNOD)            \
    395                             | CAP_TO_MASK(CAP_DAC_OVERRIDE)     \
    396                             | CAP_TO_MASK(CAP_DAC_READ_SEARCH)  \
    397                             | CAP_TO_MASK(CAP_FOWNER)           \
    398                             | CAP_TO_MASK(CAP_FSETID))
    399 
    400 # define CAP_FS_MASK_B1     (CAP_TO_MASK(CAP_MAC_OVERRIDE))
    401 
    402 #if _KERNEL_CAPABILITY_U32S != 2
    403 # error Fix up hand-coded capability macro initializers
    404 #else /* HAND-CODED capability initializers */
    405 
    406 # define CAP_EMPTY_SET    ((kernel_cap_t){{ 0, 0 }})
    407 # define CAP_FULL_SET     ((kernel_cap_t){{ ~0, ~0 }})
    408 # define CAP_INIT_EFF_SET ((kernel_cap_t){{ ~CAP_TO_MASK(CAP_SETPCAP), ~0 }})
    409 # define CAP_FS_SET       ((kernel_cap_t){{ CAP_FS_MASK_B0 \
    410                                     | CAP_TO_MASK(CAP_LINUX_IMMUTABLE), \
    411                                     CAP_FS_MASK_B1 } })
    412 # define CAP_NFSD_SET     ((kernel_cap_t){{ CAP_FS_MASK_B0 \
    413                                     | CAP_TO_MASK(CAP_SYS_RESOURCE), \
    414                                     CAP_FS_MASK_B1 } })
    415 
    416 #endif /* _KERNEL_CAPABILITY_U32S != 2 */
    417 
    418 #define CAP_INIT_INH_SET    CAP_EMPTY_SET
    419 
    420 # define cap_clear(c)         do { (c) = __cap_empty_set; } while (0)
    421 # define cap_set_full(c)      do { (c) = __cap_full_set; } while (0)
    422 # define cap_set_init_eff(c)  do { (c) = __cap_init_eff_set; } while (0)
    423 
    424 #define cap_raise(c, flag)  ((c).cap[CAP_TO_INDEX(flag)] |= CAP_TO_MASK(flag))
    425 #define cap_lower(c, flag)  ((c).cap[CAP_TO_INDEX(flag)] &= ~CAP_TO_MASK(flag))
    426 #define cap_raised(c, flag) ((c).cap[CAP_TO_INDEX(flag)] & CAP_TO_MASK(flag))
    427 
    428 #define CAP_BOP_ALL(c, a, b, OP)                                    \
    429 do {                                                                \
    430         unsigned __capi;                                            \
    431         CAP_FOR_EACH_U32(__capi) {                                  \
    432                 c.cap[__capi] = a.cap[__capi] OP b.cap[__capi];     \
    433         }                                                           \
    434 } while (0)
    435 
    436 #define CAP_UOP_ALL(c, a, OP)                                       \
    437 do {                                                                \
    438         unsigned __capi;                                            \
    439         CAP_FOR_EACH_U32(__capi) {                                  \
    440                 c.cap[__capi] = OP a.cap[__capi];                   \
    441         }                                                           \
    442 } while (0)
    443 
    444 static inline kernel_cap_t cap_combine(const kernel_cap_t a,
    445                                        const kernel_cap_t b)
    446 {
    447         kernel_cap_t dest;
    448         CAP_BOP_ALL(dest, a, b, |);
    449         return dest;
    450 }
    451 
    452 static inline kernel_cap_t cap_intersect(const kernel_cap_t a,
    453                                          const kernel_cap_t b)
    454 {
    455         kernel_cap_t dest;
    456         CAP_BOP_ALL(dest, a, b, &);
    457         return dest;
    458 }
    459 
    460 static inline kernel_cap_t cap_drop(const kernel_cap_t a,
    461                                     const kernel_cap_t drop)
    462 {
    463         kernel_cap_t dest;
    464         CAP_BOP_ALL(dest, a, drop, &~);
    465         return dest;
    466 }
    467 
    468 static inline kernel_cap_t cap_invert(const kernel_cap_t c)
    469 {
    470         kernel_cap_t dest;
    471         CAP_UOP_ALL(dest, c, ~);
    472         return dest;
    473 }
    474 
    475 static inline int cap_isclear(const kernel_cap_t a)
    476 {
    477         unsigned __capi;
    478         CAP_FOR_EACH_U32(__capi) {
    479                 if (a.cap[__capi] != 0)
    480                         return 0;
    481         }
    482         return 1;
    483 }
    484 
    485 /*
    486  * Check if "a" is a subset of "set".
    487  * return 1 if ALL of the capabilities in "a" are also in "set"
    488  *      cap_issubset(0101, 1111) will return 1
    489  * return 0 if ANY of the capabilities in "a" are not in "set"
    490  *      cap_issubset(1111, 0101) will return 0
    491  */
    492 static inline int cap_issubset(const kernel_cap_t a, const kernel_cap_t set)
    493 {
    494         kernel_cap_t dest;
    495         dest = cap_drop(a, set);
    496         return cap_isclear(dest);
    497 }
    498 
    499 /* Used to decide between falling back on the old suser() or fsuser(). */
    500 
    501 static inline int cap_is_fs_cap(int cap)
    502 {
    503         const kernel_cap_t __cap_fs_set = CAP_FS_SET;
    504         return !!(CAP_TO_MASK(cap) & __cap_fs_set.cap[CAP_TO_INDEX(cap)]);
    505 }
    506 
    507 static inline kernel_cap_t cap_drop_fs_set(const kernel_cap_t a)
    508 {
    509         const kernel_cap_t __cap_fs_set = CAP_FS_SET;
    510         return cap_drop(a, __cap_fs_set);
    511 }
    512 
    513 static inline kernel_cap_t cap_raise_fs_set(const kernel_cap_t a,
    514                                             const kernel_cap_t permitted)
    515 {
    516         const kernel_cap_t __cap_fs_set = CAP_FS_SET;
    517         return cap_combine(a,
    518                            cap_intersect(permitted, __cap_fs_set));
    519 }
    520 
    521 static inline kernel_cap_t cap_drop_nfsd_set(const kernel_cap_t a)
    522 {
    523         const kernel_cap_t __cap_fs_set = CAP_NFSD_SET;
    524         return cap_drop(a, __cap_fs_set);
    525 }
    526 
    527 static inline kernel_cap_t cap_raise_nfsd_set(const kernel_cap_t a,
    528                                               const kernel_cap_t permitted)
    529 {
    530         const kernel_cap_t __cap_nfsd_set = CAP_NFSD_SET;
    531         return cap_combine(a,
    532                            cap_intersect(permitted, __cap_nfsd_set));
    533 }
    534 
    535 extern const kernel_cap_t __cap_empty_set;
    536 extern const kernel_cap_t __cap_full_set;
    537 extern const kernel_cap_t __cap_init_eff_set;
    538 
    539 /**
    540  * has_capability - Determine if a task has a superior capability available
    541  * @t: The task in question
    542  * @cap: The capability to be tested for
    543  *
    544  * Return true if the specified task has the given superior capability
    545  * currently in effect, false if not.
    546  *
    547  * Note that this does not set PF_SUPERPRIV on the task.
    548  */
    549 #define has_capability(t, cap) (security_real_capable((t), (cap)) == 0)
    550 
    551 /**
    552  * has_capability_noaudit - Determine if a task has a superior capability available (unaudited)
    553  * @t: The task in question
    554  * @cap: The capability to be tested for
    555  *
    556  * Return true if the specified task has the given superior capability
    557  * currently in effect, false if not, but don't write an audit message for the
    558  * check.
    559  *
    560  * Note that this does not set PF_SUPERPRIV on the task.
    561  */
    562 #define has_capability_noaudit(t, cap) \
    563         (security_real_capable_noaudit((t), (cap)) == 0)
    564 
    565 extern int capable(int cap);
    566 
    567 /* audit system wants to get cap info from files as well */
    568 struct dentry;
    569 extern int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data *cpu_caps);
    570 
    571 #endif /* __KERNEL__ */
    572 
    573 #endif /* !_LINUX_CAPABILITY_H */
    574 
    
      This page was automatically generated by the LXR engine.
    ]
    Oui pourquoi ?

  12. #12
    Membre expérimenté
    Avatar de Frank
    Homme Profil pro
    Chef de projet Informatique
    Inscrit en
    Avril 2002
    Messages
    1 095
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Chef de projet Informatique
    Secteur : Industrie Pharmaceutique

    Informations forums :
    Inscription : Avril 2002
    Messages : 1 095
    Points : 1 392
    Points
    1 392
    Par défaut
    Bizarre,
    quand je clique sur le lien AVTEST, le classement que j'obtiens est complètement différent
    Nom : AV_Test.jpg
Affichages : 526
Taille : 244,3 Ko

  13. #13
    Expert éminent
    Avatar de transgohan
    Homme Profil pro
    Développeur Temps réel Embarqué
    Inscrit en
    Janvier 2011
    Messages
    3 146
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Maine et Loire (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur Temps réel Embarqué

    Informations forums :
    Inscription : Janvier 2011
    Messages : 3 146
    Points : 9 386
    Points
    9 386
    Par défaut
    Citation Envoyé par Frank Voir le message
    Bizarre,
    quand je clique sur le lien AVTEST, le classement que j'obtiens est complètement différent
    Je viens de vérifier et pour ma part j'obtiens le même classement quand je filtre sur performance.

    « Toujours se souvenir que la majorité des ennuis viennent de l'espace occupé entre la chaise et l'écran de l'ordinateur. »
    « Le watchdog aboie, les tests passent »

  14. #14
    Membre régulier
    Homme Profil pro
    Directeur de projet
    Inscrit en
    Juin 2011
    Messages
    44
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2011
    Messages : 44
    Points : 114
    Points
    114
    Par défaut Le test est basé sur la version 4.6 de Win Defender. Or, sur Windows 8.1, on utilise la version 4.7
    Je ne suis pas spécialement un fan de Windows-Defender, mais il y a quand même un aspect qui m'interpelle dans ce test comparatif.

    En effet, lorsque qu'on va sur le site qui propose le résultat du test, on constate que la version du Windows-Defender utilisé pour le test est la 4.6. Sauf qu'en février, la version 4.7 était déjà disponible.

    Il est bien évident que si l'objectif est de démontrer qu'une installation pas correctement maintenue à jour depuis 6 mois ne dispose pas des définitions des 6 derniers mois, ce test est une vraie lapalissade. Pour que le test soit réellement parlant, il aurait sans doute été judicieux d'utiliser une version à jour du programme. Il s'en suit que les résultats de ce test sont certainement biaisés.

    Voilà qui fait encore couler autant d'encre que nous faire perdre notre temps.

    Il faut être toujours très circonspect lorsqu'on considère de tels tests. Ils sont en effet rarement dépourvu de toute influence. De plus, pour ce faire une idée plus réaliste, il est préférable de ne pas se fier à un seul test ponctuel. Généralement, les résultats fluctuent assez fortement d'une fois à l'autre.

    Personnellement, j'utilise plusieurs des anti-virus mentionné sur plusieurs machines différentes. Jusqu'à présent, le seul anti-virus qui ne m'a pas vraiment satisfait était de Symantec (très lourd, et pire, planté tout en continuant de dire que tout allait bien).

  15. #15
    Modérateur
    Avatar de sevyc64
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Janvier 2007
    Messages
    10 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 51
    Localisation : France, Pyrénées Atlantiques (Aquitaine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 191
    Points : 28 070
    Points
    28 070
    Par défaut
    Citation Envoyé par l.bruninx Voir le message
    En effet, lorsque qu'on va sur le site qui propose le résultat du test, on constate que la version du Windows-Defender utilisé pour le test est la 4.6. Sauf qu'en février, la version 4.7 était déjà disponible.

    Il est bien évident que si l'objectif est de démontrer qu'une installation pas correctement maintenue à jour depuis 6 mois ne dispose pas des définitions des 6 derniers mois, ce test est une vraie lapalissade. Pour que le test soit réellement parlant, il aurait sans doute été judicieux d'utiliser une version à jour du programme. Il s'en suit que les résultats de ce test sont certainement biaisés.
    Attention, dans le cas d'antivirus, il faut bien faire la différence entre mise à jour du logiciel et mise à jour de la base de signature. LA base de signature peut être mise à jour très régulièrement (plusieurs fois par jour pour certains) et être valable pour plusieurs versions du logiciel.
    Ne pas avoir la dernière version du logiciel ne signifie aucunement qu'il n'utilise pas la dernière base de signature valide.

    Dans le cas de WD, il est mis à jour de manière transparente par les patchs Thuesday de Microsoft. Il est possible que le test ici ait été fait avant que la v7 soit poussée sur la machine. De plus, si le test à duré plusieurs jours, et qu'il a été commencé avec la v6, pour qu'il soit cohérent, les testeurs ont certainement empêcher la mise à jour en cours de route.
    --- Sevyc64 ---

    Parce que le partage est notre force, la connaissance sera notre victoire

  16. #16
    Nouveau Candidat au Club
    Homme Profil pro
    Technicien réseau
    Inscrit en
    Février 2015
    Messages
    1
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Morbihan (Bretagne)

    Informations professionnelles :
    Activité : Technicien réseau
    Secteur : Enseignement

    Informations forums :
    Inscription : Février 2015
    Messages : 1
    Points : 1
    Points
    1
    Par défaut
    @JML19
    Il est bien évident que si un anti virus empêchait d'avoir des virus depuis le temps cela se saurait.
    Un anti-virus reste efficace dans le cadre ou l'utilisateur n'a pas une navigation à risque :-).

    Après évidemment si l'utilisateur va sur certains sites non certifié, il y va en connaissance de cause en acceptant que la protection sera réduite ou inefficace face aux scripts non vérifiés et autres saloperies environnantes du dit site visité.

    Cdt.

  17. #17
    Membre éprouvé

    Homme Profil pro
    Développeur PHP/Symfony // Mentor OpenClassrooms
    Inscrit en
    Octobre 2014
    Messages
    203
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hautes Alpes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Développeur PHP/Symfony // Mentor OpenClassrooms
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Octobre 2014
    Messages : 203
    Points : 1 264
    Points
    1 264
    Billets dans le blog
    3
    Par défaut
    Personnellement je tourne sur Kaspersky, je ne fait pas l'apologie de ce monde mais il se défend bien mieux que tout les autres (notez la phrase pleine de sous-entendus ).

    Comme le disent certains, rien ne remplacera l'utilisateur, combien chopent des merdes juste en naviguant sur des eaux non sécurisées ?

  18. #18
    Expert éminent Avatar de marsupial
    Homme Profil pro
    Retraité
    Inscrit en
    Mars 2014
    Messages
    1 760
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Autre

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Mars 2014
    Messages : 1 760
    Points : 7 185
    Points
    7 185
    Par défaut
    Citation Envoyé par redcurve Voir le message
    Oui pourquoi ?
    Parce-que je voulais savoir comment les antivirus pouvaient être aussi nuls . Je vérifiais donc par rapport à Linux, et ma progression.
    Je crois que cela va en revenir à A3.
    Peut-être en mieux.


    Naviguer en eaux troubles remplit la base de connaissance indispensable de nos jours face aux menaces des cyber-espions. Rôle d'aspirateur.
    Repeat after me
    Le monsieur lutte pour la défense des libertés individuelles et collectives

    Repeat after me...

  19. #19
    Membre expérimenté Avatar de stigma
    Homme Profil pro
    Créateur jeux vidéo
    Inscrit en
    Octobre 2003
    Messages
    1 109
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 73
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Créateur jeux vidéo
    Secteur : Arts - Culture

    Informations forums :
    Inscription : Octobre 2003
    Messages : 1 109
    Points : 1 608
    Points
    1 608
    Par défaut Comodo
    J'utilise Comodo après avoir teste AVG et Avira. Beaucoup plus léger !

  20. #20
    Membre à l'essai
    Homme Profil pro
    Inscrit en
    Mai 2012
    Messages
    22
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Mai 2012
    Messages : 22
    Points : 22
    Points
    22
    Par défaut
    Sur av-comparatives.org (bien que leur dernier test est à peine assez récent), ils sont du même avis : MSE est le pire des antivirus.

    De mon côté, j'alterne entre Kaspersky et Bitdefender. Ils sont à peut prêt au même niveau de protection. Quand je dois conseiller un gratuit, j'alterne entre Avira Antivir (mon choix du moment) et Avast (pas terrible en ce moment).

Discussions similaires

  1. Windows Defender introuvable
    Par Invité dans le forum Windows Vista
    Réponses: 2
    Dernier message: 19/04/2007, 18h09
  2. [Cal3D] OpenGL/Cal3D 20x plus lents sous windows
    Par nicoenz dans le forum Moteurs 3D
    Réponses: 2
    Dernier message: 17/11/2006, 13h36
  3. [C#] niveau de protection des classes
    Par heavydrinker dans le forum Windows Forms
    Réponses: 2
    Dernier message: 08/08/2006, 15h16
  4. Installer Windows defender sur Windows 2000 ? possible ?
    Par mullger dans le forum Sécurité
    Réponses: 5
    Dernier message: 18/05/2006, 10h15
  5. Réponses: 7
    Dernier message: 10/11/2005, 15h12

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo