<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by James Chartrand on Medium]]></title>
        <description><![CDATA[Stories by James Chartrand on Medium]]></description>
        <link>https://medium.com/@jc.chartrand?source=rss-d2c306b6a475------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Stories by James Chartrand on Medium</title>
            <link>https://medium.com/@jc.chartrand?source=rss-d2c306b6a475------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 08:33:38 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jc.chartrand/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[veri-good]]></title>
            <link>https://blog.dccommons.org/veri-good-3ed1c386b958?source=rss-d2c306b6a475------2</link>
            <guid isPermaLink="false">https://medium.com/p/3ed1c386b958</guid>
            <category><![CDATA[digital-credentials]]></category>
            <category><![CDATA[verifiable-credentials]]></category>
            <category><![CDATA[decentralized-identity]]></category>
            <dc:creator><![CDATA[James Chartrand]]></dc:creator>
            <pubDate>Mon, 06 Apr 2026 16:19:54 GMT</pubDate>
            <atom:updated>2026-09-11T14:34:12.974Z</atom:updated>
            <content:encoded><![CDATA[<h4>A <a href="https://developer.mozilla.org/en-US/docs/Web/API/Web_components">Web Component</a> for easily adding fully self-contained verification of <a href="https://www.w3.org/TR/vc-data-model-2.0/">Verifiable Credentials</a> to any web site</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9QZoVSvGFW9Iy2i9dqqKaw.png" /></figure><p>W3C Verifiable Credentials are meant to be, well, verified.</p><p>They are, however, verified quite differently than how we’ve heretofore verified credentials.</p><p>Credentials, like a degree, driver’s license, or what have you, have typically been verified in a few general ways:</p><p>1. <strong>Visibly</strong> — we check that the credential shown to us, like a driver’s licence, looks real enough, and maybe even has something like laser-engraved text, holograms, or “ghost” images (or back in the day, a signature or wax seal). But, seemingly as fast as issuers come up with security features like these, someone figures out how to fake them.</p><p>2. <strong>Asking the issuer</strong> — we contact the issuer of the credential directly. This can, of course, sometimes be impossible given time or other constraints, and sometimes the issuer themselves doesn’t even want to respond to a call because of cost, privacy concerns, and so on. And indeed sometimes the holder of the credential themselves don’t want the issuer to know how the credential is being used, and so generally, we prefer not to contact the issuer directly.</p><p>3. <strong>Corroborating evidence</strong> — someone I went to university with, possibly even attended graduation with, might work in the same company to which I’m applying. Or maybe I’ve published something, like a thesis, that declares the institution from which I’ve graduated. Corroboration can of course work perfectly well, but isn’t always available, and sometimes even the corroborating evidence itself could be faked.</p><h3>Verifiable Credentials</h3><p>Fortunately, we’ve now got <a href="https://www.w3.org/TR/vc-data-model-2.0/">Verifiable Credentials</a> (VCs), which use a cryptographic signature that guarantees integrity and authenticity, can’t be faked, and can be verified instantly. If the content has been tampered with, the signature no longer matches, and verification fails.</p><p>Okay, great, but, errrr, how does one check a cryptographic signature?</p><p>For some verifiers, like a job site or a large employer, the verifier itself would typically run it’s own software to check the signatures, which makes sense when checking thousands of credentials. But how would a small business owner who is considering hiring a new accountant go about checking the cryptographic signature on a VC for the candidate’s accounting degree?</p><h3>Verification Site</h3><p>At the moment, the easiest approach is for the <strong><em>issuer</em></strong> of the credentials to run a web site that accepts uploads of credentials and verifies them. An example of such a site is VerifierPlus:</p><p><a href="https://verifierplus.org/">https://verifierplus.org</a></p><p>VerifierPlus is a verification page run by the DCC for verifying credentials issued by the DCC community.</p><p>There are a couple of challenges with this approach though:</p><p>1. The DCC site only recognizes credentials issued (signed) by members of the DCC community. Other issuers would need to run their own verification web site.</p><p>2. Unless the site name is universally recognized, it would be easy to direct employers to a fake site. Even if the site name is fairly well known, it is still possible to run a slightly differently named site, like verifyplus.org instead of verifierplus.org.</p><h3>Well Known Verification Site</h3><p>A solution to both these problems might be a single web site (or an app) that:</p><p>1. is universally known, ideally using something like a government domain name - verify.gov for example - that can be clearly trusted<br>2. recognizes credentials from most issuers</p><p>Unfortunately, until enough momentum builds with VCs, we are a ways off from having a such a universally recognized site, because:</p><ol><li>It would be difficult to widely publicize the name of the web site.</li><li>Fairly complex governance is required to manage recognition of different issuers.</li></ol><h3>Issuer Domain Verification Sites</h3><p>Until the VC ball is really rolling, the a good option is for each of the issuers themselves - the individual universities in the case of the DCC - to run their own verification page, hosted on their already well known and recognizable domains, thereby making them trustworthy.</p><p>So, for example, MIT could run a site like</p><p><a href="https://verify.mit.edu/">https://verify.mit.edu</a> (this isn’t a real site)</p><p>Someone wanting to verify a credential from MIT could then be pretty confident that uploading the credential to that url would tell them if the credential was real, had been issued by MIT, and hadn’t been tampered with.</p><p>Setting up such a site, however, can be time consuming.</p><p>Enter to much fanfare: veri-good.</p><h3>Veri-good</h3><p>veri-good is a re-usable Web Component that makes it easy to add verification to a web page. As easy as adding what is called an HTML tag to either a new web page or an existing web page.</p><p>A Web Component is a standard way to define your own HTML tag and is natively supported by all web browsers. Web Components are an incredibly effective way to encapsulate some discrete piece of functionality (like credential verification) so it is entirely unaffected by anything else around it in the web page, and conversely doesn’t itself disturb anything else on the page. You can therefore drop the HTML tag into a page and it just works.</p><p>This is what a very simple HTML page looks like with the tag thusly dropped in:</p><pre>&lt;html&gt;<br>   &lt;body&gt;<br>     &lt;div&gt; put whatever you want in the rest of the page, like this div &lt;/div&gt;<br>       &lt;veri-good&gt;&lt;/veri-good&gt;<br>       &lt;script type=&quot;module&quot; src=&quot;=bundle.js&quot;&gt;&lt;/script&gt;<br>   &lt;/body&gt;<br>&lt;/html&gt;</pre><p>You’ll notice that in addition to the tag itself, we also imported the ‘bundle.js’ file, which contains the actual code for the element, including the user interface, and the code to check the cryptographic signature on a credential (the fancy math in other words). You can get the <a href="https://github.com/digitalcredentials/veri-good/blob/main/dist/bundle.js">bundle.js</a> file from the veri-good Github repository. The source code is also available in that repository.</p><p>We’ve additionally published the component as an <a href="https://www.npmjs.com/package/@digitalcredentials/veri-good">NPM package</a> that you can import into a project and bundle with webpack, rollup, etc. Web components generally work with all frameworks, including Angular, Vue, Svelte. Notably, recent versions of React provide full support for Web Components. For older versions of React, we’ve also created a React component —<a href="https://www.npmjs.com/package/@digitalcredentials/veri-good-react"> veri-good-react </a>— that wraps the web component so you can just drop it into an older React site.</p><h3>Signing keys</h3><p>There are a couple of things that you can configure with the element, including some of the headings on the verifier screen, but importantly, there is one thing that you must provide: a list of the signing keys (encoded as Decentralized Identifiers [DIDs]) that your verifier recognizes. These<br> DIDs should be those that sign the credentials that you will verify. <br> <br> You provide that list like so:</p><pre>&lt;body&gt;<br>   &lt;veri-good&gt;<br>     &lt;template id=&quot;issuer-dids&quot;&gt;<br>       {<br>         &quot;did:web:digitalcredentials.github.io:testDID&quot;: {<br>           &quot;issuerName&quot;: &quot;Department of Chemistry&quot;,<br>           &quot;url&quot;: &quot;https://chemistry.uni.edu&quot;<br>         },<br>         &quot;did:key:z6MkjoriXdbyWD25YXTed114F8hdJrLXQ567xxPHAUKxpKkS&quot;: {<br>           &quot;issuerName&quot;: &quot;Department of Economics&quot;,<br>           &quot;url&quot;: &quot;https://econ.uni.edu&quot;<br>         }<br>      }<br>     &lt;/template&gt;<br>   &lt;/veri-good&gt;<br>   &lt;script type=&quot;module&quot; src=&quot;=bundle.js&quot;&gt;&lt;/script&gt;<br>&lt;/body&gt;</pre><p>You can also set the list programmatically if you like. More detailed help with using veri-good is provided in the <a href="https://github.com/digitalcredentials/veri-good/tree/main">README</a> in Github.</p><p>That simple example, then, ends up looking like this when viewed in a web browser:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*ds8wrboFF5kkFnEgGecLjA.png" /></figure><p>And when verifying a credential that has expired:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9QZoVSvGFW9Iy2i9dqqKaw.png" /></figure><p>And the dialog that appears when clicking the ‘more…’ button:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I0PWn_wSFzC-Vp10iAnw2g.png" /></figure><p>You can try veri-good yourself at:</p><p><a href="https://digitalcredentials.github.io/veri-good/">https://digitalcredentials.github.io/veri-good/</a></p><p>We’ve included a link to a VC in that running demo to make it easier to see the results of a verification. After loading the page, just hit the ‘Verify’ button to see the verification run.</p><h3>Direct Linking</h3><p>A very nice feature of veri-good is that you can create a link that will immediately run the veri-good verification on a specific credential. So like this example, which you can click and will open the credential in our veri-good demo instance:</p><p><a href="https://digitalcredentials.github.io/veri-good?vc=https://digitalcredentials.github.io/vc-test-fixtures/verifiableCredentials/v1/bothSignatureTypes/didWeb/legacy-validStatus-noExpiry.json">https://digitalcredentials.github.io/veri-good?vc=https://digitalcredentials.github.io/vc-test-fixtures/verifiableCredentials/v1/bothSignatureTypes/didWeb/legacy-validStatus-noExpiry.json</a></p><p>You can see that it is simply the normal url for the page in which you are running the verifier:</p><p><a href="https://digitalcredentials.github.io/veri-good?vc=https://digitalcredentials.github.io/vc-test-fixtures/verifiableCredentials/v1/bothSignatureTypes/didWeb/legacy-validStatus-noExpiry.json">https://digitalcredentials.github.io/veri-good</a></p><p>But with a ‘vc’ parameter (the bit after the question mark) whose value in this case is:</p><p><a href="https://digitalcredentials.github.io/veri-good?vc=https://digitalcredentials.github.io/vc-test-fixtures/verifiableCredentials/v1/bothSignatureTypes/didWeb/legacy-validStatus-noExpiry.json">https://digitalcredentials.github.io/vc-test-fixtures/verifiableCredentials/v1/bothSignatureTypes/didWeb/legacy-validStatus-noExpiry.json</a></p><p>Which is a URL that returns a sample Verifiable Credential that we use for testing, but can be any URL that returns a Verifiable Credential.</p><p>When opened, veri-good goes out and gets the VC from the URL and automatically runs the verification process on it.</p><p>This is nice because it allows credential holders to simply give people (like employers) a direct link that will automatically open the verified credential, removing the need to copy/paste/upload the credential.</p><p>It also allows the credential to be added to sites like a LinkedIn profile.</p><p>We don’t expect that the credential holders themselves will create these links, but rather the issuer of the credential will likely provide storage for the VC, making it available at a public URL that the issuer then uses to in turn the create the direct veri-good link, which is given to the credential holder.</p><h3>Phone Home</h3><p>As we mentioned earlier, we generally don’t want the issuer of a credential to know how a credential is being used: to whom it is being shown, when, where, how often, and so on. Systems that rely on checking a credential with the original issuer for every verification are said to ‘phone-home’, which again we want to avoid. We’d rather that the holder’s activity not be monitored.</p><p>One of the very nice things about veri-good is that the verification is done entirely in the web browser. There is no call made to a server, and most importantly, the credential never leaves the web browser — it is not in fact sent anywhere. All of the computation to verify the cryptographic signature is done using the processor of the computer on which the web page is running (so, like, your laptop right now). And therefore, no one can monitor the verification.</p><h3>Open Source</h3><p>veri-good is licensed with the MIT licence and free for anyone to use. We’d love to hear what you think about the component, and especially any suggestions you might have.</p><p>And if you are looking to <strong><em>issue </em></strong>your own credentials, take a gander at our other <a href="https://github.com/digitalcredentials">repositories</a> that include libraries for all things to do with issuing and managing Verifiable Credentials.</p><p>Veri-good then, that wraps up our article — thanks for reading!</p><p><em>DCC software is open source and available on </em><a href="https://github.com/digitalcredentials"><em>Github</em></a><em>. For additional information on the DCC, including community engagement, projects, and events, visit our </em><a href="https://dccommons.org/"><em>website</em></a><em>, </em><a href="https://wiki.dcconsortium.org/"><em>wiki</em></a><em>, and </em><a href="https://www.linkedin.com/company/dccommons"><em>Linkedin</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ed1c386b958" width="1" height="1" alt=""><hr><p><a href="https://blog.dccommons.org/veri-good-3ed1c386b958">veri-good</a> was originally published in <a href="https://blog.dccommons.org/">Digital Credentials Commons</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What makes a Verifiable Credential Verifiable?]]></title>
            <link>https://blog.dccommons.org/what-makes-a-verifiable-credential-verifiable-3023fa8afd7e?source=rss-d2c306b6a475------2</link>
            <guid isPermaLink="false">https://medium.com/p/3023fa8afd7e</guid>
            <category><![CDATA[decentralized-identifier]]></category>
            <category><![CDATA[decentralized-identity]]></category>
            <category><![CDATA[verifiable-credentials]]></category>
            <dc:creator><![CDATA[James Chartrand]]></dc:creator>
            <pubDate>Mon, 30 Mar 2026 14:23:28 GMT</pubDate>
            <atom:updated>2026-09-11T14:36:41.364Z</atom:updated>
            <content:encoded><![CDATA[<h4>Part 5: Tampering</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wDLi8FqXt9sW3FTBlvXVhA.png" /></figure><p>Today we tackle the final question in our series on the <a href="https://dccommons.org/">Digital Credential Common’</a>s <a href="https://github.com/digitalcredentials/verifier-core">verifier-core</a> software package:</p><p>Has the <a href="https://www.w3.org/TR/vc-data-model-2.0/">Verifiable Credential</a> been tampered with?</p><p>First off, as the phrasing of the question itself suggests, Verifiable Credentials (VCs) are not <strong><em>tamper-proof</em></strong> in the sense that we can prevent someone from changing the contents of the credential, but are instead <strong><em>tamper-evident</em></strong> in that we can detect that a credential has been changed - although we unfortunately can’t tell specifically what was changed.</p><p>We check for tampering with a cryptographic signature, which is essentially a mathematical result computed from two inputs:</p><p>1. Whatever is being signed, in this case the VC<br>2. A <strong><em>private</em></strong> (secret) key known only to the signer</p><p>The magic in this is that the private key has a corresponding <strong><em>public</em></strong> key that anyone can use to mathematically confirm that the signature attached to the VC was created from the private key and a VC that exactly matches the one we are now attempting to verify. If anything in the credential changes, the public key will no longer verify the signature.</p><blockquote>There are subtleties we gloss over that might distract from, but don’t fundamentally change, the gist of this article, like that the signature is actually a cryptographic hash of the credential that we then encrypt with the private key. Anyone can later decrypt it using the corresponding public key, allowing us to thereby compare the decrypted hash to our a newly generated hash of the presented credential. If the two hashes don’t match, then something was changed in the credential. There are no end of articles on the internet that go into whatever level of detail you’d like.</blockquote><p>As we mentioned earlier, we can’t tell specifically what was changed and so…. we can’t trust anything in the credential. Nothing. It could be entirely fake.</p><p>Of course we might have other reasons for trusting the credential, like that is hosted on some web site we trust, but if we are relying on the signature alone for trustworthiness, then we should outright reject a credential whose signature doesn’t verify.</p><p>Let’s use the following simple VC to demonstrate how tampering invalidates a signature.</p><pre>{<br> &quot;@context&quot;: [&quot;https://www.w3.org/ns/credentials/v2&quot;],<br> &quot;id&quot;: &quot;urn:uuid:4636EB2F-1B73–47EA-981E-CFA85A5B13E3&quot;,<br> &quot;type&quot;: [&quot;VerifiableCredential&quot;],<br> &quot;issuer&quot;: &quot;did:key:z6MknNQD1WHLGGraFi6zcbGevuAgkVfdyCdtZnQTGWVVvR5Q&quot;,<br> &quot;credentialSubject&quot;: {<br>   &quot;name&quot;: &quot;James Chartrand&quot;,<br>   &quot;description&quot;: &quot;James&#39;s article. &quot;<br> },<br> &quot;proof&quot;: {<br>   &quot;type&quot;: &quot;DataIntegrityProof&quot;,<br>   &quot;created&quot;: &quot;2025–08–25T19:28:22Z&quot;,<br>   &quot;verificationMethod&quot;: &quot;did:key:z6MknNQD1WHLGGraFi6zcbGevuAgkVfdyCdtZnQTGWVVvR5Q#z6MknNQD1WHLGGraFi6zcbGevuAgkVfdyCdtZnQTGWVVvR5Q&quot;,<br>   &quot;cryptosuite&quot;: &quot;eddsa-rdfc-2022&quot;,<br>   &quot;proofPurpose&quot;: &quot;assertionMethod&quot;,<br>   &quot;proofValue&quot;: &quot;z55KdEZMVuxVgDvhoFz8h4YC7nTqKMYuM7Fy4C1Qpff2TU9A3DMAmMM32Xkzdix6sYa5dhq7XLPHceYJz6pRz1Wmf&quot;<br> }<br>}</pre><p>The cryptographic signature is recorded in the ‘proofValue’ property, i.e., this bit:</p><pre>z55KdEZMVuxVgDvhoFz8h4YC7nTqKMYuM7Fy4C1Qpff2TU9A3DMAmMM32Xkzdix6sYa5dhq7XLPHceYJz6pRz1Wmf</pre><p>That signature was made from the contents of the credential exactly as shown above (except the signature itself — the value of the ‘proofValue’ property).</p><p>You can verify this credential by copy/pasting it into our online verification tool:</p><p><a href="https://verifierplus.org/">https://verifierplus.org/</a></p><p>Now let’s remove the trailing space (after the period) from the ‘description’ field:</p><pre>{<br> &quot;@context&quot;: [&quot;https://www.w3.org/ns/credentials/v2&quot;],<br> &quot;id&quot;: &quot;urn:uuid:4636EB2F-1B73–47EA-981E-CFA85A5B13E3&quot;,<br> &quot;type&quot;: [&quot;VerifiableCredential&quot;],<br> &quot;issuer&quot;: &quot;did:key:z6MknNQD1WHLGGraFi6zcbGevuAgkVfdyCdtZnQTGWVVvR5Q&quot;,<br> &quot;credentialSubject&quot;: {<br>   &quot;name&quot;: &quot;James Chartrand&quot;,<br>   &quot;description&quot;: &quot;James&#39;s article.&quot;<br> },<br> &quot;proof&quot;: {<br>   &quot;type&quot;: &quot;DataIntegrityProof&quot;,<br>   &quot;created&quot;: &quot;2025–08–25T19:28:22Z&quot;,<br>   &quot;verificationMethod&quot;: &quot;did:key:z6MknNQD1WHLGGraFi6zcbGevuAgkVfdyCdtZnQTGWVVvR5Q#z6MknNQD1WHLGGraFi6zcbGevuAgkVfdyCdtZnQTGWVVvR5Q&quot;,<br>   &quot;cryptosuite&quot;: &quot;eddsa-rdfc-2022&quot;,<br>   &quot;proofPurpose&quot;: &quot;assertionMethod&quot;,<br>   &quot;proofValue&quot;: &quot;z55KdEZMVuxVgDvhoFz8h4YC7nTqKMYuM7Fy4C1Qpff2TU9A3DMAmMM32Xkzdix6sYa5dhq7XLPHceYJz6pRz1Wmf&quot;<br> }<br>}</pre><p>Now the credential will no longer verify, which you can test by copy/pasting the above into the VerifierPlus web app.</p><p>We’ve made this very minor change — what seems like a very small and innocuous change that doesn’t in this case even affect the meaning of the credential — to show that even the smallest change renders the credential completely and utterly untrustworthy because we can no longer verify any part of it.</p><p>You’ll notice that the verification page no longer shows whether the credential expired, has been revoked or was issued by a known issuer. This is again because the verifier knows that something in the credential changed, but it doesn’t know specifically what, and so the verifier can’t say anything affirmative at all about anything in the credential. It could all be fake as far as the verifier is concerned. The expiration date could have been changed, the revocation status, and so on.</p><p>Particularly important is that because the signature doesn’t match up with the credential as presented, we also don’t know if the signature itself was actually made by the private key that is paired with the declared public key. The signature itself could be fake. And so we can’t even say if the signature was made by the claimed issuer.</p><blockquote>We can’t even say if the signature was made by the claimed issuer.</blockquote><p>VerifierPlus does continue to show the details of the credential, like the title, issuer, recipient, criteria, but largely because one of the primary purposes of VerifierPlus is educational — to help people better understand how VCs work. We’ve therefore chosen to continue to show data that in another system should very likely not be shown at all.</p><p>Showing the details could impart or suggest some degree of trustworthiness (that doesn’t exist). And it is highly likely that some people would ignore the errors and warnings, assuming they are a glitch or a technical problem, in much the same way that we often ignore warnings in our web browsers about invalid certificates for web sites.</p><h4>Non-repudiation</h4><p>One very interesting consequence of cryptographic signatures is what we sometimes call non-repudiation, a fancy word for saying that if someone signed something with their private key, and we can confirm that with <br>their public key, then the signer can’t deny they signed it. It could only have been signed with their private key. Of course someone might have stolen their private key, but that’s another issue. And as we talked about in our <a href="https://blog.dcconsortium.org/what-makes-a-verifiable-credential-verifiable-8f65ac8d7508">prior article</a>, we still of course need to know that the public key ‘belongs’ to the issuer.</p><p>Finally, here is the result that verifier-core returns if a credential has been tampered with:</p><pre>{<br>   &quot;credential&quot;: &lt;the submitted vc is returned here&gt;,<br>   &quot;errors&quot;: [<br>     {<br>       &quot;name&quot;: &quot;invalid_signature&quot;,<br>       &quot;message&quot;: &quot;The signature is not valid.&quot;<br>     }<br>   ]<br>}</pre><p>Again, it is important to stress that verifier-core returns no other information about the expiry date, revocation status, or issuer registration because the invalid signature is a show stopper — it means that nothing in the credential is trustworthy and so there is no point in checking any of it.</p><h4>Takeaways</h4><p>1. A cryptographic signature is specific to one credential. If *<strong><em>anything</em></strong>* changes in that credential after signing, then the signature will no longer be valid.</p><p>2. An invalid signature doesn’t tell us specifically what changed in the credential, just that something changed, making the entire credential untrustworthy.</p><p>3. Checking the signature only tells us if the credential has been tampered with. It does not tell us who signed the credential, or in other words, who holds the private key. Our prior article explains how we determine that.</p><p>4. Non-repudiation — a cryptographically signed credential makes it harder for the signer to later deny having made whatever statements are in the credential, because only the signer has access to the private signing key.</p><p>So that’s it in our series on verifier-core.</p><p>Look soon for an article on a new package we’ve recently released called <a href="https://github.com/digitalcredentials/veri-good"><strong><em>veri-good</em></strong></a> which is a <a href="https://developer.mozilla.org/en-US/docs/Web/API/Web_components">Web Component</a> for verifying VCs directly in the web browser with no calls to a server, making it very easy to add verification to any web page — it’s as simple as adding an HTML tag.</p><p>A multitude of thanks as always to the redoubtable <a href="https://medium.com/u/2fb0c86ed134"><em>Gillian Walsh</em></a><em> </em>for her assiduous stewardship.</p><p><em>DCC software is open source and available on</em><a href="https://github.com/digitalcredentials"><em> Github</em></a><em>. For additional information on the DCC, including community engagement, projects, and events, visit our</em><a href="https://dccommons.org/"><em> website</em></a><em>,</em><a href="https://wiki.dcconsortium.org/"><em> wiki</em></a><em>, and</em><a href="https://www.linkedin.com/company/dccommons"><em> Linkedin</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3023fa8afd7e" width="1" height="1" alt=""><hr><p><a href="https://blog.dccommons.org/what-makes-a-verifiable-credential-verifiable-3023fa8afd7e">What makes a Verifiable Credential Verifiable?</a> was originally published in <a href="https://blog.dccommons.org/">Digital Credentials Commons</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What makes a Verifiable Credential verifiable?]]></title>
            <link>https://blog.dccommons.org/what-makes-a-verifiable-credential-verifiable-8f65ac8d7508?source=rss-d2c306b6a475------2</link>
            <guid isPermaLink="false">https://medium.com/p/8f65ac8d7508</guid>
            <category><![CDATA[verifiable-credentials]]></category>
            <category><![CDATA[identity-verification]]></category>
            <category><![CDATA[decentralized-identity]]></category>
            <dc:creator><![CDATA[James Chartrand]]></dc:creator>
            <pubDate>Thu, 19 Mar 2026 15:01:04 GMT</pubDate>
            <atom:updated>2026-09-11T14:37:43.423Z</atom:updated>
            <content:encoded><![CDATA[<h4>Part 4: Issuer Identity and Decentralized Identifiers</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oHlRUVGZtxRZA0X73yzwuQ.png" /></figure><p>Next in our series about our <a href="https://github.com/digitalcredentials/verifier-core">verifier-core</a> package, let’s consider the question:</p><p><em>How do we know who issued (signed) a Verifiable Credential (VC)?</em></p><p>Say what? Surely the credential itself tells us who the issuer is?</p><p>Take this very simple Verifiable Credential (VC) as an example:</p><pre>{<br> &quot;@context&quot;: [ &quot;https://www.w3.org/ns/credentials/v2&quot; ],<br> &quot;type&quot;: [ &quot;VerifiableCredential&quot; ],<br> &quot;issuer&quot;: {<br>   &quot;name&quot;: &quot;University of Wonderful&quot;,<br>   &quot;id&quot;: &quot;did:key:z6MknNQD1WHLGGraFi6zcbGevuAgkVfdyCdtZnQTGWVVvR5Q&quot;<br> },<br> &quot;credentialSubject&quot;: {<br>   &quot;name&quot;: &quot;James Chartrand&quot;,<br>   &quot;description&quot;: &quot;James rode his new bike on the trails.&quot;<br> },<br> &quot;proof&quot;: {<br>   &quot;type&quot;: &quot;DataIntegrityProof&quot;,<br>   &quot;created&quot;: &quot;2026–03–01T20:37:25Z&quot;,<br>   &quot;verificationMethod&quot;: &quot;did:key:z6MknNQD1WHLGGraFi6zcbGevuAgkVfdyCdtZnQTGWVVvR5Q#z6MknNQD1WHLGGraFi6zcbGevuAgkVfdyCdtZnQTGWVVvR5Q&quot;,<br>   &quot;cryptosuite&quot;: &quot;eddsa-rdfc-2022&quot;,<br>   &quot;proofPurpose&quot;: &quot;assertionMethod&quot;,<br>   &quot;proofValue&quot;: &quot;z64sLFyZaLBEXULkSFKzfHiqhfWvssPde4kqbJjmiGABKnJ7V84zX8ohiHpYLcGvyWSBpCKMvWw4DA14BjpNMvzaT&quot;<br> }<br>}</pre><p>So, it is says right there that the issuer is the ‘University of Wonderful’. And we can confirm from the cryptographic signature that nothing in the credential, including the issuer name, was tampered with since the credential was signed.</p><p>So what’s the problem — it’s from the University of Wonderful!</p><p>The problem is that anyone can add a cryptographic signature to a VC, kind of like anyone can use any old pen to add a written signature to a paper document.</p><p>A cryptographic signature is made with something called a ‘<strong>private key</strong>’ which is one half of a ‘<strong>key pair</strong>’, the other half being the ‘<strong>public key</strong>’. The private key is kept secret, the public part not at all. The public part is in fact included directly in the VC itself in the ‘verificationMethod’ property, as you can see in the example above.</p><p>And just as anyone can buy a pen from your local stationary store, so too can anyone can generate a key pair. It is in fact even easier to generate a key pair than to buy a pen — you can create a key pair instantly on your own laptop right now by typing into a terminal:</p><pre>ssh-keygen -t ed25519</pre><p>Once you’ve created a key pair, you can then use the private key to sign whatever VCs you want. Which is exactly what a university does when issuing degrees as VCs: generate a key pair and sign their VCs with the private key.</p><p>So here is the fundamental problem:</p><p>Just as with a pen, where we need to know that a specific person’s hand used the pen to write the signature, in this case we need to know that the private key used to create a cryptographic signature is in fact controlled by the university and not by Degrees-While-You-Wait.</p><p>With a written signature the best we can do is to compare the signature to a sample of the signature that we know is real. Which is generally not terribly helpful because it is so easy to forge a written signature. Fortunately, the public key part of a cryptographic key pair provides exactly the bit of magic that we need.</p><p>The trick is that:</p><blockquote>A cryptographic signature generated by a private key can only be verified<br>with it’s corresponding public key.</blockquote><p>So, if we know that a given public key belongs to the University of Wonderful, and that key successfully ‘verifies’ a signed credential, then we know the credential was issued (signed) by the University of Wonderful (and of course we also now know that nothing in the credential was tampered with since it was signed).</p><p>Voila!</p><p>Hmmm, wait, how do we actually know that the public key belongs to the University of Wonderful?</p><p>There are at least three approaches:</p><p>1. The University of Wonderful tells us directly.<br>2. The University of Wonderful adds the key to a list of keys that we trust.<br>3. Someone else that we trust tells us.</p><p>So let’s go through each one by one.</p><p><strong>1. The University of Wonderful tells us directly.</strong></p><p>The university could tell us directly in the sense that they could say,</p><p><em>“Our public key is: did:key:z6MknNQD1WHLGGraFi6zcbGevuAgkVfdyCdtZnQTGWVVvR5Q”.</em></p><p>Leaving it to us to then use that public key (which is expressed above in a form called a <a href="https://www.w3.org/TR/did-1.0/">Decentralized Identifier</a> or DID) to verify any of their credentials. Realistically, the university would probably help us along a bit more than that though:</p><p>Let’s say, for example, that we work in the HR department of Super Duper Steel — a biggish steel company in the same town, Wonderville, as the University of Wonderful. We regularly interview and hire graduates from Wonderful. In the past we’ve typically called up the university to confirm degrees, but that’s expensive and time consuming, because we have to get the student’s consent first, submit the consent to Wonderful, wait for an answer, etc.</p><p>Luckily, Wonderful now issues VCs for their degrees, and <br>in fact no longer even accepts call-in requests, so as to better protect the student’s privacy.</p><p>So, Wonderful, knowing we are one of the bigger employers of their graduates, stopped by our offices to show us how to setup a verification system on our own systems to instantly verify degrees. Graduates now simply upload their VC as part of their job application and a bit of code that Wonderful gave us automatically verifies the uploaded VCs.</p><p>In this case, Wonderful has still effectively told us what their public key is by embedding it directly in the verification code they gave us.</p><p>That’s all fine, you say, for a biggish company that can afford to run an automated system like that, but what about the local printing shop that only occasionally hires staff (like when their accountant moved to Australia)?</p><p>For these cases, Wonderful U would likely run a web site, on the wonderful domain, wonderful.edu, that allowed VC files to be uploaded, or links or QRs pointing at VCs to be pasted, and then verified those VCs directly on the web page. In this case, Wonderful is still effectively telling us what public key to use because Wonderful has embedded the public key directly in their verification code.</p><p>Mmmmmm, okay, so that’s fine for local companies that tend to hire mostly from Wonderful U, but what about Worldwide Steel, who have<br>offices around the world, and who typically get 5000 job applicants every month, from applicants with degrees from hundreds or even thousands of different universities? Worldwide Steel can’t be uploading files to hundreds or thousands of different university verification pages?</p><p>Right you are — which brings us to the second approach to sharing public keys.</p><p><strong>2. The University of Wonderful ‘registers’ their public key in a public list of keys that we trust</strong></p><p>The idea here is that someone maintains a list of public keys (in a form called a <a href="https://www.w3.org/TR/did-1.0/">Decentralized Identifier</a> or DID) for many different issuers. Thereby allowing a verifier to verify credentials from many different issuers without the verifier having to use a verification page on each issuer’s domain, or maintain a list of known issuers. Instead, the registry maintains the list for them, and of course for every other verifier that needs the same list.</p><p>There are a few issues to consider here.</p><p>1. There have to be so-called ‘governance’ rules in place for deciding who’s public keys (hereafter called DIDs) go in the registry. We can’t just let anyone add DIDs to a public registry, because then Degree-are-Us would add their DID and would appear to be a legitimate issuer. Worse is that someone could add a DID and fraudulently claim to be some legitimate university. We have to be sure that whoever gives us a DID is an authorized representative of a ‘real’ university, which means we need some kind of vetting process.</p><p>2. We also have to somehow indicate exactly what each issuer in the registry is authorized to issue. So a university can issue degrees, but not medical licenses, or birth certificates, or even dog licenses.</p><p>One approach is to have one registry for every ‘kind’ of credential. So, for example, one registry that only lists the DIDs for accredited universities that are legally allowed to issue university degrees. But, even then, some universities are only accredited to issue certain kinds of degrees. Wonderful University, for example, might be entitled to issue Engineering Degrees, but not Medical Degrees.</p><p>We could have a different registry for every type of degree, but better would be to have a single registry that indicates not only that the issuer is a trustworthy university, but that they are entitled to issue Engineering, Science, Arts, and Law degrees.</p><p>Even better would be to have a single registry that establishes the general trustworthiness of many different kinds of issuers, for example, universities, colleges, high schools, employers, countries (<br>citizenship credentials, birth credentials, passports). And also indicates exactly what kinds of credentials each issuer is entitled to issue.</p><p>That then allows a verifier to verify a whole portfolio of credentials in one fell swoop. When applying for a job, I could submit verifiable credentials for my degree, citizenship, driver’s license (if the job requires driving), past job history, and so on. The employer’s verification system could then verify all those credentials together by using our gigantisaurous registry-of-everything.</p><p>More likely, is that each of the different kinds of issuers will have their own registry, probably run by existing accreditation and legislated bodies, and a ‘registry of registries’ or ‘meta-regsitry’ will handle requests across the individual registries. So the Association of Registrars might run a registry for universities, each state/province might maintain their own registry for birth certificates, and so on. And the meta registry of registries knows about each of them, and can manage requests to each.</p><p>There is work been done in this direction, but it is still very much early on. Until there is a well recognized registry or set of registries, solutions continue to be ad hoc and verifiers tend to rely on knowing in advance the DID for a single issuer, or DIDS for a very specific small number of issuers.</p><p>Which brings us to the third model.</p><p><strong>3. Someone else that we trust tells us</strong></p><p>This is a more flexible model and is similar to how the internet manages<br>trust using with it’s x.509 certificates.</p><p>The fundamental idea is that if someone we trust signs a credential that says that a given DID belongs to Wonderful U, then we can trust credentials signed by that DID. You might also say that our trustworthy friend has ‘endorsed’ the DID.</p><p>Using universities as an example, the national association of registrars could issue VCs to every accredited university, where the VC given to each university contains a list of DIDs that that specific university is authorized to use to sign degrees.</p><p>So now, when verifying a degree from a given university, we no longer have to look up the university in a registry. The degree’s VC will instead contain a copy of the VC signed by the association of registrars attesting that the<br>university is entitled to issue this degree.</p><p>Now we only need to know the DID for the association of registrars, which lets us verify any degree from any accredited university. We no longer have to keep that big list of university DIDs. We just need to know the single overarching association’s DID.</p><p>Furthermore, the VC from the registrars association can also define exactly what kind of credential each individual university is authorized to issue, whether that be engineering degrees, medical degrees, and so on.</p><p>There is in fact work underway on a specification to help define the structure of the VC that ‘endorses’ or ‘authorizes’ the university:</p><p><a href="https://w3c-ccg.github.io/verifiable-issuers-verifiers/">https://w3c-ccg.github.io/verifiable-issuers-verifiers/</a></p><p><strong>The DCC Approach</strong></p><p>For the moment, the DCC’s approach is to use a registry of registries that we maintain, which includes a small number of registries associated with DCC members and partners.</p><p>This is our list:<br><a href="https://digitalcredentials.github.io/dcc-known-registries/known-did-registries.json">https://digitalcredentials.github.io/dcc-known-registries/known-did-registries.json</a></p><p>It is very important to note that we aren’t saying anything more than that we feel confident that the DIDs in those registried belong to the institutions that claim to control them. We don’t, for example, say anything about how the issuers are using their DIDs, what kinds of credentials they are signing, what they are entitled or authorized to sign, and so on.</p><p><strong>What’s all this got do with verifier-core?</strong></p><p>Which brings us, finally, to how this fits with our verifier-core package, the ostensible reason for these articles.</p><p>Our verifier-core package can be configured to point at a list of registries, including the list above, which we use for our Learner Credential Wallet app and VerifierPlus site.</p><p>For every verification of a Verifiable Credential the verifier-core package loads that list and checks every registry in the list for the DID that signed the VC.</p><p>Here is, for example, the code we use in our VerifierPlus verification page:</p><pre>const response = await fetch(&quot;https://digitalcredentials.github.io/dcc-known-registries/known-did-registries.json&quot;);<br>const knownDIDRegistries = await response.json();<br>const result = await verifierCore.verifyCredential({<br> credential,<br> knownDIDRegistries: knownDIDRegistries<br> });</pre><p>The DID might appear in more than one registry — we list all in which it appears. If the DID doesn’t appear in any registry, we indicate as such. We also indicate if a registry can’t be reached.</p><p>Here’s a sample result from verifier-core that specifies one registry in which the DID for the given VC is listed, and two registries that couldn’t be checked, possibly because of network issues:</p><pre>{<br>  &quot;credential&quot;: {the supplied vc - left out here for brevity/clarity},<br>  &quot;log&quot;: [<br>    {<br>      &quot;id&quot;: &quot;valid_signature&quot;,<br>      &quot;valid&quot;: true<br>    },<br>    {<br>      &quot;id&quot;: &quot;expiration&quot;,<br>      &quot;valid&quot;: true<br>    },<br>    {<br>      &quot;id&quot;: &quot;registered_issuer&quot;,<br>      &quot;valid&quot;: false,<br>      &quot;matchingIssuers&quot;: [<br>        {<br>          &quot;issuer&quot;: {<br>            &quot;federation_entity&quot;: {<br>              &quot;organization_name&quot;: &quot;DCC did:web test&quot;,<br>              &quot;homepage_uri&quot;: &quot;https://digitalcredentials.mit.edu&quot;,<br>              &quot;location&quot;: &quot;Cambridge, MA, USA&quot;<br>            }<br>          },<br>          &quot;registry&quot;: {<br>            &quot;name&quot;: &quot;DCC Sandbox Registry&quot;,<br>            &quot;type&quot;: &quot;dcc-legacy&quot;,<br>            &quot;url&quot;: &quot;https://digitalcredentials.github.io/sandbox-registry/registry.json&quot;<br>          }<br>        }<br>      ],<br>      &quot;uncheckedRegistries&quot;: [<br>            {<br>             &quot;name&quot;: &quot;DCC Community Registry&quot;,<br>             &quot;type&quot;: &quot;dcc-legacy&quot;,<br>             &quot;url&quot;: &quot;https://onldynoyrrrt.com/registry.json&quot;<br>           },<br>           {<br>              &quot;name&quot;: &quot;DCC Pilot Registry&quot;,<br>              &quot;type&quot;: &quot;dcc-legacy&quot;,<br>              &quot;url&quot;: &quot;https://onldynoyrt.com/registry.json&quot;<br>            }<br>      ]<br>    }<br>  ]<br>}</pre><p>And that’s another article in the books.</p><p>Next up is the last article in our series on verifier-core, in which we look at the final question:</p><p>Has our credential been tampered with?</p><p><a href="https://medium.com/u/2fb0c86ed134"><em>Gillian Walsh</em></a><em> is again to thank for her sharp eye and percipience in wrangling this into shippable shape.</em></p><p><em>DCC software is open source and available on</em><a href="https://github.com/digitalcredentials"><em> Github</em></a><em>. For additional information on the DCC, including community engagement, projects, and events, visit our</em><a href="https://dccommons.org/"><em> website</em></a><em>,</em><a href="https://wiki.dcconsortium.org/"><em> wiki</em></a><em>, and</em><a href="https://www.linkedin.com/company/dccommons"><em> Linkedin</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8f65ac8d7508" width="1" height="1" alt=""><hr><p><a href="https://blog.dccommons.org/what-makes-a-verifiable-credential-verifiable-8f65ac8d7508">What makes a Verifiable Credential verifiable?</a> was originally published in <a href="https://blog.dccommons.org/">Digital Credentials Commons</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What makes a Verifiable Credential verifiable?]]></title>
            <link>https://blog.dccommons.org/what-makes-a-verifiable-credential-verifiable-f32ed27ccd7d?source=rss-d2c306b6a475------2</link>
            <guid isPermaLink="false">https://medium.com/p/f32ed27ccd7d</guid>
            <dc:creator><![CDATA[James Chartrand]]></dc:creator>
            <pubDate>Tue, 20 Jan 2026 21:30:23 GMT</pubDate>
            <atom:updated>2026-09-11T14:40:54.460Z</atom:updated>
            <content:encoded><![CDATA[<h4>Part III: Revocation and the DCC verifier-core</h4><p><em>See Parts </em><a href="https://blog.dcconsortium.org/what-makes-a-verifiable-credential-verifiable-55098585dfa8"><em>I</em></a><em> &amp; </em><a href="https://blog.dcconsortium.org/what-makes-a-verifiable-credential-verifiable-1a97b80b8920"><em>II</em></a><em> of this series for background information.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8BdokQJvJAml9UDZ2MBnKw.png" /></figure><p>Similar to expiration, which we covered in <a href="https://blog.dcconsortium.org/what-makes-a-verifiable-credential-verifiable-1a97b80b8920">Part II,</a> revocation seems simple enough on the surface. However, the very nature of Verifiable Credentials (VCs) makes it a bit tricky — with some interesting attendant questions.</p><p>Perhaps the most interesting is:</p><blockquote>How can we revoke credentials that are autonomous, carry their proof with them, and are intentionally meant to be used privately without the issuer having any idea that they are being used?</blockquote><p>We will talk about that and along the way also cover:</p><ul><li>Status lists</li><li><a href="https://w3c.github.io/vc-bitstring-status-list/">Bitstring status list</a></li><li>Other types of ‘status’ besides revocation</li><li>Un-revoking</li><li>What are we revoking?</li><li>Is revocation really needed?</li><li>Was a revoked credential valid before it was revoked?</li><li>How the <a href="https://github.com/digitalcredentials/verifier-core">DCC verifier-core</a> package checks and reports on revocation status</li></ul><p>We’ll start by describing the standard approach to managing revocation of VCs — status lists.</p><h3>Status Lists</h3><p>VCs, in some sense, take on a life of their own the moment they are issued. They are autonomous and self-contained, and carry their proof with them, enabling them to be verified without involving the issuer. They do not depend on the issuer or on the issuer’s server being available to confirm the credential, making them more durable than other kinds of credential. And, because they do not require contact with the issuer to verify, they keep our activity private.</p><p>But there’s the problem:</p><p><strong>If VCs can be used without the issuer knowing they are being used, how can the issuer let a verifier know that a given VC has been revoked?</strong></p><p>Credentials other than VCs are typically verified by directly asking the issuer if so-and-so’s claim to a credential is still — or ever was — valid. That might be a phone call to the university, or maybe a lookup form on the university’s web page where I ask about a specific person. This is colloquially called ‘phoning-home’.</p><p>Which is exactly the kind of dependency we hope to avoid with VCs. To whom I show my degree is really none of the university’s business.<br> <br>Better is if the university publishes a single list of all VCs that have been revoked. We call this a ‘status’ list rather than a ‘revocation list’, in part because such lists can be used for other kinds of status, not just revocation (more on that later).</p><p>Verifiers can download and check that list when verifying a VC, crucially, without telling anyone which specific credential they are checking.</p><p>The list could look something like this list, where each line is an identifier included within the credential itself, and so revokes three credentials:</p><p>0E38C812–93F8–42B0–9646–8A5B8AC78BDB<br>7349C0A0–23A8–44A1–8FD3–46EE4B6CB836<br>27CB3081–1624–4689-A4C6–06EE01956834</p><p>A down side to such lists is that once a verifier knows the ID of a credential, the verifier could regularly re-check the list to see if the credential has been added, and therefore revoked. There are more complicated approaches to revocation that avoid that problem, but for many situations it’s an acceptable tradeoff.</p><p>Another problem is that if we revoke a lot of credentials then the list could get prohibitively large. In many contexts we don’t typically expect to revoke very many credentials, if any at all — university degrees being a good example — and so the list size wouldn’t tend to be a problem.</p><p>For those cases where the list might grow too large, an alternative is the BitstringStatusList, which is in fact the revocation mechanism that the Digital Credentials Consortium (DCC) verifier-core library checks. Let’s talk a bit about <a href="https://w3c.github.io/vc-bitstring-status-list/">Bitstring Status List</a>.</p><blockquote>The VC extensions spec (<a href="https://w3c.github.io/vc-extensions/#credential-status">https://w3c.github.io/vc-extensions/#credential-status</a>) lists three known status list implementations, however, the DCC’s verifier-core package only checks the BitstringStatusList (<a href="https://w3c.github.io/vc-bitstring-status-list/">https://w3c.github.io/vc-bitstring-status-list/</a>) implementation.</blockquote><h4>Bitstring Status List</h4><p>A <a href="https://en.wikipedia.org/wiki/Bit_array">bitstring</a> is simply a list of zeros and ones, like this list of seven zeros and ones:</p><pre>0101100</pre><p>Each digit in the list is assigned to a single credential, so that list could manage revocation for seven credentials.</p><p>If the allocated digit is ‘1’ then the associated credential has been revoked. If the digit is ‘0’ then the credential has not been revoked.</p><p>When we issue a new credential, we allocate a position (or index) in our list to the credential and add a property to the VC like so:</p><pre>&quot;credentialStatus&quot;: {<br> &quot;id&quot;: &quot;https://example.com/list/e5Wmbrj#7&quot;,<br> &quot;type&quot;: &quot;BitstringStatusListEntry&quot;,<br> &quot;statusPurpose&quot;: &quot;revocation&quot;,<br> &quot;statusListCredential&quot;: &quot;https://example.com/list/e5Wmbrj&quot;,<br> &quot;statusListIndex&quot;: &quot;7&quot;<br> }</pre><p>That bit of code tells a verifier to check the status of the credential by retrieving the list from <a href="https://example.com/list/e5Wmbrj">https://example.com/list/e5Wmbrj</a> and checking the digit at the seventh position.</p><p>The BitstringStatusList is itself a VC, containing the bit string and signed by the issuer. This means we can get a copy of it from anywhere, like a <a href="https://en.wikipedia.org/wiki/Content_delivery_network">CDN</a>, and still know it is legitimate from the signature. Using something like a CDN can help if the issuer’s server goes down, and also prevents an issuer from tracking calls to retrieve the list. An expiry date on the VC can be used to keep the list fresh.</p><p>The fundamental advantage to the BitstringStatusList is that a single list is compact and so relatively small, while still handling revocation for a large number of credentials. A list of length 100,000 is 12,500 bytes in the worst case, and very often even smaller, at just a few hundred bytes when compressed.</p><blockquote>It may seem on the surface as though a bitstring also provides an additional measure of privacy over a list of identifiers because a zero or a one doesn’t uniquely identify a credential. But it isn’t actually the zero or one that is the identifier in this case. It is the combination of the URL that points at the list, together with the credential’s unique position in the list, as in the example above.</blockquote><blockquote><a href="https://example.com/list/e5Wmbrj#7">https://example.com/list/e5Wmbrj#7</a></blockquote><blockquote>That combination uniquely identifies the credential and can therefore be correlated just as easily as a random identifier.</blockquote><p>A disadvantage to the bitsting approach is that we have to manage allocations, which requires keeping track of which bits in the string we’ve already allocated, which credentials we’ve allocated them to, and which bits are still available, all of which can be further complicated if we try to randomly allocate bits to try to prevent correlation based on position in the list.</p><p>It is worth noting, though, that to revoke credentials we have to keep track of which credentials we’ve issued anyhow— regardless of whatever revocation system we use - and so we’d likely use a database of some sort. If we’ve got that database then it isn’t so much more work (although still some amount of work) to store a bit position in that database when we issue the credential.</p><h3>Types of Status</h3><h4>Revocation</h4><p>Revocation can be defined as a binary (true/false) status assigned to a given credential that tells us if the credential is revoked or not revoked.</p><h4>Un-revoking</h4><p>You’ll remember that we asked at the beginning of the article if a revoked credential can be un-revoked. The VC specification (<a href="https://w3c.github.io/vc-bitstring-status-list/#bitstringstatuslistentry">https://w3c.github.io/vc-bitstring-status-list/#bitstringstatuslistentry</a>) explicitly says no:</p><p>“This status is not reversible.”</p><h4>Suspension</h4><p>The specification does however suggest another status, “suspension,” described thusly:</p><p>“Used to temporarily prevent the acceptance of a Verifiable Credential. This status is reversible.”</p><p>We use this additional status, rather than allow reinstatement of revocation, so as to make it clearer to a verifier that a revoked VC will never be reinstated, and should be considered unusable.</p><h4>Other types of status</h4><p>The specification also defines two other statuses:</p><p><strong><em>refresh</em></strong>: “Used to signal that an updated Verifiable Credential is available via the credential’s refresh service feature.”</p><p><strong><em>message</em></strong>: “Used to convey an arbitrary message related to the status of the Verifiable Credential.”</p><p>It isn’t hard to imagine other types of statuses. For example, a status with values like ‘submitted’, ‘pending’, under_review, ‘approved’, and so on. Indeed the Bitstring Status List specification does allow for these non-binary statuses. (<a href="https://w3c.github.io/vc-bitstring-status-list/#example-example-statuslistcredential-using-more-complex-entries">https://w3c.github.io/vc-bitstring-status-list/#example-example-statuslistcredential-using-more-complex-entries</a>)</p><p>For the moment, revocation is by far the most common, and the only status that the DCC verifier-core library checks.</p><h3>What exactly is being revoked?</h3><p>Seems obvious, but we want to be clear that when we revoke a VC we are revoking the *attestation* that the VC makes for some claim, and not the claim itself. Although sometimes the attestation and the claim can end up as effectively the same thing.</p><p>To better explain, let’s re-establish a few definitions we used in our last article, so we all know what we’re talking about.</p><p>A <strong><em>claim</em></strong> is a statement about a subject.<br>An <strong><em>attestation</em></strong> is support for a claim<br>A <strong><em>Verifiable Credential</em></strong> is a signed attestation to claims about a subject.</p><p>Some examples of claims: (where the subject of the claim is the named person):<br> <br>James Chartand has a bachelor’s degree. <br>Taylor Tuna attended a conference. <br>James Chartrand wrote a refereed journal article. <br>Sam Salmon has a lifeguarding qualification.<br>Jamie Jones is old enough to buy alcohol.</p><p>So again, a VC isn’t the claim itself, but rather an attestation to the claim. The claim exists independently of the VC, and of any attestations for that matter. Attestations, like a VC, only provide support for the claim.</p><p>And therefore, <strong><em>revocation</em></strong> of a VC applies to the attestation, in other words to the VC itself, and not to the contained claim(s).</p><p>We stress this point, because it is important for understanding the specification, but also because revocation of certain kinds of credentials, most notably university degrees, is a very sensitive topic. We want to be very very careful not to suggest that revocation of a VC implies revocation of the degree itself. Revocation a VC simply means the VC can no longer be used as an attestation (support for) a claim to a degree.</p><p>Of course there will be cases where the only support we have for a given claim is the VC, and if the VC is revoked then the claim will likely no longer be accepted by a verifier. An example could be a VC for a student card. The claim in this case is that the person named in the VC is a student at the given school. Verifiers like the gate keeper at the school’s football stadium might only accept the VC as proof of student identity when admitting students to games.</p><p>For many claims we have recourse to multiple attestations to support our claim. We could, for example, prove we hold a university degree using a VC, but could also prove it using the paper diploma we were issued, having a verifier call up the university directly, or confirming with alumni who could in turn verify that we hold the degree. Which of those attestations is sufficient is up to whoever has asked for proof.</p><h3>Does a Verifiable Credential require a status?</h3><p>No.</p><p>A VC needn’t have a revocation status. It is perfectly reasonable to issue a credential that we expect will never be revoked, for example, a confirmation of conference attendance, where the consequences of leaving an invalid credential ‘out-there’ likely aren’t severe enough to warrant revocation.</p><p>And we sometimes have the option of introducing a kind of ‘after-the-fact’ revocation system (like a list of credential IDs) if it turns out that it would be helpful. We can add revocation after the fact if we have some way of telling verifiers about the list, which could be easy-ish in some contexts and impossible in others. So, we do want to be careful to anticipate the need for revocation before issuing credentials.</p><p>It can also be the case that a credential expires relatively quickly, sufficiently soon that revocation isn’t necessary, even if the credential did become invalid before the expiry. An example might be a VC issued for a university degree with an aggressive expiry of say, one week. Anytime the student needs to prove they earned the degree they log back into their university account and get a fresh credential good for one week.</p><h3>Was a Verifiable Credential valid before it was revoked.</h3><p>Another tricky question that is admittedly a bit esoteric.</p><p>What we mean by this question is:</p><blockquote>Is a revoked credential no longer valid after the moment of revocation, but was valid before it was revoked? Or does it mean that a revoked credential should be considered as never having been valid?</blockquote><p>If the former — that it was valid before revocation — then a verifier might be able to use it as evidence that something was once true. But they can’t if the credential should never have been considered valid.</p><p>If Taylor Tuna had been issued a Verifiable Credential for a university degree then ten years later got married and took the last name Tuna-Casserole, then the university might revoke the ‘old’ credential that had been issued to Taylor Tuna and issue a new one to Taylor Tuna-Casserole.</p><p>If revocation is taken to mean that the credential was never valid then Taylor couldn’t use the revoked credential as evidence of the prior name. On the other hand, if revocation is taken to mean that the credential is only invalid after the revocation date, then Taylor could use the credential as evidence of their past life.</p><p>As a counter example, Sam Salmon might have been issued a degree, but ten years later, Sam, overcome with paroxysms of guilt,<strong> </strong>confesses to having paid someone else to take his exams. The university forthwith revokes Sam’s VC, the intention in this case that the VC should never have been considered valid.</p><p>As we talked about in <a href="https://blog.dcconsortium.org/what-makes-a-verifiable-credential-verifiable-1a97b80b8920">Part II on expiry,</a> checks on things like the signature, the expiry date, and the revocation status are considered ‘verification’. What decision is made from the results of verification is called ‘validation’. Validation is, in a sense, applying the business rules of a verifier to the results of verification to decide if we’ll accept the credential as evidence for a given claim.</p><p>Just as with expiry, it is up to the verifier to decide if a revoked credential still has any use, with the caveat that generally speaking revocation should be considered a more definitive declaration than expiration. Revocation implies that the credential should no longer be considered valid, and indeed should possibly never have been considered valid.</p><p>If a reason for revoking could be given, or possibly a date only after which the credential is considered revoked, then a verifier might be more willing to consider the VC as evidence that the claim at one point was supported by the VC.</p><p>However, Providing a reason for revocation is typically frowned upon, because for the most part it likely isn’t relevant, introducing potential privacy problems.</p><p>Providing a date after which the credential should be considered revoked could be an alternative. This approach still reveals some information but not as much and indicates a period during which the credential was valid. So something like:</p><p><strong>revokedAsOf: 0001–01–01</strong></p><p>which indicates that the credential should always have been considered invalid</p><p><strong>revokedAsOf: 2025–02–14</strong></p><p>So revoked as of Valentine’s Day 2025, but before that was valid. The revocation in this case might have been due to a name change on the credential on Valentine’s Day, following a Vegas wedding.</p><p>For the moment, no date or reason is provided with the BitstringStatusList as used by the DCC, and so a revoked credential should usually be considered outright invalid, and not usable as evidence of anything.</p><h3>verifier-core</h3><p>The DCC’s verification library, <a href="https://github.com/digitalcredentials/verifier-core">verifier-core</a>, only supports BitstringStatusList and ignores any other status lists. It also only supports revocation and not ‘suspension’, ‘refresh’, ‘message’, or any other status.</p><p>If no revocation status is included in a VC then verifier-core returns valid (has not been revoked) as the status.</p><p>If a revocation status has been included in a credential then verifier-core will return one of three things for the status:</p><p>1. the credential has not been revoked<br>2. the credential has been revoked<br>3. the credential status list that could not be retrieved, and so we can’t say one way or the other if the credential has been revoked</p><p>A valid result, showing the log part of the verifier-core result:</p><pre>&quot;log&quot;: [<br>   {<br>     &quot;id&quot;: &quot;valid_signature&quot;,<br>     &quot;valid&quot;: true<br>   },<br>   {<br>     &quot;id&quot;: &quot;expiration&quot;,<br>     &quot;valid&quot;: true<br>   },<br>   {<br>     &quot;id&quot;: &quot;revocation_status&quot;,<br>     &quot;valid&quot;: true<br>   },<br>   {<br>     &quot;id&quot;: &quot;registered_issuer&quot;,<br>     &quot;valid&quot;: true,<br>     &quot;matchingIssuers&quot;: &quot;removed for brevity&quot;<br>   }<br>]</pre><p>If the credential has been revoked, the revocation entry simply switches to false:</p><pre>&quot;log&quot;: [<br>   {<br>     &quot;id&quot;: &quot;valid_signature&quot;,<br>     &quot;valid&quot;: true<br>   },<br>   {<br>     &quot;id&quot;: &quot;expiration&quot;,<br>     &quot;valid&quot;: true<br>   },<br>   {<br>     &quot;id&quot;: &quot;revocation_status&quot;,<br>     &quot;valid&quot;: false<br>   },<br>   {<br>     &quot;id&quot;: &quot;registered_issuer&quot;,<br>     &quot;valid&quot;: true,<br>     &quot;matchingIssuers&quot;: &quot;removed for brevity&quot;<br>    }<br>]</pre><p>If the status list can’t be retrieved:</p><pre>&quot;log&quot;: [<br>   {<br>     &quot;id&quot;: &quot;valid_signature&quot;,<br>     &quot;valid&quot;: true<br>   },<br>   {<br>     &quot;id&quot;: &quot;expiration&quot;,<br>     &quot;valid&quot;: true<br>   },<br>   {<br>     &quot;id&quot;: &quot;revocation_status&quot;,<br>     &quot;error&quot;: {<br>       &quot;name&quot;: &quot;&#39;status_list_not_found&#39;&quot;,<br>       &quot;message&quot;: &quot;Could not retrieve the revocation status list.&quot;<br>     } <br>   },<br>   {<br>     &quot;id&quot;: &quot;registered_issuer&quot;,<br>     &quot;valid&quot;: true,<br>     &quot;matchingIssuers&quot;: [ ]<br>   }<br>]</pre><p>Other errors we return for revocation status:</p><pre>&quot;error&quot;: {<br>   &quot;name&quot;: &quot;status_list_expired&quot;,<br>   &quot;message&quot;: &quot;The status list verifiable credential has expired.&quot;<br> }<br><br>&quot;error&quot;: {<br>   &quot;name&quot;: &quot;status_list_signature_error&quot;,<br>   &quot;message&quot;: &quot;The signature on the status list is invalid.&quot;<br>} <br><br>&quot;error&quot;: {<br>   &quot;name&quot;: &quot;status_list_type_error&quot;,<br>   &quot;message&quot;: &quot;Status list credential type must include \&quot;BitstringStatusListCredential\&quot;.&quot;<br>} <br><br>&quot;error&quot;: {<br>   &quot;name&quot;: &quot;status_list_not_yet_valid&quot;,<br>   &quot;message&quot;: &quot;The validFrom date on the status list credential is in the future.&quot;<br>}</pre><p>And a fallback for any unknown error:</p><pre>&quot;error&quot;: {<br>   &quot;name&quot;: &quot;status_list_error&quot;,<br>   &quot;message&quot;: &quot;The status list couldn&#39;t be verified.&quot;<br> }</pre><p>And that’s that for revocation. Next up are so called <strong><em>issuer registries</em></strong>, whose job it is to answer the question:</p><p>Who really issued this credential?</p><p>See you next time!</p><p><em>Many thanks again to </em><a href="https://medium.com/u/2fb0c86ed134"><em>Gillian Walsh</em></a><em> for her much appreciated perspicacity and judicious editing.</em></p><p><em>DCC software is open source and available on</em><a href="https://github.com/digitalcredentials"><em> Github</em></a><em>. For additional information on the DCC, including community engagement, projects, and events, visit our</em><a href="https://dccommons.org/"><em> website</em></a><em>,</em><a href="https://wiki.dcconsortium.org/"><em> wiki</em></a><em>, and</em><a href="https://www.linkedin.com/company/dccommons"><em> Linkedin</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f32ed27ccd7d" width="1" height="1" alt=""><hr><p><a href="https://blog.dccommons.org/what-makes-a-verifiable-credential-verifiable-f32ed27ccd7d">What makes a Verifiable Credential verifiable?</a> was originally published in <a href="https://blog.dccommons.org/">Digital Credentials Commons</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Makes a Verifiable Credential Verifiable]]></title>
            <link>https://blog.dccommons.org/what-makes-a-verifiable-credential-verifiable-1a97b80b8920?source=rss-d2c306b6a475------2</link>
            <guid isPermaLink="false">https://medium.com/p/1a97b80b8920</guid>
            <dc:creator><![CDATA[James Chartrand]]></dc:creator>
            <pubDate>Mon, 08 Dec 2025 16:45:28 GMT</pubDate>
            <atom:updated>2026-09-11T14:42:16.375Z</atom:updated>
            <content:encoded><![CDATA[<h3>Part II: What Makes a Verifiable Credential Verifiable?</h3><h4>Expiration and Validity</h4><p><a href="https://blog.dcconsortium.org/what-makes-a-verifiable-credential-verifiable-55098585dfa8?postPublishedType=repub"><em>See Part I — The Technology Behind Tamper-Proof Digital Credentials</em></a></p><p>Expiration would seem straightforward — after the expiry date, the credential is no longer considered valid. There are, however, some interesting and important subtleties that we’ll talk about after quickly covering some of the basics of expiration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/908/1*N0X1YRCVm2U7FX13P9WuoQ.png" /></figure><h4>Validity period</h4><p>In addition to an expiry date, W3C Verifiable Credentials (VCs) also have what we might broadly call a <strong>start date</strong> that together with the expiry date, or <strong>end date</strong>, define a specific period of time in which the VC is considered valid. Hereafter, in this article, we’ll generally refer to the <strong>validity period</strong> rather than just the expiry date.</p><p>We’ll also focus on the validity period as defined by version 2 of the VC specification rather than version 1.</p><p>We’ll talk about the validity period as defined by the Verifiable Credentials specifications, but because <a href="https://www.imsglobal.org/spec/ob/v3p0">Open Badges version 3</a> (OBv3) credentials are themselves Verifiable Credentials, everything we’ll talk about applies equally well to OBv3 credentials.</p><h4>What the specs say</h4><p><a href="https://www.w3.org/TR/vc-data-model-1.1/#expiration">Version 1 of the VC specification</a> uses the <strong>issuanceDate</strong> and <strong>expirationDate</strong> properties to define the period of validity:</p><pre>&quot;issuanceDate&quot;: &quot;2018–11–29T19:23:24Z&quot;<br>&quot;expirationDate&quot;: &quot;2020–01–01T19:23:24Z&quot;</pre><p>The issuanceDate must be included. The expirationDate is optional.</p><p><a href="https://www.w3.org/TR/vc-data-model-2.0/#validity-period">Version 2 of the VC specification</a> uses the <strong>validFrom</strong> and <strong>validUntil</strong> properties:</p><pre>&quot;validFrom&quot;: &quot;2018–11–29T19:23:24Z&quot;<br>&quot;validUntil&quot;: &quot;2020–01–01T19:23:24Z&quot;</pre><p>ValidFrom and validUntil can be used together, each on their own, or neither used at all. ValidUntil must be the same as, or later than validFrom (if it exists), but either can be in the past or future.</p><p>If there is no validUntil then the Verifiable Credential is valid indefinitely.</p><p>If there is no validFrom then the Verifiable Credential is considered valid from the time the Verifiable Credential was created.</p><p>The specification describes the properties as such:</p><p>“[<strong>validUntil</strong>] represents the <strong>latest</strong> point in time at which the information associated with the credentialSubject property is valid.”</p><p>“[<strong>validFrom</strong>] represents the <strong>earliest</strong> point in time at which the information associated with the credentialSubject property becomes valid.”</p><p>The dates must use the <a href="https://www.w3.org/TR/xmlschema11-2/#dateTimeStamp">dateTimeStamp format</a>, which is typically the <a href="https://www.iso.org/iso-8601-date-and-time-format.html">ISO 8601 format</a>. The ISO 8601 formatted date time for this moment is:</p><pre><strong>2025–11–26T20:01:40+0000</strong></pre><p>If <strong>validFrom</strong> and <strong>validUntil</strong> are not present, the <a href="https://w3c.github.io/vc-data-model/#dfn-verifiable-credential">VC</a> validity period is considered valid indefinitely. In such cases, the VC is assumed to be valid from the time the <strong>verifiable credential</strong> was created.</p><h4>Tampering</h4><p>Dates are recorded in the signed part of the credential, so can’t be changed without invalidating the signature and therefore the credential itself.</p><h4>verifier-core</h4><p>The Digital Credentials Commons software verification library verifier-core reports an expired credential as an entry in the result log, like so :</p><pre>{<br> &quot;id&quot;: &quot;expiration&quot;,<br> &quot;valid&quot;: false<br>}</pre><p>A not yet expired credential, including a credential with no expiry date, like so:</p><pre>{<br> &quot;id&quot;: &quot;expiration&quot;,<br> &quot;valid&quot;: true<br>}</pre><p>verifier-core considers a credential expired if the current date is after the validUntil date.</p><p>Okay, on then to the interesting questions.</p><h4>Does the period of validity apply to the VC itself or to the underlying credential?</h4><p>The short answer is: the VC. But this is nuanced.</p><p>First off, it is important to understand that:</p><blockquote>A Verifiable Credential is a cryptographically signed attestation of some claim about a subject.</blockquote><p>And to consequently understand that:</p><ol><li>The attestation (the VC), the claim, and the signature are three separate things.</li><li>The attestation, the claim, and the signature can have different periods of validity</li></ol><p>A common analogy is that the VC is kind of like an envelope into which we can put a claim, and then apply a seal (cryptographic signature) to the envelope that says we, the issuer, hereby support (attest to) the claims in the envelope.</p><p>And we can furthermore put validFrom and validUntil dates on the envelope that effectively say: <em>we support the contained claims during this period of time, but only this period of time</em>.</p><p>The claims themselves might be valid beyond the validFrom/validUntil dates, validFrom/validUntil simply restricts the period of our <strong><em>support</em></strong> for the claims.</p><p>Let’s follow this through with an example.</p><p>Sam Salmon takes a lifeguarding course, at the end of which, Dec 2, 2025, Sam is qualified to lifeguard for two years until Dec 1, 2027. This is a fact that exists independently of any proof, attestation, certificate, or VC.</p><p>But Sam needs to show evidence of the fact when applying for a lifeguarding job. The Royal Lifesaving Society could therefore issue a VC to Sam with this claim:</p><p>“Sam Salmon is qualified to lifeguard in Canada.”</p><p>Note that the claim in this example does not specify the dates of the qualification. The claim isn’t restricted to any date range.</p><p>The society could then include these dates in the VC:</p><p>validFrom: 2025–12–02<br>validUntil: 2027–12–01</p><p>This says that the Society is willing to support that claim only during the period from December 2, 2025 to December 1, 2027. So in this case the period of the attestation effectively restricts the period of the claim by removing the support of the attestation outside of the period.</p><p>This image might help to understand how the dates apply. The green box is the envelope (the VC/attestation) and the blue box is the contained claim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/546/1*OZz64mSTgIPWKfBXp0DiGg.png" /></figure><p>Okay, but what if — even though Sam’s lifeguarding qualification is good for two years — the Society only wants the VC to be valid for one year, maybe because the Society’s policy is to re-issue VCs yearly to mitigate the effects of fraud and technology change. Note that the Society still wants the VC to convey the fact that the lifeguarding qualification is a two year qualification, but essentially wants to require a fresh VC in the second year.</p><p>So, the Society could instead issue a VC with a different claim:</p><p>“Sam Salmon is qualified to lifeguard in Canada from December 2, 2025 to December 1, 2027”</p><p>Now the dates of the qualification are part of the claim.</p><p>The society can now separately define the period of validity of the <strong><em>attestation</em></strong> for just a single year as:</p><p>validFrom: 2025–12–02<br>validUntil: 2026–12–01</p><p>We’d ideally record the dates of the qualification in an agreed upon vocabulary for the qualification claim, which would probably look something like:</p><p>qualification.validFrom: 2025–12–02<br>qualification.validUntil: 2027–12–01</p><p>So now our image looks like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/546/1*8KMYYEFbQIwuNxWrX370dw.png" /></figure><p>So here the Society is saying that Sam is entitled to lifeguard for those two years, but they only commit to supporting that claim for the first of those two years. They aren’t in any way saying the second year of the qualification isn’t valid, just that they don’t want to — with this VC — attest to that second year. After the year was up Sam can ask the Society for a new attestation that covers the remaining year of the qualification.</p><p>Interestingly, the validFrom and validUntil dates don’t even need to overlap with the qualification’s dates. Sam might, for example, stop working as a lifeguard in Canada and let the qualification lapse, but then move to Australia where Sam decides to re-qualify because the beaches are oh-so-nice. The Australian Royal Life Saving Society, in order to expedite his re-qualification, might ask Sam to provide evidence of a prior certification in Canada. So Sam asks the Canadian Society to issue a VC stating the already expired period of the qualification. The qualification dates on the VC would look like so:</p><p>qualification.validFrom: 2025–12–02<br>qualification.validUntil: 2027–12–01</p><p>And the attestation dates, which are from the moment of issuance of the new VC and valid for one year:</p><p>validFrom: 2029–02–15<br>validUntil: 2030–02–14</p><p>You can see that the the dates during which the VC (the attestation) is valid are well after the dates during which the qualification was valid. And this makes sense because the attestation is being made <strong><em>now</em></strong> about something that was the case in the <strong><em>past</em></strong>. Which leads into our next topic.</p><h4>ValidFrom and validUntil can be in the past or future</h4><p>One case where the dates might be in the past is if an issuer re-issues a previously issued VC, maybe because someone lost it. If the validUntil has already passed, the new VC can still use that old validUntil — which says that the issuer, at one point in the past, specifically during the period of validity, stood by their assertion. Which could be useful for legal reasons, to prove something had been true, or simply to show say that a claim I’d made to a past job was at some point in time asserted by the employer, so in other words, I hadn’t lied.</p><p>An example of where the dates might be in the future is if a conference organizer issues conference tickets as VC, where the claim is:</p><p>“James Chartrand is entitled to attend the conference.”</p><p>Here the claim itself doesn’t specify the dates, so the validFrom/validUntil in the VC has to specify the period during which the conference organizer recognizes that statement as being in effect, or in other words, the period during which the organizer (the issuer of the VC) asserts that the claim is valid. If the organizer issues the VC in advance of the conference, the validFrom/validUntil dates will therefore be in the future, when the conference is underway, and not at the time the VC was issued.</p><p>Note that if the claim was instead:</p><p>“James Chartrand is entitled to attend the conference June 12 to June 15 inclusive.”</p><p>Then the validFrom/validUntil dates on the VC can be different, and will be whatever period in which the organizer wants their assertion to continue to remain valid. They might, for example, set validFrom to the date the ticket was issued, say two weeks before the conference starts, and set validUntil to 1 year after the conference ends, so as to allow the tickets to more easily be used for things like claiming travel expenses.</p><p>It is very much worth noting that in all these cases, whoever is verifying the credential has to know how to interpret the credential, or in other words, they have to know what the issuer intended. Which of course includes machines that might verify the credentials, and which would need specific rules to follow. Well get into that a bit in the forthcoming Part 3 of this blog series.</p><p>To finish this section off, we mentioned earlier that the signature can also have a validity period. The signature is in the ‘proof’ section of the VC, and has got fields to define the valid period of the signature. These fields can be used to manage things similar to what we talked about earlier, like aggressive expiry to mitigate key theft, or to restrict how long a given version of a the specification needs to be supported. However, verification software might enforce of the signature period more severely than the validFrom/validUntil period and might even outright reject the signature after the expiration, which can make it difficult for someone (like say an employer) to know if the signature was ever valid. As always, it depends on the intentions of the issuer and what rules the verifier follows. We’ll now talk about those rules a bit in this next section.</p><h4>Can I use a credential after it expires?</h4><p>In our first article we mentioned that verifier-core doesn’t assume that a credential is completely invalid even if we are now past the validUntil date. It only reports back that it has expired. How to interpret that expiration is up to whoever is viewing the credential.</p><p>This approach is often explained as the difference between <strong><em>verification</em></strong> and <strong><em>validation</em></strong>.</p><blockquote><strong>Verification</strong> is the checking of the cryptography and technological paraphernalia, which includes the expiry dates.</blockquote><blockquote><strong>Validation</strong>, on the other hand, is about deciding <strong>what to conclude</strong> from the verification checks.</blockquote><p>Validation is more like business rules. And different consumers of the credential and its verification results can have different rules.</p><p>An expired boarding pass or conference ticket might, for example, be used after expiry to submit expenses for reimbursement, still allowing the payer to verify that the travel did take place.</p><p>Another example could be a university degree that has expired (not the degree itself but the VC attesting to it), but the university has since ceased to operate — perhaps because of political unrest — leaving the alumni with only their expired VC to prove they got the degree. The alumni would obviously still present the credential to anyone who needed proof, probably with other corroborating evidence, and hope for the best. This is in fact a good argument for not setting an expiration on a credential, which brings us to our next question.</p><h4>Does a credential even have to expire?</h4><p>No.</p><p>Some credentials called low-risk credentials, like a certificate of attendance for a woodworking course, can typically be issued without an expiry date.</p><p>Credentials for things that we don’t expect will ever change can also be issued without an expiry date to provide the credential holder with a long-lived proof of their credential. A university might issue VCs for its degrees, without an expiry date, because they want the student to forever have proof of graduation that they can thereafter use any time they like, with no dependency on the university, even in the extreme case where the university might cease to operate.</p><p>Of course, there are downsides to credentials that don’t expire and can’t otherwise be revoked. With the degree example, if the university revoked the actual degree (maybe because they re-marked some exam and decided a 51 was now a 49), I could still continue to trot out my old VC, forgetting to mention that the actual degree had been revoked. So here the problem is that even though it is true - and always will be true - that I was awarded the degree at convocation, verifiers usually want to know not if I <strong><em>once</em></strong> had the degree, but rather if I <strong><em>still</em></strong> do. I am effectively lying by omission if I don’t tell them that it had subsequently been revoked.</p><p>There are other reasons why we’d want to expire a credential even if we expect the claim to always be true. We might not want to support the given version of the VC longer than say, 1 year because we expect technology to change. Setting a 1 year expiration date signals to the holder that even though they will continue to have their credential, it might not be as useful in a year’s time because technology has changed, and verifiers might no longer then support the old specification.</p><p>Or we might use short expiry periods to mitigate the risk of fake or mis-used credentials. If we only issue credentials that are valid for six months, then the usefulness of any fake credentials are limited to that six month period. For high-risk credentials, this expiry could even be as short as a few minutes. This aggressive expiry would typically be done along with something we call ‘key rotation’ which means that we periodically retire our current signing key and start using a brand new one. Credentials signed with an old key are only be considered valid during the ‘active’ period of the key. Note that the active period of the key can’t be defined in the credential itself because if someone has stolen the key they could of course set whatever active period they like in the credential. So we set the active period of the key in an external registry. We’ll talk more about key (or issuer) registries in a later article.</p><p>An interesting alternative to expiration is revocation, which affords the longevity of a credential with no expiration date, which is important for something like a degree, while still maintaining the option to invalidate the credential if necessary. Not coincidentally, revocation is our next topic.</p><p>See you next time!</p><p><em>As always, many thanks are due to </em><a href="https://medium.com/u/2fb0c86ed134?source=post_page---user_mention--55098585dfa8---------------------------------------"><em>Gillian Walsh</em></a><em> for her sharp editing eye and perspicacious suggestions.</em></p><p><em>DCC software is open source and available on</em><a href="https://github.com/digitalcredentials"><em> Github</em></a><em>. For additional information on the DCC, including community engagement, projects, and events, visit our</em><a href="https://dccommons.org/"><em> website</em></a><em>,</em><a href="https://wiki.dcconsortium.org/"><em> wiki</em></a><em>, and</em><a href="https://www.linkedin.com/company/dccommons"><em> Linkedin</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a97b80b8920" width="1" height="1" alt=""><hr><p><a href="https://blog.dccommons.org/what-makes-a-verifiable-credential-verifiable-1a97b80b8920">What Makes a Verifiable Credential Verifiable</a> was originally published in <a href="https://blog.dccommons.org/">Digital Credentials Commons</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What makes a Verifiable Credential verifiable?]]></title>
            <link>https://blog.dccommons.org/what-makes-a-verifiable-credential-verifiable-55098585dfa8?source=rss-d2c306b6a475------2</link>
            <guid isPermaLink="false">https://medium.com/p/55098585dfa8</guid>
            <dc:creator><![CDATA[James Chartrand]]></dc:creator>
            <pubDate>Wed, 19 Nov 2025 17:54:17 GMT</pubDate>
            <atom:updated>2026-09-11T14:43:10.268Z</atom:updated>
            <content:encoded><![CDATA[<h3>Part I: What makes a Verifiable Credential verifiable?</h3><h4><em>The Technology Behind Tamper-Proof Digital Credentials</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Qf6BFwJUsaslXVuByYQx0A.png" /></figure><p>Aaron Winters from Western Governor’s University — an institutional member of the Digital Credentials Consortium (DCC) — recently wrote an <a href="https://blog.dcconsortium.org/verifiable-credentials-verification-model-a-new-paradigm-for-digital-credential-verification-1f0b8b5d7d99">excellent blog post</a> about W3C Verifiable Credentials (VCs). Aaron talked about the fundamentals of VCs including issuance, sharing, and verification.</p><p>In a new series of four articles, starting with this overview, we’ll go into a bit more detail about the verification piece, especially in the context of the open-source javascript software library that the DCC recently released called <a href="https://github.com/digitalcredentials/verifier-core">verifier-core</a>, which as you might guess from the name, encapsulates some of the core functionality needed for verification.</p><h3>Motivation</h3><p>First, you might reasonably ask why we need this seemingly complicated (although it isn’t really!) verification system when a verifier — like an employer — could just call up a university to confirm that someone graduated?</p><p>Well, there are some downsides to calling up the institution:</p><ul><li>It can take a while — days or weeks even — to receive this confirmation. This is infeasible in some cases, especially if many degrees need to be verified.</li><li>The university may no longer exist or may not have the resources to verify credentials.</li><li>Privacy laws or policies may require that the student provide consent for confirmation, which can be difficult, especially if proof of that consent has to be stored for some period of time.</li><li>As we become increasingly aware of and rightfully concerned by how much our lives and data are monitored, do we want credential issuers tracking how we use our credentials, especially when they don’t have to? Should, for example, my university (or whoever might coerce my university into revealing information) know that I’m applying for a job with a given political party?</li></ul><p>Fortunately, VCs provide a durable (long-lived), privacy preserving, reliable (tamper evident), and instantaneous means to verify a credential.</p><p>And note that while we’re using a university degree as an example here, the same issues apply with high schools, colleges, employment records, conference participation, and so on.</p><p>Okay, let’s get a bit of the technical talk out of the way, so we can talk about more interesting things. You can ignore this next section without losing the plot — it’s mostly just here for reference.</p><h3>Specifications</h3><p>The current version of verifier-core (1.0.0-beta.10) works with the following versions of W3C Verifiable Credentials:</p><ul><li>Version 1.0 — <a href="https://www.w3.org/TR/2019/REC-vc-data-model-20191119/">https://www.w3.org/TR/2019/REC-vc-data-model-20191119/</a></li><li>Version 1.1 — <a href="https://www.w3.org/TR/2022/REC-vc-data-model-20220303/">https://www.w3.org/TR/2022/REC-vc-data-model-20220303/</a></li><li>Version 2.0 — <a href="https://www.w3.org/TR/vc-data-model-2.0/">https://www.w3.org/TR/vc-data-model-2.0/</a></li></ul><p>And verifies signatures from the following cryptosuites:</p><ul><li>eddsa-rdfc-2022 Data Integrity Proof — <a href="https://github.com/digitalbazaar/eddsa-rdfc-2022-cryptosuite">https://github.com/digitalbazaar/eddsa-rdfc-2022-cryptosuite</a></li><li>ed25519-signature-2020 Linked Data Proof — <a href="https://github.com/digitalbazaar/ed25519-signature-2020">https://github.com/digitalbazaar/ed25519-signature-2020</a></li></ul><p>And uses the following specification for privacy-preserving revocation:</p><ul><li>Bitstring Status List version 1.0 — <a href="https://www.w3.org/TR/vc-bitstring-status-list/">https://www.w3.org/TR/vc-bitstring-status-list/</a></li></ul><p>All right, onto the interesting bits.</p><h3>The questions that need answering</h3><p>As Aaron described in his article, there are four fundamental questions that we check for when verifying a VC:</p><ul><li>Has the credential been tampered with since it was signed?</li><li>Has the credential expired?</li><li>Has the credential been revoked?</li><li>Who signed the credential?</li></ul><p>The verifier-core package checks each of these and returns an answer for each.</p><p>Those answers are packaged into a structure that looks more or less like the following, which is effectively a log with one section for each question. There’s a lot going on in this example, but we’ll explain each section as we go. For the moment you can just take a gander at the code.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/801e73a041b1945ae42bdd3903a690ff/href">https://medium.com/media/801e73a041b1945ae42bdd3903a690ff/href</a></iframe><p>Note that the verifier-core package doesn’t anywhere in there return a decision about the <strong><em>overall</em></strong> validity of the credential. It only answers each of the four questions. Because in some circumstances a credential might still be useful even though one of the questions returned a ‘false’ answer. An expired or revoked driver’s license might still be useful because it shows I had a license from 2022 to 2025, which could be handy when negotiating car insurance rates.</p><p>All right, so that was a simple introduction to verifier-core, and what it provides. There is a lot more going on there, of course. In our series of articles we’ll go into more details about each section.</p><p>Our next article will start by explaining how verify core answers the two easiest of the four questions:</p><ul><li>Has a credential expired.</li><li>Has a credential been revoked.</li></ul><p>We’ll then follow that up with two more articles talking about the two remaining questions:</p><ul><li>Has a credential been tampered with?</li><li>Who signed the credential?</li></ul><p>See you next time!</p><p><em>Many thanks to </em><a href="https://medium.com/u/2fb0c86ed134"><em>Gillian Walsh</em></a><em> for her expert edits and suggestions.</em></p><p><em>DCC software is open source and available on</em><a href="https://github.com/digitalcredentials"><em> Github</em></a><em>. For additional information on the DCC, including community engagement, projects, and events, visit our</em><a href="https://dccommons.org/"><em> website</em></a><em>,</em><a href="https://wiki.dcconsortium.org/"><em> wiki</em></a><em>, and</em><a href="https://www.linkedin.com/company/dccommons"><em> Linkedin</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=55098585dfa8" width="1" height="1" alt=""><hr><p><a href="https://blog.dccommons.org/what-makes-a-verifiable-credential-verifiable-55098585dfa8">What makes a Verifiable Credential verifiable?</a> was originally published in <a href="https://blog.dccommons.org/">Digital Credentials Commons</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>