company logo

Product

Our Product

We are Reshaping the way Developers find and fix vulnerabilities before they get exploited.

Solutions

By Industry

BFSI

Healthcare

Education

IT & Telecom

Government

By Role

CISO/CTO

DevOps Engineer

Resources

Resource Library

Get actionable insight straight from our threat Intel lab to keep you informed about the ever-changing Threat landscape.

Subscribe to Our Weekly Threat Digest

Company

Contact Us

Have queries, feedback or prospects? Get in touch and we shall be with you shortly.

loading..
loading..
loading..
Loading...

Coinstats

AWS

Cryptotheft

loading..
loading..
loading..

CoinStats Hack: Is Social Engineering Behind $2M Loss & 1,590 Wallets?

CoinStats breach exposes 1,590 crypto wallets via alleged social engineering attack. Learn how it happened and what it means for the crypto industry

28-Jun-2024
5 min read

Related Articles

loading..

OpenSSH

Linux

A severe OpenSSH vulnerability, regreSSHion, allows unauthenticated RCE, risking...

CVE-2024-6387, identified by the Qualys Threat Research Unit (TRU), marks a significant cybersecurity vulnerability in OpenSSH's server (sshd) on glibc-based Linux systems. This Remote Unauthenticated Code Execution (RCE) vulnerability, labeled "regreSSHion," poses a substantial threat due to its ability to execute arbitrary code as root, compromising system integrity and security. The critical nature of this flaw, a regression from a previously patched issue, demands immediate attention and comprehensive analysis. The issue is a regression of the previously identified CVE-2006-5051 and stems from the asynchronous signal-unsafe functions being called within the `sshd`'s `SIGALRM` handler. ### Overview of the Vulnerability The regreSSHion vulnerability, a signal handler race condition, impacts OpenSSH in its default configuration. This issue allows remote attackers to execute arbitrary code without authentication, potentially compromising millions of systems. Censys and Shodan searches have identified over 14 million potentially vulnerable OpenSSH server instances exposed to the internet. Furthermore, Qualys CSAM 3.0 data indicates that approximately 700,000 external internet-facing instances are vulnerable, representing 31% of the global customer base with OpenSSH. Notably, 0.14% of these instances are running End-Of-Life/End-Of-Support versions of OpenSSH. ### Historical Context and Regression Analysis OpenSSH versions earlier than 4.4p1 were vulnerable to this race condition, which was initially patched but not fully resolved by CVE-2008-4109. This [vulnerability](https://blog.qualys.com/vulnerabilities-threat-research/2024/07/01/regresshion-remote-unauthenticated-code-execution-vulnerability-in-openssh-server) is a regression of CVE-2006-5051, initially reported in 2006. A regression in this context implies that a flaw, previously resolved, has reemerged due to subsequent changes in the software. This issue resurfaced in October 2020 with the release of OpenSSH 8.5p1, due to a modification in the logging infrastructure that inadvertently removed critical safeguards, reintroducing the race condition emphasizing the necessity of thorough regression testing to prevent such occurrences. The affected versions are: - **OpenSSH < 4.4p1:** Vulnerable if not patched against CVE-2006-5051 or CVE-2008-4109. - **OpenSSH 4.4p1 to 8.5p1:** Not vulnerable due to the presence of a safeguard. - **OpenSSH 8.5p1 to 9.8p1:** Vulnerable again due to the accidental removal of the safeguard. ### Technical Details and Exploitation The regreSSHion vulnerability is complex and challenging to exploit due to its remote race condition nature. The exploitation process involves interrupting a function call such as free() or malloc() within the sshd's public-key parsing code using SIGALRM, leading to a heap inconsistency. This inconsistent state is exploited in subsequent calls within the SIGALRM handler, enabling remote code execution. The advisory details the step-by-step methodology, including: - **Heap Manipulation:** Interrupting specific memory allocation calls to create a predictable memory state. - **Race Condition Exploitation:** Utilizing SIGALRM to precisely time the interruption and exploit the heap state. - **Remote Code Execution:** Achieving code execution by leveraging the inconsistent memory state to inject and execute malicious payloads. Successful exploitation requires precise timing to induce memory corruption, bypassing security mechanisms such as Address Space Layout Randomization (ASLR). The vulnerability is highly exploitable on glibc-based systems, particularly those without Address Space Layout Randomization (ASLR) and No eXecute (NX) protections, as these mitigations complicate the exploitation process. Despite the complexity, advancements in deep learning could potentially aid attackers in leveraging this vulnerability more effectively. ### Potential Impact Exploitation of this vulnerability could lead to full system compromise. Attackers can execute arbitrary code with root privileges, resulting in complete control over the affected system. This includes installing malware, manipulating data, and creating backdoors for persistent access. Moreover, attackers could bypass critical security mechanisms, leading to significant data breaches and leakage. ### Mitigation Strategies #### Patch Management Immediate patching is crucial. Organizations should apply the latest patches for OpenSSH and prioritize continuous updates. Regular patch management ensures that systems remain protected against known vulnerabilities. #### Enhanced Access Control Restricting SSH access through network-based controls can significantly reduce attack surfaces. Implementing strict access policies ensures that only authorized personnel can access critical systems. #### Network Segmentation and Intrusion Detection Dividing networks into segments restricts unauthorized access and limits lateral movement within critical environments. Deploying intrusion detection systems (IDS) helps monitor and alert on unusual activities indicative of exploitation attempts. ### Detailed Technical Analysis The following sections provide a [comprehensive technical breakdown](https://www.qualys.com/2024/07/01/cve-2024-6387/regresshion.txt) of the regreSSHion vulnerability, including code snippets and contextual examples to illustrate the issue's complexity. #### Signal Handler Race Condition The core of [CVE-2024-6387](https://github.com/xaitax/CVE-2024-6387_Check) lies in a signal handler race condition within sshd. A race condition occurs when the timing of processes influences the system's behavior, potentially leading to unexpected outcomes. ```c void signal_handler(int signo) { // Vulnerable code snippet char buffer[1024]; snprintf(buffer, sizeof(buffer), "Signal %d received", signo); // Race condition occurs here log_message(buffer); } ``` In the above code, the race condition arises from the use of `snprintf` within a signal handler. If the signal handler interrupts a critical section of the code, it can lead to memory corruption and arbitrary code execution. #### Memory Corruption and ASLR Bypass To exploit this vulnerability, attackers must induce memory corruption and bypass ASLR. This requires precise timing and repeated attempts, making the exploitation process challenging but not impossible. ```python import os import time def exploit_race_condition(): for _ in range(1000): os.kill(os.getpid(), signal.SIGUSR1) time.sleep(0.001) if __name__ == "__main__": exploit_race_condition() ``` The Python script above demonstrates a basic approach to exploiting the race condition. By repeatedly sending signals to the process, the attacker increases the chances of successful exploitation. ### Detection and Prevention Qualys provides tools and resources to help organizations detect and mitigate this vulnerability. The following QID (Qualys ID) helps identify affected systems: #### QID 42046: OpenSSH Remote Unauthenticated Code Execution Vulnerability (regreSSHion) ```qql vulnerabilities.vulnerability.cveIds:CVE-2024-6387 ``` ### Secure Blink's Solution #### Automated Detection & Remediation with ThreatSpy ThreatSpy automates both authenticated and unauthenticated scans, identifying a wide range of vulnerabilities, including those within the OWASP Top 10, CWE Top 25, and more. The platform’s heuristic approach prioritizes vulnerabilities based on a custom-built Reachability Framework, offering a Security Posture score derived from contextual analysis. **Key Features of ThreatSpy:** - Automated Scans: Performs extensive scans covering various vulnerabilities and generating detailed reports. - Remediation Playbook and Mitigation Campaign: Provides step-by-step guidance for efficient remediation and automates actions to mitigate identified vulnerabilities. - Security Posture Score: Offers a comprehensive score based on the potential impact and exploitability of vulnerabilities. - ROI Calculation: Evaluates the effectiveness of the platform by calculating the number of manual hours saved. **Addressing the regreSSHion Vulnerability** To mitigate the regreSSHion vulnerability, ThreatSpy can: - **Automated Vulnerability Detection and Remediation:** Quickly identify and apply necessary patches for OpenSSH, ensuring systems are up-to-date and secure. - **Comprehensive Vulnerability Scanning:** Perform both authenticated and unauthenticated scans to cover a wide range of potential vulnerabilities. - **Prioritization and Contextual Analysis:** Use heuristic analysis to prioritize vulnerabilities based on their potential impact and exploitability, providing a Security Posture score. ### Conclusion The [CVE-2024-6387](https://www.qualys.com/regresshion-cve-2024-6387/) regreSSHion vulnerability represents a significant security threat due to its potential for remote code execution as root. Secure Blink’s ThreatSpy offers a robust solution for identifying and mitigating such vulnerabilities through automated detection, prioritization, and remediation processes. By leveraging [ThreatSpy](https://www.secureblink.com/threatspy), organizations can enhance their security posture and effectively safeguard against this critical vulnerability. Try out our [14 day trial for free](https://threatspy.secureblink.com/signup)!

loading..   02-Jul-2024
loading..   7 min read
loading..

Supply Chain Attack

CDN

Polyfill.io relaunches on a new domain after being accused of delivering malicio...

Polyfill.io, a widely used JavaScript CDN service, has been at the center of a significant cybersecurity dispute. Following the discovery of malicious code being delivered to over 100,000 websites, the service has been relaunched on a new domain. This [Threatfeed](https://www.secureblink.com/cyber-security-news) analyzes the underlying nuances of this supply chain attack. #### Background & Initial Discovery Polyfill.io was designed to [help](https://github.com/polyfillpolyfill/polyfill-service) developers add modern JavaScript functionality to older browsers. However, in February 2024, a Chinese entity named 'Funnull' acquired the polyfill.io domain and inserted malicious code into the scripts delivered by its CDN. This malicious code primarily targeted mobile devices, redirecting users to undesirable sites. Researchers from Sansec [identified](https://sansec.io/research/polyfill-supply-chain-attack) the attack, noting that the compromised scripts affected more than 100,000 websites. The malicious code injected by polyfill.io's CDN was designed to hijack mobile devices visiting websites embedding the CDN's scripts. #### Analysis of the Malicious Code The inserted malicious code was sophisticated and strategically designed to evade detection. It redirected users to sports betting sites using a typosquatted domain name (google-anaiytics[.]com), an intentional misspelling of Google Analytics. This kind of attack highlights the potential risks of supply chain vulnerabilities, where third-party code can compromise entire networks. Here is an instance of how such malicious code might look: ![MaliCode1.jpg](https://sb-cms.s3.ap-south-1.amazonaws.com/Mali_Code1_44df6760eb.jpg) This script deceptively loads from a malicious domain, mimicking a legitimate service to avoid immediate suspicion. #### Response and Mitigation Measures Following the [exposure](https://twitter.com/Polyfill_Global/status/1805707089672815039), the polyfill.io domain was shut down by its registrar, Namecheap. The service owners swiftly relaunched it on a new domain, polyfill.com, and asserted there were "no supply chain risks." They claimed all services were cached in Cloudflare, ensuring static content delivery without third-party interference. Despite these assurances, security experts remain skeptical. Cloudflare, a prominent cloud security company, noted unauthorized use of its name and logo by polyfill.io, further eroding trust in the service. Cloudflare's CEO, Matthew Prince, highlighted the scale of the impact, revealing that tens of millions of websites had used polyfill.io, underscoring the seriousness of the breach. #### Technical Deep Dive: Supply Chain Risks Supply chain attacks like the one involving polyfill.io underscore the critical need for robust security practices. When third-party services are integrated into web applications, they become potential vectors for attacks. This incident demonstrates several key vulnerabilities: 1. **Third-Party Code Injection**: The compromised polyfill.io CDN served as an entry point for malicious code. Developers must thoroughly vet third-party services and ensure they are secure. 2. **Domain Trust and Verification**: The use of typosquatted domains (e.g., google-anaiytics[.]com) highlights the importance of domain verification. Implementing strict domain whitelisting can mitigate such risks. 3. **Content Caching and Delivery**: While caching content in services like Cloudflare can reduce risk, it is not foolproof. Continuous monitoring and verification of cached content are essential. #### Recommendations for Developers To safeguard against similar supply chain attacks, developers should consider the following practices: 1. **Self-Hosting Critical Libraries**: Instead of relying on third-party CDNs, host critical libraries on your servers. This ensures direct control over the content delivered to users. 2. **Implementing Subresource Integrity (SRI)**: SRI allows browsers to verify that resources fetched from a CDN have not been tampered with. This can prevent malicious modifications to scripts. ![MaliCode2.jpg](https://sb-cms.s3.ap-south-1.amazonaws.com/Mali_Code2_b60b6b11c2.jpg) 3. **Regular Security Audits**: Conducting periodic security audits of third-party services and dependencies can identify potential vulnerabilities before they are exploited. #### Role of Media and Public Perception Polyfill.io's response to the allegations, particularly their claims of being "maliciously defamed," underscores the challenges companies face in managing public perception during a security crisis. The service's owners have actively defended their integrity, emphasizing the use of Cloudflare caching to mitigate risks. However, trust once lost is difficult to regain, especially when authoritative entities like Cloudflare contradict the company's claims. #### Legal Implications The legal ramifications of such a breach are significant. Companies affected by the malicious code injected through polyfill.io's CDN could potentially seek legal recourse. Additionally, ethical considerations come into play, as the responsibility to protect user data and ensure secure services is paramount. The incident highlights the ethical duty of service providers to maintain the highest standards of security and transparency. #### Future Outlook and Industry Impact This incident is likely to influence future industry practices regarding the use of third-party CDNs. Developers and organizations might shift towards more secure, self-hosted solutions or rely on reputable, audited CDNs with stringent security measures. The focus on supply chain security will intensify, driving innovation in tools and practices designed to detect and prevent such attacks. #### Comparative Analysis Comparing the Polyfill.io incident with other notable supply chain attacks, such as the SolarWinds breach, provides valuable insights into common tactics and mitigation strategies. Both cases involved the compromise of trusted third-party services, highlighting the need for comprehensive security frameworks that encompass all aspects of the supply chain.

loading..   29-Jun-2024
loading..   5 min read
loading..

MoveIt

Authentication Bypass

Discover the latest critical vulnerabilities in MOVEit Transfer. Learn about CVE...

Threat actors are actively engaged to exploit a critical authentication bypass vulnerability in Progress MOVEit Transfer, shortly after the flaw was made public by the vendor. MOVEit Transfer is a managed file transfer (MFT) solution utilized in enterprise settings to securely transfer files using protocols such as SFTP, SCP, and HTTP. These vulnerabilities, notably [CVE-2024-5806](https://community.progress.com/s/article/MOVEit-Transfer-Product-Security-Alert-Bulletin-June-2024-CVE-2024-5806) and [CVE-2024-5805](https://community.progress.com/s/article/MOVEit-Transfer-Product-Security-Alert-Bulletin-June-2024-CVE-2024-5805), have severe implications for data security across various industries. This [Threatfeed](https://www.secureblink.com/cyber-security-news) delves into the technical nuances of these vulnerabilities, providing an in-depth understanding of their impact, exploitation mechanisms, and mitigation strategies. #### Overview of MOVEit Transfer Vulnerabilities ##### CVE-2024-5806: Authentication Bypass Vulnerability Initially rated with a CVSS score of 7.4, CVE-2024-5806 has been re-evaluated to 9.1, elevating its severity from High to Critical. This vulnerability affects MOVEit Transfer versions from 2023.0.0 before [2023.0.11](https://docs.progress.com/bundle/moveit-transfer-release-notes-2023/page/Whats-New-in-MOVEit-Transfer-2023.html), 2023.1.0 before [2023.1.6](https://docs.progress.com/bundle/moveit-transfer-release-notes-2023_1/page/Whats-New-in-MOVEit-Transfer-2023.1.html), and 2024.0.0 before [2024.0.2](https://docs.progress.com/bundle/moveit-transfer-release-notes-2024/page/Whats-New-in-MOVEit-Transfer-2024.html). The flaw arises from improper error handling in the IPWorks SSH library, allowing attackers to manipulate SSH key data for authentication bypass. ##### CVE-2024-5805: Critical Vulnerability in MOVEit Gateway CVE-2024-5805, with a CVSS score of 9.1, is a critical vulnerability affecting MOVEit Gateway version 2024.0.0. This vulnerability permits attackers to exploit forced authentication scenarios, enabling them to capture Net-NTLMv2 hashes by connecting to malicious SMB servers. ### Detailed Analysis #### Newly Identified Vulnerabilities **CVE-2024-5806 (CVSS 9.1 - Critical)** - **Affected Product:** MOVEit Transfer - **Description:** Authentication Bypass - **Affected Versions:** From 2023.0.0 to 2023.0.11, from 2023.1.0 to 2023.1.6, from 2024.0.0 to 2024.0.2. **CVE-2024-5805 (CVSS 9.1 - Critical)** - **Affected Product:** MOVEit Gateway - **Description:** Authentication Bypass - **Affected Version:** 2024.0.0 #### Background and Impact MOVEit Transfer is a managed file transfer (MFT) solution widely used for secure file transfers within and between organizations. The product has a history of critical vulnerabilities, with the [Clop ransomware](https://www.secureblink.com/threat-research/clop-ransomware) exploiting these vulnerabilities in 2023 to steal data from numerous organizations. [MOVEit](https://www.secureblink.com/cyber-security-news/cl0p-ransomware-s-torrent-data-leak-disclosing-mov-eit-s-massive-breach) Gateway is designed to enable safer deployments by acting as a proxy service. ![moveit-dash.webp](https://sb-cms.s3.ap-south-1.amazonaws.com/moveit_dash_186174fbc3.webp) ***Instances of MoveIt Transfer*** The recently identified vulnerabilities have significant implications: - As of June 25, 2024, 2,700 instances of MOVEit Transfer were observed online, predominantly in the US, UK, Germany, the Netherlands, and Canada. - The exposure level has remained consistent with previous observations from 2023, highlighting persistent security risks. ### Technical Analysis of CVE-2024-5806 The authentication bypass vulnerability in MOVEit Transfer stems from issues within the IPWorks SSH library. When error handling fails, attackers can manipulate SSH key data to impersonate legitimate users. This flaw enables unauthorized access to sensitive data and systems. ##### Exploitation Mechanics 1. **SSH Key Manipulation**: Attackers craft malicious SSH key data to bypass authentication checks. The server fails to properly validate the key, granting unauthorized access. 2. **Impersonation Attack**: By exploiting the manipulated SSH key, attackers can impersonate any user on the server, gaining access to restricted areas and sensitive information. ```python # Example Code Snippet def validate_ssh_key(key): try: # Error-prone validation process if not validate(key): raise InvalidKeyException("Invalid SSH Key") except InvalidKeyException as e: log.error("Key validation failed: {}".format(e)) return False return True ``` In the above code snippet, the `validate_ssh_key` function demonstrates improper handling of SSH key validation, which can be exploited for authentication bypass. ### Technical Analysis of CVE-2024-5805 The critical vulnerability in MOVEit Gateway involves forced authentication scenarios where the server connects to a malicious SMB server. This interaction exposes a Net-NTLMv2 hash, which can be used for further exploitation. ##### Exploitation Mechanics 1. **Forced Authentication**: Attackers trick the server into authenticating against a malicious SMB server, capturing the Net-NTLMv2 hash. 2. **Hash Exploitation**: The captured hash can be leveraged to impersonate the server or conduct pass-the-hash attacks, compromising the entire system. ```python # Example Code Snippet def connect_to_smb(server, credentials): try: # Attempt connection to SMB server smb_connection = SMBConnection(server, credentials) smb_connection.authenticate() except SMBException as e: log.error("SMB connection failed: {}".format(e)) return False return True ``` In this code snippet, the `connect_to_smb` function illustrates how forced authentication to a malicious server can expose sensitive credentials. ### Technical Dissection by watchTowr Labs Researchers from [watchTowr Labs](https://labs.watchtowr.com/auth-bypass-in-un-limited-scenarios-progress-moveit-transfer-cve-2024-5806/) provided an in-depth technical analysis of the authentication bypass vulnerabilities: - **Vulnerability Origin:** Unlike a straightforward SQL injection, this vulnerability arises from the interaction between MOVEit and the IPWorks SSH library, compounded by issues in error handling. - **Observed Behavior:** During authentication using SSH key pair authentication, the server throws an exception due to illegal characters in the path, indicating mishandled input. ### Exploit Scenarios #### Forced Authentication Attack An attacker can exploit this vulnerability by: 1. Supplying a UNC path to a malicious SMB server. 2. The target server attempts to connect, falling back to the less secure Net-NTLMv2 protocol, which can then be exploited to capture authentication hashes. ### Mitigation and Recommendations To mitigate these vulnerabilities, Progress Software recommends several immediate actions: 1. **Patch Deployment**: Apply the latest patches for MOVEit Transfer and MOVEit Gateway to mitigate known vulnerabilities. 2. **Restrict RDP Access**: Block inbound RDP access to MOVEit Transfer to prevent unauthorized remote access. 3. **Limit Outbound Connections**: Restrict outbound connections to trusted servers only, reducing the risk of forced authentication attacks. Additionally, users should apply patches as soon as they are available and monitor network traffic for any unusual activity indicating attempted exploitation. ### Exposure Analysis As of June 25, 2024, approximately 2,700 instances of MOVEit Transfer are online, predominantly in the United States. The majority of these instances are hosted on Microsoft or Amazon autonomous systems, underscoring the widespread usage and potential risk of exploitation. ### Conclusion The vulnerabilities in MOVEit Transfer and MOVEit Gateway present significant risks to data security. CVE-2024-5806 and CVE-2024-5805 exemplify how flaws in authentication mechanisms can be exploited to gain unauthorized access and compromise sensitive systems. By understanding the technical details and implementing recommended mitigations, organizations can protect themselves against these critical threats. The identification of these new vulnerabilities in MOVEit Transfer and Gateway underscores the importance of robust cybersecurity measures. Organizations using these products should prioritize applying the recommended mitigations and closely monitor their systems for signs of compromise. For further details and continuous updates, refer to Progress Software's advisory and security bulletins. Through meticulous evaluation and proactive measures, the integrity and security of critical systems can be maintained.

loading..   28-Jun-2024
loading..   7 min read