arch/arm/crypto/ghash-ce-glue.c

120

int buf_added = min(count, GHASH_BLOCK_SIZE - *buf_count);

arch/arm/crypto/ghash-ce-glue.c

129

if (count >= GHASH_BLOCK_SIZE || *buf_count == GHASH_BLOCK_SIZE) {

arch/arm/crypto/ghash-ce-glue.c

130

int blocks = count / GHASH_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

135

src += blocks * GHASH_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

136

count %= GHASH_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

150

u8 buf[GHASH_BLOCK_SIZE];

arch/arm/crypto/ghash-ce-glue.c

172

memset(&buf[buf_count], 0, GHASH_BLOCK_SIZE - buf_count);

arch/arm64/crypto/ghash-ce-glue.c

114

int buf_added = min(count, GHASH_BLOCK_SIZE - *buf_count);

arch/arm64/crypto/ghash-ce-glue.c

123

if (count >= GHASH_BLOCK_SIZE || *buf_count == GHASH_BLOCK_SIZE) {

arch/arm64/crypto/ghash-ce-glue.c

124

int blocks = count / GHASH_BLOCK_SIZE;

arch/arm64/crypto/ghash-ce-glue.c

128

src += blocks * GHASH_BLOCK_SIZE;

arch/arm64/crypto/ghash-ce-glue.c

129

count %= GHASH_BLOCK_SIZE;

arch/arm64/crypto/ghash-ce-glue.c

143

u8 buf[GHASH_BLOCK_SIZE];

arch/arm64/crypto/ghash-ce-glue.c

159

memset(&buf[buf_count], 0, GHASH_BLOCK_SIZE - buf_count);

arch/arm64/crypto/ghash-ce-glue.c

77

u8 key[GHASH_BLOCK_SIZE];

arch/arm64/crypto/ghash-ce-glue.c

88

memcpy(&ctx->ghash_key.k, key, GHASH_BLOCK_SIZE);

arch/arm64/crypto/sm4-ce-gcm-glue.c

107

nblocks = n / GHASH_BLOCK_SIZE;

arch/arm64/crypto/sm4-ce-gcm-glue.c

111

p += nblocks * GHASH_BLOCK_SIZE;

arch/arm64/crypto/sm4-ce-gcm-glue.c

114

buflen = n % GHASH_BLOCK_SIZE;

arch/arm64/crypto/sm4-ce-gcm-glue.c

125

memset(&buffer[buflen], 0, GHASH_BLOCK_SIZE - buflen);

arch/arm64/crypto/sm4-ce-gcm-glue.c

75

u8 __aligned(8) buffer[GHASH_BLOCK_SIZE];

arch/arm64/crypto/sm4-ce-gcm-glue.c

90

if (n + buflen < GHASH_BLOCK_SIZE) {

arch/arm64/crypto/sm4-ce-gcm-glue.c

97

unsigned int l = GHASH_BLOCK_SIZE - buflen;

arch/s390/crypto/aes_s390.c

838

u8 j0[GHASH_BLOCK_SIZE];/* initial counter value */

arch/s390/crypto/aes_s390.c

933

.ivsize = GHASH_BLOCK_SIZE - sizeof(u32),

crypto/gcm.c

170

static const u8 zeroes[GHASH_BLOCK_SIZE];

crypto/gcm.c

173

unsigned int pad_len = -len % GHASH_BLOCK_SIZE;

crypto/gcm.c

191

unsigned int datalen, u8 out[GHASH_BLOCK_SIZE])

crypto/gcm.c

75

u8 h[GHASH_BLOCK_SIZE];

drivers/crypto/inside-secure/safexcel_cipher.c

2559

ctx->state_sz = GHASH_BLOCK_SIZE;

include/crypto/gf128hash.h

113

const u8 raw_key[GHASH_BLOCK_SIZE]);

include/crypto/gf128hash.h

221

void ghash_final(struct ghash_ctx *ctx, u8 out[GHASH_BLOCK_SIZE]);

include/crypto/gf128hash.h

247

size_t len, u8 out[GHASH_BLOCK_SIZE])

include/crypto/gf128hash.h

49

u8 h_raw[GHASH_BLOCK_SIZE];

lib/crypto/aesgcm.c

60

static const u8 zeroes[GHASH_BLOCK_SIZE];

lib/crypto/aesgcm.c

72

ghash_update(&ghash, zeroes, -assoc_len & (GHASH_BLOCK_SIZE - 1));

lib/crypto/aesgcm.c

75

ghash_update(&ghash, zeroes, -src_len & (GHASH_BLOCK_SIZE - 1));

lib/crypto/arm/gf128hash.h

26

min_t(size_t, nblocks, 4096 / GHASH_BLOCK_SIZE);

lib/crypto/arm/gf128hash.h

30

data += n * GHASH_BLOCK_SIZE;

lib/crypto/arm64/gf128hash.h

52

static const u8 zeroes[GHASH_BLOCK_SIZE];

lib/crypto/gf128hash.c

224

data += GHASH_BLOCK_SIZE;

lib/crypto/gf128hash.c

241

static void __maybe_unused ghash_key_to_polyval(const u8 in[GHASH_BLOCK_SIZE],

lib/crypto/gf128hash.c

256

u8 out[GHASH_BLOCK_SIZE])

lib/crypto/gf128hash.c

263

static void __maybe_unused ghash_acc_to_polyval(const u8 in[GHASH_BLOCK_SIZE],

lib/crypto/gf128hash.c

274

void ghash_preparekey(struct ghash_key *key, const u8 raw_key[GHASH_BLOCK_SIZE])

lib/crypto/gf128hash.c

289

static const u8 zeroes[GHASH_BLOCK_SIZE];

lib/crypto/gf128hash.c

310

size_t n = min(len, GHASH_BLOCK_SIZE - ctx->partial);

lib/crypto/gf128hash.c

314

ctx->acc.bytes[GHASH_BLOCK_SIZE - 1 - ctx->partial++] ^=

lib/crypto/gf128hash.c

316

if (ctx->partial < GHASH_BLOCK_SIZE)

lib/crypto/gf128hash.c

320

if (len >= GHASH_BLOCK_SIZE) {

lib/crypto/gf128hash.c

321

size_t nblocks = len / GHASH_BLOCK_SIZE;

lib/crypto/gf128hash.c

324

data += len & ~(GHASH_BLOCK_SIZE - 1);

lib/crypto/gf128hash.c

325

len &= GHASH_BLOCK_SIZE - 1;

lib/crypto/gf128hash.c

328

ctx->acc.bytes[GHASH_BLOCK_SIZE - 1 - i] ^= data[i];

lib/crypto/gf128hash.c

333

void ghash_final(struct ghash_ctx *ctx, u8 out[GHASH_BLOCK_SIZE])

lib/crypto/powerpc/gf128hash.h

25

const u8 raw_key[GHASH_BLOCK_SIZE])

lib/crypto/powerpc/gf128hash.h

58

u8 ghash_acc[GHASH_BLOCK_SIZE];

lib/crypto/powerpc/gf128hash.h

83

u8 ghash_acc[GHASH_BLOCK_SIZE];

lib/crypto/powerpc/gf128hash.h

91

nblocks * GHASH_BLOCK_SIZE);

lib/crypto/riscv/gf128hash.h

15

asmlinkage void ghash_zvkg(u8 accumulator[GHASH_BLOCK_SIZE],

lib/crypto/riscv/gf128hash.h

16

const u8 key[GHASH_BLOCK_SIZE],

lib/crypto/riscv/gf128hash.h

21

const u8 raw_key[GHASH_BLOCK_SIZE])

lib/crypto/riscv/gf128hash.h

27

memcpy(key->h_raw, raw_key, GHASH_BLOCK_SIZE);

lib/crypto/riscv/gf128hash.h

36

u8 ghash_acc[GHASH_BLOCK_SIZE];

lib/crypto/s390/gf128hash.h

14

const u8 raw_key[GHASH_BLOCK_SIZE])

lib/crypto/s390/gf128hash.h

20

memcpy(key->h_raw, raw_key, GHASH_BLOCK_SIZE);

lib/crypto/s390/gf128hash.h

33

u8 ctx[2][GHASH_BLOCK_SIZE] __aligned(8);

lib/crypto/s390/gf128hash.h

36

memcpy(ctx[1], key->h_raw, GHASH_BLOCK_SIZE);

lib/crypto/s390/gf128hash.h

39

nblocks * GHASH_BLOCK_SIZE);

lib/crypto/tests/ghash_kunit.c

117

u8 raw_key[GHASH_BLOCK_SIZE];

lib/crypto/tests/ghash_kunit.c

136

u8 raw_key[GHASH_BLOCK_SIZE];

lib/crypto/tests/ghash_kunit.c

163

u8 raw_key[GHASH_BLOCK_SIZE];

lib/crypto/tests/ghash_kunit.c

21

u8 out[GHASH_BLOCK_SIZE])

lib/crypto/tests/ghash_kunit.c

29

#define HASH_SIZE GHASH_BLOCK_SIZE

lib/crypto/tests/ghash_kunit.c

44

u8 hash[GHASH_BLOCK_SIZE];

lib/crypto/tests/ghash_kunit.c

72

u8 hash1[GHASH_BLOCK_SIZE];

lib/crypto/tests/ghash_kunit.c

73

u8 hash2[GHASH_BLOCK_SIZE];

lib/crypto/tests/ghash_kunit.c

90

u8 raw_key[GHASH_BLOCK_SIZE];

lib/crypto/x86/gf128hash.h

89

4096 / GHASH_BLOCK_SIZE);

lib/crypto/x86/gf128hash.h

94

data += n * GHASH_BLOCK_SIZE;