Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811// SPDX-License-Identifier: GPL-2.0-or-later/* Keyring handling * * Copyright (C) 2004-2005, 2008, 2013 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) */
#include <linux/export.h>#include <linux/init.h>#include <linux/sched.h>#include <linux/slab.h>#include <linux/security.h>#include <linux/seq_file.h>#include <linux/err.h>#include <linux/user_namespace.h>#include <linux/nsproxy.h>#include <linux/once.h>#include <linux/random.h>#include <linux/siphash.h>#include <keys/keyring-type.h>#include <keys/user-type.h>#include <linux/assoc_array_priv.h>#include <linux/uaccess.h>#include <net/net_namespace.h>#include "internal.h"
/* * When plumbing the depths of the key tree, this sets a hard limit * set on how deep we're willing to go. */#define KEYRING_SEARCH_MAX_DEPTH 6
/* * We mark pointers we pass to the associative array with bit 1 set if * they're keyrings and clear otherwise. */#define KEYRING_PTR_SUBTYPE 0x2UL
static inline bool keyring_ptr_is_keyring(const struct assoc_array_ptr *x){ return (unsigned long)x & KEYRING_PTR_SUBTYPE;}static inline struct key *keyring_ptr_to_key(const struct assoc_array_ptr *x){ void *object = assoc_array_ptr_to_leaf(x); return (struct key *)((unsigned long)object & ~KEYRING_PTR_SUBTYPE);}static inline void *keyring_key_to_ptr(struct key *key){ if (key->type == &key_type_keyring) return (void *)((unsigned long)key | KEYRING_PTR_SUBTYPE); return key;}
static DEFINE_RWLOCK(keyring_name_lock);
/* * Clean up the bits of user_namespace that belong to us. */void key_free_user_ns(struct user_namespace *ns){ write_lock(&keyring_name_lock); list_del_init(&ns->keyring_name_list); write_unlock(&keyring_name_lock);
key_put(ns->user_keyring_register);#ifdef CONFIG_PERSISTENT_KEYRINGS key_put(ns->persistent_keyring_register);#endif}
/* * The keyring key type definition. Keyrings are simply keys of this type and * can be treated as ordinary keys in addition to having their own special * operations. */static int keyring_preparse(struct key_preparsed_payload *prep);static void keyring_free_preparse(struct key_preparsed_payload *prep);static int keyring_instantiate(struct key *keyring, struct key_preparsed_payload *prep);static void keyring_revoke(struct key *keyring);static void keyring_destroy(struct key *keyring);static void keyring_describe(const struct key *keyring, struct seq_file *m);static long keyring_read(const struct key *keyring, char *buffer, size_t buflen);
struct key_type key_type_keyring = { .name = "keyring", .def_datalen = 0, .preparse = keyring_preparse, .free_preparse = keyring_free_preparse, .instantiate = keyring_instantiate, .revoke = keyring_revoke, .destroy = keyring_destroy, .describe = keyring_describe, .read = keyring_read,};EXPORT_SYMBOL(key_type_keyring);
/* * Semaphore to serialise link/link calls to prevent two link calls in parallel * introducing a cycle. */static DEFINE_MUTEX(keyring_serialise_link_lock);
/* * Publish the name of a keyring so that it can be found by name (if it has * one and it doesn't begin with a dot). */static void keyring_publish_name(struct key *keyring){ struct user_namespace *ns = current_user_ns();
if (keyring->description && keyring->description[0] && keyring->description[0] != '.') { write_lock(&keyring_name_lock); list_add_tail(&keyring->name_link, &ns->keyring_name_list); write_unlock(&keyring_name_lock); }}
/* * Preparse a keyring payload */static int keyring_preparse(struct key_preparsed_payload *prep){ return prep->datalen != 0 ? -EINVAL : 0;}
/* * Free a preparse of a user defined key payload */static void keyring_free_preparse(struct key_preparsed_payload *prep){}
/* * Initialise a keyring. * * Returns 0 on success, -EINVAL if given any data. */static int keyring_instantiate(struct key *keyring, struct key_preparsed_payload *prep){ assoc_array_init(&keyring->keys); /* make the keyring available by name if it has one */ keyring_publish_name(keyring); return 0;}
/* * Give key types and domains address-independent identities. Zero means that * an ID has not yet been allocated. As with inode sequence numbers used by * futexes, this relies on the 64-bit counter not wrapping in a machine's * lifetime. */static u64 key_index_id(atomic64_t *id){ static atomic64_t next_id; u64 old, new;
old = atomic64_read(id); if (likely(old)) return old;
do { new = atomic64_inc_return(&next_id); } while (WARN_ON_ONCE(!new));
old = 0; if (!atomic64_try_cmpxchg_relaxed(id, &old, new)) return old; return new;}
/* * Hash a key type, domain and description. KEYCTL_READ exposes the tree's * traversal order, so no part of the index may contain kernel addresses. */static void hash_key_type_and_desc(struct keyring_index_key *index_key){ const unsigned level_shift = ASSOC_ARRAY_LEVEL_STEP; const unsigned long fan_mask = ASSOC_ARRAY_FAN_MASK; static siphash_key_t hash_key __read_mostly; unsigned long hash; u64 acc;
get_random_once(&hash_key, sizeof(hash_key)); acc = siphash(index_key->description, index_key->desc_len, &hash_key); acc = siphash_3u64(index_key->type_id, index_key->domain_id, acc, &hash_key);
/* Fold the hash down to 32 bits if need be. */ hash = acc; if (ASSOC_ARRAY_KEY_CHUNK_SIZE == 32) hash ^= acc >> 32;
/* Squidge all the keyrings into a separate part of the tree to * ordinary keys by making sure the lowest level segment in the hash is * zero for keyrings and non-zero otherwise. */ if (index_key->type != &key_type_keyring && (hash & fan_mask) == 0) hash |= (hash >> (ASSOC_ARRAY_KEY_CHUNK_SIZE - level_shift)) | 1; else if (index_key->type == &key_type_keyring && (hash & fan_mask) != 0) hash = (hash + (hash << level_shift)) & ~fan_mask; index_key->hash = hash;}
/* * Finalise an index key to include a part of the description actually in the * index key, to set the domain tag and index IDs, and to calculate the hash. */void key_set_index_key(struct keyring_index_key *index_key){ static struct key_tag default_domain_tag = { .usage = REFCOUNT_INIT(1), }; size_t n = min_t(size_t, index_key->desc_len, sizeof(index_key->desc));
memcpy(index_key->desc, index_key->description, n);
if (!index_key->domain_tag) { if (index_key->type->flags & KEY_TYPE_NET_DOMAIN) index_key->domain_tag = current->nsproxy->net_ns->key_domain; else index_key->domain_tag = &default_domain_tag; }
/* Preserve the IDs when copying an existing key's index. In * particular, its type may already have been unregistered. */ if (!index_key->type_id) index_key->type_id = key_index_id(&index_key->type->index_id); if (!index_key->domain_id) index_key->domain_id = key_index_id(&index_key->domain_tag->index_id);
hash_key_type_and_desc(index_key);}
/** * key_put_tag - Release a ref on a tag. * @tag: The tag to release. * * This releases a reference the given tag and returns true if that ref was the * last one. */bool key_put_tag(struct key_tag *tag){ if (refcount_dec_and_test(&tag->usage)) { kfree_rcu(tag, rcu); return true; }
return false;}
/** * key_remove_domain - Kill off a key domain and gc its keys * @domain_tag: The domain tag to release. * * This marks a domain tag as being dead and releases a ref on it. If that * wasn't the last reference, the garbage collector is poked to try and delete * all keys that were in the domain. */void key_remove_domain(struct key_tag *domain_tag){ domain_tag->removed = true; if (!key_put_tag(domain_tag)) key_schedule_gc_links();}
/* * Build the next index key chunk. * * The hash and inline description are followed by the 64-bit type and domain * IDs, low word first, and then by the rest of the description. * We return it one word-sized chunk at a time. */static unsigned long keyring_get_key_chunk(const void *data, int level){ const unsigned int id_chunks = sizeof(u64) / sizeof(unsigned long); const struct keyring_index_key *index_key = data; int desc_len = index_key->desc_len; unsigned long chunk = 0; int n = sizeof(chunk); unsigned int offset; const u8 *d;
level /= ASSOC_ARRAY_KEY_CHUNK_SIZE; switch (level) { case 0: return index_key->hash; case 1: return index_key->x; }
level -= 2; if (level < id_chunks) return index_key->type_id >> (level * ASSOC_ARRAY_KEY_CHUNK_SIZE); level -= id_chunks; if (level < id_chunks) return index_key->domain_id >> (level * ASSOC_ARRAY_KEY_CHUNK_SIZE); level -= id_chunks;
offset = sizeof(index_key->desc) + level * sizeof(long); if (desc_len <= offset) return 0;
d = index_key->description + offset; desc_len -= offset; if (desc_len > n) desc_len = n; d += desc_len; do { chunk <<= 8; chunk |= *--d; } while (--desc_len > 0); return chunk;}
static unsigned long keyring_get_object_key_chunk(const void *object, int level){ const struct key *key = keyring_ptr_to_key(object); return keyring_get_key_chunk(&key->index_key, level);}
static bool keyring_compare_object(const void *object, const void *data){ const struct keyring_index_key *index_key = data; const struct key *key = keyring_ptr_to_key(object);
return key->index_key.type == index_key->type && key->index_key.domain_tag == index_key->domain_tag && key->index_key.desc_len == index_key->desc_len && memcmp(key->index_key.description, index_key->description, index_key->desc_len) == 0;}
/* * Compare the index keys of a pair of objects and determine the bit position * at which they differ - if they differ. */static int keyring_diff_objects(const void *object, const void *data){ const struct key *key_a = keyring_ptr_to_key(object); const struct keyring_index_key *a = &key_a->index_key; const struct keyring_index_key *b = data; unsigned long seg_a, seg_b; int level, i; u64 diff;
level = 0; seg_a = a->hash; seg_b = b->hash; if ((seg_a ^ seg_b) != 0) goto differ; level += ASSOC_ARRAY_KEY_CHUNK_SIZE / 8;
/* The inline description contributes one machine-word-sized chunk. */ seg_a = a->x; seg_b = b->x; if ((seg_a ^ seg_b) != 0) goto differ; level += sizeof(unsigned long);
diff = a->type_id ^ b->type_id; if (diff) return level * 8 + __ffs64(diff); level += sizeof(u64);
diff = a->domain_id ^ b->domain_id; if (diff) return level * 8 + __ffs64(diff); level += sizeof(u64);
i = sizeof(a->desc); if (a->desc_len <= i) goto same;
for (; i < a->desc_len; i++) { seg_a = *(unsigned char *)(a->description + i); seg_b = *(unsigned char *)(b->description + i); if ((seg_a ^ seg_b) != 0) goto differ_plus_i; }
same: return -1;
differ_plus_i: level += i - (int)sizeof(a->desc);differ: i = level * 8 + __ffs(seg_a ^ seg_b); return i;}
/* * Free an object after stripping the keyring flag off of the pointer. */static void keyring_free_object(void *object){ key_put(keyring_ptr_to_key(object));}
/* * Operations for keyring management by the index-tree routines. */static const struct assoc_array_ops keyring_assoc_array_ops = { .get_key_chunk = keyring_get_key_chunk, .get_object_key_chunk = keyring_get_object_key_chunk, .compare_object = keyring_compare_object, .diff_objects = keyring_diff_objects, .free_object = keyring_free_object,};
/* * Clean up a keyring when it is destroyed. Unpublish its name if it had one * and dispose of its data. * * The garbage collector detects the final key_put(), removes the keyring from * the serial number tree and then does RCU synchronisation before coming here, * so we shouldn't need to worry about code poking around here with the RCU * readlock held by this time. */static void keyring_destroy(struct key *keyring){ if (keyring->description) { write_lock(&keyring_name_lock);
if (keyring->name_link.next != NULL && !list_empty(&keyring->name_link)) list_del(&keyring->name_link);
write_unlock(&keyring_name_lock); }
if (keyring->restrict_link) { struct key_restriction *keyres = keyring->restrict_link;
key_put(keyres->key); kfree(keyres); }
assoc_array_destroy(&keyring->keys, &keyring_assoc_array_ops);}
/* * Describe a keyring for /proc. */static void keyring_describe(const struct key *keyring, struct seq_file *m){ if (keyring->description) seq_puts(m, keyring->description); else seq_puts(m, "[anon]");
if (key_is_positive(keyring)) { if (keyring->keys.nr_leaves_on_tree != 0) seq_printf(m, ": %lu", keyring->keys.nr_leaves_on_tree); else seq_puts(m, ": empty"); }}
struct keyring_read_iterator_context { size_t buflen; size_t count; key_serial_t *buffer;};
static int keyring_read_iterator(const void *object, void *data){ struct keyring_read_iterator_context *ctx = data; const struct key *key = keyring_ptr_to_key(object);
kenter("{%s,%d},,{%zu/%zu}", key->type->name, key->serial, ctx->count, ctx->buflen);
if (ctx->count >= ctx->buflen) return 1;
*ctx->buffer++ = key->serial; ctx->count += sizeof(key->serial); return 0;}
/* * Read a list of key IDs from the keyring's contents in binary form * * The keyring's semaphore is read-locked by the caller. This prevents someone * from modifying it under us - which could cause us to read key IDs multiple * times. */static long keyring_read(const struct key *keyring, char *buffer, size_t buflen){ struct keyring_read_iterator_context ctx; long ret;
kenter("{%d},,%zu", key_serial(keyring), buflen);
if (buflen & (sizeof(key_serial_t) - 1)) return -EINVAL;
/* Copy as many key IDs as fit into the buffer */ if (buffer && buflen) { ctx.buffer = (key_serial_t *)buffer; ctx.buflen = buflen; ctx.count = 0; ret = assoc_array_iterate(&keyring->keys, keyring_read_iterator, &ctx); if (ret < 0) { kleave(" = %ld [iterate]", ret); return ret; } }
/* Return the size of the buffer needed */ ret = keyring->keys.nr_leaves_on_tree * sizeof(key_serial_t); if (ret <= buflen) kleave("= %ld [ok]", ret); else kleave("= %ld [buffer too small]", ret); return ret;}
/* * Allocate a keyring and link into the destination keyring. */struct key *keyring_alloc(const char *description, kuid_t uid, kgid_t gid, const struct cred *cred, key_perm_t perm, unsigned long flags, struct key_restriction *restrict_link, struct key *dest){ struct key *keyring; int ret;
keyring = key_alloc(&key_type_keyring, description, uid, gid, cred, perm, flags, restrict_link); if (!IS_ERR(keyring)) { ret = key_instantiate_and_link(keyring, NULL, 0, dest, NULL); if (ret < 0) { key_put(keyring); keyring = ERR_PTR(ret); } }
return keyring;}EXPORT_SYMBOL(keyring_alloc);
/** * restrict_link_reject - Give -EPERM to restrict link * @keyring: The keyring being added to. * @type: The type of key being added. * @payload: The payload of the key intended to be added. * @restriction_key: Keys providing additional data for evaluating restriction. * * Reject the addition of any links to a keyring. It can be overridden by * passing KEY_ALLOC_BYPASS_RESTRICTION to key_instantiate_and_link() when * adding a key to a keyring. * * This is meant to be stored in a key_restriction structure which is passed * in the restrict_link parameter to keyring_alloc(). */int restrict_link_reject(struct key *keyring, const struct key_type *type, const union key_payload *payload, struct key *restriction_key){ return -EPERM;}
/* * By default, we keys found by getting an exact match on their descriptions. */bool key_default_cmp(const struct key *key, const struct key_match_data *match_data){ return strcmp(key->description, match_data->raw_data) == 0;}
/* * Iteration function to consider each key found. */static int keyring_search_iterator(const void *object, void *iterator_data){ struct keyring_search_context *ctx = iterator_data; const struct key *key = keyring_ptr_to_key(object); unsigned long kflags = READ_ONCE(key->flags); short state = key_read_state(key);
kenter("{%d}", key->serial);
/* ignore keys not of this type */ if (key->type != ctx->index_key.type) { kleave(" = 0 [!type]"); return 0; }
/* skip invalidated, revoked and expired keys */ if (ctx->flags & KEYRING_SEARCH_DO_STATE_CHECK) { time64_t expiry = READ_ONCE(key->expiry);
if (kflags & ((1 << KEY_FLAG_INVALIDATED) | (1 << KEY_FLAG_REVOKED))) { ctx->result = ERR_PTR(-EKEYREVOKED); kleave(" = %d [invrev]", ctx->skipped_ret); goto skipped; }
if (expiry && ctx->now >= expiry) { if (!(ctx->flags & KEYRING_SEARCH_SKIP_EXPIRED)) ctx->result = ERR_PTR(-EKEYEXPIRED); kleave(" = %d [expire]", ctx->skipped_ret); goto skipped; } }
/* keys that don't match */ if (!ctx->match_data.cmp(key, &ctx->match_data)) { kleave(" = 0 [!match]"); return 0; }
/* key must have search permissions */ if (!(ctx->flags & KEYRING_SEARCH_NO_CHECK_PERM) && key_task_permission(make_key_ref(key, ctx->possessed), ctx->cred, KEY_NEED_SEARCH) < 0) { ctx->result = ERR_PTR(-EACCES); kleave(" = %d [!perm]", ctx->skipped_ret); goto skipped; }
if (ctx->flags & KEYRING_SEARCH_DO_STATE_CHECK) { /* we set a different error code if we pass a negative key */ if (state < 0) { ctx->result = ERR_PTR(state); kleave(" = %d [neg]", ctx->skipped_ret); goto skipped; } }
/* Found */ ctx->result = make_key_ref(key, ctx->possessed); kleave(" = 1 [found]"); return 1;
skipped: return ctx->skipped_ret;}
/* * Search inside a keyring for a key. We can search by walking to it * directly based on its index-key or we can iterate over the entire * tree looking for it, based on the match function. */static int search_keyring(struct key *keyring, struct keyring_search_context *ctx){ if (ctx->match_data.lookup_type == KEYRING_SEARCH_LOOKUP_DIRECT) { const void *object;
object = assoc_array_find(&keyring->keys, &keyring_assoc_array_ops, &ctx->index_key); return object ? ctx->iterator(object, ctx) : 0; } return assoc_array_iterate(&keyring->keys, ctx->iterator, ctx);}
/* * Search a tree of keyrings that point to other keyrings up to the maximum * depth. */static bool search_nested_keyrings(struct key *keyring, struct keyring_search_context *ctx){ struct { struct key *keyring; struct assoc_array_node *node; int slot; } stack[KEYRING_SEARCH_MAX_DEPTH];
struct assoc_array_shortcut *shortcut; struct assoc_array_node *node; struct assoc_array_ptr *ptr; struct key *key; int sp = 0, slot;
kenter("{%d},{%s,%s}", keyring->serial, ctx->index_key.type->name, ctx->index_key.description);
#define STATE_CHECKS (KEYRING_SEARCH_NO_STATE_CHECK | KEYRING_SEARCH_DO_STATE_CHECK) BUG_ON((ctx->flags & STATE_CHECKS) == 0 || (ctx->flags & STATE_CHECKS) == STATE_CHECKS);
if (ctx->index_key.description) key_set_index_key(&ctx->index_key);
/* Check to see if this top-level keyring is what we are looking for * and whether it is valid or not. */ if (ctx->match_data.lookup_type == KEYRING_SEARCH_LOOKUP_ITERATE || keyring_compare_object(keyring, &ctx->index_key)) { ctx->skipped_ret = 2; switch (ctx->iterator(keyring_key_to_ptr(keyring), ctx)) { case 1: goto found; case 2: return false; default: break; } }
ctx->skipped_ret = 0;
/* Start processing a new keyring */descend_to_keyring: kdebug("descend to %d", keyring->serial); if (keyring->flags & ((1 << KEY_FLAG_INVALIDATED) | (1 << KEY_FLAG_REVOKED))) goto not_this_keyring;
/* Search through the keys in this keyring before its searching its * subtrees. */ if (search_keyring(keyring, ctx)) goto found;
/* Then manually iterate through the keyrings nested in this one. * * Start from the root node of the index tree. Because of the way the * hash function has been set up, keyrings cluster on the leftmost * branch of the root node (root slot 0) or in the root node itself. * Non-keyrings avoid the leftmost branch of the root entirely (root * slots 1-15). */ if (!(ctx->flags & KEYRING_SEARCH_RECURSE)) goto not_this_keyring;
ptr = READ_ONCE(keyring->keys.root); if (!ptr) goto not_this_keyring;
if (assoc_array_ptr_is_shortcut(ptr)) { /* If the root is a shortcut, either the keyring only contains * keyring pointers (everything clusters behind root slot 0) or * doesn't contain any keyring pointers. */ shortcut = assoc_array_ptr_to_shortcut(ptr); if ((shortcut->index_key[0] & ASSOC_ARRAY_FAN_MASK) != 0) goto not_this_keyring;
ptr = READ_ONCE(shortcut->next_node); node = assoc_array_ptr_to_node(ptr); goto begin_node; }
node = assoc_array_ptr_to_node(ptr); ptr = node->slots[0]; if (!assoc_array_ptr_is_meta(ptr)) goto begin_node;
descend_to_node: /* Descend to a more distal node in this keyring's content tree and go * through that. */ kdebug("descend"); if (assoc_array_ptr_is_shortcut(ptr)) { shortcut = assoc_array_ptr_to_shortcut(ptr); ptr = READ_ONCE(shortcut->next_node); BUG_ON(!assoc_array_ptr_is_node(ptr)); } node = assoc_array_ptr_to_node(ptr);
begin_node: kdebug("begin_node"); slot = 0;ascend_to_node: /* Go through the slots in a node */ for (; slot < ASSOC_ARRAY_FAN_OUT; slot++) { ptr = READ_ONCE(node->slots[slot]);
if (assoc_array_ptr_is_meta(ptr)) { if (node->back_pointer || assoc_array_ptr_is_shortcut(ptr)) goto descend_to_node; }
if (!keyring_ptr_is_keyring(ptr)) continue;
key = keyring_ptr_to_key(ptr);
if (sp >= KEYRING_SEARCH_MAX_DEPTH) { if (ctx->flags & KEYRING_SEARCH_DETECT_TOO_DEEP) { ctx->result = ERR_PTR(-ELOOP); return false; } goto not_this_keyring; }
/* Search a nested keyring */ if (!(ctx->flags & KEYRING_SEARCH_NO_CHECK_PERM) && key_task_permission(make_key_ref(key, ctx->possessed), ctx->cred, KEY_NEED_SEARCH) < 0) continue;
/* stack the current position */ stack[sp].keyring = keyring; stack[sp].node = node; stack[sp].slot = slot; sp++;
/* begin again with the new keyring */ keyring = key; goto descend_to_keyring; }
/* We've dealt with all the slots in the current node, so now we need * to ascend to the parent and continue processing there. */ ptr = READ_ONCE(node->back_pointer); slot = node->parent_slot;
if (ptr && assoc_array_ptr_is_shortcut(ptr)) { shortcut = assoc_array_ptr_to_shortcut(ptr); ptr = READ_ONCE(shortcut->back_pointer); slot = shortcut->parent_slot; } if (!ptr) goto not_this_keyring; node = assoc_array_ptr_to_node(ptr); slot++;
/* If we've ascended to the root (zero backpointer), we must have just * finished processing the leftmost branch rather than the root slots - * so there can't be any more keyrings for us to find. */ if (node->back_pointer) { kdebug("ascend %d", slot); goto ascend_to_node; }
/* The keyring we're looking at was disqualified or didn't contain a * matching key. */not_this_keyring: kdebug("not_this_keyring %d", sp); if (sp <= 0) { kleave(" = false"); return false; }
/* Resume the processing of a keyring higher up in the tree */ sp--; keyring = stack[sp].keyring; node = stack[sp].node; slot = stack[sp].slot + 1; kdebug("ascend to %d [%d]", keyring->serial, slot); goto ascend_to_node;
/* We found a viable match */found: key = key_ref_to_ptr(ctx->result); key_check(key); if (!(ctx->flags & KEYRING_SEARCH_NO_UPDATE_TIME)) { key->last_used_at = ctx->now; keyring->last_used_at = ctx->now; while (sp > 0) stack[--sp].keyring->last_used_at = ctx->now; } kleave(" = true"); return true;}
/** * keyring_search_rcu - Search a keyring tree for a matching key under RCU * @keyring_ref: A pointer to the keyring with possession indicator. * @ctx: The keyring search context. * * Search the supplied keyring tree for a key that matches the criteria given. * The root keyring and any linked keyrings must grant Search permission to the * caller to be searchable and keys can only be found if they too grant Search * to the caller. The possession flag on the root keyring pointer controls use * of the possessor bits in permissions checking of the entire tree. In * addition, the LSM gets to forbid keyring searches and key matches. * * The search is performed as a breadth-then-depth search up to the prescribed * limit (KEYRING_SEARCH_MAX_DEPTH). The caller must hold the RCU read lock to * prevent keyrings from being destroyed or rearranged whilst they are being * searched. * * Keys are matched to the type provided and are then filtered by the match * function, which is given the description to use in any way it sees fit. The * match function may use any attributes of a key that it wishes to * determine the match. Normally the match function from the key type would be * used. * * RCU can be used to prevent the keyring key lists from disappearing without * the need to take lots of locks. * * Returns a pointer to the found key and increments the key usage count if * successful; -EAGAIN if no matching keys were found, or if expired or revoked * keys were found; -ENOKEY if only negative keys were found; -ENOTDIR if the * specified keyring wasn't a keyring. * * In the case of a successful return, the possession attribute from * @keyring_ref is propagated to the returned key reference. */key_ref_t keyring_search_rcu(key_ref_t keyring_ref, struct keyring_search_context *ctx){ struct key *keyring; long err;
ctx->iterator = keyring_search_iterator; ctx->possessed = is_key_possessed(keyring_ref); ctx->result = ERR_PTR(-EAGAIN);
keyring = key_ref_to_ptr(keyring_ref); key_check(keyring);
if (keyring->type != &key_type_keyring) return ERR_PTR(-ENOTDIR);
if (!(ctx->flags & KEYRING_SEARCH_NO_CHECK_PERM)) { err = key_task_permission(keyring_ref, ctx->cred, KEY_NEED_SEARCH); if (err < 0) return ERR_PTR(err); }
ctx->now = ktime_get_real_seconds(); if (search_nested_keyrings(keyring, ctx)) __key_get(key_ref_to_ptr(ctx->result)); return ctx->result;}
/** * keyring_search - Search the supplied keyring tree for a matching key * @keyring: The root of the keyring tree to be searched. * @type: The type of keyring we want to find. * @description: The name of the keyring we want to find. * @recurse: True to search the children of @keyring also * * As keyring_search_rcu() above, but using the current task's credentials and * type's default matching function and preferred search method. */key_ref_t keyring_search(key_ref_t keyring, struct key_type *type, const char *description, bool recurse){ struct keyring_search_context ctx = { .index_key.type = type, .index_key.description = description, .index_key.desc_len = strlen(description), .cred = current_cred(), .match_data.cmp = key_default_cmp, .match_data.raw_data = description, .match_data.lookup_type = KEYRING_SEARCH_LOOKUP_DIRECT, .flags = KEYRING_SEARCH_DO_STATE_CHECK, }; key_ref_t key; int ret;
if (recurse) ctx.flags |= KEYRING_SEARCH_RECURSE; if (type->match_preparse) { ret = type->match_preparse(&ctx.match_data); if (ret < 0) return ERR_PTR(ret); }
rcu_read_lock(); key = keyring_search_rcu(keyring, &ctx); rcu_read_unlock();
if (type->match_free) type->match_free(&ctx.match_data); return key;}EXPORT_SYMBOL(keyring_search);
static struct key_restriction *keyring_restriction_alloc( key_restrict_link_func_t check){ struct key_restriction *keyres = kzalloc_obj(struct key_restriction);
if (!keyres) return ERR_PTR(-ENOMEM);
keyres->check = check;
return keyres;}
/* * Semaphore to serialise restriction setup to prevent reference count * cycles through restriction key pointers. */static DECLARE_RWSEM(keyring_serialise_restrict_sem);
/* * Check for restriction cycles that would prevent keyring garbage collection. * keyring_serialise_restrict_sem must be held. */static bool keyring_detect_restriction_cycle(const struct key *dest_keyring, struct key_restriction *keyres){ while (keyres && keyres->key && keyres->key->type == &key_type_keyring) { if (keyres->key == dest_keyring) return true;
keyres = keyres->key->restrict_link; }
return false;}
/** * keyring_restrict - Look up and apply a restriction to a keyring * @keyring_ref: The keyring to be restricted * @type: The key type that will provide the restriction checker. * @restriction: The restriction options to apply to the keyring * * Look up a keyring and apply a restriction to it. The restriction is managed * by the specific key type, but can be configured by the options specified in * the restriction string. */int keyring_restrict(key_ref_t keyring_ref, const char *type, const char *restriction){ struct key *keyring; struct key_type *restrict_type = NULL; struct key_restriction *restrict_link; int ret = 0;
keyring = key_ref_to_ptr(keyring_ref); key_check(keyring);
if (keyring->type != &key_type_keyring) return -ENOTDIR;
if (!type) { restrict_link = keyring_restriction_alloc(restrict_link_reject); } else { restrict_type = key_type_lookup(type);
if (IS_ERR(restrict_type)) return PTR_ERR(restrict_type);
if (!restrict_type->lookup_restriction) { ret = -ENOENT; goto error; }
restrict_link = restrict_type->lookup_restriction(restriction); }
if (IS_ERR(restrict_link)) { ret = PTR_ERR(restrict_link); goto error; }
down_write(&keyring->sem); down_write(&keyring_serialise_restrict_sem);
if (keyring->restrict_link) { ret = -EEXIST; } else if (keyring_detect_restriction_cycle(keyring, restrict_link)) { ret = -EDEADLK; } else { keyring->restrict_link = restrict_link; notify_key(keyring, NOTIFY_KEY_SETATTR, 0); }
up_write(&keyring_serialise_restrict_sem); up_write(&keyring->sem);
if (ret < 0) { key_put(restrict_link->key); kfree(restrict_link); }
error: if (restrict_type) key_type_put(restrict_type);
return ret;}EXPORT_SYMBOL(keyring_restrict);
/* * Search the given keyring for a key that might be updated. * * The caller must guarantee that the keyring is a keyring and that the * permission is granted to modify the keyring as no check is made here. The * caller must also hold a lock on the keyring semaphore. * * Returns a pointer to the found key with usage count incremented if * successful and returns NULL if not found. Revoked and invalidated keys are * skipped over. * * If successful, the possession indicator is propagated from the keyring ref * to the returned key reference. */key_ref_t find_key_to_update(key_ref_t keyring_ref, const struct keyring_index_key *index_key){ struct key *keyring, *key; const void *object;
keyring = key_ref_to_ptr(keyring_ref);
kenter("{%d},{%s,%s}", keyring->serial, index_key->type->name, index_key->description);
guard(rcu)(); object = assoc_array_find(&keyring->keys, &keyring_assoc_array_ops, index_key);
if (object) goto found;
kleave(" = NULL"); return NULL;
found: key = keyring_ptr_to_key(object); if (key->flags & ((1 << KEY_FLAG_INVALIDATED) | (1 << KEY_FLAG_REVOKED))) { kleave(" = NULL [x]"); return NULL; } __key_get(key); kleave(" = {%d}", key->serial); return make_key_ref(key, is_key_possessed(keyring_ref));}
/* * Find a keyring with the specified name. * * Only keyrings that have nonzero refcount, are not revoked, and are owned by a * user in the current user namespace are considered. If @uid_keyring is %true, * the keyring additionally must have been allocated as a user or user session * keyring; otherwise, it must grant Search permission directly to the caller. * * Returns a pointer to the keyring with the keyring's refcount having being * incremented on success. -ENOKEY is returned if a key could not be found. */struct key *find_keyring_by_name(const char *name, bool uid_keyring){ struct user_namespace *ns = current_user_ns(); struct key *keyring;
if (!name) return ERR_PTR(-EINVAL);
read_lock(&keyring_name_lock);
/* Search this hash bucket for a keyring with a matching name that * grants Search permission and that hasn't been revoked */ list_for_each_entry(keyring, &ns->keyring_name_list, name_link) { if (!kuid_has_mapping(ns, keyring->uid)) continue;
if (test_bit(KEY_FLAG_REVOKED, &keyring->flags)) continue;
if (strcmp(keyring->description, name) != 0) continue;
if (uid_keyring) { if (!test_bit(KEY_FLAG_UID_KEYRING, &keyring->flags)) continue; } else { if (key_permission(make_key_ref(keyring, 0), KEY_NEED_SEARCH) < 0) continue; }
/* we've got a match but we might end up racing with * key_cleanup() if the keyring is currently 'dead' * (ie. it has a zero usage count) */ if (!refcount_inc_not_zero(&keyring->usage)) continue; keyring->last_used_at = ktime_get_real_seconds(); goto out; }
keyring = ERR_PTR(-ENOKEY);out: read_unlock(&keyring_name_lock); return keyring;}
static int keyring_detect_cycle_iterator(const void *object, void *iterator_data){ struct keyring_search_context *ctx = iterator_data; const struct key *key = keyring_ptr_to_key(object);
kenter("{%d}", key->serial);
/* We might get a keyring with matching index-key that is nonetheless a * different keyring. */ if (key != ctx->match_data.raw_data) return 0;
ctx->result = ERR_PTR(-EDEADLK); return 1;}
/* * See if a cycle will be created by inserting acyclic tree B in acyclic * tree A at the topmost level (ie: as a direct child of A). * * Since we are adding B to A at the top level, checking for cycles should just * be a matter of seeing if node A is somewhere in tree B. */static int keyring_detect_cycle(struct key *A, struct key *B){ struct keyring_search_context ctx = { .index_key = A->index_key, .match_data.raw_data = A, .match_data.lookup_type = KEYRING_SEARCH_LOOKUP_DIRECT, .iterator = keyring_detect_cycle_iterator, .flags = (KEYRING_SEARCH_NO_STATE_CHECK | KEYRING_SEARCH_NO_UPDATE_TIME | KEYRING_SEARCH_NO_CHECK_PERM | KEYRING_SEARCH_DETECT_TOO_DEEP | KEYRING_SEARCH_RECURSE), };
rcu_read_lock(); search_nested_keyrings(B, &ctx); rcu_read_unlock(); return PTR_ERR(ctx.result) == -EAGAIN ? 0 : PTR_ERR(ctx.result);}
/* * Lock keyring for link. */int __key_link_lock(struct key *keyring, const struct keyring_index_key *index_key) __acquires(&keyring->sem) __acquires(&keyring_serialise_link_lock){ if (keyring->type != &key_type_keyring) return -ENOTDIR;
down_write(&keyring->sem);
/* Serialise link/link calls to prevent parallel calls causing a cycle * when linking two keyring in opposite orders. */ if (index_key->type == &key_type_keyring) mutex_lock(&keyring_serialise_link_lock);
return 0;}
/* * Lock keyrings for move (link/unlink combination). */int __key_move_lock(struct key *l_keyring, struct key *u_keyring, const struct keyring_index_key *index_key) __acquires(&l_keyring->sem) __acquires(&u_keyring->sem) __acquires(&keyring_serialise_link_lock){ if (l_keyring->type != &key_type_keyring || u_keyring->type != &key_type_keyring) return -ENOTDIR;
/* We have to be very careful here to take the keyring locks in the * right order, lest we open ourselves to deadlocking against another * move operation. */ if (l_keyring < u_keyring) { down_write(&l_keyring->sem); down_write_nested(&u_keyring->sem, 1); } else { down_write(&u_keyring->sem); down_write_nested(&l_keyring->sem, 1); }
/* Serialise link/link calls to prevent parallel calls causing a cycle * when linking two keyring in opposite orders. */ if (index_key->type == &key_type_keyring) mutex_lock(&keyring_serialise_link_lock);
return 0;}
/* * Preallocate memory so that a key can be linked into to a keyring. */int __key_link_begin(struct key *keyring, const struct keyring_index_key *index_key, struct assoc_array_edit **_edit){ struct assoc_array_edit *edit; int ret;
kenter("%d,%s,%s,", keyring->serial, index_key->type->name, index_key->description);
BUG_ON(index_key->desc_len == 0); BUG_ON(*_edit != NULL);
*_edit = NULL;
ret = -EKEYREVOKED; if (test_bit(KEY_FLAG_REVOKED, &keyring->flags)) goto error;
/* Create an edit script that will insert/replace the key in the * keyring tree. */ edit = assoc_array_insert(&keyring->keys, &keyring_assoc_array_ops, index_key, NULL); if (IS_ERR(edit)) { ret = PTR_ERR(edit); goto error; }
/* If we're not replacing a link in-place then we're going to need some * extra quota. */ if (!edit->dead_leaf) { ret = key_payload_reserve(keyring, keyring->datalen + KEYQUOTA_LINK_BYTES); if (ret < 0) goto error_cancel; }
*_edit = edit; kleave(" = 0"); return 0;
error_cancel: assoc_array_cancel_edit(edit);error: kleave(" = %d", ret); return ret;}
/* * Check already instantiated keys aren't going to be a problem. * * The caller must have called __key_link_begin(). Don't need to call this for * keys that were created since __key_link_begin() was called. */int __key_link_check_live_key(struct key *keyring, struct key *key){ if (key->type == &key_type_keyring) /* check that we aren't going to create a cycle by linking one * keyring to another */ return keyring_detect_cycle(keyring, key); return 0;}
/* * Link a key into to a keyring. * * Must be called with __key_link_begin() having being called. Discards any * already extant link to matching key if there is one, so that each keyring * holds at most one link to any given key of a particular type+description * combination. */void __key_link(struct key *keyring, struct key *key, struct assoc_array_edit **_edit){ __key_get(key); assoc_array_insert_set_object(*_edit, keyring_key_to_ptr(key)); assoc_array_apply_edit(*_edit); *_edit = NULL; notify_key(keyring, NOTIFY_KEY_LINKED, key_serial(key));}
/* * Finish linking a key into to a keyring. * * Must be called with __key_link_begin() having being called. */void __key_link_end(struct key *keyring, const struct keyring_index_key *index_key, struct assoc_array_edit *edit) __releases(&keyring->sem) __releases(&keyring_serialise_link_lock){ BUG_ON(index_key->type == NULL); kenter("%d,%s,", keyring->serial, index_key->type->name);
if (edit) { if (!edit->dead_leaf) { key_payload_reserve(keyring, keyring->datalen - KEYQUOTA_LINK_BYTES); } assoc_array_cancel_edit(edit); } up_write(&keyring->sem);
if (index_key->type == &key_type_keyring) mutex_unlock(&keyring_serialise_link_lock);}
/* * Check addition of keys to restricted keyrings. */static int __key_link_check_restriction(struct key *keyring, struct key *key){ if (!keyring->restrict_link || !keyring->restrict_link->check) return 0; return keyring->restrict_link->check(keyring, key->type, &key->payload, keyring->restrict_link->key);}
/** * key_link - Link a key to a keyring * @keyring: The keyring to make the link in. * @key: The key to link to. * * Make a link in a keyring to a key, such that the keyring holds a reference * on that key and the key can potentially be found by searching that keyring. * * This function will write-lock the keyring's semaphore and will consume some * of the user's key data quota to hold the link. * * Returns 0 if successful, -ENOTDIR if the keyring isn't a keyring, * -EKEYREVOKED if the keyring has been revoked, -ENFILE if the keyring is * full, -EDQUOT if there is insufficient key data quota remaining to add * another link or -ENOMEM if there's insufficient memory. * * It is assumed that the caller has checked that it is permitted for a link to * be made (the keyring should have Write permission and the key Link * permission). */int key_link(struct key *keyring, struct key *key){ struct assoc_array_edit *edit = NULL; int ret;
kenter("{%d,%d}", keyring->serial, refcount_read(&keyring->usage));
key_check(keyring); key_check(key);
ret = __key_link_lock(keyring, &key->index_key); if (ret < 0) goto error;
ret = __key_link_begin(keyring, &key->index_key, &edit); if (ret < 0) goto error_end;
kdebug("begun {%d,%d}", keyring->serial, refcount_read(&keyring->usage)); ret = __key_link_check_restriction(keyring, key); if (ret == 0) ret = __key_link_check_live_key(keyring, key); if (ret == 0) __key_link(keyring, key, &edit);
error_end: __key_link_end(keyring, &key->index_key, edit);error: kleave(" = %d {%d,%d}", ret, keyring->serial, refcount_read(&keyring->usage)); return ret;}EXPORT_SYMBOL(key_link);
/* * Lock a keyring for unlink. */static int __key_unlink_lock(struct key *keyring) __acquires(&keyring->sem){ if (keyring->type != &key_type_keyring) return -ENOTDIR;
down_write(&keyring->sem); return 0;}
/* * Begin the process of unlinking a key from a keyring. */static int __key_unlink_begin(struct key *keyring, struct key *key, struct assoc_array_edit **_edit){ struct assoc_array_edit *edit;
BUG_ON(*_edit != NULL);
edit = assoc_array_delete(&keyring->keys, &keyring_assoc_array_ops, &key->index_key); if (IS_ERR(edit)) return PTR_ERR(edit);
if (!edit) return -ENOENT;
*_edit = edit; return 0;}
/* * Apply an unlink change. */static void __key_unlink(struct key *keyring, struct key *key, struct assoc_array_edit **_edit){ assoc_array_apply_edit(*_edit); notify_key(keyring, NOTIFY_KEY_UNLINKED, key_serial(key)); *_edit = NULL; key_payload_reserve(keyring, keyring->datalen - KEYQUOTA_LINK_BYTES);}
/* * Finish unlinking a key from to a keyring. */static void __key_unlink_end(struct key *keyring, struct key *key, struct assoc_array_edit *edit) __releases(&keyring->sem){ if (edit) assoc_array_cancel_edit(edit); up_write(&keyring->sem);}
/** * key_unlink - Unlink the first link to a key from a keyring. * @keyring: The keyring to remove the link from. * @key: The key the link is to. * * Remove a link from a keyring to a key. * * This function will write-lock the keyring's semaphore. * * Returns 0 if successful, -ENOTDIR if the keyring isn't a keyring, -ENOENT if * the key isn't linked to by the keyring or -ENOMEM if there's insufficient * memory. * * It is assumed that the caller has checked that it is permitted for a link to * be removed (the keyring should have Write permission; no permissions are * required on the key). */int key_unlink(struct key *keyring, struct key *key){ struct assoc_array_edit *edit = NULL; int ret;
key_check(keyring); key_check(key);
ret = __key_unlink_lock(keyring); if (ret < 0) return ret;
ret = __key_unlink_begin(keyring, key, &edit); if (ret == 0) __key_unlink(keyring, key, &edit); __key_unlink_end(keyring, key, edit); return ret;}EXPORT_SYMBOL(key_unlink);
/** * key_move - Move a key from one keyring to another * @key: The key to move * @from_keyring: The keyring to remove the link from. * @to_keyring: The keyring to make the link in. * @flags: Qualifying flags, such as KEYCTL_MOVE_EXCL. * * Make a link in @to_keyring to a key, such that the keyring holds a reference * on that key and the key can potentially be found by searching that keyring * whilst simultaneously removing a link to the key from @from_keyring. * * This function will write-lock both keyring's semaphores and will consume * some of the user's key data quota to hold the link on @to_keyring. * * Returns 0 if successful, -ENOTDIR if either keyring isn't a keyring, * -EKEYREVOKED if either keyring has been revoked, -ENFILE if the second * keyring is full, -EDQUOT if there is insufficient key data quota remaining * to add another link or -ENOMEM if there's insufficient memory. If * KEYCTL_MOVE_EXCL is set, then -EEXIST will be returned if there's already a * matching key in @to_keyring. * * It is assumed that the caller has checked that it is permitted for a link to * be made (the keyring should have Write permission and the key Link * permission). */int key_move(struct key *key, struct key *from_keyring, struct key *to_keyring, unsigned int flags){ struct assoc_array_edit *from_edit = NULL, *to_edit = NULL; int ret;
kenter("%d,%d,%d", key->serial, from_keyring->serial, to_keyring->serial);
if (from_keyring == to_keyring) return 0;
key_check(key); key_check(from_keyring); key_check(to_keyring);
ret = __key_move_lock(from_keyring, to_keyring, &key->index_key); if (ret < 0) goto out; ret = __key_unlink_begin(from_keyring, key, &from_edit); if (ret < 0) goto error; ret = __key_link_begin(to_keyring, &key->index_key, &to_edit); if (ret < 0) goto error;
ret = -EEXIST; if (to_edit->dead_leaf && (flags & KEYCTL_MOVE_EXCL)) goto error;
ret = __key_link_check_restriction(to_keyring, key); if (ret < 0) goto error; ret = __key_link_check_live_key(to_keyring, key); if (ret < 0) goto error;
__key_unlink(from_keyring, key, &from_edit); __key_link(to_keyring, key, &to_edit);error: __key_link_end(to_keyring, &key->index_key, to_edit); __key_unlink_end(from_keyring, key, from_edit);out: kleave(" = %d", ret); return ret;}EXPORT_SYMBOL(key_move);
/** * keyring_clear - Clear a keyring * @keyring: The keyring to clear. * * Clear the contents of the specified keyring. * * Returns 0 if successful or -ENOTDIR if the keyring isn't a keyring. */int keyring_clear(struct key *keyring){ struct assoc_array_edit *edit; int ret;
if (keyring->type != &key_type_keyring) return -ENOTDIR;
down_write(&keyring->sem);
edit = assoc_array_clear(&keyring->keys, &keyring_assoc_array_ops); if (IS_ERR(edit)) { ret = PTR_ERR(edit); } else { if (edit) assoc_array_apply_edit(edit); notify_key(keyring, NOTIFY_KEY_CLEARED, 0); key_payload_reserve(keyring, 0); ret = 0; }
up_write(&keyring->sem); return ret;}EXPORT_SYMBOL(keyring_clear);
/* * Dispose of the links from a revoked keyring. * * This is called with the key sem write-locked. */static void keyring_revoke(struct key *keyring){ struct assoc_array_edit *edit;
edit = assoc_array_clear(&keyring->keys, &keyring_assoc_array_ops); if (!IS_ERR(edit)) { if (edit) assoc_array_apply_edit(edit); key_payload_reserve(keyring, 0); }}
static bool keyring_gc_select_iterator(void *object, void *iterator_data){ struct key *key = keyring_ptr_to_key(object); time64_t *limit = iterator_data;
if (key_is_dead(key, *limit)) return false; key_get(key); return true;}
static int keyring_gc_check_iterator(const void *object, void *iterator_data){ const struct key *key = keyring_ptr_to_key(object); time64_t *limit = iterator_data;
key_check(key); return key_is_dead(key, *limit);}
/* * Garbage collect pointers from a keyring. * * Not called with any locks held. The keyring's key struct will not be * deallocated under us as only our caller may deallocate it. */void keyring_gc(struct key *keyring, time64_t limit){ int result;
kenter("%x{%s}", keyring->serial, keyring->description ?: "");
if (keyring->flags & ((1 << KEY_FLAG_INVALIDATED) | (1 << KEY_FLAG_REVOKED))) goto dont_gc;
/* scan the keyring looking for dead keys */ rcu_read_lock(); result = assoc_array_iterate(&keyring->keys, keyring_gc_check_iterator, &limit); rcu_read_unlock(); if (result == true) goto do_gc;
dont_gc: kleave(" [no gc]"); return;
do_gc: down_write(&keyring->sem); assoc_array_gc(&keyring->keys, &keyring_assoc_array_ops, keyring_gc_select_iterator, &limit); up_write(&keyring->sem); kleave(" [gc]");}
/* * Garbage collect restriction pointers from a keyring. * * Keyring restrictions are associated with a key type, and must be cleaned * up if the key type is unregistered. The restriction is altered to always * reject additional keys so a keyring cannot be opened up by unregistering * a key type. * * Not called with any keyring locks held. The keyring's key struct will not * be deallocated under us as only our caller may deallocate it. * * The caller is required to hold key_types_sem and dead_type->sem. This is * fulfilled by key_gc_keytype() holding the locks on behalf of * key_garbage_collector(), which it invokes on a workqueue. */void keyring_restriction_gc(struct key *keyring, struct key_type *dead_type){ struct key_restriction *keyres;
kenter("%x{%s}", keyring->serial, keyring->description ?: "");
/* * keyring->restrict_link is only assigned at key allocation time * or with the key type locked, so the only values that could be * concurrently assigned to keyring->restrict_link are for key * types other than dead_type. Given this, it's ok to check * the key type before acquiring keyring->sem. */ if (!dead_type || !keyring->restrict_link || keyring->restrict_link->keytype != dead_type) { kleave(" [no restriction gc]"); return; }
/* Lock the keyring to ensure that a link is not in progress */ down_write(&keyring->sem);
keyres = keyring->restrict_link;
keyres->check = restrict_link_reject;
key_put(keyres->key); keyres->key = NULL; keyres->keytype = NULL;
up_write(&keyring->sem);
kleave(" [restriction gc]");}