Abstract
Vulnerability exploits remain an important mechanism for malware delivery, despite efforts to speed up the creation of patches and improvements in software updating mechanisms. Vulnerabilities in client applications (e.g., browsers, multimedia players, document readers) are often exploited in spear phishing attacks and are difficult to characterize using network scanners. Analyzing their lifecycle requires observing the deployment of patches on hosts around the world. Using data collected over 5 years on 8.4 million hosts, available through Symantec's WINE platform, we present the first systematic study of patch deployment in client-side vulnerabilities. We analyze the patch deployment process of 1,593 vulnerabilities from 10 popular client applications and identify several new threats presented by multiple installations of the same program and by shared libraries. For the 80 vulnerabilities in our dataset that affect code shared by two applications, the time between patch releases is up to 118 days. Furthermore, as patching rates differ considerably among applications, many hosts patch the vulnerability in one application but not in the other. We demonstrate two novel attacks that enable exploitation by invoking old versions of applications that remain installed. We also find that the median fraction of vulnerable hosts patched when exploits are released is at most 14%. Finally, we show that the patching rate is affected by user-specific and application-specific factors; for example, applications with an automated updating mechanism have significantly lower median times to patch.
Introduction
While server-side patching is well-studied, the lifecycle of client-side vulnerabilities—found in browsers, media players, and document editors—has long remained a "black box." Traditional security models assume a linear path: a vulnerability is disclosed, a patch is released, and users update. However, this study argues that this model is fundamentally broken by "clones": instances of the same vulnerable code existing in multiple places on a single machine.
This phenomenon occurs primarily through shared libraries (e.g., different Adobe applications bundling the same Flash library) and multiple installations (e.g., users maintaining several versions of the same program). The core challenge is that patching one application does not necessarily secure the others, leaving a dangerous "window of opportunity" for attackers to exploit unpatched clones of the code.
Methodology and Data Sources
The researchers developed a generic framework to map files on end-host machines to specific vulnerable or patched versions. Using a "majority voting" approach on filenames and metadata, they identified version-specific files across a massive dataset spanning 2008–2012. This included telemetry from 8.4 million real-world Windows hosts via Symantec WINE, vulnerability data from NVD and OSVDB, and exploit data from the Exploit Database (EDB).
To track the patching process, the authors employed Survival Analysis, a statistical method used to track the time until an event occurs. In this context, the "event" is a host moving from a vulnerable state to a patched state. This allowed for the calculation of critical milestones, such as $t_m$ (median time to patch 50% of the population) and $t_{90\%}$ (time to patch 90%), as illustrated in the vulnerability lifecycle timeline above.
Key Insights: The Patching Race
The study reveals that the defense is currently losing the race against exploits. The median fraction of hosts patched when an exploit is released is at most 14%. In most cases, more than half of the population remains vulnerable when the first attacks appear.
The Shared Code Lag
For vulnerabilities affecting code shared by two different applications, there is a median lag of 11 days (and up to 118 days) between the release of the first patch and the second. This lag provides attackers with a "blueprint" for creating exploits for the second, unpatched application. Furthermore, the authors demonstrated that they could invoke old, unpatched versions of applications (like an old Adobe Air installation) to exploit a vulnerability, even if the user's primary browser was fully up-to-date.
Automated Updates and the Long Tail
Google Chrome, which pioneered silent background updates, demonstrated the fastest patching rates in the study. However, even automated systems face a "long tail" problem.
As shown in the survival analysis curves, reaching 90% coverage can take hundreds of days (e.g., 246 days for Chrome) due to "inactive" installations that users rarely open. While 54% of vulnerability clusters reach 50% patching within 100 days, reaching 95% is incredibly difficult; only 28% of the patches in the study ever reached that level of coverage.
Conclusion and Future Work
The findings suggest that human factors and application design significantly impact security. For instance, security analysts patch nearly three times faster than the general user. On the vendor side, 77% of vulnerabilities see patches within 7 days of disclosure, suggesting the bottleneck is deployment rather than creation.
The authors propose that software updaters should evolve into background services that scan the entire hard drive for all instances of vulnerable code, rather than just updating the active version of a single application. They also advocate for a "Clean NVD" project to rectify the numerous version-mapping errors found in public vulnerability databases, which currently hinder automated patching efforts.
Summary updated