Главная » 2017 » Ноябрь » 19 » man 2 keyctl
22:49
man 2 keyctl

SEO sprint - Всё для максимальной раскрутки!





ИМЯ


keyctl - работа с системой управления ключами ядра



ОБЗОР


#include <sys/types.h>
#include <keyutils.h>

long keyctl(int operation, ...)

/* для прямого вызова через syscall(2): */
#include <asm/unistd.h>
#include <linux/keyctl.h>
#include <unistd.h>

long syscall(__NR_keyctl, int operation, __kernel_ulong_t arg2,
__kernel_ulong_t arg3, __kernel_ulong_t arg4,
__kernel_ulong_t arg5);

В glibc нет обёрточной функции для данного системного вызова; смотрите ЗАМЕЧАНИЯ.



ОПИСАНИЕ


keyctl() позволяет программам пользовательского пространства выполнять операции с
ключами.

Операция, выполняемая keyctl(), определяется значением аргумента operation. Каждая
операция обёрнута библиотекой libkeyutils (из пакета keyutils) в отдельную функцию
(описаны далее), чтобы компилятор мог выполнять проверку типов.

Возможные значения operation:

KEYCTL_GET_KEYRING_ID (начиная с Linux 2.6.10)
Отобразить идентификатор специального ключа в идентификатор реального ключа
для этого процесса.

Эта операция ищет специальный ключ, чей идентификатор указан в arg2
(приводится к key_serial_t). Если специальный ключ найден, то функция
возвращает идентификатор соответствующего реального ключа. В аргументе arg2
могут задаваться следующие значения:

KEY_SPEC_THREAD_KEYRING
Связка ключей вызывающей нити. Смотрите thread-keyring(7).

KEY_SPEC_PROCESS_KEYRING
Связка ключей вызывающего процесса. Смотрите process-keyring(7).

KEY_SPEC_SESSION_KEYRING
Связка ключей сеанса вызывающего. Смотрите session-keyring(7).

KEY_SPEC_USER_KEYRING
Связка ключей по UID вызывающего. Смотрите user-keyring(7).

KEY_SPEC_USER_SESSION_KEYRING
Связка ключей по UID сеанса вызывающего. Смотрите
user-session-keyring(7).

KEY_SPEC_REQKEY_AUTH_KEY (начиная с Linux 2.6.16)
Ключ авторизации, созданный request_key(2) и переданный процессу,
недоступен сразу после того, как запрошенный ключ был
инициализирован; смотрите request_key(2).

Если ключ, указанный в arg2, не существует, то дальнейшая работа зависит от
значения аргумента arg3 (приводится к int). Если arg3 содержит ненулевое
значение, то — если так надлежит делать (например, когда ищется
пользовательский, сеанса пользователя или сеансовый) — создаётся новый ключ
и функция возвращает его реальный идентификатор. В противном случае,
операция завершается ошибкой ENOKEY.

Если в arg2 задан действительный идентификатор ключа и ключ существует, то
эта операция просто возвращает идентификатор ключа. Если ключ не
существует, то вызов завершается ошибкой ENOKEY.

Чтобы найти ключ вызывающий должен иметь право поиска в связке ключей.

Аргументы arg4 и arg5 игнорируются.

Эта операция доступна в libkeyutils через функцию keyctl_get_keyring_ID(3).

KEYCTL_JOIN_SESSION_KEYRING (начиная с Linux 2.6.10)
Заменить связку ключей сеанса этого процесса новой связкой ключей сеанса.

Если arg2 равно NULL, то создаётся анонимная связка ключей с описанием
«_ses» и процесс подписывается на эту связку ключей как на свою связку
ключей сеанса, вытесняя предыдущую связку ключей сеанса.

В противном случае, arg2 (приводится к char *) считается описанием (именем)
связки ключей и происходит следующее:

* Если связка ключей с таким описанием существует, то процесс, если
возможно, попытается подписаться на эту связку ключей как на сеансовую;
если это невозможно, то возвращается ошибка. Чтобы подписаться на связку
ключей, вызывающий должен иметь право поиска в связке ключей.

* Если связка ключей с таким описанием не существует, то создаётся новая
связка ключей с заданным описанием, и процесс подписывается на эту
связку ключей как на сеансовую.

Аргументы arg3, arg4 и arg5 игнорируются.

Эта операция доступна в libkeyutils через функцию
keyctl_join_session_keyring(3).

KEYCTL_UPDATE (начиная с Linux 2.6.10)
Изменить полезные данные ключа.

В аргументе arg2 (приводится к key_serial_t) указывается идентификатор
изменяемого ключа. Аргумент arg3 (приводится к void *) указывает на новые
полезные данные, а в аргументе arg4 (приводится к size_t) содержится размер
новых полезных данных в байтах.

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

С помощью этой операции отрицательно инициализированный ключ (смотрите
описание KEYCTL_REJECT) может быть положительно инициализирован.
использования ключа будут приводить к ошибке EKEYREVOKED.

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

Аргументы arg3, arg4 и arg5 игнорируются.

Эта операция доступна в libkeyutils через функцию keyctl_revoke(3).

KEYCTL_CHOWN (начиная с Linux 2.6.10)
Изменить владельца (идентификатор пользователя и группы) ключа.

В аргументе arg2 (приводится к key_serial_t) содержится идентификатор
ключа. В аргументе arg3 (приводится к uid_t) содержится идентификатор
нового пользователя (или -1, если идентификатор пользователя не меняется).
В аргументе arg4 (приводится к gid_t) содержится идентификатор новой группы
(или -1, если идентификатор группы не меняется).

Ключ должен давать разрешение на изменения атрибута вызывающему.

Для смены на новый UID или новый GID, если вызывающий не является её
членом, у вызывающего должен быть мандат CAP_SYS_ADMIN (смотрите
capabilities(7)).

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

Аргумент arg5 игнорируется.

Эта операция доступна в libkeyutils через функцию keyctl_chown(3).

KEYCTL_SETPERM (начиная с Linux 2.6.10)
Изменить права ключа с идентификатором из аргумента arg2 (приводится к
key_serial_t) на права, указанные в аргументе arg3 (приводится к
key_perm_t).

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

Ключ должен давать разрешение на изменения атрибута независимо от мандатов
вызывающего.

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

владение (начиная с Linux 2.6.14)
Это право предоставляется процессу, который владеет ключом
(прицеплен с возможностью поиска к одной из связок ключей процесса);
смотрите keyrings(7).

пользователь
Это право предоставляется процессу, чей UID файловой системы
совпадает с UID ключа.

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

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

Каждая маска прав имеет размер в восемь бит, но используются только шесть.
Доступные права:

просмотр
Позволяет читать атрибуты ключа.

Это право требуется для операции KEYCTL_DESCRIBE.

Биты прав для каждой категории KEY_POS_VIEW, KEY_USR_VIEW,
KEY_GRP_VIEW и KEY_OTH_VIEW.

чтение Позволяет читать полезные данные ключа.

Это право требуется для операции KEYCTL_READ.

Биты прав для каждой категории KEY_POS_READ, KEY_USR_READ,
KEY_GRP_READ и KEY_OTH_READ.

запись Позволяет изменять или добавлять полезные данные ключа. Для связки
ключей позволяет добавление и удаление ключей из связки.

Это право требуется для операций KEYCTL_UPDATE, KEYCTL_REVOKE,
KEYCTL_CLEAR, KEYCTL_LINK и KEYCTL_UNLINK.

Биты прав для каждой категории KEY_POS_WRITE, KEY_USR_WRITE,
KEY_GRP_WRITE и KEY_OTH_WRITE.

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

Это право требуется для операций KEYCTL_GET_KEYRING_ID,
KEYCTL_JOIN_SESSION_KEYRING, KEYCTL_SEARCH и KEYCTL_INVALIDATE.

Биты прав для каждой категории KEY_POS_SEARCH, KEY_USR_SEARCH,
KEY_GRP_SEARCH и KEY_OTH_SEARCH.

связь Позволяет прицеплять ключ или связку ключей.

Это право требуется для операций KEYCTL_LINK и
KEYCTL_SESSION_TO_PARENT.

Биты прав для каждой категории KEY_POS_LINK, KEY_USR_LINK,
KEY_GRP_LINK и KEY_OTH_LINK.

setattr (начиная с Linux 2.6.15).
Позволяет изменять UID, GID и маску прав ключа.

Это право требуется для операций KEYCTL_REVOKE, KEYCTL_CHOWN и
KEYCTL_SETPERM.

Биты прав для каждой категории KEY_POS_SETATTR, KEY_USR_SETATTR,
KEY_GRP_SETATTR и KEY_OTH_SETATTR.

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

Описываемый идентификатор ключа задаётся в arg2 (приводится к
key_serial_t). Описывающая строка возвращается в буфере, на который
указывает arg3 (приводится к char *); в arg4 (приводится к size_t) задаётся
размер этого буфера в байтах.

Ключ должен давать вызывающему разрешение на просмотр.

Возвращаемая строка оканчивается null и содержит следующую информацию о
ключе:

тип;uid;gid;права;описание

Здесь тип и описание являются строками, uid и gid — десятичным числом в
виде строки, а права — шестнадцатеричной маской прав. Описывающая строка
записывается в следующем формате:

%s;%d;%d;%08x;%s

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

Запись в буфер производится только если arg3 не равно NULL и указанный
размер буфера достаточен для описывающей строки (включая конечный байт
null). Чтобы понять, что буфер был мал, проверьте, что возвращаемое
значение больше arg4.

Аргумент arg5 игнорируется.

Эта операция доступна в libkeyutils через функцию keyctl_describe(3).

KEYCTL_CLEAR
Стереть содержимое связки ключей (т. е., удалить из неё все ключи).

Идентификатор ключа (должен иметь тип связки ключей) задаётся в arg2
(приводится к key_serial_t).

Вызывающий должен иметь право записи в связку ключей.

Аргументы arg3, arg4 и arg5 игнорируются.

Эта операция доступна в libkeyutils через функцию keyctl_clear(3).

KEYCTL_LINK (начиная с Linux 2.6.10)
Прицепить ключ к связке ключей.

Прицепляемый ключ указывается в arg2 (приводится к key_serial_t); связка
ключей указывается в arg3 (приводится к key_serial_t).

Если ключ с тем же типом и описанием уже прицеплен к связке ключей, то этот
ключ отцепляется от связки ключей.

Перед созданием связи, ядро проверяет вложенность связок ключей и
Аргументы arg4 и arg5 игнорируются.

Эта операция доступна в libkeyutils через функцию keyctl_link(3).

KEYCTL_UNLINK (начиная с Linux 2.6.10)
Отцепить ключ от связки ключей.

Идентификатор отцепляемого ключа указывается в arg2 (приводится к
key_serial_t); идентификатор связки ключей, от которой отцепляется ключ,
указывается в arg3 (приводится к key_serial_t).

Если ключ не прицеплен к связке ключей, то возвращается ошибка.

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

Если удаляется последняя ссылка на ключ, то этот ключ планируется к
уничтожению.

Аргументы arg4 и arg5 игнорируются.

Эта операция доступна в libkeyutils через функцию keyctl_unlink(3).

KEYCTL_SEARCH (начиная с Linux 2.6.10)
Найти ключ в дереве связок ключей, вернуть его идентификатор и, при
необходимости, прицепить его к заданной связке ключей.

Идентификатор начала дерева ключей, в котором производится поиск, задаётся
в arg2 (приводится к key_serial_t). Поиск выполняется сначала вширь и
рекурсивно.

В аргументах arg3 и arg4 задаётся искомый ключ: в arg3 (приводится к
char *) содержится тип ключа (строка символов длиной до 32 байт с учётом
конечного байта null), а в arg4 (приводится к char *) содержится описание
ключа (строка символов до 4096 байт с учётом конечного байта null).

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

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

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

Вместо корректных существующих идентификаторов связок ключей источника
(arg2) и приёмника (arg5) можно указывать специальные идентификаторы связок
ключей, описанных в KEYCTL_GET_KEYRING_ID.

Эта операция доступна в libkeyutils через функцию keyctl_search(3).

KEYCTL_READ (начиная с Linux 2.6.10)

Возвращаемые данные будут обработаны для представления согласно типу ключа.
Например, связка ключей будет возвращена как массив элементов key_serial_t,
представляющих идентификаторы всех ключей связки. Данные типа ключа user
будут возвращены как есть. Если для типа ключа эта функция не реализована,
то операция завершается ошибкой EOPNOTSUPP.

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

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

Аргумент arg5 игнорируется.

Эта операция доступна в libkeyutils через функцию keyctl_read(3).

KEYCTL_INSTANTIATE (начиная с Linux 2.6.10)
Положительно инициализировать неинициализированный ключ заданными полезными
данными.

Идентификатор инициализированного ключа задаётся в arg2 (приводится к
key_serial_t).

Полезные данные ключа задаются в буфере, указанном в arg3 (приводится к
void *); размер буфера задаётся в arg4 (приводится к size_t).

Ссылка на полезные данные может быть равна NULL и размер буфера может
равняться 0, если это поддерживается типом ключа (например, если это связка
ключей).

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

Если arg5 (приводится к key_serial_t) не равно нулю, то с теми же
ограничениями и правилами как у KEYCTL_LINK инициализированный ключ
прицепляется в связку ключей, идентификатор которой указан в arg5.

Вызывающий должен иметь соответствующий ключ авторизации и после
инициализации ключа ключ авторизации отзывается. Иначе говоря, эта операция
доступна только из программ, подобных request-key(8). В request_key(2)
смотрите описание неинициализированных ключей и их инициализацию.

Эта операция доступна в libkeyutils через функцию keyctl_instantiate(3).

KEYCTL_NEGATE (начиная с Linux 2.6.10)
Отрицательно инициализировать неинициализированный ключ.

Данная операция эквивалентен вызову:

keyctl(KEYCTL_REJECT, arg2, arg3, ENOKEY, arg4);

Аргумент arg5 игнорируется.


В аргументе arg2 (приводится к int) должно содержаться одно из следующих
значений, задающих новую связку ключей по умолчанию:

KEY_REQKEY_DEFL_NO_CHANGE
Не изменять связку ключей по умолчанию. Используется для определения
текущей связки ключей по умолчанию (без её изменения).

KEY_REQKEY_DEFL_DEFAULT
Применить действие по умолчанию, то есть использовать связку ключей,
привязанную к нити, если есть, в противном случае привязанную к
процессу, если есть, иначе привязанную к сеансу, если есть, иначе
привязанную к сеансу UID, иначе привязанную к пользователю.

KEY_REQKEY_DEFL_THREAD_KEYRING
В качестве новой связки ключей по умолчанию использовать связку
ключей нити (thread-keyring(7)).

KEY_REQKEY_DEFL_PROCESS_KEYRING
В качестве новой связки ключей по умолчанию использовать связку
ключей процесса (process-keyring(7)).

KEY_REQKEY_DEFL_SESSION_KEYRING
В качестве новой связки ключей по умолчанию использовать связку
ключей сеанса (session-keyring(7)).

KEY_REQKEY_DEFL_USER_KEYRING
В качестве новой связки ключей по умолчанию использовать связку
ключей UID (user-keyring(7)).

KEY_REQKEY_DEFL_USER_SESSION_KEYRING
В качестве новой связки ключей по умолчанию использовать связку
ключей UID сеанса (user-session-keyring(7)).

KEY_REQKEY_DEFL_REQUESTOR_KEYRING (начиная с Linux 2.6.29)
Использовать связку ключей запрашивающего.

Любые другие значения недопустимы.

Аргументы arg3, arg4 и arg5 игнорируются.

Параметр, контролируемый данной операцией, наследуется потомком при fork(2)
и сохраняется при execve(2).

Эта операция доступна в libkeyutils через функцию
keyctl_set_reqkey_keyring(3).

KEYCTL_SET_TIMEOUT (начиная с Linux 2.6.16)
Назначить время ожидания ключа.

Идентификатор ключа задаётся в arg2 (приводится к key_serial_t). Время
ожидания в секундах отсчитывается от текущего времени и задаётся в arg3
(приводится к unsigned int). Время ожидания изменяется по часам реального
времени.

Значение времени ожидания 0 очищается существующее ожидание ключа.

завершаться ошибкой EKEYEXPIRED.

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

Аргументы arg4 и arg5 игнорируются.

Эта операция доступна в libkeyutils через функцию keyctl_set_timeout(3).

KEYCTL_ASSUME_AUTHORITY (начиная с Linux 2.6.16)
Выдать (или отозвать) право вызывающей нити на инициализацию ключа.

В аргументе arg2 (приводится к key_serial_t) указывается ненулевое
идентификатор ключа для выдачи права допуска или 0 для отмены права
допуска.

Если arg2 не равно нулю, то будет выдано право допуска к указанному
идентификатору неинициализированного ключа. Далее этот ключ может быть
инициализирован посредством операций KEYCTL_INSTANTIATE,
KEYCTL_INSTANTIATE_IOV, KEYCTL_REJECT или KEYCTL_NEGATE. После
инициализации ключа, у нити автоматически отменяется право доступа для
инициализации ключа.

Право доступа на ключ может быть выдано только, если вызывающая нить
содержит в своих связках ключей ключ авторизации, который связан с
указанным ключом (иначе говоря, операция KEYCTL_ASSUME_AUTHORITY доступна
только из программ, подобных request-key(8); в request_key(2) смотрите
описание как используется эта операция). Вызывающий должен иметь право
поиска ключа авторизации.

Если указанный ключ совпадает с ключом авторизации, то возвращается
идентификатор этого ключа. Ключ авторизации можно прочитать (KEYCTL_READ)
для получения исходящей информации, переданной в request_key(2).

Если идентификатор в arg2 равен 0, то имеющееся в настоящее время право
выдачи очищается (отменяется и возвращается 0.

Механизм KEYCTL_ASSUME_AUTHORITY позволяет программе, такой как
request-key(8) выдать необходимые права для инициализации нового
неинициализированного ключа, который был создан предшествующим вызовом
request_key(2). Дополнительную информацию смотрите в request_key(2) и в
файле исходного кода ядра Documentation/security/keys-request-key.txt.

Аргументы arg3, arg4 и arg5 игнорируются.

Эта операция доступна в libkeyutils через функцию
keyctl_assume_authority(3).

KEYCTL_GET_SECURITY (начиная с Linux 2.6.26)
Получить метку безопасности LSM (модуль безопасности Linux) указанного
ключа.

В arg2 (приводится к key_serial_t) задаётся идентификатор ключа, чью метку
безопасности нужно получить. Метка безопасности (завершается байтом null)
будет помещена в буфер, указанный в аргументе arg3 (приводится к char *);
размер буфера должен быть указан в arg4 (приводится к size_t).


unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023

Если в данный момент LSM не работает, то в буфер помещается пустая строка.

Аргумент arg5 игнорируется.

Эта операция доступна в libkeyutils через функции keyctl_get_security(3) и
keyctl_get_security_alloc(3).

KEYCTL_SESSION_TO_PARENT (начиная с Linux 2.6.32)
Заменить связку ключей сеанса у родителя вызывающего процесса на связку
ключей сеанса вызывающего процесса.

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

Связка ключей должна существовать и позволять вызывающему выполнять сцепку.
Родительский процесс должен быть с одной нитью и иметь те же действующие
права как этот процесс и не быть set-user-ID или set-group-ID. UID связки
ключей сеанса родительского процесса (если есть), а также UID связки ключей
сеанса вызывающего должны совпадать с действующим UID вызывающего.

Факт того, что эта операция затрагивает родительский процесс, позволяет
программе, такой как оболочка, запускать дочерний процесс, который с
помощью этой операции изменит связку ключей сеанса оболочки (это то, что
делает команда new_session keyctl(1)).

Аргументы arg2, arg3, arg4 и arg5 игнорируются.

Эта операция доступна в libkeyutils через функцию
keyctl_session_to_parent(3).

KEYCTL_REJECT (начиная с Linux 2.6.39)
Пометить ключ как отрицательно инициализированный и задать таймер действия
ключа. Эта операция предоставляет собой надмножество возможности операции
KEYCTL_NEGATE, представленной ранее.

Идентификатор отрицательно инициализируемого ключа указывается в arg2
(приводится к key_serial_t). В arg3 (приводится к unsigned int) указывается
срок жизни ключа в секундах. В arg4 (приводится к unsigned int) указывается
ошибка, возвращаемая при нахождении этого ключа — обычно равно
EKEYREJECTED, EKEYREVOKED или EKEYEXPIRED.

Если arg5 (приводится к key_serial_t) не равно нулю, то с теми же
ограничениями и правилами как у KEYCTL_LINK отрицательно инициализированный
ключ прицепляется в связку ключей, идентификатор которой указан в arg5.

Вызывающий должен иметь соответствующий ключ авторизации. Иначе говоря, эта
операция доступна только из программ, подобных request-key(8). Смотрите
request_key(2).

Вызывающий должен иметь соответствующий ключ авторизации и после
инициализации ключа ключ авторизации отзывается. Иначе говоря, эта операция
доступна только из программ, подобных request-key(8). В request_key(2)
смотрите описание неинициализированных ключей и их инициализацию.

struct iovec {
void *iov_base; /* начальный адрес буфера */
size_t iov_len; /* размер буфера (в байтах) */
};

Указатель на вектор полезных данных передаётся в arg3 (приводится к const
struct iovec *). Количество элементов в векторе задаётся в arg4 (приводится
к unsigned int).

Значение аргумента arg2 (идентификатор ключа) и arg5 (идентификатор связки
ключей) рассматриваются также как у KEYCTL_INSTANTIATE.

Эта операция доступна в libkeyutils через функцию
keyctl_instantiate_iov(3).

KEYCTL_INVALIDATE (начиная с Linux 3.5)
Пометить ключ как недействительный.

Идентификатор ключа, отмечаемого недействительным, задаётся в arg2
(приводится к key_serial_t).

Чтобы сделать ключ недействительным, вызывающий должен иметь на ключ право
поиска.

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

Ключи, помеченный как недействительные, сразу становятся невидимыми для
обычных операций с ключами, хотя их видно в /proc/keys (отмечены флагом
«i») до действительного удаления.

Аргументы arg3, arg4 и arg5 игнорируются.

Эта операция доступна в libkeyutils через функцию keyctl_invalidate(3).

KEYCTL_GET_PERSISTENT (начиная с Linux 3.13)
Получить постоянную связку ключей (persistent-keyring(7)) заданного
пользователя и прицепить её к указанную связку ключей.

Идентификатор пользователя указывается в arg2 (приводится к uid_t). Если
указано значение -1, то используется реальный идентификатор пользователя
вызывающего. Идентификатор связки ключей назначения указывается в arg3
(приводится к key_serial_t).

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

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

Вызывающий должен иметь право записи в связку ключей.


Постоянные связки ключей были добавлены в ядро Linux версии 3.13.

Аргументы arg4 и arg5 игнорируются.

Эта операция доступна в libkeyutils через функцию keyctl_get_persistent(3).

KEYCTL_DH_COMPUTE (начиная с Linux 4.7)
Вычислить открытый и закрытый ключ Диффи-Хеллмана, возможно применяя к
результату функцию формирования ключа (key derivation function, KDF).

В аргументе arg2 передаётся указатель на набор параметров, содержащих
серийные номера трёх ключей "user", используемых в вычислении
Диффи-Хеллмана, упакованных в следующую структуру:

struct keyctl_dh_params {
int32_t private; /* локальный закрытый ключ */
int32_t prime; /* основание, известное обеим сторонам */
int32_t base; /* базовое целое: из общего генератора
или из открытого ключа удалённой стороны */
};

Для каждого из трёх указанных в структуре ключей у вызывающего должно быть
право на чтение. Полезные данные этих ключей используются для вычисления
результата Диффи-Хеллмана по формуле:

база ^ закрытый mod основание

Если база это общий генератор, то результатом будет локальный открытый
ключ. Если база это открытый ключ удалённой стороны, то результатом будет
общий закрытый ключ.

Аргумент arg3 (приводится к char *) указывает на буфер, в который
помещается результат вычисления. Размер буфера задаётся в arg4 (приводится
к size_t).

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

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

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

Если аргумент arg5 равен NULL, то возвращается сам результат DH. В
противном случае (начиная с Linux 4.12), значение равно указателю на
структуру, в которой задаются параметры для применения в операции KDF:

struct keyctl_kdf_params {
char *hashname; /* имя алгоритма хэширования */

найти как компонуются имена хэшей из алгоритмов шифрования и шаблонов с
типом CRYPTO_ALG_TYPE_SHASH с учётом доступного исходного кода ядра и
настроек) для применения к результату DH в операции KDF.

Поле otherinfo содержит данные OtherInfo, описанные в SP800-56A, раздел
5.8.1.2, зависящие от алгоритма. Эти данные объединяются с результатом
операции DH и предоставляются как входные операции KDF. Его размер
указывается в поле otherinfolen и ограничивается константой
KEYCTL_KDF_MAX_OI_LEN, которая определена в security/keys/internal.h и
равна 64.

Поле __spare в настоящее время не используется. Оно игнорировалось до Linux
4.13 (but still should be user-addressable since it is copied to the
kernel), и, начиная с Linux 4.13, должно содержать нули.

Реализация KDF соответствует SP800-56A, а также SP800-108 (счётчик KDF).

Эта операция доступна в libkeyutils (начиная с версии 1.5.10) через функции
keyctl_dh_compute(3) и keyctl_dh_compute_alloc(3).

KEYCTL_RESTRICT_KEYRING (начиная с Linux 4.12)
Применить ограничение прицепить ключ к связке ключей с идентификатором,
указанном в arg2 (приводится к типу key_serial_t). Вызывающий должен иметь
право setattr на ключ. Если arg3 равно NULL, то все попытки добавить ключ в
связку ключей блокируются; в противном случае он содержит указатель на
строку с именем типа ключа, а в аргументе arg4 содержится указатель на
строку, описывающую ограничения, присущие типу. В Linux 4.12 из ограничений
определено только «asymmetric»:

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

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

ключ_или_связка:ключ
ключ_или_связка:ключ:chain
Если ключ задан идентификатором ключа типа «asymmetric», то
разрешены только ключи, подписанные этим ключом.

Если ключ задан идентификатором связки ключей, то разрешены только
ключи, подписанные ключом из этой связки.

Если указана «:chain» то разрешены ключи, которые подписаны ключами
из связки назначения (то есть, связки ключей с идентификатором из
аргумента arg2).

Заметим, что ограничение можно настроить для определённой связки только
один раз; будучи назначенным, это нельзя изменить.

Аргумент arg5 игнорируется.



ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ


Размер описания (включая конечный байт null), безотносительно к указанному
размеру буфера.

KEYCTL_SEARCH
Идентификатор найденного ключа.

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

KEYCTL_SET_REQKEY_KEYRING
Идентификатор предыдущей связки ключе по умолчанию, в которую неявно
цепляются запрашиваемые ключи (одна из KEY_REQKEY_DEFL_USER_*).

KEYCTL_ASSUME_AUTHORITY
Равно 0, если был указан идентификатор равный 0, или идентификатор ключа
авторизации, совпадающий с указанным ключом, если указан ненулевой
идентификатор ключа.

KEYCTL_GET_SECURITY
Размер описания строки метки безопасности LSM (включая конечный байт null),
безотносительно к указанному размеру буфера.

KEYCTL_GET_PERSISTENT
Идентификатор постоянной связки ключей.

KEYCTL_DH_COMPUTE
Количество байт, скопированных в буфер, или требуемый размер буфера, если
arg4 равно 0.

Остальные операции
Ноль.

В случае ошибки возвращается -1, а errno устанавливается в значение ошибки.



ОШИБКИ


EACCES Запрошенная операция не разрешена.

EAGAIN Значение operation равно KEYCTL_DH_COMPUTE и при инициализации модуля
шифрования возникла ошибка.

EDEADLK
Значение operation равно KEYCTL_LINK и запрошенная связь привела бы
зацикливанию.

EDEADLK
Значение operation равно KEYCTL_RESTRICT_KEYRING и запрошенная связь
привела бы зацикливанию.

EDQUOT Квота на ключи для данного пользователя была бы превышена, если бы этот
ключ создался или был бы прицеплен в связку ключей.

EEXIST Значение operation равно KEYCTL_RESTRICT_KEYRING и связка ключей из
аргумента arg2 уже содержит набор ограничений.

EFAULT Значение operation равно KEYCTL_DH_COMPUTE и возникла ошибки в одной из
следующих операций:
keyctl_kdf_params из пользовательского пространства

· копирования данные, указанных в поле otherinfo с типом struct
keyctl_kdf_params из пользовательского пространства и поле otherinfolen
не равно нулю

· копирования результата в пользовательское пространство

EINVAL Значение operation равно KEYCTL_SETPERM и в arg3 указан неверный бит прав.

EINVAL Значение operation равно KEYCTL_SEARCH и размер описания в arg4 (включая
конечный байт null) превышает 4096 байт. Размер строки (включая конечный
байт null), указанный в arg3 (тип ключа) или arg4 (описание ключа)
превышает ограничение (32 байта и 4096 байта, соответственно).

EINVAL (ядра Linux до 4.12)
Значение operation равно KEYCTL_DH_COMPUTE и аргумент arg5 не равен NULL.

EINVAL Значение operation равно KEYCTL_DH_COMPUTE и указанный размер свёртки
алгоритма хэширования равен нулю.

EINVAL Значение operation равно KEYCTL_DH_COMPUTE, но указанный размер буфера
недостаточен для размещения результата. Укажите 0 в качестве размера
буфера, чтобы получить минимальный размер буфера.

EINVAL Значение operation равно KEYCTL_DH_COMPUTE и указанное имя хэша в поле
hashname структуры struct keyctl_kdf_params, на которую указывает аргумент
arg5, слишком велико (ограничение зависит от реализации и различно в разных
версиях ядра, но считается достаточно большим для всех допустимых имён
алгоритмов).

EINVAL Значение operation равно KEYCTL_DH_COMPUTE и поле __spare структуры struct
keyctl_kdf_params, на которую указывает аргумент arg5, содержит ненулевое
значение.

EKEYEXPIRED
Найден или указан просроченный ключ.

EKEYREJECTED
Найден или указан отклонённый (rejected) ключ.

EKEYREVOKED
Найден или указан отозванный ключ.

ELOOP Значение operation равно KEYCTL_LINK и запрошенная связь привела бы к
превышению количества вложенных друг в друга связок ключей.

EMSGSIZE
Значение operation равно KEYCTL_DH_COMPUTE и длина буфера превышает
KEYCTL_KDF_MAX_OUTPUT_LEN (в данный момент равна 1024) или поле
otherinfolen структуры struct keyctl_kdf_parms, переданной в arg5,
превышает KEYCTL_KDF_MAX_OI_LEN (в данный момент равно 64).

ENFILE (ядра Linux до 3.13)
Значение operation равно KEYCTL_LINK и связка ключей заполнена (до Linux
3.13 доступное место для хранения связей связки ключей было ограничено
одной страницей памяти; начиная с Linux 3.13 жёсткого ограничения нет).
поддерживает ограничения установленным ключом сцепления.

ENOKEY Искомый ключ не найден или указан неверный ключ.

ENOKEY Значение operation равно KEYCTL_GET_KEYRING_ID, ключ, указанный arg2, не
существует и значение arg3 равно нулю (то есть, не создавать ключ, если он
не существует).

ENOMEM При выполнении вызова одна из процедур выделения памяти ядра завершилась
ошибкой.

ENOTDIR
Ожидался ключ с типом связки ключей, но указан идентификатор ключа с другим
типом.

EOPNOTSUPP
Значение operation равно KEYCTL_READ и тип ключа не поддерживает чтение
(например, тип "login").

EOPNOTSUPP
Значение operation равно KEYCTL_UPDATE и тип ключа не поддерживает
обновление.

EOPNOTSUPP
Значение operation равно KEYCTL_RESTRICT_KEYRING, тип из аргумента arg3
равен «asymmetric» и ключ, указанный в определении ограничения,
предоставляемый аргументом arg4, имеет тип не «asymmetric» или «keyring».

EPERM Значение operation равно KEYCTL_GET_PERSISTENT, в arg2 указан UID,
отличающийся от реального или действующего UID вызывающей нити, и
вызывающий не имеет мандата CAP_SETUID.

EPERM Значение operation равно KEYCTL_SESSION_TO_PARENT и: не один из UID (GID)
родительского процесса не совпадают с действующим UID (GID) вызывающего
процесса; UID существующей связки ключей сеанса родителя или UID связки
ключей сеанса вызывающего не совпадает с действующим UID вызывающего;
родительский процесс состоит из нескольких нитей; родительский процесс это
init(1) или нить ядра.

ETIMEDOUT
Значение operation равно KEYCTL_DH_COMPUTE и истёк срок инициализации
модулей шифрования.



ВЕРСИИ


Этот системный вызов впервые появился в Linux 2.6.10.



СООТВЕТСТВИЕ СТАНДАРТАМ


Этот системный вызов является нестандартным расширением Linux.



ЗАМЕЧАНИЯ


Для этого системного вызова нет обёрточной функции в glibc. Обёрточная функция
предоставляется библиотекой libkeyutils. Для вызова нужно выполнить компоновку с
библиотекой, указав -lkeyutils. Несмотря на то, что можно вызывать системные
вызова напрямую, для выполнения отдельных операций, вероятно, лучше использовать
различные библиотечные функции, описанные выше.



ПРИМЕР


Следующий сеанс оболочки показывает использование этой программы. В сеансе мы
компилируем программу, а затем используем её как временную замены стандартной
программы request-key(8) (заметим, что временное отключение стандартной программы
request-key(8) может быть небезопасно на некоторых системах). После того, как наша
программа установлена, мы показываем её работу с request_key(2) для запроса ключа.

$ cc -o key_instantiate key_instantiate.c -lkeyutils
$ sudo mv /sbin/request-key /sbin/request-key.backup
$ sudo cp key_instantiate /sbin/request-key
$ ./t_request_key user mykey somepayloaddata
Идентификатор ключа равен 20d035bf
$ sudo mv /sbin/request-key.backup /sbin/request-key

Заглянув в файл журнала, созданный программой, мы увидим аргументы командной
строки, переданные нашей программе:

$ cat /tmp/key_instantiate.log
Время: Mon Nov 7 13:06:47 2016

Аргументы командной строки:
argv[0]: /sbin/request-key
operation: create
key_to_instantiate: 20d035bf
UID: 1000
GID: 1000
thread_keyring: 0
process_keyring: 0
session_keyring: 256e6a6

Описание ключа: user;1000;1000;3f010000;mykey
Полезные данные ключа авторизации: somepayloaddata
Связка ключей назначения: 256e6a6
Описание ключа авторизации: .request_key_auth;1000;1000;0b010000;20d035bf

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

* описание инициализируемого ключа, которое содержит имя ключа (mykey);

* полезные данные ключа авторизации, которые содержат данные (somepayloaddata),
переданные в request_key(2);

* связку ключей назначения, которая была указана в вызове request_key(2); и

* описание ключа авторизации, где мы можем увидеть, что имя ключа авторизации
совпадает с идентификатором ключа, который будет инициализирован (20d035bf).

Пример программы в request_key(2) задаёт связку ключей назначения как
KEY_SPEC_SESSION_KEYRING. Просмотрев содержимое /proc/keys, мы можем увидеть, что
он транслировался в идентификатор связки ключей назначения (0256e6a6), показанный
в журнале выше; мы также может увидеть только что созданный ключ с именем mykey и
идентификатором 20d035bf.

$ cat /proc/keys | egrep 'mykey|256e6a6'
0256e6a6 I--Q--- 194 perm 3f030000 1000 1000 keyring _ses: 3
20d035bf I--Q--- 1 perm 3f010000 1000 1000 user mykey: 16

Исходный код программы
#include <unistd.h>
#include <string.h>
#include <errno.h>

#ifndef KEY_SPEC_REQUESTOR_KEYRING
#define KEY_SPEC_REQUESTOR_KEYRING -8
#endif

int
main(int argc, char *argv[])
{
FILE *fp;
time_t t;
char *operation;
key_serial_t key_to_instantiate, dest_keyring;
key_serial_t thread_keyring, process_keyring, session_keyring;
uid_t uid;
gid_t gid;
char dbuf[256];
char auth_key_payload[256];
int akp_size; /* размер auth_key_payload */

fp = fopen("/tmp/key_instantiate.log", "w");
if (fp == NULL)
exit(EXIT_FAILURE);

setbuf(fp, NULL);

t = time(NULL);
fprintf(fp, "Время: %s\n", ctime(&t));

/*
* ядро передаёт постоянный набор аргументов в программу,
* которую выполняет execs; получаем их.
*/
operation = argv[1];
key_to_instantiate = atoi(argv[2]);
uid = atoi(argv[3]);
gid = atoi(argv[4]);
thread_keyring = atoi(argv[5]);
process_keyring = atoi(argv[6]);
session_keyring = atoi(argv[7]);

fprintf(fp, "Аргументы командной строки:\n");
fprintf(fp, " argv[0]: %s\n", argv[0]);
fprintf(fp, " operation: %s\n", operation);
fprintf(fp, " key_to_instantiate: %lx\n",
(long) key_to_instantiate);
fprintf(fp, " UID: %ld\n", (long) uid);
fprintf(fp, " GID: %ld\n", (long) gid);
fprintf(fp, " thread_keyring: %lx\n", (long) thread_keyring);
fprintf(fp, " process_keyring: %lx\n", (long) process_keyring);
fprintf(fp, " session_keyring: %lx\n", (long) session_keyring);
fprintf(fp, "\n");

/*
* выдаём право на инициализацию ключа с именем в argv[2]
*/
if (keyctl(KEYCTL_DESCRIBE, key_to_instantiate,
dbuf, sizeof(dbuf)) == -1) {
fprintf(fp, "Ошибка KEYCTL_DESCRIBE: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}

fprintf(fp, "Описание ключа: %s\n", dbuf);

/*
* получаем полезные данные ключа авторизации, который
* в действительности содержит данные, переданные в request_key()
*/
akp_size = keyctl(KEYCTL_READ, KEY_SPEC_REQKEY_AUTH_KEY,
auth_key_payload, sizeof(auth_key_payload));
if (akp_size == -1) {
fprintf(fp, "Ошибка KEYCTL_READ: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}

auth_key_payload[akp_size] = '\0';
fprintf(fp, "Полезные данные ключа авторизации: %s\n", auth_key_payload);

/*
* из любопытства, получим идентификатор ключа авторизации и
* выведем его.
*/
auth_key = keyctl(KEYCTL_GET_KEYRING_ID,
KEY_SPEC_REQKEY_AUTH_KEY);
if (auth_key == -1) {
fprintf(fp, "Ошибка KEYCTL_GET_KEYRING_ID: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}

fprintf(fp, "Идентификатор ключа авторизации: %lx\n", (long) auth_key);

/*
* получим идентификатор ключа связки ключей назначения request_key(2).
*/
dest_keyring = keyctl(KEYCTL_GET_KEYRING_ID,
KEY_SPEC_REQUESTOR_KEYRING);
if (dest_keyring == -1) {
fprintf(fp, "Ошибка KEYCTL_GET_KEYRING_ID: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}

fprintf(fp, "Связка ключей назначения: %lx\n", (long) dest_keyring);

/*
* получим описание ключа авторизации. Это
* позволит увидеть тип ключа, UID, GID, права,
* и описание (имя) ключа. Среди прочего,
* мы увидим, что имя ключа представляет шестнадцатеричную
* строку идентификатора инициализированного ключа.
*/
* Инициализируем ключ с помощью переданных данных из
* полезной нагрузки ключа авторизации.
*/
if (keyctl(KEYCTL_INSTANTIATE, key_to_instantiate,
auth_key_payload, akp_size + 1, dest_keyring) == -1) {
fprintf(fp, "Ошибка KEYCTL_INSTANTIATE: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}

exit(EXIT_SUCCESS);
}



СМОТРИТЕ ТАКЖЕ


keyctl(1), add_key(2), request_key(2), keyctl(3), keyctl_assume_authority(3),
keyctl_chown(3), keyctl_clear(3), keyctl_describe(3), keyctl_describe_alloc(3),
keyctl_dh_compute(3), keyctl_dh_compute_alloc(3), keyctl_get_keyring_ID(3),
keyctl_get_persistent(3), keyctl_get_security(3), keyctl_get_security_alloc(3),
keyctl_instantiate(3), keyctl_instantiate_iov(3), keyctl_invalidate(3),
keyctl_join_session_keyring(3), keyctl_link(3), keyctl_negate(3), keyctl_read(3),
keyctl_read_alloc(3), keyctl_reject(3), keyctl_revoke(3), keyctl_search(3),
keyctl_session_to_parent(3), keyctl_set_reqkey_keyring(3), keyctl_set_timeout(3),
keyctl_setperm(3), keyctl_unlink(3), keyctl_update(3), recursive_key_scan(3),
recursive_session_key_scan(3), capabilities(7), credentials(7), keyrings(7),
keyutils(7), persistent-keyring(7), process-keyring(7), session-keyring(7),
thread-keyring(7), user-keyring(7), user_namespaces(7), user-session-keyring(7),
request-key(8)

Файл из дерева исходного кода ядра Documentation/security/keys/ (до Linux 4.13 —
Documentation/security/keys.txt).



Категория: (2) Системные вызовы ядра (функции языка Си) | Просмотров: 36 | Добавил: Администратор | Рейтинг: 0.0/0
Всего комментариев: 0
avatar