4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.gnu.org/licenses/gpl-2.0.html
23 * Copyright (C) 2015, Trustees of Indiana University
25 * Author: Jeremy Filizetti <jfilizet@iu.edu>
31 #include <gssapi/gssapi.h>
32 #ifdef HAVE_LIBKEYUTILS
35 #include <linux/lustre/lustre_idl.h>
36 #include <openssl/dh.h>
37 #include <openssl/evp.h>
38 #include <openssl/hmac.h>
39 #include <sys/types.h>
41 #include <libcfs/libcfs_crypto.h>
45 # define ARRAY_SIZE(a) ((sizeof(a)) / (sizeof((a)[0])))
46 #endif /* !ARRAY_SIZE */
48 /* LL_CRYPTO_MAX_NAME value must match value of
49 * CRYPTO_MAX_ALG_NAME in include/linux/crypto.h
51 #ifdef HAVE_CRYPTO_MAX_ALG_NAME_128
52 #define LL_CRYPTO_MAX_NAME 128
54 #define LL_CRYPTO_MAX_NAME 64
57 #if OPENSSL_VERSION_NUMBER < 0x10100000L
58 static inline HMAC_CTX *HMAC_CTX_new(void)
60 HMAC_CTX *ctx = OPENSSL_malloc(sizeof(*ctx));
67 static inline void HMAC_CTX_free(HMAC_CTX *ctx)
70 HMAC_CTX_cleanup(ctx);
71 OPENSSL_cleanse(ctx, sizeof(*ctx));
75 static inline void DH_get0_pqg(const DH *dh,
76 const BIGNUM **p, const BIGNUM **q,
87 static inline int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g)
89 /* If the fields p and g in dh are NULL, the corresponding input
90 * parameters MUST be non-NULL. q may remain NULL.
92 if ((dh->p == NULL && p == NULL)
93 || (dh->g == NULL && g == NULL))
110 dh->length = BN_num_bits(q);
115 static inline void DH_get0_key(const DH *dh, const BIGNUM **pub_key,
116 const BIGNUM **priv_key)
119 *pub_key = dh->pub_key;
120 if (priv_key != NULL)
121 *priv_key = dh->priv_key;
125 /* Some limits and defaults */
126 #define SK_CONF_VERSION 1
127 #define SK_MSG_VERSION 1
128 #define SK_GENERATOR 2
129 #define SK_SESSION_MAX_KEYLEN_BYTES 1024
130 #define SK_MAX_KEYLEN_BYTES 128
131 #define SK_MAX_P_BYTES 2048
132 #define SK_NONCE_SIZE 4
133 #define MAX_MGSNIDS 16
135 enum sk_ctx_init_buffers {
136 /* Initiator netstring buffer ordering */
147 /* Responder netstring buffer ordering */
155 /* String consisting of "lustre:fsname:nodemap_hash" */
156 #define SK_DESCRIPTION_SIZE (9 + MTI_NAME_MAXLEN + LUSTRE_NODEMAP_NAME_LENGTH)
159 SK_TYPE_INVALID = 0x0,
160 SK_TYPE_CLIENT = 0x1,
161 SK_TYPE_SERVER = 0x2,
165 /* This is the packed structure format of key files that are distributed.
166 * The on disk format should be store in big-endian. */
167 struct sk_keyfile_config {
168 /* File format version */
169 uint32_t skc_version;
170 /* HMAC algorithm used for message integrity */
171 uint16_t skc_hmac_alg;
172 /* Crypt algorithm used for privacy mode */
173 uint16_t skc_crypt_alg;
174 /* Number of seconds that a context is valid after it is created from
177 /* Length of shared key in skc_shared_key */
178 uint32_t skc_shared_keylen;
179 /* Length of the prime used in the DHKE */
180 uint32_t skc_prime_bits;
183 /* Array of MGS NIDs to load key's for. This is for the client since
184 * the upcall only knows the target name which is MGC<IP>@<NET>
185 * Only needed when mounting with mgssec */
186 lnet_nid_t skc_mgsnids[MAX_MGSNIDS];
187 /* File system name for this key. It can be unused for MGS only keys */
188 char skc_fsname[MTI_NAME_MAXLEN + 1];
189 /* Nodemap name for this key. Used by the server side to verify the
190 * client is in the correct nodemap */
191 char skc_nodemap[LUSTRE_NODEMAP_NAME_LENGTH + 1];
193 unsigned char skc_shared_key[SK_MAX_KEYLEN_BYTES];
194 /* Prime (p) for DHKE */
195 unsigned char skc_p[SK_MAX_P_BYTES];
196 } __attribute__((packed));
198 /* Format passed to the kernel from userspace */
199 struct sk_kernel_ctx {
200 uint32_t skc_version;
201 char skc_hmac_alg[LL_CRYPTO_MAX_NAME];
202 char skc_crypt_alg[LL_CRYPTO_MAX_NAME];
204 uint32_t skc_host_random;
205 uint32_t skc_peer_random;
206 gss_buffer_desc skc_hmac_key;
207 gss_buffer_desc skc_encrypt_key;
208 gss_buffer_desc skc_shared_key;
209 gss_buffer_desc skc_session_key;
212 /* Structure used in context initiation to hold all necessary data */
215 gss_buffer_desc sc_p;
216 gss_buffer_desc sc_pub_key;
217 gss_buffer_desc sc_tgt;
218 gss_buffer_desc sc_nodemap_hash;
219 gss_buffer_desc sc_hmac;
220 gss_buffer_desc sc_dh_shared_key;
221 struct sk_kernel_ctx sc_kctx;
225 /* Names match up with openssl enc and dgst commands */
226 /* When adding new alg types, make sure first occurrence's name
227 * matches cht_name in hash_types array.
229 static const struct sk_crypt_type sk_crypt_algs[] = {
232 .sct_type = SK_CRYPT_EMPTY
236 .sct_type = SK_CRYPT_EMPTY
239 .sct_name = "ctr(aes)",
240 .sct_type = SK_CRYPT_AES256_CTR
243 .sct_name = "AES-256-CTR",
244 .sct_type = SK_CRYPT_AES256_CTR
247 static const struct sk_hmac_type sk_hmac_algs[] = {
250 .sht_type = SK_HMAC_EMPTY
254 .sht_type = SK_HMAC_EMPTY
257 .sht_name = "sha256",
258 .sht_type = SK_HMAC_SHA256
261 .sht_name = "SHA256",
262 .sht_type = SK_HMAC_SHA256
265 .sht_name = "sha512",
266 .sht_type = SK_HMAC_SHA512
269 .sht_name = "SHA512",
270 .sht_type = SK_HMAC_SHA512
274 static inline int sk_name2crypt(char *name)
278 for (i = 0; i < ARRAY_SIZE(sk_crypt_algs); i++) {
279 if (strcasecmp(name, sk_crypt_algs[i].sct_name) == 0)
280 return sk_crypt_algs[i].sct_type;
283 return SK_CRYPT_INVALID;
286 static inline int sk_name2hmac(char *name)
290 for (i = 0; i < ARRAY_SIZE(sk_hmac_algs); i++) {
291 if (strcasecmp(name, sk_hmac_algs[i].sht_name) == 0)
292 return sk_hmac_algs[i].sht_type;
295 return SK_HMAC_INVALID;
298 static inline const char *sk_crypt2name(enum sk_crypt_alg type)
302 for (i = 0; i < ARRAY_SIZE(sk_crypt_algs); i++) {
303 if (type == sk_crypt_algs[i].sct_type)
304 return sk_crypt_algs[i].sct_name;
310 static inline const char *sk_hmac2name(enum sk_hmac_alg type)
314 for (i = 0; i < ARRAY_SIZE(sk_hmac_algs); i++) {
315 if (type == sk_hmac_algs[i].sht_type)
316 return sk_hmac_algs[i].sht_name;
322 void sk_init_logging(char *program, int verbose, int fg);
323 struct sk_keyfile_config *sk_read_file(char *filename);
324 int sk_load_keyfile(char *path);
325 void sk_config_disk_to_cpu(struct sk_keyfile_config *config);
326 void sk_config_cpu_to_disk(struct sk_keyfile_config *config);
327 int sk_validate_config(const struct sk_keyfile_config *config);
328 uint32_t sk_verify_hash(const char *string, const EVP_MD *hash_alg,
329 const gss_buffer_desc *current_hash);
330 struct sk_cred *sk_create_cred(const char *fsname, const char *cluster,
331 const uint32_t flags);
332 int sk_speedtest_dh_valid(unsigned int usec_check_max);
333 uint32_t sk_gen_params(struct sk_cred *skc, int num_rounds);
334 int sk_sign_bufs(gss_buffer_desc *key, gss_buffer_desc *bufs, const int numbufs,
335 const EVP_MD *hash_alg, gss_buffer_desc *hmac);
336 uint32_t sk_verify_hmac(struct sk_cred *skc, gss_buffer_desc *bufs,
337 const int numbufs, const EVP_MD *hash_alg,
338 gss_buffer_desc *hmac);
339 void sk_free_cred(struct sk_cred *skc);
340 int sk_session_kdf(struct sk_cred *skc, lnet_nid_t client_nid,
341 gss_buffer_desc *client_token, gss_buffer_desc *server_token);
342 uint32_t sk_compute_dh_key(struct sk_cred *skc, const gss_buffer_desc *pub_key);
343 int sk_compute_keys(struct sk_cred *skc);
344 int sk_serialize_kctx(struct sk_cred *skc, gss_buffer_desc *ctx_token);
345 int sk_decode_netstring(gss_buffer_desc *bufs, int numbufs,
346 gss_buffer_desc *ns);
347 int sk_encode_netstring(gss_buffer_desc *bufs, int numbufs,
348 gss_buffer_desc *ns);
350 #endif /* SK_UTILS_H */