diff options
59 files changed, 1159 insertions, 1159 deletions
diff --git a/examples/aes128cbc.c b/examples/aes128cbc.c index 986be2e..b2eb14a 100644 --- a/examples/aes128cbc.c +++ b/examples/aes128cbc.c @@ -12,55 +12,55 @@ int main() { - AesBlock128 plain, key, cipher, decrypted, iv, next_iv; - Aes128KeySchedule key_schedule, inverted_schedule; + AesNI_Block128 plain, key, cipher, decrypted, iv, next_iv; + AesNI_KeySchedule128 key_schedule, inverted_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block128(&key).str); - print_aes_block128_as_matrix(&key); + printf("Key: %s\n", aesni_format_block128(&key).str); + aesni_print_block128_as_matrix(&key); printf("\n"); - printf("Initialization vector: %s\n", format_aes_block128(&iv).str); - print_aes_block128_as_matrix(&iv); + printf("Initialization vector: %s\n", aesni_format_block128(&iv).str); + aesni_print_block128_as_matrix(&iv); - aes128_expand_key_schedule(key, &key_schedule); + aesni_expand_key_schedule128(key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 11; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes128cbc_encrypt_block(plain, &key_schedule, iv, &next_iv); + cipher = aesni_encrypt_block_cbc128(plain, &key_schedule, iv, &next_iv); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); - aes128_invert_key_schedule(&key_schedule, &inverted_schedule); + aesni_invert_key_schedule128(&key_schedule, &inverted_schedule); printf("\n"); printf("Inverted key schedule:\n"); for (int i = 0; i < 11; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&inverted_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&inverted_schedule.keys[i]).str); - decrypted = aes128cbc_decrypt_block(cipher, &inverted_schedule, iv, &next_iv); + decrypted = aesni_decrypt_block_cbc128(cipher, &inverted_schedule, iv, &next_iv); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); return 0; } diff --git a/examples/aes128cfb.c b/examples/aes128cfb.c index 2d209ca..31ad748 100644 --- a/examples/aes128cfb.c +++ b/examples/aes128cfb.c @@ -12,48 +12,48 @@ int main() { - AesBlock128 plain, key, cipher, decrypted, iv, next_iv; - Aes128KeySchedule key_schedule; + AesNI_Block128 plain, key, cipher, decrypted, iv, next_iv; + AesNI_KeySchedule128 key_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block128(&key).str); - print_aes_block128_as_matrix(&key); + printf("Key: %s\n", aesni_format_block128(&key).str); + aesni_print_block128_as_matrix(&key); printf("\n"); - printf("Initialization vector: %s\n", format_aes_block128(&iv).str); - print_aes_block128_as_matrix(&iv); + printf("Initialization vector: %s\n", aesni_format_block128(&iv).str); + aesni_print_block128_as_matrix(&iv); - aes128_expand_key_schedule(key, &key_schedule); + aesni_expand_key_schedule128(key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 11; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes128cfb_encrypt_block(plain, &key_schedule, iv, &next_iv); + cipher = aesni_encrypt_block_cfb128(plain, &key_schedule, iv, &next_iv); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); - decrypted = aes128cfb_decrypt_block(cipher, &key_schedule, iv, &next_iv); + decrypted = aesni_decrypt_block_cfb128(cipher, &key_schedule, iv, &next_iv); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); return 0; } diff --git a/examples/aes128ctr.c b/examples/aes128ctr.c index c645da7..1efe4e2 100644 --- a/examples/aes128ctr.c +++ b/examples/aes128ctr.c @@ -12,40 +12,40 @@ int main() { - AesBlock128 plain, key, cipher, decrypted, iv; - Aes128KeySchedule key_schedule; + AesNI_Block128 plain, key, cipher, decrypted, iv; + AesNI_KeySchedule128 key_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block128(&key).str); - print_aes_block128_as_matrix(&key); + printf("Key: %s\n", aesni_format_block128(&key).str); + aesni_print_block128_as_matrix(&key); printf("\n"); - printf("Initialization vector: %s\n", format_aes_block128(&iv).str); - print_aes_block128_as_matrix(&iv); + printf("Initialization vector: %s\n", aesni_format_block128(&iv).str); + aesni_print_block128_as_matrix(&iv); - aes128_expand_key_schedule(key, &key_schedule); + aesni_expand_key_schedule128(key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 11; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes128ctr_encrypt_block(plain, &key_schedule, iv, 0); + cipher = aesni_encrypt_block_ctr128(plain, &key_schedule, iv, 0); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); - decrypted = aes128ctr_decrypt_block(cipher, &key_schedule, iv, 0); + decrypted = aesni_decrypt_block_ctr128(cipher, &key_schedule, iv, 0); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); return 0; } diff --git a/examples/aes128ecb.c b/examples/aes128ecb.c index e36cd66..4f999d4 100644 --- a/examples/aes128ecb.c +++ b/examples/aes128ecb.c @@ -12,42 +12,42 @@ int main() { - AesBlock128 plain, key, cipher, decrypted; - Aes128KeySchedule key_schedule, inverted_schedule; + AesNI_Block128 plain, key, cipher, decrypted; + AesNI_KeySchedule128 key_schedule, inverted_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block128(&key).str); - print_aes_block128_as_matrix(&key); + printf("Key: %s\n", aesni_format_block128(&key).str); + aesni_print_block128_as_matrix(&key); - aes128_expand_key_schedule(key, &key_schedule); + aesni_expand_key_schedule128(key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 11; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes128ecb_encrypt_block(plain, &key_schedule); + cipher = aesni_encrypt_block_ecb128(plain, &key_schedule); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); - aes128_invert_key_schedule(&key_schedule, &inverted_schedule); + aesni_invert_key_schedule128(&key_schedule, &inverted_schedule); printf("\n"); printf("Inverted key schedule:\n"); for (int i = 0; i < 11; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&inverted_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&inverted_schedule.keys[i]).str); - decrypted = aes128ecb_decrypt_block(cipher, &inverted_schedule); + decrypted = aesni_decrypt_block_ecb128(cipher, &inverted_schedule); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); return 0; } diff --git a/examples/aes128ofb.c b/examples/aes128ofb.c index 12ef468..49a97ed 100644 --- a/examples/aes128ofb.c +++ b/examples/aes128ofb.c @@ -12,48 +12,48 @@ int main() { - AesBlock128 plain, key, cipher, decrypted, iv, next_iv; - Aes128KeySchedule key_schedule; + AesNI_Block128 plain, key, cipher, decrypted, iv, next_iv; + AesNI_KeySchedule128 key_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block128(&key).str); - print_aes_block128_as_matrix(&key); + printf("Key: %s\n", aesni_format_block128(&key).str); + aesni_print_block128_as_matrix(&key); printf("\n"); - printf("Initialization vector: %s\n", format_aes_block128(&iv).str); - print_aes_block128_as_matrix(&iv); + printf("Initialization vector: %s\n", aesni_format_block128(&iv).str); + aesni_print_block128_as_matrix(&iv); - aes128_expand_key_schedule(key, &key_schedule); + aesni_expand_key_schedule128(key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 11; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes128ofb_encrypt_block(plain, &key_schedule, iv, &next_iv); + cipher = aesni_encrypt_block_ofb128(plain, &key_schedule, iv, &next_iv); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); - decrypted = aes128ofb_decrypt_block(cipher, &key_schedule, iv, &next_iv); + decrypted = aesni_decrypt_block_ofb128(cipher, &key_schedule, iv, &next_iv); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); return 0; } diff --git a/examples/aes192cbc.c b/examples/aes192cbc.c index 406575c..67adf95 100644 --- a/examples/aes192cbc.c +++ b/examples/aes192cbc.c @@ -12,56 +12,56 @@ int main() { - AesBlock128 plain, cipher, decrypted, iv, next_iv; - AesBlock192 key; - Aes192KeySchedule key_schedule, inverted_schedule; + AesNI_Block128 plain, cipher, decrypted, iv, next_iv; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule, inverted_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block192(&key).str); - print_aes_block192_as_matrix(&key); + printf("Key: %s\n", aesni_format_block192(&key).str); + aesni_print_block192_as_matrix(&key); printf("\n"); - printf("Initialization vector: %s\n", format_aes_block128(&iv).str); - print_aes_block128_as_matrix(&iv); + printf("Initialization vector: %s\n", aesni_format_block128(&iv).str); + aesni_print_block128_as_matrix(&iv); - aes192_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 13; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes192cbc_encrypt_block(plain, &key_schedule, iv, &next_iv); + cipher = aesni_encrypt_block_cbc192(plain, &key_schedule, iv, &next_iv); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); - aes192_invert_key_schedule(&key_schedule, &inverted_schedule); + aesni_invert_key_schedule192(&key_schedule, &inverted_schedule); printf("\n"); printf("Inverted key schedule:\n"); for (int i = 0; i < 13; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&inverted_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&inverted_schedule.keys[i]).str); - decrypted = aes192cbc_decrypt_block(cipher, &inverted_schedule, iv, &next_iv); + decrypted = aesni_decrypt_block_cbc192(cipher, &inverted_schedule, iv, &next_iv); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); return 0; } diff --git a/examples/aes192cfb.c b/examples/aes192cfb.c index 103ac12..d5bf554 100644 --- a/examples/aes192cfb.c +++ b/examples/aes192cfb.c @@ -12,49 +12,49 @@ int main() { - AesBlock128 plain, cipher, decrypted, iv, next_iv; - AesBlock192 key; - Aes192KeySchedule key_schedule; + AesNI_Block128 plain, cipher, decrypted, iv, next_iv; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block192(&key).str); - print_aes_block192_as_matrix(&key); + printf("Key: %s\n", aesni_format_block192(&key).str); + aesni_print_block192_as_matrix(&key); printf("\n"); - printf("Initialization vector: %s\n", format_aes_block128(&iv).str); - print_aes_block128_as_matrix(&iv); + printf("Initialization vector: %s\n", aesni_format_block128(&iv).str); + aesni_print_block128_as_matrix(&iv); - aes192_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 13; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes192cfb_encrypt_block(plain, &key_schedule, iv, &next_iv); + cipher = aesni_encrypt_block_cfb192(plain, &key_schedule, iv, &next_iv); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); - decrypted = aes192cfb_decrypt_block(cipher, &key_schedule, iv, &next_iv); + decrypted = aesni_decrypt_block_cfb192(cipher, &key_schedule, iv, &next_iv); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); return 0; } diff --git a/examples/aes192ctr.c b/examples/aes192ctr.c index 48d4b14..3ce7c76 100644 --- a/examples/aes192ctr.c +++ b/examples/aes192ctr.c @@ -12,41 +12,41 @@ int main() { - AesBlock128 plain, cipher, decrypted, iv; - AesBlock192 key; - Aes192KeySchedule key_schedule; + AesNI_Block128 plain, cipher, decrypted, iv; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block192(&key).str); - print_aes_block192_as_matrix(&key); + printf("Key: %s\n", aesni_format_block192(&key).str); + aesni_print_block192_as_matrix(&key); printf("\n"); - printf("Initialization vector: %s\n", format_aes_block128(&iv).str); - print_aes_block128_as_matrix(&iv); + printf("Initialization vector: %s\n", aesni_format_block128(&iv).str); + aesni_print_block128_as_matrix(&iv); - aes192_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 13; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes192ctr_encrypt_block(plain, &key_schedule, iv, 0); + cipher = aesni_encrypt_block_ctr192(plain, &key_schedule, iv, 0); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); - decrypted = aes192ctr_decrypt_block(cipher, &key_schedule, iv, 0); + decrypted = aesni_decrypt_block_ctr192(cipher, &key_schedule, iv, 0); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); return 0; } diff --git a/examples/aes192ecb.c b/examples/aes192ecb.c index f7a05af..775ca7d 100644 --- a/examples/aes192ecb.c +++ b/examples/aes192ecb.c @@ -12,43 +12,43 @@ int main() { - AesBlock128 plain, cipher, decrypted; - AesBlock192 key; - Aes192KeySchedule key_schedule, inverted_schedule; + AesNI_Block128 plain, cipher, decrypted; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule, inverted_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block192(&key).str); - print_aes_block192_as_matrix(&key); + printf("Key: %s\n", aesni_format_block192(&key).str); + aesni_print_block192_as_matrix(&key); - aes192_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 13; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes192ecb_encrypt_block(plain, &key_schedule); + cipher = aesni_encrypt_block_ecb192(plain, &key_schedule); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); - aes192_invert_key_schedule(&key_schedule, &inverted_schedule); + aesni_invert_key_schedule192(&key_schedule, &inverted_schedule); printf("\n"); printf("Inverted key schedule:\n"); for (int i = 0; i < 13; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&inverted_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&inverted_schedule.keys[i]).str); - decrypted = aes192ecb_decrypt_block(cipher, &inverted_schedule); + decrypted = aesni_decrypt_block_ecb192(cipher, &inverted_schedule); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); return 0; } diff --git a/examples/aes192ofb.c b/examples/aes192ofb.c index 3c4f025..33e9429 100644 --- a/examples/aes192ofb.c +++ b/examples/aes192ofb.c @@ -12,49 +12,49 @@ int main() { - AesBlock128 plain, cipher, decrypted, iv, next_iv; - AesBlock192 key; - Aes192KeySchedule key_schedule; + AesNI_Block128 plain, cipher, decrypted, iv, next_iv; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block192(&key).str); - print_aes_block192_as_matrix(&key); + printf("Key: %s\n", aesni_format_block192(&key).str); + aesni_print_block192_as_matrix(&key); printf("\n"); - printf("Initialization vector: %s\n", format_aes_block128(&iv).str); - print_aes_block128_as_matrix(&iv); + printf("Initialization vector: %s\n", aesni_format_block128(&iv).str); + aesni_print_block128_as_matrix(&iv); - aes192_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 13; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes192ofb_encrypt_block(plain, &key_schedule, iv, &next_iv); + cipher = aesni_encrypt_block_ofb192(plain, &key_schedule, iv, &next_iv); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); - decrypted = aes192ofb_decrypt_block(cipher, &key_schedule, iv, &next_iv); + decrypted = aesni_decrypt_block_ofb192(cipher, &key_schedule, iv, &next_iv); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); return 0; } diff --git a/examples/aes256cbc.c b/examples/aes256cbc.c index 0a148e1..3af1015 100644 --- a/examples/aes256cbc.c +++ b/examples/aes256cbc.c @@ -12,56 +12,56 @@ int main() { - AesBlock128 plain, cipher, decrypted, iv, next_iv; - AesBlock256 key; - Aes256KeySchedule key_schedule, inverted_schedule; + AesNI_Block128 plain, cipher, decrypted, iv, next_iv; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule, inverted_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block256(&key).str); - print_aes_block256_as_matrix(&key); + printf("Key: %s\n", aesni_format_block256(&key).str); + aesni_print_block256_as_matrix(&key); printf("\n"); - printf("Initialization vector: %s\n", format_aes_block128(&iv).str); - print_aes_block128_as_matrix(&iv); + printf("Initialization vector: %s\n", aesni_format_block128(&iv).str); + aesni_print_block128_as_matrix(&iv); - aes256_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 15; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes256cbc_encrypt_block(plain, &key_schedule, iv, &next_iv); + cipher = aesni_encrypt_block_cbc256(plain, &key_schedule, iv, &next_iv); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); - aes256_invert_key_schedule(&key_schedule, &inverted_schedule); + aesni_invert_key_schedule256(&key_schedule, &inverted_schedule); printf("\n"); printf("Inverted key schedule:\n"); for (int i = 0; i < 15; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&inverted_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&inverted_schedule.keys[i]).str); - decrypted = aes256cbc_decrypt_block(cipher, &inverted_schedule, iv, &next_iv); + decrypted = aesni_decrypt_block_cbc256(cipher, &inverted_schedule, iv, &next_iv); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); return 0; } diff --git a/examples/aes256cfb.c b/examples/aes256cfb.c index 44d5f30..6ee1134 100644 --- a/examples/aes256cfb.c +++ b/examples/aes256cfb.c @@ -12,49 +12,49 @@ int main() { - AesBlock128 plain, cipher, decrypted, iv, next_iv; - AesBlock256 key; - Aes256KeySchedule key_schedule; + AesNI_Block128 plain, cipher, decrypted, iv, next_iv; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block256(&key).str); - print_aes_block256_as_matrix(&key); + printf("Key: %s\n", aesni_format_block256(&key).str); + aesni_print_block256_as_matrix(&key); printf("\n"); - printf("Initialization vector: %s\n", format_aes_block128(&iv).str); - print_aes_block128_as_matrix(&iv); + printf("Initialization vector: %s\n", aesni_format_block128(&iv).str); + aesni_print_block128_as_matrix(&iv); - aes256_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 15; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes256cfb_encrypt_block(plain, &key_schedule, iv, &next_iv); + cipher = aesni_encrypt_block_cfb256(plain, &key_schedule, iv, &next_iv); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); - decrypted = aes256cfb_decrypt_block(cipher, &key_schedule, iv, &next_iv); + decrypted = aesni_decrypt_block_cfb256(cipher, &key_schedule, iv, &next_iv); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); return 0; } diff --git a/examples/aes256ctr.c b/examples/aes256ctr.c index 0a47004..05c5090 100644 --- a/examples/aes256ctr.c +++ b/examples/aes256ctr.c @@ -12,41 +12,41 @@ int main() { - AesBlock128 plain, cipher, decrypted, iv; - AesBlock256 key; - Aes256KeySchedule key_schedule; + AesNI_Block128 plain, cipher, decrypted, iv; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block256(&key).str); - print_aes_block256_as_matrix(&key); + printf("Key: %s\n", aesni_format_block256(&key).str); + aesni_print_block256_as_matrix(&key); printf("\n"); - printf("Initialization vector: %s\n", format_aes_block128(&iv).str); - print_aes_block128_as_matrix(&iv); + printf("Initialization vector: %s\n", aesni_format_block128(&iv).str); + aesni_print_block128_as_matrix(&iv); - aes256_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 15; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes256ctr_encrypt_block(plain, &key_schedule, iv, 0); + cipher = aesni_encrypt_block_ctr256(plain, &key_schedule, iv, 0); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); - decrypted = aes256ctr_decrypt_block(cipher, &key_schedule, iv, 0); + decrypted = aesni_decrypt_block_ctr256(cipher, &key_schedule, iv, 0); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); return 0; } diff --git a/examples/aes256ecb.c b/examples/aes256ecb.c index f96a368..ead4c15 100644 --- a/examples/aes256ecb.c +++ b/examples/aes256ecb.c @@ -12,43 +12,43 @@ int main() { - AesBlock128 plain, cipher, decrypted; - AesBlock256 key; - Aes256KeySchedule key_schedule, inverted_schedule; + AesNI_Block128 plain, cipher, decrypted; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule, inverted_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block256(&key).str); - print_aes_block256_as_matrix(&key); + printf("Key: %s\n", aesni_format_block256(&key).str); + aesni_print_block256_as_matrix(&key); - aes256_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 15; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes256ecb_encrypt_block(plain, &key_schedule); + cipher = aesni_encrypt_block_ecb256(plain, &key_schedule); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); - aes256_invert_key_schedule(&key_schedule, &inverted_schedule); + aesni_invert_key_schedule256(&key_schedule, &inverted_schedule); printf("\n"); printf("Inverted key schedule:\n"); for (int i = 0; i < 15; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&inverted_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&inverted_schedule.keys[i]).str); - decrypted = aes256ecb_decrypt_block(cipher, &inverted_schedule); + decrypted = aesni_decrypt_block_ecb256(cipher, &inverted_schedule); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); return 0; } diff --git a/examples/aes256ofb.c b/examples/aes256ofb.c index 1104438..098b321 100644 --- a/examples/aes256ofb.c +++ b/examples/aes256ofb.c @@ -12,49 +12,49 @@ int main() { - AesBlock128 plain, cipher, decrypted, iv, next_iv; - AesBlock256 key; - Aes256KeySchedule key_schedule; + AesNI_Block128 plain, cipher, decrypted, iv, next_iv; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule; - plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); - key = make_aes_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); - iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); + plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100); + key = aesni_make_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100); + iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210); - printf("Plain: %s\n", format_aes_block128(&plain).str); - print_aes_block128_as_matrix(&plain); + printf("Plain: %s\n", aesni_format_block128(&plain).str); + aesni_print_block128_as_matrix(&plain); printf("\n"); - printf("Key: %s\n", format_aes_block256(&key).str); - print_aes_block256_as_matrix(&key); + printf("Key: %s\n", aesni_format_block256(&key).str); + aesni_print_block256_as_matrix(&key); printf("\n"); - printf("Initialization vector: %s\n", format_aes_block128(&iv).str); - print_aes_block128_as_matrix(&iv); + printf("Initialization vector: %s\n", aesni_format_block128(&iv).str); + aesni_print_block128_as_matrix(&iv); - aes256_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); printf("\n"); printf("Key schedule:\n"); for (int i = 0; i < 15; ++i) - printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str); + printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str); - cipher = aes256ofb_encrypt_block(plain, &key_schedule, iv, &next_iv); + cipher = aesni_encrypt_block_ofb256(plain, &key_schedule, iv, &next_iv); printf("\n"); - printf("Cipher: %s\n", format_aes_block128(&cipher).str); - print_aes_block128_as_matrix(&cipher); + printf("Cipher: %s\n", aesni_format_block128(&cipher).str); + aesni_print_block128_as_matrix(&cipher); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); - decrypted = aes256ofb_decrypt_block(cipher, &key_schedule, iv, &next_iv); + decrypted = aesni_decrypt_block_ofb256(cipher, &key_schedule, iv, &next_iv); printf("\n"); - printf("Decrypted: %s\n", format_aes_block128(&decrypted).str); - print_aes_block128_as_matrix(&decrypted); + printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str); + aesni_print_block128_as_matrix(&decrypted); printf("\n"); - printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str); - print_aes_block128_as_matrix(&next_iv); + printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str); + aesni_print_block128_as_matrix(&next_iv); return 0; } diff --git a/include/aesni/block.h b/include/aesni/block.h index 6de2632..7f8be7b 100644 --- a/include/aesni/block.h +++ b/include/aesni/block.h @@ -16,358 +16,358 @@ extern "C" { #endif -static __inline void __fastcall aes128_expand_key_schedule( - AesBlock128 key, - Aes128KeySchedule* key_schedule) +static __inline void __fastcall aesni_expand_key_schedule128( + AesNI_Block128 key, + AesNI_KeySchedule128* key_schedule) { - raw_aes128_expand_key_schedule(key, key_schedule); + aesni_raw_expand_key_schedule128(key, key_schedule); } -static __inline void __fastcall aes128_invert_key_schedule( - Aes128KeySchedule* key_schedule, - Aes128KeySchedule* inverted_schedule) +static __inline void __fastcall aesni_invert_key_schedule128( + AesNI_KeySchedule128* key_schedule, + AesNI_KeySchedule128* inverted_schedule) { - raw_aes128_invert_key_schedule(key_schedule, inverted_schedule); + aesni_raw_invert_key_schedule128(key_schedule, inverted_schedule); } -static __inline AesBlock128 __fastcall aes128ecb_encrypt_block( - AesBlock128 plain, - Aes128KeySchedule* key_schedule) +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ecb128( + AesNI_Block128 plain, + AesNI_KeySchedule128* key_schedule) { - return raw_aes128_encrypt_block(plain, key_schedule); + return aesni_raw_encrypt_block128(plain, key_schedule); } -static __inline AesBlock128 __fastcall aes128ecb_decrypt_block( - AesBlock128 cipher, - Aes128KeySchedule* inverted_schedule) +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ecb128( + AesNI_Block128 cipher, + AesNI_KeySchedule128* inverted_schedule) { - return raw_aes128_decrypt_block(cipher, inverted_schedule); + return aesni_raw_decrypt_block128(cipher, inverted_schedule); } -static __inline AesBlock128 __fastcall aes128cbc_encrypt_block( - AesBlock128 plain, - Aes128KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cbc128( + AesNI_Block128 plain, + AesNI_KeySchedule128* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 cipher = raw_aes128_encrypt_block(_mm_xor_si128(plain, init_vector), key_schedule); + AesNI_Block128 cipher = aesni_raw_encrypt_block128(_mm_xor_si128(plain, init_vector), key_schedule); *next_init_vector = cipher; return cipher; } -static __inline AesBlock128 __fastcall aes128cbc_decrypt_block( - AesBlock128 cipher, - Aes128KeySchedule* inverted_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cbc128( + AesNI_Block128 cipher, + AesNI_KeySchedule128* inverted_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 plain = _mm_xor_si128(raw_aes128_decrypt_block(cipher, inverted_schedule), init_vector); + AesNI_Block128 plain = _mm_xor_si128(aesni_raw_decrypt_block128(cipher, inverted_schedule), init_vector); *next_init_vector = cipher; return plain; } -static __inline AesBlock128 __fastcall aes128cfb_encrypt_block( - AesBlock128 plain, - Aes128KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cfb128( + AesNI_Block128 plain, + AesNI_KeySchedule128* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 cipher = _mm_xor_si128(raw_aes128_encrypt_block(init_vector, key_schedule), plain); + AesNI_Block128 cipher = _mm_xor_si128(aesni_raw_encrypt_block128(init_vector, key_schedule), plain); *next_init_vector = cipher; return cipher; } -static __inline AesBlock128 __fastcall aes128cfb_decrypt_block( - AesBlock128 cipher, - Aes128KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cfb128( + AesNI_Block128 cipher, + AesNI_KeySchedule128* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 plain = _mm_xor_si128(raw_aes128_encrypt_block(init_vector, key_schedule), cipher); + AesNI_Block128 plain = _mm_xor_si128(aesni_raw_encrypt_block128(init_vector, key_schedule), cipher); *next_init_vector = cipher; return plain; } -static __inline AesBlock128 __fastcall aes128ofb_encrypt_block( - AesBlock128 plain, - Aes128KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ofb128( + AesNI_Block128 plain, + AesNI_KeySchedule128* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 tmp = raw_aes128_encrypt_block(init_vector, key_schedule); + AesNI_Block128 tmp = aesni_raw_encrypt_block128(init_vector, key_schedule); *next_init_vector = tmp; return _mm_xor_si128(tmp, plain); } -static __inline AesBlock128 __fastcall aes128ofb_decrypt_block( - AesBlock128 cipher, - Aes128KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ofb128( + AesNI_Block128 cipher, + AesNI_KeySchedule128* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 tmp = raw_aes128_encrypt_block(init_vector, key_schedule); + AesNI_Block128 tmp = aesni_raw_encrypt_block128(init_vector, key_schedule); *next_init_vector = tmp; return _mm_xor_si128(tmp, cipher); } -static __inline AesBlock128 __fastcall aes128ctr_encrypt_block( - AesBlock128 plain, - Aes128KeySchedule* key_schedule, - AesBlock128 init_vector, +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ctr128( + AesNI_Block128 plain, + AesNI_KeySchedule128* key_schedule, + AesNI_Block128 init_vector, int counter) { - init_vector = aes128_le2be(init_vector); - init_vector = _mm_add_epi32(init_vector, make_aes_block128(0, 0, 0, counter)); - init_vector = aes128_be2le(init_vector); - return _mm_xor_si128(plain, raw_aes128_encrypt_block(init_vector, key_schedule)); + init_vector = aesni_le2be128(init_vector); + init_vector = _mm_add_epi32(init_vector, aesni_make_block128(0, 0, 0, counter)); + init_vector = aesni_be2le128(init_vector); + return _mm_xor_si128(plain, aesni_raw_encrypt_block128(init_vector, key_schedule)); } -static __inline AesBlock128 __fastcall aes128ctr_decrypt_block( - AesBlock128 cipher, - Aes128KeySchedule* key_schedule, - AesBlock128 init_vector, +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ctr128( + AesNI_Block128 cipher, + AesNI_KeySchedule128* key_schedule, + AesNI_Block128 init_vector, int counter) { - init_vector = aes128_le2be(init_vector); - init_vector = _mm_add_epi32(init_vector, make_aes_block128(0, 0, 0, counter)); - init_vector = aes128_be2le(init_vector); - return _mm_xor_si128(cipher, raw_aes128_encrypt_block(init_vector, key_schedule)); + init_vector = aesni_le2be128(init_vector); + init_vector = _mm_add_epi32(init_vector, aesni_make_block128(0, 0, 0, counter)); + init_vector = aesni_be2le128(init_vector); + return _mm_xor_si128(cipher, aesni_raw_encrypt_block128(init_vector, key_schedule)); } -static __inline void __fastcall aes192_expand_key_schedule( - AesBlock192* key, - Aes192KeySchedule* key_schedule) +static __inline void __fastcall aesni_expand_key_schedule192( + AesNI_Block192* key, + AesNI_KeySchedule192* key_schedule) { - raw_aes192_expand_key_schedule(key->lo, key->hi, key_schedule); + aesni_raw_expand_key_schedule192(key->lo, key->hi, key_schedule); } -static __inline void __fastcall aes192_invert_key_schedule( - Aes192KeySchedule* key_schedule, - Aes192KeySchedule* inverted_schedule) +static __inline void __fastcall aesni_invert_key_schedule192( + AesNI_KeySchedule192* key_schedule, + AesNI_KeySchedule192* inverted_schedule) { - raw_aes192_invert_key_schedule(key_schedule, inverted_schedule); + aesni_raw_invert_key_schedule192(key_schedule, inverted_schedule); } -static __inline AesBlock128 __fastcall aes192ecb_encrypt_block( - AesBlock128 plain, - Aes192KeySchedule* key_schedule) +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ecb192( + AesNI_Block128 plain, + AesNI_KeySchedule192* key_schedule) { - return raw_aes192_encrypt_block(plain, key_schedule); + return aesni_raw_encrypt_block192(plain, key_schedule); } -static __inline AesBlock128 __fastcall aes192ecb_decrypt_block( - AesBlock128 cipher, - Aes192KeySchedule* inverted_schedule) +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ecb192( + AesNI_Block128 cipher, + AesNI_KeySchedule192* inverted_schedule) { - return raw_aes192_decrypt_block(cipher, inverted_schedule); + return aesni_raw_decrypt_block192(cipher, inverted_schedule); } -static __inline AesBlock128 __fastcall aes192cbc_encrypt_block( - AesBlock128 plain, - Aes192KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cbc192( + AesNI_Block128 plain, + AesNI_KeySchedule192* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 cipher = raw_aes192_encrypt_block(_mm_xor_si128(plain, init_vector), key_schedule); + AesNI_Block128 cipher = aesni_raw_encrypt_block192(_mm_xor_si128(plain, init_vector), key_schedule); *next_init_vector = cipher; return cipher; } -static __inline AesBlock128 __fastcall aes192cbc_decrypt_block( - AesBlock128 cipher, - Aes192KeySchedule* inverted_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cbc192( + AesNI_Block128 cipher, + AesNI_KeySchedule192* inverted_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 plain = _mm_xor_si128(raw_aes192_decrypt_block(cipher, inverted_schedule), init_vector); + AesNI_Block128 plain = _mm_xor_si128(aesni_raw_decrypt_block192(cipher, inverted_schedule), init_vector); *next_init_vector = cipher; return plain; } -static __inline AesBlock128 __fastcall aes192cfb_encrypt_block( - AesBlock128 plain, - Aes192KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cfb192( + AesNI_Block128 plain, + AesNI_KeySchedule192* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 cipher = _mm_xor_si128(raw_aes192_encrypt_block(init_vector, key_schedule), plain); + AesNI_Block128 cipher = _mm_xor_si128(aesni_raw_encrypt_block192(init_vector, key_schedule), plain); *next_init_vector = cipher; return cipher; } -static __inline AesBlock128 __fastcall aes192cfb_decrypt_block( - AesBlock128 cipher, - Aes192KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cfb192( + AesNI_Block128 cipher, + AesNI_KeySchedule192* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 plain = _mm_xor_si128(raw_aes192_encrypt_block(init_vector, key_schedule), cipher); + AesNI_Block128 plain = _mm_xor_si128(aesni_raw_encrypt_block192(init_vector, key_schedule), cipher); *next_init_vector = cipher; return plain; } -static __inline AesBlock128 __fastcall aes192ofb_encrypt_block( - AesBlock128 plain, - Aes192KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ofb192( + AesNI_Block128 plain, + AesNI_KeySchedule192* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 tmp = raw_aes192_encrypt_block(init_vector, key_schedule); + AesNI_Block128 tmp = aesni_raw_encrypt_block192(init_vector, key_schedule); *next_init_vector = tmp; return _mm_xor_si128(tmp, plain); } -static __inline AesBlock128 __fastcall aes192ofb_decrypt_block( - AesBlock128 cipher, - Aes192KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ofb192( + AesNI_Block128 cipher, + AesNI_KeySchedule192* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 tmp = raw_aes192_encrypt_block(init_vector, key_schedule); + AesNI_Block128 tmp = aesni_raw_encrypt_block192(init_vector, key_schedule); *next_init_vector = tmp; return _mm_xor_si128(tmp, cipher); } -static __inline AesBlock128 __fastcall aes192ctr_encrypt_block( - AesBlock128 plain, - Aes192KeySchedule* key_schedule, - AesBlock128 init_vector, +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ctr192( + AesNI_Block128 plain, + AesNI_KeySchedule192* key_schedule, + AesNI_Block128 init_vector, int counter) { - init_vector = aes128_le2be(init_vector); - init_vector = _mm_add_epi32(init_vector, make_aes_block128(0, 0, 0, counter)); - init_vector = aes128_be2le(init_vector); - return _mm_xor_si128(plain, raw_aes192_encrypt_block(init_vector, key_schedule)); + init_vector = aesni_le2be128(init_vector); + init_vector = _mm_add_epi32(init_vector, aesni_make_block128(0, 0, 0, counter)); + init_vector = aesni_be2le128(init_vector); + return _mm_xor_si128(plain, aesni_raw_encrypt_block192(init_vector, key_schedule)); } -static __inline AesBlock128 __fastcall aes192ctr_decrypt_block( - AesBlock128 cipher, - Aes192KeySchedule* key_schedule, - AesBlock128 init_vector, +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ctr192( + AesNI_Block128 cipher, + AesNI_KeySchedule192* key_schedule, + AesNI_Block128 init_vector, int counter) { - init_vector = aes128_le2be(init_vector); - init_vector = _mm_add_epi32(init_vector, make_aes_block128(0, 0, 0, counter)); - init_vector = aes128_be2le(init_vector); - return _mm_xor_si128(cipher, raw_aes192_encrypt_block(init_vector, key_schedule)); + init_vector = aesni_le2be128(init_vector); + init_vector = _mm_add_epi32(init_vector, aesni_make_block128(0, 0, 0, counter)); + init_vector = aesni_be2le128(init_vector); + return _mm_xor_si128(cipher, aesni_raw_encrypt_block192(init_vector, key_schedule)); } -static __inline void __fastcall aes256_expand_key_schedule( - AesBlock256* key, - Aes256KeySchedule* key_schedule) +static __inline void __fastcall aesni_expand_key_schedule256( + AesNI_Block256* key, + AesNI_KeySchedule256* key_schedule) { - raw_aes256_expand_key_schedule(key->lo, key->hi, key_schedule); + aesni_raw_expand_key_schedule256(key->lo, key->hi, key_schedule); } -static __inline void __fastcall aes256_invert_key_schedule( - Aes256KeySchedule* key_schedule, - Aes256KeySchedule* inverted_schedule) +static __inline void __fastcall aesni_invert_key_schedule256( + AesNI_KeySchedule256* key_schedule, + AesNI_KeySchedule256* inverted_schedule) { - raw_aes256_invert_key_schedule(key_schedule, inverted_schedule); + aesni_raw_invert_key_schedule256(key_schedule, inverted_schedule); } -static __inline AesBlock128 __fastcall aes256ecb_encrypt_block( - AesBlock128 plain, - Aes256KeySchedule* key_schedule) +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ecb256( + AesNI_Block128 plain, + AesNI_KeySchedule256* key_schedule) { - return raw_aes256_encrypt_block(plain, key_schedule); + return aesni_raw_encrypt_block256(plain, key_schedule); } -static __inline AesBlock128 __fastcall aes256ecb_decrypt_block( - AesBlock128 cipher, - Aes256KeySchedule* inverted_schedule) +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ecb256( + AesNI_Block128 cipher, + AesNI_KeySchedule256* inverted_schedule) { - return raw_aes256_decrypt_block(cipher, inverted_schedule); + return aesni_raw_decrypt_block256(cipher, inverted_schedule); } -static __inline AesBlock128 __fastcall aes256cbc_encrypt_block( - AesBlock128 plain, - Aes256KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cbc256( + AesNI_Block128 plain, + AesNI_KeySchedule256* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 cipher = raw_aes256_encrypt_block(_mm_xor_si128(plain, init_vector), key_schedule); + AesNI_Block128 cipher = aesni_raw_encrypt_block256(_mm_xor_si128(plain, init_vector), key_schedule); *next_init_vector = cipher; return cipher; } -static __inline AesBlock128 __fastcall aes256cbc_decrypt_block( - AesBlock128 cipher, - Aes256KeySchedule* inverted_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cbc256( + AesNI_Block128 cipher, + AesNI_KeySchedule256* inverted_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 plain = _mm_xor_si128(raw_aes256_decrypt_block(cipher, inverted_schedule), init_vector); + AesNI_Block128 plain = _mm_xor_si128(aesni_raw_decrypt_block256(cipher, inverted_schedule), init_vector); *next_init_vector = cipher; return plain; } -static __inline AesBlock128 __fastcall aes256cfb_encrypt_block( - AesBlock128 plain, - Aes256KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cfb256( + AesNI_Block128 plain, + AesNI_KeySchedule256* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 cipher = _mm_xor_si128(raw_aes256_encrypt_block(init_vector, key_schedule), plain); + AesNI_Block128 cipher = _mm_xor_si128(aesni_raw_encrypt_block256(init_vector, key_schedule), plain); *next_init_vector = cipher; return cipher; } -static __inline AesBlock128 __fastcall aes256cfb_decrypt_block( - AesBlock128 cipher, - Aes256KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cfb256( + AesNI_Block128 cipher, + AesNI_KeySchedule256* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 plain = _mm_xor_si128(raw_aes256_encrypt_block(init_vector, key_schedule), cipher); + AesNI_Block128 plain = _mm_xor_si128(aesni_raw_encrypt_block256(init_vector, key_schedule), cipher); *next_init_vector = cipher; return plain; } -static __inline AesBlock128 __fastcall aes256ofb_encrypt_block( - AesBlock128 plain, - Aes256KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ofb256( + AesNI_Block128 plain, + AesNI_KeySchedule256* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 tmp = raw_aes256_encrypt_block(init_vector, key_schedule); + AesNI_Block128 tmp = aesni_raw_encrypt_block256(init_vector, key_schedule); *next_init_vector = tmp; return _mm_xor_si128(tmp, plain); } -static __inline AesBlock128 __fastcall aes256ofb_decrypt_block( - AesBlock128 cipher, - Aes256KeySchedule* key_schedule, - AesBlock128 init_vector, - AesBlock128* next_init_vector) +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ofb256( + AesNI_Block128 cipher, + AesNI_KeySchedule256* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) { - AesBlock128 tmp = raw_aes256_encrypt_block(init_vector, key_schedule); + AesNI_Block128 tmp = aesni_raw_encrypt_block256(init_vector, key_schedule); *next_init_vector = tmp; return _mm_xor_si128(tmp, cipher); } -static __inline AesBlock128 __fastcall aes256ctr_encrypt_block( - AesBlock128 plain, - Aes256KeySchedule* key_schedule, - AesBlock128 init_vector, +static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ctr256( + AesNI_Block128 plain, + AesNI_KeySchedule256* key_schedule, + AesNI_Block128 init_vector, int counter) { - init_vector = aes128_le2be(init_vector); - init_vector = _mm_add_epi32(init_vector, make_aes_block128(0, 0, 0, counter)); - init_vector = aes128_be2le(init_vector); - return _mm_xor_si128(plain, raw_aes256_encrypt_block(init_vector, key_schedule)); + init_vector = aesni_le2be128(init_vector); + init_vector = _mm_add_epi32(init_vector, aesni_make_block128(0, 0, 0, counter)); + init_vector = aesni_be2le128(init_vector); + return _mm_xor_si128(plain, aesni_raw_encrypt_block256(init_vector, key_schedule)); } -static __inline AesBlock128 __fastcall aes256ctr_decrypt_block( - AesBlock128 cipher, - Aes256KeySchedule* key_schedule, - AesBlock128 init_vector, +static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ctr256( + AesNI_Block128 cipher, + AesNI_KeySchedule256* key_schedule, + AesNI_Block128 init_vector, int counter) { - init_vector = aes128_le2be(init_vector); - init_vector = _mm_add_epi32(init_vector, make_aes_block128(0, 0, 0, counter)); - init_vector = aes128_be2le(init_vector); - return _mm_xor_si128(cipher, raw_aes256_encrypt_block(init_vector, key_schedule)); + init_vector = aesni_le2be128(init_vector); + init_vector = _mm_add_epi32(init_vector, aesni_make_block128(0, 0, 0, counter)); + init_vector = aesni_be2le128(init_vector); + return _mm_xor_si128(cipher, aesni_raw_encrypt_block256(init_vector, key_schedule)); } #ifdef __cplusplus diff --git a/include/aesni/buffer.h b/include/aesni/buffer.h index c0a3805..daafc3e 100644 --- a/include/aesni/buffer.h +++ b/include/aesni/buffer.h @@ -8,23 +8,23 @@ #pragma once -#include <stdio.h> +#include <stdlib.h> #ifdef __cplusplus extern "C" { #endif -size_t aes128ecb_encrypt_buffer( - const unsigned char* src, +size_t aesni_encrypt_buffer_ecb128( + const void* src, size_t src_size, - unsigned char* dest, - Aes128KeySchedule* key_schedule); -size_t aes128ecb_decrypt_buffer( - const unsigned char* src, + void* dest, + AesNI_KeySchedule128* key_schedule); +size_t aesni_decrypt_buffer_ecb128( + const void* src, size_t src_size, - unsigned char* dest, - Aes128KeySchedule* inverted_schedule); + void* dest, + AesNI_KeySchedule128* inverted_schedule); #ifdef __cplusplus } diff --git a/include/aesni/data.h b/include/aesni/data.h index d104f9d..de03110 100644 --- a/include/aesni/data.h +++ b/include/aesni/data.h @@ -16,146 +16,146 @@ extern "C" { #endif -typedef __m128i AesBlock128; +typedef __m128i AesNI_Block128; -static __inline AesBlock128 load_aes_block128(const unsigned char* src) +static __inline AesNI_Block128 aesni_load_block128(const void* src) { - return _mm_loadu_si128((AesBlock128*) src); + return _mm_loadu_si128((AesNI_Block128*) src); } -static __inline void __fastcall store_aes_block128(AesBlock128 block, - unsigned char* dest) +static __inline void __fastcall aesni_store_block128( + void* dest, AesNI_Block128 block) { - _mm_storeu_si128((AesBlock128*) dest, block); + _mm_storeu_si128((AesNI_Block128*) dest, block); } -static __inline AesBlock128 __fastcall make_aes_block128(int hi3, int hi2, int lo1, int lo0) +static __inline AesNI_Block128 __fastcall aesni_make_block128(int hi3, int hi2, int lo1, int lo0) { return _mm_set_epi32(hi3, hi2, lo1, lo0); } typedef struct { - AesBlock128 hi; - AesBlock128 lo; + AesNI_Block128 hi; + AesNI_Block128 lo; } -AesBlock192; +AesNI_Block192; -static __inline AesBlock192 __fastcall make_aes_block192(int hi5, int hi4, int lo3, int lo2, int lo1, int lo0) +static __inline AesNI_Block192 __fastcall aesni_make_block192(int hi5, int hi4, int lo3, int lo2, int lo1, int lo0) { - AesBlock192 result; - result.hi = make_aes_block128( 0, 0, hi5, hi4); - result.lo = make_aes_block128(lo3, lo2, lo1, lo0); + AesNI_Block192 result; + result.hi = aesni_make_block128( 0, 0, hi5, hi4); + result.lo = aesni_make_block128(lo3, lo2, lo1, lo0); return result; } typedef struct { - AesBlock128 hi; - AesBlock128 lo; + AesNI_Block128 hi; + AesNI_Block128 lo; } -AesBlock256; +AesNI_Block256; -static __inline AesBlock256 __fastcall make_aes_block256(int hi7, int hi6, int hi5, int hi4, int lo3, int lo2, int lo1, int lo0) +static __inline AesNI_Block256 __fastcall aesni_make_block256(int hi7, int hi6, int hi5, int hi4, int lo3, int lo2, int lo1, int lo0) { - AesBlock256 result; - result.hi = make_aes_block128(hi7, hi6, hi5, hi4); - result.lo = make_aes_block128(lo3, lo2, lo1, lo0); + AesNI_Block256 result; + result.hi = aesni_make_block128(hi7, hi6, hi5, hi4); + result.lo = aesni_make_block128(lo3, lo2, lo1, lo0); return result; } typedef struct { - AesBlock128 keys[11]; + AesNI_Block128 keys[11]; } -Aes128KeySchedule; +AesNI_KeySchedule128; typedef struct { - AesBlock128 keys[13]; + AesNI_Block128 keys[13]; } -Aes192KeySchedule; +AesNI_KeySchedule192; typedef struct { - AesBlock128 keys[15]; + AesNI_Block128 keys[15]; } -Aes256KeySchedule; +AesNI_KeySchedule256; -static __inline AesBlock128 __fastcall aes128_reverse_byte_order(AesBlock128 block) +static __inline AesNI_Block128 __fastcall aesni_reverse_byte_order128(AesNI_Block128 block) { - return _mm_shuffle_epi8(block, make_aes_block128(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f)); + return _mm_shuffle_epi8(block, aesni_make_block128(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f)); } -static __inline AesBlock128 __fastcall aes128_le2be(AesBlock128 block) +static __inline AesNI_Block128 __fastcall aesni_le2be128(AesNI_Block128 block) { - return aes128_reverse_byte_order(block); + return aesni_reverse_byte_order128(block); } -static __inline AesBlock128 __fastcall aes128_be2le(AesBlock128 block) +static __inline AesNI_Block128 __fastcall aesni_be2le128(AesNI_Block128 block) { - return aes128_reverse_byte_order(block); + return aesni_reverse_byte_order128(block); } -typedef struct { char str[33]; } AesBlockString128; -typedef struct { char str[49]; } AesBlockString192; -typedef struct { char str[65]; } AesBlockString256; +typedef struct { char str[33]; } AesNI_BlockString128; +typedef struct { char str[49]; } AesNI_BlockString192; +typedef struct { char str[65]; } AesNI_BlockString256; -AesBlockString128 format_aes_block128(AesBlock128*); -AesBlockString192 format_aes_block192(AesBlock192*); -AesBlockString256 format_aes_block256(AesBlock256*); +AesNI_BlockString128 aesni_format_block128(AesNI_Block128*); +AesNI_BlockString192 aesni_format_block192(AesNI_Block192*); +AesNI_BlockString256 aesni_format_block256(AesNI_Block256*); -AesBlockString128 format_aes_block128_le(AesBlock128*); -AesBlockString192 format_aes_block192_le(AesBlock192*); -AesBlockString256 format_aes_block256_le(AesBlock256*); +AesNI_BlockString128 aesni_format_block128_le(AesNI_Block128*); +AesNI_BlockString192 aesni_format_block192_le(AesNI_Block192*); +AesNI_BlockString256 aesni_format_block256_le(AesNI_Block256*); -AesBlockString128 format_aes_block128_be(AesBlock128*); -AesBlockString192 format_aes_block192_be(AesBlock192*); -AesBlockString256 format_aes_block256_be(AesBlock256*); +AesNI_BlockString128 aesni_format_block128_be(AesNI_Block128*); +AesNI_BlockString192 aesni_format_block192_be(AesNI_Block192*); +AesNI_BlockString256 aesni_format_block256_be(AesNI_Block256*); -typedef struct { char str[49]; } AesBlockMatrixString128; -typedef struct { char str[73]; } AesBlockMatrixString192; -typedef struct { char str[97]; } AesBlockMatrixString256; +typedef struct { char str[49]; } AesNI_BlockMatrixString128; +typedef struct { char str[73]; } AesNI_BlockMatrixString192; +typedef struct { char str[97]; } AesNI_BlockMatrixString256; -AesBlockMatrixString128 format_aes_block128_as_matrix(AesBlock128*); -AesBlockMatrixString192 format_aes_block192_as_matrix(AesBlock192*); -AesBlockMatrixString256 format_aes_block256_as_matrix(AesBlock256*); +AesNI_BlockMatrixString128 aesni_format_block128_as_matrix(AesNI_Block128*); +AesNI_BlockMatrixString192 aesni_format_block192_as_matrix(AesNI_Block192*); +AesNI_BlockMatrixString256 aesni_format_block256_as_matrix(AesNI_Block256*); -AesBlockMatrixString128 format_aes_block128_be_as_matrix(AesBlock128*); -AesBlockMatrixString192 format_aes_block192_be_as_matrix(AesBlock192*); -AesBlockMatrixString256 format_aes_block256_be_as_matrix(AesBlock256*); +AesNI_BlockMatrixString128 aesni_format_block128_be_as_matrix(AesNI_Block128*); +AesNI_BlockMatrixString192 aesni_format_block192_be_as_matrix(AesNI_Block192*); +AesNI_BlockMatrixString256 aesni_format_block256_be_as_matrix(AesNI_Block256*); -void print_aes_block128(AesBlock128*); -void print_aes_block192(AesBlock192*); -void print_aes_block256(AesBlock256*); +void aesni_print_block128(AesNI_Block128*); +void aesni_print_block192(AesNI_Block192*); +void aesni_print_block256(AesNI_Block256*); -void print_aes_block128_le(AesBlock128*); -void print_aes_block192_le(AesBlock192*); -void print_aes_block256_le(AesBlock256*); +void aesni_print_block128_le(AesNI_Block128*); +void aesni_print_block192_le(AesNI_Block192*); +void aesni_print_block256_le(AesNI_Block256*); -void print_aes_block128_be(AesBlock128*); -void print_aes_block192_be(AesBlock192*); -void print_aes_block256_be(AesBlock256*); +void aesni_print_block128_be(AesNI_Block128*); +void aesni_print_block192_be(AesNI_Block192*); +void aesni_print_block256_be(AesNI_Block256*); -void print_aes_block128_as_matrix(AesBlock128*); -void print_aes_block192_as_matrix(AesBlock192*); -void print_aes_block256_as_matrix(AesBlock256*); +void aesni_print_block128_as_matrix(AesNI_Block128*); +void aesni_print_block192_as_matrix(AesNI_Block192*); +void aesni_print_block256_as_matrix(AesNI_Block256*); -void print_aes_block128_be_as_matrix(AesBlock128*); -void print_aes_block192_be_as_matrix(AesBlock192*); -void print_aes_block256_be_as_matrix(AesBlock256*); +void aesni_print_block128_be_as_matrix(AesNI_Block128*); +void aesni_print_block192_be_as_matrix(AesNI_Block192*); +void aesni_print_block256_be_as_matrix(AesNI_Block256*); -int parse_aes_block128(AesBlock128*, const char*); -int parse_aes_block192(AesBlock192*, const char*); -int parse_aes_block256(AesBlock256*, const char*); +int aesni_parse_block128(AesNI_Block128*, const char*); +int aesni_parse_block192(AesNI_Block192*, const char*); +int aesni_parse_block256(AesNI_Block256*, const char*); -int parse_aes_block128_le(AesBlock128*, const char*); -int parse_aes_block192_le(AesBlock192*, const char*); -int parse_aes_block256_le(AesBlock256*, const char*); +int aesni_parse_block128_le(AesNI_Block128*, const char*); +int aesni_parse_block192_le(AesNI_Block192*, const char*); +int aesni_parse_block256_le(AesNI_Block256*, const char*); -int parse_aes_block128_be(AesBlock128*, const char*); -int parse_aes_block192_be(AesBlock192*, const char*); -int parse_aes_block256_be(AesBlock256*, const char*); +int aesni_parse_block128_be(AesNI_Block128*, const char*); +int aesni_parse_block192_be(AesNI_Block192*, const char*); +int aesni_parse_block256_be(AesNI_Block256*, const char*); #ifdef __cplusplus } diff --git a/include/aesni/raw.h b/include/aesni/raw.h index 562ac0c..4432231 100644 --- a/include/aesni/raw.h +++ b/include/aesni/raw.h @@ -15,49 +15,49 @@ extern "C" { #endif -void __fastcall raw_aes128_expand_key_schedule( - AesBlock128 key, - Aes128KeySchedule* key_schedule); -void __fastcall raw_aes128_invert_key_schedule( - Aes128KeySchedule* key_schedule, - Aes128KeySchedule* inverted_schedule); +void __fastcall aesni_raw_expand_key_schedule128( + AesNI_Block128 key, + AesNI_KeySchedule128* key_schedule); +void __fastcall aesni_raw_invert_key_schedule128( + AesNI_KeySchedule128* key_schedule, + AesNI_KeySchedule128* inverted_schedule); -AesBlock128 __fastcall raw_aes128_encrypt_block( - AesBlock128 plain, - Aes128KeySchedule* key_schedule); -AesBlock128 __fastcall raw_aes128_decrypt_block( - AesBlock128 cipher, - Aes128KeySchedule* inverted_schedule); +AesNI_Block128 __fastcall aesni_raw_encrypt_block128( + AesNI_Block128 plain, + AesNI_KeySchedule128* key_schedule); +AesNI_Block128 __fastcall aesni_raw_decrypt_block128( + AesNI_Block128 cipher, + AesNI_KeySchedule128* inverted_schedule); -void __fastcall raw_aes192_expand_key_schedule( - AesBlock128 key_lo, - AesBlock128 key_hi, - Aes192KeySchedule* key_schedule); -void __fastcall raw_aes192_invert_key_schedule( - Aes192KeySchedule* key_schedule, - Aes192KeySchedule* inverted_schedule); +void __fastcall aesni_raw_expand_key_schedule192( + AesNI_Block128 key_lo, + AesNI_Block128 key_hi, + AesNI_KeySchedule192* key_schedule); +void __fastcall aesni_raw_invert_key_schedule192( + AesNI_KeySchedule192* key_schedule, + AesNI_KeySchedule192* inverted_schedule); -AesBlock128 __fastcall raw_aes192_encrypt_block( - AesBlock128 plain, - Aes192KeySchedule* key_schedule); -AesBlock128 __fastcall raw_aes192_decrypt_block( - AesBlock128 cipher, - Aes192KeySchedule* inverted_schedule); +AesNI_Block128 __fastcall aesni_raw_encrypt_block192( + AesNI_Block128 plain, + AesNI_KeySchedule192* key_schedule); +AesNI_Block128 __fastcall aesni_raw_decrypt_block192( + AesNI_Block128 cipher, + AesNI_KeySchedule192* inverted_schedule); -void __fastcall raw_aes256_expand_key_schedule( - AesBlock128 key_lo, - AesBlock128 key_hi, - Aes256KeySchedule* key_schedule); -void __fastcall raw_aes256_invert_key_schedule( - Aes256KeySchedule* key_schedule, - Aes256KeySchedule* inverted_schedule); +void __fastcall aesni_raw_expand_key_schedule256( + AesNI_Block128 key_lo, + AesNI_Block128 key_hi, + AesNI_KeySchedule256* key_schedule); +void __fastcall aesni_raw_invert_key_schedule256( + AesNI_KeySchedule256* key_schedule, + AesNI_KeySchedule256* inverted_schedule); -AesBlock128 __fastcall raw_aes256_encrypt_block( - AesBlock128 plain, - Aes256KeySchedule* key_schedule); -AesBlock128 __fastcall raw_aes256_decrypt_block( - AesBlock128 cipher, - Aes256KeySchedule* inverted_schedule); +AesNI_Block128 __fastcall aesni_raw_encrypt_block256( + AesNI_Block128 plain, + AesNI_KeySchedule256* key_schedule); +AesNI_Block128 __fastcall aesni_raw_decrypt_block256( + AesNI_Block128 cipher, + AesNI_KeySchedule256* inverted_schedule); #ifdef __cplusplus } diff --git a/src/asm/aes128.asm b/src/asm/aes128.asm index 874f876..4f88f09 100644 --- a/src/asm/aes128.asm +++ b/src/asm/aes128.asm @@ -8,7 +8,7 @@ .code -@raw_aes128_encrypt_block@20 proc +@aesni_raw_encrypt_block128@20 proc pxor xmm0, [ecx] aesenc xmm0, [ecx + 10h] aesenc xmm0, [ecx + 20h] @@ -21,9 +21,9 @@ aesenc xmm0, [ecx + 90h] aesenclast xmm0, [ecx + 0A0h] ret -@raw_aes128_encrypt_block@20 endp +@aesni_raw_encrypt_block128@20 endp -@raw_aes128_decrypt_block@20 proc +@aesni_raw_decrypt_block128@20 proc pxor xmm0, [ecx] aesdec xmm0, [ecx + 10h] aesdec xmm0, [ecx + 20h] @@ -36,9 +36,9 @@ aesdec xmm0, [ecx + 90h] aesdeclast xmm0, [ecx + 0A0h] ret -@raw_aes128_decrypt_block@20 endp +@aesni_raw_decrypt_block128@20 endp -@raw_aes128_expand_key_schedule@20 proc +@aesni_raw_expand_key_schedule128@20 proc ; A "word" (in terms of the FIPS 187 standard) is a 32-bit block. ; Words are denoted by `w[N]`. ; @@ -165,9 +165,9 @@ aes128_keygen_assist: add ecx, 10h ; ecx = &w[i+8] ret -@raw_aes128_expand_key_schedule@20 endp +@aesni_raw_expand_key_schedule128@20 endp -@raw_aes128_invert_key_schedule@8 proc +@aesni_raw_invert_key_schedule128@8 proc movdqa xmm5, [ecx] movdqa xmm4, [ecx + 0A0h] movdqa [edx], xmm4 @@ -197,6 +197,6 @@ aes128_keygen_assist: movdqa [edx + 50h], xmm5 ret -@raw_aes128_invert_key_schedule@8 endp +@aesni_raw_invert_key_schedule128@8 endp end diff --git a/src/asm/aes192.asm b/src/asm/aes192.asm index adbc690..e045910 100644 --- a/src/asm/aes192.asm +++ b/src/asm/aes192.asm @@ -8,7 +8,7 @@ .code -@raw_aes192_encrypt_block@20 proc +@aesni_raw_encrypt_block192@20 proc pxor xmm0, [ecx] aesenc xmm0, [ecx + 10h] aesenc xmm0, [ecx + 20h] @@ -23,9 +23,9 @@ aesenc xmm0, [ecx + 0B0h] aesenclast xmm0, [ecx + 0C0h] ret -@raw_aes192_encrypt_block@20 endp +@aesni_raw_encrypt_block192@20 endp -@raw_aes192_decrypt_block@20 proc +@aesni_raw_decrypt_block192@20 proc pxor xmm0, [ecx] aesdec xmm0, [ecx + 10h] aesdec xmm0, [ecx + 20h] @@ -40,9 +40,9 @@ aesdec xmm0, [ecx + 0B0h] aesdeclast xmm0, [ecx + 0C0h] ret -@raw_aes192_decrypt_block@20 endp +@aesni_raw_decrypt_block192@20 endp -@raw_aes192_expand_key_schedule@36 proc +@aesni_raw_expand_key_schedule192@36 proc ; A "word" (in terms of the FIPS 187 standard) is a 32-bit block. ; Words are denoted by `w[N]`. ; @@ -206,9 +206,9 @@ aes192_keygen_assist: ; xmm1[31:0] == w[i+10] == RotWord(SubWord(w[i+5]))^Rcon^w[i+4]^w[i+3]^w[i+2]^w[i+1]^w[i] ret -@raw_aes192_expand_key_schedule@36 endp +@aesni_raw_expand_key_schedule192@36 endp -@raw_aes192_invert_key_schedule@8 proc +@aesni_raw_invert_key_schedule192@8 proc movdqa xmm5, [ecx] movdqa xmm4, [ecx + 0C0h] movdqa [edx], xmm4 @@ -243,6 +243,6 @@ aes192_keygen_assist: movdqa [edx + 60h], xmm5 ret -@raw_aes192_invert_key_schedule@8 endp +@aesni_raw_invert_key_schedule192@8 endp end diff --git a/src/asm/aes256.asm b/src/asm/aes256.asm index 479b0f5..285cf69 100644 --- a/src/asm/aes256.asm +++ b/src/asm/aes256.asm @@ -8,7 +8,7 @@ .code -@raw_aes256_encrypt_block@20 proc +@aesni_raw_encrypt_block256@20 proc pxor xmm0, [ecx] aesenc xmm0, [ecx + 10h] aesenc xmm0, [ecx + 20h] @@ -25,9 +25,9 @@ aesenc xmm0, [ecx + 0D0h] aesenclast xmm0, [ecx + 0E0h] ret -@raw_aes256_encrypt_block@20 endp +@aesni_raw_encrypt_block256@20 endp -@raw_aes256_decrypt_block@20 proc +@aesni_raw_decrypt_block256@20 proc pxor xmm0, [ecx] aesdec xmm0, [ecx + 10h] aesdec xmm0, [ecx + 20h] @@ -44,9 +44,9 @@ aesdec xmm0, [ecx + 0D0h] aesdeclast xmm0, [ecx + 0E0h] ret -@raw_aes256_decrypt_block@20 endp +@aesni_raw_decrypt_block256@20 endp -@raw_aes256_expand_key_schedule@36 proc +@aesni_raw_expand_key_schedule256@36 proc ; A "word" (in terms of the FIPS 187 standard) is a 32-bit block. ; Words are denoted by `w[N]`. ; @@ -239,9 +239,9 @@ aes256_keygen_assist: pxor xmm0, xmm1 ret -@raw_aes256_expand_key_schedule@36 endp +@aesni_raw_expand_key_schedule256@36 endp -@raw_aes256_invert_key_schedule@8 proc +@aesni_raw_invert_key_schedule256@8 proc movdqa xmm5, [ecx] movdqa xmm4, [ecx + 0E0h] movdqa [edx], xmm4 @@ -281,6 +281,6 @@ aes256_keygen_assist: movdqa [edx + 70h], xmm5 ret -@raw_aes256_invert_key_schedule@8 endp +@aesni_raw_invert_key_schedule256@8 endp end diff --git a/src/buffer.c b/src/buffer.c index ff14f18..b4896f7 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -13,11 +13,11 @@ static unsigned char FULL_BLOCK_PADDING[16] = { 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 }; -size_t aes128ecb_encrypt_buffer( - const unsigned char* src, +size_t aesni_encrypt_buffer_ecb128( + const void* src, size_t src_size, - unsigned char* dest, - Aes128KeySchedule* key_schedule) + void* dest, + AesNI_KeySchedule128* key_schedule) { size_t rem_size = src_size % 16; size_t padding_size = 16 - rem_size; @@ -28,11 +28,11 @@ size_t aes128ecb_encrypt_buffer( size_t src_len = src_size / 16; - for (size_t i = 0; i < src_len; ++i, src += 16, dest += 16) + for (size_t i = 0; i < src_len; ++i, (char*) src += 16, (char*) dest += 16) { - AesBlock128 plaintext = load_aes_block128(src); - AesBlock128 ciphertext = aes128ecb_encrypt_block(plaintext, key_schedule); - store_aes_block128(ciphertext, dest); + AesNI_Block128 plaintext = aesni_load_block128(src); + AesNI_Block128 ciphertext = aesni_encrypt_block_ecb128(plaintext, key_schedule); + aesni_store_block128(dest, ciphertext); } unsigned char padding[16]; @@ -47,9 +47,9 @@ size_t aes128ecb_encrypt_buffer( memset(padding + rem_size, padding_size, padding_size); } - AesBlock128 plaintext = load_aes_block128(padding); - AesBlock128 ciphertext = aes128ecb_encrypt_block(plaintext, key_schedule); - store_aes_block128(ciphertext, dest); + AesNI_Block128 plaintext = aesni_load_block128(padding); + AesNI_Block128 ciphertext = aesni_encrypt_block_ecb128(plaintext, key_schedule); + aesni_store_block128(dest, ciphertext); return dest_size; } @@ -66,11 +66,11 @@ static unsigned char get_padding_size(const unsigned char* padding) return padding[15]; } -size_t aes128ecb_decrypt_buffer( - const unsigned char* src, +size_t aesni_decrypt_buffer_ecb128( + const void* src, size_t src_size, - unsigned char* dest, - Aes128KeySchedule* inverted_schedule) + void* dest, + AesNI_KeySchedule128* inverted_schedule) { size_t dest_size = src_size; @@ -79,17 +79,17 @@ size_t aes128ecb_decrypt_buffer( size_t src_len = src_size / 16; - for (size_t i = 0; i < src_len - 1; ++i, src += 16, dest += 16) + for (size_t i = 0; i < src_len - 1; ++i, (char*) src += 16, (char*) dest += 16) { - AesBlock128 ciphertext = load_aes_block128(src); - AesBlock128 plaintext = aes128ecb_decrypt_block(ciphertext, inverted_schedule); - store_aes_block128(plaintext, dest); + AesNI_Block128 ciphertext = aesni_load_block128(src); + AesNI_Block128 plaintext = aesni_decrypt_block_ecb128(ciphertext, inverted_schedule); + aesni_store_block128(dest, plaintext); } - AesBlock128 ciphertext = load_aes_block128(src); - AesBlock128 plaintext = aes128ecb_decrypt_block(ciphertext, inverted_schedule); + AesNI_Block128 ciphertext = aesni_load_block128(src); + AesNI_Block128 plaintext = aesni_decrypt_block_ecb128(ciphertext, inverted_schedule); unsigned char padding[16]; - store_aes_block128(plaintext, padding); + aesni_store_block128(padding, plaintext); unsigned char padding_size = get_padding_size(padding); diff --git a/src/c/aes128.c b/src/c/aes128.c index d4c609d..ac1b4f5 100644 --- a/src/c/aes128.c +++ b/src/c/aes128.c @@ -11,9 +11,9 @@ #include <emmintrin.h> #include <wmmintrin.h> -AesBlock128 __fastcall raw_aes128_encrypt_block( - AesBlock128 plain, - Aes128KeySchedule* key_schedule) +AesNI_Block128 __fastcall aesni_raw_encrypt_block128( + AesNI_Block128 plain, + AesNI_KeySchedule128* key_schedule) { plain = _mm_xor_si128(plain, key_schedule->keys[0]); plain = _mm_aesenc_si128(plain, key_schedule->keys[1]); @@ -28,9 +28,9 @@ AesBlock128 __fastcall raw_aes128_encrypt_block( return _mm_aesenclast_si128(plain, key_schedule->keys[10]); } -AesBlock128 __fastcall raw_aes128_decrypt_block( - AesBlock128 cipher, - Aes128KeySchedule* inverted_schedule) +AesNI_Block128 __fastcall aesni_raw_decrypt_block128( + AesNI_Block128 cipher, + AesNI_KeySchedule128* inverted_schedule) { cipher = _mm_xor_si128(cipher, inverted_schedule->keys[0]); cipher = _mm_aesdec_si128(cipher, inverted_schedule->keys[1]); @@ -45,11 +45,11 @@ AesBlock128 __fastcall raw_aes128_decrypt_block( return _mm_aesdeclast_si128(cipher, inverted_schedule->keys[10]); } -static AesBlock128 __fastcall aes128_keygen_assist( - AesBlock128 prev, - AesBlock128 hwgen) +static AesNI_Block128 __fastcall aes128_keygen_assist( + AesNI_Block128 prev, + AesNI_Block128 hwgen) { - AesBlock128 tmp = prev; + AesNI_Block128 tmp = prev; tmp = _mm_slli_si128(tmp, 4); prev = _mm_xor_si128(prev, tmp); @@ -64,11 +64,11 @@ static AesBlock128 __fastcall aes128_keygen_assist( return prev; } -void __fastcall raw_aes128_expand_key_schedule( - AesBlock128 key, - Aes128KeySchedule* key_schedule) +void __fastcall aesni_raw_expand_key_schedule128( + AesNI_Block128 key, + AesNI_KeySchedule128* key_schedule) { - AesBlock128 prev = key_schedule->keys[0] = key; + AesNI_Block128 prev = key_schedule->keys[0] = key; prev = key_schedule->keys[1] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x01)); prev = key_schedule->keys[2] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x02)); prev = key_schedule->keys[3] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x04)); @@ -81,9 +81,9 @@ void __fastcall raw_aes128_expand_key_schedule( prev = key_schedule->keys[10] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x36)); } -void __fastcall raw_aes128_invert_key_schedule( - Aes128KeySchedule* key_schedule, - Aes128KeySchedule* inverted_schedule) +void __fastcall aesni_raw_invert_key_schedule128( + AesNI_KeySchedule128* key_schedule, + AesNI_KeySchedule128* inverted_schedule) { inverted_schedule->keys[0] = key_schedule->keys[10]; inverted_schedule->keys[1] = _mm_aesimc_si128(key_schedule->keys[9]); diff --git a/src/c/aes192.c b/src/c/aes192.c index fec8f06..c0d410a 100644 --- a/src/c/aes192.c +++ b/src/c/aes192.c @@ -11,9 +11,9 @@ #include <emmintrin.h> #include <wmmintrin.h> -AesBlock128 __fastcall raw_aes192_encrypt_block( - AesBlock128 plain, - Aes192KeySchedule* key_schedule) +AesNI_Block128 __fastcall aesni_raw_encrypt_block192( + AesNI_Block128 plain, + AesNI_KeySchedule192* key_schedule) { plain = _mm_xor_si128(plain, key_schedule->keys[0]); plain = _mm_aesenc_si128(plain, key_schedule->keys[1]); @@ -30,9 +30,9 @@ AesBlock128 __fastcall raw_aes192_encrypt_block( return _mm_aesenclast_si128(plain, key_schedule->keys[12]); } -AesBlock128 __fastcall raw_aes192_decrypt_block( - AesBlock128 cipher, - Aes192KeySchedule* inverted_schedule) +AesNI_Block128 __fastcall aesni_raw_decrypt_block192( + AesNI_Block128 cipher, + AesNI_KeySchedule192* inverted_schedule) { cipher = _mm_xor_si128(cipher, inverted_schedule->keys[0]); cipher = _mm_aesdec_si128(cipher, inverted_schedule->keys[1]); @@ -50,11 +50,11 @@ AesBlock128 __fastcall raw_aes192_decrypt_block( } static void __fastcall aes192_keygen_assist( - AesBlock128* prev_lo, - AesBlock128* prev_hi, - AesBlock128 hwgen) + AesNI_Block128* prev_lo, + AesNI_Block128* prev_hi, + AesNI_Block128 hwgen) { - AesBlock128 tmp = *prev_lo; + AesNI_Block128 tmp = *prev_lo; tmp = _mm_slli_si128(tmp, 4); *prev_lo = _mm_xor_si128(*prev_lo, tmp); @@ -74,10 +74,10 @@ static void __fastcall aes192_keygen_assist( *prev_hi = _mm_xor_si128(*prev_hi, tmp); } -void __fastcall raw_aes192_expand_key_schedule( - AesBlock128 key_lo, - AesBlock128 key_hi, - Aes192KeySchedule* key_schedule) +void __fastcall aesni_raw_expand_key_schedule192( + AesNI_Block128 key_lo, + AesNI_Block128 key_hi, + AesNI_KeySchedule192* key_schedule) { key_schedule->keys[0] = key_lo; key_schedule->keys[1] = key_hi; @@ -114,9 +114,9 @@ void __fastcall raw_aes192_expand_key_schedule( key_schedule->keys[12] = key_lo; } -void __fastcall raw_aes192_invert_key_schedule( - Aes192KeySchedule* key_schedule, - Aes192KeySchedule* inverted_schedule) +void __fastcall aesni_raw_invert_key_schedule192( + AesNI_KeySchedule192* key_schedule, + AesNI_KeySchedule192* inverted_schedule) { inverted_schedule->keys[0] = key_schedule->keys[12]; inverted_schedule->keys[1] = _mm_aesimc_si128(key_schedule->keys[11]); diff --git a/src/c/aes256.c b/src/c/aes256.c index be4f783..a9042c6 100644 --- a/src/c/aes256.c +++ b/src/c/aes256.c @@ -11,9 +11,9 @@ #include <emmintrin.h> #include <wmmintrin.h> -AesBlock128 __fastcall raw_aes256_encrypt_block( - AesBlock128 plain, - Aes256KeySchedule* key_schedule) +AesNI_Block128 __fastcall aesni_raw_encrypt_block256( + AesNI_Block128 plain, + AesNI_KeySchedule256* key_schedule) { plain = _mm_xor_si128(plain, key_schedule->keys[0]); plain = _mm_aesenc_si128(plain, key_schedule->keys[1]); @@ -32,9 +32,9 @@ AesBlock128 __fastcall raw_aes256_encrypt_block( return _mm_aesenclast_si128(plain, key_schedule->keys[14]); } -AesBlock128 __fastcall raw_aes256_decrypt_block( - AesBlock128 cipher, - Aes256KeySchedule* inverted_schedule) +AesNI_Block128 __fastcall aesni_raw_decrypt_block256( + AesNI_Block128 cipher, + AesNI_KeySchedule256* inverted_schedule) { cipher = _mm_xor_si128(cipher, inverted_schedule->keys[0]); cipher = _mm_aesdec_si128(cipher, inverted_schedule->keys[1]); @@ -53,12 +53,12 @@ AesBlock128 __fastcall raw_aes256_decrypt_block( return _mm_aesdeclast_si128(cipher, inverted_schedule->keys[14]); } -static AesBlock128 __fastcall aes256_keygen_assist( - AesBlock128* prev_lo, - AesBlock128* prev_hi, - AesBlock128 hwgen) +static AesNI_Block128 __fastcall aes256_keygen_assist( + AesNI_Block128* prev_lo, + AesNI_Block128* prev_hi, + AesNI_Block128 hwgen) { - AesBlock128 tmp = *prev_lo; + AesNI_Block128 tmp = *prev_lo; tmp = _mm_slli_si128(tmp, 4); *prev_lo = _mm_xor_si128(*prev_lo, tmp); @@ -76,13 +76,13 @@ static AesBlock128 __fastcall aes256_keygen_assist( return *prev_hi; } -void __fastcall raw_aes256_expand_key_schedule( - AesBlock128 key_lo, - AesBlock128 key_hi, - Aes256KeySchedule* key_schedule) +void __fastcall aesni_raw_expand_key_schedule256( + AesNI_Block128 key_lo, + AesNI_Block128 key_hi, + AesNI_KeySchedule256* key_schedule) { - AesBlock128 prev_lo, prev_hi; - AesBlock128 hwgen; + AesNI_Block128 prev_lo, prev_hi; + AesNI_Block128 hwgen; prev_lo = key_schedule->keys[0] = key_lo; prev_hi = key_schedule->keys[1] = key_hi; @@ -140,9 +140,9 @@ void __fastcall raw_aes256_expand_key_schedule( key_schedule->keys[14] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen); } -void __fastcall raw_aes256_invert_key_schedule( - Aes256KeySchedule* key_schedule, - Aes256KeySchedule* inverted_schedule) +void __fastcall aesni_raw_invert_key_schedule256( + AesNI_KeySchedule256* key_schedule, + AesNI_KeySchedule256* inverted_schedule) { inverted_schedule->keys[0] = key_schedule->keys[14]; inverted_schedule->keys[1] = _mm_aesimc_si128(key_schedule->keys[13]); diff --git a/src/common.c b/src/common.c index c2e7530..e8d6e5b 100644 --- a/src/common.c +++ b/src/common.c @@ -13,36 +13,36 @@ #include <stdio.h> #include <string.h> -AesBlockString128 format_aes_block128(AesBlock128* block) +AesNI_BlockString128 aesni_format_block128(AesNI_Block128* block) { #if defined AESNI_LE_BLOCK_IO && AESNI_LE_BLOCK_IO - return format_aes_block128_le(block); + return aesni_format_block128_le(block); #else - return format_aes_block128_be(block); + return aesni_format_block128_be(block); #endif } -AesBlockString192 format_aes_block192(AesBlock192* block) +AesNI_BlockString192 aesni_format_block192(AesNI_Block192* block) { #if defined AESNI_LE_BLOCK_IO && AESNI_LE_BLOCK_IO - return format_aes_block192_le(block); + return aesni_format_block192_le(block); #else - return format_aes_block192_be(block); + return aesni_format_block192_be(block); #endif } -AesBlockString256 format_aes_block256(AesBlock256* block) +AesNI_BlockString256 aesni_format_block256(AesNI_Block256* block) { #if defined AESNI_LE_BLOCK_IO && AESNI_LE_BLOCK_IO - return format_aes_block256_le(block); + return aesni_format_block256_le(block); #else - return format_aes_block256_be(block); + return aesni_format_block256_be(block); #endif } -AesBlockString128 format_aes_block128_le(AesBlock128* block) +AesNI_BlockString128 aesni_format_block128_le(AesNI_Block128* block) { - AesBlockString128 result; + AesNI_BlockString128 result; char *cursor = result.str; for (int i = 0; i < 16; ++i, cursor += 2) @@ -52,9 +52,9 @@ AesBlockString128 format_aes_block128_le(AesBlock128* block) return result; } -AesBlockString192 format_aes_block192_le(AesBlock192* block) +AesNI_BlockString192 aesni_format_block192_le(AesNI_Block192* block) { - AesBlockString192 result; + AesNI_BlockString192 result; char *cursor = result.str; for (int i = 0; i < 8; ++i, cursor += 2) @@ -66,9 +66,9 @@ AesBlockString192 format_aes_block192_le(AesBlock192* block) return result; } -AesBlockString256 format_aes_block256_le(AesBlock256* block) +AesNI_BlockString256 aesni_format_block256_le(AesNI_Block256* block) { - AesBlockString256 result; + AesNI_BlockString256 result; char *cursor = result.str; for (int i = 0; i < 16; ++i, cursor += 2) @@ -80,9 +80,9 @@ AesBlockString256 format_aes_block256_le(AesBlock256* block) return result; } -AesBlockString128 format_aes_block128_be(AesBlock128* block) +AesNI_BlockString128 aesni_format_block128_be(AesNI_Block128* block) { - AesBlockString128 result; + AesNI_BlockString128 result; char *cursor = result.str; for (int i = 0; i < 16; ++i, cursor += 2) @@ -92,9 +92,9 @@ AesBlockString128 format_aes_block128_be(AesBlock128* block) return result; } -AesBlockString192 format_aes_block192_be(AesBlock192* block) +AesNI_BlockString192 aesni_format_block192_be(AesNI_Block192* block) { - AesBlockString192 result; + AesNI_BlockString192 result; char *cursor = result.str; for (int i = 0; i < 16; ++i, cursor += 2) @@ -106,9 +106,9 @@ AesBlockString192 format_aes_block192_be(AesBlock192* block) return result; } -AesBlockString256 format_aes_block256_be(AesBlock256* block) +AesNI_BlockString256 aesni_format_block256_be(AesNI_Block256* block) { - AesBlockString256 result; + AesNI_BlockString256 result; char *cursor = result.str; for (int i = 0; i < 16; ++i, cursor += 2) @@ -120,28 +120,28 @@ AesBlockString256 format_aes_block256_be(AesBlock256* block) return result; } -AesBlockMatrixString128 format_aes_block128_as_matrix(AesBlock128* block) +AesNI_BlockMatrixString128 aesni_format_block128_as_matrix(AesNI_Block128* block) { - return format_aes_block128_be_as_matrix(block); + return aesni_format_block128_be_as_matrix(block); } -AesBlockMatrixString192 format_aes_block192_as_matrix(AesBlock192* block) +AesNI_BlockMatrixString192 aesni_format_block192_as_matrix(AesNI_Block192* block) { - return format_aes_block192_be_as_matrix(block); + return aesni_format_block192_be_as_matrix(block); } -AesBlockMatrixString256 format_aes_block256_as_matrix(AesBlock256* block) +AesNI_BlockMatrixString256 aesni_format_block256_as_matrix(AesNI_Block256* block) { - return format_aes_block256_be_as_matrix(block); + return aesni_format_block256_be_as_matrix(block); } -AesBlockMatrixString128 format_aes_block128_be_as_matrix(AesBlock128* block) +AesNI_BlockMatrixString128 aesni_format_block128_be_as_matrix(AesNI_Block128* block) { __declspec(align(16)) unsigned char bytes[4][4]; - AesBlockMatrixString128 result; + AesNI_BlockMatrixString128 result; char* cursor = result.str; - _mm_store_si128((AesBlock128*) bytes, *block); + _mm_store_si128((AesNI_Block128*) bytes, *block); for (int i = 0; i < 4; ++i, cursor += 3) { @@ -154,14 +154,14 @@ AesBlockMatrixString128 format_aes_block128_be_as_matrix(AesBlock128* block) return result; } -AesBlockMatrixString192 format_aes_block192_be_as_matrix(AesBlock192* block) +AesNI_BlockMatrixString192 aesni_format_block192_be_as_matrix(AesNI_Block192* block) { __declspec(align(16)) unsigned char bytes[8][4]; - AesBlockMatrixString192 result; + AesNI_BlockMatrixString192 result; char* cursor = result.str; - _mm_store_si128((AesBlock128*) bytes, block->lo); - _mm_store_si128((AesBlock128*) bytes + 1, block->hi); + _mm_store_si128((AesNI_Block128*) bytes, block->lo); + _mm_store_si128((AesNI_Block128*) bytes + 1, block->hi); for (int i = 0; i < 4; ++i, cursor += 3) { @@ -174,14 +174,14 @@ AesBlockMatrixString192 format_aes_block192_be_as_matrix(AesBlock192* block) return result; } -AesBlockMatrixString256 format_aes_block256_be_as_matrix(AesBlock256* block) +AesNI_BlockMatrixString256 aesni_format_block256_be_as_matrix(AesNI_Block256* block) { __declspec(align(16)) unsigned char bytes[8][4]; - AesBlockMatrixString256 result; + AesNI_BlockMatrixString256 result; char* cursor = result.str; - _mm_store_si128((AesBlock128*) bytes, block->lo); - _mm_store_si128((AesBlock128*) bytes + 1, block->hi); + _mm_store_si128((AesNI_Block128*) bytes, block->lo); + _mm_store_si128((AesNI_Block128*) bytes + 1, block->hi); for (int i = 0; i < 4; ++i, cursor += 3) { @@ -194,139 +194,139 @@ AesBlockMatrixString256 format_aes_block256_be_as_matrix(AesBlock256* block) return result; } -void print_aes_block128(AesBlock128* block) +void aesni_print_block128(AesNI_Block128* block) { - printf("%s\n", format_aes_block128(block).str); + printf("%s\n", aesni_format_block128(block).str); } -void print_aes_block192(AesBlock192* block) +void aesni_print_block192(AesNI_Block192* block) { - printf("%s\n", format_aes_block192(block).str); + printf("%s\n", aesni_format_block192(block).str); } -void print_aes_block256(AesBlock256* block) +void aesni_print_block256(AesNI_Block256* block) { - printf("%s\n", format_aes_block256(block).str); + printf("%s\n", aesni_format_block256(block).str); } -void print_aes_block128_le(AesBlock128* block) +void aesni_print_block128_le(AesNI_Block128* block) { - printf("%s\n", format_aes_block128_le(block).str); + printf("%s\n", aesni_format_block128_le(block).str); } -void print_aes_block192_le(AesBlock192* block) +void aesni_print_block192_le(AesNI_Block192* block) { - printf("%s\n", format_aes_block192_le(block).str); + printf("%s\n", aesni_format_block192_le(block).str); } -void print_aes_block256_le(AesBlock256* block) +void aesni_print_block256_le(AesNI_Block256* block) { - printf("%s\n", format_aes_block256_le(block).str); + printf("%s\n", aesni_format_block256_le(block).str); } -void print_aes_block128_be(AesBlock128* block) +void aesni_print_block128_be(AesNI_Block128* block) { - printf("%s\n", format_aes_block128_be(block).str); + printf("%s\n", aesni_format_block128_be(block).str); } -void print_aes_block192_be(AesBlock192* block) +void aesni_print_block192_be(AesNI_Block192* block) { - printf("%s\n", format_aes_block192_be(block).str); + printf("%s\n", aesni_format_block192_be(block).str); } -void print_aes_block256_be(AesBlock256* block) +void aesni_print_block256_be(AesNI_Block256* block) { - printf("%s\n", format_aes_block256_be(block).str); + printf("%s\n", aesni_format_block256_be(block).str); } -void print_aes_block128_as_matrix(AesBlock128* block) +void aesni_print_block128_as_matrix(AesNI_Block128* block) { - printf("%s", format_aes_block128_as_matrix(block).str); + printf("%s", aesni_format_block128_as_matrix(block).str); } -void print_aes_block192_as_matrix(AesBlock192* block) +void aesni_print_block192_as_matrix(AesNI_Block192* block) { - printf("%s", format_aes_block192_as_matrix(block).str); + printf("%s", aesni_format_block192_as_matrix(block).str); } -void print_aes_block256_as_matrix(AesBlock256* block) +void aesni_print_block256_as_matrix(AesNI_Block256* block) { - printf("%s", format_aes_block256_as_matrix(block).str); + printf("%s", aesni_format_block256_as_matrix(block).str); } -void print_aes_block128_be_as_matrix(AesBlock128* block) +void aesni_print_block128_be_as_matrix(AesNI_Block128* block) { - printf("%s", format_aes_block128_be_as_matrix(block).str); + printf("%s", aesni_format_block128_be_as_matrix(block).str); } -void print_aes_block192_be_as_matrix(AesBlock192* block) +void aesni_print_block192_be_as_matrix(AesNI_Block192* block) { - printf("%s", format_aes_block192_be_as_matrix(block).str); + printf("%s", aesni_format_block192_be_as_matrix(block).str); } -void print_aes_block256_be_as_matrix(AesBlock256* block) +void aesni_print_block256_be_as_matrix(AesNI_Block256* block) { - printf("%s", format_aes_block256_be_as_matrix(block).str); + printf("%s", aesni_format_block256_be_as_matrix(block).str); } -int parse_aes_block128(AesBlock128* block, const char* src) +int aesni_parse_block128(AesNI_Block128* block, const char* src) { #if defined AESNI_LE_BLOCK_IO && AESNI_LE_BLOCK_IO - return parse_aes_block128_le(block, src); + return aesni_parse_block128_le(block, src); #else - return parse_aes_block128_be(block, src); + return aesni_parse_block128_be(block, src); #endif } -int parse_aes_block192(AesBlock192* block, const char* src) +int aesni_parse_block192(AesNI_Block192* block, const char* src) { #if defined AESNI_LE_BLOCK_IO && AESNI_LE_BLOCK_IO - return parse_aes_block192_le(block, src); + return aesni_parse_block192_le(block, src); #else - return parse_aes_block192_be(block, src); + return aesni_parse_block192_be(block, src); #endif } -int parse_aes_block256(AesBlock256* block, const char* src) +int aesni_parse_block256(AesNI_Block256* block, const char* src) { #if defined AESNI_LE_BLOCK_IO && AESNI_LE_BLOCK_IO - return parse_aes_block256_le(block, src); + return aesni_parse_block256_le(block, src); #else - return parse_aes_block256_be(block, src); + return aesni_parse_block256_be(block, src); #endif } -int parse_aes_block128_le(AesBlock128* block, const char* src) +int aesni_parse_block128_le(AesNI_Block128* block, const char* src) { int n, xs[4]; if (sscanf(src, "%8x%8x%8x%8x%n", &xs[0], &xs[1], &xs[2], &xs[3], &n) != 4 || n != strlen(src)) return 1; - *block = make_aes_block128(xs[0], xs[1], xs[2], xs[3]); + *block = aesni_make_block128(xs[0], xs[1], xs[2], xs[3]); return 0; } -int parse_aes_block192_le(AesBlock192* block, const char* src) +int aesni_parse_block192_le(AesNI_Block192* block, const char* src) { int n, xs[6]; if (sscanf(src, "%8x%8x%8x%8x%8x%8x%n", &xs[0], &xs[1], &xs[2], &xs[3], &xs[4], &xs[5], &n) != 6 || n != strlen(src)) return 1; - *block = make_aes_block192(xs[0], xs[1], xs[2], xs[3], xs[4], xs[5]); + *block = aesni_make_block192(xs[0], xs[1], xs[2], xs[3], xs[4], xs[5]); return 0; } -int parse_aes_block256_le(AesBlock256* block, const char* src) +int aesni_parse_block256_le(AesNI_Block256* block, const char* src) { int n, xs[8]; if (sscanf(src, "%8x%8x%8x%8x%8x%8x%8x%8x%n", &xs[0], &xs[1], &xs[2], &xs[3], &xs[4], &xs[5], &xs[6], &xs[7], &n) != 8 || n != strlen(src)) return 1; - *block = make_aes_block256(xs[0], xs[1], xs[2], xs[3], xs[4], xs[5], xs[6], xs[7]); + *block = aesni_make_block256(xs[0], xs[1], xs[2], xs[3], xs[4], xs[5], xs[6], xs[7]); return 0; } -int parse_aes_block128_be(AesBlock128* block, const char* src) +int aesni_parse_block128_be(AesNI_Block128* block, const char* src) { unsigned char bytes[16]; @@ -340,13 +340,13 @@ int parse_aes_block128_be(AesBlock128* block, const char* src) src += n; } - *block = _mm_loadu_si128((AesBlock128*) bytes); + *block = _mm_loadu_si128((AesNI_Block128*) bytes); return 0; } -int parse_aes_block192_be(AesBlock192* block, const char* src) +int aesni_parse_block192_be(AesNI_Block192* block, const char* src) { - AesBlock128 lo, hi; + AesNI_Block128 lo, hi; unsigned char lo_bytes[16], hi_bytes[16] = { 0 }; for (int i = 0; i < 16; ++i) @@ -359,7 +359,7 @@ int parse_aes_block192_be(AesBlock192* block, const char* src) src += n; } - lo = _mm_loadu_si128((AesBlock128*) lo_bytes); + lo = _mm_loadu_si128((AesNI_Block128*) lo_bytes); for (int i = 0; i < 8; ++i) { @@ -371,16 +371,16 @@ int parse_aes_block192_be(AesBlock192* block, const char* src) src += n; } - hi = _mm_loadu_si128((AesBlock128*) hi_bytes); + hi = _mm_loadu_si128((AesNI_Block128*) hi_bytes); block->hi = hi; block->lo = lo; return 0; } -int parse_aes_block256_be(AesBlock256* block, const char* src) +int aesni_parse_block256_be(AesNI_Block256* block, const char* src) { - AesBlock128 lo, hi; + AesNI_Block128 lo, hi; unsigned char lo_bytes[16], hi_bytes[16]; for (int i = 0; i < 16; ++i) @@ -393,7 +393,7 @@ int parse_aes_block256_be(AesBlock256* block, const char* src) src += n; } - lo = _mm_loadu_si128((AesBlock128*) lo_bytes); + lo = _mm_loadu_si128((AesNI_Block128*) lo_bytes); for (int i = 0; i < 16; ++i) { @@ -405,7 +405,7 @@ int parse_aes_block256_be(AesBlock256* block, const char* src) src += n; } - hi = _mm_loadu_si128((AesBlock128*) hi_bytes); + hi = _mm_loadu_si128((AesNI_Block128*) hi_bytes); block->hi = hi; block->lo = lo; diff --git a/test/aes128cbc_decrypt_block.c b/test/aes128cbc_decrypt_block.c index 3aacb83..b160cfa 100644 --- a/test/aes128cbc_decrypt_block.c +++ b/test/aes128cbc_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes128cbc_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_cbc128.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,39 +22,39 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, key, cipher, iv; - Aes128KeySchedule key_schedule, inverted_schedule; + AesNI_Block128 plain, key, cipher, iv; + AesNI_KeySchedule128 key_schedule, inverted_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block128(&key, *argv) != 0) + if (aesni_parse_block128(&key, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes128_expand_key_schedule(key, &key_schedule); - aes128_invert_key_schedule(&key_schedule, &inverted_schedule); + aesni_expand_key_schedule128(key, &key_schedule); + aesni_invert_key_schedule128(&key_schedule, &inverted_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes128cbc_decrypt_block(cipher, &inverted_schedule, iv, &iv); - print_aes_block128(&plain); + plain = aesni_decrypt_block_cbc128(cipher, &inverted_schedule, iv, &iv); + aesni_print_block128(&plain); } } diff --git a/test/aes128cbc_encrypt_block.c b/test/aes128cbc_encrypt_block.c index 2d831ad..73ec1e0 100644 --- a/test/aes128cbc_encrypt_block.c +++ b/test/aes128cbc_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes128cbc_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_cbc128.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,38 +22,38 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, key, cipher, iv; - Aes128KeySchedule key_schedule; + AesNI_Block128 plain, key, cipher, iv; + AesNI_KeySchedule128 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block128(&key, *argv) != 0) + if (aesni_parse_block128(&key, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes128_expand_key_schedule(key, &key_schedule); + aesni_expand_key_schedule128(key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes128cbc_encrypt_block(plain, &key_schedule, iv, &iv); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_cbc128(plain, &key_schedule, iv, &iv); + aesni_print_block128(&cipher); } } diff --git a/test/aes128cfb_decrypt_block.c b/test/aes128cfb_decrypt_block.c index 7bffd4f..c556d3d 100644 --- a/test/aes128cfb_decrypt_block.c +++ b/test/aes128cfb_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes128cfb_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_cfb128.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,38 +22,38 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, key, cipher, iv; - Aes128KeySchedule key_schedule; + AesNI_Block128 plain, key, cipher, iv; + AesNI_KeySchedule128 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block128(&key, *argv) != 0) + if (aesni_parse_block128(&key, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes128_expand_key_schedule(key, &key_schedule); + aesni_expand_key_schedule128(key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes128cfb_decrypt_block(cipher, &key_schedule, iv, &iv); - print_aes_block128(&plain); + plain = aesni_decrypt_block_cfb128(cipher, &key_schedule, iv, &iv); + aesni_print_block128(&plain); } } diff --git a/test/aes128cfb_encrypt_block.c b/test/aes128cfb_encrypt_block.c index a991864..c1db28c 100644 --- a/test/aes128cfb_encrypt_block.c +++ b/test/aes128cfb_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes128cfb_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_cfb128.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,38 +22,38 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, key, cipher, iv; - Aes128KeySchedule key_schedule; + AesNI_Block128 plain, key, cipher, iv; + AesNI_KeySchedule128 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block128(&key, *argv) != 0) + if (aesni_parse_block128(&key, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes128_expand_key_schedule(key, &key_schedule); + aesni_expand_key_schedule128(key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes128cfb_encrypt_block(plain, &key_schedule, iv, &iv); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_cfb128(plain, &key_schedule, iv, &iv); + aesni_print_block128(&cipher); } } diff --git a/test/aes128ctr_decrypt_block.c b/test/aes128ctr_decrypt_block.c index e6f9cee..61d9931 100644 --- a/test/aes128ctr_decrypt_block.c +++ b/test/aes128ctr_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes128ctr_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_ctr128.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,25 +22,25 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, key, cipher, iv; - Aes128KeySchedule key_schedule; + AesNI_Block128 plain, key, cipher, iv; + AesNI_KeySchedule128 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block128(&key, *argv) != 0) + if (aesni_parse_block128(&key, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes128_expand_key_schedule(key, &key_schedule); + aesni_expand_key_schedule128(key, &key_schedule); int ctr = 0; @@ -49,13 +49,13 @@ int main(int argc, char** argv) if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes128ctr_decrypt_block(cipher, &key_schedule, iv, ctr++); - print_aes_block128(&plain); + plain = aesni_decrypt_block_ctr128(cipher, &key_schedule, iv, ctr++); + aesni_print_block128(&plain); } } diff --git a/test/aes128ctr_encrypt_block.c b/test/aes128ctr_encrypt_block.c index 6baa266..8191172 100644 --- a/test/aes128ctr_encrypt_block.c +++ b/test/aes128ctr_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes128ctr_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_ctr128.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,25 +22,25 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, key, cipher, iv; - Aes128KeySchedule key_schedule; + AesNI_Block128 plain, key, cipher, iv; + AesNI_KeySchedule128 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block128(&key, *argv) != 0) + if (aesni_parse_block128(&key, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes128_expand_key_schedule(key, &key_schedule); + aesni_expand_key_schedule128(key, &key_schedule); int ctr = 0; @@ -49,13 +49,13 @@ int main(int argc, char** argv) if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes128ctr_encrypt_block(plain, &key_schedule, iv, ctr++); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_ctr128(plain, &key_schedule, iv, ctr++); + aesni_print_block128(&cipher); } } diff --git a/test/aes128ecb_decrypt_block.c b/test/aes128ecb_decrypt_block.c index 54b890d..79f47ed 100644 --- a/test/aes128ecb_decrypt_block.c +++ b/test/aes128ecb_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes128ecb_decrypt_block.exe KEY0 [CIPHER0...] [-- KEY1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_ecb128.exe KEY0 [CIPHER0...] [-- KEY1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,33 +22,33 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, key, cipher; - Aes128KeySchedule key_schedule, inverted_schedule; + AesNI_Block128 plain, key, cipher; + AesNI_KeySchedule128 key_schedule, inverted_schedule; if (argc < 1) exit_with_usage(); - if (parse_aes_block128(&key, *argv) != 0) + if (aesni_parse_block128(&key, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); exit_with_usage(); } - aes128_expand_key_schedule(key, &key_schedule); - aes128_invert_key_schedule(&key_schedule, &inverted_schedule); + aesni_expand_key_schedule128(key, &key_schedule); + aesni_invert_key_schedule128(&key_schedule, &inverted_schedule); for (--argc, ++argv; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes128ecb_decrypt_block(cipher, &inverted_schedule); - print_aes_block128(&plain); + plain = aesni_decrypt_block_ecb128(cipher, &inverted_schedule); + aesni_print_block128(&plain); } } diff --git a/test/aes128ecb_encrypt_block.c b/test/aes128ecb_encrypt_block.c index 43b1c1a..17ec89e 100644 --- a/test/aes128ecb_encrypt_block.c +++ b/test/aes128ecb_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes128ecb_encrypt_block.exe KEY0 [PLAIN0...] [-- KEY1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_ecb128.exe KEY0 [PLAIN0...] [-- KEY1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,32 +22,32 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, key, cipher; - Aes128KeySchedule key_schedule; + AesNI_Block128 plain, key, cipher; + AesNI_KeySchedule128 key_schedule; if (argc < 1) exit_with_usage(); - if (parse_aes_block128(&key, *argv) != 0) + if (aesni_parse_block128(&key, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); exit_with_usage(); } - aes128_expand_key_schedule(key, &key_schedule); + aesni_expand_key_schedule128(key, &key_schedule); for (--argc, ++argv; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes128ecb_encrypt_block(plain, &key_schedule); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_ecb128(plain, &key_schedule); + aesni_print_block128(&cipher); } } diff --git a/test/aes128ofb_decrypt_block.c b/test/aes128ofb_decrypt_block.c index edcbe77..84b220d 100644 --- a/test/aes128ofb_decrypt_block.c +++ b/test/aes128ofb_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes128ofb_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_ofb128.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,38 +22,38 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, key, cipher, iv; - Aes128KeySchedule key_schedule; + AesNI_Block128 plain, key, cipher, iv; + AesNI_KeySchedule128 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block128(&key, *argv) != 0) + if (aesni_parse_block128(&key, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes128_expand_key_schedule(key, &key_schedule); + aesni_expand_key_schedule128(key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes128ofb_decrypt_block(cipher, &key_schedule, iv, &iv); - print_aes_block128(&plain); + plain = aesni_decrypt_block_ofb128(cipher, &key_schedule, iv, &iv); + aesni_print_block128(&plain); } } diff --git a/test/aes128ofb_encrypt_block.c b/test/aes128ofb_encrypt_block.c index d1ff412..f52affa 100644 --- a/test/aes128ofb_encrypt_block.c +++ b/test/aes128ofb_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes128ofb_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_ofb128.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,38 +22,38 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, key, cipher, iv; - Aes128KeySchedule key_schedule; + AesNI_Block128 plain, key, cipher, iv; + AesNI_KeySchedule128 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block128(&key, *argv) != 0) + if (aesni_parse_block128(&key, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes128_expand_key_schedule(key, &key_schedule); + aesni_expand_key_schedule128(key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes128ofb_encrypt_block(plain, &key_schedule, iv, &iv); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_ofb128(plain, &key_schedule, iv, &iv); + aesni_print_block128(&cipher); } } diff --git a/test/aes192cbc_decrypt_block.c b/test/aes192cbc_decrypt_block.c index a714c2b..f7eb235 100644 --- a/test/aes192cbc_decrypt_block.c +++ b/test/aes192cbc_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes192cbc_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_cbc192.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,40 +22,40 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock192 key; - Aes192KeySchedule key_schedule, inverted_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule, inverted_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block192(&key, *argv) != 0) + if (aesni_parse_block192(&key, *argv) != 0) { fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes192_expand_key_schedule(&key, &key_schedule); - aes192_invert_key_schedule(&key_schedule, &inverted_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); + aesni_invert_key_schedule192(&key_schedule, &inverted_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes192cbc_decrypt_block(cipher, &inverted_schedule, iv, &iv); - print_aes_block128(&plain); + plain = aesni_decrypt_block_cbc192(cipher, &inverted_schedule, iv, &iv); + aesni_print_block128(&plain); } } diff --git a/test/aes192cbc_encrypt_block.c b/test/aes192cbc_encrypt_block.c index f0a23bc..ba04d9c 100644 --- a/test/aes192cbc_encrypt_block.c +++ b/test/aes192cbc_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes192cbc_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_cbc192.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,39 +22,39 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock192 key; - Aes192KeySchedule key_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block192(&key, *argv) != 0) + if (aesni_parse_block192(&key, *argv) != 0) { fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes192_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes192cbc_encrypt_block(plain, &key_schedule, iv, &iv); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_cbc192(plain, &key_schedule, iv, &iv); + aesni_print_block128(&cipher); } } diff --git a/test/aes192cfb_decrypt_block.c b/test/aes192cfb_decrypt_block.c index d8096a5..5048804 100644 --- a/test/aes192cfb_decrypt_block.c +++ b/test/aes192cfb_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes192cfb_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_cfb192.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,39 +22,39 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock192 key; - Aes192KeySchedule key_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block192(&key, *argv) != 0) + if (aesni_parse_block192(&key, *argv) != 0) { fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes192_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes192cfb_decrypt_block(cipher, &key_schedule, iv, &iv); - print_aes_block128(&plain); + plain = aesni_decrypt_block_cfb192(cipher, &key_schedule, iv, &iv); + aesni_print_block128(&plain); } } diff --git a/test/aes192cfb_encrypt_block.c b/test/aes192cfb_encrypt_block.c index 9ee207f..4a81432 100644 --- a/test/aes192cfb_encrypt_block.c +++ b/test/aes192cfb_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes192cfb_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_cfb192.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,39 +22,39 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock192 key; - Aes192KeySchedule key_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block192(&key, *argv) != 0) + if (aesni_parse_block192(&key, *argv) != 0) { fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes192_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes192cfb_encrypt_block(plain, &key_schedule, iv, &iv); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_cfb192(plain, &key_schedule, iv, &iv); + aesni_print_block128(&cipher); } } diff --git a/test/aes192ctr_decrypt_block.c b/test/aes192ctr_decrypt_block.c index 0c818cf..501c27a 100644 --- a/test/aes192ctr_decrypt_block.c +++ b/test/aes192ctr_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes192ctr_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_ctr192.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,26 +22,26 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock192 key; - Aes192KeySchedule key_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block192(&key, *argv) != 0) + if (aesni_parse_block192(&key, *argv) != 0) { fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes192_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); int ctr = 0; @@ -50,13 +50,13 @@ int main(int argc, char** argv) if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes192ctr_decrypt_block(cipher, &key_schedule, iv, ctr++); - print_aes_block128(&plain); + plain = aesni_decrypt_block_ctr192(cipher, &key_schedule, iv, ctr++); + aesni_print_block128(&plain); } } diff --git a/test/aes192ctr_encrypt_block.c b/test/aes192ctr_encrypt_block.c index 1a494c3..af73a98 100644 --- a/test/aes192ctr_encrypt_block.c +++ b/test/aes192ctr_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes192ctr_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_ctr192.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,26 +22,26 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock192 key; - Aes192KeySchedule key_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block192(&key, *argv) != 0) + if (aesni_parse_block192(&key, *argv) != 0) { fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes192_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); int ctr = 0; @@ -50,13 +50,13 @@ int main(int argc, char** argv) if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes192ctr_encrypt_block(plain, &key_schedule, iv, ctr++); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_ctr192(plain, &key_schedule, iv, ctr++); + aesni_print_block128(&cipher); } } diff --git a/test/aes192ecb_decrypt_block.c b/test/aes192ecb_decrypt_block.c index c034236..be4eeee 100644 --- a/test/aes192ecb_decrypt_block.c +++ b/test/aes192ecb_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes192ecb_decrypt_block.exe KEY0 [CIPHER0...] [-- KEY1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_ecb192.exe KEY0 [CIPHER0...] [-- KEY1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,34 +22,34 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher; - AesBlock192 key; - Aes192KeySchedule key_schedule, inverted_schedule; + AesNI_Block128 plain, cipher; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule, inverted_schedule; if (argc < 1) exit_with_usage(); - if (parse_aes_block192(&key, *argv) != 0) + if (aesni_parse_block192(&key, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); exit_with_usage(); } - aes192_expand_key_schedule(&key, &key_schedule); - aes192_invert_key_schedule(&key_schedule, &inverted_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); + aesni_invert_key_schedule192(&key_schedule, &inverted_schedule); for (--argc, ++argv; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes192ecb_decrypt_block(cipher, &inverted_schedule); - print_aes_block128(&plain); + plain = aesni_decrypt_block_ecb192(cipher, &inverted_schedule); + aesni_print_block128(&plain); } } diff --git a/test/aes192ecb_encrypt_block.c b/test/aes192ecb_encrypt_block.c index 9af1e3e..b652ee5 100644 --- a/test/aes192ecb_encrypt_block.c +++ b/test/aes192ecb_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes192ecb_encrypt_block.exe KEY0 [PLAIN0...] [-- KEY1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_ecb192.exe KEY0 [PLAIN0...] [-- KEY1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,33 +22,33 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher; - AesBlock192 key; - Aes192KeySchedule key_schedule; + AesNI_Block128 plain, cipher; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule; if (argc < 1) exit_with_usage(); - if (parse_aes_block192(&key, *argv) != 0) + if (aesni_parse_block192(&key, *argv) != 0) { fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv); exit_with_usage(); } - aes192_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); for (--argc, ++argv; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes192ecb_encrypt_block(plain, &key_schedule); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_ecb192(plain, &key_schedule); + aesni_print_block128(&cipher); } } diff --git a/test/aes192ofb_decrypt_block.c b/test/aes192ofb_decrypt_block.c index 4044435..2f830e1 100644 --- a/test/aes192ofb_decrypt_block.c +++ b/test/aes192ofb_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes192ofb_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_ofb192.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,39 +22,39 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock192 key; - Aes192KeySchedule key_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block192(&key, *argv) != 0) + if (aesni_parse_block192(&key, *argv) != 0) { fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes192_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes192ofb_decrypt_block(cipher, &key_schedule, iv, &iv); - print_aes_block128(&plain); + plain = aesni_decrypt_block_ofb192(cipher, &key_schedule, iv, &iv); + aesni_print_block128(&plain); } } diff --git a/test/aes192ofb_encrypt_block.c b/test/aes192ofb_encrypt_block.c index 8d57208..e541496 100644 --- a/test/aes192ofb_encrypt_block.c +++ b/test/aes192ofb_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes192ofb_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_ofb192.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,39 +22,39 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock192 key; - Aes192KeySchedule key_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block192 key; + AesNI_KeySchedule192 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block192(&key, *argv) != 0) + if (aesni_parse_block192(&key, *argv) != 0) { fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes192_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule192(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes192ofb_encrypt_block(plain, &key_schedule, iv, &iv); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_ofb192(plain, &key_schedule, iv, &iv); + aesni_print_block128(&cipher); } } diff --git a/test/aes256cbc_decrypt_block.c b/test/aes256cbc_decrypt_block.c index 7a1defe..f58dfa7 100644 --- a/test/aes256cbc_decrypt_block.c +++ b/test/aes256cbc_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes256cbc_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_cbc256.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,40 +22,40 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock256 key; - Aes256KeySchedule key_schedule, inverted_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule, inverted_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block256(&key, *argv) != 0) + if (aesni_parse_block256(&key, *argv) != 0) { fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes256_expand_key_schedule(&key, &key_schedule); - aes256_invert_key_schedule(&key_schedule, &inverted_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); + aesni_invert_key_schedule256(&key_schedule, &inverted_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes256cbc_decrypt_block(cipher, &inverted_schedule, iv, &iv); - print_aes_block128(&plain); + plain = aesni_decrypt_block_cbc256(cipher, &inverted_schedule, iv, &iv); + aesni_print_block128(&plain); } } diff --git a/test/aes256cbc_encrypt_block.c b/test/aes256cbc_encrypt_block.c index 81ffcc8..5bc2af8 100644 --- a/test/aes256cbc_encrypt_block.c +++ b/test/aes256cbc_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes256cbc_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_cbc256.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,39 +22,39 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock256 key; - Aes256KeySchedule key_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block256(&key, *argv) != 0) + if (aesni_parse_block256(&key, *argv) != 0) { fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes256_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes256cbc_encrypt_block(plain, &key_schedule, iv, &iv); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_cbc256(plain, &key_schedule, iv, &iv); + aesni_print_block128(&cipher); } } diff --git a/test/aes256cfb_decrypt_block.c b/test/aes256cfb_decrypt_block.c index ffa352a..5839a36 100644 --- a/test/aes256cfb_decrypt_block.c +++ b/test/aes256cfb_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes256cfb_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_cfb256.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,39 +22,39 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock256 key; - Aes256KeySchedule key_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block256(&key, *argv) != 0) + if (aesni_parse_block256(&key, *argv) != 0) { fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes256_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes256cfb_decrypt_block(cipher, &key_schedule, iv, &iv); - print_aes_block128(&plain); + plain = aesni_decrypt_block_cfb256(cipher, &key_schedule, iv, &iv); + aesni_print_block128(&plain); } } diff --git a/test/aes256cfb_encrypt_block.c b/test/aes256cfb_encrypt_block.c index 5afb7ab..acff8d7 100644 --- a/test/aes256cfb_encrypt_block.c +++ b/test/aes256cfb_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes256cfb_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_cfb256.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,39 +22,39 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock256 key; - Aes256KeySchedule key_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block256(&key, *argv) != 0) + if (aesni_parse_block256(&key, *argv) != 0) { fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes256_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes256cfb_encrypt_block(plain, &key_schedule, iv, &iv); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_cfb256(plain, &key_schedule, iv, &iv); + aesni_print_block128(&cipher); } } diff --git a/test/aes256ctr_decrypt_block.c b/test/aes256ctr_decrypt_block.c index 79d60e4..0bf1545 100644 --- a/test/aes256ctr_decrypt_block.c +++ b/test/aes256ctr_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes256ctr_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_ctr256.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,26 +22,26 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock256 key; - Aes256KeySchedule key_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block256(&key, *argv) != 0) + if (aesni_parse_block256(&key, *argv) != 0) { fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes256_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); int ctr = 0; @@ -50,13 +50,13 @@ int main(int argc, char** argv) if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes256ctr_decrypt_block(cipher, &key_schedule, iv, ctr++); - print_aes_block128(&plain); + plain = aesni_decrypt_block_ctr256(cipher, &key_schedule, iv, ctr++); + aesni_print_block128(&plain); } } diff --git a/test/aes256ctr_encrypt_block.c b/test/aes256ctr_encrypt_block.c index 3b384dc..a8894ea 100644 --- a/test/aes256ctr_encrypt_block.c +++ b/test/aes256ctr_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes256ctr_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_ctr256.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,26 +22,26 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock256 key; - Aes256KeySchedule key_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block256(&key, *argv) != 0) + if (aesni_parse_block256(&key, *argv) != 0) { fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes256_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); int ctr = 0; @@ -50,13 +50,13 @@ int main(int argc, char** argv) if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes256ctr_encrypt_block(plain, &key_schedule, iv, ctr++); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_ctr256(plain, &key_schedule, iv, ctr++); + aesni_print_block128(&cipher); } } diff --git a/test/aes256ecb_decrypt_block.c b/test/aes256ecb_decrypt_block.c index 106aa8b..203d1d5 100644 --- a/test/aes256ecb_decrypt_block.c +++ b/test/aes256ecb_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes256ecb_decrypt_block.exe KEY0 [CIPHER0...] [-- KEY1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_ecb256.exe KEY0 [CIPHER0...] [-- KEY1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,34 +22,34 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher; - AesBlock256 key; - Aes256KeySchedule key_schedule, inverted_schedule; + AesNI_Block128 plain, cipher; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule, inverted_schedule; if (argc < 1) exit_with_usage(); - if (parse_aes_block256(&key, *argv) != 0) + if (aesni_parse_block256(&key, *argv) != 0) { fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv); exit_with_usage(); } - aes256_expand_key_schedule(&key, &key_schedule); - aes256_invert_key_schedule(&key_schedule, &inverted_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); + aesni_invert_key_schedule256(&key_schedule, &inverted_schedule); for (--argc, ++argv; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes256ecb_decrypt_block(cipher, &inverted_schedule); - print_aes_block128(&plain); + plain = aesni_decrypt_block_ecb256(cipher, &inverted_schedule); + aesni_print_block128(&plain); } } diff --git a/test/aes256ecb_encrypt_block.c b/test/aes256ecb_encrypt_block.c index 4f550b6..ff11ce7 100644 --- a/test/aes256ecb_encrypt_block.c +++ b/test/aes256ecb_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes256ecb_encrypt_block.exe KEY0 [PLAIN0...] [-- KEY1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_ecb256.exe KEY0 [PLAIN0...] [-- KEY1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,33 +22,33 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher; - AesBlock256 key; - Aes256KeySchedule key_schedule; + AesNI_Block128 plain, cipher; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule; if (argc < 1) exit_with_usage(); - if (parse_aes_block256(&key, *argv) != 0) + if (aesni_parse_block256(&key, *argv) != 0) { fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv); exit_with_usage(); } - aes256_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); for (--argc, ++argv; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes256ecb_encrypt_block(plain, &key_schedule); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_ecb256(plain, &key_schedule); + aesni_print_block128(&cipher); } } diff --git a/test/aes256ofb_decrypt_block.c b/test/aes256ofb_decrypt_block.c index 7b4c614..ddc0024 100644 --- a/test/aes256ofb_decrypt_block.c +++ b/test/aes256ofb_decrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes256ofb_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); + puts("Usage: aesni_decrypt_block_ofb256.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]"); exit(EXIT_FAILURE); } @@ -22,39 +22,39 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock256 key; - Aes256KeySchedule key_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block256(&key, *argv) != 0) + if (aesni_parse_block256(&key, *argv) != 0) { fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes256_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&cipher, *argv) != 0) + if (aesni_parse_block128(&cipher, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aes256ofb_decrypt_block(cipher, &key_schedule, iv, &iv); - print_aes_block128(&plain); + plain = aesni_decrypt_block_ofb256(cipher, &key_schedule, iv, &iv); + aesni_print_block128(&plain); } } diff --git a/test/aes256ofb_encrypt_block.c b/test/aes256ofb_encrypt_block.c index 09d2edb..94138ca 100644 --- a/test/aes256ofb_encrypt_block.c +++ b/test/aes256ofb_encrypt_block.c @@ -14,7 +14,7 @@ static void exit_with_usage() { - puts("Usage: aes256ofb_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); + puts("Usage: aesni_encrypt_block_ofb256.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]"); exit(EXIT_FAILURE); } @@ -22,39 +22,39 @@ int main(int argc, char** argv) { for (--argc, ++argv; argc > -1; --argc, ++argv) { - AesBlock128 plain, cipher, iv; - AesBlock256 key; - Aes256KeySchedule key_schedule; + AesNI_Block128 plain, cipher, iv; + AesNI_Block256 key; + AesNI_KeySchedule256 key_schedule; if (argc < 2) exit_with_usage(); - if (parse_aes_block256(&key, *argv) != 0) + if (aesni_parse_block256(&key, *argv) != 0) { fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv); exit_with_usage(); } - if (parse_aes_block128(&iv, argv[1]) != 0) + if (aesni_parse_block128(&iv, argv[1]) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]); exit_with_usage(); } - aes256_expand_key_schedule(&key, &key_schedule); + aesni_expand_key_schedule256(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { if (strcmp("--", *argv) == 0) break; - if (parse_aes_block128(&plain, *argv) != 0) + if (aesni_parse_block128(&plain, *argv) != 0) { fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aes256ofb_encrypt_block(plain, &key_schedule, iv, &iv); - print_aes_block128(&cipher); + cipher = aesni_encrypt_block_ofb256(plain, &key_schedule, iv, &iv); + aesni_print_block128(&cipher); } } diff --git a/utils/aes128ecb_decrypt_file.cpp b/utils/aes128ecb_decrypt_file.cpp index 60b1546..6be3f94 100644 --- a/utils/aes128ecb_decrypt_file.cpp +++ b/utils/aes128ecb_decrypt_file.cpp @@ -34,13 +34,13 @@ namespace int main(int argc, char** argv) { - AesBlock128 key; - Aes128KeySchedule key_schedule, inverted_schedule; + AesNI_Block128 key; + AesNI_KeySchedule128 key_schedule, inverted_schedule; if (argc != 4) exit_with_usage(); - if (parse_aes_block128(&key, argv[1]) != 0) + if (aesni_parse_block128(&key, argv[1]) != 0) { std::cerr << "Invalid 128-bit AES block '" << argv[1] << "'\n"; exit_with_usage(); @@ -62,15 +62,15 @@ int main(int argc, char** argv) src_buf.assign(std::istreambuf_iterator<char>(src_ifs), std::istreambuf_iterator<char>()); - aes128_expand_key_schedule(key, &key_schedule); - aes128_invert_key_schedule(&key_schedule, &inverted_schedule); + aesni_expand_key_schedule128(key, &key_schedule); + aesni_invert_key_schedule128(&key_schedule, &inverted_schedule); - auto dest_size = aes128ecb_decrypt_buffer( + auto dest_size = aesni_decrypt_buffer_ecb128( src_buf.data(), static_cast<std::size_t>(src_size), NULL, &inverted_schedule); std::vector<unsigned char> dest_buf(static_cast<std::vector<char>::size_type>(dest_size)); - dest_size = aes128ecb_decrypt_buffer( + dest_size = aesni_decrypt_buffer_ecb128( src_buf.data(), static_cast<std::size_t>(src_size), dest_buf.data(), &inverted_schedule); std::ofstream dest_ofs; diff --git a/utils/aes128ecb_encrypt_file.cpp b/utils/aes128ecb_encrypt_file.cpp index 2e24f04..34a7dae 100644 --- a/utils/aes128ecb_encrypt_file.cpp +++ b/utils/aes128ecb_encrypt_file.cpp @@ -34,13 +34,13 @@ namespace int main(int argc, char** argv) { - AesBlock128 key; - Aes128KeySchedule key_schedule; + AesNI_Block128 key; + AesNI_KeySchedule128 key_schedule; if (argc != 4) exit_with_usage(); - if (parse_aes_block128(&key, argv[1]) != 0) + if (aesni_parse_block128(&key, argv[1]) != 0) { std::cerr << "Invalid 128-bit AES block '" << argv[1] << "'\n"; exit_with_usage(); @@ -62,9 +62,9 @@ int main(int argc, char** argv) src_buf.assign(std::istreambuf_iterator<char>(src_ifs), std::istreambuf_iterator<char>()); - aes128_expand_key_schedule(key, &key_schedule); + aesni_expand_key_schedule128(key, &key_schedule); - const auto dest_size = aes128ecb_encrypt_buffer( + const auto dest_size = aesni_encrypt_buffer_ecb128( src_buf.data(), static_cast<std::size_t>(src_size), NULL, @@ -72,7 +72,7 @@ int main(int argc, char** argv) std::vector<unsigned char> dest_buf(static_cast<std::vector<char>::size_type>(dest_size)); - aes128ecb_encrypt_buffer( + aesni_encrypt_buffer_ecb128( src_buf.data(), static_cast<std::size_t>(src_size), dest_buf.data(), |