Файловая система

/proc

/proc

В каталогах процессов находятся следующие файлы.

■

cmdline

■

cwd

chdir()

■

environ

■

exe

■

fd

■

maps

■

root

/

chroot

chroot()

■

stat

status

■

statm

■

status

■

cpu

Из соображений безопасности права доступа к некоторым файлам предоставляются только владельцу процесса и суперпользователю.

7.2.1. Файл /proc/self

В файловой системе

/proc

/proc/self

Например, программа, представленная в листинге 7.2, с помощью файла

/proc/self

getpid()

readlink()

/proc/self

#include 

#include 

#include 

/* Определение идентификатора вызывающего процесса

  на основании символической ссылки /proc/self. */

pid_t get_pid_from_proc_self() {

 char target[32];

 int pid;

 /* Чтение содержимого символической ссылки. */

 readlink("/proc/self", target, sizeof(target));

 /* Адресатом ссылки является каталог, имя которого соответствует

   идентификатору процесса. */

 sscanf(target, "%d", &pid);

 return (pid_t)pid;

}

int main() {

 printf("/proc/self reports process id %d\n",

  (int)get_pid_from_proc_self());

 printf("getpid() reports process id %d\n", (int)getpid());

 return 0;

}

7.2.2. Список аргументов процесса

Файл

cmdline

cmdline

В листинге 2.1 приводилась программа, которая отображала переданный ей список аргументов. Теперь, когда мы узнали назначение файлов

cmdline

/proc

cmdline

strlen()

read()

#include 

#include 

#include 

#include 

#include 

#include 

/* Вывод списка аргументов (по одному в строке) процесса

  с заданным идентификатором. */

void print_process_arg_list(pid_t pid) {

 int fd;

 char filename[24];

 char arg_list[1024];

 size_t length;

 char* next_arg;

 /* Определение полного имени файла cmdline

   для заданного процесса. */

 snprintf(filename, sizeof(filename), "/proc/%d/cmdline",

  (int)pid);

 /* Чтение содержимого файла. */

 fd = open(filename, O_RDONLY);

 length = read(fd, arg_list, sizeof(arg_list));

 close(fd);

 /* Функция read() не помещает в конец текста нулевой символ,

   поэтому его приходится добавлять отдельно. */

 arg_list[length] = '\0';

 /* Перебор аргументов. Аргументы отделяются друг от друга

   нулевыми символами. */

 next_arg = arg_list;

 while (next_arg < arg_list + length) {

  /* Вывод аргументов. Каждый из них оканчивается нулевым

   символом и потому интерпретируется как обычная строка. */

  printf("%s\n", next_arg);

  /* Переход к следующем аргументу. Поскольку каждый аргумент

   заканчивается нулевым символом, функция strlen() вычисляет

   длину отдельного аргумента, а не всего списка. */

 next_arg += strlen(next_arg) + 1;

 }

}

int main(int argc, char* argv[]) {

 pid_t pid = (pid_t)atoi(argv[1]);

 print_process_arg_list(pid);

 return 0;

}

Предположим, к примеру, что номер процесса системного демона

syslogd

% ps 372

 PID TTY STAT TIME COMMAND

 372 ?  S   0:00 syslogd -m 0

% ./print-arg-list 372

syslogd

-m

0

В данном случае программа

print-arg-list

syslogd

-m 0

7.2.3. Переменные среды процесса

Файл

environ

cmdline

ПЕРЕМЕННАЯ=значение

Представленная в листинге 7.4 программа является обобщением программы, которая была показана в листинге 2.3. В данном случае программа принимает в командной строке идентификатор процесса и отображает список его переменных среды, извлекаемый из файловой системы

/proc

#include 

#include 

#include 

#include 

#include 

#include 

/* Вывод переменных среды (по одной в строке) процесса

  с заданным идентификатором. */

void print_process_environment(pid_t pid) {

 int fd;

 char filename[24];

 char environment[8192];

 size_t length;

 char* next_var;

 /* Определение полного имени файла environ

  для заданного процесса. */

 snprintf(filename, sizeof(filename), "/proc/%d/environ",

  (int)pid);

 /* Чтение содержимого файла. */

 fd = open(filename, O_RDONLY);

 length = read(fd, environment, sizeof (environment));

 close(fd);

 /* Функция read() не помещает в конец текста нулевой символ,

   поэтому его приходится добавлять отдельно. */

 environment[length] = ' \0';

 /* Перебор переменных. Элементы списка отделяются друг от друга

   нулевыми символами. */

 next_var = environment;

 while (next_var < environment + length) {

  /* Вывод элементов списка. Каждый из них оканчивается нулевым

   символом и потому интерпретируется как обычная строка. */

  printf("%s\n", next_var);

  /* Переход к следующей переменной. Поскольку каждый элемент

   списка заканчивается нулевым символом, функция strlen()

   вычисляет длину отдельного элемента, а не всего списка. */

  next_var += strlen(next_var) + 1;

 }

}

int main(int argc, char* argv[]) {

 pid_t pid = (pid_t)atoi(argv[1]);

 print_process_environment(pid);

 return 0;

}

7.2.4. Исполняемый файл процесса

Файл

exe

exe

/proc

Во многих программах путь ко вспомогательным файлам задан относительно исполняемого файла, поэтому важно знать, где именно он находится. Функция

get_executable_path()

/proc/self/exe

#include 

#include 

#include 

#include 

/* Нахождение путевого имени текущего исполняемого файла.

  путевое имя помещается в строку BUFFER, длина которой

  равна LEN. Возвращается число символов в имени либо

  -1 в случае ошибки. */

size_t get_executable_path(char* buffer, size_t len) {

 char* path_end;

 /* чтение содержимого символической ссылки /proc/self/exe. */

 if (readlink("/proc/self/exe", buffer, len) <= 0)

  return -1;

 /* Нахождение последней косой черты, отделяющей путевое имя. */

 path_end = strrchr(buffer, '/');

 if (path_end == NULL)

 return -1;

 /* Переход к символу, стоящему за последней косой чертой. */

 ++path_end;

 /* Усечение полной строки до путевого имени. */

 *path_end = '\0';

 /* Длина путевого имени — это число символов до последней

   косой черты. */

 return (size_t)(path_end - buffer);

}

int main() {

 char path[PATH_MAX];

 get_executable_path(path, sizeof (path));

 printf("this program is in the directory %e\n", path);

 return 0;

}

7.2.5. Дескрипторы файлов процесса

Элемент

fd

/proc

Рассмотрим небольшой трюк. Откройте новое терминальное окно и найдите с помощью команды

ps

% ps

 PID TTY    TIME CMD

1261 pts/4 00:00:00 bash

2455 pts/4 00:00:00 ps

В данном случае процесс идентификатора команд (

bash

fd

% ls -l /proc/1261/fd total 0

lrwx------ 1 samuel samuel 64 Jan 30 01:02 0 -> /dev/pts/4

lrwx------ 1 samuel samuel 64 Jan 30 01:02 1 -> /dev/pts/4

lrwx------ 1 samuel samuel 64 Jan 30 01:02 2 -> /dev/pts/4

(В выводе могут присутствовать дополнительные строки, соответствующие другим открытым файлам.) Вспомните в разделе 2.1.4, "Стандартный ввод-вывод", рассказывалось о том. что дескрипторы 0, 1 и 2 закрепляются за стандартными потоками ввода, вывода и ошибок соответственно. Таким образом, при записи в файл

/proc/1261/fd/1

stdout

% echo "Hello, world." >> /proc/1261/fd/1

Сообщение "Hello, world." появится в первом окне.

В подкаталоге

fd

#include 

#include 

#include 

#include 

#include 

int main(int argc, char* argv[]) {

 const char* const filename = argv[1];

 int fd = open(filename, O_RDONLY);

 printf("in process %d, file descriptor %d is open to %s\n",

  (int)getpid(), (int)fd, filename);

 while (1);

 return 0;

}

Запустите программу в терминальном окне:

% ./open-and-spin /etc/fstab

in process 2570, file descriptor 3 is open to /etc/fstab

Теперь откройте другое окно и проверьте подкаталог

fd

% ls -l /proc/2570/fd

total 0

lrwx------ 1 samuel samuel 64 Jan 30 01:30 0 -> /dev/pts/2

lrwx------ 1 samuel samuel 64 Jan 30 01:30 1 -> /dev/pts/2

lrwx------ 1 samuel samuel 64 Jan 30 01:30 2 -> /dev/pts/2

lr-x------ 1 samuel samuel 64 Jan 30 01:30 3 -> /etc/fstab

Как видите, появилась, ссылка 3, которая соответствует дескриптору файла

/etc/fstab

Программа может открывать дескрипторы не только файлов, но также сокетов и каналов. В таких случаях адресатом символической ссылки будет строка "socket" или "pipe", а не имя файла либо устройства.

7.2.6. Статистика использования процессом памяти

Файл

statm

■ общий размер процесса;

■ размер резидентной части процесса;

■ память, совместно используемая с другими процессами (например, загруженные библиотеки или нетронутые страницы, созданные в режиме "копирование при записи");

■ текстовый размер процесса, т.е. размер сегмента кода исполняемого файла;

■ размер совместно используемых библиотек, загруженных процессом;

■ память, выделенная под стек процесса;

■ число недействительных страниц, т.е. страниц памяти, которые были модифицированы программой.

7.2.7. Статистика процесса

Файл

status

В файловой системе

/proc

7.3.1. Центральный процессор

Как уже говорилось, файл

/proc/cpuinfo

Большая часть информации, содержащейся в файле

/proc/cpuinfo

cpuid

http://developer.intel.com/design

Последний элемент файла,

bogomips

7.3.2. Аппаратные устройства

В файле

/proc/devices

7.3.3. Шина PCI

В файле

/proc/pci

7.3.4. Последовательные порты

Файл

/proc/tty/driver/serial

setserial

/proc/tty/driver/serial

Например, следующая строка описывает последовательный порт 1 (COM2 в Windows):

1: uart:16550А port:2F8 irq:3 baud:9600 tx:11 rx:0

Здесь говорится о том, что последовательный порт оснащен микросхемой UART 16550А, использует порт ввода-вывода 0x218 и прерывание 3 и работает со скоростью 9600 бод. Через этот порт было передано 11 запросов на прерывание и получено 0 таких запросов.

В файловой системе

/proc

/proс/sys/kernel

7.4.1. Версия ядра

В файле

/proc/version

% cat /proc/version

Linux version 2.2.14-5.0 (root@porky.devel.redhat.com)

(gcc version egcs-2.91.66 19990314/Linux (egcs-1.1.2 release))

#1 Tue Mar 7 21:07:39 EST 2000

Здесь сказано, что в системе используется ядро Linux версии 2.2.14, которое было скомпилировано программой EGCS версии 1.1.2 (эта программа является предшественницей широко распространенного в настоящее время пакета GCC).

Для наиболее важных параметров, а именно названия операционной системы и номера версии/модификации ядра, созданы отдельные записи в файловой системе

/proc

/proc/sys/kernel/ostype

/proc/sys/kernel/osrelease

/proc/sys/kernel/version

% cat /proc/sys/kernel/ostype Linux

% cat /proc/sys/kernel/osrelease 2.2.14-5.0

% cat /proc/sys/kernel/version #1 Tue Mar 7 21:07:39 EST 2000

7.4.2. Имя компьютера и домена

В файлах

/proc/sys/kernel/hostname

/proc/sys/kernel/domainname

uname()

7.4.3. Использование памяти

Файл

/proc/meminfo

% cat /proc/meminfo

     total:   used:   free: shared:  buffers: cached:

Mem:  529694720 519610368 10084352 82612224 10977280 82108416

Swap: 271392766 44003328  227389440

MemTotal:  517280 kB

MemFree:   9848 kB

MemShared:  80676 kB

Buffers:   10720 kB

Cached:   80184 kB

BigTotal:    0 kB

BigFree:     0 kB

SwapTotal: 265032 kB

SwapFree:  222060 kB

Как видите, в системе имеется 512 Мбайт ОЗУ, из которых 9 Мбайт свободно. Для области подкачки выделено 258 Мбайт, из которых свободно 216 Мбайт. В строке, соответствующей физической памяти, показаны три других значения.

■ В колонке "shared" отображается общий объем совместно используемой памяти, выделенной в системе.

■ В колонке "buffers" отображается объем памяти, выделенной для буферов блочных устройств. Эти буферы используются драйверами устройств для временного хранения считываемых и записываемых блоков данных.

■ В колонке "cached" отображается объем памяти, выделенной для страничного кэш-буфера. В этом буфере сохраняются страницы файлов, отображаемых в памяти.

Ту же самую информацию можно получить с помощью команды

free

В файловой системе

/proc

7.5.1. Файловые системы

Файл

/proc/filesystems

/proc/filesystems

7.5.2. Диски и разделы

В файловой системе

/proc

/proc/ide

ide0

ide1

Таблица 7.1. Каталоги, соответствующие четырем возможным IDE-устройствам

/рroc/ide/ide0/hda/

/proc/ide/ide0/hdb/

/proc/ide/ide1/hdc/

/proc/ide/ide1/hdd/

В каталоге каждого IDE-устройства есть несколько файлов, хранящих конфигурационные данные устройства. Перечислим наиболее важные из них.

■

model

■

media

disk

cdrom

tape

floppy

UNKNOWN

■

capacity

Ниже показано, как определить тип носителя и идентификатор главного устройства, подключенного к дополнительному IDE-контроллеру:

% cat /proc/ide/ide1/hdc/media

cdrom

% cat /proc/ide/ide1/hdc/model

TOSHIBA CD-ROM XM-6702B

В данном случае это дисковод CDROM компании Toshiba.

Если в системе есть SCSI-устройства, в файле

/proc/scsi/scsi

% cat /proc/scsi/scsi

Attached devices:

Host: scsi0 Channel: 00 Id: 00 Lun: 00

 Vendor: QUANTUM Model: ATLAS_V__9_WLS Rev: 0230

 Type:  Direct-Access ANSI SCSI revision: 03

Host: scsi0 Channel: 00 Id: 04 Lun: 00

 Vendor: QUANTUM Model: QM39100TD-SW Rev: N491

 Type:  Direct-Access ANSI SCSI revision: 02

В системе присутствует один одноканальный SCSI-контроллер (обозначен как

scsi0

В файле

/proc/partitions

Файл

/proc/sys/dev/cdrom/info

% cat /proc/sys/dev/cdrom/info

CD-ROM information, Id: cdrom.с 2.56 1999/09/09

drive name: hdc

drive speed: 48

drive # of slots: 0

Can close tray: 1

Can open tray: 1

Can lock tray: 1

Can change speed: 1

Can select disk: 0

Can read multisession: 1

Can read MCN: 1

Reports media changed: 1

Can play audio: 1

7.5.3. Точки монтирования

В файле

/proc/mounts

/etc/mtab

mount

Ниже перечислены элементы дескриптора монтирования.

■ Первый элемент строки — это имя смонтированного устройства. Для специальных файловых систем, например

/proc

none

■ Второй элемент — это имя точки монтирования, т.е. места в корневой файловой системе, где появится содержимое монтируемой файловой системы. Для самой корневой системы точка монтирования обозначается символом

/

swap

■ Третий элемент — это тип файловой системы. В настоящее время на жестких дисках Linux в основном устанавливаются файловые системы типа

ext2

fat

vfat

iso9660

man

mount

■ Четвертый элемент — это флаги монтирования. Они указываются при добавлении точки монтирования. Пояснение этих флагов также дано на

man

mount

В файле

/proc/mounts

Подробнее о формате дескрипторов монтирования можно узнать на

man

fstab

man

getmntent()

7.5.4. Блокировки

В файле

/proc/locks

Для блокировок, созданных функцией

fcntl()

POSIX

ADVISORY

WRITE

READ

Чтобы понять, как работает файл

/proc/locks

/tmp/test-file

% touch /trap/test-file

% ./lock-file /tmp/test-file

file /tmp/test-file

opening /tmp/test-file

locking

locked; hit enter to unlock...

В другом окне просмотрите содержимое файла

/proc/ locks

% cat /proc/locks

ls POSIX ADVISORY WRITE 5467 08:05:181288 0 2147483647 d1b5f740

00000000 dfea7d40 00000000 00000000

В файле могут присутствовать дополнительные строки, если какие-то программы устанавливали свои блокировки. В данном случае идентификатор процесса программы

lock-file

% ps 5467

 PID TTY   STAT TIME COMMAND

5467 pts/28 S   0:00 ./lock-file /tmp/test-file

Заблокированный файл

/tmp/test-file

/dev/sda5

% df /trap

Filesystem 1k-blocks   Used Available Use% Mounted on

/dev/sda5   8459764 5094292  2935736  63% /

% ls -l /dev/sda5

brw-rw---- 1 root disk 8, 5 May 5 1998 /dev/sda5

На этом устройстве с файлом

/tmp/test-file

% ls --inode /trap/test-file

181288 /tmp/test-file

Вот как с помощью функции

asm()

asm("shrl $8, %0" : "=r" (answer) : "r" (operand) : "cc");

Выражение в скобках состоит из секций, разделенных двоеточиями. В первой секции указана ассемблерная инструкция и ее операнды. Команда

shrl

%0

$8

Во второй секции задаются выходные операнды. Единственный такой операнд будет помещен в C-переменную

answer

"=r"

r

answer

В третьей секции перечислены входные операнды. Переменная

operand

"r"

Выражение

"cc"

cc

9.2.1. Преобразование функции asm() в ассемблерные инструкции

Компилятор

gcc

asm()

Например, следующий фрагмент программы:

double foo, bar;

asm("mycool_asm %1, %0" : "=r" (bar) : "r" (foo));

будет преобразован в такую последовательность команд x86:

 movl -8(%ebp),%edx

 movl -4(%ebp),%ecx

#APP

 mycool_asm %edx, %edx

#NO_APP

 movl %edx,-16(%ebp)

 movl %ecx,-12(%ebp)

Переменные

foo

bar

ebp

Первые две команды копируют переменную foo в регистры

edx

ecx

mycool_asm

bar

В следующих подразделах будет описан синтаксис правил, по которым строятся выражения в функции

asm()

x > y

asm("fucomip %%st(1), %%st; seta %%al" :

 "=a" (result) : "u" (y), "t" (x) : "cc", "st");

Сначала инструкция

fucomip

x

y

cc

seta

9.3.1. Ассемблерные инструкции

Первая секция содержит ассемблерные инструкции, заключенные в кавычки. В рассматриваемом примере таких инструкций две:

fucomip

seta

\n

Компилятор игнорирует содержимое первого раздела, разве что один уровень символов процента удаляется, т.е. вместо

%%

%%st(1)

Если при компиляции программы, содержащей функцию

asm()

-traditional

-ansi

gcc

__asm__

9.3.2. Выходные операнды

Во второй секции указаны выходные операнды инструкции. Каждому операнду соответствует строка адресации и выражение языка С, записанное в скобках. В случае выходных операндов (все они должны быть левосторонними значениями) строка адресации должна начинаться со знака равенства. Компилятор проверяет, действительно ли каждый выходной операнд является левосторонним значением (т.е может стоять в левой части оператора присваивания).

Список обозначений регистров для конкретной архитектуры можно найти в исходных текстах компилятора

gcc

REG_CLASS_FROM_LETTER

gcc/config/i386/i386.h

Таблица 9.1. Обозначения регистров в архитектуре Intel x86

gcc

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

%0

%1

%9

/* нет выходных данных */

9.3.3. Входные операнды

В третьей секции задаются входные операнды. Строка адресации такого операнда не должна содержать знака равенства, в остальном синтаксис совпадает с синтаксисом выходных операндов.

Если требуется указать, что в одной инструкции осуществляется как чтение регистра, так и запись в него, необходимо в строке адресации входного операнда поставить номер выходного операнда. Например, если входной регистр должен быть тем же, что и регистр первого выходного операнда, назначьте ему номер 0. Выходные операнды нумеруются слева направо, начиная с нуля. Если просто указать одинаковое C-выражение для входного и выходного операндов, то это еще не означает, что оба значения будут помещены в один и тот же регистр.

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

9.3.4. Модифицируемые регистры

Если в качестве побочного эффекта инструкция модифицирует значение одного или нескольких регистров, в функции

asm()

fucomip

memory

asm()

В Linux каждому пользователю назначается уникальный номер, называемый его идентификатором (UID, user identifier). При регистрации в системе, естественно, вводится имя пользователя, а не идентификатор. Система преобразовывает введенное имя в соответствующий идентификатор и дальше работает только с ним.

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

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

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

Но выход все же есть — это создание группы. Ей также назначается уникальный номер, называемый идентификатором группы (GID, group identifier). В каждую группу входит один или несколько идентификаторов пользователей. Один и тот же пользователь может быть членом множества групп, но членами групп не могут быть другие группы. У групп, как и у пользователей, есть имена, но они не играют практически никакой роли, так как система работает с идентификаторами групп.

Например, можно создать группу managers и включить в нее идентификаторы всех менеджеров компании. Тогда любой файл, принадлежащий этой группе, будет доступен только менеджерам и никому другому. Всякому системному ресурсу соответствует только одна группа.

Команда

id

% id

uid=501(mitchell) gid=501(mitchell) groups=501(mitchell), 503(csl)

В первой части выходных данных указано, что идентификатор пользователя равен 501. В скобках приведено соответствующее этому идентификатору имя пользователя. Как следует из результатов работы команды, пользователь

mitchell

mitchell

csl

gid

groups

10.1.1. Суперпользователь

Одна учетная запись имеет для системы особое значение.[31] Пользователь, чей идентификатор равен 0, обычно носит имя

root

К сожалению, этих специальных операций так много, что очень большое число программ должно принадлежать пользователю

root

root

Хороший способ разобраться в назначении идентификаторов пользователей и групп — изучить права доступа к файловой системе. В частности, нужно узнать, как система устанавливает права доступа к файлам и как ядро определяет, кому разрешено обращаться к запрашиваемым файлам.

У каждого файла есть лишь один пользователь-владелец и одна группа-владелец. При создании файла за ним закрепляются идентификаторы пользователя и группы того процесса, в котором происходит эта операция.

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

Linux позволяет задавать, какие действия — чтение, запись, выполнение — разрешено осуществлять над файлом его владельцу, группе и остальным пользователям. Например, можно указать, что владелец имеет все права доступа к файлу, пользователям группы разрешено читать и выполнять файл (но не записывать в него), а остальные пользователи не должны получать к нему доступ.

Совокупность прав доступа к файлу называется кодом режима. Он состоит из трех триад битов, соответствующих владельцу, группе и остальным пользователям. В каждой триаде первый бит означает право чтения, второй — право записи, третий — право выполнения. Символьное представление этих битов называется строкой режима. Просмотреть ее можно с помощью команды

ls -l

stat()

chmod

hello

% ls -l hello

-rwxr-x--- 1 samuel csl 11734 Jan 22 16:29 hello

Третье и четвертое поля выводных данных сообщают о том, что файл принадлежит пользователю

samuel

csl

samuel

Давайте проверим, действительно ли все вышесказанное — правда. Для начала попробуем обратиться к файлу от имени пользователя

nobody

csl

% id

uid=99(nobody) gid=99(nobody) groups=99(nobody)

% cat hello

cat: hello: Permission denied

% echo hi > hello

sh: ./hello: Permission denied

% ./hello

sh: ./hello: Permission denied

Команда

cat

echo

hello

Посмотрим, что будет, если к файлу обратится пользователь

mitchell

csl

% id

uid=501 (mitchell) gid=501 {mitchell) groups=501 (mitchell), 503 (csl)

% cat hello

#!/bin/bash

echo "Hello, world."

% ./hello

Hello, world.

% echo hi > hello

bash: ./hello: Permission denied

В данном случае можно отобразить содержимое файла и запустить его на выполнение (файл является простейшим командным сценарием), но осуществить перезапись файла невозможно. Доступ для записи разрешен только владельцу файла (пользователь

samuel

% id

uid=502(samuel) gid=502(samuel) groups=502(samuel),503(csl)

% echo hi > hello

% cat hello

hi

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

% chmod o+k hello

% ls -l hello

-rwxr-x--x 1 samuel csl 3 Jan 22 16:38 hello

Обратите внимание на появление буквы

x

о+x

chmod

+

x

о

g-w.

Функция

stat()

stat()

#include 

#include 

int main(int argc, char* argv[]) {

 const char* const filename = argv[1];

 struct stat buf;

 /* Получение информации о файле. */

 stat(filename, &buf);

 /* Если владельцу разрешена запись в файл,

   отображаем сообщение. */

 if (buf.st_mode & S_IWUSR)

  printf("Owning user can write '%s'.\n", filename);

 return 0;

}

Если запустить программу с файлом

hello

% ./stat-perm hello

Owning user can write 'hello'.

Константа

S_IWUSR

S_IRGRP

S_IXOTH

stat()

errno

С помощью функции

chmod()

hello

chmod("hello", S_IRUSR | S_IXUSR);

Те же самые права доступа действуют и в отношении каталогов, но имеют несколько иной смысл. Если у пользователя есть право чтения каталога, то это означает разрешение на получение списка содержимого каталога. Право записи означает возможность добавлять и удалять файлы в каталоге. Пользователь, которому разрешена запись в каталог, может удалять из него файлы даже в том случае, когда у него нет права доступа к этим файлам. Право выполнения применительно к каталогам называется правом поиска. Пользователю. имеющему это право, разрешается входить в каталог и обращаться к его файлам. Если пользователь не может перейти в каталог, то ему не удастся получить доступ к находящимся в нем файлам независимо от их собственных прав доступа.

Подводя итог, рассмотрим, как ядро определяет, имеет ли процесс право обратиться к заданному файлу. Сначала выясняется, кем является пользователь, запустивший процесс: владельцем файла, членом его группы или кем-то другим. В зависимости от категории пользователя проверяется соответствующий набор битов чтения/записи/выполнения и на его основании принимается окончательное решение.[32]

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

10.3.1. Проблема безопасности: программы без права выполнения

Есть один хороший пример того, как обмануть неопытного пользователя, пытающегося защитить свои программы от несанкционированного запуска. Сброс бита выполнения файла еще не означает, что файл нельзя будет запустить. Дело в том, что при копировании файла копия переходит в распоряжение нового владельца. Как вы понимаете, ему не составляет никакого труда изменить права доступа к скопированному файлу и снова сделать его исполняемым. Вывод: защищайте программы не от несанкционированного запуска, а от несанкционированного копирования!

10.3.2. Sticky-бит

Помимо обычных битов режима есть один особый бит, называемый sticky-битом ("липучкой").[33] Он применим только в отношении каталогов.

Обычно удалять файлы могут пользователи, имеющие право записи в каталог. Каталог, для которого установлен sticky-бит, допускает удаление файла только в том случае, когда пользователь является владельцем этого файла или самого каталога и имеет право записи в каталог.

В типичной Linux-системе есть несколько таких каталогов. Один из них — каталог

/tmp

/tmp

О наличии sticky-бита говорит буква

t

% ls -ld /trap

drwxrwxrwt 12 root root 2048 Jan 24 17:51 /tmp

Соответствующий флаг функций

stat()

chmod()

S_ISVTX

Если требуется установить для каталога sticky-бит. следует воспользоваться такой командой:

% chmod o+t каталог

А вот как можно назначить каталогу те же права доступа, что и к каталогу

/tmp

chmod(dir_path, S_IRWXU | S_IRWXG | S_IRWXO | S_ISVTX);

До сих пор подразумевалось, что у процесса — один идентификатор пользователя и один идентификатор группы. На самом деле не все так просто. У каждого процесса есть два пользовательских идентификатора: реальный и эффективный. То же самое справедливо и в отношении идентификаторов групп. В большинстве случаев ядро работает с эффективным идентификатором. Например, если процесс пытается открыть файл, ядро проверяет допустимость этой операции именно на основании эффективного идентификатора.

Упомянутые выше функции

geteuid()

getegid()

getuid()

getgid()

Раз ядро работает только с эффективным идентификатором, какой смысл в существовании еще и реального идентификатора? Есть один специальный случай, когда он необходим: ядро проверяет его при попытке изменения эффективного идентификатора выполняющегося процесса.

Прежде чем выяснять, как менять эффективный идентификатор процесса, рассмотрим, зачем это необходимо. Предположим, имеется серверный процесс, который может просматривать любой файл независимо от того, кто является его владельцем. Такой процесс должен быть запущен пользователем

root

mitchell

Гораздо лучший подход — временно поменять эффективный идентификатор пользователя root на

mitchell

mitchell

Механизм временной замены идентификаторов используется программами, которые выполняют аутентификацию пользователей, пытающихся зарегистрироваться в системе. Такие программы работают с правами пользователя

root

exec()

Функция, меняющая пользовательский идентификатор процесса, называется

setreuid()

setregid()

setreuid(geteuid(), getuid());

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

■ заменять эффективный идентификатор реальным;

■ заменять реальный идентификатор эффективным;

■ переставлять местами значения реального и эффективного идентификаторов.

Первый вариант будет использован серверным процессом, когда он закончит работать от имени пользователя

mitchell

root

root

В качестве любого из аргументов функции

setreuid()

seteuid()

seteuid(id);

setreuid(-1, id);

10.4.1. Программы с установленным битом SUID

Выше было показано, как процесс пользователя

root

% whoami

mitchell

% su

Password: ...

% whoami

root

Команда

whoami

id

su

Как же работает команда

su

mitchell

setreuid()

Дело в том, что у программы

su

chmod +s

S_SUID

chmod()

В качестве примера рассмотрим программу, показанную в листинге 10.3.

#include 

#include 

int main() {

 printf("uid=%d euid=%d\n", (int)getuid(), (int)geteuid());

 return 0;

}

Теперь предположим, что у программы установлен бит SUID и она принадлежит пользователю

root

ls

-rwsrws--x 1 root root 11931 Jan 24 18:25 setuid-test

Буквы s в строке режима означают, что этот файл не только является исполняемым, но для него установлены также биты SUID и SGID. Результат работы программы будет таким:

% whoami

mitchell

% ./setuid-test

uid=501 euid=0

Обратите внимание на то, что эффективный идентификатор стал равным нулю. Устанавливать биты SUID и SGID позволяют команда

chmod u+s

chmod g+s

% ls -l program

-rwxr-xr-x 1 samuel csl 0 Jan 30 23:38 program

% chmod g+s program

% ls -l program

-rwxr-sr-x 1 samuel csl 0 Jan 30 23:38 program

% chmod u+s program

% ls -l program

-rwsr-sr-x 1 samuel csl 0 Jan 30 23:38 program

Аналогичным целям служат флаги

S_ISUID

S_ISGID

chmod()

Именно так работает команда

su

Рассмотрим атрибуты программы

su

% ls -l /bin/su

-rwsr-xr-x 1 root root 14188 Mar 7 2000 /bin/su

Как видите, она принадлежит пользователю

root

su

exit

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

10.6.1. Переполнение буфера

Почти псе основные Internet-демоны, включая демоны таких программ, как

sendmail

finger

talk

Суть атаки заключается в том, чтобы заставить программу выполнить код, который она не собиралась выполнять. Типичный механизм достижения этой цели — перезапись части стека программы. В стеке, помимо всего прочего, сохраняется адрес памяти, по которому программа передает управление после завершения текущей функции. Следовательно, если поместить код взлома в памяти, а затем изменить адрес возврата так. чтобы он указывал на этот код, то по завершении текущей функции программа начнет выполнять код хакера с правами текущего процесса. Если процесс принадлежит пользователю

root

Хуже всего обстоит дело с программами, которые работают в режиме демона и ожидают поступление запросов на подключение. Демоны обычно принадлежат пользователю

root

Старым версиям программ

finger

talk

sendmail

#include 

int main() {

 /* Никто, будучи в здравом уме, не выбирает имя пользователя

   длиной более 32 символов. Кроме того, я думаю, что в UNIX

   допускаются только 8-символьные имена. Поэтому выделенного

   буфера должно быть достаточно. */

 char username[32];

 /* Предлагаем пользователю ввести свое имя. */

 printf("Enter your username: ");

 /* Читаем введенную строку. */

 gets(username);

 /* Выполняем другие действия... */

return 0;

}

Комбинация 32-символьного буфера и функции

gets()

gets()

username

username

К счастью, предотвратить переполнение буфера относительно несложно. При чтении строк следует всегда пользоваться функцией наподобие

getline()

char* username = getline(NULL, 0, stdin);

Функция

getline()

malloc()

free()

Ситуация еще проще, если используется язык C++, где есть готовые строковые примитивы. В C++ ввод строки осуществляется так:

string username;

getline(cin, username);

Буфер строки

username

free()

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

10.6.2. Конкуренция доступа к каталогу /tmp

Другая распространенная проблема безопасности связана с созданием файлов с предсказуемыми именами, в основном в каталоге

/tmp

prog

root

/tmp/prog

/tmp/prog

open()

В такой ситуации говорят о конкуренции. Она неявно существует между автором программы и хакером. Кто первым успеет создать временный файл, тот и победит.

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

/etc/passwd

Один из способов избежать такой атаки — создавать временные файлы со случайными именами. Например, можно прочитать из устройства

/dev/random

Другой подход заключается в вызове функции

open()

O_EXCL

O_EXCL

В разделе 2.1.7, "Временные файлы", рассказывалось о применении функции

mkstemp()

O_EXCL

/tmp

Прием, который всегда работает, заключается в вызове функции

lstat()

В листинге 10.5 представлена функция, которая пытается безопасно открыть файл в каталоге

/tmp

#include 

#include 

#include 

#include 

/* Функция возвращает дескриптор созданного временного файла.

  Файл будет доступен для чтения и записи только тому

  пользователю, чей идентификатор равен эффективному

  идентификатору текущего процесса. Если файл не удалось создать,

  возвращается -1. */

int secure_temp_file() {

 /* Этот дескриптор ссылается на устройство /dev/random, из

   которого будут получены случайные данные. */

 static int random_fd = -1;

 /* Случайное целое число. */

 unsigned int random;

 /* Буфер для преобразования числа в строку. */

 char filename[128];

 /* дескриптор создаваемого временного файла. */

 int fd;

 /* информация о созданном файле. */

 struct stat stat_buf;

 /* Если устройство /dev/random еще не было открыто,

   открываем его. */

 if (random_fd == -1) {

  /* Открытие устройства /dev/random. Предполагается, что

   это устройство является источником случайных данных,

   а не файлом, созданным хакером. */

  random_fd = open("/dev/random", O_RDONLY);

  /* Если устройство /dev/random не удалось открыть,

   завершаем работу. */

  if (random_fd == -1)

  return -1;

 }

 /* чтение целого числа из устройства /dev/random. */

 if (read(random_fd, &random, sizeof(random)) != sizeof(random))

  return -1;

 /* Формирование имени файла из случайного числа. */

 sprintf(filename, "/tmp/%u", random);

 /* Попытка открытия файла. */

 fd = open(filename,

  /* Используем флаг O_EXCL. */

  O_RDWR | O_CREAT | O_EXCL,

  /* Разрешаем доступ только владельцу файла. "/

  S_IRUSR | S_IWUSR);

 if (fd == -1)

  return -1;

 /* Вызываем функцию lstat(), чтобы проверить, не является ли

   файл символической ссылкой */

 if (lstat(filename, &stat_buf) == -1)

  return -1;

 /* Если файл не является обычным файлом, кто-то пытается

   обмануть нас. */

 if (!S_ISREG(stat_buf.st_mode))

  return -1;

 /* Если файл нам не принадлежит, то, возможно, кто-то успел

   подменить его. */

 if (stat_buf.st_uid != geteuid() ||

  stat_buf.st_gid != getegid())

  return -1;

 /* Если у файла установлены дополнительные биты доступа,

   что-то не так. */

 if ((stat_buf.st_mode & ~(S_IRUSR | S_IWUSR)) != 0)

  return -1;

 return fd;

}

Рассмотренная функция вызывает функцию

open()

lstat()

open()

lstat()

В данной ситуации на помощь приходит sticky-бит. Поскольку для каталога

/tmp

root

Грамотный системный администратор не допустит, чтобы каталог

/tmp

mkstemp()

O_EXCL

10.6.3. Функции system() и popen()

Третья распространенная проблема безопасности, о которой должен помнить каждый программист, заключается в несанкционированном запуске программ через интерпретатор команд. В качестве наглядной демонстрации рассмотрим сервер словарей. Серверная программа ожидает поступления запросов через Internet. Клиент посылает слово, а сервер сообщает, является ли оно корректным словом английского языка. В любой Linux-системе имеется файл

/usr/dict/words

% grep -х слово /usr/dict/words

Код завершения команды

grep

/usr/dict/words

В листинге 10.6 показан пример реализации поискового модуля сервера.

#include 

#include 

/* Функция возвращает ненулевое значение, если аргумент WORD

  встречается в файле /usr/dict/words. */

int grep_for_word(const char* word) {

 size_t length;

 char* buffer;

 int exit_code;

 /* Формирование строки 'grep -x WORD /usr/dict/words'.

   Строка выделяется динамически во избежание

   переполнения буфера. */

 length =

  strlen("grep -х ") + strlen(word) +

 strlen(" /usr/dict/words") + 1;

 buffer = (char*)malloc(length);

 sprintf(buffer, "grep -x %s /usr/dict/words", word);

 /* Запуск команды. */

 exit_code = system(buffer);

 /* Очистка буфера. */

 free(buffer);

 /* Если команда grep вернула значение 0, значит, слово найдено

   в словаре. */

 return exit_code == 0;

}

Обратите внимание на подсчет числа символов в строке и динамическое выделение буфера, что позволяет обезопасить программу от переполнения буфера. К сожалению, небезопасна сама функция

system()

foo /dev/null; rm -rf /

В этом случае сервер выполнит такую команду:

grep -х foo /dev/null; rm -rf / /usr/dict/words

Теперь проблема стала очевидной. Пользователь запустил одну команду, якобы grep, а на самом деле их оказалось две, так как интерпретатор считает точку с запятой разделителем команд. Первая команда — это по-прежнему безобидный вызов утилиты

grep

popen()

popen()

pclose()

Существуют два способа устранения подобных проблем. Первый заключается в использовании функции семейства

exec()

system()

popen()

exec()

system()

popen()

Второй способ — проверка строки на предмет "благонадежности". В случае сервера словарей следует убедиться в том, что слово содержит только буквы (для этого предназначена функция

isalpha()

Демонстрационная программа является частью пакета мониторинга Linux-системы и предоставляет следующие возможности.

■ Программа реализует минимально необходимые функции Web-сервера. Локальные и удаленные клиенты получают доступ к системной информации, запрашивая Web-страницы у сервера по протоколу HTTP.

■ Программа не работает со статическими HTML-страницами. Все страницы динамически генерируются модулями, каждый из которых вычисляет итоговую информацию о какой-либо характеристике системы.

■ Все модули подключаются к серверу динамически, загружаясь из совместно используемых библиотек. Их можно добавлять, удалять и заменять по ходу работы сервера.

■ Для каждого запроса на подключение сервер создает дочерний процесс. Это позволяет серверу продолжать реагировать на запросы, а также защищает его от ошибок в модулях.

■ Серверу не требуются привилегии суперпользователя (он не работает с привилегированным портом). Это ограничивает его в доступе к системной информации.

Программу сопровождают четыре модуля, в которых иллюстрируются методики сбора системной информации. В модуле

time

gettimeofday()

issue

sendfile()

diskfree

fork()

exec()

dup2()

processes

/proc

11.1.1. Существующие ограничения

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

■ Мы не пытались создать полноценную реализацию протокола HTTP. Воплощены лишь те его функции, которые достаточны для организации взаимодействия Web-сервера и клиентов. В реальных приложениях используются готовые реализации Web-сервера.[36]

■ Программа не претендует на полную совместимость со спецификациями HTML (

http://www.w3.org/MarkUp/

■ Сервер не настроен на максимальную производительность или минимальное потребление ресурсов. В частности, мы сознательно опустили код сетевой настройки, обычно имеющийся у Web-сервера. Рассмотрение этой темы выходит за рамки нашей книги.

■ Мы не пытаемся регулировать объем ресурсов (число процессов, объем используемой памяти), потребляемых сервером или его модулями. Многие многозадачные Web-серверы обслуживают запросы посредством фиксированного пула процессов, а не создают новый дочерний процесс для каждого соединения.

■ Всякий раз, когда поступает запрос, сервер загружает библиотеку с модулем, которая немедленно выгружается по окончании обработки запроса. Эффективнее было бы кэшировать загруженные модули.

GET /page HTTP/1.0

GET

HTTP/1.0 200 OK

Content-type: text/html

http://www.w3.org/Protocols

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

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

server.h

static

server.h

#ifndef SERVER_H

#define SERVER_H

#include 

#include 

/*** Символические константы файла common.c. ********************/

/* Имя программы. */

extern const char* program_name;

/* Если не равна нулю, отображаются развернутые сообщения. */

extern int verbose;

/* Напоминает функцию malloc(), не прерывает работу программы,

  если выделить память не удалось. */

extern void* xmalloc(size_t size);

/* Напоминает функцию realloc(), но прерывает работу программы,

  если выделить память не удалось */

extern void* xrealloc(void* ptr, size_t size);

/* Напоминает функцию strdup(), но прерывает работу программы,

  если выделить память не удалось. */

extern char* xstrdup(const char* s);

/* Выводит сообщение об ошибке заданного системного вызова

  и завершает работу программы. */

extern void system_error(const char* operation);

/* Выводит сообщение об ошибке и завершает работу программы. */

extern void error(const char* cause, const char* message);

/* Возвращает имя каталога, содержащего исполняемый файл

  программы. Поскольку возвращается указатель на область памяти,

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

  функции free(). В случае неудачи выполнение программы

  завершается. */

extern char* get_self_executable_directory();

/*** Символические константы файла module.с *********************/

/* Экземпляр загруженного серверного модуля. */

struct server_module {

 /* Дескриптор библиотеки, в которой находится модуль. */

 void* handle;

 /* Описательное имя модуля. */

 const char* name;

 /* Функция, генерирующая HTML-код для модуля. */

 void (*generatе_function)(int);

};

/* Каталог, из которого загружаются модули. */

extern char* module_dir;

/* Функция, пытающаяся загрузить указанный серверный модуль.

  Если модуль существует, возвращается структура

  с его описанием, в противном случае возвращается NULL. */

extern struct server_module* module_open(const char* module_path);

/* Закрытие модуля и удаление объекта MODULE. */

extern void module_close(struct server_module* module);

/*** Символические константы файла server.c. ********************/

/* Запуск сервера по адресу LOCAL_ADDRESS и порту PORT. */

extern void server_run(struct in_addr local_address, uint16_t port);

#endif /* SERVER_H */

11.2.1. Общие функции

Файл

common.c