Проверка целостности корня с помощью скрипта

Не обижайтесь, но ваш код полностью нарушен. Вы используете цитаты ... творчески, но совершенно неправильно. К сожалению, Ваш код подвержен расширению пути и разделению слов. И это действительно позор, чтобы иметь небезопасный код для "защиты" вашего PATH.

Одна стратегия заключается в том, чтобы (безопасно!) разбейте переменную PATH на массив и сканируйте каждую запись. Расщепление производится следующим образом:

IFS=: read -r -d '' -a path_ary < <(printf '%s:\0' "$PATH")

Смотрите мой макет which и Как разделить строку на разделитель отвечает.

С помощью этой команды вы получите хороший массив path_ary, содержащий все поля PATH.

Затем вы можете проверить, есть ли там пустое поле, или поле ., или относительный путь:

for ((i=0;i<${#path_ary[@]};++i)); do
    if [[ ${path_ary[i]} = ?(.) ]]; then
        printf 'Warning: the entry %d contains the current dir\n' "$i"
    elif [[ ${path_ary[i]} != /* ]]; then
        printf 'Warning: the entry %s is not an absolute path\n' "$i"
    fi
done

Вы можете добавить еще elif, например, чтобы проверить, не является ли запись допустимым каталогом:

elif [[ ! -d ${path_ary[i]} ]]; then
    printf 'Warning: the entry %s is not a directory\n' "$i"

Теперь, чтобы проверить разрешение и право собственности, к сожалению, нет ни чистых способов Bash, ни портативных способов продолжения. Но разбор Весьма вероятно, что это не очень хорошая идея. stat может работать, но, как известно, имеет различное поведение на разных платформах. Так что вам придется поэкспериментировать с тем, что вам подходит. Вот пример, который работает с GNU stat в Linux:

read perms owner_id < <(/usr/bin/stat -Lc '%a %u' -- "${path_ary[i]}")

Вы захотите проверить, что owner_id является 0 (обратите внимание, что это нормально иметь путь dir, который не принадлежит root; например, у меня есть /home/gniourf/bin, и это нормально!). perms находится в восьмеричном, и вы можете легко проверить для g+w или o+w с битом тесты:

elif [[ $owner_id != 0 ]]; then
    printf 'Warning: the entry %s is not owned by root\n' "$i"
elif ((0022&8#$perms)); then
    printf 'Warning: the entry %s has group or other write permission\n' "$i"

Обратите внимание на использование 8#$perms, чтобы заставить Баша понимать perms как восьмеричное число. Теперь, чтобы удалить их, вы можете unset path_ary[i] при срабатывании одного из этих тестов, а затем поместить все оставшиеся обратно в PATH:

else
    # In the else statement, the corresponding entry is good
    unset_it=false
fi
if $unset_it; then
    printf 'Unsetting entry %s: %s\n' "$i" "${path_ary[i]}"
    unset path_ary[i]
fi

Конечно, у вас будет unset_it=true в качестве первой инструкции цикла.

И вернуть все обратно в PATH:

IFS=: eval 'PATH="${path_ary[*]}"'

Я знаю, что некоторые будут громко кричать, что это зло, но это каноническое (и безопасное!) путь к соедините элементы массива в Bash (обратите внимание на одинарные кавычки).

Наконец, соответствующая функция может выглядеть следующим образом:

clean_path() {
    local path_ary perms owner_id unset_it
    IFS=: read -r -d '' -a path_ary < <(printf '%s:\0' "$PATH")
    for ((i=0;i<${#path_ary[@]};++i)); do
        unset_it=true
        read perms owner_id < <(/usr/bin/stat -Lc '%a %u' -- "${path_ary[i]}" 2>/dev/null)
        if [[ ${path_ary[i]} = ?(.) ]]; then
            printf 'Warning: the entry %d contains the current dir\n' "$i"
        elif [[ ${path_ary[i]} != /* ]]; then
            printf 'Warning: the entry %s is not an absolute path\n' "$i"
        elif [[ ! -d ${path_ary[i]} ]]; then
            printf 'Warning: the entry %s is not a directory\n' "$i"
        elif [[ $owner_id != 0 ]]; then
            printf 'Warning: the entry %s is not owned by root\n' "$i"
        elif ((0022 & 8#$perms)); then
            printf 'Warning: the entry %s has group or other write permission\n' "$i"
        else
            # In the else statement, the corresponding entry is good
            unset_it=false
        fi

        if $unset_it; then
            printf 'Unsetting entry %s: %s\n' "$i" "${path_ary[i]}"
            unset path_ary[i]
        fi
    done

    IFS=: eval 'PATH="${path_ary[*]}"'
}

Эта конструкция с if/elif/.../else/fi хороша для этой простой задачи, но может стать неудобной для использования для более сложных тестов. Например, обратите внимание, что мы должны были вызвать stat заранее перед тестами, чтобы информация была доступна позже в тестах, прежде чем мы даже проверили, что имеем дело с каталогом.

Конструкция может быть изменена с помощью своего рода спагетти ужасны следующим образом:

for ((oneblock=1;oneblock--;)); do
    # This block is only executed once
    # You can exit this block with break at any moment
done

Обычно гораздо лучше использовать функцию вместо этого и return из функции. Но поскольку в следующем я также собираюсь проверить наличие нескольких записей, мне понадобится таблица подстановки (ассоциативный массив), и странно иметь независимую функцию, которая использует ассоциативный массив, определенный где-то еще...

clean_path() {
    local path_ary perms owner_id unset_it oneblock
    local -A lookup
    IFS=: read -r -d '' -a path_ary < <(printf '%s:\0' "$PATH")
    for ((i=0;i<${#path_ary[@]};++i)); do
        unset_it=true
        for ((oneblock=1;oneblock--;)); do
            if [[ ${path_ary[i]} = ?(.) ]]; then
                printf 'Warning: the entry %d contains the current dir\n' "$i"
                break
            elif [[ ${path_ary[i]} != /* ]]; then
                printf 'Warning: the entry %s is not an absolute path\n' "$i"
                break
            elif [[ ! -d ${path_ary[i]} ]]; then
                printf 'Warning: the entry %s is not a directory\n' "$i"
                break
            elif [[ ${lookup[${path_ary[i]}]} ]]; then
                printf 'Warning: the entry %s appears multiple times\n' "$i"
                break
            fi
            # Here I'm sure I'm dealing with a directory
            read perms owner_id < <(/usr/bin/stat -Lc '%a %u' -- "${path_ary[i]}")
            if [[ $owner_id != 0 ]]; then
                printf 'Warning: the entry %s is not owned by root\n' "$i"
                break
            elif ((0022 & 8#$perms)); then
                printf 'Warning: the entry %s has group or other write permission\n' "$i"
                break
            fi
            # All tests passed, will keep it
            lookup[${path_ary[i]}]=1
            unset_it=false
        done
        if $unset_it; then
            printf 'Unsetting entry %s: %s\n' "$i" "${path_ary[i]}"
            unset path_ary[i]
        fi
    done

    IFS=: eval 'PATH="${path_ary[*]}"'
}

Все это действительно безопасно в отношении пробелов и символов Глоб и новых строк внутри PATH; только что мне действительно не нравится, так это использование внешней (и непереносимой) команды stat.