Файловый менеджер

Файловый менеджер - Редактировать - /var/www/xthruster/html/wp-content/uploads/flags/keys.tar

Назад
asymmetric-type.h��0000644��00000005247�14722070436�0010066 0��ustar�00��/* SPDX-License-Identifier: GPL-2.0-or-later / / Asymmetric Public-key cryptography key type interface * * See Documentation/crypto/asymmetric-keys.txt * * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) / #ifndef _KEYS_ASYMMETRIC_TYPE_H #define _KEYS_ASYMMETRIC_TYPE_H #include <linux/key-type.h> #include <linux/verification.h> extern struct key_type key_type_asymmetric; / * The key payload is four words. The asymmetric-type key uses them as * follows: / enum asymmetric_payload_bits { asym_crypto, / The data representing the key / asym_subtype, / Pointer to an asymmetric_key_subtype struct / asym_key_ids, / Pointer to an asymmetric_key_ids struct / asym_auth / The key's authorisation (signature, parent key ID) / }; / * Identifiers for an asymmetric key ID. We have three ways of looking up a * key derived from an X.509 certificate: * * (1) Serial Number & Issuer. Non-optional. This is the only valid way to * map a PKCS#7 signature to an X.509 certificate. * * (2) Issuer & Subject Unique IDs. Optional. These were the original way to * match X.509 certificates, but have fallen into disuse in favour of (3). * * (3) Auth & Subject Key Identifiers. Optional. SKIDs are only provided on * CA keys that are intended to sign other keys, so don't appear in end * user certificates unless forced. * * We could also support an PGP key identifier, which is just a SHA1 sum of the * public key and certain parameters, but since we don't support PGP keys at * the moment, we shall ignore those. * * What we actually do is provide a place where binary identifiers can be * stashed and then compare against them when checking for an id match. / struct asymmetric_key_id { unsigned short len; unsigned char data[]; }; struct asymmetric_key_ids { void id[2]; }; extern bool asymmetric_key_id_same(const struct asymmetric_key_id kid1, const struct asymmetric_key_id kid2); extern bool asymmetric_key_id_partial(const struct asymmetric_key_id kid1, const struct asymmetric_key_id kid2); extern struct asymmetric_key_id asymmetric_key_generate_id(const void val_1, size_t len_1, const void val_2, size_t len_2); static inline const struct asymmetric_key_ids asymmetric_key_ids(const struct key key) { return key->payload.data[asym_key_ids]; } extern struct key find_asymmetric_key(struct key keyring, const struct asymmetric_key_id id_0, const struct asymmetric_key_id id_1, bool partial); / * The payload is at the discretion of the subtype. / #endif / _KEYS_ASYMMETRIC_TYPE_H / ��keyring-type.h��0000644��00000000521�14722070436�0007347 0��ustar�00��/ SPDX-License-Identifier: GPL-2.0-or-later / / Keyring key type * * Copyright (C) 2008, 2013 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) / #ifndef _KEYS_KEYRING_TYPE_H #define _KEYS_KEYRING_TYPE_H #include <linux/key.h> #include <linux/assoc_array.h> #endif / _KEYS_KEYRING_TYPE_H / ��asymmetric-subtype.h��0000644��00000003240�14722070436�0010567 0��ustar�00��/ SPDX-License-Identifier: GPL-2.0-or-later / / Asymmetric public-key cryptography key subtype * * See Documentation/crypto/asymmetric-keys.txt * * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) / #ifndef _KEYS_ASYMMETRIC_SUBTYPE_H #define _KEYS_ASYMMETRIC_SUBTYPE_H #include <linux/seq_file.h> #include <keys/asymmetric-type.h> struct kernel_pkey_query; struct kernel_pkey_params; struct public_key_signature; / * Keys of this type declare a subtype that indicates the handlers and * capabilities. / struct asymmetric_key_subtype { struct module owner; const char name; unsigned short name_len; / length of name / / Describe a key of this subtype for /proc/keys / void (describe)(const struct key key, struct seq_file m); /* Destroy a key of this subtype / void (destroy)(void payload_crypto, void payload_auth); int (query)(const struct kernel_pkey_params params, struct kernel_pkey_query info); / Encrypt/decrypt/sign data / int (eds_op)(struct kernel_pkey_params params, const void in, void out); / Verify the signature on a key of this subtype (optional) / int (verify_signature)(const struct key key, const struct public_key_signature sig); }; /** * asymmetric_key_subtype - Get the subtype from an asymmetric key * @key: The key of interest. * * Retrieves and returns the subtype pointer of the asymmetric key from the * type-specific data attached to the key. / static inline struct asymmetric_key_subtype asymmetric_key_subtype(const struct key key) { return key->payload.data[asym_subtype]; } #endif / _KEYS_ASYMMETRIC_SUBTYPE_H / ��system_keyring.h��0000644��00000004504�14722070436�0010001 0��ustar�00��/ SPDX-License-Identifier: GPL-2.0-or-later / / System keyring containing trusted public keys. * * Copyright (C) 2013 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) / #ifndef _KEYS_SYSTEM_KEYRING_H #define _KEYS_SYSTEM_KEYRING_H #include <linux/key.h> #ifdef CONFIG_SYSTEM_TRUSTED_KEYRING extern int restrict_link_by_builtin_trusted(struct key keyring, const struct key_type type, const union key_payload payload, struct key restriction_key); #else #define restrict_link_by_builtin_trusted restrict_link_reject #endif #ifdef CONFIG_SECONDARY_TRUSTED_KEYRING extern int restrict_link_by_builtin_and_secondary_trusted( struct key keyring, const struct key_type type, const union key_payload payload, struct key restriction_key); #else #define restrict_link_by_builtin_and_secondary_trusted restrict_link_by_builtin_trusted #endif extern struct pkcs7_message pkcs7; #ifdef CONFIG_SYSTEM_BLACKLIST_KEYRING extern int mark_hash_blacklisted(const char hash); extern int is_hash_blacklisted(const u8 hash, size_t hash_len, const char type); extern int is_binary_blacklisted(const u8 hash, size_t hash_len); #else static inline int is_hash_blacklisted(const u8 hash, size_t hash_len, const char type) { return 0; } static inline int is_binary_blacklisted(const u8 hash, size_t hash_len) { return 0; } #endif #ifdef CONFIG_SYSTEM_REVOCATION_LIST extern int add_key_to_revocation_list(const char data, size_t size); extern int is_key_on_revocation_list(struct pkcs7_message pkcs7); #else static inline int add_key_to_revocation_list(const char data, size_t size) { return 0; } static inline int is_key_on_revocation_list(struct pkcs7_message pkcs7) { return -ENOKEY; } #endif #ifdef CONFIG_IMA_BLACKLIST_KEYRING extern struct key ima_blacklist_keyring; static inline struct key get_ima_blacklist_keyring(void) { return ima_blacklist_keyring; } #else static inline struct key get_ima_blacklist_keyring(void) { return NULL; } #endif /* CONFIG_IMA_BLACKLIST_KEYRING / #if defined(CONFIG_INTEGRITY_PLATFORM_KEYRING) && \ defined(CONFIG_SYSTEM_TRUSTED_KEYRING) extern void __init set_platform_trusted_keys(struct key keyring); #else static inline void set_platform_trusted_keys(struct key keyring) { } #endif #endif / _KEYS_SYSTEM_KEYRING_H / ��trusted-type.h��0000644��00000002016�14722070436�0007372 0��ustar�00��/ SPDX-License-Identifier: GPL-2.0-only / / * Copyright (C) 2010 IBM Corporation * Author: David Safford <safford@us.ibm.com> / #ifndef _KEYS_TRUSTED_TYPE_H #define _KEYS_TRUSTED_TYPE_H #include <linux/key.h> #include <linux/rcupdate.h> #include <linux/tpm.h> #define MIN_KEY_SIZE 32 #define MAX_KEY_SIZE 128 #define MAX_BLOB_SIZE 512 #define MAX_PCRINFO_SIZE 64 #define MAX_DIGEST_SIZE 64 struct trusted_key_payload { struct rcu_head rcu; unsigned int key_len; unsigned int blob_len; unsigned char migratable; unsigned char key[MAX_KEY_SIZE + 1]; unsigned char blob[MAX_BLOB_SIZE]; }; struct trusted_key_options { uint16_t keytype; uint32_t keyhandle; unsigned char keyauth[TPM_DIGEST_SIZE]; unsigned char blobauth[TPM_DIGEST_SIZE]; uint32_t pcrinfo_len; unsigned char pcrinfo[MAX_PCRINFO_SIZE]; int pcrlock; uint32_t hash; uint32_t policydigest_len; unsigned char policydigest[MAX_DIGEST_SIZE]; uint32_t policyhandle; }; extern struct key_type key_type_trusted; #endif / _KEYS_TRUSTED_TYPE_H / ��request_key_auth-type.h��0000644��00000001353�14722070436�0011264 0��ustar�00��/ SPDX-License-Identifier: GPL-2.0-or-later / / request_key authorisation token key type * * Copyright (C) 2005 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) / #ifndef _KEYS_REQUEST_KEY_AUTH_TYPE_H #define _KEYS_REQUEST_KEY_AUTH_TYPE_H #include <linux/key.h> / * Authorisation record for request_key(). / struct request_key_auth { struct rcu_head rcu; struct key target_key; struct key dest_keyring; const struct cred cred; void callout_info; size_t callout_len; pid_t pid; char op[8]; } __randomize_layout; static inline struct request_key_auth get_request_key_auth(const struct key key) { return key->payload.data[0]; } #endif / _KEYS_REQUEST_KEY_AUTH_TYPE_H / ��trusted.h��0000644��00000007215�14722070436�0006421 0��ustar�00��/ SPDX-License-Identifier: GPL-2.0 / #ifndef __TRUSTED_KEY_H #define __TRUSTED_KEY_H / implementation specific TPM constants / #define MAX_BUF_SIZE 1024 #define TPM_GETRANDOM_SIZE 14 #define TPM_OSAP_SIZE 36 #define TPM_OIAP_SIZE 10 #define TPM_SEAL_SIZE 87 #define TPM_UNSEAL_SIZE 104 #define TPM_SIZE_OFFSET 2 #define TPM_RETURN_OFFSET 6 #define TPM_DATA_OFFSET 10 #define LOAD32(buffer, offset) (ntohl((uint32_t )&buffer[offset])) #define LOAD32N(buffer, offset) ((uint32_t )&buffer[offset]) #define LOAD16(buffer, offset) (ntohs((uint16_t )&buffer[offset])) struct tpm_buf { int len; unsigned char data[MAX_BUF_SIZE]; }; #define INIT_BUF(tb) (tb->len = 0) struct osapsess { uint32_t handle; unsigned char secret[SHA1_DIGEST_SIZE]; unsigned char enonce[TPM_NONCE_SIZE]; }; / discrete values, but have to store in uint16_t for TPM use / enum { SEAL_keytype = 1, SRK_keytype = 4 }; int TSS_authhmac(unsigned char digest, const unsigned char key, unsigned int keylen, unsigned char h1, unsigned char h2, unsigned int h3, ...); int TSS_checkhmac1(unsigned char buffer, const uint32_t command, const unsigned char ononce, const unsigned char key, unsigned int keylen, ...); int trusted_tpm_send(unsigned char cmd, size_t buflen); int oiap(struct tpm_buf tb, uint32_t handle, unsigned char nonce); #define TPM_DEBUG 0 #if TPM_DEBUG static inline void dump_options(struct trusted_key_options o) { pr_info("trusted_key: sealing key type %d\n", o->keytype); pr_info("trusted_key: sealing key handle %0X\n", o->keyhandle); pr_info("trusted_key: pcrlock %d\n", o->pcrlock); pr_info("trusted_key: pcrinfo %d\n", o->pcrinfo_len); print_hex_dump(KERN_INFO, "pcrinfo ", DUMP_PREFIX_NONE, 16, 1, o->pcrinfo, o->pcrinfo_len, 0); } static inline void dump_payload(struct trusted_key_payload p) { pr_info("trusted_key: key_len %d\n", p->key_len); print_hex_dump(KERN_INFO, "key ", DUMP_PREFIX_NONE, 16, 1, p->key, p->key_len, 0); pr_info("trusted_key: bloblen %d\n", p->blob_len); print_hex_dump(KERN_INFO, "blob ", DUMP_PREFIX_NONE, 16, 1, p->blob, p->blob_len, 0); pr_info("trusted_key: migratable %d\n", p->migratable); } static inline void dump_sess(struct osapsess s) { print_hex_dump(KERN_INFO, "trusted-key: handle ", DUMP_PREFIX_NONE, 16, 1, &s->handle, 4, 0); pr_info("trusted-key: secret:\n"); print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 1, &s->secret, SHA1_DIGEST_SIZE, 0); pr_info("trusted-key: enonce:\n"); print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 1, &s->enonce, SHA1_DIGEST_SIZE, 0); } static inline void dump_tpm_buf(unsigned char buf) { int len; pr_info("\ntrusted-key: tpm buffer\n"); len = LOAD32(buf, TPM_SIZE_OFFSET); print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 1, buf, len, 0); } #else static inline void dump_options(struct trusted_key_options o) { } static inline void dump_payload(struct trusted_key_payload p) { } static inline void dump_sess(struct osapsess s) { } static inline void dump_tpm_buf(unsigned char buf) { } #endif static inline void store8(struct tpm_buf buf, const unsigned char value) { buf->data[buf->len++] = value; } static inline void store16(struct tpm_buf buf, const uint16_t value) { (uint16_t ) & buf->data[buf->len] = htons(value); buf->len += sizeof value; } static inline void store32(struct tpm_buf buf, const uint32_t value) { (uint32_t ) & buf->data[buf->len] = htonl(value); buf->len += sizeof value; } static inline void storebytes(struct tpm_buf buf, const unsigned char in, const int len) { memcpy(buf->data + buf->len, in, len); buf->len += len; } #endif ��rxrpc-type.h��0000644��00000010334�14722070436�0007040 0��ustar�00��/ SPDX-License-Identifier: GPL-2.0-or-later / / RxRPC key type * * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) / #ifndef _KEYS_RXRPC_TYPE_H #define _KEYS_RXRPC_TYPE_H #include <linux/key.h> / * key type for AF_RXRPC keys / extern struct key_type key_type_rxrpc; extern struct key rxrpc_get_null_key(const char ); / * RxRPC key for Kerberos IV (type-2 security) / struct rxkad_key { u32 vice_id; u32 start; / time at which ticket starts / u32 expiry; / time at which ticket expires / u32 kvno; / key version number / u8 primary_flag; / T if key for primary cell for this user / u16 ticket_len; / length of ticket[] / u8 session_key[8]; / DES session key / u8 ticket[0]; / the encrypted ticket / }; / * Kerberos 5 principal * name/name/name@realm / struct krb5_principal { u8 n_name_parts; / N of parts of the name part of the principal / char name_parts; / parts of the name part of the principal / char realm; /* parts of the realm part of the principal / }; / * Kerberos 5 tagged data / struct krb5_tagged_data { / for tag value, see /usr/include/krb5/krb5.h * - KRB5_AUTHDATA_* for auth data * - / s32 tag; u32 data_len; u8 data; }; /* * RxRPC key for Kerberos V (type-5 security) / struct rxk5_key { u64 authtime; / time at which auth token generated / u64 starttime; / time at which auth token starts / u64 endtime; / time at which auth token expired / u64 renew_till; / time to which auth token can be renewed / s32 is_skey; / T if ticket is encrypted in another ticket's * skey / s32 flags; / mask of TKT_FLG_* bits (krb5/krb5.h) / struct krb5_principal client; / client principal name / struct krb5_principal server; / server principal name / u16 ticket_len; / length of ticket / u16 ticket2_len; / length of second ticket / u8 n_authdata; / number of authorisation data elements / u8 n_addresses; / number of addresses / struct krb5_tagged_data session; / session data; tag is enctype / struct krb5_tagged_data addresses; /* addresses / u8 ticket; /* krb5 ticket / u8 ticket2; /* second krb5 ticket, if related to ticket (via * DUPLICATE-SKEY or ENC-TKT-IN-SKEY) / struct krb5_tagged_data authdata; /* authorisation data / }; / * list of tokens attached to an rxrpc key / struct rxrpc_key_token { u16 security_index; / RxRPC header security index / struct rxrpc_key_token next; /* the next token in the list / union { struct rxkad_key kad; struct rxk5_key k5; }; }; / * structure of raw payloads passed to add_key() or instantiate key / struct rxrpc_key_data_v1 { u16 security_index; u16 ticket_length; u32 expiry; / time_t / u32 kvno; u8 session_key[8]; u8 ticket[0]; }; / * AF_RXRPC key payload derived from XDR format * - based on openafs-1.4.10/src/auth/afs_token.xg / #define AFSTOKEN_LENGTH_MAX 16384 / max payload size / #define AFSTOKEN_STRING_MAX 256 / max small string length / #define AFSTOKEN_DATA_MAX 64 / max small data length / #define AFSTOKEN_CELL_MAX 64 / max cellname length / #define AFSTOKEN_MAX 8 / max tokens per payload / #define AFSTOKEN_BDATALN_MAX 16384 / max big data length / #define AFSTOKEN_RK_TIX_MAX 12000 / max RxKAD ticket size / #define AFSTOKEN_GK_KEY_MAX 64 / max GSSAPI key size / #define AFSTOKEN_GK_TOKEN_MAX 16384 / max GSSAPI token size / #define AFSTOKEN_K5_COMPONENTS_MAX 16 / max K5 components / #define AFSTOKEN_K5_NAME_MAX 128 / max K5 name length / #define AFSTOKEN_K5_REALM_MAX 64 / max K5 realm name length / #define AFSTOKEN_K5_TIX_MAX 16384 / max K5 ticket size / #define AFSTOKEN_K5_ADDRESSES_MAX 16 / max K5 addresses / #define AFSTOKEN_K5_AUTHDATA_MAX 16 / max K5 pieces of auth data / / * Truncate a time64_t to the range from 1970 to 2106 as in the network * protocol. / static inline u32 rxrpc_time64_to_u32(time64_t time) { if (time < 0) return 0; if (time > UINT_MAX) return UINT_MAX; return (u32)time; } / * Extend u32 back to time64_t using the same 1970-2106 range. / static inline time64_t rxrpc_u32_to_time64(u32 time) { return (time64_t)time; } #endif / _KEYS_RXRPC_TYPE_H / ��asymmetric-parser.h��0000644��00000001725�14722070436�0010376 0��ustar�00��/ SPDX-License-Identifier: GPL-2.0-or-later / / Asymmetric public-key cryptography data parser * * See Documentation/crypto/asymmetric-keys.txt * * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) / #ifndef _KEYS_ASYMMETRIC_PARSER_H #define _KEYS_ASYMMETRIC_PARSER_H / * Key data parser. Called during key instantiation. / struct asymmetric_key_parser { struct list_head link; struct module owner; const char name; / Attempt to parse a key from the data blob passed to add_key() or * keyctl_instantiate(). Should also generate a proposed description * that the caller can optionally use for the key. * * Return EBADMSG if not recognised. / int (parse)(struct key_preparsed_payload prep); }; extern int register_asymmetric_key_parser(struct asymmetric_key_parser ); extern void unregister_asymmetric_key_parser(struct asymmetric_key_parser ); #endif / _KEYS_ASYMMETRIC_PARSER_H / ��dns_resolver-type.h��0000644��00000000742�14722070436�0010411 0��ustar�00��/ SPDX-License-Identifier: GPL-2.0-or-later / / DNS resolver key type * * Copyright (C) 2010 Wang Lei. All Rights Reserved. * Written by Wang Lei (wang840925@gmail.com) / #ifndef _KEYS_DNS_RESOLVER_TYPE_H #define _KEYS_DNS_RESOLVER_TYPE_H #include <linux/key-type.h> extern struct key_type key_type_dns_resolver; extern int request_dns_resolver_key(const char description, const char callout_info, char data); #endif / _KEYS_DNS_RESOLVER_TYPE_H / ��user-type.h��0000644��00000003650�14722070436�0006663 0��ustar�00��/ SPDX-License-Identifier: GPL-2.0-or-later / / user-type.h: User-defined key type * * Copyright (C) 2005 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) / #ifndef _KEYS_USER_TYPE_H #define _KEYS_USER_TYPE_H #include <linux/key.h> #include <linux/rcupdate.h> #ifdef CONFIG_KEYS /***************************************************************************/ / * the payload for a key of type "user" or "logon" * - once filled in and attached to a key: * - the payload struct is invariant may not be changed, only replaced * - the payload must be read with RCU procedures or with the key semaphore * held * - the payload may only be replaced with the key semaphore write-locked * - the key's data length is the size of the actual data, not including the * payload wrapper / struct user_key_payload { struct rcu_head rcu; / RCU destructor / unsigned short datalen; / length of this data / char data[0] __aligned(__alignof__(u64)); / actual data / }; extern struct key_type key_type_user; extern struct key_type key_type_logon; struct key_preparsed_payload; extern int user_preparse(struct key_preparsed_payload prep); extern void user_free_preparse(struct key_preparsed_payload prep); extern int user_update(struct key key, struct key_preparsed_payload prep); extern void user_revoke(struct key key); extern void user_destroy(struct key key); extern void user_describe(const struct key user, struct seq_file m); extern long user_read(const struct key key, char buffer, size_t buflen); static inline const struct user_key_payload user_key_payload_rcu(const struct key key) { return (struct user_key_payload )dereference_key_rcu(key); } static inline struct user_key_payload user_key_payload_locked(const struct key key) { return (struct user_key_payload )dereference_key_locked((struct key )key); } #endif /* CONFIG_KEYS / #endif / _KEYS_USER_TYPE_H / ��encrypted-type.h��0000644��00000002136�14722070436�0007700 0��ustar�00��/ SPDX-License-Identifier: GPL-2.0-only / / * Copyright (C) 2010 IBM Corporation * Copyright (C) 2010 Politecnico di Torino, Italy * TORSEC group -- http://security.polito.it * * Authors: * Mimi Zohar <zohar@us.ibm.com> * Roberto Sassu <roberto.sassu@polito.it> / #ifndef _KEYS_ENCRYPTED_TYPE_H #define _KEYS_ENCRYPTED_TYPE_H #include <linux/key.h> #include <linux/rcupdate.h> struct encrypted_key_payload { struct rcu_head rcu; char format; /* datablob: format / char master_desc; /* datablob: master key name / char datalen; /* datablob: decrypted key length / u8 iv; /* datablob: iv / u8 encrypted_data; /* datablob: encrypted data / unsigned short datablob_len; / length of datablob / unsigned short decrypted_datalen; / decrypted data length / unsigned short payload_datalen; / payload data length / unsigned short encrypted_key_format; / encrypted key format / u8 decrypted_data; /* decrypted data / u8 payload_data[0]; / payload data + datablob + hmac / }; extern struct key_type key_type_encrypted; #endif / _KEYS_ENCRYPTED_TYPE_H / ��ceph-type.h��0000644��00000000242�14722070436�0006616 0��ustar�00��/ SPDX-License-Identifier: GPL-2.0 / #ifndef _KEYS_CEPH_TYPE_H #define _KEYS_CEPH_TYPE_H #include <linux/key.h> extern struct key_type key_type_ceph; #endif ��big_key-type.h��0000644��00000001340�14722070436�0007310 0��ustar�00��/ SPDX-License-Identifier: GPL-2.0-or-later / / Big capacity key type. * * Copyright (C) 2013 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) / #ifndef _KEYS_BIG_KEY_TYPE_H #define _KEYS_BIG_KEY_TYPE_H #include <linux/key-type.h> extern struct key_type key_type_big_key; extern int big_key_preparse(struct key_preparsed_payload prep); extern void big_key_free_preparse(struct key_preparsed_payload prep); extern void big_key_revoke(struct key key); extern void big_key_destroy(struct key key); extern void big_key_describe(const struct key big_key, struct seq_file m); extern long big_key_read(const struct key key, char buffer, size_t buflen); #endif / _KEYS_BIG_KEY_TYPE_H */ ��

| ver. 1.4 | Github | . | PHP 7.4.3-4ubuntu2.24 | Генерация страницы: 0 | proxy | phpinfo | Настройка