descifrando sd

* key_task_permission - Check a key can be used
* @key_ref: The key to check
* @cred: The credentials to use
* @perm: The permissions to check for
*
* Check to see whether permission is granted to use a key in the desired way,
* but permit the security modules to override.
*
* The caller must hold either a ref on cred or must hold the RCU readlock or a
* spinlock.
*/
int key_task_permission(const key_ref_t key_ref, const struct cred *cred,
key_perm_t perm)
{
struct key *key;
key_perm_t kperm;
int ret;

key = key_ref_to_ptr(key_ref);

if (key->user->user_ns != cred->user->user_ns)
goto use_other_perms;

/* use the second 8-bits of permissions for keys the caller owns */
if (key->uid == cred->fsuid) {
kperm = key->perm >> 16;
goto use_these_perms;
}

/* use the third 8-bits of permissions for keys the caller has a group
* membership in common with */
if (key->gid != -1 && key->perm & KEY_GRP_ALL) {
if (key->gid == cred->fsgid) {
kperm = key->perm >> 8;
goto use_these_perms;
}

ret = groups_search(cred->group_info, key->gid);
if (ret) {
kperm = key->perm >> 8;
goto use_these_perms;
}
}

use_other_perms:

/* otherwise use the least-significant 8-bits */
kperm = key->perm;

use_these_perms:

/* use the top 8-bits of permissions for keys the caller possesses
* - possessor permissions are additive with other permissions
*/
if (is_key_possessed(key_ref))
kperm |= key->perm >> 24;

kperm = kperm & perm & KEY_ALL;

if (kperm != perm)
return -EACCES;

/* let LSM be the final arbiter */
return security_key_permission(key_ref, cred, perm);

} /* end key_task_permission() */

EXPORT_SYMBOL(key_task_permission);

/*****************************************************************************/
/*
* validate a key
*/
int key_validate(struct key *key)
{
struct timespec now;
int ret = 0;

if (key) {
/* check it's still accessible */
ret = -EKEYREVOKED;
if (test_bit(KEY_FLAG_REVOKED, &key->flags) ||
test_bit(KEY_FLAG_DEAD, &key->flags))
goto error;

/* check it hasn't expired */
ret = 0;
if (key->expiry) {
now = current_kernel_time();
if (now.tv_sec >= key->expiry)
ret = -EKEYEXPIRED;
}
}

error:
return ret;

} /* end key_validate() */

EXPORT_SYMBOL(key_validate);



TRADUCIDO


 * Key_task_permission - Disponibilidad de una tecla se puede utilizar
 * @key_ref: La clave para comprobar
 * @cred: Las credenciales de usar
 * @perm: Los permisos para verificar si hay
 *
 * Compruebe si se concede permiso para utilizar una clave de la manera deseada,
 * Pero permitir que los módulos de seguridad para anular.
 *
 * La persona que llama debe suscribir una referencia de credibilidad o debe sostener el mando a distancia o un readlock
 * Spinlock.
 * /
int key_task_permission (const key_ref_t key_ref, const struct CRED * CRED,
perm key_perm_t)
{
struct tecla *;
kperm key_perm_t;
int ret;

clave = key_ref_to_ptr (key_ref);

si (teclado> usuario-> user_ns! = cred-> usuario-> user_ns)
use_other_perms Goto;

/ * Usar los segundos 8-bits de permisos para las claves de la persona que llama es propietaria * /
si (teclado> uid == cred-> fsuid) {
kperm = teclado> perm >> 16;
use_these_perms Goto;
}

/ * Usar los terceros 8-bits de permisos para las claves de la persona que llama tiene un grupo
* La membresía en común con * /
si (teclado> gid! = -1 && teclado> perm y KEY_GRP_ALL) {
si (teclado> gid == cred-> fsgid) {
kperm = teclado> perm >> 8;
use_these_perms Goto;
}

ret = groups_search (cred-> group_info, teclado> GID);
si (r) {
kperm = teclado> perm >> 8;
use_these_perms Goto;
}
}

use_other_perms:

/ * De otro modo utilizar los menos significativos de 8 bits * /
kperm = teclado> perm;

use_these_perms:

/ * Utilizar los mejores 8-bits de permisos para las claves de la persona que llama posee
* - Poseedor permisos son aditivos con otros permisos
* /
si (is_key_possessed (key_ref))
kperm | = teclado> perm >> 24;

kperm = kperm y ondulación permanente y KEY_ALL;

si (kperm! = perm)
-EACCES Regresar;

/ * Deje LSM ser el árbitro final * /
security_key_permission (key_ref, CRED, perm) return;

} / * Key_task_permission Fin () * /

EXPORT_SYMBOL (key_task_permission);

/ ************************************************* **************************** /
/ *
 * Validar una clave
 * /
int key_validate (clave struct tecla *)
{
struct timespec ahora;
int ret = 0;

if (key) {
/ * Ver sigue siendo accesible * /
ret = -EKEYREVOKED;
si (test_bit (KEY_FLAG_REVOKED, y teclado> banderas) ||
test_bit (KEY_FLAG_DEAD, y teclados> banderas))
goto error;

/ * Comprobar que no haya expirado * /
ret = 0;
si (teclado> caducidad) {
Ahora current_kernel_time = ();
si (now.tv_sec> = teclado> caducidad)
ret = -EKEYEXPIRED;
}
}

 de error:
ret regresar;

} / * Key_validate Fin () * /

Buenas tardes.
Me tienes intrigado.
¿Para qué sirve?
Un saludo.