Lines Matching refs:vec
1123 const struct hash_testvec *vec,
1131 kv.iov_base = (void *)vec->plaintext;
1132 kv.iov_len = vec->psize;
1133 iov_iter_kvec(&input, WRITE, &kv, 1, vec->psize);
1134 return build_test_sglist(tsgl, cfg->src_divs, alignmask, vec->psize,
1140 const struct hash_testvec *vec,
1145 if (memcmp(result, vec->digest, digestsize) != 0) {
1175 const struct hash_testvec *vec,
1192 if (vec->ksize) {
1193 err = do_setkey(crypto_shash_setkey, tfm, vec->key, vec->ksize,
1196 if (err == vec->setkey_error)
1199 driver, vec_name, vec->setkey_error, err,
1203 if (vec->setkey_error) {
1205 driver, vec_name, vec->setkey_error);
1211 err = build_hash_sglist(tsgl, vec, cfg, alignmask, divs);
1224 vec->digest_error) {
1235 if (err == vec->digest_error)
1238 driver, vec_name, vec->digest_error, err,
1242 if (vec->digest_error) {
1244 driver, vec_name, vec->digest_error, cfg->name);
1318 return check_hash_result("shash", result, digestsize, vec, vec_name,
1359 const struct hash_testvec *vec,
1380 if (vec->ksize) {
1381 err = do_setkey(crypto_ahash_setkey, tfm, vec->key, vec->ksize,
1384 if (err == vec->setkey_error)
1387 driver, vec_name, vec->setkey_error, err,
1391 if (vec->setkey_error) {
1393 driver, vec_name, vec->setkey_error);
1399 err = build_hash_sglist(tsgl, vec, cfg, alignmask, divs);
1412 vec->digest_error) {
1416 ahash_request_set_crypt(req, tsgl->sgl, result, vec->psize);
1419 if (err == vec->digest_error)
1422 driver, vec_name, vec->digest_error, err,
1426 if (vec->digest_error) {
1428 driver, vec_name, vec->digest_error, cfg->name);
1520 return check_hash_result("ahash", result, digestsize, vec, vec_name,
1525 const struct hash_testvec *vec,
1542 err = test_shash_vec_cfg(driver, vec, vec_name, cfg, desc, tsgl,
1548 return test_ahash_vec_cfg(driver, vec, vec_name, cfg, req, tsgl,
1552 static int test_hash_vec(const char *driver, const struct hash_testvec *vec,
1564 err = test_hash_vec_cfg(driver, vec, vec_name,
1579 err = test_hash_vec_cfg(driver, vec, vec_name, &cfg,
1593 * Assumes the buffers in 'vec' were already allocated.
1596 struct hash_testvec *vec,
1602 vec->psize = generate_random_length(maxdatasize);
1603 generate_random_bytes((u8 *)vec->plaintext, vec->psize);
1609 vec->setkey_error = 0;
1610 vec->ksize = 0;
1612 vec->ksize = maxkeysize;
1614 vec->ksize = 1 + (prandom_u32() % maxkeysize);
1615 generate_random_bytes((u8 *)vec->key, vec->ksize);
1617 vec->setkey_error = crypto_shash_setkey(desc->tfm, vec->key,
1618 vec->ksize);
1620 if (vec->setkey_error)
1625 vec->digest_error = crypto_shash_digest(desc, vec->plaintext,
1626 vec->psize, (u8 *)vec->digest);
1629 vec->psize, vec->ksize);
1653 struct hash_testvec vec = { 0 };
1721 vec.key = kmalloc(maxkeysize, GFP_KERNEL);
1722 vec.plaintext = kmalloc(maxdatasize, GFP_KERNEL);
1723 vec.digest = kmalloc(digestsize, GFP_KERNEL);
1724 if (!vec.key || !vec.plaintext || !vec.digest) {
1730 generate_random_hash_testvec(generic_desc, &vec,
1735 err = test_hash_vec_cfg(driver, &vec, vec_name, cfg,
1744 kfree(vec.key);
1745 kfree(vec.plaintext);
1746 kfree(vec.digest);
1927 const struct aead_testvec *vec,
1936 const unsigned int authsize = vec->clen - vec->plen;
1948 if (vec->wk)
1953 err = do_setkey(crypto_aead_setkey, tfm, vec->key, vec->klen,
1955 if (err && err != vec->setkey_error) {
1957 driver, vec_name, vec->setkey_error, err,
1961 if (!err && vec->setkey_error) {
1963 driver, vec_name, vec->setkey_error);
1969 if (err && err != vec->setauthsize_error) {
1971 driver, vec_name, vec->setauthsize_error, err);
1974 if (!err && vec->setauthsize_error) {
1976 driver, vec_name, vec->setauthsize_error);
1980 if (vec->setkey_error || vec->setauthsize_error)
1986 if (vec->iv)
1987 memcpy(iv, vec->iv, ivsize);
1992 input[0].iov_base = (void *)vec->assoc;
1993 input[0].iov_len = vec->alen;
1994 input[1].iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext;
1995 input[1].iov_len = enc ? vec->plen : vec->clen;
1997 vec->alen + (enc ? vec->plen :
1998 vec->clen),
1999 vec->alen + (enc ? vec->clen :
2000 vec->plen),
2012 enc ? vec->plen : vec->clen, iv);
2013 aead_request_set_ad(req, vec->alen);
2022 if (req->cryptlen != (enc ? vec->plen : vec->clen) ||
2023 req->assoclen != vec->alen ||
2033 if (req->cryptlen != (enc ? vec->plen : vec->clen))
2035 if (req->assoclen != vec->alen)
2066 if ((err == 0 && vec->novrfy) ||
2067 (err != vec->crypt_error && !(err == -EBADMSG && vec->novrfy))) {
2070 if (vec->novrfy &&
2071 vec->crypt_error != 0 && vec->crypt_error != -EBADMSG)
2073 vec->crypt_error);
2074 else if (vec->novrfy)
2077 sprintf(expected_error, "%d", vec->crypt_error);
2092 err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext,
2093 enc ? vec->clen : vec->plen,
2094 vec->alen, enc || !cfg->inplace);
2110 const struct aead_testvec *vec, unsigned int vec_num,
2118 if (enc && vec->novrfy)
2124 err = test_aead_vec_cfg(driver, enc, vec, vec_name,
2139 err = test_aead_vec_cfg(driver, enc, vec, vec_name,
2161 struct aead_testvec vec;
2172 static void mutate_aead_message(struct aead_testvec *vec, bool aad_iv,
2176 const unsigned int authsize = vec->clen - vec->plen;
2178 if (prandom_u32() % 2 == 0 && vec->alen > aad_tail_size) {
2180 flip_random_bit((u8 *)vec->assoc, vec->alen - aad_tail_size);
2186 flip_random_bit((u8 *)vec->ctext + vec->plen, authsize);
2189 flip_random_bit((u8 *)vec->ctext, vec->clen);
2202 struct aead_testvec *vec,
2207 const unsigned int authsize = vec->clen - vec->plen;
2212 generate_random_bytes((u8 *)vec->assoc, vec->alen);
2213 if (suite->aad_iv && vec->alen >= ivsize)
2215 memcpy((u8 *)vec->assoc + vec->alen - ivsize, vec->iv, ivsize);
2219 generate_random_bytes((u8 *)vec->ctext, vec->clen);
2228 if (vec->alen)
2229 sg_set_buf(&src[i++], vec->assoc, vec->alen);
2230 if (vec->plen) {
2231 generate_random_bytes((u8 *)vec->ptext, vec->plen);
2232 sg_set_buf(&src[i++], vec->ptext, vec->plen);
2234 sg_init_one(&dst, vec->ctext, vec->alen + vec->clen);
2235 memcpy(iv, vec->iv, ivsize);
2237 aead_request_set_crypt(req, src, &dst, vec->plen, iv);
2238 aead_request_set_ad(req, vec->alen);
2239 vec->crypt_error = crypto_wait_req(crypto_aead_encrypt(req),
2242 if (vec->crypt_error != 0)
2244 memmove((u8 *)vec->ctext, vec->ctext + vec->alen, vec->clen);
2251 mutate_aead_message(vec, suite->aad_iv, ivsize);
2253 vec->novrfy = 1;
2255 vec->crypt_error = -EINVAL;
2259 * Generate an AEAD test vector 'vec' using the implementation specified by
2260 * 'req'. The buffers in 'vec' must already be allocated.
2263 * test vectors (i.e. vectors with 'vec->novrfy=1') more often.
2266 struct aead_testvec *vec,
2280 vec->klen = maxkeysize;
2282 vec->klen = prandom_u32() % (maxkeysize + 1);
2283 generate_random_bytes((u8 *)vec->key, vec->klen);
2284 vec->setkey_error = crypto_aead_setkey(tfm, vec->key, vec->klen);
2287 generate_random_bytes((u8 *)vec->iv, ivsize);
2298 vec->setauthsize_error = crypto_aead_setauthsize(tfm, authsize);
2303 vec->alen = 0;
2305 vec->alen = generate_random_length(total_len);
2306 vec->plen = total_len - vec->alen;
2307 vec->clen = vec->plen + authsize;
2313 vec->novrfy = 0;
2314 vec->crypt_error = 0;
2315 if (vec->setkey_error == 0 && vec->setauthsize_error == 0)
2316 generate_aead_message(req, suite, vec, prefer_inauthentic);
2319 vec->alen, vec->plen, authsize, vec->klen, vec->novrfy);
2328 generate_random_aead_testvec(ctx->req, &ctx->vec,
2333 if (ctx->vec.novrfy)
2351 * test vectors other than inauthentic ones (vec.novrfy=1) here.
2358 if (ctx->vec.novrfy) {
2361 err = test_aead_vec_cfg(ctx->driver, DECRYPT, &ctx->vec,
2449 generate_random_aead_testvec(generic_req, &ctx->vec,
2456 if (!ctx->vec.novrfy) {
2457 err = test_aead_vec_cfg(driver, ENCRYPT, &ctx->vec,
2463 if (ctx->vec.crypt_error == 0 || ctx->vec.novrfy) {
2464 err = test_aead_vec_cfg(driver, DECRYPT, &ctx->vec,
2505 ctx->vec.key = kmalloc(ctx->maxkeysize, GFP_KERNEL);
2506 ctx->vec.iv = kmalloc(crypto_aead_ivsize(ctx->tfm), GFP_KERNEL);
2507 ctx->vec.assoc = kmalloc(ctx->maxdatasize, GFP_KERNEL);
2508 ctx->vec.ptext = kmalloc(ctx->maxdatasize, GFP_KERNEL);
2509 ctx->vec.ctext = kmalloc(ctx->maxdatasize, GFP_KERNEL);
2510 if (!ctx->vec.key || !ctx->vec.iv || !ctx->vec.assoc ||
2511 !ctx->vec.ptext || !ctx->vec.ctext) {
2522 kfree(ctx->vec.key);
2523 kfree(ctx->vec.iv);
2524 kfree(ctx->vec.assoc);
2525 kfree(ctx->vec.ptext);
2526 kfree(ctx->vec.ctext);
2699 const struct cipher_testvec *vec,
2719 if (vec->wk)
2724 err = do_setkey(crypto_skcipher_setkey, tfm, vec->key, vec->klen,
2727 if (err == vec->setkey_error)
2730 driver, vec_name, vec->setkey_error, err,
2734 if (vec->setkey_error) {
2736 driver, vec_name, vec->setkey_error);
2744 if (vec->generates_iv && !enc)
2745 memcpy(iv, vec->iv_out, ivsize);
2746 else if (vec->iv)
2747 memcpy(iv, vec->iv, ivsize);
2751 if (vec->generates_iv) {
2760 input.iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext;
2761 input.iov_len = vec->len;
2763 vec->len, vec->len, &input, 1);
2774 vec->len, iv);
2783 if (req->cryptlen != vec->len ||
2793 if (req->cryptlen != vec->len)
2825 if (err == vec->crypt_error)
2828 driver, op, vec_name, vec->crypt_error, err, cfg->name);
2831 if (vec->crypt_error) {
2833 driver, op, vec_name, vec->crypt_error, cfg->name);
2838 err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext,
2839 vec->len, 0, true);
2852 if (vec->iv_out && memcmp(iv, vec->iv_out, ivsize) != 0) {
2863 const struct cipher_testvec *vec,
2872 if (fips_enabled && vec->fips_skip)
2878 err = test_skcipher_vec_cfg(driver, enc, vec, vec_name,
2893 err = test_skcipher_vec_cfg(driver, enc, vec, vec_name,
2907 * Assumes the buffers in 'vec' were already allocated.
2910 struct cipher_testvec *vec,
2922 vec->klen = maxkeysize;
2924 vec->klen = prandom_u32() % (maxkeysize + 1);
2925 generate_random_bytes((u8 *)vec->key, vec->klen);
2926 vec->setkey_error = crypto_skcipher_setkey(tfm, vec->key, vec->klen);
2929 generate_random_bytes((u8 *)vec->iv, ivsize);
2932 vec->len = generate_random_length(maxdatasize);
2933 generate_random_bytes((u8 *)vec->ptext, vec->len);
2936 if (vec->setkey_error)
2940 sg_init_one(&src, vec->ptext, vec->len);
2941 sg_init_one(&dst, vec->ctext, vec->len);
2942 memcpy(iv, vec->iv, ivsize);
2944 skcipher_request_set_crypt(req, &src, &dst, vec->len, iv);
2945 vec->crypt_error = crypto_wait_req(crypto_skcipher_encrypt(req), &wait);
2946 if (vec->crypt_error != 0) {
2953 memset((u8 *)vec->ctext, 0, vec->len);
2957 vec->len, vec->klen);
2979 struct cipher_testvec vec = { 0 };
3066 vec.key = kmalloc(maxkeysize, GFP_KERNEL);
3067 vec.iv = kmalloc(ivsize, GFP_KERNEL);
3068 vec.ptext = kmalloc(maxdatasize, GFP_KERNEL);
3069 vec.ctext = kmalloc(maxdatasize, GFP_KERNEL);
3070 if (!vec.key || !vec.iv || !vec.ptext || !vec.ctext) {
3076 generate_random_cipher_testvec(generic_req, &vec, maxdatasize,
3080 err = test_skcipher_vec_cfg(driver, ENCRYPT, &vec, vec_name,
3084 err = test_skcipher_vec_cfg(driver, DECRYPT, &vec, vec_name,
3093 kfree(vec.key);
3094 kfree(vec.iv);
3095 kfree(vec.ptext);
3096 kfree(vec.ctext);
3746 static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec,
3766 err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size);
3792 if (vec->genkey) {
3801 if (memcmp(vec->expected_a_public, sg_virt(req->dst),
3802 vec->expected_a_public_size)) {
3811 input_buf = kmemdup(vec->b_public, vec->b_public_size, GFP_KERNEL);
3817 sg_init_one(&src, input_buf, vec->b_public_size);
3819 kpp_request_set_input(req, &src, vec->b_public_size);
3830 if (vec->genkey) {
3832 a_ss = kmemdup(sg_virt(req->dst), vec->expected_ss_size, GFP_KERNEL);
3842 err = crypto_kpp_set_secret(tfm, vec->b_secret,
3843 vec->b_secret_size);
3847 sg_init_one(&src, a_public, vec->expected_a_public_size);
3849 kpp_request_set_input(req, &src, vec->expected_a_public_size);
3863 shared_secret = (void *)vec->expected_ss;
3871 vec->expected_ss_size)) {