crypto/chacha20poly1305.c

29

u8 salt[] __counted_by(saltlen);

crypto/chacha20poly1305.c

312

memcpy(ctx->salt, key + keylen, ctx->saltlen);

crypto/chacha20poly1305.c

76

memcpy(iv + sizeof(leicb), ctx->salt, ctx->saltlen);

crypto/echainiv.c

62

memcpy(&a, ctx->salt + ivsize - 8, 8);

crypto/essiv.c

115

crypto_shash_finup(desc, keys.authkey, keys.authkeylen, salt);

crypto/essiv.c

122

return crypto_cipher_setkey(tctx->essiv_cipher, salt,

crypto/essiv.c

70

u8 salt[HASH_MAX_DIGESTSIZE];

crypto/essiv.c

81

err = crypto_shash_tfm_digest(tctx->hash, key, keylen, salt);

crypto/essiv.c

89

return crypto_cipher_setkey(tctx->essiv_cipher, salt,

crypto/essiv.c

99

u8 salt[HASH_MAX_DIGESTSIZE];

crypto/geniv.c

121

err = crypto_rng_get_bytes(crypto_default_rng, ctx->salt,

crypto/hkdf.c

135

const u8 *salt;

crypto/hkdf.c

158

.salt = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c",

crypto/hkdf.c

177

.salt = "\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f"

crypto/hkdf.c

204

.salt = NULL,

crypto/hkdf.c

219

.salt = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c",

crypto/hkdf.c

235

.salt = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"

crypto/hkdf.c

256

.salt = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c",

crypto/hkdf.c

276

.salt = "\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f"

crypto/hkdf.c

304

.salt = NULL,

crypto/hkdf.c

320

.salt = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c",

crypto/hkdf.c

337

.salt = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"

crypto/hkdf.c

360

.salt = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c",

crypto/hkdf.c

381

.salt = "\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f"

crypto/hkdf.c

410

.salt = NULL,

crypto/hkdf.c

427

.salt = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c",

crypto/hkdf.c

445

.salt = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"

crypto/hkdf.c

45

unsigned int ikmlen, const u8 *salt, unsigned int saltlen,

crypto/hkdf.c

494

tv->salt, tv->salt_size, prk);

crypto/hkdf.c

50

err = crypto_shash_setkey(hmac_tfm, salt, saltlen);

crypto/seqiv.c

90

crypto_xor(info, ctx->salt, ivsize);

drivers/char/tpm/tpm2-sessions.c

112

u8 salt[EC_PT_SZ];

drivers/char/tpm/tpm2-sessions.c

549

sg_init_one(d, auth->salt, EC_PT_SZ);

drivers/char/tpm/tpm2-sessions.c

560

tpm2_KDFe(auth->salt, "SECRET", x, chip->null_ec_key_x, auth->salt);

drivers/char/tpm/tpm2-sessions.c

928

tpm2_KDFa(auth->salt, sizeof(auth->salt), "ATH", auth->tpm_nonce,

drivers/crypto/bcm/cipher.c

2702

ctx->salt, ctx->salt_len);

drivers/crypto/bcm/cipher.c

2906

memcpy(ctx->salt, key + keylen - GCM_ESP_SALT_SIZE, GCM_ESP_SALT_SIZE);

drivers/crypto/bcm/cipher.c

2910

flow_dump("salt: ", ctx->salt, GCM_ESP_SALT_SIZE);

drivers/crypto/bcm/cipher.c

2938

memcpy(ctx->salt, key + keylen - GCM_ESP_SALT_SIZE, GCM_ESP_SALT_SIZE);

drivers/crypto/bcm/cipher.c

2943

flow_dump("salt: ", ctx->salt, GCM_ESP_SALT_SIZE);

drivers/crypto/bcm/cipher.c

2971

memcpy(ctx->salt, key + keylen - CCM_ESP_SALT_SIZE, CCM_ESP_SALT_SIZE);

drivers/crypto/bcm/cipher.c

2974

flow_dump("salt: ", ctx->salt, CCM_ESP_SALT_SIZE);

drivers/crypto/bcm/cipher.h

186

u8 salt[MAX_SALT_SIZE];

drivers/crypto/caam/pdb.h

102

u8 salt[4];

drivers/crypto/caam/pdb.h

114

u8 salt[4];

drivers/crypto/caam/pdb.h

178

u8 salt[4];

drivers/crypto/caam/pdb.h

188

u8 salt[4];

drivers/crypto/caam/pdb.h

408

u16 salt[7];

drivers/crypto/caam/pdb.h

423

u16 salt[7];

drivers/crypto/chelsio/chcr_algo.c

2857

memcpy(ivptr + 1, &aeadctx->salt[0], 3);

drivers/crypto/chelsio/chcr_algo.c

3138

memcpy(ivptr, aeadctx->salt, 4);

drivers/crypto/chelsio/chcr_algo.c

3398

memcpy(aeadctx->salt, key + keylen, 3);

drivers/crypto/chelsio/chcr_algo.c

3422

memcpy(aeadctx->salt, key + keylen, 4);

drivers/crypto/chelsio/chcr_core.h

69

u8 salt[MAX_SALT];

drivers/crypto/chelsio/chcr_crypto.h

235

u8 salt[MAX_SALT];

drivers/crypto/hisilicon/sec2/sec_crypto.h

351

__le32 salt;

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

185

u8 salt[MAX_IVLEN];

drivers/md/dm-integrity.c

1664

r = crypto_shash_update(req, (__u8 *)&ic->sb->salt, SALT_SIZE);

drivers/md/dm-integrity.c

1724

sg_set_buf(s, (const __u8 *)&ic->sb->salt, SALT_SIZE);

drivers/md/dm-integrity.c

4178

get_random_bytes(ic->sb->salt, SALT_SIZE);

drivers/md/dm-integrity.c

804

r = crypto_shash_update(desc, (__u8 *)&ic->sb->salt, SALT_SIZE);

drivers/md/dm-integrity.c

85

__u8 salt[SALT_SIZE];

drivers/md/dm-verity-target.c

1081

kfree(v->salt);

drivers/md/dm-verity-target.c

1358

v->salt = kmalloc(v->salt_size, GFP_KERNEL);

drivers/md/dm-verity-target.c

1359

if (!v->salt) {

drivers/md/dm-verity-target.c

1364

hex2bin(v->salt, arg, v->salt_size)) {

drivers/md/dm-verity-target.c

1379

v->salt, v->salt_size);

drivers/md/dm-verity-target.c

1396

crypto_shash_update(desc, v->salt, v->salt_size) ?:

drivers/md/dm-verity-target.c

143

crypto_shash_update(desc, v->salt, v->salt_size) ?:

drivers/md/dm-verity-target.c

872

DMEMIT("%02x", v->salt[x]);

drivers/md/dm-verity-target.c

948

DMEMIT("%02x", v->salt[x]);

drivers/md/dm-verity.h

45

u8 *salt; /* salt: its size is salt_size */

drivers/net/ethernet/chelsio/inline_crypto/ch_ipsec/chcr_ipsec.c

178

memcpy(sa_entry->salt, key + keylen, 4);

drivers/net/ethernet/chelsio/inline_crypto/ch_ipsec/chcr_ipsec.c

531

memcpy(key_ctx->salt, sa_entry->salt, MAX_SALT);

drivers/net/ethernet/chelsio/inline_crypto/ch_ipsec/chcr_ipsec.h

52

char salt[MAX_SALT];

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_common.h

23

u8 salt[CHCR_MAX_SALT];

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1418

memcpy(pos, tx_info->key_ctx.salt, tx_info->salt_size);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

159

memcpy(kctx->salt, salt, tx_info->salt_size);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

80

unsigned char *key, *salt;

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

95

salt = info_128_gcm->salt;

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_hw.c

247

unsigned char *key_p, *salt;

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_hw.c

267

salt = gcm_ctx_128->salt;

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_hw.c

280

salt = gcm_ctx_256->salt;

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_hw.c

318

memcpy(kctx->salt, salt, salt_size);

drivers/net/ethernet/fungible/funcore/fun_hci.h

993

__u8 salt[8];

drivers/net/ethernet/fungible/funeth/funeth_ktls.c

50

memcpy(req.salt, c->salt, sizeof(c->salt));

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

22

u8 salt;

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

392

xn->salt = vcxn_mngr->salt++;

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

466

cookie = FIELD_PREP(IDPF_VC_XN_SALT_M, xn->salt) |

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

498

xn->salt, params->timeout_ms);

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

582

u16 salt;

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

593

salt = FIELD_GET(IDPF_VC_XN_SALT_M, msg_info);

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

594

if (xn->salt != salt) {

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

596

xn->vc_op, xn->salt, xn->state,

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

597

ctlq_msg->cookie.mbx.chnl_opcode, salt);

drivers/net/ethernet/intel/idpf/idpf_virtchnl.h

67

u8 salt;

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.c

22

u32 key[], u32 salt)

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.c

30

IXGBE_WRITE_REG(hw, IXGBE_IPSTXSALT, (__force u32)cpu_to_be32(salt));

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.c

327

r->key, r->salt,

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.c

335

ixgbe_ipsec_set_tx_sa(hw, i, t->key, t->salt);

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.c

621

ret = ixgbe_ipsec_parse_proto_keys(dev, xs, rsa.key, &rsa.salt);

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.c

700

rsa.salt, rsa.mode, rsa.iptbl_ind);

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.c

730

ret = ixgbe_ipsec_parse_proto_keys(dev, xs, tsa.key, &tsa.salt);

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.c

74

u32 key[], u32 salt, u32 mode, u32 ip_idx)

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.c

740

ixgbe_ipsec_set_tx_sa(hw, sa_idx, tsa.key, tsa.salt);

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.c

90

IXGBE_WRITE_REG(hw, IXGBE_IPSRXSALT, (__force u32)cpu_to_be32(salt));

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.h

36

u32 salt;

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.h

53

u32 salt;

drivers/net/ethernet/intel/ixgbevf/ipsec.c

319

&rsa.salt);

drivers/net/ethernet/intel/ixgbevf/ipsec.c

373

&tsa.salt);

drivers/net/ethernet/intel/ixgbevf/ipsec.h

22

u32 salt;

drivers/net/ethernet/intel/ixgbevf/ipsec.h

38

u32 salt;

drivers/net/ethernet/marvell/octeontx2/nic/cn10k_macsec.c

1316

memcpy(&txsc->salt[sa_num], sw_tx_sa->key.salt.bytes, MACSEC_SALT_LEN);

drivers/net/ethernet/marvell/octeontx2/nic/cn10k_macsec.c

1489

memcpy(&rxsc->salt[sa_num], rx_sa->key.salt.bytes, MACSEC_SALT_LEN);

drivers/net/ethernet/marvell/octeontx2/nic/cn10k_macsec.c

385

u8 *sak, u8 *salt, ssci_t ssci)

drivers/net/ethernet/marvell/octeontx2/nic/cn10k_macsec.c

407

salt_rev[i] = salt[MACSEC_SALT_LEN - 1 - i];

drivers/net/ethernet/marvell/octeontx2/nic/cn10k_macsec.c

426

u8 *salt = rxsc->salt[assoc_num];

drivers/net/ethernet/marvell/octeontx2/nic/cn10k_macsec.c

447

salt, rxsc->ssci[assoc_num]);

drivers/net/ethernet/marvell/octeontx2/nic/cn10k_macsec.c

665

u8 *salt = txsc->salt[assoc_num];

drivers/net/ethernet/marvell/octeontx2/nic/cn10k_macsec.c

678

salt, txsc->ssci[assoc_num]);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_common.h

427

u8 salt[CN10K_MCS_SA_PER_SC][MACSEC_SALT_LEN];

drivers/net/ethernet/marvell/octeontx2/nic/otx2_common.h

442

u8 salt[CN10K_MCS_SA_PER_SC][MACSEC_SALT_LEN];

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec.c

415

memcpy(&aes_gcm->seq_iv, &geniv_ctx->salt, ivsize);

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec.c

416

memcpy(&aes_gcm->salt, x->aead->alg_key + key_len,

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec.c

417

sizeof(aes_gcm->salt));

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec.h

49

u32 salt;

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_offload.c

159

salt_p = MLX5_ADDR_OF(ipsec_obj, obj, salt);

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_offload.c

160

memcpy(salt_p, &aes_gcm->salt, sizeof(aes_gcm->salt));

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_txrx.c

16

salt = info->salt; \

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_txrx.c

18

salt_sz = sizeof(info->salt); \

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_txrx.c

29

char *salt, *rec_seq;

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_txrx.c

59

memcpy(gcm_iv, salt, salt_sz);

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

139

salt_t salt;

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

269

salt_p = MLX5_ADDR_OF(macsec_offload_obj, obj, salt);

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

271

memcpy((u32 *)salt_p + i, &attrs->salt.bytes[4 * (2 - i)], 4);

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

384

memcpy(&obj_attrs.salt, &sa->salt, sizeof(sa->salt));

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

498

sa->salt = key->salt;

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

67

salt_t salt;

drivers/net/ethernet/netronome/nfp/crypto/fw.h

56

__be32 salt;

drivers/net/ethernet/netronome/nfp/crypto/ipsec.c

484

cfg->aesgcm_fields.salt = get_unaligned_be32(x->aead->alg_key + key_len);

drivers/net/ethernet/netronome/nfp/crypto/ipsec.c

93

u32 salt; /* Initialized with SA */

drivers/net/ethernet/netronome/nfp/crypto/tls.c

346

memcpy(&back->salt, tls_ci->salt, TLS_CIPHER_AES_GCM_128_SALT_SIZE);

drivers/net/macsec.c

1827

nla_memcpy(rx_sa->key.salt.bytes, tb_sa[MACSEC_SA_ATTR_SALT],

drivers/net/macsec.c

2035

nla_memcpy(tx_sa->key.salt.bytes, tb_sa[MACSEC_SA_ATTR_SALT],

drivers/net/macsec.c

439

salt_t salt)

drivers/net/macsec.c

443

gcm_iv->ssci = ssci ^ salt.ssci;

drivers/net/macsec.c

444

gcm_iv->pn = cpu_to_be64(pn) ^ salt.pn;

drivers/net/macsec.c

688

macsec_fill_iv_xpn(iv, tx_sa->ssci, pn.full64, tx_sa->key.salt);

drivers/net/macsec.c

924

rx_sa->key.salt);

drivers/net/netdevsim/ipsec.c

176

ret = nsim_ipsec_parse_proto_keys(dev, xs, sa.key, &sa.salt);

drivers/net/netdevsim/ipsec.c

53

sap->xs->id.proto, sap->salt, sap->crypt);

drivers/net/netdevsim/netdevsim.h

46

u32 salt;

drivers/net/phy/nxp-c45-tja11xx-macsec.c

1211

nxp_c45_sa_set_key(ctx, sa->regs, rx_sa->key.salt.bytes, rx_sa->ssci);

drivers/net/phy/nxp-c45-tja11xx-macsec.c

1300

nxp_c45_sa_set_key(ctx, sa->regs, tx_sa->key.salt.bytes, tx_sa->ssci);

drivers/net/phy/nxp-c45-tja11xx-macsec.c

214

u16 salt;

drivers/net/phy/nxp-c45-tja11xx-macsec.c

230

.salt = MACSEC_RXSA_A_SALT,

drivers/net/phy/nxp-c45-tja11xx-macsec.c

244

.salt = MACSEC_RXSA_B_SALT,

drivers/net/phy/nxp-c45-tja11xx-macsec.c

256

.salt = MACSEC_TXSA_A_SALT,

drivers/net/phy/nxp-c45-tja11xx-macsec.c

267

.salt = MACSEC_TXSA_B_SALT,

drivers/net/phy/nxp-c45-tja11xx-macsec.c

490

u8 *salt, ssci_t ssci)

drivers/net/phy/nxp-c45-tja11xx-macsec.c

496

u32 *salt_u32 = (u32 *)salt;

drivers/net/phy/nxp-c45-tja11xx-macsec.c

508

reg = sa_regs->salt + (2 - i) * 4;

drivers/scsi/qla2xxx/qla_edif.c

2465

sa_update_iocb->salt = cpu_to_le32(sa_frame->salt);

drivers/scsi/qla2xxx/qla_edif.c

2521

sa_update_iocb->salt = 0;

drivers/scsi/qla2xxx/qla_edif.h

83

__le32 salt;

drivers/scsi/qla2xxx/qla_edif_bsg.h

178

uint32_t salt;

fs/btrfs/send.c

5112

TLV_PUT(sctx, BTRFS_SEND_A_VERITY_SALT_DATA, desc->salt,

fs/ecryptfs/debug.c

20

char salt[ECRYPTFS_SALT_SIZE * 2 + 1];

fs/ecryptfs/debug.c

29

ecryptfs_to_hex(salt, auth_tok->token.password.salt,

fs/ecryptfs/debug.c

31

ecryptfs_printk(KERN_DEBUG, " * salt = [%s]\n", salt);

fs/ecryptfs/keystore.c

1427

memcpy((*new_auth_tok)->token.password.salt,

fs/ecryptfs/keystore.c

2326

memcpy(&dest[(*packet_size)], auth_tok->token.password.salt,

fs/namei.c

2394

unsigned int full_name_hash(const void *salt, const char *name, unsigned int len)

fs/namei.c

2396

unsigned long a, x = 0, y = (unsigned long)salt;

fs/namei.c

2415

u64 hashlen_string(const void *salt, const char *name)

fs/namei.c

2417

unsigned long a = 0, x = 0, y = (unsigned long)salt;

fs/namei.c

2509

unsigned int full_name_hash(const void *salt, const char *name, unsigned int len)

fs/namei.c

2511

unsigned long hash = init_name_hash(salt);

fs/namei.c

2519

u64 hashlen_string(const void *salt, const char *name)

fs/namei.c

2521

unsigned long hash = init_name_hash(salt);

fs/netfs/fscache_main.c

50

unsigned int fscache_hash(unsigned int salt, const void *data, size_t len)

fs/netfs/fscache_main.c

53

unsigned int a, x = 0, y = salt, n = len / sizeof(__le32);

fs/netfs/internal.h

362

extern unsigned int fscache_hash(unsigned int salt, const void *data, size_t len);

fs/notify/fanotify/fanotify.c

49

long salt = (long)fh->type | (long)fh->len << 8;

fs/notify/fanotify/fanotify.c

54

return full_name_hash((void *)salt, fanotify_fh_buf(fh), fh->len);

fs/unicode/utf8-core.c

121

int utf8_casefold_hash(const struct unicode_map *um, const void *salt,

fs/unicode/utf8-core.c

126

unsigned long hash = init_name_hash(salt);

fs/verity/enable.c

200

copy_from_user(desc->salt, u64_to_user_ptr(arg->salt_ptr),

fs/verity/enable.c

222

desc->salt, desc->salt_size);

fs/verity/enable.c

345

if (arg.salt_size > sizeof_field(struct fsverity_descriptor, salt))

fs/verity/fsverity_private.h

127

const u8 *salt, size_t salt_size);

fs/verity/fsverity_private.h

93

const u8 *salt, size_t salt_size);

fs/verity/hash_algs.c

56

const u8 *salt, size_t salt_size)

fs/verity/hash_algs.c

74

memcpy(padded_salt, salt, salt_size);

fs/verity/open.c

200

desc->salt, desc->salt_size);

fs/verity/open.c

287

if (desc->salt_size > sizeof(desc->salt)) {

fs/verity/open.c

42

const u8 *salt, size_t salt_size)

fs/verity/open.c

61

fsverity_prepare_hash_state(hash_alg, salt, salt_size);

include/crypto/hkdf.h

15

unsigned int ikmlen, const u8 *salt, unsigned int saltlen,

include/crypto/internal/geniv.h

18

u8 salt[] __attribute__ ((aligned(__alignof__(u32))));

include/linux/ecryptfs.h

79

u8 salt[ECRYPTFS_SALT_SIZE];

include/linux/mlx5/mlx5_ifc.h

12858

u8 salt[0x20];

include/linux/mlx5/mlx5_ifc.h

12952

u8 salt[3][0x20];

include/linux/platform_data/cros_ec_commands.h

6390

uint8_t salt[FP_CONTEXT_SALT_BYTES];

include/linux/stringhash.h

39

#define init_name_hash(salt) (unsigned long)(salt)

include/linux/stringhash.h

66

extern unsigned int __pure full_name_hash(const void *salt, const char *, unsigned int);

include/linux/stringhash.h

77

extern u64 __pure hashlen_string(const void *salt, const char *name);

include/linux/unicode.h

75

int utf8_casefold_hash(const struct unicode_map *um, const void *salt,

include/net/macsec.h

71

salt_t salt;

include/uapi/linux/fsverity.h

59

__u8 salt[32]; /* salt prepended to each hashed block */

include/uapi/linux/tls.h

130

unsigned char salt[TLS_CIPHER_AES_GCM_128_SALT_SIZE];

include/uapi/linux/tls.h

138

unsigned char salt[TLS_CIPHER_AES_GCM_256_SALT_SIZE];

include/uapi/linux/tls.h

146

unsigned char salt[TLS_CIPHER_AES_CCM_128_SALT_SIZE];

include/uapi/linux/tls.h

154

unsigned char salt[TLS_CIPHER_CHACHA20_POLY1305_SALT_SIZE];

include/uapi/linux/tls.h

162

unsigned char salt[TLS_CIPHER_SM4_GCM_SALT_SIZE];

include/uapi/linux/tls.h

170

unsigned char salt[TLS_CIPHER_SM4_CCM_SALT_SIZE];

include/uapi/linux/tls.h

178

unsigned char salt[TLS_CIPHER_ARIA_GCM_128_SALT_SIZE];

include/uapi/linux/tls.h

186

unsigned char salt[TLS_CIPHER_ARIA_GCM_256_SALT_SIZE];

include/uapi/rdma/ib_user_ioctl_verbs.h

158

__u32 salt;

lib/crypto/tests/sha256_kunit.c

59

u8 salt[SHA256_BLOCK_SIZE];

lib/crypto/tests/sha256_kunit.c

70

rand_bytes(salt, sizeof(salt));

lib/crypto/tests/sha256_kunit.c

74

size_t salt_len = rand_length(sizeof(salt));

lib/crypto/tests/sha256_kunit.c

81

sha256_update(ctx, salt, salt_len);

net/bluetooth/smp.c

1161

const u8 salt[16] = { 0x31, 0x70, 0x6d, 0x74 };

net/bluetooth/smp.c

1163

if (smp_h7(smp->tfm_cmac, smp->tk, salt, smp->link_key)) {

net/bluetooth/smp.c

1219

const u8 salt[16] = { 0x32, 0x70, 0x6d, 0x74 };

net/bluetooth/smp.c

1221

if (smp_h7(smp->tfm_cmac, key->val, salt, smp->tk))

net/bluetooth/smp.c

243

const u8 salt[16] = { 0xbe, 0x83, 0x60, 0x5a, 0xdb, 0x0b, 0x37, 0x60,

net/bluetooth/smp.c

253

err = aes_cmac(tfm_cmac, salt, w, 32, t);

net/bluetooth/smp.c

356

const u8 salt[16], u8 res[16])

net/bluetooth/smp.c

360

SMP_DBG("w %16phN salt %16phN", w, salt);

net/bluetooth/smp.c

362

err = aes_cmac(tfm_cmac, salt, w, 16, res);

net/sched/sch_sfb.c

255

int *qerr, u32 *salt)

net/sched/sch_sfb.c

273

*salt = TC_H_MIN(res.classid);

net/sched/sch_sfb.c

316

u32 salt;

net/sched/sch_sfb.c

319

if (!sfb_classify(skb, fl, &ret, &salt))

net/sched/sch_sfb.c

321

sfbhash = siphash_1u32(salt, &q->bins[slot].perturbation);

net/tipc/crypto.c

156

u32 salt;

net/tipc/crypto.c

604

memcpy(&tmp->salt, ukey->key + keylen, TIPC_AES_GCM_SALT_SIZE);

net/tipc/crypto.c

657

aead->salt = src->salt;

net/tipc/crypto.c

745

u32 salt;

net/tipc/crypto.c

792

salt = aead->salt;

net/tipc/crypto.c

794

salt ^= __be32_to_cpu(ehdr->addr);

net/tipc/crypto.c

796

salt ^= tipc_node_get_addr(__dnode);

net/tipc/crypto.c

797

memcpy(iv, &salt, 4);

net/tipc/crypto.c

897

u32 salt;

net/tipc/crypto.c

926

salt = aead->salt;

net/tipc/crypto.c

928

salt ^= __be32_to_cpu(ehdr->addr);

net/tipc/crypto.c

930

salt ^= tipc_own_addr(net);

net/tipc/crypto.c

931

memcpy(iv, &salt, 4);

net/tls/tls.h

58

unsigned int salt;

net/tls/tls_device.c

1110

memcpy(ctx->tx.iv + cipher_desc->salt, iv, cipher_desc->iv);

net/tls/tls_device_fallback.c

308

void *buf, *iv, *aad, *dummy_buf, *salt;

net/tls/tls_device_fallback.c

320

buf_len = cipher_desc->salt + cipher_desc->iv + TLS_AAD_SPACE_SIZE +

net/tls/tls_device_fallback.c

327

salt = crypto_info_salt(&tls_ctx->crypto_send.info, cipher_desc);

net/tls/tls_device_fallback.c

328

memcpy(iv, salt, cipher_desc->salt);

net/tls/tls_device_fallback.c

329

aad = buf + cipher_desc->salt + cipher_desc->iv;

net/tls/tls_device_fallback.c

73

memcpy(iv + cipher_desc->salt, buf + TLS_HEADER_SIZE, cipher_desc->iv);

net/tls/tls_main.c

485

cctx->iv + cipher_desc->salt, cipher_desc->iv);

net/tls/tls_main.c

68

static_assert(sizeof_field(struct ci, salt) == cipher ## _SALT_SIZE); \

net/tls/tls_main.c

74

.salt_offset = offsetof(struct ci, salt), \

net/tls/tls_main.c

82

.salt = cipher ## _SALT_SIZE, \

net/tls/tls_main.c

94

.salt = cipher ## _SALT_SIZE, \

net/tls/tls_sw.c

2763

prot->salt_size = cipher_desc->salt;

net/tls/tls_sw.c

2785

char *iv, *rec_seq, *key, *salt;

net/tls/tls_sw.c

2835

salt = crypto_info_salt(src_crypto_info, cipher_desc);

net/tls/tls_sw.c

2880

memcpy(cctx->iv, salt, cipher_desc->salt);

net/tls/tls_sw.c

2881

memcpy(cctx->iv + cipher_desc->salt, iv, cipher_desc->iv);

security/selinux/ss/policydb.c

421

unsigned long salt = ft->ttype ^ ft->tclass;

security/selinux/ss/policydb.c

423

return full_name_hash((void *)salt, ft->name, strlen(ft->name));

tools/include/uapi/linux/tls.h

74

unsigned char salt[TLS_CIPHER_AES_GCM_128_SALT_SIZE];