devops-курс Все курсы

✻ Урок 1.3 · Тема 1: Linux, Bash и systemd

Пользователи, права и sudo

⏱ 4 ч

Как работать с кодом и когда идти дальше

Команды не нужно писать по памяти. Пользуйся примерами из урока и справкой. Ориентируйся на цель задания:

  • Запусти готовое. Код приложения и вспомогательных скриптов можно скопировать. Пойми, зачем они нужны, что запускают или меняют и как проверить результат. Разбирать каждую функцию внутри готового инструмента не требуется.
  • Измени по образцу. Разбери новые конструкции, объяснённые в уроке. Измени указанный параметр или часть кода, предскажи результат и проверь запуском.
  • Напиши сам. Собери свой вариант под условия задания. Образцы и справка разрешены: важно объяснить своё решение и проверить его работу.

Можно идти дальше, если ты выполнил практику, получил ожидаемый результат и понимаешь, что проверил. Если задание просит изменить код, проверь и своё изменение.

Непонятные детали готового инструмента можно оставить на потом. При ошибке запуска вернись к разбору вывода и типичным ошибкам в уроке.

Зачем это нужно

chmod -R 777 на проде встречается чаще, чем хотелось бы: обычно за ним стоит человек, которому просто нужно было, чтобы «заработало». Так выглядит отказ, который его к этому толкает: ты запускаешь сервис и получаешь в ответ одну строку.

PermissionError: [Errno 13] Permission denied: '/var/lib/notes/notes.txt'

Это значит «в доступе отказано»: программа хотела открыть файл с заметками, а система её не пустила. Что именно не так, читается из прав на файл и на папки по пути к нему.

Частая причина сбоя на новом сервере звучит одинаково: Permission denied. Сервис не может записать файл, прочитать конфиг или открыть порт. Самое частое «лечение», которое советуют в интернете: chmod -R 777 (команда chmod меняет права на файл, -R значит «и на всё внутри», а 777 это «всем можно всё») или запуск от root (пользователя с неограниченными правами). Оно работает и ломает безопасность: любая программа на машине получает право читать и портить твои данные.

Правильный подход короткий: у сервиса свой пользователь, у пользователя ровно те права, которые нужны, а админские действия (установка программ, правка системных файлов) идут через sudo («выполни эту команду с правами администратора») с узким списком разрешённого. На собеседованиях про это спрашивают почти всегда: «что значит 755», «зачем запускать сервис не от root», «чем sudo отличается от su».

Шаг проекта: «Заметки» переезжают на сервер (версия v2). Появляется системный пользователь notes (служебная учётная запись для программы: в неё никто не входит с паролем, у сервиса просто свои, ограниченные права). Данные лежат в /var/lib/notes (режим 750, разберём ниже), код в /opt/notes/ (владелец root), а app.py получает файловое хранилище и две служебные страницы /healthz («ты жив?») и /readyz («ты готов принимать запросы?»).

Что нужно знать

  • Урок 1.1: первый сервер, терминал, файловая система - файловая система это дерево каталогов, в котором лежат все файлы (раздел «Файловая система: одно дерево» в том же уроке). Ты умеешь открыть терминал, ходить по каталогам (cd, ls), знаешь, что ~ это домашний каталог, и пользоваться man и --help. Файл ~/notes/app.py (версия v1) уже создан. Если файла нет, вернись к заданию 5 урока 1.1 и создай его.
  • Урок 1.2: текст, потоки и конвейеры - grep ищет строки в тексте, cut режет строку на поля, | (конвейер) передаёт вывод одной команды другой. Ими мы прочитаем файл /etc/passwd (системный список всех пользователей, по строке на каждого; подробно разберём в теории).

Всё остальное (что такое пользователь, права, sudo, rwx, UID) объясняется ниже с нуля.

Картина целиком

Начнём с главного: ядро хранит число, а не имя. Каждый процесс действует от имени какого-то пользователя, у файла есть владелец и права, и при каждом обращении ядро сверяет одно с другим. Из этого состоят все понятия урока:

  • пользователь это учётная запись с числом UID (user id: по нему система узнаёт пользователя; имя нужно только людям);
  • группа это набор пользователей, которым можно выдать право сразу всем;
  • права на файле или каталоге: что может владелец, что может группа, что могут остальные. Записываются тремя буквами rwx (разберём ниже);
  • root это пользователь, которому можно почти всё;
  • sudo это выдача прав администратора на одну операцию, с записью в журнал.
flowchart TD
    P["Программа запущена от пользователя notes<br>(UID 999, группа notes)"] --> W["Хочет открыть /var/lib/notes/notes.txt на запись"]
    W --> D1["каталог /: есть x?"] --> D2["var: есть x?"] --> D3["lib: есть x?"] --> D4["notes: есть x у владельца?"] --> D5["файл notes.txt: есть w у владельца?"]
    D5 -->|"все двери открыты"| OK["запись разрешена"]
    D1 -.->|"хотя бы одна закрыта"| NO["Permission denied"]

За урок ты разберёшь каждый кусок схемы: что такое пользователь и где он записан, как читать табличку прав (rwx и числа вроде 750), почему для каталога она значит другое, как задаются права новых файлов, как работает sudo и почему сервису нужен свой пользователь. Потом соберёшь по этой схеме настоящий сервер «Заметок».

Теория

Пользователь и его номер (UID)

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

Сначала два слова про то, что здесь происходит «за кулисами».

  • Ядро (kernel) это главная часть операционной системы. Оно управляет памятью, диском, сетью и решает, что разрешено, а что нет. Все программы просят ядро о помощи, и ядро проверяет права.
  • Процесс (process) это запущенная программа (см. урок 1.1). Подробно процессы разберём в уроке 1.4.

У каждого пользователя есть имя (ubuntu, notes, root) и число, идентификатор пользователя (UID, user id). Имя нужно людям, а ядро работает только с числами. Когда ты запускаешь программу, её процесс получает твой UID и «действует от твоего имени»: всё, что он делает с файлами, ядро проверяет по этому числу. Такие же числа есть у групп: GID (group id).

Команда id печатает, кто ты для системы:

id
uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),27(sudo)

Разбор по кускам:

  • uid=1000(ubuntu): твой номер 1000, имя ubuntu;
  • gid=1000(ubuntu): основная группа (primary group), в неё попадают новые файлы, которые ты создаёшь. Номер 1000, имя ubuntu. В Ubuntu у каждого человека по умолчанию своя личная группа с тем же именем;
  • groups=1000(ubuntu),27(sudo): все группы, где ты состоишь. Группа sudo (номер 27) даёт право пользоваться командой sudo. (В виртуальной машине Multipass список групп длиннее, он показан в задании 1; для нас важна только 27(sudo).)

Особый пользователь: root, UID 0. Ядро почти не проверяет права процессов с UID 0: им можно читать и изменять любые файлы и заходить в любые каталоги (исключение: файл, у которого нет ни одного бита x, не запустится даже у root; бит здесь это один из переключателей r, w, x, включён он или выключен). Суперправа даёт не имя «root», а число 0. Если создать пользователя с UID 0 и любым именем, он станет вторым root.

Пользователи делятся на два вида:

  • человеческие: UID от 1000. Для них есть домашний каталог и оболочка (shell, программа, которая читает твои команды в терминале; у нас это bash);
  • системные (для сервисов и служб): UID меньше 1000. Так устроен, например, sshd, программа, которая принимает вход по SSH. Системному пользователю не нужен интерактивный вход, поэтому вместо оболочки ему ставят /usr/sbin/nologin: это «программа», которая при попытке войти отвечает «эта учётная запись недоступна» и завершается.

Прикинь сам: кто-то создал пользователя admin2 с UID 0. Станет ли он суперпользователем?

Да. Права даёт число 0, а не имя root: ядро даёт процессам с UID 0 суперправа, как бы он ни назывался.

Ошибка: «права даёт имя root». Как на самом деле: права даёт число 0. И ещё одна ошибка: «пользователь это всегда человек». В проде большинство пользователей на сервере это сервисы.

Главное: для ядра пользователь это число (UID), а имя нужно людям; UID 0 это root, а сервисам выдают системных пользователей с UID меньше 1000.

Проверь понимание: в выводе id у тебя uid=1000, а у коллеги на другой машине uid=1001, и оба зовутся ubuntu. Один и тот же ли это пользователь для ядра?

Ответ

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

Мы знаем, что пользователь это номер. Где система хранит списки пользователей и групп?

Где хранятся пользователи: passwd, shadow, group

Ядру и программам нужно место, откуда узнать, какие пользователи есть, какой у них домашний каталог и в каких группах они состоят. В Linux это не база данных, а три обычных текстовых файла в каталоге /etc (там лежат настройки системы). Их можно прочитать и grep-ом, и глазами.

Linux не сверяет эти файлы с каким-то другим списком: что записано в /etc/passwd, то и действует. Поэтому руками их правят редко, для этого есть команды useradd и usermod.

Файл /etc/passwd: одна строка на пользователя, семь полей через двоеточие. Возьмём реальную строку:

ubuntu:x:1000:1000::/home/ubuntu:/bin/bash
  |    | |    |    |     |           |
  |    | |    |    |     |           +---- 7. оболочка (что запустить при входе)
  |    | |    |    |     +---------------- 6. домашний каталог
  |    | |    |    +---------------------- 5. комментарий (полное имя, тут пусто)
  |    | |    +--------------------------- 4. GID основной группы
  |    | +-------------------------------- 3. UID
  |    +---------------------------------- 2. пароль: x значит «лежит в /etc/shadow»
  +--------------------------------------- 1. имя

Файл /etc/shadow («тень»): хэши паролей. Хэш пароля (password hash) это результат необратимого превращения пароля в строку символов: по хэшу можно проверить, тот ли пароль ввели, но восстановить сам пароль нельзя. Читать /etc/shadow может только root и группа shadow. Раньше хэши лежали прямо в passwd, но файл passwd должны читать все программы (чтобы, например, ls -l мог показать имя вместо числа), и хэши вынесли отдельно, чтобы их нельзя было подсмотреть и подобрать пароль.

Файл /etc/group: одна строка на группу, четыре поля: имя, x, GID, участники через запятую. Например:

sudo:x:27:ubuntu

Это группа sudo, номер 27, в ней состоит ubuntu.

Посмотрим права на эти три файла (ls -l разберём подробно в следующем разделе, пока смотри на суть):

-rw-r--r-- 1 root root    533 Sep 30 11:34 /etc/group
-rw-r--r-- 1 root root   1056 Sep 30 11:34 /etc/passwd
-rw-r----- 1 root shadow  578 Sep 30 11:34 /etc/shadow

passwd и group читают все (r-- в конце), а shadow для «остальных» полностью закрыт (---). Попытка cat /etc/shadow от обычного пользователя даст Permission denied, а через sudo файл откроется.

Группы: основная и дополнительные. У пользователя одна основная группа (четвёртое поле passwd) и сколько угодно дополнительных (supplementary groups, те, где его имя указано в /etc/group). Права проверяются по всем группам сразу. Чтобы добавить пользователя в группу, используют usermod -aG группа пользователь: -G задаёт список дополнительных групп, -a (append, «добавить») говорит «не стирай прежние».

Прикинь сам: ты добавил себя в группу docker и сразу набрал id в том же терминале. Увидишь ли новую группу?

Нет. Список групп процесс получает при запуске, поэтому id в старом терминале покажет прежние группы. id <имя> читает файлы заново и покажет новую, а в терминале поможет новый вход.

Осторожно, тут часто путают:

  • Забыли -a: usermod -G docker alice без -a заменит весь список её дополнительных групп на одну docker. Она потеряет, например, sudo.
  • x в passwd это не пароль из одного символа, а пометка «хэш смотри в shadow».

Главное: пользователи и группы лежат в /etc/passwd, /etc/group и /etc/shadow; пароли только в shadow, который читает один root.

Проверь понимание: в /etc/passwd у пользователя nginx стоит оболочка /usr/sbin/nologin. Сможет ли веб-сервер nginx, запущенный от этого пользователя, читать файлы? Сможет ли администратор зайти в SSH под этим пользователем?

Ответ

Веб-сервер читать файлы сможет: оболочка нужна только для интерактивного входа, а процесс работает от UID пользователя и без неё. Зайти в SSH под этим пользователем нельзя: вместо оболочки запустится nologin и отвергнет вход. Так и задумано: сервису вход не нужен, а значит, украденным паролем или ключом им не воспользоваться.

Теперь, когда у каждого есть номер и группа, посмотрим, как файл решает, кого пускать.

Права rwx: читаем табличку на двери

Раз на машине много пользователей, нужно правило, кто что может делать с каждым файлом. Без него любая программа могла бы стереть чужие данные или прочитать пароли. Это правило записано прямо на файле и называется правами доступа (permissions).

Над файлом можно делать три действия. Для обычного файла:

  • r (read): прочитать содержимое;
  • w (write): изменить содержимое;
  • x (execute): запустить файл как программу.

Эти три права выдаются отдельно трём классам людей:

  • владелец (user, u): пользователь, которому файл принадлежит. Обычно создатель;
  • группа (group, g): любой участник группы, назначенной файлу;
  • остальные (other, o): все, кто не подошёл под первые два класса.

Права и владельцев показывает ls -l (long, «подробно»). Возьмём настоящую строку про файл с заметками, который мы создадим в задании 4:

-rw-r----- 1 notes notes 92 Sep 30 11:55 notes.txt

Разбор строки по позициям описан в уроке 1.1 (раздел про ls -l). Здесь важно одно: файл принадлежит пользователю notes и группе notes, владелец rw-, группа r--, остальные ---. Прочерк на месте x значит «нельзя запускать».

Как ядро выбирает класс. Это главное правило, на нём построены почти все «загадки» с правами. Когда процесс обращается к файлу, ядро идёт по шагам и останавливается на первом подходящем:

  1. UID процесса равен владельцу файла? Тогда применяются права владельца, остальные графы не смотрят.
  2. Иначе: основная или любая дополнительная группа процесса равна группе файла? Тогда права группы.
  3. Иначе права остальных.
flowchart TD
    A["Процесс обращается к файлу"] --> B{"UID процесса равен владельцу файла?"}
    B -->|"да"| U["права владельца (первая тройка)"]
    B -->|"нет"| C{"Группа процесса совпала с группой файла?"}
    C -->|"да"| G["права группы (вторая тройка)"]
    C -->|"нет"| O["права остальных (третья тройка)"]

Для -rw-r----- notes notes это значит: процесс notes пишет и читает; процесс пользователя deploy (не владелец, не в группе notes) попадает в «остальные» и получает ---, то есть ничего. Из этого правила следуют два вывода:

  • Владелец с правами --- не может открыть даже собственный файл (но chmod он выполнить сможет, чтобы вернуть права).
  • Root обычными правами не останавливается: чтение и запись ему разрешены всегда. Исключения редки, они перечислены в «Для любопытных» ниже.
Для любопытных: когда не всесилен и root

Root останавливают: файловая система, смонтированная только для чтения (mount | grep ' ro,'); атрибут i на файле (chattr +i, проверка lsattr файл); сетевая файловая система NFS с root_squash (root на клиенте превращается в обычного пользователя); системы защиты SELinux и AppArmor.

Права числами. Каждую тройку записывают одной цифрой: r весит 4, w весит 2, x весит 1, вес прав складывают. Зачем числа: rwxr-x--- длинно писать в команде, а 750 коротко.

rwx r-x ---
421 4-1 ---      суммы по тройкам:
 7   5   0       4+2+1 = 7,   4+1 = 5,   0
              => 750

rw- r-- ---      4+2 = 6,   4,   0    => 640
rw- r-- r--                           => 644
rwx r-x r-x      7,  5,  5            => 755

В обратную сторону: 640 это 6=4+2=rw-, 4=r--, 0=---. Запомни четыре числа, они встречаются везде:

Режим Кому что Где встретишь
600 (rw-------) только владелец читает и пишет закрытые SSH-ключи (файл-ключ для входа на сервер без пароля, выданный только тебе; разберём в уроке 2.2), токены (длинный секретный пароль для программ), пароли
640 (rw-r-----) владелец пишет, группа читает конфиги (640 root:notes: правит root, читает сервис notes)
644 (rw-r--r--) все читают, пишет владелец обычные файлы и код
755 (rwxr-xr-x) все читают и запускают, пишет владелец программы и каталоги

Прикинь сам: расшифруй 640 и 750 в виде rwx.

640 это rw-r-----: владелец читает и пишет, группа читает, остальным ничего. 750 это rwxr-x---: владелец всё, группа читает и входит, остальным ничего.

Осторожно, тут часто путают:

  • Что 777 «просто чтобы заработало»: это право писать и запускать любому пользователю и любой программе на машине. Это не решение, а отказ от защиты.
  • Что права суммируются: «я и владелец, и в группе, значит у меня права и владельца, и группы». Нет, применяется первый подходящий класс.
  • Что x на файле нужен, чтобы его прочитать. Нет, для чтения хватит r. x нужен, чтобы запустить файл как программу.

Главное: права rwx выдаются трём классам (владелец, группа, остальные), ядро применяет первый подходящий класс, а числа считаются как r=4, w=2, x=1.

Проверь понимание: файл -rw-rw-r-- deploy devs, ты пользователь alice и состоишь в группе devs. Можешь ли ты его изменить? А пользователь bob, не состоящий в devs?

Ответ

alice не владелец, но в группе devs: применяются права группы rw-, значит она может читать и изменять. bob попадает в «остальные» с правами r--: читать может, изменять нет.

С файлами ясно. А почему при файле 644 бывает отказ при чтении? Всё дело в каталогах.

Права на каталоги и путь до файла

Каталог (папка) тоже защищён правами, и они значат другое, чем у файла. Из-за этого возникает самая коварная ошибка новичка: файл 644, читать должны все, а получаешь Permission denied.

Для каталога те же три бита значат:

  • r: увидеть список имён внутри (ls);
  • w (вместе с x): создавать, удалять и переименовывать файлы внутри. Права самого файла при этом не важны: удалить файл можно, если есть w на его каталоге, даже когда сам файл тебе не принадлежит;
  • x: «проходить» через каталог: заходить (cd) и обращаться к файлам внутри по имени. Пример: у каталога только x без r. Списка файлов ты не увидишь (ls откажет), но cat каталог/secret.txt сработает, если ты заранее знаешь имя.

Чтобы открыть файл по пути /var/lib/notes/notes.txt, ядро проходит путь целиком: нужен x на каждом каталоге (/, var, lib, notes), и только потом смотрится право r на самом файле. Если хоть один каталог закрыт, права файла даже не проверяются.

Права по всему пути показывает namei -l (от «follow a pathname», «пройти по пути звено за звеном»; флаг -l значит «подробный список» с владельцем и правами каждого звена).

На настоящем сервере Ubuntu домашний каталог закрыт для чужих: у него режим 750 (drwxr-x---). В нём лежит файл a.txt с режимом 644, который «читают все». Пробуем прочитать его от имени системного пользователя nobody (служебная учётная запись с UID 65534: у неё нет ни прав владельца, ни группы файла).

Сначала о командах. sudo -u nobody команда запускает команду от имени пользователя nobody (служебная учётная запись без особых прав, удобна для проверки «что видит чужой»); подробнее про sudo ниже. ~ это твой домашний каталог (урок 1.1). namei -l печатает права каждого звена пути по очереди.

sudo -u nobody cat ~/perm-lab/a.txt
namei -l ~/perm-lab/a.txt
cat: /home/ubuntu/perm-lab/a.txt: Permission denied
f: /home/ubuntu/perm-lab/a.txt
drwxr-xr-x root    root    /
drwxr-xr-x root    root    home
drwxr-x--- ubuntu ubuntu ubuntu
drwxr-xr-x ubuntu ubuntu perm-lab
-rw-r--r-- ubuntu ubuntu a.txt

Идём по строкам namei. / и home: x есть у всех. ubuntu (домашний каталог): права rwxr-x---, для «остальных» три прочерка, нет x. Здесь ядро останавливает nobody. До a.txt он не дошёл, и права 644 на файле не сыграли роли.

Прикинь сам: у каталога /srv/data режим 711, внутри файл report.txt с 644. Что получится у обычного пользователя: ls /srv/data и cat /srv/data/report.txt?

ls откажет: для списка нужен r, а у остальных только x. cat по известному имени сработает: x пускает внутрь, а у файла r есть.

Осторожно, тут часто путают:

  • «У файла 644, значит читают все». Нет, читают все, кто дошёл до файла по пути.
  • «Чтобы удалить файл, нужно право на файл». Нет, нужно w (и x) на каталоге. Поэтому на общих каталогах вроде /tmp ставят особый бит (ниже), иначе любой удалял бы чужие файлы.
  • «x на каталоге значит, что в нём что-то запускается». Нет, это «можно войти».

Главное: для каталога r значит «увидеть список», w «создавать и удалять», x «проходить»; чтобы дойти до файла, нужен x на каждом каталоге пути.

Проверь понимание: у файла /srv/data/report.txt права 644, но Permission denied при чтении. Каталог /srv/data имеет 700 и владельца root. Ты обычный пользователь. Почему?

Ответ

Чтобы добраться до файла, нужен бит x на каждом каталоге пути. У /srv/data для остальных нет ничего, до файла ты не доходишь, права самого файла не проверяются. Быстрая проверка: namei -l /srv/data/report.txt показывает права по всему пути.

Права мы читаем. Как их менять и как передать файл другому владельцу?

chmod и chown: как менять права и владельца

Права при создании файла выдаются по умолчанию (о них следующий раздел), и почти всегда их приходится менять: закрыть ключ, открыть скрипт для запуска, передать каталог сервису.

  • chmod (change mode, «изменить режим») меняет права. Два способа записи:
    • числом: chmod 640 файл выставляет режим целиком;
    • символами: chmod кто оператор права файл. Кто: u владелец, g группа, o остальные, a все. Оператор: + добавить, - убрать, = выставить точно. Права: r, w, x. Части можно перечислять через запятую: u+x,g-r.
  • chown (change owner) меняет владельца: chown notes:notes файл ставит пользователя notes и группу notes (формат пользователь:группа). Менять владельца может только root, поэтому обычно sudo chown. Ключ -R (recursive) применяет команду ко всему содержимому каталога, будь с ним внимателен.

Число удобно, когда знаешь итог, символы удобны, когда нужно поменять один бит и не помнить остальные.

У файла 640, выполняем chmod u+x,g-r. Считаем по битам:

было:        rw- r-- ---   = 640
u+x          rwx r-- ---   = 740   (владельцу добавили x)
g-r          rwx --- ---   = 700   (у группы убрали r)

Ещё частый случай: скрипт, который скачали или создали, обычно запуститься не даёт, потому что при создании x не выдают. Команда chmod +x скрипт (без «кто» означает «всем, кому позволяет маска создания») добавляет запуск.

Прикинь сам: у файла 755. Какой режим станет после chmod go-x?

755 это rwxr-xr-x. Убираем x у группы и остальных: rwxr--r--, то есть 744.

Осторожно, тут часто путают:

  • chmod o без оператора: ошибка, после o нужен +, - или =. Чтобы очистить права остальных, пиши o=.
  • «Я обычный пользователь и владелец, значит могу сменить владельца на другого». Нет, сменить пользователя-владельца на другого может только root (иначе можно было бы подсовывать другим свои файлы); свою группу файла владелец менять может.
  • chmod -R 777. Не делай так никогда. Ты одновременно открываешь запись всем и делаешь исполняемыми файлы, которые не должны запускаться.

Главное: chmod меняет права числом или символами (u+x, g-w, o=), chown меняет владельца и группу, но пользователя-владельца может сменить только root.

Проверь понимание: какой режим будет у файла 644 после chmod g+w,o-r?

Ответ

644 это rw- r-- r--. g+w даёт группе запись: rw- rw- r--. o-r убирает чтение у остальных: rw- rw- ---. Итог 660.

А какие права получит файл при создании? Это решает не chmod.

umask: какие права получает новый файл

Когда программа создаёт файл, она обычно не указывает права. Кто-то должен решить за неё. Чтобы каждый файл не получал 666 (все пишут), в системе есть «фильтр» на выдаваемые права, маска создания (umask). Он работает без твоего участия и объясняет, почему файл, созданный сервисом, получается не с такими правами, как файл, созданный тобой.

  1. Программа создаёт файл и просит максимум: обычный текстовый файл она обычно создаёт с запросом 666 (rw-rw-rw-, бит x для таких файлов не просят: новый файл сам не должен стать программой), каталог с запросом 777. (Исключение: компилятор просит 777 для готовой программы.)
  2. Ядро берёт маску создания процесса и отбрасывает те права, которые в ней записаны: цифра 2 в маске означает «убрать w» (напомним веса: r=4, w=2, x=1), цифра 7 означает «убрать всё». Строго говоря, ядро не вычитает числа, а выключает переключатели (биты), но для типичных масок результат совпадает с вычитанием, поэтому считать так проще.
  3. Что осталось, то и есть права нового файла.

Маска относится к процессу: у каждого процесса своя. Поэтому у файла, созданного твоей командой, и у файла, созданного сервисом, права могут отличаться.

Маска 022, создаём файл и каталог:

файл:     666  rw- rw- rw-
маска:    022  --- -w- -w-   (эти биты отбрасываем)
итог:     644  rw- r-- r--

каталог:  777  rwx rwx rwx
маска:    022  --- -w- -w-
итог:     755  rwx r-x r-x

Маска 077 даёт 600 и 700 (всё только владельцу), маска 027 даёт 640 и 750. Текущую маску показывает команда umask. Меняет umask 077 (только в текущем терминале и его дочерних процессах).

Особенность Ubuntu. У пользователей с личной группой того же имени (ubuntu:ubuntu, notes:notes) при входе в систему (через ssh или su -) ставится маска 002, а не 022: в личной группе, кроме тебя, никого нет, поэтому писать ей безопасно. Файл из такой сессии получит 664 (rw-rw-r--). Но маска зависит от способа запуска. Сам sudo по умолчанию не пускает маску слабее 022, однако при открытии сессии Ubuntu может выставить свою (модуль PAM pam_umask), и на нашем стенде с Ubuntu 24.04 файл от sudo -u notes получил 664, а на 26.04 644. Менеджер сервисов systemd по умолчанию использует 022. Поэтому не гадай, а проверь: umask в своей сессии и sudo -u notes sh -c umask. В задании 4 ты увидишь реальные права файла.

Прикинь сам: процесс с umask 077 создаёт файл и каталог. Какие права у каждого?

Файл: 666 минус 077 даёт 600. Каталог: 777 минус 077 даёт 700. Всё достаётся только владельцу.

Осторожно, тут часто путают:

  • «umask 022 значит 022 на файле». Нет, это то, что отнимают: файл получит 644.
  • «Права нового файла копируются с каталога». Нет, только от маски процесса (исключение, setgid, ниже).

Главное: umask отнимает права у максимума (666 для файлов, 777 для каталогов) и действует на процесс, а не на систему.

Проверь понимание: процесс с umask 027 создаёт файл и каталог. Какие получатся права?

Ответ

Файл: 666 минус 027 даёт 640 (rw-r-----). Каталог: 777 минус 027 даёт 750 (rwxr-x---).

Обычных rwx иногда не хватает. Для таких случаев есть особые биты.

Особые биты: setuid, setgid и sticky

Обычных rwx иногда не хватает. Пример: команда passwd меняет твой пароль, то есть записывает в /etc/shadow, а этот файл может изменять только root. Как обычный пользователь ухитряется его изменить? Через особый бит.

Кроме rwx есть три дополнительных переключателя (бита), они стоят перед обычными тремя цифрами:

  • setuid (4000, буква s на месте x владельца): программа запускается с правами владельца файла, а не того, кто её запустил;
  • setgid (2000, s на месте x группы): для программы то же самое с группой, а на каталоге новые файлы внутри наследуют группу этого каталога (полезно для общих папок команды);
  • sticky bit («липкий», 1000, буква t в конце): на каталоге запрещает удалять и переименовывать чужие файлы, даже если у каталога есть w для всех.

Реальные строки:

-rwsr-xr-x 1 root root 72056 May 30  2024 /usr/bin/passwd
drwxrwxrwt 1 root root  4096 Sep 30 12:00 /tmp
drwxrwsr-x 2 ubuntu ubuntu 4096 Sep 30 12:00 team
  • /usr/bin/passwd: s вместо x у владельца, значит setuid. Владелец root, поэтому программа работает как root и может изменить /etc/shadow. Режим этого файла числом: 4755.
  • /tmp: drwxrwxrwt. Писать в каталог может любой (rwx для всех), но t в конце (режим 1777) не даёт удалять чужое. Так устроены общие временные каталоги.
  • team: s в группе, режим 2775. Файлы в нём получают группу каталога.

Типичные программы с setuid: passwd, sudo, su. Полный список на машине даёт sudo find / -xdev -perm -4000 -type f 2>/dev/null (-xdev не заходит на другие диски, 2>/dev/null прячет сообщения об ошибках). В минимальном образе таких программ девять, у тебя может быть больше. Каждая должна быть там осознанно, лишние это повод для аудита безопасности.

Прикинь сам: какой числовой режим у /tmp, если ls -ld показывает drwxrwxrwt?

1777: rwx для всех это 777, а t на конце даёт sticky bit, то есть 1000 в начале.

Ошибка: «setuid на скрипте даст ему права владельца». Как на самом деле: ядро Linux игнорирует setuid на скриптах, работает только на скомпилированных программах. И ещё: s и t не отдельные права, а отметки поверх x. Заглавная S или T значит, что бита x под ней нет.

Главное: setuid запускает программу от владельца файла, setgid наследует группу каталога, sticky bit не даёт удалять чужое в общем каталоге.

Проверь понимание: почему в общем каталоге /tmp каждый может создавать файлы, но не может удалить файл соседа, хотя на каталоге у всех w?

Ответ

Потому что на /tmp стоит sticky bit (t). Он добавляет правило: удалить или переименовать файл в таком каталоге может только владелец файла, владелец каталога или root, а обычное w на каталоге этого уже не даёт.

Одна из программ с setuid, sudo, нужна тебе каждый день. Разберёмся, как она устроена.

root, su и sudo

Часть действий требует прав администратора: установить пакет (программу из системного каталога программ, командой apt install), создать пользователя, править системные файлы. Работать постоянно под root опасно: одна опечатка (rm -rf /) уничтожает систему, а любая запущенная программа получает все права. Нужен способ получать права на одну команду, с записью, кто и что сделал.

  • su (switch user) переключает тебя на другого пользователя целиком, нужен его пароль. У root на Ubuntu пароля нет, поэтому там пишут sudo su - имя или sudo -iu имя. Сессия открыта до выхода, вся работа идёт от чужого имени, а пароль root приходится знать нескольким людям.
  • sudo (substitute user do, раньше superuser do) выполняет одну команду от имени другого пользователя (по умолчанию root). Просит твой пароль, а не пароль root, и пишет факт запуска в журнал (дневник событий: кто, когда и что запускал; смотреть так: journalctl _COMM=sudo, а если установлен rsyslog, то ещё и /var/log/auth.log). Что кому можно, описано в /etc/sudoers и файлах каталога /etc/sudoers.d/.

Как работает sudo systemctl restart notes по шагам:

  1. Ты запускаешь sudo (это программа с setuid, поэтому у неё сразу права root).
  2. sudo читает sudoers и ищет правило про тебя и команду.
  3. Правило нашлось: при необходимости спрашивает твой пароль, затем запускает команду от имени root.
  4. Правила нет: sudo печатает отказ и ничего не запускает.
sequenceDiagram
    participant T as Ты (bash)
    participant S as sudo (setuid root)
    participant F as /etc/sudoers
    participant K as Команда
    T->>S: sudo systemctl restart notes
    S->>F: есть ли правило для меня и этой команды?
    F-->>S: да, спросить пароль
    S->>T: пароль (твой, не root)
    T-->>S: пароль
    S->>K: запуск от имени root, запись в журнал
    S-->>T: отказ и конец, если правила нет

Чтобы выполнить команду от имени другого пользователя (не root), добавляют -u: sudo -u notes id выполнит id от имени notes. Так мы в уроке будем запускать «Заметки» под их собственным пользователем и проверять, что доступно ему.

Реальная строка из /etc/sudoers Ubuntu:

%sudo	ALL=(ALL:ALL) ALL

Читается по полям: %sudo группа sudo (знак % значит «группа»); ALL= на любых машинах; (ALL:ALL) от имени любого пользователя и любой группы; ALL любые команды. Поэтому участнику группы sudo разрешено всё, обычно с вводом его пароля (на облачных образах для пользователя по умолчанию есть ещё отдельный файл в sudoers.d с NOPASSWD (на образе Multipass он назван по имени пользователя, ubuntu, на других облачных образах 90-cloud-init-users), и пароль не спрашивают). Саму группу эта строка не создаёт и людей в неё не добавляет: она только связывает группу с правом sudo. Если в id есть 27(sudo), эта строка применяется к тебе.

Прикинь сам: почему sudo echo hi > /etc/test.txt отвечает Permission denied, хотя sudo перед echo есть?

Перенаправление > выполняет твоя оболочка до запуска sudo, то есть с твоими правами: она сама пытается открыть /etc/test.txt, получает отказ, и до sudo дело не доходит. Верно так: echo hi | sudo tee /etc/test.txt. Здесь tee (урок 1.2) открывает файл сама, и запускается она с sudo, поэтому права есть.

Осторожно, тут часто путают:

  • «sudo echo > файл запишет в защищённый файл». Нет, > открывает твоя оболочка до sudo. Верно: echo hi | sudo tee файл (разбор выше).
  • «sudo cd /root сработает». Нет: cd это команда самой оболочки, отдельной программы для sudo нет.

Главное: su переключает на другого пользователя целиком по его паролю, а sudo выполняет одну команду по твоему паролю и пишет её в журнал.

Проверь понимание: зачем sudo спрашивает твой пароль, а не пароль root?

Ответ

Пароль root не нужно раздавать: у каждого свой пароль, и в журнале видно, кто что запустил. Твой пароль подтверждает, что за клавиатурой именно ты, а не тот, кто присел за незаблокированный ноутбук. На облачных образах (в том числе на твоей ВМ) для пользователя по умолчанию пароль отключён через NOPASSWD, поэтому sudo у него не спросит.

sudo работает по правилам. Как выдать человеку одну команду, а не весь root?

Правила sudoers и безопасная правка

Иногда нужно разрешить человеку или программе только одну административную команду: разработчику перезапускать один сервис, скрипту деплоя выполнять одну операцию. Полный sudo для этого избыточен. Запомни три вещи:

  • sudoers это список, кто что может от чужого имени;
  • править его нужно только через visudo (проверяющий редактор), потому что опечатка может отнять доступ у всех;
  • пиши одно правило с точным путём команды и аргументами.

Правило состоит из полей кто где=(от_имени) что_можно:

deploy ALL=(root) NOPASSWD: /usr/bin/du -sh /var/log
  |    |     |       |              |
  |    |     |       |              +-- команда с аргументами: ровно эта
  |    |     |       +----------------- NOPASSWD: пароль не спрашивать
  |    |     +------------------------- от имени root
  |    +------------------------------- на любых машинах
  +------------------------------------ пользователь deploy

Поле «где» (ALL) нужно потому, что один файл правил можно раздать на много серверов. На одиночной машине всегда пиши ALL.

Путь команды пишется полностью (/usr/bin/du, а не du): правило с одним du visudo не пропустит (expected a fully-qualified path name). Аргументы можно не писать, но тогда разрешены любые: правило /usr/bin/du позволит и du -sh /etc. Чтобы разрешить только одно действие, пиши аргументы точно: с du -sh /var/log разрешено именно это, а du -sh /etc нет.

Правила кладут отдельным файлом в /etc/sudoers.d/, а не правят главный /etc/sudoers: пакетные обновления не затрут правку, а ошибка в одном файле не трогает остальные. Имя файла не должно содержать точку (иначе sudo его пропустит).

Три правила безопасной правки:

  1. Файл сначала пишется в обычное место и проверяется командой visudo -cf файл (-c только проверить, -f указывает файл). Она должна ответить parsed OK.
  2. Только потом файл ставится в /etc/sudoers.d/ с владельцем root и режимом 440 (читать могут root и группа, писать никто).
  3. Пока не проверил, держи открытой вторую сессию с root-доступом (например, второй терминал с sudo -i). Если что-то сломается, ты сможешь исправить.

Если в правиле опечатка, visudo -cf покажет файл, строку и символ ошибки (syntax error). Пример разбора лежит ниже, в «Для любопытных».

Прикинь сам: правило deploy ALL=(root) NOPASSWD: /usr/bin/systemctl restart notes. Сможет ли deploy выполнить sudo systemctl stop notes?

Нет: правило разрешает команду только с этими аргументами. Поэтому узкие правила безопаснее, чем NOPASSWD: ALL.

Ошибка: «если visudo -cf сказал parsed OK, правило работает как я хотел». Как на самом деле: он проверяет только синтаксис. Что правило даёт именно то, что нужно, проверяют командой sudo -l -U пользователь и пробным запуском.

Для любопытных: опечатки, шаблоны, опасные команды и права на файлы
  • Опечатка в правиле. Потеряем знак =: deploy ALL(root) NOPASSWD: .... visudo -cf ответит (вывод со стенда, sudo 1.9.15):

    /home/ubuntu/bad.tmp:1:11: syntax error
    deploy ALL(root) NOPASSWD: /usr/bin/du -sh /var/log
              ^
    

    Файл, строка 1, символ 11 (под стрелкой). Если такой файл всё же попадёт в sudoers.d, результат зависит от версии sudo: в 1.9.15 пропадали только сломанные строки, в старом 1.8 отключался весь sudo. Рассчитывай на худшее и всегда проверяй visudo -cf.

  • Шаблон * в аргументах. Правило deploy ALL=(root) NOPASSWD: /usr/bin/du * разрешает любые аргументы. Например, du --files0-from=/etc/shadow попытается прочитать список имён из закрытого файла и покажет его куски в сообщениях об ошибках. Пиши точные аргументы.
  • Каких команд не выдавать через sudo. Редакторы и пейджеры (vim, less), find, интерпретаторы (python3), tar, systemctl edit: из них можно открыть оболочку и получить полный root (приём «shell escape», каталог таких приёмов называется GTFOBins). Для сервиса выдавай узкое systemctl restart notes, как в примере выше.
  • Старый sudo (1.8). Любая синтаксическая ошибка в любом файле отключает sudo целиком, поэтому вторая сессия с root особенно важна.
  • Права на файлы. Файл в sudoers.d с неверным владельцем или открытый всем на запись sudo отвергает (is world writable, is owned by uid 1000, should be 0). Главный /etc/sudoers с правом записи для всех: sudo отказывается работать для всех.
  • NOPASSWD: ALL. Это полный root без пароля: кража ноутбука разработчика или его ключа даёт root на сервере.

Главное: правила sudo кладут файлом в /etc/sudoers.d/, проверяют visudo -cf и ставят с владельцем root и режимом 440, а команды пишут абсолютными путями.

Проверь понимание: почему правило пишут /usr/bin/du, а не просто du?

Ответ

Так требует sudoers: правило с коротким именем du не пройдёт visudo -cf (expected a fully-qualified path name). Полный путь привязывает правило к одной конкретной программе, а не к любому файлу с именем du.

Теперь соберём всё это для настоящего сервиса: каким пользователем и с какими правами его запускать?

Сервис под своим пользователем: принцип наименьших привилегий

«Заметки» это программа, к которой обращаются по сети. Любая такая программа может содержать ошибку, через которую её взломают. Вопрос не «взломают ли», а «что получит взломщик». Если сервис работает от root, взломщик получает всю машину. Если от отдельного пользователя с минимальными правами, он получает только то, что доступно этому пользователю. Это называется принцип наименьших привилегий (least privilege): дай ровно то, что нужно для работы, и не больше.

Определи, что сервису действительно нужно, и разложи по правам:

Что Нужно сервису Как выдаём
Читать свой код /opt/notes/app.py читать владелец root, режим 644: читать могут все, менять только root
Писать данные в /var/lib/notes/ читать, писать, входить владелец notes, режим 750
Менять свой код нет, и это плюс у пользователя notes нет w на код
Читать чужие данные, входить в SSH нет системный пользователь, оболочка nologin, права 750 закрывают остальных

Так делят каталоги по Linux-традиции: код программы в /opt (или /usr), изменяемые данные в /var/lib/<имя>, настройки в /etc/<имя>. Так сделано и у «Заметок» (/opt/notes, /var/lib/notes, /etc/notes).

Кто /opt/notes/app.py (644 root:root) /var/lib/notes/ (750 notes:notes)
notes (сервис) читает, изменить не может читает и пишет
root владелец, меняет доступ есть всегда
deploy, ubuntu и другие читают закрыто (нет x)

Допустим, в app.py нашли ошибку, и взломщик заставил его выполнить rm -rf /opt/notes. От notes эта команда не сработает: у пользователя нет w на /opt/notes, и ядро скажет Permission denied. От root она бы удалила всё. Другой случай: сервис пишет в лог файл, которого не существует, в каталоге, куда пользователь notes писать не может. Ошибка Permission denied в логе сервиса здесь правильная реакция системы, а не «баг», и лечить её надо правами, а не запуском от root.

Прикинь сам: взломщик заставил app.py выполнить rm -rf /opt/notes, а сервис работает от notes без права w на этот каталог. Что произойдёт?

Ядро откажет с Permission denied: у notes нет права удалять в /opt/notes. Пострадать могут только его данные в /var/lib/notes.

Осторожно, тут часто путают:

  • «Запущу от root, чтобы не возиться с правами». Так делают чаще всего, и так получаются взломы.

Главное: сервис запускают от отдельного системного пользователя с минимумом прав: код только для чтения, запись только в свои данные.

Проверь понимание: зачем выдавать каталогу данных режим 750, а не 755? Ведь сервис в обоих случаях работает.

Ответ

750 закрывает каталог для «остальных» полностью (нет ни r, ни x), а 755 разрешает им войти и читать файлы, если у самих файлов права позволяют. Данные приложения обычно не для чужих глаз, а закрытая дверь защищает и тогда, когда у файла внутри по ошибке окажутся слишком широкие права.

Одному пользователю права понятны. А если доступ нужен нескольким людям, на помощь приходят группы.

Группы как способ делиться доступом

Часто файл должен быть доступен не одному пользователю и не всем, а нескольким конкретным: например, конфиг читает сервис, а правит администратор. Без групп пришлось бы выбирать между «только владелец» и «все остальные», то есть между закрытым и слишком открытым. Группа даёт третий вариант: доступ по списку.

Файлу назначаются владелец и группа (chown пользователь:группа), в правах используется средняя тройка. Схема, которую ты будешь применять всё время, называется «шаблон 640 root:сервис»:

  1. Владелец файла root: только он может его менять.
  2. Группа файла равна группе сервиса (notes): все участники группы могут читать.
  3. Режим 640: владелец читает и пишет, группа читает, остальные не видят.

Так лежат конфиги с паролями и ключами: сервис читает свой файл, посторонние пользователи не читают, изменить его может только администратор. Точно так же в уроке 1.8 будет устроен /etc/notes/notes.env (640 root:notes).

Файл /etc/notes/notes.env с режимом 640 root:notes и три пользователя:

-rw-r----- 1 root notes 27 Sep 30 12:00 /etc/notes/notes.env

root    (UID 0)           суперправа, проверка не нужна        читает и пишет
notes   (группа notes)    не владелец, но группа совпала       r--  читает
deploy  (нет в группе)    не владелец, группа не совпала       ---  Permission denied

Первому шагу ядра («я владелец?») соответствует только root, второму («моя группа совпадает?») пользователь notes через свою личную группу, все остальные падают на третий шаг и получают три прочерка.

Прикинь сам: файл 640 root:notes, пользователи root, notes и alice (в группе alice). Кто что получит?

root читает и пишет, notes только читает (группа), alice ничего: она попадает в «остальные» с ---.

Осторожно, тут часто путают:

  • «Добавлю в группу, и всё сразу заработает». Нет, нужен новый вход (причина разобрана выше), а сервису перезапуск. Проверка: grep Groups /proc/НОМЕР_ПРОЦЕССА/status (номер даёт pgrep -f app.py).
  • «Группа файла и группа пользователя это одно и то же». Нет: у файла своя группа-владелец, у пользователя своя основная и дополнительные. Права сработают, когда они совпадут.
  • «Раздам группе docker или sudo всем подряд». Эти группы дают фактически права root (членам docker разрешено запускать контейнеры с доступом к файлам хоста), поэтому их выдают так же осторожно, как sudo.

Главное: группы делят доступ между несколькими пользователями: шаблон 640 root:сервис даёт сервису чтение, а правку оставляет администратору.

Проверь понимание: файл -rw-r----- root notes. Пользователь alice состоит только в группе alice. Может ли она его прочитать? Что нужно сделать, чтобы могла, не открывая файл всем?

Ответ

Не может: она не владелец, её группы не совпадают с notes, применяются права «остальных» (---). Чтобы дать доступ только ей, добавь её в группу notes (sudo usermod -aG notes alice) и попроси перезайти в систему. Права файла менять не нужно.

Мы научились выдавать доступ. Что делать, когда он не работает, а в голову лезет 777?

Почему chmod 777 не лечит, а прячет проблему

Увидев Permission denied, почти каждый новичок хочет одного: чтобы заработало. Советы из интернета предлагают самый короткий путь, chmod -R 777. Он действительно убирает ошибку, поэтому важно понять, что именно ты при этом разрешаешь.

777 значит rwx для владельца, группы и всех остальных (чтение 4 + запись 2 + запуск 1 = 7 в каждой позиции). Опция -R распространяет это на каждый файл внутри. Теперь любой пользователь машины, включая системного пользователя чужого сервиса, может прочитать конфиги с паролями и переписать твой код.

Сервису notes отказано в записи в /var/lib/notes. Плохое лечение: sudo chmod -R 777 /var/lib/notes. Правильное: посмотреть ls -ld /var/lib/notes (-d показывает права самого каталога, а не его содержимого).

Помнишь отказ из начала урока? Вот как он объясняется в выводе:

drwxr-xr-x 2 root root 4096 Sep 30 11:50 /var/lib/notes

Приложение работает от пользователя notes, а папка принадлежит root (третье и четвёртое слово), и у остальных в ней только r-x: читать можно, писать нельзя. Значит, надо передать каталог сервису: sudo chown notes:notes /var/lib/notes. Ошибка исчезает в обоих случаях, но во втором доступ получил только тот, кому он нужен.

Прикинь сам: сервис получил отказ в записи в /var/lib/notes. Сравни chmod -R 777 и chown notes:notes: кому открыт доступ в каждом случае?

С 777 всем пользователям и всем программам машины. С chown notes:notes только сервису notes. Ошибка пропадёт в обоих случаях, но второй вариант не создаёт дыры.

Ошибка: «раз заработало, значит, починил». Как на самом деле: дыра осталась, и её найдут позже, уже в инциденте. Признак верного лечения: ты можешь сказать, кому и что именно ты разрешил.

Главное: chmod 777 не чинит, а раздаёт доступ всем; верное лечение называет, кому и что именно разрешено.

Проверь понимание: что изменится в правах, если вместо 777 выставить 750?

Ответ

Владелец сохранит все права (7 = rwx), группа сможет читать и входить (5 = r-x), остальные потеряют доступ совсем (0). Это и есть режим каталога данных «Заметок».

Чтобы не искать вслепую, нужен порядок разбора. Вот он.

Как разбирать Permission denied

Отказ в доступе - самая частая ошибка в этой теме. Если действовать по порядку, причина обычно находится быстро, без chmod 777.

Порядок из шести шагов:

  1. От чьего имени работает процесс? ps -o user,pid,args -C python3 | grep -E 'USER|[a]pp.py' покажет пользователя процесса: ps выводит список процессов, -o выбирает колонки (пользователь, номер процесса, команда запуска), -C python3 оставляет процессы с именем python3, а grep оставляет заголовок и строку с app.py (остальные python3 на машине это системные службы). Или ps -u notes -o user,pid,args. Для своей сессии хватит id.
  2. Что именно он пытается сделать? Читать, писать, создавать файл, войти в каталог? Точный путь виден в сообщении об ошибке.
  3. Права по всему пути. namei -l /полный/путь. Ищи первый каталог без x для нужного класса и файл без нужного r или w.
  4. Воспроизведи от имени этого пользователя. sudo -u notes cat /путь или sudo -u notes touch /путь. Ошибка повторилась, значит ты нашёл её.
  5. Исправь минимально. Владелец (chown) или режим (chmod) на конкретном месте. Не 777, не root. Если ls -l ничего не объясняет, а доступа нет, проверь getfacl путь (список доступа ACL, дополнительные правила поверх rwx) и ls -Z путь (метка SELinux; на Ubuntu обычно работает AppArmor, на RHEL-подобных системах SELinux).
  6. Не решилось за 15 минут? Напиши владельцу сервиса или в поддержку и приложи namei -l ПУТЬ, вывод id и точный текст ошибки. С этим набором тебе ответят с первого раза.
flowchart LR
    A["1. Чей процесс?"] --> B["2. Что делает?"] --> C["3. namei -l"] --> D["4. Воспроизвести"] --> E["5. Исправить минимально"] --> F["6. Не вышло: написать владельцу"]

POST к «Заметкам» отвечает 500 {"error": "storage"}, в логе сервиса PermissionError: [Errno 13] Permission denied: '/var/lib/notes/notes.txt'. По шагам: процесс работает от notes (шаг 1); он открывает notes.txt на дозапись (шаг 2); namei -l показывает, что каталог notes и файл принадлежат root и у остальных только r (шаг 3); sudo -u notes touch /var/lib/notes/probe даёт Permission denied (шаг 4); значит chown -R notes:notes /var/lib/notes (шаг 5). Именно так ты разберёшь поломку в разделе «Сломай и почини».

Прикинь сам: сервис падает с Permission denied: /var/lib/app/data.db. Какую проверку сделаешь первой?

Выяснишь, от чьего имени работает процесс (ps -o user,pid,args -C python3 | grep -E 'USER|[a]pp.py' или id), потому что все остальные шаги зависят от пользователя.

Ошибка: «есть волшебная команда, которая чинит доступ всем и всегда». Как на самом деле: такой команды нет, причина каждый раз в конкретном месте пути.

Ошибка: «после chmod или chown сервис нужно перезапускать». Как на самом деле: права проверяются при каждом открытии файла, перезапуск нужен, только если сервис уже упал. Исключение: файл, который сервис уже держит открытым, сохраняет старые права до закрытия.

Главное: разбор Permission denied: чей процесс, что делает, права по пути (namei -l), воспроизвести от его имени, исправить минимально.

Проверь понимание: сервис от пользователя app не может записать /var/lib/app/data.db. ls -l показывает файл -rw-rw-rw- root root, а ls -ld /var/lib/app показывает drwxr-x--- root root. Что не так и как исправить?

Ответ

Сам файл с rw-rw-rw- писать позволяет, но до него app не доходит: каталог /var/lib/app принадлежит root с режимом 750, для app это «остальные» с ---, нет даже x, внутрь войти нельзя. Проверка: namei -l /var/lib/app/data.db. Исправление: sudo chown app:app /var/lib/app (теперь app владелец каталога и имеет rwx), файлу тоже app:app и режим 640. Режим 666 на файле снимаем: писать в него не должен никто, кроме сервиса.

Теория закончена. В практике ты соберёшь сервер «Заметок» под отдельным пользователем.

Практика

Нужна Ubuntu Server 24.04 или 26.04 (ВМ из урока 1.1) и пользователь с sudo. Выводы ниже сняты в контейнере с Ubuntu 24.04, кроме списка групп пользователя ubuntu: он показан таким, каким бывает в виртуальной машине Multipass (номера групп приблизительные). Во всех выводах ниже пользователь называется ubuntu, а домашний каталог /home/ubuntu. У тебя имя и путь могут быть другими: подставляй свои. Числа UID, время, размеры и хэши у тебя будут отличаться, ориентируйся на структуру.

Задание 1. Кто ты и где записаны пользователи

Цель: найти в системе то, о чём говорилось в теории: свой UID, группы, файлы passwd, shadow, group, и увидеть, что новая группа появляется не сразу.

Предскажи: сможешь ли ты прочитать /etc/shadow без sudo? А /etc/passwd?

Ответ

/etc/passwd сможешь (-rw-r--r--, читают все), /etc/shadow нет (-rw-r-----, читает root и группа shadow): будет Permission denied.

Шаги

  1. Твоя личность. Разбор команд:

    • id мы разобрали в теории;
    • whoami печатает только имя;
    • grep "^$(whoami):" /etc/passwd: $(whoami) подставляет твоё имя, ^ в регулярном выражении значит «начало строки», grep показывает строку passwd, которая начинается с твоего имени;
    • getent group sudo показывает запись группы sudo.

    Сами команды:

id
whoami
grep "^$(whoami):" /etc/passwd
getent group sudo

getent (get entries) спрашивает у системы записи о пользователях и группах. Это надёжнее, чем читать файл: на серверах с общей учётной базой (LDAP) пользователи лежат не только в /etc/passwd, а getent найдёт всех.

  1. Права на файлы учётных записей и попытка прочитать shadow:
ls -l /etc/passwd /etc/shadow /etc/group
head -n 1 /etc/shadow
sudo head -n 1 /etc/shadow
  1. Разберём passwd конвейером из урока 1.2: сколько всего записей, кто из них живой (оболочка не nologin и не /bin/false) и какие системные. Разбор команд:

    • wc -l < /etc/passwd считает строки;
    • grep -Ev 'nologin|/bin/false': -v (invert) выводит строки, не содержащие образец, -E включает расширенные выражения, чтобы работала черта | («или»);
    • cut -d: -f1,3,7 режет каждую строку по двоеточию (-d:) и оставляет поля 1, 3 и 7 (имя, UID, оболочка);
    • awk -F: '$3<1000 {n++} END{print n}' считает строки, у которых третье поле (UID) меньше 1000.

    Сами команды:

wc -l < /etc/passwd
grep -Ev 'nologin|/bin/false' /etc/passwd | cut -d: -f1,3,7
awk -F: '$3<1000 {n++} END{print n}' /etc/passwd
  1. Ловушка с группами. Создай тестовую группу, добавь себя и сравни id со старым процессом с id <имя>. groupadd создаёт группу, usermod -aG добавляет тебя в неё, gpasswd -d и groupdel в конце всё возвращают.
sudo groupadd demo
sudo usermod -aG demo "$(whoami)"
id
id "$(whoami)"
getent group demo
sudo gpasswd -d "$(whoami)" demo
sudo groupdel demo

Что должно получиться (у тебя на Ubuntu 24.04 то же по структуре)

uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),4(adm),20(dialout),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),100(users),118(lxd)
ubuntu
ubuntu:x:1000:1000::/home/ubuntu:/bin/bash
sudo:x:27:ubuntu
-rw-r--r-- 1 root root    533 Sep 30 11:34 /etc/group
-rw-r--r-- 1 root root   1056 Sep 30 11:34 /etc/passwd
-rw-r----- 1 root shadow  578 Sep 30 11:34 /etc/shadow
head: cannot open '/etc/shadow' for reading: Permission denied
root:*:20707:0:99999:7:::
22
root:0:/bin/bash
sync:4:/bin/sync
ubuntu:1000:/bin/bash
20
uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),4(adm),20(dialout),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),100(users),118(lxd)
uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),4(adm),20(dialout),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),100(users),118(lxd),1002(demo)
demo:x:1002:ubuntu
Removing user ubuntu from group demo

Точные тексты: в старых версиях coreutils кавычки в сообщении другие, а на Ubuntu 26.04 (утилиты на Rust) хвост может чуть отличаться; смысл тот же: Permission denied. Строка Removing user ubuntu from group demo может быть на русском или иначе, если у тебя другая локаль.

Как читать вывод:

  • Первые четыре строки: твои id, имя, запись из passwd (семь полей, как разобрали в теории) и группа sudo. В длинном списке групп виртуальной машины Multipass нас интересует только 27(sudo): она даёт право на sudo. Остальные группы выданы образом (журналы, звук, диски), номера у тебя могут отличаться.
  • ls -l подтверждает теорию: passwd и group открыты всем (r-- в конце), shadow для остальных закрыт (---), его группа shadow.
  • В shadow у root вместо хэша стоит *: это «пароля нет, войти паролем нельзя». Остальные поля про срок жизни пароля, сейчас не важны.
  • Записей всего 22 (у тебя число другое), из них 20 системных с UID меньше 1000. На ВМ Multipass у ubuntu групп больше (adm, sudo, lxd и другие), это нормально. Живая оболочка только у root, sync (служебная учётная запись, оболочка /bin/sync не для входа) и тебя. Служебные учётные записи (nobody, www-data и подобные) имеют оболочку nologin или /bin/false, поэтому фильтр их убирает; nobody это пользователь с UID 65534, которому намеренно ничего не принадлежит.
  • Последние строки: первая id (процесс, который живёт с момента твоего входа) не знает о demo, а id ubuntu читает файл заново и показывает 1002(demo). Поэтому «добавил в группу, а доступа нет» лечится новым входом в систему.

Объясни себе:

  • Почему у /etc/passwd права 644, если это «список пользователей», а у /etc/shadow закрыт от всех?
  • Что случилось бы, если бы в команде usermod не было -a?

Типичные ошибки:

  • usermod: group 'demo' does not exist: группа не создана (шаг groupadd пропущен или упал).
  • groupadd: group 'demo' already exists: остался хвост от прошлого запуска. Удали: sudo groupdel demo и повтори.
  • usermod: user '' does not exist: пустое имя (ты написал $USER, а переменная не задана). Возьми "$(whoami)", как в примере.

Задание 2. Права числами, каталоги и umask

Цель: научиться предсказывать права результата, понять, что делает x на каталоге, и прочитать namei -l.

Предскажи: какие права получит новый файл при umask 022? А новый каталог? Что станет с файлом 640 после chmod u+x,g-r?

Ответ

Файл 644 (-rw-r--r--), каталог 755. Файл 640 после u+x станет 740, после g-r станет 700.

Шаги

  1. Подготовь песочницу и создай файл и каталог. mkdir -p создаёт каталог и не ругается, если он уже есть, && запускает следующую команду только при успехе предыдущей. Команда umask 022 действует, пока открыта эта вкладка терминала (закроешь, вернётся прежняя маска). Она сделана явно: на Ubuntu у обычного пользователя часто 0002, и тогда результаты были бы другими (см. теорию). Команда stat -c '%a %A %n' печатает права числом (%a), права буквами (%A) и имя (%n):
mkdir -p ~/perm-lab && cd ~/perm-lab
umask 022
umask
touch a.txt && mkdir d
stat -c '%a %A %n' a.txt d
  1. Меняй права и сверяй с предсказанием. Вторую команду мы разбирали в теории: u+x,g-r:
chmod 640 a.txt && stat -c '%a %A' a.txt
chmod u+x,g-r a.txt && stat -c '%a %A' a.txt
  1. Каталог: сначала r без x, потом x без r. Строка echo hello > d/f.txt создаёт файл f.txt внутри d с текстом hello (перенаправление > из урока 1.2). Владельцу (тебе) дадим только нужные биты, чтобы твои права «владельца» не мешали проверке:
echo hello > d/f.txt
chmod 644 d
command ls d
cat d/f.txt
chmod 100 d
command ls d
cat d/f.txt
chmod 755 d

command ls d вместо простого ls d нужен потому, что на Ubuntu ls в интерактивной оболочке подменён алиасом с цветом (ls --color=auto), а раскраска просит у системы сведения о каждом файле и может добавить лишние ошибки; command запускает настоящую программу без алиаса.

chmod 644 d: у владельца rw-, то есть есть r (видеть имена), но нет x (заходить). chmod 100 d: у владельца только x. Обрати внимание: тебе нужны именно права владельца, потому что ты владелец каталога и ядро применяет к тебе только их (правило «первый подходящий класс»).

  1. Чужой пользователь и путь. Системный пользователь nobody не владелец и не в твоей группе, он попадает в «остальные». Сначала вернём файлу 644 (в шаге 2 мы его закрыли), чтобы проверить только каталоги. namei -l покажет, где его останавливает система:
chmod 644 a.txt
sudo -u nobody cat ~/perm-lab/a.txt
namei -l ~/perm-lab/a.txt
  1. Маска для новых файлов. Скобки ( ... ) запускают команды в подоболочке, поэтому umask меняется только внутри и не влияет на твой терминал:
( umask 077; touch b.txt; mkdir e; stat -c '%a %A %n' b.txt e )
( umask 027; touch c.txt; mkdir g; stat -c '%a %A %n' c.txt g )
  1. Права на запуск. Создадим скрипт (printf печатает строку с \n как переводом строки), попробуем запустить, потом добавим x. Первая строка скрипта #!/bin/sh говорит системе, какой программой его выполнять:
printf '#!/bin/sh\necho "привет из скрипта"\n' > hello.sh
ls -l hello.sh
./hello.sh
chmod +x hello.sh
ls -l hello.sh
./hello.sh
  1. Частые ошибки, чтобы узнать их в лицо. Первая: ты не владелец, chmod запрещён (для опыта создаём файл и отдаём его root). Вторая: o без оператора. Обе команды должны упасть:
touch /tmp/x && sudo chown root /tmp/x && chmod 600 /tmp/x
chmod u+rwx,g-w,o hello.sh
sudo rm /tmp/x

Что должно получиться (Ubuntu 24.04)

0022
644 -rw-r--r-- a.txt
755 drwxr-xr-x d
640 -rw-r-----
700 -rwx------
f.txt
cat: d/f.txt: Permission denied
ls: cannot open directory 'd': Permission denied
hello
cat: /home/ubuntu/perm-lab/a.txt: Permission denied
f: /home/ubuntu/perm-lab/a.txt
drwxr-xr-x root    root    /
drwxr-xr-x root    root    home
drwxr-x--- ubuntu ubuntu ubuntu
drwxr-xr-x ubuntu ubuntu perm-lab
-rw-r--r-- ubuntu ubuntu a.txt
600 -rw------- b.txt
700 drwx------ e
640 -rw-r----- c.txt
750 drwxr-x--- g
-rw-r--r-- 1 ubuntu ubuntu 50 Sep 30 11:57 hello.sh
bash: ./hello.sh: Permission denied
-rwxr-xr-x 1 ubuntu ubuntu 50 Sep 30 11:57 hello.sh
привет из скрипта
chmod: changing permissions of '/tmp/x': Operation not permitted
chmod: invalid mode: 'u+rwx,g-w,o'
Try 'chmod --help' for more information.

На Ubuntu 26.04 часть базовых утилит может быть заменена на другие реализации (uutils coreutils, написаны на Rust), и тексты ошибок там формулируются по-своему. Смысл тот же: запрет и неверный режим.

Как читать вывод:

  • 0022 и первые две строки stat: права 644 и 755, ровно как считали по маске в теории (666-022, 777-022).
  • 640 -rw-r----- и 700 -rwx------: после chmod 640, затем после u+x,g-r. Совпадает с расчётом по битам.
  • Каталог 644: ls d работает (есть r, видно имена), но cat d/f.txt отказывает, потому что нет x, чтобы дойти до файла. Каталог 100: наоборот, ls отказывает (нет r, нельзя прочитать список), а если знаешь имя, то файл читается (cat d/f.txt печатает hello).
  • namei -l: первая строка f: это то, что мы проверяем, ниже права каждого звена пути. Виден drwxr-x--- на ubuntu (это домашний каталог), и именно там ядро останавливает nobody, хотя у самого a.txt права 644.
  • Маски: 077 дала 600 и 700, 027 дала 640 и 750. Значит, маска действительно определяет права новых файлов.
  • ./hello.sh до chmod +x отказывает (Permission denied при запуске, хотя читать файл можно), после выдачи x работает.

Объясни себе:

  • Почему при 644 на каталоге имена видны, а файл не прочитать, а при 100 наоборот?
  • Почему nobody не смог прочитать a.txt с правами 644? Какое звено пути его остановило?
  • Что изменилось бы, если бы я не поставил umask 022 в шаге 1, а у тебя была бы маска 0002?

Типичные ошибки:

  • chmod: invalid mode: 'u+rwx,g-w,o': после o не хватило =, + или -. Пиши o=, чтобы очистить.
  • chmod: changing permissions of '/tmp/x': Operation not permitted: ты не владелец файла, нужен sudo.
  • -bash: ./hello.sh: Permission denied (или bash: ./hello.sh: ...): у файла нет бита x. Выдай chmod +x hello.sh.
  • mkdir: cannot create directory 'd': File exists: каталог остался от прошлого запуска, это не ошибка, продолжай.

Если нейросеть предлагает chmod 777 или NOPASSWD: ALL, спроси, кому именно и что открывает каждое предложение, и проси вариант с минимальными правами. Правило sudoers всё равно проверь visudo -cf и sudo -l -U.

Задание 3. sudo на одну команду без риска

Цель: выдать пользователю право на одну команду, проверить файл до применения и убедиться, что остальное запрещено.

Предскажи: что произойдёт, если положить в /etc/sudoers.d/ файл с опечаткой и не проверять его visudo -cf?

Ответ

Правило с опечаткой не заработает, а sudo будет печатать syntax error. В зависимости от версии sudo пропадёт только это правило или sudo целиком (особенно если оно было единственным, дающим тебе доступ). Поэтому файл сначала проверяют в другом месте.

Шаги

  1. Создай пользователя без пароля (входить под ним не будем, только запускать команды через sudo -u). adduser создаёт пользователя вместе с домашним каталогом и группой, --disabled-password не задаёт пароль (по паролю войти нельзя), --gecos "" оставляет пустым поле «полное имя», чтобы adduser не задавал вопросов:
sudo adduser --disabled-password --gecos "" deploy
id deploy
  1. Открой вторую сессию: во втором окне терминала на ноутбуке выполни multipass shell devops (в WSL: wsl -d Ubuntu), потом в ней sudo -i (откроет оболочку root и оставит её). Если что-то сломаешь в первой, вторая это подстраховка. В первой сформируй правило в обычном файле и проверь. Здесь printf '...\n' > файл записывает одну строку, а ~/ это домашний каталог. sudo visudo -cf файл проверяет файл и ничего не устанавливает:
printf 'deploy ALL=(root) NOPASSWD: /usr/bin/du -sh /var/log\n' > ~/deploy-du.tmp
sudo visudo -cf ~/deploy-du.tmp
  1. Только после parsed OK установи файл. sudo install -m 440 -o root -g root источник цель копирует файл и сразу задаёт режим (-m), владельца (-o) и группу (-g). Дальше проверим правила целиком и попробуем разрешённую и запрещённую команду. Строка sudo -u deploy sudo -n команда означает: от имени deploy запустить sudo -n команда, а флаг -n (non-interactive) запрещает спрашивать пароль: если правила не хватает, команда сразу упадёт с отказом. du -sh /var/log (disk usage, -s итог, -h человекочитаемо) показывает размер каталога:
sudo install -m 440 -o root -g root ~/deploy-du.tmp /etc/sudoers.d/deploy-du
rm ~/deploy-du.tmp
ls -l /etc/sudoers.d/
sudo visudo -c
sudo -u deploy sudo -n /usr/bin/du -sh /var/log
sudo -u deploy sudo -n cat /etc/shadow
sudo -l -U deploy
  1. Убедись, что опечатка ловится. Файл заведомо неверный, поэтому мы его не устанавливаем:
printf 'deploy ALL(root) NOPASSWD: /usr/bin/du -sh /var/log\n' > ~/bad.tmp
sudo visudo -cf ~/bad.tmp
rm ~/bad.tmp

Что должно получиться (Ubuntu 24.04, sudo 1.9.15)

info: Adding user `deploy' ...
info: Selecting UID/GID from range 1000 to 59999 ...
info: Adding new group `deploy' (1001) ...
info: Adding new user `deploy' (1001) with group `deploy (1001)' ...
info: Creating home directory `/home/deploy' ...
info: Copying files from `/etc/skel' ...
info: Adding new user `deploy' to supplemental / extra groups `users' ...
info: Adding user `deploy' to group `users' ...
uid=1001(deploy) gid=1001(deploy) groups=1001(deploy),100(users)
/home/ubuntu/deploy-du.tmp: parsed OK
total 12
-r--r----- 1 root root 1068 Jan 29  2024 README
-r--r----- 1 root root   53 Sep 30 11:52 deploy-du
-r--r----- 1 root root   31 Sep 30 11:34 ubuntu
/etc/sudoers: parsed OK
/etc/sudoers.d/README: parsed OK
/etc/sudoers.d/deploy-du: parsed OK
/etc/sudoers.d/ubuntu: parsed OK
17M	/var/log
sudo: a password is required
Matching Defaults entries for deploy on b04c0542541c:
    env_reset, mail_badpass, secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin\:/snap/bin, use_pty

User deploy may run the following commands on b04c0542541c:
    (root) NOPASSWD: /usr/bin/du -sh /var/log
/home/ubuntu/bad.tmp:1:11: syntax error
deploy ALL(root) NOPASSWD: /usr/bin/du -sh /var/log
          ^

Этот вывод получен в контейнере с Ubuntu 24.04, поэтому имя машины (b04c0542541c) похоже на случайный набор символов, а в твоей ВМ будет её имя. Размер /var/log и список файлов в /etc/sudoers.d/ у тебя свои: файл пользователя называется ubuntu или 90-cloud-init-users, лишние строки parsed OK про такие файлы это нормально. Первый sudo в конвейере sudo -u deploy sudo ... может один раз спросить твой пароль.

На Ubuntu 26.04 вместо классического sudo может стоять его переписанная на Rust версия sudo-rs, и тексты там другие. Пример (тексты зависят от версии, сверяй со своим выводом):

/home/ubuntu/bad.tmp:1:11: syntax error: expecting '=' but found '('
deploy ALL(root) NOPASSWD: /usr/bin/du -sh /var/log
          ^
visudo: invalid sudoers file

visudo -c там печатает одну строку /etc/sudoers: parsed OK, а отказ на запрещённой команде звучит как sudo: I'm sorry deploy. I'm afraid I can't do that. Смысл тот же: разрешена только одна команда.

Как читать вывод:

  • info: ... строки: что делает adduser. Ему нужно создать пользователя deploy (номер 1001), личную группу с тем же именем, домашний каталог, скопировать в него шаблоны из /etc/skel. Затем id deploy подтверждает результат.
  • parsed OK про временный файл: синтаксис верный, можно ставить.
  • ls -l /etc/sudoers.d/: наш файл deploy-du с режимом -r--r----- (это и есть 440), владелец root. Файл README идёт с пакетом.
  • visudo -c перечисляет главный файл и все файлы каталога, у каждого parsed OK.
  • 17M /var/log: разрешённая команда сработала от имени root, хотя deploy обычный пользователь.
  • sudo: a password is required: запрещённая команда cat /etc/shadow отвергнута. Мы использовали -n, поэтому sudo не спросил пароль, а сразу отказал.
  • sudo -l -U deploy (list, «покажи разрешённое» для пользователя) выводит, что можно deploy. Это лучший способ проверить, что правило даёт именно то, что ты хотел.
  • Последний блок: visudo -cf на файле с опечаткой показал строку, позицию и стрелку ^ на месте ошибки.

Объясни себе:

  • Почему файл лежит в sudoers.d, а не в /etc/sudoers?
  • Чем правило deploy ALL=(root) NOPASSWD: /usr/bin/du -sh /var/log отличается от deploy ALL=(ALL) NOPASSWD: ALL? Какое из них ты выдашь разработчику?
  • Почему в правиле путь /usr/bin/du, а не просто du? Что ответит visudo -cf, если написать du без пути?

Типичные ошибки:

  • fatal: The user deploy’ already exists.: пользователь уже есть, пропусти шаг создания и иди дальше (в adduser на Ubuntu 24.04 и 26.04 это fatal:`, код возврата 11).
  • /home/ubuntu/deploy-du.tmp:1:11: syntax error: опечатка в правиле, например пропущен =. Исправь файл, не устанавливая его. Стрелка ^ показывает, где смотреть.
  • sudo: a password is required на разрешённой команде: не совпали аргументы (правило разрешает ровно du -sh /var/log, а ты набрал du -h /var/log).
  • visudo: /etc/sudoers.d/deploy-du: bad permissions, should be mode 0440: ты положил файл через cp с режимом 644. Исправь sudo chmod 440 /etc/sudoers.d/deploy-du.

Получил Permission denied в логе сервиса? Дай нейросети текст ошибки, вывод namei -l /путь и ps -o user,pid,args -u notes. По этим трём выводам она сможет назвать причину, а без них будет гадать. Перед вставкой замени в выводе имена хостов, IP-адреса, токены и рабочие пути на заглушки (HOST, 10.0.0.1, TOKEN).

Задание 4. Проект: сервис живёт под пользователем notes

Цель: установить «Заметки» как на сервере: свой пользователь, каталог данных 750, код в /opt/notes/ под root, запуск через sudo -u notes. Это шаг сквозного проекта, после него app.py версии v2.

Предскажи: запустим сервис от notes, а код принадлежит root с 644. Сможет ли сервис читать код? Сможет ли он его изменить?

Ответ

Читать сможет (644, «остальным» чтение разрешено), изменить нет: писать может только root. Даже при взломе сервиса код не подменить.

Нужен пользователь deploy из задания 3 (в шаге 4 мы проверим, что он не читает данные). Если ты его пропустил, создай: sudo adduser --disabled-password --gecos "" deploy.

Шаги

  1. Обнови ~/notes/app.py до v2 (замени файл целиком). Версия из эталона: project/notes/versions/v2.py. Скопируй код ниже в редактор, который использовал в уроке 1.1, или скачай файл командой curl -fsSL -o ~/notes/app.py https://raw.githubusercontent.com/distinguished-sre/learning/main/devops/project/notes/versions/v2.py.
#!/usr/bin/env python3
"""Заметки v2: файловое хранилище и /healthz."""
import json
import os
import sys
import threading
from datetime import datetime, timezone
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import urlparse

VERSION = os.environ.get("APP_VERSION", "dev")
HOST = os.environ.get("HOST", "127.0.0.1")
DATA = os.environ.get("NOTES_DATA", "/var/lib/notes/notes.txt")
try:
    PORT = int(os.environ.get("PORT", "8080"))
except ValueError:
    print("ошибка: PORT должен быть числом", file=sys.stderr)
    sys.exit(2)

LOCK = threading.Lock()  # записи в файл идут по одной


def read_notes():
    """Одна заметка на строку, формат JSON. Нет файла: заметок нет."""
    try:
        with open(DATA, encoding="utf-8") as f:
            return [json.loads(line) for line in f if line.strip()]
    except FileNotFoundError:
        return []


def add_note(text):
    with LOCK:
        note = {
            "id": len(read_notes()) + 1,
            "text": text,
            "created_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
        }
        with open(DATA, "a", encoding="utf-8") as f:
            f.write(json.dumps(note, ensure_ascii=False) + "\n")
        return note["id"]


class Handler(BaseHTTPRequestHandler):
    def send(self, code, body, ctype="application/json; charset=utf-8"):
        data = body.encode("utf-8")
        self.send_response(code)
        self.send_header("Content-Type", ctype)
        self.send_header("Content-Length", str(len(data)))
        self.end_headers()
        self.wfile.write(data)

    def json(self, code, obj):
        self.send(code, json.dumps(obj, ensure_ascii=False))

    def do_GET(self):
        path = urlparse(self.path).path
        if path == "/":
            self.send(200, f"Notes service v{VERSION}\n", "text/plain; charset=utf-8")
        elif path == "/healthz":
            self.send(200, "ok", "text/plain; charset=utf-8")
        elif path == "/readyz":
            ok = os.access(os.path.dirname(DATA), os.W_OK)
            self.send(200 if ok else 503, "ready" if ok else "not ready",
                      "text/plain; charset=utf-8")
        elif path == "/notes":
            try:
                self.json(200, read_notes())
            except OSError as e:
                print(f"ошибка хранилища: {e}", file=sys.stderr)
                self.json(500, {"error": "storage"})
        else:
            self.json(404, {"error": "not found"})

    def do_POST(self):
        if urlparse(self.path).path != "/notes":
            self.json(404, {"error": "not found"})
            return
        try:
            length = int(self.headers.get("Content-Length", "0"))
            text = json.loads(self.rfile.read(length))["text"]
        except (ValueError, KeyError, TypeError):
            self.json(400, {"error": "нужен JSON {\"text\": \"...\"}"})
            return
        if not isinstance(text, str) or not text.strip() or len(text) > 1000:
            self.json(400, {"error": "text: от 1 до 1000 символов"})
            return
        try:
            self.json(201, {"id": add_note(text)})
        except OSError as e:
            print(f"ошибка хранилища: {e}", file=sys.stderr)
            self.json(500, {"error": "storage"})

    def log_message(self, fmt, *args):
        if getattr(self, "path", "") not in ("/healthz", "/readyz"):
            print(f"{self.address_string()} {fmt % args}", file=sys.stderr)


if __name__ == "__main__":
    print(f"Notes v{VERSION} слушает {HOST}:{PORT}, данные {DATA}", file=sys.stderr)
    ThreadingHTTPServer((HOST, PORT), Handler).serve_forever()

Что нового в v2 по сравнению с v1, чтобы не читать код вслепую:

  • Файловое хранилище. Заметки не теряются при перезапуске: add_note дописывает по одной заметке в строку файла (NOTES_DATA, по умолчанию /var/lib/notes/notes.txt), read_notes читает файл обратно. Формат JSON: каждая строка отдельный объект {"id": ..., "text": ..., "created_at": ...}. Пока файла нет (первый запуск), заметок просто нет.
  • LOCK. Сервер обслуживает несколько запросов одновременно (потоками). Замок гарантирует, что две записи не смешаются в файле: пока пишет один, второй ждёт.
  • /healthz отвечает ok, если процесс жив. /readyz отвечает ready, если каталог данных доступен на запись (os.access(..., os.W_OK)), иначе 503 not ready. Разница: healthz это «процесс работает», readyz это «он готов принимать работу». Подробнее про такие проверки в теме Kubernetes.
  • Ошибки хранилища. Если файл не открыть (нет прав, нет места), сервер печатает причину в stderr и отвечает клиенту 500 {"error": "storage"}. Именно такой ответ мы будем провоцировать в «Сломай и почини».
  1. Создай системного пользователя и каталоги. Разбор команд:
    • useradd --system --no-create-home --shell /usr/sbin/nologin notes: --system создаёт системного пользователя (UID меньше 1000, без срока жизни пароля), --no-create-home не создаёт домашний каталог, --shell /usr/sbin/nologin запрещает вход. Личную группу notes useradd --system создаёт сам;
    • install -d -m 750 -o notes -g notes /var/lib/notes: -d значит «создать каталог», -m 750 режим, -o и -g владелец и группа. Одной командой создаётся каталог с нужными правами, без отдельных mkdir, chown, chmod;
    • install -m 644 -o root -g root ... /opt/notes/app.py: копирует код с владельцем root;
    • stat -c '%a %U:%G %n': режим числом, владелец пользователь:группа, имя;
    • getent passwd notes: запись пользователя из passwd;
    • sudo su - notes: пытается «войти» пользователем notes через su. Так мы проверяем отказ nologin. Пишем именно с sudo, потому что у обычного su спросили бы пароль notes, а пароля у него нет; у root на Ubuntu пароля тоже нет.
# системный пользователь: без домашнего каталога и без входа
sudo useradd --system --no-create-home --shell /usr/sbin/nologin notes
sudo install -d -m 750 -o notes -g notes /var/lib/notes
sudo install -d -m 755 -o root -g root /opt/notes
sudo install -m 644 -o root -g root ~/notes/app.py /opt/notes/app.py
stat -c '%a %U:%G %n' /var/lib/notes /opt/notes /opt/notes/app.py
getent passwd notes
sudo su - notes

Последняя команда должна не пустить: у notes оболочка nologin.

  1. В первом терминале запусти сервис от notes. Команда sudo -u notes python3 /opt/notes/app.py запустит python3 от имени notes и передаст ему путь к программе. Права созданного файла зависят от маски процесса: перед запуском можно посмотреть sudo -u notes sh -c umask (в нашем запуске маска была 0002; у тебя может быть 0022). Терминал будет занят: сервис работает «на переднем плане», логи печатаются в него же:
sudo -u notes python3 /opt/notes/app.py
  1. Во втором терминале проверь работу и файл данных. Разбор команд:

    • ps -o user,pid,args -C python3 | grep -E 'USER|[a]pp.py': пользователь, номер процесса и командная строка; grep оставляет заголовок и строку с app.py, потому что на сервере есть и другие python3, это системные службы;
    • curl -s тихий режим (без полосы загрузки), -X POST метод POST, -d '...' тело запроса;
    • echo в конце нужен только чтобы следующий вывод начался с новой строки;
    • sudo ls -l /var/lib/notes нужен с sudo, потому что каталог закрыт для остальных (750);
    • sudo -u deploy cat ... и sudo -u notes sh -c '...' проверяют, что чужой пользователь данных не читает, а сам сервис не может переписать свой код.

    Команды:

ps -o user,pid,args -C python3 | grep -E 'USER|[a]pp.py'
curl -s localhost:8080/healthz; echo
curl -s localhost:8080/readyz; echo
curl -s -X POST localhost:8080/notes -d '{"text":"первая заметка"}'; echo
curl -s localhost:8080/notes; echo
sudo ls -l /var/lib/notes
sudo -u deploy cat /var/lib/notes/notes.txt
sudo -u notes sh -c 'echo x >> /opt/notes/app.py'
  1. Останови сервис Ctrl+C в первом терминале.

Что должно получиться (Ubuntu 24.04)

750 notes:notes /var/lib/notes
755 root:root /opt/notes
644 root:root /opt/notes/app.py
notes:x:999:997::/home/notes:/usr/sbin/nologin
su: warning: cannot change directory to /home/notes: No such file or directory
This account is currently not available.

В первом терминале при запуске сервис пишет в stderr:

Notes vdev слушает 127.0.0.1:8080, данные /var/lib/notes/notes.txt

Во втором терминале:

USER         PID COMMAND
notes        396 python3 /opt/notes/app.py
ok
ready
{"id": 1}
[{"id": 1, "text": "первая заметка", "created_at": "2026-09-30T11:54:25+00:00"}]
total 4
-rw-rw-r-- 1 notes notes 92 Sep 30 11:55 notes.txt
cat: /var/lib/notes/notes.txt: Permission denied
sh: 1: cannot create /opt/notes/app.py: Permission denied

В логе первого терминала после запросов появятся строки вида 127.0.0.1 "POST /notes HTTP/1.1" 201 - (запросы к /healthz и /readyz сервис не логирует намеренно, чтобы проверки не засоряли журнал). UID notes (999), PID (396) и время у тебя свои. Права notes.txt зависят от маски процесса: в нашем запуске получилось 664 (-rw-rw-r--), у тебя может быть 644 (-rw-r--r--). Проверь umask в своей сессии (см. теорию про umask). Сам вывод сервиса версии называет vdev: переменная APP_VERSION не задана, поэтому версия dev. Из юнит-файла в уроке 1.8 она будет приходить в нормальном виде.

Как читать вывод:

  • Первые три строки: каталог данных 750 notes:notes, каталог кода 755 root:root и файл кода 644 root:root, ровно то, что мы хотели по схеме «принципа наименьших привилегий».
  • getent passwd notes: UID 999 (меньше 1000, системный), основная группа 997 (личная группа notes), домашний каталог /home/notes записан, но не создан, оболочка nologin. su - notes не пускает: This account is currently not available.
  • ps: процесс python3 работает от пользователя notes, а не root. Проверь это всегда, когда сомневаешься, кто владелец процесса.
  • ok и ready: сервис жив и каталог данных доступен на запись.
  • {"id": 1} и следом список: заметка записана и читается обратно. Поле created_at время создания в формате UTC (всемирное время).
  • sudo ls -l: файл создал сам сервис, поэтому владелец notes:notes. Права у файла определил umask процесса: сервис создал файл с максимумом 666, минус маска процесса (в нашем запуске 002, поэтому 664; ответ на вопрос «кто определяет права файла»).
  • Permission denied для deploy: файл читаем даже «остальным» (r-- в конце), но deploy до него не дошёл: каталог /var/lib/notes закрыт (750), а мы помним, что права файла проверяются только после прохода по всему пути.
  • Последняя строка: даже под notes нельзя изменить свой собственный код. Взломщик сервиса не сможет подменить программу.

Состояние проекта: app.py v2, пользователь notes, /var/lib/notes (750 notes:notes), код в /opt/notes/, запуск руками. Сервис пока не переживает закрытие терминала, это тема урока 1.8.

Объясни себе:

  • Почему процесс notes может писать в /var/lib/notes, а deploy не может даже читать?
  • Почему файл notes.txt получил 664 (или 644), хотя каталог 750? Кто определяет права файла: каталог или создающий процесс?
  • Что произойдёт с новой заметкой, если запустить сервис не от notes, а от ubuntu, и почему это плохо?

Типичные ошибки:

  • useradd: user 'notes' already exists: пользователь уже создан, пропусти этот шаг.
  • PermissionError: [Errno 13] Permission denied: '/var/lib/notes/notes.txt' (в логе сервиса, клиент видит 500 {"error": "storage"}): каталог принадлежит не notes или режим не тот. Проверь stat -c '%a %U:%G' /var/lib/notes.
  • OSError: [Errno 98] Address already in use: порт 8080 уже занят прежним запуском сервиса. Найди процесс sudo ss -tlnp | grep 8080 (подробно про ss в уроке 2.1) и останови его: Ctrl+C в первом терминале или sudo pkill -f '[o]pt/notes/app.py' (скобки в образце нужны, чтобы pkill не нашёл сам себя).
  • curl: (7) Failed to connect to localhost port 8080 after 0 ms: Couldn't connect to server: сервис не запущен (не выполнен шаг 3 или он упал). Посмотри вывод первого терминала.
  • python3: can't open file '/opt/notes/app.py': [Errno 2] No such file or directory: шаг с install пропущен или путь неверный.
  • ls: cannot open directory '/var/lib/notes': Permission denied: ты запустил ls без sudo. Каталог закрыт для остальных, это ожидаемо.

Сломай и почини

Скачай скрипт и запусти нужный сценарий. Запускай его только в ВМ: он меняет права каталога данных и файл /etc/sudoers.d/deploy-du. Здесь его можно запустить, не читая: сумма сверяется, а ВМ одноразовая. На работе чужой скрипт сначала читают (less), и только потом запускают; на проде непрочитанное не запускают никогда. Прочитай его после упражнения: less ~/break-1.3.sh. У curl флаг -f значит «при ошибке сервера не сохраняй страницу с ошибкой», -s тихий режим, -S показывать ошибки, -L идти по перенаправлениям, -o задаёт имя файла. Команда sha256sum -c сверяет контрольную сумму скачанного файла с ожидаемой:

curl -fsSL -o ~/break-1.3.sh https://raw.githubusercontent.com/distinguished-sre/learning/main/devops/project/notes/break/1.3/break.sh
echo 'd84ebe8ffc7d60818d39b5c4183c9a04f140021e7a429c5d46d9f66d8d9ce853  '"$HOME/break-1.3.sh" | sha256sum -c
sudo bash ~/break-1.3.sh 1

Должно быть OK. Если FAILED, не запускай и сообщи автору курса.

Сценарии 1, 2 и 3. Проходи по одному: запусти, найди причину, почини сам или командой sudo bash ~/break-1.3.sh fix, потом бери следующий. Каждый начинай с чистого состояния из заданий 3 и 4 (пользователь deploy, сервис под notes). Для сценариев 1 и 3 сервис должен быть запущен, как в задании 4 (sudo -u notes python3 /opt/notes/app.py в отдельном терминале). В конце выполни fix и удали скрипт: rm ~/break-1.3.sh.

Симптом

  • Сценарий 1. Сервис стартует, /healthz отвечает ok, GET /notes показывает заметки, но POST /notes возвращает 500 {"error": "storage"}, а в логе сервиса Permission denied.
  • Сценарий 2. Каждая команда с sudo начинает печатать syntax error про файл в /etc/sudoers.d/, а sudo -u deploy sudo -n /usr/bin/du -sh /var/log перестаёт работать (просит пароль или отказывает).
  • Сценарий 3. Сервис работает, но ты вдруг видишь drwxrwxrwx на /var/lib/notes, и deploy спокойно читает заметки.

Гипотезы

Прежде чем проверять, выпиши возможные причины. Для этих симптомов подходят:

  1. Сценарий 1: не тот владелец или режим каталога или файла (например, файл создали sudo при отладке).
  2. Сценарий 2: опечатка в правиле sudoers, неверный режим или владелец файла.
  3. Сценарий 3: кто-то «починил» права через chmod -R 777.

Подумай, какие из этих гипотез подтвердит stat, какие visudo -c. Порядок из последнего раздела теории («как разбирать Permission denied») тебе поможет.

Проверки

stat -c '%a %U:%G %n' /var/lib/notes /var/lib/notes/notes.txt   # 1 и 3: владелец и режим
namei -l /var/lib/notes/notes.txt                                # 1: где ломается путь
sudo -u notes touch /var/lib/notes/probe                         # 1: воспроизвести от имени notes
sudo visudo -c                                                   # 2: какой файл и какая строка сломаны
ls -l /etc/sudoers.d/                                            # 2: владелец и режим файлов
sudo find /var/lib/notes -perm -o+w                              # 3: что доступно на запись всем

Если в первой строке stat показывает stat: cannot statx ...: Permission denied, запусти её с sudo: каталог 750 закрыт и для тебя.

Разбор всех сценариев

Сценарий 1. stat показывает 755 root:root /var/lib/notes и 644 root:root .../notes.txt, а namei -l выводит те же root root у каталога notes и файла. Пробный sudo -u notes touch /var/lib/notes/probe даёт Permission denied. Каталог и файл принадлежат root (например, их создали sudo при отладке), у notes нет права записи. Читать он может (r для остальных), поэтому GET /notes работает, а POST нет. В логе сервиса появляется ошибка хранилища: [Errno 13] Permission denied: '/var/lib/notes/notes.txt'. Заодно /readyz отвечает not ready. Исправление минимально нужным:

sudo chown -R notes:notes /var/lib/notes
sudo chmod 750 /var/lib/notes
sudo chmod 640 /var/lib/notes/notes.txt

После этого POST снова возвращает {"id": ...}. Перезапуск сервиса не нужен: права проверяются при каждом обращении к файлу.

Сценарий 2. sudo visudo -c печатает файл, строку и стрелку:

/etc/sudoers.d/deploy-du:1:11: syntax error
deploy ALL(root) NOPASSWD: /usr/bin/du -sh /var/log
          ^

Ты видишь, что после ALL пропущено =. На стенде (sudo 1.9.15) такая ошибка не отключила sudo целиком, пропала только сломанная строка, но правило для deploy не работает, а шум появляется при каждой команде. sudo -l -U deploy печатает User deploy is not allowed to run sudo on .... Исправление: либо поправь файл через безопасный путь (временный файл, visudo -cf, install), либо удали его и создай заново:

printf 'deploy ALL=(root) NOPASSWD: /usr/bin/du -sh /var/log\n' > ~/deploy-du.tmp
sudo visudo -cf ~/deploy-du.tmp
sudo install -m 440 -o root -g root ~/deploy-du.tmp /etc/sudoers.d/deploy-du
rm ~/deploy-du.tmp

Это лёгкий вариант поломки. Настоящая авария случается, когда сломано единственное правило, которое давало тебе sudo, или неверны права /etc/sudoers: тогда sudo не запустится совсем. Спасает вторая сессия, где ты уже стал root командой sudo -i (из неё можно исправить или удалить файл), либо консоль ВМ у провайдера или режим восстановления. Урок: правило не попадает в sudoers.d, пока visudo -cf не сказал parsed OK, режим у файла 440, а вторая root-сессия открыта заранее.

Сценарий 3. ls -ld /var/lib/notes показывает drwxrwxrwx, файл тоже -rwxrwxrwx, sudo find /var/lib/notes -perm -o+w перечисляет оба, а sudo -u deploy cat /var/lib/notes/notes.txt печатает заметки. Ошибку прав 777 скрыл (сервис пишет), но открыл данные всем и сделал файл данных исполняемым. Верни правильные права:

sudo chown -R notes:notes /var/lib/notes
sudo chmod 750 /var/lib/notes
sudo find /var/lib/notes -type f -exec chmod 640 {} +

Разбор find: -type f выбирает только файлы, -exec chmod 640 {} + запускает chmod 640 для найденных ({} подставляет их пути, + передаёт сразу пачкой). Каталог и файлы получают разные режимы, поэтому одним chmod -R это не сделать.

Правило для дежурного: увидел Permission denied, иди по порядку: чей процесс, какой путь, права по пути (namei -l), проверка от имени пользователя сервиса (sudo -u), минимальная правка владельца или режима. 777 и root не решения.

ИИ в помощь

Нейросеть хорошо объясняет права и правила sudo, но не видит твой сервер: кто владелец файла и какие права у каталога по пути, она знает только по тому, что ты ей покажешь. Общие правила работы с ней: ИИ-помощник.

Задача: найти причину Permission denied по выводам команд.

Сервис работает от пользователя <имя> и пишет в лог: <точный текст ошибки>.
Вот вывод проверок: namei -l <путь>: <вывод>; id <имя>: <вывод>; ls -ld <каталог>: <вывод>.
Объясни по шагам, где отказ и какое минимальное исправление нужно. Не предлагай chmod 777
и запуск от root. Для каждого шага скажи, кому именно открывается доступ.

Проверь ответ: воспроизведи отказ от имени сервиса: sudo -u <имя> cat <путь>, а после исправления проверь, что отказ исчез и что чужой пользователь по-прежнему не имеет доступа. Типичная ошибка: нейросеть советует chmod -R 777 или chown на весь каталог вместо одного файла.

Задача: составить правило sudoers для одной команды.

Нужно разрешить пользователю deploy перезапускать сервис notes через sudo без пароля
и ничего больше. Напиши файл для /etc/sudoers.d/ и команды проверки (visudo -cf)
и установки с правильными владельцем и режимом. Используй абсолютные пути и точные аргументы.

Проверь ответ: прогони visudo -cf файл, потом sudo -l -U deploy и проверь, что stop и status не разрешены. Типичная ошибка: NOPASSWD: ALL или шаблон * в аргументах, который открывает больше, чем нужно.

Задача: объяснить права числом и символами.

Объясни по цифрам и по буквам режимы 640, 750, 2775 и 1777: кто что может,
и приведи по одному примеру, где такой режим уместен. Скажи, как получить каждый из них через chmod.

Проверь ответ: выставь режимы на тестовых файлах и сверь строку ls -l с ответом. Типичная ошибка: путают позицию s и t или забывают, что setuid на скриптах игнорируется.

Словарик урока

Термин Простыми словами
Пользователь (user) Учётная запись, от имени которой работают программы и люди; ядро видит её как число
UID, GID Номер пользователя и номер группы; ядро работает с числами, а не с именами
root Пользователь с UID 0, которому разрешено всё; суперправа дают число 0, а не имя
Ядро (kernel) Главная часть системы: управляет памятью, диском, сетью и проверяет права
Процесс Запущенная программа; действует от имени пользователя, который её запустил
Оболочка (shell) Программа, которая читает команды в терминале, у людей bash, у сервисов nologin
Системный пользователь Пользователь для сервиса: UID меньше 1000, без входа в систему
/etc/passwd, /etc/shadow, /etc/group Файлы пользователей, хэшей паролей и групп; shadow читает только root
Хэш пароля Необратимое превращение пароля в строку: можно проверить пароль, нельзя восстановить
Основная и дополнительные группы Группа новых файлов пользователя и остальные группы, где он состоит; права проверяются по всем
Права (permissions) Кто (владелец, группа, остальные) что (r, w, x) может делать с файлом или каталогом
rwx Читать (4), писать (2), запускать или «проходить» через каталог (1)
Режим 750 Числовая запись прав: владелец rwx, группа r-x, остальные ничего
x на каталоге Право войти в каталог и обращаться к файлам по имени; нужно на каждом звене пути
chmod, chown Изменить права и изменить владельца (владельца меняет только root)
umask Маска процесса: какие права отбросить у новых файлов (022 даёт файлам 644)
setuid, setgid, sticky Особые биты: запуск с правами владельца, наследование группы, запрет удалять чужие файлы
su Переключение на другого пользователя целиком с его паролем
sudo Выполнить одну команду от имени другого пользователя (по умолчанию root) с твоим паролем и записью в журнал
sudoers, /etc/sudoers.d/ Правила: кто и какие команды может выполнять через sudo
visudo -cf Проверка синтаксиса файла правил до установки
Принцип наименьших привилегий Выдавай ровно те права, что нужны для работы, и не больше
namei -l Показывает владельцев и права каждого звена пути до файла

Вопросы с собеседований

Раздел для повторения: ответь вслух, потом открой ответ. Короткие вопросы с пометкой [на скорость] тренируй на время: ответ за 30 секунд.

1. [junior] [часто] Что значит 755, 644 и 600 и где ты их применяешь?

Ответ

Каждая цифра это права одного класса: владелец, группа, остальные. Цифра складывается из r=4, w=2, x=1. 755: владелец читает, пишет и запускает, остальные читают и запускают. Это каталоги и программы. 644: владелец пишет, все читают: обычные файлы. 600: только владелец: ключи, токены, пароли.

Что хотят услышать: разбор по цифрам (4, 2, 1), три примера использования, для каталога x значит «проходить».

Красный флаг: «755 это когда файл виден всем» без объяснения битов.

2. [junior] [часто] Зачем запускать сервис не от root?

Ответ

Если сервис взломают, у злоумышленника будут права процесса. От root это вся система, от отдельного пользователя только его данные. Ещё меньше ущерба от ошибок: баг удаления не заденет систему.

Что хотят услышать: принцип наименьших привилегий (least privilege), отдельный пользователь на сервис, код только для чтения.

Красный флаг: «root удобнее, не нужно возиться с правами».

3. [junior] [часто] В чём разница между su и sudo?

Ответ

su переключает на другого пользователя целиком, нужен его пароль. sudo выполняет одну команду от имени другого по правилам sudoers, требует твой пароль и пишет в журнал.

Что хотят услышать: аудит команд, отсутствие общего пароля root, тонкая настройка правил.

Красный флаг: «sudo это просто su с другим названием».

4. [junior] [на скорость] Сервис пишет лог, а получает Permission denied. Как разберёшься?

Ответ

Сначала узнаю, от кого работает процесс (ps -o user), затем смотрю права на файл и на каждый каталог пути (namei -l). Проверяю запись от имени пользователя сервиса (sudo -u svc touch ...). Правлю владельца или группу, а не открываю всем. Если файл 644, а отказ всё равно есть, проверяю x на каждом каталоге пути, свои группы (id), ACL (getfacl) и параметры монтирования.

Что хотят услышать: namei -l, проверка x на каталогах пути, sudo -u, «минимально нужные права».

Красный флаг: сразу chmod 777 или запуск от root.

5. [junior] Что такое umask и почему файл, созданный сервисом, отличается по правам от твоего?

Ответ

Это маска процесса: биты, которые отбрасываются от максимума (666 для файлов, 777 для каталогов) при создании. Маска у каждого процесса своя. У меня 022 даёт 644, у сервиса может быть 077 и 600, а у пользователя с личной группой на Ubuntu 002 и 664.

Что хотят услышать: «отбрасывает биты», привязка к процессу, где задаётся (для сервисов в unit-файле UMask=, тема 1.8).

Красный флаг: «umask это права по умолчанию для всех файлов на системе».

6. [middle] Тебе нужно, чтобы разработчик мог перезапускать один сервис и больше ничего. Как выдашь?

Ответ

Отдельный файл в /etc/sudoers.d/ с правилом на конкретную команду с абсолютным путём и аргументами, режим 440. Проверяю visudo -cf до установки и держу вторую root-сессию. В правиле sudoers пишу точную команду с аргументами: правило без аргументов разрешает любые. Шаблоны * в аргументах не использую: через них можно добавить лишние аргументы и обойти ограничение.

Что хотят услышать: visudo -cf, sudoers.d, абсолютный путь, риск шаблонов (* позволяет добавить аргументы и обойти ограничение), sudo -l -U.

Красный флаг: «добавлю в группу sudo» или ALL=(ALL) NOPASSWD: ALL.

7. [middle] Прод после чьей-то правки отвечает 500, в логе Permission denied на /var/lib/app/data. Коллега предлагает chmod -R 777. Твои действия?

Ответ

Отказываюсь. Смотрю stat и namei -l, выясняю, кто владелец процесса и что изменилось (деплой мог создать файлы от root). Возвращаю владельца chown -R app:app и режим 750 на каталог, 640 на файлы. Проверяю запись от имени app и перезапускаю, если нужно. Причину закрепляю: деплой не должен запускаться от root.

Что хотят услышать: диагностика раньше действий, минимальные права, поиск первопричины (кто создал файлы), исключение root из процесса деплоя.

Красный флаг: согласие на 777 «временно».

8. [middle] Ты добавил пользователя в группу docker (или другую), но доступа всё ещё нет. Почему?

Ответ

Группы процесс получает при входе. Текущая сессия и уже запущенные процессы живут со старым списком. Нужен новый вход (для сервиса перезапуск), проверяю id и grep Groups /proc/PID/status. Отдельно помню: группа docker это де-факто root, потому что членам разрешено запускать контейнеры с доступом к файлам хоста. Группу выдают осознанно.

Что хотят услышать: id против getent group, новая сессия или перезапуск сервиса, безопасность группы docker.

Красный флаг: перезагружает сервер.

9. [middle] Что такое setuid, зачем он нужен и чем опасен?

Ответ

Бит на исполняемом файле: процесс работает с правами владельца файла. Так passwd меняет /etc/shadow, обычному пользователю запись туда недоступна. Опасно: уязвимость в такой программе даёт root. Аудит: find / -xdev -perm -4000 -type f, лишние снимаю или убираю; на дисках с данными ставлю параметр монтирования nosuid, который запрещает setuid.

Что хотят услышать: пример (passwd, sudo), find -perm -4000, что на скриптах бит игнорируется, nosuid при монтировании.

Красный флаг: «это просто права на запуск».

10. [middle] В каталоге лежит чужой файл с правами 600. Можешь ли ты его удалить, и от чего это зависит?

Ответ

Удаление зависит от прав на каталог, а не на файл. Если у меня есть w и x на каталоге, я удалю файл, даже когда его не могу прочитать. Исключение: sticky bit на каталоге (как /tmp): тогда удалить может только владелец файла, владелец каталога или root. Sticky bit виден буквой t в drwxrwxrwt, ставится chmod +t или 1777.

Что хотят услышать: удаление это изменение каталога, права файла при этом не проверяются; sticky bit; пример /tmp.

Красный флаг: «нельзя, потому что файл не мой и права 600».

11. [junior] Где Linux хранит пользователей и пароли, и почему пароли не в /etc/passwd?

Ответ

Учётки лежат в /etc/passwd: имя, UID, GID, домашний каталог, оболочка. Этот файл читают многие программы (например, чтобы превратить UID в имя), поэтому он доступен всем на чтение. Хеши паролей вынесены в /etc/shadow, который читает только root (и группа shadow). Группы описаны в /etc/group. Правлю эти файлы не руками, а через useradd, usermod, passwd. Быстро посмотреть пользователя: id имя, getent passwd имя.

Что хотят услышать: passwd, shadow, group, зачем отдельный shadow, id/getent, не править руками.

Красный флаг: «Пароли лежат в открытом виде в /etc/passwd».

12. [middle] Как сделать общий каталог для команды, чтобы новые файлы в нём получали группу каталога?

Ответ

Создаю группу и кладу в неё пользователей: groupadd team, usermod -aG team имя. Каталог отдаю группе: chown :team /srv/shared (меняет только группу), права chmod 2770 /srv/shared. Двойка в начале - это setgid на каталоге: новые файлы и подкаталоги наследуют группу каталога, а не основную группу создавшего. В ls -l у группы вместо x будет s. Права самих файлов зависят от umask, поэтому при необходимости выставляю umask 002. Пользователям нужно перелогиниться, чтобы группа применилась.

Что хотят услышать: chmod 2770, setgid на каталоге наследует группу, usermod -aG, umask, перелогин.

Красный флаг: «Дам всем 777».

Проверено на версиях

Проверено на стенде (контейнер Docker, образ devops-lab:24.04, без запуска systemd, 30 сентября 2026; в виртуальной машине Multipass и на Windows уроки не прогонялись):

  • Ubuntu 24.04.5 LTS: все команды заданий 1, 2, 3 и 4 и три сценария break.sh (включая повторный fix), выводы в уроке настоящие.
  • coreutils 9.4 (chmod, stat, ls), util-linux 2.39.3 (namei), shadow 4.13 (useradd, usermod), adduser 3.137, sudo 1.9.15p5, iproute2 6.1.0 (ss), curl 8.5.0, Python 3.12.3.
  • Ubuntu 26.04.1 LTS (контейнер без systemd): задания 2, 3 и 4 и сценарии break.sh проверены. Отличаются тексты ошибок (coreutils заменён на uutils 0.8.0, sudo на sudo-rs 0.2.13), права notes.txt (644 вместо 664, маска 022), Python 3.14.4, curl 8.18.0. Задание 1 на 26.04 не гонялось: оно читает те же файлы, отличий не ожидается.
  • Сценарий 2 намеренно не запускается на sudo 1.8 (там одна ошибка отключает sudo целиком).

Итог урока: ты умеешь

  • найти пользователя и его группы (id, getent, /etc/passwd) и объяснить, где лежат хэши паролей
  • читать ls -l и переводить права в числа и обратно
  • предсказать результат chmod и umask и проверить его stat
  • объяснить, зачем нужен x на каталоге, и найти отказ по пути через namei -l
  • создать системного пользователя и каталог данных 750 для сервиса
  • выдать sudo на одну команду через sudoers.d с проверкой visudo -cf
  • починить Permission denied, не доходя до chmod -R 777

Дальше: Урок 1.4: Процессы и сигналы

Проверь себя

Короткий тест по уроку: 5 вопросов из банка в 30. Засчитывается только полностью правильный ответ, порог 60%. Каждая новая попытка даёт другие вопросы, пока банк не закончится. Ответы видны после проверки.

Тест работает с включённым JavaScript.

тема 1 урок 1.3 4 ч курс 0/0 ← → уроки

Помоги улучшить курс

Что нужно изменить?