Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 694 insertions, 0 deletions

diff --git a/src/spdk/intel-ipsec-mb/LibTestApp/pon_test.c b/src/spdk/intel-ipsec-mb/LibTestApp/pon_test.c
new file mode 100644
index 000000000..e5091a94e
--- /dev/null
+++ b/src/spdk/intel-ipsec-mb/LibTestApp/pon_test.c
@@ -0,0 +1,694 @@
+/*****************************************************************************
+ Copyright (c) 2019, Intel Corporation
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+     * Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+     * Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+     * Neither the name of Intel Corporation nor the names of its contributors
+       may be used to endorse or promote products derived from this software
+       without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************/
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <intel-ipsec-mb.h>
+#include "gcm_ctr_vectors_test.h"
+#include "utils.h"
+
+int pon_test(const enum arch_type arch, struct MB_MGR *mb_mgr);
+
+/* === vector 1 */
+
+static const uint8_t KEY1_PON[] = {
+        0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
+        0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00
+};
+
+static const uint8_t IV1_PON[] = {
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04
+};
+
+static const uint8_t IN1_PON[] = {
+        0x00, 0x20, 0x27, 0x11, 0x00, 0x00, 0x21, 0x23, /* XGEM header */
+        0x01, 0x02, 0x03, 0x04,                         /* Ethernet frame */
+        0xcd, 0xfb, 0x3c, 0xb6                          /* CRC value */
+};
+
+static const uint8_t OUT1_PON[] = {
+        0x00, 0x20, 0x27, 0x11, 0x00, 0x00, 0x21, 0x23, /* XGEM header */
+        0xC7, 0x62, 0x82, 0xCA,                         /* Ethernet frame */
+        0x3E, 0x92, 0xC8, 0x5A                          /* CRC value */
+};
+#define BIPOUT1_PON  0xA24CD0F9
+#define OFFSET1_PON  8
+#define LENBIP1_PON  sizeof(IN1_PON)
+#define LENCIPH1_PON (LENBIP1_PON - OFFSET1_PON)
+
+/* === vector 2 */
+
+static const uint8_t IN2_PON[] = {
+        0x00, 0x40, 0x27, 0x11, 0x00, 0x00, 0x29, 0x3C, /* XGEM header */
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x01, 0x01, /* Ethernet frame */
+        0x01, 0x01, 0x01, 0x01,
+        0x00, 0x14, 0xa9, 0x04                          /* CRC value */
+};
+
+static const uint8_t OUT2_PON[] = {
+        0x00, 0x40, 0x27, 0x11, 0x00, 0x00, 0x29, 0x3C, /* XGEM header */
+        0xC7, 0x62, 0x82, 0xCA, 0xF6, 0x6F, 0xF5, 0xED,
+        0xB7, 0x90, 0x1E, 0x02,
+        0xEA, 0x38, 0xA1, 0x78
+};
+
+#define KEY2_PON KEY1_PON
+#define IV2_PON IV1_PON
+#define BIPOUT2_PON  0x70C6E56C
+#define OFFSET2_PON  8
+#define LENBIP2_PON  sizeof(IN2_PON)
+#define LENCIPH2_PON (LENBIP2_PON - OFFSET2_PON)
+
+/* === vector 3 */
+
+static const uint8_t IN3_PON[] = {
+        0x01, 0x00, 0x27, 0x11, 0x00, 0x00, 0x33, 0x0B, /* XGEM header */
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x01, 0x01, /* Ethernet frame */
+        0x01, 0x01, 0x01, 0x01, 0x81, 0x00, 0x00, 0x01,
+        0x08, 0x00, 0x45, 0x00, 0x00, 0x6A, 0xB0, 0x7E,
+        0x00, 0x00, 0x04, 0x06, 0x83, 0xBD, 0xC0, 0xA8,
+        0x00, 0x01, 0xC0, 0xA8, 0x01, 0x01, 0x04, 0xD2,
+        0x16, 0x2E, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34,
+        0x56, 0x90, 0x50, 0x10, 0x20, 0x00, 0xA6, 0x33,
+        0x00, 0x00, 0x30, 0x31,
+        0x53, 0xc1, 0xe6, 0x0c                          /* CRC value */
+};
+
+static const uint8_t OUT3_PON[] = {
+        0x01, 0x00, 0x27, 0x11, 0x00, 0x00, 0x33, 0x0B, /* XGEM header */
+        0xC7, 0x62, 0x82, 0xCA, 0xF6, 0x6F, 0xF5, 0xED,
+        0xB7, 0x90, 0x1E, 0x02, 0x6B, 0x2C, 0x08, 0x7D,
+        0x3C, 0x90, 0xE8, 0x2C, 0x44, 0x30, 0x03, 0x29,
+        0x5F, 0x88, 0xA9, 0xD6, 0x1E, 0xF9, 0xD1, 0xF1,
+        0xD6, 0x16, 0x8C, 0x72, 0xA4, 0xCD, 0xD2, 0x8F,
+        0x63, 0x26, 0xC9, 0x66, 0xB0, 0x65, 0x24, 0x9B,
+        0x60, 0x5B, 0x18, 0x60, 0xBD, 0xD5, 0x06, 0x13,
+        0x40, 0xC9, 0x60, 0x64,
+        0x36, 0x5F, 0x86, 0x8C
+};
+#define KEY3_PON KEY1_PON
+#define IV3_PON IV1_PON
+#define BIPOUT3_PON  0xFBADE0DF
+#define OFFSET3_PON  8
+#define LENBIP3_PON  sizeof(IN3_PON)
+#define LENCIPH3_PON (LENBIP3_PON - OFFSET3_PON)
+
+/* === vector 4 */
+
+static const uint8_t IN4_PON[] = {
+        0x01, 0x10, 0x27, 0x11, 0x00, 0x00, 0x3C, 0x18, /* XGEM header */
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x01, 0x01, /* Ethernet frame */
+        0x01, 0x01, 0x01, 0x01, 0x81, 0x00, 0x00, 0x01,
+        0x08, 0x00, 0x45, 0x00, 0x00, 0x6A, 0x70, 0x63,
+        0x00, 0x00, 0x04, 0x06, 0xC3, 0xD8, 0xC0, 0xA8,
+        0x00, 0x01, 0xC0, 0xA8, 0x01, 0x01, 0x04, 0xD2,
+        0x16, 0x2E, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34,
+        0x56, 0x90, 0x50, 0x10, 0x20, 0x00, 0xA6, 0x33,
+        0x00, 0x00, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
+        0x49, 0x0d, 0x52, 0xab                          /* CRC value */
+};
+
+static const uint8_t OUT4_PON[] = {
+        0x01, 0x10, 0x27, 0x11, 0x00, 0x00, 0x3C, 0x18, /* XGEM header */
+        0xC7, 0x62, 0x82, 0xCA, 0xF6, 0x6F, 0xF5, 0xED, /* Ethernet frame */
+        0xB7, 0x90, 0x1E, 0x02, 0x6B, 0x2C, 0x08, 0x7D,
+        0x3C, 0x90, 0xE8, 0x2C, 0x44, 0x30, 0xC3, 0x34,
+        0x5F, 0x88, 0xA9, 0xD6, 0x5E, 0x9C, 0xD1, 0xF1,
+        0xD6, 0x16, 0x8C, 0x72, 0xA4, 0xCD, 0xD2, 0x8F,
+        0x63, 0x26, 0xC9, 0x66, 0xB0, 0x65, 0x24, 0x9B,
+        0x60, 0x5B, 0x18, 0x60, 0xBD, 0xD5, 0x06, 0x13,
+        0x40, 0xC9, 0x60, 0x64, 0x57, 0xAD, 0x54, 0xB5,
+        0xD9, 0xEA, 0x01, 0xB2
+};
+#define KEY4_PON KEY1_PON
+#define IV4_PON IV1_PON
+#define BIPOUT4_PON  0x7EB18D27
+#define OFFSET4_PON  8
+#define LENBIP4_PON  sizeof(IN4_PON)
+#define LENCIPH4_PON (LENBIP4_PON - OFFSET4_PON)
+
+/* Vectors with no encryption */
+static const uint8_t IN5_PON[] = {
+        0x00, 0x20, 0x27, 0x11, 0x00, 0x00, 0x21, 0x23, /* XGEM header */
+        0x01, 0x02, 0x03, 0x04,                         /* Ethernet frame */
+        0xCD, 0xFB, 0x3C, 0xB6                          /* CRC value */
+};
+
+static const uint8_t OUT5_PON[] = {
+        0x00, 0x20, 0x27, 0x11, 0x00, 0x00, 0x21, 0x23, /* XGEM header */
+        0x01, 0x02, 0x03, 0x04,                         /* Ethernet frame */
+        0xCD, 0xFB, 0x3C, 0xB6                          /* CRC value */
+};
+#define BIPOUT5_PON  0x8039D9CC
+#define OFFSET5_PON  8
+#define LENBIP5_PON  sizeof(IN5_PON)
+#define LENCIPH5_PON (LENBIP5_PON - OFFSET5_PON)
+
+static const uint8_t IN6_PON[] = {
+        0x00, 0x40, 0x27, 0x11, 0x00, 0x00, 0x29, 0x3C, /* XGEM header */
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x01, 0x01, /* Ethernet frame */
+        0x01, 0x01, 0x01, 0x01,
+        0x00, 0x14, 0xa9, 0x04                          /* CRC value */
+};
+
+static const uint8_t OUT6_PON[] = {
+        0x00, 0x40, 0x27, 0x11, 0x00, 0x00, 0x29, 0x3C, /* XGEM header */
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x01, 0x01, /* Ethernet frame */
+        0x01, 0x01, 0x01, 0x01,
+        0x00, 0x14, 0xa9, 0x04
+};
+
+#define BIPOUT6_PON  0x2DA45105
+#define OFFSET6_PON  8
+#define LENBIP6_PON  sizeof(IN6_PON)
+#define LENCIPH6_PON (LENBIP6_PON - OFFSET6_PON)
+
+static const uint8_t IN7_PON[] = {
+        0x01, 0x00, 0x27, 0x11, 0x00, 0x00, 0x33, 0x0B, /* XGEM header */
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x01, 0x01, /* ethernet frame */
+        0x01, 0x01, 0x01, 0x01, 0x81, 0x00, 0x00, 0x01,
+        0x08, 0x00, 0x45, 0x00, 0x00, 0x6a, 0xb0, 0x7e,
+        0x00, 0x00, 0x04, 0x06, 0x83, 0xbd, 0xc0, 0xa8,
+        0x00, 0x01, 0xc0, 0xa8, 0x01, 0x01, 0x04, 0xd2,
+        0x16, 0x2e, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34,
+        0x56, 0x90, 0x50, 0x10, 0x20, 0x00, 0xa6, 0x33,
+        0x00, 0x00, 0x30, 0x31,
+        0x53, 0xC1, 0xE6, 0x0C                          /* CRC value */
+};
+
+static const uint8_t OUT7_PON[] = {
+        0x01, 0x00, 0x27, 0x11, 0x00, 0x00, 0x33, 0x0B, /* XGEM header */
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x01, 0x01, /* ethernet frame */
+        0x01, 0x01, 0x01, 0x01, 0x81, 0x00, 0x00, 0x01,
+        0x08, 0x00, 0x45, 0x00, 0x00, 0x6a, 0xb0, 0x7e,
+        0x00, 0x00, 0x04, 0x06, 0x83, 0xbd, 0xc0, 0xa8,
+        0x00, 0x01, 0xc0, 0xa8, 0x01, 0x01, 0x04, 0xd2,
+        0x16, 0x2e, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34,
+        0x56, 0x90, 0x50, 0x10, 0x20, 0x00, 0xa6, 0x33,
+        0x00, 0x00, 0x30, 0x31,
+        0x53, 0xC1, 0xE6, 0x0C
+};
+#define BIPOUT7_PON  0xABC2D56A
+#define OFFSET7_PON  8
+#define LENBIP7_PON  sizeof(IN7_PON)
+#define LENCIPH7_PON (LENBIP7_PON - OFFSET7_PON)
+
+static const uint8_t IN8_PON[] = {
+        0x01, 0x10, 0x27, 0x11, 0x00, 0x00, 0x3C, 0x18, /* XGEM header */
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x01, 0x01, /* Ethernet frame */
+        0x01, 0x01, 0x01, 0x01, 0x81, 0x00, 0x00, 0x01,
+        0x08, 0x00, 0x45, 0x00, 0x00, 0x6A, 0x70, 0x63,
+        0x00, 0x00, 0x04, 0x06, 0xC3, 0xD8, 0xC0, 0xA8,
+        0x00, 0x01, 0xC0, 0xA8, 0x01, 0x01, 0x04, 0xD2,
+        0x16, 0x2E, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34,
+        0x56, 0x90, 0x50, 0x10, 0x20, 0x00, 0xA6, 0x33,
+        0x00, 0x00, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
+        0x49, 0x0D, 0x52, 0xAB                          /* CRC value */
+};
+
+static const uint8_t OUT8_PON[] = {
+        0x01, 0x10, 0x27, 0x11, 0x00, 0x00, 0x3C, 0x18, /* XGEM header */
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x01, 0x01, /* Ethernet frame */
+        0x01, 0x01, 0x01, 0x01, 0x81, 0x00, 0x00, 0x01,
+        0x08, 0x00, 0x45, 0x00, 0x00, 0x6A, 0x70, 0x63,
+        0x00, 0x00, 0x04, 0x06, 0xC3, 0xD8, 0xC0, 0xA8,
+        0x00, 0x01, 0xC0, 0xA8, 0x01, 0x01, 0x04, 0xD2,
+        0x16, 0x2E, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34,
+        0x56, 0x90, 0x50, 0x10, 0x20, 0x00, 0xA6, 0x33,
+        0x00, 0x00, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
+        0x49, 0x0D, 0x52, 0xAB                          /* CRC value */
+};
+#define BIPOUT8_PON  0x378D5F02
+#define OFFSET8_PON  8
+#define LENBIP8_PON  sizeof(IN8_PON)
+#define LENCIPH8_PON (LENBIP8_PON - OFFSET8_PON)
+
+/* Vectors with encryption and with padding */
+/* === vector 9 */
+static const uint8_t IN9_PON[] = {
+        0x00, 0x39, 0x03, 0xfd, 0x00, 0x00, 0xb3, 0x6a,  /* XGEM header */
+        0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,  /* Ethernet frame */
+        0x10, 0x11,
+        0x8c, 0xd0, 0x9a, 0x8b,                          /* CRC value */
+        0x55, 0x55                                       /* XGEM padding */
+};
+
+static const uint8_t OUT9_PON[] = {
+        0x00, 0x39, 0x03, 0xfd, 0x00, 0x00, 0xb3, 0x6a,  /* XGEM header */
+        0x73, 0xe0, 0x5d, 0x5d, 0x32, 0x9c, 0x3b, 0xfa,  /* Ethernet frame */
+        0x6b, 0x66,
+        0xf6, 0x8e, 0x5b, 0xd5,                          /* CRC value */
+        0xab, 0xcd                                       /* XGEM padding */
+};
+
+#define KEY9_PON KEY1_PON
+
+static const uint8_t IV9_PON[] = {
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+#define BIPOUT9_PON  0x738bf671
+#define OFFSET9_PON  8
+#define LENBIP9_PON  sizeof(IN9_PON)
+#define LENCIPH9_PON (LENBIP9_PON - OFFSET9_PON)
+
+/* === vector 10 */
+
+/* This is fragmented frame (1 bytes payload + padding)
+ * - computed CRC will not match value in the message
+ * - on encrypt CRC should not be written into the message
+ */
+static const uint8_t IN10_PON[] = {
+        0x00, 0x05, 0x03, 0xfd, 0x00, 0x00, 0xb9, 0xb4,  /* XGEM header */
+        0x08,                                            /* Ethernet frame */
+        0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55         /* XGEM padding */
+};
+
+static const uint8_t OUT10_PON[] = {
+        0x00, 0x05, 0x03, 0xfd, 0x00, 0x00, 0xb9, 0xb4,  /* XGEM header */
+        0x73,                                            /* Ethernet frame */
+        0xbc, 0x02, 0x03, 0x6b, 0xc4, 0x60, 0xa0         /* XGEM padding */
+};
+
+#define KEY10_PON KEY1_PON
+#define IV10_PON IV9_PON
+#define BIPOUT10_PON  0xead87d18
+#define OFFSET10_PON  8
+#define LENBIP10_PON  sizeof(IN10_PON)
+#define LENCIPH10_PON (LENBIP10_PON - OFFSET10_PON)
+
+/* Vectors with no encryption and with padding */
+/* === vector 11 */
+static const uint8_t IN11_PON[] = {
+        0x00, 0x39, 0x03, 0xfd, 0x00, 0x00, 0xb3, 0x6a,  /* XGEM header */
+        0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,  /* Ethernet frame */
+        0x10, 0x11,
+        0x8c, 0xd0, 0x9a, 0x8b,                          /* CRC value */
+        0x55, 0x55                                       /* XGEM padding */
+};
+
+static const uint8_t OUT11_PON[] = {
+        0x00, 0x39, 0x03, 0xfd, 0x00, 0x00, 0xb3, 0x6a,  /* XGEM header */
+        0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,  /* Ethernet frame */
+        0x10, 0x11,
+        0x8c, 0xd0, 0x9a, 0x8b,                          /* CRC value */
+        0x55, 0x55                                       /* XGEM padding */
+};
+
+#define KEY11_PON KEY1_PON
+#define BIPOUT11_PON  0x166da78e
+#define OFFSET11_PON  8
+#define LENBIP11_PON  sizeof(IN11_PON)
+#define LENCIPH11_PON (LENBIP11_PON - OFFSET11_PON)
+
+/* === vector 12 */
+
+/* This is fragmented frame (1 bytes payload + padding)
+ * - computed CRC will not match value in the message
+ * - on encrypt CRC should not be written into the message
+ */
+static const uint8_t IN12_PON[] = {
+        0x00, 0x05, 0x03, 0xfd, 0x00, 0x00, 0xb9, 0xb4,  /* XGEM header */
+        0x08,                                            /* Ethernet frame */
+        0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55         /* XGEM padding */
+};
+
+static const uint8_t OUT12_PON[] = {
+        0x00, 0x05, 0x03, 0xfd, 0x00, 0x00, 0xb9, 0xb4,  /* XGEM header */
+        0x08,                                            /* Ethernet frame */
+        0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55         /* XGEM padding */
+};
+
+#define KEY12_PON KEY1_PON
+#define BIPOUT12_PON  0x49ba055d
+#define OFFSET12_PON  8
+#define LENBIP12_PON  sizeof(IN12_PON)
+#define LENCIPH12_PON (LENBIP12_PON - OFFSET12_PON)
+
+/* === vector 13 */
+
+/* This is fragmented frame (4 bytes payload + padding)
+ * - computed CRC will not match value in the message
+ * - on encrypt CRC should not be written into the message
+ */
+static const uint8_t IN13_PON[] = {
+        0x00, 0x11, 0x03, 0xfd, 0x00, 0x00, 0xbf, 0xff,  /* XGEM header */
+        0x08, 0x09, 0x0a, 0x0b,                          /* Ethernet frame */
+        0x55, 0x55, 0x55, 0x55                           /* XGEM padding */
+};
+
+static const uint8_t OUT13_PON[] = {
+        0x00, 0x11, 0x03, 0xfd, 0x00, 0x00, 0xbf, 0xff,  /* XGEM header */
+        0x73, 0xe0, 0x5d, 0x5d,                          /* Ethernet frame */
+        0x6b, 0xc4, 0x60, 0xa0                           /* XGEM padding */
+};
+
+#define KEY13_PON KEY1_PON
+#define IV13_PON IV9_PON
+#define BIPOUT13_PON  0xff813518
+#define OFFSET13_PON  8
+#define LENBIP13_PON  sizeof(IN13_PON)
+#define LENCIPH13_PON (LENBIP13_PON - OFFSET13_PON)
+
+
+#define ponvector(tname) \
+        { KEY ## tname, IV ## tname, IN ## tname, OUT ## tname, \
+                        BIPOUT ## tname, LENBIP ## tname,    \
+                        LENCIPH ## tname, OFFSET ## tname }
+
+#define pon_no_ctr_vector(tname) \
+        { NULL, NULL, IN ## tname, OUT ## tname, \
+                        BIPOUT ## tname, LENBIP ## tname,    \
+                        LENCIPH ## tname, OFFSET ## tname }
+
+
+static const struct pon_test_vector {
+        const uint8_t *key;
+        const uint8_t *iv;
+        const uint8_t *in;
+        const uint8_t *out;
+        const uint32_t bip_out;
+        size_t length_to_bip;
+        size_t length_to_cipher;
+        size_t offset_to_crc_cipher;
+} pon_vectors[] = {
+	ponvector(1_PON),
+	ponvector(2_PON),
+	ponvector(3_PON),
+	ponvector(4_PON),
+        pon_no_ctr_vector(5_PON),
+        pon_no_ctr_vector(6_PON),
+        pon_no_ctr_vector(7_PON),
+        pon_no_ctr_vector(8_PON),
+	ponvector(9_PON),
+	ponvector(10_PON),
+        pon_no_ctr_vector(11_PON),
+        pon_no_ctr_vector(12_PON),
+	ponvector(13_PON),
+};
+
+static int
+test_pon(struct MB_MGR *mb_mgr,
+         const void *expkey,
+         const void *iv,
+         const uint8_t *in_text,
+         const uint8_t *out_text,
+         const size_t len_to_cipher,
+         const size_t len_to_bip,
+         const size_t offset_to_cipher_crc,
+         const uint32_t bip_out,
+         const int dir,
+         const int order)
+{
+        struct JOB_AES_HMAC *job;
+        uint8_t padding[16];
+        uint8_t *target = malloc(len_to_bip + (sizeof(padding) * 2));
+        int ret = -1;
+        uint64_t tag_output = 0;
+        uint32_t bip_output = 0;
+        uint32_t crc_output = 0;
+
+        if (target == NULL) {
+		fprintf(stderr, "Can't allocate buffer memory\n");
+		return ret;
+        }
+
+        memset(target, -1, len_to_bip + (sizeof(padding) * 2));
+        memset(padding, -1, sizeof(padding));
+
+        if (dir == ENCRYPT) {
+                const uint16_t pli = ((((uint16_t) in_text[0]) << 8) |
+                                      ((uint16_t) in_text[1])) >> 2;
+
+                memcpy(target + sizeof(padding), in_text, len_to_bip);
+
+                /* Corrupt HEC on encrypt direction
+                 * This is to make sure HEC gets updated by the library
+                 */
+                target[sizeof(padding) + 7] ^= 0xff;
+
+                /* Corrupt Ethernet FCS/CRC on encrypt direction
+                 * This is to make sure CRC gets updated by the library
+                 */
+                if (pli > 4) {
+                        uint8_t *p_crc = &target[sizeof(padding) + 8 + pli - 4];
+
+                        p_crc[0] ^= 0xff;
+                        p_crc[1] ^= 0xff;
+                        p_crc[2] ^= 0xff;
+                        p_crc[3] ^= 0xff;
+                }
+        } else {
+                memcpy(target + sizeof(padding), out_text, len_to_bip);
+        }
+
+        while ((job = IMB_FLUSH_JOB(mb_mgr)) != NULL)
+                ;
+
+        job = IMB_GET_NEXT_JOB(mb_mgr);
+        job->cipher_direction = dir;
+        job->chain_order = order;
+        job->dst = target + sizeof(padding) + offset_to_cipher_crc;
+        job->src = target + sizeof(padding) /* in_text */;
+        job->cipher_mode = PON_AES_CNTR;
+        job->cipher_start_src_offset_in_bytes = (uint64_t) offset_to_cipher_crc;
+
+        /* If IV == NULL, NO CTR is done */
+        if (iv != NULL) {
+                job->aes_enc_key_expanded = expkey;
+                job->aes_dec_key_expanded = expkey;
+                job->aes_key_len_in_bytes = AES_128_BYTES;
+                job->iv = iv;
+                job->iv_len_in_bytes = 16;
+                job->msg_len_to_cipher_in_bytes = (uint64_t) len_to_cipher;
+        } else {
+                job->aes_enc_key_expanded = NULL;
+                job->aes_dec_key_expanded = NULL;
+                job->aes_key_len_in_bytes = 0;
+                job->iv = NULL;
+                job->iv_len_in_bytes = 0;
+                job->msg_len_to_cipher_in_bytes = 0;
+        }
+
+        job->hash_alg = PON_CRC_BIP;
+        job->hash_start_src_offset_in_bytes = 0;
+        job->msg_len_to_hash_in_bytes = (uint64_t) len_to_bip;
+        job->auth_tag_output = (void *) &tag_output;
+        job->auth_tag_output_len_in_bytes = (uint64_t) sizeof(tag_output);
+        job = IMB_SUBMIT_JOB(mb_mgr);
+
+        if (job == NULL) {
+                printf("%d NULL job after submit()", __LINE__);
+                goto end;
+        }
+
+        if (job->status != STS_COMPLETED) {
+                printf("%d Error status:%d", __LINE__, job->status);
+                goto end;
+        }
+
+        bip_output = (uint32_t) tag_output;
+        crc_output = (uint32_t) (tag_output >> 32);
+
+#ifdef DEBUG
+        printf("CRC received 0x%08x\n", crc_output);
+        printf("BIP received 0x%08x\n", bip_output);
+#endif
+
+#ifdef DEBUG
+        int is_error = 0;
+#endif
+
+        if (dir == DECRYPT) {
+                const uint16_t pli = ((((uint16_t) in_text[0]) << 8) |
+                                      ((uint16_t) in_text[1])) >> 2;
+
+                if (pli > 4) {
+                        const uint32_t crc_in_msg =
+                                *((const uint32_t *)&in_text[8 + pli - 4]);
+                        if (crc_in_msg != crc_output) {
+                                printf("CRC mismatch on decrypt! "
+                                       "expected 0x%08x, received 0x%08x\n",
+                                       crc_in_msg, crc_output);
+#ifdef DEBUG
+                                is_error = 1;
+#else
+                                goto end;
+#endif
+                        }
+                }
+        }
+
+        if (bip_output != bip_out) {
+                printf("BIP mismatch! expected 0x%08x, received 0x%08x\n",
+                       bip_out, bip_output);
+#ifdef DEBUG
+                is_error = 1;
+#else
+                goto end;
+#endif
+        }
+
+        if (dir == ENCRYPT) {
+                if (memcmp(out_text, target + sizeof(padding), len_to_bip)) {
+                        printf("output mismatch\n");
+                        hexdump(stderr, "Target",
+                                target, len_to_bip + (2 * sizeof(padding)));
+#ifdef DEBUG
+                        is_error = 1;
+#else
+                        goto end;
+#endif
+                }
+        } else {
+                if (memcmp(in_text, target + sizeof(padding), len_to_bip - 4)) {
+                        printf("output mismatch\n");
+                        hexdump(stderr, "Target", target,
+                                len_to_bip + (2 * sizeof(padding)));
+#ifdef DEBUG
+                        is_error = 1;
+#else
+                        goto end;
+#endif
+                }
+        }
+
+        if (memcmp(padding, target, sizeof(padding))) {
+                printf("overwrite head\n");
+                hexdump(stderr, "Target", target,
+                        len_to_bip + (2 * sizeof(padding)));
+#ifdef DEBUG
+                is_error = 1;
+#else
+                goto end;
+#endif
+        }
+
+        if (memcmp(padding, target + sizeof(padding) + len_to_bip,
+                   sizeof(padding))) {
+                printf("overwrite tail\n");
+                hexdump(stderr, "Target", target,
+                        len_to_bip + (2 * sizeof(padding)));
+#ifdef DEBUG
+                is_error = 1;
+#else
+                goto end;
+#endif
+        }
+
+#ifdef DEBUG
+        if (is_error)
+                goto end;
+#endif
+
+        /* all checks passed */
+        ret = 0;
+
+        while ((job = IMB_FLUSH_JOB(mb_mgr)) != NULL)
+                ;
+ end:
+        if (target != NULL)
+                free(target);
+
+        return ret;
+}
+
+static int
+test_pon_std_vectors(struct MB_MGR *mb_mgr)
+{
+	const int vectors_cnt = sizeof(pon_vectors) / sizeof(pon_vectors[0]);
+	int vect;
+	int errors = 0;
+        DECLARE_ALIGNED(uint32_t expkey[4*15], 16);
+        DECLARE_ALIGNED(uint32_t dust[4*15], 16);
+
+	printf("PON (AES128-CTR/CRC/BIP) test vectors:\n");
+
+	for (vect = 0; vect < vectors_cnt; vect++) {
+#ifdef DEBUG
+		printf("Vector %d/%d CIPHLen:%d BIPLen:%d\n",
+                       vect + 1, vectors_cnt,
+                       (int) pon_vectors[vect].length_to_cipher,
+                       (int) pon_vectors[vect].length_to_bip);
+#else
+		printf(".");
+#endif
+
+                if (pon_vectors[vect].key != NULL)
+                        IMB_AES_KEYEXP_128(mb_mgr, pon_vectors[vect].key,
+                                           expkey, dust);
+
+                if (test_pon(mb_mgr,
+                             expkey,
+                             pon_vectors[vect].iv,
+                             pon_vectors[vect].in,
+                             pon_vectors[vect].out,
+                             pon_vectors[vect].length_to_cipher,
+                             pon_vectors[vect].length_to_bip,
+                             pon_vectors[vect].offset_to_crc_cipher,
+                             pon_vectors[vect].bip_out,
+                             ENCRYPT, HASH_CIPHER)) {
+                        printf("error #%d encrypt\n", vect + 1);
+                        errors++;
+                }
+
+                if (test_pon(mb_mgr,
+                             expkey,
+                             pon_vectors[vect].iv,
+                             pon_vectors[vect].in,
+                             pon_vectors[vect].out,
+                             pon_vectors[vect].length_to_cipher,
+                             pon_vectors[vect].length_to_bip,
+                             pon_vectors[vect].offset_to_crc_cipher,
+                             pon_vectors[vect].bip_out,
+                             DECRYPT, CIPHER_HASH)) {
+                        printf("error #%d decrypt\n", vect + 1);
+                        errors++;
+                }
+	}
+	printf("\n");
+	return errors;
+}
+
+int pon_test(const enum arch_type arch, struct MB_MGR *mb_mgr)
+{
+        int errors = 0;
+
+        if (arch != ARCH_NO_AESNI)
+                errors = test_pon_std_vectors(mb_mgr);
+
+	if (0 == errors)
+		printf("...Pass\n");
+	else
+		printf("...Fail\n");
+
+	return errors;
+}