• Netizen: Monday Security Brief (6/29/2026)

    Today’s Topics:

    • Squidbleed Shows Why Old Proxy Code Still Belongs in the Threat Model
    • FortiBleed Shows Why Firewall Credentials Are Now Perimeter Risk
    • How can Netizen help?

    Squidbleed Shows Why Old Proxy Code Still Belongs in the Threat Model

    Squidbleed is the kind of vulnerability that looks small in code and much larger in an environment diagram. Tracked as CVE-2026-47729, the flaw is an out-of-bounds read in Squid’s FTP gateway that can leak fragments of proxy memory back to a client. In the worst case, that memory may contain another user’s cleartext HTTP request, including an Authorization header, bearer token, API key, session cookie, or other credential material that was never meant to leave the proxy process.

    The bug is being compared to Heartbleed for a reason. This is not remote code execution. It does not give an attacker shell access, modify traffic, or knock the service offline. It reads memory past the intended boundary and returns data that should have stayed inside the process. That makes the vulnerability easier to underrate if teams focus only on exploit categories, yet memory disclosure against a shared proxy can still be a direct path to account takeover. If a leaked header contains a valid token, the attacker does not need to exploit the victim’s endpoint. They can simply reuse what the proxy exposed.

    The threat model is narrow, but realistic. Squid describes the attacker as a trusted client, meaning someone already permitted to send traffic through the proxy. That matters in environments where Squid is used as a shared forward proxy for schools, enterprises, guest networks, public Wi-Fi, managed networks, or filtering gateways. The attacker does not need to be an external internet host hitting Squid from the outside. They need access as a proxy user, a Squid instance with FTP gateway functionality available, and an FTP server they control or can influence.

    That limitation is also what makes the bug easy to miss during risk scoring. CVSS places it in the moderate range with network attack vector, low attack complexity, low privileges required, no user interaction, high confidentiality impact, and no integrity or availability impact. On paper, that looks contained. In practice, a shared proxy is a collection point for other people’s requests. A confidentiality-only vulnerability in that position can still expose high-value secrets.

    The exposed traffic is also bounded. Standard HTTPS traffic sent through an HTTP CONNECT tunnel remains opaque to Squid, so Squidbleed does not magically decrypt the modern web. The most direct exposure is cleartext HTTP. The risk expands in deployments where Squid is configured to terminate or inspect TLS, such as SSL Bump environments, since the proxy can then see decrypted request contents before forwarding them upstream. Legacy internal applications, captive portals, old appliances, device management pages, and operational tools are the kinds of places where cleartext HTTP still tends to survive longer than security teams expect.

    The root cause sits in Squid’s FTP directory-listing parser. FTP directory listings are messy, old, and inconsistent across server implementations, so Squid contains parsing logic meant to turn FTP listings into something usable for clients. The vulnerable behavior traces back to compatibility handling introduced in 1997 for NetWare-style listings, where extra whitespace could appear between a timestamp and a filename.

    The parser advances a pointer after a parsed timestamp and then skips whitespace before treating the next bytes as the filename. The edge case appears when a crafted FTP listing line ends right after the timestamp and provides no filename at all. At that point, the pointer lands on the string terminator. The relevant C library behavior is the catch: strchr can match the terminating null byte in a string. If code asks whether that terminator appears inside the whitespace string, it can get a positive result. The parser then advances past the end of the intended buffer and keeps reading until it finds a byte that stops the scan.

    That is where an old parser bug turns into a data exposure issue. Squid reuses memory buffers, and reused heap memory may still contain data from prior transactions. If a buffer recently held part of a different user’s HTTP request, a crafted FTP listing can overwrite only a small portion of that buffer and cause Squid to return the remaining stale bytes as if they were part of an FTP filename. The attacker sees the data in the generated FTP directory response.

    Calif.io’s demonstration showed an Authorization header leaking from another client using the same proxy. That is the security impact in one line: a user who is allowed to use the proxy may be able to trigger a malformed FTP response and receive secrets from unrelated traffic handled by the same Squid process.

    The fix itself is small. Squid patched the FTP gateway parsing logic by checking for the null terminator before using the character membership test that caused the over-read. The official advisory lists Squid versions older than 7.6 as affected, with Squid 4.x, 5.x, 6.x, and 7.x through 7.5 vulnerable. Squid versions older than 3.5.28 were not tested and should be treated as vulnerable. Operators using vendor-packaged builds should rely on distribution advisories and backported package fixes rather than only checking the upstream version string.

    That distinction matters. Enterprise Linux distributions often backport security patches into older package versions. An environment may still show a Squid 5.x or 6.x package and be patched, or it may show a seemingly familiar package version that still lacks the fix. Ubuntu, for example, lists fixed Squid packages for supported releases such as 22.04 LTS and 24.04 LTS. Debian’s tracker shows fixed status for some releases and vulnerable status for others. The right validation step is to confirm the vendor package status or inspect whether the FtpGateway.cc guard is present.

    The better mitigation, where operations allow it, is to disable FTP through Squid entirely. FTP is a legacy protocol with little place in most modern browser-driven networks. Chrome removed FTP URL support years ago, and many organizations have little legitimate need for proxy-mediated FTP access. Squid’s own advisory provides a workaround that denies FTP traffic through the proxy, with an optional allowlist for trusted FTP destinations. In many networks, the safer answer is no allowlist at all.

    Blocking outbound TCP port 21 from the proxy can also reduce practical exploitability, but it should be treated as a compensating control rather than the full fix. A proxy policy change inside squid.conf is more direct, and a patched package removes the parser bug itself. Organizations should also review whether Squid is performing TLS interception, whether cleartext HTTP remains in use internally, and whether proxy users are segmented by trust level. A guest network user and a corporate endpoint should not be sharing sensitive proxy memory in the same risk bucket.

    Detection is not straightforward. A successful attempt may look like FTP traffic through Squid to an attacker-controlled server, followed by abnormal directory listing responses. Security teams can review Squid access logs for unexpected ftp:// requests, outbound connections to untrusted FTP servers, and spikes of repeated FTP listing activity from a single proxy client. Network controls can flag outbound FTP from proxy infrastructure, especially in environments that do not use FTP operationally. Still, the absence of obvious logs should not be treated as proof of safety. Memory disclosure vulnerabilities rarely leave clean, high-confidence forensic markers.

    The incident response question is less about wiping systems and more about credential exposure. If an organization confirms exploitability or suspicious FTP traffic through a vulnerable Squid instance, it should identify which applications and internal services still sent cleartext HTTP through that proxy. Tokens, API keys, basic authentication headers, session cookies, and service credentials exposed over HTTP should be rotated. Legacy internal applications that still rely on cleartext authentication deserve extra attention, as they are exactly the kind of systems that turn a moderate proxy bug into a real identity problem.

    Squidbleed also says something broader about aging internet infrastructure. The vulnerable logic survived for nearly three decades in a mature, widely deployed open-source proxy. It sat in compatibility code for an old FTP listing format tied to platforms most modern defenders will never touch. That is not an indictment of Squid alone. It is a reminder that mature software often carries protocol support, parser logic, and compatibility branches that outlive their original use case by decades.

    The AI angle is real, but it should not be exaggerated. Calif.io credited Anthropic’s Claude Mythos Preview with surfacing the strchr behavior quickly during research into Squid’s FTP state machine. That does not mean AI agents are suddenly replacing security engineering. It means they are becoming useful at finding weird interactions between old parser code, language semantics, and forgotten protocol features. For defenders, the lesson is practical: AI-assisted review may be most valuable in the code nobody wants to audit by hand anymore.


    FortiBleed Shows Why Firewall Credentials Are Now Perimeter Risk

    FortiBleed is not being treated as a new Fortinet zero-day, and that may be the most useful detail in the story. The campaign is larger than a single vulnerability bulletin. It is a credential problem at perimeter scale, involving internet-facing FortiGate firewalls and SSL VPN gateways where valid logins, old password hashes, weak account hygiene, and exposed management paths appear to have converged into a large verified access dataset.

    CISA issued guidance after reports that malicious actors were using compromised credentials against Fortinet devices across government and private-sector networks. The public numbers vary by source and date. CISA referenced leaked credentials tied to about 74,000 Fortinet devices. SOCRadar later reported 86,644 compromised FortiGate devices, more than 80,000 unique IPs, 22,405 domains, and exposure across 194 countries. Arctic Wolf placed the confirmed range between 30,000 and 75,000 devices in its June analysis, citing differences in dataset validation and source reporting. The exact count matters less than the operating model: the actors were not guessing at a few exposed VPN portals. They were building a verified inventory of working perimeter credentials.

    Fortinet has pushed back on the idea that FortiBleed is tied to a new product flaw. In its June 19 PSIRT post, the company said the activity appears to involve reused credentials from prior incidents and brute-force activity against devices with weak password hygiene and no MFA. Fortinet also said it was not related to any current incident or advisory. That distinction is technically meaningful. It also should not make defenders comfortable. A valid firewall login obtained through credential reuse can be just as operationally useful as access gained through an exploit chain.

    The risk starts with what FortiGate devices are. These appliances often sit at the boundary between the public internet and internal networks. They terminate VPN access, enforce firewall policy, route traffic, hold certificates, connect to identity providers, and often integrate with Active Directory, LDAP, RADIUS, TACACS+, SAML, or other authentication systems. Administrative access to that control plane gives an attacker far more than a login screen. It can provide network topology, user access paths, VPN visibility, configuration data, and a starting point for lateral movement.

    SOCRadar described FortiBleed as an automated operation built in two stages. The first stage tests curated username and password combinations against internet-facing Fortinet endpoints. The second stage reportedly uses successful access to collect more credentials from traffic passing through the device, feeding those credentials back into the same access operation. Dutch NCSC also warned that researchers had seen attackers collect packet captures from Fortinet systems in several cases, creating the possibility that more authentication material was exposed after initial firewall access.

    That is what makes this different from a normal credential stuffing story. The firewall is not just the target. Once compromised, it can become a collection point. A compromised SSL VPN or firewall appliance may expose user names, VPN sessions, internal addressing, authentication integrations, service accounts, and administrative behavior. If the appliance is tied into directory services, the downstream risk moves into identity infrastructure. Fortinet’s own guidance says that if AD or LDAP integration is configured, that account should be treated as compromised and monitored for use elsewhere.

    The older credential storage behavior adds another layer. Fortinet’s technical guidance says FortiOS 7.2.11, 7.4.8, and 7.6.1 introduced PBKDF2 for administrator password storage, replacing SHA-256-based storage. The migration is conditional. After an upgrade from an older version, administrator passwords can remain stored as SHA-256 hashes until the corresponding administrator logs in after the upgrade. Fortinet also notes that older SHA-256 values may remain in a hidden old-password setting for backward compatibility, visible in configuration backups taken by a super admin account.

    That matters for two reasons. First, SHA-256 is fast. Fast hashing is bad for password storage when an attacker can obtain hashes and work offline with GPU cracking rigs. Second, many organizations treat firmware upgrades as complete once the version number changes. In this case, the version number alone may not remove the weaker stored credential material. Admin logins, password resets, and Fortinet’s weaker-encryption lockout setting may still be needed to move accounts away from legacy hash exposure.

    This is why “patch and move on” is too narrow here. Updating FortiOS is part of the response, but FortiBleed is about credential state, session state, configuration state, and exposure state. A firewall can be on a newer train and still carry old credential baggage. A password can be complex and still be compromised if it was reused, leaked, harvested from an earlier incident, or cracked from a stored hash. An admin interface can be patched and still risky if it remains reachable from the public internet.

    The account patterns reported by SOCRadar point to basic but damaging failures. Generic admin accounts and Fortinet system-style accounts accounted for a large share of the exposed credentials. Organization-specific accounts also made up a significant portion of the dataset, which suggests the campaign reached beyond factory naming conventions and default behavior. This is a familiar perimeter problem: predictable account names reduce attacker cost, password reuse extends breach life, and exposed management interfaces let attackers test access at internet scale.

    For attackers, a valid FortiGate credential can be more valuable than a workstation foothold. It may allow rule changes, VPN account creation, configuration export, traffic capture, route manipulation, certificate inspection, logging changes, and stealthy access maintenance. A firewall is also a trust anchor in many environments. Security tools often assume it is enforcing policy correctly. If an attacker controls or modifies that enforcement point, detections inside the network may see only the later stages of an intrusion.

    That is the defensive lesson. FortiBleed should be treated as an identity incident and a perimeter device incident at the same time. Ending active SSL VPN and administrative sessions is the containment step that breaks live access. Password resets address known and unknown credential exposure. MFA limits replay. PBKDF2 migration reduces the value of stolen configuration hashes. Management access restrictions reduce the number of systems attackers can test. Log review determines whether the appliance was just exposed or actually used as a pivot.

    The log review should be wide. Firewall and VPN logs can show unexpected administrator access, unfamiliar source IPs, strange login times, failed sprays, successful logins after long dormancy, new local users, password resets, policy changes, route changes, certificate changes, and configuration exports. Domain controller and identity logs can show lateral movement after the perimeter event, such as unusual use of LDAP bind accounts, new privileged accounts, VPN users authenticating from rare geographies, or service accounts appearing outside their normal pattern. Configuration comparison against a known-good backup can catch subtle persistence that normal event review may miss.

    The response also needs to cover more than human administrator passwords. Local Fortinet administrators, VPN users, API accounts, service accounts, LDAP and RADIUS bind accounts, TACACS+ secrets, SAML-related credentials, shared accounts, and any reused credentials on adjacent edge devices should be rotated where exposure is plausible. If packet capture or traffic inspection occurred, downstream application credentials may also need review. Treating this as a single admin password reset can leave the real blast radius untouched.

    Management exposure is another core issue. Fortinet recommends trusted hosts as a baseline, local-in policy as a stronger control, and removal of internet administration as the preferred end state. That hierarchy is correct. Internet-facing firewall administration creates a public test surface for credential abuse. Even with MFA, every exposed login endpoint becomes an opportunity for enumeration, spraying, social engineering follow-up, and future vulnerability exploitation. Admin access should be reachable through controlled management networks, jump hosts, VPN paths with strong MFA, and explicit source restrictions.

    This incident also fits a broader pattern. Perimeter appliances have become high-value identity targets, not just vulnerability targets. Attackers do not always need a new exploit if they can reuse credentials from an old one. They do not need malware on an endpoint if a firewall hands them remote access. They do not need to decrypt the whole network if the gateway already sees enough traffic to collect the next set of secrets. FortiBleed shows how yesterday’s breach data, today’s exposed management interface, and legacy password storage can combine into a current intrusion path.

    The name makes the campaign sound like a single wound. The real problem is more structural. Many organizations still operate perimeter devices as static infrastructure, patched on a schedule and checked during audits, rather than as identity-bearing systems that need continuous credential rotation, configuration drift review, management-plane isolation, and telemetry. A firewall is not just a box that filters traffic. It is a privileged identity system with routes, secrets, sessions, and trust relationships attached to it.

    For Fortinet customers, the near-term answer is clear: terminate sessions, rotate credentials, confirm MFA, upgrade to supported FortiOS branches, force PBKDF2 migration, remove legacy hashes, review logs, compare configurations, and restrict management access. For any environment with signs of unauthorized configuration changes, unexpected accounts, suspicious VPN activity, or packet capture use, treat the appliance as compromised and investigate internal movement from that point forward.


    How Can Netizen Help?

    Founded in 2013, Netizen is an award-winning technology firm that develops and leverages cutting-edge solutions to create a more secure, integrated, and automated digital environment for government, defense, and commercial clients worldwide. Our innovative solutions transform complex cybersecurity and technology challenges into strategic advantages by delivering mission-critical capabilities that safeguard and optimize clients’ digital infrastructure. One example of this is our popular “CISO-as-a-Service” offering that enables organizations of any size to access executive level cybersecurity expertise at a fraction of the cost of hiring internally. 

    Netizen also operates a state-of-the-art 24x7x365 Security Operations Center (SOC) that delivers comprehensive cybersecurity monitoring solutions for defense, government, and commercial clients. Our service portfolio includes cybersecurity assessments and advisory, hosted SIEM and EDR/XDR solutions, software assurance, penetration testing, cybersecurity engineering, and compliance audit support. We specialize in serving organizations that operate within some of the world’s most highly sensitive and tightly regulated environments where unwavering security, strict compliance, technical excellence, and operational maturity are non-negotiable requirements. Our proven track record in these domains positions us as the premier trusted partner for organizations where technology reliability and security cannot be compromised.

    Netizen holds ISO 27001, ISO 9001, ISO 20000-1, and CMMI Level III SVC registrations demonstrating the maturity of our operations. We are a proud Service-Disabled Veteran-Owned Small Business (SDVOSB) certified by U.S. Small Business Administration (SBA) that has been named multiple times to the Inc. 5000 and Vet 100 lists of the most successful and fastest-growing private companies in the nation. Netizen has also been named a national “Best Workplace” by Inc. Magazine, a multiple awardee of the U.S. Department of Labor HIRE Vets Platinum Medallion for veteran hiring and retention, the Lehigh Valley Business of the Year and Veteran-Owned Business of the Year, and the recipient of dozens of other awards and accolades for innovation, community support, working environment, and growth.

    Looking for expert guidance to secure, automate, and streamline your IT infrastructure and operations? Start the conversation today.


  • The Growing Market for Stolen Browser Data

    The modern browser has become one of the most valuable data repositories in the enterprise. It stores passwords, cookies, active sessions, autofill fields, saved payment details, authentication tokens, browsing history, device identifiers, and traces of nearly every cloud platform a user touches during the workday. For attackers, that makes the browser less like a utility and more like a portable identity vault.

    The market for stolen browser data has grown around that reality. Criminal marketplaces no longer need to sell only usernames and passwords. They can sell full identity packages: the credential, the session cookie, the login URL, the user’s device metadata, the browser profile, the local context, and sometimes the victim’s screenshot at the time of infection. That combination gives buyers more than a password. It gives them the ability to impersonate a real user with less friction, fewer alerts, and a greater chance of bypassing traditional authentication controls.

    This shift is changing the economics of cybercrime. A single endpoint infection can produce dozens of usable credentials across corporate applications, personal accounts, VPN portals, cloud consoles, developer tools, email platforms, password managers, and SaaS environments. The infected machine does not need to belong to a domain administrator to create enterprise risk. A personal device used to check work email, log into Microsoft 365, access a ticketing system, or authenticate into a cloud dashboard can produce enough browser data to become the first step in a larger intrusion.

    The result is a market where browser data has become a raw material for account takeover, fraud, ransomware, data extortion, identity abuse, and initial access brokerage.


    What Stolen Browser Data Actually Contains

    The phrase “stolen credentials” can understate the issue. Infostealer malware is usually built to extract a much broader set of browser artifacts. A typical stealer log may contain saved usernames and passwords, authentication cookies, session tokens, autofill data, browser history, downloaded file history, cryptocurrency wallet files, local application data, screenshots, hostnames, IP addresses, operating system details, installed software, and browser profile metadata.

    This matters since the value of the log is tied to context. A password by itself may be blocked by MFA, conditional access, password rotation, or impossible-travel detection. A session cookie can be more useful to an attacker since it may represent a session that already passed MFA. A login URL tells the buyer what service the credential belongs to. Device metadata helps the attacker reproduce the victim’s environment. Browser history can reveal which applications the victim uses, which administrative portals are active, and which organizations may be linked to the account.

    A stealer log, then, is not just a list of secrets. It is a snapshot of the user’s digital working environment.

    This is one reason browser data is so attractive to downstream criminals. A buyer can search a marketplace for logs tied to a target domain, a cloud provider, a bank, a cryptocurrency service, an RMM platform, a VPN appliance, or a government email address. The buyer does not need to run the malware campaign personally. They can purchase the output of someone else’s infection operation and focus on exploitation.

    That division of labor has made stolen browser data a core component of cybercrime supply chains.


    How the Market Became Industrialized

    The infostealer market has matured into a service economy. Developers build and maintain malware families. Affiliates distribute them through phishing, cracked software, fake browser updates, malicious ads, search engine poisoning, Discord lures, game cheats, fake AI tools, and compromised websites. Log sellers aggregate the stolen data. Marketplaces index it. Initial access brokers turn selected entries into enterprise intrusion opportunities. Fraud actors use the same data for bank, crypto, email, and social account takeover.

    This model scales. The person who infects a machine is often not the person who uses the stolen session. The operator who runs the stealer may sell raw logs in bulk. Another actor may parse those logs for corporate domains. A third actor may test credentials against VPN, SSO, or cloud portals. A ransomware affiliate may purchase only the subset of access that supports lateral movement or data theft.

    Markets such as Genesis Market, Russian Market, 2easy, Telegram-based log shops, and invite-only criminal forums helped normalize this structure. Genesis was especially significant since it packaged credentials together with browser cookies and device fingerprints. That model allowed buyers to impersonate victims more convincingly by making their access attempts look closer to the original user’s browser and device profile.

    Even after takedowns, the model persists. Criminal infrastructure is disrupted, operators lose domains, servers are seized, and some users are arrested, but the market adapts. New shops appear, existing shops absorb demand, sellers shift channels, and malware families are rebranded or replaced. The demand side remains strong since the product solves a central attacker problem: getting valid access without burning time on exploitation.


    Why Session Cookies Changed the Value of the Market

    MFA changed the economics of password theft. It did not end credential abuse, but it reduced the usefulness of a password in isolation. Infostealer operators responded by placing more value on session material.

    A session cookie is powerful since it can prove to an application that a user has already authenticated. In many environments, the application does not challenge the user again until the session expires, the risk score changes, or the token is revoked. If an attacker can replay that session from a compatible environment, they may avoid the login sequence entirely.

    This is why stolen browser data is often more dangerous than breached password data. A reused password may trigger MFA. A session artifact may bypass the MFA step entirely. A password reset may not invalidate every active session. A user may change a password and still remain logged in across browsers, mobile apps, and SaaS sessions. If incident response focuses only on password rotation, the attacker may keep access through tokens or cookies that were never invalidated.

    This also changes detection. A brute-force attempt, impossible travel event, or failed MFA challenge can stand out. A replayed session may look like normal post-authentication activity, particularly when the attacker uses residential proxies, browser automation, stolen fingerprints, or infrastructure near the victim’s region. From the application’s view, the attacker may appear to be an already authenticated user returning to an active session.

    That makes stolen browser data an identity-layer problem rather than a malware problem alone.


    Infostealers as an Initial Access Pipeline

    Infostealers are often treated as commodity malware, but their downstream use can be far more serious than the initial infection suggests. A user may download a fake software installer on a personal laptop. The stealer runs for seconds, extracts browser data, sends a compressed archive to a command-and-control server, and exits. The endpoint may never touch a corporate network. No ransomware runs. No lateral movement occurs at the time of infection.

    The enterprise impact begins later.

    If the user has logged into corporate SaaS from that machine, the stolen log may contain access to email, SSO, VPN, cloud storage, CRM, source code repositories, ticketing systems, payroll systems, or administrator portals. A broker can identify those entries and sell them to a buyer focused on enterprise compromise. That buyer may then use the access to enumerate internal data, create OAuth grants, register MFA devices, add inbox rules, access cloud files, or pivot into other systems.

    This creates a delayed blast radius. The infection event and the breach event may be separated by hours, days, or weeks. Security teams may clean the endpoint without knowing that its browser data has already entered an underground market. A password reset may occur after the session has already been replayed. A user may have no sign that their browser profile has become an access package.

    The market thrives on that delay.


    The Role of Personal Devices and Identity Sprawl

    The stolen browser data problem is made worse by identity sprawl. Users mix personal and professional browsing. They access work applications from unmanaged devices. They save corporate credentials in consumer browsers. They reuse passwords across personal accounts and work-adjacent tools. Contractors, vendors, executives, developers, and remote workers may all create exposure outside managed endpoint telemetry.

    This breaks many defensive assumptions. An organization may have strong EDR coverage on corporate laptops, but no visibility into a personal system used to access cloud email. It may enforce MFA, but allow long-lived browser sessions. It may centralize SSO, but still permit unmanaged devices for certain SaaS platforms. It may rotate passwords, but leave OAuth tokens and active sessions untouched.

    Developers introduce another high-value exposure point. Browser data on a developer workstation may include access to GitHub, GitLab, CI/CD platforms, package registries, cloud consoles, secrets managers, issue trackers, and internal documentation. A stolen browser profile from one developer can expose code, deployment workflows, API keys, infrastructure credentials, and third-party integrations.

    For executives, the risk is different but just as severe. Browser sessions may expose email, financial systems, HR platforms, board materials, legal correspondence, and approval workflows. Attackers can use that access for fraud, business email compromise, extortion, or reconnaissance.

    The common thread is that the browser has become a bridge between human identity and enterprise systems.


    Why Marketplace Data Is Hard to Defend Against

    Stolen browser data creates several problems for defenders.

    The first is speed. Stealer logs can be posted, indexed, searched, resold, and exploited quickly. By the time an organization learns that an employee’s credentials appeared in a log, the highest-value material may already have been used or resold.

    The second is attribution. A login using stolen session data may not look like malware activity. It may look like a user accessing a cloud service from a new IP, a familiar browser, or a plausible device profile. If the attacker uses a proxy close to the victim, location-based controls may not trigger.

    The third is scope. One infected machine can expose many identities across many platforms. Traditional incident response often treats credential compromise as an account-level event. Infostealer exposure has to be treated as a device-level identity spill. Every account, token, cookie, OAuth grant, API key, and saved login touched by that browser profile may be in scope.

    The fourth is data quality. Stealer logs are noisy. They may contain old passwords, expired cookies, personal accounts, duplicates, typos, and stale artifacts. Criminal buyers account for that by testing and filtering at scale. Defenders need a process that can triage exposure without creating alert fatigue.

    The fifth is ownership. Browser data often spans corporate and personal boundaries. A corporate security team may discover that a user’s personal Gmail, personal password manager, and work SSO were present in the same stealer log. That creates response, privacy, and policy issues that many organizations have not planned for.


    Browser Vendors Are Raising the Cost, but the Market Is Still Active

    Browser and platform vendors are responding. Chrome’s App-Bound Encryption on Windows was built to reduce the ability of same-user malware to decrypt cookies directly through standard operating system protections. Device Bound Session Credentials go further by tying session use to a device-held private key, making stolen cookies less useful when replayed elsewhere.

    These controls raise attacker cost. Malware may need higher privileges, browser injection, live session manipulation, or more advanced tradecraft. That makes some theft noisier and easier for endpoint tools to detect.

    Still, these protections do not remove the market overnight. Coverage depends on browser version, operating system, hardware support, enterprise configuration, and application-side adoption. Many applications still rely on long-lived bearer tokens. Many environments still allow unmanaged devices. Many users still install untrusted extensions, cracked software, fake updates, and malicious tools. Attackers can also shift from offline cookie replay to adversary-in-the-browser techniques, malicious extensions, remote control, OAuth abuse, device code phishing, or live proxying.

    Defender strategy has to assume that browser data will remain a target even as browser security improves.


    What Security Teams Should Do

    The right response is not just “train users better” or “turn on MFA.” Those controls matter, but the stolen browser data market exists in part since attackers have learned how to work around them.

    Security teams need to treat browser data as part of the identity attack surface. That starts with policy. Organizations should define which browsers are approved, which extensions are allowed, whether password saving is permitted, which devices can access corporate SaaS, and how long sessions can persist. Browser management should be handled through enterprise policy where possible, not left to individual user choice.

    Conditional access should enforce device health, compliance state, geography, risk score, and phishing-resistant MFA for sensitive applications. Access from unmanaged devices should be limited, isolated, or blocked for high-risk services. Persistent sessions should be shortened for privileged users and sensitive apps. Token revocation needs to be part of standard incident response, not a rare step taken only after confirmed account takeover.

    Endpoint controls should watch for browser data access patterns. Attempts to read browser credential stores, cookie databases, local storage, browser profile directories, or password manager data should be treated as high-signal behavior. Chrome App-Bound Encryption event logs, suspicious browser process injection, abnormal access to DPAPI-protected data, and execution from user-writable paths should all feed detection logic.

    Security teams should also monitor underground exposure. Infostealer intelligence can identify employee credentials, session-bearing logs, contractor exposure, and third-party access risk before a breach is confirmed. This has to be paired with an internal response workflow: identify the user, determine whether the device is managed, revoke active sessions, rotate passwords, review OAuth grants, inspect recent SaaS activity, check mailbox rules, audit MFA changes, and look for follow-on access.

    For SaaS applications, defenders should collect logs that show session creation, token refresh, device registration, OAuth consent, impossible travel, suspicious user agents, new inbox rules, mass downloads, administrative changes, and access from anonymization infrastructure. The key is to focus on post-authentication behavior. If attackers are logging in with valid sessions, the strongest signals may appear after access is granted.

    For privileged users, the bar should be higher. Administrators, executives, developers, finance staff, and help desk personnel should use phishing-resistant MFA, managed devices, tighter session lifetimes, stronger browser controls, and stricter extension policies. Their browser profiles should be treated as high-value assets.


    The Market Will Keep Growing

    The market for stolen browser data is growing since it fits the way modern organizations work. Enterprise identity has moved into SaaS. SaaS has moved into the browser. The browser has become the place where authentication, productivity, administration, development, and communication converge.

    Attackers follow concentration of value. A browser profile can contain access to email, cloud storage, code, finance, customer data, internal tickets, identity platforms, and administrative consoles. It can also contain the session artifacts needed to avoid some login challenges. That makes it one of the most efficient targets in the modern intrusion chain.

    The defensive model has to change in response. Password resets alone are not enough. MFA alone is not enough. EDR alone is not enough. Organizations need identity-aware endpoint telemetry, managed browser policy, session revocation playbooks, device-bound access, phishing-resistant authentication, SaaS log coverage, and dark web exposure monitoring tied to real response actions.

    Stolen browser data has become a marketplace product because it collapses the distance between infection and access. The attacker does not need to exploit the perimeter if the browser already contains the keys to the environment. That is why this market matters, and why browser security now belongs at the center of enterprise identity defense.


    How Can Netizen Help?

    Founded in 2013, Netizen is an award-winning technology firm that develops and leverages cutting-edge solutions to create a more secure, integrated, and automated digital environment for government, defense, and commercial clients worldwide. Our innovative solutions transform complex cybersecurity and technology challenges into strategic advantages by delivering mission-critical capabilities that safeguard and optimize clients’ digital infrastructure. One example of this is our popular “CISO-as-a-Service” offering that enables organizations of any size to access executive level cybersecurity expertise at a fraction of the cost of hiring internally. 

    Netizen also operates a state-of-the-art 24x7x365 Security Operations Center (SOC) that delivers comprehensive cybersecurity monitoring solutions for defense, government, and commercial clients. Our service portfolio includes cybersecurity assessments and advisory, hosted SIEM and EDR/XDR solutions, software assurance, penetration testing, cybersecurity engineering, and compliance audit support. We specialize in serving organizations that operate within some of the world’s most highly sensitive and tightly regulated environments where unwavering security, strict compliance, technical excellence, and operational maturity are non-negotiable requirements. Our proven track record in these domains positions us as the premier trusted partner for organizations where technology reliability and security cannot be compromised.

    Netizen holds ISO 27001, ISO 9001, ISO 20000-1, and CMMI Level III SVC registrations demonstrating the maturity of our operations. We are a proud Service-Disabled Veteran-Owned Small Business (SDVOSB) certified by U.S. Small Business Administration (SBA) that has been named multiple times to the Inc. 5000 and Vet 100 lists of the most successful and fastest-growing private companies in the nation. Netizen has also been named a national “Best Workplace” by Inc. Magazine, a multiple awardee of the U.S. Department of Labor HIRE Vets Platinum Medallion for veteran hiring and retention, the Lehigh Valley Business of the Year and Veteran-Owned Business of the Year, and the recipient of dozens of other awards and accolades for innovation, community support, working environment, and growth.

    Looking for expert guidance to secure, automate, and streamline your IT infrastructure and operations? Start the conversation today.


  • The Next Software Supply Chain Problem May Not Be Code

    Software supply chain security has spent the last several years focused on source code, third-party packages, vulnerable libraries, and malicious dependencies. That focus made sense. Incidents like Log4Shell, dependency confusion, typosquatting, and compromised open-source packages made it clear that organizations needed better visibility into what their applications were built from.

    That visibility still matters. SBOMs, dependency scanning, signed artifacts, vulnerability intelligence, and secure development frameworks are now part of the baseline conversation for software risk. The problem is that attackers are also moving past the obvious target. The next major software supply chain failure may not begin with a vulnerable function, a poisoned library, or a malicious commit. It may begin with everything around the code.

    Modern software is no longer just written, reviewed, built, and shipped by people. It is assembled through CI/CD pipelines, package registries, GitHub Actions, build runners, signing keys, service accounts, AI coding assistants, secrets managers, release tokens, container builders, deployment automation, vendor portals, and third-party SaaS integrations. Every one of those pieces can influence what eventually runs in production. Every one of them can become a trust boundary.

    That is the part many organizations still underestimate. A clean code review does not prove that the build process was clean. A dependency scan does not prove that the package came from the expected workflow. An SBOM does not prove that runtime behavior matches what was declared at build time. A vendor security questionnaire does not prove that release automation cannot be bypassed. Supply chain risk has moved into the operational machinery that turns source code into deployed software.

    That shift changes the problem. The question is no longer just “what code are we using?” It is also “who or what was allowed to build it, sign it, publish it, modify it, and deploy it?”


    The Supply Chain Is the System That Produces the Software

    Many organizations still treat the software supply chain as a dependency inventory problem. They want to know which packages are present, which versions are vulnerable, and which vendors are connected to the product. That is a necessary starting point, but it is incomplete.

    A modern release path can include dozens of non-code decisions that materially affect risk. A workflow file can define what runs during a build. A package registry token can authorize a release. A GitHub Actions trigger can decide whether untrusted pull request input reaches a privileged job. A build runner can hold environment variables, cloud credentials, signing material, or deployment permissions. A release artifact can be produced outside the expected process and still appear legitimate to downstream consumers.

    From an attacker’s perspective, compromising the codebase is no longer the only path. It may not even be the easiest path. Stealing a publishing token can be more useful than landing a malicious pull request. Abusing a CI/CD workflow can be quieter than modifying application logic. Targeting a maintainer account can provide access that security tooling treats as normal. Manipulating the build process can place malicious behavior downstream without leaving obvious source-level evidence.

    This is why supply chain security has to expand past repository scanning. The repository is only one layer. The release pipeline, identity model, artifact store, and deployment path are also part of the product.


    The Nx Incident Showed the Risk Around Release Automation

    The 2025 Nx supply chain attack is a clear example of this shift. The issue was not simply that a malicious package appeared in npm. The more important lesson was how the release path became the attack path.

    Malicious versions of several Nx packages were published to npm after attackers exploited a GitHub Actions injection vulnerability and stole an npm publishing token. The packages were live for several hours and scanned user systems for sensitive data, including developer credentials and tokens. The payload also attempted to use local AI CLI tools, including Claude and Gemini, for reconnaissance and data exfiltration.

    That incident matters because it ties several supply chain trends together at once. The attacker did not need a conventional application vulnerability in a production system. They targeted automation, publishing authority, developer workstations, secrets, and AI-assisted tooling. The trust placed in a widely used package became the delivery mechanism.

    Nx later stated that the malicious packages lacked npm provenance signing, which helped identify that they did not come from the expected CI pipeline. That detail is important. Provenance did not prevent installation by itself, but it gave defenders a signal that the package did not match the normal release path. In a mature supply chain program, that signal should become enforceable policy rather than post-incident context.

    This is where many organizations are still behind. They may scan dependencies after installation, but they do not always block artifacts that lack expected provenance. They may require MFA for maintainers, but still rely on long-lived publish tokens. They may review source changes, but leave workflow files, release triggers, and build permissions under weaker control.

    The result is a supply chain model that trusts the final package more than it verifies the process that produced it.


    Provenance Is Becoming More Important Than Package Name

    For years, software trust has often been based on names and locations. Developers pull a package from npm, PyPI, Maven Central, GitHub, Docker Hub, or a vendor portal and assume that the package is what it claims to be. That model is fragile. Package names can be spoofed. Maintainer accounts can be compromised. Tokens can leak. Build jobs can be manipulated. Registries can host packages that are technically valid but operationally suspicious.

    Provenance changes the question. Instead of asking whether a package came from a known place, defenders can ask whether it was built by the expected workflow, from the expected repository, at the expected commit, under the expected identity.

    That distinction is becoming central to software supply chain security. A package name tells you what something claims to be. Provenance tells you how it came into existence. The second answer is much harder for an attacker to fake if the organization enforces it correctly.

    This is why trusted publishing, artifact attestations, Sigstore-style signing, and SLSA-aligned build controls are becoming more important. They help move the supply chain from implicit trust to verifiable trust. A signed artifact with build provenance gives security teams a way to connect a release to the process that created it. A short-lived OIDC publishing flow reduces the value of stolen long-lived tokens. A dedicated build environment reduces the risk of local developer machines becoming the release authority.

    None of this removes the need for code review or dependency scanning. It adds a missing control layer. Code can be safe and the release process can still be compromised. The inverse is also true: a package can look normal at the registry level and still fail provenance checks.

    The organizations that treat provenance as optional metadata will have a harder time detecting this type of attack. The organizations that treat provenance as a deployment requirement will have a stronger control point before malicious artifacts reach production.


    The Non-Human Identity Problem Is Growing

    The next supply chain problem may also be an identity problem.

    Software delivery is full of non-human identities. CI jobs authenticate to cloud providers. Build runners access artifact repositories. Deployment bots modify infrastructure. Package publishing workflows request tokens. Scanners read source code. Service accounts push container images. AI tools may access repositories, issue trackers, local files, terminal sessions, and internal documentation.

    These identities often have more reach than individual users. They may run across multiple projects. They may be exempt from normal MFA requirements. They may hold long-lived credentials. They may be poorly documented. They may lack clear ownership. In many environments, these accounts are treated as plumbing rather than privileged access.

    Attackers see the opposite. A non-human identity inside a build or release process is a high-value target. It can provide persistence, data access, publishing authority, cloud access, or deployment control. Compromising that identity can be more useful than compromising a single developer account.

    This is especially dangerous in CI/CD environments. A pipeline is usually trusted to run code, access secrets, fetch dependencies, build artifacts, sign releases, and deploy changes. If an attacker can influence the pipeline, they can often cross boundaries that would be blocked in a normal user session.

    The control model has to change. Release automation should not depend on broad, long-lived secrets stored in build systems. Workflows should use short-lived, scoped credentials where possible. Publishing should be bound to specific workflows and protected environments. Runners should be isolated by sensitivity. Secrets should not be exposed to untrusted pull request contexts. Build jobs should be treated like privileged production systems, not disposable developer conveniences.

    The supply chain is now an identity graph. Organizations that cannot map that graph cannot reliably defend it.


    AI Adds Another Supply Chain Layer

    AI is adding a new layer to the software supply chain, and it is not limited to generated code.

    Security teams are already paying attention to insecure code generated by AI assistants. That matters, but it is only part of the risk. AI tools are also being connected to repositories, terminals, ticketing systems, internal documentation, cloud environments, package managers, and build workflows. In some cases, AI agents can read files, write code, run commands, call APIs, open pull requests, summarize logs, modify configuration, or assist with releases.

    That means AI tooling can become part of the development and delivery chain. If it has access, it has to be governed. If it can act, its actions have to be logged. If it can read secrets, the exposure has to be treated as real. If it can execute commands, the execution path has to be constrained.

    The Nx incident showed one version of this problem from the attacker side: malware attempted to use local AI CLI tools for reconnaissance and exfiltration. That is a warning sign. AI developer tools are attractive to attackers because they may already have broad local context and user trust. They may know where projects are stored, how repositories are structured, which files look sensitive, and how to automate discovery across a workstation.

    For defenders, this creates a hard policy question. Is an AI coding assistant just a developer productivity tool, or is it a supply chain participant? If it can influence code, configuration, tests, dependencies, release notes, infrastructure, or deployment logic, the answer is clear. It belongs in the supply chain model.

    That does not mean organizations should ban AI development tools by default. It means they need controls that match the access level. AI tools should be restricted from secrets. Generated changes should go through the same review path as human-written changes. Agent actions should be logged. Tool permissions should be scoped. Local developer environments should not become uncontrolled bridges between repositories, cloud credentials, and AI execution.

    The security concern is not that AI writes code. The concern is that AI tools are being connected to privileged development contexts faster than many organizations can inventory or govern them.


    SBOMs Are Necessary, But They Are Not the Whole Answer

    SBOM adoption has improved software transparency by forcing organizations to document the components inside their applications. That is valuable. It gives teams a way to answer exposure questions faster when a dependency vulnerability is disclosed. It also helps with vendor risk, procurement, compliance, and incident response.

    Still, an SBOM is not a complete supply chain control by itself. It is an inventory artifact. It does not automatically prove that the build was trustworthy, that the published artifact matches source, that the runtime environment loaded only declared components, or that a package was produced by the expected workflow.

    This gap matters during real incidents. A static SBOM can tell an organization what was expected to be present at a point in time. It may not reveal what actually executed in memory, what a malicious post-install script did during package installation, what a compromised build runner injected, or whether a release artifact was created outside the approved pipeline.

    SBOMs should be paired with provenance, artifact signing, runtime visibility, and policy enforcement. The goal is not just to know what components exist. The goal is to know whether the software that reached production was built, signed, and deployed through a trusted path.

    That is a higher bar. It also fits the direction of modern software risk. Static inventory helps answer “what is inside this application?” Provenance helps answer “can we trust how this application was produced?” Runtime validation helps answer “is the application behaving like the inventory said it would?”

    All three questions matter.


    Vendor Risk Has to Move Past Questionnaires

    The same issue applies to third-party software vendors. Many organizations still evaluate software suppliers through questionnaires, SOC 2 reports, penetration test summaries, vulnerability disclosure policies, and security addendums. Those documents have value, but they rarely show the full release path.

    A vendor can have a secure coding policy and still use weak release controls. A vendor can provide an SBOM and still lack enforceable artifact provenance. A vendor can require MFA for employees and still rely on overprivileged service accounts. A vendor can pass an audit and still have build runners with excessive network access, exposed secrets, or unreviewed workflow changes.

    Procurement and security teams need to ask more operational questions. How are release artifacts signed? Are builds reproducible or at least traceable? Are package publishing tokens long-lived or replaced with trusted publishing? Are workflow changes reviewed as security-sensitive changes? Are build runners isolated? Are deployment credentials short-lived? Can the vendor prove which commit, workflow, and environment produced a given release? Can customers verify that proof?

    These questions matter more than a generic statement that secure development practices are followed. A mature supplier should be able to explain how code becomes software and how that process is protected from tampering.

    This is where supply chain security becomes a shared accountability problem. Buyers need stronger evidence. Vendors need stronger release controls. Security teams need to stop treating the vendor’s final artifact as the beginning of the risk conversation. The artifact is the end of a process. That process needs assurance.


    What Defenders Should Prioritize Next

    The next phase of software supply chain defense should focus on the systems that produce, publish, and deploy software.

    Organizations should start by identifying their critical build and release paths. That means mapping repositories, CI/CD workflows, build runners, package registries, artifact stores, signing keys, service accounts, cloud roles, deployment jobs, and third-party integrations. This should include internal software and vendor-managed software that has privileged access to the environment.

    Next, teams should reduce reliance on long-lived credentials. Package publishing, cloud access, and deployment automation should move to short-lived identity flows where possible. OIDC-based trusted publishing is a strong example of this pattern. If a token cannot be removed, it should be scoped narrowly, rotated regularly, monitored closely, and kept out of workflows that handle untrusted input.

    Build provenance should become a policy control. Artifacts should be signed. Provenance should be generated by the build system. Production deployment should prefer, and eventually require, artifacts that can prove where and how they were built. This is the point where supply chain security becomes enforceable instead of advisory.

    Workflow files should be treated as sensitive code. A change to a CI/CD pipeline can be as dangerous as a change to authentication logic. Pull request triggers, external contributor permissions, environment variable access, and secret exposure rules need review from people who understand both engineering and security impact.

    Developer workstations also need more attention. Many supply chain attacks target the developer first, then move into repositories, secrets, package publishing, and cloud environments. Endpoint controls, secret scanning, local credential hygiene, and restrictions on package install scripts can reduce this risk. Development systems should not hold broad, reusable credentials that can turn one malicious package install into an organization-wide incident.

    AI development tools should be added to the access review process. Security teams need to know which tools are in use, what data they can read, what commands they can run, and whether their actions are logged. AI-generated or AI-assisted changes should follow the same review, testing, and approval path as any other change.

    SBOMs should continue to mature, but they should not be treated as a finish line. The stronger model is SBOM plus provenance plus signing plus runtime visibility plus deployment policy. That gives organizations a better chance of detecting mismatch between what was declared, what was built, what was shipped, and what actually ran.


    The Next Problem Is Trust Without Verification

    The software supply chain problem is no longer limited to unknown code. It is trust without verification across the systems that produce software.

    A package can have the right name and still be malicious. A release can come from the right maintainer account and still bypass the expected pipeline. A build can pass tests and still leak secrets. A vendor can provide documentation and still lack defensible artifact controls. An AI tool can improve productivity and still create a new path into sensitive development context.

    That is the next supply chain problem. It is not just the code organizations import. It is the authority granted to everything around that code.

    Security teams need to treat the software factory as production infrastructure. CI/CD systems, package publishers, build runners, signing services, AI developer tools, and service accounts are no longer background components. They are part of the attack surface. They decide what becomes trusted software.

    The organizations that understand this will move from dependency visibility to process assurance. They will ask for proof, not promises. They will verify artifacts, not just scan packages. They will govern automation, not just developers. They will treat the release path as a security boundary.

    The next software supply chain problem may not be code. It may be the system that everyone already trusts to deliver it.


    How Can Netizen Help?

    Founded in 2013, Netizen is an award-winning technology firm that develops and leverages cutting-edge solutions to create a more secure, integrated, and automated digital environment for government, defense, and commercial clients worldwide. Our innovative solutions transform complex cybersecurity and technology challenges into strategic advantages by delivering mission-critical capabilities that safeguard and optimize clients’ digital infrastructure. One example of this is our popular “CISO-as-a-Service” offering that enables organizations of any size to access executive level cybersecurity expertise at a fraction of the cost of hiring internally. 

    Netizen also operates a state-of-the-art 24x7x365 Security Operations Center (SOC) that delivers comprehensive cybersecurity monitoring solutions for defense, government, and commercial clients. Our service portfolio includes cybersecurity assessments and advisory, hosted SIEM and EDR/XDR solutions, software assurance, penetration testing, cybersecurity engineering, and compliance audit support. We specialize in serving organizations that operate within some of the world’s most highly sensitive and tightly regulated environments where unwavering security, strict compliance, technical excellence, and operational maturity are non-negotiable requirements. Our proven track record in these domains positions us as the premier trusted partner for organizations where technology reliability and security cannot be compromised.

    Netizen holds ISO 27001, ISO 9001, ISO 20000-1, and CMMI Level III SVC registrations demonstrating the maturity of our operations. We are a proud Service-Disabled Veteran-Owned Small Business (SDVOSB) certified by U.S. Small Business Administration (SBA) that has been named multiple times to the Inc. 5000 and Vet 100 lists of the most successful and fastest-growing private companies in the nation. Netizen has also been named a national “Best Workplace” by Inc. Magazine, a multiple awardee of the U.S. Department of Labor HIRE Vets Platinum Medallion for veteran hiring and retention, the Lehigh Valley Business of the Year and Veteran-Owned Business of the Year, and the recipient of dozens of other awards and accolades for innovation, community support, working environment, and growth.

    Looking for expert guidance to secure, automate, and streamline your IT infrastructure and operations? Start the conversation today.


  • Netizen: Monday Security Brief (6/22/2026)

    Today’s Topics:

    • INTERPOL Warns Cybercrime Is Surging Across Asia-Pacific as Phishing, Ransomware, and AI Scams Scale Up
    • The Gentlemen Ransomware Shows How Former Affiliates Are Building Faster, Leaner RaaS Operations
    • How can Netizen help?

    INTERPOL Warns Cybercrime Is Surging Across Asia-Pacific as Phishing, Ransomware, and AI Scams Scale Up

    Cybercrime is rising sharply across Asia and the South Pacific, with phishing, ransomware, banking malware, information stealers, deepfakes, and AI-assisted fraud placing new pressure on governments, businesses, and law enforcement agencies across the region. A new INTERPOL assessment says the threat environment has been shaped by fast digital adoption, wider internet access, organized criminal networks, uneven cybersecurity maturity, and the growing use of artificial intelligence in online crime.

    According to INTERPOL’s 2025/2026 Asia and South Pacific Cyberthreat Assessment Report, phishing is now the most widespread and financially damaging form of cybercrime reported across the region. A third of countries covered in the assessment recorded more than 10,000 phishing cases between January 2024 and March 2025. More than half of INTERPOL member countries also reported that cybercrime made up at least 30% of all nationally recorded crime.

    The numbers point to a broader shift in how cybercrime is operating. Phishing is no longer limited to low-effort credential theft emails or generic lures. Criminal groups are combining social engineering, fake login pages, malware delivery, business impersonation, and AI-generated content to reach more victims at scale. In many cases, phishing now serves as the entry point for broader fraud, account takeover, ransomware deployment, or data theft.

    Ransomware also remains a major threat across the Asia-Pacific region. INTERPOL estimated that more than 135,000 ransomware-related attacks affected the region in 2024, with real estate, manufacturing, and financial services among the most heavily impacted sectors. These industries are attractive targets due to their operational reliance on digital systems, high-value data, financial exposure, and limited tolerance for downtime.

    Ransomware groups are also increasing pressure during extortion by using victims’ regulatory and legal obligations against them. Rather than relying only on encryption, attackers may steal data, threaten public leaks, contact customers, reference compliance requirements, or use breach disclosure timelines to force faster payment decisions. This makes ransomware a legal, financial, operational, and reputational crisis, not just a technical incident.

    INTERPOL also warned that AI-enabled scams are becoming more common, especially in impersonation and fraud campaigns. Deepfake audio, synthetic video, AI-generated personas, and more convincing written messages are being used to impersonate executives, manipulate victims, authorize fraudulent transfers, and support romance or investment scams. These tools reduce the skill required to produce believable social engineering content and allow criminal groups to run higher-volume campaigns with more convincing narratives.

    The report also points to the industrialization of cyber-enabled fraud by transnational organized crime groups. Scam centers in Cambodia, Laos, Myanmar, and the Philippines have been linked to large-scale fraud operations that use forced labor to conduct investment scams, romance baiting schemes, and other online fraud. INTERPOL said organized crime groups in Myanmar, Cambodia, and Laos have used deepfakes in romance baiting scams, combining AI personas with social engineering in schemes tied to billions of dollars in regional cybercrime losses.

    Malware activity is also expanding. Banking trojans and information stealers ranked as the second most common category of cybercrime in the report, with families such as RedLine, Lumma, LokiBot, Negasteal, and ZBot appearing among the most active threats. These tools are often used to harvest browser-stored credentials, session cookies, cryptocurrency wallet data, system information, and authentication material that can later be sold, reused, or combined with other intrusion activity.

    Phishing link engagement in the region also exceeded the global average. INTERPOL reported that 5.5 out of every 1,000 individuals in Asia and the South Pacific clicked phishing links monthly, compared with a global average of 2.9 per 1,000. That higher rate gives attackers more opportunities to harvest credentials, compromise accounts, deliver malware, and move into business email compromise or identity fraud.

    Distributed denial-of-service attacks also increased sharply, rising 92% in 2024 compared with the prior year. These attacks can be used to disrupt public services, pressure businesses, distract defenders, or support extortion campaigns. For organizations with weak network resilience or limited incident response capability, DDoS activity can create service outages that damage operations and public trust.

    System intrusions remain a major driver of data breaches, accounting for about 80% of all data breach activity in 2024, according to the report. INTERPOL cited misconfigured systems, weak encryption, insecure APIs, and insufficient monitoring as common weaknesses attackers exploit to gain access to target networks. These issues are familiar to defenders, but their impact grows as organizations move more services online and expose more cloud, application, and identity infrastructure to the internet.

    The rise in deepfake abuse has also created new risks beyond financial fraud. INTERPOL warned that synthetic media is being used for sexual exploitation, blackmail, and coercion. That threat category shows how AI-enabled cybercrime can cross from enterprise risk into personal harm, placing pressure on law enforcement agencies to respond to both technical abuse and human exploitation.

    The regional trend is clear: cybercrime across Asia and the South Pacific is becoming more organized, more automated, and more closely tied to traditional criminal enterprises. Phishing, ransomware, infostealers, deepfakes, and online scams are no longer separate threat categories. They increasingly operate as connected parts of a broader criminal economy, where stolen credentials, synthetic identities, malware access, extortion, and fraud infrastructure support one another.

    INTERPOL said law enforcement organizations across the region are scaling joint efforts to disrupt cybercriminal infrastructure, coordinate investigations, share intelligence, train personnel, and strengthen cyber resilience policies. That cooperation will be necessary as criminal groups continue using AI, ransomware-as-a-service, social engineering, and cross-border infrastructure to target victims at scale.

    For organizations, the report reinforces the need to treat phishing resistance, ransomware readiness, identity security, endpoint visibility, API hardening, monitoring, incident response planning, and employee training as connected defensive priorities. The threat is no longer limited to isolated scams or opportunistic malware. It is a regional cybercrime ecosystem built to exploit weak controls, human trust, exposed systems, and the growing use of AI in both business and crime.


    The Gentlemen Ransomware Shows How Former Affiliates Are Building Faster, Leaner RaaS Operations

    The Gentlemen ransomware operation is a case study in how the ransomware-as-a-service economy is changing. The group did not appear as a fully isolated criminal brand with no prior tradecraft behind it. Reporting from PRODAFT, Microsoft, Check Point Research, Huntress, Trend Micro, and other threat intelligence teams indicates that The Gentlemen grew out of earlier affiliate activity tied to established ransomware ecosystems, then moved into its own independent partnership program after disputes, leaks, and instability inside the underground market.

    PRODAFT tracks the group as Phantom Mantis and says it was initially known as ArmCorp. The operation has been active since March 2025 and is assessed to be led by a Russian-speaking threat actor tracked as LARVA-368, associated with aliases including hastalamuerte, ArmCorp, zeta88, nobody0, and santamuerte. Before launching The Gentlemen as a standalone program, the actor is said to have worked with or borrowed from ransomware ecosystems linked to LockBit, Qilin, Medusa, and Embargo. That background matters, since The Gentlemen does not look like a novice operation. It looks like a group built by people who already knew how ransomware crews recruit affiliates, manage panels, negotiate payments, move data, and pressure victims.

    The operation’s shift from ArmCorp into The Gentlemen appears to have accelerated in July 2025 after a dispute with Qilin, with LARVA-368 alleging that roughly $48,000 in affiliate commissions had been withheld. That dispute fits a larger pattern in the ransomware market. Since 2023, major crews have been disrupted, exposed, rebranded, or accused of cheating affiliates. LockBit was hit by law enforcement action, ALPHV collapsed after payment controversy, RansomHub disappeared from public view, and several smaller crews splintered into private or semi-private programs. In that climate, experienced affiliates have more incentive to build their own platforms rather than depend on larger brands that may steal commissions, lose infrastructure, or attract too much law enforcement pressure.

    The Gentlemen’s growth has been tied closely to that affiliate-first model. Check Point Research reported that the group publicly claimed more than 320 victims by April 2026, with 240 of those claims occurring in the first months of 2026. Halcyon has assessed that the group offered affiliates a 90/10 revenue split, giving affiliates 90 percent of ransom proceeds. That is higher than the 70/30 or 80/20 split common across many RaaS programs, making it a strong recruitment tool for operators who already have access, tradecraft, and victim pipelines.

    This is one reason The Gentlemen should be seen as a business-model threat, not just a malware threat. The ransomware itself is dangerous, but the affiliate structure is what allows the operation to scale. Operators provide the locker, infrastructure, support, leak site, and build process. Affiliates bring access, execute intrusions, steal data, deploy ransomware, and negotiate with victims through their own Tox or messaging identifiers. That separation lets the core program support many intrusions without directly conducting each one.

    The group’s internal communications, later exposed through leaks affecting its Rocket.Chat environment, gave researchers an unusually clear view into how the operation functioned. PRODAFT said it identified 34 registered users in the group’s Rocket.Chat instance between May 2025 and April 2026. Check Point Research reported that leaked material included conversations about initial access, edge appliance exploitation, affiliate roles, shared tools, backend systems, victim handling, and ransom negotiations. The leak also exposed accounts connected to the administrator, who reportedly managed infrastructure, built lockers, handled the RaaS panel, and oversaw payouts.

    The internal structure shows a division of labor that resembles a criminal services platform. One role, referred to as The Gentlemen Data, appears focused on data exfiltration support, helping move stolen information from affiliate-controlled cloud storage into The Gentlemen infrastructure for publication on the group’s leak site. LARVA-368 and related support channels appear to have helped affiliates with encryption, intrusion troubleshooting, and security-tool bypasses. Support moved through Tox, SimpleX Chat, Ricochet Refresh, and other messaging platforms after the Rocket.Chat leaks damaged the group’s internal trust.

    The affiliate panel also reflects the maturity of the operation. PRODAFT reported that prospective affiliates needed to provide at least 1 GB of exfiltrated victim data before gaining access to the panel, a vetting method also seen in other ransomware crews trying to keep researchers and law enforcement out. The panel reportedly allowed affiliates to configure targets, build ransomware packages, download lockers, manage users, and track victim states. That kind of infrastructure lowers friction for affiliates and helps standardize attacks across different operators.

    The ransomware payload is built for broad enterprise coverage. Reporting indicates that The Gentlemen supports Windows, Linux, ESXi, older Windows systems, and LVM environments. Microsoft tracks the operators as Storm-2697 and described the Windows encryptor as a Go-based ransomware family obfuscated with Garble. Microsoft also reported that the ransomware can use self-propagation logic, turning a single-host encryptor into malware that attempts to spread across reachable systems once enabled by the operator. That feature raises the risk of domain-wide impact after initial access, particularly in flat networks with weak segmentation and overprivileged accounts.

    The ransomware’s options show a focus on speed, reach, and recovery disruption. Analysts have reported features for local encryption, network share encryption, delayed execution, selective scope, self-deletion, free-space wiping, GPO-based deployment, and propagation using credential material. ESXi support gives the group a path to affect virtualization infrastructure, where encrypting hosts or datastores can impact many workloads at once. LVM support extends the reach against Linux storage configurations and block-device targets. This cross-platform coverage reflects how modern ransomware crews build for mixed enterprise environments rather than single endpoint classes.

    Incident reporting from Huntress and Trend Micro also shows that affiliates deploying The Gentlemen have used common enterprise intrusion tradecraft before encryption. Observed activity has included scheduled task abuse, Windows scripting, log clearing, Defender tampering, antivirus exclusions, remote access tooling such as AnyDesk, Group Policy manipulation, privileged account compromise, encrypted file transfer, and legitimate driver abuse. These techniques are not new on their own. The risk comes from how they are packaged into a repeatable affiliate workflow backed by a growing RaaS program.

    Initial access patterns also match broader ransomware trends. Researchers have pointed to exposed edge devices, VPN appliances, firewall infrastructure, stolen credentials, and public-facing services as common entry paths. Check Point’s analysis of an affiliate-linked incident involving SystemBC found more than 1,570 victims connected to the relevant command-and-control server, with signs that many were corporate or organizational environments. SystemBC is often used in human-operated ransomware intrusions to create proxy access, support tunneling, and enable later payload delivery.

    The Gentlemen’s use of AI, as described by PRODAFT, adds another layer to the story. LARVA-368 reportedly used AI to assist with ransomware and tool development, maintenance, and post-exploitation procedures. That does not mean AI created the operation by itself. The more realistic concern is that AI can reduce development time, help operators troubleshoot code, generate scripts, translate instructions, maintain panels, and produce procedural guidance for affiliates. For groups already familiar with ransomware operations, AI can act as a force multiplier across coding, documentation, support, and attack planning.


    How Can Netizen Help?

    Founded in 2013, Netizen is an award-winning technology firm that develops and leverages cutting-edge solutions to create a more secure, integrated, and automated digital environment for government, defense, and commercial clients worldwide. Our innovative solutions transform complex cybersecurity and technology challenges into strategic advantages by delivering mission-critical capabilities that safeguard and optimize clients’ digital infrastructure. One example of this is our popular “CISO-as-a-Service” offering that enables organizations of any size to access executive level cybersecurity expertise at a fraction of the cost of hiring internally. 

    Netizen also operates a state-of-the-art 24x7x365 Security Operations Center (SOC) that delivers comprehensive cybersecurity monitoring solutions for defense, government, and commercial clients. Our service portfolio includes cybersecurity assessments and advisory, hosted SIEM and EDR/XDR solutions, software assurance, penetration testing, cybersecurity engineering, and compliance audit support. We specialize in serving organizations that operate within some of the world’s most highly sensitive and tightly regulated environments where unwavering security, strict compliance, technical excellence, and operational maturity are non-negotiable requirements. Our proven track record in these domains positions us as the premier trusted partner for organizations where technology reliability and security cannot be compromised.

    Netizen holds ISO 27001, ISO 9001, ISO 20000-1, and CMMI Level III SVC registrations demonstrating the maturity of our operations. We are a proud Service-Disabled Veteran-Owned Small Business (SDVOSB) certified by U.S. Small Business Administration (SBA) that has been named multiple times to the Inc. 5000 and Vet 100 lists of the most successful and fastest-growing private companies in the nation. Netizen has also been named a national “Best Workplace” by Inc. Magazine, a multiple awardee of the U.S. Department of Labor HIRE Vets Platinum Medallion for veteran hiring and retention, the Lehigh Valley Business of the Year and Veteran-Owned Business of the Year, and the recipient of dozens of other awards and accolades for innovation, community support, working environment, and growth.

    Looking for expert guidance to secure, automate, and streamline your IT infrastructure and operations? Start the conversation today.


  • How AI Changes Secure Code Review

    Secure code review has always required more than finding obvious injection bugs or checking whether a developer used the right library call. Good review connects code behavior to trust boundaries, data flow, authorization logic, state changes, error handling, deployment context, and abuse cases. AI does not remove that requirement. It changes the volume, speed, source, and shape of the code entering the review process.

    AI coding assistants can generate handlers, tests, infrastructure files, database queries, IAM policies, Kubernetes manifests, documentation, and deployment scripts in minutes. That changes the risk profile of pull requests. A reviewer may no longer be assessing code that reflects a developer’s full reasoning process. They may be assessing code that was assembled from model suggestions, partial prompts, copied snippets, generated fixes, and tool-driven refactors.

    The result is a new secure code review problem: code can look complete, pass tests, follow style rules, and still contain subtle flaws introduced by an assistant that does not truly know the organization’s threat model, production architecture, security controls, or abuse history. AI can speed development, but it can also increase the amount of security-relevant code that reaches review without the same level of human design intent behind it.


    AI changes the reviewer’s starting assumption

    Traditional review often starts with the assumption that a human developer made a set of deliberate implementation choices. The reviewer looks for mistakes in those choices: missing input validation, broken access control, unsafe deserialization, weak cryptography, race conditions, insecure defaults, or risky dependency use.

    AI-generated code changes that assumption. Some code may be technically correct in isolation but wrong for the system it enters. A model may generate an authorization check that matches a common pattern but ignores tenant boundaries. It may use a secure-looking encryption API with poor key management. It may create a helper function that validates syntax but not authorization. It may add retry logic that hides failed security events. It may produce tests that confirm happy-path behavior but never test malicious input.

    That means secure review has to ask a different opening question: “What did the model assume?” The answer is rarely visible in the diff. AI-generated code often arrives without the prompt, rejected options, hidden context, or tradeoffs that shaped the final output. A reviewer sees the artifact, not the reasoning chain that produced it.

    This makes design intent more valuable. Pull requests that include AI-generated security-relevant code should explain what the code is meant to protect, what inputs are trusted, what inputs are hostile, what privilege level the code runs with, what data it can reach, and what failure mode is acceptable. Without that context, AI-generated code can create a false sense of review coverage.


    The main risk is not bad syntax

    AI coding tools are usually good at producing plausible syntax. That is part of the problem. The code often looks clean enough to move past superficial review. The risky parts are more likely to appear in security semantics.

    An assistant may generate SQL parameterization correctly in one part of an application, then concatenate query fragments in a reporting function. It may correctly escape HTML in a template, then pass untrusted content through a markdown renderer or client-side sink. It may use JWT validation code, but fail to enforce issuer, audience, expiration, key rotation, or algorithm restrictions. It may check that a user is authenticated, but fail to check that the user can access the specific object being requested.

    Generated code can also normalize insecure defaults. Examples include permissive CORS settings, overbroad IAM policies, disabled TLS verification, weak random number generation, hardcoded secrets in test fixtures that later become real examples, broad exception handlers, verbose error messages, debug endpoints, and temporary bypass logic left in place.

    Secure review in the AI-assisted SDLC has to treat “looks reasonable” as a weak signal. The reviewer’s job is to validate security behavior against concrete attacker actions, not to grade code fluency.

    AI increases the amount of code that needs context-aware review

    Code review has always had a throughput problem. Teams can produce code faster than security teams can manually inspect it. AI makes that gap wider. More code can be generated, more refactors can be proposed, and more files can change in a single pull request.

    This has two effects. First, reviewers face larger diffs with less time to reason through them. Second, low-friction code generation can lead to more security-sensitive changes made by developers who are not domain specialists in that area.

    A frontend developer might ask an assistant to add an API route. A backend developer might ask for Terraform. A platform engineer might generate a GitHub Actions workflow. A junior developer might ask for OAuth integration code. Each of these tasks can cross trust boundaries. The assistant can produce usable code, but usable code is not the same as secure code.

    The secure review process must adjust by classifying AI-assisted changes by risk. A generated unit test does not carry the same risk as a generated authentication middleware. A generated README update is not the same as a generated IAM policy. Teams need review triggers for security-sensitive files and patterns: auth code, crypto, identity claims, secrets handling, logging, deserialization, payment logic, object access, tenant isolation, CI/CD workflows, infrastructure definitions, container permissions, Kubernetes RBAC, and dependency changes.


    AI can help review, but it cannot own review

    AI review tools can be useful in the first pass. They can summarize diffs, flag suspicious functions, identify missing tests, compare code to internal patterns, explain complex changes, and draft questions for human reviewers. They can also help security teams scale routine checks by identifying risky areas in a large pull request.

    The limitation is that AI review is probabilistic and context-bound. It may miss serious flaws that require system-level reasoning. It may focus on style or minor correctness issues rather than exploitability. It may give confident comments on code it has not fully interpreted. It may fail to account for downstream controls, compensating controls, hidden dependencies, or production-specific data flows.

    Secure code review should use AI as a review assistant, not a reviewer of record. The human reviewer still owns the acceptance decision for security-relevant changes. Automated AI comments should be treated like SAST findings, lint findings, or dependency alerts: useful signal, not final judgment.

    A practical review workflow uses AI to improve coverage, then routes high-risk changes to humans with the right expertise. The AI can summarize “what changed,” “which files affect authentication,” “where user-controlled input enters,” or “which new permissions are requested.” The human reviewer decides whether the design is safe.


    Generated fixes need review too

    AI tools are increasingly used to remediate findings. A scanner reports SQL injection, an assistant proposes parameterization. A dependency alert appears, an assistant updates the package. A SAST finding flags path traversal, an assistant adds path normalization. These workflows can reduce remediation time, but generated fixes can create new failure modes.

    A generated fix may patch the visible sink but leave another path open. It may validate input too late. It may break backward compatibility in a way that causes teams to disable the control. It may introduce a denylist instead of a safer allowlist. It may catch exceptions and return generic success, hiding failures from logs. It may upgrade a package without reviewing breaking security-relevant behavior. It may add tests that prove the patched sample no longer works, but not test the broader class of exploit.

    Every generated security fix should be reviewed as a security change, not treated as an automatic scanner response. The reviewer should ask whether the root cause was fixed, whether the fix applies at the right layer, whether tests cover the vulnerability class, whether the patch changes authorization or data exposure, and whether the finding can recur elsewhere.


    AI makes prompt and context part of the security boundary

    Secure code review now has to account for inputs that do not live in application code. AI assistants take context from prompts, open files, repository instructions, issue comments, documentation, README files, tool output, terminal output, dependency metadata, and sometimes external systems connected through plugins or MCP servers.

    That context can be malicious or misleading. A repository can contain instructions that tell an assistant to ignore security checks. A README can include prompt injection content. A generated file can influence the next AI-assisted change. A tool response can be crafted to steer the assistant into leaking secrets or making unsafe edits. A compromised dependency page can influence generated remediation guidance.

    For AI-assisted development, secure review should include the environment around the code. Teams should review assistant instruction files, repository-level prompts, agent permissions, tool integrations, local workspace access, secret exposure, and which external systems the assistant can query or modify. An AI coding agent with repository write access, terminal access, browser access, and secrets access is no longer a passive autocomplete tool. It is an automation actor inside the development environment.

    That changes review scope. Security teams need policies for which agents can modify code, which branches they can write to, which workflows they can trigger, which secrets they can access, and what approvals are required before generated changes merge.


    The new review target: AI-shaped pull requests

    A pull request affected by AI often has certain traits. It may touch many files with consistent formatting. It may introduce generic helper abstractions. It may include comments that describe obvious behavior. It may contain tests that mirror implementation logic too closely. It may use APIs that are common in public examples but misaligned with internal patterns. It may refactor working security code into cleaner but weaker code.

    Reviewers should look for these AI-shaped issues:

    • Generated authorization code that checks identity but not object ownership.
    • Input validation placed at the edge but bypassed by internal callers.
    • Logging that captures sensitive request data, tokens, session identifiers, or personal data.
    • Error handling that returns too much information or suppresses security-relevant failures.
    • New dependencies added for small tasks that could be handled internally.
    • Infrastructure permissions that use wildcards or broad managed roles.
    • Client-side checks used as if they were server-side enforcement.
    • Secrets inserted into examples, tests, scripts, Docker files, or CI variables.
    • Security tests that only prove the generated implementation works, not that attacks fail.
    • Code comments that sound authoritative but do not match the implementation.
    • These are not AI-only flaws. AI raises their frequency and makes them easier to introduce at scale.

    Secure review must become more data-flow driven

    AI-generated code is often local in appearance. It may add one route, one helper, one workflow file, or one configuration block. The security impact is rarely local. A secure review should trace data across boundaries.

    For each AI-assisted change, reviewers should identify the input source, trust level, transformation logic, authorization decision, storage location, outbound call, and output sink. This matters more than the specific language or framework.

    For example, a generated file upload function should be reviewed across the entire path: client-supplied filename, content type, size limit, extension handling, malware scanning, storage bucket permissions, metadata handling, public access flags, CDN behavior, logging, retention, and deletion. A generated API route should be reviewed across authentication, object lookup, tenant boundary, field-level authorization, serialization, caching, error messages, and audit logging.

    AI can help build that map, but human reviewers need to verify it. The main security question is not “is this function written cleanly?” It is “can an attacker use this path to cross a boundary?”


    AI also changes supply chain review

    AI-assisted code review is not limited to application logic. Assistants often recommend packages, generate package manager commands, update lockfiles, write Dockerfiles, configure CI/CD workflows, and produce infrastructure code.

    That makes supply chain review more significant. A model may choose an abandoned package, a typo-squatted package, a package with risky transitive dependencies, or a dependency that is far larger than the task requires. It may generate a Dockerfile that runs as root, uses a broad base image, disables certificate checks, pins nothing, or pulls scripts from the internet during build. It may create CI workflows that run untrusted pull request code with secrets available.

    Secure review should treat AI-suggested dependencies and build changes as high-risk until validated. Reviewers should check package reputation, maintenance status, license, version pinning, known vulnerabilities, transitive risk, build scripts, install hooks, and whether the dependency is necessary. For CI/CD, reviewers should inspect token permissions, event triggers, secret exposure, third-party actions, pinned action SHAs, artifact handling, and deployment gates.

    AI can write infrastructure faster than most teams can review it. That means infrastructure-as-code and pipeline changes need strict review ownership.


    AI affects secure coding standards

    Most secure coding standards were written for human-authored code. They list approved libraries, banned functions, validation patterns, logging rules, crypto requirements, and review gates. AI requires these standards to become machine-usable.

    If teams want AI review tools to support secure development, the standards must be explicit, testable, and available in the places the assistant reads. Vague guidance such as “use secure authentication” is weak. Better guidance says which middleware to use, which claims are required, how tenant ID must be enforced, which libraries are banned, how secrets must be loaded, which logging fields are prohibited, and which files require security review.

    This creates a new kind of security artifact: review instructions for AI-assisted development. These instructions should not be treated as magic. They should be version-controlled, reviewed, tested, and scoped by path. Instructions for Terraform are different from instructions for React. Instructions for authentication code are different from instructions for test utilities.

    Security teams should build small, precise review rules that map to known internal failure modes. For example: “No new cloud role may include wildcard resource access without a linked exception.” “All API handlers that load objects by ID must call the tenant authorization helper before returning data.” “Do not log authorization headers, cookies, session IDs, reset tokens, or API keys.” These rules help AI tools produce better comments and help human reviewers stay consistent.


    Reviewers need to inspect AI-generated tests

    AI-generated tests can be helpful, but they can also create shallow confidence. A model often writes tests that confirm the code does what the code was written to do. Security testing needs to prove that unsafe behavior is rejected.

    For generated code touching security boundaries, reviewers should look for negative tests. Authentication code should test missing, malformed, expired, and wrong-audience tokens. Authorization code should test cross-tenant access, object ownership violations, role downgrades, and privilege boundaries. Input handling code should test malicious payloads, nested encodings, oversized input, null bytes, Unicode edge cases, path traversal, SSRF targets, and injection strings. File handling should test content-type mismatch, extension tricks, archive bombs, and storage permission failures.

    Tests should also check logging behavior, error messages, and side effects. A failed authorization test should not write data. A rejected upload should not leave a public object behind. A failed payment action should not trigger fulfillment. AI can generate these tests, but the reviewer has to ask for abuse cases rather than accept happy-path coverage.


    Accountability cannot be automated away

    One of the most serious risks in AI-assisted review is responsibility drift. Developers may assume the AI reviewer caught security issues. Security teams may assume developers reviewed AI output. Managers may assume the tool reduced risk due to more comments and faster pull request cycles. No one may own the final security judgment.

    The process must assign clear responsibility. Developers remain responsible for code they submit. Human reviewers remain responsible for approvals. Security teams remain responsible for standards, tooling, and high-risk review paths. AI-generated comments are supporting material.

    Pull request templates should ask whether AI was used for security-sensitive code, whether generated code was modified, whether new dependencies were added, whether secrets or permissions changed, and whether negative security tests were included. This is not about blocking AI. It is about making review context visible.

    For mature teams, AI usage metadata can become part of the SDLC record. Security teams can track which repositories use AI-generated code, which types of changes are most common, which findings recur, which generated fixes were accepted, and where review failures reach production. That data can improve secure coding rules, training, and detection.


    A practical secure review model for AI-assisted code

    Secure code review in the AI era should have layered gates.

    The first gate is developer-side review before the pull request. Developers should scan generated code locally, remove unused code, validate dependencies, check secrets, run tests, and document security-relevant assumptions. Generated code should never be pasted directly into production paths without local inspection.

    The second gate is automated security analysis. SAST, SCA, IaC scanning, secret scanning, container scanning, policy-as-code, and CI/CD workflow analysis should run on every relevant change. AI can help explain findings or suggest patches, but scanner output remains a separate signal.

    The third gate is AI-assisted review. The AI reviewer can summarize high-risk files, compare changes to secure coding rules, flag missing tests, and identify suspicious patterns. This gate is useful for coverage and triage.

    The fourth gate is human review. Humans should own approval for high-risk areas: authentication, authorization, crypto, identity, payments, audit logging, secrets, deployment, cloud permissions, exposed APIs, data export, and tenant isolation.

    The fifth gate is post-merge monitoring. Some issues only appear in runtime behavior. Teams should monitor security logs, rejected authorization attempts, new error patterns, unusual API use, dependency behavior, cloud role usage, and secret access after major AI-assisted changes.

    This model treats AI as one control in a layered review process. It does not give AI final authority over secure code.


    What security teams should change now

    Security teams do not need to ban AI coding tools to manage the risk. They need to update secure code review so it reflects how code is now produced.

    Start by defining which code paths require human security review. Then update pull request templates to surface AI use in high-risk changes. Add repository instructions that encode internal secure coding rules. Build detections for AI-shaped risks such as broad permissions, hardcoded secrets, unsafe generated workflows, and dependency sprawl. Train reviewers to ask what the model assumed, what context it lacked, and where the generated code crosses a trust boundary.

    Security teams should also review the AI tools themselves. That includes data retention settings, model access, repository access, agent permissions, local IDE integrations, MCP servers, plugin access, secret exposure, and audit logs. A coding assistant with write access and tool access should be governed like a development automation system.

    The long-term shift is clear: secure code review is no longer limited to reviewing code. It now includes reviewing generated context, assistant permissions, AI-produced fixes, review instructions, and the automation path that created the change.

    AI can make secure code review faster and broader, but it also raises the cost of shallow approval. The organizations that benefit most will not be the ones that let AI approve more code. They will be the ones that use AI to expose more risk before a human signs off.


    How Can Netizen Help?

    Founded in 2013, Netizen is an award-winning technology firm that develops and leverages cutting-edge solutions to create a more secure, integrated, and automated digital environment for government, defense, and commercial clients worldwide. Our innovative solutions transform complex cybersecurity and technology challenges into strategic advantages by delivering mission-critical capabilities that safeguard and optimize clients’ digital infrastructure. One example of this is our popular “CISO-as-a-Service” offering that enables organizations of any size to access executive level cybersecurity expertise at a fraction of the cost of hiring internally. 

    Netizen also operates a state-of-the-art 24x7x365 Security Operations Center (SOC) that delivers comprehensive cybersecurity monitoring solutions for defense, government, and commercial clients. Our service portfolio includes cybersecurity assessments and advisory, hosted SIEM and EDR/XDR solutions, software assurance, penetration testing, cybersecurity engineering, and compliance audit support. We specialize in serving organizations that operate within some of the world’s most highly sensitive and tightly regulated environments where unwavering security, strict compliance, technical excellence, and operational maturity are non-negotiable requirements. Our proven track record in these domains positions us as the premier trusted partner for organizations where technology reliability and security cannot be compromised.

    Netizen holds ISO 27001, ISO 9001, ISO 20000-1, and CMMI Level III SVC registrations demonstrating the maturity of our operations. We are a proud Service-Disabled Veteran-Owned Small Business (SDVOSB) certified by U.S. Small Business Administration (SBA) that has been named multiple times to the Inc. 5000 and Vet 100 lists of the most successful and fastest-growing private companies in the nation. Netizen has also been named a national “Best Workplace” by Inc. Magazine, a multiple awardee of the U.S. Department of Labor HIRE Vets Platinum Medallion for veteran hiring and retention, the Lehigh Valley Business of the Year and Veteran-Owned Business of the Year, and the recipient of dozens of other awards and accolades for innovation, community support, working environment, and growth.

    Looking for expert guidance to secure, automate, and streamline your IT infrastructure and operations? Start the conversation today.


  • The Security Risks Hidden in Service Accounts

    Service accounts sit at the intersection of identity, application runtime, infrastructure automation, and privileged access. They run Windows services, connect middleware to databases, let pipelines deploy code, let SaaS applications read tenant data, and allow workloads in cloud and Kubernetes environments to call APIs without a person at the keyboard. That operational value also makes them high-value attack paths.

    A compromised service account rarely looks like a compromised employee account. It may have no mailbox, no MFA challenge, no interactive login history, no single owner, and no clean joiner, mover, or leaver trigger. It can keep working for years with the same credential, long after the application, administrator, or deployment model that justified it has changed.

    The security issue is ambient authority. A service account often carries standing rights at the point where business logic and infrastructure control meet. An account that was created to read one database may later gain write access to queues, file shares, secret stores, backups, cloud APIs, deployment tooling, and directory groups. Over time, the account becomes a reusable identity object with a larger blast radius than anyone intended.


    Why service accounts become high-value attack paths

    Service accounts are attractive to attackers for four reasons: persistence, privilege, weak attribution, and weak controls.

    Persistence comes from long-lived credentials. Many service accounts are created with non-expiring passwords, static access keys, manually generated client secrets, or certificates that are rarely reviewed. This gives an attacker a durable credential that can survive password resets for human users, endpoint reimaging, and even partial incident response actions.

    Privilege comes from operational convenience. A broken service account can take down an application, so teams often over-grant access to avoid outages. Database accounts get schema owner rights. Windows service accounts get local administrator access. Cloud automation principals get contributor or administrator roles. CI/CD identities get deployment authority across multiple environments. Kubernetes service accounts get broad namespace or cluster permissions. These choices reduce operational friction, then become privilege escalation paths.

    Weak attribution comes from shared execution. A log entry showing that a service account accessed a secret, modified a storage bucket, created a process, or deployed code does not always identify the developer, administrator, workload, runner, or compromised host that caused the action. This creates a non-repudiation gap. The service account becomes the visible principal, but the real initiator may sit several layers away.

    Weak controls come from identity programs that focus on employees. Human identities usually have lifecycle workflows, MFA, conditional access, access reviews, HR triggers, device signals, and user behavior analytics. Service accounts often sit outside that control plane. They may be exempted from password rotation, excluded from MFA, ignored by access reviews, and filtered out of anomaly detection rules to reduce alert noise.


    Active Directory: Kerberoasting, delegation, and local privilege

    In Active Directory environments, one of the most common risks is the SPN-backed user account. A domain user can request a Kerberos service ticket for a registered Service Principal Name. The returned ticket is encrypted with a key derived from the target account’s password. An attacker can take that ticket offline and attempt to crack it. This is the core Kerberoasting pattern.

    Kerberoasting is effective since it abuses legitimate Kerberos behavior. The attacker does not need administrative rights to request service tickets. The activity can appear as normal ticket issuance, especially in environments with large numbers of applications, SQL services, IIS services, backup platforms, and middleware systems. The risk grows when the target service account has a weak password, a non-expiring password, RC4-HMAC support, privileged group membership, or rights that lead to administrative control over servers.

    Detection should focus on service ticket behavior, encryption type, and account risk. Windows Event ID 4769 is central for service ticket requests. Analysts should watch for unusual request volume from one source, ticket requests for many SPNs in a short period, RC4 ticket encryption type 0x17, requests for high-value service accounts, and service accounts with stale passwords. Directory attributes such as servicePrincipalName, pwdLastSet, adminCount, msDS-SupportedEncryptionTypes, delegation flags, group membership, and local administrator exposure should be joined with Kerberos telemetry.

    Kerberoasting is one part of the issue. Service accounts with local administrator rights can support lateral movement across server tiers. If the same service account runs on many hosts, credential material obtained from one system can unlock others. If that account can access backups, hypervisors, deployment shares, or domain management tooling, the attacker may move from application compromise to infrastructure control.

    Delegation settings add more risk. Unconstrained delegation can expose user tickets on a compromised service host, including tickets from privileged users that authenticate to the service. Constrained delegation and resource-based constrained delegation reduce scope, but misconfiguration can still create impersonation paths. Service account review should include delegation settings, SPNs, sensitive account flags, admin tier alignment, and host placement.

    The safer Windows pattern is to move eligible workloads to Group Managed Service Accounts or delegated managed service account models where supported. These models reduce manual password handling, provide automatic password management, and restrict which machines can retrieve and use the account credential. For accounts that cannot migrate, passwords should be long, random, unique, rotated, audited for exposure, and configured to support stronger Kerberos encryption.


    Cloud workload identities: secret sprawl and entitlement drift

    Cloud environments change the failure mode. The main risk is less about cracking a password and more about who can mint, store, use, or impersonate a machine identity.

    In Microsoft Entra ID, workload identities include applications, service principals, and managed identities. Application permissions can grant app-only access to Microsoft Graph, Azure resources, SaaS APIs, or internal services without a user session. A service principal with permissions such as Application.ReadWrite.All, Directory.ReadWrite.All, AppRoleAssignment.ReadWrite.All, RoleManagement.ReadWrite.Directory, or broad subscription ownership can become a tenant-level escalation point. A leaked client secret or certificate can give an attacker direct access as the app. A poorly governed consent grant can let an external or internal application read mail, files, directory objects, or security data at scale.

    Managed identities reduce developer-managed secrets, but they do not remove the need for authorization governance. A managed identity attached to a virtual machine, function, automation account, or container workload still has effective permissions. If an attacker gains execution in that workload, the identity can become an access bridge to Key Vault, storage, databases, management APIs, or deployment systems.

    AWS environments face a related issue with long-lived IAM user access keys. Static keys are frequently exposed through source code, build logs, Terraform state, shell history, container images, CI variables, endpoint files, and third-party integrations. Once exposed, an access key can be used from outside the original workload context. Roles and short-lived credentials reduce this risk, especially when combined with conditions that bind access to source account, source ARN, external ID, session tags, device context, or OIDC claims.

    Google Cloud service accounts carry two roles in the security model: they are principals that can access resources, and they are resources that other users or workloads may be allowed to impersonate. This dual nature is easy to miss. A user who can create a key for a privileged service account, grant themselves token creator rights, or modify the service account’s allow policy may effectively grant themselves the service account’s access. Default service accounts add more risk when broad roles are inherited from older project settings.

    Across cloud providers, the most dangerous pattern is a service account that combines static credentials, broad permissions, and weak source restrictions. The practical control is to reduce or remove static secrets, use workload-native identity where possible, scope permissions to one function or deployment boundary, and log both the service account action and the caller that obtained the token.


    Kubernetes and CI/CD: service account tokens in the automation plane

    Kubernetes service accounts create identities for pod processes. If a pod has a mounted service account token and an attacker gains code execution inside the container, that token can be used against the Kubernetes API subject to RBAC. The impact depends on the permissions attached to that service account. A read-only token may expose secrets, pod specs, config maps, service discovery data, or workload metadata. A privileged token may allow pod creation, secret retrieval, role binding changes, node access, or deployment modification.

    Modern Kubernetes supports time-bound tokens through the TokenRequest API and projected volumes. These tokens are bound to a pod and audience, with a default lifespan of one hour in common configurations. Legacy long-lived token secrets are more dangerous since they can remain usable beyond the pod lifecycle. Security teams should audit namespaces for service accounts with automounted tokens, legacy token secrets, broad RoleBindings or ClusterRoleBindings, and unexpected access to secrets.

    CI/CD systems are another service account concentration point. Build runners often hold the authority to pull source code, read secrets, build containers, push images, deploy infrastructure, modify Kubernetes objects, assume cloud roles, and trigger production workflows. A compromised pipeline identity can move from repository to registry to runtime without touching a human account.

    The preferred pattern is federated workload identity from the CI/CD system to the cloud provider, using OIDC claims tied to repository, branch, environment, workflow, and approval state. Static cloud keys in CI/CD variables should be treated as high-risk exceptions. Each runner should have narrow permissions, clear environment boundaries, strong secret isolation, and logs that correlate the cloud action back to the pipeline run, commit, actor, and approval event.


    SaaS integrations and API service accounts

    Service accounts are no longer limited to operating systems and cloud infrastructure. SaaS platforms commonly rely on API users, OAuth applications, integration users, bot users, admin tokens, webhook secrets, SCIM tokens, and automation accounts. These identities often have durable access to CRM data, ticketing systems, HR records, mailboxes, collaboration platforms, security tooling, and finance systems.

    The risk is often hidden in consent and token scope. An OAuth application may have read access to all mailboxes or files. A ticketing integration may have permission to create users or reset workflows. A security automation account may have the ability to isolate hosts or close alerts. A backup integration may have access to large volumes of sensitive data. These permissions can be valid for business reasons, yet still create a direct path for mass data access if the token is stolen.

    SaaS service account review should include token age, last use, scopes, admin role assignments, IP restrictions, source application, owner, vendor, downstream data access, and revocation process. For high-risk integrations, teams should prefer scoped OAuth grants, certificate-based authentication, conditional access controls where supported, short token lifetimes, vendor access reviews, and dedicated monitoring for bulk export, mass read, privilege change, and configuration drift.


    Detection logic that actually works

    Service account monitoring fails when it treats all machine activity as expected background noise. A better model separates detection into five planes: inventory, authentication, authorization, runtime, and change.

    The inventory plane asks whether every service account is known, owned, justified, and mapped to a workload. It should track name, platform, owner, business service, credential type, storage location, last authentication, last permission use, privilege level, delegated rights, dependencies, and decommission date. Unknown service accounts should be treated as unresolved access debt.

    The authentication plane looks at where and how the account is used. In Windows, this includes service logons, scheduled task execution, Kerberos service ticket requests, interactive logon attempts, remote logons, and use from hosts outside the expected server set. In cloud environments, it includes source IP, user agent, token issuer, key ID, assumed role session, service principal sign-in, OAuth grant usage, and API call geography. In Kubernetes, it includes audit events where user.username maps to system:serviceaccount:<namespace>:<name>.

    The authorization plane compares assigned permissions with used permissions. High-value signals include unused high-risk rights, service accounts with administrator roles, app-only permissions across tenant data, ability to create or modify credentials, ability to impersonate other service accounts, ability to read secret stores, and cross-environment deployment rights. Effective privilege matters more than assigned role names.

    The runtime plane links service account activity to processes, containers, hosts, pods, pipelines, and workloads. A service account used from a new host, a new pod, an unusual runner, or an unrecognized automation tool deserves attention. A credential used outside its normal execution boundary is often a stronger signal than the API call itself.

    The change plane watches for modifications that increase future access. This includes new SPNs, new client secrets, new certificates, new access keys, new OAuth grants, new role assignments, new service account token secrets, delegation changes, modified trust policies, added group membership, and changes to conditional access exclusions. Many service account compromises start with a credential leak, then mature into persistence through new credentials or expanded grants.


    Hardening service accounts without breaking production

    The first step is inventory. No team can secure service accounts it cannot name. Inventory should come from multiple systems: Active Directory, Entra ID, cloud IAM, Kubernetes clusters, CI/CD platforms, secret stores, SaaS admin consoles, endpoint telemetry, SIEM logs, and configuration management. Naming conventions help, but discovery should not rely on naming alone.

    The second step is ownership. Each service account needs a technical owner, business owner, supported workload, contact path, and review cadence. Orphaned accounts should lose access or enter a quarantine process. Accounts tied to retired applications should be disabled before deletion so hidden dependencies can surface with less risk.

    The third step is secret reduction. Replace static credentials with platform-managed identity wherever practical. In Active Directory, use managed service account models for supported Windows workloads. In Azure, prefer managed identities or workload identity federation. In AWS, prefer IAM roles and short-lived STS credentials over IAM user access keys. In Google Cloud, prefer service account impersonation or attached service accounts without downloaded keys. In Kubernetes, use projected, time-bound tokens and disable automounting where the pod does not need API access. In CI/CD, use OIDC federation rather than static cloud keys.

    The fourth step is privilege decomposition. A single service account should not span development, test, and production. It should not combine database access, secret access, deployment rights, and directory rights. Break large identities into workload-specific identities, then scope each identity to the smallest resource set that supports the application path. Separate read, write, deploy, administer, and break-glass functions.

    The fifth step is conditional control. Restrict where service accounts can authenticate from. Bind cloud roles to source conditions. Limit service principal sign-ins by location where supported. Limit IAM role assumption by external ID, organization ID, repository claim, branch claim, or workload identity claim. Restrict Kubernetes service account use through namespace boundaries, admission policy, network policy, and RBAC. Deny interactive logon for Windows service accounts, and remove local administrator rights where they are not required.

    The sixth step is rotation and revocation. Static credentials that remain in use should have documented exceptions, expiration dates, rotation schedules, and emergency revocation procedures. Rotation should be tested. Many organizations discover during an incident that a service account password cannot be changed without breaking an application that no one owns. That is not a credential problem; it is an operational resilience problem.

    The seventh step is detection engineering. Build detections around account behavior, entitlement change, and source boundary violations. Good alerts include a service account used from a new host, a service principal receiving a new secret, a cloud key used from a new country, a Kubernetes service account creating privileged pods, a CI/CD deploy role used outside approved workflow claims, an AD service account requesting RC4 tickets, and a service account added to a privileged group.


    The real risk is unmanaged trust

    Service accounts are often treated as background plumbing, but they are active security principals. They authenticate, authorize, move data, deploy software, change infrastructure, and bridge trust between systems. In many environments, they now outnumber human accounts and hold access that would be unacceptable if assigned to a standard user.

    The defense is identity engineering. Every service account should be named, owned, scoped, observed, and replaceable. Every static secret should have a reason to exist. Every privilege should map to a workload requirement. Every action should be traceable back to a source system, host, pipeline, or human sponsor.

    The safest service account is often the one that no longer has a static secret, no longer has standing broad access, and no longer sits outside the normal identity governance process. Attackers know service accounts are durable access paths. Defenders need to treat them with the same scrutiny given to privileged human accounts, and in many cases, more.


    How Can Netizen Help?

    Founded in 2013, Netizen is an award-winning technology firm that develops and leverages cutting-edge solutions to create a more secure, integrated, and automated digital environment for government, defense, and commercial clients worldwide. Our innovative solutions transform complex cybersecurity and technology challenges into strategic advantages by delivering mission-critical capabilities that safeguard and optimize clients’ digital infrastructure. One example of this is our popular “CISO-as-a-Service” offering that enables organizations of any size to access executive level cybersecurity expertise at a fraction of the cost of hiring internally. 

    Netizen also operates a state-of-the-art 24x7x365 Security Operations Center (SOC) that delivers comprehensive cybersecurity monitoring solutions for defense, government, and commercial clients. Our service portfolio includes cybersecurity assessments and advisory, hosted SIEM and EDR/XDR solutions, software assurance, penetration testing, cybersecurity engineering, and compliance audit support. We specialize in serving organizations that operate within some of the world’s most highly sensitive and tightly regulated environments where unwavering security, strict compliance, technical excellence, and operational maturity are non-negotiable requirements. Our proven track record in these domains positions us as the premier trusted partner for organizations where technology reliability and security cannot be compromised.

    Netizen holds ISO 27001, ISO 9001, ISO 20000-1, and CMMI Level III SVC registrations demonstrating the maturity of our operations. We are a proud Service-Disabled Veteran-Owned Small Business (SDVOSB) certified by U.S. Small Business Administration (SBA) that has been named multiple times to the Inc. 5000 and Vet 100 lists of the most successful and fastest-growing private companies in the nation. Netizen has also been named a national “Best Workplace” by Inc. Magazine, a multiple awardee of the U.S. Department of Labor HIRE Vets Platinum Medallion for veteran hiring and retention, the Lehigh Valley Business of the Year and Veteran-Owned Business of the Year, and the recipient of dozens of other awards and accolades for innovation, community support, working environment, and growth.

    Looking for expert guidance to secure, automate, and streamline your IT infrastructure and operations? Start the conversation today.


  • The Difference Between Passing a SOC 2 Audit and Maintaining a SOC 2 Program

    For many organizations, SOC 2 begins as a customer request. A prospect asks for the report, a contract requires it, or a sales cycle stalls until the organization can prove that it has controls in place to protect customer data. That pressure often turns SOC 2 into a project with a deadline, an audit window, evidence requests, policy updates, and a final report.

    That approach may get an organization through the audit, but it does not necessarily create a mature compliance program. Passing a SOC 2 audit and maintaining a SOC 2 program are related goals, but they are not the same. One produces an attestation report for a defined period. The other builds repeatable governance, risk management, control ownership, and operational discipline into the way the organization runs.

    SOC 2 is built around the AICPA Trust Services Criteria, which address controls related to security, availability, processing integrity, confidentiality, and privacy. The exact scope depends on the services provided, the systems included, the risks facing the organization, and the trust service categories selected for the report. At a basic level, the audit asks whether management’s description of the system is accurate and whether the controls are suitably designed and operating as described.

    A SOC 2 program asks a broader question: can the organization keep those controls working after the auditor leaves?


    Passing the Audit Is a Point in the Compliance Lifecycle

    A SOC 2 audit is a formal examination. It has a defined scope, a defined set of systems, a defined audit period, and a defined body of evidence. For a Type I report, the focus is control design at a point in time. For a Type II report, the focus expands to control design and operating effectiveness over a period.

    That distinction matters. A Type I report may show that policies, procedures, and controls were in place on a selected date. A Type II report gives customers more assurance that those controls operated over time. Both can create business value. Both can support customer trust. Both can help satisfy vendor due diligence requirements.

    Still, an audit is an assessment of evidence. It is not a substitute for ownership. It does not automatically mean that access reviews will keep happening, terminated users will always be removed on time, vendors will be reassessed, risk decisions will be documented, incidents will be tested, or changes will be reviewed before deployment.

    Organizations that treat SOC 2 as a one-time event often scramble before the audit window closes. Policies get updated in bulk. Screenshots are collected manually. Control owners rush to document work that may have been performed inconsistently. Exceptions are handled reactively. The organization may still receive a report, but the process is inefficient and fragile.

    A mature SOC 2 program reduces that scramble by making compliance part of normal operations.


    Maintaining a Program Means Controls Have Owners

    The most significant difference between an audit and a program is accountability. In an audit-driven model, compliance often sits with one person or one small team. That team chases evidence, reminds departments to complete tasks, updates policies, and acts as the main interface with the auditor.

    In a program-driven model, compliance responsibilities are distributed across the business. Human resources owns onboarding and termination workflows. IT owns access provisioning, device management, and system hardening. Engineering owns change management and secure development practices. Security owns monitoring, vulnerability management, incident response, and risk tracking. Legal and procurement own vendor review and contractual obligations. Executive leadership owns governance, risk acceptance, and resourcing.

    This shift matters because SOC 2 controls usually reflect real business processes. If control owners do not understand their responsibilities, the organization may pass one audit cycle and fail to sustain the same control quality during the next one. A program requires named owners, documented procedures, recurring tasks, escalation paths, and management oversight.


    Evidence Should Be Produced by Operations, Not Reconstructed Later

    One of the clearest signs of an immature SOC 2 effort is evidence reconstruction. This happens when a team performs control activities informally, then tries to recreate proof later. Examples include backfilling access review notes, searching through ticketing systems for change approvals, manually pulling screenshots from cloud consoles, or trying to prove that security monitoring occurred months after the fact.

    A stronger program treats evidence as an output of the process itself. Access reviews are documented when they occur. Change approvals are captured in the ticket or pull request. Vulnerability remediation is tracked through the scanning and ticketing workflow. Security incidents, even minor ones, are logged with timestamps, impact, response actions, and closure notes. Vendor reviews are stored in a central repository with risk ratings and renewal dates.

    This does not mean compliance needs to slow down the business. It means the business should generate defensible records as work happens. The goal is to make audit evidence a byproduct of good operations, rather than a separate burden added at the end of the audit period.


    Policies Need to Match Reality

    Policies are often created early in a SOC 2 effort, but policies alone do not prove that a program is effective. A password policy, access control policy, change management policy, incident response plan, or vendor management policy only has value if it reflects how the organization actually works.

    A common issue in first-time audits is policy overreach. Organizations adopt generic policy language that sounds mature but does not match their size, tooling, staffing, or operating model. The result is a gap between documented expectations and actual practice. Auditors may test against the policy, and customers may rely on the report, so that gap can become a compliance risk.

    A maintainable SOC 2 program keeps policies practical, approved, reviewed, and aligned with real control activity. If the organization requires quarterly access reviews, those reviews need to happen every quarter. If all production changes require approval, the workflow needs to capture that approval. If critical vulnerabilities must be remediated within a defined timeframe, the vulnerability management process needs to track age, severity, risk decisions, and exceptions.

    A good policy is not the longest document. It is the document the organization can follow consistently.


    Risk Management Is More Than a Spreadsheet

    SOC 2 programs require risk awareness. The organization needs to know what systems support the service, what data is processed, who has access, what third parties are involved, what threats could disrupt operations, and what controls reduce those risks.

    In weaker programs, risk assessment is performed once a year to satisfy an audit request. The risk register is updated shortly before fieldwork, reviewed quickly, then ignored until the next cycle.

    In stronger programs, risk management drives decisions. New vendors trigger review. New products or features trigger security and privacy analysis. Major infrastructure changes are assessed before implementation. Control failures are tied back to risk. Accepted risks are documented with ownership and expiration dates. Leadership receives enough information to make informed decisions.

    This is where SOC 2 shifts from compliance paperwork to governance. A functioning program gives management a way to see control health, open risks, audit findings, recurring exceptions, and areas needing investment.


    Control Exceptions Should Lead to Corrective Action

    No program is perfect. Access reviews may be late. A terminated user may retain access longer than expected. A vulnerability may miss its remediation target. A vendor review may not be completed before renewal. An incident response test may reveal unclear roles.

    The issue is not that exceptions occur. The issue is whether the organization detects them, documents them, evaluates impact, and fixes the process that allowed them to happen.

    An audit-focused organization may treat exceptions as problems to explain away. A program-focused organization treats them as data. If access removals are late, the termination workflow may need better integration between HR and IT. If change approvals are missing, engineering workflows may need clearer enforcement. If vulnerability remediation is delayed, the organization may need ownership rules, risk-based prioritization, or better patch reporting.

    A SOC 2 program matures through this cycle: operate controls, detect failures, document exceptions, remediate root causes, and verify that the fix works.


    Automation Can Help, but It Cannot Own the Program

    Compliance automation platforms can reduce manual effort by collecting evidence, mapping controls, monitoring integrations, and tracking audit requests. These tools can be useful, especially for cloud-native environments with many systems and recurring evidence needs.

    The risk is assuming that automation equals compliance. A tool can show that multifactor authentication is enabled in an identity provider. It cannot decide whether privileged access is appropriate for a user’s role. A tool can collect vulnerability scan results. It cannot make the risk decision for an unpatched system that supports a critical business process. A tool can store policy acknowledgments. It cannot prove that employees understand how to report an incident.

    Automation supports a SOC 2 program. It does not replace governance, judgment, ownership, or control design.


    The Real Goal Is Trust That Survives the Audit Cycle

    A SOC 2 report is valuable because it gives customers an independent view into how a service organization manages controls relevant to trust. For many companies, it can reduce friction in vendor reviews and support growth into larger customers or more regulated markets.

    The deeper value comes when the audit becomes part of a sustained program. A well-run SOC 2 program can improve operational discipline, clarify ownership, strengthen security processes, reduce customer due diligence friction, and help leadership make better risk decisions.

    Passing the audit proves that the organization met the requirements of a defined examination. Maintaining the program proves that trust is being managed every day.

    Organizations that understand the difference are better positioned for repeat audits, customer scrutiny, security incidents, vendor risk reviews, and growth. SOC 2 should not be treated as an annual fire drill. It should operate as a management system for trust, control performance, and accountability across the business.


    How Can Netizen Help?

    Founded in 2013, Netizen is an award-winning technology firm that develops and leverages cutting-edge solutions to create a more secure, integrated, and automated digital environment for government, defense, and commercial clients worldwide. Our innovative solutions transform complex cybersecurity and technology challenges into strategic advantages by delivering mission-critical capabilities that safeguard and optimize clients’ digital infrastructure. One example of this is our popular “CISO-as-a-Service” offering that enables organizations of any size to access executive level cybersecurity expertise at a fraction of the cost of hiring internally. 

    Netizen also operates a state-of-the-art 24x7x365 Security Operations Center (SOC) that delivers comprehensive cybersecurity monitoring solutions for defense, government, and commercial clients. Our service portfolio includes cybersecurity assessments and advisory, hosted SIEM and EDR/XDR solutions, software assurance, penetration testing, cybersecurity engineering, and compliance audit support. We specialize in serving organizations that operate within some of the world’s most highly sensitive and tightly regulated environments where unwavering security, strict compliance, technical excellence, and operational maturity are non-negotiable requirements. Our proven track record in these domains positions us as the premier trusted partner for organizations where technology reliability and security cannot be compromised.

    Netizen holds ISO 27001, ISO 9001, ISO 20000-1, and CMMI Level III SVC registrations demonstrating the maturity of our operations. We are a proud Service-Disabled Veteran-Owned Small Business (SDVOSB) certified by U.S. Small Business Administration (SBA) that has been named multiple times to the Inc. 5000 and Vet 100 lists of the most successful and fastest-growing private companies in the nation. Netizen has also been named a national “Best Workplace” by Inc. Magazine, a multiple awardee of the U.S. Department of Labor HIRE Vets Platinum Medallion for veteran hiring and retention, the Lehigh Valley Business of the Year and Veteran-Owned Business of the Year, and the recipient of dozens of other awards and accolades for innovation, community support, working environment, and growth.

    Looking for expert guidance to secure, automate, and streamline your IT infrastructure and operations? Start the conversation today.


  • Netizen: Monday Security Brief (6/15/2026)

    Today’s Topics:

    • Self-Replicating AI Worm Shows Malware Can Reason Its Way Through a Network
    • U.S. Order Pulling Anthropic’s Fable 5 and Mythos 5 Turns AI Cyber Capability Into a National Security Fight
    • How can Netizen help?

    Self-Replicating AI Worm Shows Malware Can Reason Its Way Through a Network

    University of Toronto researchers have demonstrated a proof-of-concept AI worm that changes one of the oldest assumptions in worm defense: that the malware arrives with a fixed exploit path. In a preprint posted to arXiv on June 2, a team from the University of Toronto, the Vector Institute, the University of Cambridge, and ServiceNow described an AI-driven worm that used a locally hosted open-weight large language model to inspect systems, plan attacks, gain elevated access, and copy itself across a network without human direction.

    The research does not describe malware released into the wild. The worm was tested inside an isolated virtual environment, and the authors withheld operational details from the public paper. Still, the results are a warning about where autonomous offensive tooling is heading. This prototype did not rely on OpenAI, Anthropic, Google, or another commercial model provider. It used a local model running on a single GPU, which means provider-side controls such as account suspension, rate limits, refusals, and API revocation would not stop the core mechanism.

    Traditional worms are usually constrained by the exploit logic built into them before deployment. They scan for systems matching a known condition, run a known payload, and spread if that specific path works. Patch the vulnerability, block the traffic pattern, or remove the exposed service, and the worm’s propagation path can collapse.

    The Toronto prototype works differently. It uses the model as an attack engine. The worm identifies what is exposed on a target, reasons about the likely weakness, generates or adapts an attack plan, attempts exploitation, troubleshoots failures, and then stages a replica if access is obtained. The attack path is not fixed at build time. It is produced during execution.

    The researchers tested the worm across 15 independent runs inside a deliberately vulnerable 33-host network named FakeCorp. The network included Ubuntu, Debian, Alpine Linux, Rocky Linux, CentOS Stream, Windows Server 2008 R2, Windows Server 2019, Windows Server 2022, and IoT-style devices. Each host was seeded with at least one realistic vulnerability or weakness drawn from sources such as the CISA Known Exploited Vulnerabilities catalog, OWASP Top 10 categories, and MITRE ATT&CK techniques.

    Across seven days of autonomous operation per run, the worm identified an average of 31.3 vulnerabilities, gained elevated access on 23.1 hosts, and launched independent replicas on 20.4 hosts. In percentage terms, it obtained elevated access on 73.8% of the network and replicated to 61.8%. The worm reached up to seven generations of self-replication, with a mean of 5.1 generations.

    The result is significant less for the raw success rate than for the operating model. The test network was intentionally vulnerable and did not include active endpoint defense, antivirus, or firewall enforcement. The authors make that limitation clear. The experiment measured whether an autonomous agent could reason across a mixed network, adapt to different host types, and sustain propagation, not whether it could defeat a mature production security program.

    Even with those limits, the mechanics are difficult to ignore. The worm did not need a universal exploit. It could use one route on a Linux host, another on a Windows system, and another against a web application or exposed service. In one run, the propagation tree crossed multiple generations and operating systems, showing how the model could treat each host as a separate problem rather than a copy of the previous target.

    The paper also undercuts the idea that model training cutoffs create a stable defensive boundary. The worm successfully exploited test hosts configured with three vulnerabilities disclosed after the model’s training period: the Marimo pre-authentication RCE tracked as CVE-2026-39987, the Linux kernel Copy Fail privilege escalation tracked as CVE-2026-31431, and the Dirty Frag Linux kernel privilege-escalation chain tracked through CVE-2026-43284 and CVE-2026-43500. The agent did this by ingesting public advisory information at runtime and converting it into working attack logic inside the lab environment.

    That finding connects directly to real-world exploitation timelines. Sysdig reported that CVE-2026-39987 in Marimo was exploited within 9 hours and 41 minutes of public disclosure, before public proof-of-concept code was available. In a later investigation, Sysdig also documented an intrusion where an attacker used an LLM agent during post-exploitation after compromising an internet-facing Marimo instance. The observed attack moved from initial access to internal database exfiltration in under an hour.

    The broader pattern is not limited to one research paper. Google Threat Intelligence Group reported in May that it had identified what it assessed with high confidence as a zero-day exploit developed with AI assistance, intended for a planned mass exploitation event. Google also reported malware families using AI-linked techniques for dynamic modification, decoy logic, and autonomous command generation. Anthropic reported in November 2025 that it disrupted a cyber-espionage campaign attributed with high confidence to a China-linked state-sponsored group, where Claude Code allegedly handled most of the intrusion workflow across reconnaissance, exploitation, credential harvesting, lateral movement, and exfiltration.

    The Toronto work pushes that trend into worm propagation. Earlier AI worm research, such as Morris II, focused on adversarial self-replicating prompts spreading through GenAI applications and retrieval-augmented generation systems. In that model, the AI application is the propagation medium. In the Toronto prototype, the LLM is not the victim ecosystem. It is the reasoning layer driving attacks against ordinary network infrastructure.

    The compute model is part of the concern. The worm was built around the idea that compromised machines can supply reach, compute, or both. GPU-equipped hosts can become inference nodes for other infected machines that lack the resources to run the model locally. In a poorly segmented network, a compromised AI workstation, research server, rendering box, or machine learning node could become more than another endpoint. It could become a local reasoning hub for autonomous activity.

    That changes the containment problem. Blocking outbound calls to commercial AI services would not address a worm using local open-weight inference. Revoking API keys would not matter if the model is already running on victim-controlled compute. Provider-side safety controls can still reduce abuse of hosted systems, but they are not a complete answer for malware that brings its own model or steals the compute needed to run one.

    The prototype also showed signs that defenders should start thinking beyond static indicators. The authors reported that individual exploitation attempts succeeded 44% of the time, with many failures tied to malformed payload syntax rather than poor strategy. That weakness may shrink as code-generation models improve. They also observed the agent establishing persistence in two trajectories through mechanisms that were not part of the intended experiment, including service registration and scheduled task behavior. The researchers removed those mechanisms when they appeared, but the behavior shows how goal-directed agents can infer operational steps that were not explicitly coded into the harness.

    For defenders, the immediate lesson is not that every network now faces a fully autonomous AI worm. The lab environment was favorable to the attacker, and the implementation has not been publicly released. The lesson is that vulnerability management, segmentation, credential hygiene, and telemetry need to account for malware that can adapt during execution.

    GPU-capable systems deserve closer treatment in enterprise threat models. They are no longer just expensive workstations or infrastructure for AI teams. In an autonomous intrusion scenario, they can provide the compute needed for local reasoning. These systems should be segmented, monitored for unusual inference workloads, and restricted from broad lateral reach.

    Published advisories also need to be treated as near-term weaponization material. The Marimo exploitation window showed that attackers can move from advisory text to working intrusion activity within hours. The Toronto worm’s ability to use newer advisory information inside the test environment reinforces the same point. Patch prioritization can no longer rely only on severity scores and monthly cycles. Internet exposure, exploitability, compensating controls, and credential access paths need to drive response.

    Credential reuse remains one of the fastest propagation paths. An adaptive worm does not need a novel exploit for every host if harvested credentials, exposed keys, or weak service accounts let it move laterally. Any host that is compromised or credibly suspected should trigger credential rotation for secrets reachable from that system, including cloud keys, SSH keys, service tokens, database credentials, and local admin material.

    Detection programs also need behavioral logic for autonomous agents. Useful signals may include unusual process trees launching scanning tools, automated SSH key injection, repeated failed payload generation across multiple hosts, unexpected package installation followed by agent startup, nonstandard local inference activity, unexplained GPU utilization, and clusters of command execution that look like machine-speed troubleshooting rather than human terminal use.

    The central issue is not that AI creates a new category of vulnerability from nothing. It compresses the time between discovery, interpretation, exploitation, and propagation. A worm that can read advisories, test paths, recover from errors, and copy itself does not need attackers to manually script every step. It turns public vulnerability knowledge into operational movement.

    The research is still a controlled demonstration, but the direction is clear. The next meaningful shift in worm behavior may not come from a single devastating exploit. It may come from malware that can decide which exploit, weakness, credential, misconfiguration, or exposed service makes sense next.


    U.S. Order Pulling Anthropic’s Fable 5 and Mythos 5 Turns AI Cyber Capability Into a National Security Fight

    Anthropic took its most advanced AI models offline after the U.S. government ordered the company to suspend access to Claude Fable 5 and Claude Mythos 5 for foreign nationals, a sudden intervention that turned a model-safety dispute into one of the clearest examples yet of AI capability being treated like a controlled national security asset.

    The company said it received the directive at 5:21 p.m. Eastern time on June 12. The order applied to foreign nationals inside and outside the United States, including Anthropic employees. Anthropic said the practical effect was that it had to disable Fable 5 and Mythos 5 for all customers to comply, though access to the company’s other Claude models was not affected.

    The shutdown came only days after Anthropic launched Fable 5 as its first broadly available Mythos-class model. Fable 5 was the public-facing version, built on the same underlying model family as Mythos 5 but wrapped in stricter safety controls. Mythos 5, by comparison, was reserved for a smaller group of vetted cyber defenders and critical infrastructure partners through Anthropic’s trusted-access programs, with certain cybersecurity safeguards lifted for authorized defensive work.

    That distinction is at the center of the dispute. Anthropic’s own launch materials described Mythos-class systems as more capable than its Opus models, with strong performance across software engineering, cyber tasks, scientific work, and long-running agentic workflows. The company said Fable 5 used classifiers and fallback behavior to block high-risk cybersecurity requests, including attack planning, exploit development, and defense evasion. For many cyber-related prompts, Fable 5 was supposed to route the user to a less capable model or refuse the request.

    The government’s concern appears to have focused on whether those protections could be bypassed. Anthropic said officials told the company they were aware of a potential method for jailbreaking Fable 5. According to Anthropic, the method it reviewed involved asking the model to inspect a specific codebase and fix software flaws, producing a small number of known and relatively minor vulnerabilities. The company argued that the demonstrated capability was not unique to Fable 5 and could be reproduced with other publicly available models.

    That argument has not ended the controversy. Reuters reported that U.S. officials saw a risk that the models could be diverted to military intelligence use in adversarial countries, including China and Russia. Semafor separately reported that the decision was linked to fears that a China-linked group may have accessed the models. The Wall Street Journal and other outlets reported that Amazon security researchers raised concerns after using prompts that allegedly led Fable 5 to return information that could aid cyberattacks, and that Amazon CEO Andy Jassy discussed those concerns with the White House.

    David Sacks, a senior White House AI adviser, publicly argued that a trusted partner of both Anthropic and the U.S. government had found a jailbreak that Anthropic refused to fix before the government moved. Anthropic rejected the idea that the reported issue justified recalling a commercial model deployed at scale, saying it had not received technical evidence of a broad jailbreak and that no universal jailbreak had been demonstrated against Fable 5.

    The fight is not just about one model. It is about how governments, AI labs, cloud providers, and defenders draw the line between legitimate security work and offensive capability. Anthropic’s own red-team research had already raised the stakes. Days before the shutdown, the company published findings showing that Mythos Preview could turn recently disclosed vulnerabilities into working exploits far faster than traditional patch cycles assume.

    In Anthropic’s N-day testing, Mythos Preview produced working exploits against Firefox vulnerabilities and full privilege-escalation chains against Windows kernel vulnerabilities. The company said the model generated its first Windows proof of concept in 31 minutes and produced multiple full exploit chains for a few thousand dollars in API credits. Anthropic’s conclusion was blunt: the old assumption that attackers need expert-weeks to weaponize patches is breaking down.

    That context makes the government’s reaction easier to parse. A model that can compress exploit development from weeks into hours changes the risk calculation around public advisories, patch diffing, and delayed remediation. The same capability can help defenders validate fixes, understand exploitability, and prioritize patches. It can also help attackers move faster against organizations still sitting inside the patch gap.

    Fable 5 was supposed to solve that tension through safeguards. Mythos 5 was supposed to limit the highest-risk cyber capabilities to vetted users. The government’s order suggests officials were not satisfied that Anthropic’s controls, monitoring, and access restrictions were enough, at least once the alleged jailbreak and foreign-access concerns entered the picture.

    Cybersecurity leaders have pushed back. A group led by former Facebook security chief Alex Stamos argued that restricting Fable 5 harms defenders more than attackers, since comparable capabilities are available through other frontier models and open models. Their position is that security teams need access to the same level of automation attackers are beginning to use, especially for exploit validation, code review, patch triage, and defensive research.

    That is the operational dilemma. If frontier cyber models are locked down too tightly, authorized defenders lose speed. If they are released too broadly, offensive users may gain a cheaper route to exploit development. If access is limited by nationality rather than risk, companies with global teams can lose the ability to run their own products. Anthropic said the directive was broad enough to include foreign-national employees, which made selective compliance difficult and forced the wider shutdown.

    The case also puts cloud and supply-chain politics in the middle of AI security. Amazon is both a major Anthropic investor and a cloud partner. Its reported role in raising concerns to the White House has drawn attention to how much influence large infrastructure providers may have over the future of model deployment. A security finding from a partner can become a regulatory event if it reaches government officials at the right moment.

    For enterprises, the most immediate lesson is that AI access is becoming a dependency risk. Organizations building workflows around frontier models may have to plan for sudden policy-driven outages, regional restrictions, nationality-based controls, or trusted-access gates. That matters for software development, SOC workflows, vulnerability management, secure code review, incident response, and any business process tied to model-specific performance.

    The case also signals that AI governance is moving from voluntary safety frameworks into hard national security controls. Frontier models are being evaluated less like ordinary SaaS products and more like dual-use infrastructure. Cyber capability, biological capability, agentic autonomy, data retention, user vetting, export controls, and monitoring are becoming part of the same policy conversation.

    For defenders, the issue should not be reduced to whether Fable 5 should or should not have been suspended. The more durable issue is that model-assisted exploit development is now credible enough to trigger emergency government action. That alone should change how security teams think about patch windows, exposure management, and cyber tooling.

    Patch Tuesday can no longer be treated as a slow-moving administrative cycle if models can turn public patches into working attack paths within hours. Internet-facing systems need faster triage. Critical vulnerabilities need temporary controls when patching cannot happen immediately. Security teams need better exploitability analysis, stronger asset visibility, and faster validation that mitigations actually work.

    At the same time, defenders will need clear, auditable ways to use advanced AI safely. Trusted-access programs, identity-gated cyber models, enterprise monitoring, approved-use scoping, and stronger account security are likely to become standard features for high-capability defensive AI. The question is whether those controls can be precise enough to support real defense without handing the same capability to malicious users.


    How Can Netizen Help?

    Founded in 2013, Netizen is an award-winning technology firm that develops and leverages cutting-edge solutions to create a more secure, integrated, and automated digital environment for government, defense, and commercial clients worldwide. Our innovative solutions transform complex cybersecurity and technology challenges into strategic advantages by delivering mission-critical capabilities that safeguard and optimize clients’ digital infrastructure. One example of this is our popular “CISO-as-a-Service” offering that enables organizations of any size to access executive level cybersecurity expertise at a fraction of the cost of hiring internally. 

    Netizen also operates a state-of-the-art 24x7x365 Security Operations Center (SOC) that delivers comprehensive cybersecurity monitoring solutions for defense, government, and commercial clients. Our service portfolio includes cybersecurity assessments and advisory, hosted SIEM and EDR/XDR solutions, software assurance, penetration testing, cybersecurity engineering, and compliance audit support. We specialize in serving organizations that operate within some of the world’s most highly sensitive and tightly regulated environments where unwavering security, strict compliance, technical excellence, and operational maturity are non-negotiable requirements. Our proven track record in these domains positions us as the premier trusted partner for organizations where technology reliability and security cannot be compromised.

    Netizen holds ISO 27001, ISO 9001, ISO 20000-1, and CMMI Level III SVC registrations demonstrating the maturity of our operations. We are a proud Service-Disabled Veteran-Owned Small Business (SDVOSB) certified by U.S. Small Business Administration (SBA) that has been named multiple times to the Inc. 5000 and Vet 100 lists of the most successful and fastest-growing private companies in the nation. Netizen has also been named a national “Best Workplace” by Inc. Magazine, a multiple awardee of the U.S. Department of Labor HIRE Vets Platinum Medallion for veteran hiring and retention, the Lehigh Valley Business of the Year and Veteran-Owned Business of the Year, and the recipient of dozens of other awards and accolades for innovation, community support, working environment, and growth.

    Looking for expert guidance to secure, automate, and streamline your IT infrastructure and operations? Start the conversation today.


  • How Living-Off-the-Land Attacks Bypass Traditional Security Controls

    Living-off-the-land attacks have become one of the clearest examples of a security problem that cannot be solved by malware detection alone. Instead of bringing obvious malicious tooling into an environment, attackers use what is already present: signed Windows binaries, administrative consoles, scripting engines, remote management services, cloud command-line tools, backup utilities, identity platforms, and trusted software already approved by IT.

    The strategy is effective for a simple reason. Many security controls were built to answer a narrow question: “Is this file, hash, domain, attachment, or executable known to be bad?” Living-off-the-land activity changes the question. The executable may be signed by Microsoft. The command may be launched by an account that has valid credentials. The network traffic may use HTTPS, SMB, WinRM, RDP, or a sanctioned cloud API. The action may look like administration until it is placed in the correct behavioral context.

    That is why these attacks bypass traditional controls so often. The problem is not that antivirus, EDR, firewalls, SIEMs, or allowlists have no value. The problem is that many of them fail when telemetry is incomplete, baselines are missing, alert logic is too generic, and legitimate administration has never been separated from attacker tradecraft.


    What Living Off the Land Means Mechanically

    A living-off-the-land attack is the abuse of native or trusted tools to perform malicious actions. In Windows environments, this often includes PowerShell, cmd.exe, Windows Management Instrumentation, Windows Remote Management, rundll32.exe, regsvr32.exe, mshta.exe, certutil.exe, bitsadmin.exe, schtasks.exe, net.exe, netsh.exe, vssadmin.exe, and ntdsutil.exe. In Linux environments, attackers may use bash, curl, wget, Python, systemctl, cron, SSH, tar, or built-in package managers. In macOS environments, native scripting and persistence mechanisms such as osascript, launchctl, shell scripts, and LaunchAgents can serve a similar role. In cloud environments, the same pattern appears through Azure CLI, AWS CLI, Google Cloud CLI, Microsoft Graph PowerShell modules, cloud shells, service principals, API tokens, and management consoles.

    The attacker’s goal is not merely stealth. LOTL tradecraft also reduces operational cost. An attacker using built-in tooling does not need to deploy a large malware set, maintain custom implants for every target, or risk immediate detection by hash-based scanning. Once valid credentials are obtained, native tools can support reconnaissance, execution, lateral movement, credential access, persistence, exfiltration staging, and defense evasion.

    A typical intrusion may start with phishing, exposed remote access, a vulnerable edge device, stolen credentials, or a compromised SaaS account. After access is obtained, the attacker can enumerate the domain with net.exe or PowerShell, execute commands remotely through WMI or WinRM, copy files through SMB, stage payloads with certutil or BITS, dump Active Directory data using vssadmin and ntdsutil, create scheduled tasks for persistence, and modify firewall or proxy settings with netsh. Each individual action may resemble legitimate administrative work. The malicious nature comes from the sequence, account context, timing, destination, parent process, host role, and deviation from baseline.


    Why Traditional Antivirus Misses LOTL Activity

    Traditional antivirus is strongest against known malicious files, suspicious static traits, and recognized malware families. LOTL activity often leaves no traditional malware artifact. The attacker may execute commands directly in memory, use trusted interpreters, or run one-line scripts that never persist as a conventional executable on disk.

    PowerShell is a common example. It is a legitimate Windows automation framework used by administrators, help desk teams, endpoint management tools, and software deployment systems. An attacker can use it for discovery, credential access, payload retrieval, code execution, and remote administration. A static scanner looking only for a malicious binary may see nothing abnormal. The binary being executed is powershell.exe, signed and expected on Windows systems.

    The same issue applies to rundll32.exe and regsvr32.exe. Both can be abused to proxy execution through trusted signed binaries. If a control treats signed Microsoft binaries as inherently safe, an attacker can use that trust boundary against the environment. The executable itself is legitimate; the abuse sits in the arguments, loaded content, parent-child relationship, loaded DLL path, network connection, or scriptlet behavior.

    This is why hash-centric detection breaks down. The hash of powershell.exe or rundll32.exe is not the signal. The signal is that PowerShell was launched by Word, Excel, a browser, a PDF reader, or a suspicious parent process; that it used encoded or hidden execution parameters; that it made outbound network connections; that it spawned another process; or that it ran under a user context that does not normally perform administration.


    Why Allowlisting Can Still Fail

    Application allowlisting is valuable, but weak policy design can create a false sense of control. Many organizations allow Windows system binaries by default, trust signed Microsoft executables broadly, or grant broad script execution rights to avoid disrupting IT operations. Attackers know this and select binaries likely to pass policy checks.

    This is the central weakness behind signed binary proxy execution. The security control permits the signed tool, then the attacker uses that tool to execute or load untrusted content. Mshta.exe can execute HTML application content. Regsvr32.exe can proxy execution through COM registration behavior. Rundll32.exe can load DLLs from locations that should not host executable content. InstallUtil.exe, MSBuild.exe, and similar developer or framework utilities may run code paths that were never expected in standard user workflows.

    A mature allowlisting model must account for more than file identity. It needs path, signer, command-line parameters, parent process, user role, device group, child process creation, and network behavior. Allowing rundll32.exe from System32 is not the same as allowing rundll32.exe to load a DLL from a user profile, temporary directory, browser cache, SMB share, or newly created directory.


    Why EDR Alerts Become Noisy

    Modern EDR tools are far better suited to LOTL detection than legacy antivirus, but EDR is still limited by tuning, data quality, and analyst workflow. A generic alert for PowerShell usage is not useful in an enterprise where administrators, endpoint management agents, installers, and security tools use PowerShell every day. A generic alert for WMI activity can create the same problem.

    Attackers exploit this operational noise. They run commands that resemble IT administration, use real accounts, operate during business hours, and avoid obviously malicious binaries. In many environments, suspicious LOTL activity is visible in telemetry, yet it is buried among high-volume administrative events.

    This is where many defenses fail. The issue is not always missing data. It is often missing context. Security teams need to know which users normally run remote PowerShell, which devices initiate WMI connections, which servers should use ntdsutil.exe, which hosts are allowed to use certutil.exe for network retrieval, and which administrative tools should never launch from an Office child process.

    A tuned detection should ask context-heavy questions. Did a non-administrative user launch a scripting interpreter? Did PowerShell spawn from a browser, email client, Office process, archive utility, or PDF reader? Did a workstation initiate WMI execution against several servers? Did certutil.exe contact an external domain and write to a user-writable path? Did rundll32.exe load a DLL from a nonstandard directory? Did netsh create a port proxy rule on a device that has no operational reason to do so?


    Why Network Security Controls Miss It

    Network defenses often look for known malicious destinations, exploit signatures, suspicious protocols, or abnormal traffic volume. LOTL activity can avoid each of these. Attackers may use legitimate remote access channels, built-in management protocols, sanctioned cloud services, or encrypted web traffic. They may transfer data in small volumes, blend activity with real administrative traffic, or route activity through already compromised internal systems.

    For example, WMI, WinRM, SMB, RDP, SSH, and HTTPS may all be legitimate inside an enterprise. Blocking them outright is rarely practical. Attackers can use these same protocols for remote execution, file movement, tunneling, discovery, or credentialed access. A firewall that permits WinRM from a management subnet may have no way to judge whether the command sent across that connection is normal administration or malicious execution. A proxy may see a connection to a permitted cloud service, yet not the intent behind the session.

    This is also where cloud LOTL becomes difficult. If an attacker obtains a valid cloud token, many actions happen in the control plane rather than on a monitored endpoint. The attacker may enumerate storage, create access keys, modify firewall rules, snapshot disks, change identity policies, or export data through cloud-native APIs. A traditional endpoint control may see little or nothing. Detection depends on audit logging, identity telemetry, API activity, conditional access signals, and correlation across cloud and endpoint data.


    Credential Abuse Makes LOTL Harder to Separate From Administration

    LOTL attacks often become most dangerous after credential theft or token compromise. Once the attacker has valid credentials, authentication may appear successful, compliant, and routine. The account may pass MFA if the attacker stole a session token, used an approved device, abused legacy authentication, or socially engineered the user.

    Valid credentials let attackers reduce the need for exploit code. They can access management interfaces, move laterally, run native commands, and query internal resources without dropping malware. This changes the detection problem from “block the exploit” to “identify account behavior that does not match the user, host, privilege level, or business process.”

    Identity telemetry becomes central. Defenders should correlate logon type, source device, geographic context, impossible travel indicators, privilege use, new device enrollment, new service principal activity, administrative group changes, token use, and unusual command execution. A domain admin logging into a domain controller during a maintenance window may be normal. A help desk account using remote PowerShell against finance servers from an unmanaged workstation at 2:00 a.m. is a different event.


    Common LOTL Attack Patterns

    One common pattern is script-based execution. An attacker uses PowerShell, cmd.exe, wscript.exe, cscript.exe, mshta.exe, Python, or bash to execute commands, retrieve payloads, perform discovery, or load code into memory. Detection should focus on parent process, execution policy changes, encoded or compressed command content, web requests, unusual child processes, and use by accounts that do not normally run scripts.

    A second pattern is remote administration abuse. WMI, WinRM, PsExec-like behavior, SMB admin shares, RDP, SSH, and remote service creation can all support lateral movement. Detection should focus on source-to-destination relationships, remote execution from non-management systems, rare administrator account use, sudden fan-out to many endpoints, new services, and command execution following authentication.

    A third pattern is signed binary proxy execution. Rundll32.exe, regsvr32.exe, mshta.exe, cmstp.exe, installutil.exe, and msbuild.exe can execute or load content through trusted binaries. Detection should focus on unusual file paths, suspicious command-line arguments, network retrieval, user-writable directories, unexpected parent processes, DLL loads from temporary paths, and child process chains.

    A fourth pattern is trusted transfer tooling. Certutil.exe, bitsadmin.exe, curl, wget, ftp, scp, cloud storage clients, and native package managers can retrieve or move tools. The command may look like a normal download. The relevant question is whether that tool should contact that destination, write to that directory, run under that account, and launch follow-on execution.

    A fifth pattern is credential and directory abuse. Vssadmin.exe, ntdsutil.exe, esentutl.exe, reg.exe, net.exe, dsquery, nltest, whoami, and PowerShell directory modules can support credential access and domain discovery. Use of vssadmin or ntdsutil on a domain controller should be tightly controlled and reviewed. A command sequence that creates a volume shadow copy, accesses NTDS.dit, stages files, and transfers them off-host is highly suspicious outside a known backup workflow.

    A sixth pattern is security control tampering. Attackers may disable services, modify logging, alter firewall settings, create proxy rules, clear event logs, change exclusions, or weaken endpoint protection through native tools. Commands that stop security services, modify Defender exclusions, clear logs, change audit settings, or create netsh port proxy entries should be treated as high-value telemetry.


    Detection Requires Behavior, Not Just Indicators

    The main weakness of IOC-based detection is that LOTL activity produces fewer stable indicators. Domains, IP addresses, file names, and command syntax can change quickly. The underlying behavior changes less. An attacker still needs to execute, discover, authenticate, move, stage, persist, collect, and exfiltrate.

    Behavioral detection does not mean vague anomaly alerts. It means mapping expected activity and identifying high-risk deviations. A strong LOTL detection program starts with telemetry coverage: process creation with full command line, parent and child processes, file writes, module loads, network connections, DNS queries, script block logging, WMI activity, scheduled task creation, service creation, authentication events, privilege use, cloud audit logs, and identity provider logs.

    From there, detections should be written around chains of activity. A single PowerShell command may be benign. PowerShell spawned by an Office process, making an external web request, writing into a temporary directory, and spawning rundll32.exe is much more meaningful. A single WMI event may be normal. WMI execution from a workstation into several servers, followed by service creation and outbound traffic, is not.

    Security teams should prioritize detections that combine context. Useful dimensions include user role, host role, process ancestry, command-line content, execution path, signer, destination, time of day, peer group behavior, privilege level, and recent authentication pattern. This approach reduces false positives and makes alerts more actionable.


    Logging Gaps Are a Major Reason LOTL Works

    Many organizations cannot detect LOTL tradecraft due to missing telemetry. Default logging often does not capture enough detail to reconstruct attacker behavior. Without full command-line logging, defenders may know that powershell.exe ran but not what it did. Without script block logging, the executed content may remain opaque. Without Sysmon or comparable endpoint telemetry, parent-child relationships, network connections, file writes, and module loads may be incomplete. Without centralized log storage, attackers can delete or modify local evidence.

    For Windows environments, high-value telemetry often includes Security Event ID 4688 with command-line process creation, PowerShell Script Block Logging Event ID 4104, PowerShell Module Logging Event ID 4103, WMI-Activity Operational events such as 5857 through 5861, Sysmon process creation, network connection, DNS, image load, file creation, WMI event subscription, and scheduled task events. Domain controllers need close monitoring for vssadmin.exe, ntdsutil.exe, esentutl.exe, suspicious volume shadow copy access, unusual replication activity, privileged logons, and sensitive directory queries.

    For Linux and macOS environments, defenders need shell history where available, auditd or equivalent event collection, process execution telemetry, cron and systemd changes, SSH authentication logs, sudo usage, new authorized keys, package manager activity, outbound network connections, and file integrity monitoring for persistence locations.

    For cloud environments, defenders need audit logs for identity, compute, storage, network, key management, serverless functions, SaaS administration, service principal changes, API token creation, conditional access changes, and data access. Cloud-native LOTL can bypass endpoint visibility completely, so cloud control-plane logs must be treated as primary security telemetry.


    Hardening Against LOTL

    Reducing LOTL risk starts with limiting who can use high-risk administrative tools, where they can run, and what they can reach. Admin activity should occur from hardened administrative workstations, not daily-use endpoints. Privileged accounts should be separated from standard user accounts. Remote administration should be restricted by network segment, device trust, and role. PowerShell remoting, WinRM, WMI, RDP, SSH, and administrative shares should be exposed only where operationally required.

    Application control should be used with care. Blocking every native tool is unrealistic, but high-risk LOLBins can be constrained by user group, device group, path, and use case. Script execution should be controlled through signed scripts, constrained language mode where suitable, and policy-backed execution controls. User-writable directories should not be trusted execution locations.

    Identity controls matter just as much as endpoint controls. Phishing-resistant MFA, conditional access, privileged access management, just-in-time administration, local administrator password management, service account governance, and regular privilege review all reduce the chance that valid credentials become a quiet path for LOTL activity.

    Network segmentation also limits the blast radius. Workstations should not have broad management access to servers. Domain controllers should accept administration only from approved systems. Backup infrastructure, identity systems, hypervisors, and security tooling should sit in protected segments with strict authentication, logging, and access paths.


    SOC Priorities for LOTL Detection

    A SOC trying to improve LOTL coverage should start with a small set of high-value use cases rather than a flood of generic alerts. The first priority is process execution visibility on endpoints and servers, including command line and parent-child process relationships. The second priority is privileged account monitoring, especially unusual logons, remote execution, administrative group changes, and new service or scheduled task creation. The third priority is high-risk LOLBin monitoring for binaries that are rarely used in normal workflows.

    Detection engineering should focus on attacker objectives. For execution, monitor suspicious script interpreters and signed proxy binaries. For lateral movement, monitor WMI, WinRM, SMB admin shares, RDP, SSH, and remote service creation. For credential access, monitor LSASS access, shadow copy creation, NTDS.dit access, registry hive export, and suspicious use of directory tools. For defense evasion, monitor logging changes, service stops, security tool exclusions, firewall changes, and event log clearing. For exfiltration, monitor unusual compression, staging directories, cloud storage uploads, outbound transfers, and data access from abnormal accounts.

    The best detections will not simply say, “PowerShell ran.” They will say, “PowerShell ran from an abnormal parent process, under a non-administrative user, with encoded content, followed by external network access and a child process.” That is the difference between a noisy rule and a useful detection.


    Why LOTL Requires a Different Security Model

    Living-off-the-land attacks succeed when security programs treat trusted tools as trusted behavior. That assumption no longer holds. A signed binary can execute malicious content. A valid account can act maliciously. A sanctioned protocol can carry attacker commands. A normal cloud API can exfiltrate data. A legitimate remote management tool can become persistence.

    The defensive model needs to move from object reputation to operational context. Security teams need to know what normal administration looks like, where privileged actions should originate, which tools are expected on which hosts, what scripts are approved, and which cloud actions match business workflows. Controls should then detect deviations from that model.

    LOTL is not a niche tradecraft problem. It is a visibility, identity, hardening, and detection engineering problem. Organizations that rely only on static malware detection, default logging, broad allowlists, and untuned EDR rules will continue to miss attacker activity that is plainly visible but poorly interpreted. The stronger approach is to combine centralized logging, behavior-based analytics, least privilege, segmented administration, cloud audit coverage, and detection logic built around real attacker workflows.

    The core lesson is direct: if defenders cannot distinguish legitimate administration from malicious administration, attackers will continue to hide inside the tools the business already trusts.


    How Can Netizen Help?

    Founded in 2013, Netizen is an award-winning technology firm that develops and leverages cutting-edge solutions to create a more secure, integrated, and automated digital environment for government, defense, and commercial clients worldwide. Our innovative solutions transform complex cybersecurity and technology challenges into strategic advantages by delivering mission-critical capabilities that safeguard and optimize clients’ digital infrastructure. One example of this is our popular “CISO-as-a-Service” offering that enables organizations of any size to access executive level cybersecurity expertise at a fraction of the cost of hiring internally. 

    Netizen also operates a state-of-the-art 24x7x365 Security Operations Center (SOC) that delivers comprehensive cybersecurity monitoring solutions for defense, government, and commercial clients. Our service portfolio includes cybersecurity assessments and advisory, hosted SIEM and EDR/XDR solutions, software assurance, penetration testing, cybersecurity engineering, and compliance audit support. We specialize in serving organizations that operate within some of the world’s most highly sensitive and tightly regulated environments where unwavering security, strict compliance, technical excellence, and operational maturity are non-negotiable requirements. Our proven track record in these domains positions us as the premier trusted partner for organizations where technology reliability and security cannot be compromised.

    Netizen holds ISO 27001, ISO 9001, ISO 20000-1, and CMMI Level III SVC registrations demonstrating the maturity of our operations. We are a proud Service-Disabled Veteran-Owned Small Business (SDVOSB) certified by U.S. Small Business Administration (SBA) that has been named multiple times to the Inc. 5000 and Vet 100 lists of the most successful and fastest-growing private companies in the nation. Netizen has also been named a national “Best Workplace” by Inc. Magazine, a multiple awardee of the U.S. Department of Labor HIRE Vets Platinum Medallion for veteran hiring and retention, the Lehigh Valley Business of the Year and Veteran-Owned Business of the Year, and the recipient of dozens of other awards and accolades for innovation, community support, working environment, and growth.

    Looking for expert guidance to secure, automate, and streamline your IT infrastructure and operations? Start the conversation today.


  • June 2026 Patch Tuesday: Microsoft Addresses 200 Flaws, Including BitLocker and HTTP/2 Zero-Days

    Microsoft’s June 2026 Patch Tuesday includes security updates for 200 vulnerabilities, making it one of the largest patch releases in recent years. The update addresses three publicly disclosed zero-days and 33 critical vulnerabilities, the majority of which are remote code execution flaws. While none of the zero-days are known to have been exploited in the wild, several involve core Windows security mechanisms and could present significant risk if left unpatched.


    Breakdown of Vulnerabilities

    • 65 Elevation of Privilege vulnerabilities
    • 55 Remote Code Execution vulnerabilities
    • 30 Information Disclosure vulnerabilities
    • 27 Spoofing vulnerabilities
    • 19 Security Feature Bypass vulnerabilities
    • 7 Denial of Service vulnerabilities

    These totals do not include vulnerabilities addressed earlier in Microsoft services such as Mariner, Azure HorizonDB, Microsoft Copilot, Copilot Chat, Microsoft 365 Copilot, Exchange Online, and Microsoft Graph. They also exclude 360 Microsoft Edge and Chromium vulnerabilities fixed separately by Google.


    Zero-Day Vulnerabilities

    This month’s release addresses three publicly disclosed zero-days.

    CVE-2026-45586 | Windows Collaborative Translation Framework (CTFMON) Elevation of Privilege Vulnerability

    This vulnerability allows an authorized attacker to gain SYSTEM privileges through improper link resolution before file access, commonly known as a link-following flaw. Successful exploitation requires local access and could enable complete system compromise. Microsoft attributes the discovery to an anonymous researcher but has not disclosed additional details regarding its public disclosure.

    CVE-2026-49160 | HTTP.sys Denial of Service Vulnerability

    This vulnerability, referred to as “HTTP/2 Bomb,” allows attackers to trigger denial of service conditions by abusing HTTP/2 header compression and resource allocation mechanisms. Researchers demonstrated that specially crafted requests can force disproportionate memory consumption, potentially leading to service degradation or outages. To mitigate this issue, Microsoft introduced a new MaxHeadersCount registry setting that allows administrators to limit the number of headers accepted in HTTP/2 and HTTP/3 requests. The vulnerability was discovered by Quang Luong and Codex of Calif.io.

    CVE-2026-50507 | Windows BitLocker Security Feature Bypass Vulnerability

    This vulnerability allows attackers with physical access to bypass BitLocker protections and access encrypted drives. The flaw, known publicly as “YellowKey,” abuses the Windows Recovery Environment by leveraging specially crafted files placed on removable media or EFI partitions. Researchers demonstrated that holding a specific key sequence during recovery could expose a command shell with unrestricted access to protected drives. The issue primarily impacts systems configured with TPM-only BitLocker authentication. Microsoft previously recommended mitigating the risk by enabling TPM+PIN authentication rather than relying solely on TPM protection.


    Other Notable Vulnerabilities

    Beyond the zero-days, Microsoft patched a significant number of critical remote code execution vulnerabilities across Windows components, enterprise services, and productivity applications. The unusually high number of RCE vulnerabilities this month makes patch prioritization especially important for organizations managing internet-facing systems and collaborative platforms.


    Adobe and Other Vendor Updates

    Several major vendors released security updates alongside Microsoft’s June patches:

    • Acer warned customers about two maximum-severity vulnerabilities affecting Wave 7 routers that remain unpatched.
    • Check Point released updates for Remote Access VPN and Mobile Access vulnerabilities exploited by Qilin ransomware operators.
    • Cisco issued patches for multiple products, including a Unified Communications Manager vulnerability with public proof-of-concept exploit code and an actively exploited SD-WAN zero-day.
    • Fortinet released updates addressing vulnerabilities in FortiOS, FortiSandbox, and FortiProxy.
    • Google’s June Android bulletin fixed 124 vulnerabilities and one actively exploited flaw. Google also patched an actively exploited Chrome zero-day.
    • Ivanti released updates for Endpoint Manager Mobile and Ivanti Sentry vulnerabilities, with no active exploitation reported.
    • Ubiquiti fixed three maximum-severity vulnerabilities that could lead to remote code execution.
    • SAP addressed four critical vulnerabilities across multiple products.
    • Veeam released fixes for a critical Backup & Replication vulnerability that could enable remote code execution on domain-joined backup servers.

    Recommendations for Users and Administrators

    Organizations should prioritize deployment of June’s updates due to the unusually high number of remote code execution and privilege escalation vulnerabilities. Systems utilizing SharePoint, Windows recovery environments, HTTP/2 services, and BitLocker should receive particular attention.

    Administrators should review BitLocker configurations and consider TPM+PIN deployments where feasible, evaluate HTTP.sys exposure and implement the new header-limiting controls, and validate that endpoint and server systems receive the latest cumulative updates. Security teams should also review third-party advisories from Cisco, Veeam, Fortinet, and Check Point, especially where active exploitation has already been observed.

    A patch volume of 200 vulnerabilities and 33 critical flaws makes June 2026 one of the most significant Patch Tuesday releases of the year, warranting accelerated testing and deployment across enterprise environments.

    Full technical details and patch links are available in Microsoft’s Security Update Guide.


    How Can Netizen Help?

    Founded in 2013, Netizen is an award-winning technology firm that develops and leverages cutting-edge solutions to create a more secure, integrated, and automated digital environment for government, defense, and commercial clients worldwide. Our innovative solutions transform complex cybersecurity and technology challenges into strategic advantages by delivering mission-critical capabilities that safeguard and optimize clients’ digital infrastructure. One example of this is our popular “CISO-as-a-Service” offering that enables organizations of any size to access executive level cybersecurity expertise at a fraction of the cost of hiring internally. 

    Netizen also operates a state-of-the-art 24x7x365 Security Operations Center (SOC) that delivers comprehensive cybersecurity monitoring solutions for defense, government, and commercial clients. Our service portfolio includes cybersecurity assessments and advisory, hosted SIEM and EDR/XDR solutions, software assurance, penetration testing, cybersecurity engineering, and compliance audit support. We specialize in serving organizations that operate within some of the world’s most highly sensitive and tightly regulated environments where unwavering security, strict compliance, technical excellence, and operational maturity are non-negotiable requirements. Our proven track record in these domains positions us as the premier trusted partner for organizations where technology reliability and security cannot be compromised.

    Netizen holds ISO 27001, ISO 9001, ISO 20000-1, and CMMI Level III SVC registrations demonstrating the maturity of our operations. We are a proud Service-Disabled Veteran-Owned Small Business (SDVOSB) certified by U.S. Small Business Administration (SBA) that has been named multiple times to the Inc. 5000 and Vet 100 lists of the most successful and fastest-growing private companies in the nation. Netizen has also been named a national “Best Workplace” by Inc. Magazine, a multiple awardee of the U.S. Department of Labor HIRE Vets Platinum Medallion for veteran hiring and retention, the Lehigh Valley Business of the Year and Veteran-Owned Business of the Year, and the recipient of dozens of other awards and accolades for innovation, community support, working environment, and growth.

    Looking for expert guidance to secure, automate, and streamline your IT infrastructure and operations? Start the conversation today.