Comment rechercher des fichiers avec un ensemble d'attributs immuable?

Pour des raisons d'audit de configuration, je souhaite pouvoir rechercher dans mon système de fichiers ext3 des fichiers dont l'attribut immuable est défini (via chattr +i). Je ne trouve aucune option findou similaire pour cela. À ce stade, je crains de devoir écrire mon propre script pour analyser la lsattrsortie de chaque répertoire. Existe-t-il un utilitaire standard qui offre un meilleur moyen?

Cela peut être partiellement accompli en canalisant la grepcommande pour lsattrcommander.

lsattr -R | grep +i

Cependant, je pense que lorsque vous mentionnez l'ensemble ext3du système de fichiers que la recherche peut impliquer /proc, /devainsi que certains autres répertoires qui, s'ils signalent une erreur, vous souhaitez simplement ignorer. Vous pouvez probablement exécuter la commande en tant que,

lsattr -R 2>/dev/null | grep -- "-i-"

Vous voudrez peut-être rendre le grepun peu plus strict en utilisant grepla fonction PCRE de pour faire correspondre plus explicitement le "-i-".

lsattr -R 2>/dev/null | grep -P "(?<=-)i(?=-)"

Cela fonctionnera alors pour des situations comme celle-ci:

$ lsattr -R 2>/dev/null afile | grep -P "(?<=-)i(?=-)"
----i--------e-- afile

Mais est imparfait. S'il y a des attributs supplémentaires activés autour de l'indicateur immuable, alors nous ne les ferons pas correspondre, et cela sera trompé par des fichiers dont les noms correspondent également au modèle ci-dessus, comme celui-ci:

$ lsattr -R 2>/dev/null afile* | grep -P "(?<=-)i(?=-)"
----i--------e-- afile
-------------e-- afile-i-am

Nous pouvons resserrer le modèle un peu plus comme ceci:

$ lsattr -a -R 2>/dev/null afile* | grep -P "(?<=-)i(?=-).* "
----i--------e-- afile

Mais il est toujours un peu trop fragile et nécessiterait des ajustements supplémentaires en fonction des fichiers de votre système de fichiers. Sans oublier que @StephaneChazeles a mentionné dans les commentaires que cela peut être joué assez facilement par l'inclusion de nouvelles lignes avec un nom de fichier pour contourner le modèle ci-dessus grep.

Les références

https://groups.google.com/forum/#!topic/alt.os.linux/LkatROg2SlM

Étant donné que le but du script est l'audit, il est particulièrement important de traiter correctement les noms de fichiers arbitraires, par exemple les noms contenant des retours à la ligne. Cela rend impossible l'utilisation lsattrsimultanée sur plusieurs fichiers, car la sortie de lsattrpeut être ambiguë dans ce cas.

Vous pouvez recurse findet appeler lsattrsur un fichier à la fois. Ce sera assez lent cependant.

find / -xdev -exec sh -c '
  for i do
     attrs=$(lsattr -d "$i"); attrs=${attrs%% *}
     case $attrs in
       *i*) printf "%s\0" "$i";;
     esac
  done' sh {} +

Je recommande d'utiliser un langage moins grincheux comme Perl, Python ou Ruby et de faire le travail lsattrpar vous-même. lsattrfonctionne en émettant un FS_IOC_GETFLAGSappel système ioctl et en récupérant les indicateurs d'inode du fichier . Voici une preuve de concept Python.

#!/usr/bin/env python2
import array, fcntl, os, sys
FS_IOC_GETFLAGS = 0x80086601
EXT3_IMMUTABLE_FL = 0x00000010
count = 0
def check(filename):
    fd = os.open(filename, os.O_RDONLY)
    a = array.array('L', [0])
    fcntl.ioctl(fd, FS_IOC_GETFLAGS, a, True)
    if a[0] & EXT3_IMMUTABLE_FL: 
        sys.stdout.write(filename + '\0')
        global count
        count += 1
    os.close(fd)
for x in sys.argv[1:]:
    for (dirpath, dirnames, filenames) in os.walk(x):
        for name in dirnames + filenames:
            check(os.path.join(dirpath, name))
if count != 0: exit(1)

Pour gérer les noms de fichiers arbitraires (y compris ceux contenant des caractères de nouvelle ligne), l' astuce habituelle consiste à rechercher des fichiers à l'intérieur .//.au lieu de .. Étant donné que //cela ne peut normalement pas se produire lors de la traversée de l'arborescence des répertoires, vous êtes sûr qu'un //signale le début d'un nouveau nom de fichier dans la sortie find(ou ici lsattr -R).

lsattr -R .//. | awk '
  function process() {
    i = index(record, " ")
    if (i && index(substr(record,1,i), "i"))
      print substr(record, i+4)
  }
  {
    if (/\/\//) {
      process()
      record=$0
    } else {
      record = record "\n" $0
    }
  }
  END{process()}'

Notez que la sortie sera toujours séparée par des sauts de ligne. Si vous devez le post-traiter, vous devrez l'adapter. Par exemple, vous pouvez ajouter un -v ORS='\0'pour pouvoir le transmettre aux GNU xargs -r0.

Notez également que lsattr -R(au moins 1.42.13) ne peut pas signaler les indicateurs de fichiers dont le chemin est plus grand que PATH_MAX (généralement 4096), donc quelqu'un pourrait masquer un tel fichier immuable en déplaçant son répertoire parent (ou l'un des composants de chemin qui mènent à , sauf lui-même car il est immuable) dans un répertoire très profond.

Une solution de contournement consisterait à utiliser findavec -execdir:

find . -execdir sh -c '
  a=$(lsattr -d "$1") &&
    case ${a%% *} in
      (*i*) ;;
      (*) false
    esac' sh {} \; -print0

Maintenant, avec -print0, c'est post-processable, mais si vous avez l'intention de faire quoi que ce soit avec ces chemins, notez que tout appel système sur des chemins de fichier supérieurs à PATH_MAX échouera toujours et les composants de répertoire auraient pu être renommés dans l'intervalle.

Si nous voulons obtenir un rapport fiable sur une arborescence de répertoires potentiellement accessible en écriture par d'autres, il y a quelques autres problèmes inhérents à la lsattrcommande elle-même que nous devons mentionner:

• le chemin lsattr -R .traverse l'arborescence des répertoires, il est soumis à des conditions de concurrence. On peut le faire descendre dans des répertoires en dehors de l'arborescence de répertoires routés .en remplaçant certains répertoires par des liens symboliques au bon moment.
• a même lsattr -d fileune condition de course. Ces attributs ne s'appliquent qu'aux fichiers ou répertoires standard. Alors , lsattrfait un lstat()premier à vérifier que le fichier est des bons types et ne open()suivi ioctl()pour récupérer les attributs. Mais il appelle open()sans O_NOFOLLOW(ni O_NOCTTY). Quelqu'un pourrait remplacer filepar un lien symbolique /dev/watchdogpar exemple entre le lstat()et open()et provoquer le redémarrage du système. Il faut le faire open(O_PATH|O_NOFOLLOW)suivi fstat(), openat()et ioctl()ici pour éviter les conditions de course.

Merci à Ramesh, slm et Stéphane de m'avoir pointé dans la bonne direction (il me manquait le -Rswitch pour lsattr). Malheureusement, aucune des réponses n'a jusqu'à présent fonctionné correctement pour moi.

J'ai trouvé ce qui suit:

lsattr -aR .//. | sed -rn '/i.+\.\/\/\./s/\.\/\///p'

Cela protège contre les sauts de ligne utilisés pour faire apparaître un fichier comme immuable alors qu'il ne l'est pas. Il ne protège pas contre les fichiers qui sont définis comme immuables et qui ont des nouvelles lignes dans leurs noms de fichiers. Mais comme un tel fichier devrait être créé de cette façon par root, je peux être sûr que de tels fichiers n'existent pas sur mon système de fichiers pour mon cas d'utilisation. (Cette méthode ne convient pas à la détection d'intrusion dans les cas où l'utilisateur root peut être compromis, mais aucun n'utilise l' lsattrutilitaire du même système qui appartient également au même utilisateur root.)

L'utilisation find -execest trop lente, l'analyse de la sortie de lsattrn'est pas fiable de la même manière que celle dels , l'utilisation de Python comme dans la réponse de Gilles nécessite de choisir la constante pour ioctlselon que l'interpréteur Python est 32 ou 64 bits ...

Le problème est plus ou moins bas, alors allons plus bas: C ++ n'est pas si mal comme langage de script :) En bonus, il a accès aux en-têtes C du système avec toute la puissance du préprocesseur C.

Le programme suivant recherche des fichiers immuables, en restant dans un système de fichiers, c'est-à-dire qu'il ne traverse jamais de points de montage. Pour rechercher l'arbre apparent, en traversant les points de montage si nécessaire, supprimez le FTW_MOUNTdrapeau dans l' nftwappel. De plus, il ne suit pas les liens symboliques. Pour les suivre, supprimez le FTW_PHYSdrapeau.

#define _FILE_OFFSET_BITS 64
#include <iostream>
#include <stdio.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/fs.h>
#include <sys/stat.h>
#include <ftw.h>

bool isImmutable(const char* path)
{
    static const int EXT3_IMMUTABLE_FLAG=0x10;

    const int fd=open(path,O_RDONLY|O_NONBLOCK|O_LARGEFILE);
    if(fd<=0)
    {
        perror(("Failed to open file \""+std::string(path)+"\"").c_str());
        return false;
    }
    unsigned long attrs;
    if(ioctl(fd,FS_IOC_GETFLAGS,&attrs)==-1)
    {
        perror(("Failed to get flags for file \""+std::string(path)+"\"").c_str());
        close(fd);
        return false;
    }
    close(fd);
    return attrs & EXT3_IMMUTABLE_FLAG;
}

int processPath(const char* path, const struct stat* info, int type, FTW* ftwbuf)
{
    switch(type)
    {
    case FTW_DNR:
        std::cerr << "Failed to read directory: " << path << "\n";
        return 0;
    case FTW_F:
        if(isImmutable(path))
            std::cout << path << '\n';
        return 0;
    }
    return 0;
}

int main(int argc, char** argv)
{
    if(argc!=2)
    {
        std::cerr << "Usage: " << argv[0] << " dir\n";
        return 1;
    }
    static const int maxOpenFDs=15;
    if(nftw(argv[1],processPath,maxOpenFDs,FTW_PHYS|FTW_MOUNT))
    {
        perror("nftw failed");
        return 1;
    }
}

Au lieu de diriger la sortie vers grep, pourquoi ne pas simplement utiliser awk pour ne faire correspondre que le «i» dans le premier champ de la sortie?

lsattr -Ra 2>/dev/null /|awk '$1 ~ /i/ && $1 !~ /^\// {print}'

En fait, je l'exécute quotidiennement via cron pour analyser le répertoire / etc sur des centaines de serveurs et envoyer la sortie à syslog. Je peux ensuite générer un rapport quotidien via Splunk:

lsattr -Ra 2>/dev/null /etc|awk '$1 ~ /i/ && $1 !~ /^\// {print "Immutable_file="$2}'|logger -p local0.notice -t find_immutable

Très simple, allez dans le dossier suspect et exécutez la commande:

lsattr -laR | grep *immutable