Bitrise security incident report · October–November 2026

Anatomy of an AI-driven attack: What ARTEX looks like in action

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.
What was reached, and what was not

If you defend another company

  • 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.
Indicators and detection ideas

If you want the short version

  • 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.
What we changed

The story

67 steps in 6 chapters, in the order they happened. Every step carries an outcome, an evidence grade and the log lines behind it.

j k 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.

  1. Attacker

    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,698 requests
    • 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.1
    Total requests for the IP (sum of count column): 36698
    12813 pentest-probe-i5938/1.0
    9311 curl/7.88.1
    1074 Mozilla/5.0 (compatible; authorized-pentest/bitrise-readonly)
    819 Fuzz Faster U Fool v2.3.0
    457 Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) research-readonly
    383 Mozilla/5.0 (research; read-only; pentest)
    369 Mozilla/5.0 (compatible; authorized-security-research)
    180 python-requests/2.34.2
    159 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.

  2. Attacker

    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.

    EvidenceCloud audit logs (Google Cloud)4 lines
    first/last/count/succeeded  principal
    2026-10-25T17:31:24.488  2026-10-25T17:33:29.105  59  59  <service-account> (signed URL)
    <bucket>, apps <app>, <app>, <app>, <app>, …
    Application database (repositories): all 12 app slugs have is_public = true.
    

    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.

  3. Attacker

    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.

    EvidenceApplication database change history11 lines
    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:36
    pentest-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:28
    test-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:54
    pentestprobeq7m4z2@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:53
    pentestprobv2mbjlcuxr@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:53
    CDC 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 204
    2026-10-25T21:25Z POST app.bitrise.io <password-reset endpoint> 201
    2026-10-25T21:30–21:32Z PUT <password-reset endpoint> 422 x13, 204 x1
    2026-10-25T21:39Z POST /me/profile/security/activate_two_factor_auth.json 422
    2026-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.

  4. Attacker

    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.

    • 70 apps with opened links
    • 59 successful object reads
    • 13 bucket 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> 200
    GCP storage.objects.get by <service-account> (signed URL), bucket <bucket>:
    first                    last                     n  status  app
    2026-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.

  5. Attacker

    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.

    • 26 successful reads, Oct 25–26
    • 5 successful reads, Nov 12
    • 1 request 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> 200
    GCP 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 MB
    2026-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.

  6. Attacker

    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.

    EvidenceEdge request logs (CDN/WAF)6 lines
    2026-10-25T21:33:00Z <our own egress address> GET <internal-host> /_i6084_probe_missing 404 Go-http-client/2.0 (x3)
    95.40.73.129 → <internal-host>: 8115 requests, 2026-10-25T19:38Z – 2026-10-26T22:55Z
    2026-10-25T20:00 egress_<internal-host> 301 x1
    2026-10-25T20:00 egress_<internal-host> 301 x1
    2026-10-26T08:00 egress_<internal-host> 503 x3
    2026-10-26T08:00 egress_<internal-host>:9000 503 x1
    

    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.

  7. Attacker

    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 404
    2026-10-26T14:09Z POST <internal-host> /session_login.cgi 404
    2026-10-26T14:11Z POST app.bitrise.io /user/register?element_parents=account/mail/%23value&ajax_form=1&_wrapper_format=drupal_ajax 404
    2026-10-26T14:12Z POST <internal-host> /artifactory/ui/auth/login 404
    2026-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.

  8. Attacker

    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.

    EvidenceApplication database change history11 lines
    bsd3b8a0f967@maxxspace.com pqprobe386873 created 2026-10-30 19:01:33 ip 185.197.251.16
    bsc69064bfb3@maxxspace.com probe387344 created 2026-10-30 19:09:47 ip 185.197.251.16
    pqp390718 Oct 30 20:05 <email omitted> 0
    pqp391294 Oct 30 20:15 <email omitted> 0
    pqp391428 Oct 30 20:17 <email omitted> 0
    pqp391973 Oct 30 20:26 <email omitted> 0
    pqp394149 Oct 30 21:02 <email omitted> 0
    pqp394257 Oct 30 21:04 <email omitted> 0
    pqp394365 Oct 30 21:06 <email omitted> 0
    pqp394473 Oct 30 21:08 <email omitted> 0
    pqp394581 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.

  9. Attacker

    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.

    EvidenceApplication database change history7 lines
    <username omitted> Nov 4 06:35:49 <email domain omitted> 0
    probe3196914374 Nov 4 06:36:07 <email domain omitted> 0
    probe2229013017 Nov 4 06:36:08 <email domain omitted> 0
    probe2640930265 Nov 4 06:36:11 <email domain omitted> 0
    probe1140114712 Nov 4 06:36:14 <email domain omitted> 0
    probe1114832364 Nov 4 06:36:18 <email domain omitted> 0
    probe2618023238 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.

  1. Attacker

    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,084 Nov 12 requests
    • 35,346 requests 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.

    EvidenceEdge request logs (CDN/WAF)4 lines
    118.100.234.120 2026-11-10 10:30–10:30 5 req bitrise.io
    118.100.234.120 2026-11-11 14:38–14:48 116 req bitrise.io
    118.100.234.120 2026-11-12 12:52–19:08 48084 req (top) <internal-host> 35346, api 2381, <internal-host> 1726, <internal-host> 1181, <internal-host> 776 (ffuf 481)
    WHOIS: TM TECHNOLOGY SERVICES SDN. BHD., Kuala Lumpur, MY (AS4788)
    

    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.

  2. Attacker

    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.

    EvidenceCloud monitoring metrics2 lines
    2026-11-12T14:00 egress_169.254.169.254 200 x3
    Cloudflare: 118.100.234.120 → <internal-host> 776 req 2026-11-12T13:39Z–17:08Z (481 via ffuf)
    

    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.

  3. Attacker

    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.

    EvidenceApplication database change history3 lines
    wanyyj999@gmail.com username auwiqns created 2026-11-12 14:00:41 confirmed 2026-11-12 14:01:02
    118.100.234.120 2026-11-12 14:01:02 → 18:49:47
    Cloudflare: 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.

  4. Attacker

    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 404
    2026-11-12T14:34:31.935 GET /v0.1/apps/<app>/build-certificates 404
    2026-11-12T14:34:39.631 GET /v0.1/apps/<app>/provisioning-profiles 404
    2026-11-12T14:34:43.011 GET /v0.1/apps/<app>/generic-project-files 404
    2026-11-12T14:34:43.842 GET /v0.1/apps/<app>/build-certificates 404
    2026-11-12T14:34:44.317 GET /v0.1/apps/<app>/provisioning-profiles 404
    2026-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 200
    2026-11-12T14:36:38.475 GET /v0.1/apps/<app>/build-certificates 404
    2026-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.

  5. Attacker

    It runs its own scripts on our build machines

    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.

    EvidenceApplication database change history7 lines
    repo <app> idor-probe-812 <app> created 14:35:38 (deleted 14:38:31)
    repo <app> i871-probe <app> created 15:06:39
    repo <app> i901a <app> created 15:28:32
    repo <app> i901b <app> created 15:28:37
    builds (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.

  6. Attacker

    It probes internal tools; no sign-in succeeds

    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_backend
    e.g. 16:00:55 GET https://<internal-host>/_cat/indices ; 16:00:56 /_search ; 16:01:02 /_security/_authenticate ; 16:01:23 /wazuh
    15:30:17 GET /api/v1/auths/signin 200
    15:30:49–15:30:50 POST /api/v1/auths/signin 400 (x3)
    15:30:51 POST /api/v1/auths/oauth/google/login 405
    15: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 200
    15:42:05 GET /api/v1/tools 200 15:45:09 GET /api/config 200
    16: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.

  7. Attacker

    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-script
    json_type= service_account
    project_id= <project>
    client_email= <service-account>
    first                    last                     total ok ip
    2026-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.1
    2026-11-13T16:44:22.757 2026-11-13T19:53:34.334 50 0 74.211.97.67
    2026-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.

  8. Attacker

    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.

    • 11 apps from October list
    • 11 successful object reads
    • 3 private 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 apps
    GCP storage.objects.get by <service-account> (signed URL), callerIp 118.100.234.120:
    first                    last                     n status app
    2026-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.

  9. Attacker

    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.

    EvidenceApplication request logs6 lines
    first_seen last_seen count message (shortened)
    2026-11-12T17:17:30.595Z 2026-11-12T18:38:10.920Z 66 Failed to authenticate … Cf-Connecting-Ip:118.100.234.120 … User-Agent:curl/7.88.1
    2026-11-12T17:38:59Z 2026-11-12T17:46:29Z 2 … X-Service-Token:<credential omitted> (build-scoped JWT, build <app>, <workspace>)
    2026-11-12T17:38:25Z 2026-11-12T17:46:26Z 2 … X-Api-Key:<credential omitted>
    2026-11-12T18:32:04Z 2026-11-12T18:38:44Z 4 … <agent-token header>:<credential omitted>
    Success check: same query with -"Failed to authenticate" → 0 results.
    

    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.

  10. Attacker

    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.

    EvidenceApplication database change history4 lines
    2026-11-12 18:00:05 i1040probe 18:03:57 i1170certs 18:07:59 i1170den 18:11:00 i1170den2 18:13:19 i1170den3
    2026-11-12 18:30:00 i1222 18:33:51 i1222b 18:36:40 i1222c 18:42:44 i1246net 18:46:55 i1246net2
    2026-11-12 18:49:47 i1246net3 19:19:48 i1294probe (from 74.211.97.67)
    GET /v0.1/apps/<app>/builds/<build>/log at 16:39:54, 19:31:25 …
    

    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.

  11. Attacker

    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.1
    CDC: <attacker account> current_sign_in_ip = 74.211.97.67 from 2026-11-12 19:19:43
    WHOIS 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.

  1. AttackerT−02:10

    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
    

  2. AttackerT+00:00:00

    It signs in to a test account last used in 2022

    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.

    • 3 sign-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.

    EvidenceApplication database change history5 lines
    2026-11-13 11:46:48 u 15→16 1→0 74.211.97.67 NULL
    2026-11-13 11:47:04 u 17→18 1→0 74.211.97.67 NULL
    2026-11-13 11:47:08 u 19→20 1→0 74.211.97.67 NULL
    CDC 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.

  3. AttackerT+00:01:48

    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 signing
    11:48:40 | Build certificate of <app> | Apple signing
    11:48:47 | Workflows of <app> | Shows which secrets its builds use
    11:54:45 | Creates 2 website auth tokens as the bot | A third at 14:06:52
    GET /api/app/<app>/build_certificate/show.json 200
    GET /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.

  4. AttackerT+00:08:41

    It reveals secrets by asking for them by name

    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.

    EvidenceApplication request logs8 lines
    74.211.97.67 <employee> show 2026-11-13T11:55:29.712Z 2026-11-13T12:25:58.370Z 30 29
    11:55:29 /apps/<app>/secrets/BITRISE_API_TOKEN
    11:55:43 /apps/<app>/secrets/<secret>
    11:55:49 /apps/<app>/secrets/GITHUB_TOKEN
    12:22:34 /apps/<app>/secrets/<secret>
    12:24:58 /apps/<app>/secrets/<secret>
    12:25:58 /apps/<app>/secrets/<secret>
    GET /apps/<app>/secrets/BITRISE_API_TOKEN - 200 (OK) 23ms
    

    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.

  5. AttackerT+00:10:37

    It tries cloud keys, and some work

    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 / 454 successful / 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.

    EvidenceCloud audit logs (Google Cloud)3 lines
    2026-11-13T11:57:25.345 2026-11-13T19:53:49.282 86 0 <service-account> <key>
    2026-11-13T11:57:49.175 2026-11-13T19:53:34.333 454 396 <service-account> <key>
    2026-11-13T11:58:40.023 2026-11-13T19:53:50.041 73 2 <service-account> <key>
    

    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.

  6. AttackerT+00:13

    It downloads Bitrise's own signing files

    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.

    • 81 Apple 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.

    EvidenceCloud audit logs (Google Cloud)7 lines
    Selected successful storage.objects.get:
    11:59:22 <bucket>/<signing-file>.p12
    12:03:06 <bucket>/<signing-file>.p8
    12:07:34 <bucket>/<signing-file>.p12
    12:09:36 <bucket>/<signing-file>.keystore
    12:10:03 <bucket>/<signing-file>.p8
    14:34:29–14:35:05 <bucket>/<signing-file>.p12 (15 files)
    

    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.

  7. AttackerT+00:35

    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 870 build logs from Bitrise’s own apps
    • 13 customer 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.67
    first 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.

  8. AttackerT+00:36:15

    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.

    • 385 internal 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 / 133
    2,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.

  9. AttackerT+00:54

    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=50
    12:52:20 GET …/builds/<build>/log
    12: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.

  10. AttackerT+03:12:25

    It tries about 40 cloud keys, but most are denied

    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 40 cloud 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.

    EvidenceCloud audit logs (Google Cloud)6 lines
    principals first used 14:59–15:06 (total / succeeded)
    <service-account> 4/0, <service-account> 4/0, <service-account> 4/0
    <service-account> 33/0, <service-account> 4/0, <service-account> 38/0
    <service-account> 7/0, <service-account> 4/0, <service-account> 29/2
    <service-account> 4/0, <service-account> 5/0, <service-account> 51/1
    <service-account> 5/0, <service-account> 4/0, <service-account> 43/4
    

    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.

  11. AttackerT+03:18:23

    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,040 successful / total calls
    • 44 distinct secrets read
    • 123 successful 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.

    EvidenceCloud audit logs (Google Cloud)6 lines
    principal <service-account> key <key>
    2026-11-13T15:05:11.253 → 19:53:30.736 1040 calls, 957 OK
    AccessSecretVersion OK 15:12:15.937 → 19:36:00.154 123 calls, 44 distinct secrets (projects/<project>/secrets/…):
    <secret>, <secret>, <secret>, <secret>
    + 23 test/sandbox secrets
    storage.objects.get OK: <bucket>/<object>.tfstate, <bucket>/<object>.tfstate, <bucket>/*/<object>.tfstate (12)
    

    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.

  12. AttackerT+03:18:57

    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.

    EvidenceGitHub audit log export5 lines
    2026-11-13T15:05:45Z git.clone deploy_key <repo> key <key>
    2026-11-13T15:05:58Z git.clone deploy_key <repo> key <key>
    2026-11-13T15:06:05Z git.push deploy_key <repo> key <key>
    2026-11-13T15:57:24Z / 15:57:33Z git.clone (x2) <repo>
    protected_branch.rejected_ref_update for this repo: none
    

    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.

  13. AttackerT+04:24

    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.67
    Success 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.

  14. AttackerT+04:43:32

    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.

    • 8 internal 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.

    EvidenceGitHub audit log export5 lines
    2026-11-13T16:30:20Z git.clone <service-account> <repo> PAT (classic)
    2026-11-13T16:36:58Z git.clone <service-account> <repo>
    2026-11-13T16:37:05Z git.clone <service-account> <repo>
    2026-11-13T16:46:47Z … 16:47:18Z <repo>, <repo>, <repo>, <repo>
    2026-11-13T17:25:47Z git.clone <service-account> <repo>
    

    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.

16:30 to 22:00 UTC, to scale: Attacker above the line, Bitrise below. Each mark links to its step.16:3017:0018:0019:0020:0021:0022:00AttackerBitrise36 · It tries tokens for more user accounts · Nov 13 · 17:39 → 20:06 UTC36More tokens tried38 · It uses an existing OAuth grant to read Workspace data · Nov 13 · 17:57:49 → 18:05:13 UTC38Workspace data read39 · It uses an engineer's cloud login to read infrastructure state · Nov 13 · 19:13:29 → 19:54:20 UTC39State objects read40 · It tests webhooks, but internal access remains unproven · Nov 13 · 19:20:46 → 20:06:30 UTC40All returned 40443 · It uses an organization-wide key to reach 502 cloud projects · Nov 13 · 19:47:02 UTC43Broad cloud reach44 · It uses more credentials to clone infrastructure repositories · Nov 13 · 19:52:26 → 20:30:23 UTC44Infrastructure code cloned47 · It uses the Bitrise GitHub App key to create a token · Nov 13 · 20:46:15 → 20:46:53 UTC47App token created49 · It lists a build-machine log bucket with a remaining key · Nov 13 · 21:03:27 → 21:57:50 UTC49Log bucket listed51 · It downloads 1,535 build-machine log archives · Nov 13 · 21:15 → 21:29 UTC51Machine logs downloaded54 · It makes its last recorded successful cloud API call · Nov 13 · 21:57:50 UTC54Last recorded success35 · We begin investigating suspicious behavior · Nov 13 · 16:32 UTC35Investigation started37 · We declare a SEV-1, our highest incident level · Nov 13 · 17:42 UTC37SEV-1 declared41 · We trigger a shutdown of the whole platform · Nov 13 · 19:26 UTC41Shutdown triggered42 · We remove the bot's membership and lock its account · Nov 13 · 19:26:43 → 19:34:38 UTC42Bot access removed45 · We challenge and block requests at the edge · Nov 13 · 20:28 UTC45Challenged and blocked46 · We switch the platform off · Nov 13 · 20:34 UTC46Platform off48 · We delete and replace the Bitrise GitHub App's private key · Nov 13 · 20:53:12 UTC48App key replaced50 · We delete the compromised GitHub deploy keys · Nov 13 · 21:08 UTC50Deploy keys deleted52 · We disable the key, but issued tokens keep working · Nov 13 · 21:22:11 UTC52Infrastructure key disabled53 · We disable the metrics key after its recorded calls are denied · Nov 13 · 21:38:39 UTC53Metrics key disabled

Swipe sideways to see the whole chart.

  1. BitriseT+04:45

    We begin investigating suspicious behavior

    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 time is from the responders' record.

  2. AttackerT+05:52

    It tries tokens for more user accounts

    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.

    EvidenceApplication request logs3 lines
    74.211.97.67 <employee> 2026-11-13T18:33:09.770Z 2026-11-13T20:05:28.022Z 2
    74.211.97.67 <employee> 2026-11-13T20:04:44.708Z 2026-11-13T20:04:44.708Z 1
    74.211.97.67 <employee> 2026-11-13T20:06:17.768Z 2026-11-13T20:06:17.768Z 1
    

    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.

  3. BitriseT+05:55

    We declare a SEV-1, our highest incident level

    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.

  4. AttackerT+06:11:01

    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.

    • 61 Workspace 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.

    EvidenceGoogle Workspace audit reports6 lines
    61 events, 2026-11-13T17:57:49Z → 18:05:12Z, actor <employee>, app <app>
    49 calendar.events.list, 4 people.listDirectoryPeople, 3 calendarList.list, 2 sheets.values.get, 2 sheets.get, 1 people.searchDirectoryPeople
    sum(num_response_bytes) = 964,330
    18:04:59, 18:05:03 <document>
    18:05:08, 18:05:13 <document>
    login ip <each of 118.100.234.120, 74.211.97.67, 74.82.199.230, 95.40.73.129>: 0 events
    

    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.

  5. AttackerT+07:26:41

    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 / 294 successful / total calls
    • 237 Terraform 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.

    EvidenceCloud audit logs (Google Cloud)3 lines
    principal <employee> 2026-11-13T19:13:29.447 → 19:54:20.530 294 calls / 294 OK
    storage.objects.get 237 (<bucket> 232, <bucket> 5)
    ListSecrets 23, storage.buckets.list 14, ListSecretVersions 3 (19:36:40–19:36:49), GetIamPolicy 3, instances.aggregatedList 1, ListClusters 1
    

    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.

  6. AttackerT+07:33:58

    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 401
    19:20:49 POST /workspaces/nope/outgoing-webhooks 401
    2026-11-13T19:23:30Z POST /workspaces/nope/outgoing-webhooks/test 422
    19:23:38 POST /workspaces/nope/outgoing-webhooks 422
    2026-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.

  7. BitriseT+07:39

    We trigger a shutdown of the whole platform

    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.

  8. BitriseT+07:39:55

    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.

    EvidenceApplication database change history2 lines
    users_roles <employee> Organization <workspace> member op=d 2026-11-13 19:26:43
    users <employee> locked_at 2026-11-13 19:34:38
    

    Selected membership-deletion and account-lock records with internal identifiers removed.

  9. AttackerT+08:00:14

    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,779 successful / total calls
    • 502 cloud projects touched
    • 236 production 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.

    EvidenceCloud audit logs (Google Cloud)4 lines
    principal <service-account> key <key> (validAfter 2022-01-21T14:24:25Z)
    2026-11-13T19:47:02.560 → 21:29:36.212 2779 calls, 2183 OK, 502 projects
    ListSecrets OK 250, storage.buckets.list OK 358
    20:16 1, 20:17 3, 20:18 1, 20:19 6, 20:20 2, 20:21 2, 20:23 2 (+1x404), 20:27 20, 20:28 9 → 46 x HTTP 200
    

    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.

  10. AttackerT+08:05:38

    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.

    • 28 private 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.

    EvidenceGitHub audit log export7 lines
    2026-11-13T19:52:26Z git.clone <service-account> <repo> (PAT classic)
    2026-11-13T19:56:07Z GET /app 200 JWT <app> 74.211.97.xxx UA "recon"
    2026-11-13T19:56:18Z POST /app/installations/<installation>/access_tokens 201 JWT <app>
    2026-11-13T19:56:23Z GET /installation/repositories 200 INTEGRATION_SERVER_TO_SERVER
    2026-11-13T19:58:14Z git.clone <service-account> <repo> (GitHub App server-to-server token)
    2026-11-13T20:02:35Z / 20:23:46Z git.clone <service-account> <repo>, <repo>
    2026-11-13T20:26:18Z → 20:30:23Z git.clone <service-account> ×10 (<repo>)
    

    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.

  11. BitriseT+08:41

    We challenge and block requests at the edge

    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.

    EvidenceEdge request logs (CDN/WAF)1 line
    74.211.97.67 security_action: managed_challenge 125 (first 2026-11-13T20:28Z <internal-host> /readyz 403), block 2
    

    The logs prove enforcement, not when a manual rule changed. Our records show all internal-hostname requests at 20:29–20:57 UTC as challenged.

  12. BitriseT+08:47

    We switch the platform off

    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.

  13. AttackerT+08:59:27

    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.xxx
    2026-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.

  14. BitriseT+09:06:24

    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.

  15. AttackerT+09:16:39

    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.

    • 641 successful 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.

  16. BitriseT+09:21

    We delete the compromised GitHub deploy keys

    We deleted the compromised GitHub deploy keys at 21:08 UTC. These were separate credentials from the Bitrise GitHub App's private key.

    Outcome: Deploy keys deletedEvidence grade: ReportedA response action taken from the responders’ record.

    EvidenceResponders' incident record1 line
    21:08 compromised GitHub deploy keys deleted (<employee>, <employee>).
    

    The response action is from the responders' record; no deploy-key deletion audit row is shown.

  17. AttackerT+09:28

    It downloads 1,535 build-machine log archives

    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,535 build-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.

    EvidenceCloud audit logs (Google Cloud)1 line
    storage.objects.get OK 1551 (<bucket> 12 @ 20:14:56–20:15:39, <bucket> 1539 @ 21:15:58–21:29:36)
    

    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.

  18. BitriseT+09:35:23

    We disable the key, but issued tokens keep working

    We disabled the organization-wide infrastructure key at 21:22:11 UTC. Access tokens already issued through it continued working until 21:29:36 UTC.

    Outcome: Infrastructure key disabledEvidence grade: VerifiedShown directly by a log record.

    EvidenceCloud audit logs (Google Cloud)2 lines
    Admin Activity: 2026-11-13T21:22:11Z DisableServiceAccountKey <key> by <employee>
    2026-11-13T19:47:02.560 → 21:29:36.212 2779 calls, 2183 OK, 502 projects
    

    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.

  19. BitriseT+09:51:51

    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.67
    2026-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.

  20. AttackerT+10:11:02

    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.906
    Denied 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.

  1. Attacker

    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,544 requests on Nov 14
    • 357 HTTP 403 API responses
    • about 600 HTTP 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.1
    Every 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.

  2. Bitrise

    We expire its account token and disable its apps

    At 07:10:05 UTC, we expired the long-lived token on the attacker’s account. At 08:35:58 UTC, we disabled its apps.

    Outcome: Token and apps disabledEvidence grade: VerifiedShown directly by a log record.

    EvidenceApplication database change history1 line
    user_auth_tokens <token> (uid <attacker-account>) expire_at → 2026-11-14 07:10:05 ; repositories <app>/<app>/<app> last change 2026-11-14 08:35:58
    

    The database records the token expiration and app changes at these two times. These actions did not mark the end of the attacker’s activity.

  3. Attacker

    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.

    • 12 requests 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.

  4. Attacker

    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.

    EvidenceCloud monitoring metrics3 lines
    2026-11-14T12:00  egress_169.254.169.254          200 x1, 403 x2, 404 x3
    2026-11-14T12:00  egress_metadata.google.internal 403 x1
    2026-11-14T13:00:00Z <our-own-egress> GET <internal-host> /nope-1774 404 Go-http-client/2.0
    

    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.

  5. Attacker

    It retries a stolen token and gets refused again

    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.

  6. Attacker

    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.

    EvidenceApplication database change history3 lines
    uid <attacker-account> u04tjp6@gmail.com created 2026-11-14 16:28:53 ip 74.82.199.230 ; identities: provider google uid <identity>
    16:28:54–16:29:24 GET /create-workspace - 500 (x3)
    WHOIS 74.82.199.230 and 74.211.97.67: OrgName Cluster Logic Inc, NetName CL-1210
    

    The sign-up is recorded in database history; workspace errors come from application logs and the provider match from network registration.

  7. Attacker

    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.

    • 70 cloud 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.

  8. Attacker

    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)
The Nov 18 session, to scale. Every event from 20:24:10 to 21:19:55 UTC, to scale, in 3 lanes. Each mark links to its row in the table below.PhaseOld accounts and keySecrets and code signingNew accountTerraform state20:2520:3020:3520:4020:4520:5020:5521:0021:0521:1021:1521:20Google Cloud20:24:10 · First event. Without credentials, tries listing the bucket holding our Apple signing files (curl/7.88.1). · denied20:24:1020:31:27–20:31:43 · 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. · denied20:31:2720:44:38–20:44:39 · Uses the stolen cloud key to request Secret Manager ListSecrets in four production projects. · denied20:44:3820:54:39 · Without credentials, tries listing the infrastructure state bucket. · denied21:18:00–21:18:52 · Without credentials, requests a service-account Terraform state object in the infrastructure state bucket by exact path: 2× read, 2× list. · denied21:18:00Bitrise web20:25:27–20:25:55 · Loads the sign-in page 3×. · 20020:26:07 · Tries signing in as the old bot account. · 40120:26:35 · Tries signing in as its original account, auwiqns. · 40120:27:34 · Requests a cloud-key secret from an internal app in the workspace that builds and tests Bitrise's open-source build steps. · 40420:39:27–20:39:34 · Requests GET / and the sign-in page. · 302 / 20020:40:45–20:41:18 · Requests /me/account 2× with a bare Mozilla/5.0 user agent. · 40120:49:30–20:50:39 · Requests GET /, the sign-in page and /v0.1/me. · 302 / 200 / 40120:51:21–20:53:50 · Tries signing in as auwiqns 5×. · 401 / 42220:52:44–20:54:44 · Requests the internal documentation-site app's page, .json and /settings. · 40120:57:31–20:58:27 · Tries the internal documentation-site app's build/start.json 3×, including 2× without parameters. · 400 / 40120:59:19 · Requests the internal documentation-site app's secrets. · 40420:59:44–21:00:02 · Loads the sign-in page and tries signing in. · 200 / 40121:00:23–21:01:16 · Requests the internal documentation-site app's page and .json, 2× each. · 40121:03:03–21:04:42 · Opens the sign-up page 2×. · 20021:05:01 · Creates a new account, i3694canary, with a new personal Gmail address. · created21:05:0121:05:20 · Requests the app list. · 40121:05:39 · Tries its own new user ID as a workspace ID. · 40421:05:58 · Requests its own API tokens. · 40121:06:17–21:07:13 · Opens the email-confirmation page 2× and makes one more sign-in attempt. · 200 / 40121:19:55 · Last event: GET /. · 30221:19:55Bitrise API20:27:13–20:30:35 · Checks for a working token about every 10 seconds: /v0.1/me, /me/profile/organizations. · 40120:29:29 · Requests an internal documentation-site app using the short form of its ID. · 40420:35:01–20:36:55 · Checks tokens at /v0.1/me. · 40120:39:58–20:41:07 · Requests the internal documentation-site app's details, secrets and latest build. · 40420:41:46–20:44:23 · Checks /v0.1/me; 3× HTTP 499 because the agent gave up on deliberately slowed responses. · 40120:56:20–20:57:49 · Requests the internal documentation-site app's details, build certificates and provisioning profiles. · 40121:15:00–21:16:01 · Requests GET /, then /v0.1/apps 3×. · 200 / 40121:19:17 · Requests /v0.1/apps. · 401

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)LaneWhatResult
20:24:10Google CloudFirst event. Without credentials, tries listing the bucket holding our Apple signing files (curl/7.88.1).Denied: denied
20:25:27–20:25:55Bitrise webLoads the sign-in page 3×.Neutral: 200
20:26:07Bitrise webTries signing in as the old bot account.Rejected: 401
20:26:35Bitrise webTries signing in as its original account, auwiqns.Rejected: 401
20:27:13–20:30:35Bitrise APIChecks for a working token about every 10 seconds: /v0.1/me, /me/profile/organizations.Rejected: 401
20:27:34Bitrise webRequests 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:29Bitrise APIRequests an internal documentation-site app using the short form of its ID.Rejected: 404
20:31:27–20:31:43Google CloudUses 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:55Bitrise APIChecks tokens at /v0.1/me.Rejected: 401
20:39:27–20:39:34Bitrise webRequests GET / and the sign-in page.Neutral: 302 / 200
20:39:58–20:41:07Bitrise APIRequests the internal documentation-site app's details, secrets and latest build.Rejected: 404
20:40:45–20:41:18Bitrise webRequests /me/account 2× with a bare Mozilla/5.0 user agent.Rejected: 401
20:41:46–20:44:23Bitrise APIChecks /v0.1/me; 3× HTTP 499 because the agent gave up on deliberately slowed responses.Rejected: 401
20:44:38–20:44:39Google CloudUses the stolen cloud key to request Secret Manager ListSecrets in four production projects.Denied: denied
20:49:30–20:50:39Bitrise webRequests GET /, the sign-in page and /v0.1/me.Neutral: 302 / 200 / 401
20:51:21–20:53:50Bitrise webTries signing in as auwiqns 5×.Rejected: 401 / 422
20:52:44–20:54:44Bitrise webRequests the internal documentation-site app's page, .json and /settings.Rejected: 401
20:54:39Google CloudWithout credentials, tries listing the infrastructure state bucket.Denied: denied
20:56:20–20:57:49Bitrise APIRequests the internal documentation-site app's details, build certificates and provisioning profiles.Rejected: 401
20:57:31–20:58:27Bitrise webTries the internal documentation-site app's build/start.json 3×, including 2× without parameters.Rejected: 400 / 401
20:59:19Bitrise webRequests the internal documentation-site app's secrets.Rejected: 404
20:59:44–21:00:02Bitrise webLoads the sign-in page and tries signing in.Rejected: 200 / 401
21:00:23–21:01:16Bitrise webRequests the internal documentation-site app's page and .json, 2× each.Rejected: 401
21:03:03–21:04:42Bitrise webOpens the sign-up page 2×.Neutral: 200
21:05:01Bitrise webCreates a new account, i3694canary, with a new personal Gmail address.Success: created
21:05:20Bitrise webRequests the app list.Rejected: 401
21:05:39Bitrise webTries its own new user ID as a workspace ID.Rejected: 404
21:05:58Bitrise webRequests its own API tokens.Rejected: 401
21:06:17–21:07:13Bitrise webOpens the email-confirmation page 2× and makes one more sign-in attempt.Neutral: 200 / 401
21:15:00–21:16:01Bitrise APIRequests GET /, then /v0.1/apps 3×.Rejected: 200 / 401
21:18:00–21:18:52Google CloudWithout credentials, requests a service-account Terraform state object in the infrastructure state bucket by exact path: 2× read, 2× list.Denied: denied
21:19:17Bitrise APIRequests /v0.1/apps.Rejected: 401
21:19:55Bitrise webLast event: GET /.Neutral: 302
  1. Attacker

    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.

  2. Attacker

    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.

  3. Attacker

    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.

  4. Attacker

    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.

    EvidenceResponders' incident record3 lines
    ["21:18:00", "21:18:52", "gcp", "No credentials: <bucket>/<state-object-path>, 2× read, 2× list", "denied", "denied", 1],
    ["21:19:17", null, "api", "/v0.1/apps", "401", "rejected"],
    ["21:19:55", null, "web", "GET /: last event", "302", "neutral", 1]
    

    The exact internal bucket and object path are generalized; operation counts and times are preserved.

  5. Attacker

    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.

    • 19 Google Cloud requests denied
    • 9 old-account sign-in attempts, all rejected
    • 0 successful 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:55
    0successful reads of secrets, buckets or apps
    19Google Cloud requests, all denied
    1new 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

  1. 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.

  2. 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.

  3. 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 observedWhat 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.
The numbers as a rough clock590059506000605061006150Oct 25Oct 26Oct 27Oct 25 – Oct 27counter value5938 · user agent pentest-probe-i5938/1.0 · some time between Oct 25 and Oct 275938some time between Oct 25 and Oct 276084 · SSRF canary /_i6084_probe_missing · Oct 25 · 21:336084010002000300040005000Nov 12Nov 13Nov 14Nov 15Nov 16Nov 17Nov 18Nov 12 – Nov 18counter valueno readings in betweenone new row about every 2.2 minutes871 · CI app i871-probe · Nov 12 · 15:06:39871901 · CI apps i901a, i901b · Nov 12 · 15:28:329011040 · workflow i1040probe · Nov 12 · 18:00:0510401170 · workflows i1170certs, i1170den · Nov 12 · 18:03:5711701222 · workflow i1222 · Nov 12 · 18:3012221246 · workflow i1246net · Nov 12 · 18:42:4412461294 · workflow i1294probe · Nov 12 · 19:19:4812941655 · workflow i1655nodeopt · Nov 13 · 19:58:1916553694 · account i3694canary · Nov 18 · 21:05:013694

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 valueSeen (UTC)Where it appearedSeries
5938some time between and user agent pentest-probe-i5938/1.0Counter A
6084SSRF canary /_i6084_probe_missingCounter A
871CI app i871-probeCounter B
901CI apps i901a, i901bCounter B
1040workflow i1040probeCounter B
1170workflows i1170certs, i1170denCounter B
1222workflow i1222Counter B
1246workflow i1246netCounter B
1294workflow i1294probeCounter B
1655workflow i1655nodeoptCounter B
3694account i3694canaryCounter 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.

References

Where it came from

Source addresses

  • Discovery and tests

    95.40.73.129

    Network
    Amazon Web Services (AS16509)
    Place
    Hong Kong
    First seen
    Last seen
    Confidence
    High

    36,698 requests in three days: scanning, throw-away accounts, share-link harvesting, the first SSRF.

    First appears in step 1
  • Noise

    185.197.251.16

    Network
    Contabo GmbH
    Place
    Germany
    First seen
    Last seen
    Confidence
    Low

    11 probe-named sign-ups in two hours and nothing else. We assess it as noise generation.

    First appears in step 8
  • Possibly related

    60.173.247.xxx

    Network
    China Telecom, CHINANET Anhui (AS4134)
    Place
    China
    First seen
    Last seen
    Confidence
    Low

    7 sign-ups in 32 seconds, six named probe<digits>, never used. Linked by naming and timing only.

    First appears in step 9
  • Arrived as a customer

    118.100.234.120

    Network
    TM Technology Services (AS4788)
    Place
    Kuala Lumpur, Malaysia
    First seen
    Last seen
    Confidence
    High

    A subscriber-type address: the sign-up, the builds, 48,084 requests on Nov 12 (much of it fuzzing), the first stolen key, and the return on Nov 18.

    First appears in step 10
  • Operations

    74.211.97.67

    Network
    Cluster Logic Inc (CL-1210), AS25820
    Place
    Los Angeles, United States
    First seen
    Last seen
    Confidence
    High

    The sign-in to the dormant account and most of the stolen-credential use: web, API, Google Cloud, GitHub, Google Workspace.

    First appears in step 19
  • One late sign-up

    74.82.199.230

    Network
    Cluster Logic Inc (CL-1210)
    Place
    United States
    First seen
    Last seen
    Confidence
    Low

    A single account created after the main address was blocked. Linked by hosting provider only.

    First appears in step 60

Seen times are in UTC.

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.

LinkStrengthEvidence
95.40.73.129 ↔ 118.100.234.120Strong (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.67Strong (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 threeModerate (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.230Weak (1 of 3)Same hosting provider and network owner. Nothing else.
185.197.251.16 and 60.173.247.xxxWeak (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.

Obtained6

  • Files in 15 customer workspaces

    Owner: Customers

    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.

Response

What we did, and what changed

  1. Investigation startsSuspicious behaviour identified.
  2. 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.
  3. GitHub App key replacedSeven minutes after the attacker first used it.
  4. 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.
  5. Declared resolvedThe immediate security risks had been addressed. Each one returned only after its credentials were rotated and it passed a security review.
  6. 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

  1. A second factor on every bot account

    Every bot account was reviewed. Two-factor authentication is enforced on all of them.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  1. 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.

    Prologue: It introduced itself as a pentester
  2. Look for the serial numbers

    What we sawAccounts, CI apps, workflows, canary paths and user agents all carried i<number>.

    What to doSearch sign-ups, tenant and job names, Host headers and URL paths for i followed by 3–5 digits and a word.

    Chapter 1: It came back as a customer
  3. Find your dormant doors

    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.

    Chapter 2: One dormant account
  4. A secret that can be revealed will be

    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.

    Chapter 2: One dormant account
  5. Keys do not travel

    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.

    Chapter 2: One dormant account
  6. Count identities per source

    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.

    Chapter 2: One dormant account
  7. Treat infrastructure state as a vault

    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.

    Chapter 3: The race
  8. Log reads of your secret store before you need them

    What we sawIn one project we could count secret reads from metrics but could not name the secrets, because read audit logging was off.

    What to doTurn on data-access (read) audit logging for your secret manager everywhere, and alert on identities that have never read secrets before.

    Chapter 3: The race
  9. Watch your own GitHub Apps

    What we sawWith an App’s private key the agent went from first call to an installation token in under a minute.

    What to doFor Apps you own, alert on any JWT-authenticated call or token creation from an address that is not your backend.

    Chapter 3: The race
  10. Pull the plug early

    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.

    Chapter 3: The race
  11. Expect it back

    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.

    Epilogue: It came back. Nothing opened.

Anatomy of an AI-driven attack · · version 1.3

For defenders

Indicators

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.
Indicators
ValueTypeFirst / last seen (UTC)RoleConfidenceUse / scopeNote
74.211.97.67ipv4 – Primary operations host: stolen-credential use against Bitrise web/API, Google Cloud, GitHub and Google Workspace APIsHighMatchActorWHOIS 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.120ipv4 – Attacker account registration, attacker-controlled CI builds, fuzzing, reuse of install-page links; returned on Nov 18 for 55 minutesHighMatchActorAS4788 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.129ipv4 – Discovery and tests: reconnaissance, throw-away account registration, artifact downloads via install-page links, SSRF probingHighMatchActorAWS 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.230ipv4 – One account sign-up after the primary host was blockedLowCorrelateActorLinked only by hosting provider (same WHOIS org as 74.211.97.67). Do not block or alert on this alone.
185.197.251.16ipv4 – 11 probe-named account registrations in about two hours; assessed as noise generationLowCorrelateActorContabo GmbH, DE. Linked by account naming and timing only. Do not block or alert on this alone.
pentest-probe-i5938/1.0user agent – Scanner user agent (12,813 requests)HighMatchToolThe number is consistent with an ARTEX intent id and will differ in your logs; also hunt the regex row.
Mozilla/5.0 (compatible; authorized-pentest/bitrise-readonly)user agent – Scanner user agent (1,074 requests)HighMatchToolEmbeds the target name; expect your own name in place of 'bitrise'.
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) research-readonlyuser agent – Scanner user agent (457 requests)HighMatchTool
Mozilla/5.0 (research; read-only; pentest)user agent – Scanner user agent (383 requests)HighMatchTool
Mozilla/5.0 (compatible; authorized-security-research)user agent – Scanner user agent (369 requests)HighMatchTool
bitrise-pentest-probe/1.0 (authorized read-only)user agent – Scanner user agent (159 requests)HighMatchToolEmbeds the target name; expect your own name in place of 'bitrise'.
pentest-probe-readonly/1.0 (authorized read-only baseline)user agent – Scanner user agent (76 requests)HighMatchTool
norma/0.4user agent substring – Web-fetch client of the norma agent SDK that ARTEX is built on; seen on all three main source addressesHighMatchToolIdentifies the tool family, not one operator: other software built on the same SDK sends it too. Substring match.
reconuser agent – User agent on GitHub REST call GET /app authenticated with a stolen GitHub App keyMediumCorrelateActorWhole-string match only. Short generic string: use together with GitHub App JWT activity, not alone.
(?i)(pentest-probe|authorized-pentest|authorized-security-research|research-readonly|research; read-only; pentest|\(authorized read-only)user agent regex – Family pattern for the self-labelled 'authorised pentest' user agentsMediumCorrelateToolWill also match genuine contracted testing that uses similar labels; check against your own test schedule.
curl/7.88.1user agent – Common tool, used on all three main source IPsLowContextContextNot usable alone. Supporting detail when the source IP also matches.
curl/8.7.1user agent – Common tool, last request seen from primary hostLowContextContextNot usable alone.
Python-urllib/3.12user agent – Common library, used for cloud API calls with stolen keysLowContextContextNot usable alone.
python-requests/2.34.2user agent – Common library, seen in October and NovemberLowContextContextNot usable alone.
Fuzz Faster U Fool v2.3.0user agent – ffuf directory fuzzer v2.3.0LowContextContextCommon scanner. Supporting detail when the source IP also matches.
git/2.39.5user agent – Git client on all repository clones made with stolen GitHub credentialsLowContextContextVery common client. Useful only combined with source IP or an unexpected GitHub App / bot actor.
wanyyj999@gmail.comemail – Account registered by the attacker and used to run CI buildsHighMatchActorCheck sign-ups, invitations, support tickets and SaaS tenants. Platform username: auwiqns.
auwiqnsusername – Platform username of the account aboveHighMatchActorSign-in attempts as this account were rejected during the Nov 18 return.
pentest-probe-1d2bf9@maxxspace.comemail – Throw-away probe accountHighMatchActorRegistered from 95.40.73.129. Pattern: pentest-probe-<6 hex>@<disposable domain>.
pentest-probe-9cede9@maxxspace.comemail – Throw-away probe accountHighMatchActorRegistered from 95.40.73.129.
test-5fowzn6@srv1.mail-tester.comemail – Throw-away probe accountHighMatchActorRegistered from 95.40.73.129. mail-tester.com is a legitimate mail-testing service; the domain is not an indicator.
pentestprobeq7m4z2@olipii.comemail – Throw-away probe accountHighMatchActorRegistered from 95.40.73.129.
pentestprobv2mbjlcuxr@ruutukf.comemail – Throw-away probe accountHighMatchActorRegistered from 95.40.73.129.
bsd3b8a0f967@maxxspace.comemail – Probe-named account (username pqprobe386873)LowCorrelateActorRegistered from 185.197.251.16. Linked by naming and disposable domain only.
bsc69064bfb3@maxxspace.comemail – Probe-named account (username probe387344)LowCorrelateActorRegistered from 185.197.251.16. Linked by naming and disposable domain only.
(?i)^pentest-?prob[a-z0-9-]*@email regex – Sign-up address pattern of the throw-away accountsMediumCorrelateActorCombine with disposable-mail domains.
maxxspace.comdomain context – Disposable-mail domain used for 4 of the 7 probe sign-upsLowContextContextPublic disposable-mail service used by many unrelated people.
olipii.comdomain context – Disposable-mail domain used for 1 probe sign-upLowContextContextPublic disposable-mail service.
ruutukf.comdomain context – Disposable-mail domain used for 1 probe sign-upLowContextContextPublic disposable-mail service.
/_i6084_probe_missingurl path substring – SSRF callback canary pathHighMatchActorArrived from the victim's own egress, not the attacker IP. The number will differ in your logs; hunt the regex row.
/nope-1774url path substring – SSRF callback canary pathMediumMatchActorArrived from the victim's own egress. The number will differ in your logs.
zzq-random-nonexist-9182hostname label substring – Made-up subdomain label used to test wildcard DNS / routingHighMatchActorLook in DNS and HTTP Host / SNI logs.
/_i\d{3,5}_probe_[a-z_]+|/nope-\d{3,5}\burl path regex – Family pattern for the SSRF canary pathsMediumCorrelateTool
idor-probe-812ci job name – App name created by the attacker on the CI platformHighMatchActorUseful to other CI/CD and developer-platform operators.
i871-probeci job name – App name created by the attacker on the CI platformHighMatchActor
\bi\d{3,4}[a-z]?(-?probe|certs|den\d?|net\d?|nodeopt)?\bci job name regex – Family pattern for actor app and workflow names: i871-probe, i901a, i901b, i901probe, i1040probe, i1170certs, i1170den, i1170den2, i1170den3, i1222, i1222b, i1222c, i1246net, i1246net2, i1246net3, i1294probe, i1655nodeoptMediumCorrelateToolMatches the app and workflow names listed in this report (i871-probe … i1655nodeopt).
=== I871C STARTlog string – Banner printed by the attacker’s build script that dumped VM instance metadataMediumCorrelateActorThe number will differ in your logs. Regex: === I\d{3,4}[A-Z] START
github.com/octocat/Hello-Worldrepo url context – Public placeholder repository the attacker connected to its appsLowContextContextBenign public repository used widely for testing.
url=http://169.254.169.254/latest/meta-data/url substring – SSRF attempt through a URL-fetching endpoint (combined with path=../../etc/passwd and image=http://evil/)MediumMatchActorBlocked by WAF at Bitrise. Generic SSRF payload; the three-parameter combination is the distinctive part.
/axis2-admin/login | /session_login.cgi | /artifactory/ui/auth/login | /redfish/v1/SessionService/Sessions/ | /user/register?element_parents=account/mail/%23value&ajax_form=1&_wrapper_format=drupal_ajaxurl path set – Generic exploit / admin-panel spray, POST, one burst of about 8 minutesLowContextContextCommodity paths. Meaningful only from a matching source IP or as a burst sequence.
/_cat/indices | /_search | /_security/_authenticate | /app/kibana | /wazuhurl path set – Probing of a monitoring / SIEM-looking hostname for Elasticsearch, Kibana, Wazuh and GrafanaLowContextContextCommodity paths.
/api/v1/auths/signin | /api/v1/auths/ldap | /api/v1/openai/config | /api/v1/ollama/config | /api/v1/rag/config | /api/v1/tools | /api/configurl path set – Enumeration of an Open WebUI (LLM chat) deployment, including unauthenticated config endpointsMediumCorrelateActorIf 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 cloneapi sequence – GitHub App private-key abuse sequence, from authentication to token creation in 11 and 23 seconds for the two AppsHighCorrelateActorBehavioural. For your own GitHub Apps: any JWT-authenticated call from an address that is not your app backend.
60.173.247.xxxNewipv4 masked – Possibly related: 7 account registrations in 32 seconds, six named probe<digits>, never usedLowContextActorLast 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-1d2bf9Newusername – Platform username of a throw-away probe accountHighMatchActorRegistered from 95.40.73.129.
pentestprobe-9cede9Newusername – Platform username of a throw-away probe accountHighMatchActorRegistered from 95.40.73.129.
pentestprobe-280c2cfdNewusername – Platform username of a throw-away probe accountHighMatchActorRegistered from 95.40.73.129.
pentestprobe-q7m4z2Newusername – Platform username of a throw-away probe accountHighMatchActorRegistered from 95.40.73.129.
pentest-probe-v2-mbjlcuxrNewusername – Platform username of a throw-away probe accountHighMatchActorRegistered from 95.40.73.129.
pqprobe386873Newusername – Platform username of a probe-named accountLowCorrelateActorRegistered from 185.197.251.16; e-mail confirmed.
probe387344Newusername – Platform username of a probe-named accountLowCorrelateActorRegistered from 185.197.251.16; e-mail confirmed.
pqp390718Newusername – Platform username of a never-confirmed sign-upLowCorrelateActorRegistered 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.
pqp391294Newusername – Platform username of a never-confirmed sign-upLowCorrelateActorRegistered 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.
pqp391428Newusername – Platform username of a never-confirmed sign-upLowCorrelateActorRegistered 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.
pqp391973Newusername – Platform username of a never-confirmed sign-upLowCorrelateActorRegistered 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.
pqp394149Newusername – Platform username of a never-confirmed sign-upLowCorrelateActorRegistered 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.
pqp394257Newusername – Platform username of a never-confirmed sign-upLowCorrelateActorRegistered 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.
pqp394365Newusername – Platform username of a never-confirmed sign-upLowCorrelateActorRegistered 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.
pqp394473Newusername – Platform username of a never-confirmed sign-upLowCorrelateActorRegistered 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.
pqp394581Newusername – Platform username of a never-confirmed sign-upLowCorrelateActorRegistered 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.
probe3196914374Newusername – Platform username of a never-confirmed sign-up (possibly related)LowCorrelateActorRegistered from 60.173.247.xxx; never signed in. Sign-up addresses used large free-mail providers.
probe2229013017Newusername – Platform username of a never-confirmed sign-up (possibly related)LowCorrelateActorRegistered from 60.173.247.xxx; never signed in. Sign-up addresses used large free-mail providers.
probe2640930265Newusername – Platform username of a never-confirmed sign-up (possibly related)LowCorrelateActorRegistered from 60.173.247.xxx; never signed in. Sign-up addresses used large free-mail providers.
probe1140114712Newusername – Platform username of a never-confirmed sign-up (possibly related)LowCorrelateActorRegistered from 60.173.247.xxx; never signed in. Sign-up addresses used large free-mail providers.
probe1114832364Newusername – Platform username of a never-confirmed sign-up (possibly related)LowCorrelateActorRegistered from 60.173.247.xxx; never signed in. Sign-up addresses used large free-mail providers.
probe2618023238Newusername – Platform username of a never-confirmed sign-up (possibly related)LowCorrelateActorRegistered from 60.173.247.xxx; never signed in. Sign-up addresses used large free-mail providers.
^(pqprobe|pqp|probe)\d{6,10}$Newusername regex – Family pattern for the probe-named sign-upsLowCorrelateActorCombine with several sign-ups from one address within minutes.
i3694canaryNewusername – Account created during the Nov 18 returnHighMatchActorRegistered 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}$Newusername regex – Accounts, apps and jobs named in the ARTEX intent-id styleMediumCorrelateToolExamples: i871-probe, i901a, i1170certs, i3694canary. Expect different numbers on your side.
u04tjp6@gmail.comNewemail – Account registered with Google sign-in after the primary host was blockedLowCorrelateActorRegistered from 74.82.199.230. Linked by hosting provider only.
single sign-in attempts against several bot or test account names from one addressNewbehaviour – 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 18HighCorrelateToolAlert on single-attempt sign-ins across several machine-account names from one address.

Method and limits

What we could not establish

  1. 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.
  2. How the attacker collected the install-page links it used in October. They contain hashes that cannot be guessed.
  3. 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.
  4. 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.
  5. How several later tokens and keys were obtained, including an engineer’s API token and cloud login. Each is marked in its step.
  6. Which language model drove the agents, and who operated them.
  7. 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.
  8. 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.

Keyboard shortcuts

j / nNext step
k / pPrevious step
eOpen or close the evidence of the current step
g then 0Prologue: It introduced itself as a pentester
g then 1Chapter 1: It came back as a customer
g then 2Chapter 2: One dormant account
g then 3Chapter 3: The race
g then 4Chapter 4: It kept knocking
g then 5Epilogue: It came back. Nothing opened.
?Show this list
EscClose

Shortcuts are single letters without modifier keys. Scrolling, Space and the arrow keys are left alone.