hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

RxRPC: Allow key payloads to be passed in XDR form 

Allow add_key() and KEYCTL_INSTANTIATE to accept key payloads in XDR form as
described by openafs-1.4.10/src/auth/afs_token.xg.  This provides a way of
passing kaserver, Kerberos 4, Kerberos 5 and GSSAPI keys from userspace, and
allows for future expansion.

Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David Howells 2009-09-14 01:17:35 +00:00 committed by David S. Miller
parent 8b815477f3
commit 339412841d
5 changed files with 353 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
include/keys/rxrpc-type.h
View File

@ -21,4 +21,59 @@ extern struct key_type key_type_rxrpc;
extern struct key *rxrpc_get_null_key(const char *); 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 */
};
/*
* 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;
};
};
/*
* structure of raw payloads passed to add_key() or instantiate key
*/
struct rxrpc_key_data_v1 {
u32 kif_version; /* 1 */
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_CELL_MAX 64 /* max cellname length */
#define AFSTOKEN_MAX 8 /* max tokens per payload */
#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 */
#endif /* _KEYS_RXRPC_TYPE_H */ #endif /* _KEYS_RXRPC_TYPE_H */

16
net/rxrpc/ar-internal.h
View File

@ -401,22 +401,6 @@ struct rxrpc_call {
__be32 call_id; /* call ID on connection */ __be32 call_id; /* call ID on connection */
}; };
/*
* RxRPC key for Kerberos (type-2 security)
*/
struct rxkad_key {
u16 security_index; /* RxRPC header security index */
u16 ticket_len; /* length of ticket[] */
u32 expiry; /* time at which expires */
u32 kvno; /* key version number */
u8 session_key[8]; /* DES session key */
u8 ticket[0]; /* the encrypted ticket */
};
struct rxrpc_key_payload {
struct rxkad_key k;
};
/* /*
* locally abort an RxRPC call * locally abort an RxRPC call
*/ */

308
net/rxrpc/ar-key.c
View File

@ -17,6 +17,7 @@
#include <linux/skbuff.h> #include <linux/skbuff.h>
#include <linux/key-type.h> #include <linux/key-type.h>
#include <linux/crypto.h> #include <linux/crypto.h>
#include <linux/ctype.h>
#include <net/sock.h> #include <net/sock.h>
#include <net/af_rxrpc.h> #include <net/af_rxrpc.h>
#include <keys/rxrpc-type.h> #include <keys/rxrpc-type.h>
@ -54,6 +55,202 @@ struct key_type key_type_rxrpc_s = {
.describe = rxrpc_describe, .describe = rxrpc_describe,
}; };
/*
* parse an RxKAD type XDR format token
* - the caller guarantees we have at least 4 words
*/
static int rxrpc_instantiate_xdr_rxkad(struct key *key, const __be32 *xdr,
unsigned toklen)
{
struct rxrpc_key_token *token;
size_t plen;
u32 tktlen;
int ret;
_enter(",{%x,%x,%x,%x},%u",
ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
toklen);
if (toklen <= 8 * 4)
return -EKEYREJECTED;
tktlen = ntohl(xdr[7]);
_debug("tktlen: %x", tktlen);
if (tktlen > AFSTOKEN_RK_TIX_MAX)
return -EKEYREJECTED;
if (8 * 4 + tktlen != toklen)
return -EKEYREJECTED;
plen = sizeof(*token) + sizeof(*token->kad) + tktlen;
ret = key_payload_reserve(key, key->datalen + plen);
if (ret < 0)
return ret;
plen -= sizeof(*token);
token = kmalloc(sizeof(*token), GFP_KERNEL);
if (!token)
return -ENOMEM;
token->kad = kmalloc(plen, GFP_KERNEL);
if (!token->kad) {
kfree(token);
return -ENOMEM;
}
token->security_index = RXRPC_SECURITY_RXKAD;
token->kad->ticket_len = tktlen;
token->kad->vice_id = ntohl(xdr[0]);
token->kad->kvno = ntohl(xdr[1]);
token->kad->start = ntohl(xdr[4]);
token->kad->expiry = ntohl(xdr[5]);
token->kad->primary_flag = ntohl(xdr[6]);
memcpy(&token->kad->session_key, &xdr[2], 8);
memcpy(&token->kad->ticket, &xdr[8], tktlen);
_debug("SCIX: %u", token->security_index);
_debug("TLEN: %u", token->kad->ticket_len);
_debug("EXPY: %x", token->kad->expiry);
_debug("KVNO: %u", token->kad->kvno);
_debug("PRIM: %u", token->kad->primary_flag);
_debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
token->kad->session_key[0], token->kad->session_key[1],
token->kad->session_key[2], token->kad->session_key[3],
token->kad->session_key[4], token->kad->session_key[5],
token->kad->session_key[6], token->kad->session_key[7]);
if (token->kad->ticket_len >= 8)
_debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
token->kad->ticket[0], token->kad->ticket[1],
token->kad->ticket[2], token->kad->ticket[3],
token->kad->ticket[4], token->kad->ticket[5],
token->kad->ticket[6], token->kad->ticket[7]);
/* count the number of tokens attached */
key->type_data.x[0]++;
/* attach the data */
token->next = key->payload.data;
key->payload.data = token;
if (token->kad->expiry < key->expiry)
key->expiry = token->kad->expiry;
_leave(" = 0");
return 0;
}
/*
* attempt to parse the data as the XDR format
* - the caller guarantees we have more than 7 words
*/
static int rxrpc_instantiate_xdr(struct key *key, const void *data, size_t datalen)
{
const __be32 *xdr = data, *token;
const char *cp;
unsigned len, tmp, loop, ntoken, toklen, sec_ix;
int ret;
_enter(",{%x,%x,%x,%x},%zu",
ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
datalen);
if (datalen > AFSTOKEN_LENGTH_MAX)
goto not_xdr;
/* XDR is an array of __be32's */
if (datalen & 3)
goto not_xdr;
/* the flags should be 0 (the setpag bit must be handled by
* userspace) */
if (ntohl(*xdr++) != 0)
goto not_xdr;
datalen -= 4;
/* check the cell name */
len = ntohl(*xdr++);
if (len < 1 || len > AFSTOKEN_CELL_MAX)
goto not_xdr;
datalen -= 4;
tmp = (len + 3) & ~3;
if (tmp > datalen)
goto not_xdr;
cp = (const char *) xdr;
for (loop = 0; loop < len; loop++)
if (!isprint(cp[loop]))
goto not_xdr;
if (len < tmp)
for (; loop < tmp; loop++)
if (cp[loop])
goto not_xdr;
_debug("cellname: [%u/%u] '%*.*s'",
len, tmp, len, len, (const char *) xdr);
datalen -= tmp;
xdr += tmp >> 2;
/* get the token count */
if (datalen < 12)
goto not_xdr;
ntoken = ntohl(*xdr++);
datalen -= 4;
_debug("ntoken: %x", ntoken);
if (ntoken < 1 || ntoken > AFSTOKEN_MAX)
goto not_xdr;
/* check each token wrapper */
token = xdr;
loop = ntoken;
do {
if (datalen < 8)
goto not_xdr;
toklen = ntohl(*xdr++);
sec_ix = ntohl(*xdr);
datalen -= 4;
_debug("token: [%x/%zx] %x", toklen, datalen, sec_ix);
if (toklen < 20 || toklen > datalen)
goto not_xdr;
datalen -= (toklen + 3) & ~3;
xdr += (toklen + 3) >> 2;
} while (--loop > 0);
_debug("remainder: %zu", datalen);
if (datalen != 0)
goto not_xdr;
/* okay: we're going to assume it's valid XDR format
* - we ignore the cellname, relying on the key to be correctly named
*/
do {
xdr = token;
toklen = ntohl(*xdr++);
token = xdr + ((toklen + 3) >> 2);
sec_ix = ntohl(*xdr++);
toklen -= 4;
switch (sec_ix) {
case RXRPC_SECURITY_RXKAD:
ret = rxrpc_instantiate_xdr_rxkad(key, xdr, toklen);
if (ret != 0)
goto error;
break;
default:
ret = -EPROTONOSUPPORT;
goto error;
}
} while (--ntoken > 0);
_leave(" = 0");
return 0;
not_xdr:
_leave(" = -EPROTO");
return -EPROTO;
error:
_leave(" = %d", ret);
return ret;
}
/* /*
* instantiate an rxrpc defined key * instantiate an rxrpc defined key
* data should be of the form: * data should be of the form:
@ -70,8 +267,8 @@ struct key_type key_type_rxrpc_s = {
*/ */
static int rxrpc_instantiate(struct key *key, const void *data, size_t datalen) static int rxrpc_instantiate(struct key *key, const void *data, size_t datalen)
{ {
const struct rxkad_key *tsec; const struct rxrpc_key_data_v1 *v1;
struct rxrpc_key_payload *upayload; struct rxrpc_key_token *token, **pp;
size_t plen; size_t plen;
u32 kver; u32 kver;
int ret; int ret;
@ -82,6 +279,13 @@ static int rxrpc_instantiate(struct key *key, const void *data, size_t datalen)
if (!data && datalen == 0) if (!data && datalen == 0)
return 0; return 0;
/* determine if the XDR payload format is being used */
if (datalen > 7 * 4) {
ret = rxrpc_instantiate_xdr(key, data, datalen);
if (ret != -EPROTO)
return ret;
}
/* get the key interface version number */ /* get the key interface version number */
ret = -EINVAL; ret = -EINVAL;
if (datalen <= 4 || !data) if (datalen <= 4 || !data)
@ -98,53 +302,67 @@ static int rxrpc_instantiate(struct key *key, const void *data, size_t datalen)
/* deal with a version 1 key */ /* deal with a version 1 key */
ret = -EINVAL; ret = -EINVAL;
if (datalen < sizeof(*tsec)) if (datalen < sizeof(*v1))
goto error; goto error;
tsec = data; v1 = data;
if (datalen != sizeof(*tsec) + tsec->ticket_len) if (datalen != sizeof(*v1) + v1->ticket_length)
goto error; goto error;
_debug("SCIX: %u", tsec->security_index); _debug("SCIX: %u", v1->security_index);
_debug("TLEN: %u", tsec->ticket_len); _debug("TLEN: %u", v1->ticket_length);
_debug("EXPY: %x", tsec->expiry); _debug("EXPY: %x", v1->expiry);
_debug("KVNO: %u", tsec->kvno); _debug("KVNO: %u", v1->kvno);
_debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x", _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
tsec->session_key[0], tsec->session_key[1], v1->session_key[0], v1->session_key[1],
tsec->session_key[2], tsec->session_key[3], v1->session_key[2], v1->session_key[3],
tsec->session_key[4], tsec->session_key[5], v1->session_key[4], v1->session_key[5],
tsec->session_key[6], tsec->session_key[7]); v1->session_key[6], v1->session_key[7]);
if (tsec->ticket_len >= 8) if (v1->ticket_length >= 8)
_debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x", _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
tsec->ticket[0], tsec->ticket[1], v1->ticket[0], v1->ticket[1],
tsec->ticket[2], tsec->ticket[3], v1->ticket[2], v1->ticket[3],
tsec->ticket[4], tsec->ticket[5], v1->ticket[4], v1->ticket[5],
tsec->ticket[6], tsec->ticket[7]); v1->ticket[6], v1->ticket[7]);
ret = -EPROTONOSUPPORT; ret = -EPROTONOSUPPORT;
if (tsec->security_index != RXRPC_SECURITY_RXKAD) if (v1->security_index != RXRPC_SECURITY_RXKAD)
goto error; goto error;
key->type_data.x[0] = tsec->security_index; plen = sizeof(*token->kad) + v1->ticket_length;
ret = key_payload_reserve(key, plen + sizeof(*token));
plen = sizeof(*upayload) + tsec->ticket_len;
ret = key_payload_reserve(key, plen);
if (ret < 0) if (ret < 0)
goto error; goto error;
ret = -ENOMEM; ret = -ENOMEM;
upayload = kmalloc(plen, GFP_KERNEL); token = kmalloc(sizeof(*token), GFP_KERNEL);
if (!upayload) if (!token)
goto error; goto error;
token->kad = kmalloc(plen, GFP_KERNEL);
if (!token->kad)
goto error_free;
token->security_index = RXRPC_SECURITY_RXKAD;
token->kad->ticket_len = v1->ticket_length;
token->kad->expiry = v1->expiry;
token->kad->kvno = v1->kvno;
memcpy(&token->kad->session_key, &v1->session_key, 8);
memcpy(&token->kad->ticket, v1->ticket, v1->ticket_length);
/* attach the data */ /* attach the data */
memcpy(&upayload->k, tsec, sizeof(*tsec)); key->type_data.x[0]++;
memcpy(&upayload->k.ticket, (void *)tsec + sizeof(*tsec),
tsec->ticket_len); pp = (struct rxrpc_key_token **)&key->payload.data;
key->payload.data = upayload; while (*pp)
key->expiry = tsec->expiry; pp = &(*pp)->next;
*pp = token;
if (token->kad->expiry < key->expiry)
key->expiry = token->kad->expiry;
token = NULL;
ret = 0; ret = 0;
error_free:
kfree(token);
error: error:
return ret; return ret;
} }
@ -184,7 +402,22 @@ static int rxrpc_instantiate_s(struct key *key, const void *data,
*/ */
static void rxrpc_destroy(struct key *key) static void rxrpc_destroy(struct key *key)
{ {
kfree(key->payload.data); struct rxrpc_key_token *token;
while ((token = key->payload.data)) {
key->payload.data = token->next;
switch (token->security_index) {
case RXRPC_SECURITY_RXKAD:
kfree(token->kad);
break;
default:
printk(KERN_ERR "Unknown token type %x on rxrpc key\n",
token->security_index);
BUG();
}
kfree(token);
}
} }
/* /*
@ -293,7 +526,7 @@ int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
struct { struct {
u32 kver; u32 kver;
struct rxkad_key tsec; struct rxrpc_key_data_v1 v1;
} data; } data;
_enter(""); _enter("");
@ -308,13 +541,12 @@ int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
_debug("key %d", key_serial(key)); _debug("key %d", key_serial(key));
data.kver = 1; data.kver = 1;
data.tsec.security_index = RXRPC_SECURITY_RXKAD; data.v1.security_index = RXRPC_SECURITY_RXKAD;
data.tsec.ticket_len = 0; data.v1.ticket_length = 0;
data.tsec.expiry = expiry; data.v1.expiry = expiry;
data.tsec.kvno = 0; data.v1.kvno = 0;
memcpy(&data.tsec.session_key, session_key, memcpy(&data.v1.session_key, session_key, sizeof(data.v1.session_key));
sizeof(data.tsec.session_key));
ret = key_instantiate_and_link(key, &data, sizeof(data), NULL, NULL); ret = key_instantiate_and_link(key, &data, sizeof(data), NULL, NULL);
if (ret < 0) if (ret < 0)

8
net/rxrpc/ar-security.c
View File

@ -16,6 +16,7 @@
#include <linux/crypto.h> #include <linux/crypto.h>
#include <net/sock.h> #include <net/sock.h>
#include <net/af_rxrpc.h> #include <net/af_rxrpc.h>
#include <keys/rxrpc-type.h>
#include "ar-internal.h" #include "ar-internal.h"
static LIST_HEAD(rxrpc_security_methods); static LIST_HEAD(rxrpc_security_methods);
@ -122,6 +123,7 @@ EXPORT_SYMBOL_GPL(rxrpc_unregister_security);
*/ */
int rxrpc_init_client_conn_security(struct rxrpc_connection *conn) int rxrpc_init_client_conn_security(struct rxrpc_connection *conn)
{ {
struct rxrpc_key_token *token;
struct rxrpc_security *sec; struct rxrpc_security *sec;
struct key *key = conn->key; struct key *key = conn->key;
int ret; int ret;
@ -135,7 +137,11 @@ int rxrpc_init_client_conn_security(struct rxrpc_connection *conn)
if (ret < 0) if (ret < 0)
return ret; return ret;
sec = rxrpc_security_lookup(key->type_data.x[0]); if (!key->payload.data)
return -EKEYREJECTED;
token = key->payload.data;
sec = rxrpc_security_lookup(token->security_index);
if (!sec) if (!sec)
return -EKEYREJECTED; return -EKEYREJECTED;
conn->security = sec; conn->security = sec;

41
net/rxrpc/rxkad.c
View File

@ -18,6 +18,7 @@
#include <linux/ctype.h> #include <linux/ctype.h>
#include <net/sock.h> #include <net/sock.h>
#include <net/af_rxrpc.h> #include <net/af_rxrpc.h>
#include <keys/rxrpc-type.h>
#define rxrpc_debug rxkad_debug #define rxrpc_debug rxkad_debug
#include "ar-internal.h" #include "ar-internal.h"
@ -59,14 +60,14 @@ static DEFINE_MUTEX(rxkad_ci_mutex);
*/ */
static int rxkad_init_connection_security(struct rxrpc_connection *conn) static int rxkad_init_connection_security(struct rxrpc_connection *conn)
{ {
struct rxrpc_key_payload *payload;
struct crypto_blkcipher *ci; struct crypto_blkcipher *ci;
struct rxrpc_key_token *token;
int ret; int ret;
_enter("{%d},{%x}", conn->debug_id, key_serial(conn->key)); _enter("{%d},{%x}", conn->debug_id, key_serial(conn->key));
payload = conn->key->payload.data; token = conn->key->payload.data;
conn->security_ix = payload->k.security_index; conn->security_ix = token->security_index;
ci = crypto_alloc_blkcipher("pcbc(fcrypt)", 0, CRYPTO_ALG_ASYNC); ci = crypto_alloc_blkcipher("pcbc(fcrypt)", 0, CRYPTO_ALG_ASYNC);
if (IS_ERR(ci)) { if (IS_ERR(ci)) {
@ -75,8 +76,8 @@ static int rxkad_init_connection_security(struct rxrpc_connection *conn)
goto error; goto error;
} }
if (crypto_blkcipher_setkey(ci, payload->k.session_key, if (crypto_blkcipher_setkey(ci, token->kad->session_key,
sizeof(payload->k.session_key)) < 0) sizeof(token->kad->session_key)) < 0)
BUG(); BUG();
switch (conn->security_level) { switch (conn->security_level) {
@ -110,7 +111,7 @@ error:
*/ */
static void rxkad_prime_packet_security(struct rxrpc_connection *conn) static void rxkad_prime_packet_security(struct rxrpc_connection *conn)
{ {
struct rxrpc_key_payload *payload; struct rxrpc_key_token *token;
struct blkcipher_desc desc; struct blkcipher_desc desc;
struct scatterlist sg[2]; struct scatterlist sg[2];
struct rxrpc_crypt iv; struct rxrpc_crypt iv;
@ -123,8 +124,8 @@ static void rxkad_prime_packet_security(struct rxrpc_connection *conn)
if (!conn->key) if (!conn->key)
return; return;
payload = conn->key->payload.data; token = conn->key->payload.data;
memcpy(&iv, payload->k.session_key, sizeof(iv)); memcpy(&iv, token->kad->session_key, sizeof(iv));
desc.tfm = conn->cipher; desc.tfm = conn->cipher;
desc.info = iv.x; desc.info = iv.x;
@ -197,7 +198,7 @@ static int rxkad_secure_packet_encrypt(const struct rxrpc_call *call,
u32 data_size, u32 data_size,
void *sechdr) void *sechdr)
{ {
const struct rxrpc_key_payload *payload; const struct rxrpc_key_token *token;
struct rxkad_level2_hdr rxkhdr struct rxkad_level2_hdr rxkhdr
__attribute__((aligned(8))); /* must be all on one page */ __attribute__((aligned(8))); /* must be all on one page */
struct rxrpc_skb_priv *sp; struct rxrpc_skb_priv *sp;
@ -219,8 +220,8 @@ static int rxkad_secure_packet_encrypt(const struct rxrpc_call *call,
rxkhdr.checksum = 0; rxkhdr.checksum = 0;
/* encrypt from the session key */ /* encrypt from the session key */
payload = call->conn->key->payload.data; token = call->conn->key->payload.data;
memcpy(&iv, payload->k.session_key, sizeof(iv)); memcpy(&iv, token->kad->session_key, sizeof(iv));
desc.tfm = call->conn->cipher; desc.tfm = call->conn->cipher;
desc.info = iv.x; desc.info = iv.x;
desc.flags = 0; desc.flags = 0;
@ -400,7 +401,7 @@ static int rxkad_verify_packet_encrypt(const struct rxrpc_call *call,
struct sk_buff *skb, struct sk_buff *skb,
u32 *_abort_code) u32 *_abort_code)
{ {
const struct rxrpc_key_payload *payload; const struct rxrpc_key_token *token;
struct rxkad_level2_hdr sechdr; struct rxkad_level2_hdr sechdr;
struct rxrpc_skb_priv *sp; struct rxrpc_skb_priv *sp;
struct blkcipher_desc desc; struct blkcipher_desc desc;
@ -431,8 +432,8 @@ static int rxkad_verify_packet_encrypt(const struct rxrpc_call *call,
skb_to_sgvec(skb, sg, 0, skb->len); skb_to_sgvec(skb, sg, 0, skb->len);
/* decrypt from the session key */ /* decrypt from the session key */
payload = call->conn->key->payload.data; token = call->conn->key->payload.data;
memcpy(&iv, payload->k.session_key, sizeof(iv)); memcpy(&iv, token->kad->session_key, sizeof(iv));
desc.tfm = call->conn->cipher; desc.tfm = call->conn->cipher;
desc.info = iv.x; desc.info = iv.x;
desc.flags = 0; desc.flags = 0;
@ -737,7 +738,7 @@ static int rxkad_respond_to_challenge(struct rxrpc_connection *conn,
struct sk_buff *skb, struct sk_buff *skb,
u32 *_abort_code) u32 *_abort_code)
{ {
const struct rxrpc_key_payload *payload; const struct rxrpc_key_token *token;
struct rxkad_challenge challenge; struct rxkad_challenge challenge;
struct rxkad_response resp struct rxkad_response resp
__attribute__((aligned(8))); /* must be aligned for crypto */ __attribute__((aligned(8))); /* must be aligned for crypto */
@ -778,7 +779,7 @@ static int rxkad_respond_to_challenge(struct rxrpc_connection *conn,
if (conn->security_level < min_level) if (conn->security_level < min_level)
goto protocol_error; goto protocol_error;
payload = conn->key->payload.data; token = conn->key->payload.data;
/* build the response packet */ /* build the response packet */
memset(&resp, 0, sizeof(resp)); memset(&resp, 0, sizeof(resp));
@ -797,13 +798,13 @@ static int rxkad_respond_to_challenge(struct rxrpc_connection *conn,
(conn->channels[3] ? conn->channels[3]->call_id : 0); (conn->channels[3] ? conn->channels[3]->call_id : 0);
resp.encrypted.inc_nonce = htonl(nonce + 1); resp.encrypted.inc_nonce = htonl(nonce + 1);
resp.encrypted.level = htonl(conn->security_level); resp.encrypted.level = htonl(conn->security_level);
resp.kvno = htonl(payload->k.kvno); resp.kvno = htonl(token->kad->kvno);
resp.ticket_len = htonl(payload->k.ticket_len); resp.ticket_len = htonl(token->kad->ticket_len);
/* calculate the response checksum and then do the encryption */ /* calculate the response checksum and then do the encryption */
rxkad_calc_response_checksum(&resp); rxkad_calc_response_checksum(&resp);
rxkad_encrypt_response(conn, &resp, &payload->k); rxkad_encrypt_response(conn, &resp, token->kad);
return rxkad_send_response(conn, &sp->hdr, &resp, &payload->k); return rxkad_send_response(conn, &sp->hdr, &resp, token->kad);
protocol_error: protocol_error:
*_abort_code = abort_code; *_abort_code = abort_code;