Back to Archive

Daily Digest

Major Security News

Trend Micro warns of Apex One zero-day exploited in the wild

Zero-Day

Another day, another zero-day in the wild. This time, it’s Trend Micro’s Apex One—an enterprise endpoint security platform—that’s under active attack. Tracked as CVE-2026-34926, this directory traversal bug lets a local attacker with admin privileges inject malicious code directly into the Apex One server. The kicker? TrendAI has already spotted at least one real-world exploit attempt. If your organization runs the on-premises version, you’re in the crosshairs.

**What exactly happened** Trend Micro confirmed on Thursday that a zero-day vulnerability in its Apex One (on-premises) server is being exploited in the wild. The bug, CVE-2026-34926, is a directory traversal flaw that allows a local attacker to modify a key table on the server. This lets them inject malicious code that then gets deployed to agents across the network. The exploit requires admin credentials to the Apex One server—so it’s not a simple drive-by attack. But TrendAI’s detection of at least one active attempt proves the threat is real and urgent. **Who is affected and how** This vulnerability only impacts the on-premises version of Apex One—cloud-based deployments are safe. Organizations using Trend Micro’s enterprise endpoint security platform to protect corporate networks from malware, ransomware, and fileless attacks are the primary targets. Attackers must already have administrative access to the Apex One server, likely gained through phishing, credential theft, or other means. Once inside, they can pivot to deploy malicious code to all connected agents, effectively turning your security tool into a weapon. **The real-world impact and consequences** The U.S. Cybersecurity and Infrastructure Security Agency (CISA) has already added CVE-2026-34926 to its list of actively exploited vulnerabilities. Federal agencies are ordered to patch by June 4, under Binding Operational Directive (BOD) 22-01. For private enterprises, the stakes are equally high. A compromised Apex One server means attackers can push malware, ransomware, or backdoors to every endpoint under management. This isn’t just a server breach—it’s a network-wide compromise waiting to happen. **Technical breakdown** Directory traversal vulnerabilities allow attackers to navigate outside the intended directory structure. In this case, CVE-2026-34926 lets an authenticated local attacker modify a key table—a critical configuration file—on the Apex One server. By altering this table, they can inject malicious code that the server then distributes to agents. The attack is pre-authenticated but requires admin-level access, meaning the attacker must already have compromised the server through other means. Still, once inside, the damage can spread fast. **What should be done — mitigation and recommendations** Trend Micro has released security updates for Apex One (on-premises). Organizations should apply these patches immediately. CISA’s deadline for federal agencies is June 4, but private companies shouldn’t wait. Additionally, review administrative access controls on your Apex One server. Limit who has admin credentials, enable multi-factor authentication, and monitor for unusual activity. If you can’t patch immediately, consider isolating the server from the broader network. **Why this matters in the bigger cybersecurity landscape** This is not Trend Micro’s first zero-day rodeo. The company has patched multiple Apex One flaws exploited in the wild since 2022, including CVE-2025-54948 (RCE) and CVE-2023-41179. CISA currently tracks 12 Trend Micro Apex vulnerabilities that have been abused in attacks. The pattern is clear: enterprise security tools are becoming prime targets. Attackers know that compromising a security platform gives them a golden ticket to the entire network. This zero-day is a stark reminder that even your defenses need defending.

Patch Tuesday, May 2026 Edition

General Security

May’s Patch Tuesday just dropped, and it’s a massive one. Microsoft alone patched 118 security holes, with 16 rated critical—but for the first time in nearly two years, none are zero-days under active attack. That’s the good news. The bad news? Attackers don’t need zero-days when so many bugs let them take full control of your systems remotely. If you’re running Windows, Apple, Google, Mozilla, or Oracle products, your devices are on the line. Update now, or risk being the next headline.

**What exactly happened** Microsoft released its May 2026 Patch Tuesday updates, addressing 118 vulnerabilities across Windows and other products. Sixteen of these are rated critical, meaning they could let attackers remotely take over a device without user interaction. Notably, this is the first Patch Tuesday in nearly two years without any emergency zero-day fixes or publicly disclosed flaws. But don’t let that calm you. The volume alone signals a dangerous landscape—attackers are shifting tactics, exploiting known weaknesses faster than ever. **Who is affected and how** Anyone using Windows, Office, or Microsoft’s cloud services is at risk. But it’s not just Microsoft—Apple, Google, Mozilla, and Oracle also shipped critical patches this month. If you’re a business, your domain controllers are prime targets. If you’re a home user, your browser and operating system need immediate attention. The most alarming bug? CVE-2026-41089, a stack-based buffer overflow in Windows Netlogon. It gives attackers SYSTEM privileges on domain controllers with zero user interaction. That’s a nightmare for IT admins. **The real-world impact and consequences** Imagine an attacker silently taking over your company’s central authentication server. They could reset passwords, steal data, or deploy ransomware across your entire network. No phishing email required. No user mistake. Just pure, technical exploitation. For individuals, critical bugs in browsers like Chrome and Firefox mean malicious websites could hijack your machine. One wrong click, and your personal files, banking credentials, or even webcam access could be compromised. **Technical breakdown (the “how” explained simply)** A stack-based buffer overflow works like this: software allocates a fixed amount of memory for data. If an attacker sends more data than expected, it overflows into adjacent memory, overwriting critical instructions. The attacker then injects malicious code that the system executes with high privileges. In CVE-2026-41089, the flaw exists in how Windows Netlogon handles authentication requests. By sending a specially crafted packet, an attacker can bypass security checks and gain full control of the domain controller. No password, no user click—just raw network access. **What should be done — mitigation and recommendations** First, apply all updates immediately. For Windows, go to Settings > Update & Security > Windows Update and check for updates. For browsers like Chrome and Firefox, they update automatically, but a full restart is required. Second, prioritize patching domain controllers and servers. These are the crown jewels. If you can’t patch right away, restrict network access to critical systems and monitor for unusual authentication attempts. Third, back up your data before updating. It’s rare, but patches can sometimes cause conflicts. A recent backup ensures you can roll back if something goes wrong. **Why this matters in the bigger cybersecurity landscape** This Patch Tuesday highlights a shift: attackers are moving away from flashy zero-days and toward exploiting high-volume, critical bugs that are already known. The sheer number of patches—118 from Microsoft alone—shows that software complexity is outpacing security. But there’s a silver lining. AI platforms are proving remarkably good at finding vulnerabilities in human-made code. That means we’re catching more bugs before attackers do. The race is on, and for now, patching fast is your best defense.

Canvas Breach Disrupts Schools & Colleges Nationwide

Data Breach

A massive data extortion attack just brought the nation’s most widely used education platform to its knees. Canvas, the backbone of coursework for thousands of U.S. schools and universities, was defaced with a ransom demand threatening to leak data on 275 million students and faculty. The attack forced Instructure, Canvas’s parent company, to temporarily disable the platform, disrupting classes and assignments nationwide. If you’re a student, teacher, or administrator at an affected institution, your name, email, and student ID may already be in the hands of cybercriminals. The group behind it, ShinyHunters, set a ransom deadline—and then extended it. The stakes couldn’t be higher for the education sector.

**What exactly happened** On May 6, the education technology platform Canvas was hit by a coordinated data extortion attack. Cybercrime group ShinyHunters defaced the login page with a ransom demand, threatening to leak data on 275 million users across nearly 9,000 institutions. Instructure, Canvas’s parent company, responded by taking the platform offline. This move, while necessary to contain the breach, caused immediate chaos in classrooms and online coursework systems nationwide. **Who is affected and how** The breach impacts students, faculty, and staff at school districts and universities across the United States. Canvas is used by thousands of educational institutions—from K-12 schools to major universities—to manage assignments, grades, and communications. For many, the platform is a daily essential. Its sudden shutdown meant lost access to course materials, disrupted deadlines, and broken communication channels. The real-world impact was immediate: classes paused, assignments delayed, and IT teams scrambled. **The real-world impact and consequences** Beyond the disruption, the stolen data includes names, email addresses, and student ID numbers. While Instructure says no passwords, birth dates, or financial info were taken, the leaked data is still a goldmine for identity theft and phishing campaigns. The extortionists initially set a payment deadline of May 6, later pushed to May 12. In a surprising twist, Instructure later confirmed they paid the ransom and received digital proof that the stolen data was destroyed. But trust in the platform’s security has taken a serious hit. **Technical breakdown: how it happened** ShinyHunters gained access to Instructure’s systems and extracted user data from Canvas. The breach appears to have involved compromised credentials or an exploited vulnerability—though Instructure has not disclosed the exact entry point. The attackers then defaced the login page, a bold move designed to maximize panic and pressure. By publicly displaying the ransom demand, they ensured maximum visibility and disruption, forcing Instructure’s hand. **What should be done — mitigation and recommendations** For affected institutions, the first step is to assume the leaked data is already in the wild. Reset all user passwords immediately, enable multi-factor authentication (MFA), and monitor for phishing attempts targeting students and staff. Individuals should be on high alert for suspicious emails or messages asking for personal info. Change passwords on any accounts that share credentials with Canvas, and consider credit monitoring if your student ID was exposed. **Why this matters in the bigger cybersecurity landscape** This breach is a wake-up call for the education sector, which has long been underfunded and under-protected when it comes to cybersecurity. Canvas’s near-universal adoption makes it a high-value target—one attack can ripple across thousands of schools. The fact that Instructure paid the ransom shows how desperate organizations can become when student safety and operational continuity are on the line. But paying doesn’t guarantee safety—it only emboldens attackers. The real lesson here is that prevention, not ransom, is the only sustainable defense.

Netherlands seizes 800 servers of hosting firm enabling cyberattacks

General Security

Dutch authorities just pulled the plug on a web hosting empire that was secretly fueling Russian cyberattacks and disinformation. In a sweeping operation, financial crime investigators (FIOD) arrested two men—a 57-year-old director and a 39-year-old connectivity provider—and seized 800 servers. The suspects allegedly used a shell company to funnel resources to EU-sanctioned Russian and Belarusian entities, enabling DDoS attacks, info manipulation, and economic disruption. If you’re a European business, government agency, or critical infrastructure operator, this matters: the servers they shut down were the backbone for pro-Russian hacktivist groups targeting you.

**What exactly happened** On a quiet day in the Netherlands, FIOD agents raided data centers in Dronten and Schiphol-Rijk, plus offices in Enschede and Almere. They walked out with 800 servers, laptops, phones, and piles of administrative records. Two suspects were arrested: a 57-year-old company director and a 39-year-old head of a separate firm that provided internet connectivity. The charge? Indirectly supplying economic resources to Russian and Belarusian entities blacklisted by the EU. The web hosting firm at the center is Stark Industries—founded on February 10, 2022, just days before Russia invaded Ukraine. That timing wasn’t a coincidence. **Who is affected and how** The EU added Stark Industries to its sanctions list on May 20, 2023. But the hosting infrastructure didn’t disappear. Instead, it was transferred to a newly created Dutch company called WorkTitans B.V., operating under the brand THE.Hosting. Investigators believe WorkTitans was a front for the sanctioned entities. Behind it all sat Mirhosting, based in Almere, which ran physical servers, provided colocation, and supplied high-capacity connectivity to major internet exchanges in Amsterdam and Frankfurt. That setup acted as the transport layer—the pipeline through which Stark’s traffic entered Europe to reach WorkTitans’ infrastructure. **The real-world impact and consequences** According to Dutch publication De Volkskrant, Danish authorities and infrastructure providers linked WorkTitans to attacks by NoName057(16)—a pro-Russian hacktivist group known for DDoS assaults on key organizations. FIOD’s statement is blunt: the hosting company “provided support to actions by the Russian Federation that undermine democracy and security, including through information manipulation and disruption of public and economic systems.” Think about that. These servers weren’t just hosting cat videos. They were enabling disinformation campaigns that sway public opinion, and DDoS attacks that cripple hospitals, banks, and government portals. **Technical breakdown** The scheme was layered. Stark Industries (sanctioned) couldn’t operate openly, so it funneled clients and traffic through WorkTitans B.V. (the front). WorkTitans then used Mirhosting for physical server space and high-speed connectivity to major internet exchanges. That gave attackers a clean European IP address and low-latency access to targets across the continent. For DDoS groups like NoName057(16), this is gold—it hides their origin and amplifies attack power. The 800 servers seized likely held command-and-control infrastructure, botnet nodes, and disinformation content distribution systems. **What should be done** For organizations: audit your supply chain. If you’re using hosting providers that resell capacity from unknown upstream sources, you could be routing traffic through sanctioned infrastructure. Implement strict DDoS protection, monitor for unusual traffic patterns from Dutch IP ranges, and report suspicious activity to national cybersecurity centers. For policymakers: this case shows sanctions alone aren’t enough. You need active enforcement, cross-border cooperation, and the ability to seize physical assets quickly. **Why this matters in the bigger cybersecurity landscape** This isn’t a one-off bust. It’s a blueprint for how state-backed actors use commercial hosting to wage hybrid warfare. The Netherlands just proved that shutting down the pipes is as important as patching the software. When you cut off the infrastructure, you cut off the oxygen for cyberattacks and disinformation. For the rest of us, it’s a reminder: the next DDoS attack on your company might be powered by a server sitting in a Dutch data center, rented through a shell company, paid for with sanctioned money. Now, that server is dark.

Former US execs plead guilty to aiding tech support scammers

General Security

Two former executives of a call-tracking company just pleaded guilty to knowingly helping tech support scammers fleece victims for years. The CEO and CSO of C.A. Cloud Attribution didn't just look the other way—they actively advised fraudsters on how to avoid detection. This isn't some minor compliance slip. These executives profited from scams that targeted the elderly, drained life savings, and even stole identities. If you've ever wondered how those fake "your computer is infected" pop-ups connect to real criminals, this case reveals the infrastructure that makes it all possible.

**What exactly happened** Former CEO Adam Young and former CSO Harrison Gevirtz admitted to a single felony charge: misprision of a felony—essentially, knowing about a crime and doing nothing to stop it. Between 2017 and 2022, their company provided phone numbers, call recordings, and forwarding services to customers they knew were running tech support fraud. The scammers used deceptive pop-up ads claiming victims' computers were infected with malware. When panicked users called the number shown, they reached call center agents posing as Microsoft or Apple support. These agents charged hundreds of dollars for fake services, remotely accessed computers, and sometimes stole financial information to drain bank accounts. **Who is affected and how** The victims span the globe, but the most devastating impact hit elderly Americans. In one related case, a single scam leader collected over $6 million from at least 6,500 seniors. The FBI's 2025 Internet Crime Report reveals Americans lost $2.1 billion to tech support fraud last year alone, based on nearly 48,000 complaints. But the damage goes beyond money. As FBI Special Agent Ted E. Docks put it, "Behind every fraudulent call was a real person left frightened, humiliated, or financially shattered." These scams don't just empty bank accounts—they destroy trust and peace of mind. **The real-world impact and consequences** Young and Gevirtz face up to three years in federal prison and fines up to $250,000 each. Their sentencing is scheduled for June 16. But the bigger story is the infrastructure they built. They owned a call center in Tunisia where employees directly engaged in fraud, accessing victims' computers through compromised links and sending fake invoices. The scheme's longevity is staggering—five years of active facilitation without a single report to law enforcement. Instead of stopping the fraud, these executives advised customers to rotate phone numbers to reduce complaints and prevent account terminations. They even introduced fraudsters to each other to buy and sell call leads. **Technical breakdown explained simply** Think of C.A. Cloud Attribution as a utility company for scammers. They provided the phone numbers, call routing, and analytics that made large-scale fraud operations possible. When victims called the number from a pop-up, the system connected them to scammers, recorded the conversation, and tracked which ads were most effective. The key enabler was number rotation. By constantly changing phone numbers, scammers avoided being flagged by telecom providers or law enforcement. Young and Gevirtz didn't just know about this—they actively recommended it to their customers. **What should be done — mitigation and recommendations** For individuals, never call numbers from pop-up ads. Legitimate tech companies like Microsoft and Apple never display unsolicited warnings or ask for remote access. If you see a pop-up, close your browser entirely—don't click anything. For businesses, this case is a stark warning. Know your customers. If you provide services that could enable fraud, you have a legal and ethical obligation to report suspicious activity. Ignorance is no defense, and willful blindness can land executives in federal prison. **Why this matters in the bigger cybersecurity landscape** This case cracks open the hidden economy that fuels tech support scams. We often focus on the front-line fraudsters, but the real enablers are the infrastructure providers—the call tracking companies, payment processors, and hosting services that make large-scale fraud possible. The guilty pleas signal that law enforcement is now targeting these enablers. If you build tools that scammers rely on, you're not a neutral party—you're an accomplice. For the cybersecurity industry, this means compliance and due diligence aren't just best practices; they're survival strategies. The $2.1 billion lost in 2025 is just the reported figure. The real number is likely much higher. Every company that provides communication or analytics services should be asking hard questions about who their customers really are—before the FBI asks them instead.

Why Chargebacks are Just One Piece of the Fraud Puzzle

General Security

Chargeback rates have long been the gold standard for measuring fraud performance. But here’s the uncomfortable truth: they’re only showing you a tiny slice of the damage. A recent deep dive between Alexander Hall, VP of Fraud Strategy at IPQS, and Jordan Harris of The Fraud Boxer reveals a hidden iceberg of losses that rarely appear in chargeback metrics. Think account takeovers, stolen loyalty points, and identity theft that silently erode your revenue and brand trust. If you’re only watching chargebacks, you’re flying blind.

**What exactly happened** The fraud landscape is shifting beneath our feet, and most teams haven’t noticed. In a candid conversation, Alexander Hall and Jordan Harris unpacked a critical blind spot: fraud programs that obsess over chargeback rates are missing the bigger picture. Chargebacks capture only a narrow slice of fraud losses. The real damage—from account takeovers, stolen stored value, and identity theft—rarely shows up in dispute metrics. These hidden costs eat into margins just as much as chargebacks, but they’re rarely tagged as fraud in internal reporting. **Who is affected and how** Ecommerce and airlines are feeling this acutely. Account takeovers (ATOs) are surging, and they’re not just about stolen credit cards. Attackers are after loyalty points, stored value, and personally identifiable information (PII). The impact cascades: customer churn spikes, acquisition costs rise through negative word of mouth, and off-platform identity theft becomes a real threat. Even iGaming platforms are seeing similar patterns, with fraudsters exploiting account balances and reward systems. **The real-world impact and consequences** The hidden costs are staggering. When a customer’s account is taken over, you’re not just losing the transaction—you’re losing their trust. That trust is expensive to rebuild, often costing 5-10 times more to acquire a new customer than to retain an existing one. Beyond direct losses, there’s the operational drag. Teams spend hours investigating false positives, managing disputes, and cleaning up after ATOs. These costs rarely appear in chargeback reports but directly impact profitability and growth. **Technical breakdown (the “how” explained simply)** Here’s how it works: fraudsters don’t just target credit cards anymore. They use credential stuffing—automated tools that test stolen usernames and passwords across multiple sites—to break into accounts. Once inside, they drain stored value, steal personal data, or make fraudulent purchases. The problem is that these activities often don’t trigger chargebacks. The legitimate account holder might not notice for days or weeks. By the time they do, the damage is done, and the loss is absorbed by the business, not the payment network. **What should be done — mitigation and recommendations** The fix starts with broadening how you measure fraud. Stop relying solely on chargeback rates. Track ATO rates, account recovery costs, and customer churn linked to security incidents. Invest in real-time fraud prevention that catches attacks before they happen. Tools like IPQS’s platform analyze behavior patterns, device fingerprints, and transaction velocity to flag suspicious activity instantly. Train your team to recognize the full spectrum of fraud, not just chargebacks. **Why this matters in the bigger cybersecurity landscape** This isn’t just about better metrics—it’s about rethinking what fraud prevention means. The strongest programs don’t just stop fraud; they protect customer experience, enable safe marketing growth, and give leadership confidence that risk controls support long-term success. As Alexander Hall puts it, when you understand that chargebacks are only one symptom, you can redesign your fraud program around a wider set of outcomes. The future belongs to teams that see the full picture.

Lawmakers Demand Answers as CISA Tries to Contain Data Leak

Data Breach

A CISA contractor with admin-level access just did the unthinkable: they posted the agency’s crown jewels—including AWS GovCloud keys—on a public GitHub account. The kicker? They named the profile “Private-CISA” as if that would somehow keep it secret. This isn’t just a screw-up. It’s a wake-up call for every organization that trusts contractors with sensitive systems. If you’re in government, critical infrastructure, or any sector handling classified data, your risk just spiked. The leak is still being contained, and lawmakers are already demanding heads roll.

**What exactly happened** On May 18, cybersecurity outlet KrebsOnSecurity revealed that a CISA contractor had created a public GitHub profile called “Private-CISA.” Inside that repo? Plaintext credentials to dozens of internal CISA systems, including AWS GovCloud keys—the kind of access that could let an attacker waltz into classified government cloud environments. The contractor didn’t just make a mistake. Commit logs show they deliberately disabled GitHub’s built-in protection against publishing sensitive credentials. This wasn’t an accident; it was a conscious bypass of security controls. **Who is affected and how** The immediate victims are CISA and any agency relying on its infrastructure. But the ripple effects extend to every organization that shares data with CISA—state election boards, critical infrastructure operators, and federal partners. If those leaked keys were used maliciously, an attacker could have accessed GovCloud environments hosting sensitive threat intelligence, incident response data, or even classified communications. The contractor’s admin-level access means the exposure could go far beyond just credentials. **The real-world impact and consequences** CISA claims “no indication that any sensitive data was compromised.” But experts who reviewed the repo say it was created in November 2025 and used as a working scratchpad—meaning secrets were exposed for months. Lawmakers aren’t buying the “no harm done” line. Sen. Maggie Hassan and others have sent letters demanding answers. The incident erodes trust in CISA’s ability to secure its own house while telling everyone else to lock theirs down. **Technical breakdown** The contractor used GitHub as a personal sync tool—copying files between work and home machines. They disabled GitHub’s secret scanning, which would have flagged the exposed credentials. The repo contained plaintext passwords, API keys, and AWS GovCloud access tokens. Truffle Security researchers found the most sensitive secrets were added in late April 2026. That’s barely a month before the leak was discovered. The contractor essentially created a backdoor for themselves, and left it wide open for anyone who knew where to look. **What should be done — mitigation and recommendations** CISA must immediately rotate all compromised credentials, audit access logs for unauthorized activity, and review every system the contractor touched. But the bigger fix is cultural: contractors shouldn’t have admin-level access without continuous monitoring. Organizations should enforce GitHub secret scanning, block personal repos on work machines, and implement data loss prevention for code repositories. The lesson? Never assume a contractor will follow security protocols just because they have clearance. **Why this matters in the bigger cybersecurity landscape** This isn’t just a CISA problem. It’s a textbook example of insider risk amplified by poor oversight. Government agencies spend billions on perimeter defenses, but a single contractor with admin access can bypass them all. The incident also highlights the danger of “shadow IT”—employees using personal tools for work. Until agencies treat contractor access with the same rigor as employee access, this will happen again. And next time, the leak might not be contained so quietly.

CISA Admin Leaked AWS GovCloud Keys on Github

Data Breach

A CISA contractor just left the keys to the kingdom on a public GitHub repo. We're talking AWS GovCloud credentials, internal system access, and a blueprint of how the agency builds and deploys software. This isn't just a slip-up—it's one of the most jaw-dropping government data leaks in recent memory. Who's at risk? Every agency and citizen relying on CISA's cybersecurity guidance. If an adversary grabbed these keys, they could have waltzed into highly classified cloud environments and internal networks. The fact that it took a third-party security firm to sound the alarm makes this a five-alarm fire for federal security.

**What exactly happened** A contractor working for CISA maintained a public GitHub repository named "Private-CISA" that leaked a treasure trove of sensitive data. Security researcher Guillaume Valadon from GitGuardian spotted the exposure on May 15 after the repo's owner ignored automated alerts. The archive contained AWS GovCloud keys, plaintext passwords, SSH tokens, and detailed documentation of CISA's internal software development process. **Who is affected and how** This leak puts CISA's entire digital infrastructure at risk. GovCloud is the government's most sensitive cloud environment, used for classified workloads. The exposed credentials could have allowed an attacker to access internal CISA systems, modify security tools, or pivot to other federal networks. Any organization that relies on CISA for threat intelligence or incident response—which is basically every US government agency—could face downstream consequences. **The real-world impact and consequences** The timing couldn't be worse. CISA is the nation's lead agency for defending against cyber threats, and this leak undermines its credibility. If adversaries exploited these credentials, they could have disrupted critical infrastructure monitoring or planted backdoors in security tools. The fact that the repo included build and deployment processes gives attackers a playbook for future attacks. This isn't just an embarrassment—it's a national security risk. **Technical breakdown** The repo's commit logs reveal a shocking lack of security hygiene. The CISA admin disabled GitHub's default protection that blocks users from publishing secrets in public repos. Passwords were stored in plaintext CSV files, and SSH keys were committed directly. Valadon noted this is a textbook example of poor security practices—the kind of thing that would fail any basic audit. The contractor appears to have used the repo to sync files between a work laptop and home computer, committing regularly since November 2025. **What should be done — mitigation and recommendations** CISA must immediately rotate all exposed credentials, revoke access for the contractor, and conduct a full forensic audit. They need to implement automated secret scanning across all repositories and enforce GitHub's security defaults. The agency should also review its contractor vetting process and mandate security training for anyone with privileged access. For other organizations, this is a wake-up call to scan public repos for secrets and never disable security features. **Why this matters in the bigger cybersecurity landscape** This leak exposes a systemic problem: even the agency responsible for national cybersecurity can't secure its own house. It highlights the dangers of contractor access, the risks of shadow IT, and the critical need for automated secret detection. As one security expert put it, "This would be an embarrassing leak for any company, but it's even more so for CISA." The incident should force a reckoning across all federal agencies about how they manage and monitor privileged access.

Vulnerabilities & CVEs

Drupal: Critical SQL injection flaw now targeted in attacks

Imagine waking up to find your website has been turned into a digital puppet, with hackers pulling the strings from the shadows. That’s the nightmare Drupal users are facing right now. A critical SQL injection flaw, tracked as CVE-2026-9082, is being actively exploited in the wild, and the clock is ticking for anyone running an unpatched version of this popular content management system. This isn’t just a theoretical risk. Drupal’s own advisory, updated on May 22, confirms that exploit attempts have been detected. The flaw lives in Drupal’s database abstraction API, and it’s particularly nasty for sites using PostgreSQL. Hackers can send specially crafted requests to inject malicious SQL commands directly into your database, all without needing any login credentials. That means they can steal data, delete information, escalate privileges, or even execute remote code on your server. The vulnerability is rated “highly critical” by Drupal, scoring a 23 out of 25 on their internal scale. While NIST gives it a more moderate 6.5 on the CVSS scale, the real-world impact is undeniable. If you’re running Drupal 8.9.x, 10.4.x through 10.6.x, or any 11.x version before the specific patches, you’re in the crosshairs. The affected versions are a long list, so don’t assume you’re safe just because you updated recently. Here’s the kicker: even if you’re not using PostgreSQL, you should still update immediately. The latest security patches also fix vulnerabilities in upstream dependencies like Symfony and Twig. Think of it as a digital vaccine that protects against multiple strains of malware at once. For those still clinging to Drupal 8 or 9, it’s time to face the music. These versions are end-of-life, meaning patches are provided on a best-effort basis. Continuing to use them is like leaving your front door unlocked in a high-crime neighborhood—it’s not a matter of if you’ll be hit, but when. The takeaway is simple: upgrade now. Don’t wait for a breach to be your wake-up call. Visit the Drupal security page, find your version’s latest release, and apply the update. Your website’s data—and your reputation—depend on it.

Breaking the Sound Barrier, Part II: Exploiting CVE-2024-54529

Imagine a ghost in the machine, hiding inside your Mac’s own audio system. That’s the reality behind CVE-2024-54529, a dangerous “type confusion” bug that lets an attacker trick macOS into treating one kind of data object as another. The flaw lives deep inside coreaudiod, a system daemon that handles everything from microphone input to speaker output. By sending a specially crafted message, an attacker can make the daemon misidentify a harmless piece of memory as a powerful, executable object. The result? A crash that’s actually a door—one that can be pried open for full control. This isn’t just a theoretical risk. The vulnerability affects every Mac running a vulnerable version of macOS, and the impact is severe. Because coreaudiod runs with system-level privileges, a successful exploit can break out of the app sandbox and gain code execution at the kernel’s level. Think of it as a backdoor into the very heart of your operating system. The researcher who found it, working through a method called “knowledge-driven fuzzing,” had to navigate a maze of dead ends—heap spraying, uninitialized memory, and carefully orchestrated crashes—just to turn a crash into a working exploit. It’s a stark reminder that even the most mundane system components can become attack surfaces. So what can you do? First, update your Mac immediately. Apple has patched CVE-2024-54529 in recent security updates, so running the latest version of macOS is your first line of defense. Second, stay cautious about what apps you install and what permissions you grant—especially microphone and audio access. Third, consider enabling FileVault and keeping your firewall active to add layers of protection. The researcher has open-sourced their tools, including a proof-of-concept, so security teams can test their own systems. But for everyday users, the takeaway is simple: patch early, patch often, and remember that even your Mac’s sound system can be a silent threat.

Vulnerability CVE-1999-0095

There's a ghost in the machine, and it’s been lurking since the 1990s. A vulnerability known as CVE-1999-0095 has resurfaced in Sendmail, a core email server software. The problem? The debug command is left enabled, giving attackers a direct line to execute commands as the root user. That means total system takeover with zero authentication required. This isn't just a minor glitch. Anyone running an outdated or misconfigured Sendmail server is wide open. From small businesses to large enterprises, if your email traffic flows through Sendmail, you're at risk. The impact is catastrophic: attackers can read, modify, or delete any file on the system, install malware, or pivot to other connected networks. It's like handing the keys to your entire digital infrastructure to a stranger. The fix is straightforward but urgent. First, disable the debug command in Sendmail by updating your configuration files. Second, apply the latest patches from your vendor—this vulnerability has been known for decades, so patches exist. Finally, audit your system for any signs of compromise, like unexpected root processes or altered system files. Don't let a relic from the past become your present-day nightmare.

Vulnerability CVE-1999-0082

A blast from the past just resurfaced, and it's a reminder that old code never truly dies. A vulnerability from 1999, CVE-1999-0082, is making headlines again because it highlights a classic, devastating flaw: a simple command in an FTP server could hand over root access. This isn't about some complex, multi-stage attack. It's about the "CWD ~root" command in certain FTP daemons (ftpd). By sending this seemingly innocent request, an attacker could trick the server into giving them a directory traversal, effectively breaking out of the user's sandbox and landing in the root user's home directory. From there, full system compromise was a short walk. Who should care? Anyone running legacy FTP servers or systems that haven't been patched in over two decades. While modern systems have largely moved on from this specific bug, the underlying principle is a stark warning for anyone managing older infrastructure, like embedded devices, industrial control systems, or internal servers that never got a security update. The impact is total: an attacker gains complete control, can steal data, install backdoors, or use the server as a launchpad for further attacks. The takeaway is simple, but powerful. First, if you're still running an FTP server from the late 90s, stop. Immediately. Replace it with a modern, secure alternative like SFTP or FTPS. Second, audit your systems. Any device or server that hasn't been patched in years is a ticking time bomb. Finally, remember the lesson: even the simplest commands can be weaponized. Always apply the principle of least privilege, and never trust user input, especially in core services. This old vulnerability is a loud echo of a lesson we keep learning the hard way.

Vulnerability CVE-1999-1471

Remember that old saying about too much of a good thing? In the world of BSD-based operating systems from the 4.3 era and earlier, a simple string of characters could turn a harmless user command into a digital skeleton key. That’s the story behind CVE-1999-1471, a classic buffer overflow lurking inside the `passwd` utility. This wasn’t some sophisticated remote hack. It was a local exploit, meaning someone already had a toehold on the system. The trick was deceptively simple: by feeding the `passwd` command an overly long string in the shell or GECOS fields (those little boxes for your name and office info), the program would overflow its memory buffer. And when that buffer burst, it handed over the keys to the kingdom—full root privileges. Who felt the sting? Anyone running BSD 4.3 or earlier. Think of it as a flaw in the very plumbing of the system, where a single user could escalate their access from a regular account to the all-powerful root account. The impact was total compromise: an attacker could install software, modify system files, spy on other users, or wipe everything clean. For organizations running these systems, it was a nightmare scenario hiding in plain sight. So, what’s the takeaway for today? While this specific vulnerability is ancient history, its lesson is timeless. First, always patch promptly. If you’re maintaining legacy systems, check for updates or workarounds. Second, enforce the principle of least privilege: don’t let users run `passwd` with elevated permissions unless absolutely necessary. Third, validate all input. Modern systems have safeguards against buffer overflows, but old habits die hard. Finally, if you’re still running BSD 4.3 or earlier, it’s time to migrate. Seriously. The digital world has moved on, and so should your infrastructure. In the end, CVE-1999-1471 is a reminder that even the smallest oversight—a forgotten field, a missing length check—can open the door to disaster. Stay sharp, keep your systems updated, and never underestimate the power of a well-crafted string.

Vulnerability CVE-1999-1122

Imagine a backdoor so old it’s practically a fossil—yet it still works. That’s the story behind CVE-1999-1122, a vulnerability in the `restore` command on SunOS 4.0.3 and earlier versions. This wasn’t a sophisticated hack; it was a simple flaw that let local users quietly grab system-level privileges, like a skeleton key left in an ancient lock. Who’s affected? Anyone still running SunOS 4.0.3 or older—think legacy systems in research labs, old servers, or forgotten hardware. The impact is blunt: a local user, maybe a disgruntled employee or a curious student, could escalate their access to root. That means full control over the machine, from reading files to deleting logs. For modern environments, this is a relic, but it’s a reminder that old code can haunt you if left unpatched. So, what should you do? First, check if any SunOS 4.0.3 systems are still breathing in your network—unlikely, but worth a scan. If they exist, isolate them immediately; don’t let them touch critical data. Second, apply any available patches from Sun (now Oracle) or consider migrating to a supported OS. Finally, treat this as a lesson: old vulnerabilities don’t die, they just wait. Regular audits and updates are your shield against these digital zombies.

Vulnerability CVE-1999-1467

Imagine a backdoor that’s been quietly hiding in plain sight for decades. That’s the story of CVE-1999-1467, a vulnerability in the rcp command on SunOS 4.0.x systems. This flaw lets attackers from trusted hosts execute any command as the almighty root user. It’s like giving a house key to a neighbor, only to find they can walk in and redecorate your entire home. The core issue revolves around how the system handles the “nobody” user. When rcp is configured to trust certain hosts, it doesn’t properly check who’s knocking. An attacker on a trusted machine can slip through, impersonate root, and run commands that can delete files, install malware, or steal sensitive data. It’s a classic case of trust being exploited. Who’s affected? Anyone running SunOS 4.0.x, which was a popular operating system in the early 1990s. While this might sound ancient, many legacy systems in critical infrastructure—like power grids or financial networks—still run outdated software. The impact is severe: a full system compromise from a trusted host. That means attackers can pivot to other machines, escalate privileges, or cause chaos without raising alarms. For those still using these systems, the fix is straightforward but crucial. First, disable rcp or restrict its use to only essential, monitored operations. Second, update to a patched version of SunOS if available, or migrate to a modern OS entirely. Third, audit your trusted hosts list—remove any that aren’t absolutely necessary. Finally, implement strict user permissions and monitor for unusual root activity. The takeaway here is timeless: trust no one, even from within your network. This vulnerability reminds us that old code can still bite, and a single misconfiguration can open doors for attackers. Stay vigilant, patch early, and always question who you’re letting in.

Vulnerability CVE-1999-1506

Imagine a ghost from the dawn of the internet, still lurking in the shadows of your email server. That’s CVE-1999-1506 for you. This vulnerability in SMI Sendmail 4.0 and earlier, running on SunOS up to version 4.0.3, lets a remote attacker waltz right in and access the user "bin." It’s not a flashy exploit—no fireworks or data heists—but it’s a quiet backdoor that could let someone snoop on system files or mess with core functions. Who’s affected? If you’re still running ancient SunOS or SMI Sendmail from the late 90s, this is your wake-up call. But here’s the twist: most modern systems have patched this decades ago. The real impact hits organizations clinging to legacy infrastructure—think old research labs, embedded systems, or vintage servers in dusty closets. For them, this vulnerability opens a door to privilege escalation or information leaks, potentially compromising the entire system’s integrity. What should you do? First, check your systems for any Sendmail version older than 4.0 on SunOS 4.0.3 or earlier. If you find one, upgrade immediately to a supported version—like Sendmail 8.x or later—which has long since fixed this flaw. For systems that can’t be updated (hello, legacy hardware), isolate them on a separate network segment with strict firewall rules. Block all unnecessary inbound traffic, especially to port 25 (SMTP), and monitor logs for unusual activity. If you’re feeling extra cautious, replace Sendmail with a modern alternative like Postfix or Exim. This vulnerability is a relic, but it’s a reminder that old code never truly dies—it just waits for someone to wake it up. Don’t let that someone be an attacker. Patch, isolate, or retire those ancient systems before they become your biggest security headache.

Vulnerability CVE-1999-0084

Imagine a backdoor so old it predates Y2K panic, yet still creeps into modern networks. That's CVE-1999-0084—a vulnerability that lets anyone with a keyboard turn a simple command into a privilege escalator. The trick is deceptively simple. Using `mknod`, an attacker creates a special file that mimics the system's memory device (`kmem`). Once that's done, they can overwrite critical kernel data and set their user ID to zero—the all-powerful root. It's like forging a master key to the entire server. This flaw lives in certain NFS (Network File System) servers. If your organization still runs legacy Unix systems or older Linux distributions with NFS enabled, you're at risk. Even partial exposure—like a misconfigured NFS export—could let an attacker on the network hijack the server entirely. The impact is total compromise. Once root is gained, attackers can steal data, install backdoors, or pivot to other systems. For industries like finance, healthcare, or government, that's a regulatory nightmare. Small businesses aren't safe either—anyone with an old server in a closet could be vulnerable. Here's the good news: this vulnerability is ancient, so most modern systems are patched. But if you're running legacy hardware or software for compatibility reasons, you need to act. First, audit your NFS exports. Disable any that allow `root` squashing or write access to sensitive directories. Next, patch or upgrade your NFS server software. If that's not possible, restrict access with firewalls—only allow trusted IPs to connect. Finally, monitor logs for unusual `mknod` commands or sudden UID changes. A simple script can alert you to these red flags. In a world of zero-days and AI-powered attacks, it's easy to forget the classics. But CVE-1999-0084 proves that old vulnerabilities never die—they just wait for someone to forget them. Don't be that someone.

Vulnerability CVE-2000-0388

Picture this: you're casually working on your FreeBSD system, and a seemingly harmless environmental variable—TERMCAP—turns into a loaded weapon. That's the reality behind CVE-2000-0388, a buffer overflow vulnerability lurking in the libmytinfo library. Attackers can exploit it by feeding an overly long TERMCAP variable, overflowing the buffer and gaining the power to execute arbitrary commands. It's a classic case of a simple input turning into a digital Trojan horse. Who's in the crosshairs? Anyone running FreeBSD with the libmytinfo library is fair game. The impact is local, meaning an attacker needs some form of access to the system first—think a disgruntled employee or a compromised user account. Once they're in, they can elevate privileges, run malicious code, or even seize control of the machine. For organizations relying on FreeBSD for servers or critical infrastructure, this isn't just a nuisance—it's a backdoor waiting to be kicked open. So, what's the fix? First, patch your system. FreeBSD released updates to address this flaw, so ensure your libmytinfo library is up to date. If patching isn't immediate, restrict local access to trusted users only. Monitor for unusual TERMCAP variable lengths or suspicious command executions. And remember, this vulnerability is a reminder that even small, overlooked components can pack a punch. Stay vigilant, keep your systems current, and never underestimate the power of a long string.

Vulnerability CVE-1999-0209

Remember when sharing meant sending a file? In 1999, a bug in SunView's selection_svc service let anyone on the network read files without permission. It's like leaving your desk unlocked in a co-working space—except the entire office is the internet. This vulnerability, CVE-1999-0209, turned a handy file-sharing tool into a backdoor for prying eyes. Who's affected? Anyone using SunView (also known as SunTools) on older Solaris or SunOS systems. Think of it as a legacy feature that never got a security update. The impact is simple but severe: a remote attacker could read any file on the system, from passwords to private documents. No authentication needed. No trace left behind. For businesses running these systems in the late 90s, it was a silent leak. What should you do today? If you're still running SunView or SunTools, patch immediately. For most of us, this is a history lesson: never trust default services that share files without permission. Modern equivalents? Be wary of any network service that doesn't ask for a password. Always disable unnecessary services, and keep your systems updated. Even old vulnerabilities can teach new tricks.

Vulnerability CVE-1999-1198

Here’s something you don’t see every day: a security flaw from 1999 that still teaches a brutal lesson about trust in software. Before the Y2K panic, before smartphones, a program called BuildDisk on NeXT computers had a dangerous shortcut. It didn’t ask for the root password. That’s it. No prompt, no check, no barrier. If you could run BuildDisk, you could become the all-powerful root user. In the late 90s, that was a golden ticket to total system control. Who felt the heat? Anyone using a NeXT system before version 2.0. Think early web pioneers, university labs, and creative studios running Steve Jobs’ iconic black hardware. The impact was direct and ugly: any local user—a student, a curious intern, a disgruntled employee—could escalate privileges without a single password guess. No brute force. No exploit kit. Just a missing prompt. For a general audience today, this sounds almost quaint. But the core threat is timeless. The software assumed the user was already authorized. It trusted the environment instead of verifying intent. That’s the same pattern behind modern privilege escalation bugs in cloud containers, IoT devices, and even some mobile apps. What can you do, decades later? First, understand the lesson: never assume a program will ask for permission. If a tool can perform a sensitive action—like formatting a drive or changing system settings—without authentication, it’s a risk. Second, apply the fix mindset. The solution for NeXT users was simple: update to version 2.0 or later, where the prompt was added. For you, that means always running the latest software versions. Patch early, patch often. Third, think about local access. Even now, many breaches start with someone who already has a keyboard. Lock down physical access, use strong user accounts, and never leave a root shell open. Finally, audit your own tools. Check if your backup software, disk utilities, or admin panels ask for credentials before doing something destructive. If they don’t, consider that a red flag. This old bug isn’t just history. It’s a reminder that security isn’t about fancy algorithms. Sometimes, it’s just about asking one simple question: “Are you sure?” And then actually waiting for the answer.

Found this issue useful?

Get daily insights delivered straight to your inbox. No spam. Unsubscribe anytime.