Instructure Canvas Breach (April–May 2026)
On 22 April 2026, someone who had signed up for a free Canvas account opened a support ticket. The ticket had a linked file with hidden code in it. Three days later a Canvas customer service representative opened that ticket, and the code ran inside the rep's logged-in session. For the next several days the attacker used the rep's privileges to call Canvas APIs and take usernames, email addresses, course names, enrolment records and in-product messages from Canvas, the learning management system (LMS) that thousands of schools and universities around the world use (Instructure customer FAQ; On EdTech).
The extortion group ShinyHunters claimed the attack. Instructure said on 6 May that the incident was resolved. On 7 May, in the middle of end-of-term exams, the same attacker got back in through a second, unpatched XSS bug. This time it used Canvas's own custom-theme feature to replace school login pages with a ransom note. Instructure took Canvas offline. On 11 May it said it had "reached an agreement with the unauthorized actor" and that the data had been destroyed (Instructure incident update).
The data stolen is less sensitive than in many breaches: no passwords, grades or financial data. What makes this one worth studying is the path. A free tier ran in the same production environment as paying schools. A help-desk form that anyone could fill in was rendered inside a privileged internal tool. And the support session it hijacked could reach across tenants. Each of those choices is common, and together they turned one support ticket into a breach across the whole platform.
TL;DR
- What: Data was taken from Instructure's multi-tenant Canvas LMS, and about a week later login portals were defaced with an extortion note.
- Who: ShinyHunters, a financially motivated data-extortion group, claimed it publicly. Instructure calls it "a cybercriminal organization known for large-scale attacks across multiple sectors" (incident update).
- How (confirmed by Instructure): The attacker opened a Free-for-Teacher account and submitted a support ticket containing malicious code. When a support agent opened the ticket, an XSS vulnerability let the attacker "obtain an authorization token" and gain elevated access inside Canvas. On 7 May, a second unpatched XSS in the discussion feature was used, this time obtaining a token "using the OAuth flow". The ransom note was then pushed "via CSS in a Canvas custom theme" (customer FAQ).
- Data (confirmed): usernames, email addresses, course names, enrolment information and messages, plus API provisioning records, user reports and DAP messaging data. Instructure says core learning data (course content, submissions, credentials) was not involved (incident update).
- Scale: disputed. ShinyHunters claimed about 275 million users, 3.65 TB of data and nearly 9,000 schools. A ShinyHunters member told TechCrunch the haul held 231 million unique email addresses. Instructure has not published a total.
- Outcome: Instructure reached an undisclosed agreement with the attacker, got the data back and received "shred logs". It then permanently shut down the Free-for-Teacher programme, added rate limits and network restrictions to admin access, and started removing lifetime tokens.
- Lesson: Anything an anonymous user can submit and a privileged employee will later view can become a path into every customer. Treat help-desk content as hostile, keep free tiers away from paid production, and make sure support roles cannot read every tenant's data in bulk.
The Alert
Instructure says it detected unauthorized activity in Canvas on 29 April 2026 (incident update). It has not said publicly what raised the alarm, whether that was an internal detection rule, a customer report or an outside tip. That gap matters, because by Instructure's own account the support representative opened the malicious ticket on 25 April and the API-driven data collection ran from 28 to 30 April (On EdTech). So about four days passed between the first code execution in a privileged session and detection.
The second intrusion was caught much faster. Instructure says the ransom-note theme was "detected and disabled approximately 10 minutes after it began" (customer FAQ). BleepingComputer reported that the defacements stayed visible for roughly 30 minutes before they were taken offline (BleepingComputer). The two figures may be measuring different things: time to detection versus time until every cached login page and mobile app view was clean. The page treats both as reported, not reconciled.
Why this one hit so hard
Canvas is the system schools run day to day. Students submit work through it, teachers post exams in it, and its login page is often the first thing a student sees each morning. The 7 May defacement and the outage that followed came during end-of-semester exams at many institutions. Some Australian universities and education departments kept Canvas switched off for days afterwards (Wikipedia summary of ABC and other reports).
Impact
What is confirmed by Instructure and what is only claimed by the attacker need to stay separate. The numbers differ by an order of magnitude.
Confirmed by Instructure
| Item | Detail | Source |
|---|---|---|
| Data fields involved | Usernames, email addresses, course names, enrolment information, messages | Incident update |
| Additional data | API provisioning records, user reports, DAP messaging data | Incident update |
| Not involved | Core learning data (course content, submissions, credentials). No evidence of passwords, dates of birth, government IDs or financial data | Incident update, FSA alert |
| Enrolment information means | Links between users and courses, terms or sections, including enrolment status and role type | Customer FAQ |
| 7 May defacement reach | Ransom note visible to "roughly 300 organizations" | Customer FAQ |
| Data taken on 7 May | "We have not found evidence that data was taken during the May 7 activity" | Customer FAQ |
| Systems outside Canvas | CrowdStrike found "no evidence to date that any system outside of Canvas was affected" | Customer FAQ |
Claimed or reported, not confirmed by Instructure
| Claim | Who says so | Status |
|---|---|---|
| About 275 million users affected | ShinyHunters | Unverified. Instructure has not confirmed it (Wikipedia) |
| 3.65 TB of data | ShinyHunters | Unverified |
| 231 million unique email addresses | A ShinyHunters member, speaking to TechCrunch | Unverified. TechCrunch called it "unique emails" on 5 May and "231 million people" on 7 May (TechCrunch, 5 May; TechCrunch, 7 May) |
| About 8,800 schools (8,809 per Reuters) | ShinyHunters' list | TechCrunch could not confirm that every institution on the list was affected, or even an Instructure customer |
| About 330 institutions defaced | BleepingComputer reporting | Close to, but not the same as, Instructure's "roughly 300 organizations" (BleepingComputer) |
| Instructure's Salesforce instance also breached in 2026 | ShinyHunters | Not confirmed by Instructure. Instructure did disclose a separate, earlier social-engineering compromise of its Salesforce instance in September 2025, which it says did not reach Canvas product data |
| Ransom amount of about US$10 million | Unsourced rumour | Unverified. Instructure did not disclose any payment amount or terms |
Reading breach numbers
Extortion groups inflate their numbers because a bigger number means more pressure to pay. Vendors understate them because forensic review is slow and legal exposure is large. Canvas has on the order of 30 million active users, and the 275 million figure probably counts every account ever created across every institution's history, including duplicates. Neither number is "the truth" until the forensic review that Instructure says was completed on 29 September 2026 is published per institution. Instructure says those findings go only to affected institutions, not to the public (incident update).
Operational impact
- Canvas was put into maintenance mode on 7 May. Instructure said on 9 May that it was "fully back online" (incident update).
- The attacker also "disrupted authentication provider configurations", so some users saw the native Canvas login page instead of their school's SSO. Instructure restored the SSO configurations "to their last known secure state" before Canvas came back (customer FAQ).
- Several institutions, especially in Australia and the Netherlands, cut their Canvas integrations or kept the service off for days as a precaution (Wikipedia, citing ABC and NOS).
- Regulators and lawmakers got involved. The US Department of Education's Federal Student Aid office issued a security alert to institutions (FSA). The House Homeland Security Committee requested a briefing (letter, 11 May 2026). A proposed class action was filed on 13 May (Wikipedia).
Timeline
sequenceDiagram
participant SH as ShinyHunters
participant FFT as Free-for-Teacher account
participant HD as Support tooling
participant Rep as Support representative
participant API as Canvas APIs
participant IN as Instructure security
participant Schools as Schools and students
Note over SH,FFT: 22 April — staging
SH->>FFT: Sign up for a free teacher account
FFT->>HD: Submit support ticket with a linked file carrying hidden code
Note over HD: Payload sits dormant for three days
Note over Rep,API: 25 April — execution
Rep->>HD: Opens the ticket
HD-->>SH: Script runs in the rep's session and yields an authorization token
Note over SH,API: 28 to 30 April — collection
SH->>API: First-party API calls using rep privileges
API-->>SH: Usernames, emails, courses, enrolments, messages
Note over IN: 29 April — detection
IN->>SH: Access revoked, forensics engaged
IN->>Schools: 1 May — status page disclosure
SH->>Schools: 3 May — ransom post on leak site
IN->>Schools: 6 May — incident described as resolved
Note over SH,Schools: 7 May — second intrusion
SH->>API: Second XSS in discussions, token via OAuth flow
SH->>API: Publish ransom note as CSS in a custom theme
API-->>Schools: About 300 login portals show the extortion message
IN->>API: Theme disabled about 10 minutes later, Canvas in maintenance mode
IN->>Schools: 11 May — agreement reached, data destroyed
| Date / time | Event | Source |
|---|---|---|
| 2025-09 | Separate, earlier incident: Instructure discloses a social-engineering compromise of its Salesforce instance. It says Canvas product data was not reached | Reported in coverage summarised by Reed Smith |
| 2026-04-22 | Free-for-Teacher user submits a support ticket containing "a linked file with hidden code" | On EdTech, citing Instructure's webinar |
| 2026-04-25 | A customer service representative opens the ticket. Code executes in the rep's authenticated session | On EdTech; log-review window in customer FAQ |
| 2026-04-28 to 04-30 | Attacker uses the rep's elevated privileges to collect data via Canvas APIs | On EdTech |
| 2026-04-29 | Instructure detects unauthorized activity in Canvas | Incident update |
| 2026-05-01 | Incident disclosed on Instructure's status page | Wikipedia, citing status.instructure.com |
| 2026-05-02 | Instructure's CISO: "We believe the incident has been contained" | Wikipedia |
| 2026-05-03 | ShinyHunters posts Instructure on its leak site with a ransom demand | Wikipedia |
| 2026-05-05 | TechCrunch reports the breach. A ShinyHunters member claims 231 million unique emails | TechCrunch |
| 2026-05-06 | Instructure says the incident is resolved and Canvas is fully operational | Wikipedia |
| 2026-05-07, ~13:20 PDT | Students start posting screenshots of defaced login pages. Second XSS (discussion feature) and custom-theme CSS used. About 300 organisations see the note. Canvas goes into maintenance mode | Wikipedia; customer FAQ; BleepingComputer |
| 2026-05-07, 20:00 ET | Ransom note replaced with a maintenance notice | Wikipedia |
| 2026-05-08 | CEO update opens with an apology | Incident update |
| 2026-05-09 | "Canvas is fully back online." CrowdStrike engaged | Incident update |
| 2026-05-11 | Agreement with the attacker announced: data returned, "shred logs" received. House Homeland Security Committee requests a briefing | Incident update; House letter |
| 2026-05-12 | ShinyHunters' original leak deadline. FSA security alert issued to institutions | FSA |
| 2026-05-13 | Proposed class action filed in US District Court, Southern District of California | Wikipedia |
| 2026-06-08 | Free-for-Teacher permanently discontinued | Incident update |
| 2026-07-26 | Per-institution data findings start being delivered to named security contacts | Incident update |
| 2026-09-29 | CEO: "Our forensic review of the data involved in this incident is now complete" | Incident update |
Timestamps
Instructure publishes dates, not precise times, for the April events. The only wall-clock times here come from press reconstructions of the 7 May defacement. Some summaries give a 25 April start, matching when the ticket was opened. Others start from the 22 April submission. Both are right about different events.
Root Cause
Instructure has disclosed the shape of the attack, but not the specific code paths. The account below keeps to what Instructure said. Where it relies on outside analysis, mainly Scott Helme's write-up, that is marked.
The chain in one picture
flowchart TD
A["Anonymous signup<br/>Free-for-Teacher, weak identity checks"] --> B["Support ticket with<br/>linked file carrying hidden code"]
B --> C["Support rep opens ticket<br/>in privileged tooling"]
C --> D["Stored XSS executes<br/>in the rep's session"]
D --> E["Authorization token<br/>obtained by attacker"]
E --> F["First-party Canvas API calls<br/>with support privileges"]
F --> G["Bulk read: users, emails,<br/>courses, enrolments, messages"]
G --> H["Exfiltration and<br/>extortion"]
style A fill:#cc5500,color:#fff
style D fill:#ff6b6b,color:#fff
style E fill:#ff6b6b,color:#fff
style G fill:#ff6b6b,color:#fff
No single bug did this. It took four separate weaknesses lining up.
Weakness 1: a free tier inside paid production
Free-for-Teacher let individual educators create Canvas accounts without an institution. Instructure's statement that "the unauthorized actor carried out this activity in both instances using one of our Free-For-Teacher accounts" (incident update) confirms that this tier could reach the same support channel, and the same application, as institutional customers. Outside analysts describe the free tier as running on the same production infrastructure as paid schools with weak identity verification (Helme). Instructure has not published architecture details, so the exact degree of sharing (same database cluster, same app servers, same support queue) is not publicly confirmed.
Free tiers are a growth tool, and they are also the cheapest way for an attacker to get an authenticated foothold. Signing up costs nothing, there is usually no contract, and the identity checks are an email address. Anything a free user can reach inside production is part of your attack surface.
Weakness 2: untrusted content rendered in privileged tooling
The help desk is where the system turns around: content written by the least-trusted users on the platform is read by some of the most-trusted employees. Instructure confirmed that when a support agent opened the ticket, the code "triggered a cross-site scripting (XSS) vulnerability, allowing the threat actor to obtain an authorization token" (customer FAQ).
What exactly the "linked file with hidden code" was has not been disclosed. Helme lists plausible candidates, including an HTML or SVG attachment rendered inline, a link preview, or a document previewer, and argues that because it was a file, it may have bypassed the HTML sanitiser that cleans inline rich text. That reasoning is inference, not confirmed fact.
flowchart LR
subgraph Untrusted["Low trust"]
U["Free-tier user"]
end
subgraph Shared["Same origin as privileged UI"]
T["Ticket body and attachments"]
V["Support agent view"]
end
subgraph Priv["High trust"]
S["Support session and token"]
API2["Canvas APIs"]
end
U -->|"writes"| T
T -->|"rendered inside"| V
V -->|"runs with"| S
S -->|"authorizes"| API2
The pattern to recognise: if user content renders on the same origin as a privileged session, then any script in that content runs with that session's authority. It does not matter whether the token sits in a cookie or in memory. Code running on the same origin can make authenticated requests as that user, and often read the token too.
Weakness 3: a support identity with very wide reach
A help-desk session usually needs to look at any customer's account, because that is what support is for. Instructure has not described the scope of the representative's permissions. It did tell customers to look for "access from Canvas customer support representative accounts between April 25 and April 30" and for "rapid access to multiple courses or user accounts" not tied to a ticket they had filed (customer FAQ). That guidance only makes sense if a single support identity could touch many institutions. Helme calls cross-tenant API reach from the rep's session "the most plausible way" one session could affect thousands of institutions, and labels it as inference.
The core design failure is standing, bulk, cross-tenant read access attached to a human role. Support staff need to see one customer's account, when that customer has asked for help, for as long as the ticket is open. A role that can list every user across every tenant through the public API at machine speed is far more than the job needs.
Weakness 4: long-lived tokens and missing bulk-read alarms
An authorization token taken from a browser session is only useful for as long as it stays valid. Instructure's remediation list includes "token expiration is enforced" and the "elimination of lifetime tokens" (customer FAQ). That tells you long-lived tokens existed somewhere in the system, though Instructure has not said whether the stolen token itself was one of them.
The collection ran for about three days (28 to 30 April). A support identity making API calls across many tenants, with no ticket open for those tenants, is exactly the kind of behaviour a detection rule can catch. The four-day gap suggests that no such rule existed, or that it did not fire in time.
The second intrusion: same pattern, new bug, legitimate feature
On 7 May the attacker came back. Instructure's FAQ says the actor used "a second, unpatched XSS vulnerability in the Canvas discussion feature" and bypassed the earlier fix "by using the OAuth flow to generate a token instead." The ransom note was "posted via CSS in a Canvas custom theme, visible to roughly 300 organizations", and the attacker "disrupted authentication provider configurations" (customer FAQ).
Conflicting early reports
BleepingComputer's early follow-up quoted Instructure as saying the 7 May attack used "the same vulnerability" as the first intrusion (BleepingComputer). Instructure's later FAQ describes a second XSS in discussions. The likely reading is "the same class of vulnerability, reached the same way (through a Free-for-Teacher account)", but the page uses Instructure's later, more specific wording.
flowchart TD
A2["Free-for-Teacher account<br/>still active on 7 May"] --> B2["Stored XSS in<br/>discussion feature"]
B2 --> C2["Privileged user views<br/>the discussion"]
C2 --> D2["Token minted through<br/>the OAuth flow"]
D2 --> E2["Custom theme API:<br/>upload attacker CSS"]
D2 --> F2["Edit SSO provider<br/>configurations"]
E2 --> G2["Ransom note on about 300<br/>institutions' login pages"]
F2 --> H2["Users dropped to native<br/>Canvas login"]
style B2 fill:#ff6b6b,color:#fff
style E2 fill:#ff6b6b,color:#fff
style F2 fill:#ff6b6b,color:#fff
Two lessons stand out:
- Patching the bug is not the same as closing the path. After the first intrusion the specific ticket XSS was fixed, but the entry point (a free account that can put content in front of privileged users) and the capability (privileged tokens that can change many tenants) were both still there. The attacker only needed a second bug of the same kind.
- The defacement used features working as designed. The custom-themes API exists so that institutions can brand their login pages. Nothing in the theme upload was a vulnerability. The problem was who could call it, and how many tenants one caller could reach. Helme puts it bluntly: "CSP doesn't magically fix architectural mistakes about what privileged features can do."
Detection
What Instructure has said
- First intrusion: detected 29 April, with no public detail on what triggered it (incident update).
- Second intrusion: detected and shut down about 10 minutes after it began (customer FAQ). By then the company had deployed CrowdStrike Falcon EDR and was running "eyes-on glass, hands-on-keyboard monitoring" (incident update).
The gap between those two numbers, roughly four days versus ten minutes, is the clearest lesson from the detection side. The same organisation, against the same attacker, was more than 500 times faster once it was actively watching for this behaviour.
Signals that were available
None of these are confirmed to have been missed. They are the signals this attack would have produced on most platforms:
| Signal | Why it is anomalous | Where it shows up |
|---|---|---|
| Script execution or outbound beacon from a support-agent page | Support views should not run third-party script or contact unknown hosts | CSP violation reports, browser telemetry |
| Support identity calling bulk-list APIs | Support work is one-account-at-a-time and driven by tickets | API gateway logs |
| Support identity touching many tenants with no open ticket | Helpdesk access should correlate with ticket ownership | Join API logs with ticket system |
| API call volume from one principal far above its baseline | Humans click, and scripts paginate | Per-principal rate metrics |
| New OAuth token minted for a privileged user from an unusual client or IP | Token issuance is a high-value event | Identity provider logs |
| Theme or SSO configuration changed on many tenants within minutes | Branding changes are rare and per-tenant | Config audit log |
Instructure's own guidance to customers maps onto the second and third rows. It asked institutions to look for support-rep access between 25 and 30 April and for "rapid access to multiple courses or user accounts that doesn't correlate with a support ticket you submitted" (customer FAQ).
A detection rule you can actually ship
This is an illustrative rule for the third and fourth rows, written as SQL over an API-access log joined to a ticket table. It is not Instructure's code.
-- Support principals touching tenants they have no open ticket for,
-- or reading far more records than a human could in one hour.
WITH support_calls AS (
SELECT a.principal_id,
a.tenant_id,
date_trunc('hour', a.ts) AS hour,
count(*) AS calls,
sum(a.records_returned) AS records
FROM api_access_log a
JOIN principals p ON p.id = a.principal_id
WHERE p.role = 'support'
AND a.ts > now() - interval '1 hour'
GROUP BY 1, 2, 3
),
ticketed AS (
SELECT DISTINCT assignee_id AS principal_id, tenant_id
FROM support_tickets
WHERE status IN ('open', 'pending')
)
SELECT s.principal_id,
count(DISTINCT s.tenant_id) AS tenants_touched,
count(DISTINCT s.tenant_id) FILTER (WHERE t.tenant_id IS NULL) AS tenants_without_ticket,
sum(s.records) AS records_read
FROM support_calls s
LEFT JOIN ticketed t
ON t.principal_id = s.principal_id AND t.tenant_id = s.tenant_id
GROUP BY s.principal_id
HAVING count(DISTINCT s.tenant_id) FILTER (WHERE t.tenant_id IS NULL) > 3
OR sum(s.records) > 5000; -- tune to your baseline; page the on-call
A single support agent working ten tickets an hour might touch ten tenants. A script with a stolen token touches thousands. You do not need machine learning to tell those apart. A threshold and a join will do. For more sophisticated baselining, see Anomaly Detection.
Response
Instructure's response is well documented on its incident page, and the public criticism of it is part of the record.
Containment
- First intrusion: attacker access revoked, the vulnerabilities and "privilege escalation paths" remediated, internal tokens rotated as a precaution (incident update; customer FAQ).
- Second intrusion: malicious theme disabled within about 10 minutes, Canvas put into maintenance mode, SSO configurations restored to their last known-good state before the platform came back (customer FAQ).
- Free-for-Teacher: suspended at first, then permanently discontinued on 8 June. Users got short windows to download their materials (incident update).
Hardening that Instructure reported
From the customer FAQ:
- Admin access limited to trusted locations, with rate limiting.
- Sensitive admin paths locked down.
- Third-party integrations restricted by geography or network.
- Token expiration enforced, with "elimination of lifetime tokens" under way.
- CrowdStrike Falcon EDR deployed, with 24/7 monitoring.
Forensics and notification
CrowdStrike led the forensic analysis. Charles River Associates helped with the data review, and Kroll handles user notifications on institutions' behalf (incident update). Institutions were asked to name up to two individual security contacts, not shared inboxes. Per-institution findings were delivered from 26 July, after one pause "out of an abundance of caution" on 14 July. On 29 September the CEO said the forensic review was complete.
The agreement with the attacker
On 11 May Instructure wrote that it had "reached an agreement with the unauthorized actor", that "the data was returned to us", that it "received digital confirmation of data destruction (shred logs)", and that "no Instructure customers will be extorted as a result of this incident, publicly or otherwise" (incident update). Instructure did not say whether money changed hands. Inside Higher Ed headlined it as Instructure paying the ransom (Inside Higher Ed). Any dollar figure in circulation is unverified.
What "shred logs" are worth
A criminal's proof of deletion is a log file the criminal produced. It cannot prove that no other copy exists. The FBI and CISA consistently advise that paying does not guarantee deletion. Plan as if the data is still out there: assume phishing will target students and staff using real course names and enrolment details, and warn users.
Communication
The CEO's 8 May update opened: "I'll start where I should: with an apology." On 11 May the company apologised for its lack of transparency (incident update). Critics, including edtech analyst Phil Hill, pointed out that the 6 May "resolved" message came one day before the second intrusion. They also argued that the technical webinar left integration partners and academic-continuity questions largely unanswered (On EdTech). The lesson for your own runbook is in Communication Templates: never say "resolved" about a security incident until you have closed the path, not just the bug.
Remediation for Customers
If you ran Canvas, or you run any SaaS that holds your users' data, this is what the guidance boiled down to.
From Instructure (customer FAQ):
- Review Canvas admin and Canvas Data logs for access from customer-support accounts between 25 and 30 April and briefly on 7 May, and for rapid access to many courses or users that you did not ask for.
- Enable Canvas MFA for all admins.
- Broad rotation of LTI, SIS and API keys was "not currently required", though institutions could cycle keys if they chose to. If a SIS sync stopped, Instructure may have rotated that key.
From the US Department of Education, FSA (alert):
- Enforce MFA everywhere, for faculty, staff, students and admins.
- Remove or disable non-managed "teacher-created" or "free" accounts, and use institution-controlled identities.
- Review identity-provider logs, especially from 25 April to 8 May 2026.
- Review data-sharing agreements with third parties.
Guidance that conflicted
The FSA alert relays an Instructure recommendation to "rotate local Canvas integrations, LTI tools, SSO connectors, and API keys." Instructure's later FAQ says broad rotation was "not currently required." The cautious choice, and the one most security teams made, was to rotate anyway. It is cheap compared with being wrong.
What Would Have Prevented It
None of these controls is exotic. Each one alone would have broken the chain, or at least shrunk it a lot.
1. Render user-submitted content on a sandbox origin
User attachments and rich ticket bodies should never render on the same origin as the support console. Serve them from a separate, cookieless domain, the pattern Google (googleusercontent.com) and GitHub (githubusercontent.com) use.
# usercontent.example-support.net — no cookies, no app, just bytes
server {
server_name usercontent.example-support.net;
# Never let the browser sniff HTML out of an "image" or "text" upload
add_header X-Content-Type-Options "nosniff" always;
# Force download for anything that could execute
add_header Content-Disposition "attachment" always;
# Even if it renders, it cannot run script or reach out
add_header Content-Security-Policy "default-src 'none'; img-src 'self'; style-src 'unsafe-inline'; sandbox" always;
add_header Cross-Origin-Resource-Policy "cross-origin" always;
location / {
proxy_pass http://attachment-store;
proxy_hide_header Set-Cookie;
}
}
When the support console must preview content inline, use an iframe sandbox without allow-same-origin, so that script, if it runs at all, runs in an opaque origin with no access to the parent's session:
<!-- Support console: preview a customer attachment -->
<iframe
src="https://usercontent.example-support.net/t/8121/att/3"
sandbox=""
referrerpolicy="no-referrer"
loading="lazy"
title="Customer attachment preview"></iframe>
2. Strict CSP with reporting on every privileged UI
A nonce-based CSP with no 'unsafe-inline' leaves injected inline script nowhere to run. Reporting turns every blocked attempt into an alert. Helme argues this plausibly would have broken both XSS stages and would have flagged the first one days earlier. He also says clearly that CSP would not have stopped the theme-CSS abuse (Helme).
// Express middleware for the support console (illustrative)
import crypto from "node:crypto";
import type { Request, Response, NextFunction } from "express";
export function supportConsoleCsp(req: Request, res: Response, next: NextFunction) {
const nonce = crypto.randomBytes(16).toString("base64");
res.locals.cspNonce = nonce;
res.setHeader(
"Content-Security-Policy",
[
"default-src 'self'",
`script-src 'nonce-${nonce}' 'strict-dynamic'`,
"object-src 'none'",
"base-uri 'none'",
"frame-src https://usercontent.example-support.net",
"connect-src 'self'", // blocks beacons to attacker hosts
"form-action 'self'",
"frame-ancestors 'none'",
"report-to csp-endpoint",
].join("; ")
);
res.setHeader(
"Reporting-Endpoints",
'csp-endpoint="https://csp-reports.example.com/support"'
);
next();
}
A sudden spike in CSP violation reports from the support console should page someone. Support agents do not normally trigger script violations. For the full directive reference, see Content Security Policy and XSS Advanced.
3. Keep the free tier out of paid production
If a free tier has to exist, it should be its own cell: separate application deployment, separate database, separate support queue. A compromise there should be unable to reach a paying tenant even in theory.
flowchart LR
subgraph Edge["Edge router"]
R["Route by tenant plan"]
end
subgraph FreeCell["Free cell"]
FA["App"]
FD[("Free DB")]
FS["Free support queue<br/>limited agent role"]
end
subgraph PaidCell["Institution cells"]
PA["App"]
PD[("Tenant DBs")]
PS["Institution support<br/>ticket-scoped access"]
end
R -->|"plan = free"| FA
R -->|"plan = institution"| PA
FA --> FD
PA --> PD
FS -.->|"no route"| PD
On a smaller budget, at least route free-tier tickets to a queue that agents open with a low-privilege role that cannot see institution data, and require identity proofing (verified institutional email, or payment card) before an account can file tickets with attachments. See Multi-Tenancy for the silo / pool / bridge trade-offs.
4. Make support access ticket-scoped and just-in-time
Replace standing cross-tenant read with a short-lived grant that is tied to a ticket and approved by the customer:
# Illustrative: support access is minted per ticket, per tenant, with an expiry.
from datetime import datetime, timedelta, timezone
MAX_GRANT = timedelta(hours=2)
def issue_support_grant(agent, ticket, db):
if ticket.status not in ("open", "pending"):
raise PermissionError("ticket not active")
if ticket.assignee_id != agent.id:
raise PermissionError("agent not assigned to ticket")
if not ticket.customer_consented_to_access:
raise PermissionError("customer has not granted access")
grant = {
"agent_id": agent.id,
"tenant_id": ticket.tenant_id, # one tenant, never '*'
"scopes": ["read:course", "read:user"], # no bulk export scopes
"expires_at": datetime.now(timezone.utc) + MAX_GRANT,
"ticket_id": ticket.id,
}
db.support_grants.insert(grant)
db.audit_log.insert({"event": "support_grant_issued", **grant})
return grant
if __name__ == "__main__":
class O: # tiny self-check
def __init__(self, **k): self.__dict__.update(k)
class FakeTable(list):
def insert(self, x): self.append(x)
db = O(support_grants=FakeTable(), audit_log=FakeTable())
agent = O(id=7)
ok = O(id=1, status="open", assignee_id=7, tenant_id="t1", customer_consented_to_access=True)
g = issue_support_grant(agent, ok, db)
assert g["tenant_id"] == "t1" and len(db.audit_log) == 1
try:
issue_support_grant(agent, O(id=2, status="closed", assignee_id=7, tenant_id="t2",
customer_consented_to_access=True), db)
raise AssertionError("closed ticket must be refused")
except PermissionError:
pass
print("ok")
Then enforce the grant in the data layer, not only in the UI. In PostgreSQL that is row-level security:
-- Every tenant-owned table carries tenant_id. The app sets the session's
-- tenant context, and support sessions may only set a tenant they hold a live grant for.
ALTER TABLE enrollments ENABLE ROW LEVEL SECURITY;
ALTER TABLE enrollments FORCE ROW LEVEL SECURITY;
CREATE POLICY tenant_isolation ON enrollments
USING (tenant_id = current_setting('app.tenant_id')::uuid);
-- Support role: the tenant must match an unexpired grant for this agent.
CREATE POLICY support_scoped ON enrollments
FOR SELECT TO support_role
USING (EXISTS (
SELECT 1 FROM support_grants g
WHERE g.agent_id = current_setting('app.agent_id')::bigint
AND g.tenant_id = enrollments.tenant_id
AND g.expires_at > now()
));
With this in place, a stolen support token is worth one tenant for at most two hours, not the whole platform. See Least Privilege, RBAC, ABAC and ReBAC and Broken Access Control.
5. Short-lived, bound tokens and step-up for dangerous actions
Instructure's own fix list includes ending lifetime tokens. Two further controls follow from the second intrusion:
- Bind tokens to the client (DPoP or mTLS-bound tokens) so that a token lifted from a browser cannot simply be replayed from the attacker's machine.
- Require step-up auth (a fresh WebAuthn assertion) for actions that affect many tenants or authentication itself: theme changes, SSO provider edits, bulk exports.
# Illustrative policy-engine rule set for privileged Canvas-like actions
rules:
- action: ["theme:update", "sso:update", "export:bulk"]
require:
mfa_age_seconds_max: 300 # fresh WebAuthn within 5 minutes
token_binding: dpop
tenants_per_request_max: 1
network: [corp-vpn, admin-bastion]
on_violation: deny_and_alert
- action: ["users:list", "enrollments:list"]
principal_role: support
require:
support_grant: active
rate_limit:
requests_per_minute: 30
records_per_hour: 2000
See Session Management, OAuth 2.0 Flows and Policy Engines.
6. Rate-limit enumeration and bulk export by principal
Data theft at the scale ShinyHunters claimed means paginating through very large lists. A per-principal limiter on list endpoints, keyed on records returned, not just requests, makes that slow and noisy:
-- OpenResty / Redis: token bucket on records returned per principal per hour (illustrative)
local principal = ngx.ctx.principal_id
local key = "rl:records:" .. principal .. ":" .. os.date("!%Y%m%d%H")
local returned = tonumber(ngx.var.upstream_http_x_records_returned) or 0
local red = require("resty.redis"):new()
red:connect("127.0.0.1", 6379)
local total = red:incrby(key, returned)
red:expire(key, 3600)
if ngx.ctx.role == "support" and total > 2000 then
ngx.log(ngx.ERR, "bulk-read threshold exceeded by ", principal)
-- alerting hook here; next request will be rejected upstream
end
See Rate Limiting and API Abuse Prevention.
7. Audit-log every cross-tenant and configuration-changing action
Theme uploads, SSO edits, support grants and bulk list calls should each produce an immutable audit record with principal, tenant, client, IP and ticket ID. Those records feed the detection rule shown above and also let you answer "which tenants did this token touch?" in minutes rather than months. Instructure's per-institution findings took until late July to start arriving. See Audit Logging and Audit Log blueprint.
Lessons for System Design
- The support console is part of your trust boundary. It reads the least-trusted input in the system with some of the most-trusted credentials. Design it as you would a public endpoint: sandboxed rendering, strict CSP, minimal privileges.
- A free tier is an anonymous authenticated user. Anything it can reach, an attacker can reach at no cost. Isolate it as a cell, or put identity proofing in front of anything that reaches privileged humans.
- Bound blast radius by tenant, not only by role. "Support can read users" is a role check. "Support can read users of tenant X while ticket Y is open" is a blast-radius check. Only the second one limits a stolen token.
- Fix the path, not just the bug. After an intrusion, ask what class of input reached what class of privilege, and close that. Patching one XSS while leaving the same entry point and the same privileged capability left room for a second XSS a week later.
- Features are attack surface too. Theme upload and SSO configuration are working features that became the defacement mechanism. Classify features by what they can change, and require step-up auth for those that can change many tenants or how people log in.
- Detection speed is a design property. Instructure went from about four days to about ten minutes once targeted monitoring was in place. Build the "support identity touching many tenants" alert before you need it.
- Don't say "resolved" early. Saying an incident is contained when the entry point is still open costs credibility you will need later.
- Centralisation concentrates risk. One LMS vendor holds identity, enrolment and message data for thousands of institutions. As 404 Media's headline put it, the Canvas hack "shows the danger of centralized edtech". For architects, that means per-tenant encryption keys and per-tenant data stores are not over-engineering when your customers are thousands of independent organisations.
What Would You Do?
Scenario 1: You run support tooling for a multi-tenant SaaS. Product wants ticket attachments to preview inline so agents can work faster. Do you (A) render attachments inline in the console with your HTML sanitiser, (B) preview them in a sandboxed iframe from a separate cookieless domain, or (C) force-download every attachment?
Best answer: (B). It keeps the speed benefit and puts untrusted bytes on an origin with no session to steal. (A) is what makes this incident's class of attack possible: sanitisers handle inline HTML, and files (SVG, HTML, PDF previews) are often a different code path. (C) is safe but agents will work around it, for example by opening files on their own machine, which brings back a different risk.
Scenario 2: Your monitoring shows a support-agent principal has read 40,000 user records across 600 tenants in the last hour. The agent is on shift and says they "did nothing unusual". Do you (A) ask the agent to log out and back in, (B) revoke every token and session for that principal immediately, then investigate, or (C) wait for the hourly report to confirm?
Best answer: (B). A human cannot read 40,000 records across 600 tenants in an hour. Either the account or its session has been taken over. Logging out (A) may not revoke an already-stolen bearer token. Waiting (C) lets more data leave. Revoke first, and confirm with the agent afterwards.
Scenario 3: You patched the XSS that let an attacker in through a free-tier support ticket. Leadership wants to announce the incident as "resolved" today. What must be true first?
At minimum: the entry point (free-tier accounts reaching privileged reviewers) is closed or isolated. Every token that could have been minted from compromised sessions has been revoked. Privileged features that can change many tenants (themes, SSO, exports) have step-up controls. And you have searched for sibling bugs of the same class, such as other places where user content renders in privileged views. Instructure's 6 May "resolved" was followed by a second intrusion through a sibling bug on 7 May.
Key Lessons
Key Lessons
- A support ticket can be the way in to every tenant. Render ticket content on a cookieless sandbox origin, behind a strict CSP with reporting.
- Free tiers need isolation. Run them as a separate cell, or keep them away from anything a privileged human views.
- Support access should be per ticket, per tenant, time-boxed and enforced in the database. Row-level security makes a stolen token worth one tenant instead of all of them.
- Rate-limit and alert on records read per principal, especially for human roles.
- Step-up auth for features that change many tenants or how people log in. Themes and SSO configuration were the defacement mechanism.
- Fix the class, not the instance. One XSS was patched and a sibling XSS was used a week later.
- Attacker numbers are not facts. 275M users, 231M emails and 3.65 TB are claims. Instructure confirmed data categories, not counts.
Quiz
Q1: According to Instructure, how did the attacker first obtain elevated access? Through a Free-for-Teacher account they submitted a support ticket containing malicious code. When a customer service representative opened it, an XSS vulnerability let the attacker obtain an authorization token and use elevated access within Canvas.
Q2: Why does rendering user content on a separate, cookieless origin defeat this attack class?
Script that runs on a different origin cannot make same-origin authenticated requests to the console's APIs or read its session. Without allow-same-origin in the iframe sandbox, it runs in an opaque origin with no access to the parent at all.
Q3: How did the 7 May intrusion differ from the first? It used a second, unpatched XSS in the discussion feature, obtained a token through the OAuth flow, and then used the legitimate custom-theme feature to publish a ransom note as CSS to about 300 organisations. It also disrupted SSO provider configurations. Instructure found no evidence that data was taken that day.
Q4: Which numbers about this breach are confirmed by Instructure? The data categories (usernames, emails, course names, enrolment information, messages, plus API provisioning records, user reports and DAP messaging data), the roughly 300 organisations shown the ransom note, and about 10 minutes to detect the second attack. The 275 million users, 231 million emails and 3.65 TB figures come from the attacker.
Q5: What single database-layer control would most limit a stolen support token? Row-level security that only allows a support role to read rows for a tenant where that agent holds a live, unexpired, ticket-bound grant. It turns platform-wide read into one tenant for a limited time.
Related Pages
- XSS Advanced: stored XSS, sanitiser bypasses, and why file previews are dangerous
- Content Security Policy: nonce-based CSP and violation reporting
- Multi-Tenancy and Multi-Tenant Database Strategies: silo, pool and row-level isolation
- Broken Access Control (OWASP A01)
- Security Logging and Monitoring Failures (OWASP A09)
- Least Privilege and RBAC, ABAC and ReBAC
- Session Management and OAuth 2.0 Flows
- Rate Limiting and API Abuse Prevention
- Audit Logging
- Incident Response and Forensics and Communication Templates
- Axios Supply Chain Attack (March 2026): another 2026 incident in which one stolen credential gave access across a huge downstream population
One-Liner Summary
A free account filed a support ticket, the ticket ran code in a support agent's browser, and that agent's cross-tenant session let ShinyHunters read data across Canvas. A week later a sibling XSS let them deface about 300 schools' login pages, because the bug was patched but the path was not.
Sources
Primary (Instructure and government)
- Instructure: Security Incident Update & FAQs: dated updates from 29 April to 29 September 2026, the agreement statement, and the remediation list
- Instructure: Incident update for customers (FAQ): XSS-in-support-ticket mechanism, the 7 May OAuth and custom-theme details, log-review windows and hardening steps
- Instructure status page: the 1 May disclosure
- US Department of Education, FSA: Technology Security Alert GENERAL-26-27 (updated 29 May 2026)
- House Homeland Security Committee letter to Instructure, 11 May 2026
Analysis
- Scott Helme: The Instructure Canvas Breach (2026): How XSS in a Support Ticket Compromised 275 Million Students (15 June 2026). Clearly separates confirmed facts from inference. The headline figure is the attacker's claim.
- Phil Hill, On EdTech: A Technical Deep Dive Is Not a Crisis Response: the 22, 25 and 28–30 April timeline from Instructure's webinar
- Reed Smith: Canvas/Instructure cyberattack, key developments and action items
Reporting
- TechCrunch: Hackers steal students' data during breach at education tech giant Instructure (5 May 2026)
- TechCrunch: Hackers deface school login pages after claiming another Instructure hack (7 May 2026)
- BleepingComputer: Canvas login portals hacked in mass ShinyHunters extortion campaign
- BleepingComputer: Instructure confirms hackers used Canvas flaw to deface portals
- Inside Higher Ed: Instructure pays ransom to Canvas hackers (11 May 2026)
- 404 Media: The biggest student data privacy disaster in history
- Wikipedia: 2026 Canvas data breach. Used as a pointer to the AP, Reuters, ABC, NOS and LA Times coverage for regional impact and the 7 May wall-clock times.