<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:media="http://search.yahoo.com/mrss/"><channel><title>Fundamentals | FirewallSync</title><link>https://firewallsync.com/tags/fundamentals/</link><description>Practical cybersecurity writing for engineering teams that ship fast.</description><language>en-us</language><image><url>https://firewallsync.com/icon-512.png</url><title>FirewallSync</title><link>https://firewallsync.com/</link></image><lastBuildDate>Fri, 16 Oct 2026 06:12:00 +0000</lastBuildDate><atom:link href="https://firewallsync.com/tags/fundamentals/index.xml" rel="self" type="application/rss+xml"/><item><title>CVE Record States: Published, Rejected and Disputed, and What Each Means for Vulnerability Triage</title><link>https://firewallsync.com/posts/cve-record-states-published-rejected-and-disputed-what-each-means-for-vulnerability-triage/</link><guid>https://firewallsync.com/posts/cve-record-states-published-rejected-and-disputed-what-each-means-for-vulnerability-triage/</guid><pubDate>Fri, 16 Oct 2026 06:12:00 +0000</pubDate><dc:creator>FirewallSync Editorial</dc:creator><category>Security Operations</category><description>A CVE ID is not always a confirmed, fixable flaw. The CVE Record Format has two states, Published and Rejected, plus tags such as disputed and unsupported-when-assigned. Here is what the rules say, what real records look like, and how to handle each in a triage queue.</description><enclosure url="https://firewallsync.com/posts/cve-record-states-published-rejected-and-disputed-what-each-means-for-vulnerability-triage/cover_hu9444216300449806353.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/cve-record-states-published-rejected-and-disputed-what-each-means-for-vulnerability-triage/cover_hu9444216300449806353.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/cve-record-states-published-rejected-and-disputed-what-each-means-for-vulnerability-triage/cover_hu9444216300449806353.jpg" alt="An open drawer of a pale grey metal card-index cabinet packed with index cards and divider tabs, with a wooden panel at left" width="1200" height="630"></p><p>A CVE ID (Common Vulnerabilities and Exposures identifier) looks like a settled fact: a number for one specific flaw. In practice the record behind it can be rejected, disputed, about a product nobody supports, or about a service you cannot patch. If your triage process treats every CVE ID in a scanner report the same way, it will waste effort on some and under-react to others. This guide explains the states and tags the CVE Program defines, shows real records, and suggests how to handle each case.</p>
<p><strong>Scope.</strong> This is research-based analysis plus one script we ran. On October 16, 2026 we read the CVE Record Format schema (the CVEProject/cve-schema repository on GitHub, main branch), its tag definitions, and the CVE Program&rsquo;s CNA Operational Rules version 4.2.0 (approved August 20, 2026, effective August 25, 2026). We fetched records from the CVE Services API and queried the NVD (National Vulnerability Database) API. We did not read the CVE Program&rsquo;s policy for disputing a CVE record, which the rules reference. For how CISA adds triage fields in an ADP container, see <a href="/posts/cisa-vulnrichment-how-to-read-ssvc-values-in-a-cve-record-and-turn-them-into-a-patch-decision/">Vulnrichment SSVC values</a>.</p>
<h2 id="who-writes-a-cve-record">Who writes a CVE record</h2>
<p>The schema&rsquo;s own description says the record format is the blueprint that CVE Numbering Authorities (CNAs) and Authorized Data Publishers (ADPs) use to describe a CVE record. A CNA is an organization authorized to assign CVE IDs within a defined scope. The schema says a record has at least one <code>cna</code> container, with exactly one allowed because only one CNA assigns the ID, and any number of <code>adp</code> containers added by other organizations. The CNA container must carry certain fields; an ADP container does not have to.</p>
<p>That split matters for triage. Everything you read in the <code>cna</code> container is the assigning organization&rsquo;s statement. Anything in an <code>adp</code> container, such as CISA&rsquo;s SSVC fields, was added by someone else.</p>
<h2 id="the-two-states-published-and-rejected">The two states: PUBLISHED and REJECTED</h2>
<p>The schema defines a record as either &ldquo;Published&rdquo; (when a CNA populates the data for the ID) or &ldquo;Rejected&rdquo;, and the <code>state</code> field in <code>cveMetadata</code> has only those two values. IDs that have been reserved but not yet published have no public record in this format that we could find; we did not test how the API presents them.</p>
<table>
  <thead>
      <tr>
          <th>State</th>
          <th>What the record contains</th>
          <th>Key fields</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>PUBLISHED</td>
          <td>The CNA&rsquo;s description, affected products, references and more</td>
          <td><code>datePublished</code>, <code>descriptions</code>, <code>affected</code>, <code>references</code>, optional <code>tags</code></td>
      </tr>
      <tr>
          <td>REJECTED</td>
          <td>No vulnerability details; an explanation instead</td>
          <td><code>dateRejected</code>, required <code>rejectedReasons</code>, optional <code>replacedBy</code> (an array of CVE IDs)</td>
      </tr>
  </tbody>
</table>
<p>Source: the schema&rsquo;s <code>cveMetadataPublished</code>, <code>cveMetadataRejected</code> and <code>cnaRejectedContainer</code> definitions.</p>
<h3 id="why-records-get-rejected">Why records get rejected</h3>
<p>The CNA Operational Rules (version 4.2.0) say:</p>
<ul>
<li>CNAs <strong>must</strong> reject unused or unpublished CVE IDs (rule 4.5.3.5).</li>
<li>CNAs <strong>may</strong> reject a published record. Common reasons include determining that no vulnerability exists, using an incorrect CVE ID, a duplicate assignment, or combining multiple IDs (4.5.3.6).</li>
<li>A rejection must use the CVE Program&rsquo;s formats and must include an explanation (4.5.3.7).</li>
<li>When IDs are merged, the redundant published IDs must be rejected (4.5.3.8).</li>
</ul>
<h3 id="two-real-rejected-records">Two real rejected records</h3>
<p>We fetched both from the CVE Services API on October 16, 2026.</p>
<table>
  <thead>
      <tr>
          <th>CVE ID</th>
          <th>Assigner</th>
          <th>Reserved</th>
          <th>Rejected</th>
          <th>Reason text in the record</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>CVE-2024-1992</td>
          <td>Wordfence</td>
          <td>2024-02-28</td>
          <td>2024-03-20</td>
          <td>&ldquo;Rejected as duplicate of CVE-2024-2306&rdquo;</td>
      </tr>
      <tr>
          <td>CVE-2019-1508</td>
          <td>Microsoft</td>
          <td>2018-11-26</td>
          <td>2020-01-24</td>
          <td>&ldquo;DO NOT USE THIS CANDIDATE NUMBER&hellip; This candidate was in a CNA pool that was not assigned to any issues during 2019.&rdquo;</td>
      </tr>
  </tbody>
</table>
<p>Neither record&rsquo;s <code>replacedBy</code> field was present, even though CVE-2024-1992&rsquo;s reason names a replacement in free text. If you automate &ldquo;follow the replacement&rdquo;, parse the reason text as a fallback and do not assume the structured field is populated. We examined only these two records, so we cannot say how common that is.</p>
<h2 id="tags-disputed-unsupported-when-assigned-exclusively-hosted-service">Tags: disputed, unsupported-when-assigned, exclusively-hosted-service</h2>
<p>The schema defines tag lists. CNAs can use three tags, and ADPs only one.</p>
<table>
  <thead>
      <tr>
          <th>Tag</th>
          <th>Who can set it</th>
          <th>Schema definition (paraphrased)</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>disputed</code></td>
          <td>CNA or ADP</td>
          <td>One party disagrees with another party&rsquo;s assertion that an issue in software is a vulnerability</td>
      </tr>
      <tr>
          <td><code>unsupported-when-assigned</code></td>
          <td>CNA</td>
          <td>When the CVE request was received, the product was already end-of-life or not supported by the vendor; only for records where all affected products or version lines are end-of-life</td>
      </tr>
      <tr>
          <td><code>exclusively-hosted-service</code></td>
          <td>CNA</td>
          <td>All known affected software or hardware exists only in the affected hosted service; not used if on-premises products are also affected</td>
      </tr>
  </tbody>
</table>
<p>Sources: the schema&rsquo;s <code>cna-tags.json</code> and <code>adp-tags.json</code>, and CNA rules 4.2.17.1 (CNAs must use <code>unsupported-when-assigned</code> where all affected products no longer receive fixes), 4.5.3.10 and 5.1.11.</p>
<p>On disputes, the rules say CNAs and the Secretariat <strong>must</strong> use the <code>disputed</code> tag <strong>and</strong> provide an explanation in the record (4.5.3.10), and that CVE Program members <strong>must</strong> show the disputed status and the explanation when displaying CVE record data (4.5.3.11). The disputed tag marks a disagreement; it is not a verdict. The CNA rules point disputes to a separate CVE Program policy that we did not read.</p>
<h3 id="what-these-look-like-in-real-records">What these look like in real records</h3>
<table>
  <thead>
      <tr>
          <th>CVE ID</th>
          <th>State and tag</th>
          <th>What the record says</th>
          <th>Other checks on October 16, 2026</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>CVE-2026-14683</td>
          <td>PUBLISHED, <code>disputed</code>, assigned by VulDB</td>
          <td>A local memory-allocation issue in HdrHistogram up to 2.2.2. Text includes &ldquo;It is still unclear if this vulnerability genuinely exists. This issue is disputed due to the potential lack of crossing of security boundaries and the pre-requisites for a successful attack.&rdquo;</td>
          <td>Published 2026-07-04, updated 2026-07-16; has a CISA-ADP container; NVD lists it as disputed with vulnStatus &ldquo;Deferred&rdquo;; EPSS 0.0016 (percentile 0.04694)</td>
      </tr>
      <tr>
          <td>CVE-2020-35235</td>
          <td>PUBLISHED, <code>unsupported-when-assigned</code>, assigned by mitre</td>
          <td>elFinder access-control flaw in the secure-file-manager WordPress plugin through 2.5 that lets any authenticated user run the upload command to achieve remote code execution; description notes it affects only products no longer supported by the maintainer</td>
          <td>Published 2020-12-14; EPSS 0.18284 (percentile 0.97186)</td>
      </tr>
  </tbody>
</table>
<p>The affected-products list of CVE-2020-35235 says vendor &ldquo;n/a&rdquo;, product &ldquo;n/a&rdquo;, version &ldquo;n/a&rdquo; with status &ldquo;affected&rdquo;, so a scanner cannot match it by version from the CVE record alone.</p>
<p>Two points follow. First, the disputed record in our example questions whether the issue is a vulnerability at all. Its EPSS score is low, but a low score is a probability estimate, not proof that the dispute is right. Second, an end-of-life tag does not mean low risk: EPSS, which estimates the probability of observed exploitation activity in the next 30 days, put CVE-2020-35235 at the 97th percentile in the file scored 2026-10-15. See our <a href="/posts/epss-data-feed-columns-percentile-vs-probability-and-how-to-join-it-to-a-scanner-export/">EPSS data feed guide</a> for how to read that column.</p>
<h2 id="the-affected-status-field-affected-unaffected-unknown">The affected-status field: affected, unaffected, unknown</h2>
<p>Inside a published record, each product version has a status of <code>affected</code>, <code>unaffected</code> or <code>unknown</code>. The schema says <code>unknown</code> means it is unknown or unspecified whether a version is affected, for reasons including that no investigation has been done or the vendor has not disclosed the status. The CNA rules require every record to identify at least one product as affected or unknown (5.1.4), say CNAs should resolve unknown status within a reasonable timeframe, and add that a permanent unknown may be appropriate, for instance when a product is suspected of being affected but has not been investigated (5.1.6). A record may not contain only unaffected products (5.1.8).</p>
<p>For triage: <code>unknown</code> is not a clean bill of health, and a version listed as <code>unaffected</code> is only as good as the CNA&rsquo;s analysis.</p>
<h2 id="how-big-are-these-categories">How big are these categories?</h2>
<p>We queried the NVD API on October 16, 2026. NVD is a separate database that ingests CVE records, so its numbers describe NVD&rsquo;s data, not the CVE List itself.</p>
<table>
  <thead>
      <tr>
          <th>Measure (NVD API, October 16, 2026)</th>
          <th>Result</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Total CVE records returned</td>
          <td>408,789</td>
      </tr>
      <tr>
          <td>Records returned with the <code>noRejected</code> parameter</td>
          <td>390,296</td>
      </tr>
      <tr>
          <td>Difference (implied rejected records)</td>
          <td>18,493 (4.5% of the total)</td>
      </tr>
      <tr>
          <td>Records with <code>cveTag=disputed</code></td>
          <td>1,509</td>
      </tr>
  </tbody>
</table>
<p>We inferred the rejected count by subtraction; we confirmed that CVE-2019-1508 has vulnStatus &ldquo;Rejected&rdquo; without the parameter and returns no results with it, and that CVE-2024-1992 has vulnStatus &ldquo;Rejected&rdquo;. The EPSS file we used elsewhere held 389,824 scored CVEs, close to the 390,296 non-rejected count but not identical. We did not investigate the 472-record gap, and the two files were queried hours apart.</p>
<h2 id="a-triage-playbook">A triage playbook</h2>
<p>These steps are our suggestions, not part of any CVE Program rule, and we did not test them in a production queue.</p>
<table>
  <thead>
      <tr>
          <th>What the scanner or feed shows</th>
          <th>What to check</th>
          <th>Suggested handling</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>CVE state is REJECTED</td>
          <td><code>rejectedReasons</code>, then <code>replacedBy</code> or the reason text</td>
          <td>Close the finding as stale; if the reason names another CVE ID, make sure that ID is on your list</td>
      </tr>
      <tr>
          <td>Published, tagged <code>disputed</code></td>
          <td>The explanation in the record, the vendor&rsquo;s advisory, your own exposure</td>
          <td>Keep it in a &ldquo;needs decision&rdquo; state; record who decided and why. Do not auto-close and do not auto-escalate</td>
      </tr>
      <tr>
          <td>Tagged <code>unsupported-when-assigned</code></td>
          <td>Whether you still run the product</td>
          <td>If you do, the remedy is usually removal or replacement, since no vendor fix may exist. Check threat signals such as <a href="/posts/cisa-kev-json-feed-what-each-field-means-and-how-to-match-it-against-a-scanner-export/">KEV</a> and EPSS before assuming it is low priority</td>
      </tr>
      <tr>
          <td>Tagged <code>exclusively-hosted-service</code></td>
          <td>Whether you use the hosted service</td>
          <td>There may be nothing for you to patch; ask the vendor for confirmation instead</td>
      </tr>
      <tr>
          <td>Affected status <code>unknown</code> for your version</td>
          <td>Vendor advisory</td>
          <td>Treat as unresolved, not safe</td>
      </tr>
      <tr>
          <td>In the CISA KEV catalog</td>
          <td>The KEV entry and its notes</td>
          <td>KEV is evidence of exploitation; see <a href="/posts/cvss-vs-epss-vs-kev-which-signal-should-decide-what-you-patch-first/">CVSS vs EPSS vs KEV</a></td>
      </tr>
  </tbody>
</table>
<h2 id="a-tested-script-to-read-state-and-tags">A tested script to read state and tags</h2>
<p>This script fetches a record from the CVE Services API and prints the fields above. It uses only the Python standard library. The endpoint is a public API; we did not need a key for single-record lookups, but bulk queries returned a message that a <code>CVE-API-ORG</code> header is required.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#f92672">import</span> json<span style="color:#f92672">,</span> sys<span style="color:#f92672">,</span> urllib.request
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">triage_view</span>(cve_id):
</span></span><span style="display:flex;"><span>    url <span style="color:#f92672">=</span> <span style="color:#e6db74">f</span><span style="color:#e6db74">&#34;https://cveawg.mitre.org/api/cve/</span><span style="color:#e6db74">{</span>cve_id<span style="color:#e6db74">}</span><span style="color:#e6db74">&#34;</span>
</span></span><span style="display:flex;"><span>    rec <span style="color:#f92672">=</span> json<span style="color:#f92672">.</span>load(urllib<span style="color:#f92672">.</span>request<span style="color:#f92672">.</span>urlopen(url, timeout<span style="color:#f92672">=</span><span style="color:#ae81ff">30</span>))
</span></span><span style="display:flex;"><span>    meta <span style="color:#f92672">=</span> rec[<span style="color:#e6db74">&#34;cveMetadata&#34;</span>]
</span></span><span style="display:flex;"><span>    cna <span style="color:#f92672">=</span> rec[<span style="color:#e6db74">&#34;containers&#34;</span>][<span style="color:#e6db74">&#34;cna&#34;</span>]
</span></span><span style="display:flex;"><span>    out <span style="color:#f92672">=</span> {<span style="color:#e6db74">&#34;cve&#34;</span>: meta[<span style="color:#e6db74">&#34;cveId&#34;</span>], <span style="color:#e6db74">&#34;state&#34;</span>: meta[<span style="color:#e6db74">&#34;state&#34;</span>],
</span></span><span style="display:flex;"><span>           <span style="color:#e6db74">&#34;assigner&#34;</span>: meta<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;assignerShortName&#34;</span>),
</span></span><span style="display:flex;"><span>           <span style="color:#e6db74">&#34;updated&#34;</span>: meta<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;dateUpdated&#34;</span>)}
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> meta[<span style="color:#e6db74">&#34;state&#34;</span>] <span style="color:#f92672">==</span> <span style="color:#e6db74">&#34;REJECTED&#34;</span>:
</span></span><span style="display:flex;"><span>        out[<span style="color:#e6db74">&#34;rejectedReasons&#34;</span>] <span style="color:#f92672">=</span> [r[<span style="color:#e6db74">&#34;value&#34;</span>] <span style="color:#66d9ef">for</span> r <span style="color:#f92672">in</span> cna<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;rejectedReasons&#34;</span>, [])]
</span></span><span style="display:flex;"><span>        out[<span style="color:#e6db74">&#34;replacedBy&#34;</span>] <span style="color:#f92672">=</span> cna<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;replacedBy&#34;</span>, [])
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">else</span>:
</span></span><span style="display:flex;"><span>        out[<span style="color:#e6db74">&#34;cnaTags&#34;</span>] <span style="color:#f92672">=</span> cna<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;tags&#34;</span>, [])
</span></span><span style="display:flex;"><span>        out[<span style="color:#e6db74">&#34;adpTags&#34;</span>] <span style="color:#f92672">=</span> [t <span style="color:#66d9ef">for</span> a <span style="color:#f92672">in</span> rec[<span style="color:#e6db74">&#34;containers&#34;</span>]<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;adp&#34;</span>, [])
</span></span><span style="display:flex;"><span>                          <span style="color:#66d9ef">for</span> t <span style="color:#f92672">in</span> a<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;tags&#34;</span>, [])]
</span></span><span style="display:flex;"><span>        out[<span style="color:#e6db74">&#34;statuses&#34;</span>] <span style="color:#f92672">=</span> sorted({v[<span style="color:#e6db74">&#34;status&#34;</span>] <span style="color:#66d9ef">for</span> p <span style="color:#f92672">in</span> cna<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;affected&#34;</span>, [])
</span></span><span style="display:flex;"><span>                                  <span style="color:#66d9ef">for</span> v <span style="color:#f92672">in</span> p<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;versions&#34;</span>, [])})
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> out
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">if</span> __name__ <span style="color:#f92672">==</span> <span style="color:#e6db74">&#34;__main__&#34;</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> cid <span style="color:#f92672">in</span> sys<span style="color:#f92672">.</span>argv[<span style="color:#ae81ff">1</span>:]:
</span></span><span style="display:flex;"><span>        print(json<span style="color:#f92672">.</span>dumps(triage_view(cid)))
</span></span></code></pre></div><p>Run on October 16, 2026 against five IDs:</p>
<pre tabindex="0"><code>{&#34;cve&#34;: &#34;CVE-2024-1992&#34;, &#34;state&#34;: &#34;REJECTED&#34;, &#34;assigner&#34;: &#34;Wordfence&#34;, &#34;updated&#34;: &#34;2024-03-20T16:44:07.699Z&#34;, &#34;rejectedReasons&#34;: [&#34;Rejected as duplicate of CVE-2024-2306&#34;], &#34;replacedBy&#34;: []}
{&#34;cve&#34;: &#34;CVE-2019-1508&#34;, &#34;state&#34;: &#34;REJECTED&#34;, &#34;assigner&#34;: &#34;microsoft&#34;, &#34;updated&#34;: &#34;2020-01-24T21:14:20.000Z&#34;, &#34;rejectedReasons&#34;: [&#34;DO NOT USE THIS CANDIDATE NUMBER. ConsultIDs: none. Reason: This candidate was in a CNA pool that was not assigned to any issues during 2019. Notes: none&#34;], &#34;replacedBy&#34;: []}
{&#34;cve&#34;: &#34;CVE-2026-14683&#34;, &#34;state&#34;: &#34;PUBLISHED&#34;, &#34;assigner&#34;: &#34;VulDB&#34;, &#34;updated&#34;: &#34;2026-07-16T07:18:18.631Z&#34;, &#34;cnaTags&#34;: [&#34;disputed&#34;], &#34;adpTags&#34;: [], &#34;statuses&#34;: [&#34;affected&#34;]}
{&#34;cve&#34;: &#34;CVE-2020-35235&#34;, &#34;state&#34;: &#34;PUBLISHED&#34;, &#34;assigner&#34;: &#34;mitre&#34;, &#34;updated&#34;: &#34;2024-08-04T17:02:07.522Z&#34;, &#34;cnaTags&#34;: [&#34;unsupported-when-assigned&#34;], &#34;adpTags&#34;: [], &#34;statuses&#34;: [&#34;affected&#34;]}
{&#34;cve&#34;: &#34;CVE-2021-44228&#34;, &#34;state&#34;: &#34;PUBLISHED&#34;, &#34;assigner&#34;: &#34;apache&#34;, &#34;updated&#34;: &#34;2025-10-21T23:25:23.121Z&#34;, &#34;cnaTags&#34;: [], &#34;adpTags&#34;: [], &#34;statuses&#34;: [&#34;affected&#34;]}
</code></pre><p>Known limits of the script: it assumes the record has a <code>cna</code> container and reads tags only from <code>tags</code>; it does not follow the version ranges inside <code>affected</code>; and it makes one request per ID, so do not run it over a whole scanner export without caching and rate limiting. A real pipeline should also handle HTTP errors, which we did not test.</p>
<h2 id="limits-of-this-article">Limits of this article</h2>
<p>We examined two rejected records, one disputed record and one end-of-life record out of hundreds of thousands, chosen for illustration, so they do not show how typical records look. Record contents and NVD counts change over time. We did not read the CVE Program&rsquo;s dispute policy and did not investigate NVD&rsquo;s own status labels such as &ldquo;Deferred&rdquo;.</p>
<h2 id="sources-and-verification">Sources and verification</h2>
<p>Checked on October 16, 2026.</p>
<table>
  <thead>
      <tr>
          <th>Important claim</th>
          <th>Source</th>
          <th>Verification</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Records have one <code>cna</code> container and any number of <code>adp</code> containers; the two states are Published and Rejected; rejected records carry <code>rejectedReasons</code> and optional <code>replacedBy</code>; status values affected, unaffected, unknown</td>
          <td><a href="https://github.com/CVEProject/cve-schema/blob/main/schema/CVE_Record_Format.json">CVE Record Format schema</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Tag definitions for disputed, unsupported-when-assigned and exclusively-hosted-service; ADPs may use only disputed</td>
          <td><a href="https://github.com/CVEProject/cve-schema/blob/main/schema/tags/cna-tags.json">CNA tags</a>, <a href="https://github.com/CVEProject/cve-schema/blob/main/schema/tags/adp-tags.json">ADP tags</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Rules on rejecting, disputed tagging and display, EOL tagging, unknown status</td>
          <td><a href="https://www.cve.org/Resources/Roles/Cnas/CNA_Rules_v4.2.0.pdf">CNA Operational Rules v4.2.0</a>, effective August 25, 2026</td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>CVE-2024-1992 and CVE-2019-1508 are rejected, with the dates and reasons shown</td>
          <td><a href="https://cveawg.mitre.org/api/cve/CVE-2024-1992">CVE Services API record</a>, <a href="https://cveawg.mitre.org/api/cve/CVE-2019-1508">second record</a></td>
          <td>Verified on October 16, 2026</td>
      </tr>
      <tr>
          <td>CVE-2026-14683 is tagged disputed with the quoted text; CVE-2020-35235 is tagged unsupported-when-assigned</td>
          <td><a href="https://cveawg.mitre.org/api/cve/CVE-2026-14683">CVE-2026-14683</a>, <a href="https://cveawg.mitre.org/api/cve/CVE-2020-35235">CVE-2020-35235</a></td>
          <td>Verified on October 16, 2026</td>
      </tr>
      <tr>
          <td>NVD totals: 408,789 records, 390,296 with noRejected, 1,509 tagged disputed; vulnStatus of the examples</td>
          <td><a href="https://services.nvd.nist.gov/rest/json/cves/2.0?cveTag=disputed&amp;resultsPerPage=1">NVD CVE API 2.0</a></td>
          <td>Qualified: NVD counts on October 16, 2026; the rejected count is our subtraction</td>
      </tr>
      <tr>
          <td>EPSS values for CVE-2020-35235 and CVE-2026-14683; 389,824 scored CVEs</td>
          <td><a href="https://epss.empiricalsecurity.com/epss_scores-current.csv.gz">EPSS daily CSV</a>, file scored 2026-10-15T12:03:56Z</td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>EPSS definition: probability of observed exploitation activity in the next 30 days</td>
          <td><a href="https://www.first.org/epss/faq">FIRST EPSS FAQ</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Script output</td>
          <td>Run by us on October 16, 2026 against the five IDs shown</td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Triage playbook</td>
          <td>Our analysis</td>
          <td>Qualified: not tested in production</td>
      </tr>
  </tbody>
</table>
]]></content:encoded></item><item><title>Encryption at Rest vs Encryption in Transit: What Each Actually Protects Against</title><link>https://firewallsync.com/posts/encryption-at-rest-vs-encryption-in-transit-what-each-actually-protects-against/</link><guid>https://firewallsync.com/posts/encryption-at-rest-vs-encryption-in-transit-what-each-actually-protects-against/</guid><pubDate>Sun, 04 Oct 2026 09:00:00 +0000</pubDate><dc:creator>Tehseen Arbab</dc:creator><category>Fundamentals</category><description>Both terms get used as a single checkbox on a compliance form, but they protect against completely different threats — and having one without the other leaves a specific, predictable gap.</description><enclosure url="https://firewallsync.com/posts/encryption-at-rest-vs-encryption-in-transit-what-each-actually-protects-against/cover_hu11246221763005267923.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/encryption-at-rest-vs-encryption-in-transit-what-each-actually-protects-against/cover_hu11246221763005267923.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/encryption-at-rest-vs-encryption-in-transit-what-each-actually-protects-against/cover_hu11246221763005267923.jpg" alt="Internal hard disk drive" width="1200" height="630"></p><p>&ldquo;Encryption at rest and in transit&rdquo; gets treated as a single line item on compliance checklists and security questionnaires, as if it&rsquo;s one control rather than two separate ones addressing two distinct threats. Having one without the other is common, and it leaves a specific, predictable gap that&rsquo;s worth understanding rather than assuming the checkbox covers everything.</p>
<h2 id="encryption-in-transit-protecting-data-while-it-moves">Encryption in transit: protecting data while it moves</h2>
<p>Encryption in transit protects data as it travels across a network — between a browser and a server, between two internal services, between a client application and a database. TLS is the dominant mechanism here, and its threat model is specifically about interception: preventing someone positioned on the network path (a compromised router, a malicious Wi-Fi access point, an attacker performing a man-in-the-middle attempt) from reading or altering data as it moves between two endpoints.</p>
<p>What it explicitly doesn&rsquo;t protect: data sitting at either endpoint once it arrives. TLS secures the pipe, not what&rsquo;s inside the buildings at either end of it — once data reaches its destination and is decrypted for processing or storage, encryption in transit&rsquo;s job is done, for better or worse.</p>
<h2 id="encryption-at-rest-protecting-data-while-its-stored">Encryption at rest: protecting data while it&rsquo;s stored</h2>
<p>Encryption at rest protects data while it&rsquo;s stored on disk — a database, a file system, a backup, an object storage bucket. Its threat model is different: it protects against someone gaining direct access to the storage medium itself without going through the application&rsquo;s normal access controls — a stolen laptop, a compromised backup, a misconfigured storage bucket exposed publicly, or physical theft of a drive. If storage is encrypted at rest and an attacker only obtains the raw storage medium without the corresponding decryption key, the data itself remains protected even though they have physical or direct access to it.</p>
<p>What it explicitly doesn&rsquo;t protect: data that&rsquo;s already been decrypted for legitimate use. An application with proper access to a database will read data in its decrypted, usable form as part of normal operation — encryption at rest doesn&rsquo;t prevent an authenticated user or process with legitimate access from reading, it only protects against someone bypassing that access layer to read the raw stored bytes directly.</p>
<h2 id="the-gap-that-shows-up-when-only-one-is-implemented">The gap that shows up when only one is implemented</h2>
<p><strong>Encryption in transit without encryption at rest</strong> means data is protected while moving across the network but sits as plaintext on disk once it arrives — meaning a stolen backup, a compromised storage bucket, or physical access to the storage medium exposes everything, even though every network connection to that system was properly encrypted the entire time.</p>
<p><strong>Encryption at rest without encryption in transit</strong> means data is protected on disk, but travels as plaintext across the network to reach an application or a user — meaning anyone positioned on that network path can intercept and read it in transit, even though it was perfectly protected the moment before and after that transmission.</p>
<p>Neither gap is hypothetical. Both configurations show up regularly in real environments, usually because one was implemented as part of a specific project (setting up HTTPS, for example) without a corresponding review of whether the data&rsquo;s storage layer received equivalent protection, or vice versa.</p>
<h2 id="where-the-boundary-actually-sits-and-why-it-matters-for-incident-response">Where the boundary actually sits, and why it matters for incident response</h2>
<p>Understanding exactly where encryption in transit&rsquo;s protection ends and encryption at rest&rsquo;s protection begins matters directly for incident response: if an attacker intercepts network traffic, the relevant question is whether TLS was properly configured and not downgraded. If an attacker gains access to a storage snapshot or backup, the relevant question is whether at-rest encryption was enabled and whether the encryption keys were themselves adequately protected — these are different investigations, with different evidence to check, and conflating them as &ldquo;was data encrypted&rdquo; without specifying which layer leads to an incomplete assessment.</p>
<h2 id="encryption-in-use-the-gap-neither-one-covers">Encryption in use: the gap neither one covers</h2>
<p>Worth naming, even briefly: data being actively processed in memory — while an application is computing on it — is generally not protected by either encryption at rest or in transit, since the application needs the plaintext to actually operate on the data. This is what &ldquo;encryption in use&rdquo; or confidential computing technologies specifically address, though they remain less universally deployed than the other two. For most organizations, this represents an accepted gap rather than a solved problem, and it&rsquo;s worth being aware of as a limitation rather than assuming &ldquo;encrypted at rest and in transit&rdquo; means data is protected at every stage of its lifecycle.</p>
<h2 id="a-practical-checklist">A practical checklist</h2>
<ul>
<li>Confirm TLS is properly configured (not just present, but not downgradable to weaker or deprecated versions) for every network path handling sensitive data</li>
<li>Confirm at-rest encryption is enabled for every storage layer — primary databases, backups, and object storage alike, since backups are a commonly missed layer</li>
<li>Verify encryption keys themselves are properly managed and access-controlled, since at-rest encryption with poorly protected keys provides much weaker protection than it appears to</li>
<li>Treat &ldquo;encrypted at rest and in transit&rdquo; as two separate items to verify independently, not one checkbox that covers both by association</li>
</ul>
]]></content:encoded></item><item><title>What Is a Zero-Day Vulnerability, and How Should You Actually Respond to One?</title><link>https://firewallsync.com/posts/what-is-a-zero-day-vulnerability-and-how-should-you-actually-respond-to-one/</link><guid>https://firewallsync.com/posts/what-is-a-zero-day-vulnerability-and-how-should-you-actually-respond-to-one/</guid><pubDate>Sat, 03 Oct 2026 09:00:00 +0000</pubDate><dc:creator>Tehseen Arbab</dc:creator><category>Fundamentals</category><description>The term gets used loosely for anything urgent, but a zero-day specifically means a vulnerability being actively exploited before a fix exists — which changes what a reasonable response actually looks like.</description><enclosure url="https://firewallsync.com/posts/what-is-a-zero-day-vulnerability-and-how-should-you-actually-respond-to-one/cover_hu2391771669361433159.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/what-is-a-zero-day-vulnerability-and-how-should-you-actually-respond-to-one/cover_hu2391771669361433159.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/what-is-a-zero-day-vulnerability-and-how-should-you-actually-respond-to-one/cover_hu2391771669361433159.jpg" alt="Open padlock surrounded by scattered keyboard keys" width="1200" height="630"></p><p>&ldquo;Zero-day&rdquo; gets used loosely in general conversation to mean any urgent or scary-sounding vulnerability, but the term has a specific meaning worth being precise about: it refers to a vulnerability that&rsquo;s known to attackers — and often being actively exploited — before the vendor has had any opportunity to develop and release a fix. The &ldquo;zero&rdquo; refers to the number of days the defender has had to prepare before exploitation began, not the severity of the flaw itself, though the two often correlate.</p>
<h2 id="zero-day-versus-a-regular-unpatched-vulnerability">Zero-day versus a regular unpatched vulnerability</h2>
<p>Most vulnerabilities follow a predictable lifecycle: discovered (often by a researcher, sometimes by the vendor itself), reported responsibly, a patch developed, the patch released, and then organizations have a window to apply it before public disclosure makes exploitation easier. A zero-day breaks this sequence at the start — exploitation is happening, or the flaw is publicly known, before a patch exists at all. This means the standard response of &ldquo;apply the vendor&rsquo;s patch&rdquo; isn&rsquo;t available as an immediate option, which is what makes zero-day response meaningfully different from routine patch management.</p>
<h2 id="why-zero-days-are-valuable-to-attackers-and-how-they-typically-surface">Why zero-days are valuable to attackers, and how they typically surface</h2>
<p>A zero-day represents a period where a vulnerability can be exploited with essentially no risk of the target having a patch available — this makes them valuable enough that they&rsquo;re bought, sold, and stockpiled in dedicated markets, sometimes for use by sophisticated actors, sometimes for cybercriminal use. Zero-days typically surface in one of a few ways: a security researcher discovers and responsibly discloses one to the vendor (giving the vendor lead time before public disclosure), a researcher or attacker discloses one publicly without prior vendor notice, or evidence of active exploitation is detected in the wild before anyone outside the attacker knows the vulnerability exists at all — this last case is the most dangerous, since defenders have no advance warning whatsoever.</p>
<h2 id="what-a-realistic-response-actually-looks-like">What a realistic response actually looks like</h2>
<p><strong>Confirm whether you&rsquo;re actually affected, quickly, rather than assuming.</strong> Not every zero-day affecting a widely used product or library actually applies to your specific configuration or usage pattern — checking whether the vulnerable code path is present and reachable in your environment, rather than reacting to every zero-day headline with the same urgency, is what separates a prioritized response from panic.</p>
<p><strong>Check for a vendor-provided interim mitigation before assuming you&rsquo;re stuck waiting.</strong> Vendors frequently publish mitigation guidance — a configuration change, a feature to disable, a workaround — well before a full patch is ready, specifically because they understand the exploitation window is the most dangerous part. This is often available faster than a permanent fix and can meaningfully reduce risk in the interim.</p>
<p><strong>Increase monitoring specifically for indicators related to the vulnerability</strong>, if a patch or mitigation genuinely isn&rsquo;t available yet. Security advisories for active zero-days frequently include indicators of compromise or exploitation patterns — adjusting detection rules to specifically watch for these, even temporarily, is a reasonable interim response when the primary fix isn&rsquo;t yet available.</p>
<p><strong>Apply the actual patch as soon as it&rsquo;s released and validated</strong>, rather than following your normal patch cadence. Zero-day patches warrant expedited testing and deployment specifically because the exploitation window is already open — the usual arguments for a slower, more cautious rollout schedule carry less weight when active exploitation is already a documented reality rather than a theoretical risk.</p>
<h2 id="why-just-patch-faster-in-general-isnt-the-complete-answer">Why &ldquo;just patch faster in general&rdquo; isn&rsquo;t the complete answer</h2>
<p>Faster patching as a general practice is good hygiene, but it doesn&rsquo;t fully address zero-day risk, because by definition, a zero-day has no patch to apply during the period that matters most — the gap between disclosure/exploitation and a fix being available. This is why zero-day-specific response capability (rapid impact assessment, interim mitigation application, targeted monitoring) matters as a distinct capability from routine patch management speed, even though the two are related and both benefit from similar underlying processes.</p>
<h2 id="what-this-means-for-a-small-team-without-dedicated-security-staff">What this means for a small team without dedicated security staff</h2>
<p>You won&rsquo;t catch every zero-day advisory the moment it&rsquo;s published, and that&rsquo;s a reasonable resource constraint to accept rather than something to feel obligated to fully solve. What&rsquo;s achievable: subscribing to security advisories for your actual critical dependencies (not everything in the ecosystem, just what you specifically run), having a documented, fast path to apply an emergency patch outside your normal release cycle when one is genuinely warranted, and knowing, in advance, who has the authority to approve an expedited deployment — so that decision doesn&rsquo;t have to be made for the first time during an actual incident.</p>
]]></content:encoded></item><item><title>Symmetric vs Asymmetric Encryption: When to Use Each</title><link>https://firewallsync.com/posts/symmetric-vs-asymmetric-encryption-when-to-use-each/</link><guid>https://firewallsync.com/posts/symmetric-vs-asymmetric-encryption-when-to-use-each/</guid><pubDate>Fri, 02 Oct 2026 09:00:00 +0000</pubDate><dc:creator>Tehseen Arbab</dc:creator><category>Fundamentals</category><description>Almost every real system uses both symmetric and asymmetric encryption together, each for the specific job it's actually good at. Understanding why explains a lot of how modern security protocols are built.</description><enclosure url="https://firewallsync.com/posts/symmetric-vs-asymmetric-encryption-when-to-use-each/cover_hu3902981657570566499.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/symmetric-vs-asymmetric-encryption-when-to-use-each/cover_hu3902981657570566499.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/symmetric-vs-asymmetric-encryption-when-to-use-each/cover_hu3902981657570566499.jpg" alt="Skeleton keys on a wooden table" width="1200" height="630"></p><p>Symmetric and asymmetric encryption get presented as two competing approaches to the same problem, which makes it easy to miss that almost every real-world secure system uses both together, each handling the specific part of the problem it&rsquo;s actually suited for. Understanding why explains a surprising amount of how protocols like TLS, SSH, and most secure messaging systems are actually built.</p>
<h2 id="symmetric-encryption-one-key-fast-but-requires-a-shared-secret">Symmetric encryption: one key, fast, but requires a shared secret</h2>
<p>Symmetric encryption uses the same key to both encrypt and decrypt data. Algorithms like AES are computationally efficient — fast enough to encrypt large volumes of data (a full disk, a video stream, a database) with minimal performance overhead. The limitation is the name itself: both parties need the same key, which means it has to be shared somehow before secure communication can happen, and the security of the entire system depends on that key exchange happening without anyone else intercepting it. Sharing a symmetric key over an insecure channel defeats the purpose of encrypting anything with it.</p>
<h2 id="asymmetric-encryption-two-keys-solves-the-sharing-problem-but-slower">Asymmetric encryption: two keys, solves the sharing problem, but slower</h2>
<p>Asymmetric (public-key) encryption uses a mathematically related key pair: a public key that can be shared openly, and a private key that never leaves its owner. Data encrypted with the public key can only be decrypted with the corresponding private key, which solves the key distribution problem symmetric encryption has — two parties who&rsquo;ve never met can establish secure communication, because the public key doesn&rsquo;t need to be kept secret at all. The tradeoff is computational cost: asymmetric algorithms like RSA and elliptic-curve cryptography are significantly slower than symmetric algorithms for encrypting the same volume of data, which makes them impractical for encrypting large amounts of data directly.</p>
<h2 id="why-real-systems-use-both-together">Why real systems use both together</h2>
<p>TLS, the protocol securing HTTPS connections, is the clearest illustration of this pattern. When a browser connects to a server, asymmetric cryptography is used briefly, during the handshake, specifically to solve the key exchange problem — establishing a shared secret without either party needing to have exchanged one in advance. Once that shared secret is established, the connection switches to symmetric encryption (AES, typically) for the actual data transfer, because it&rsquo;s fast enough to handle real traffic volume without meaningful latency. This is a &ldquo;hybrid&rdquo; approach: asymmetric cryptography solves the problem it&rsquo;s uniquely good at (secure key exchange between parties with no prior shared secret), and symmetric cryptography handles the problem it&rsquo;s uniquely good at (fast, efficient encryption of the actual data).</p>
<p>SSH follows essentially the same pattern, and most modern secure messaging protocols do as well — asymmetric cryptography for initial authentication and key exchange, symmetric cryptography for the ongoing encrypted session.</p>
<h2 id="digital-signatures-asymmetric-cryptography-solving-a-different-problem">Digital signatures: asymmetric cryptography solving a different problem</h2>
<p>Beyond key exchange, asymmetric cryptography also enables digital signatures, which use the key pair in the opposite direction from encryption: data is signed with the private key, and anyone with the public key can verify the signature is authentic, without being able to forge one themselves. This is what underlies code signing, certificate authorities validating a website&rsquo;s identity, and verifying that a software update genuinely came from its claimed publisher — a distinct use case from confidentiality, addressing integrity and authenticity instead.</p>
<h2 id="when-to-actually-choose-one-over-the-other-directly">When to actually choose one over the other directly</h2>
<p>Most application developers don&rsquo;t choose between symmetric and asymmetric encryption directly — established protocols and libraries (TLS, established encryption libraries) make this decision internally, using the hybrid approach described above. The situations where the choice becomes a direct decision:</p>
<p><strong>Encrypting data at rest, with no key exchange problem to solve</strong> (a database column, a file on disk, where the same application will both encrypt and later decrypt it) is a symmetric encryption use case — there&rsquo;s no separate party to exchange a key with, so asymmetric cryptography&rsquo;s main advantage doesn&rsquo;t apply, and its performance cost isn&rsquo;t worth paying.</p>
<p><strong>Establishing trust or identity between two parties with no prior relationship</strong> (verifying a certificate, establishing a new secure session, signing software to prove authenticity) is fundamentally an asymmetric cryptography problem, since it depends on the public/private key separation to work without a pre-shared secret.</p>
<h2 id="a-practical-mental-model">A practical mental model</h2>
<p>Symmetric encryption answers &ldquo;how do we encrypt this efficiently, given that we already have a shared secret.&rdquo; Asymmetric encryption answers &ldquo;how do we establish trust or exchange a secret when we don&rsquo;t have one yet, or how do we prove something is authentic without a shared secret at all.&rdquo; Most secure systems need to solve both problems, which is exactly why most of them end up using both types of cryptography, each for the part of the problem it actually solves well.</p>
]]></content:encoded></item><item><title>What Is the CIA Triad, and Why It Still Shapes Security Decisions</title><link>https://firewallsync.com/posts/what-is-the-cia-triad-and-why-it-still-shapes-security-decisions/</link><guid>https://firewallsync.com/posts/what-is-the-cia-triad-and-why-it-still-shapes-security-decisions/</guid><pubDate>Thu, 01 Oct 2026 09:00:00 +0000</pubDate><dc:creator>Tehseen Arbab</dc:creator><category>Fundamentals</category><description>Confidentiality, integrity, and availability are taught as a checklist. In practice they're better understood as three competing priorities that most security decisions are actually trading off against each other.</description><enclosure url="https://firewallsync.com/posts/what-is-the-cia-triad-and-why-it-still-shapes-security-decisions/cover_hu3947948365143041662.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/what-is-the-cia-triad-and-why-it-still-shapes-security-decisions/cover_hu3947948365143041662.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/what-is-the-cia-triad-and-why-it-still-shapes-security-decisions/cover_hu3947948365143041662.jpg" alt="Red padlock on a black computer keyboard" width="1200" height="630"></p><p>Confidentiality, integrity, and availability get introduced early in most security education as a simple checklist — three properties a secure system should have. Treated that way, the CIA triad feels almost too obvious to be useful. It becomes genuinely useful once you notice that these three properties routinely compete with each other, and that most real security decisions are actually judgment calls about which one to prioritize given a specific constraint, not a checklist to satisfy simultaneously.</p>
<h2 id="confidentiality-only-the-right-people-can-read-it">Confidentiality: only the right people can read it</h2>
<p>Confidentiality is about restricting access to data and systems to those authorized to have it — encryption, access control, and authentication all serve this property directly. It&rsquo;s the property most people think of first when they hear &ldquo;security,&rdquo; partly because breach headlines are almost always about confidentiality failures: data that leaked, credentials that were stolen, information that reached people who shouldn&rsquo;t have had it.</p>
<h2 id="integrity-the-data-is-what-it-claims-to-be">Integrity: the data is what it claims to be</h2>
<p>Integrity means data hasn&rsquo;t been altered, whether by an attacker, a bug, or an unauthorized change, and that any alteration that does happen is detectable. This is a distinct concern from confidentiality — a system can leak data (a confidentiality failure) while every value in it remains completely accurate, and a system can have data silently corrupted or tampered with (an integrity failure) while remaining perfectly confidential, visible to nobody unauthorized. Checksums, digital signatures, and version control all exist primarily to serve integrity, not confidentiality.</p>
<h2 id="availability-the-system-works-when-its-needed">Availability: the system works when it&rsquo;s needed</h2>
<p>Availability means authorized users can actually access the system and data when they need to. A denial-of-service attack is a pure availability failure — nothing is stolen or altered, the system simply stops responding to legitimate requests. Availability is often underweighted in security thinking relative to confidentiality, despite the fact that for many businesses, an availability failure (a critical system down for hours) causes more immediate, measurable damage than a confidentiality failure that takes months to even be discovered.</p>
<h2 id="where-the-three-actually-conflict">Where the three actually conflict</h2>
<p><strong>Encryption strengthens confidentiality but can work against availability.</strong> Aggressive encryption-at-rest policies, combined with strict key management, protect data from unauthorized access — but if a key is lost or a legitimate process can&rsquo;t access the decryption path quickly enough, the same control that protects confidentiality has now created an availability problem for legitimate use.</p>
<p><strong>Strict access control strengthens confidentiality but can slow down legitimate response, hurting practical availability.</strong> A system that requires multiple approval steps before granting emergency access protects against unauthorized use, but during a genuine incident, that same friction can delay the people who legitimately need fast access to fix the problem.</p>
<p><strong>High-availability architecture (more replicas, more access points, more redundancy) can work against confidentiality.</strong> Every additional copy of data, every additional system with access to it, is another place a confidentiality failure could originate — the same redundancy that makes a system resilient against downtime also expands the attack surface for unauthorized access.</p>
<p><strong>Integrity checks add overhead that can affect availability under load.</strong> Cryptographic verification, audit logging, and validation steps that protect integrity all consume processing time and resources — at sufficient scale or under sufficient load, aggressive integrity controls can become the bottleneck that creates an availability problem.</p>
<h2 id="why-this-framing-matters-more-than-the-checklist-version">Why this framing matters more than the checklist version</h2>
<p>Treating the triad as three boxes to check leads to security programs that invest heavily in whichever property is easiest to demonstrate progress on (usually confidentiality, since encryption and access control are concrete, auditable controls) while underinvesting in the other two. Treating it as three competing priorities means every meaningful security decision gets evaluated honestly: what are we actually trading off here, and is that the right tradeoff for this specific system and this specific data.</p>
<p>A payment processing system reasonably prioritizes integrity above almost everything else — an inaccurate transaction is a worse outcome than a brief outage. A public content delivery system reasonably prioritizes availability, since the data isn&rsquo;t sensitive and the entire value of the system depends on it being reachable. A system handling health records reasonably weighs confidentiality most heavily, given the regulatory and personal consequences of unauthorized disclosure. None of these are wrong for deprioritizing the other two properties relative to their primary one — they&rsquo;re making a deliberate tradeoff appropriate to what they actually protect.</p>
<h2 id="the-practical-takeaway">The practical takeaway</h2>
<p>When evaluating a security control or making an architecture decision, it&rsquo;s worth asking explicitly which of the three properties it&rsquo;s optimizing for, and what it&rsquo;s costing in terms of the other two. A control that improves confidentiality at a cost to availability isn&rsquo;t automatically wrong — but it should be a decision made with that tradeoff in view, not an accident of only ever asking &ldquo;is this more secure&rdquo; without specifying secure against what, at the cost of what else.</p>
]]></content:encoded></item></channel></rss>