Phishing
Upcoming SlideShare
Loading in...5
×
 

Phishing

on

  • 1,097 views

Phishing

Phishing

Statistics

Views

Total Views
1,097
Views on SlideShare
896
Embed Views
201

Actions

Likes
0
Downloads
37
Comments
0

2 Embeds 201

http://www.comss.info 200
http://translate.googleusercontent.com 1

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Phishing Phishing Document Transcript

    • Phishing by data URI Henning Klevjer henning@klevjers.com August 29, 20121 AbstractHistorically, phishing web pages have been hosted by web servers that areeither compromised or owned by the attacker. This paper introduces a newapproach to creating working phishing web pages without the direct need ofa host. The contents of the phishing web page is simply contained its ownURI (link). We present the appropriate steps to do this, and show a workingexample of such a phishing page.2 IntroductionUsing the data URI scheme it is possible to present media content in a webbrowser without hosting the actual data on the internet. Data URIs followthis scheme: data:[<mediatype>][;base64],<data> Here, <mediatype> are one of the MIME media types described in RFC2046[1]. The MIME media types were originally intended for use with email-ing, but are also used to describe all content on the Internet as well. Thismeans that you can represent any content type (e.g. image/jpeg, text/html,etc.) from the specification that is supported by the web browser. Base64 encoding is optional. Using it ensures that any representation ofdata can be correctly transferred over the internet, by using a manageablealphabet to represent the data rather than raw bytes. Base64 splits the datainto pieces of six bits (yielding 26 = 64) different characters to choose from. To exemplify, data:text/plain;,hello 1
    • shows the text hello without the use of Base64 encoding, and data:text/plain;base64,aGVsbG8=shows the same hello, and the data field now encoded. Data URI technology has been available as RFC 2397[2] since 1998 –described as a way to easily embed text, pictures and other data in HTMLpages, and for such it may be more efficient and hassle-free than hosting apossibly large number of small files. However, with the ability to host arbitrary data within a URI, the possi-bility of doing the same with malicious web content springs to mind. Phish-ing web pages are minimally modified copies of original web pages, usuallyhosted at a compromised or malicious web server. Creating a phishing sitefrom PayPal, Inc., for example, usually implies hosting at least a copy ofPayPal’s login site, credit card information site, or other web page dealingwith sensitive data. All content on the web page can be linked from PayPal’sown content servers. However, using the data URI scheme to contain theentire web page’s contents is also possible. Pictures, JavaScript, style sheetsetc. can either be translated into their own data URI embedded in the file,or be linked from their respective sources. In the last case, all content, suchas a JavaScript in the head tag, must be referenced in an absolute mannerto work, i.e.:<script type=”text/javascript” src=”./javascript.js” />is changed to<script type=”text/javascript” src=”http://example.org/javascript.js” />or<script type=”text/javascript” src=”data:text/javascript;,contents of javascript.js” />3 Creating a phishing siteAn easy recipe of creating a phishing site is shown below: 1. Download the login web page to be copied. 2. Change all file paths relative to the domain to absolute ones, or convert them to data URIs. 3. Make the desired modifications to the site’s code. One can, for example, transfer user credentials or private data to another location. 4. (Optional) Encode the text contents of the web page with Base64 en- coding to obfuscate the data to the victim. Base64 encoding will extend the overall data size by about 33 %. 2
    • 5. Append the encoded material or the text contents of the web page into a data URI: Everything from <!DOCTYPE> (or <HTML>) to </HTML> must be moved into the <data> field above. After this, you will end up with something along these lines. Note thatwe have used text/html as the MIME type as this is the appropriate wayto present HTML pages.data : text / html ; base64 , D Q o 8 I U R P Q 1 R Z U E U g a H R t b C B QVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wMSBUcmFuc2l0aW9uYWwvL0VOIg0KImh0dHA6Ly93d3cudzMub3JnL1RSL 2h 0 b W w 0 L 2 x v b 3 N l L m R 0 Z C I + D Q o 8 a H R t b D 4 N C i A g I C A 8 a G(...)bnR3ZWIyLndvYS9Db250ZW50cy9XZWJTZXJ2ZXJSZXNvdXJjZXMvc3dfYmFzZS5jc3MnIHJlbD0ic3R5bGVzaGVldCIgdHlwZT0idGV4dC9jc3MiPg0KICAgICAgICA8c3R5bGUgdHlwZT0idGV4dC9jc3MiPg0KCQkJdGQ The length of the final URI is a consequence of the data hidden within.If the original web page is very large, embedding linked material within maynot be viable. An example is provided below (Appendix A), which because of its sizehas been appended at the end.4 Spreading the phishing web pageRemembering that the web page is contained within the URI, “only”1 theURI must be passed on to a potential victim. Historically, phishing URIsare transferred by email, but in recent years, social media phishing has ex-ploded. The use of URL shortening services has provided an additional layerof uncertainty in abstracting the original URL from the user2 . (At least)One URL shortening services, TinyURL.com3 , also provides the possibilityof shortening data URIs into short URLs. Whether or not TinyURL doesthis unwittingly is not known.5 Applicability and limitationsBeing a rather old RFC specification, data URIs are supported by all majorcontemporary web browsers. A possible problem of this approach is rather 1 The URI could easily reach hundreds of kilobytes 2 However, as the user reaches the target URL, it will be shown in the address bar. 3 http://TinyURL.com 3
    • the web browsers’ memory management. The address field is simply notcreated for containing the enormous amount of bytes contained in the dataURI. In Google Chrome in particular, a control for unsafe redirection is im-plemented, disabling the user direct access to a data URI if that URI isthe target of a redirection, such as from a URL shortening service. Theuser is presented with an alert that ”This webpage is not available”, to-gether with the entire URI. Appended below is the error code Error 311(net::ERR UNSAFE REDIRECT): Unknown error. indicating that the re-quest was denied due to an unsafe state. However, the target URI is stillpresent in the address field, and a push of the enter button successfully ren-ders the web page. Note that Google Chrome does not produce an errorwhen the user clicks directly on the data URI, without the redirection. Internet Explorer has a limit to data URIs,6 Legal issuesIn addition to the obvious issues with phishing, a discussion is appropriateas to whether a web host that keeps malicious data URIs is liable for hostingthe malicious content they represent. In the above scenario, it can be arguedthat the URL shortening service is the host, as it provides and keeps theactual content.7 Future WorkWe may see more of so called “spear phishing”, attempts focused on indi-viduals, as phishing pages now can be created more easily. A personalisedphishing web page can be created automatically, based on gathered informa-tion, and transmitted to one victim only. There is reason to believe that thedata URI scheme can provide other unknown attack vectors, so research onthis topic and further scrutiny of the scheme is a prudent choice.8 ConclusionIn this paper we have introduced a new way of presenting phishing webpages using a rather old, seldom used way to present web content. Usingthis procedure, there is no clear source of the phishing page and its content,which makes it difficult to trace, monitor the movement or establish theorigin of the web page. Also, we conclude that phishing no longer requires 4
    • web hosting of the page4 , so phishing web pages may be more elusive passedaround the Internet. They have no established anchor point in the Internet. There is no way to shut down or remove a data URI web page, besidesremoving all instances of its link. The example presented in this document contains no harmfulcode. The example, and anything learned from this documentshould NEVER be used to perform any malicious activity.We do not with this example try to point out any vulnerability orweakness specific to Wikipedia, which was selected because of itsinternational reputation and simple login page.References[1] N. Freed and N. Borenstein. Multipurpose Internet Mail Extensions (MIME) Part Two: Media Types. RFC 2046 (Draft Standard). Updated by RFCs 2646, 3798, 5147. Internet Engineering Task Force, Nov. 1996. url: http://www.ietf.org/RFC/RFC2046.txt.[2] L. Masinter. The “data” URL scheme. RFC 2397 (Proposed Standard). Internet Engineering Task Force, Aug. 1998. url: http://www.ietf. org/RFC/RFC2397.txt.Appendix A: An example phishing web pageBelow we present a phishing edition of the login and registration page of theEnglish Wikipedia, http://en.wikipedia.org/. It is a minimal example, inwhich some relative links have been corrected. Additionally, the functionalityof the “Log in” button has been altered, showing the password entered in thepassword field to the user. The login screen of the English Wikipedia can befound here: http://en.wikipedia.org/w/index.php?title=Special:UserLogin 4 While transmission of sensitive data can be handled within the phishing page, receivingand storing the data is not taken into consideration here. 5
    • The rendered web page 6
    • Base64 encoded data URIThis data URI consists of 24682 characters and can with ease be shrunkto 26 characters with a supported URL shortening service, such as the onementioned. 7
    • data:text/html;base64,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
    • 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
    • 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
    • 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