pq_crypto-seal 0.1.0

data/ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_neon_aes.c

@@ -0,0 +1,119 @@
+#if defined(__aarch64__) || defined(_M_ARM64)
+
+#    include <stddef.h>
+#    include <stdint.h>
+
+#    include "../common/common.h"
+#    include "aegis128x4.h"
+#    include "aegis128x4_neon_aes.h"
+
+#    ifndef __ARM_FEATURE_CRYPTO
+#        define __ARM_FEATURE_CRYPTO 1
+#    endif
+#    ifndef __ARM_FEATURE_AES
+#        define __ARM_FEATURE_AES 1
+#    endif
+
+#    include <arm_neon.h>
+
+#    ifdef __clang__
+#        pragma clang attribute push(__attribute__((target("neon,crypto,aes"))), \
+                                     apply_to = function)
+#    elif defined(__GNUC__)
+#        pragma GCC target("+simd+crypto")
+#    endif
+
+#    define AES_BLOCK_LENGTH 64
+
+typedef struct {
+    uint8x16_t b0;
+    uint8x16_t b1;
+    uint8x16_t b2;
+    uint8x16_t 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) { veorq_u8(a.b0, b.b0), veorq_u8(a.b1, b.b1), veorq_u8(a.b2, b.b2),
+                           veorq_u8(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) { vandq_u8(a.b0, b.b0), vandq_u8(a.b1, b.b1), vandq_u8(a.b2, b.b2),
+                           vandq_u8(a.b3, b.b3) };
+}
+
+static inline aes_block_t
+AES_BLOCK_LOAD(const uint8_t *a)
+{
+    return (aes_block_t) { vld1q_u8(a), vld1q_u8(a + 16), vld1q_u8(a + 32), vld1q_u8(a + 48) };
+}
+
+static inline aes_block_t
+AES_BLOCK_LOAD_64x2(uint64_t a, uint64_t b)
+{
+    const uint8x16_t t = vreinterpretq_u8_u64(vsetq_lane_u64((a), vmovq_n_u64(b), 1));
+    return (aes_block_t) { t, t, t, t };
+}
+static inline void
+AES_BLOCK_STORE(uint8_t *a, const aes_block_t b)
+{
+    vst1q_u8(a, b.b0);
+    vst1q_u8(a + 16, b.b1);
+    vst1q_u8(a + 32, b.b2);
+    vst1q_u8(a + 48, b.b3);
+}
+
+static inline aes_block_t
+AES_ENC(const aes_block_t a, const aes_block_t b)
+{
+    return (aes_block_t) { veorq_u8(vaesmcq_u8(vaeseq_u8(vmovq_n_u8(0), a.b0)), b.b0),
+                           veorq_u8(vaesmcq_u8(vaeseq_u8(vmovq_n_u8(0), a.b1)), b.b1),
+                           veorq_u8(vaesmcq_u8(vaeseq_u8(vmovq_n_u8(0), a.b2)), b.b2),
+                           veorq_u8(vaesmcq_u8(vaeseq_u8(vmovq_n_u8(0), a.b3)), b.b3) };
+}
+
+static inline void
+aegis128x4_update(aes_block_t *const state, const aes_block_t d1, const aes_block_t d2)
+{
+    aes_block_t tmp;
+
+    tmp      = state[7];
+    state[7] = AES_ENC(state[6], state[7]);
+    state[6] = AES_ENC(state[5], state[6]);
+    state[5] = AES_ENC(state[4], state[5]);
+    state[4] = AES_BLOCK_XOR(AES_ENC(state[3], state[4]), d2);
+    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]), d1);
+}
+
+#    include "aegis128x4_common.h"
+
+struct aegis128x4_implementation aegis128x4_neon_aes_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/aegis128x4/aegis128x4_neon_aes.h

@@ -0,0 +1,9 @@
+#ifndef aegis128x4_neon_aes_H
+#define aegis128x4_neon_aes_H
+
+#include "../common/common.h"
+#include "implementations.h"
+
+extern struct aegis128x4_implementation aegis128x4_neon_aes_implementation;
+
+#endif

data/ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_soft.c

@@ -0,0 +1,104 @@
+#include <stddef.h>
+#include <stdint.h>
+
+#include "../common/common.h"
+#include "../common/cpu.h"
+
+#ifndef HAS_HW_AES
+
+#    include "../common/softaes.h"
+#    include "aegis128x4.h"
+#    include "aegis128x4_soft.h"
+
+#    define AES_BLOCK_LENGTH 64
+
+typedef struct {
+    SoftAesBlock b0;
+    SoftAesBlock b1;
+    SoftAesBlock b2;
+    SoftAesBlock 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) { softaes_block_xor(a.b0, b.b0), softaes_block_xor(a.b1, b.b1),
+                           softaes_block_xor(a.b2, b.b2), softaes_block_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) { softaes_block_and(a.b0, b.b0), softaes_block_and(a.b1, b.b1),
+                           softaes_block_and(a.b2, b.b2), softaes_block_and(a.b3, b.b3) };
+}
+
+static inline aes_block_t
+AES_BLOCK_LOAD(const uint8_t *a)
+{
+    return (aes_block_t) { softaes_block_load(a), softaes_block_load(a + 16),
+                           softaes_block_load(a + 32), softaes_block_load(a + 48) };
+}
+
+static inline aes_block_t
+AES_BLOCK_LOAD_64x2(uint64_t a, uint64_t b)
+{
+    const SoftAesBlock t = softaes_block_load64x2(a, b);
+    return (aes_block_t) { t, t, t, t };
+}
+static inline void
+AES_BLOCK_STORE(uint8_t *a, const aes_block_t b)
+{
+    softaes_block_store(a, b.b0);
+    softaes_block_store(a + 16, b.b1);
+    softaes_block_store(a + 32, b.b2);
+    softaes_block_store(a + 48, b.b3);
+}
+
+static inline aes_block_t
+AES_ENC(const aes_block_t a, const aes_block_t b)
+{
+    return (aes_block_t) { softaes_block_encrypt(a.b0, b.b0), softaes_block_encrypt(a.b1, b.b1),
+                           softaes_block_encrypt(a.b2, b.b2), softaes_block_encrypt(a.b3, b.b3) };
+}
+
+static inline void
+aegis128x4_update(aes_block_t *const state, const aes_block_t d1, const aes_block_t d2)
+{
+    aes_block_t tmp;
+
+    tmp      = state[7];
+    state[7] = AES_ENC(state[6], state[7]);
+    state[6] = AES_ENC(state[5], state[6]);
+    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_ENC(tmp, state[0]);
+
+    state[0] = AES_BLOCK_XOR(state[0], d1);
+    state[4] = AES_BLOCK_XOR(state[4], d2);
+}
+
+#    include "aegis128x4_common.h"
+
+struct aegis128x4_implementation aegis128x4_soft_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,
+};
+
+#endif

data/ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_soft.h

@@ -0,0 +1,9 @@
+#ifndef aegis128x4_soft_H
+#define aegis128x4_soft_H
+
+#include "../common/common.h"
+#include "implementations.h"
+
+extern struct aegis128x4_implementation aegis128x4_soft_implementation;
+
+#endif

data/ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/implementations.h

@@ -0,0 +1,41 @@
+#ifndef aegis128x4_implementations_H
+#define aegis128x4_implementations_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "aegis128x4.h"
+
+/* Namespacing to avoid conflicts with libsodium */
+#define aegis128x4_soft_implementation     libaegis_aegis128x4_soft_implementation
+#define aegis128x4_aesni_implementation    libaegis_aegis128x4_aesni_implementation
+#define aegis128x4_neon_aes_implementation libaegis_aegis128x4_neon_aes_implementation
+#define aegis128x4_altivec_implementation  libaegis_aegis128x4_altivec_implementation
+#define aegis128x4_avx2_implementation     libaegis_aegis128x4_avx2_implementation
+#define aegis128x4_avx512_implementation   libaegis_aegis128x4_avx512_implementation
+
+typedef struct aegis128x4_implementation {
+    int (*encrypt_detached)(uint8_t *c, uint8_t *mac, size_t maclen, const uint8_t *m, size_t mlen,
+                            const uint8_t *ad, size_t adlen, const uint8_t *npub, const uint8_t *k);
+    int (*decrypt_detached)(uint8_t *m, const uint8_t *c, size_t clen, const uint8_t *mac,
+                            size_t maclen, const uint8_t *ad, size_t adlen, const uint8_t *npub,
+                            const uint8_t *k);
+    void (*stream)(uint8_t *out, size_t len, const uint8_t *npub, const uint8_t *k);
+    void (*encrypt_unauthenticated)(uint8_t *c, const uint8_t *m, size_t mlen, const uint8_t *npub,
+                                    const uint8_t *k);
+    void (*decrypt_unauthenticated)(uint8_t *m, const uint8_t *c, size_t clen, const uint8_t *npub,
+                                    const uint8_t *k);
+    void (*state_init)(aegis128x4_state *st_, const uint8_t *ad, size_t adlen, const uint8_t *npub,
+                       const uint8_t *k);
+    int (*state_encrypt_update)(aegis128x4_state *st_, uint8_t *c, const uint8_t *m, size_t mlen);
+    int (*state_encrypt_final)(aegis128x4_state *st_, uint8_t *mac, size_t maclen);
+    int (*state_decrypt_update)(aegis128x4_state *st_, uint8_t *m, const uint8_t *c, size_t clen);
+    int (*state_decrypt_final)(aegis128x4_state *st_, const uint8_t *mac, size_t maclen);
+    void (*state_mac_init)(aegis128x4_mac_state *st_, const uint8_t *npub, const uint8_t *k);
+    int (*state_mac_update)(aegis128x4_mac_state *st_, const uint8_t *ad, size_t adlen);
+    int (*state_mac_final)(aegis128x4_mac_state *st_, uint8_t *mac, size_t maclen);
+    void (*state_mac_reset)(aegis128x4_mac_state *st);
+    void (*state_mac_clone)(aegis128x4_mac_state *dst, const aegis128x4_mac_state *src);
+} aegis128x4_implementation;
+
+#endif

data/ext/pq_crypto_seal/vendor/libaegis/src/aegis256/aegis256.c

@@ -0,0 +1,240 @@
+#include <stddef.h>
+#include <stdint.h>
+
+#include "../common/common.h"
+#include "../common/cpu.h"
+#include "aegis256.h"
+#include "aegis256_aesni.h"
+#include "aegis256_altivec.h"
+#include "aegis256_neon_aes.h"
+
+#ifndef HAS_HW_AES
+#    include "aegis256_soft.h"
+static const aegis256_implementation *implementation = &aegis256_soft_implementation;
+#else
+#    if defined(__aarch64__) || defined(_M_ARM64)
+static const aegis256_implementation *implementation = &aegis256_neon_aes_implementation;
+#    elif defined(__x86_64__) || defined(__i386__)
+static const aegis256_implementation *implementation = &aegis256_aesni_implementation;
+#    elif defined(__ALTIVEC__) && defined(__CRYPTO__)
+static const aegis256_implementation *implementation = &aegis256_altivec_implementation;
+#    else
+#        error "Unsupported architecture"
+#    endif
+#endif
+
+size_t
+aegis256_keybytes(void)
+{
+    return aegis256_KEYBYTES;
+}
+
+size_t
+aegis256_npubbytes(void)
+{
+    return aegis256_NPUBBYTES;
+}
+
+size_t
+aegis256_abytes_min(void)
+{
+    return aegis256_ABYTES_MIN;
+}
+
+size_t
+aegis256_abytes_max(void)
+{
+    return aegis256_ABYTES_MAX;
+}
+
+size_t
+aegis256_tailbytes_max(void)
+{
+    return aegis256_TAILBYTES_MAX;
+}
+
+int
+aegis256_encrypt_detached(uint8_t *c, uint8_t *mac, size_t maclen, const uint8_t *m, size_t mlen,
+                          const uint8_t *ad, size_t adlen, const uint8_t *npub, const uint8_t *k)
+{
+    if (maclen != 16 && maclen != 32) {
+        errno = EINVAL;
+        return -1;
+    }
+    return implementation->encrypt_detached(c, mac, maclen, m, mlen, ad, adlen, npub, k);
+}
+
+int
+aegis256_decrypt_detached(uint8_t *m, const uint8_t *c, size_t clen, const uint8_t *mac,
+                          size_t maclen, const uint8_t *ad, size_t adlen, const uint8_t *npub,
+                          const uint8_t *k)
+{
+    if (maclen != 16 && maclen != 32) {
+        errno = EINVAL;
+        return -1;
+    }
+    return implementation->decrypt_detached(m, c, clen, mac, maclen, ad, adlen, npub, k);
+}
+
+int
+aegis256_encrypt(uint8_t *c, size_t maclen, const uint8_t *m, size_t mlen, const uint8_t *ad,
+                 size_t adlen, const uint8_t *npub, const uint8_t *k)
+{
+    return aegis256_encrypt_detached(c, c + mlen, maclen, m, mlen, ad, adlen, npub, k);
+}
+
+int
+aegis256_decrypt(uint8_t *m, const uint8_t *c, size_t clen, size_t maclen, const uint8_t *ad,
+                 size_t adlen, const uint8_t *npub, const uint8_t *k)
+{
+    int ret = -1;
+
+    if (clen >= maclen) {
+        ret = aegis256_decrypt_detached(m, c, clen - maclen, c + clen - maclen, maclen, ad, adlen,
+                                        npub, k);
+    }
+    return ret;
+}
+
+void
+aegis256_state_init(aegis256_state *st_, const uint8_t *ad, size_t adlen, const uint8_t *npub,
+                    const uint8_t *k)
+{
+    memset(st_, 0, sizeof *st_);
+    implementation->state_init(st_, ad, adlen, npub, k);
+}
+
+int
+aegis256_state_encrypt_update(aegis256_state *st_, uint8_t *c, const uint8_t *m, size_t mlen)
+{
+    return implementation->state_encrypt_update(st_, c, m, mlen);
+}
+
+int
+aegis256_state_encrypt_final(aegis256_state *st_, uint8_t *mac, size_t maclen)
+{
+    if (maclen != 16 && maclen != 32) {
+        errno = EINVAL;
+        return -1;
+    }
+    return implementation->state_encrypt_final(st_, mac, maclen);
+}
+
+int
+aegis256_state_decrypt_update(aegis256_state *st_, uint8_t *m, const uint8_t *c, size_t clen)
+{
+    return implementation->state_decrypt_update(st_, m, c, clen);
+}
+
+int
+aegis256_state_decrypt_final(aegis256_state *st_, const uint8_t *mac, size_t maclen)
+{
+    if (maclen != 16 && maclen != 32) {
+        errno = EINVAL;
+        return -1;
+    }
+    return implementation->state_decrypt_final(st_, mac, maclen);
+}
+
+void
+aegis256_stream(uint8_t *out, size_t len, const uint8_t *npub, const uint8_t *k)
+{
+    implementation->stream(out, len, npub, k);
+}
+
+void
+aegis256_encrypt_unauthenticated(uint8_t *c, const uint8_t *m, size_t mlen, const uint8_t *npub,
+                                 const uint8_t *k)
+{
+    implementation->encrypt_unauthenticated(c, m, mlen, npub, k);
+}
+
+void
+aegis256_decrypt_unauthenticated(uint8_t *m, const uint8_t *c, size_t clen, const uint8_t *npub,
+                                 const uint8_t *k)
+{
+    implementation->decrypt_unauthenticated(m, c, clen, npub, k);
+}
+
+void
+aegis256_mac_init(aegis256_mac_state *st_, const uint8_t *k, const uint8_t *npub)
+{
+    implementation->state_mac_init(st_, npub, k);
+}
+
+int
+aegis256_mac_update(aegis256_mac_state *st_, const uint8_t *m, size_t mlen)
+{
+    return implementation->state_mac_update(st_, m, mlen);
+}
+
+int
+aegis256_mac_final(aegis256_mac_state *st_, uint8_t *mac, size_t maclen)
+{
+    if (maclen != 16 && maclen != 32) {
+        errno = EINVAL;
+        return -1;
+    }
+    return implementation->state_mac_final(st_, mac, maclen);
+}
+
+int
+aegis256_mac_verify(aegis256_mac_state *st_, const uint8_t *mac, size_t maclen)
+{
+    uint8_t expected_mac[32];
+
+    switch (maclen) {
+    case 16:
+        implementation->state_mac_final(st_, expected_mac, maclen);
+        return aegis_verify_16(expected_mac, mac);
+    case 32:
+        implementation->state_mac_final(st_, expected_mac, maclen);
+        return aegis_verify_32(expected_mac, mac);
+    default:
+        errno = EINVAL;
+        return -1;
+    }
+}
+
+void
+aegis256_mac_reset(aegis256_mac_state *st_)
+{
+    implementation->state_mac_reset(st_);
+}
+
+void
+aegis256_mac_state_clone(aegis256_mac_state *dst, const aegis256_mac_state *src)
+{
+    implementation->state_mac_clone(dst, src);
+}
+
+int
+aegis256_pick_best_implementation(void)
+{
+#ifndef HAS_HW_AES
+    implementation = &aegis256_soft_implementation;
+#endif
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+    if (aegis_runtime_has_neon_aes()) {
+        implementation = &aegis256_neon_aes_implementation;
+        return 0;
+    }
+#endif
+
+#if defined(__x86_64__) || defined(_M_AMD64) || defined(__i386__) || defined(_M_IX86)
+    if (aegis_runtime_has_aesni() && aegis_runtime_has_avx()) {
+        implementation = &aegis256_aesni_implementation;
+        return 0;
+    }
+#endif
+
+#if defined(__ALTIVEC__) && defined(__CRYPTO__)
+    if (aegis_runtime_has_altivec()) {
+        implementation = &aegis256_altivec_implementation;
+        return 0;
+    }
+#endif
+
+    return 0; /* LCOV_EXCL_LINE */
+}

data/ext/pq_crypto_seal/vendor/libaegis/src/aegis256/aegis256_aesni.c

@@ -0,0 +1,68 @@
+#if defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_AMD64)
+
+#    include <stddef.h>
+#    include <stdint.h>
+
+#    include "../common/common.h"
+#    include "aegis256.h"
+#    include "aegis256_aesni.h"
+
+#    ifdef __clang__
+#        pragma clang attribute push(__attribute__((target("aes,avx"))), apply_to = function)
+#    elif defined(__GNUC__)
+#        pragma GCC target("aes,avx")
+#    endif
+
+#    include <immintrin.h>
+#    include <wmmintrin.h>
+
+#    define AES_BLOCK_LENGTH 16
+
+typedef __m128i aes_block_t;
+
+#    define AES_BLOCK_XOR(A, B)       _mm_xor_si128((A), (B))
+#    define AES_BLOCK_AND(A, B)       _mm_and_si128((A), (B))
+#    define AES_BLOCK_LOAD(A)         _mm_loadu_si128((const aes_block_t *) (const void *) (A))
+#    define AES_BLOCK_LOAD_64x2(A, B) _mm_set_epi64x((long long) (A), (long long) (B))
+#    define AES_BLOCK_STORE(A, B)     _mm_storeu_si128((aes_block_t *) (void *) (A), (B))
+#    define AES_ENC(A, B)             _mm_aesenc_si128((A), (B))
+
+static inline void
+aegis256_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 "aegis256_common.h"
+
+struct aegis256_implementation aegis256_aesni_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/aegis256/aegis256_aesni.h

@@ -0,0 +1,9 @@
+#ifndef aegis256_aesni_H
+#define aegis256_aesni_H
+
+#include "../common/common.h"
+#include "implementations.h"
+
+extern struct aegis256_implementation aegis256_aesni_implementation;
+
+#endif

data/ext/pq_crypto_seal/vendor/libaegis/src/aegis256/aegis256_altivec.c

@@ -0,0 +1,68 @@
+#if defined(__ALTIVEC__) && defined(__CRYPTO__)
+
+#    include <stddef.h>
+#    include <stdint.h>
+
+#    include "../common/common.h"
+#    include "aegis256.h"
+#    include "aegis256_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 16
+
+typedef vector unsigned char aes_block_t;
+
+#    define AES_BLOCK_XOR(A, B) vec_xor((A), (B))
+#    define AES_BLOCK_AND(A, B) vec_and((A), (B))
+#    define AES_BLOCK_LOAD(A)   vec_xl_be(0, (const unsigned char *) (A))
+#    define AES_BLOCK_LOAD_64x2(A, B) \
+        ((aes_block_t) vec_revb(vec_insert((A), vec_promote((unsigned long long) (B), 1), 0)))
+#    define AES_BLOCK_STORE(A, B) vec_xst_be((B), 0, (unsigned char *) (A))
+#    define AES_ENC(A, B)         ((aes_block_t) vec_cipher_be((A), (B)))
+
+static inline void
+aegis256_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 "aegis256_common.h"
+
+struct aegis256_implementation aegis256_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/aegis256/aegis256_altivec.h

@@ -0,0 +1,9 @@
+#ifndef aegis256_altivec_H
+#define aegis256_altivec_H
+
+#include "../common/common.h"
+#include "implementations.h"
+
+extern struct aegis256_implementation aegis256_altivec_implementation;
+
+#endif