Lines Matching defs:vec
1222 const struct hash_testvec *vec,
1230 kv.iov_base = (void *)vec->plaintext;
1231 kv.iov_len = vec->psize;
1232 iov_iter_kvec(&input, ITER_SOURCE, &kv, 1, vec->psize);
1233 return build_test_sglist(tsgl, cfg->src_divs, alignmask, vec->psize,
1239 const struct hash_testvec *vec,
1244 if (memcmp(result, vec->digest, digestsize) != 0) {
1268 static int test_shash_vec_cfg(const struct hash_testvec *vec,
1285 if (vec->ksize) {
1286 err = do_setkey(crypto_shash_setkey, tfm, vec->key, vec->ksize,
1289 if (err == vec->setkey_error)
1292 driver, vec_name, vec->setkey_error, err,
1296 if (vec->setkey_error) {
1298 driver, vec_name, vec->setkey_error);
1304 err = build_hash_sglist(tsgl, vec, cfg, 0, divs);
1317 vec->digest_error) {
1328 if (err == vec->digest_error)
1331 driver, vec_name, vec->digest_error, err,
1335 if (vec->digest_error) {
1337 driver, vec_name, vec->digest_error, cfg->name);
1411 return check_hash_result("shash", result, digestsize, vec, vec_name,
1451 static int test_ahash_vec_cfg(const struct hash_testvec *vec,
1472 if (vec->ksize) {
1473 err = do_setkey(crypto_ahash_setkey, tfm, vec->key, vec->ksize,
1476 if (err == vec->setkey_error)
1479 driver, vec_name, vec->setkey_error, err,
1483 if (vec->setkey_error) {
1485 driver, vec_name, vec->setkey_error);
1491 err = build_hash_sglist(tsgl, vec, cfg, 0, divs);
1504 vec->digest_error) {
1508 ahash_request_set_crypt(req, tsgl->sgl, result, vec->psize);
1511 if (err == vec->digest_error)
1514 driver, vec_name, vec->digest_error, err,
1518 if (vec->digest_error) {
1520 driver, vec_name, vec->digest_error, cfg->name);
1612 return check_hash_result("ahash", result, digestsize, vec, vec_name,
1616 static int test_hash_vec_cfg(const struct hash_testvec *vec,
1633 err = test_shash_vec_cfg(vec, vec_name, cfg, desc, tsgl,
1639 return test_ahash_vec_cfg(vec, vec_name, cfg, req, tsgl, hashstate);
1642 static int test_hash_vec(const struct hash_testvec *vec, unsigned int vec_num,
1653 err = test_hash_vec_cfg(vec, vec_name,
1671 err = test_hash_vec_cfg(vec, vec_name, &cfg,
1685 * Assumes the buffers in 'vec' were already allocated.
1689 struct hash_testvec *vec,
1695 vec->psize = generate_random_length(rng, maxdatasize);
1696 generate_random_bytes(rng, (u8 *)vec->plaintext, vec->psize);
1702 vec->setkey_error = 0;
1703 vec->ksize = 0;
1705 vec->ksize = maxkeysize;
1707 vec->ksize = prandom_u32_inclusive(rng, 1, maxkeysize);
1708 generate_random_bytes(rng, (u8 *)vec->key, vec->ksize);
1710 vec->setkey_error = crypto_shash_setkey(desc->tfm, vec->key,
1711 vec->ksize);
1713 if (vec->setkey_error)
1718 vec->digest_error = crypto_shash_digest(desc, vec->plaintext,
1719 vec->psize, (u8 *)vec->digest);
1722 vec->psize, vec->ksize);
1747 struct hash_testvec vec = { 0 };
1817 vec.key = kmalloc(maxkeysize, GFP_KERNEL);
1818 vec.plaintext = kmalloc(maxdatasize, GFP_KERNEL);
1819 vec.digest = kmalloc(digestsize, GFP_KERNEL);
1820 if (!vec.key || !vec.plaintext || !vec.digest) {
1826 generate_random_hash_testvec(&rng, generic_desc, &vec,
1832 err = test_hash_vec_cfg(&vec, vec_name, cfg,
1841 kfree(vec.key);
1842 kfree(vec.plaintext);
1843 kfree(vec.digest);
2025 static int test_aead_vec_cfg(int enc, const struct aead_testvec *vec,
2034 const unsigned int authsize = vec->clen - vec->plen;
2047 if (vec->wk)
2052 err = do_setkey(crypto_aead_setkey, tfm, vec->key, vec->klen,
2054 if (err && err != vec->setkey_error) {
2056 driver, vec_name, vec->setkey_error, err,
2060 if (!err && vec->setkey_error) {
2062 driver, vec_name, vec->setkey_error);
2068 if (err && err != vec->setauthsize_error) {
2070 driver, vec_name, vec->setauthsize_error, err);
2073 if (!err && vec->setauthsize_error) {
2075 driver, vec_name, vec->setauthsize_error);
2079 if (vec->setkey_error || vec->setauthsize_error)
2085 if (vec->iv)
2086 memcpy(iv, vec->iv, ivsize);
2091 input[0].iov_base = (void *)vec->assoc;
2092 input[0].iov_len = vec->alen;
2093 input[1].iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext;
2094 input[1].iov_len = enc ? vec->plen : vec->clen;
2096 vec->alen + (enc ? vec->plen :
2097 vec->clen),
2098 vec->alen + (enc ? vec->clen :
2099 vec->plen),
2111 enc ? vec->plen : vec->clen, iv);
2112 aead_request_set_ad(req, vec->alen);
2121 if (req->cryptlen != (enc ? vec->plen : vec->clen) ||
2122 req->assoclen != vec->alen ||
2132 if (req->cryptlen != (enc ? vec->plen : vec->clen))
2134 if (req->assoclen != vec->alen)
2165 if ((err == 0 && vec->novrfy) ||
2166 (err != vec->crypt_error && !(err == -EBADMSG && vec->novrfy))) {
2169 if (vec->novrfy &&
2170 vec->crypt_error != 0 && vec->crypt_error != -EBADMSG)
2172 vec->crypt_error);
2173 else if (vec->novrfy)
2176 sprintf(expected_error, "%d", vec->crypt_error);
2191 err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext,
2192 enc ? vec->clen : vec->plen,
2193 vec->alen,
2209 static int test_aead_vec(int enc, const struct aead_testvec *vec,
2217 if (enc && vec->novrfy)
2223 err = test_aead_vec_cfg(enc, vec, vec_name,
2241 err = test_aead_vec_cfg(enc, vec, vec_name,
2263 struct aead_testvec vec;
2275 struct aead_testvec *vec, bool aad_iv,
2279 const unsigned int authsize = vec->clen - vec->plen;
2281 if (prandom_bool(rng) && vec->alen > aad_tail_size) {
2283 flip_random_bit(rng, (u8 *)vec->assoc,
2284 vec->alen - aad_tail_size);
2290 flip_random_bit(rng, (u8 *)vec->ctext + vec->plen, authsize);
2293 flip_random_bit(rng, (u8 *)vec->ctext, vec->clen);
2307 struct aead_testvec *vec,
2312 const unsigned int authsize = vec->clen - vec->plen;
2318 generate_random_bytes(rng, (u8 *)vec->assoc, vec->alen);
2319 if (suite->aad_iv && vec->alen >= ivsize)
2321 memcpy((u8 *)vec->assoc + vec->alen - ivsize, vec->iv, ivsize);
2325 generate_random_bytes(rng, (u8 *)vec->ctext, vec->clen);
2334 if (vec->alen)
2335 sg_set_buf(&src[i++], vec->assoc, vec->alen);
2336 if (vec->plen) {
2337 generate_random_bytes(rng, (u8 *)vec->ptext, vec->plen);
2338 sg_set_buf(&src[i++], vec->ptext, vec->plen);
2340 sg_init_one(&dst, vec->ctext, vec->alen + vec->clen);
2341 memcpy(iv, vec->iv, ivsize);
2343 aead_request_set_crypt(req, src, &dst, vec->plen, iv);
2344 aead_request_set_ad(req, vec->alen);
2345 vec->crypt_error = crypto_wait_req(crypto_aead_encrypt(req),
2348 if (vec->crypt_error != 0)
2350 memmove((u8 *)vec->ctext, vec->ctext + vec->alen, vec->clen);
2357 mutate_aead_message(rng, vec, suite->aad_iv, ivsize);
2359 vec->novrfy = 1;
2361 vec->crypt_error = -EINVAL;
2365 * Generate an AEAD test vector 'vec' using the implementation specified by
2366 * 'req'. The buffers in 'vec' must already be allocated.
2369 * test vectors (i.e. vectors with 'vec->novrfy=1') more often.
2373 struct aead_testvec *vec,
2387 vec->klen = maxkeysize;
2389 vec->klen = prandom_u32_below(rng, maxkeysize + 1);
2390 generate_random_bytes(rng, (u8 *)vec->key, vec->klen);
2391 vec->setkey_error = crypto_aead_setkey(tfm, vec->key, vec->klen);
2394 generate_random_bytes(rng, (u8 *)vec->iv, ivsize);
2405 vec->setauthsize_error = crypto_aead_setauthsize(tfm, authsize);
2410 vec->alen = 0;
2412 vec->alen = generate_random_length(rng, total_len);
2413 vec->plen = total_len - vec->alen;
2414 vec->clen = vec->plen + authsize;
2420 vec->novrfy = 0;
2421 vec->crypt_error = 0;
2422 if (vec->setkey_error == 0 && vec->setauthsize_error == 0)
2423 generate_aead_message(rng, req, suite, vec, prefer_inauthentic);
2426 vec->alen, vec->plen, authsize, vec->klen, vec->novrfy);
2435 generate_random_aead_testvec(&ctx->rng, ctx->req, &ctx->vec,
2440 if (ctx->vec.novrfy)
2458 * test vectors other than inauthentic ones (vec.novrfy=1) here.
2465 if (ctx->vec.novrfy) {
2469 err = test_aead_vec_cfg(DECRYPT, &ctx->vec,
2557 generate_random_aead_testvec(&ctx->rng, generic_req, &ctx->vec,
2565 if (!ctx->vec.novrfy) {
2566 err = test_aead_vec_cfg(ENCRYPT, &ctx->vec,
2572 if (ctx->vec.crypt_error == 0 || ctx->vec.novrfy) {
2573 err = test_aead_vec_cfg(DECRYPT, &ctx->vec,
2613 ctx->vec.key = kmalloc(ctx->maxkeysize, GFP_KERNEL);
2614 ctx->vec.iv = kmalloc(crypto_aead_ivsize(ctx->tfm), GFP_KERNEL);
2615 ctx->vec.assoc = kmalloc(ctx->maxdatasize, GFP_KERNEL);
2616 ctx->vec.ptext = kmalloc(ctx->maxdatasize, GFP_KERNEL);
2617 ctx->vec.ctext = kmalloc(ctx->maxdatasize, GFP_KERNEL);
2618 if (!ctx->vec.key || !ctx->vec.iv || !ctx->vec.assoc ||
2619 !ctx->vec.ptext || !ctx->vec.ctext) {
2630 kfree(ctx->vec.key);
2631 kfree(ctx->vec.iv);
2632 kfree(ctx->vec.assoc);
2633 kfree(ctx->vec.ptext);
2634 kfree(ctx->vec.ctext);
2804 static int test_skcipher_vec_cfg(int enc, const struct cipher_testvec *vec,
2825 if (vec->wk)
2830 err = do_setkey(crypto_skcipher_setkey, tfm, vec->key, vec->klen,
2833 if (err == vec->setkey_error)
2836 driver, vec_name, vec->setkey_error, err,
2840 if (vec->setkey_error) {
2842 driver, vec_name, vec->setkey_error);
2850 if (vec->generates_iv && !enc)
2851 memcpy(iv, vec->iv_out, ivsize);
2852 else if (vec->iv)
2853 memcpy(iv, vec->iv, ivsize);
2857 if (vec->generates_iv) {
2866 input.iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext;
2867 input.iov_len = vec->len;
2869 vec->len, vec->len, &input, 1);
2880 vec->len, iv);
2889 if (req->cryptlen != vec->len ||
2899 if (req->cryptlen != vec->len)
2931 if (err == vec->crypt_error)
2934 driver, op, vec_name, vec->crypt_error, err, cfg->name);
2937 if (vec->crypt_error) {
2939 driver, op, vec_name, vec->crypt_error, cfg->name);
2944 err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext,
2945 vec->len, 0, true);
2958 if (vec->iv_out && memcmp(iv, vec->iv_out, ivsize) != 0) {
2968 static int test_skcipher_vec(int enc, const struct cipher_testvec *vec,
2977 if (fips_enabled && vec->fips_skip)
2983 err = test_skcipher_vec_cfg(enc, vec, vec_name,
3001 err = test_skcipher_vec_cfg(enc, vec, vec_name,
3015 * Assumes the buffers in 'vec' were already allocated.
3019 struct cipher_testvec *vec,
3031 vec->klen = maxkeysize;
3033 vec->klen = prandom_u32_below(rng, maxkeysize + 1);
3034 generate_random_bytes(rng, (u8 *)vec->key, vec->klen);
3035 vec->setkey_error = crypto_skcipher_setkey(tfm, vec->key, vec->klen);
3038 generate_random_bytes(rng, (u8 *)vec->iv, ivsize);
3041 vec->len = generate_random_length(rng, maxdatasize);
3042 generate_random_bytes(rng, (u8 *)vec->ptext, vec->len);
3045 if (vec->setkey_error)
3049 sg_init_one(&src, vec->ptext, vec->len);
3050 sg_init_one(&dst, vec->ctext, vec->len);
3051 memcpy(iv, vec->iv, ivsize);
3053 skcipher_request_set_crypt(req, &src, &dst, vec->len, iv);
3054 vec->crypt_error = crypto_wait_req(crypto_skcipher_encrypt(req), &wait);
3055 if (vec->crypt_error != 0) {
3062 memset((u8 *)vec->ctext, 0, vec->len);
3066 vec->len, vec->klen);
3089 struct cipher_testvec vec = { 0 };
3178 vec.key = kmalloc(maxkeysize, GFP_KERNEL);
3179 vec.iv = kmalloc(ivsize, GFP_KERNEL);
3180 vec.ptext = kmalloc(maxdatasize, GFP_KERNEL);
3181 vec.ctext = kmalloc(maxdatasize, GFP_KERNEL);
3182 if (!vec.key || !vec.iv || !vec.ptext || !vec.ctext) {
3188 generate_random_cipher_testvec(&rng, generic_req, &vec,
3194 err = test_skcipher_vec_cfg(ENCRYPT, &vec, vec_name,
3198 err = test_skcipher_vec_cfg(DECRYPT, &vec, vec_name,
3207 kfree(vec.key);
3208 kfree(vec.iv);
3209 kfree(vec.ptext);
3210 kfree(vec.ctext);
3887 static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec,
3907 err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size);
3933 if (vec->genkey) {
3942 if (memcmp(vec->expected_a_public, sg_virt(req->dst),
3943 vec->expected_a_public_size)) {
3952 input_buf = kmemdup(vec->b_public, vec->b_public_size, GFP_KERNEL);
3958 sg_init_one(&src, input_buf, vec->b_public_size);
3960 kpp_request_set_input(req, &src, vec->b_public_size);
3971 if (vec->genkey) {
3973 a_ss = kmemdup(sg_virt(req->dst), vec->expected_ss_size, GFP_KERNEL);
3983 err = crypto_kpp_set_secret(tfm, vec->b_secret,
3984 vec->b_secret_size);
3988 sg_init_one(&src, a_public, vec->expected_a_public_size);
3990 kpp_request_set_input(req, &src, vec->expected_a_public_size);
4004 shared_secret = (void *)vec->expected_ss;
4012 vec->expected_ss_size)) {