LeoVasanko/aegis-python
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Build updated for upstream libaegis 0.9.0 simplified API with matching changes on Python side. Set lower MacOS build target (11.0). Build abi3 version for all supported Python versions, reducing the number of wheels. Other build cleanup.

Browse Source
This commit is contained in:
LeoVasanko committed 2026-01-10 20:23:37 +00:00
1 parent a26ce6a9fb
commit a1bfeb2434
12 files changed
+389 -567
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/aeg/aegis128l.py
+6 -29
View File
@@ -708,24 +708,17 @@ class Encryptor:
raise TypeError(
"into length must be >= expected output size for this update"
)
written = ffi.new("size_t *")
rc = _lib.aegis128l_state_encrypt_update(
self._state.ptr,
ffi.from_buffer(out_mv),
out_mv.nbytes,
written,
_ptr(message),
message.nbytes,
)
if rc != 0:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(
f"state encrypt update failed: {err_name} written {written[0]}"
)
w = int(written[0])
assert w == expected_out
return out if into is None else memoryview(out)[:w] # type: ignore
raise RuntimeError(f"state encrypt update failed: {err_name}")
return out if into is None else memoryview(out)[:expected_out] # type: ignore
def final(self, into: Buffer | None = None) -> bytearray | memoryview:
"""Finalize encryption and return the authentication tag.
@@ -746,24 +739,17 @@ class Encryptor:
if into is not None:
into = memoryview(into)
out = into if into is not None else bytearray(maclen)
written = ffi.new("size_t *")
rc = _lib.aegis128l_state_encrypt_final(
self._state.ptr,
ffi.from_buffer(out),
memoryview(out).nbytes,
written,
maclen,
)
if rc != 0:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(f"state encrypt final failed: {err_name}")
w = int(written[0])
if into is None:
# Only the tag bytes are returned when we allocate the buffer
assert w == maclen
self._state = None
return out if into is None else memoryview(out)[:w] # type: ignore
return out if into is None else memoryview(out)[:maclen] # type: ignore
class Decryptor:
@@ -837,12 +823,9 @@ class Decryptor:
out_mv = memoryview(out)
if out_mv.nbytes < expected_out:
raise TypeError("into length must be >= required capacity for this update")
written = ffi.new("size_t *")
rc = _lib.aegis128l_state_decrypt_detached_update(
rc = _lib.aegis128l_state_decrypt_update(
self._state.ptr,
ffi.from_buffer(out_mv),
out_mv.nbytes,
written,
_ptr(ct),
ct.nbytes,
)
@@ -850,11 +833,7 @@ class Decryptor:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(f"state decrypt update failed: {err_name}")
w = int(written[0])
assert w == expected_out, (
f"got {w}, expected {expected_out}, ct.nbytes={ct.nbytes}"
)
return out if into is None else memoryview(out)[:w] # type: ignore
return out if into is None else memoryview(out)[:expected_out] # type: ignore
def final(self, mac: Buffer) -> None:
"""Finalize decryption by verifying the MAC tag.
@@ -873,9 +852,7 @@ class Decryptor:
mac = memoryview(mac)
if mac.nbytes != maclen:
raise TypeError(f"mac length must be {maclen}")
rc = _lib.aegis128l_state_decrypt_detached_final(
self._state.ptr, ffi.NULL, 0, ffi.NULL, _ptr(mac), maclen
)
rc = _lib.aegis128l_state_decrypt_final(self._state.ptr, _ptr(mac), maclen)
if rc != 0:
raise ValueError("authentication failed")
self._state = None
src/aeg/aegis128x2.py
+6 -29
View File
@@ -708,24 +708,17 @@ class Encryptor:
raise TypeError(
"into length must be >= expected output size for this update"
)
written = ffi.new("size_t *")
rc = _lib.aegis128x2_state_encrypt_update(
self._state.ptr,
ffi.from_buffer(out_mv),
out_mv.nbytes,
written,
_ptr(message),
message.nbytes,
)
if rc != 0:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(
f"state encrypt update failed: {err_name} written {written[0]}"
)
w = int(written[0])
assert w == expected_out
return out if into is None else memoryview(out)[:w] # type: ignore
raise RuntimeError(f"state encrypt update failed: {err_name}")
return out if into is None else memoryview(out)[:expected_out] # type: ignore
def final(self, into: Buffer | None = None) -> bytearray | memoryview:
"""Finalize encryption and return the authentication tag.
@@ -746,24 +739,17 @@ class Encryptor:
if into is not None:
into = memoryview(into)
out = into if into is not None else bytearray(maclen)
written = ffi.new("size_t *")
rc = _lib.aegis128x2_state_encrypt_final(
self._state.ptr,
ffi.from_buffer(out),
memoryview(out).nbytes,
written,
maclen,
)
if rc != 0:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(f"state encrypt final failed: {err_name}")
w = int(written[0])
if into is None:
# Only the tag bytes are returned when we allocate the buffer
assert w == maclen
self._state = None
return out if into is None else memoryview(out)[:w] # type: ignore
return out if into is None else memoryview(out)[:maclen] # type: ignore
class Decryptor:
@@ -837,12 +823,9 @@ class Decryptor:
out_mv = memoryview(out)
if out_mv.nbytes < expected_out:
raise TypeError("into length must be >= required capacity for this update")
written = ffi.new("size_t *")
rc = _lib.aegis128x2_state_decrypt_detached_update(
rc = _lib.aegis128x2_state_decrypt_update(
self._state.ptr,
ffi.from_buffer(out_mv),
out_mv.nbytes,
written,
_ptr(ct),
ct.nbytes,
)
@@ -850,11 +833,7 @@ class Decryptor:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(f"state decrypt update failed: {err_name}")
w = int(written[0])
assert w == expected_out, (
f"got {w}, expected {expected_out}, ct.nbytes={ct.nbytes}"
)
return out if into is None else memoryview(out)[:w] # type: ignore
return out if into is None else memoryview(out)[:expected_out] # type: ignore
def final(self, mac: Buffer) -> None:
"""Finalize decryption by verifying the MAC tag.
@@ -873,9 +852,7 @@ class Decryptor:
mac = memoryview(mac)
if mac.nbytes != maclen:
raise TypeError(f"mac length must be {maclen}")
rc = _lib.aegis128x2_state_decrypt_detached_final(
self._state.ptr, ffi.NULL, 0, ffi.NULL, _ptr(mac), maclen
)
rc = _lib.aegis128x2_state_decrypt_final(self._state.ptr, _ptr(mac), maclen)
if rc != 0:
raise ValueError("authentication failed")
self._state = None
src/aeg/aegis128x4.py
+6 -29
View File
@@ -708,24 +708,17 @@ class Encryptor:
raise TypeError(
"into length must be >= expected output size for this update"
)
written = ffi.new("size_t *")
rc = _lib.aegis128x4_state_encrypt_update(
self._state.ptr,
ffi.from_buffer(out_mv),
out_mv.nbytes,
written,
_ptr(message),
message.nbytes,
)
if rc != 0:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(
f"state encrypt update failed: {err_name} written {written[0]}"
)
w = int(written[0])
assert w == expected_out
return out if into is None else memoryview(out)[:w] # type: ignore
raise RuntimeError(f"state encrypt update failed: {err_name}")
return out if into is None else memoryview(out)[:expected_out] # type: ignore
def final(self, into: Buffer | None = None) -> bytearray | memoryview:
"""Finalize encryption and return the authentication tag.
@@ -746,24 +739,17 @@ class Encryptor:
if into is not None:
into = memoryview(into)
out = into if into is not None else bytearray(maclen)
written = ffi.new("size_t *")
rc = _lib.aegis128x4_state_encrypt_final(
self._state.ptr,
ffi.from_buffer(out),
memoryview(out).nbytes,
written,
maclen,
)
if rc != 0:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(f"state encrypt final failed: {err_name}")
w = int(written[0])
if into is None:
# Only the tag bytes are returned when we allocate the buffer
assert w == maclen
self._state = None
return out if into is None else memoryview(out)[:w] # type: ignore
return out if into is None else memoryview(out)[:maclen] # type: ignore
class Decryptor:
@@ -837,12 +823,9 @@ class Decryptor:
out_mv = memoryview(out)
if out_mv.nbytes < expected_out:
raise TypeError("into length must be >= required capacity for this update")
written = ffi.new("size_t *")
rc = _lib.aegis128x4_state_decrypt_detached_update(
rc = _lib.aegis128x4_state_decrypt_update(
self._state.ptr,
ffi.from_buffer(out_mv),
out_mv.nbytes,
written,
_ptr(ct),
ct.nbytes,
)
@@ -850,11 +833,7 @@ class Decryptor:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(f"state decrypt update failed: {err_name}")
w = int(written[0])
assert w == expected_out, (
f"got {w}, expected {expected_out}, ct.nbytes={ct.nbytes}"
)
return out if into is None else memoryview(out)[:w] # type: ignore
return out if into is None else memoryview(out)[:expected_out] # type: ignore
def final(self, mac: Buffer) -> None:
"""Finalize decryption by verifying the MAC tag.
@@ -873,9 +852,7 @@ class Decryptor:
mac = memoryview(mac)
if mac.nbytes != maclen:
raise TypeError(f"mac length must be {maclen}")
rc = _lib.aegis128x4_state_decrypt_detached_final(
self._state.ptr, ffi.NULL, 0, ffi.NULL, _ptr(mac), maclen
)
rc = _lib.aegis128x4_state_decrypt_final(self._state.ptr, _ptr(mac), maclen)
if rc != 0:
raise ValueError("authentication failed")
self._state = None
src/aeg/aegis256.py
+6 -29
View File
@@ -708,24 +708,17 @@ class Encryptor:
raise TypeError(
"into length must be >= expected output size for this update"
)
written = ffi.new("size_t *")
rc = _lib.aegis256_state_encrypt_update(
self._state.ptr,
ffi.from_buffer(out_mv),
out_mv.nbytes,
written,
_ptr(message),
message.nbytes,
)
if rc != 0:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(
f"state encrypt update failed: {err_name} written {written[0]}"
)
w = int(written[0])
assert w == expected_out
return out if into is None else memoryview(out)[:w] # type: ignore
raise RuntimeError(f"state encrypt update failed: {err_name}")
return out if into is None else memoryview(out)[:expected_out] # type: ignore
def final(self, into: Buffer | None = None) -> bytearray | memoryview:
"""Finalize encryption and return the authentication tag.
@@ -746,24 +739,17 @@ class Encryptor:
if into is not None:
into = memoryview(into)
out = into if into is not None else bytearray(maclen)
written = ffi.new("size_t *")
rc = _lib.aegis256_state_encrypt_final(
self._state.ptr,
ffi.from_buffer(out),
memoryview(out).nbytes,
written,
maclen,
)
if rc != 0:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(f"state encrypt final failed: {err_name}")
w = int(written[0])
if into is None:
# Only the tag bytes are returned when we allocate the buffer
assert w == maclen
self._state = None
return out if into is None else memoryview(out)[:w] # type: ignore
return out if into is None else memoryview(out)[:maclen] # type: ignore
class Decryptor:
@@ -837,12 +823,9 @@ class Decryptor:
out_mv = memoryview(out)
if out_mv.nbytes < expected_out:
raise TypeError("into length must be >= required capacity for this update")
written = ffi.new("size_t *")
rc = _lib.aegis256_state_decrypt_detached_update(
rc = _lib.aegis256_state_decrypt_update(
self._state.ptr,
ffi.from_buffer(out_mv),
out_mv.nbytes,
written,
_ptr(ct),
ct.nbytes,
)
@@ -850,11 +833,7 @@ class Decryptor:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(f"state decrypt update failed: {err_name}")
w = int(written[0])
assert w == expected_out, (
f"got {w}, expected {expected_out}, ct.nbytes={ct.nbytes}"
)
return out if into is None else memoryview(out)[:w] # type: ignore
return out if into is None else memoryview(out)[:expected_out] # type: ignore
def final(self, mac: Buffer) -> None:
"""Finalize decryption by verifying the MAC tag.
@@ -873,9 +852,7 @@ class Decryptor:
mac = memoryview(mac)
if mac.nbytes != maclen:
raise TypeError(f"mac length must be {maclen}")
rc = _lib.aegis256_state_decrypt_detached_final(
self._state.ptr, ffi.NULL, 0, ffi.NULL, _ptr(mac), maclen
)
rc = _lib.aegis256_state_decrypt_final(self._state.ptr, _ptr(mac), maclen)
if rc != 0:
raise ValueError("authentication failed")
self._state = None
src/aeg/aegis256x2.py
+6 -29
View File
@@ -708,24 +708,17 @@ class Encryptor:
raise TypeError(
"into length must be >= expected output size for this update"
)
written = ffi.new("size_t *")
rc = _lib.aegis256x2_state_encrypt_update(
self._state.ptr,
ffi.from_buffer(out_mv),
out_mv.nbytes,
written,
_ptr(message),
message.nbytes,
)
if rc != 0:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(
f"state encrypt update failed: {err_name} written {written[0]}"
)
w = int(written[0])
assert w == expected_out
return out if into is None else memoryview(out)[:w] # type: ignore
raise RuntimeError(f"state encrypt update failed: {err_name}")
return out if into is None else memoryview(out)[:expected_out] # type: ignore
def final(self, into: Buffer | None = None) -> bytearray | memoryview:
"""Finalize encryption and return the authentication tag.
@@ -746,24 +739,17 @@ class Encryptor:
if into is not None:
into = memoryview(into)
out = into if into is not None else bytearray(maclen)
written = ffi.new("size_t *")
rc = _lib.aegis256x2_state_encrypt_final(
self._state.ptr,
ffi.from_buffer(out),
memoryview(out).nbytes,
written,
maclen,
)
if rc != 0:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(f"state encrypt final failed: {err_name}")
w = int(written[0])
if into is None:
# Only the tag bytes are returned when we allocate the buffer
assert w == maclen
self._state = None
return out if into is None else memoryview(out)[:w] # type: ignore
return out if into is None else memoryview(out)[:maclen] # type: ignore
class Decryptor:
@@ -837,12 +823,9 @@ class Decryptor:
out_mv = memoryview(out)
if out_mv.nbytes < expected_out:
raise TypeError("into length must be >= required capacity for this update")
written = ffi.new("size_t *")
rc = _lib.aegis256x2_state_decrypt_detached_update(
rc = _lib.aegis256x2_state_decrypt_update(
self._state.ptr,
ffi.from_buffer(out_mv),
out_mv.nbytes,
written,
_ptr(ct),
ct.nbytes,
)
@@ -850,11 +833,7 @@ class Decryptor:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(f"state decrypt update failed: {err_name}")
w = int(written[0])
assert w == expected_out, (
f"got {w}, expected {expected_out}, ct.nbytes={ct.nbytes}"
)
return out if into is None else memoryview(out)[:w] # type: ignore
return out if into is None else memoryview(out)[:expected_out] # type: ignore
def final(self, mac: Buffer) -> None:
"""Finalize decryption by verifying the MAC tag.
@@ -873,9 +852,7 @@ class Decryptor:
mac = memoryview(mac)
if mac.nbytes != maclen:
raise TypeError(f"mac length must be {maclen}")
rc = _lib.aegis256x2_state_decrypt_detached_final(
self._state.ptr, ffi.NULL, 0, ffi.NULL, _ptr(mac), maclen
)
rc = _lib.aegis256x2_state_decrypt_final(self._state.ptr, _ptr(mac), maclen)
if rc != 0:
raise ValueError("authentication failed")
self._state = None
src/aeg/aegis256x4.py
+6 -29
View File
@@ -708,24 +708,17 @@ class Encryptor:
raise TypeError(
"into length must be >= expected output size for this update"
)
written = ffi.new("size_t *")
rc = _lib.aegis256x4_state_encrypt_update(
self._state.ptr,
ffi.from_buffer(out_mv),
out_mv.nbytes,
written,
_ptr(message),
message.nbytes,
)
if rc != 0:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(
f"state encrypt update failed: {err_name} written {written[0]}"
)
w = int(written[0])
assert w == expected_out
return out if into is None else memoryview(out)[:w] # type: ignore
raise RuntimeError(f"state encrypt update failed: {err_name}")
return out if into is None else memoryview(out)[:expected_out] # type: ignore
def final(self, into: Buffer | None = None) -> bytearray | memoryview:
"""Finalize encryption and return the authentication tag.
@@ -746,24 +739,17 @@ class Encryptor:
if into is not None:
into = memoryview(into)
out = into if into is not None else bytearray(maclen)
written = ffi.new("size_t *")
rc = _lib.aegis256x4_state_encrypt_final(
self._state.ptr,
ffi.from_buffer(out),
memoryview(out).nbytes,
written,
maclen,
)
if rc != 0:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(f"state encrypt final failed: {err_name}")
w = int(written[0])
if into is None:
# Only the tag bytes are returned when we allocate the buffer
assert w == maclen
self._state = None
return out if into is None else memoryview(out)[:w] # type: ignore
return out if into is None else memoryview(out)[:maclen] # type: ignore
class Decryptor:
@@ -837,12 +823,9 @@ class Decryptor:
out_mv = memoryview(out)
if out_mv.nbytes < expected_out:
raise TypeError("into length must be >= required capacity for this update")
written = ffi.new("size_t *")
rc = _lib.aegis256x4_state_decrypt_detached_update(
rc = _lib.aegis256x4_state_decrypt_update(
self._state.ptr,
ffi.from_buffer(out_mv),
out_mv.nbytes,
written,
_ptr(ct),
ct.nbytes,
)
@@ -850,11 +833,7 @@ class Decryptor:
err_num = ffi.errno
err_name = errno.errorcode.get(err_num, f"errno_{err_num}")
raise RuntimeError(f"state decrypt update failed: {err_name}")
w = int(written[0])
assert w == expected_out, (
f"got {w}, expected {expected_out}, ct.nbytes={ct.nbytes}"
)
return out if into is None else memoryview(out)[:w] # type: ignore
return out if into is None else memoryview(out)[:expected_out] # type: ignore
def final(self, mac: Buffer) -> None:
"""Finalize decryption by verifying the MAC tag.
@@ -873,9 +852,7 @@ class Decryptor:
mac = memoryview(mac)
if mac.nbytes != maclen:
raise TypeError(f"mac length must be {maclen}")
rc = _lib.aegis256x4_state_decrypt_detached_final(
self._state.ptr, ffi.NULL, 0, ffi.NULL, _ptr(mac), maclen
)
rc = _lib.aegis256x4_state_decrypt_final(self._state.ptr, _ptr(mac), maclen)
if rc != 0:
raise ValueError("authentication failed")
self._state = None
src/aeg/aegis_cdef.h
+32 -158
View File
@@ -55,35 +55,10 @@ void aegis128l_state_init(aegis128l_state *st_,
size_t adlen,
const uint8_t *npub,
const uint8_t *k);
int aegis128l_state_encrypt_update(aegis128l_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
const uint8_t *m,
size_t mlen);
int aegis128l_state_encrypt_detached_final(aegis128l_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
uint8_t *mac,
size_t maclen);
int aegis128l_state_encrypt_final(aegis128l_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
size_t maclen);
int aegis128l_state_decrypt_detached_update(aegis128l_state *st_,
uint8_t *m,
size_t mlen_max,
size_t *written,
const uint8_t *c,
size_t clen) ;
int aegis128l_state_decrypt_detached_final(aegis128l_state *st_,
uint8_t *m,
size_t mlen_max,
size_t *written,
const uint8_t *mac,
size_t maclen) ;
int aegis128l_state_encrypt_update(aegis128l_state *st_, uint8_t *c, const uint8_t *m, size_t mlen);
int aegis128l_state_encrypt_final(aegis128l_state *st_, uint8_t *mac, size_t maclen);
int aegis128l_state_decrypt_update(aegis128l_state *st_, uint8_t *m, const uint8_t *c, size_t clen) ;
int aegis128l_state_decrypt_final(aegis128l_state *st_, const uint8_t *mac, size_t maclen) ;
void aegis128l_stream(uint8_t *out, size_t len, const uint8_t *npub, const uint8_t *k);
void aegis128l_encrypt_unauthenticated(uint8_t *c,
const uint8_t *m,
@@ -151,33 +126,14 @@ void aegis128x2_state_init(aegis128x2_state *st_,
const uint8_t *k);
int aegis128x2_state_encrypt_update(aegis128x2_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
const uint8_t *m,
size_t mlen);
int aegis128x2_state_encrypt_detached_final(aegis128x2_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
uint8_t *mac,
size_t maclen);
int aegis128x2_state_encrypt_final(aegis128x2_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
size_t maclen);
int aegis128x2_state_decrypt_detached_update(aegis128x2_state *st_,
uint8_t *m,
size_t mlen_max,
size_t *written,
const uint8_t *c,
size_t clen) ;
int aegis128x2_state_decrypt_detached_final(aegis128x2_state *st_,
uint8_t *m,
size_t mlen_max,
size_t *written,
const uint8_t *mac,
size_t maclen) ;
int aegis128x2_state_encrypt_final(aegis128x2_state *st_, uint8_t *mac, size_t maclen);
int aegis128x2_state_decrypt_update(aegis128x2_state *st_,
uint8_t *m,
const uint8_t *c,
size_t clen) ;
int aegis128x2_state_decrypt_final(aegis128x2_state *st_, const uint8_t *mac, size_t maclen) ;
void aegis128x2_stream(uint8_t *out, size_t len, const uint8_t *npub, const uint8_t *k);
void aegis128x2_encrypt_unauthenticated(uint8_t *c,
const uint8_t *m,
@@ -245,33 +201,14 @@ void aegis128x4_state_init(aegis128x4_state *st_,
const uint8_t *k);
int aegis128x4_state_encrypt_update(aegis128x4_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
const uint8_t *m,
size_t mlen);
int aegis128x4_state_encrypt_detached_final(aegis128x4_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
uint8_t *mac,
size_t maclen);
int aegis128x4_state_encrypt_final(aegis128x4_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
size_t maclen);
int aegis128x4_state_decrypt_detached_update(aegis128x4_state *st_,
uint8_t *m,
size_t mlen_max,
size_t *written,
const uint8_t *c,
size_t clen) ;
int aegis128x4_state_decrypt_detached_final(aegis128x4_state *st_,
uint8_t *m,
size_t mlen_max,
size_t *written,
const uint8_t *mac,
size_t maclen) ;
int aegis128x4_state_encrypt_final(aegis128x4_state *st_, uint8_t *mac, size_t maclen);
int aegis128x4_state_decrypt_update(aegis128x4_state *st_,
uint8_t *m,
const uint8_t *c,
size_t clen) ;
int aegis128x4_state_decrypt_final(aegis128x4_state *st_, const uint8_t *mac, size_t maclen) ;
void aegis128x4_stream(uint8_t *out, size_t len, const uint8_t *npub, const uint8_t *k);
void aegis128x4_encrypt_unauthenticated(uint8_t *c,
const uint8_t *m,
@@ -337,35 +274,10 @@ void aegis256_state_init(aegis256_state *st_,
size_t adlen,
const uint8_t *npub,
const uint8_t *k);
int aegis256_state_encrypt_update(aegis256_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
const uint8_t *m,
size_t mlen);
int aegis256_state_encrypt_detached_final(aegis256_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
uint8_t *mac,
size_t maclen);
int aegis256_state_encrypt_final(aegis256_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
size_t maclen);
int aegis256_state_decrypt_detached_update(aegis256_state *st_,
uint8_t *m,
size_t mlen_max,
size_t *written,
const uint8_t *c,
size_t clen) ;
int aegis256_state_decrypt_detached_final(aegis256_state *st_,
uint8_t *m,
size_t mlen_max,
size_t *written,
const uint8_t *mac,
size_t maclen) ;
int aegis256_state_encrypt_update(aegis256_state *st_, uint8_t *c, const uint8_t *m, size_t mlen);
int aegis256_state_encrypt_final(aegis256_state *st_, uint8_t *mac, size_t maclen);
int aegis256_state_decrypt_update(aegis256_state *st_, uint8_t *m, const uint8_t *c, size_t clen) ;
int aegis256_state_decrypt_final(aegis256_state *st_, const uint8_t *mac, size_t maclen) ;
void aegis256_stream(uint8_t *out, size_t len, const uint8_t *npub, const uint8_t *k);
void aegis256_encrypt_unauthenticated(uint8_t *c,
const uint8_t *m,
@@ -433,33 +345,14 @@ void aegis256x2_state_init(aegis256x2_state *st_,
const uint8_t *k);
int aegis256x2_state_encrypt_update(aegis256x2_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
const uint8_t *m,
size_t mlen);
int aegis256x2_state_encrypt_detached_final(aegis256x2_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
uint8_t *mac,
size_t maclen);
int aegis256x2_state_encrypt_final(aegis256x2_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
size_t maclen);
int aegis256x2_state_decrypt_detached_update(aegis256x2_state *st_,
uint8_t *m,
size_t mlen_max,
size_t *written,
const uint8_t *c,
size_t clen) ;
int aegis256x2_state_decrypt_detached_final(aegis256x2_state *st_,
uint8_t *m,
size_t mlen_max,
size_t *written,
const uint8_t *mac,
size_t maclen) ;
int aegis256x2_state_encrypt_final(aegis256x2_state *st_, uint8_t *mac, size_t maclen);
int aegis256x2_state_decrypt_update(aegis256x2_state *st_,
uint8_t *m,
const uint8_t *c,
size_t clen) ;
int aegis256x2_state_decrypt_final(aegis256x2_state *st_, const uint8_t *mac, size_t maclen) ;
void aegis256x2_stream(uint8_t *out, size_t len, const uint8_t *npub, const uint8_t *k);
void aegis256x2_encrypt_unauthenticated(uint8_t *c,
const uint8_t *m,
@@ -527,33 +420,14 @@ void aegis256x4_state_init(aegis256x4_state *st_,
const uint8_t *k);
int aegis256x4_state_encrypt_update(aegis256x4_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
const uint8_t *m,
size_t mlen);
int aegis256x4_state_encrypt_detached_final(aegis256x4_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
uint8_t *mac,
size_t maclen);
int aegis256x4_state_encrypt_final(aegis256x4_state *st_,
uint8_t *c,
size_t clen_max,
size_t *written,
size_t maclen);
int aegis256x4_state_decrypt_detached_update(aegis256x4_state *st_,
uint8_t *m,
size_t mlen_max,
size_t *written,
const uint8_t *c,
size_t clen) ;
int aegis256x4_state_decrypt_detached_final(aegis256x4_state *st_,
uint8_t *m,
size_t mlen_max,
size_t *written,
const uint8_t *mac,
size_t maclen) ;
int aegis256x4_state_encrypt_final(aegis256x4_state *st_, uint8_t *mac, size_t maclen);
int aegis256x4_state_decrypt_update(aegis256x4_state *st_,
uint8_t *m,
const uint8_t *c,
size_t clen) ;
int aegis256x4_state_decrypt_final(aegis256x4_state *st_, const uint8_t *mac, size_t maclen) ;
void aegis256x4_stream(uint8_t *out, size_t len, const uint8_t *npub, const uint8_t *k);
void aegis256x4_encrypt_unauthenticated(uint8_t *c,
const uint8_t *m,