Hospital software holds some of the most private information a person can share. I found authentication flaws and exposed data in the software trusted to manage that care.

The software is e-Sushrut, a Hospital Management Information System (HMIS) developed and deployed by C-DAC. It manages patient information, hospital workflows and administrative processes in healthcare organizations.

I tested the installations at Bokaro General Hospital and AIIMS Patna. I reproduced the dashboard access, exposed activity counts and password-hashing issue at both. The findings led to three CVEs.

Bokaro’s login page linked to its hospital dashboard. I opened it without signing in. The server returned the dashboard page and its report information.

I could see real patient activity data without logging in. It was already present in the public login HTML.

The password code used an odd-looking Java object string.

Captured hospital names, hostnames, identifiers, activity figures and token suffixes are redacted in the examples. The code and field order are preserved.

These captures are from September 1, 2026. I reported the issues to CERT-In, which later relayed the organization’s fix confirmation.

The assigned CVEs:

Patient privacy was the bigger concern

An HMIS handles patient information, registration, clinical workflows and administration.

A failure in its access controls threatens the boundary around confidential personal and medical information.

The dashboard flaw let me reach report information without signing in. The login page also disclosed hospital activity.

The password-hashing design allowed offline guessing if an attacker first captured a submitted hash, username and token.

An unchecked patient-report action could expose sensitive patient information. A compromised staff account could expose the records it was allowed to read.

Those are potential paths to patient-data exposure. The evidence here establishes dashboard access and operational-data disclosure; it does not establish that I retrieved individual patient records.

I could open the dashboard without signing in

CVE-2026-124643 · High · CVSS 4.0: 8.7
improper authentication

Bokaro’s login page used the /AHIMSG5/hissso/ path. I checked its forms, JavaScript files and links. One link pointed to the dashboard:

The dashboard link in the landing HTMLCode excerpt
<a href="/HISUtilities/dashboard/dashBoardACTION.cnt?groupId=NQ==&amp;dashboardFor=SE1JUw==&amp;hospitalCode=REDACTED&amp;seatId=REDACTED&amp;isGlobal=1&amp;isPreview=0">…</a>
The link from the public page. Link text is left out. The &amp; spelling comes from the HTML.

The page gave me the full address and its URL parameters. I used that address in a separate request. I sent no username, password or saved login cookie.

Historical unauthenticated requestSeptember 1, 2026
GET /HISUtilities/dashboard/dashBoardACTION.cnt?groupId=NQ==&dashboardFor=SE1JUw==&hospitalCode=REDACTED&seatId=REDACTED&isGlobal=1&isPreview=0 HTTP/1.1
Host: [REDACTED]
Send
No credentialsThe request has no username, password or saved login cookie.
Select
A hospital dashboardURL parameters choose the page; they do not authenticate the visitor.
Observe
Report metadata returnedThe saved response contained the dashboard and its report information.
The September 1 request. I sent no login details or saved cookies.

What the URL parameters meant

Two values used Base64, a text encoding anyone can decode. NQ== means 5. SE1JUw== means HMIS. The dashboard HTML included both decoded values in hidden form fields.

ParameterValueWhat the response showed
groupIdNQ== → 5The HTML included name="groupId" value="5".
dashboardForSE1JUw== → HMISThe HTML set dashboardFor to HMIS.
hospitalCodeREDACTEDThe same hospital code appeared in the activity counts.
seatIdREDACTEDA value sent in the URL and copied into the HTML.
isGlobal, isPreview1, 0Page options copied into the HTML.

These values chose the dashboard. They did not prove who was asking. Anyone could copy a seatId into a URL.

The server needed to check the caller’s login and access rights before returning the page.

What came back

Selected dashboard response contentCode excerpt
HTTP/1.1 200 OK
content-type: text/html;charset=ISO-8859-1
server: Abhijaiya

<title>DASHBOARD</title>
<input type='hidden' name='rptDisplayName' id='RPTDISPLAYNAME_REDACTED' value=' OPD Count' />
<input type="hidden" name="linkTab" id='linkTab_REDACTED' value='OPD Count' />
Selected headers and HTML lines from the response. The full body was 274,427 bytes. Cookie values are left out.

The response body contained the dashboard title, report names and report IDs. The reports covered outpatient visits, emergencies, prescriptions and lab work.

An ID such as RPTDISPLAYNAME_REDACTED linked a report name to a specific part of the dashboard.

I repeated the request without a saved login. The server again returned HTTP 200 and a 274,427-byte page.

A request with Cookie: none gave the same result. The response set a new TID cookie, but I had not signed in.

Checking where the report data came from

The page loaded /HISUtilities/dashboard/js/dashboard.js. I read it to find how the reports got their data.

Each widget key had three parts: dashboard ID, section ID and report ID. The code used them to request data from the same server address:

Following a report widget into dashboard.jsCode excerpt
var key = getKeyValue(id);
var arrId = key.split("_");
var data = preparejsonForAjax(key, mode, pageNo, blockNo, loadFromDatabase);
data.isAjaxRequest = "2";
data = initSecurityParameterFromajaxjson(data);
$.getJSON('/HISUtilities/dashboard/dashBoardACTION.cnt', data, showWidgetData);
Identify
Split the widget keykey.split("_") separates the dashboard, section and report IDs.
Prepare
Build the queryThe helper packs those IDs and request options into data.
Request
Call the controller$.getJSON() asks for widget data. This code alone does not prove the request succeeded.
From callDataForSpecificWidget(). The three parts of the key become dashboardId, sectionId and rptId. Code that only changed the page’s appearance is left out.

A visitor could get the dashboard page and its report information without signing in. CERT-In recorded this as weak authentication and session checks.

The fix needs to cover the page and every action it calls. The server should check the user’s login, hospital and role.

That identity should come from the login session. An ID supplied in the URL is not proof of identity.

The login page included hospital activity counts

CVE-2026-124644 · Medium · CVSS 4.0: 6.9
sensitive information disclosure

The login HTML also had a JavaScript object named _GET_MAIN_LOGIN. Its HOSPITALS field held the hospital name and a long string of numbers:

Embedded in the unauthenticated login responseCode excerpt
const _GET_MAIN_LOGIN = {
    // Other fields omitted.
    HOSPITALS : "[[Hospital redacted, HOSPITAL_CODE#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED]]"
};
The September 1 payload structure. The hospital name, code and activity figures are redacted. Other object fields are left out.

The hospital name came first, followed by numbers separated by #. I checked the JavaScript that read the string to find out what each number meant.

The JavaScript explained the numbers

In sso_main_login.js, convertJavaArrayListToJSArray() removed the outer [[ and ]]. It split entries at ], [.

For the selected hospital, changeHospitalSelected() split the numbers at each # and copied them into named page fields:

The client supplied the field namesCode excerpt
// convertJavaArrayListToJSArray(a)
a = a.substring(2, a.length - 2).split("], [");

// changeHospitalSelected(a): selected assignments
b = a.split("#");
document.getElementById('OPDToday').innerHTML = b[1];
document.getElementById('IPDToday').innerHTML = b[3];
document.getElementById('LabTestToday').innerHTML = b[4];
document.getElementById('OPDTotal').innerHTML = b[8];
document.getElementById('IPDTotal').innerHTML = b[10];
document.getElementById('LabTestTotal').innerHTML = b[11];
Unpack
Remove the wrappersubstring() strips the outer brackets from the server value.
Decode
Split on #b[1] is today’s OPD count; b[8] is the OPD total.
Display
Write into the pageinnerHTML places each value beside its label. The data arrived before any login.
Selected lines from sso_main_login.js. You can read the captured mapping function. Comments were added; other assignments are left out.

The field names supplied the labels. Position 0 was the hospital code. Positions 1–7 were the “Today” counts; positions 8–14 were the matching “Total” counts.

OPD means outpatient visits. IPD refers to inpatient care. Rx means prescriptions.

Daily and total activity exposed in the response. Captured figures are redacted; labels come from the JavaScript.
Client metricTodayTotal
OPDRedactedRedacted
EmergencyRedactedRedacted
IPDRedactedRedacted
Lab testsRedactedRedacted
ABHARedactedRedacted
Prescriptions (Rx)RedactedRedacted
PharmacyRedactedRedacted

This short Python example reads the same format with the captured values redacted. You can run it locally:

Decode the redacted value locallyPython · local only
raw = "[[Hospital redacted, HOSPITAL_CODE#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED#REDACTED]]"
record = raw[2:-2]
name, packed = record.rsplit(",", 1)
fields = packed.strip().split("#")
assert len(fields) == 15

print(name)       # Hospital redacted
print(fields[0])  # HOSPITAL_CODE
print(fields[1])  # REDACTED: OPDToday
print(fields[8])  # REDACTED: OPDTotal
Redaction preserves all 15 field positions. This example makes no network request.

What this exposed

I didn’t need the dashboard for this finding. The data was already in the public login HTML. No form submission was needed.

I could see real patient activity data without logging in.

The no-store header tells browsers and caches not to save a response. It does not stop a visitor from reading it.

Hiding the statistics on screen would not fix this. The server needs to keep internal counts out of public login HTML and require authentication before sending them.

The password code used a Java object string

CVE-2026-124645 · High · CVSS 4.0: 8.7
static/predictable value in client-side password hashing

The same JavaScript object had a field named SESSION_TOKEN. I searched for where it was used. Bokaro’s login HTML set the value in two places:

Bokaro’s server-rendered token declarationsCode excerpt
const sessionToken = "[B@REDACTED";
const _GET_MAIN_LOGIN = {
    // Other fields omitted.
    SESSION_TOKEN : "[B@REDACTED"
};
The same value appeared in sessionToken and SESSION_TOKEN. Other object fields are left out.
Public login HTML · September 2026No login required
const sessionToken = [B@REDACTED
An array
Marks an array in Java.
Of bytes
B is the byte type code.
An object hash
The number Java prints after @. It is separate from the password hash.
The token format in Bokaro’s first saved login page. The object-hash suffix is redacted.

The [B@ prefix comes from Java. Object.toString() prints this kind of string for a byte array.

[B means “byte array.” After @ comes the object’s hash code in hex. It does not print the bytes inside the array.

The likely mistake was converting the byte-array object to text instead of encoding the random bytes inside it.

The page received the object’s label as its login token. The token did not contain the array’s contents.

Pawn-shop meme: Can I get the random bytes? Best I can do is [B@…

How the value reached the password hash

A hash turns some input into a fixed-length result. The same input gives the same result.

The page loaded ssoLogin.js. Its login routine called validate(), which called securePassword().

That function hashed the password and username, then hashed the result with sessionToken. The final hash replaced the password field. The code also set window.name = sessionToken.

Bokaro’s active function used SHA-512. An older SHA-1 version was still in the file, inside a comment. The active function was:

Bokaro: the active securePassword() codeSHA-512 · original capture
var objPassHash = new jsSHA('SHA-512', 'TEXT', 1);
objPassHash.update(
    document.getElementsByName("varPassword")[0].value +
    document.getElementsByName("varUserName")[0].value
);
hashValue = objPassHash.getHash("HEX");

var objPassHash1 = new jsSHA('SHA-512', 'TEXT', 1);
objPassHash1.update(hashValue + sessionToken);
hashValue = objPassHash1.getHash("HEX");

document.getElementsByName("varPassword")[0].value = hashValue;
First hash
Password + usernameSHA-512 turns the joined credentials into hex text.
Second hash
Hex text + tokenAnother SHA-512 pass mixes in the server-supplied object string.
Submit
Replace the passwordThe final hex hash overwrites the password field before form submission.
Bokaro’s active function on September 1. Error handling and debug comments are left out. Read the captured function.

Patna used the same steps, with SHA-1

I checked the e-Sushrut installation at AIIMS Patna. Its HTML set var sessionToken = "[B@REDACTED" in two places. Its securePassword() function used SHA-1:

AIIMS Patna: the active SHA-1 constructionSHA-1 · original capture
var objPassHash = new jsSHA(
    document.getElementsByName("varPassword")[0].value +
    document.getElementsByName("varUserName")[0].value,
    "ASCII"
);
hashValue = objPassHash.getHash("SHA-1", "HEX");
objPassHash = new jsSHA(hashValue + sessionToken, "ASCII");
hashValue = objPassHash.getHash("SHA-1", "HEX");
document.getElementsByName("varPassword")[0].value = hashValue;
From Patna’s September 1 output. Error handling and debug comments are left out.

Bokaro General Hospital

SAIL · original login HTML

[B@REDACTED

AIIMS Patna

Original login HTML

[B@REDACTED
Both sites used a Java object string in the second hash. Bokaro used SHA-512; Patna used SHA-1. Token suffixes are redacted.

Both sites followed these steps:

What the browser computesConstruction
p = password
u = username
t = sessionToken
H = SHA-512 at Bokaro; SHA-1 at Patna

inner     = hex(H(p || u))
submitted = hex(H(inner || t))
Inputs
p, u and tPassword, username and the token from the login page.
Transform
Two fast hash roundsThe second round hashes the first round’s hex text joined to the token.
Consequence
Guesses can stay offlineAfter capturing a submitted hash and its username and token, an attacker can compare password guesses locally.
|| means “join these strings.” The second round uses the first hash as hex text.

The first hash becomes hex text: 128 characters for SHA-512 or 40 for SHA-1. The second hash takes that text followed by the token.

If the password, username and token stay the same, the result stays the same too.

Why the object string mattered

The browser hashed the Java object label. Generating random bytes would not help if the page received the label instead of those bytes.

The challenge should carry the actual bytes in an encoding such as Base64. Its security also depends on how the server creates and checks it.

A login token can be public

A server can send a fresh random value with each login attempt. This is called a nonce or challenge, and the browser can read it.

The server must remember which attempt it belongs to and check it when the form comes back.

Try both algorithms below. Keep the token the same or change it for each attempt to see what happens to the hash.

The second hash uses the first hash as hex text.

What an attacker would need

Suppose an attacker captures a user’s submitted hash, username and token.

They can guess a password locally, run the same two hash steps and compare the result with the captured hash.

They do not need to send each guess to the hospital. This is offline password guessing.

A fresh token does not stop those guesses once the attacker has captured it too. It changes the submitted hash, but does not make each guess slow.

Both SHA-1 and SHA-512 are fast in this two-round setup.

The server should issue a fresh challenge, tie it to a login attempt, and check its expiry and reuse rules.

Stored passwords need a dedicated password-hashing function that makes guesses slow. Adding another fast hash in the browser does not replace these steps.

AIIMS Patna had the same three issues

I reproduced the dashboard access, exposed activity counts and password-hashing issue at AIIMS Patna as well as Bokaro.

The request and counter-mapping examples use saved Bokaro responses. The password-code excerpts show both installations.

The outpatient department building at AIIMS Patna, with its name above the entrance.
AIIMS Patna’s outpatient department. Context photograph from 2018, not an incident capture. Photo: AIIMS Patna, via Wikimedia Commons, CC BY-SA 4.0. Converted to WebP.

Reporting the issues

I sent the findings and steps to reproduce them to CERT-In on September 1. On September 18, CERT-In passed on this fix confirmation:

“the concerned organization has confirmed that, the reported vulnerabilities are fixed.”

CERT-In correspondence · September 18, 2026
  1. I sent the reports and steps to reproduce the issues to CERT-In.
  2. CERT-In passed on the fix confirmation and acknowledged my report.
  3. I followed up on the CVE requests.
  4. CERT-In published the vulnerability note and three CVE records.
A smiling man giving a thumbs-up.
thank you CERT-In

Severity ratings are CERT-In’s CVSS 4.0 base scores, published in the linked CVE records.

CVE-2026-124643
Dashboard authentication and session validationImproper authentication
8.7HighCVSS 4.0
CVE-2026-124644
Hospital operational data in the login responseSensitive information disclosure
6.9MediumCVSS 4.0
CVE-2026-124645
Static value in client-side password hashingPublished as a hardcoded cryptographic key vulnerability
8.7HighCVSS 4.0

More research: Hacking GISEC Before Speaking at GISEC · JEE Advanced’s exposed cloud storage