pq_crypto-seal 0.1.0

data/ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_altivec.c

@@ -0,0 +1,109 @@
+#if defined(__ALTIVEC__) && defined(__CRYPTO__)
+
+#    include <stddef.h>
+#    include <stdint.h>
+
+#    include "../common/common.h"
+#    include "aegis256x4.h"
+#    include "aegis256x4_altivec.h"
+
+#    include <altivec.h>
+
+#    ifdef __clang__
+#        pragma clang attribute push(__attribute__((target("altivec,crypto"))), apply_to = function)
+#    elif defined(__GNUC__)
+#        pragma GCC target("altivec,crypto")
+#    endif
+
+#    define AES_BLOCK_LENGTH 64
+
+typedef struct {
+    vector unsigned char b0;
+    vector unsigned char b1;
+    vector unsigned char b2;
+    vector unsigned char b3;
+} aes_block_t;
+
+static inline aes_block_t
+AES_BLOCK_XOR(const aes_block_t a, const aes_block_t b)
+{
+    return (aes_block_t) { vec_xor(a.b0, b.b0), vec_xor(a.b1, b.b1), vec_xor(a.b2, b.b2),
+                           vec_xor(a.b3, b.b3) };
+}
+
+static inline aes_block_t
+AES_BLOCK_AND(const aes_block_t a, const aes_block_t b)
+{
+    return (aes_block_t) { vec_and(a.b0, b.b0), vec_and(a.b1, b.b1), vec_and(a.b2, b.b2),
+                           vec_and(a.b3, b.b3) };
+}
+
+static inline aes_block_t
+AES_BLOCK_LOAD(const uint8_t *a)
+{
+    return (aes_block_t) { vec_xl_be(0, a), vec_xl_be(0, a + 16), vec_xl_be(0, a + 32),
+                           vec_xl_be(0, a + 48) };
+}
+
+static inline aes_block_t
+AES_BLOCK_LOAD_64x2(uint64_t a, uint64_t b)
+{
+    const vector unsigned char t = ((vector unsigned char) vec_revb(
+        vec_insert(a, vec_promote((unsigned long long) (b), 1), 0)));
+    return (aes_block_t) { t, t, t, t };
+}
+static inline void
+AES_BLOCK_STORE(uint8_t *a, const aes_block_t b)
+{
+    vec_xst_be(b.b0, 0, a);
+    vec_xst_be(b.b1, 0, a + 16);
+    vec_xst_be(b.b2, 0, a + 32);
+    vec_xst_be(b.b3, 0, a + 48);
+}
+
+static inline aes_block_t
+AES_ENC(const aes_block_t a, const aes_block_t b)
+{
+    return (aes_block_t) { vec_cipher_be(a.b0, b.b0), vec_cipher_be(a.b1, b.b1),
+                           vec_cipher_be(a.b2, b.b2), vec_cipher_be(a.b3, b.b3) };
+}
+
+static inline void
+aegis256x4_update(aes_block_t *const state, const aes_block_t d)
+{
+    aes_block_t tmp;
+
+    tmp      = state[5];
+    state[5] = AES_ENC(state[4], state[5]);
+    state[4] = AES_ENC(state[3], state[4]);
+    state[3] = AES_ENC(state[2], state[3]);
+    state[2] = AES_ENC(state[1], state[2]);
+    state[1] = AES_ENC(state[0], state[1]);
+    state[0] = AES_BLOCK_XOR(AES_ENC(tmp, state[0]), d);
+}
+
+#    include "aegis256x4_common.h"
+
+struct aegis256x4_implementation aegis256x4_altivec_implementation = {
+    .encrypt_detached        = encrypt_detached,
+    .decrypt_detached        = decrypt_detached,
+    .encrypt_unauthenticated = encrypt_unauthenticated,
+    .decrypt_unauthenticated = decrypt_unauthenticated,
+    .stream                  = stream,
+    .state_init              = state_init,
+    .state_encrypt_update    = state_encrypt_update,
+    .state_encrypt_final     = state_encrypt_final,
+    .state_decrypt_update    = state_decrypt_update,
+    .state_decrypt_final     = state_decrypt_final,
+    .state_mac_init          = state_mac_init,
+    .state_mac_update        = state_mac_update,
+    .state_mac_final         = state_mac_final,
+    .state_mac_reset         = state_mac_reset,
+    .state_mac_clone         = state_mac_clone,
+};
+
+#    ifdef __clang__
+#        pragma clang attribute pop
+#    endif
+
+#endif

data/ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_altivec.h

@@ -0,0 +1,9 @@
+#ifndef aegis256x4_altivec_H
+#define aegis256x4_altivec_H
+
+#include "../common/common.h"
+#include "implementations.h"
+
+extern struct aegis256x4_implementation aegis256x4_altivec_implementation;
+
+#endif

data/ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_avx2.c

@@ -0,0 +1,107 @@
+#if defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_AMD64)
+
+#    include <stddef.h>
+#    include <stdint.h>
+
+#    include "../common/common.h"
+#    include "aegis256x4.h"
+#    include "aegis256x4_avx2.h"
+
+#    ifdef HAVE_VAESINTRIN_H
+
+#        ifdef __clang__
+#            pragma clang attribute push(__attribute__((target("aes,vaes,avx2"))), \
+                                         apply_to = function)
+#        elif defined(__GNUC__)
+#            pragma GCC target("aes,vaes,avx2")
+#        endif
+
+#        include <immintrin.h>
+
+#        define AES_BLOCK_LENGTH 64
+
+typedef struct {
+    __m256i b0;
+    __m256i b1;
+} aes_block_t;
+
+static inline aes_block_t
+AES_BLOCK_XOR(const aes_block_t a, const aes_block_t b)
+{
+    return (aes_block_t) { _mm256_xor_si256(a.b0, b.b0), _mm256_xor_si256(a.b1, b.b1) };
+}
+
+static inline aes_block_t
+AES_BLOCK_AND(const aes_block_t a, const aes_block_t b)
+{
+    return (aes_block_t) { _mm256_and_si256(a.b0, b.b0), _mm256_and_si256(a.b1, b.b1) };
+}
+
+static inline aes_block_t
+AES_BLOCK_LOAD(const uint8_t *a)
+{
+    return (aes_block_t) { _mm256_loadu_si256((const __m256i *) (const void *) a),
+                           _mm256_loadu_si256((const __m256i *) (const void *) (a + 32)) };
+}
+
+static inline aes_block_t
+AES_BLOCK_LOAD_64x2(uint64_t a, uint64_t b)
+{
+    const __m256i t = _mm256_broadcastsi128_si256(_mm_set_epi64x((long long) a, (long long) b));
+    return (aes_block_t) { t, t };
+}
+
+static inline void
+AES_BLOCK_STORE(uint8_t *a, const aes_block_t b)
+{
+    _mm256_storeu_si256((__m256i *) (void *) a, b.b0);
+    _mm256_storeu_si256((__m256i *) (void *) (a + 32), b.b1);
+}
+
+static inline aes_block_t
+AES_ENC(const aes_block_t a, const aes_block_t b)
+{
+    return (aes_block_t) { _mm256_aesenc_epi128(a.b0, b.b0), _mm256_aesenc_epi128(a.b1, b.b1) };
+}
+
+static inline void
+aegis256x4_update(aes_block_t *const state, const aes_block_t d)
+{
+    aes_block_t tmp;
+
+    tmp      = state[5];
+    state[5] = AES_ENC(state[4], state[5]);
+    state[4] = AES_ENC(state[3], state[4]);
+    state[3] = AES_ENC(state[2], state[3]);
+    state[2] = AES_ENC(state[1], state[2]);
+    state[1] = AES_ENC(state[0], state[1]);
+    state[0] = AES_BLOCK_XOR(AES_ENC(tmp, state[0]), d);
+}
+
+#        include "aegis256x4_common.h"
+
+struct aegis256x4_implementation aegis256x4_avx2_implementation = {
+    .encrypt_detached        = encrypt_detached,
+    .decrypt_detached        = decrypt_detached,
+    .encrypt_unauthenticated = encrypt_unauthenticated,
+    .decrypt_unauthenticated = decrypt_unauthenticated,
+    .stream                  = stream,
+    .state_init              = state_init,
+    .state_encrypt_update    = state_encrypt_update,
+    .state_encrypt_final     = state_encrypt_final,
+    .state_decrypt_update    = state_decrypt_update,
+    .state_decrypt_final     = state_decrypt_final,
+    .state_mac_init          = state_mac_init,
+    .state_mac_update        = state_mac_update,
+    .state_mac_final         = state_mac_final,
+    .state_mac_reset         = state_mac_reset,
+    .state_mac_clone         = state_mac_clone,
+};
+
+#        ifdef __clang__
+#            pragma clang attribute pop
+#        endif
+
+#    endif
+
+#endif

data/ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_avx2.h

@@ -0,0 +1,11 @@
+#ifndef aegis256x4_avx2_H
+#define aegis256x4_avx2_H
+
+#include "../common/common.h"
+#include "implementations.h"
+
+#ifdef HAVE_VAESINTRIN_H
+extern struct aegis256x4_implementation aegis256x4_avx2_implementation;
+#endif
+
+#endif

data/ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_avx512.c

@@ -0,0 +1,79 @@
+#if defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_AMD64)
+
+#    include <stddef.h>
+#    include <stdint.h>
+
+#    include "../common/common.h"
+#    include "aegis256x4.h"
+#    include "aegis256x4_avx512.h"
+
+#    ifdef HAVE_VAESINTRIN_H
+
+#        ifdef __clang__
+#            if __clang_major__ >= 18 && __clang_major__ < 22
+#                pragma clang attribute push(__attribute__((target("aes,vaes,avx512f,evex512"))), \
+                                             apply_to = function)
+#            else
+#                pragma clang attribute push(__attribute__((target("aes,vaes,avx512f"))), \
+                                             apply_to = function)
+#            endif
+#        elif defined(__GNUC__)
+#            pragma GCC target("aes,vaes,avx512f")
+#        endif
+
+#        include <immintrin.h>
+
+#        define AES_BLOCK_LENGTH 64
+
+typedef __m512i aes_block_t;
+
+#        define AES_BLOCK_XOR(A, B) _mm512_xor_si512((A), (B))
+#        define AES_BLOCK_AND(A, B) _mm512_and_si512((A), (B))
+#        define AES_BLOCK_LOAD128_BROADCAST(A) \
+            _mm512_broadcast_i32x4(_mm_loadu_si128((const void *) (A)))
+#        define AES_BLOCK_LOAD(A)         _mm512_loadu_si512((const aes_block_t *) (const void *) (A))
+#        define AES_BLOCK_LOAD_64x2(A, B) _mm512_broadcast_i32x4(_mm_set_epi64x((A), (B)))
+#        define AES_BLOCK_STORE(A, B)     _mm512_storeu_si512((aes_block_t *) (void *) (A), (B))
+#        define AES_ENC(A, B)             _mm512_aesenc_epi128((A), (B))
+
+static inline void
+aegis256x4_update(aes_block_t *const state, const aes_block_t d)
+{
+    aes_block_t tmp;
+
+    tmp      = state[5];
+    state[5] = AES_ENC(state[4], state[5]);
+    state[4] = AES_ENC(state[3], state[4]);
+    state[3] = AES_ENC(state[2], state[3]);
+    state[2] = AES_ENC(state[1], state[2]);
+    state[1] = AES_ENC(state[0], state[1]);
+    state[0] = AES_BLOCK_XOR(AES_ENC(tmp, state[0]), d);
+}
+
+#        include "aegis256x4_common.h"
+
+struct aegis256x4_implementation aegis256x4_avx512_implementation = {
+    .encrypt_detached        = encrypt_detached,
+    .decrypt_detached        = decrypt_detached,
+    .encrypt_unauthenticated = encrypt_unauthenticated,
+    .decrypt_unauthenticated = decrypt_unauthenticated,
+    .stream                  = stream,
+    .state_init              = state_init,
+    .state_encrypt_update    = state_encrypt_update,
+    .state_encrypt_final     = state_encrypt_final,
+    .state_decrypt_update    = state_decrypt_update,
+    .state_decrypt_final     = state_decrypt_final,
+    .state_mac_init          = state_mac_init,
+    .state_mac_update        = state_mac_update,
+    .state_mac_final         = state_mac_final,
+    .state_mac_reset         = state_mac_reset,
+    .state_mac_clone         = state_mac_clone,
+};
+
+#        ifdef __clang__
+#            pragma clang attribute pop
+#        endif
+
+#    endif
+
+#endif

data/ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_avx512.h

@@ -0,0 +1,11 @@
+#ifndef aegis256x4_avx512_H
+#define aegis256x4_avx512_H
+
+#include "../common/common.h"
+#include "implementations.h"
+
+#ifdef HAVE_VAESINTRIN_H
+extern struct aegis256x4_implementation aegis256x4_avx512_implementation;
+#endif
+
+#endif