/* RxRPC key management * * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. * * RxRPC keys should have a description of describing their purpose: * "afs@CAMBRIDGE.REDHAT.COM> */ #include <linux/module.h> #include <linux/net.h> #include <linux/skbuff.h> #include <linux/key-type.h> #include <linux/crypto.h> #include <net/sock.h> #include <net/af_rxrpc.h> #include <keys/rxrpc-type.h> #include <keys/user-type.h> #include "ar-internal.h" static int rxrpc_instantiate(struct key *, const void *, size_t); static int rxrpc_instantiate_s(struct key *, const void *, size_t); static void rxrpc_destroy(struct key *); static void rxrpc_destroy_s(struct key *); static void rxrpc_describe(const struct key *, struct seq_file *); /* * rxrpc defined keys take an arbitrary string as the description and an * arbitrary blob of data as the payload */ struct key_type key_type_rxrpc = { .name = "rxrpc", .instantiate = rxrpc_instantiate, .match = user_match, .destroy = rxrpc_destroy, .describe = rxrpc_describe, }; EXPORT_SYMBOL(key_type_rxrpc); /* * rxrpc server defined keys take "<serviceId>:<securityIndex>" as the * description and an 8-byte decryption key as the payload */ struct key_type key_type_rxrpc_s = { .name = "rxrpc_s", .instantiate = rxrpc_instantiate_s, .match = user_match, .destroy = rxrpc_destroy_s, .describe = rxrpc_describe, }; /* * instantiate an rxrpc defined key * data should be of the form: * OFFSET LEN CONTENT * 0 4 key interface version number * 4 2 security index (type) * 6 2 ticket length * 8 4 key expiry time (time_t) * 12 4 kvno * 16 8 session key * 24 [len] ticket * * if no data is provided, then a no-security key is made */ static int rxrpc_instantiate(struct key *key, const void *data, size_t datalen) { const struct rxkad_key *tsec; struct rxrpc_key_payload *upayload; size_t plen; u32 kver; int ret; _enter("{%x},,%zu", key_serial(key), datalen); /* handle a no-security key */ if (!data && datalen == 0) return 0; /* get the key interface version number */ ret = -EINVAL; if (datalen <= 4 || !data) goto error; memcpy(&kver, data, sizeof(kver)); data += sizeof(kver); datalen -= sizeof(kver); _debug("KEY I/F VERSION: %u", kver); ret = -EKEYREJECTED; if (kver != 1) goto error; /* deal with a version 1 key */ ret = -EINVAL; if (datalen < sizeof(*tsec)) goto error; tsec = data; if (datalen != sizeof(*tsec) + tsec->ticket_len) goto error; _debug("SCIX: %u", tsec->security_index); _debug("TLEN: %u", tsec->ticket_len); _debug("EXPY: %x", tsec->expiry); _debug("KVNO: %u", tsec->kvno); _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x", tsec->session_key[0], tsec->session_key[1], tsec->session_key[2], tsec->session_key[3], tsec->session_key[4], tsec->session_key[5], tsec->session_key[6], tsec->session_key[7]); if (tsec->ticket_len >= 8) _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x", tsec->ticket[0], tsec->ticket[1], tsec->ticket[2], tsec->ticket[3], tsec->ticket[4], tsec->ticket[5], tsec->ticket[6], tsec->ticket[7]); ret = -EPROTONOSUPPORT; if (tsec->security_index != 2) goto error; key->type_data.x[0] = tsec->security_index; plen = sizeof(*upayload) + tsec->ticket_len; ret = key_payload_reserve(key, plen); if (ret < 0) goto error; ret = -ENOMEM; upayload = kmalloc(plen, GFP_KERNEL); if (!upayload) goto error; /* attach the data */ memcpy(&upayload->k, tsec, sizeof(*tsec)); memcpy(&upayload->k.ticket, (void *)tsec + sizeof(*tsec), tsec->ticket_len); key->payload.data = upayload; key->expiry = tsec->expiry; ret = 0; error: return ret; } /* * instantiate a server secret key * data should be a pointer to the 8-byte secret key */ static int rxrpc_instantiate_s(struct key *key, const void *data, size_t datalen) { struct crypto_blkcipher *ci; _enter("{%x},,%zu", key_serial(key), datalen); if (datalen != 8) return -EINVAL; memcpy(&key->type_data, data, 8); ci = crypto_alloc_blkcipher("pcbc(des)", 0, CRYPTO_ALG_ASYNC); if (IS_ERR(ci)) { _leave(" = %ld", PTR_ERR(ci)); return PTR_ERR(ci); } if (crypto_blkcipher_setkey(ci, data, 8) < 0) BUG(); key->payload.data = ci; _leave(" = 0"); return 0; } /* * dispose of the data dangling from the corpse of a rxrpc key */ static void rxrpc_destroy(struct key *key) { kfree(key->payload.data); } /* * dispose of the data dangling from the corpse of a rxrpc key */ static void rxrpc_destroy_s(struct key *key) { if (key->payload.data) { crypto_free_blkcipher(key->payload.data); key->payload.data = NULL; } } /* * describe the rxrpc key */ static void rxrpc_describe(const struct key *key, struct seq_file *m) { seq_puts(m, key->description); } /* * grab the security key for a socket */ int rxrpc_request_key(struct rxrpc_sock *rx, char __user *optval, int optlen) { struct key *key; char *description; _enter(""); if (optlen <= 0 || optlen > PAGE_SIZE - 1) return -EINVAL; description = kmalloc(optlen + 1, GFP_KERNEL); if (!description) return -ENOMEM; if (copy_from_user(description, optval, optlen)) { kfree(description); return -EFAULT; } description[optlen] = 0; key = request_key(&key_type_rxrpc, description, NULL); if (IS_ERR(key)) { kfree(description); _leave(" = %ld", PTR_ERR(key)); return PTR_ERR(key); } rx->key = key; kfree(description); _leave(" = 0 [key %x]", key->serial); return 0; } /* * grab the security keyring for a server socket */ int rxrpc_server_keyring(struct rxrpc_sock *rx, char __user *optval, int optlen) { struct key *key; char *description; _enter(""); if (optlen <= 0 || optlen > PAGE_SIZE - 1) return -EINVAL; description = kmalloc(optlen + 1, GFP_KERNEL); if (!description) return -ENOMEM; if (copy_from_user(description, optval, optlen)) { kfree(description); return -EFAULT; } description[optlen] = 0; key = request_key(&key_type_keyring, description, NULL); if (IS_ERR(key)) { kfree(description); _leave(" = %ld", PTR_ERR(key)); return PTR_ERR(key); } rx->securities = key; kfree(description); _leave(" = 0 [key %x]", key->serial); return 0; } /* * generate a server data key */ int rxrpc_get_server_data_key(struct rxrpc_connection *conn, const void *session_key, time_t expiry, u32 kvno) { struct key *key; int ret; struct { u32 kver; struct rxkad_key tsec; } data; _enter(""); key = key_alloc(&key_type_rxrpc, "x", 0, 0, current, 0, KEY_ALLOC_NOT_IN_QUOTA); if (IS_ERR(key)) { _leave(" = -ENOMEM [alloc %ld]", PTR_ERR(key)); return -ENOMEM; } _debug("key %d", key_serial(key)); data.kver = 1; data.tsec.security_index = 2; data.tsec.ticket_len = 0; data.tsec.expiry = expiry; data.tsec.kvno = 0; memcpy(&data.tsec.session_key, session_key, sizeof(data.tsec.session_key)); ret = key_instantiate_and_link(key, &data, sizeof(data), NULL, NULL); if (ret < 0) goto error; conn->key = key; _leave(" = 0 [%d]", key_serial(key)); return 0; error: key_revoke(key); key_put(key); _leave(" = -ENOMEM [ins %d]", ret); return -ENOMEM; } EXPORT_SYMBOL(rxrpc_get_server_data_key); /** * rxrpc_get_null_key - Generate a null RxRPC key * @keyname: The name to give the key. * * Generate a null RxRPC key that can be used to indicate anonymous security is * required for a particular domain. */ struct key *rxrpc_get_null_key(const char *keyname) { struct key *key; int ret; key = key_alloc(&key_type_rxrpc, keyname, 0, 0, current, KEY_POS_SEARCH, KEY_ALLOC_NOT_IN_QUOTA); if (IS_ERR(key)) return key; ret = key_instantiate_and_link(key, NULL, 0, NULL, NULL); if (ret < 0) { key_revoke(key); key_put(key); return ERR_PTR(ret); } return key; } EXPORT_SYMBOL(rxrpc_get_null_key);