Copy link to this section

C3 AI 8.11 Patch Notes

Last updated: October 28, 2026

The following document identifies known issues, known CVEs, and patch fixes in the C3 AI Platform 8.11 release (all these patches are backwards compatible).

Copy link to this section

8.11.7 Patch Notes

• Fixed cloud message source systems so credential lookups reject custom overrides of platform cloud-resource methods instead of running them with elevated privileges.
• Fixed session validation so identifiers from a session token are passed as data, not built into executable code, during cross-app session checks.
• Fixed file system access checks so paths and mount URLs that contain .. segments are rejected, directory listings and presigned URL generation are authorized, and file operations stay within the app's mounts.
• Fixed User.addToGroup, User.addUsersToGroup, User.removeFromGroup, and User.removeUsersFromGroup so they enforce the caller's permissions instead of always authorizing the call.
• Fixed cloud service URL registration so it updates only the app's cloudServiceUrls setting and no longer overwrites other app configuration, such as the root package version, written at the same time.
• Fixed the data sharing compatibility check so it reports when the consumer app does not depend on the producer package, the producer package is not available, or the data lake app cannot be reached, instead of reporting the share as compatible.
• Fixed data sharing so a consumer app can access shared data when the data lake app shares the types under a domain name different from the types' declared domain.
• Fixed Db.Domain.Config.requestAccess so requesting access again after an approval or denial reopens the request with the previous decision cleared.
• Fixed app termination so the terminated app's entries are removed from the data catalog, and added Data.Provider.removeAll to remove the current app's catalog entries.
• Fixed Data.Catalog.add so a field cleared on a data domain, such as its description, is also cleared in the data catalog entry.
• Fixed outbound REST calls so a dropped or stale pooled connection is retried on a new connection and reported as the underlying connection error instead of a NullPointerException.
• Fixed app startup with an external secrets vault so new apps no longer stay unready after an "Unknown file-system scheme: mem" error.
• Added the c3.cluster.metadata.manageNamespace Helm value (default false) so C3 AI Server can create environments without cluster-scoped get permission on Kubernetes namespaces. On clusters with boot config enabled, each environment's namespace must already exist unless the value is set to true.
• Fixed Importable.importData so asynchronous imports queue the correct import spec, and removed the deprecation from importData and ImportDataSpec.retrySingleObjOnFailure.
• Fixed the Studio Start App flow so deploying a built artifact to a multi-node environment uses that artifact's compatible server version.
• Changed the Studio Start App flow so it no longer defaults to Development mode and requires you to choose an application mode.
• Fixed starting an application from a quickstart artifact in Artifact Hub so Studio deploys the quickstart's parent package version.
• Fixed the Artifact Hub Push Upstream action so it registers the artifact upstream.
• Fixed the Artifact Hub versions list so deleted artifacts disappear without a manual refresh.
• Fixed the Data Fusion Configure GitHub dialog so it no longer fails with a server error when the environment has no GitHub authentication, and so it skips ahead when GitHub is already configured.
• Added separate error messages to the Data Fusion Configure GitHub dialog for an unreachable GitHub URL, an invalid token, and a token without enough permissions.
• Fixed Data Fusion connections so clearing an optional connection property, such as the Databricks database, persists when you save.
• Fixed Databricks table discovery in Data Fusion so it lists tables from every schema the connection can access instead of only the default schema.
• Changed DataLakeSourceCollection to resolve its table by catalog, namespace, and name at run time so a packaged collection works in every environment.
• Fixed the Object Model so changing the package filter marks the view as unsaved and Reset restores the saved package selection.
• Fixed the Object Model graph so an entity added to a new package appears in its package group without a page reload.
• Rounded the memory-used percentage to two decimal places in the ExMachina Spark cluster selection dialog.
• Changed the 128 GB ExMachina cluster size to four 32 GB executors so it provisions reliably.
• Updated the browser VS Code image to 0.5.5, which includes C3 AI VS Code extension 4.3.5 with an upgraded axios library.
• Fixed the C3.Code.Admin role so it grants every permission C3 Code administrators need without also assigning C3.Code.User.
• Changed C3 Code chat so prompts queued while the agent asks a question are held instead of being sent as the answer. The queue shows a paused indicator and a Resume button.
• Fixed the Workspaces table on the C3 Code My Usage and Cost page so deleted workspaces show their last-known name with a Removed label, and added search, sorting, and pagination to the table.
• Fixed date inputs on the C3 Code My Usage and Cost page so the calendar icon and pop-up follow dark mode, and fixed chart date labels that were cut off.
• Added a scheduled job that removes pre-provisioned C3 Code workspaces and applications no longer tracked by a pool, and added an Enable reconciler button for cluster admins on the Pre-provisioning admin page.
• Changed C3 Code collaborator, share, and resource-request emails to send from a configurable system address (default noreply@c3.ai) so invitations from users on other email domains no longer fail.
• Renamed the Data Integration tab on the C3 Code workspace Configure page to Data Monitoring.
• Fixed C3 Code LLM cost tracking so each chat turn is charged only for its own cost. Continuing a chat session, including another user's, no longer charges the session's earlier cost again.
• Fixed an intermittent error when claiming a pre-provisioned C3 Code workspace that had been idle for several hours.
• Fixed the C3 Code agent model list in the chat panel so it scrolls on small screens.
• Fixed choosing Start from a C3 Code workspace card's menu so the card shows the starting state at once and the actual error appears if the start fails.
• Fixed connecting a new C3 Code application to an existing repository so the preview no longer fails with "Error occurred while trying to proxy". C3 Code now checks the package path, pulls the selected branch, and offers to create a new application when the package name differs.
• Fixed C3 Code workspaces so they start on a branch with a UI lint or compile error, and the preview shows the UI error so it can be fixed.
• Added a dismissible warning in the C3 Code chat panel at 75% and 90% of your monthly LLM budget. It updates as you send messages and reappears when your budget is raised.
• Fixed a misconfigured GitHub OAuth App sending C3 Code users to a GitHub error page. C3 Code now offers OAuth sign-in only when the app is set up correctly, and the admin Health page reports its status.
• Fixed C3 Code dialogs closing when you press the mouse inside and release it outside, for example while selecting text.
• Updated the starter code in all C3 Code application templates to use the c3Call helper for backend calls.
• Fixed applications built from C3 Code templates showing a generic error in place of the server's error message.
• Fixed the C3 Code agent leaving the preview broken after fixing a UI error; it now restarts the stopped dev server.
• Fixed the C3 Code agent creating types or fields whose names clash with platform names, which caused "does not declare field" errors when loading data.
• Fixed the C3 Code agent declaring parent-child relationships incorrectly, which caused "Required field ... not set" errors when loading data.
• Fixed the C3 Code agent adding nonexistent or incorrect mixins to type declarations.
• Fixed LLM completion calls generated by the C3 Code agent failing with "can only be called natively from" errors.
• Fixed pages generated by the C3 Code agent displaying raw {type, value} objects because backend methods declared untyped return values.
• Fixed the C3 Code agent creating an incomplete React frontend without package.json, which stopped the preview from building.
• Fixed pages generated by the C3 Code agent that could stay stuck loading because of an unsafe cancellation pattern in React effects.
• Fixed the C3 Code agent giving unopenable file paths or localhost links for downloadable files; it now provides a temporary download link.
• Fixed the C3 Code agent styling primary buttons and selected items with a pale background instead of the solid brand color.
• Patched CVE-2026-34477 and CVE-2026-34480 (log4j-core).
• Patched CVE-2026-107725 and CVE-2026-107726 (Hazelcast).
• Patched CVE-2026-85721, CVE-2026-107231, and CVE-2026-107282 (async-http-client).
• Patched CVE-2026-75140 (jsoup), CVE-2025-27553 (commons-vfs2), CVE-2025-11965 (vertx-web), and CVE-2026-102834 (JavaCV).
• Patched CVE-2026-54873, CVE-2026-63073, CVE-2026-72897, CVE-2026-75803, CVE-2026-84782, and CVE-2026-84784 (OpenSSL).
• Patched CVE-2026-19445, CVE-2026-19553, and CVE-2026-82049 (Python).
• Patched CVE-2026-6357 (pip) in the server's conda environment and the bundled Python runtime definitions.
• Patched CVE-2026-63374 (anyio), CVE-2026-102268 (PyJWT), CVE-2026-69247 (cryptography), and CVE-2026-97687 and CVE-2026-97689 (urllib3).
• Patched GHSA-6q48-6c7w-9gw2 (certifi).
• Patched CVE-2026-85091 (zlib).
• Patched CVE-2026-102276 and CVE-2026-102278 (brace-expansion), CVE-2026-19534 (undici), and CVE-2026-93748 (http-cache-semantics) in the bundled npm.
• Patched CVE-2026-56855 and CVE-2026-78662 (golang.org/x/crypto) in the bundled Helm binary.
• Patched CVE-2026-42271, CVE-2026-49468, and CVE-2026-59822 (LiteLLM) in the C3 Code agent image.

Copy link to this section

8.11.6 Patch Notes

• Fixed the Data Sharing Discover tab so the Refresh button updates the "Has Access" status column.
• Corrected the Data Fusion package filter so it hides Transform and unstructured data-integration nodes.
• Fixed the Object Model so removing a package from the filter hides only that package's types instead of re-laying out the whole graph.
• Changed the C3 Code agent so it no longer prompts for permission to read c3pkg.json and c3pkg.lock; only edits prompt.
• Added a C3 Code skill for configuring email delivery through SendGrid.
• Made Opus 5.5 the default C3 Code agent model.
• Fixed silent connection drops on outbound HTTP calls in C3 Code.
• Improved C3 Code usage and billing metrics so they tolerate Studio call timeouts.
• Added automated cleanup of orphaned Cassandra keyspaces and Postgres databases.
• Fixed a null-reference error in JupyterLab resource-profile handling.
• Patched CVE-2026-18401 (jackson-core) and CVE-2026-68497 (jackson-databind).

Copy link to this section

8.11.5 Patch Notes

• Added a health-checklist admin page for C3 Code.
• Corrected GitHub authentication when pushing changes so commits are attributed to the correct author.
• Restored the ability to use MCP in Ask mode.
• Changed the WebFetch tool so it no longer prompts for permission on every call in Agent mode.
• Corrected the C3 Code share-preview flow to show a clear error instead of a raw 401.
• Guarded agent edits to c3pkg manifest and lock files so they require explicit confirmation.
• Fixed Studio tool tabs so they survive a browser refresh.
• Preserved the File Explorer action toolbar in the embedded Studio.
• Simplified the Contact Support form and promoted it to a header button.
• Added pagination and refresh to the pre-provisioning admin tables, including the Invalidate All action.
• Corrected dark-theme rendering of the pre-provisioning tables.
• Fixed the billing compute chart so it shows all data and reflects the selected filters.
• Fixed the My Usage and Cost page so data persists across time-range changes and unselected models stay visible in the filter.
• Replaced the shared-database toggle with datastore request fields in the start-environment flow.
• Hid the add-user and remove-user actions for inactive user groups.
• Added the Data Quality Analyst and Ad-Hoc Reporting Analyst roles to Studio page access.
• Excluded the package lock file from C3 Code template artifact archives.
• Corrected Jsn.zipMerge so it no longer truncates configuration and secret arrays.
• Included the target version in the Studio Activity Log upgrade message.
• Resolved a null-reference error in User#invalidateSessions for users with Studio user groups.
• Added server-version validation to environment creation, resolving a null-reference error in StudioCluster.startEnv().
• Strengthened privileged-action enforcement across the Platform, including a confused-deputy fix in the Cloud Message layer.
• Reduced the Data Fusion Edit Source System modal load time.
• Corrected the Data Fusion Change Connector flow so selecting Postgres advances to the Destination step.
• Restored the ability to page through more than 100 records in the Object Model data preview.
• Fixed the Object Model so the package-filter selection is saved when creating or saving a view.
• Fixed broken breadcrumb links in Visual Notebooks.
• Corrected catalog handling so Hadoop and JDBC catalogs are accepted.
• Patched CVE-2026-75596 (Netty).
• Patched CVEs in the bundled jackson and async-http-client libraries (Java).
• Patched CVEs in the bundled golang.org/x/crypto library.
• Patched CVEs in the Jupyter, istio, and base container images.

Copy link to this section

8.11.4 Patch Notes

• Resolved a C3 Code error when sharing a workspace with collaborators.
• Corrected C3 Code workspace startup so workspaces no longer fail when artifact versions cannot be resolved, including pre-provisioned workspaces affected by package-lock.json conflicts.
• Fixed connecting to an existing GitHub repository in C3 Code.
• Fixed C3 Code workspace creation so a missing template artifact returns a clear error instead of an HTTP 500.
• Fixed an error when deleting C3 Code workspaces, and corrected agent connection handling when starting an application from a template.
• Fixed follow-up questions asked by the agent in C3 Code chat, a stream error when a deleted chat was reopened, and expanded step content that was not visible.
• Fixed scrolling on the C3 Code Configure tab.
• Fixed a permission issue that prevented users from starting a new chat session in an app.
• Corrected deployment so administrators added while a deployment is stopped can deploy.
• Fixed downloading a C3 Code application artifact from Release Management.
• Resolved an ExMachina Visual Notebooks issue where an empty canvas showed a loading indicator that never cleared.
• Corrected Data Fusion so an uploaded credential key file, such as a GCP service account JSON, populates the connector authentication fields.
• Corrected orphan cleanup so it no longer deletes valid CloudService instances when the service listing exceeds 2,000 entries.
• Improved dark-theme accessibility for error messages.
• Patched CVE-2026-75595 (Netty).
• Updated the external-secrets operator to remediate CVEs.

Copy link to this section

8.11.3 Patch Notes

• Fixed an ACL being removed from a referenced type.
• Fixed Medusa not cleaning up snapshots from disk, which caused disk usage growth.
• Improved pkgStoreLocal to seed and refresh validation issues from Pkg.Store instead of the .vs-cache.
• Fixed environments failing to stop, with threads blocked, after adding a dependency.
• Rebased the Chainguard server image (backported to 8.11).
• Removed the Generate PDF link in Stories.
• Added support for configurable user groups on an application.
• Patched CVEs in org.apache.httpcomponents.core5:httpcore5 (Java).
• Fixed StudioApp#endpoint returning the wrong canonical URL for the Canvas and Workflows tabs, which caused an Okta login page to appear.
• Backported setTimeHorizon in PsrWorkflowRunner to 8.11 and 8.10.
• Restored SourceFile/SourceStatus database indexes that were lost during an automerge.
• Exposed JupyterHub NetworkPolicy configuration (egress rules and a disable option).
• Fixed OpenSearch @timestamp corruption from a grok-parse-failure fallback that caused gaps in the log timeline.
• Patched CVE-2026-56740 and CVE-2026-56741 (jline).

[!NOTE] Don't deploy C3 Code on this patch version.

Copy link to this section

8.11.2 Patch Notes

• Patched CVEs in bundled platform dependencies.
• Updated the image puller and the Python and Spark components of the Vector Analytics Daemon image to pick up the latest security fixes.
• Enabled identity provider (IdP) logout for OIDC, so signing out of C3 AI Platform also ends the upstream identity provider session.
• Corrected the ActionCtxFilter.userName definition so it matches its filtering behavior, making action-context queries return the expected results.
• Ensured Db.Engine queue and cron processing continues uninterrupted after an instance cache eviction, keeping scheduled and queued work flowing.
• Resolved an issue where PartitionableCompactor crons were unexpectedly set to active and cron inputs were cleared, preserving configured compaction schedules.
• Reduced Cassandra load by decoupling the shared database flag, improving overall data store throughput and stability.
• Corrected file access so that gzip-compressed files with correctly set metadata are read successfully.
• Restored Spark.DataFrame.to_spark and SparkSession.fromSpark, so conversions between C3 AI Platform and native Spark DataFrames work as documented.
• Improved Spark Connect reliability so createOrReplaceTempView completes successfully rather than terminating with a gRPC stream error.
• Added email as a supported notification channel for Data Validation, so validation results can be delivered directly to stakeholders.
• Added Kafka offset persistence for billing analytics in the exporter, making usage metering resilient across restarts.
• Smoothed the 8.10 to 8.11 upgrade path for environments that moved containers to init containers, allowing those environments to upgrade in place.
• Ensured the CPU usage metric is consistently available on the Monitoring tab when creating a new alert rule.
• Improved styling on the Data Sharing page for a cleaner, more consistent presentation.
• Made the default application MCP server name unique to each application, preventing collisions across applications in the same environment.
• Enabled document parsing to run successfully in air-gapped environments, with corrected file paths and environment variables.
• Restored backward compatibility for Data Fusion Studio, so 8.8 applications continue to resolve Genai.SourceCollection on 8.11.
• Restored visualizations and citations in generative AI responses.

Copy link to this section

8.11.1 Patch Notes

• Fixed C3 REPL regressions in C3 Code.
• Removed an unnecessary platform version check on artifact downloads.
• Added a granular refresh of ClusterCtx App/Env caches to resolve a startup bottleneck in large clusters.
• Fixed Feature.merge() intermittently failing with a Seed Data error, caused by a missing actualize field in the stored EvalSpec.
• Fixed evalMetricsWithMetadata MONTH interval generating 30-day fixed timestamps instead of calendar month boundaries.
• Fixed skipFields not being accepted from BatchExportSpec.
• Fixed a NullPointerException in Feature.Set.CreateSnapshotJob.
• Added nodepool targeting support for Jupyter resources.
• Fixed a dedicated-instance flag being set incorrectly when using a shared database.
• Fixed selecting the Load Dataset node causing a rapid, infinite sequence of repeated requests to the server.
• Upgraded code-server to 4.130.
• Fixed the Data Fusion "+ Add Data Source" connector modal cold-load time, bringing it in line with the platform's ~3 second SLA.
• Fixed creating a CloudMessageSourceSystem merging existing SqlSourceSystem and FileSourceSystem unconfigured nodes into a single node.
• Fixed C3.StudioAdmin incorrectly nesting C3.StudioUser.
• Fixed the Terminate All Executors modal.
• Fixed MCP Access "Generate & Install" writing a relative URL instead of the app's absolute URL into the generated MCP client config.
• Patched vulnerabilities in the image-puller image.
• Fixed a Log4j2 ForwardingAppender recursive call that could permanently disable c3-server-log structured logging.
• Fixed the Apps grid showing the MNE icon instead of SNE for app-only users.
• Fixed a stale Pkg.Issue that never cleared.
• Fixed file upload to a source collection auto-triggering processing; ingestion is now a separate, explicit user action.
• Fixed the Add Users form in User Management not rejecting invalid user identifiers.
• Fixed the Git connection status showing as connected even with an incorrect token.
• Fixed Grafana returning a 404 Not Found error after upgrading the C3 aiOps version.
• Fixed Cluster Admins being unable to see User Management details.
• Fixed the dynamic chat tab title no longer updating.
• Added the C3 telemetry exporter and the underlying telemetry framework (cache, refresh, scrape, and produce).
• Fixed an issue that prevented bundling applications.
• Fixed application users being able to deploy when they should not have that permission.

Copy link to this section

8.11.0 Known Common Vulnerabilities and Exposures (CVE)

C3 AI has accounted for all critical vulnerabilities and maintains a stringent internal patching policy. At this time, there are no critical vulnerabilities for C3 AI developed code. For open-source code vulnerabilities (CVEs), Critical and High issues are patched once fixes are available. In the interim, C3 AI provides mitigation remedies and statements as part of the patch notes. Vulnerabilities in open-source and third-party containers are remediated when new versions addressing the vulnerabilities are available and have been tested internally.

Copy link to this section

General CVEs

CVE ID	Problem Title	C3 AI Severity Rating	Mitigation Statement
CVE-2025-15467	Parsing CMS AuthEnvelopedData or EnvelopedData message with maliciously crafted AEAD parameters can trigger a stack buffer overflow.	High	Expand Denial of Service (DoS) conditions arise when an attacker overwhelms a system with excessive requests or consumes critical resources—such as memory, CPU, or bandwidth—resulting in degraded performance or complete service outage. These attacks may be executed via long-lived sessions, malformed traffic, or automated request floods, posing significant threats to business continuity and user accessibility. The C3 AI Platform addresses these threats through a layered defense strategy: * Session Isolation: Scoped, time-bound tokens ensure that each session is securely contained and cannot be reused or hijacked. * Rate Limiting: Enforced across service interfaces to throttle excessive or anomalous request patterns. * Load Distribution: Traffic is balanced across nodes to prevent bottlenecks and isolate failure domains. * Cache Consistency Controls: Safeguards against stale data propagation that could compromise system integrity. * Web Application Firewall (WAF): Filters malformed and high-volume requests before they reach application endpoints. * Timeout Enforcement & Telemetry: Real-time monitoring detects traffic anomalies and enforces session timeouts to preempt resource exhaustion. Together, these controls ensure high availability and resilience under stress, protecting the platform from operational disruption and resource depletion.
CVE-2025-26625	Git LFS is a Git extension for versioning large files.	High	Expand Data leakage and tampering occur when sensitive information is exposed to unauthorized parties or when application data and protocol messages are modified to bypass controls or execute malicious code. In C3-built containers, the C3 AI Platform mitigates both through strict type system enforcement, which validates application-level data and messages, rejects untyped or malformed inputs, and constrains what fields can be requested or returned—preventing both protocol tampering and unintended disclosure. Highly sensitive information is protected by C3 Vault and application-level encryption (@PII(encrypt=true)), with data-at-rest encryption and hierarchical key management (KEK/DEK). Instances are strictly isolated at the network (segmentation, authenticated and encrypted service-to-service communication), compute, and runtime (scoped, ephemeral session tokens) levels, preventing cross-instance access, tampering, and lateral exfiltration. RBAC, TLS-encrypted transit, audit logging, real-time telemetry, and WAF protections further preserve data integrity and confidentiality against unauthorized modification, access, or exfiltration.
CVE-2025-48734	Apache Commons Improper Access Control vulnerability	High	Expand Privilege escalation occurs when an attacker gains elevated access rights by exploiting misconfigured roles, insecure APIs, or flaws in access control mechanisms. In C3-built containers, such exploitation can result in unauthorized access to sensitive resources, manipulation of system configurations, or disruption of platform operations. The C3 AI Platform addresses these threats through strict access governance and layered security controls: * Role-Based Access Control (RBAC): Enforces least-privilege principles and restricts role modifications and nested assignments to authorized entities. * Fine-Grained Access Control: Implemented via AclEntry and AclPrivilege models to tightly scope permissions based on user roles and operational context. * Web Application Firewall (WAF): Blocks unauthorized access attempts and injection vectors targeting privilege boundaries. * Strict TypeSystem Enforcement: Validates API message structures and drops any request that deviates from its declared schema, preventing privilege manipulation via malformed inputs. * Session Isolation: Limits exposure windows for elevated access attempts by enforcing scoped, time-bound session tokens. These controls ensure that access rights within C3-built containers are tightly scoped, traceable, and resilient against unauthorized privilege elevation—preserving operational integrity and protecting sensitive platform resources.
CVE-2025-55131	A flaw in Node.js's buffer allocation logic can expose uninitialized memory when allocations are interrupted, when using the vm module with the timeout option.	High	Expand Data leakage in C3-built containers occurs when sensitive information is exposed through improper access controls, insufficient encryption, or misconfigured data handling pathways. Such exposure can result in unauthorized access to application data, credentials, or internal system state. The C3 AI Platform addresses data leakage risks in C3-built containers through layered security controls: * Application-Level Encryption: Sensitive fields are protected using @PII(encrypt=true) annotations, enforcing encryption at the data model level independently of transport mechanisms. * Vault-Based Key Management: Secrets and credentials are centrally managed via C3 Vault, ensuring encrypted storage and scoped access. * Role-Based Access Control (RBAC): Enforces least-privilege principles to restrict access to sensitive data and operations. * Network Segmentation: Containers reside in isolated execution environments with network access control lists (NACLs) and cloud provider security groups, minimizing lateral movement and data exposure. * Encrypted Communications: All service-to-service communication is authenticated and encrypted, preventing interception or exfiltration of data in transit. * Web Application Firewall (WAF): Filters requests targeting data extraction endpoints and blocks common exfiltration techniques. * Audit Logging and Real-Time Telemetry: Provide visibility into data access patterns and anomalous flows, enabling rapid detection of leakage attempts. These controls collectively ensure that sensitive data within C3-built containers remains protected against unauthorized access and exfiltration, preserving confidentiality across operational environments.
CVE-2025-59728	When calculating the content path in handling of MPEG-DASH manifests, there's an out-of-bounds NUL-byte write one byte past the end of the buffer.	High	Expand Buffer overflow vulnerabilities occur when a program writes more data to a memory buffer than it can accommodate, potentially overwriting adjacent memory regions. This can enable attackers to execute arbitrary code, crash services, or escalate privileges. In C3-built containers, such threats may stem from unsafe memory operations, unbounded input handling, or insufficient runtime protections. The C3 AI Platform employs a multi-layered defense strategy to prevent buffer overflow exploitation: * Address Space Layout Randomization (ASLR): Randomizes memory address allocations to disrupt predictable targeting and reduce exploit reliability. * Kernel-Level Stack and Heap Protections: Enforces memory integrity at runtime, blocking low-level corruption attempts. * Role-Based Access Control (RBAC): Restricts access to memory-sensitive operations and enforces least-privilege principles. * Input Validation via C3 AI TypeSystem: Ensures safe memory usage by validating inputs during runtime, addressing threats from malformed or excessive data. * Logical Container Isolation: Containers are segmented using network access control lists (NACLs) and cloud provider security groups, minimizing lateral movement and reducing the attack surface. * FIPS 140-2-Compliant Encryption: All data is encrypted at rest and in transit using validated cryptographic modules, preserving confidentiality and integrity. * Multi-Factor Authentication (MFA): Enforced for privileged users and administrators to prevent unauthorized access and exploitation of memory-related vulnerabilities. These controls collectively safeguard C3-built containers against memory corruption and unauthorized code execution, ensuring platform stability and data integrity.
CVE-2025-66414	Model Context Protocol (MCP) TypeScript SDK does not enable DNS rebinding protection by default	High	Expand DNS-based attacks can exploit weaknesses in name resolution, hostname verification, or DNS protocol handling—potentially enabling network interface spoofing, traffic redirection, or unauthorized access to platform services. To reduce the risk of exploitation, the C3 AI Platform relies on security-assured service meshes and DNS infrastructure, restricts direct exposure of internal resolution paths, and routes service connectivity through authenticated and encrypted channels with RBAC enforcement. Strict validation of application-layer messages and hostname or endpoint identity further limits the impact of spoofed or malformed DNS-related traffic, while the WAF blocks common network exploitation techniques. Audit logs provide traceability for DNS- and network-related transactions. Additionally, the platform enforces multiple layers of security that further mitigate risks associated with authorization and access control: * Role-Based Access Control (RBAC) ensures that permissions are tightly scoped and enforced at runtime. * Vault-Based Key Management secures cryptographic keys and secrets, preventing unauthorized access. * Application-Level Encryption protects sensitive data independently of transport or authentication mechanisms. * Audit Logging and WAF provide visibility and protection against unauthorized access attempts. These controls collectively ensure that name-resolution and endpoint identity decisions within the C3 AI Platform are made securely and traceably, without undue reliance on unvalidated DNS or callback mechanisms.
CVE-2025-68121	During session resumption in crypto/tls, if the underlying Config has its ClientCAs or RootCAs fields mutated between the initial handshake and the resumed handshake, the resumed h...	High	Expand Web application security in C3-built containers is essential for protecting user data and platform integrity. To reduce the risk of exploitation, the platform applies RBAC, WAF, strict type validation, and session isolation. API endpoints are protected against injection, privilege escalation, and data leakage, while audit logging and real-time telemetry provide continuous monitoring. Load distribution and timeout enforcement help maintain secure and reliable web application operations.
CVE-2025-69419	Calling PKCS12_get_friendlyname() function on a maliciously crafted PKCS#12 file with a BMPString (UTF-16BE) friendly name containing non-ASCII BMP code point can trigger a one byt...	High	Expand Buffer overflow vulnerabilities occur when a program writes more data to a memory buffer than it can accommodate, potentially overwriting adjacent memory regions. This can enable attackers to execute arbitrary code, crash services, or escalate privileges. In C3-built containers, such threats may stem from unsafe memory operations, unbounded input handling, or insufficient runtime protections. The C3 AI Platform employs a multi-layered defense strategy to prevent buffer overflow exploitation: * Address Space Layout Randomization (ASLR): Randomizes memory address allocations to disrupt predictable targeting and reduce exploit reliability. * Kernel-Level Stack and Heap Protections: Enforces memory integrity at runtime, blocking low-level corruption attempts. * Role-Based Access Control (RBAC): Restricts access to memory-sensitive operations and enforces least-privilege principles. * Input Validation via C3 AI TypeSystem: Ensures safe memory usage by validating inputs during runtime, addressing threats from malformed or excessive data. * Logical Container Isolation: Containers are segmented using network access control lists (NACLs) and cloud provider security groups, minimizing lateral movement and reducing the attack surface. * FIPS 140-2-Compliant Encryption: All data is encrypted at rest and in transit using validated cryptographic modules, preserving confidentiality and integrity. * Multi-Factor Authentication (MFA): Enforced for privileged users and administrators to prevent unauthorized access and exploitation of memory-related vulnerabilities. These controls collectively safeguard C3-built containers against memory corruption and unauthorized code execution, ensuring platform stability and data integrity.
CVE-2025-9951	A heap-buffer-overflow write exists in jpeg2000dec FFmpeg which allows an attacker to potentially gain remote code execution or cause denial of service via the channel definition c...	High	Expand ThisVuln ID affects theapplication protocol implemented that are validated in C3 AI's Java runtime environment. The decoder uses a deserialization protocol allowing attackers to send malicious serialized data that could lead toremote code execution (RCE). The C3 AI Platform’s architecture includes multiple layers of defense that risks associated with unsafe deserialization: * Application-Level EncryptionandRBACprevent unauthorized access to sensitive data and restrict execution privileges. * Vault-Based Key Managementensures that secrets and credentials are securely stored and accessed only by authorized services. * Audit LoggingandWAFprovide visibility and protection against suspicious payloads and malformed requests bypassing the WAF would require additional privileges in the platform * Type System for Application-Level Message or Protocol Tampering: C3 AI's type system in C3 server ensures that application-level messages and protocols are strictly validated, preventing tampering and ensuring data integrity. This helps mitigate the risk of request smuggling and other protocol-related attacks. significantly reducing the risks of processing untrusted data. *Network Segmentation: All c3server container instances reside in highly isolated execution environments within the C3 AI Platform. This network segmentation minimizes lateral movement and the scope of potential exploitation, ensuring that attacks are contained within a narrow blast radius. These controls collectively reduce the risk of deserialization-based RCE, even in cases where third-party libraries are integrated.
CVE-2026-0861	Passing too large an alignment to the memalign suite of functions (memalign, posix_memalign, aligned_alloc, valloc, pvalloc) in the GNU C Library version 2.30 to 2.42 may result in...	High	Expand Buffer overflow vulnerabilities occur when a program writes more data to a memory buffer than it can accommodate, potentially overwriting adjacent memory regions. This can enable attackers to execute arbitrary code, crash services, or escalate privileges. In C3-built containers, such threats may stem from unsafe memory operations, unbounded input handling, or insufficient runtime protections. The C3 AI Platform employs a multi-layered defense strategy to prevent buffer overflow exploitation: * Address Space Layout Randomization (ASLR): Randomizes memory address allocations to disrupt predictable targeting and reduce exploit reliability. * Kernel-Level Stack and Heap Protections: Enforces memory integrity at runtime, blocking low-level corruption attempts. * Role-Based Access Control (RBAC): Restricts access to memory-sensitive operations and enforces least-privilege principles. * Input Validation via C3 AI TypeSystem: Ensures safe memory usage by validating inputs during runtime, addressing threats from malformed or excessive data. * Logical Container Isolation: Containers are segmented using network access control lists (NACLs) and cloud provider security groups, minimizing lateral movement and reducing the attack surface. * FIPS 140-2-Compliant Encryption: All data is encrypted at rest and in transit using validated cryptographic modules, preserving confidentiality and integrity. * Multi-Factor Authentication (MFA): Enforced for privileged users and administrators to prevent unauthorized access and exploitation of memory-related vulnerabilities. These controls collectively safeguard C3-built containers against memory corruption and unauthorized code execution, ensuring platform stability and data integrity.
CVE-2026-0915	Calling getnetbyaddr or getnetbyaddr_r with a configured nsswitch.conf that specifies the library's DNS backend for networks and queries for a zero-valued network in the GNU C Libr...	High	Expand Data leakage in C3-built containers occurs when sensitive information is exposed through improper access controls, insufficient encryption, or misconfigured data handling pathways. Such exposure can result in unauthorized access to application data, credentials, or internal system state. The C3 AI Platform addresses data leakage risks in C3-built containers through layered security controls: * Application-Level Encryption: Sensitive fields are protected using @PII(encrypt=true) annotations, enforcing encryption at the data model level independently of transport mechanisms. * Vault-Based Key Management: Secrets and credentials are centrally managed via C3 Vault, ensuring encrypted storage and scoped access. * Role-Based Access Control (RBAC): Enforces least-privilege principles to restrict access to sensitive data and operations. * Network Segmentation: Containers reside in isolated execution environments with network access control lists (NACLs) and cloud provider security groups, minimizing lateral movement and data exposure. * Encrypted Communications: All service-to-service communication is authenticated and encrypted, preventing interception or exfiltration of data in transit. * Web Application Firewall (WAF): Filters requests targeting data extraction endpoints and blocks common exfiltration techniques. * Audit Logging and Real-Time Telemetry: Provide visibility into data access patterns and anomalous flows, enabling rapid detection of leakage attempts. These controls collectively ensure that sensitive data within C3-built containers remains protected against unauthorized access and exfiltration, preserving confidentiality across operational environments.
CVE-2026-1580	A security issue was discovered in ingress-nginx where the nginx.ingress.kubernetes.io/auth-method Ingress annotation can be used to inject configuration into nginx.	High	Expand Data leakage in C3-built containers occurs when sensitive information is exposed through improper access controls, insufficient encryption, or misconfigured data handling pathways. Such exposure can result in unauthorized access to application data, credentials, or internal system state. The C3 AI Platform addresses data leakage risks in C3-built containers through layered security controls: * Application-Level Encryption: Sensitive fields are protected using @PII(encrypt=true) annotations, enforcing encryption at the data model level independently of transport mechanisms. * Vault-Based Key Management: Secrets and credentials are centrally managed via C3 Vault, ensuring encrypted storage and scoped access. * Role-Based Access Control (RBAC): Enforces least-privilege principles to restrict access to sensitive data and operations. * Network Segmentation: Containers reside in isolated execution environments with network access control lists (NACLs) and cloud provider security groups, minimizing lateral movement and data exposure. * Encrypted Communications: All service-to-service communication is authenticated and encrypted, preventing interception or exfiltration of data in transit. * Web Application Firewall (WAF): Filters requests targeting data extraction endpoints and blocks common exfiltration techniques. * Audit Logging and Real-Time Telemetry: Provide visibility into data access patterns and anomalous flows, enabling rapid detection of leakage attempts. These controls collectively ensure that sensitive data within C3-built containers remains protected against unauthorized access and exfiltration, preserving confidentiality across operational environments.
CVE-2026-23949	jaraco.context Has a Path Traversal Vulnerability	High	Expand Web application security in C3-built containers is essential for protecting user data and platform integrity. To reduce the risk of exploitation, the platform applies RBAC, WAF, strict type validation, and session isolation. API endpoints are protected against injection, privilege escalation, and data leakage, while audit logging and real-time telemetry provide continuous monitoring. Load distribution and timeout enforcement help maintain secure and reliable web application operations.
CVE-2026-2447	Heap buffer overflow in libvpx.	High	Expand Buffer overflow vulnerabilities occur when a program writes more data to a memory buffer than it can accommodate, potentially overwriting adjacent memory regions. This can enable attackers to execute arbitrary code, crash services, or escalate privileges. In C3-built containers, such threats may stem from unsafe memory operations, unbounded input handling, or insufficient runtime protections. The C3 AI Platform employs a multi-layered defense strategy to prevent buffer overflow exploitation: * Address Space Layout Randomization (ASLR): Randomizes memory address allocations to disrupt predictable targeting and reduce exploit reliability. * Kernel-Level Stack and Heap Protections: Enforces memory integrity at runtime, blocking low-level corruption attempts. * Role-Based Access Control (RBAC): Restricts access to memory-sensitive operations and enforces least-privilege principles. * Input Validation via C3 AI TypeSystem: Ensures safe memory usage by validating inputs during runtime, addressing threats from malformed or excessive data. * Logical Container Isolation: Containers are segmented using network access control lists (NACLs) and cloud provider security groups, minimizing lateral movement and reducing the attack surface. * FIPS 140-2-Compliant Encryption: All data is encrypted at rest and in transit using validated cryptographic modules, preserving confidentiality and integrity. * Multi-Factor Authentication (MFA): Enforced for privileged users and administrators to prevent unauthorized access and exploitation of memory-related vulnerabilities. These controls collectively safeguard C3-built containers against memory corruption and unauthorized code execution, ensuring platform stability and data integrity.
CVE-2026-24512	A security issue was discovered in ingress-nginx where the rules.http.paths.path Ingress field can be used to inject configuration into nginx.	High	Expand Data leakage in C3-built containers occurs when sensitive information is exposed through improper access controls, insufficient encryption, or misconfigured data handling pathways. Such exposure can result in unauthorized access to application data, credentials, or internal system state. The C3 AI Platform addresses data leakage risks in C3-built containers through layered security controls: * Application-Level Encryption: Sensitive fields are protected using @PII(encrypt=true) annotations, enforcing encryption at the data model level independently of transport mechanisms. * Vault-Based Key Management: Secrets and credentials are centrally managed via C3 Vault, ensuring encrypted storage and scoped access. * Role-Based Access Control (RBAC): Enforces least-privilege principles to restrict access to sensitive data and operations. * Network Segmentation: Containers reside in isolated execution environments with network access control lists (NACLs) and cloud provider security groups, minimizing lateral movement and data exposure. * Encrypted Communications: All service-to-service communication is authenticated and encrypted, preventing interception or exfiltration of data in transit. * Web Application Firewall (WAF): Filters requests targeting data extraction endpoints and blocks common exfiltration techniques. * Audit Logging and Real-Time Telemetry: Provide visibility into data access patterns and anomalous flows, enabling rapid detection of leakage attempts. These controls collectively ensure that sensitive data within C3-built containers remains protected against unauthorized access and exfiltration, preserving confidentiality across operational environments.
CVE-2026-31431	In the Linux kernel, the following vulnerability has been resolved: crypto: algif_aead - Revert to operating out-of-place This mostly reverts commit 72548b093ee3 except for the cop...	High	Expand Isolated memory safety attacks in peripheral container environments can occur when minimal runtime protections allow attackers to exploit memory allocation flaws or session persistence. In peripheral containers, the risk is reduced by design, but improper privilege scoping or runtime misconfiguration could still expose memory vulnerabilities. Within the C3 AI Platform, peripheral containers are deployed with de-privileged rights and runtime isolation to prevent unauthorized access to memory regions. Additional security features include: * Kubernetes namespace isolation and firewall group restrictions to contain runtime behavior * RBAC enforcement and seccomp profiles to limit system calls and memory-sensitive operations * Medium- and low-value assets are deployed on peripheral containers with tightly controlled access and limited interface exposure These controls ensure that peripheral containers within C3 AI operate with hardened memory boundaries, protecting against isolated memory safety attacks and maintaining secure container execution.
CVE-2026-31663	In the Linux kernel, the following vulnerability has been resolved: xfrm: hold dev ref until after transport_finish NF_HOOK After async crypto completes, xfrm_input_resume() calls...	High	Expand Isolated memory safety attacks target containerized environments by exploiting flaws such as uninitialized memory access, buffer mismanagement, or improper session handling. In C3-built containers, these vulnerabilities can lead to unauthorized memory access, data corruption, or privilege escalation if runtime protections are not enforced. The C3 AI Platform prevents these risks by applying session isolation using scoped, ephemeral tokens and enforcing kernel-level stack and heap protections. Additional security features include: * Address Space Layout Randomization (ASLR) to randomize memory locations and disrupt exploit predictability * Role-Based Access Control (RBAC) to restrict access to memory-sensitive operations * Input validation mechanisms using C3 AI TypeSystem to ensure safe memory usage during runtime These controls ensure that memory operations within C3-built containers are tightly scoped and protected, reducing the risk of isolated memory exploitation and preserving runtime integrity.
CVE-2026-33186	gRPC-Go has an authorization bypass via missing leading slash in :path	High	Expand Privilege escalation occurs when an attacker gains elevated access rights by exploiting misconfigured roles, insecure APIs, or flaws in access control mechanisms. In C3-built containers, such exploitation can result in unauthorized access to sensitive resources, manipulation of system configurations, or disruption of platform operations. The C3 AI Platform addresses these threats through strict access governance and layered security controls: * Role-Based Access Control (RBAC): Enforces least-privilege principles and restricts role modifications and nested assignments to authorized entities. * Fine-Grained Access Control: Implemented via AclEntry and AclPrivilege models to tightly scope permissions based on user roles and operational context. * Web Application Firewall (WAF): Blocks unauthorized access attempts and injection vectors targeting privilege boundaries. * Strict TypeSystem Enforcement: Validates API message structures and drops any request that deviates from its declared schema, preventing privilege manipulation via malformed inputs. * Session Isolation: Limits exposure windows for elevated access attempts by enforcing scoped, time-bound session tokens. These controls ensure that access rights within C3-built containers are tightly scoped, traceable, and resilient against unauthorized privilege elevation—preserving operational integrity and protecting sensitive platform resources.
CVE-2026-34182	Cryptographic Message Services (CMS) processing fails to perform sufficient input validation on the cipher and tag length fields of AuthEnvelopedData containers, leading to various...	High	Expand Privilege escalation occurs when an attacker gains elevated access rights by exploiting misconfigured roles, insecure APIs, or flaws in access control mechanisms. In C3-built containers, such exploitation can result in unauthorized access to sensitive resources, manipulation of system configurations, or disruption of platform operations. The C3 AI Platform addresses these threats through strict access governance and layered security controls: * Role-Based Access Control (RBAC): Enforces least-privilege principles and restricts role modifications and nested assignments to authorized entities. * Fine-Grained Access Control: Implemented via AclEntry and AclPrivilege models to tightly scope permissions based on user roles and operational context. * Web Application Firewall (WAF): Blocks unauthorized access attempts and injection vectors targeting privilege boundaries. * Strict TypeSystem Enforcement: Validates API message structures and drops any request that deviates from its declared schema, preventing privilege manipulation via malformed inputs. * Session Isolation: Limits exposure windows for elevated access attempts by enforcing scoped, time-bound session tokens. These controls ensure that access rights within C3-built containers are tightly scoped, traceable, and resilient against unauthorized privilege elevation—preserving operational integrity and protecting sensitive platform resources.
CVE-2026-40393	In Mesa before 25.3.6 and 26 before 26.0.1, out-of-bounds memory access can occur in WebGPU because the amount of to-be-allocated data depends on an untrusted party, and is then us...	High	Expand Buffer overflow vulnerabilities occur when a program writes more data to a memory buffer than it can accommodate, potentially overwriting adjacent memory regions. This can enable attackers to execute arbitrary code, crash services, or escalate privileges. In C3-built containers, such threats may stem from unsafe memory operations, unbounded input handling, or insufficient runtime protections. The C3 AI Platform employs a multi-layered defense strategy to prevent buffer overflow exploitation: * Address Space Layout Randomization (ASLR): Randomizes memory address allocations to disrupt predictable targeting and reduce exploit reliability. * Kernel-Level Stack and Heap Protections: Enforces memory integrity at runtime, blocking low-level corruption attempts. * Role-Based Access Control (RBAC): Restricts access to memory-sensitive operations and enforces least-privilege principles. * Input Validation via C3 AI TypeSystem: Ensures safe memory usage by validating inputs during runtime, addressing threats from malformed or excessive data. * Logical Container Isolation: Containers are segmented using network access control lists (NACLs) and cloud provider security groups, minimizing lateral movement and reducing the attack surface. * FIPS 140-2-Compliant Encryption: All data is encrypted at rest and in transit using validated cryptographic modules, preserving confidentiality and integrity. * Multi-Factor Authentication (MFA): Enforced for privileged users and administrators to prevent unauthorized access and exploitation of memory-related vulnerabilities. These controls collectively safeguard C3-built containers against memory corruption and unauthorized code execution, ensuring platform stability and data integrity.
CVE-2026-42266	JupyterLab has an Extension Manager API/GUI Policy Discrepancy, allowing 3rd party (malicious) extensions install via POST request	High	Expand Privilege escalation occurs when an attacker gains elevated access rights by exploiting misconfigured roles, insecure APIs, or flaws in access control mechanisms. In C3-built containers, such exploitation can result in unauthorized access to sensitive resources, manipulation of system configurations, or disruption of platform operations. The C3 AI Platform addresses these threats through strict access governance and layered security controls: * Role-Based Access Control (RBAC): Enforces least-privilege principles and restricts role modifications and nested assignments to authorized entities. * Fine-Grained Access Control: Implemented via AclEntry and AclPrivilege models to tightly scope permissions based on user roles and operational context. * Web Application Firewall (WAF): Blocks unauthorized access attempts and injection vectors targeting privilege boundaries. * Strict TypeSystem Enforcement: Validates API message structures and drops any request that deviates from its declared schema, preventing privilege manipulation via malformed inputs. * Session Isolation: Limits exposure windows for elevated access attempts by enforcing scoped, time-bound session tokens. These controls ensure that access rights within C3-built containers are tightly scoped, traceable, and resilient against unauthorized privilege elevation—preserving operational integrity and protecting sensitive platform resources.
CVE-2026-56407	libexpat before 2.8.2 has an integer overflow in doProlog that is related to storeEntityValue and entity textLen.	High	Expand Buffer overflow vulnerabilities occur when a program writes more data to a memory buffer than it can accommodate, potentially overwriting adjacent memory regions. This can enable attackers to execute arbitrary code, crash services, or escalate privileges. In C3-built containers, such threats may stem from unsafe memory operations, unbounded input handling, or insufficient runtime protections. The C3 AI Platform employs a multi-layered defense strategy to prevent buffer overflow exploitation: * Address Space Layout Randomization (ASLR): Randomizes memory address allocations to disrupt predictable targeting and reduce exploit reliability. * Kernel-Level Stack and Heap Protections: Enforces memory integrity at runtime, blocking low-level corruption attempts. * Role-Based Access Control (RBAC): Restricts access to memory-sensitive operations and enforces least-privilege principles. * Input Validation via C3 AI TypeSystem: Ensures safe memory usage by validating inputs during runtime, addressing threats from malformed or excessive data. * Logical Container Isolation: Containers are segmented using network access control lists (NACLs) and cloud provider security groups, minimizing lateral movement and reducing the attack surface. * FIPS 140-2-Compliant Encryption: All data is encrypted at rest and in transit using validated cryptographic modules, preserving confidentiality and integrity. * Multi-Factor Authentication (MFA): Enforced for privileged users and administrators to prevent unauthorized access and exploitation of memory-related vulnerabilities. These controls collectively safeguard C3-built containers against memory corruption and unauthorized code execution, ensuring platform stability and data integrity.
CVE-2026-56408	libexpat before 2.8.2 has an integer overflow in copyString.	High	Expand Buffer overflow vulnerabilities occur when a program writes more data to a memory buffer than it can accommodate, potentially overwriting adjacent memory regions. This can enable attackers to execute arbitrary code, crash services, or escalate privileges. In C3-built containers, such threats may stem from unsafe memory operations, unbounded input handling, or insufficient runtime protections. The C3 AI Platform employs a multi-layered defense strategy to prevent buffer overflow exploitation: * Address Space Layout Randomization (ASLR): Randomizes memory address allocations to disrupt predictable targeting and reduce exploit reliability. * Kernel-Level Stack and Heap Protections: Enforces memory integrity at runtime, blocking low-level corruption attempts. * Role-Based Access Control (RBAC): Restricts access to memory-sensitive operations and enforces least-privilege principles. * Input Validation via C3 AI TypeSystem: Ensures safe memory usage by validating inputs during runtime, addressing threats from malformed or excessive data. * Logical Container Isolation: Containers are segmented using network access control lists (NACLs) and cloud provider security groups, minimizing lateral movement and reducing the attack surface. * FIPS 140-2-Compliant Encryption: All data is encrypted at rest and in transit using validated cryptographic modules, preserving confidentiality and integrity. * Multi-Factor Authentication (MFA): Enforced for privileged users and administrators to prevent unauthorized access and exploitation of memory-related vulnerabilities. These controls collectively safeguard C3-built containers against memory corruption and unauthorized code execution, ensuring platform stability and data integrity.
CVE-2026-6846	A flaw was found in binutils.	High	Expand Buffer overflow vulnerabilities occur when a program writes more data to a memory buffer than it can accommodate, potentially overwriting adjacent memory regions. This can enable attackers to execute arbitrary code, crash services, or escalate privileges. In C3-built containers, such threats may stem from unsafe memory operations, unbounded input handling, or insufficient runtime protections. The C3 AI Platform employs a multi-layered defense strategy to prevent buffer overflow exploitation: * Address Space Layout Randomization (ASLR): Randomizes memory address allocations to disrupt predictable targeting and reduce exploit reliability. * Kernel-Level Stack and Heap Protections: Enforces memory integrity at runtime, blocking low-level corruption attempts. * Role-Based Access Control (RBAC): Restricts access to memory-sensitive operations and enforces least-privilege principles. * Input Validation via C3 AI TypeSystem: Ensures safe memory usage by validating inputs during runtime, addressing threats from malformed or excessive data. * Logical Container Isolation: Containers are segmented using network access control lists (NACLs) and cloud provider security groups, minimizing lateral movement and reducing the attack surface. * FIPS 140-2-Compliant Encryption: All data is encrypted at rest and in transit using validated cryptographic modules, preserving confidentiality and integrity. * Multi-Factor Authentication (MFA): Enforced for privileged users and administrators to prevent unauthorized access and exploitation of memory-related vulnerabilities. These controls collectively safeguard C3-built containers against memory corruption and unauthorized code execution, ensuring platform stability and data integrity.
CVE-2026-7383	A signed integer overflow when sizing the destination buffer for Unicode output in ASN1_mbstring_ncopy() can lead to a heap buffer overflow.	High	Expand Buffer overflow vulnerabilities occur when a program writes more data to a memory buffer than it can accommodate, potentially overwriting adjacent memory regions. This can enable attackers to execute arbitrary code, crash services, or escalate privileges. In C3-built containers, such threats may stem from unsafe memory operations, unbounded input handling, or insufficient runtime protections. The C3 AI Platform employs a multi-layered defense strategy to prevent buffer overflow exploitation: * Address Space Layout Randomization (ASLR): Randomizes memory address allocations to disrupt predictable targeting and reduce exploit reliability. * Kernel-Level Stack and Heap Protections: Enforces memory integrity at runtime, blocking low-level corruption attempts. * Role-Based Access Control (RBAC): Restricts access to memory-sensitive operations and enforces least-privilege principles. * Input Validation via C3 AI TypeSystem: Ensures safe memory usage by validating inputs during runtime, addressing threats from malformed or excessive data. * Logical Container Isolation: Containers are segmented using network access control lists (NACLs) and cloud provider security groups, minimizing lateral movement and reducing the attack surface. * FIPS 140-2-Compliant Encryption: All data is encrypted at rest and in transit using validated cryptographic modules, preserving confidentiality and integrity. * Multi-Factor Authentication (MFA): Enforced for privileged users and administrators to prevent unauthorized access and exploitation of memory-related vulnerabilities. These controls collectively safeguard C3-built containers against memory corruption and unauthorized code execution, ensuring platform stability and data integrity.
GHSA-5c6j-r48x-rmvq	Serialize JavaScript is Vulnerable to RCE via RegExp.flags and Date.prototype.toISOString()	High	Expand ThisVuln ID affects theapplication protocol implemented that are validated in C3 AI's Java runtime environment. The decoder uses a deserialization protocol allowing attackers to send malicious serialized data that could lead toremote code execution (RCE). The C3 AI Platform’s architecture includes multiple layers of defense that risks associated with unsafe deserialization: * Application-Level EncryptionandRBACprevent unauthorized access to sensitive data and restrict execution privileges. * Vault-Based Key Managementensures that secrets and credentials are securely stored and accessed only by authorized services. * Audit LoggingandWAFprovide visibility and protection against suspicious payloads and malformed requests bypassing the WAF would require additional privileges in the platform * Type System for Application-Level Message or Protocol Tampering: C3 AI's type system in C3 server ensures that application-level messages and protocols are strictly validated, preventing tampering and ensuring data integrity. This helps mitigate the risk of request smuggling and other protocol-related attacks. significantly reducing the risks of processing untrusted data. *Network Segmentation: All c3server container instances reside in highly isolated execution environments within the C3 AI Platform. This network segmentation minimizes lateral movement and the scope of potential exploitation, ensuring that attacks are contained within a narrow blast radius. These controls collectively reduce the risk of deserialization-based RCE, even in cases where third-party libraries are integrated.