GPU Code 52: Windows Cannot Verify the Driver's Digital Signature? Signature Chain, Secure Boot & Driver Source Diagnosis Guide

Key Takeaways
Code 52 means Windows refused to load the graphics driver because signature verification failed at load time, not because the card is broken. The failure can sit in the driver file, the catalog file, the certificate chain, the system clock, or the firmware, so diagnosis means checking each link in turn before replacing anything.
What Code 52 Actually Says
Open Device Manager, expand Display adapters, right-click the graphics card, and choose Properties. On the General tab, the Device status box shows a yellow exclamation mark and the message: "Windows cannot verify the digital signature for the drivers required for this device. A recent hardware or software change might have installed a file that is signed incorrectly or damaged, or that might be malicious software from an unknown source. (Code 52)". That message is the whole diagnosis in one sentence, and it is worth reading carefully, because it already narrows the problem in a way that a plain "driver failed to load" message does not.
Code 52 is a Device Manager problem code, not a blue screen code. It appears when Windows tries to load a driver and the signature check on that driver fails, so Windows refuses to load it. The graphics card then sits in Device Manager with a yellow exclamation mark, and the display falls back to the Microsoft Basic Display Driver, which provides a picture but none of the card's normal performance or features. A picture on the screen therefore proves nothing about whether the graphics driver loaded; the error code is the evidence that matters.
Three things Code 52 does not say are just as important as what it does say. It does not say the driver has a bug. It does not say the graphics card is faulty. And it does not say, in the simple sense, that the driver is unsigned. Its precise meaning is that Windows, at the moment of loading the driver, checked the signature and the check failed. The signature itself, the chain of certificates behind it, the state of the machine doing the checking, and the integrity of the driver files can each be the link that breaks. Any one of them produces the same code, so Code 52 is the start of a diagnosis, not the end of one.
How the Signature Chain Works: Five Layers, Checked in Order
On 64-bit Windows, kernel-mode drivers are subject to Kernel-Mode Code Signing (KMCS). A graphics driver runs in kernel mode, so it must pass this check before Windows will load it. The check is a chain, and the chain has five layers. Explaining them in order matters, because each layer can fail independently, and each failure points to a different branch of the diagnosis.
| Layer | What it is | What a failure here means |
|---|---|---|
| 1. The driver file | Each driver file (a `.sys` file) has a hash value computed from its contents. Change one byte of the file and the hash changes. | The file has been altered or damaged since it was signed. The signature no longer matches the file. |
| 2. The signature | The publisher signs the hash with a private key. The signature can be embedded inside the file itself, or stored in a catalog file (`.cat`), which signs a whole set of driver files at once. | The signature is missing, was made with a key Windows does not recognise, or does not match the file's current hash. |
| 3. The certificate chain | The certificate used for the signature must chain upward, step by step, to a root certificate that Windows trusts. Microsoft's Windows Hardware Compatibility Program (WHCP) signing is the normal route for a production driver. | A certificate in the chain is missing, has expired, or has been revoked, so the chain is broken even though the signature itself looks intact. |
| 4. The load-time check | Windows recomputes the hash, checks the signature, and walks the certificate chain at the moment the driver loads, on this machine, in its current state. | Verification fails on this machine even though the same driver package loads on another machine. The machine's state, not the driver, is the problem. |
| 5. Secure Boot (the boot chain, a different layer) | Secure Boot verifies the boot chain: UEFI firmware, then the bootloader, then the kernel. It does not verify drivers at load time. | A Secure Boot problem and a driver signature problem are two different failures. One does not cause, and does not fix, the other. |
A signature proves two things only: that the file has not been changed since it was signed, and who signed it. It does not prove that the driver is free of bugs, that it matches this version of Windows, or that the certificate chain behind it is complete. Verification happens at load time, on this machine. The same driver package can load on one computer and produce Code 52 on another, because the second machine's clock is wrong, its certificate store is damaged, or its catalog file is missing. That is why roughly half of a Code 52 diagnosis has nothing to do with the driver itself, and everything to do with the state of the machine doing the checking.
Certificate policy also changes over time. Older cross-signing arrangements, under which a driver signed with a vendor certificate and a Microsoft cross-certificate was accepted, are subject to the rules in Microsoft's Driver Signing Policy, and the exceptions that still apply are narrow — for example, a machine upgraded from an earlier release of Windows, or a machine with Secure Boot switched off. Per Microsoft official documentation, the details of which signatures are trusted depend on the Windows version, the Secure Boot state, and the current policy. This guide does not state any specific date on which a policy changed, because the policy itself is the authority and it is updated by Microsoft. What matters for diagnosis is the principle: an older driver that once loaded can stop loading after a Windows update changes the trust rules, without the driver file itself changing at all.
The Seven Cause Branches
Code 52 has seven distinct cause branches. They are not seven ways of saying the same thing; each one is a different broken link, with a different trigger and a different test. Work through them as branches, not as a single answer.
| Branch | Mechanism | Typical trigger |
|---|---|---|
| 1. Driver file altered or damaged | The file's contents changed, so its hash no longer matches the signature. | A modified driver (for example, a mining-modified driver build), a download interrupted partway, or a third-party tool that "optimised" the driver files. |
| 2. Catalog file (.cat) missing or damaged | The signature lives in the catalog file. If the catalog is missing or damaged, there is nothing to verify against. | Installing a driver by copying files by hand instead of using the official installer, so the catalog is never registered; or damaged system files. |
| 3. Certificate expired or revoked | The signing certificate has passed its validity period, or has been revoked by the issuer or by Microsoft. | A very old driver paired with a current system; a revocation list update that invalidates an older signature. |
| 4. System clock wrong | Certificate validity is judged against the system clock. If the clock is far enough out, a valid certificate is treated as expired or not yet valid. | A dead CMOS battery that sends the date back to the year the machine was made; a dual-boot setup or a manually changed clock. |
| 5. Certificate chain incomplete or untrusted | An intermediate certificate is missing, or the signing certificate is not on a chain Windows trusts. | A self-signed or test-signed driver; an older cross-signed certificate that a current Windows version no longer trusts; an enterprise or test-environment certificate. |
| 6. Secure Boot / UEFI setting conflict | The boot chain's requirements and the driver chain's requirements do not line up, for example in a pure UEFI plus Secure Boot environment with an old driver or old firmware. | A new motherboard paired with an old card or old driver; a change to the CSM (Compatibility Support Module) setting that alters how the driver behaves. |
| 7. Graphics card firmware modified (vBIOS signature) | The official driver checks the card's firmware signature. A card whose vBIOS has been modified is refused. | A modified-vBIOS AMD card: the official driver refuses to load because the BIOS signature does not pass. This is a firmware-layer signature, not a driver-layer signature, and it is a different layer from the rest of this guide. |
Note the boundary in branch 7. A modified vBIOS is a firmware signature problem, and this guide borrows only that one observation as a boundary marker; the firmware side of the story belongs to the guide on modified vBIOS cards. Similarly, the Secure Boot requirement that a graphics card's GOP (Graphics Output Protocol) carry a signature is a boot-layer matter, not a driver-layer one. Keeping the layers apart is what makes the diagnosis work: a boot-chain failure and a driver-chain failure look similar from the outside, but they are tested in different places.
Code 52 vs Code 31, Code 10 and Code 43
Code 52 is often confused with three neighbouring Device Manager codes. They are not interchangeable, and using the wrong code's troubleshooting flow wastes the whole diagnosis. The four codes start at different points.
| Code | What it means | Where the problem sits |
|---|---|---|
| Code 52 | Windows cannot verify the digital signature for the drivers required for this device. | Signature verification at load time. The cause is already narrowed to the signature layer: the file, the catalog, the certificate chain, the clock, or the firmware. |
| Code 31 | Windows cannot load the drivers required for this device. | Loading itself failed. The cause is still broad: damaged files, incompatibility, or a signing problem are all possible, and signing is only one of them. |
| Code 10 | This device cannot start. | The driver loaded, but the device would not start. The problem is past the loading stage. |
| Code 43 | Windows has stopped this device because it has reported problems. | The driver loaded and the device started, then stopped during operation. The problem is in running, not in loading. |
The practical rule is simple: if the code is 52, use this guide. If the code is 31, 10, or 43, the diagnosis belongs to the guide that covers those codes, and the signature chain is at most one branch of that guide rather than its subject. A code that changes during diagnosis is itself diagnostic information: if Code 52 becomes Code 31, 10, or 43 after a step, the signature layer has been passed and the next layer has surfaced. Record the change; it tells you where the boundary moved.
Why a Signed Driver Can Still Fail
Seeing a signature on a driver file does not mean the driver will load. Four separate gaps explain why.
First, the signature may live only in the catalog file. Some drivers are catalog-signed: the individual `.sys` file carries no signature of its own, and the signature sits in the `.cat` file instead. A file with no Digital Signatures tab in its Properties window is not automatically an unsigned driver; it may be catalog-signed, and the catalog is where the signature lives. Judging a driver unsigned from one file's Properties window alone is a mistake this guide returns to below.
Second, the chain behind the signature may be broken. A signature that is genuine and intact still fails if an intermediate certificate is missing from the machine, or if the certificate has expired or been revoked since the driver was signed. The file is unchanged; the trust around it has changed.
Third, the machine's own state is part of the check. The system clock, the certificate store, and the system files that hold the catalog are all local. A wrong date, a damaged certificate store, or a missing catalog registration can each turn a good driver into a Code 52 on this machine alone.
Fourth, the driver may be signed and still be the wrong driver for this Windows version. A signature says nothing about compatibility. A signed driver that is not built for this Windows build can load cleanly through the signature check and then fail for an entirely different reason — but that failure will carry a different code, not Code 52. The signature check and the compatibility check are separate gates, and passing one says nothing about the other.
Step-by-Step Diagnosis
Work through the steps in order, changing one variable at a time. Each step states what it proves and what it does not prove. Do not skip ahead to a favourite explanation, and do not change several things at once: if the code clears after three simultaneous changes, there is no way to know which one mattered, and the next time it appears the diagnosis has to start over.
Step 0: Read the code first — confirm it really is Code 52
In Device Manager, open the graphics card's Properties and read the full Device status text and problem code on the General tab. Do not rely on the yellow exclamation mark alone; write down the exact code.
What this proves: the problem is narrowed to the signature verification layer. What it does not prove: which link in the chain is broken. That is what the steps below establish, one link at a time. If the code is 31, 10, or 43, this is not the right guide; use the guide for those codes instead.
Step 1: Match the timing — did Code 52 appear after a change, or out of nowhere?
Ask what changed just before the code appeared: a driver change, a Windows update, moving the machine, a CMOS battery change, or a third-party driver tool being run.
- After a driver change, lean toward branches 1, 2, and 5 (file, catalog, or chain).
- After a Windows update, lean toward branches 3 and 5 (a revocation list update, or an older signature no longer trusted). Do not write this as "the update delivered an unsigned driver": drivers distributed by Windows Update are themselves signed, so an update that produces Code 52 points at the trust layer, not at an unsigned delivery.
- With no change at all, lean toward branch 4 (the clock moved), branch 2 (system files damaged), or branch 3 (a certificate reached its expiry date).
What this proves: timing is a clue, not a verdict. A change that happened just before the code appeared is a lead; it is not proof of cause.
Step 2: Look at the driver file's own signature state — no extra software needed
In Device Manager, open the graphics card's Properties, go to the Driver tab, and choose Driver Details to see the `.sys` file paths. Then, in File Explorer, right-click one of those files, choose Properties, and look for a Digital Signatures tab.
- A Digital Signatures tab listing a signer and a timestamp means the file itself carries a signature. The problem is more likely in the catalog, the chain, or the clock (branches 2, 3, 4, or 5).
- No Digital Signatures tab means the file itself carries no signature, which leans toward branches 1 or 2 (the file was altered, or the installation method was wrong).
What this proves: whether the file layer carries a signature. What it does not prove: a signature on the file does not mean the load-time check will pass, because the catalog, chain, and clock links are still untested. And a missing tab does not condemn the driver, because a catalog-signed driver keeps its signature in the `.cat` file rather than in the individual file. Never declare a driver unsigned on the strength of one file's Properties window.
Step 3: Check the system date and time — the cheapest, fastest, most easily missed check
Look at the system clock. Is the year and date correct? A dead CMOS battery is the classic cause: the date jumps back to the year the machine was manufactured, and every certificate is then judged against a date years in the past.
If the date is wrong, correct the date and time, restart, and check whether Code 52 is still there. If it clears, branch 4 is confirmed: the certificate validity judgement was wrong because the clock was wrong.
What this proves: a corrected clock that clears the code confirms the clock branch. What it does not prove: a correct clock does not rule out a certificate problem (branches 3 and 5 remain possible), and a wrong clock may be a coincidence — the test is whether Code 52 actually disappears after the correction.
Step 4: Check the Secure Boot state and the test-signing state — read-only checks only
Open System Information (`msinfo32`) and look at the Secure Boot State line, which reports On, Off, or Unsupported. Then, in an elevated Command Prompt, run the read-only command that lists the current boot configuration (`bcdedit /enum`) and look for whether a testsigning entry is present. This step is a read-only inspection: it shows the current state and nothing more.
- Secure Boot on, paired with an old card or old driver, leans toward branch 6 (boot chain versus driver chain conflict). Remember the boundary: Secure Boot's GOP signature requirement is a boot-layer matter, and it must not be mixed up with the driver layer.
- Test signing switched on means the machine was at some point put into test mode. A test-signed driver loads in test mode and produces Code 52 in normal mode, so a machine found in test mode is itself a clue pointing at branch 5 (the driver is not formally signed).
What this proves: the current boot and test-signing state. What it does not prove: switching Secure Boot off does not switch driver signature checking off — the two mechanisms are independent, and 64-bit Windows still checks driver signatures with Secure Boot off. Test signing being on does not mean the driver is safe; test signing only relaxes the check, it does not verify that a driver is harmless. Test mode is a development and testing facility, not a repair, and it is not recommended for general users. This guide gives no instructions for switching test signing on or off, and no instructions for disabling signature enforcement in any form, because removing the check removes the protection that stops untrusted kernel-mode code from loading. The correct direction is always to find a properly signed driver, not to remove the check that caught the problem.
Step 5: Clean reinstall of the official driver as a controlled test
Use Display Driver Uninstaller (DDU) in Safe Mode to clean out the existing driver, then download the complete installer from the graphics card manufacturer's own website and install it cleanly. Do not use a third-party one-click driver tool for this test: such tools can install the wrong version or an incompatible driver, which makes Code 52 harder to trace, and a test is only useful if one variable changes at a time. The full DDU procedure belongs to the site's TDR guide; this guide uses it only as a controlled test, one line, not a rewritten tutorial.
- If Code 52 clears, lean toward branches 1 and 2 (the old installation's files or catalog were damaged).
- If Code 52 remains, the driver file layer is less likely to be the problem, and the diagnosis moves to step 6 (chain, clock, and system layers).
What this proves: whether a clean, official installation behaves differently from the old one. What it does not prove: a clean reinstall that works does not mean the old driver had a bug — the old installation may simply have been damaged. A clean reinstall that fails does not mean the hardware is faulty — Code 52 is not a hardware verdict in the first place.
Step 6: Check system files
Run the System File Checker (`sfc /scannow`) from an elevated Command Prompt. This is a general Windows step, not a graphics-card-specific one, and it should be described as such. If it finds and repairs damaged system files, restart and check Code 52 again; a code that clears points toward branch 2 (catalog or system file damage).
What this proves: whether protected system files were damaged. What it does not prove: a clean result does not rule out the system layer, because damage to the certificate store is not necessarily within what the System File Checker covers.
Step 7: Cross-test on another machine
Install the same official driver package on a different Windows computer with the same model of graphics card, or fit a known-good graphics card into this machine.
- If the driver loads on the other machine with no Code 52, the problem follows this machine (chain, clock, or system state), not the driver.
- If the other machine also shows Code 52, the problem follows the driver package or the card's firmware (branches 1, 5, or 7), and the next questions are about the driver source and the firmware state.
What this proves: whether the fault travels with the machine or with the driver and card. What it does not prove: a cross-test is only valid if the two machines run similar Windows versions. Comparing a Windows 10 machine with a Windows 11 machine introduces a second variable, because the signature policy itself differs between versions.
Step 8: Treat a change in the code as diagnostic information
After every step, re-read the Device status. If Code 52 becomes Code 31, 10, or 43, the signature layer has been passed and the next layer has surfaced. If Code 52 disappears but the card still does not behave normally, record that too; the signature problem is gone, and whatever remains is a different problem with its own guide. The code changing is itself diagnostic information — it marks where the boundary moved.
Edge Cases
These situations produce the same symptom with a different cause, and each one needs to be separated out rather than folded into the main flow.
An old card with a new Windows version. A manufacturer may no longer sign new drivers for an old card, but that does not mean the old card must produce Code 52. An older signed driver whose chain is complete can still load. "Old" does not mean "cannot be signed". In the other direction, an old driver signed under an older cross-signing arrangement may no longer be trusted on a current Windows version — a certificate policy change, not a fault in the driver itself. The rule is to check the manufacturer's official support list for the card, and not to guess from the year the card was made.
A card with a modified vBIOS. The official driver checks the firmware signature, and a modified vBIOS is refused. The distinguishing check is to look at the BIOS version in GPU-Z and see whether it matches an official release. If the firmware is suspected of being modified, the direction is the firmware layer, not the driver signature chain. This guide notes the boundary and stops there; the firmware side belongs to the modified-vBIOS guide.
Code 52 after a Windows Update. Drivers distributed by Windows Update are signed, so the update did not deliver an unsigned driver. Code 52 after an update points at the trust layer: a revocation list update, or an older signature that is no longer trusted. Two questions must be answered separately: which driver version was in use before the update, and did the driver version change after the update? Conflating them hides the branch.
A machine left in test-signing mode. If a machine has been running in test mode for a long time, a test-signed driver loads. Switch back to normal mode and the same driver produces Code 52. This is not a case of something being fixed and then breaking again; it is the difference between the two modes. Test mode is not a normal operating state and must not be treated as a long-term solution.
A company or school computer (MDM or Group Policy). Device installation restriction policies can affect driver loading. On a company machine, ask the IT department first and do not change policies yourself. This is a boundary note, not a procedure.
Code 52 with a picture still on the screen. The system is running on the Microsoft Basic Display Driver, which provides output without loading the graphics driver. A picture on the screen does not mean the graphics driver loaded; the error code is the evidence, not the presence of a picture.
When the code is not 52. Code 31 (loading failed, cause not yet narrowed), Code 10 (failed to start), and Code 43 (stopped during operation) each belong to their own guides. This guide covers only the signature-verification branch.
Common Misconceptions
| Misconception | Correction |
|---|---|
| "Switching Secure Boot off switches signature checking off." | Wrong. The two are independent. Secure Boot verifies the boot chain; kernel-mode code signing checks drivers on 64-bit Windows, and it keeps running with Secure Boot off. |
| "A driver that will not install must be unsigned." | Wrong. A driver can fail to install for many reasons. Code 52 is the specific code for signature verification failure. Codes 31, 10, and 43 each mean something different, and they must not be mixed together. |
| "Just switch off signature enforcement and the problem is solved." | Wrong, and this guide does not give instructions for doing it. Switching off signature enforcement removes a barrier against malicious drivers, after which any unsigned or unknown driver can load. The correct direction is to find a properly signed driver, not to remove the check. Test mode is a development facility, not a user repair method. |
| "A signed driver cannot have a problem." | Wrong. A signature proves only that the file is unchanged since signing and who signed it. It does not prove the driver is free of bugs or right for this Windows version. A driver can pass the signature check and still have bugs; those belong to other guides. |
| "Code 52 means the card is dead." | Wrong. Code 52 is a driver trust-layer problem, not a hardware verdict. A wrong clock, an expired certificate, or a damaged catalog can all produce Code 52 on a card that is completely healthy. |
| "A Digital Signatures tab on the file means verification will pass." | Wrong. A signature on the file is only one link. If the catalog file, the certificate chain, or the system clock breaks, loading still fails. |
| "A third-party one-click driver tool will sort it out." | Wrong. Third-party tools can install the wrong version or an incompatible driver, making Code 52 harder to trace. A test should use the manufacturer's complete installer, changing one variable at a time. |
| "Reinstalling Windows will definitely fix Code 52." | Wrong. Reinstalling only resets the driver and system-file layers. A wrong clock, modified firmware, or a certificate policy problem survives a reinstall. Before reinstalling, Code 52 has already said the problem is in the signature verification layer. |
| "An old card will always produce Code 52." | Wrong. "Old" does not mean "cannot be signed". An older signed driver with a complete chain can still load. Check the manufacturer's official support list; do not guess from the year. |
When the Code Does Not Clear
If the eight steps point to a cause that cannot be confirmed from settings alone — for example, Code 52 persists after a clean official reinstall, a correct clock, and a clean system file check, or the cross-test shows the fault follows the card rather than the machine — the next step is a physical inspection. A shop inspection can check the card's seating, its power delivery, and whether the card behaves the same way in a different machine, which no settings change can establish.
HK GPU Fix offers a diagnostic inspection at its Shek Mun shop: Room 1209, Dali Plaza, Shek Mun. The published inspection fee range is HK$400–2,800 in total, and the actual price is subject to a post-inspection quotation. Phone 2186 8010, WhatsApp 6558 6806. There is no on-site service; inspection is carried out at the shop.
Frequently Asked Questions
What does Code 52 mean, in plain terms?
It means Windows tried to load the graphics driver and the signature check failed, so Windows refused to load it. It is not a statement that the driver has a bug or that the card is faulty. The failure can sit in the driver file, the catalog file, the certificate chain, the system clock, or the card's firmware, and the steps in this guide test each link in turn.
My screen still shows a picture. Is the graphics driver working?
Not necessarily. When the graphics driver refuses to load, Windows falls back to the Microsoft Basic Display Driver, which provides a picture without the card's normal performance or features. A picture on the screen does not mean the graphics driver loaded. Check the Device status in Device Manager; the error code is the evidence.
I switched Secure Boot off and Code 52 is still there. Why?
Because Secure Boot and driver signature checking are independent mechanisms. Secure Boot verifies the boot chain (firmware, bootloader, kernel). Driver signature checking verifies kernel-mode drivers at load time on 64-bit Windows, and it continues to run with Secure Boot off. Switching Secure Boot off was never a fix for Code 52, and it weakens the machine's boot protection without addressing the signature layer at all.
The driver file has a Digital Signatures tab. Why does it still fail?
A signature on the file is only one link in the chain. The signature may live in the catalog file rather than the file itself, an intermediate certificate may be missing, the certificate may have expired or been revoked, or the system clock may be wrong. Any one of those breaks verification at load time even though the file itself is signed. Check the date and time first — it is the cheapest test — then work through the remaining links.
The driver worked yesterday and Code 52 appeared after a Windows update. Did the update install an unsigned driver?
No. Drivers distributed by Windows Update are signed. Code 52 after an update points at the trust layer instead: a revocation list update, or an older signature that the updated policy no longer trusts. Answer two questions separately: which driver version was in use before the update, and did the driver version change after the update? That separates a trust change from a driver change.
The file has no Digital Signatures tab. Does that mean the driver is unsigned?
Not necessarily. Some drivers are catalog-signed: the signature sits in the `.cat` file that covers the whole driver set, not in the individual `.sys` file. A missing tab on one file proves nothing on its own. Check the catalog file's signature as well, and confirm how the driver was installed — a driver installed by copying files by hand may never have had its catalog registered.
I found the machine is in test-signing mode. Is that the fix?
No. Test mode is a development and testing facility that relaxes the signature check; it is not a repair and it is not a normal operating state for a general user. A machine found in test mode is a clue, not a solution: it suggests the driver in use is test-signed rather than formally signed, which points at the certificate chain branch. The correct direction is a properly signed driver from the manufacturer, not continued use of test mode.
Will reinstalling Windows fix Code 52?
Only sometimes, and it should not be the first step. Reinstalling resets the driver and system-file layers, so it can clear a damaged catalog or a damaged driver installation. It cannot fix a wrong system clock, modified firmware, or a certificate policy problem — those survive a reinstall. Work through the eight diagnostic steps first; Code 52 has already said the problem is in the signature verification layer, and the steps exist to find which link broke.