diff --git a/doc/guides/cryptodevs/kasumi.rst b/doc/guides/cryptodevs/kasumi.rst
index bff9321..273ed18 100644
--- a/doc/guides/cryptodevs/kasumi.rst
+++ b/doc/guides/cryptodevs/kasumi.rst
@@ -51,7 +51,7 @@ Limitations
 -----------
 
 * Chained mbufs are not supported.
-* KASUMI(F9) supported only if hash offset field is byte-aligned.
+* KASUMI(F9) supported only if hash offset and length field is byte-aligned.
 * In-place bit-level operations for KASUMI(F8) are not supported
   (if length and/or offset of data to be ciphered is not byte-aligned).
 
@@ -108,3 +108,20 @@ Example:
 .. code-block:: console
 
     ./l2fwd-crypto -l 6 -n 4 --vdev="crypto_kasumi,socket_id=1,max_nb_sessions=128"
+
+Extra notes on KASUMI F9
+------------------------
+
+When using KASUMI F9 authentication algorithm, the input buffer must be
+constructed according to the 3GPP KASUMI specifications (section 4.4, page 13):
+`<http://cryptome.org/3gpp/35201-900.pdf>`_.
+Input buffer has to have COUNT (4 bytes), FRESH (4 bytes), MESSAGE and DIRECTION (1 bit)
+concatenated. After the DIRECTION bit, a single '1' bit is appended, followed by
+between 0 and 7 '0' bits, so that the total length of the buffer is multiple of 8 bits.
+Note that the actual message can be any length, specified in bits.
+
+Once this buffer is passed this way, when creating the crypto operation,
+length of data to authenticate (op.sym.auth.data.length) must be the length
+of all the items described above, including the padding at the end.
+Also, offset of data to authenticate (op.sym.auth.data.offset)
+must be such that points at the start of the COUNT bytes.
diff --git a/doc/guides/cryptodevs/qat.rst b/doc/guides/cryptodevs/qat.rst
index b2d05e5..21c7f5d 100644
--- a/doc/guides/cryptodevs/qat.rst
+++ b/doc/guides/cryptodevs/qat.rst
@@ -366,3 +366,21 @@ Another way to bind the VFs to the DPDK UIO driver is by using the
 
     cd to the top-level DPDK directory
     ./usertools/dpdk-devbind.py -b igb_uio 0000:03:01.1
+
+
+Extra notes on KASUMI F9
+------------------------
+
+When using KASUMI F9 authentication algorithm, the input buffer must be
+constructed according to the 3GPP KASUMI specifications (section 4.4, page 13):
+`<http://cryptome.org/3gpp/35201-900.pdf>`_.
+Input buffer has to have COUNT (4 bytes), FRESH (4 bytes), MESSAGE and DIRECTION (1 bit)
+concatenated. After the DIRECTION bit, a single '1' bit is appended, followed by
+between 0 and 7 '0' bits, so that the total length of the buffer is multiple of 8 bits.
+Note that the actual message can be any length, specified in bits.
+
+Once this buffer is passed this way, when creating the crypto operation,
+length of data to authenticate (op.sym.auth.data.length) must be the length
+of all the items described above, including the padding at the end.
+Also, offset of data to authenticate (op.sym.auth.data.offset)
+must be such that points at the start of the COUNT bytes.
diff --git a/drivers/crypto/kasumi/rte_kasumi_pmd.c b/drivers/crypto/kasumi/rte_kasumi_pmd.c
index cff40fb..0e12913 100644
--- a/drivers/crypto/kasumi/rte_kasumi_pmd.c
+++ b/drivers/crypto/kasumi/rte_kasumi_pmd.c
@@ -142,12 +142,6 @@ kasumi_set_session_parameters(struct kasumi_session *sess,
 
 		sess->auth_op = auth_xform->auth.op;
 
-		sess->auth_iv_offset = auth_xform->auth.iv.offset;
-		if (auth_xform->auth.iv.length != KASUMI_IV_LENGTH) {
-			KASUMI_LOG_ERR("Wrong IV length");
-			return -EINVAL;
-		}
-
 		/* Initialize key */
 		sso_kasumi_init_f9_key_sched(auth_xform->auth.key.data,
 				&sess->pKeySched_hash);
@@ -274,12 +268,8 @@ process_kasumi_hash_op(struct rte_crypto_op **ops,
 	unsigned i;
 	uint8_t processed_ops = 0;
 	uint8_t *src, *dst;
-	uint8_t *iv_ptr;
 	uint32_t length_in_bits;
 	uint32_t num_bytes;
-	uint32_t shift_bits;
-	uint64_t iv;
-	uint8_t direction;
 
 	for (i = 0; i < num_ops; i++) {
 		/* Data must be byte aligned */
@@ -293,21 +283,15 @@ process_kasumi_hash_op(struct rte_crypto_op **ops,
 
 		src = rte_pktmbuf_mtod(ops[i]->sym->m_src, uint8_t *) +
 				(ops[i]->sym->auth.data.offset >> 3);
-		iv_ptr = rte_crypto_op_ctod_offset(ops[i], uint8_t *,
-				session->auth_iv_offset);
-		iv = *((uint64_t *)(iv_ptr));
 		/* Direction from next bit after end of message */
-		num_bytes = (length_in_bits >> 3) + 1;
-		shift_bits = (BYTE_LEN - 1 - length_in_bits) % BYTE_LEN;
-		direction = (src[num_bytes - 1] >> shift_bits) & 0x01;
+		num_bytes = length_in_bits >> 3;
 
 		if (session->auth_op == RTE_CRYPTO_AUTH_OP_VERIFY) {
 			dst = (uint8_t *)rte_pktmbuf_append(ops[i]->sym->m_src,
 					KASUMI_DIGEST_LENGTH);
+			sso_kasumi_f9_1_buffer(&session->pKeySched_hash, src,
+					num_bytes, dst);
 
-			sso_kasumi_f9_1_buffer_user(&session->pKeySched_hash,
-					iv, src,
-					length_in_bits,	dst, direction);
 			/* Verify digest. */
 			if (memcmp(dst, ops[i]->sym->auth.digest.data,
 					KASUMI_DIGEST_LENGTH) != 0)
@@ -319,9 +303,8 @@ process_kasumi_hash_op(struct rte_crypto_op **ops,
 		} else  {
 			dst = ops[i]->sym->auth.digest.data;
 
-			sso_kasumi_f9_1_buffer_user(&session->pKeySched_hash,
-					iv, src,
-					length_in_bits, dst, direction);
+			sso_kasumi_f9_1_buffer(&session->pKeySched_hash, src,
+					num_bytes, dst);
 		}
 		processed_ops++;
 	}
diff --git a/drivers/crypto/kasumi/rte_kasumi_pmd_ops.c b/drivers/crypto/kasumi/rte_kasumi_pmd_ops.c
index 1d9c0fc..569a8de 100644
--- a/drivers/crypto/kasumi/rte_kasumi_pmd_ops.c
+++ b/drivers/crypto/kasumi/rte_kasumi_pmd_ops.c
@@ -56,11 +56,7 @@ static const struct rte_cryptodev_capabilities kasumi_pmd_capabilities[] = {
 					.max = 4,
 					.increment = 0
 				},
-				.iv_size = {
-					.min = 8,
-					.max = 8,
-					.increment = 0
-				},
+				.iv_size = { 0 },
 				.aad_size = { 0 }
 			}, }
 		}, }
diff --git a/drivers/crypto/kasumi/rte_kasumi_pmd_private.h b/drivers/crypto/kasumi/rte_kasumi_pmd_private.h
index 9315a79..0ce2a2e 100644
--- a/drivers/crypto/kasumi/rte_kasumi_pmd_private.h
+++ b/drivers/crypto/kasumi/rte_kasumi_pmd_private.h
@@ -96,7 +96,6 @@ struct kasumi_session {
 	enum kasumi_operation op;
 	enum rte_crypto_auth_operation auth_op;
 	uint16_t cipher_iv_offset;
-	uint16_t auth_iv_offset;
 } __rte_cache_aligned;
 
 
diff --git a/drivers/crypto/qat/qat_crypto.c b/drivers/crypto/qat/qat_crypto.c
index 7e04f21..a5e16f4 100644
--- a/drivers/crypto/qat/qat_crypto.c
+++ b/drivers/crypto/qat/qat_crypto.c
@@ -1195,18 +1195,7 @@ qat_write_hw_desc_entry(struct rte_crypto_op *op, uint8_t *out_msg,
 			auth_ofs = op->sym->auth.data.offset >> 3;
 			auth_len = op->sym->auth.data.length >> 3;
 
-			if (ctx->qat_hash_alg ==
-					ICP_QAT_HW_AUTH_ALGO_KASUMI_F9) {
-				if (do_cipher) {
-					auth_len = auth_len + auth_ofs + 1 -
-						ICP_QAT_HW_KASUMI_BLK_SZ;
-					auth_ofs = ICP_QAT_HW_KASUMI_BLK_SZ;
-				} else {
-					auth_len = auth_len + auth_ofs + 1;
-					auth_ofs = 0;
-				}
-			} else
-				auth_param->u1.aad_adr =
+			auth_param->u1.aad_adr =
 					rte_crypto_op_ctophys_offset(op,
 							ctx->auth_iv.offset);
 
diff --git a/drivers/crypto/qat/qat_crypto_capabilities.h b/drivers/crypto/qat/qat_crypto_capabilities.h
index fee8ee1..7f9135d 100644
--- a/drivers/crypto/qat/qat_crypto_capabilities.h
+++ b/drivers/crypto/qat/qat_crypto_capabilities.h
@@ -429,11 +429,7 @@
 					.max = 4,			\
 					.increment = 0			\
 				},					\
-				.iv_size = {				\
-					.min = 8,			\
-					.max = 8,			\
-					.increment = 0			\
-				},					\
+				.iv_size = { 0 },			\
 				.aad_size = { 0 }			\
 			}, }						\
 		}, }							\
diff --git a/lib/librte_cryptodev/rte_crypto_sym.h b/lib/librte_cryptodev/rte_crypto_sym.h
index f1b2f38..d4b403b 100644
--- a/lib/librte_cryptodev/rte_crypto_sym.h
+++ b/lib/librte_cryptodev/rte_crypto_sym.h
@@ -343,9 +343,8 @@ struct rte_crypto_auth_xform {
 		uint16_t length;
 		/**< Length of valid IV data.
 		 *
-		 * - For KASUMI in F9 mode, SNOW3G in UIA2 mode, for
-		 *   ZUC in EIA3 mode and for AES-GMAC, this is the length
-		 *   of the IV.
+		 * - For SNOW3G in UIA2 mode, for ZUC in EIA3 mode and
+		 *   for AES-GMAC, this is the length of the IV.
 		 *
 		 */
 	} iv;	/**< Initialisation vector parameters */
@@ -625,6 +624,11 @@ struct rte_crypto_sym_op {
 					  * KASUMI @ RTE_CRYPTO_AUTH_KASUMI_F9
 					  * and ZUC @ RTE_CRYPTO_AUTH_ZUC_EIA3,
 					  * this field should be in bits.
+					  *
+					  * @note
+					  * For KASUMI @ RTE_CRYPTO_AUTH_KASUMI_F9,
+					  * this offset should be such that
+					  * data to authenticate starts at COUNT.
 					  */
 					uint32_t length;
 					 /**< The message length, in bytes, of the source
@@ -635,6 +639,12 @@ struct rte_crypto_sym_op {
 					  * KASUMI @ RTE_CRYPTO_AUTH_KASUMI_F9
 					  * and ZUC @ RTE_CRYPTO_AUTH_ZUC_EIA3,
 					  * this field should be in bits.
+					  *
+					  * @note
+					  * For KASUMI @ RTE_CRYPTO_AUTH_KASUMI_F9,
+					  * the length should include the COUNT,
+					  * FRESH, message, direction bit and padding
+					  * (to be multiple of 8 bits).
 					  */
 				} data;
 				/**< Data offsets and length for authentication */
diff --git a/test/test/test_cryptodev.c b/test/test/test_cryptodev.c
index b068609..b57b3de 100644
--- a/test/test/test_cryptodev.c
+++ b/test/test/test_cryptodev.c
@@ -2335,9 +2335,9 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
 	rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
 
 	sym_op->cipher.data.length = cipher_len;
-	sym_op->cipher.data.offset = cipher_offset + auth_offset;
+	sym_op->cipher.data.offset = cipher_offset;
 	sym_op->auth.data.length = auth_len;
-	sym_op->auth.data.offset = auth_offset + cipher_offset;
+	sym_op->auth.data.offset = auth_offset;
 
 	return 0;
 }
@@ -2391,10 +2391,10 @@ create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len,
 	rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
 
 	sym_op->cipher.data.length = cipher_len;
-	sym_op->cipher.data.offset = auth_offset + cipher_offset;
+	sym_op->cipher.data.offset = cipher_offset;
 
 	sym_op->auth.data.length = auth_len;
-	sym_op->auth.data.offset = auth_offset + cipher_offset;
+	sym_op->auth.data.offset = auth_offset;
 
 	return 0;
 }
@@ -2533,7 +2533,7 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
 	/* Create KASUMI session */
 	retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
 			tdata->key.data, tdata->key.len,
-			tdata->auth_iv.len, tdata->digest.len,
+			0, tdata->digest.len,
 			RTE_CRYPTO_AUTH_OP_GENERATE,
 			RTE_CRYPTO_AUTH_KASUMI_F9);
 	if (retval < 0)
@@ -2555,9 +2555,9 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
 
 	/* Create KASUMI operation */
 	retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
-			tdata->auth_iv.data, tdata->auth_iv.len,
+			NULL, 0,
 			plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
-			tdata->validAuthLenInBits.len,
+			tdata->plaintext.len,
 			0);
 	if (retval < 0)
 		return retval;
@@ -2593,7 +2593,7 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
 	/* Create KASUMI session */
 	retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
 				tdata->key.data, tdata->key.len,
-				tdata->auth_iv.len, tdata->digest.len,
+				0, tdata->digest.len,
 				RTE_CRYPTO_AUTH_OP_VERIFY,
 				RTE_CRYPTO_AUTH_KASUMI_F9);
 	if (retval < 0)
@@ -2615,10 +2615,10 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
 	/* Create KASUMI operation */
 	retval = create_wireless_algo_hash_operation(tdata->digest.data,
 			tdata->digest.len,
-			tdata->auth_iv.data, tdata->auth_iv.len,
+			NULL, 0,
 			plaintext_pad_len,
 			RTE_CRYPTO_AUTH_OP_VERIFY,
-			tdata->validAuthLenInBits.len,
+			tdata->plaintext.len,
 			0);
 	if (retval < 0)
 		return retval;
@@ -2816,9 +2816,9 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata)
 
 	/* Create KASUMI operation */
 	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
-					tdata->cipher_iv.len,
-					tdata->plaintext.len,
-					0);
+				tdata->cipher_iv.len,
+				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
+				tdata->validCipherOffsetInBits.len);
 	if (retval < 0)
 		return retval;
 
@@ -2830,14 +2830,16 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata)
 	if (ut_params->obuf)
 		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
 	else
-		ciphertext = plaintext;
+		ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
 
 	TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
 
+	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
 	/* Validate obuf */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
 		ciphertext,
-		tdata->ciphertext.data,
+		reference_ciphertext,
 		tdata->validCipherLenInBits.len,
 		"KASUMI Ciphertext data not as expected");
 	return 0;
@@ -2889,9 +2891,9 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
 
 	/* Create KASUMI operation */
 	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
-					tdata->cipher_iv.len,
-					tdata->plaintext.len,
-					0);
+				tdata->cipher_iv.len,
+				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
+				tdata->validCipherOffsetInBits.len);
 	if (retval < 0)
 		return retval;
 
@@ -2905,19 +2907,22 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
 		ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
 				plaintext_len, buffer);
 	else
-		ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
+		ciphertext = rte_pktmbuf_read(ut_params->ibuf,
+				tdata->validCipherOffsetInBits.len >> 3,
 				plaintext_len, buffer);
 
 	/* Validate obuf */
 	TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
 
-		/* Validate obuf */
-		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-			ciphertext,
-			tdata->ciphertext.data,
-			tdata->validCipherLenInBits.len,
-			"KASUMI Ciphertext data not as expected");
-		return 0;
+	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+		ciphertext,
+		reference_ciphertext,
+		tdata->validCipherLenInBits.len,
+		"KASUMI Ciphertext data not as expected");
+	return 0;
 }
 
 static int
@@ -2960,9 +2965,9 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
 
 	/* Create KASUMI operation */
 	retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
-					tdata->cipher_iv.len,
-					tdata->plaintext.len,
-					0);
+				tdata->cipher_iv.len,
+				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
+				tdata->validCipherOffsetInBits.len);
 	if (retval < 0)
 		return retval;
 
@@ -2974,14 +2979,16 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
 	if (ut_params->obuf)
 		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
 	else
-		ciphertext = plaintext;
+		ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
 
 	TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
 
+	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
 	/* Validate obuf */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
 		ciphertext,
-		tdata->ciphertext.data,
+		reference_ciphertext,
 		tdata->validCipherLenInBits.len,
 		"KASUMI Ciphertext data not as expected");
 	return 0;
@@ -3034,9 +3041,9 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
 
 	/* Create KASUMI operation */
 	retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
-					tdata->cipher_iv.len,
-					tdata->plaintext.len,
-					0);
+				tdata->cipher_iv.len,
+				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
+				tdata->validCipherOffsetInBits.len);
 	if (retval < 0)
 		return retval;
 
@@ -3049,13 +3056,16 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
 		ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
 				plaintext_pad_len, buffer);
 	else
-		ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
+		ciphertext = rte_pktmbuf_read(ut_params->ibuf,
+				tdata->validCipherOffsetInBits.len >> 3,
 				plaintext_pad_len, buffer);
 
+	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
 	/* Validate obuf */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
 		ciphertext,
-		tdata->ciphertext.data,
+		reference_ciphertext,
 		tdata->validCipherLenInBits.len,
 		"KASUMI Ciphertext data not as expected");
 	return 0;
@@ -3102,9 +3112,9 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
 
 	/* Create KASUMI operation */
 	retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
-					tdata->cipher_iv.len,
-					tdata->ciphertext.len,
-					0);
+				tdata->cipher_iv.len,
+				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
+				tdata->validCipherOffsetInBits.len);
 	if (retval < 0)
 		return retval;
 
@@ -3116,14 +3126,16 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
 	if (ut_params->obuf)
 		plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
 	else
-		plaintext = ciphertext;
+		plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
 
 	TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
 
+	const uint8_t *reference_plaintext = tdata->plaintext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
 	/* Validate obuf */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
 		plaintext,
-		tdata->plaintext.data,
+		reference_plaintext,
 		tdata->validCipherLenInBits.len,
 		"KASUMI Plaintext data not as expected");
 	return 0;
@@ -3169,7 +3181,7 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata)
 	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
 					tdata->cipher_iv.len,
 					tdata->ciphertext.len,
-					0);
+					tdata->validCipherOffsetInBits.len);
 	if (retval < 0)
 		return retval;
 
@@ -3181,14 +3193,16 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata)
 	if (ut_params->obuf)
 		plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
 	else
-		plaintext = ciphertext;
+		plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
 
 	TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
 
+	const uint8_t *reference_plaintext = tdata->plaintext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
 	/* Validate obuf */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
 		plaintext,
-		tdata->plaintext.data,
+		reference_plaintext,
 		tdata->validCipherLenInBits.len,
 		"KASUMI Plaintext data not as expected");
 	return 0;
@@ -3764,7 +3778,7 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
 			RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 			RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
 			tdata->key.data, tdata->key.len,
-			tdata->auth_iv.len, tdata->digest.len,
+			0, tdata->digest.len,
 			tdata->cipher_iv.len);
 	if (retval < 0)
 		return retval;
@@ -3929,7 +3943,7 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
 			RTE_CRYPTO_AUTH_KASUMI_F9,
 			RTE_CRYPTO_CIPHER_KASUMI_F8,
 			tdata->key.data, tdata->key.len,
-			tdata->auth_iv.len, tdata->digest.len,
+			0, tdata->digest.len,
 			tdata->cipher_iv.len);
 	if (retval < 0)
 		return retval;
@@ -3952,10 +3966,10 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
 	/* Create KASUMI operation */
 	retval = create_wireless_algo_auth_cipher_operation(tdata->digest.len,
 				tdata->cipher_iv.data, tdata->cipher_iv.len,
-				tdata->auth_iv.data, tdata->auth_iv.len,
+				NULL, 0,
 				plaintext_pad_len,
 				tdata->validCipherLenInBits.len,
-				0,
+				tdata->validCipherOffsetInBits.len,
 				tdata->validAuthLenInBits.len,
 				0
 				);
@@ -3966,19 +3980,23 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-	ut_params->obuf = ut_params->op->sym->m_src;
-	if (ut_params->obuf)
-		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
+	if (ut_params->op->sym->m_dst)
+		ut_params->obuf = ut_params->op->sym->m_dst;
 	else
-		ciphertext = plaintext;
+		ut_params->obuf = ut_params->op->sym->m_src;
 
+	ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
+				tdata->validCipherOffsetInBits.len >> 3);
+
+	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
 	/* Validate obuf */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
 			ciphertext,
-			tdata->ciphertext.data,
+			reference_ciphertext,
 			tdata->validCipherLenInBits.len,
 			"KASUMI Ciphertext data not as expected");
-	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
+	ut_params->digest = rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *)
 	    + plaintext_pad_len;
 
 	/* Validate obuf */
@@ -4010,7 +4028,7 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
 			RTE_CRYPTO_AUTH_KASUMI_F9,
 			RTE_CRYPTO_CIPHER_KASUMI_F8,
 			tdata->key.data, tdata->key.len,
-			tdata->auth_iv.len, tdata->digest.len,
+			0, tdata->digest.len,
 			tdata->cipher_iv.len);
 	if (retval < 0)
 		return retval;
@@ -4033,12 +4051,11 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
 
 	/* Create KASUMI operation */
 	retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
-				tdata->digest.len, tdata->auth_iv.data,
-				tdata->auth_iv.len,
+				tdata->digest.len, NULL, 0,
 				plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
 				tdata->cipher_iv.data, tdata->cipher_iv.len,
-				tdata->validCipherLenInBits.len,
-				0,
+				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
+				tdata->validCipherOffsetInBits.len,
 				tdata->validAuthLenInBits.len,
 				0
 				);
@@ -4048,19 +4065,24 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-	ut_params->obuf = ut_params->op->sym->m_src;
-	if (ut_params->obuf)
-		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
+
+	if (ut_params->op->sym->m_dst)
+		ut_params->obuf = ut_params->op->sym->m_dst;
 	else
-		ciphertext = plaintext;
+		ut_params->obuf = ut_params->op->sym->m_src;
+
+	ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
+				tdata->validCipherOffsetInBits.len >> 3);
 
 	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
 			+ plaintext_pad_len;
 
+	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
 	/* Validate obuf */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
 		ciphertext,
-		tdata->ciphertext.data,
+		reference_ciphertext,
 		tdata->validCipherLenInBits.len,
 		"KASUMI Ciphertext data not as expected");
 
@@ -8187,10 +8209,31 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
 		TEST_CASE_ST(ut_setup, ut_teardown,
 			test_null_auth_cipher_operation),
 
+		/** KASUMI tests */
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_kasumi_hash_generate_test_case_1),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_kasumi_hash_generate_test_case_2),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_kasumi_hash_generate_test_case_3),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_kasumi_hash_generate_test_case_4),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_kasumi_hash_generate_test_case_5),
 		TEST_CASE_ST(ut_setup, ut_teardown,
 			test_kasumi_hash_generate_test_case_6),
 
-		/** KASUMI tests */
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_kasumi_hash_verify_test_case_1),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_kasumi_hash_verify_test_case_2),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_kasumi_hash_verify_test_case_3),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_kasumi_hash_verify_test_case_4),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_kasumi_hash_verify_test_case_5),
+
 		TEST_CASE_ST(ut_setup, ut_teardown,
 			test_kasumi_encryption_test_case_1),
 		TEST_CASE_ST(ut_setup, ut_teardown,
diff --git a/test/test/test_cryptodev_kasumi_hash_test_vectors.h b/test/test/test_cryptodev_kasumi_hash_test_vectors.h
index 61dbb09..a6dd4f5 100644
--- a/test/test/test_cryptodev_kasumi_hash_test_vectors.h
+++ b/test/test/test_cryptodev_kasumi_hash_test_vectors.h
@@ -39,24 +39,16 @@ struct kasumi_hash_test_data {
 		unsigned len;
 	} key;
 
-	/* Includes: COUNT (4 bytes) and FRESH (4 bytes) */
-	struct {
-		uint8_t data[8];
-		unsigned len;
-	} auth_iv;
-
-	/* Includes message and DIRECTION (1 bit), plus 1 0*,
-	 * with enough 0s, so total length is multiple of 64 bits */
+	/*
+	 * Includes COUNT (4 bytes), FRESH (4 bytes), message
+	 * and DIRECTION (1 bit), plus 1 0*, with enough 0s,
+	 * so total length is multiple of 8 or 64 bits
+	 */
 	struct {
 		uint8_t data[2056];
 		unsigned len; /* length must be in Bits */
 	} plaintext;
 
-	/* Actual length of data to be hashed */
-	struct {
-		unsigned len;
-	} validAuthLenInBits;
-
 	struct {
 		uint8_t data[64];
 		unsigned len;
@@ -71,22 +63,14 @@ struct kasumi_hash_test_data kasumi_hash_test_case_1 = {
 		},
 		.len = 16
 	},
-	.auth_iv = {
-		.data = {
-			0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49,
-		},
-		.len = 8
-	},
 	.plaintext = {
 		.data = {
+			0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49,
 			0x6B, 0x22, 0x77, 0x37, 0x29, 0x6F, 0x39, 0x3C,
 			0x80, 0x79, 0x35, 0x3E, 0xDC, 0x87, 0xE2, 0xE8,
 			0x05, 0xD2, 0xEC, 0x49, 0xA4, 0xF2, 0xD8, 0xE2
 		},
-		.len = 192
-	},
-	.validAuthLenInBits = {
-		.len = 189
+		.len = 256
 	},
 	.digest = {
 		.data = {0xF6, 0x3B, 0xD7, 0x2C},
@@ -102,23 +86,15 @@ struct kasumi_hash_test_data kasumi_hash_test_case_2 = {
 		},
 		.len = 16
 	},
-	.auth_iv = {
-		.data = {
-			0x3E, 0xDC, 0x87, 0xE2, 0xA4, 0xF2, 0xD8, 0xE2,
-		},
-		.len = 8
-	},
 	.plaintext = {
 		.data = {
+			0x3E, 0xDC, 0x87, 0xE2, 0xA4, 0xF2, 0xD8, 0xE2,
 			0xB5, 0x92, 0x43, 0x84, 0x32, 0x8A, 0x4A, 0xE0,
 			0x0B, 0x73, 0x71, 0x09, 0xF8, 0xB6, 0xC8, 0xDD,
 			0x2B, 0x4D, 0xB6, 0x3D, 0xD5, 0x33, 0x98, 0x1C,
 			0xEB, 0x19, 0xAA, 0xD5, 0x2A, 0x5B, 0x2B, 0xC3
 		},
-		.len = 256
-	},
-	.validAuthLenInBits = {
-		.len = 254
+		.len = 320
 	},
 	.digest = {
 		.data = {0xA9, 0xDA, 0xF1, 0xFF},
@@ -134,14 +110,9 @@ struct kasumi_hash_test_data kasumi_hash_test_case_3 = {
 		},
 		.len = 16
 	},
-	.auth_iv = {
-		.data = {
-			0x36, 0xAF, 0x61, 0x44, 0x98, 0x38, 0xF0, 0x3A,
-		},
-		.len = 8
-	},
 	.plaintext = {
 		.data = {
+			0x36, 0xAF, 0x61, 0x44, 0x98, 0x38, 0xF0, 0x3A,
 			0x59, 0x32, 0xBC, 0x0A, 0xCE, 0x2B, 0x0A, 0xBA,
 			0x33, 0xD8, 0xAC, 0x18, 0x8A, 0xC5, 0x4F, 0x34,
 			0x6F, 0xAD, 0x10, 0xBF, 0x9D, 0xEE, 0x29, 0x20,
@@ -149,10 +120,7 @@ struct kasumi_hash_test_data kasumi_hash_test_case_3 = {
 			0xDF, 0x6C, 0xAA, 0x72, 0x05, 0x3A, 0xBF, 0xF3,
 			0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 		},
-		.len = 384
-	},
-	.validAuthLenInBits = {
-		.len = 319
+		.len = 448
 	},
 	.digest = {
 		.data = {0x15, 0x37, 0xD3, 0x16},
@@ -168,14 +136,9 @@ struct kasumi_hash_test_data kasumi_hash_test_case_4 = {
 		},
 	.len = 16
 	},
-	.auth_iv = {
-		.data = {
-			0x14, 0x79, 0x3E, 0x41, 0x03, 0x97, 0xE8, 0xFD
-		},
-		.len = 8
-	},
 	.plaintext = {
 		.data = {
+			0x14, 0x79, 0x3E, 0x41, 0x03, 0x97, 0xE8, 0xFD,
 			0xD0, 0xA7, 0xD4, 0x63, 0xDF, 0x9F, 0xB2, 0xB2,
 			0x78, 0x83, 0x3F, 0xA0, 0x2E, 0x23, 0x5A, 0xA1,
 			0x72, 0xBD, 0x97, 0x0C, 0x14, 0x73, 0xE1, 0x29,
@@ -184,11 +147,8 @@ struct kasumi_hash_test_data kasumi_hash_test_case_4 = {
 			0xA4, 0x99, 0x27, 0x6A, 0x50, 0x42, 0x70, 0x09,
 			0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 		},
-		.len = 448
+		.len = 512
 	},
-	.validAuthLenInBits = {
-		.len = 384
-		},
 	.digest = {
 		.data = {0xDD, 0x7D, 0xFA, 0xDD },
 		.len  = 4
@@ -203,14 +163,9 @@ struct kasumi_hash_test_data kasumi_hash_test_case_5 = {
 		},
 		.len = 16
 	},
-	.auth_iv = {
-		.data = {
-			0x29, 0x6F, 0x39, 0x3C, 0x6B, 0x22, 0x77, 0x37,
-		},
-		.len = 8
-	},
 	.plaintext = {
 		.data = {
+			0x29, 0x6F, 0x39, 0x3C, 0x6B, 0x22, 0x77, 0x37,
 			0x10, 0xBF, 0xFF, 0x83, 0x9E, 0x0C, 0x71, 0x65,
 			0x8D, 0xBB, 0x2D, 0x17, 0x07, 0xE1, 0x45, 0x72,
 			0x4F, 0x41, 0xC1, 0x6F, 0x48, 0xBF, 0x40, 0x3C,
@@ -228,10 +183,7 @@ struct kasumi_hash_test_data kasumi_hash_test_case_5 = {
 			0x3D, 0x7C, 0xFE, 0xE9, 0x45, 0x85, 0xB5, 0x88,
 			0x5C, 0xAC, 0x46, 0x06, 0x8B, 0xC0, 0x00, 0x00
 		},
-		.len = 1024
-	},
-	.validAuthLenInBits = {
-		.len = 1000
+		.len = 1088
 	},
 	.digest = {
 		.data = {0xC3, 0x83, 0x83, 0x9D},
@@ -247,14 +199,9 @@ struct kasumi_hash_test_data kasumi_hash_test_case_6 = {
 		},
 		.len = 16
 	},
-	.auth_iv = {
-		.data = {
-			0x36, 0xAF, 0x61, 0x44, 0x4F, 0x30, 0x2A, 0xD2
-		},
-		.len = 8
-	},
 	.plaintext = {
 		.data = {
+			0x36, 0xAF, 0x61, 0x44, 0x4F, 0x30, 0x2A, 0xD2,
 			0x35, 0xC6, 0x87, 0x16, 0x63, 0x3C, 0x66, 0xFB,
 			0x75, 0x0C, 0x26, 0x68, 0x65, 0xD5, 0x3C, 0x11,
 			0xEA, 0x05, 0xB1, 0xE9, 0xFA, 0x49, 0xC8, 0x39,
@@ -269,10 +216,7 @@ struct kasumi_hash_test_data kasumi_hash_test_case_6 = {
 			0x74, 0xCD, 0xA5, 0xA4, 0x85, 0xF7, 0x4D, 0x7A,
 			0xC0
 		},
-		.len = 776
-	},
-	.validAuthLenInBits = {
-		.len = 768
+		.len = 840
 	},
 	.digest = {
 		.data = {0x95, 0xAE, 0x41, 0xBA},
@@ -288,21 +232,13 @@ struct kasumi_hash_test_data kasumi_hash_test_case_7 = {
 		},
 		.len = 16
 	},
-	.auth_iv = {
-		.data = {
-			0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49,
-		},
-		.len = 8
-	},
 	.plaintext = {
 		.data = {
+			0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49,
 			0xAD, 0x9C, 0x44, 0x1F, 0x89, 0x0B, 0x38, 0xC4,
 			0x57, 0xA4, 0x9D, 0x42, 0x14, 0x07, 0xE8, 0xC0
 		},
-		.len = 128
-	},
-	.validAuthLenInBits = {
-		.len = 120
+		.len = 192
 	},
 	.digest = {
 		.data = {0x87, 0x5F, 0xE4, 0x89},
diff --git a/test/test/test_cryptodev_kasumi_test_vectors.h b/test/test/test_cryptodev_kasumi_test_vectors.h
index ee6ddef..0d042d0 100644
--- a/test/test/test_cryptodev_kasumi_test_vectors.h
+++ b/test/test/test_cryptodev_kasumi_test_vectors.h
@@ -44,14 +44,13 @@ struct kasumi_test_data {
 		unsigned len;
 	} cipher_iv;
 
-	/* Includes: COUNT (4 bytes) and FRESH (4 bytes) */
+	/*
+	 * Data may include COUNT (4 bytes), FRESH (4 bytes),
+	 * DIRECTION (1 bit), plus 1 0*, with enough 0s,
+	 * so total length is multiple of 8 or 64 bits
+	 */
 	struct {
-		uint8_t data[8];
-		unsigned len;
-	} auth_iv;
-
-	struct {
-		uint8_t data[1024]; /* Data may include direction bit */
+		uint8_t data[1024];
 		unsigned len; /* length must be in Bits */
 	} plaintext;
 
@@ -68,6 +67,10 @@ struct kasumi_test_data {
 		unsigned len;
 	} validCipherLenInBits;
 
+	struct {
+		unsigned int len;
+	} validCipherOffsetInBits;
+
 	/* Actual length of data to be hashed */
 	struct {
 		unsigned len;
@@ -132,6 +135,9 @@ struct kasumi_test_data kasumi_test_case_1 = {
 	},
 	.validCipherLenInBits = {
 		.len = 798
+	},
+	.validCipherOffsetInBits = {
+		.len = 0
 	}
 };
 
@@ -177,6 +183,9 @@ struct kasumi_test_data kasumi_test_case_2 = {
 	},
 	.validCipherLenInBits = {
 		.len = 510
+	},
+	.validCipherOffsetInBits = {
+		.len = 0
 	}
 };
 
@@ -194,34 +203,33 @@ struct kasumi_test_data kasumi_test_case_3 = {
 		},
 		.len = 8
 	},
-	.auth_iv = {
-		.data = {
-			0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49
-		},
-		.len = 8
-	},
 	.plaintext = {
 		.data = {
+			0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49,
 			0xAD, 0x9C, 0x44, 0x1F, 0x89, 0x0B, 0x38, 0xC4,
 			0x57, 0xA4, 0x9D, 0x42, 0x14, 0x07, 0xE8, 0xC0
 		},
-		.len = 128
+		.len = 192
 	},
 	.ciphertext = {
 		.data = {
+			0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49,
 			0x9B, 0xC9, 0x2C, 0xA8, 0x03, 0xC6, 0x7B, 0x28,
-			0xA1, 0x1A, 0x4B, 0xEE, 0x5A, 0x0C, 0x25
+			0xA1, 0x1A, 0x4B, 0xEE, 0x5A, 0x0C, 0x25, 0xC0
 		},
-		.len = 120
+		.len = 192
 	},
 	.validDataLenInBits = {
-			.len = 128
+		.len = 192
 	},
 	.validCipherLenInBits = {
 		.len = 120
 	},
 	.validAuthLenInBits = {
-		.len = 120
+		.len = 192
+	},
+	.validCipherOffsetInBits = {
+		.len = 64
 	},
 	.digest = {
 		.data = {0x87, 0x5F, 0xE4, 0x89},
@@ -263,6 +271,9 @@ struct kasumi_test_data kasumi_test_case_4 = {
 	},
 	.validCipherLenInBits = {
 		.len = 253
+	},
+	.validCipherOffsetInBits = {
+		.len = 0
 	}
 };
 
@@ -320,6 +331,9 @@ struct kasumi_test_data kasumi_test_case_5 = {
 	},
 	.validCipherLenInBits = {
 		.len = 837
+	},
+	.validCipherOffsetInBits = {
+		.len = 0
 	}
 };
 
@@ -337,39 +351,37 @@ struct kasumi_test_data kasumi_test_case_6 = {
 		},
 		.len = 8
 	},
-	.auth_iv = {
-		.data = {
-			0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49
-		},
-		.len = 8
-	},
 	.plaintext = {
 		.data = {
+			0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49,
 			0xAD, 0x9C, 0x44, 0x1F, 0x89, 0x0B, 0x38, 0xC4,
 			0x57, 0xA4, 0x9D, 0x42, 0x14, 0x07, 0xE8, 0xC0
 		},
-		.len = 128
+		.len = 192
 	},
 	.ciphertext = {
 		.data = {
+			0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49,
 			0x9B, 0xC9, 0x2C, 0xA8, 0x03, 0xC6, 0x7B, 0x28,
-			0xA1, 0x1A, 0x4B, 0xEE, 0x5A, 0x0C, 0x25
+			0xA1, 0x1A, 0x4B, 0xEE, 0x5A, 0x0C, 0x25, 0xC0
 		},
-		.len = 120
+		.len = 192
 	},
 	.validDataLenInBits = {
-			.len = 128
+		.len = 192
 	},
 	.validCipherLenInBits = {
 		.len = 120
 	},
+	.validCipherOffsetInBits = {
+		.len = 64
+	},
 	.validAuthLenInBits = {
-		.len = 120
+		.len = 192
 	},
 	.digest = {
 		.data = {0x0F, 0xD2, 0xAA, 0xB5},
 		.len  = 4
 	}
 };
-
 #endif /* TEST_CRYPTODEV_KASUMI_TEST_VECTORS_H_ */
