challenge
rsi_attestation_token_init(const u8 *challenge, unsigned long size)
if (!challenge || size < 32 || size > 64)
memcpy(®s.a1, challenge, size);
response.reply = request.challenge << 1;
request.challenge = 1;
request.challenge, response.reply,
challenge(response);
const u8 *challenge, u8 *aug, size_t hlen)
return nvme_auth_hmac(hmac_id, skey, skey_len, challenge, hlen, aug);
u8 buf[4], *challenge = chap->c1;
challenge = kmalloc(chap->hash_len, GFP_KERNEL);
if (!challenge) {
chap->c1, challenge,
nvme_auth_hmac_update(&hmac, challenge, chap->hash_len);
if (challenge != chap->c1)
kfree(challenge);
u8 buf[4], *challenge = chap->c2;
challenge = kmalloc(chap->hash_len, GFP_KERNEL);
if (!challenge) {
chap->c2, challenge,
__func__, chap->qid, (int)chap->hash_len, challenge);
nvme_auth_hmac_update(&hmac, challenge, chap->hash_len);
if (challenge != chap->c2)
kfree(challenge);
u8 *challenge = req->sq->dhchap_c1;
challenge = kmalloc(shash_len, GFP_KERNEL);
if (!challenge) {
challenge, shash_len);
nvme_auth_hmac_update(&hmac, challenge, shash_len);
if (challenge != req->sq->dhchap_c1)
kfree(challenge);
u8 *challenge = req->sq->dhchap_c2;
challenge = kmalloc(shash_len, GFP_KERNEL);
if (!challenge) {
challenge, shash_len);
nvme_auth_hmac_update(&hmac, challenge, shash_len);
if (challenge != req->sq->dhchap_c2)
kfree(challenge);
u8 *challenge, u8 *result, u8 *auth_response,
memcpy(request->challenge, challenge, sizeof(request->challenge));
authenticate->challenge,
__u8 challenge[32];
elems->challenge = pos;
u8 *challenge;
ret = crypto_shash_finup(desc, chap->challenge,
!memcmp(initiatorchg_binhex, chap->challenge,
memset(chap->challenge, 0, MAX_CHAP_CHALLENGE_LEN);
ret = get_random_bytes_wait(chap->challenge, chap->challenge_len);
bin2hex(challenge_asciihex, chap->challenge,
unsigned char challenge[MAX_CHAP_CHALLENGE_LEN];
u8 challenge[TB_SWITCH_KEY_SIZE];
get_random_bytes(challenge, sizeof(challenge));
ret = tb->cm_ops->challenge_switch_key(tb, sw, challenge, response);
challenge, sizeof(challenge), hmac);
const u8 *challenge, u8 *response)
memcpy(request.challenge, challenge, TB_SWITCH_KEY_SIZE);
const u8 *challenge, u8 *response)
memcpy(request.challenge, challenge, TB_SWITCH_KEY_SIZE);
const u8 *challenge, u8 *response);
u32 challenge[8];
u32 challenge[8];
u32 challenge[8];
u32 challenge[8];
info.challenge = desc->inblob;
void *challenge;
info->result = rsi_attestation_token_init(info->challenge,
static int afs_create_yfs_cm_token(struct sk_buff *challenge,
enctype = rxgk_kernel_query_challenge(challenge);
static int afs_create_yfs_cm_token(struct sk_buff *challenge,
static int afs_respond_to_challenge(struct sk_buff *challenge)
rxrpc_kernel_query_challenge(challenge, &peer, &peer_data,
return rxrpc_kernel_reject_challenge(challenge, RX_USER_ABORT, -EPROTO,
return rxkad_kernel_respond_to_challenge(challenge);
return rxgk_kernel_respond_to_challenge(challenge, &appdata);
afs_create_yfs_cm_token(challenge, server);
return rxgk_kernel_respond_to_challenge(challenge, &appdata);
return rxrpc_kernel_reject_challenge(challenge, RX_USER_ABORT, -EPROTO,
offsetof(struct ntlmv2_resp, challenge.key[0]));
memcpy(ntlmv2->challenge.key, ses->ntlmssp->cryptkey, CIFS_SERVER_CHALLENGE_SIZE);
memcpy(ntlmv2->challenge.key, ses->server->cryptkey, CIFS_SERVER_CHALLENGE_SIZE);
ntlmv2->challenge.key, hash_len,
} __packed challenge;
__u8 challenge[32];
const u8 *challenge, u8 *aug, size_t hlen);
void rxrpc_kernel_query_challenge(struct sk_buff *challenge,
int rxrpc_kernel_reject_challenge(struct sk_buff *challenge, u32 abort_code,
int rxkad_kernel_respond_to_challenge(struct sk_buff *challenge);
u32 rxgk_kernel_query_challenge(struct sk_buff *challenge);
int rxgk_kernel_respond_to_challenge(struct sk_buff *challenge,
uint32_t challenge;
uint32_t challenge;
__field(rxrpc_serial_t, challenge)
__entry->challenge = rsp->resp.challenge_serial;
__entry->challenge,
void *challenge, int challenge_len,
challenge, challenge_len);
dp = challenge + __ceph_x_encrypt_offset(secret);
void *challenge, int challenge_len)
ret = decrypt_authorizer_challenge(&au->session_key, challenge,
const struct element *challenge;
challenge = cfg80211_find_elem(WLAN_EID_CHALLENGE, pos,
if (!challenge)
(void *)challenge,
challenge->datalen + sizeof(*challenge),
struct sk_buff *challenge,
int (*sendmsg_respond_to_challenge)(struct sk_buff *challenge,
struct sk_buff *challenge);
static int none_sendmsg_respond_to_challenge(struct sk_buff *challenge,
void rxrpc_kernel_query_challenge(struct sk_buff *challenge,
struct rxrpc_skb_priv *sp = rxrpc_skb(challenge);
int rxrpc_kernel_reject_challenge(struct sk_buff *challenge, u32 abort_code,
struct rxrpc_skb_priv *sp = rxrpc_skb(challenge);
struct sk_buff *challenge, unsigned int flags)
struct rxrpc_skb_priv *sp = rxrpc_skb(challenge);
return conn->security->challenge_to_recvmsg(conn, challenge, msg);
struct sk_buff *challenge,
return rxgk_construct_response(conn, challenge, appdata);
struct sk_buff *challenge)
return rxgk_respond_to_challenge(conn, challenge, &appdata);
int rxgk_kernel_respond_to_challenge(struct sk_buff *challenge,
struct rxrpc_skb_priv *csp = rxrpc_skb(challenge);
return rxgk_respond_to_challenge(csp->chall.conn, challenge, appdata);
static int rxgk_sendmsg_respond_to_challenge(struct sk_buff *challenge,
return rxgk_kernel_respond_to_challenge(challenge, &appdata);
u32 rxgk_kernel_query_challenge(struct sk_buff *challenge)
struct rxrpc_skb_priv *sp = rxrpc_skb(challenge);
struct sk_buff *challenge,
struct sk_buff *challenge,
ret = skb_copy_bits(challenge, sizeof(struct rxrpc_wire_header),
struct sk_buff *challenge,
ret = rxgk_construct_authenticator(conn, challenge, appdata, response,
csp = rxrpc_skb(challenge);
struct rxkad_challenge challenge;
challenge.version = htonl(2);
challenge.nonce = htonl(conn->rxkad.nonce);
challenge.min_level = htonl(0);
challenge.__padding = 0;
iov[1].iov_base = &challenge;
iov[1].iov_len = sizeof(challenge);
struct rxkad_challenge challenge;
&challenge, sizeof(challenge)) < 0) {
version = ntohl(challenge.version);
sp->chall.rxkad_nonce = ntohl(challenge.nonce);
min_level = ntohl(challenge.min_level);
struct sk_buff *challenge,
struct rxrpc_skb_priv *csp = rxrpc_skb(challenge);
struct sk_buff *challenge)
return rxrpc_abort_conn(conn, challenge, RXKADEXPIRED, ret,
ret = rxkad_insert_response_header(conn, token, challenge, response,
csp = rxrpc_skb(challenge);
static int rxkad_sendmsg_respond_to_challenge(struct sk_buff *challenge,
int rxkad_kernel_respond_to_challenge(struct sk_buff *challenge)
struct rxrpc_skb_priv *csp = rxrpc_skb(challenge);
return rxkad_respond_to_challenge(csp->chall.conn, challenge);