Just another security blog - by Jon Bottarini

Tag: bug bounty (page 1 of 1)

Don’t Reply: A Clever Phishing Method In Apple’s Mail App

About four or five years ago, friend and fellow bug bounty hunter Sam Curry asked if I had “ever thought about what was possible to load inside an <img> tag, besides an image“. What a peculiar question. I didn’t really understand what he was asking, and I assume Sam got bored of me guessing the wrong answers, so he sent a simple payload that looked like this:

<img src=https://www.jonbottarini.com/pocs/restricted.php></img>

At the surface, this appears to be a normal HTML <img> element, until you look a bit closer and realize that the src= parameter is not pointing to an image at all, but rather a webpage ending in .php. If you navigate to this page directly, you’ll be prompted with something that looks like this:

What you’re looking at is an implementation of WWW-Authenticate. In 2017, if you were to embed this <img> payload in an HTML editor on a 3rd party website, nearly anyone who viewed the page with the rendered <img> tag would see an authentication prompt, asking you to sign in to my site. It looked like this:

A prompt asking users on an AirBnb community website to login to my website

Simply incredible. I don’t think Sam realized at the time what he was sitting on in the world of bug bounty – this was essentially a lazy way to phish users on forums, help centers, etc – anywhere that you could enter an image tag. It was unique because in situations where you were allowed to insert an <img> tag but not able to pop an XSS payload (due to CSP or other protections in place), rarely did an application prevent you from loading an external “image” that was really my malicious WWW-Authenticate page. Remember: this was 2017, a lot has changed since then.

After sharing this revelation with Sam, we reported instances of sites vulnerable this issue to a few bug bounty programs, and it was largely hit or miss. Some programs (Yahoo!, if I remember correctly, back before they rebranded their program to Oath, and then to Verizon Media¹) paid $1,000 for each instance of the issue – other programs didn’t pay anything at all, and stated that it was a browser issue. This is understandable – in a way, this issue could be fixed by the browser. The Chrome team decided to fix this outright back in 2013 by preventing cross-origin authentication prompts to image resources. Sam petitioned Mozilla to do the same in 2017, which they (begrudgingly) implemented the change to disallow loading external WWW-Authenticate prompts via image somewhere around Firefox Version 57. Apple never responded to us when we reached out to inform them that Safari was the last (major) browser to suffer from this.

The Problem in Apple Mail

I got bored with the 50/50 odds of getting a bounty through the web programs we were reporting to. A few months passed and I had an epiphany – in the form of a spam email. In short, an email evaded my spam filter because the email had no content besides a photo. Just a big, massive JPG image. This led to an idea – what if I sent a “photo” that was behind a WWW-Authenticate response header in an email? What type of prompt would the recipient see? Would they see any anything at all?

It doesn’t work. Simply put, I am not sure why it doesn’t work when the recipient receives the email – but the prompt does appear when replying to the email. When you reply to an email with that <img> payload I mentioned above, the user is presented with this prompt, which asks them to enter their name and password “to view this page”:

This prompt poses a two-fold problem. This first being that users are already familiar with entering their username and password in ambiguous and confusing prompts on Apple devices – Apple keychain being a major offender.

But this is not a keychain prompt – when a user enters their username and password in this prompt, their credentials are sent directly to my server.

The second problem is that it’s possible to customize the message displayed underneath the URL – in the example above, I put “You need to enter your Apple Mail password again!”. This is made possible through the realm directive:


A string describing a protected area. A realm allows a server to partition up the areas it protects (if supported by a scheme that allows such partitioning), and informs users about which particular username/password are required. If no realm is specified, clients often display a formatted hostname instead.

Mozilla developer portal

All in all – you get a very clever Apple Mail phishing method. Now – a savvy person would realize that “jonbottarini.com” has nothing to do with Apple, and would probably be skeptical of entering a username and password in the prompt – but official-sounding Apple domain names are cheap!

This issue affected versions of Apple Mail from macOS High Sierra 10.13 to macOS Big Sur 11.2. Yes, you read that right – it took multiple operating systems and four years to fix this issue completely. But before you get out the pitchforks – it’s not entirely Apple’s fault it took so long – there was a two year period where both Apple and myself thought the issue was fixed – when it really wasn’t.


  • Sometime mid to late 2017 (email comms are a bit messy here) – reported issue to Apple
  • Oct 2017 – Apple can’t reproduce the issue, I reply with additional info
  • Nov 2017 – More back and forth, explaining to Apple that the issue only occurs when replying/forwarding the email
  • Sometime in 2018 – Apple states this issue is not eligible for a CVE 🙁
  • July 2018 – Apple states they fixed the issue in macOS High Sierra 10.13 and macOS High Sierra 10.13.2
  • May 2020 – I start to write this blog post, but when I test the old proof of concepts, I notice that the payload is not fully fixed on macOS Catalina 10.15.4 and I am still getting the prompt. Replied back to Apple with proof that the issue still exists.
  • October 2020 – Apple states they have fixed the issue again – I find a bypass pretty quickly (by sending a email with an embedded image loaded inside a pre-made feature in Apple mail called “email templates”). Apple continues work on the remediation.
  • April 2021 – I follow up asking for a status update. Apple states the issue has been resolved in macOS Big Sur 11.2
  • August 2021 – Apple sends me an email out of the blue stating that the issue is eligible for a $5,000 bounty (w0w!)
  • December 2021 – Bounty paid + this writeup is disclosed.

¹ – At time of writing, Verizon Media has rebranded back to Yahoo. We have come full circle.

Very special thanks to Sam Curry (@samwcyo) and Tanner (@itscachemoney) for reviewing a draft of this post.

Follow me on Twitter to stay up to date with my latest bugs + bug bounty finds.

Using Burp Suite match and replace settings to escalate your user privileges and find hidden features

On May 14th, Lew Cirne, the CEO of New Relic, announced a new platform called New Relic One. The platform, featuring a fresh new design and better data visualizations, came as a surprise to investors and New Relic users alike.

But it did not come as a surprise to me, for I had found out about it months prior, using a common trick that I’ve used multiple times in other bug bounty programs to access unreleased beta and admin features; the Burp Suite match and replace rule.

The concept is simple: By changing the server response body from “false” to “true” (I cheekily refer to this as the FALSE2TRUE trick, because everything has to have a catchy name nowadays 😏) – you open up much more on the client side that might previously be hidden or unaccessible, and that’s exactly what happened when I found out about New Relic One. This is not a secret, and has been a method for a long time.

For those of you new to using the Burp Suite match and replace rule, this article goes deeper into where to find it in Burp and how to use it – but it lives under the Proxy settings in Options:

The match and replace rule goes well beyond just changing false responses to true – it can also be used for privilege escalation to change your user permissions from “User” to “Admin”. Let’s use the following example:

Imagine the server performs a check of the permissions of the user with the current session. The request to the server might look something like this:

POST /api/getUserDetails HTTP/1.1
Host: myserver.jonbottarini.com
Cookie: mycookies


And the response might look like this:

HTTP/1.1 200 OK


In the response, the client operates under the assumption that the user is in “READONLY” mode, and has a “BASIC” subscription. If we add a match and replace rule to change the “userLevel”:READONLY response to “userLevel”:ADMIN, we can trick the client to display UI elements that are meant only for Administrators:

We can go one step further and display UI elements that are meant only for a “Professional” level subscription as well:

If we were to add the match/replace rules above, the response to the client will now look like this:

HTTP/1.1 200 OK


@daeken has another nifty trick with the Burp match/replace rule: injecting payloads into forms instead of typing out the entire payload:

Back to New Relic. I was using the FALSE2TRUE trick when I realized that there was a feature flag on my account which was always returning false. By simply changing this response to true using Burp match/replace rule, I noticed that there was additional UI elements that appeared on the page.

This is the New Relic landing page when logging in without FALSE2TRUE:

Now, when using the FALSE2TRUE trick, changing all “false” values to “true”:

Bug found!

The Burp match and replace rule gave me access to a completely unreleased feature with a ton of new functionality, where I found other bugs as well, prior to the public release.

A word of warning: Be careful when using the FALSE2TRICK on big websites, because you can really mess up your session, or even your entire account.

I’m curious how you use the match/replace tool in your Burp projects – leave a comment below or ping me on Twitter if you would like to share. If it’s a really good tip, I’ll put it in this post so others can learn!

Until next time 👋

(The New Relic security team reviewed this post in full before it was published and have agreed to let me use one of my reports as an example. I am especially grateful for the New Relic team to be so open and accepting of using their program and bugs I’ve found in examples on my blog).

Get as image function pulls any Insights/NRQL data from any New Relic account (IDOR)

This writeup walks you through the full process as to how I found a pretty bad Insecure Direct Object Reference (IDOR) in New Relic. 

In New Relic, there is the ability to add a 3rd party integration to a product line called New Relic Infrastructure. Common integrations include AWS, Azure, and most recently Google Cloud Platform (GCP). In Google Cloud Platform there is also the ability to create dashboards:

new relic dashboards

Dashboards are pretty common in New Relic, but there was something unique about the dashboards that are within the integrations section; the dropdown options for each chart allow you to do the following actions, which are not present in any of the other dashboard areas:

The option that immediately stood out to me was the “Get as image” option. This option converts the NRQL query that generates the dashboard into an image – and this is where the vulnerability lies. For more info on the New Relic Query Language (NRQL) works, check out this link:


The normal POST request to generate the dashboard image is as follows:

{"query":{"account_id":1523936,"nrql":"SELECT count(*) FROM IntegrationError FACET dataSourceName SINCE 1 DAY AGO"},"account_id":1523936,"endpoint":"/v2/nrql","title":"Authentication Errors"}

The application failed to check and see if the account_id parameter belonged to the user making the request. The account number 1523936 belongs to me, but if I changed it to another number, I could pull data from another account.

So now that I had control over this value, I could change the account ID to any other account ID on New Relic. Since the account ID parameter is incremental, if I was malicious I could simply throw this request into Burp Intruder and highlight the account id value to increment by one on each request, enabling me to pull any data I wanted from any or all accounts on New Relic. The NRQL query could be modified as well, so instead of pulling the data that generated the original dashboard, I could instead change the request to something like this:

{"query":{"account_id":any_account_number_here,"nrql":"SELECT * FROM SystemSample"},"account_id":any_account_number_here,"endpoint":"/v2/nrql","title":"Uh oh!"}

This query runs the SystemSample NRQL query on any account ID, which downloads the following photo:

So this is interesting, but it doesn’t really tell me any juicy info. I know that I’m hitting other accounts, but the information I’m retrieving back is useless – it just shows an empty chart! I played around with this for a little while, trying different NRQL queries until I discovered an interesting header that is in the response back from the server when you send this type of request:

X-Image-Url: http://gorgon.nr-assets.net/image/{UNIQUE_ID}

I realized that if you add ?type= at the end of the URL it will show you different chart types, allowing you to exfiltrate more data than normal. If you enter a incorrect “?type=” value, it will show you all of the available chart options within the error message:

{"code":"BadRequestError","message":"uhoh is not a valid Vizco chart type. Permitted Types: apdex area bar baseline billboard bullet empty event-feed funnel heatmap histogram json line markdown pie stacked-horizontal-bar scatter table traffic-light vertical-bar"}

Now I can use any of the above chart types of return more information than I normally would from the NRQL query:

X-Image-Url: http://gorgon.nr-assets.net/image/{UNIQUE_ID}?type=json

Now we’re getting somewhere! Instead of the normal chart type, I’m now returning a JSON dump of the dashboard, downloaded as a photo. This is pretty great considering I can perform this JSON dump against any account – but I want to go one step further. How can I exfiltrate as much data as possible in each request? Just add a &height=2000 at the end of the URL 🙂

X-Image-Url: http://gorgon.nr-assets.net/image/{UNIQUE_ID}?type=json&height=2000

I reported this to the New Relic team and they fixed it shortly afterwards within a few days. I was awarded $2,500 for this bug. I asked them if they wanted to include any comment on this post about how they fixed the issue, and they provided the following:

For some background, this report helped us identify a logic error with the validation code we have in place in our backend authentication proxy. A very specific combination of configuration options for an application would result in the validation checks not taking place.

Once we identified that issue, we were able to search for anywhere we were using that combination of configuration options to quickly mitigate the issue. That then led to a permanent fix of the logic issue, ensuring that the account validation always took place before the request was allowed to proceed.

The New Relic security team is one of the best ones out there – they award quickly and their time to resolution is fantastic. It’s really one of the main reasons I enjoy hunting for bugs on them so much!

Follow me on Twitter to stay up to date with what I’m working on and security/bug bounties in general 🙂

Abusing internal API to achieve IDOR in New Relic

I recently found a nice insecure direct object reference (IDOR) in New Relic which allowed me to pull data from other user accounts, and I thought it was worthy of writing up because it might make you think twice about the types (and the sheer number!) of API’s that are used in popular web services.

New Relic has a private bug bounty program (I was given permission to talk about it here), and I’ve been on their program for quite some time, so I’ve become very familiar with their overall setup and functionality of the application, but this bug took me a long time to find … and you’ll see why below.

Some background first: New Relic has a public REST API which can be used by anyone with a standard user account . This API operates by passing the X-api-key header along with your query. Here’s an example of a typical API call:

curl -X GET 'https://api.newrelic.com/v2/applications/{application_id}/hosts.json' \
     -H 'X-Api-Key:{api_key}' -i

Pretty typical. I tried to poke at this a little bit by swapping the {application_id} with another user account’s {application_id} that belongs to me. I usually test for IDOR’s this way, by having one browser (Usually Chrome) setup as my “victim account” and another browser (usually Firefox) as the “attacker” account, where I route everything through Burp and check the responses after I change values here and there. It’s kind of an old school way to test for IDOR’s and permission structure issues, and there is probably a much more effective way to automate something like this, but it works for me. Needless to say this was a dead end, and it didn’t return anything fruitful.

I looked further and found that New Relic also implements an internal API which occurs on both their infrastructure product and their alerts product. They conveniently identify this through the /internal_api/ endpoint (and put references to their internal API in some of their .js files as well).

The two products operate on different subdomains, infrastructure.newrelic.com and alerts.newrelic.com. This is what it looks like in Burp, on the alerts.newrelic.com domain (where the IDOR originally occurred).

The reason I bring up the fact there are two separate subdomains is because this bug sat there for an excessive amount of time because I didn’t bother checking both subdomains and their respective internal API’s. To make it even more difficult, there are multiple versions of the internal_api, and the bug only worked on version 1. Here’s what the vulnerable endpoint looked like:

https://alerts.newrelic.com/internal_api/1/accounts/{ACCOUNT NUMBER}/incidents

The account number increases by 1 every time a new account is created, so I could have literally enumerated every single account pretty easily by just running an intruder attack and increasing the value by one each time. The IDOR was possible because the application did not ensure that the account number being requested through the above internal API GET request matched the account number of the authenticated user. 

This IDOR allowed me to view the following from any New Relic account:

  • Account Events
  • Account Messages
  • Violations (Through NR Alerts)
  • Policy Summaries
  • Infrastructure events and filters
  • Account Settings

This bug has been resolved and I was rewarded $1,000. I’d just like to point out that the New Relic engineering and development team was super quick to remediate this. Special thanks to the New Relic team for running one of, if not the best bug bounty programs out there!

Follow me on Twitter to stay up to date with what I’m working on and security/bug bounties in general 🙂