summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
91266a9)
Instead of passing the authentication and cipher offset
from the test vectors, just get them from the IV and AAD lengths.
Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
Acked-by: Fiona Trahe <fiona.trahe@intel.com>
const uint8_t *iv = tdata->iv.data;
const uint8_t iv_len = tdata->iv.len;
const unsigned int cipher_len = tdata->validCipherLenInBits.len;
const uint8_t *iv = tdata->iv.data;
const uint8_t iv_len = tdata->iv.len;
const unsigned int cipher_len = tdata->validCipherLenInBits.len;
- const unsigned int cipher_offset =
- tdata->validCipherOffsetLenInBits.len;
+ const unsigned int cipher_offset = tdata->iv.len << 3;
const unsigned int auth_len = tdata->validAuthLenInBits.len;
const unsigned int auth_len = tdata->validAuthLenInBits.len;
- const unsigned int auth_offset = tdata->validAuthOffsetLenInBits.len;
+ const unsigned int auth_offset = tdata->aad.len << 3;
unsigned int iv_pad_len = 0;
unsigned int aad_buffer_len;
unsigned int iv_pad_len = 0;
unsigned int aad_buffer_len;
plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
RTE_CRYPTO_AUTH_SNOW3G_UIA2,
tdata->validAuthLenInBits.len,
plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
RTE_CRYPTO_AUTH_SNOW3G_UIA2,
tdata->validAuthLenInBits.len,
- tdata->validAuthOffsetLenInBits.len);
+ (tdata->aad.len << 3));
if (retval < 0)
return retval;
if (retval < 0)
return retval;
RTE_CRYPTO_AUTH_OP_VERIFY,
RTE_CRYPTO_AUTH_SNOW3G_UIA2,
tdata->validAuthLenInBits.len,
RTE_CRYPTO_AUTH_OP_VERIFY,
RTE_CRYPTO_AUTH_SNOW3G_UIA2,
tdata->validAuthLenInBits.len,
- tdata->validAuthOffsetLenInBits.len);
+ (tdata->aad.len << 3));
if (retval < 0)
return retval;
if (retval < 0)
return retval;
plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
RTE_CRYPTO_AUTH_KASUMI_F9,
tdata->validAuthLenInBits.len,
plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
RTE_CRYPTO_AUTH_KASUMI_F9,
tdata->validAuthLenInBits.len,
- tdata->validAuthOffsetLenInBits.len);
+ (tdata->aad.len << 3));
if (retval < 0)
return retval;
if (retval < 0)
return retval;
RTE_CRYPTO_AUTH_OP_VERIFY,
RTE_CRYPTO_AUTH_KASUMI_F9,
tdata->validAuthLenInBits.len,
RTE_CRYPTO_AUTH_OP_VERIFY,
RTE_CRYPTO_AUTH_KASUMI_F9,
tdata->validAuthLenInBits.len,
- tdata->validAuthOffsetLenInBits.len);
+ (tdata->aad.len << 3));
if (retval < 0)
return retval;
if (retval < 0)
return retval;
/* Create KASUMI operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->plaintext.len,
/* Create KASUMI operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->plaintext.len,
- tdata->validCipherOffsetLenInBits.len,
RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
retval = create_wireless_algo_cipher_operation(tdata->iv.data,
tdata->iv.len,
tdata->plaintext.len,
retval = create_wireless_algo_cipher_operation(tdata->iv.data,
tdata->iv.len,
tdata->plaintext.len,
- tdata->validCipherOffsetLenInBits.len,
RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->plaintext.len,
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->plaintext.len,
- tdata->validCipherOffsetLenInBits.len,
RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->plaintext.len,
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->plaintext.len,
- tdata->validCipherOffsetLenInBits.len,
RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->ciphertext.len,
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->ciphertext.len,
- tdata->validCipherOffsetLenInBits.len,
RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
retval = create_wireless_algo_cipher_operation(tdata->iv.data,
tdata->iv.len,
tdata->ciphertext.len,
retval = create_wireless_algo_cipher_operation(tdata->iv.data,
tdata->iv.len,
tdata->ciphertext.len,
- tdata->validCipherOffsetLenInBits.len,
RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
RTE_CRYPTO_CIPHER_KASUMI_F8);
if (retval < 0)
return retval;
/* Create SNOW 3G operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
/* Create SNOW 3G operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
- tdata->validCipherOffsetLenInBits.len,
RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
- tdata->validCipherOffsetLenInBits.len,
RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
- tdata->validCipherOffsetLenInBits.len,
RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
- tdata->validCipherOffsetLenInBits.len +
extra_offset,
RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
extra_offset,
RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
/* Create SNOW 3G operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
/* Create SNOW 3G operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
- tdata->validCipherOffsetLenInBits.len,
RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
tdata->iv.len,
tdata->validCipherLenInBits.len,
- tdata->validCipherOffsetLenInBits.len,
RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
if (retval < 0)
return retval;
RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
- tdata->validCipherOffsetLenInBits.len,
tdata->validAuthLenInBits.len,
tdata->validAuthLenInBits.len,
- tdata->validAuthOffsetLenInBits.len
);
if (retval < 0)
return retval;
);
if (retval < 0)
return retval;
tdata->aad.data, tdata->aad.len,
plaintext_pad_len,
tdata->validCipherLenInBits.len,
tdata->aad.data, tdata->aad.len,
plaintext_pad_len,
tdata->validCipherLenInBits.len,
- tdata->validCipherOffsetLenInBits.len,
tdata->validAuthLenInBits.len,
tdata->validAuthLenInBits.len,
- tdata->validAuthOffsetLenInBits.len,
RTE_CRYPTO_AUTH_SNOW3G_UIA2,
RTE_CRYPTO_CIPHER_SNOW3G_UEA2
);
RTE_CRYPTO_AUTH_SNOW3G_UIA2,
RTE_CRYPTO_CIPHER_SNOW3G_UEA2
);
tdata->aad.data, tdata->aad.len,
plaintext_pad_len,
tdata->validCipherLenInBits.len,
tdata->aad.data, tdata->aad.len,
plaintext_pad_len,
tdata->validCipherLenInBits.len,
- tdata->validCipherOffsetLenInBits.len,
tdata->validAuthLenInBits.len,
tdata->validAuthLenInBits.len,
- tdata->validAuthOffsetLenInBits.len,
RTE_CRYPTO_AUTH_KASUMI_F9,
RTE_CRYPTO_CIPHER_KASUMI_F8
);
RTE_CRYPTO_AUTH_KASUMI_F9,
RTE_CRYPTO_CIPHER_KASUMI_F8
);
RTE_CRYPTO_CIPHER_KASUMI_F8,
tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
RTE_CRYPTO_CIPHER_KASUMI_F8,
tdata->iv.data, tdata->iv.len,
tdata->validCipherLenInBits.len,
- tdata->validCipherOffsetLenInBits.len,
tdata->validAuthLenInBits.len,
tdata->validAuthLenInBits.len,
- tdata->validAuthOffsetLenInBits.len
);
if (retval < 0)
return retval;
);
if (retval < 0)
return retval;
/* Create ZUC operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->plaintext.len,
/* Create ZUC operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
tdata->plaintext.len,
- tdata->validCipherOffsetLenInBits.len,
RTE_CRYPTO_CIPHER_ZUC_EEA3);
if (retval < 0)
return retval;
RTE_CRYPTO_CIPHER_ZUC_EEA3);
if (retval < 0)
return retval;
/* Create ZUC operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data,
tdata->iv.len, tdata->plaintext.len,
/* Create ZUC operation */
retval = create_wireless_algo_cipher_operation(tdata->iv.data,
tdata->iv.len, tdata->plaintext.len,
- tdata->validCipherOffsetLenInBits.len,
RTE_CRYPTO_CIPHER_ZUC_EEA3);
if (retval < 0)
return retval;
RTE_CRYPTO_CIPHER_ZUC_EEA3);
if (retval < 0)
return retval;
plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
RTE_CRYPTO_AUTH_ZUC_EIA3,
tdata->validAuthLenInBits.len,
plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
RTE_CRYPTO_AUTH_ZUC_EIA3,
tdata->validAuthLenInBits.len,
- tdata->validAuthOffsetLenInBits.len);
+ (tdata->aad.len << 3));
if (retval < 0)
return retval;
if (retval < 0)
return retval;
unsigned len;
} validAuthLenInBits;
unsigned len;
} validAuthLenInBits;
- struct {
- unsigned len;
- } validAuthOffsetLenInBits;
-
struct {
uint8_t data[64];
unsigned len;
struct {
uint8_t data[64];
unsigned len;
.validAuthLenInBits = {
.len = 189
},
.validAuthLenInBits = {
.len = 189
},
- .validAuthOffsetLenInBits = {
- .len = 64
- },
.digest = {
.data = {0xF6, 0x3B, 0xD7, 0x2C},
.len = 4
.digest = {
.data = {0xF6, 0x3B, 0xD7, 0x2C},
.len = 4
.validAuthLenInBits = {
.len = 254
},
.validAuthLenInBits = {
.len = 254
},
- .validAuthOffsetLenInBits = {
- .len = 64
- },
.digest = {
.data = {0xA9, 0xDA, 0xF1, 0xFF},
.len = 4
.digest = {
.data = {0xA9, 0xDA, 0xF1, 0xFF},
.len = 4
.validAuthLenInBits = {
.len = 319
},
.validAuthLenInBits = {
.len = 319
},
- .validAuthOffsetLenInBits = {
- .len = 64
- },
.digest = {
.data = {0x15, 0x37, 0xD3, 0x16},
.len = 4
.digest = {
.data = {0x15, 0x37, 0xD3, 0x16},
.len = 4
.validAuthLenInBits = {
.len = 384
},
.validAuthLenInBits = {
.len = 384
},
- .validAuthOffsetLenInBits = {
- .len = 64
- },
.digest = {
.data = {0xDD, 0x7D, 0xFA, 0xDD },
.len = 4
.digest = {
.data = {0xDD, 0x7D, 0xFA, 0xDD },
.len = 4
.validAuthLenInBits = {
.len = 1000
},
.validAuthLenInBits = {
.len = 1000
},
- .validAuthOffsetLenInBits = {
- .len = 64
- },
.digest = {
.data = {0xC3, 0x83, 0x83, 0x9D},
.len = 4
.digest = {
.data = {0xC3, 0x83, 0x83, 0x9D},
.len = 4
.validAuthLenInBits = {
.len = 768
},
.validAuthLenInBits = {
.len = 768
},
- .validAuthOffsetLenInBits = {
- .len = 64
- },
.digest = {
.data = {0x95, 0xAE, 0x41, 0xBA},
.len = 4
.digest = {
.data = {0x95, 0xAE, 0x41, 0xBA},
.len = 4
.validAuthLenInBits = {
.len = 120
},
.validAuthLenInBits = {
.len = 120
},
- .validAuthOffsetLenInBits = {
- .len = 64
- },
.digest = {
.data = {0x87, 0x5F, 0xE4, 0x89},
.len = 4
.digest = {
.data = {0x87, 0x5F, 0xE4, 0x89},
.len = 4
unsigned len;
} validCipherLenInBits;
unsigned len;
} validCipherLenInBits;
- struct {
- unsigned len;
- } validCipherOffsetLenInBits;
-
/* Actual length of data to be hashed */
struct {
unsigned len;
} validAuthLenInBits;
/* Actual length of data to be hashed */
struct {
unsigned len;
} validAuthLenInBits;
- struct {
- unsigned len;
- } validAuthOffsetLenInBits;
-
struct {
uint8_t data[64];
unsigned len;
struct {
uint8_t data[64];
unsigned len;
},
.validCipherLenInBits = {
.len = 798
},
.validCipherLenInBits = {
.len = 798
- },
- .validCipherOffsetLenInBits = {
- .len = 64
- },
};
struct kasumi_test_data kasumi_test_case_2 = {
};
struct kasumi_test_data kasumi_test_case_2 = {
},
.validCipherLenInBits = {
.len = 510
},
.validCipherLenInBits = {
.len = 510
- },
- .validCipherOffsetLenInBits = {
- .len = 64
.validCipherLenInBits = {
.len = 120
},
.validCipherLenInBits = {
.len = 120
},
- .validCipherOffsetLenInBits = {
- .len = 64
- },
.validAuthLenInBits = {
.len = 120
},
.validAuthLenInBits = {
.len = 120
},
- .validAuthOffsetLenInBits = {
- .len = 64
- },
.digest = {
.data = {0x87, 0x5F, 0xE4, 0x89},
.len = 4
.digest = {
.data = {0x87, 0x5F, 0xE4, 0x89},
.len = 4
},
.validCipherLenInBits = {
.len = 253
},
.validCipherLenInBits = {
.len = 253
- },
- .validCipherOffsetLenInBits = {
- .len = 64
},
.validCipherLenInBits = {
.len = 837
},
.validCipherLenInBits = {
.len = 837
- },
- .validCipherOffsetLenInBits = {
- .len = 64
- },
};
struct kasumi_test_data kasumi_test_case_6 = {
};
struct kasumi_test_data kasumi_test_case_6 = {
.validCipherLenInBits = {
.len = 120
},
.validCipherLenInBits = {
.len = 120
},
- .validCipherOffsetLenInBits = {
- .len = 64
- },
.validAuthLenInBits = {
.len = 120
},
.validAuthLenInBits = {
.len = 120
},
- .validAuthOffsetLenInBits = {
- .len = 64
- },
.digest = {
.data = {0x0F, 0xD2, 0xAA, 0xB5},
.len = 4
.digest = {
.data = {0x0F, 0xD2, 0xAA, 0xB5},
.len = 4
unsigned len;
} validAuthLenInBits;
unsigned len;
} validAuthLenInBits;
- struct {
- unsigned len;
- } validAuthOffsetLenInBits;
-
struct {
uint8_t data[64];
unsigned len;
struct {
uint8_t data[64];
unsigned len;
.validAuthLenInBits = {
.len = 384
},
.validAuthLenInBits = {
.len = 384
},
- .validAuthOffsetLenInBits = {
- .len = 128
- },
.digest = {
.data = {0x38, 0xB5, 0x54, 0xC0 },
.len = 4
.digest = {
.data = {0x38, 0xB5, 0x54, 0xC0 },
.len = 4
.validAuthLenInBits = {
.len = 1000
},
.validAuthLenInBits = {
.len = 1000
},
- .validAuthOffsetLenInBits = {
- .len = 128
- },
.digest = {
.data = {0x06, 0x17, 0x45, 0xAE},
.len = 4
.digest = {
.data = {0x06, 0x17, 0x45, 0xAE},
.len = 4
.validAuthLenInBits = {
.len = 16448
},
.validAuthLenInBits = {
.len = 16448
},
- .validAuthOffsetLenInBits = {
- .len = 128
- },
.digest = {
.data = {0x17, 0x9F, 0x2F, 0xA6},
.len = 4
.digest = {
.data = {0x17, 0x9F, 0x2F, 0xA6},
.len = 4
.validAuthLenInBits = {
.len = 189
},
.validAuthLenInBits = {
.len = 189
},
- .validAuthOffsetLenInBits = {
- .len = 128
- },
.digest = {
.data = {0x2B, 0xCE, 0x18, 0x20},
.len = 4
.digest = {
.data = {0x2B, 0xCE, 0x18, 0x20},
.len = 4
.validAuthLenInBits = {
.len = 254
},
.validAuthLenInBits = {
.len = 254
},
- .validAuthOffsetLenInBits = {
- .len = 128
- },
.digest = {
.data = {0xFC, 0x7B, 0x18, 0xBD},
.len = 4
.digest = {
.data = {0xFC, 0x7B, 0x18, 0xBD},
.len = 4
.validAuthLenInBits = {
.len = 319
},
.validAuthLenInBits = {
.len = 319
},
- .validAuthOffsetLenInBits = {
- .len = 128
- },
.digest = {
.data = {0x02, 0xF1, 0xFA, 0xAF},
.len = 4
.digest = {
.data = {0x02, 0xF1, 0xFA, 0xAF},
.len = 4
unsigned len;
} validCipherLenInBits;
unsigned len;
} validCipherLenInBits;
- struct {
- unsigned len;
- } validCipherOffsetLenInBits;
-
struct {
unsigned len;
} validAuthLenInBits;
struct {
unsigned len;
} validAuthLenInBits;
- struct {
- unsigned len;
- } validAuthOffsetLenInBits;
-
struct {
uint8_t data[64];
unsigned len;
struct {
uint8_t data[64];
unsigned len;
.validCipherLenInBits = {
.len = 800
},
.validCipherLenInBits = {
.len = 800
},
- .validCipherOffsetLenInBits = {
- .len = 128
- },
.aad = {
.data = {
0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00,
.aad = {
.data = {
0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00,
.validCipherLenInBits = {
.len = 512
},
.validCipherLenInBits = {
.len = 512
},
- .validCipherOffsetLenInBits = {
- .len = 128
- },
.aad = {
.data = {
0xE2, 0x8B, 0xCF, 0x7B, 0xC0, 0x00, 0x00, 0x00,
.aad = {
.data = {
0xE2, 0x8B, 0xCF, 0x7B, 0xC0, 0x00, 0x00, 0x00,
.validCipherLenInBits = {
.len = 120
},
.validCipherLenInBits = {
.len = 120
},
- .validCipherOffsetLenInBits = {
- .len = 128
- },
.aad = {
.data = {
0xFA, 0x55, 0x6B, 0x26, 0x1C, 0x00, 0x00, 0x00,
.aad = {
.data = {
0xFA, 0x55, 0x6B, 0x26, 0x1C, 0x00, 0x00, 0x00,
},
.validAuthLenInBits = {
.len = 120
},
.validAuthLenInBits = {
.len = 120
- },
- .validAuthOffsetLenInBits = {
- .len = 128
},
.validCipherLenInBits = {
.len = 256
},
.validCipherLenInBits = {
.len = 256
- },
- .validCipherOffsetLenInBits = {
- .len = 128
.validCipherLenInBits = {
.len = 840
},
.validCipherLenInBits = {
.len = 840
},
- .validCipherOffsetLenInBits = {
- .len = 128
- }
};
struct snow3g_test_data snow3g_test_case_6 = {
.key = {
};
struct snow3g_test_data snow3g_test_case_6 = {
.key = {
.validCipherLenInBits = {
.len = 384
},
.validCipherLenInBits = {
.len = 384
},
- .validCipherOffsetLenInBits = {
- .len = 128
- },
.validAuthLenInBits = {
.len = 384
},
.validAuthLenInBits = {
.len = 384
},
- .validAuthOffsetLenInBits = {
- .len = 128
- }
};
#endif /* TEST_CRYPTODEV_SNOW3G_TEST_VECTORS_H_ */
};
#endif /* TEST_CRYPTODEV_SNOW3G_TEST_VECTORS_H_ */
unsigned len;
} validCipherLenInBits;
unsigned len;
} validCipherLenInBits;
- struct {
- unsigned len;
- } validCipherOffsetLenInBits;
-
struct {
unsigned len;
} validAuthLenInBits;
struct {
unsigned len;
} validAuthLenInBits;
- struct {
- unsigned len;
- } validAuthOffsetLenInBits;
-
struct {
uint8_t data[64];
unsigned len;
struct {
uint8_t data[64];
unsigned len;
},
.validCipherLenInBits = {
.len = 193
},
.validCipherLenInBits = {
.len = 193
- },
- .validCipherOffsetLenInBits = {
- .len = 128
},
.validCipherLenInBits = {
.len = 800
},
.validCipherLenInBits = {
.len = 800
- },
- .validCipherOffsetLenInBits = {
- .len = 128
},
.validCipherLenInBits = {
.len = 1570
},
.validCipherLenInBits = {
.len = 1570
- },
- .validCipherOffsetLenInBits = {
- .len = 128
- },
};
static struct wireless_test_data zuc_test_case_cipher_2798b = {
};
static struct wireless_test_data zuc_test_case_cipher_2798b = {
},
.validCipherLenInBits = {
.len = 2798
},
.validCipherLenInBits = {
.len = 2798
- },
- .validCipherOffsetLenInBits = {
- .len = 128
},
.validCipherLenInBits = {
.len = 4019
},
.validCipherLenInBits = {
.len = 4019
- },
- .validCipherOffsetLenInBits = {
- .len = 128
.validCipherLenInBits = {
.len = 200
},
.validCipherLenInBits = {
.len = 200
},
- .validCipherOffsetLenInBits = {
- .len = 128
- },
.aad = {
.data = {
0xFA, 0x55, 0x6B, 0x26, 0x1C, 0x00, 0x00, 0x00,
.aad = {
.data = {
0xFA, 0x55, 0x6B, 0x26, 0x1C, 0x00, 0x00, 0x00,
},
.validAuthLenInBits = {
.len = 200
},
.validAuthLenInBits = {
.len = 200
- },
- .validAuthOffsetLenInBits = {
- .len = 128
.validCipherLenInBits = {
.len = 800
},
.validCipherLenInBits = {
.len = 800
},
- .validCipherOffsetLenInBits = {
- .len = 128
- },
.aad = {
.data = {
0xFA, 0x55, 0x6B, 0x26, 0x1C, 0x00, 0x00, 0x00,
.aad = {
.data = {
0xFA, 0x55, 0x6B, 0x26, 0x1C, 0x00, 0x00, 0x00,
},
.validAuthLenInBits = {
.len = 120
},
.validAuthLenInBits = {
.len = 120
- },
- .validAuthOffsetLenInBits = {
- .len = 128
.validAuthLenInBits = {
.len = 1
},
.validAuthLenInBits = {
.len = 1
},
- .validAuthOffsetLenInBits = {
- .len = 128
- },
.digest = {
.data = {0xC8, 0xA9, 0x59, 0x5E},
.len = 4
.digest = {
.data = {0xC8, 0xA9, 0x59, 0x5E},
.len = 4
.validAuthLenInBits = {
.len = 90
},
.validAuthLenInBits = {
.len = 90
},
- .validAuthOffsetLenInBits = {
- .len = 128
- },
.digest = {
.data = {0x67, 0x19, 0xA0, 0x88},
.len = 4
.digest = {
.data = {0x67, 0x19, 0xA0, 0x88},
.len = 4
.validAuthLenInBits = {
.len = 577
},
.validAuthLenInBits = {
.len = 577
},
- .validAuthOffsetLenInBits = {
- .len = 128
- },
.digest = {
.data = {0xFA, 0xE8, 0xFF, 0x0B},
.len = 4
.digest = {
.data = {0xFA, 0xE8, 0xFF, 0x0B},
.len = 4
.validAuthLenInBits = {
.len = 2079
},
.validAuthLenInBits = {
.len = 2079
},
- .validAuthOffsetLenInBits = {
- .len = 128
- },
.digest = {
.data = {0x00, 0x4A, 0xC4, 0xD6},
.len = 4
.digest = {
.data = {0x00, 0x4A, 0xC4, 0xD6},
.len = 4
.validAuthLenInBits = {
.len = 5670
},
.validAuthLenInBits = {
.len = 5670
},
- .validAuthOffsetLenInBits = {
- .len = 128
- },
.digest = {
.data = {0x0C, 0xA1, 0x27, 0x92},
.len = 4
.digest = {
.data = {0x0C, 0xA1, 0x27, 0x92},
.len = 4
.validAuthLenInBits = {
.len = 8
},
.validAuthLenInBits = {
.len = 8
},
- .validAuthOffsetLenInBits = {
- .len = 128
- },
.digest = {
.data = { 0x39, 0x0a, 0x91, 0xb7 },
.len = 4
.digest = {
.data = { 0x39, 0x0a, 0x91, 0xb7 },
.len = 4
.validAuthLenInBits = {
.len = 2080
},
.validAuthLenInBits = {
.len = 2080
},
- .validAuthOffsetLenInBits = {
- .len = 128
- },
.digest = {
.data = {0x03, 0x95, 0x32, 0xe1},
.len = 4
.digest = {
.data = {0x03, 0x95, 0x32, 0xe1},
.len = 4
.validAuthLenInBits = {
.len = 584
},
.validAuthLenInBits = {
.len = 584
},
- .validAuthOffsetLenInBits = {
- .len = 128
- },
.digest = {
.data = {0x24, 0xa8, 0x42, 0xb3},
.len = 4
.digest = {
.data = {0x24, 0xa8, 0x42, 0xb3},
.len = 4