From fef78d728fb4c0c6edf7f57bdb43c7f44553d3ed Mon Sep 17 00:00:00 2001 From: Aron Podrigal Date: Wed, 15 Jan 2025 16:05:28 -0600 Subject: [PATCH] Add support for UUID versioning and generation of UUIDv7. This update introduces support for generating UUIDs with specific versions, including the newly implemented UUIDv7. The `create_uuid` API has been updated to accept optional version parameters. Additionally, a new utility function `switch_getentropy` was added to ensure secure random number generation. --- src/include/switch_apr.h | 7 +- src/include/switch_utils.h | 6 +- .../applications/mod_commands/mod_commands.c | 9 +- src/switch_apr.c | 17 +++- src/switch_utils.c | 98 ++++++++++++++++++- 5 files changed, 130 insertions(+), 7 deletions(-) diff --git a/src/include/switch_apr.h b/src/include/switch_apr.h index 36f1531bef..c04b481780 100644 --- a/src/include/switch_apr.h +++ b/src/include/switch_apr.h @@ -560,7 +560,12 @@ SWITCH_DECLARE(void) switch_uuid_format(char *buffer, const switch_uuid_t *uuid) * Generate and return a (new) UUID * @param uuid The resulting UUID */ -SWITCH_DECLARE(void) switch_uuid_get(switch_uuid_t *uuid); +#ifndef DEFAULT_UUID_VERSION +#define DEFAULT_UUID_VERSION 4 +#endif +SWITCH_DECLARE(switch_status_t) switch_uuid_generate_v4(switch_uuid_t *uuid); +SWITCH_DECLARE(switch_status_t) switch_uuid_generate_version(switch_uuid_t *uuid, int version); +#define switch_uuid_get(uuid) switch_uuid_generate_version(uuid, DEFAULT_UUID_VERSION); /** * Parse a standard-format string into a UUID diff --git a/src/include/switch_utils.h b/src/include/switch_utils.h index a0c91e6384..f0cd0010f8 100644 --- a/src/include/switch_utils.h +++ b/src/include/switch_utils.h @@ -1421,7 +1421,8 @@ SWITCH_DECLARE(void *) switch_calloc(size_t nmemb, size_t size); SWITCH_DECLARE(const char *) switch_inet_ntop(int af, void const *src, char *dst, size_t size); #endif -SWITCH_DECLARE(char *) switch_uuid_str(char *buf, switch_size_t len); +#define switch_uuid_str(buf, len) switch_uuid_str_version(buf, len, DEFAULT_UUID_VERSION); +SWITCH_DECLARE(char *) switch_uuid_str_version(char *buf, switch_size_t len, int version); SWITCH_DECLARE(char *) switch_format_number(const char *num); SWITCH_DECLARE(unsigned int) switch_atoui(const char *nptr); @@ -1518,6 +1519,9 @@ SWITCH_DECLARE(const char *) switch_memory_usage_stream(switch_stream_handle_t * / Compliant random number generator. Returns the value between 0 and 0x7fff (RAND_MAX). **/ SWITCH_DECLARE(int) switch_rand(void); +SWITCH_DECLARE(int) switch_getentropy(void *buffer, switch_size_t length); +SWITCH_DECLARE(switch_status_t) switch_uuid_generate_v7(switch_uuid_t *uuid); +SWITCH_DECLARE(switch_status_t) switch_uuid_generate_v7(switch_uuid_t *uuid); SWITCH_END_EXTERN_C #endif diff --git a/src/mod/applications/mod_commands/mod_commands.c b/src/mod/applications/mod_commands/mod_commands.c index 5b9620a781..8541473fbf 100644 --- a/src/mod/applications/mod_commands/mod_commands.c +++ b/src/mod/applications/mod_commands/mod_commands.c @@ -3162,11 +3162,16 @@ SWITCH_STANDARD_API(tone_detect_session_function) return SWITCH_STATUS_SUCCESS; } +#define UUID_GENERATE_SYNTAX " [4|7]" SWITCH_STANDARD_API(uuid_function) { char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1]; + int version = DEFAULT_UUID_VERSION; + if (!zstr(cmd)) { + version = atoi(cmd); + } - switch_uuid_str(uuid_str, sizeof(uuid_str)); + switch_uuid_str_version(uuid_str, sizeof(uuid_str), version); stream->write_function(stream, "%s", uuid_str); return SWITCH_STATUS_SUCCESS; @@ -7598,7 +7603,7 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_commands_load) SWITCH_ADD_API(commands_api_interface, "cond", "Evaluate a conditional", cond_function, " ? : "); SWITCH_ADD_API(commands_api_interface, "console_complete", "", console_complete_function, ""); SWITCH_ADD_API(commands_api_interface, "console_complete_xml", "", console_complete_xml_function, ""); - SWITCH_ADD_API(commands_api_interface, "create_uuid", "Create a uuid", uuid_function, UUID_SYNTAX); + SWITCH_ADD_API(commands_api_interface, "create_uuid", "Create a uuid", uuid_function, UUID_GENERATE_SYNTAX); SWITCH_ADD_API(commands_api_interface, "db_cache", "Manage db cache", db_cache_function, "status"); SWITCH_ADD_API(commands_api_interface, "domain_data", "Find domain data", domain_data_function, " [var|param|attr] "); SWITCH_ADD_API(commands_api_interface, "domain_exists", "Check if a domain exists", domain_exists_function, ""); diff --git a/src/switch_apr.c b/src/switch_apr.c index bd6cfdec56..703f20903f 100644 --- a/src/switch_apr.c +++ b/src/switch_apr.c @@ -1149,7 +1149,7 @@ SWITCH_DECLARE(void) switch_uuid_format(char *buffer, const switch_uuid_t *uuid) #endif } -SWITCH_DECLARE(void) switch_uuid_get(switch_uuid_t *uuid) +SWITCH_DECLARE(void) switch_uuid_generate_v4(switch_uuid_t *uuid) { switch_mutex_lock(runtime.uuid_mutex); #ifndef WIN32 @@ -1160,6 +1160,21 @@ SWITCH_DECLARE(void) switch_uuid_get(switch_uuid_t *uuid) switch_mutex_unlock(runtime.uuid_mutex); } +SWITCH_DECLARE(switch_status_t) switch_uuid_generate_version(switch_uuid_t *uuid, int version) +{ + switch(version) { + case 4: + switch_uuid_generate_v4(uuid); + break; + case 7: + switch_uuid_generate_v7(uuid); + break; + default: + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ERROR: Unsupported UUID version %d\n", version); + return SWITCH_STATUS_FALSE; + } +} + SWITCH_DECLARE(switch_status_t) switch_uuid_parse(switch_uuid_t *uuid, const char *uuid_str) { #ifndef WIN32 diff --git a/src/switch_utils.c b/src/switch_utils.c index 1293ca3fbd..1d91bbe7b4 100644 --- a/src/switch_utils.c +++ b/src/switch_utils.c @@ -4110,14 +4110,14 @@ SWITCH_DECLARE(int) switch_split_user_domain(char *in, char **user, char **domai } -SWITCH_DECLARE(char *) switch_uuid_str(char *buf, switch_size_t len) +SWITCH_DECLARE(char *) switch_uuid_str_version(char *buf, switch_size_t len, int version) { switch_uuid_t uuid; if (len < (SWITCH_UUID_FORMATTED_LENGTH + 1)) { switch_snprintf(buf, len, "INVALID"); } else { - switch_uuid_get(&uuid); + switch_uuid_generate_version(&uuid, version); switch_uuid_format(buf, &uuid); } @@ -4872,6 +4872,100 @@ SWITCH_DECLARE(int) switch_rand(void) #endif } + +SWITCH_DECLARE(int) switch_getentropy(void *buffer, switch_size_t length) +{ + if (!buffer || length > 256) { // Enforce same limit as `getentropy` + errno = EIO; // Input/Output error + return -1; + } + +#ifdef WIN32 + BCRYPT_ALG_HANDLE hAlgorithm = NULL; + NTSTATUS status = BCryptOpenAlgorithmProvider(&hAlgorithm, BCRYPT_RNG_ALGORITHM, NULL, 0); + + if (!BCRYPT_SUCCESS(status)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "BCryptOpenAlgorithmProvider failed with status %d\n", status); + errno = EIO; // Input/Output error + return -1; + } + + status = BCryptGenRandom(hAlgorithm, (PUCHAR)buffer, (ULONG)length, 0); + if (!BCRYPT_SUCCESS(status)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "BCryptGenRandom failed with status %d\n", status); + BCryptCloseAlgorithmProvider(hAlgorithm, 0); + errno = EIO; // Input/Output error + return -1; + } + + BCryptCloseAlgorithmProvider(hAlgorithm, 0); + return 0; + +#elif defined(__unix__) || defined(__APPLE__) + int random_fd = open("/dev/urandom", O_RDONLY); + switch_ssize_t result; + char error_msg[100]; + + if (random_fd == -1) { + strncpy(error_msg, strerror(errno), sizeof(error_msg) - 1); + error_msg[sizeof(error_msg) - 1] = '\0'; + + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "open failed: %s\n", error_msg); + errno = EIO; // Input/Output error + return -1; + } + + result = read(random_fd, buffer, length); + if (result < 0 || (switch_size_t)result != length) { + strncpy(error_msg, strerror(errno), sizeof(error_msg) - 1); + error_msg[sizeof(error_msg) - 1] = '\0'; + + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "read failed: %s\n", error_msg); + close(random_fd); + errno = EIO; // Input/Output error + return -1; + } + + close(random_fd); + return 0; + +#else + // Fallback: Use rand() for platforms that do not support secure randomness + unsigned char *buf = (unsigned char *)buffer; + for (switch_size_t i = 0; i < length; i++) { + buf[i] = (unsigned char)(rand() & 0xFF); // Generate byte-wise randomness + } + return 0; +#endif +} + + +SWITCH_DECLARE(switch_status_t) switch_uuid_generate_v7(switch_uuid_t *uuid) { + /* random bytes */ + unsigned char *value = uuid->data; + + if (switch_getentropy(value, 16) != 0) { + return -1; + } + + /* current timestamp in ms */ + switch_time_t timestamp = switch_time_now() / 1000; + + // timestamp + value[0] = (timestamp >> 40) & 0xFF; + value[1] = (timestamp >> 32) & 0xFF; + value[2] = (timestamp >> 24) & 0xFF; + value[3] = (timestamp >> 16) & 0xFF; + value[4] = (timestamp >> 8) & 0xFF; + value[5] = timestamp & 0xFF; + + // version and variant + value[6] = (value[6] & 0x0F) | 0x70; + value[8] = (value[8] & 0x3F) | 0x80; + + return SWITCH_STATUS_SUCCESS; +} + /* For Emacs: * Local Variables: * mode:c