Lines Matching refs:key
11 - Asymmetric key subtypes.
19 The "asymmetric" key type is designed to be a container for the keys used in
20 public-key cryptography, without imposing any particular restrictions on the
21 form or mechanism of the cryptography or form of the key.
23 The asymmetric key is given a subtype that defines what sort of data is
24 associated with the key and provides operations to describe and destroy it.
25 However, no requirement is made that the key data actually be stored in the
26 key.
28 A completely in-kernel key retention and operation subtype can be defined, but
30 a TPM) that might be used to both retain the relevant key and perform
31 operations using that key. In such a case, the asymmetric key would then
37 subtype of the key and define the operations that can be done on that key.
40 key, or it may interpret it as a reference to a key held somewhere else in the
48 If a key is added with an empty name, the instantiation data parsers are given
49 the opportunity to pre-parse a key and to determine the description the key
50 should be given from the content of the key.
52 This can then be used to refer to the key, either by complete match or by
53 partial match. The key type may also use other criteria to refer to a key.
55 The asymmetric key type's match function can then perform a wider range of
60 function will examine a key's fingerprint to see if the hex digits given
65 will match a key with fingerprint:
76 Looking in /proc/keys, the last 8 hex digits of the key fingerprint are
92 Three enums are defined there for representing public-key cryptography
101 and key identifier representations:
105 Note that the key type representation types are required because key
107 instance, PGP generates key identifiers by hashing the key data plus some
110 The operations defined upon a key are:
114 Other operations are possible (such as encryption) with the same key data
116 (eg. decryption and signature generation) require extra key data.
123 an asymmetric key to provide or to provide access to the public key.
125 int verify_signature(const struct key *key,
128 The caller must have already obtained the key from some source and can then use
154 The function may also return -ENOTSUPP if an unsupported public-key algorithm
155 or public-key/hash algorithm combination is specified or the key doesn't
158 if the key argument is the wrong type or is incompletely set up.
166 performed on that key and that determines what data is attached as the key
169 The subtype is selected by the key data parser and the parser must initialise
170 the data required for it. The asymmetric key retains a reference on the
183 void (*describe)(const struct key *key, struct seq_file *m);
185 int (*verify_signature)(const struct key *key,
199 against the key. For instance the name of the public key algorithm type
200 could be displayed. The key type will display the tail of the key
205 Mandatory. This should free the memory associated with the key. The
206 asymmetric key will look after freeing the fingerprint and releasing the
211 Optional. These are the entry points for the key usage operations.
221 The asymmetric key type doesn't generally want to store or to deal with a raw
222 blob of data that holds the key data. It would have to parse it and error
225 dates) and may contain useful data about the key (identifiers, capabilities).
227 Also, the blob may represent a pointer to some hardware containing the key
228 rather than the key itself.
234 - Pointer to TPM key.
235 - Pointer to UEFI key.
237 During key instantiation each parser in the list is tried until one doesn't
261 This is called to preparse the key from the key creation and update paths.
262 In particular, it is called during the key creation _before_ a key is
263 allocated, and as such, is permitted to provide the key's description in
285 the key and attach it to ->description, ->payload[asym_subtype] should be
289 quotalen should be updated to indicate how much quota this key should
300 is recognised, but the key cannot for some reason be set up, some other
303 The key's fingerprint string may be partially matched upon. For a
304 public-key algorithm such as RSA and DSA this will likely be a printable
305 hex version of the key's fingerprint.