Over 25 days an autonomous AI hacking platform probed Bitrise while posing as an authorized penetration test, came back, got in, and was shut out. This is what it did, step by step, and how we stopped it.
An evidence-graded account: how it got in, what it reached, what it did not, how we shut it out, and what every defender should look for.
StatusBitrise is safe to use. The attack path is closed, every production secret and credential we manage was rotated, and we keep watching.
How this report was made
Checked by people. Written with AI help.
AI helped us write this report and build its visuals. The claims, the timeline and the findings were checked by people: our engineers and security engineers. In the age of AI-accelerated attacks, we use AI tools in the response too, so we can report quickly.
Open Evidence under any step to see the log lines behind it.
Classification
TLP:CLEAR · public · share freely
Version
1.3
Published
Authors
Arpad Kun, VP of Engineering and Infrastructure, Bitrise Imre Szvorenyi, Information Security Engineer, Bitrise
Times
All times are UTC.
How we countedFirst request from 95.40.73.129 on Oct 25, 01:43 UTC; last request from 118.100.234.120 on Nov 18, 21:19:55 UTC.
How we countedSign-in recorded 11:46:48 UTC; first cloud API call from the attacker’s address with a service-account key 11:57:25 UTC (Nov 13). The key is linked to the secrets revealed minutes earlier by timing: secret values are not logged.
How we countedSuspicious activity detected and investigation initiated 16:32 UTC; shutdown started 19:26 UTC (Nov 13), 7 h 39 min after the sign-in. The platform was switched off at 20:34 UTC.
How we countedFrom the sign-in at 11:46:48 UTC to the last successful cloud API call recorded from the attacker’s addresses at 21:57:50 UTC (Nov 13).
How we countedGoogle Cloud audit logs swept across every project for the attacker’s source addresses: 8,725 entries, 5,662 successful; 72 identities tried, 18 with at least one successful call. A separate search for Nov 18 found 19 more requests, all denied.
How we counted55 minutes, 19 cloud requests all denied, 9 sign-in attempts all refused. One new sign-up was created, never confirmed, and banned.
Summary
Between October 25 and November 18, 2026, an operator pointed ARTEX, an open-source AI penetration-testing platform, at Bitrise. Its agents spent three days in October mapping our public surface under user agents that claimed to be an “authorized pentest”. On November 12 they came back as an ordinary customer, ran their own builds and tested whether one customer could reach another’s files. They could not.
The decisive step came on November 13 at 11:46:48 UTC: a sign-in to a dormant internal test bot account that had no two-factor authentication and still belonged to an internal workspace. Less than eleven minutes later the agents were using cloud keys that belong to that workspace’s projects, and over the next ten hours they chained one credential into the next: Bitrise’s own signing files, source code, infrastructure state and build logs.
We detected suspicious activity at 16:32 UTC, started a platform-wide shutdown at 19:26 UTC and switched the platform off at 20:34 UTC. The last successful cloud call with a stolen key was recorded at 21:57:50 UTC. We then revoked all 919 of our cloud service-account keys, rotated every production secret and credential we manage, and rebuilt our build infrastructure from trusted sources: thousands of servers in three data centers.
When the attacker returned on November 18 and replayed the attack with what it had stolen, every attempt to read anything was refused. We watched it live.
If you are a Bitrise customer
Bitrise is safe to use. The path used in this attack no longer exists.
Most of what the attacker accessed was Bitrise’s own. Files in 15 customer workspaces were accessed without authorization: 1 code-signing certificate file (the attacker could not access the password needed to open it), 1 provisioning profile and 13 diagnostic build logs from May 2026. All 15 customers were contacted immediately.
For every other workspace, our file-level analysis found no evidence of the customer’s secrets, code-signing files, build artifacts or source code in what the attacker accessed. Our logs show no access, and no attempted access, to the store that holds customer secrets.
As a precaution we still recommend rotating the secrets, tokens and certificates you store in Bitrise and reconnecting GitHub. Protected Secret Masked Review shows the last four characters of each secret to help you find them.
This is what an ARTEX-class attack looks like from the receiving end, with exact times, user agents, account names and addresses.
Three fingerprints identify the tool: the client string norma/0.4, things named i<number> (i871-probe, i3694canary), and traffic that announces an “authorized pentest” nobody ordered.
The door was a forgotten account. The damage came from long-lived keys sitting in CI secrets and infrastructure state. The irony of a CI company being breached through a CI bot. We learned.
The techniques were familiar: a forgotten account, secrets that could be revealed, long-lived keys. What stood out was the speed: stolen keys were in use within minutes of being found, and the automation kept probing through the night.
Due to the speed of the spread, Arpad Kun, our VP of Engineering and Infrastructure, made the call: shut the platform down, rotate every production secret and credential we manage rather than only those known to be affected, and rebuild from trusted sources.
In the era of AI-accelerated attacks we need AI-accelerated defense. We now run AI agents that watch activity in real time and investigate what they see. The time of the Defense Agents has arrived.
67 steps in 6 chapters, in the order they happened. Every step carries an outcome, an evidence grade and the log lines behind it.
jk next / previous stepe evidence
Evidence grade of each step
Verified
Shown directly by a log record.
Correlated
Each fact is verified; the link between them is inferred from timing or fingerprints.
Not established
We could not prove this with the data available.
Reported
A response action taken from the responders’ record.
What happened to each attempt
Succeeded
Partly
Refused
Observed
Unknown
Bitrise action
PrologueOct 25 – Nov 4
It introduced itself as a pentester
For three days an automated client on a cloud address in Hong Kong mapped Bitrise's public surface: 36,698 requests to more than 20 hostnames, five throw-away accounts, and one service it could trick into fetching URLs for it. Its traffic announced an “authorized pentest” that nobody had ordered. It also downloaded a build that one of our customers publishes for its own penetration testing, which tied the scan to activity that looked legitimate. At the time it looked like the scanning every public platform sees every day. Two bursts of sign-ups from Germany and China followed; their link to the attacker is weaker, and we say so.
The lessonTraffic that calls itself an authorized test, when you ordered none, is an attacker introducing itself.
It scans 20+ hostnames and labels its traffic authorized testing
From 95.40.73.129, an AWS address in Hong Kong, the attacker sent 36,698 requests across 20+ Bitrise hostnames. This address was used for discovery and tests. It used ffuf, a tool that tries many URL paths, and user agents including pentest-probe-i5938/1.0 and Mozilla/5.0 (compatible; authorized-pentest/bitrise-readonly).
The tool behind this traffic tells each of its AI agents that it is part of an authorized penetration test, which explains these labels, and is identified in the section “The tool” further down.
36,698requests
20+hostnames
Outcome: Scanning observedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on request logs showing one source scanning many hostnames with authorized-testing user agents when no approved test is scheduled.
EvidenceEdge request logs (CDN/WAF)12 lines
2026-10-25T01:43:00Z 95.40.73.129 AS16509 HK GET app.bitrise.io /app/<app> 404 curl/7.88.1Total requests for the IP (sum of count column): 3669812813 pentest-probe-i5938/1.09311 curl/7.88.11074 Mozilla/5.0 (compatible; authorized-pentest/bitrise-readonly)819 Fuzz Faster U Fool v2.3.0457 Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) research-readonly383 Mozilla/5.0 (research; read-only; pentest)369 Mozilla/5.0 (compatible; authorized-security-research)180 python-requests/2.34.2159 bitrise-pentest-probe/1.0 (authorized read-only)76 pentest-probe-readonly/1.0 (authorized read-only baseline)
These labels, the task-numbered names such as i5938 and the norma/0.4 documentation fetches point to ARTEX or software derived from it. norma/0.4 appeared 8 times from 95.40.73.129, 5 times from 118.100.234.120 and 38 times from 74.211.97.67. This identifies the tooling, not an operator, a location or a language model; the client string alone would not be enough.
It reads public build logs from 12 open-source apps
The same address used signed download links to read build logs from 12 public open-source apps. Cloud logs recorded 59 successful object reads. These logs were public by design.
Outcome: Public logs readEvidence grade: VerifiedShown directly by a log record.
How to catch thisCorrelate bursts of public build-log reads in cloud audit logs with scanning from the same source.
Storage request totals and public-app flags establish the scope, but 59 object reads do not establish a count of unique files. Project names and identifiers are omitted.
It creates five accounts and tests their security settings
The attacker registered five accounts from 95.40.73.129 and tested security settings without creating workspaces, apps or builds. It created 15 one-hour personal access tokens, exercised password resets and tried to activate two-factor authentication. It also tried to delete a token belonging to someone else. That request returned HTTP 404.
The usernames were pentestprobe-1d2bf9, pentestprobe-9cede9, pentestprobe-280c2cfd, pentestprobe-q7m4z2 and pentest-probe-v2-mbjlcuxr. All five confirmed sign-up addresses appear in the evidence below.
Outcome: Settings partly testedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on account logs showing fresh accounts creating tokens, resetting passwords, changing two-factor settings and failing token deletions without ordinary product use.
pentest-probe-1d2bf9@maxxspace.com 2026-10-25 19:58:21 2026-10-25 19:58:34 95.40.73.129 2026-10-25 19:58:34 2026-10-25 22:20:36pentest-probe-9cede9@maxxspace.com 2026-10-25 20:09:23 2026-10-25 20:09:29 95.40.73.129 2026-10-25 20:09:29 2026-10-25 22:19:28test-5fowzn6@srv1.mail-tester.com 2026-10-25 20:14:21 2026-10-25 20:14:31 <mail-testing service>,95.40.73.129 2026-10-25 20:14:31 2026-10-25 20:15:54pentestprobeq7m4z2@olipii.com 2026-10-25 23:00:56 2026-10-25 23:05:40 95.40.73.129 2026-10-25 23:05:40 2026-10-25 23:07:53pentestprobv2mbjlcuxr@ruutukf.com 2026-10-26 08:18:25 2026-10-26 08:24:53 95.40.73.129 2026-10-26 08:24:53 2026-10-26 08:24:53CDC user_auth_tokens: 15 one-hour tokens created by these users between 2026-10-25 20:04:37 and 2026-10-26 22:05:52.2026-10-25T20:04Z POST app.bitrise.io /me/profile/security/create_website_user_auth_token 2042026-10-25T21:25Z POST app.bitrise.io <password-reset endpoint> 2012026-10-25T21:30–21:32Z PUT <password-reset endpoint> 422 x13, 204 x12026-10-25T21:39Z POST /me/profile/security/activate_two_factor_auth.json 4222026-10-25T21:39Z DELETE /me/profile/security/user_auth_tokens/<token> 404 (IDOR probe)
Account rows give creation, confirmation, source address and first and last sign-in. The usernames are the platform usernames, not the e-mail local parts. One sign-in at the moment of e-mail confirmation came from a mail-testing service, not from the attacker. The window includes the later token tests; endpoint paths are generalized.
It reads files through public links; bucket listings are denied
The attacker opened public install-page links for 70 different apps. These pages are public by design and need no sign-in. Adding .json to a page link returns a signed download URL. Cloud logs recorded 59 successful object reads across three private customer apps. Three more apps returned only missing-object results. One of the three was a customer’s penetration-testing build, described in the next step.
These reads were not unauthorized access. How the attacker collected the links is not established. Separately, all 13 anonymous attempts to list the storage bucket were denied.
70apps with opened links
59successful object reads
13bucket listings denied
Outcome: Reads partly succeededEvidence grade: VerifiedShown directly by a log record.
EvidenceCloud audit logs (Google Cloud)11 lines
2026-10-25T20:23Z GET app.bitrise.io /app/<app>/installable-artifacts/<artifact>/public-install-page/<hash> 200GCP storage.objects.get by <service-account> (signed URL), bucket <bucket>:first last n status app2026-10-25T20:26:01.786 2026-10-26T12:36:18.045 26 OK apps/<app> (private, <workspace>)2026-10-25T20:26:16.618 2026-10-26T12:36:27.705 19 OK apps/<app> (private, <workspace>)2026-10-25T20:26:22.502 2026-10-26T12:36:32.081 14 OK apps/<app> (private, <workspace>)2026-10-25T20:26:12.163 2026-10-26T12:35:43.155 9 NOT_FOUND apps/<app> (private, <workspace>)2026-10-25T20:26:14.773 2026-10-26T12:35:45.772 9 NOT_FOUND apps/<app> (private, <workspace>)2026-10-26T12:33:16.119 2026-10-26T12:35:49.702 4 NOT_FOUND apps/<app> (private, <workspace>)2026-10-26T08:53:54 → 12:02:23 13 anonymous bucket listings — all DENIED (code 7)Cloudflare: distinct app slugs in public-install-page URLs requested by 95.40.73.129 = 70
The 59 reads are operations, not unique files, and each generalized app row represents a different app. Three apps had successful reads, not six; NOT_FOUND means a missing object, not expiration.
It downloads a customer’s penetration-testing build: a decoy
One of the public install links belonged to an app build that a customer publishes for its own penetration testing. The attacker opened that page on Oct 25 at 20:23 UTC. By 12:36 UTC the next day, cloud storage had recorded 26 successful reads of that app’s files.
On Nov 12 it came back to the same app from 118.100.234.120. In 32 seconds it made five successful reads; one requested about 96 MB of the iOS app file. A sixth request, sent without the signed link, was denied.
The customer had made this link public, so these downloads were not unauthorized access, and we do not name the customer. We treat the download as a decoy. Fetching a real pentest build ties a hostile scan to activity that looks like legitimate testing. The logs record the downloads; they cannot record the motive.
26successful reads, Oct 25–26
5successful reads, Nov 12
1request denied without the link
Outcome: Public build downloadedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on public install links fetched by command-line clients or scanners, and on the same link fetched again from a different network weeks later.
EvidenceCloud audit logs (Google Cloud)10 lines
2026-10-25T20:23Z GET app.bitrise.io /app/<app>/installable-artifacts/<artifact>/public-install-page/<hash> 200GCP storage.objects.get by <service-account> (signed URL), callerIp 95.40.73.129:2026-10-25T20:26:01.786 2026-10-26T12:36:18.045 26 OK apps/<app> (private, <workspace>)GCP storage.objects.get, callerIp 118.100.234.120, user agent curl/7.88.1:2026-11-12T16:21:36.296Z OK apps/<app>/builds/<build>/artifacts/<artifact>/<android package>2026-11-12T16:21:36.642Z OK apps/<app>/builds/<build>/artifacts/<artifact>/<ios app file>2026-11-12T16:21:51.433Z OK …/<android package>2026-11-12T16:21:52.103Z OK …/<ios app file>2026-11-12T16:22:08.018Z OK …/<ios app file> requested_bytes ≈ 96 MB2026-11-12T16:22:26.385Z DENIED …/<ios app file> anonymous caller, no signed link (code 7)
The October and November rows concern the same app, and the install page opened in October belongs to the iOS file requested on Nov 12. The build record identifies it as the customer’s penetration-testing build. The customer, app and file names are withheld and the byte count is rounded. A requested byte count shows what was asked for, not that the transfer completed; the two reads of the Android package record none. That the download served as a decoy is our assessment.
It makes a Bitrise service fetch a URL of its choosing
The attacker made our code-signing identity lookup service fetch a URL it chose. This confirmed server-side request forgery (SSRF): making a server fetch an attacker-chosen URL. At 21:33 UTC, our edge received /_i6084_probe_missing from our own egress address, using Go-http-client/2.0. The attacker had been probing the service from 95.40.73.129.
Service egress metrics also recorded requests to internal-only service names on Oct 25–26. These establish internal requests, not what their response bodies contained. The i6084 canary path followed the task-numbered naming pattern in the scanning user agents.
Outcome: Server fetch confirmedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on egress metrics showing URL-fetching workloads contacting internal destinations and edge logs showing probe paths requested from your own egress addresses.
The first line is the edge canary; the last four are hourly service-egress metrics. Distinct internal destinations are generalized, and Bitrise’s egress address is not an attacker indicator.
It tries common exploit paths; every request returns 404
The attacker sent a short burst of POST requests to common exploit and administration paths for Axis2, Webmin, Artifactory, Drupal and Redfish. Every recorded request in this burst returned HTTP 404: the requested route was not found.
Outcome: Requests refusedEvidence grade: VerifiedShown directly by a log record.
How to catch thisFlag request logs showing bursts of unrelated product-login and exploit paths from a source also scanning services or testing accounts.
EvidenceEdge request logs (CDN/WAF)5 lines
2026-10-26T14:07Z POST app.bitrise.io /axis2-admin/login 4042026-10-26T14:09Z POST <internal-host> /session_login.cgi 4042026-10-26T14:11Z POST app.bitrise.io /user/register?element_parents=account/mail/%23value&ajax_form=1&_wrapper_format=drupal_ajax 4042026-10-26T14:12Z POST <internal-host> /artifactory/ui/auth/login 4042026-10-26T14:15Z POST app.bitrise.io /redfish/v1/SessionService/Sessions/ 404
Selected POST requests from 95.40.73.129. These results describe this burst, not every service or route.
A German server creates accounts with no follow-on activity
From 185.197.251.16, a Contabo address in Germany, two probe-named accounts were created and confirmed between 19:01 and 19:10 UTC. Nine more pqp<digits> accounts followed between 20:05 and 21:09 UTC. None of the nine confirmed its email or signed in.
This address is assessed as noise generation only, with no follow-on activity from it. The link to the attacker is inferred from naming, not a shared authenticated session. The nine never-confirmed email addresses are not published because nothing shows the attacker controlled those mailboxes.
Outcome: Sign-ups observedEvidence grade: CorrelatedEach fact is verified; the link between them is inferred from timing or fingerprints.
How to catch thisCorrelate account logs showing probe-named sign-ups and high nonconfirmation rates with other incident indicators rather than disposable-mail domains alone.
bsd3b8a0f967@maxxspace.com pqprobe386873 created 2026-10-30 19:01:33 ip 185.197.251.16bsc69064bfb3@maxxspace.com probe387344 created 2026-10-30 19:09:47 ip 185.197.251.16pqp390718 Oct 30 20:05 <email omitted> 0pqp391294 Oct 30 20:15 <email omitted> 0pqp391428 Oct 30 20:17 <email omitted> 0pqp391973 Oct 30 20:26 <email omitted> 0pqp394149 Oct 30 21:02 <email omitted> 0pqp394257 Oct 30 21:04 <email omitted> 0pqp394365 Oct 30 21:06 <email omitted> 0pqp394473 Oct 30 21:08 <email omitted> 0pqp394581 Oct 30 21:09 <email omitted> 0
The last column in the nine later rows is recorded sign-ins; the last sign-up is available only to the minute. The noise-only reading is the investigation's assessment, not a logged fact; disposable-mail domains alone do not establish the link.
A possibly related address creates seven accounts that stay unused
A China Telecom address, 60.173.247.xxx, created seven accounts in about 32 seconds. Six usernames followed the probe<digits> pattern. None of the seven accounts ever signed in.
This burst is possibly related, with low confidence. The only links are the probe-style usernames and timing between the October and November activity. We withhold the first username because it reads like a personal name, and the email addresses because nothing shows the attacker controlled those mailboxes.
Outcome: Sign-ups observedEvidence grade: CorrelatedEach fact is verified; the link between them is inferred from timing or fingerprints.
How to catch thisFlag account logs showing rapid sign-up bursts with probe-style names, but require additional evidence before linking them to an existing attacker.
<username omitted> Nov 4 06:35:49 <email domain omitted> 0probe3196914374 Nov 4 06:36:07 <email domain omitted> 0probe2229013017 Nov 4 06:36:08 <email domain omitted> 0probe2640930265 Nov 4 06:36:11 <email domain omitted> 0probe1140114712 Nov 4 06:36:14 <email domain omitted> 0probe1114832364 Nov 4 06:36:18 <email domain omitted> 0probe2618023238 Nov 4 06:36:21 <email domain omitted> 0
All rows are sign-ups from 60.173.247.xxx, and the last column is recorded sign-ins; no shared session or credential ties them to the attacker. The network is China Telecom, AS4134, Anhui, China, which does not identify the operator.
Chapter 1Nov 10 – Nov 12
It came back as a customer
Two weeks later the attacker returned from an address in Kuala Lumpur, signed up like any customer and ran its own builds on our machines. It tested whether one customer could reach another's files: every request was refused. One of its builds printed the startup script of the machine it ran on and took the long-lived cloud key inside. That key can only publish utilization metrics, by design, and every other call made with it was denied. Still, the attacker was trying it against our cloud 17 minutes later.
The lessonCustomer build code is untrusted code. Assume it reads everything on the machine, and that whatever it finds is tried elsewhere within minutes.
It returns from Kuala Lumpur and sends 48,084 requests
From 118.100.234.120, a TM Technology Services subscriber-type address in Kuala Lumpur, the attacker made five requests on Nov 10 and 116 on Nov 11. The earliest browser session reported a UTC+8 (China Standard Time) setting. A browser setting is not a location.
From 12:52 to 19:08 UTC on Nov 12, the address sent 48,084 requests in about six hours. One API host received 35,346, mostly using ffuf. The attacker also tried the made-up hostname label zzq-random-nonexist-9182 to test how wildcard DNS and routing handled a name with no deployed service.
48,084Nov 12 requests
35,346requests to one API host
Outcome: Scanning observedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on request logs showing rapidly rising per-source volume and Host or SNI labels matching no deployed service, especially alongside ffuf traffic.
The browser time-zone setting is a reported observation, not established by this request-count excerpt. The made-up hostname label is from the responders' record; internal hostname suffixes are omitted.
It reaches cloud metadata; the response contents remain unknown
The URL-fetching service received **three HTTP 200 responses from 169.254.169.254**, the cloud metadata address, while the attacker probed it. These appeared in the 14:00–15:00 UTC hourly metric bucket. SSRF reached that destination, but the metric contains neither the request path nor the response body.
Whether anything sensitive came back is not established. HTTP 200 alone does not prove a token was returned. We took the service offline on Nov 14.
Outcome: Contents unknownEvidence grade: VerifiedShown directly by a log record.
How to catch thisMonitor service egress metrics for cloud metadata addresses and retain request paths and response context to distinguish successful requests from token theft.
The timestamp marks an hourly bucket, not an individual request. The service-offline action is from the responders' record; the metadata response contents remain unknown.
It confirms an account 21 seconds after signing up
The attacker created wanyyj999@gmail.com, username auwiqns, from 118.100.234.120 at 14:00:41 UTC. It confirmed the account at 14:01:02 UTC, 21 seconds later, and received its own workspace. At 14:05 UTC, the edge recorded a successful sign-in request from the same address.
Outcome: Account confirmedEvidence grade: VerifiedShown directly by a log record.
How to catch thisJoin account-creation and confirmation logs to earlier source-address scanning so a new account does not reset an existing risk signal.
wanyyj999@gmail.com username auwiqns created 2026-11-12 14:00:41 confirmed 2026-11-12 14:01:02118.100.234.120 2026-11-12 14:01:02 → 18:49:47Cloudflare: 2026-11-12T14:05Z 118.100.234.120 POST app.bitrise.io <sign-in endpoint> 201
The second line is the account’s sign-in-IP window, not a continuous connection. The edge sign-in time is available only to the minute; its endpoint path is generalized while method, timestamp and status are retained.
It asks for other tenants’ signing files; every request is refused
The attacker created personal access tokens and two workspace API tokens, then requested signing and project file lists for six public open-source apps in other tenants. It tested whether changing an app identifier could bypass ownership checks. Every file-list request to those tenants returned HTTP 404. A separate outgoing-webhook check returned HTTP 403.
The attacker created idor-probe-812 and made the same file-list requests against its own app as a control. Those returned HTTP 200. A public-app listing returned public data as designed. The workspace-token service users were created at 14:38:02 and deleted around 14:38:22 UTC.
Outcome: File requests refusedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on request logs showing one account receiving 404 or 403 across unowned sensitive resources while matching requests to its own resource return 200.
EvidenceApplication request logs13 lines
2026-11-12T14:34:20.433 GET /v0.1/apps/<app>/android-keystore-files 4042026-11-12T14:34:31.935 GET /v0.1/apps/<app>/build-certificates 4042026-11-12T14:34:39.631 GET /v0.1/apps/<app>/provisioning-profiles 4042026-11-12T14:34:43.011 GET /v0.1/apps/<app>/generic-project-files 4042026-11-12T14:34:43.842 GET /v0.1/apps/<app>/build-certificates 4042026-11-12T14:34:44.317 GET /v0.1/apps/<app>/provisioning-profiles 4042026-11-12T14:35:42.464 GET /v0.1/apps/<app>/provisioning-profiles 200 (own app idor-probe-812)2026-11-12T14:35:43.302 GET /v0.1/apps/<app>/android-keystore-files 200 (own)2026-11-12T14:35:43.715 GET /v0.1/apps/<app>/generic-project-files 200 (own)2026-11-12T14:35:59.558 GET /v0.1/organizations/<workspace>/apps 2002026-11-12T14:36:38.475 GET /v0.1/apps/<app>/build-certificates 4042026-11-12T14:36:39.178 GET /v0.1/apps/<app>/build-certificates 200 (own)CDC workspace-token service users: <service-account>, <service-account> created 14:38:02, deleted ~14:38:22
The six-app scope comes from request and ownership records. These rows show the file-list and control calls, made with curl/7.88.1; the separate 403 webhook result is not among them. None of these requests disclosed another tenant’s files.
The attacker created i871-probe, i901a and i901b, pointing them at octocat/Hello-World, a public placeholder repository. The first build started at 15:07:22 UTC. These builds ran attacker-written scripts on our build machines. Its earlier control app, idor-probe-812, had already been deleted.
The account’s credentials were also used from our own egress address between 15:06:51 and 15:11:48 UTC. That timing is consistent with build scripts calling the Bitrise API from inside our network, rather than another external attacker address.
Outcome: Build scripts ranEvidence grade: VerifiedShown directly by a log record.
How to catch thisCorrelate account logs showing new placeholder-repository builds with platform API requests from build egress and immediate build-log retrieval.
repo <app> idor-probe-812 <app> created 14:35:38 (deleted 14:38:31)repo <app> i871-probe <app> created 15:06:39repo <app> i901a <app> created 15:28:32repo <app> i901b <app> created 15:28:37builds (repo <app> unless noted), all stack ubuntu-latest-stable:15:07:22 probe 15:09:09 probe 15:10:31 probe (<app>) 15:25:59 probe 15:26:33 probe 15:29:24 i901probe (<app>)<our own egress address> 2026-11-12 15:06:51 → 15:11:48
Build execution and the internal-origin credential-use window are directly recorded; their causal link is inferred from timing. The earlier control app had been deleted before these builds.
The attacker tried many hostnames, including internal ones. Where it found them is not established. A likely source is Certificate Transparency logs: every publicly trusted TLS certificate is recorded there, so any hostname that has ever had one is public.
It sent 61 requests to an internal security information and event management (SIEM) hostname. The tool behind it had been decommissioned, so every request returned HTTP 502.
The attacker also requested sign-in and configuration endpoints on an internal LLM chat UI, Open WebUI. Its sign-in attempts failed.
Outcome: Sign-ins refusedEvidence grade: VerifiedShown directly by a log record.
How to catch thisThere is not much to catch here. The lesson is that forgotten services and public pages will be probed: expect these agents to try every hostname that has ever had a public TLS certificate. Clean up leftover services to shrink your attack surface, and treat every hostname with a public certificate as public information.
EvidenceLoad-balancer request logs8 lines
61 entries, 2026-11-12T15:08:47 → 16:03:41, all status 502 statusDetails=failed_to_pick_backende.g. 16:00:55 GET https://<internal-host>/_cat/indices ; 16:00:56 /_search ; 16:01:02 /_security/_authenticate ; 16:01:23 /wazuh15:30:17 GET /api/v1/auths/signin 20015:30:49–15:30:50 POST /api/v1/auths/signin 400 (x3)15:30:51 POST /api/v1/auths/oauth/google/login 40515:32:01 GET /api/v1/ollama/config 200 15:32:02 GET /api/v1/openai/config 200 15:32:02 GET /api/v1/rag/config 20015:42:05 GET /api/v1/tools 200 15:45:09 GET /api/config 20016:08:26–16:09:40 GET /oauth/google/login 302 (x2)
The first two lines are SIEM load-balancer records from 118.100.234.120; the remaining excerpts are Open WebUI application access records. Configuration response codes are not an assertion about their contents.
It extracts a long-lived cloud key; every recorded call is denied
A build printed its machine’s startup script, which contains a long-lived cloud key that can only publish metrics. The key sends utilization figures such as CPU and memory to our dashboards. This is by design: we know that customer-controlled build code can read it, and we accept that. The build log recorded the extraction under the banner === I871C START.
About 17 minutes later, at 15:27:12.062 UTC, the same key was used from 118.100.234.120. All 32 recorded cloud API calls on Nov 12 were denied. Another 50 calls from 74.211.97.67 on Nov 13 were also denied.
Outcome: Recorded calls deniedEvidence grade: VerifiedShown directly by a log record.
How to catch thisWatch for the replay. Expect every secret an agent like this collects to be tried elsewhere within minutes, to probe for wider access. Here the key was in use from the attacker’s address about 17 minutes after the build printed it.
EvidenceThe attacker's own build log12 lines
=== I871C START Thu Nov 12 03:10:36 PM UTC 2026 ===startup_script_bytes=22859--- attribute keys ---startup-scriptjson_type= service_accountproject_id= <project>client_email= <service-account>first last total ok ip2026-11-12T15:27:12.062 2026-11-12T18:11:10.380 32 0 118.100.234.120 UA Python-urllib/3.12 and curl/7.88.12026-11-13T16:44:22.757 2026-11-13T19:53:34.334 50 0 74.211.97.672026-11-12T15:31:35Z secretmanager ListSecrets projects/<project> → PERMISSION_DENIED (IAM_PERMISSION_DENIED)2026-11-13T21:38:39Z DisableServiceAccountKey by <employee> from <responder address>
The build log and service-account JSON analysis establish extraction; our records match that key to later cloud-audit calls without publishing credential material. Nov 13 retries and disablement fall outside this step’s Nov 12 window, and denied calls cannot rule out unlogged metric publishes.
It reuses October’s public links, connecting the two phases
From 118.100.234.120, the attacker reopened install-page links for 11 apps, all in the October list of 70 used by 95.40.73.129. Reusing the same links with unguessable hashes ties the October and November activity to the same attacker.
These sharing pages are public by design. Cloud storage recorded 11 successful object reads for three private customer apps, while other requested objects were missing. Five of those reads were for the customer penetration-testing app first fetched in October. These reads were not unauthorized access. The 56 page requests count page access, not successful object reads or unique downloaded files.
11apps from October list
11successful object reads
3private customer apps
Outcome: Link reuse confirmedEvidence grade: VerifiedShown directly by a log record.
How to catch thisCorrelate sharing-link request logs across source networks to identify reuse of the same unguessable links after earlier scanning and downloads.
EvidenceCloud audit logs (Google Cloud)6 lines
Cloudflare 118.100.234.120 /app/*/installable-artifacts/*/public-install-page/*: 56 requests 2026-11-12T16:12Z–16:20Z (200 x48, 404 x8), 11 distinct appsGCP storage.objects.get by <service-account> (signed URL), callerIp 118.100.234.120:first last n status app2026-11-12T16:21:36.296 2026-11-12T16:22:08.018 5 OK apps/<app> (private, <workspace>)2026-11-12T16:21:37.002 2026-11-12T16:21:57.076 4 OK apps/<app> (private, <workspace>)2026-11-12T16:21:44.514 2026-11-12T16:21:55.980 2 OK apps/<app> (private, <workspace>)
All 11 November app identifiers appeared among the 70 October apps, linking the activity beyond similarities in tools or names. Page requests and object reads measure different operations; NOT_FOUND means missing objects, not expiration.
It tries several credential types; none authenticates
The attacker tried the build-agent control-plane API with a build-scoped JWT, a signed token intended for a build. It also tried a personal access token and an agent token. Logs recorded **66 authentication failures from 118.100.234.120**. None of the reviewed requests authenticated.
Outcome: Authentication refusedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on authentication logs showing one source cycling credential header types against a control-plane API and repeatedly failing; never log credential values.
The 66-failure summary ends at 18:38:10.920 UTC, but a credential-specific excerpt continues to 18:38:44 UTC; the broader window is retained without adding those rows to 66. Credential values, prefixes and internal service names are omitted.
It runs twelve more probing builds and fetches their logs
The attacker ran twelve more builds, then fetched each build’s log through the API. The workflow names advertised test areas: i1040probe, i1170certs, i1170den, i1170den2, i1170den3, i1222, i1222b, i1222c, i1246net, i1246net2, i1246net3 and i1294probe.
The numbers are interpreted as ARTEX task (“intent”) numbers leaking into workflow names, not successful-attack counts. October’s i5938 and i6084 are higher than these November numbers, suggesting a separate or reinstalled ARTEX database. The counters are per installation, may include other targets and have gaps, so they cannot measure the work directed at Bitrise.
Outcome: Probing builds ranEvidence grade: CorrelatedEach fact is verified; the link between them is inferred from timing or fingerprints.
How to catch thisCorrelate workflow and API logs showing numbered probe, certificate or network names followed by repeated build-log fetches; use names as context, not proof.
Build times and names are directly recorded, but the ARTEX counter interpretation and database inference come from naming and code, not an ARTEX execution log. The log-retrieval excerpt illustrates requests rather than listing all twelve build-log fetches.
It moves the same account, app and token to a Los Angeles server
At 19:13 UTC, the attacker used its existing token from 74.211.97.67, a rented Cluster Logic server in Los Angeles, to read its own i871-probe app. This was the first request from that address. At 19:19:43 UTC, the auwiqns account’s recorded sign-in IP changed to it.
The same account, app and token moved from the Kuala Lumpur address to the Los Angeles server. That continuity ties the two addresses together. It does not establish the operator’s physical location.
Outcome: Account move confirmedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on token and account logs showing an account associated with probing moving from a subscriber network to a rented server.
EvidenceEdge request logs (CDN/WAF)3 lines
2026-11-12T19:13:00Z 74.211.97.67 GET api.bitrise.io /v0.1/apps/<app> 200 curl/7.88.1CDC: <attacker account> current_sign_in_ip = 74.211.97.67 from 2026-11-12 19:19:43WHOIS 74.211.97.67: Cluster Logic Inc (CL-1210) — same registrant as 74.82.199.230
Application change history supplies the account-IP change, and our records identify the first request’s existing token and app. This is stronger evidence than shared user agents or a provider match; the shared provider alone does not link 74.82.199.230.
Chapter 2Nov 13 · 09:37 – 16:30 UTC
One dormant account
At 11:46:48 UTC the attacker signed in to an internal test bot account that had not been used since 2022. It had no two-factor authentication and still belonged to the internal workspace that builds and tests our open-source build steps. Less than nine minutes later the attacker was reading that workspace's secrets; before eleven minutes had passed it was using cloud keys. From there it chained one credential into the next: our signing files, build logs, secrets and private repositories. Where the bot's password came from is not established.
The lessonThe door was not a software flaw. It was an account everyone had forgotten, still holding its keys.
It probes the docs site, but the edge blocks the request
The attacker tried server-side request forgery (SSRF), making a server fetch a URL of its choosing. Its request to docs.bitrise.io combined a cloud-metadata URL with a path aimed at /etc/passwd. The edge blocked it before it reached the origin. This was the first recorded block for 74.211.97.67.
Outcome: Blocked at edgeEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on URL-fetching endpoints receiving metadata-address URLs or filesystem traversal paths, including requests blocked at the edge.
EvidenceEdge request logs (CDN/WAF)1 line
2026-11-13T09:37:00Z 74.211.97.67 GET docs.bitrise.io /og ?url=http://169.254.169.254/latest/meta-data/&path=../../etc/passwd&image=http://evil/… 403 origin=0 action=block
At 11:46:48 UTC, the attacker signed in to a dormant internal test bot account. Two more sign-ins followed within 20 seconds. Starting at 11:45 UTC, one sign-in attempt each on three other bot accounts had been refused. Created in 2018 and last used in November 2022, the account still belonged to the internal workspace that builds and tests Bitrise's open-source build steps.
Two-factor authentication was off. No password reset was requested, and no single sign-on identity was linked. That history points to password-based entry, but does not prove it. Where the password came from is not established.
3sign-ins in 20 seconds
Outcome: Signed inEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert when a long-inactive privileged account signs in from a new network, especially after failed attempts on neighboring machine accounts.
2026-11-13 11:46:48 u 15→16 1→0 74.211.97.67 NULL2026-11-13 11:47:04 u 17→18 1→0 74.211.97.67 NULL2026-11-13 11:47:08 u 19→20 1→0 74.211.97.67 NULLCDC identities: no rows for user <employee> (no SSO/OAuth login)user <employee> member Organization <workspace> (snapshot 2025-06-20; removed 2026-11-13 19:26:43)
The selected change-history rows show sign-in counts, failed counts, source IPs and password-reset timestamps. Request logs record three refused attempts on other bots, not a failed attempt on this bot.
It requests signing files and creates its own access tokens
One minute and 48 seconds after the sign-in, the attacker requested an Apple provisioning profile, which identifies where an app can run. It requested a build certificate at 11:48:40 UTC and an app's workflows at 11:48:47 UTC. Published research on ARTEX campaigns describes the same targeting of Apple signing certificates and provisioning profiles.
At 11:54:45 UTC, the attacker created two web authentication tokens for itself under the compromised bot account. The signing responses returned links, not proof that every linked file was downloaded.
Outcome: Signing links returnedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on signing-material requests followed by token creation immediately after a dormant account resumes activity.
EvidenceApplication request logs6 lines
11:48:36 | Provisioning profile of <app> | Apple signing11:48:40 | Build certificate of <app> | Apple signing11:48:47 | Workflows of <app> | Shows which secrets its builds use11:54:45 | Creates 2 website auth tokens as the bot | A third at 14:06:52GET /api/app/<app>/build_certificate/show.json 200GET /api/app/<app>/prov_profile_document/show.json 200
Request logs give the exact seconds and token creation; the edge excerpt groups signing requests into the 11:48 UTC minute. Token creation was at T+7m57s.
Eight minutes and 41 seconds after the sign-in, the attacker began revealing secrets in clear text through the web interface. It requested each by exact name: BITRISE_API_TOKEN at 11:55:29 UTC, a cloud storage credential at 11:55:43 UTC, then GITHUB_TOKEN at 11:55:49 UTC.
These were Bitrise's own CI secrets, stored in our internal apps. They were not marked protected, so they were masked but an account with access could still reveal them. The initial session covered 29 distinct secret-value paths across about 20 internal apps in roughly the first half hour. It also included chat credentials, certificate passphrases and AWS keys. The revealed values cannot be matched to later credential use.
Outcome: Secrets revealedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on rapid secret-reveal requests across multiple apps, including requests by exact name without a preceding secret-list request.
The initial bot-session excerpt counts 30 reveal requests on 29 distinct paths; it does not cover the later, broader set of secret requests. Whether the names were known beforehand or learned from the workflows is not established.
Ten minutes and 37 seconds after the sign-in, the attacker began using cloud service-account keys from its address. This was about two minutes after the first cloud credential reveal. The first identity's calls were denied. A build-steps project identity for Terraform, an infrastructure configuration tool, made 396 successful calls out of 454 over the day.
Secret values are not logged, so which secret became which key is linked by timing, not proven. The first three cloud identities made reads, listings and project lookups. No create, update, delete or permission-change calls were recorded.
396 / 454successful / total calls for one key
Outcome: Some keys workedEvidence grade: CorrelatedEach fact is verified; the link between them is inferred from timing or fingerprints.
How to catch thisCorrelate secret-reveal events with first-seen external use of service-account keys in the following minutes.
The rows show first and last calls, total and successful calls, then the redacted principal and key. Only reads, listings and project lookups are recorded for these three identities.
Twelve minutes and 34 seconds after the sign-in, the attacker downloaded the first Apple signing file from cloud storage. It downloaded up to 81 Apple signing files from the primary and backup buckets. Other successful reads included App Store Connect API keys and Android keystores. These were Bitrise's own signing files.
It also read certificate passphrases from internal build-step apps at 12:23–12:26 UTC. It tried AWS keys found in secrets from 12:05 UTC. Those calls were denied because the key had already been rotated.
81Apple signing files, upper bound
Outcome: Signing files readEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on external reads of signing-file objects and correlate them with certificate-passphrase reveals and denied use of already-rotated cloud keys.
The selected cloud rows generalize object names; the 81-file upper bound also includes later backup reads. The passphrase window and AWS denial are from our records; no raw AWS request excerpt is shown.
It reads build logs of Bitrise’s own apps, and 13 customer logs
Through the API, the attacker read about 870 build logs from Bitrise’s own internal apps between 12:22 and 17:33 UTC. Build logs can contain secrets that were not masked.
In the same activity it read 13 diagnostic build logs from May 2026 that belonged to customers. They contain short snippets of source or test code, a few lines at a time; one contained a credential and another an email address. Every customer concerned was contacted.
The cloud-storage downloads at 15:40–17:33 UTC were the same reads, not additional logs.
about 870build logs from Bitrise’s own apps
13customer diagnostic logs
Outcome: Build logs readEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on one identity or source retrieving build logs across many apps, joining API requests and signed storage downloads so they are not counted twice.
EvidenceCloud audit logs (Google Cloud)2 lines
principal <service-account> (signed URL) callerIp 74.211.97.67first 2026-11-13T15:40:05.088 last 2026-11-13T17:33:08.629 819 storage.objects.get, 819 OK
The storage rows cover only part of the API activity. In total about 880 build logs were read across 52 apps: 13 customer diagnostic logs, and the rest from Bitrise’s own internal apps. Storage downloads must not be added to that total.
It uses an engineer's token to reach more internal workspaces
Thirty-six minutes and 15 seconds after the sign-in, the attacker used an engineer's API token from 74.211.97.67. The real engineer was active from another country. The token opened more than 20 internal workspaces.
The attacker then read CI secrets broadly across those workspaces: 1,842 single-secret requests were answered HTTP 200 on 385 of Bitrise's own internal apps. This is an upper bound on requests, not a count of returned values: an empty answer also returns 200, and secret values are not logged.
It targeted code-host, container-registry, package-registry, edge-provider, chat and observability tokens, cloud keys and an SSH private key. How the engineer's token was obtained is not established.
385internal Bitrise apps with single-secret HTTP 200s (upper bound)
Outcome: Broader internal accessEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on an API identity used concurrently from different countries and on sudden secret-list or reveal activity across many workspaces.
EvidenceApplication request logs4 lines
74.211.97.67 2026-11-13 12:23:03 → 17:28:05 (attacker)<employee> show 12:24:44.605 → 17:27:56.376 75 reads / 75 paths<employee> index 12:41:18.277 → 16:40:54.112 139 / 1332,656 secret-list requests on 1,087 apps and 1,842 single-secret requests answered 200 on 385 apps over 626 names (rehydrated logs; upper bound).
The identity-specific excerpt covers fewer requests than the full set of recorded requests. Every app counted in the last line was one of Bitrise's own internal apps. No exact secret-to-token match is established.
It fails to sign in to more bots, but another token works
The attacker made nine more sign-in attempts on other bot names from 12:41 to 12:56 UTC. All failed. It separately used an internal service account's token to list builds and read build logs from 12:45:55 to 12:58:56 UTC. How it was obtained is not established.
Outcome: Partly workedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on repeated bot-account sign-in failures and on service-account tokens used from a network absent from their normal history.
EvidenceApplication request logs5 lines
A second round of 9 logins on other bot names (12:41–12:56) all failed.<employee> current_sign_in_ip 74.211.97.67 2026-11-13 12:45:55 → 12:58:56 (8 sign-ins)12:48:51 GET /v0.1/apps/<app>/builds?limit=5012:52:20 GET …/builds/<build>/log12:54:06 GET …/builds/<build> (python-requests/2.34.2)
Request logs record the failed sign-ins and selected build requests. Database change history gives the service-account interval.
The attacker tried about 40 harvested cloud service-account keys in seven minutes. Most were denied. A few worked with narrow rights, including bucket listings in a small number of projects. How each key was obtained is not established.
about 40cloud keys tried in seven minutes
Outcome: Most keys deniedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert when one external source presents many distinct service-account identities within minutes, including identities whose calls are all denied.
The rows show selected principal counts; the approximate key count and exact window are from the responders' record. The listed counts are operations, not resources or downloaded files.
It uses a sandbox key to read secrets and infrastructure state
The attacker used a sandbox project's test key with broad rights: 957 of its 1,040 calls succeeded. It read 44 distinct secrets through 123 successful value-read requests in Secret Manager, the cloud secret store. These included a GitHub App private key and the build control plane's admin secret.
It also read Terraform state for test environments, records of deployed infrastructure that can contain credentials. Secret names alone do not prove which later credential use came from each read. How the test key was obtained is not established.
957 / 1,040successful / total calls
44distinct secrets read
123successful secret-value reads
Outcome: Sandbox secrets readEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on test identities reading many distinct secrets or infrastructure-state objects, especially from outside their expected automation networks.
Selected audit-log rows have secret and resource names generalized. This project had secret-value read audit logging enabled; the excerpt supports value-read requests rather than merely secret-name listings.
It clones private code, but a push changes nothing
The attacker used two deploy keys, credentials for repository access, to clone Bitrise's private repositories. A push at 15:06:05 UTC, seven seconds after a clone, changed nothing. No repository reference update was recorded, and no build was triggered. How the keys were obtained is not established.
Outcome: Cloned without changesEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on deploy-key use outside CI networks and on push attempts by credentials that normally only clone repositories.
Our records show no repository reference update after the legitimate 12:58:52 UTC update. A recorded push operation is not proof that a change landed; the reason it changed nothing is not established.
It tries control-plane credentials, but every request is rejected
The attacker tried about 20 forged or misused JSON Web Tokens (JWTs), signed authentication tokens, against the build control-plane admin API. All were rejected. Requests presenting the stolen admin secret were also rejected. The attempts began before our investigation and continued during the response.
Outcome: Authentication rejectedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on repeated control-plane authentication failures that cycle through token formats and credential-header types from one source.
EvidenceApplication request logs2 lines
2026-11-13T19:38:56Z 2026-11-13T19:39:23Z 2 … <admin-secret-header>:<secret> Cf-Connecting-Ip:74.211.97.67Success check: same query with -"Failed to authenticate" → 0 results.
The rows show admin-secret failures and a check that found no accepted requests. Our records show about 20 JWT attempts during 16:11–19:52 UTC; credential values are omitted.
It uses a bot token to clone eight internal repositories
The attacker used a bot account's classic personal access token to clone eight internal repositories. Cloning began at 16:30:20 UTC and continued after our investigation started. A GitHub token revealed earlier is a possible source. How it was obtained is not established.
8internal repositories cloned
Outcome: Internal code clonedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on bot tokens cloning multiple private repositories from a first-seen external address.
Repository names, bot identity and all authentication fragments are omitted. The first clone time is not the time at which responders detected the access.
Chapter 3Nov 13 · 16:32 – 21:57 UTC
The race
We started investigating at 16:32 UTC, started a platform-wide shutdown at 19:26 UTC and switched the platform off at 20:34 UTC. The attacker did not stop: keys it had already copied still worked directly against cloud and code-hosting services. For two and a half more hours both sides moved at once, the attacker trying each key and we revoking them. The last successful call with a stolen key was recorded at 21:57:50 UTC.
The lessonShutting your own platform down does not revoke keys that have already left it. Each one has to be killed where it is honored.
The race, to scale
Attacker above the line, Bitrise below. Select a mark to jump to its step.
We began investigating suspicious behavior at 16:32 UTC. The attacker continued expanding access while the investigation was under way.
Outcome: Investigation startedEvidence grade: ReportedA response action taken from the responders’ record.
EvidenceResponders' incident record1 line
November 13, 16:32 UTC. Promptly after identifying suspicious behavior, an investigation was initiated; meanwhile, the attacker expanded their access as the investigation was under way.
The attacker tried more user-account tokens between 17:39 and 20:06 UTC. Requests for three additional user accounts began at 18:33:09.770 UTC, with four requests recorded. How the tokens were obtained is not established.
Outcome: More tokens triedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert when one external address presents tokens for several user identities, even if each identity makes only one or two requests.
The broader token-trial window begins at 17:39 UTC; the three-account, four-request record begins later and does not identify three distinct employees. The rows give no response status codes.
We declared a SEV-1, our highest incident level, at 17:42 UTC. At first the attack seemed contained. Then new findings kept arriving, and the facts were changing by the minute.
Outcome: SEV-1 declaredEvidence grade: ReportedA response action taken from the responders’ record.
EvidenceResponders' incident record1 line
We declared a SEV-1, our highest incident level at 17:42.
The time is from Bitrise's published preliminary review of Nov 18, 2026.
It uses an existing OAuth grant to read Workspace data
The attacker used an employee's OAuth grant, permission previously given to an internal app to call Google Workspace APIs. It made 61 API calls covering calendar entries, the internal directory and two internal spreadsheets.
No attacker address was recorded signing in to a Workspace account. This access used an existing grant, so login records alone would not show it. How the grant's credentials were obtained is not established.
61Workspace API calls
Outcome: Workspace data readEvidence grade: VerifiedShown directly by a log record.
How to catch thisMonitor OAuth-token and API-activity reports as well as sign-ins, and alert on calendar or directory enumeration from a first-seen network.
The token-event report ends at 18:05:12 UTC; the separate document-access report includes an event at 18:05:13 UTC. Document titles, IDs, the employee identity and the OAuth client ID are omitted.
It uses an engineer's cloud login to read infrastructure state
The attacker used an engineer's own cloud command-line login rather than a service-account key. All 294 recorded calls succeeded, including 237 Terraform state-object reads. State can contain plain-text credentials as well as infrastructure details. How the credential was obtained is not established.
294 / 294successful / total calls
237Terraform state-object reads
Outcome: State objects readEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on personal cloud command-line credentials used from hosting-provider networks and on unusual batches of infrastructure-state reads.
The operation breakdown is selective, not a reconciliation of all 294 calls. The 237 state-object GETs are operations, not an assertion of 237 unique files.
It tests webhooks, but internal access remains unproven
The attacker sent four probes against a nonexistent workspace, then 23 test-webhook requests from its own workspace. Those 23 requests ran from 19:26:55 to 20:06:30 UTC. Every one returned HTTP 404. The feature asks Bitrise's server to fetch a supplied URL, making this another SSRF attempt.
The destination URLs are not logged. An HTTP 404 does not establish whether an internal destination was reached.
Outcome: All returned 404Evidence grade: CorrelatedEach fact is verified; the link between them is inferred from timing or fingerprints.
How to catch thisAlert on repeated test-webhook requests and log their destinations safely so private, link-local and metadata targets can be identified.
EvidenceApplication request logs5 lines
2026-11-13T19:20:46Z POST /workspaces/nope/outgoing-webhooks/test 40119:20:49 POST /workspaces/nope/outgoing-webhooks 4012026-11-13T19:23:30Z POST /workspaces/nope/outgoing-webhooks/test 42219:23:38 POST /workspaces/nope/outgoing-webhooks 4222026-11-13T19:26:55Z → 20:06:30Z POST /workspaces/<workspace>/outgoing-webhooks/test 404 x23
The logs record the requests and response codes, but not their destinations or any resulting internal access. The SSRF interpretation follows the feature's URL-fetching behavior.
We triggered a platform-wide shutdown at 19:26 UTC, within minutes of observing access to some of Bitrise's own private GitHub repositories. It included backend systems, databases, secret access, all data centers and GitHub access. Previously issued credentials did not all stop working at that moment.
Outcome: Shutdown triggeredEvidence grade: ReportedA response action taken from the responders’ record.
EvidenceResponders' incident record2 lines
November 13, 19:26 UTC. Platform-wide shutdown was triggered within minutes once we observed access to some of Bitrise's own GitHub private repositories.The shutdown included: backend systems, databases, secret access, all data centers and GitHub access.
The time and scope of the shutdown are from the responders' record.
We remove the bot's membership and lock its account
We removed the dormant bot from the internal build-steps workspace at 19:26:43 UTC and locked its account at 19:34:38 UTC. This contained the entry account, but did not revoke credentials already copied from its workspace.
Outcome: Bot access removedEvidence grade: VerifiedShown directly by a log record.
It uses an organization-wide key to reach 502 cloud projects
The attacker began using an organization-wide infrastructure key created in 2022. It made 2,779 calls, with 2,183 successes, touching 502 cloud projects. Not every request in every project succeeded.
Across multiple credentials, the attacker downloaded 236 production Terraform state files between 19:32 and 20:15 UTC. This began before this key's first recorded use, so the total is not attributed to this key alone. We treated every secret in those files as exposed and rotated it.
Cloud monitoring counted 46 successful value-read requests to the cloud secret store by this identity in a production project from 20:16 to 20:28 UTC. Value-read audit records were unavailable there, leaving secret names and links to later credential use unproven. How the key was obtained is not established.
2,183 / 2,779successful / total calls
502cloud projects touched
236production state files across credentials
Outcome: Broad cloud reachEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert when one infrastructure identity enumerates hundreds of projects or begins reading production secrets and state from an external network.
The final line counts AccessSecretVersion calls in cloud monitoring, not value-read audit records. The 236 state files span multiple credentials and must not be added to state-object operation counts.
It uses more credentials to clone infrastructure repositories
The attacker used a second bot token, an internal GitHub App's private key and a machine deploy key to clone infrastructure repositories. It used the internal App to create an installation token, a credential scoped to one installation, before a clone. The final machine-key burst cloned ten repositories in about four minutes.
Across the whole day, it cloned 28 private repositories, not 28 additional repositories in this interval. How each credential was obtained is not established.
28private repositories cloned all day
Outcome: Infrastructure code clonedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on installation-token creation outside backend networks and on machine identities cloning many infrastructure repositories in a short burst.
GitHub masks the last IP octet; App IDs, token fragments, repository names and key fingerprints are omitted. This internal App is different from the Bitrise GitHub App used later.
From 20:28 UTC, our edge began challenging 74.211.97.67, with 125 recorded challenges and two blocks. All requests to internal hostnames from 20:29 to 20:57 UTC were challenged. This enforced those routes, but did not revoke cloud keys or tokens at other providers.
Outcome: Challenged and blockedEvidence grade: VerifiedShown directly by a log record.
We switched the platform off at 20:34 UTC, 68 minutes after starting the shutdown. Keys the attacker had already copied still worked directly against cloud and code-hosting services until each one was revoked.
Outcome: Platform offEvidence grade: ReportedA response action taken from the responders’ record.
EvidenceResponders' incident record2 lines
At 19:26 UTC, we started shutting down our backend systems, database, secret access, all data centers, and GitHub access.We switched off the platform at 20:34 UTC.
The times are from Bitrise's published preliminary review of Nov 18, 2026.
It uses the Bitrise GitHub App key to create a token
The attacker used the Bitrise GitHub App's private key. The recorded sequence contains one installation listing, one token created for Bitrise's own installation and one repository listing. These are API operations, not a repository-clone count.
The only period in which the attacker could have created access tokens for the Bitrise GitHub App was November 13, 20:46:15–20:53:12 UTC. Such a token is valid for at most one hour. We have no indication that any customer repository was accessed through the App. How the private key was obtained is not established.
Outcome: App token createdEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on GitHub App private-key authentication and installation-token creation from addresses outside your backend networks.
EvidenceGitHub audit log export4 lines
2026-11-13T20:46:15Z GET /app 200 JWT <app> 74.211.97.xxx2026-11-13T20:46:15Z GET /app/installations 200 JWT <app>2026-11-13T20:46:38Z POST /app/installations/<installation>/access_tokens 201 JWT <app>2026-11-13T20:46:53Z GET /installation/repositories 200 INTEGRATION_SERVER_TO_SERVER <app>
The token-creation window and customer-impact assessment are from the responders' record. GitHub masks the final octet of the address in its export; identifiers are omitted.
We delete and replace the Bitrise GitHub App's private key
We deleted the Bitrise GitHub App's private key at 20:53:12 UTC and replaced it, ending the period in which the attacker could create access tokens. An already-issued token is valid for at most one hour.
Customers can check their own GitHub audit logs for activity by the Bitrise GitHub App from 74.211.97.67 between November 13, 20:46 and 21:53 UTC.
Outcome: App key replacedEvidence grade: ReportedA response action taken from the responders’ record.
EvidenceResponders' incident record3 lines
The only period in which the attacker could have created access tokens for the Bitrise GitHub App was 7 minutes on November 13:from 20:46:15 UTC until we deleted the App's private key at 20:53:12 UTC.A token of this kind is valid for at most one hour.
The key was deleted at 20:53:12 UTC and replaced at 20:53 UTC; these times and the customer audit-log check are from the responders' record.
It lists a build-machine log bucket with a remaining key
The attacker used a log-uploader key to list a bucket holding build-machine logs. The key made 676 calls, with 641 successes. Successful listings do not establish that the listed objects were downloaded. How the key was obtained is not established.
641successful calls
Outcome: Log bucket listedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert when upload-only workflow identities enumerate their storage buckets from external networks or continue operating during credential containment.
EvidenceCloud audit logs (Google Cloud)1 line
<service-account> key <key> 2026-11-13T21:03:27.648 → 21:57:50.906 676 calls, 641 OK
The row shows 676 calls, with 641 successes. These listings are separate from the archive downloads made with another identity.
The attacker downloaded 1,535 build-machine log archives during the response. These were separate from the earlier API build-log reads and the log-uploader key's bucket listings.
1,535build-machine log archives
Outcome: Machine logs downloadedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on bulk reads from build-machine log storage, including activity continuing through a key-disable operation.
The row counts 1,539 successful read operations on the archive bucket; our records count 1,535 distinct archives downloaded. Operations and archives measure different things.
The disable operation is directly logged. Later successful activity is recorded under the same identity; our records identify already-issued access tokens as the reason it continued.
We disable the metrics key after its recorded calls are denied
We disabled the metrics-publishing key at 21:38:39 UTC. It had been taken from a build machine in the previous chapter. The attacker had tried it again 50 times between 16:44:22.757 and 19:53:34.334 UTC. Every recorded call in that interval was denied.
Outcome: Metrics key disabledEvidence grade: VerifiedShown directly by a log record.
EvidenceCloud audit logs (Google Cloud)2 lines
2026-11-13T16:44:22.757 2026-11-13T19:53:34.334 50 0 74.211.97.672026-11-13T21:38:39Z DisableServiceAccountKey by <employee> from <responder-address>
The first row counts recorded calls and successful calls for the metrics identity. It does not cover unlogged metrics-publishing operations.
It makes its last recorded successful cloud API call
The remaining log-uploader key made the last successful cloud API call recorded from the attacker's addresses at 21:57:50 UTC. Later attempts with other keys were denied. This marks the last observed cloud success, not the end of requests or proof that every access path was visible.
Outcome: Last recorded successEvidence grade: VerifiedShown directly by a log record.
How to catch thisContinue monitoring denied credential use after the last success, keeping separate timelines for cloud APIs, application access and edge blocks.
EvidenceCloud audit logs (Google Cloud)2 lines
Latest successful non-anonymous call from any attacker IP: 2026-11-13T21:57:50.906Denied after 21:30: <service-account> (23/24, 0 OK), <service-account> (0 OK), <service-account> (13, 0 OK)
The audit-log timestamp has subsecond precision and falls within the 21:57:50 UTC second. Later denied attempts are not evidence that requests ceased.
Chapter 4Nov 14
It kept knocking
After the shutdown the attacker kept checking its tokens every 15–40 minutes through the night, retried the URL-fetching trick, and went looking for control systems named in the infrastructure files it had taken. Everything it tried with stolen credentials was refused. One question from this day stays open and we mark it as such: whether the URL-fetching service returned anything sensitive before we took it offline.
The lessonContainment is not the end of the incident. Keep watching the blocked sources: they show you what the attacker thinks it still has.
It keeps checking its tokens, but the API blocks every check
From 02:15 UTC, 74.211.97.67 checked the API every 15–40 minutes, then loaded a sign-in page outside the edge protection. The API checks returned HTTP 403. No login attempt was recorded in this overnight pattern.
Across Nov 14, the address sent 1,544 requests. Of these, 357 received HTTP 403 on api.bitrise.io. About 600 targeted the URL-fetching service and returned HTTP 400 or 503. Loading a public sign-in page did not restore access.
1,544requests on Nov 14
357HTTP 403 API responses
about 600HTTP 400/503 URL-fetching responses
Outcome: Checks blockedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on edge logs showing repeated blocked token checks followed by sign-in-page loads from the same source after containment.
EvidenceEdge request logs (CDN/WAF)2 lines
74.211.97.67 2026-11-14 first 02:15Z GET api.bitrise.io /v0.1/me 403 curl/7.88.1Every 15–40 minutes overnight: a token check on the API (blocked), then the sign-in page on a host <edge protection> didn't cover. No login attempt.
The second line is the request-log summary; the daily totals include later activity, not just the overnight checks.
It tries two routes to the deployment controller; both refuse access
The attacker tried an internal deployment controller through the edge at 11:35–11:53 UTC. It then tried an identity-checking access proxy at 13:45–14:01 UTC. Both routes refused access. The second burst contained 12 requests, all redirected by the proxy before reaching the controller.
12requests stopped at the proxy
Outcome: Access refusedEvidence grade: VerifiedShown directly by a log record.
How to catch thisCorrelate edge-log denials with later access-proxy requests for the same internal service from the same source.
EvidenceLoad-balancer request logs2 lines
74.211.97.67 → <internal-host>, 12 requests 2026-11-14T13:45:42–14:01:36, all 302 handled_by_<access-proxy><internal-host> on 11-14, through <edge> (11:35–11:53) and <access-proxy> (13:45–14:01): all refused.
The first line is the load-balancer record; the second summarizes both routes from the responders' record.
It makes the URL-fetching service contact cloud metadata again
The attacker retried SSRF, making a server fetch a URL of its choosing. In the 12:00 UTC hourly metric bucket, the URL-fetching service contacted 169.254.169.254: one response was HTTP 200, two were 403 and three were 404. A request to metadata.google.internal received 403. Whether anything sensitive came back is not established.
At 13:00:00 UTC, the test path /nope-1774 reached our edge from our own egress address with Go-http-client/2.0, returning 404. This showed the server fetching the attacker’s chosen path. We took the service offline that day.
Outcome: Response unknownEvidence grade: Not establishedWe could not prove this with the data available.
How to catch thisAlert on application egress logs showing metadata-address requests and edge logs showing attacker test paths arriving from your own egress address.
Metadata times identify an hourly metric bucket, not exact request times; neither requested paths nor response bodies are recorded. The third line proves the test-path fetch; the service shutdown time is not recorded.
At 12:49 and 13:07 UTC, the attacker tried a stolen personal access token three times in the query string. All three requests returned HTTP 401.
At 14:17 UTC, 118.100.234.120, the Kuala Lumpur address used earlier in the attack, returned for six requests. Responses were HTTP 403 or 302: blocks or redirects, not successful reads.
Outcome: Access refusedEvidence grade: VerifiedShown directly by a log record.
How to catch thisWatch application logs for rejected query-string credentials and edge logs for renewed requests from previously linked attacker addresses.
EvidenceApplication request logs2 lines
A stolen PAT tried 3× in the query string (12:49, 13:07; 401).118.100.234.120 2026-11-14 14:17Z: GET api.bitrise.io / 403 ; GET <internal-host> / 302
The first line summarizes application logs; the second is an edge-log record.
An account signs up, but its workspace creation fails
At 16:28:53 UTC, an account signed up through Google as u04tjp6@gmail.com from 74.82.199.230. The only link to the attack is a correlation: this address and 74.211.97.67 share the hosting provider Cluster Logic Inc.
Workspace creation failed three times with HTTP 500 between 16:28:54 and 16:29:24 UTC. No further activity was seen in this session. The account was locked at 20:19:30 UTC.
Outcome: Workspace creation failedEvidence grade: CorrelatedEach fact is verified; the link between them is inferred from timing or fingerprints.
How to catch thisReview sign-up logs for accounts from a blocked source’s hosting provider, but do not treat provider overlap alone as proof.
It requests control-plane credentials by name and gets refused
At 19:02–19:09 UTC, the attacker requested an internal certificate authority’s certificate chain, client certificate and access token by exact name. It used a key from outside our organization. The requests were denied. Across Nov 13–14, that key made 70 cloud calls with no successes. The names appear in the stolen Terraform state, files describing deployed infrastructure. We infer that those files told it where to look.
At 19:15–19:21 UTC, it probed a device-management service with an already-rotated token. It fetched an enrollment profile, but device and command-queue API requests were refused. Fetching the profile did not establish control of devices.
70cloud calls on Nov 13–14; zero successes
Outcome: Access refusedEvidence grade: CorrelatedEach fact is verified; the link between them is inferred from timing or fingerprints.
How to catch thisAlert on cloud audit logs showing exact-name requests for control-plane credentials listed in infrastructure state, especially from keys outside your organization.
EvidenceResponders' incident record4 lines
<service-account>@<project> 2026-11-13T13:00:54 → 2026-11-14T19:09:56 70 calls, 0 OK<internal-PKI> on 11-14 (19:02–19:09): CA chain, client cert and ACL token requested by exact name with an out-of-org key, all denied.The names fit the stolen Terraform state.<device-management-service> on 11-14 (19:15–19:21): enrolment profile fetched, device and enqueue APIs tried with an already-rotated token.
The record shows credential requests, denials and an enrollment-profile fetch. The 70-call total covers Nov 13–14, not just the 19:02–19:09 requests.
It gets a public diagnostic response, not renewed access
The attacker’s last event in application logs was at 19:45:25 UTC. Its last edge request was at 19:47 UTC: /cdn-cgi/trace with curl/8.7.1, answered HTTP 200. This public diagnostic response did not show renewed access to sensitive resources.
The last successful cloud API call recorded from the attacker’s addresses remained at 21:57:50 UTC on Nov 13.
Outcome: Public response onlyEvidence grade: VerifiedShown directly by a log record.
How to catch thisTrack last-seen requests in application and edge logs separately from successful cloud audit operations; public HTTP 200 responses do not prove sensitive access.
EvidenceEdge request logs (CDN/WAF)2 lines
Last attacker event in our logs 19:45:25; last sighting in <edge> 19:47.last 19:47Z GET <internal-host> /cdn-cgi/trace 200 curl/8.7.1
The application-log cutoff is from the responders' record; the edge log records the later public request.
EpilogueNov 18 · 20:24 – 21:19 UTC
It came back. Nothing opened.
Five days later the attacker returned for 55 minutes and replayed what it had stolen: the old accounts, a cloud key, app identifiers, a secret name, the exact path of an infrastructure state file. Every attempt to read anything was denied or rejected. The one thing that worked was creating a new account, which never confirmed its e-mail, never signed in and was banned. We watched it live, holding it in a tarpit: our responses to it were deliberately slowed.
The lessonA denied request made with a retired credential is the best alarm you will ever get: the attacker is telling you what it took.
The Nov 18 session, to scale
55 minactive, 20:24:10–21:19:55 UTC
0successful reads of secrets, buckets or apps
19Google Cloud requests, all denied
1new account created (i3694canary)
Swipe sideways to see the whole chart.
Denied
Rejected
Neutral
Success
A time above a mark: a key event
All 33 events
The Nov 18 session, to scale: every event
Time (UTC)
Lane
What
Result
20:24:10
Google Cloud
First event. Without credentials, tries listing the bucket holding our Apple signing files (curl/7.88.1).
Denied: denied
20:25:27–20:25:55
Bitrise web
Loads the sign-in page 3×.
Neutral: 200
20:26:07
Bitrise web
Tries signing in as the old bot account.
Rejected: 401
20:26:35
Bitrise web
Tries signing in as its original account, auwiqns.
Rejected: 401
20:27:13–20:30:35
Bitrise API
Checks for a working token about every 10 seconds: /v0.1/me, /me/profile/organizations.
Rejected: 401
20:27:34
Bitrise web
Requests a cloud-key secret from an internal app in the workspace that builds and tests Bitrise's open-source build steps.
Rejected: 404
20:29:29
Bitrise API
Requests an internal documentation-site app using the short form of its ID.
Rejected: 404
20:31:27–20:31:43
Google Cloud
Uses a cloud key stolen on Nov 13, then no credentials, to try listing both Apple signing-file buckets and an internal CI storage bucket.
Denied: denied
20:35:01–20:36:55
Bitrise API
Checks tokens at /v0.1/me.
Rejected: 401
20:39:27–20:39:34
Bitrise web
Requests GET / and the sign-in page.
Neutral: 302 / 200
20:39:58–20:41:07
Bitrise API
Requests the internal documentation-site app's details, secrets and latest build.
Rejected: 404
20:40:45–20:41:18
Bitrise web
Requests /me/account 2× with a bare Mozilla/5.0 user agent.
Rejected: 401
20:41:46–20:44:23
Bitrise API
Checks /v0.1/me; 3× HTTP 499 because the agent gave up on deliberately slowed responses.
Rejected: 401
20:44:38–20:44:39
Google Cloud
Uses the stolen cloud key to request Secret Manager ListSecrets in four production projects.
Denied: denied
20:49:30–20:50:39
Bitrise web
Requests GET /, the sign-in page and /v0.1/me.
Neutral: 302 / 200 / 401
20:51:21–20:53:50
Bitrise web
Tries signing in as auwiqns 5×.
Rejected: 401 / 422
20:52:44–20:54:44
Bitrise web
Requests the internal documentation-site app's page, .json and /settings.
Rejected: 401
20:54:39
Google Cloud
Without credentials, tries listing the infrastructure state bucket.
Denied: denied
20:56:20–20:57:49
Bitrise API
Requests the internal documentation-site app's details, build certificates and provisioning profiles.
Rejected: 401
20:57:31–20:58:27
Bitrise web
Tries the internal documentation-site app's build/start.json 3×, including 2× without parameters.
Rejected: 400 / 401
20:59:19
Bitrise web
Requests the internal documentation-site app's secrets.
Rejected: 404
20:59:44–21:00:02
Bitrise web
Loads the sign-in page and tries signing in.
Rejected: 200 / 401
21:00:23–21:01:16
Bitrise web
Requests the internal documentation-site app's page and .json, 2× each.
Rejected: 401
21:03:03–21:04:42
Bitrise web
Opens the sign-up page 2×.
Neutral: 200
21:05:01
Bitrise web
Creates a new account, i3694canary, with a new personal Gmail address.
Success: created
21:05:20
Bitrise web
Requests the app list.
Rejected: 401
21:05:39
Bitrise web
Tries its own new user ID as a workspace ID.
Rejected: 404
21:05:58
Bitrise web
Requests its own API tokens.
Rejected: 401
21:06:17–21:07:13
Bitrise web
Opens the email-confirmation page 2× and makes one more sign-in attempt.
Neutral: 200 / 401
21:15:00–21:16:01
Bitrise API
Requests GET /, then /v0.1/apps 3×.
Rejected: 200 / 401
21:18:00–21:18:52
Google Cloud
Without credentials, requests a service-account Terraform state object in the infrastructure state bucket by exact path: 2× read, 2× list.
It returns with the accounts and cloud key; access is refused
The attacker returned from 118.100.234.120. At 20:24:10 UTC, it tried listing the bucket holding our Apple signing files without credentials, using curl/7.88.1. Google Cloud denied the request.
It loaded the sign-in page, then tried the bot account and its original account, auwiqns. Both sign-ins returned HTTP 401, as did token checks. At 20:31:27–20:31:43 UTC, it tried a cloud key stolen on Nov 13, then no credentials, against signing-file buckets and an internal CI storage bucket. All those cloud requests were denied.
Outcome: Access refusedEvidence grade: VerifiedShown directly by a log record.
How to catch thisCorrelate cloud audit denials for key replay and anonymous bucket requests with application-log sign-in failures from the same source.
EvidenceResponders' incident record4 lines
["20:24:10", null, "gcp", "First event. No credentials: lists <bucket> (curl/7.88.1)", "denied", "denied", 1],["20:26:07", null, "web", "Sign-in as the bot <bot-account>", "401", "rejected"],["20:26:35", null, "web", "Sign-in as its original account auwiqns", "401", "rejected"],["20:31:27", "20:31:43", "gcp", "Uses the <cloud-key>, then no credentials: lists both Apple certificate/profile buckets and <bucket>", "denied", "denied", 1],
Redacted rows from the combined cloud and application event log.
It retries secret reads and a build trigger; all are refused
The attacker used the stolen cloud key to ask Secret Manager to list secrets in four production projects. Every request was denied. It also requested an internal documentation-site app’s details, secrets, build certificates, provisioning profiles and a build trigger. These returned HTTP 401, 404 or 400. A request for a cloud-key secret in the internal build-steps workspace returned 404.
Token checks kept failing. Three requests ended with HTTP 499 because the attacker’s client gave up waiting on responses we were deliberately slowing. Public sign-in pages still loaded, but did not provide access to the resources it tried to read.
Outcome: Requests refusedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on cloud audit and application logs showing a blocked source replaying known app identifiers and secret names.
EvidenceResponders' incident record4 lines
["20:41:46", "20:44:23", "api", "/v0.1/me; 3× 499: it gave up on slowed responses", "401", "rejected"],["20:44:38", "20:44:39", "gcp", "<cloud-key>: Secret Manager ListSecrets in <project>, <project>, <project>, <project>", "denied", "denied", 1],["20:56:20", "20:57:49", "api", "<app> app: details, build certificates, provisioning profiles", "401", "rejected"],["20:57:31", "20:58:27", "web", "<app> build/start.json, 3× (2× with no parameters)", "400 / 401", "rejected"],
Redacted event-log rows; HTTP 499 records the abandoned requests, not a successful response. The cloud-key secret request occurred earlier, at 20:27:34 UTC.
It creates i3694canary, but its requests are refused
The attacker opened the reopened sign-up page twice and created i3694canary at 21:05:01 UTC with a new personal Gmail address. Its app-list and API-token requests returned HTTP 401. Using its own new user ID as a workspace ID returned 404.
The account never confirmed its email, never signed in and was banned. Its name correlates with ARTEX’s pattern of i<number> task IDs appearing in the names of things its agents create. We withhold the email address because nothing shows the attacker controlled that mailbox.
Outcome: Sign-up onlyEvidence grade: CorrelatedEach fact is verified; the link between them is inferred from timing or fingerprints.
How to catch thisWatch application logs for accounts from known attacker sources whose first requests target tokens, app lists or workspace identifiers.
EvidenceResponders' incident record4 lines
["21:05:01", null, "web", "Creates a new account, i3694canary (new personal Gmail address)", "created", "success", 1],["21:05:20", null, "web", "App list", "401", "rejected"],["21:05:39", null, "web", "Its own new user ID (<attacker-user-id>) tried as a workspace ID", "404", "rejected"],["21:05:58", null, "web", "Its own API tokens", "401", "rejected"]
Account activity is recorded directly. The naming comparison is with the public ARTEX source code: its workers use directories named after task IDs, and the things they create carry that prefix.
It requests a Terraform state file by path and is refused
After more rejected app-list requests, the attacker requested a service-account Terraform state object in our infrastructure state bucket without credentials. Between 21:18:00 and 21:18:52 UTC, two read attempts and two list attempts were denied.
Another /v0.1/apps request returned HTTP 401 at 21:19:17 UTC. The last recorded event was a public GET / at 21:19:55 UTC, answered with a 302 redirect.
Outcome: Access refusedEvidence grade: VerifiedShown directly by a log record.
How to catch thisAlert on cloud audit logs showing anonymous requests for infrastructure state by exact path, especially from a source that previously accessed infrastructure inventory.
It makes no successful reads during the 55-minute session
The recorded session ran from 20:24:10 to 21:19:55 UTC: 55 minutes. All 19 Google Cloud requests were denied. Nine sign-in attempts on the two old accounts were all rejected (HTTP 401 or 422). There were zero successful reads of secrets, buckets or apps. The only action that worked was a sign-up: i3694canary never confirmed its email, never signed in and was banned.
Our visibility has limits: edge exports omit allowed traffic to hosts without their own logs, some cloud projects returned collection errors, and a group of system projects was outside the search. We keep monitoring.
19Google Cloud requests denied
9old-account sign-in attempts, all rejected
0successful secret, bucket or app reads
Outcome: Zero successful readsEvidence grade: VerifiedShown directly by a log record.
How to catch thisMeasure post-containment successes and failures across identity, application and cloud logs, and retain explicit gaps in collection coverage.
EvidenceResponders' incident record6 lines
55 minactive, 20:24:10–21:19:550successful reads of secrets, buckets or apps19Google Cloud requests, all denied1new account created (i3694canary)401Its original account auwiqns (<attacker-account>) and the bot <bot-account> (<bot-account-id>): 9 sign-in attempts.Never confirmed its email and never signed in; now banned.
These session totals are not counts of chart rows; one row can cover several requests. Five of the nine sign-in attempts, as auwiqns at 20:51:21–20:53:50 UTC, returned HTTP 401 or 422.
The tool
The tool behind it: ARTEX
ARTEX is an open-source platform that turns large language models into a team of penetration testers. A planner agent breaks a goal into “intents”; worker agents each take one intent, run real tools against the target and write back what they found; the planner reads the results and issues new intents. The operator sets a goal and can walk away.
It was built for authorized testing. Its developer took the project closed-source in autumn 2026, but public forks keep it available, and Check Point Research has documented more than 1,600 live ARTEX servers and several criminal campaigns run with it.
We name the tool because the evidence is unusually direct. Three things we saw in our logs match lines in ARTEX’s public source code that anyone can read.
Fingerprints
1The client string
What we saw
A rare HTTP client, norma/0.4, fetched documentation pages from all three main source addresses: 8 times from Hong Kong, 5 from Kuala Lumpur, 38 from Los Angeles.
What the public code says
ARTEX’s agents are built on an SDK called norma. Its web-fetch tool hard-codes the header.
req.Header.Set("user-agent", "norma/0.4")
norma · tool/webfetch.go, line 188
Hunt for itA user agent containing norma/0.4 is a strong lead: it is the default of the norma agent SDK. Check what else that source did.
2The serial numbers
What we saw
Things the attacker created carried a small i and a number: user agent pentest-probe-i5938/1.0, canary path /_i6084_probe_missing, CI apps and workflows i871-probe, i1170certs, i1246net, i1655nodeopt, and on Nov 18 the account i3694canary.
What the public code says
Each ARTEX worker handles one intent and runs in a working directory named after it. The names we saw fit a model naming what it creates after the folder it works in; that reading is ours.
dir = filepath.Join(dir, "i"+strconv.FormatInt(intentID, 10))
ARTEX · agent/worker.go, line 325 (session name exp<N>-worker-i<intent>, line 107)
Hunt for itNew accounts, CI jobs, hostnames or paths named i<3–5 digits> plus a word such as probe, canary, certs or net.
3The polite introduction
What we saw
In October the scanner rotated through user agents such as authorized-pentest/bitrise-readonly, bitrise-pentest-probe/1.0 (authorized read-only) and authorized-security-research. Nobody had authorized anything.
What the public code says
ARTEX’s default system prompt tells every agent that it belongs to an authorized test. The labels we saw fit agents that take that at face value. The prompt is a default and can be edited.
You are an "executor" (work agent) of a network-security platform's authorized penetration testing system.
ARTEX · agent/worker.go, line 257 (also planner.go line 410, promptcatalog.go line 35)
Hunt for itUser agents that contain your company name next to “pentest”, “probe”, “authorized” or “research” when no test is scheduled.
Behaviour
What we observed
What published research describes
The first thing requested after the stolen sign-in, 1 minute 48 seconds in, was an Apple provisioning profile, then a signing certificate. The first bulk download with a stolen cloud key was Apple signing files.
Check Point Research describes an ARTEX campaign whose stated goal was Apple .p12 signing certificates and provisioning profiles for resale.
The “customer” phase came from a Malaysian subscriber address; the same session then moved to a rented server in Los Angeles.
Operators often route their agents through residential proxies to get around blocks.
Common tools with their default client strings (curl, ffuf, Python’s standard HTTP clients), in activity that ran through days and nights.
Observed ARTEX instances ran default configurations and default tools, almost fully autonomously after the operator set a goal.
The numbers as a rough clock
Evidence grade: CorrelatedEach fact is verified; the link between them is inferred from timing or fingerprints.
Swipe sideways to see the whole chart.
Two panels, two counters: the series are separate counters and each panel has its own vertical scale. Time runs to scale inside each panel. A bar is a reading known only to within that span of time; a line joins readings only where they follow each other closely.
ARTEX stores its agents’ plans (“intents”), facts and findings as rows in one table, numbered by a counter that only goes up. An intent’s number is its row number. Because the agents leaked those numbers into names, we can read the counter at eleven moments.
Between the first build app on Nov 12 at 15:06:39 UTC (i871) and a workflow on Nov 13 at 19:58:19 UTC (i1655) the counter advanced by 784 in 28 hours 52 minutes: on average one new row about every 2.2 minutes, through the night. A row can be a plan, a fact or a finding, so this shows how busy the tool was, not how many attacks it launched.
The October numbers (5938, 6084) are higher than the November ones. That is consistent with October and November running from separate or reinstalled ARTEX databases, which would fit the Hong Kong address being a separate discovery-and-test deployment. The deployment history is not established.
CaveatThis is our reading of public source code, not of an ARTEX log. The counter is shared by every record type and belongs to one ARTEX installation, not to one target, so it is an upper bound on activity aimed at Bitrise.
The 11 readings
Counter value
Seen (UTC)
Where it appeared
Series
5938
some time between and
user agent pentest-probe-i5938/1.0
Counter A
6084
SSRF canary /_i6084_probe_missing
Counter A
871
CI app i871-probe
Counter B
901
CI apps i901a, i901b
Counter B
1040
workflow i1040probe
Counter B
1170
workflows i1170certs, i1170den
Counter B
1222
workflow i1222
Counter B
1246
workflow i1246net
Counter B
1294
workflow i1294probe
Counter B
1655
workflow i1655nodeopt
Counter B
3694
account i3694canary
Counter B
What is established, and what is not
EstablishedThe traffic was produced by ARTEX or software derived from it and its norma agent SDK.
ObservedARTEX is a project of Chinese origin; the earliest browser session reported a China Standard Time (UTC+8) time-zone setting; one possibly related sign-up burst came from a China Telecom address. These are observations about a tool, a browser setting and an address.
Not establishedWhich language model drove the agents.
Not establishedWho the operator is, or where they are. An address is not a person.
For scale: Check Point Research estimates that the ARTEX campaigns it examined cost their operators between $145 and $1,500 in model usage. We did not establish what this one cost.
Why we treat these addresses as one attacker’s activity
This table links activity between addresses. It does not identify a person: who operated the tool is not established.
Link
Strength
Evidence
95.40.73.129 ↔ 118.100.234.120
Strong (3 of 3)
On Nov 12 the Kuala Lumpur address reopened public install-page links for 11 apps. All 11 were among the 70 the Hong Kong address had used on Oct 25. The links contain hashes that cannot be guessed, so both held the same list.
118.100.234.120 ↔ 74.211.97.67
Strong (3 of 3)
The first request ever seen from the Los Angeles address used the attacker’s own app and token, and the attacker account’s recorded sign-in address changed from one (last at 18:49:47 UTC on Nov 12) to the other (from 19:19:43 UTC).
All three
Moderate (2 of 3)
The rare client norma/0.4 on all three; the same curl/7.88.1, Python-urllib/3.12 and ffuf v2.3.0; the same primary target; and i<number> naming in user agents, canary paths, workflow names and, on Nov 18, an account name.
74.211.97.67 ↔ 74.82.199.230
Weak (1 of 3)
Same hosting provider and network owner. Nothing else.
185.197.251.16 and 60.173.247.xxx
Weak (1 of 3)
Probe-style account names and timing between the October and November activity. No shared tooling, links or credentials were observed.
Strength of a link, strongest first
Strong3 of 3
Moderate2 of 3
Weak1 of 3
Impact
What was reached, and what was not
Counts are operations recorded in logs (requests, object reads) unless we say files. “Upper bound” means the log cannot tell an empty answer from a full one.
Which “secret” is which
Bitrise’s own CI secrets
Tokens and keys stored in our internal apps on Bitrise for our own builds. They were not marked protected, so they were masked but could be revealed.
Cloud secret store
Google Secret Manager, where we keep our infrastructure secrets.
Customer secrets
What customers store in Bitrise for their builds. Our logs show no access, and no attempted access, to the store that holds them.
1 code-signing certificate file (the attacker could not access the password needed to open it), 1 provisioning profile and 13 diagnostic build logs from May 2026. The logs contain short snippets of source or test code, a few lines at a time; one contained a credential and another an email address. All 15 customers were contacted immediately.
Bitrise’s own Apple and Android signing files
Owner: Bitrise
Up to 81 of Bitrise’s own Apple signing files (certificates and provisioning profiles) downloaded from cloud storage: 41 from one bucket and 40 from its backup. With the exception of one app, these are sandbox and test certificates used for automation testing, not for production apps. App Store Connect API keys and Android keystores were also read, and certificate passphrases were read from our CI secrets. The attacker also sent certificate and profile list requests through the application. A list request is answered even when an app has no such files, so those requests are not a count of files. Our file-level analysis shows which files were fetched; the two customer files it found are in the first row.
Bitrise’s own CI secrets
Owner: Bitrise
Secret values returned for up to 385 of Bitrise’s own internal apps (upper bound) through the web interface and API, using the bot account and then an engineer’s API token. These secrets were not marked protected: they were masked, but an account with access could still reveal them.
Infrastructure state (Terraform)
Owner: Bitrise
236 production state files and 5 staging ones downloaded. Every secret inside them was treated as exposed and rotated.
Source code
Owner: Bitrise
28 private Bitrise repositories cloned, mostly deployment configurations. One push was attempted; it changed nothing.
Bitrise’s own build logs and build-machine logs
Owner: Bitrise
About 870 build logs from Bitrise’s own internal apps, and 1,535 log archives from our build machines. The machine logs are operational records: they mention customers by name or ID in places, but contain no customer confidential data. Build logs can contain secrets that were not masked. No customer logs are counted in this row.
Read3
Google Cloud
Owner: Bitrise
8,725 audit entries from the attacker’s addresses through Nov 14, 5,662 successful, across 72 identities (18 with at least one successful call). For the first three identities the recorded calls were reads, listings and project lookups, with no create, update, delete or permission-change calls.
Cloud secret store
Owner: Bitrise
These are Bitrise’s infrastructure secrets in Google Secret Manager. Audit logs show 44 secrets read in a sandbox project (123 reads). Separately, in one production project where read logging was not enabled at the time, monitoring metrics count 46 successful reads by the organisation-wide key; the names of those secrets are not available. We treated every secret we manage as exposed and rotated it.
Employee calendar and directory
Owner: Bitrise
61 API calls through one employee’s OAuth grant for an internal app: calendar entries, the staff directory and two internal sign-up sheets. The Google Workspace login reports we reviewed show no sign-in from the attacker’s addresses.
Partial1
GitHub Apps
Owner: Bitrise
The private keys of two GitHub Apps were used to authenticate. For the Bitrise GitHub App the only window in which tokens could have been created was 20:46:15–20:53:12 UTC (7 minutes) on Nov 13. We have no indication that any customer repository was accessed through the App.
Refused2
Other customers’ files through the API
Owner: Customers
The attacker’s own account asked for code-signing files of six apps in other tenants. Every request was refused (HTTP 404).
Control planes
Owner: Bitrise
The build-agent control plane, a second cloud provider, the deployment controller, device management and the internal certificate authority were all tried with stolen or forged credentials. None gave it control. One device-management enrolment profile was fetched; the device and command APIs refused.
Untouched2
The store that holds customer secrets
Owner: Customers
Our logs show no access and no attempted access.
Integrity of our code and releases
Owner: Bitrise
We found no change. One push was attempted and no branch moved. Release-related storage was read and listed; we found no attempt to modify it. The code itself was copied: see “Source code” above.
Customer impact
Most of what the attacker accessed was Bitrise’s own: internal credentials, some of our repositories, and operational records such as infrastructure configuration and build-machine logs. Those records mention customers by name or ID in places, but contain no customer confidential data.
Files in 15 customer workspaces were accessed without authorization. The attacker downloaded 1 code-signing certificate file, but could not access the password needed to open it; 1 provisioning profile; and 13 diagnostic build logs from May 2026 containing short snippets of source or test code, a few lines at a time. One log contained a credential, and another an email address.
All 15 customers were contacted immediately. For every other workspace, our file-level analysis found no evidence of the customer’s secrets, code-signing files, build artifacts or source code in what the attacker accessed.
Our logs show no access, and no attempted access, to the store that holds customer secrets.
Secrets, tokens and certificates you store in Bitrise
If we have not contacted you: no indication of access, safe to use. As a precaution, rotate them: Protected Secret Masked Review shows the last four characters of each one to help you identify it. If we contacted you, follow the notice you received.
Bitrise GitHub App
Private key replaced on Nov 13 at 20:53 UTC and all user authorizations revoked. Safe to reconnect: authorize the App again.
GitHub OAuth connection
All tokens revoked and the client secret rotated on Nov 13. Safe to reconnect your GitHub account in Bitrise.
SSH deploy keys added by Bitrise
Removed by GitHub when the OAuth tokens were revoked. Safe to re-add after reconnecting.
Build OIDC tokens
Signing key replaced. Safe to use; nothing to do.
Site-to-site VPN
All credentials rotated for every customer that uses it. Safe to re-enable with the new credentials we sent you.
Build infrastructure and build cache
Rebuilt from trusted sources. Safe to use; nothing to do.
A check only you can run
This applies if you have the Bitrise GitHub App installed and your repositories on github.com can be reached from anywhere on the internet, that is, your organization does not restrict access with an IP allow list. GitHub does not share one organisation’s logs with another, so this is the one check that can only be done from your side. The only period in which the attacker could have created access tokens for the Bitrise GitHub App was seven minutes on Nov 13: from 20:46:15 UTC until we deleted the App’s private key at 20:53:12 UTC. A token of this kind is valid for at most one hour. In your GitHub audit log, look for activity by the Bitrise GitHub App between Nov 13, 20:46 and 21:53 UTC from 74.211.97.67. We have no indication that any customer repository was accessed through the App.
Platform-wide shutdown startsBackend systems, databases, secret access, all data centers and GitHub access, within minutes of seeing access to some of our own private repositories. The platform was switched off at 20:34 UTC.
GitHub App key replacedSeven minutes after the attacker first used it.
Last successful stolen-key callThe last successful cloud API call recorded from the attacker’s addresses. Every later attempt we recorded to read a protected resource was refused.
Declared resolvedThe immediate security risks had been addressed. Each one returned only after its credentials were rotated and it passed a security review.
The attacker returns55 minutes. Every attempt to read anything was refused.
Root cause
An internal test bot account did not have two-factor authentication. It had originally been set up to validate authentication with the Apple Developer Portal. Its last recorded sign-in was in November 2022, but it still belonged to an internal workspace used to build and test Bitrise build steps. With that access the attacker obtained further internal credentials and used them to reach other internal systems.
StatusClosed. The account was disabled on Nov 13 together with every other bot account. We reviewed every bot account and enforced two-factor authentication on all of them.
What we did
Revoked all potentially affected internal access tokens and sessions.
Revoked all 919 of our cloud service-account keys, including keys we had no reason to suspect.
Rotated every Bitrise-managed production secret and credential, not only those known to be affected.
Revoked every token and key of our GitHub Apps, replaced the Bitrise GitHub App private key, revoked all tokens issued by our GitHub OAuth app and rotated its client secret.
Factory-reset and reinstalled the build infrastructure, Linux and macOS, in all three data centers, from trusted sources.
Brought each service back only after its credentials were rotated and it passed a security review.
Replaced the build OIDC signing key and rotated site-to-site VPN credentials for every customer that uses one.
In total, revoked about 25,000 tokens across Bitrise and GitHub.
What changed
A second factor on every bot account
Every bot account was reviewed. Two-factor authentication is enforced on all of them.
Monitoring, massively expanded
We expanded logging and monitoring across the platform and learned where we had been blind, for example read access to the cloud secret store.
A tarpit: we slowed it down to watch it
We deliberately slowed our responses to the attacker to about one every 8 seconds so we could watch the automation work. This is called a tarpit: instead of blocking an attacker, you answer it slowly, which costs it time and lets you observe it. Its swarm sent so many requests in parallel that even that was hard to follow, so we raised the delay to 16–24 seconds, above all when it came back to scan and try again. The team watched in full incident mode and saw the whole pattern.
AI agents on watch
We deployed AI agents that monitor activity in real time, and gave them the ability to investigate what they see. We are training them on the pattern we watched.
Next: quarantine
We are giving those agents the tools to quarantine suspicious activity on their own, so that containment starts at machine speed too.
In the era of AI-accelerated attacks we need AI-accelerated defense.
Arpad Kun, VP of Engineering and Infrastructure, Bitrise
On November 18 the attacker came back for 55 minutes and replayed what it had stolen: old accounts, an old cloud key, app identifiers, a secret name, an exact path to an infrastructure state file. Every attempt to read anything was denied or rejected.
Lessons
What we would tell another team
Each of these comes from something described above. They are detection ideas, not tested rules: tune them against your own baseline and your own authorized testing.
01
Believe the label
What we sawFor three days the traffic called itself an “authorized pentest” with our company name in the user agent. It also downloaded a customer’s real penetration-testing build through a public link.
What to doAlert on user agents that put your name next to “pentest”, “probe”, “authorized” or “research” when no test is scheduled, even if it looks like a customer’s own pentest. Confirm a test against your own schedule, never against how the traffic looks.
What we sawA test account with no recorded sign-in for almost four years, and no second factor, was still a member of an internal workspace.
What to doInventory bot, test and service identities that sign in with a password. Enforce a second factor or delete them. Alert on any sign-in to an account idle for months.
What we sawOur own CI secrets were not marked protected: they were masked, but an account with access could reveal them. The attacker revealed them by exact name, and the first key linked to them was in use two minutes later.
What to doWhere your CI offers protected (write-only) secrets, use them. Alert on bursts of secret reveals by one identity, and correlate every reveal with the first use of any credential from a new network in the following hour. We are removing revealable secrets from Bitrise: all secrets will be protected by default and cannot be revealed. A convenience feature will inevitably be abused.
What we sawThe stolen service-account keys we saw in use came from a rented server or a subscriber address, with a stock Python or curl client.
What to doAlert on any service-account key used from outside your cloud and office ranges. This one rule matches every stolen-key use described in this report.
What we sawAbout 40 different cloud identities were tried from one address in seven minutes; one key touched 502 projects in under two hours.
What to doAlert on distinct principals per source address and on distinct projects per principal. Alert on a principal whose calls are all denied: someone is learning what a key can do.
What we sawAfter listing storage, the agent went straight for Terraform state and for .p12, .p8 and keystore files. Days later it asked for internal resources by exact names that match that state.
What to doRestrict and alert on reads of state and key-material objects by anything other than the pipeline identity. Prefer short-lived workload identity over long-lived keys in state and CI secrets.
What we sawAgainst automation that puts a stolen key to use within minutes, scoping first and containing second loses.
What to doBuild a kill switch into every system that holds sensitive data, so it can be shut down on demand within seconds. Decide in advance who may shut the platform down, and rehearse it. Encourage defenders to dare to make the call: it is not an easy decision, and every second counts. Do not let yourself or your team freeze. Then replace every credential, not only the ones you can prove were touched, and rebuild from trusted sources.
What we sawIt kept trying for a day after the block. A sign-up from the same hosting provider followed, which may be related. Five days later it returned and replayed what it had stolen.
What to doKeep blocked sources, their hosting provider and every stolen identifier under watch. A denied request with a retired credential is a free, high-quality alarm.
76 indicators from this attack, 28 of them new in this report.
Use
how to apply an indicator
Match
an exact value seen in this attack. Search for it as it is.
Correlate
a pattern or behaviour. A hit is a lead to combine with other signals, not proof.
Context
common or benign on its own. Background for an investigation; do not alert on it alone.
Scope
what an indicator identifies
Actor
tied to this attacker: its addresses, accounts and names.
Tool
produced by the tool. Expect it wherever the same software is pointed at another target.
Context
shared or public things the attacker happened to use.
Type
Use
Scope
Status
76 of 76 indicators
Indicators
Value
Type
First / last seen (UTC)
Role
Confidence
Use / scope
Note
74.211.97.67
ipv4
–
Primary operations host: stolen-credential use against Bitrise web/API, Google Cloud, GitHub and Google Workspace APIs
High
MatchActor
WHOIS Cluster Logic Inc (CL-1210), US-CA; Google Workspace reporting shows AS25820. GitHub exports mask the last octet (74.211.97.xxx).
118.100.234.120
ipv4
–
Attacker account registration, attacker-controlled CI builds, fuzzing, reuse of install-page links; returned on Nov 18 for 55 minutes
High
MatchActor
AS4788 TM Technology Services, Kuala Lumpur MY. Subscriber-type address: the address may be reassigned, so corroborate any match, especially outside the seen window.
95.40.73.129
ipv4
–
Discovery and tests: reconnaissance, throw-away account registration, artifact downloads via install-page links, SSRF probing
High
MatchActor
AWS AS16509, geolocated HK. Cloud address, reassignable: the address may be reassigned, so corroborate any match, especially outside the seen window. 36,698 requests in window.
74.82.199.230
ipv4
–
One account sign-up after the primary host was blocked
Low
CorrelateActor
Linked only by hosting provider (same WHOIS org as 74.211.97.67). Do not block or alert on this alone.
185.197.251.16
ipv4
–
11 probe-named account registrations in about two hours; assessed as noise generation
Low
CorrelateActor
Contabo GmbH, DE. Linked by account naming and timing only. Do not block or alert on this alone.
pentest-probe-i5938/1.0
user agent
–
Scanner user agent (12,813 requests)
High
MatchTool
The number is consistent with an ARTEX intent id and will differ in your logs; also hunt the regex row.
Enumeration of an Open WebUI (LLM chat) deployment, including unauthenticated config endpoints
Medium
CorrelateActor
If you run Open WebUI or similar, check what these endpoints return without authentication.
GET /app -> GET /app/installations -> POST /app/installations/{id}/access_tokens -> GET /installation/repositories -> git clone
api sequence
–
GitHub App private-key abuse sequence, from authentication to token creation in 11 and 23 seconds for the two Apps
High
CorrelateActor
Behavioural. For your own GitHub Apps: any JWT-authenticated call from an address that is not your app backend.
60.173.247.xxxNew
ipv4 masked
–
Possibly related: 7 account registrations in 32 seconds, six named probe<digits>, never used
Low
ContextActor
Last octet withheld: this address is linked by naming and timing only. China Telecom, CHINANET Anhui province network, AS4134, CN. Do not block or alert on this network.
pentestprobe-1d2bf9New
username
–
Platform username of a throw-away probe account
High
MatchActor
Registered from 95.40.73.129.
pentestprobe-9cede9New
username
–
Platform username of a throw-away probe account
High
MatchActor
Registered from 95.40.73.129.
pentestprobe-280c2cfdNew
username
–
Platform username of a throw-away probe account
High
MatchActor
Registered from 95.40.73.129.
pentestprobe-q7m4z2New
username
–
Platform username of a throw-away probe account
High
MatchActor
Registered from 95.40.73.129.
pentest-probe-v2-mbjlcuxrNew
username
–
Platform username of a throw-away probe account
High
MatchActor
Registered from 95.40.73.129.
pqprobe386873New
username
–
Platform username of a probe-named account
Low
CorrelateActor
Registered from 185.197.251.16; e-mail confirmed.
probe387344New
username
–
Platform username of a probe-named account
Low
CorrelateActor
Registered from 185.197.251.16; e-mail confirmed.
pqp390718New
username
–
Platform username of a never-confirmed sign-up
Low
CorrelateActor
Registered from 185.197.251.16; never confirmed its e-mail, never signed in. The sign-up address is withheld because control of the mailbox by the attacker is not shown.
pqp391294New
username
–
Platform username of a never-confirmed sign-up
Low
CorrelateActor
Registered from 185.197.251.16; never confirmed its e-mail, never signed in. The sign-up address is withheld because control of the mailbox by the attacker is not shown.
pqp391428New
username
–
Platform username of a never-confirmed sign-up
Low
CorrelateActor
Registered from 185.197.251.16; never confirmed its e-mail, never signed in. The sign-up address is withheld because control of the mailbox by the attacker is not shown.
pqp391973New
username
–
Platform username of a never-confirmed sign-up
Low
CorrelateActor
Registered from 185.197.251.16; never confirmed its e-mail, never signed in. The sign-up address is withheld because control of the mailbox by the attacker is not shown.
pqp394149New
username
–
Platform username of a never-confirmed sign-up
Low
CorrelateActor
Registered from 185.197.251.16; never confirmed its e-mail, never signed in. The sign-up address is withheld because control of the mailbox by the attacker is not shown.
pqp394257New
username
–
Platform username of a never-confirmed sign-up
Low
CorrelateActor
Registered from 185.197.251.16; never confirmed its e-mail, never signed in. The sign-up address is withheld because control of the mailbox by the attacker is not shown.
pqp394365New
username
–
Platform username of a never-confirmed sign-up
Low
CorrelateActor
Registered from 185.197.251.16; never confirmed its e-mail, never signed in. The sign-up address is withheld because control of the mailbox by the attacker is not shown.
pqp394473New
username
–
Platform username of a never-confirmed sign-up
Low
CorrelateActor
Registered from 185.197.251.16; never confirmed its e-mail, never signed in. The sign-up address is withheld because control of the mailbox by the attacker is not shown.
pqp394581New
username
–
Platform username of a never-confirmed sign-up
Low
CorrelateActor
Registered from 185.197.251.16; never confirmed its e-mail, never signed in. The sign-up address is withheld because control of the mailbox by the attacker is not shown.
probe3196914374New
username
–
Platform username of a never-confirmed sign-up (possibly related)
Low
CorrelateActor
Registered from 60.173.247.xxx; never signed in. Sign-up addresses used large free-mail providers.
probe2229013017New
username
–
Platform username of a never-confirmed sign-up (possibly related)
Low
CorrelateActor
Registered from 60.173.247.xxx; never signed in. Sign-up addresses used large free-mail providers.
probe2640930265New
username
–
Platform username of a never-confirmed sign-up (possibly related)
Low
CorrelateActor
Registered from 60.173.247.xxx; never signed in. Sign-up addresses used large free-mail providers.
probe1140114712New
username
–
Platform username of a never-confirmed sign-up (possibly related)
Low
CorrelateActor
Registered from 60.173.247.xxx; never signed in. Sign-up addresses used large free-mail providers.
probe1114832364New
username
–
Platform username of a never-confirmed sign-up (possibly related)
Low
CorrelateActor
Registered from 60.173.247.xxx; never signed in. Sign-up addresses used large free-mail providers.
probe2618023238New
username
–
Platform username of a never-confirmed sign-up (possibly related)
Low
CorrelateActor
Registered from 60.173.247.xxx; never signed in. Sign-up addresses used large free-mail providers.
^(pqprobe|pqp|probe)\d{6,10}$New
username regex
–
Family pattern for the probe-named sign-ups
Low
CorrelateActor
Combine with several sign-ups from one address within minutes.
i3694canaryNew
username
–
Account created during the Nov 18 return
High
MatchActor
Registered from 118.100.234.120 with a new Gmail address; never confirmed, never signed in. The number is consistent with an ARTEX intent id.
^i\d{3,5}[a-z-]{0,12}$New
username regex
–
Accounts, apps and jobs named in the ARTEX intent-id style
Medium
CorrelateTool
Examples: i871-probe, i901a, i1170certs, i3694canary. Expect different numbers on your side.
u04tjp6@gmail.comNew
email
–
Account registered with Google sign-in after the primary host was blocked
Low
CorrelateActor
Registered from 74.82.199.230. Linked by hosting provider only.
single sign-in attempts against several bot or test account names from one addressNew
behaviour
–
Three other bot names were tried once each before the successful sign-in to the dormant account; nine more attempts on other bot names failed later; the old accounts were retried on Nov 18
High
CorrelateTool
Alert on single-attempt sign-ins across several machine-account names from one address.
No indicator matches these filters.
Method and limits
What we could not establish
Where the dormant account’s password came from. No reset was requested and no single sign-on identity was linked, so we infer the attacker held the actual password.
How the attacker collected the install-page links it used in October. They contain hashes that cannot be guessed.
Which revealed secret became which credential. Secret values are not logged, so we can show what was revealed and when, and what was used and when, and link them by timing.
Which secrets were read from the cloud secret store in one production project. Read logging was not enabled there, so monitoring gives us a count (46) but no names.
How several later tokens and keys were obtained, including an engineer’s API token and cloud login. Each is marked in its step.
Which language model drove the agents, and who operated them.
Activity inside customers’ own GitHub organisations. GitHub’s exports to us cover our own resources; your own GitHub audit log can show what ours cannot.
Exact totals where logs are sampled or were not retained. Counts from application logs are minimums; counts marked “upper bound” may include empty answers.
Method
Sources: edge request logs, application database change history, application request logs, Google Cloud audit logs swept across every project, cloud monitoring metrics, GitHub audit log exports, Google Workspace audit reports, network registries and the attacker’s own build logs.
Every step is graded. Verified: shown directly by a log record. Correlated: each fact is verified and the link between them is inferred. Not established: we could not prove it. Reported: a response action taken from the responders’ record.
First-seen and last-seen times are when we saw an indicator. They are not proof of when an address was used by the attacker, and they are not safe bounds for your own search.
We have engaged multiple independent digital forensics and incident response firms to verify our findings and actions. That work is ongoing.
AI helped us write this report and build its visuals. The claims, the timeline and the findings were checked by people: our engineers and security engineers. In the age of AI-accelerated attacks, we use AI tools in the response too, so we can report quickly.
This is version 1.3. We will publish corrections with a new version number if the record changes.
Grades and outcomes
Evidence grade of each step
Verified
Shown directly by a log record.
Correlated
Each fact is verified; the link between them is inferred from timing or fingerprints.
Not established
We could not prove this with the data available.
Reported
A response action taken from the responders’ record.
What happened to each attempt
Succeeded
Partly
Refused
Observed
Unknown
Bitrise action
Glossary
ARTEX
An open-source platform that uses language models as autonomous penetration testers: a planner agent hands out tasks and worker agents run real tools.
Intent
ARTEX’s word for one task given to one worker agent. Each has a number.
SSRF
Server-side request forgery: tricking a server into fetching a URL the attacker chose, so the request comes from inside the network.
Canary path
A made-up URL path. If it shows up in your logs coming from your own servers, something inside fetched what the attacker asked for.
IDOR
Asking for another user’s object by changing its identifier in the request, hoping the server forgets to check ownership.
CI secret
A token, password or key stored in a Bitrise app or workspace for builds to use. In this report these are Bitrise’s own, in our internal apps. A secret that is not marked protected is masked, but an account with access can reveal it.
Cloud secret store
Google Secret Manager, where Bitrise keeps its own infrastructure secrets. Not the same thing as CI secrets.
Customer secrets
Secrets that customers store in Bitrise for their own builds. Our logs show no access, and no attempted access, to the store that holds them.
Service-account key
A long-lived password for a program rather than a person. Whoever holds the file can act as that program, within its permissions.
Terraform state
A file describing the infrastructure a configuration manages, often including credentials in plain text.
GitHub App private key
The key an integration uses to prove it is itself to GitHub and request short-lived access tokens.
Deploy key
An SSH key that grants access to a single repository.
Tarpit
A defence that answers an attacker deliberately slowly instead of blocking it. It costs the attacker time and gives defenders time to watch.
TLP:CLEAR
A sharing label meaning there is no restriction: pass it on.