| /* 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); |