arch/arm64/include/asm/rsi_cmds.h

110

rsi_attestation_token_init(const u8 *challenge, unsigned long size)

arch/arm64/include/asm/rsi_cmds.h

115

if (!challenge || size < 32 || size > 64)

arch/arm64/include/asm/rsi_cmds.h

119

memcpy(&regs.a1, challenge, size);

drivers/firmware/tegra/bpmp.c

549

response.reply = request.challenge << 1;

drivers/firmware/tegra/bpmp.c

564

request.challenge = 1;

drivers/firmware/tegra/bpmp.c

584

request.challenge, response.reply,

drivers/media/usb/hdpvr/hdpvr-core.c

175

challenge(response);

drivers/nvme/common/auth.c

333

u8 *challenge, u8 *aug, size_t hlen)

drivers/nvme/common/auth.c

367

ret = crypto_shash_tfm_digest(tfm, challenge, hlen, aug);

drivers/nvme/host/auth.c

438

u8 buf[4], *challenge = chap->c1;

drivers/nvme/host/auth.c

466

challenge = kmalloc(chap->hash_len, GFP_KERNEL);

drivers/nvme/host/auth.c

467

if (!challenge) {

drivers/nvme/host/auth.c

474

chap->c1, challenge,

drivers/nvme/host/auth.c

484

ret = crypto_shash_update(shash, challenge, chap->hash_len);

drivers/nvme/host/auth.c

516

if (challenge != chap->c1)

drivers/nvme/host/auth.c

517

kfree(challenge);

drivers/nvme/host/auth.c

526

u8 buf[4], *challenge = chap->c2;

drivers/nvme/host/auth.c

545

challenge = kmalloc(chap->hash_len, GFP_KERNEL);

drivers/nvme/host/auth.c

546

if (!challenge) {

drivers/nvme/host/auth.c

553

chap->c2, challenge,

drivers/nvme/host/auth.c

561

__func__, chap->qid, (int)chap->hash_len, challenge);

drivers/nvme/host/auth.c

570

ret = crypto_shash_update(shash, challenge, chap->hash_len);

drivers/nvme/host/auth.c

601

if (challenge != chap->c2)

drivers/nvme/host/auth.c

602

kfree(challenge);

drivers/nvme/target/auth.c

299

u8 *challenge = req->sq->dhchap_c1;

drivers/nvme/target/auth.c

337

challenge = kmalloc(shash_len, GFP_KERNEL);

drivers/nvme/target/auth.c

338

if (!challenge) {

drivers/nvme/target/auth.c

346

challenge, shash_len);

drivers/nvme/target/auth.c

359

ret = crypto_shash_update(shash, challenge, shash_len);

drivers/nvme/target/auth.c

390

if (challenge != req->sq->dhchap_c1)

drivers/nvme/target/auth.c

391

kfree(challenge);

drivers/nvme/target/auth.c

406

u8 *challenge = req->sq->dhchap_c2;

drivers/nvme/target/auth.c

444

challenge = kmalloc(shash_len, GFP_KERNEL);

drivers/nvme/target/auth.c

445

if (!challenge) {

drivers/nvme/target/auth.c

453

challenge, shash_len);

drivers/nvme/target/auth.c

469

ret = crypto_shash_update(shash, challenge, shash_len);

drivers/nvme/target/auth.c

501

if (challenge != req->sq->dhchap_c2)

drivers/nvme/target/auth.c

502

kfree(challenge);

drivers/staging/greybus/authentication.c

144

u8 *challenge, u8 *result, u8 *auth_response,

drivers/staging/greybus/authentication.c

164

memcpy(request->challenge, challenge, sizeof(request->challenge));

drivers/staging/greybus/authentication.c

249

authenticate->challenge,

drivers/staging/greybus/greybus_authentication.h

61

__u8 challenge[32];

drivers/staging/rtl8723bs/core/rtw_ieee80211.c

904

elems->challenge = pos;

drivers/staging/rtl8723bs/include/ieee80211.h

686

u8 *challenge;

drivers/target/iscsi/iscsi_target_auth.c

391

ret = crypto_shash_finup(desc, chap->challenge,

drivers/target/iscsi/iscsi_target_auth.c

504

!memcmp(initiatorchg_binhex, chap->challenge,

drivers/target/iscsi/iscsi_target_auth.c

52

memset(chap->challenge, 0, MAX_CHAP_CHALLENGE_LEN);

drivers/target/iscsi/iscsi_target_auth.c

54

ret = get_random_bytes_wait(chap->challenge, chap->challenge_len);

drivers/target/iscsi/iscsi_target_auth.c

58

bin2hex(challenge_asciihex, chap->challenge,

drivers/target/iscsi/iscsi_target_auth.h

37

unsigned char challenge[MAX_CHAP_CHALLENGE_LEN];

drivers/thunderbolt/domain.c

714

u8 challenge[TB_SWITCH_KEY_SIZE];

drivers/thunderbolt/domain.c

728

get_random_bytes(challenge, sizeof(challenge));

drivers/thunderbolt/domain.c

729

ret = tb->cm_ops->challenge_switch_key(tb, sw, challenge, response);

drivers/thunderbolt/domain.c

735

challenge, sizeof(challenge), hmac);

drivers/thunderbolt/icm.c

1122

const u8 *challenge, u8 *response)

drivers/thunderbolt/icm.c

1134

memcpy(request.challenge, challenge, TB_SWITCH_KEY_SIZE);

drivers/thunderbolt/icm.c

553

const u8 *challenge, u8 *response)

drivers/thunderbolt/icm.c

564

memcpy(request.challenge, challenge, TB_SWITCH_KEY_SIZE);

drivers/thunderbolt/tb.h

529

const u8 *challenge, u8 *response);

drivers/thunderbolt/tb_msgs.h

256

u32 challenge[8];

drivers/thunderbolt/tb_msgs.h

265

u32 challenge[8];

drivers/thunderbolt/tb_msgs.h

419

u32 challenge[8];

drivers/thunderbolt/tb_msgs.h

449

u32 challenge[8];

drivers/virt/coco/arm-cca-guest/arm-cca-guest.c

113

info.challenge = desc->inblob;

drivers/virt/coco/arm-cca-guest/arm-cca-guest.c

26

void *challenge;

drivers/virt/coco/arm-cca-guest/arm-cca-guest.c

39

info->result = rsi_attestation_token_init(info->challenge,

fs/afs/cm_security.c

179

static int afs_create_yfs_cm_token(struct sk_buff *challenge,

fs/afs/cm_security.c

203

enctype = rxgk_kernel_query_challenge(challenge);

fs/afs/cm_security.c

22

static int afs_create_yfs_cm_token(struct sk_buff *challenge,

fs/afs/cm_security.c

29

static int afs_respond_to_challenge(struct sk_buff *challenge)

fs/afs/cm_security.c

40

rxrpc_kernel_query_challenge(challenge, &peer, &peer_data,

fs/afs/cm_security.c

57

return rxrpc_kernel_reject_challenge(challenge, RX_USER_ABORT, -EPROTO,

fs/afs/cm_security.c

64

return rxkad_kernel_respond_to_challenge(challenge);

fs/afs/cm_security.c

69

return rxgk_kernel_respond_to_challenge(challenge, &appdata);

fs/afs/cm_security.c

79

afs_create_yfs_cm_token(challenge, server);

fs/afs/cm_security.c

86

return rxgk_kernel_respond_to_challenge(challenge, &appdata);

fs/afs/cm_security.c

90

return rxrpc_kernel_reject_challenge(challenge, RX_USER_ABORT, -EPROTO,

fs/smb/client/cifsencrypt.c

326

offsetof(struct ntlmv2_resp, challenge.key[0]));

fs/smb/client/cifsencrypt.c

329

memcpy(ntlmv2->challenge.key, ses->ntlmssp->cryptkey, CIFS_SERVER_CHALLENGE_SIZE);

fs/smb/client/cifsencrypt.c

331

memcpy(ntlmv2->challenge.key, ses->server->cryptkey, CIFS_SERVER_CHALLENGE_SIZE);

fs/smb/client/cifsencrypt.c

335

ntlmv2->challenge.key, hash_len,

fs/smb/client/smb1pdu.h

536

} __packed challenge;

include/linux/greybus/greybus_protocols.h

353

__u8 challenge[32];

include/linux/nvme-auth.h

36

u8 *challenge, u8 *aug, size_t hlen);

include/net/af_rxrpc.h

102

void rxrpc_kernel_query_challenge(struct sk_buff *challenge,

include/net/af_rxrpc.h

106

int rxrpc_kernel_reject_challenge(struct sk_buff *challenge, u32 abort_code,

include/net/af_rxrpc.h

108

int rxkad_kernel_respond_to_challenge(struct sk_buff *challenge);

include/net/af_rxrpc.h

109

u32 rxgk_kernel_query_challenge(struct sk_buff *challenge);

include/net/af_rxrpc.h

110

int rxgk_kernel_respond_to_challenge(struct sk_buff *challenge,

include/soc/tegra/bpmp-abi.h

449

uint32_t challenge;

include/soc/tegra/bpmp-abi.h

522

uint32_t challenge;

include/trace/events/rxrpc.h

1292

__field(rxrpc_serial_t, challenge)

include/trace/events/rxrpc.h

1304

__entry->challenge = rsp->resp.challenge_serial;

include/trace/events/rxrpc.h

1315

__entry->challenge,

net/ceph/auth_x.c

858

void *challenge, int challenge_len,

net/ceph/auth_x.c

867

challenge, challenge_len);

net/ceph/auth_x.c

872

dp = challenge + __ceph_x_encrypt_offset(secret);

net/ceph/auth_x.c

886

void *challenge, int challenge_len)

net/ceph/auth_x.c

892

ret = decrypt_authorizer_challenge(&au->session_key, challenge,

net/mac80211/mlme.c

4865

const struct element *challenge;

net/mac80211/mlme.c

4874

challenge = cfg80211_find_elem(WLAN_EID_CHALLENGE, pos,

net/mac80211/mlme.c

4876

if (!challenge)

net/mac80211/mlme.c

4884

(void *)challenge,

net/mac80211/mlme.c

4885

challenge->datalen + sizeof(*challenge),

net/rxrpc/ar-internal.h

300

struct sk_buff *challenge,

net/rxrpc/ar-internal.h

304

int (*sendmsg_respond_to_challenge)(struct sk_buff *challenge,

net/rxrpc/ar-internal.h

309

struct sk_buff *challenge);

net/rxrpc/insecure.c

53

static int none_sendmsg_respond_to_challenge(struct sk_buff *challenge,

net/rxrpc/oob.c

342

void rxrpc_kernel_query_challenge(struct sk_buff *challenge,

net/rxrpc/oob.c

347

struct rxrpc_skb_priv *sp = rxrpc_skb(challenge);

net/rxrpc/oob.c

369

int rxrpc_kernel_reject_challenge(struct sk_buff *challenge, u32 abort_code,

net/rxrpc/oob.c

372

struct rxrpc_skb_priv *sp = rxrpc_skb(challenge);

net/rxrpc/recvmsg.c

187

struct sk_buff *challenge, unsigned int flags)

net/rxrpc/recvmsg.c

189

struct rxrpc_skb_priv *sp = rxrpc_skb(challenge);

net/rxrpc/recvmsg.c

192

return conn->security->challenge_to_recvmsg(conn, challenge, msg);

net/rxrpc/rxgk.c

1005

struct sk_buff *challenge,

net/rxrpc/rxgk.c

1014

return rxgk_construct_response(conn, challenge, appdata);

net/rxrpc/rxgk.c

1018

struct sk_buff *challenge)

net/rxrpc/rxgk.c

1022

return rxgk_respond_to_challenge(conn, challenge, &appdata);

net/rxrpc/rxgk.c

1035

int rxgk_kernel_respond_to_challenge(struct sk_buff *challenge,

net/rxrpc/rxgk.c

1038

struct rxrpc_skb_priv *csp = rxrpc_skb(challenge);

net/rxrpc/rxgk.c

1040

return rxgk_respond_to_challenge(csp->chall.conn, challenge, appdata);

net/rxrpc/rxgk.c

1048

static int rxgk_sendmsg_respond_to_challenge(struct sk_buff *challenge,

net/rxrpc/rxgk.c

1064

return rxgk_kernel_respond_to_challenge(challenge, &appdata);

net/rxrpc/rxgk.c

734

u32 rxgk_kernel_query_challenge(struct sk_buff *challenge)

net/rxrpc/rxgk.c

736

struct rxrpc_skb_priv *sp = rxrpc_skb(challenge);

net/rxrpc/rxgk.c

747

struct sk_buff *challenge,

net/rxrpc/rxgk.c

830

struct sk_buff *challenge,

net/rxrpc/rxgk.c

848

ret = skb_copy_bits(challenge, sizeof(struct rxrpc_wire_header),

net/rxrpc/rxgk.c

916

struct sk_buff *challenge,

net/rxrpc/rxgk.c

958

ret = rxgk_construct_authenticator(conn, challenge, appdata, response,

net/rxrpc/rxgk.c

986

csp = rxrpc_skb(challenge);

net/rxrpc/rxkad.c

657

struct rxkad_challenge challenge;

net/rxrpc/rxkad.c

669

challenge.version = htonl(2);

net/rxrpc/rxkad.c

670

challenge.nonce = htonl(conn->rxkad.nonce);

net/rxrpc/rxkad.c

671

challenge.min_level = htonl(0);

net/rxrpc/rxkad.c

672

challenge.__padding = 0;

net/rxrpc/rxkad.c

693

iov[1].iov_base = &challenge;

net/rxrpc/rxkad.c

694

iov[1].iov_len = sizeof(challenge);

net/rxrpc/rxkad.c

773

struct rxkad_challenge challenge;

net/rxrpc/rxkad.c

794

&challenge, sizeof(challenge)) < 0) {

net/rxrpc/rxkad.c

800

version = ntohl(challenge.version);

net/rxrpc/rxkad.c

801

sp->chall.rxkad_nonce = ntohl(challenge.nonce);

net/rxrpc/rxkad.c

802

min_level = ntohl(challenge.min_level);

net/rxrpc/rxkad.c

827

struct sk_buff *challenge,

net/rxrpc/rxkad.c

831

struct rxrpc_skb_priv *csp = rxrpc_skb(challenge);

net/rxrpc/rxkad.c

875

struct sk_buff *challenge)

net/rxrpc/rxkad.c

887

return rxrpc_abort_conn(conn, challenge, RXKADEXPIRED, ret,

net/rxrpc/rxkad.c

905

ret = rxkad_insert_response_header(conn, token, challenge, response,

net/rxrpc/rxkad.c

919

csp = rxrpc_skb(challenge);

net/rxrpc/rxkad.c

936

static int rxkad_sendmsg_respond_to_challenge(struct sk_buff *challenge,

net/rxrpc/rxkad.c

950

int rxkad_kernel_respond_to_challenge(struct sk_buff *challenge)

net/rxrpc/rxkad.c

952

struct rxrpc_skb_priv *csp = rxrpc_skb(challenge);

net/rxrpc/rxkad.c

954

return rxkad_respond_to_challenge(csp->chall.conn, challenge);