- What: India's CERT-In published note CIVN-2026-0557 on November 17, 2026, with three CVEs in e-Sushrut, the Hospital Management Information System built by C-DAC and run at government hospitals. All three are unauthenticated and need no account.
- The flaws: a dashboard that answers unauthenticated requests (CVE-2026-124643, CVSS 8.7), live hospital operational counters embedded in the login page's HTML (CVE-2026-124644, CVSS 6.9), and a static, predictable value used in the client-side password hashing (CVE-2026-124645, CVSS 8.7).
- Why it matters here: every one of them trusts what the browser sends instead of a session the server controls. That is the same mistake that leaves an OT or water management console open, and the same mistake nobody catches without access logs.
- Status: C-DAC confirmed to CERT-In that the reported issues are fixed. Operators still have to confirm their own build is patched, because the records name "previous versions" and no fixed version number.
On November 17, 2026 India's national CERT (CERT-In) released vulnerability note CIVN-2026-0557 and three CVE records for e-Sushrut, the Hospital Management Information System developed by C-DAC (the Centre for Development of Advanced Computing) and deployed across government hospitals. The research is credited to Rylen Anil, who reported the findings to CERT-In on September 1 and was told on September 18 that the vendor had fixed them.
None of the three needs a password. Each is rated by CVSS v4 as remotely exploitable by an unauthenticated attacker, two of them High at 8.7. Read together they are not three unrelated bugs. They are one habit: the application trusts the client.
The three flaws, as CERT-In records them
CVE-2026-124643: an unauthenticated dashboard (CVSS 8.7)
CERT-In: the flaw "exists in e-Sushrut HMIS due to insufficient authentication and session validation in the dashboard functionality." An unauthenticated attacker sends crafted HTTP requests to the dashboard endpoint and the server answers with the dashboard, including report names and identifiers. The researcher's write-up shows the login page itself linking to the dashboard route, which returned an HTTP 200 and a full dashboard page to a request that carried no login and no cookie. The parameters in the URL, which hospital, which group, which report, decided what was shown. They did not decide who was asking.
CVE-2026-124644: operational statistics in the login page (CVSS 6.9)
CERT-In: the login page's HTML carries "internal hospital operational statistics" in an embedded data structure, readable by anyone who loads the page and reads the source. The researcher found a block of counters that client-side JavaScript maps to labels: outpatient and inpatient numbers, emergency, lab tests, prescriptions, pharmacy, for today and in total. No individual patient records were retrieved, but a visitor who never logs in learns how busy the hospital is, by department, in real time.
CVE-2026-124645: a static value in client-side password hashing (CVSS 8.7)
CERT-In: a "static and predictable value" is used in the client-side password hashing, embedded in the login page where any unauthenticated user can read it. The browser hashes the password with this fixed value, so the value is not the per-login, unpredictable challenge that a login should use. CERT-In records it as a hardcoded cryptographic key. The practical effect: an attacker who captures one submitted login can reproduce the hashing offline and test password guesses at their own pace, because the one moving part that should have made each attempt unique never moved.
One root cause: the client is not the authority
A login page is a public document. Anyone can fetch it, read every line of its HTML, and watch every request it makes. So nothing a login page hands the browser is a secret, and nothing the browser hands back can be trusted on its own. e-Sushrut broke that rule three ways at once:
- the dashboard decided what to show from URL parameters rather than from a server-side session, so changing the URL changed the answer;
- the login page shipped real operational data to a visitor who had not authenticated;
- the step that was supposed to make each login unique was a fixed value printed in the page, so it made nothing unique.
The correct version of all three is the same sentence: decide access from a session the server issues and controls, never from an id, a value or a counter the client supplies. CERT-In's own guidance on the dashboard says exactly that, the server should check the caller's login, hospital and role from the session, not from the URL.
This is not only a hospital problem
e-Sushrut is a management console for a healthcare operation, and healthcare delivery is critical infrastructure. But the shape of this failure is the one we find again and again on the operational side, in water, energy, manufacturing and building automation:
- A management interface that trusts the URL. The SCADA HMI, the building-automation dashboard, the meter head-end and the device web page are frequently reached by a crafted request that was never checked against a session. We wrote the same finding up on CIRCUTOR PowerStudio SCADA, where an
alg=nonetoken let the server accept an unsigned pass, and on the Danfoss AK-SM 800A. - Information handed out before login. A device or console that discloses its state, its inventory or its activity to an unauthenticated request is giving an attacker the map before the break-in.
- Authentication that depends on a value in the page. Hardcoded keys, static tokens and predictable challenges are endemic to embedded and operational software, where the login was bolted onto a device that was never meant to face a network.
And the thread that ties the hospital to the water plant: in both places the management system is the one nobody is watching. There was no attacker in this story, a researcher found it, but had there been one, nothing in e-Sushrut would have recorded a stranger reading the dashboard, because the application did not know a stranger from a clinician. That is a logging problem, and it is the one we solve.
What detection looks like
None of these three flaws trips an alarm on its own, because to the server the malicious request looks like a normal one. What separates them from normal use is context that lives in the logs, if the logs are kept and read:
- a request to a management or dashboard endpoint that returned a full page with no preceding authenticated session for that client;
- enumeration: one source walking through hospital codes, group ids or report ids in the URL;
- reconnaissance on the login page: repeated fetches of the login HTML from one source that never completes a login, the signature of someone harvesting the embedded data or the hashing value;
- a burst of failed logins that reuse a captured hash rather than typing a password.
Every one of those is an ordinary web and application access log line. The detection is not exotic. The hard part is having the logs at all, from the system nobody instruments, and keeping them long enough to answer the question weeks later.
Where RedEye and Caver fit
Caver is built for exactly this gap: bring the web, application, authentication and access logs from every system into one searchable place, including the management console that was bolted onto a device or an inherited platform, and keep them long enough to answer who reached what. On top of that, RedEye's detection feed supplies the rules that turn the log lines above into alerts, a dashboard endpoint answering an unauthenticated client, id enumeration in a management URL, a login page scraped without a login. A new dashboard read on a forgotten console raises an alert instead of a CERT note two months later.
It is the same foundation CISA lays out in its Logging Reference Architecture, which we map to Caver at getcaver.com/cisa-logging. A hospital HMIS, a water SCADA console and a building-automation front end share one problem: the system that runs the operation is the one with no record of who touched it. Caver gives it that record, and runs the detections that read it.
RedEye assessment
The disclosure is handled well, reported privately, fixed by the vendor, published through the national CERT with CVEs. The lasting lesson is not any one of the three bugs. It is that a login page is public, so authority has to live on the server, and that the only thing standing between a flaw like this and a quiet breach is a log that noticed. e-Sushrut had the flaw and, by its own design, could not have had the log. That is the exposure we close, on hospital systems and on the OT consoles that fail the same way.
Two cautions. The CVE records name "previous versions" with no fixed version string, so "patched" is not a status an operator can take on faith; confirm the running build against C-DAC's advisory. And the researcher did not retrieve individual patient records, so the confirmed exposure is operational data and dashboard metadata, not PHI, though the records themselves sit behind the same authority the dashboard failed to enforce.
Questions about your exposure?
RedEye Security provides assessments for organizations that need to understand their real risk, on IT and OT.
Talk to us