A vulnerability in GitLab CE/EE versions from 13.2 before 19.3.9, 19.4 before 19.4.8, and 19.5 before 19.5.6 allowed an authenticated user with owner-role permissions to execute arbitrary JavaScript in another user's browser via the Confluence integration due to improper input validation. This cross-site scripting (XSS) flaw could lead to partial confidentiality and integrity impacts but does not affect availability.
Kaneo versions prior to 2.13.0 have a vulnerability where the GET /api/external-link/task/:taskId endpoint exposes the integration.config object to any workspace member, including those with viewer roles, if a task is linked to a Gitea issue or pull request. This configuration data includes sensitive information such as the Gitea accessToken and webhookSecret. These secrets could allow unauthorized actions on Gitea and forged webhook deliveries that pass HMAC verification. GitHub integrations without Gitea are not affected. The issue is fixed in version 2.13.0.
This is a behavioral detection engine designed to identify Living-off-the-Land Binaries (LOLBins) abuse on Windows endpoints. It uses process telemetry, sequential event correlation, PE masquerading checks, and command-line obfuscation heuristics to detect suspicious activity involving legitimate Windows utilities often exploited by attackers. The engine includes a modular pipeline, a local web dashboard for triage, and automated incident reporting. It aims to overcome limitations of signature-based detection by focusing on behavioral patterns and multi-stage attack chains.
A vulnerability in konflux-ci's Continuous Integration automation scripts causes sensitive GitHub access tokens to be stored in plaintext on the runner without cleanup after execution. A local attacker with access to the CI environment can read these tokens and gain unauthorized repository access, potentially modifying source code or release artifacts. Exploitation requires prior code execution access on the CI runner. No effective mitigation or patch is currently available according to the vendor advisory.
Tartufo's GitPython integration contains a regex vulnerability in the parse_actor_and_date() function, causing quadratic backtracking on malformed author/committer/tagger identity lines missing or having malformed epoch or timezone data. This leads to significant CPU exhaustion when processing crafted commit or tag objects. The issue persists in version 3.1.62 despite partial fixes in 3.1.60. Accessing affected commit or tag fields with maliciously crafted identity lines can cause processing delays of several seconds per access.
Mistral vibe's GitPython integration has a vulnerability where the submodule creation function clones into the .git/hooks directory before validating the path. This allows an attacker to plant an executable hook script that runs on subsequent git operations, leading to arbitrary code execution. The issue affects versions from 2.1.0 up to but not including 3.0.3. Although versions 3.2.0 and later added stricter validation, the check occurs too late to prevent the malicious hook from being written. Versions 3.1.x do not perform this validation at all and silently allow the attack.
GitPython's fdroidserver integration has three methods that omit important safety checks against unsafe protocols and options, leading to potential remote code execution (RCE) and argument injection vulnerabilities. The ls_remote method does not check the URL for unsafe protocols, allowing RCE if the underlying git transport policy permits the 'ext' protocol. The merge_base and IndexFile.move methods forward caller-controlled arguments without proper option checks, exposing latent injection surfaces. These issues affect versions from 0.7.0 up to but not including 2.4.5_7. A fix is available in version 2.4.5_7.
Antidetect browsers such as Kameleo, AdsPower, and MultiLogin enable threat actors to conceal their digital identities and manage thousands of isolated accounts across multiple social media and financial platforms without detection. These tools facilitate account takeovers, financial fraud, phishing, malware distribution, and coordinated influence operations by evading platform detection systems that rely on behavioral and device identity signals. The integration of AI enhances these browsers' capabilities, automating persona management and content generation at scale, reducing the need for large technical teams. These commercially available browsers have legitimate uses but are actively abused in underground criminal ecosystems. The threat is significant because accounts created or taken over via antidetect browsers can pass KYC verification and appear legitimate, making fraud detection difficult until after damage occurs.
## Summary
A small attacker-supplied TIFF can be opened and loaded normally, then reach an out-of-bounds read when an application saves it back to TIFF with retained metadata. The fixed reproducer is a 1×1, 16-bit grayscale, PackBits-compressed TIFF containing tag 320 (ColorMap) with **768 SHORT values**: three zero-filled planes of 256 entries each. No Python object is forged and no metadata is injected after loading.
Pillow's TIFF encoder allocates **768 × 2 = 1536 bytes**, then passes three plane pointers separated by 256 SHORT entries to libtiff. With `BitsPerSample = 16`, libtiff instead expects **65536 SHORT values per plane** and attempts a **131072-byte read** from a plane pointer. Existing ASAN observations identify a heap-buffer-overflow READ crossing the 1536-byte allocation made in `PyImaging_LibTiffEncoderNew`.
The malformed ColorMap need not be a valid palette for this grayscale image. The issue is that accepted metadata is forwarded on save without reconciling the fixed plane extent with the effective sample depth. Opening/loading alone is not the demonstrated fault; the encoder path is required.
## Impact and prerequisites
An application must accept the input, retain the relevant TIFF metadata, and invoke the libtiff-backed TIFF save path. The observed consequence is an out-of-bounds read and ASAN termination. Process-memory exposure during encoding is a potential consequence, **not demonstrated by extracting arbitrary heap contents in this report**. No arbitrary read primitive, full memory-disclosure chain, code execution, address-space bypass, or cross-process effect is claimed.
The 131072-byte attempted copy is not the number of bytes proven disclosed. This report does not run a synthetic-canary serializer or collect an unsanitized encoded output.
## Tested environment and limits of the evidence
The existing observations were recorded on August 30, 2026, with **CPython 3.11.8 on macOS ARM64**, using the unmodified official **Pillow 12.3.0** wheel and its bundled **libtiff 4.7.1**:
- Wheel: `pillow-12.3.0-cp311-cp311-macosx_11_0_arm64.whl`
- Wheel size: `4785266` bytes
- Wheel SHA-256: `37d6d0a00072fd2948eb22bce7e1475f34569d90c87c59f7a2ec59541b77f7a6`
- Pillow source revision: `bb1d8e8ab8d29048624d96e3ee53cecf7c13d13d`
- Bundled libtiff SHA-256: `e8988717b7470394a47d5ccd343130796b24ee70b6d885d3818e0e0b53238be1`
Apple's ASAN runtime was injected at process startup. This is **not an ASAN-rebuilt Pillow wheel**; allocation/memcpy interception detects the reported boundary violation, but the wheel's native instructions are not comprehensively instrumented.
Only this concrete full-package environment is established here. No affected-version range, current development-branch result, or patched release is asserted. Severity is **Unknown**; no CVSS score is proposed.
Separate earlier evidence reached the original Pillow 8.0.1 encoder constructor compiled as a component against a modern Python/libtiff environment. **That was not a complete Pillow 8.0.1 installation** and does not establish the historical package's full runtime behavior. It is not part of this reproducer or an affected-version range.
## Observed evidence and controls
The earlier integration harness performed the natural sequence `Image.open(BytesIO(input))`, `image.load()`, then `image.save(BytesIO(), format="TIFF")`, without replacing the image's metadata. Each case was recorded three times:
| Original fixture | Bytes | Recorded result |
| --- | ---: | --- |
| `colormap16` | 1685 | Loaded as `I;16`; save terminated with ASAN exit 86, READ of size 131072 crossing a 1536-byte heap region (3/3). |
| `colormap8` | 1684 | Same fixed ColorMap, but 8-bit samples; save succeeded and retained SHORT/count 768 (3/3). |
| `colormap_absent` | 137 | Same 16-bit geometry without ColorMap; save succeeded (3/3). |
Address-free summary of the recorded native diagnostic:
```text
AddressSanitizer: heap-buffer-overflow
READ of size 131072
0 bytes after 1536-byte region
Copy path: memcpy -> _TIFFmemcpy -> setByteArray -> _TIFFsetShortArrayExt
-> _TIFFVSetField -> TIFFVSetField -> ImagingLibTiffSetField
-> PyImaging_LibTiffEncoderNew
Allocation: calloc -> PyImaging_LibTiffEncoderNew
```
Input SHA-256 values (also enforced inside the script):
- `colormap16`: `5f38e0ead90b97949fb0c98c63f9c68d00ba9181db6631ecb8927376dcc75f4d`
- `colormap8`: `fdb26d9135549ed44824901985086c5ee4f06515699ca3291e498c523935405c`
- `colormap_absent`: `bd54979624f3ffb713342e0458caff9e17c477f940cda2f0960feebfabbc9556`
## Root cause and source references
- [Pillow `src/encode.c`, lines 870–899, pinned revision](https://github.com/python-pillow/Pillow/blob/bb1d8e8ab8d29048624d96e3ee53cecf7c13d13d/src/encode.c#L870): the ColorMap tuple must contain exactly 768 entries; a 1536-byte allocation is passed with a fixed stride of 256. The check does not reconcile that extent with `BitsPerSample`.
- [Pillow `src/PIL/TiffImagePlugin.py`, lines 1944–19
If a certain set of MathML tags are enabled, an attacker can inject arbitrary JavaScript code into the user's browser.
The `annotation-xml` tag has slightly different behavior than the other "integration point"
tags in MathML and SVG, but ammonia didn't handle it, so it didn't correctly
strip the namespace-incompatible tags.
This vulnerability only has an effect when the `math` and `annotation-xml` tags
are both enabled, but the `encoding` attribute is disabled, because it relies
on the following sequence of steps:
1. User writes code like `<math><annotation-xml encoding="text/html"><gadget></annotation-xml></math>`.
2. Namespace filtering checks the DOM, and it passes. `<gadget>` is parsed as HTML.
3. Attribute filter strips it down to `<math><annotation-xml><gadget></annotation-xml></math>`. Because the encoding attribute is gone, `<gadget>` is now parsed as MathML.
4. The gadget is written in such a way that it exploits the parsing differences between HTML and MathML.
Additionally, the gadget can only be written using a tag that is parsed as raw text in HTML.
These [elements] are:
* title
* textarea
* xmp
* iframe
* noembed
* noframes
* plaintext
* noscript
* style
* script
Applications that do not explicitly allow any of these tags should not be affected, since none are allowed by default.
[elements]: https://github.com/servo/html5ever/blob/045a0378f2b0f8d4a350793899cf722a2a9b3d11/html5ever/src/tree_builder/rules.rs
### Impact
Low: Requires both MathML and at least one raw-text HTML tag to be enabled, and most websites don't enable either of those.
### Patches
- https://github.com/rust-ammonia/ammonia/pull/245 (released in 4.1.3)
- https://github.com/rust-ammonia/ammonia/pull/244 (released in 4.0.2)
- https://github.com/rust-ammonia/ammonia/pull/243 (released in 3.3.2)
### Workarounds
Call <code>builder.[add_clean_content_tags](https://docs.rs/ammonia/latest/ammonia/struct.Builder.html#method.add_clean_content_tags)("annotation-xml")</code> to remove the annotation-xml element and all of its children, including the XSS gadget.