diff --git a/NEWS b/NEWS index 89b82cf594a..b43e8b26d6b 100644 --- a/NEWS +++ b/NEWS @@ -87,6 +87,10 @@ SOAP: Sockets: . Removed the deprecated inet_ntoa call support. (David Carlier) +Sodium: + . Add support for AEGIS-128L and AEGIS-256 (jedisct1) + . Enable AES-GCM on aarch64 with the ARM crypto extensions (jedisct1) + Standard: . Implement GH-12188 (Indication for the int size in phpinfo()). (timwolla) . Partly fix GH-12143 (Incorrect round() result for 0.49999999999999994). diff --git a/UPGRADING b/UPGRADING index d2985b3e080..58c60420aeb 100644 --- a/UPGRADING +++ b/UPGRADING @@ -243,6 +243,13 @@ PHP 8.4 UPGRADE NOTES . If JIT is enabled, PHP will now exit with a fatal error on startup in case of JIT startup initialization issues. +- Sodium: + . Added the sodium_crypto_aead_aegis128l_*() and sodium_crypto_aead_aegis256l_*() + functions to support the AEGIS family of authenticated encryption algorithms, + that was introduced in libsodium 1.0.19. + . sodium_crypto_aead_aes256gcm_*() functions are now enabled on aarch64 CPUs + with the ARM cryptographic extensions. + ======================================== 7. New Classes and Interfaces ======================================== diff --git a/ext/sodium/libsodium.c b/ext/sodium/libsodium.c index 173e67036f5..6a71d37a349 100644 --- a/ext/sodium/libsodium.c +++ b/ext/sodium/libsodium.c @@ -34,7 +34,7 @@ static zend_class_entry *sodium_exception_ce; #if (defined(__amd64) || defined(__amd64__) || defined(__x86_64__) || defined(__i386__) || \ - defined(_M_AMD64) || defined(_M_IX86)) + defined(_M_AMD64) || defined(_M_IX86) || defined(__aarch64__) || defined(_M_ARM64)) # define HAVE_AESGCM 1 #endif @@ -1866,6 +1866,236 @@ PHP_FUNCTION(sodium_crypto_aead_aes256gcm_decrypt) } #endif +#ifdef crypto_aead_aegis128l_KEYBYTES +PHP_FUNCTION(sodium_crypto_aead_aegis128l_encrypt) +{ + zend_string *ciphertext; + unsigned char *ad; + unsigned char *msg; + unsigned char *npub; + unsigned char *secretkey; + unsigned long long ciphertext_real_len; + size_t ad_len; + size_t ciphertext_len; + size_t msg_len; + size_t npub_len; + size_t secretkey_len; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss", + &msg, &msg_len, + &ad, &ad_len, + &npub, &npub_len, + &secretkey, &secretkey_len) == FAILURE) { + sodium_remove_param_values_from_backtrace(EG(exception)); + RETURN_THROWS(); + } + if (npub_len != crypto_aead_aegis128l_NPUBBYTES) { + zend_argument_error(sodium_exception_ce, 3, "must be SODIUM_CRYPTO_AEAD_AEGIS128L_NPUBBYTES bytes long"); + RETURN_THROWS(); + } + if (secretkey_len != crypto_aead_aegis128l_KEYBYTES) { + zend_argument_error(sodium_exception_ce, 4, "must be SODIUM_CRYPTO_AEAD_AEGIS128L_KEYBYTES bytes long"); + RETURN_THROWS(); + } + if (SIZE_MAX - msg_len <= crypto_aead_aegis128l_ABYTES) { + zend_throw_exception(sodium_exception_ce, "arithmetic overflow", 0); + RETURN_THROWS(); + } + ciphertext_len = msg_len + crypto_aead_aegis128l_ABYTES; + ciphertext = zend_string_alloc((size_t) ciphertext_len, 0); + if (crypto_aead_aegis128l_encrypt + ((unsigned char *) ZSTR_VAL(ciphertext), &ciphertext_real_len, msg, + (unsigned long long) msg_len, + ad, (unsigned long long) ad_len, NULL, npub, secretkey) != 0) { + zend_string_efree(ciphertext); + zend_throw_exception(sodium_exception_ce, "internal error", 0); + RETURN_THROWS(); + } + if (ciphertext_real_len <= 0U || ciphertext_real_len >= SIZE_MAX || + ciphertext_real_len > ciphertext_len) { + zend_string_efree(ciphertext); + zend_throw_exception(sodium_exception_ce, "arithmetic overflow", 0); + RETURN_THROWS(); + } + PHP_SODIUM_ZSTR_TRUNCATE(ciphertext, (size_t) ciphertext_real_len); + ZSTR_VAL(ciphertext)[ciphertext_real_len] = 0; + + RETURN_NEW_STR(ciphertext); +} + +PHP_FUNCTION(sodium_crypto_aead_aegis128l_decrypt) +{ + zend_string *msg; + unsigned char *ad; + unsigned char *ciphertext; + unsigned char *npub; + unsigned char *secretkey; + unsigned long long msg_real_len; + size_t ad_len; + size_t ciphertext_len; + size_t msg_len; + size_t npub_len; + size_t secretkey_len; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss", + &ciphertext, &ciphertext_len, + &ad, &ad_len, + &npub, &npub_len, + &secretkey, &secretkey_len) == FAILURE) { + sodium_remove_param_values_from_backtrace(EG(exception)); + RETURN_THROWS(); + } + if (npub_len != crypto_aead_aegis128l_NPUBBYTES) { + zend_argument_error(sodium_exception_ce, 3, "must be SODIUM_CRYPTO_AEAD_AEGIS128L_NPUBBYTES bytes long"); + RETURN_THROWS(); + } + if (secretkey_len != crypto_aead_aegis128l_KEYBYTES) { + zend_argument_error(sodium_exception_ce, 4, "must be SODIUM_CRYPTO_AEAD_AEGIS128L_KEYBYTES bytes long"); + RETURN_THROWS(); + } + if (ciphertext_len < crypto_aead_aegis128l_ABYTES) { + RETURN_FALSE; + } + msg_len = ciphertext_len; + if (msg_len >= SIZE_MAX) { + zend_throw_exception(sodium_exception_ce, "arithmetic overflow", 0); + RETURN_THROWS(); + } + msg = zend_string_alloc((size_t) msg_len, 0); + if (crypto_aead_aegis128l_decrypt + ((unsigned char *) ZSTR_VAL(msg), &msg_real_len, NULL, + ciphertext, (unsigned long long) ciphertext_len, + ad, (unsigned long long) ad_len, npub, secretkey) != 0) { + zend_string_efree(msg); + RETURN_FALSE; + } + if (msg_real_len >= SIZE_MAX || msg_real_len > msg_len) { + zend_string_efree(msg); + zend_throw_exception(sodium_exception_ce, "arithmetic overflow", 0); + RETURN_THROWS(); + } + PHP_SODIUM_ZSTR_TRUNCATE(msg, (size_t) msg_real_len); + ZSTR_VAL(msg)[msg_real_len] = 0; + + RETURN_NEW_STR(msg); +} +#endif + +#ifdef crypto_aead_aegis256_KEYBYTES +PHP_FUNCTION(sodium_crypto_aead_aegis256_encrypt) +{ + zend_string *ciphertext; + unsigned char *ad; + unsigned char *msg; + unsigned char *npub; + unsigned char *secretkey; + unsigned long long ciphertext_real_len; + size_t ad_len; + size_t ciphertext_len; + size_t msg_len; + size_t npub_len; + size_t secretkey_len; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss", + &msg, &msg_len, + &ad, &ad_len, + &npub, &npub_len, + &secretkey, &secretkey_len) == FAILURE) { + sodium_remove_param_values_from_backtrace(EG(exception)); + RETURN_THROWS(); + } + if (npub_len != crypto_aead_aegis256_NPUBBYTES) { + zend_argument_error(sodium_exception_ce, 3, "must be SODIUM_CRYPTO_AEAD_AEGIS256_NPUBBYTES bytes long"); + RETURN_THROWS(); + } + if (secretkey_len != crypto_aead_aegis256_KEYBYTES) { + zend_argument_error(sodium_exception_ce, 4, "must be SODIUM_CRYPTO_AEAD_AEGIS256_KEYBYTES bytes long"); + RETURN_THROWS(); + } + if (SIZE_MAX - msg_len <= crypto_aead_aegis256_ABYTES) { + zend_throw_exception(sodium_exception_ce, "arithmetic overflow", 0); + RETURN_THROWS(); + } + ciphertext_len = msg_len + crypto_aead_aegis256_ABYTES; + ciphertext = zend_string_alloc((size_t) ciphertext_len, 0); + if (crypto_aead_aegis256_encrypt + ((unsigned char *) ZSTR_VAL(ciphertext), &ciphertext_real_len, msg, + (unsigned long long) msg_len, + ad, (unsigned long long) ad_len, NULL, npub, secretkey) != 0) { + zend_string_efree(ciphertext); + zend_throw_exception(sodium_exception_ce, "internal error", 0); + RETURN_THROWS(); + } + if (ciphertext_real_len <= 0U || ciphertext_real_len >= SIZE_MAX || + ciphertext_real_len > ciphertext_len) { + zend_string_efree(ciphertext); + zend_throw_exception(sodium_exception_ce, "arithmetic overflow", 0); + RETURN_THROWS(); + } + PHP_SODIUM_ZSTR_TRUNCATE(ciphertext, (size_t) ciphertext_real_len); + ZSTR_VAL(ciphertext)[ciphertext_real_len] = 0; + + RETURN_NEW_STR(ciphertext); +} + +PHP_FUNCTION(sodium_crypto_aead_aegis256_decrypt) +{ + zend_string *msg; + unsigned char *ad; + unsigned char *ciphertext; + unsigned char *npub; + unsigned char *secretkey; + unsigned long long msg_real_len; + size_t ad_len; + size_t ciphertext_len; + size_t msg_len; + size_t npub_len; + size_t secretkey_len; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss", + &ciphertext, &ciphertext_len, + &ad, &ad_len, + &npub, &npub_len, + &secretkey, &secretkey_len) == FAILURE) { + sodium_remove_param_values_from_backtrace(EG(exception)); + RETURN_THROWS(); + } + if (npub_len != crypto_aead_aegis256_NPUBBYTES) { + zend_argument_error(sodium_exception_ce, 3, "must be SODIUM_CRYPTO_AEAD_AEGIS256_NPUBBYTES bytes long"); + RETURN_THROWS(); + } + if (secretkey_len != crypto_aead_aegis256_KEYBYTES) { + zend_argument_error(sodium_exception_ce, 4, "must be SODIUM_CRYPTO_AEAD_AEGIS256_KEYBYTES bytes long"); + RETURN_THROWS(); + } + if (ciphertext_len < crypto_aead_aegis256_ABYTES) { + RETURN_FALSE; + } + msg_len = ciphertext_len; + if (msg_len >= SIZE_MAX) { + zend_throw_exception(sodium_exception_ce, "arithmetic overflow", 0); + RETURN_THROWS(); + } + msg = zend_string_alloc((size_t) msg_len, 0); + if (crypto_aead_aegis256_decrypt + ((unsigned char *) ZSTR_VAL(msg), &msg_real_len, NULL, + ciphertext, (unsigned long long) ciphertext_len, + ad, (unsigned long long) ad_len, npub, secretkey) != 0) { + zend_string_efree(msg); + RETURN_FALSE; + } + if (msg_real_len >= SIZE_MAX || msg_real_len > msg_len) { + zend_string_efree(msg); + zend_throw_exception(sodium_exception_ce, "arithmetic overflow", 0); + RETURN_THROWS(); + } + PHP_SODIUM_ZSTR_TRUNCATE(msg, (size_t) msg_real_len); + ZSTR_VAL(msg)[msg_real_len] = 0; + + RETURN_NEW_STR(msg); +} +#endif + PHP_FUNCTION(sodium_crypto_aead_chacha20poly1305_encrypt) { zend_string *ciphertext; @@ -1881,10 +2111,10 @@ PHP_FUNCTION(sodium_crypto_aead_chacha20poly1305_encrypt) size_t secretkey_len; if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss", - &msg, &msg_len, - &ad, &ad_len, - &npub, &npub_len, - &secretkey, &secretkey_len) == FAILURE) { + &msg, &msg_len, + &ad, &ad_len, + &npub, &npub_len, + &secretkey, &secretkey_len) == FAILURE) { sodium_remove_param_values_from_backtrace(EG(exception)); RETURN_THROWS(); } @@ -2801,6 +3031,32 @@ PHP_FUNCTION(sodium_crypto_aead_aes256gcm_keygen) } #endif +#ifdef crypto_aead_aegis128l_KEYBYTES +PHP_FUNCTION(sodium_crypto_aead_aegis128l_keygen) +{ + unsigned char key[crypto_aead_aegis128l_KEYBYTES]; + + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + crypto_aead_aegis128l_keygen(key); + RETURN_STRINGL((const char *) key, sizeof key); +} +#endif + +#ifdef crypto_aead_aegis256_KEYBYTES +PHP_FUNCTION(sodium_crypto_aead_aegis256_keygen) +{ + unsigned char key[crypto_aead_aegis256_KEYBYTES]; + + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + crypto_aead_aegis256_keygen(key); + RETURN_STRINGL((const char *) key, sizeof key); +} +#endif + PHP_FUNCTION(sodium_crypto_aead_chacha20poly1305_keygen) { unsigned char key[crypto_aead_chacha20poly1305_KEYBYTES]; diff --git a/ext/sodium/libsodium.stub.php b/ext/sodium/libsodium.stub.php index 8ae94ad3af2..4bf6fade913 100644 --- a/ext/sodium/libsodium.stub.php +++ b/ext/sodium/libsodium.stub.php @@ -40,6 +40,52 @@ const SODIUM_CRYPTO_AEAD_AES256GCM_NPUBBYTES = UNKNOWN; const SODIUM_CRYPTO_AEAD_AES256GCM_ABYTES = UNKNOWN; #endif +#ifdef crypto_aead_aegis128l_KEYBYTES +/** + * @var int + * @cvalue crypto_aead_aegis128l_KEYBYTES + */ +const SODIUM_CRYPTO_AEAD_AEGIS128L_KEYBYTES = UNKNOWN; +/** + * @var int + * @cvalue crypto_aead_aegis128l_NSECBYTES + */ +const SODIUM_CRYPTO_AEAD_AEGIS128L_NSECBYTES = UNKNOWN; +/** + * @var int + * @cvalue crypto_aead_aegis128l_NPUBBYTES + */ +const SODIUM_CRYPTO_AEAD_AEGIS128L_NPUBBYTES = UNKNOWN; +/** + * @var int + * @cvalue crypto_aead_aegis128l_ABYTES + */ +const SODIUM_CRYPTO_AEAD_AEGIS128L_ABYTES = UNKNOWN; +#endif + +#ifdef crypto_aead_aegis256_KEYBYTES +/** + * @var int + * @cvalue crypto_aead_aegis256_KEYBYTES + */ +const SODIUM_CRYPTO_AEAD_AEGIS256_KEYBYTES = UNKNOWN; +/** + * @var int + * @cvalue crypto_aead_aegis256_NSECBYTES + */ +const SODIUM_CRYPTO_AEAD_AEGIS256_NSECBYTES = UNKNOWN; +/** + * @var int + * @cvalue crypto_aead_aegis256_NPUBBYTES + */ +const SODIUM_CRYPTO_AEAD_AEGIS256_NPUBBYTES = UNKNOWN; +/** + * @var int + * @cvalue crypto_aead_aegis256_ABYTES + */ +const SODIUM_CRYPTO_AEAD_AEGIS256_ABYTES = UNKNOWN; +#endif + /** * @var int * @cvalue crypto_aead_chacha20poly1305_KEYBYTES @@ -507,6 +553,22 @@ function sodium_crypto_aead_aes256gcm_encrypt(#[\SensitiveParameter] string $mes function sodium_crypto_aead_aes256gcm_keygen(): string {} #endif +#ifdef crypto_aead_aegis128l_KEYBYTES +function sodium_crypto_aead_aegis128l_decrypt(string $ciphertext, string $additional_data, string $nonce, #[\SensitiveParameter] string $key): string|false {} + +function sodium_crypto_aead_aegis128l_encrypt(#[\SensitiveParameter] string $message, string $additional_data, string $nonce, #[\SensitiveParameter] string $key): string {} + +function sodium_crypto_aead_aegis128l_keygen(): string {} +#endif + +#ifdef crypto_aead_aegis256_KEYBYTES +function sodium_crypto_aead_aegis256_decrypt(string $ciphertext, string $additional_data, string $nonce, #[\SensitiveParameter] string $key): string|false {} + +function sodium_crypto_aead_aegis256_encrypt(#[\SensitiveParameter] string $message, string $additional_data, string $nonce, #[\SensitiveParameter] string $key): string {} + +function sodium_crypto_aead_aegis256_keygen(): string {} +#endif + function sodium_crypto_aead_chacha20poly1305_decrypt(string $ciphertext, string $additional_data, string $nonce, #[\SensitiveParameter] string $key): string|false {} function sodium_crypto_aead_chacha20poly1305_encrypt(#[\SensitiveParameter] string $message, string $additional_data, string $nonce, #[\SensitiveParameter] string $key): string {} diff --git a/ext/sodium/libsodium_arginfo.h b/ext/sodium/libsodium_arginfo.h index 8fb0b9a32ac..c2bbfb8d35c 100644 --- a/ext/sodium/libsodium_arginfo.h +++ b/ext/sodium/libsodium_arginfo.h @@ -1,5 +1,5 @@ /* This is a generated file, edit the .stub.php file instead. - * Stub hash: 5711a4c90afa943e660fdc5fa15a0e91ae554057 */ + * Stub hash: 89cbb449ee6146dc8d50ba4bb1e76f83444a2db2 */ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_sodium_crypto_aead_aes256gcm_is_available, 0, 0, _IS_BOOL, 0) ZEND_END_ARG_INFO() @@ -27,6 +27,52 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_sodium_crypto_aead_aes256gcm_key ZEND_END_ARG_INFO() #endif +#if defined(crypto_aead_aegis128l_KEYBYTES) +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_sodium_crypto_aead_aegis128l_decrypt, 0, 4, MAY_BE_STRING|MAY_BE_FALSE) + ZEND_ARG_TYPE_INFO(0, ciphertext, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, additional_data, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, nonce, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0) +ZEND_END_ARG_INFO() +#endif + +#if defined(crypto_aead_aegis128l_KEYBYTES) +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_sodium_crypto_aead_aegis128l_encrypt, 0, 4, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, message, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, additional_data, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, nonce, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0) +ZEND_END_ARG_INFO() +#endif + +#if defined(crypto_aead_aegis128l_KEYBYTES) +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_sodium_crypto_aead_aegis128l_keygen, 0, 0, IS_STRING, 0) +ZEND_END_ARG_INFO() +#endif + +#if defined(crypto_aead_aegis256_KEYBYTES) +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_sodium_crypto_aead_aegis256_decrypt, 0, 4, MAY_BE_STRING|MAY_BE_FALSE) + ZEND_ARG_TYPE_INFO(0, ciphertext, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, additional_data, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, nonce, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0) +ZEND_END_ARG_INFO() +#endif + +#if defined(crypto_aead_aegis256_KEYBYTES) +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_sodium_crypto_aead_aegis256_encrypt, 0, 4, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, message, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, additional_data, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, nonce, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0) +ZEND_END_ARG_INFO() +#endif + +#if defined(crypto_aead_aegis256_KEYBYTES) +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_sodium_crypto_aead_aegis256_keygen, 0, 0, IS_STRING, 0) +ZEND_END_ARG_INFO() +#endif + ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_sodium_crypto_aead_chacha20poly1305_decrypt, 0, 4, MAY_BE_STRING|MAY_BE_FALSE) ZEND_ARG_TYPE_INFO(0, ciphertext, IS_STRING, 0) ZEND_ARG_TYPE_INFO(0, additional_data, IS_STRING, 0) @@ -516,6 +562,24 @@ ZEND_FUNCTION(sodium_crypto_aead_aes256gcm_encrypt); #if defined(HAVE_AESGCM) ZEND_FUNCTION(sodium_crypto_aead_aes256gcm_keygen); #endif +#if defined(crypto_aead_aegis128l_KEYBYTES) +ZEND_FUNCTION(sodium_crypto_aead_aegis128l_decrypt); +#endif +#if defined(crypto_aead_aegis128l_KEYBYTES) +ZEND_FUNCTION(sodium_crypto_aead_aegis128l_encrypt); +#endif +#if defined(crypto_aead_aegis128l_KEYBYTES) +ZEND_FUNCTION(sodium_crypto_aead_aegis128l_keygen); +#endif +#if defined(crypto_aead_aegis256_KEYBYTES) +ZEND_FUNCTION(sodium_crypto_aead_aegis256_decrypt); +#endif +#if defined(crypto_aead_aegis256_KEYBYTES) +ZEND_FUNCTION(sodium_crypto_aead_aegis256_encrypt); +#endif +#if defined(crypto_aead_aegis256_KEYBYTES) +ZEND_FUNCTION(sodium_crypto_aead_aegis256_keygen); +#endif ZEND_FUNCTION(sodium_crypto_aead_chacha20poly1305_decrypt); ZEND_FUNCTION(sodium_crypto_aead_chacha20poly1305_encrypt); ZEND_FUNCTION(sodium_crypto_aead_chacha20poly1305_keygen); @@ -701,6 +765,24 @@ static const zend_function_entry ext_functions[] = { #endif #if defined(HAVE_AESGCM) ZEND_FE(sodium_crypto_aead_aes256gcm_keygen, arginfo_sodium_crypto_aead_aes256gcm_keygen) +#endif +#if defined(crypto_aead_aegis128l_KEYBYTES) + ZEND_FE(sodium_crypto_aead_aegis128l_decrypt, arginfo_sodium_crypto_aead_aegis128l_decrypt) +#endif +#if defined(crypto_aead_aegis128l_KEYBYTES) + ZEND_FE(sodium_crypto_aead_aegis128l_encrypt, arginfo_sodium_crypto_aead_aegis128l_encrypt) +#endif +#if defined(crypto_aead_aegis128l_KEYBYTES) + ZEND_FE(sodium_crypto_aead_aegis128l_keygen, arginfo_sodium_crypto_aead_aegis128l_keygen) +#endif +#if defined(crypto_aead_aegis256_KEYBYTES) + ZEND_FE(sodium_crypto_aead_aegis256_decrypt, arginfo_sodium_crypto_aead_aegis256_decrypt) +#endif +#if defined(crypto_aead_aegis256_KEYBYTES) + ZEND_FE(sodium_crypto_aead_aegis256_encrypt, arginfo_sodium_crypto_aead_aegis256_encrypt) +#endif +#if defined(crypto_aead_aegis256_KEYBYTES) + ZEND_FE(sodium_crypto_aead_aegis256_keygen, arginfo_sodium_crypto_aead_aegis256_keygen) #endif ZEND_FE(sodium_crypto_aead_chacha20poly1305_decrypt, arginfo_sodium_crypto_aead_chacha20poly1305_decrypt) ZEND_FE(sodium_crypto_aead_chacha20poly1305_encrypt, arginfo_sodium_crypto_aead_chacha20poly1305_encrypt) @@ -900,6 +982,30 @@ static void register_libsodium_symbols(int module_number) #endif #if defined(HAVE_AESGCM) REGISTER_LONG_CONSTANT("SODIUM_CRYPTO_AEAD_AES256GCM_ABYTES", crypto_aead_aes256gcm_ABYTES, CONST_PERSISTENT); +#endif +#if defined(crypto_aead_aegis128l_KEYBYTES) + REGISTER_LONG_CONSTANT("SODIUM_CRYPTO_AEAD_AEGIS128L_KEYBYTES", crypto_aead_aegis128l_KEYBYTES, CONST_PERSISTENT); +#endif +#if defined(crypto_aead_aegis128l_KEYBYTES) + REGISTER_LONG_CONSTANT("SODIUM_CRYPTO_AEAD_AEGIS128L_NSECBYTES", crypto_aead_aegis128l_NSECBYTES, CONST_PERSISTENT); +#endif +#if defined(crypto_aead_aegis128l_KEYBYTES) + REGISTER_LONG_CONSTANT("SODIUM_CRYPTO_AEAD_AEGIS128L_NPUBBYTES", crypto_aead_aegis128l_NPUBBYTES, CONST_PERSISTENT); +#endif +#if defined(crypto_aead_aegis128l_KEYBYTES) + REGISTER_LONG_CONSTANT("SODIUM_CRYPTO_AEAD_AEGIS128L_ABYTES", crypto_aead_aegis128l_ABYTES, CONST_PERSISTENT); +#endif +#if defined(crypto_aead_aegis256_KEYBYTES) + REGISTER_LONG_CONSTANT("SODIUM_CRYPTO_AEAD_AEGIS256_KEYBYTES", crypto_aead_aegis256_KEYBYTES, CONST_PERSISTENT); +#endif +#if defined(crypto_aead_aegis256_KEYBYTES) + REGISTER_LONG_CONSTANT("SODIUM_CRYPTO_AEAD_AEGIS256_NSECBYTES", crypto_aead_aegis256_NSECBYTES, CONST_PERSISTENT); +#endif +#if defined(crypto_aead_aegis256_KEYBYTES) + REGISTER_LONG_CONSTANT("SODIUM_CRYPTO_AEAD_AEGIS256_NPUBBYTES", crypto_aead_aegis256_NPUBBYTES, CONST_PERSISTENT); +#endif +#if defined(crypto_aead_aegis256_KEYBYTES) + REGISTER_LONG_CONSTANT("SODIUM_CRYPTO_AEAD_AEGIS256_ABYTES", crypto_aead_aegis256_ABYTES, CONST_PERSISTENT); #endif REGISTER_LONG_CONSTANT("SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES", crypto_aead_chacha20poly1305_KEYBYTES, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES", crypto_aead_chacha20poly1305_NSECBYTES, CONST_PERSISTENT); @@ -1081,6 +1187,26 @@ static void register_libsodium_symbols(int module_number) zend_add_parameter_attribute(zend_hash_str_find_ptr(CG(function_table), "sodium_crypto_aead_aes256gcm_encrypt", sizeof("sodium_crypto_aead_aes256gcm_encrypt") - 1), 3, ZSTR_KNOWN(ZEND_STR_SENSITIVEPARAMETER), 0); #endif +#if defined(crypto_aead_aegis128l_KEYBYTES) + + zend_add_parameter_attribute(zend_hash_str_find_ptr(CG(function_table), "sodium_crypto_aead_aegis128l_decrypt", sizeof("sodium_crypto_aead_aegis128l_decrypt") - 1), 3, ZSTR_KNOWN(ZEND_STR_SENSITIVEPARAMETER), 0); +#endif +#if defined(crypto_aead_aegis128l_KEYBYTES) + + zend_add_parameter_attribute(zend_hash_str_find_ptr(CG(function_table), "sodium_crypto_aead_aegis128l_encrypt", sizeof("sodium_crypto_aead_aegis128l_encrypt") - 1), 0, ZSTR_KNOWN(ZEND_STR_SENSITIVEPARAMETER), 0); + + zend_add_parameter_attribute(zend_hash_str_find_ptr(CG(function_table), "sodium_crypto_aead_aegis128l_encrypt", sizeof("sodium_crypto_aead_aegis128l_encrypt") - 1), 3, ZSTR_KNOWN(ZEND_STR_SENSITIVEPARAMETER), 0); +#endif +#if defined(crypto_aead_aegis256_KEYBYTES) + + zend_add_parameter_attribute(zend_hash_str_find_ptr(CG(function_table), "sodium_crypto_aead_aegis256_decrypt", sizeof("sodium_crypto_aead_aegis256_decrypt") - 1), 3, ZSTR_KNOWN(ZEND_STR_SENSITIVEPARAMETER), 0); +#endif +#if defined(crypto_aead_aegis256_KEYBYTES) + + zend_add_parameter_attribute(zend_hash_str_find_ptr(CG(function_table), "sodium_crypto_aead_aegis256_encrypt", sizeof("sodium_crypto_aead_aegis256_encrypt") - 1), 0, ZSTR_KNOWN(ZEND_STR_SENSITIVEPARAMETER), 0); + + zend_add_parameter_attribute(zend_hash_str_find_ptr(CG(function_table), "sodium_crypto_aead_aegis256_encrypt", sizeof("sodium_crypto_aead_aegis256_encrypt") - 1), 3, ZSTR_KNOWN(ZEND_STR_SENSITIVEPARAMETER), 0); +#endif zend_add_parameter_attribute(zend_hash_str_find_ptr(CG(function_table), "sodium_crypto_aead_chacha20poly1305_decrypt", sizeof("sodium_crypto_aead_chacha20poly1305_decrypt") - 1), 3, ZSTR_KNOWN(ZEND_STR_SENSITIVEPARAMETER), 0); diff --git a/ext/sodium/tests/crypto_aead.phpt b/ext/sodium/tests/crypto_aead.phpt index 0da84194bbc..66be5a2c6e3 100644 --- a/ext/sodium/tests/crypto_aead.phpt +++ b/ext/sodium/tests/crypto_aead.phpt @@ -5,6 +5,8 @@ sodium --SKIPIF-- --FILE-- --EXPECT-- aead_chacha20poly1305: @@ -133,3 +187,13 @@ bool(true) bool(true) bool(false) bool(true) +aead_aegis128l: +bool(true) +bool(true) +bool(false) +bool(false) +aead_aegis256: +bool(true) +bool(true) +bool(false) +bool(false)