I'm working on an assistant (written in VB.NET for Winforms) to help screening and distribution of incoming e-mails inside my organization, which is and will continue to be made by human employees (I just need to speed up their work). Program will convert each message to HTML document and its attachments to PDF and will store it in internal database. This part is already working.
I'm already using HtmlAgilityPack to handle inline images (src="cid:..."), but I'm worried about what can I do to prevent malicious content inside the message can be activated when showing it (in a .NET's WebBrowser control).
I thought of two things I could do, also with HtmlAgilityPack:
removal of every <script> element;
changing of every <a href="..."> attribute to "#"
Can anyone who is more experienced with this issue suggest additional steps I should take on this "cleansing" of each message's HTML?
Thank you very much!
As an extra layer of security you can:
check embedded URLs with an URL scanner. I suggest UrlVoid, they have an API too (pointless if you have already a proper virus scanner).
As suggested, you can remove all script and additional all style blocks:
Dim doc As HtmlAgilityPack.HtmlDocument = New HtmlAgilityPack.HtmlDocument
doc.LoadHtml(html)
doc.DocumentNode.Descendants.Where(() => { }, ((n.Name = "script") _
OrElse (n.Name = "style"))).ToList.ForEach(() => { }, n.Remove)
parse out any unwanted attributes to elements you don't want to allow, like onclick() and other javascript events.
remove other unwanted tags: HTML Agility Pack strip tags NOT IN whitelist
Note: There are a lot of powerful PHP HTML sanitizer/purifier. You can play around with them to do some quick tests (or even use one to pre-process your content). Most often HTML Purifier is recommended.
Let's say a user adds some PHP code <?php //code here ?> into an input text tag (which they aren't supposed to in this case), would the opening and closing tags be converted into < and > or would they remain as they are like in a contenteditable div?
User input is just raw text attached to a property in the DOM.
It isn't HTML, PHP, or anything else until something is done with it (such as a form being submitted or JavaScript reading the property and manipulating it).
The raw text will reside in the standard HTML input and the PHP code a users enters will not be executed.
However depending on what your code does with it (send it to a database or web service), an attacker may potentially be able to perform an attack if it is not sanitized correctly.
Therefore, you should always aim to sanitize user input, both at the client and server side level, especially if it fires off to a database.
Different frameworks will support Sanitization. In PHP, you have access to the following sanitization filters.
For reference, you should also be aware of other attacks such as SQL injection/XSS. I would recommend looking at the OWASP top 10 which outlines some common web attacks and discusses PHP filters.
I have created a very basic example of reflecting back user input here which could happen if the attacker manages to save malicious code in your database:
var text = document.getElementById("test").value;
eval(text);
<input id="test" type="text" value="alert('I have access to you document cookies and could use a windows redirection here')" />
tl;dr
Hide email address from bots without using scripts and maintain mailto: functionality. Method must also support screen-readers.
Summary
Email obfuscation without using scripts or contact forms
Email address needs to be completely visible to human viewers and maintain mailto: functionality
Email Address must not be in image form.
Email address must be "completely" hidden from spam-crawlers and spam-bots and any other harvester type
Desired Effect:
No scripts, please. There are no scripts used in the project and I'd like to keep it that way.
Email address is either displayed on the page or can be easily displayed after some sort of user interaction, like opening a modal.
The user can click on on the email address which in turn would trigger the mailto: functionality.
Clicking the email will open the user's email application.
In other words, mailto: functionality must work.
The email address in not visible or not identified as an email address to bots (This includes the page source)
I don't have an inbox that's full of spam
What does NOT Work
Adding a contact form - or anything similar - instead of the email address
I hate contact forms. I rarely fill up a contact form. If there's no email address, I look for a phone number, and if that's not there, I start looking for an alternative service. I would only fill up a contact form if I absolutely have to.
Replacing the address with an image of the address
This creates a HUGE disadvantage to someone using a screenreader (please remember the visually impaired in your future projects)
It also removes the mailto: functionality unless you make the image clickable and then add the mailto: functionality as the href for the link, but that defeats the purpose and now the email is visible to bots.
What might work:
Clever usage of pseudo-elements in CSS
Solutions that make use of base64 encoding
Breaking up the email address and spreading the parts across the document then putting them back together in a modal when the user clicks a button (This will probably involve multiple CSS classes and the usage of anchor tags)
Alterting html attributes via CSS
#MortezaAsadi gracefully brought up the possibility in the comments below. This is the link to the full - The article is from 2012:
What if We Could Use CSS to Alter HTML Attributes?
Other creative solutions that are beyond my scope of knowledge.
Similar Questions / Fixes
JavaScript: Protect your email address by Joe Maller
(This a great fix suggested by Joe Maller, it works well but it's script based. Here's what it looks like;
<SCRIPT TYPE="text/javascript">
emailE = 'example.com'
emailE = ('yourname' + '#' + emailE)
document.write('' + emailE + '')
</script>
<NOSCRIPT>
Email address protected by JavaScript
</NOSCRIPT>
Looking for a PHP only email address obfuscator function
(A Clever solution using both PHP and CSS to first reverse the email using PHP then reverse it back with CSS) A very promising solution that Works great! But it's too easy to solve.
Is it worth obfuscating email addresses on the web these days?
(JavaScript fix)
Best way to obfuscate an e-mail address on a website?
The selected answer works. It actually works really well. It involves encoding the email as html entities. Can it be improved?
Here's what it looks like;
<A HREF="mailto:
yourname#domain.com">
yourname#domain.com
</A>
Does e-mail address obfuscation actually work?
(The selected answer to this SuperUser question is great and it presents a study of the amount of spam received by using different obfuscation methods.
It seems that manipulating the email address with CSS to make it rtl does work. This is the same method used in the first question I linked to in this section.
I am uncertain what effects adding mailto: functionality to the fix would have on the results.
There are also many other questions on SO which all have similar answers. I have not found anything that fits my desired effect
The Question:
Would it be possible to increase the efficiency (ie as little spam as possible) of the email obfuscation methods above by combining two or more of the fixes (or even adding new fixes) while:
A- Maintaining mailto: functionality; and
B- Supporting screen-readers
Many of the answers and comments below pose a very good question while indicating the impossibility of doing this without some sort of js
The question that's asked/implied is:
Why not use js?
The answer is that I am allergic to js
Joking aside though,
The three main reasons I asked this question are:
Contact forms are becoming more and more accepted as a replacement
for providing an email address - which they should not.
If it can be done without scripting then it should be done without
scripting.
Curiosity: (as I am in fact using one of the js fixes currently) I wanted to see if discussing the matter would lead to a better way of doing it.
The issue with your request is specifically the "Supporting screen-readers", as by definition screen readers are a "bot" of some sort. If a screen-reader needs to be able to interpret the email address, then a page-crawler would be able to interpret it as well.
Also, the point of the mailto attribute is to be the standard of how to do email addresses on the web. Asking if there is a second way to do that is sort of asking if there is a second standard.
Doing it through scripts will still have the same issue as once the page is loaded, the script would have been run and the email address rendered in the DOM (unless you populate the email address on click or something). Either way, screen readers will still have issues with this since it's not already loaded.
Honestly, just get an email service with a half decent spam filter and specify a default subject line that is easy for you to sort in your inbox.
Email me
What you're asking for is if the standard has two ways to do something, one for bots and the other for non-bots. The answer is it doesn't, and you have to just fight the bots as best you can.
Defeating email bots is a tough one. You may want to check out the Email Address Harvesting countermeasures section on Wikipedia.
My back-story is that I've written a search bot. It crawled 105,000+ URLs during it's initial run many years ago. From what I've learned from doing that is that web crawling bots literally see EVERYTHING that is text, which appears on a web page. Bots read everything except images.
Spam can't be easily stopped via code for these reasons:
CSS & JS are irrelevant when using the mailto: tag. Bots specifically look at HTML pages for that "mailto:" keyword. Everything from that colon to the next single quote or double quote (whichever comes first) is seen as an email address. HTML entity email addresses - like the example above - can be quickly translated using a reverse ASCII method/function. Running the JavaScript code snippet above, quickly turns the string which starts with: your... into... yourname#example.com. (My search bot threw away hrefs with mailto:email addresses, as I wanted URLs for web pages & not email addresses.)
If a page crashes a bot, the bot author will tune the bot to fix the crash with that page in mind, so that the bot won't crash at that page again in the future. Thus making their bot smarter.
Bot authors can write bots, which generate all known variations of email addresses... without crawling pages & never using any starter email addresses. While it may not be feasible to do that, it's not inconceivable with today's high-core count CPUs (which are hyper-threaded & run at 4+ GHz), plus the availability of using distributed cloud-based computing & even super computers. It's conceivable that someone can now create a bot-farm to spam everyone, without knowing anyone's email address. 20 years ago, that would have been incomprehensible.
Free email providers have had a history of selling their free user accounts to their advertisers. In the past, simply signing up for a free email account automatically guaranteed them a green light to start delivering spam to that email address... without ever using that email address online. I've seen that happen multiple times, with famous company names. (I won't mention any names.)
The mailto: keyword is part of this IETF RFC, where browsers are built to automatically launch the default email clients, from links with that keyword in them. JavaScript has to be used to interrupt that application launching process, when it happens.
I don't think it's possible to stop 100% of spam while using traditional email servers, without using filters on the email server and possibly using images.
There is one alternative... You can also build a chat-like email client, which runs internally on a website. It would be like Facebook's chat client. It's "kind of like email", but not really email. It's simply 1-to-1 instant messaging with an archiving feature... that auto-loads upon login. Since it has document attachment + link features, it works kind of like email... but without the spam. As long as you don't build an externally accessible API, then it's a closed system where people can't send spam into it.
If you're planning to stick with strictly traditional email, then your best bet may be to run something like Apache's SpamAssassin on a company's email server.
You can also try combining multiple strategies as you've listed above, to make it harder for email harvesters to glean email addresses from your web pages. They won't stop 100% of the spam, 100% of the time... while also allowing 100% of the screen readers to work for blind visitors.
You've created a really good starting look at what's wrong with traditional email! Kudos to you for that!
A good screen reader is JAWS from Freedom Scientific. I've used that before to listen to how my webpages are read by blind users. (If you hear a male voice reading both actions [like clicking on a link] & text, try changing 1 voice to female so that 1 voice reads actions & another reads text. That makes it easier to hear how the web page is read for the visually impared.)
Good luck with your Email Address Harvesting countermeasure endeavours!
Here is an approach that does make use of JavaScript, but with a rather small foot-print. It's also very "ghetto", and generally I would not recommend an approach with inline JS in the HTML except you have an extreme reluctance to use JS, at all.
<a
href="#"
data-contact="bGUtZW1haWxAdGhlLWRvbWFpbi5jb20="
data-subj="QW4gQW1hemluZyBTdWJqZWN0"
onfocus="this.href = 'mailto:' + atob(this.dataset.contact) + '?subject=' + atob(this.dataset.subj || '')"
>
Send an email
</a>
data-contact is the base64 encoded email address. And, data-subj is an optional base64 encoded subject.
The main challenge with doing this without JS is that CSS can't alter HTML attributes. (The article you linked is a "pie-in-the-sky" musing and does not have any bearing on what is possible today or in the near future.)
The HTML entities approach you mentioned, or some variation of it, is likely the simplest option that will have some efficacy. Additionally, the iframe approach is clever and the server redirect approach is pretty awesome. But, all three are vulnerable to bots:
The HTML entities just need to be converted (and detecting that is simple)
The document referenced by the iframe might simply be followed
The server redirect might simply be followed, as well
With the approach outlined above, the use of a base64 encoded email address in a data-contact attribute is very "one-off" – as long as the scraper is not specifically designed for your site, it should work.
Simple + Lot of # + Editable without tools
<a href="mailto:user#domain##com"
onmouseover="this.href=this.href.replace('##','.')">
Send email
</a>
Have you considered using google's recaptcha mailhide?
https://www.google.com/recaptcha/admin#mailhide
The idea is that when a user clicks the checkbox (see nocaptcha below), the full e-mail address is displayed.
While recaptcha is traditionally not only hard for screen readers but also humans as well, with the roleout of google's nocaptcha recaptcha which you can read about
here as they relate to accessibility tests. It appears to show promise with to screen readers as it renders as a traditional checkbox from their view.
Example #1 - Not secure but for easy illustration of the idea
Here is some code as an example without using mailhide but implementing something using recaptcha yourself: https://jsfiddle.net/43fad8pf/36/
<div class="container">
<div id="recaptcha"></div>
</div>
<div id="email">
Verify captcha to get e-mail
</div>
function createRecaptcha() {
grecaptcha.render("recaptcha", {sitekey: "6LcgSAMTAAAAACc2C7rc6HB9ZmEX4SyB0bbAJvTG", theme: "light", callback: showEmail});
}
createRecaptcha();
function showEmail() {
// ideally you would do server side verification of the captcha and then the server would return the e-mail
document.getElementById("email").innerHTML = "email#example.com";
}
Note: In my example I have the e-mail in a JavaScript function. Ideally you would have the recaptcha validated on the server end, and return the e-mail, otherwise the bot can simply get it in the code.
Example #2 - Server side validation and returning of e-mail
If we use an example more like this, we get additional security: https://designracy.com/recaptcha-using-ajax-php-and-jquery/
function showEmail() {
/* Check if the captcha is complete */
if ($("#g-recaptcha-response").val()) {
$.ajax({
type: ‘POST’,
url: "verify.php", // The file we’re making the request to
dataType: ‘html’,
async: true,
data: {
captchaResponse: $("#g-recaptcha-response").val() // The generated response from the widget sent as a POST parameter
},
success: function (data) {
alert("everything looks ok. Here is where we would take 'data' which contains the e-mail and put it somewhere in the document");
},
error: function (XMLHttpRequest, textStatus, errorThrown) {
alert("You’re a bot");
}
});
} else {
alert("Please fill the captcha!");
}
});
Where verify.php is:
$captcha = filter_input(INPUT_POST, ‘captchaResponse’); // get the captchaResponse parameter sent from our ajax
/* Check if captcha is filled */
if (!$captcha) {
http_response_code(401); // Return error code if there is no captcha
}
$response = file_get_contents("https://www.google.com/recaptcha/api/siteverify?secret=YOUR-SECRET-KEY-HERE&response=" . $captcha);
if ($response . success == false) {
echo ‘SPAM’;
http_response_code(401); // It’s SPAM! RETURN SOME KIND OF ERROR
} else {
// Everything is ok, should output this in json or something better, but this is an example
echo 'email#example.com';
}
People who write scrapers want to make their scrapers as efficient as possible. Therefore, they won't download styles, scripts, and other external resources. There's no method that I know of to set a mailto link using CSS. In addition, you specifically said you didn't want to set the link using Javascript.
If you think about what other types of resources there are, there's also external documents (i.e. HTML documents using iframes). Almost no scrapers would bother downloading the contents of iframes. Therefore, you can simply do:
index.html:
<iframe src="frame.html" style="height: 1em; width: 100%; border: 0;"></iframe>
frame.html:
My email is me#example.com
To human users, the iframe looks just like normal text. Iframes are inline and transparent by default, so we just need set its border and dimensions. You can't make the size of the iframe match its content's size without using Javascript, so the best we can do is giving it predefined dimensions.
First, I don't think doing anything with CSS will work. All bots (except Google's crawler) simply ignore all styling on websites. Any solution has to work with JS or server-side.
A server-side solution could be making an <a> that links to a new tab, which simply redirects to the desired mailto:
That's all my ideas for now. Hope it helps.
Short answer to fulfill all your requirements is that it's impossible
Some of the script-based options answered here may work for certain bots, but you wanted no-script, so, no, you can't.
based on the code of MaanooAk, here is my version:
<a href="mailto: Mike Myers"
onclick="this.href=this.href.replace(' Mike ','MikeMy'); this.href=this.href.replace('Myers','ers#vwx.yz')">✉ Send Email</a>
The difference to MaanookAks version is, that on hover you don't see mailto: and a broken email adress but mailto: and the name of contact. And when you click on it, the name is replaced by the email adress.
In the code the email adress is splitted into two parts. Nowhere in the code the email adress is visible complete.
Here is my new solution for this. I first build the email adress string by addition of small pieces and then use this string also as title:
adress = 'mailt' + 'o:MikeM' + 'yers#v' + 'wx.yz';
document.getElementsByClassName('Email')[0].title = adress;
function mail(){window.location.href = adress;}
<a class='Email' onclick='mail()'>✉ Send Email</a>
I use this in a footer of a website. Many pages with all the same footer.
PHP solution
function printEmail($email){
$email = ''.$email.'';
$a = str_split($email);
return "<script>document.write('".implode("'+'",$a)."');</script>";
}
Use
echo printEmail('test#example.com');
Result
<script>document.write('<'+'a'+' '+'h'+'r'+'e'+'f'+'='+'"'+'m'+'a'+'i'+'l'+'t'+'o'+':'+'t'+'e'+'s'+'t'+'#'+'g'+'m'+'a'+'i'+'l'+'.'+'c'+'o'+'m'+'"'+'>'+'t'+'e'+'s'+'t'+'#'+'g'+'m'+'a'+'i'+'l'+'.'+'c'+'o'+'m'+'<'+'/'+'a'+'>');</script>
P.S. Requirement: user must have JavaScript enabled
The one method I found effective is using it with CSS like below:
<a href="mailto:myemail#ignore-domain.com">myemail#<span style="display:none;">ignore-</span>example.com
and then write a JavaScript to remove the ignoreme- word from the href="mailto:..." attribute with regex. This will hide email from bot as it will append ignore- word before real domain and this will work on screen reader and when user clicks on the link custom JS function will remove the ignore- word from href attribute so it will open the real email.
This method has been working very effectively for me till date. you can read more on this - http://techblog.tilllate.com/2008/07/20/ten-methods-to-obfuscate-e-mail-addresses-compared/
I read some AJAX-Form tutorial like this. The tag form is used in HTML code. However, I believed that it is not necessary. Since we send HTTP request through XmlHttpRequest, the sent data can be anything, not necessary input in form.
So, is there any reason to have form tag in HTML for AJAX application?
Apart from progressive enhancement as already discussed (don't make your site require JavaScript until it really has to), a <form> with onsubmit would be necessary to reliably catch an Enter keypress submission.
(Sure, you can try trapping keypresses on separate form fields, but it's fiddly, fragile and will never 100% reproduce the browser's native behaviour over what constitutes a form submission.)
Sometimes, web apps using ajax to transform their data either use forms as a fallback when the user has no JavaScript enabled (a sometimes expensive but very good thing to do).
Otherwise, if an application builds and sends an AJAX request, there is no compelling reason to use a form except in rare special cases when you actually need a form element. Off the top of my head:
when using jQuery's form serialize function
when monitoring all fields in a form for changes
when there is need to make use of the reset form button (that to my knowledge is available in a proper <form> only).
I see at least two possible reasons :
Graceful degradation (see also Unobtrusive JavaScript) : if a user doesn't have Javascript enabled in his browser, your website should still work, with plain-old HTML.
Behavior of the browser : users know what forms look like and how they behave (auto-completion, error-correction, ...) ; it's best not going too far away from that
And I would add that, if you want the user to input some data, that's why <form> and <input> tags exist ;-)
Using the right tags also helps users -- as an example, think about blind users who are navigating with some specific software : those software will probably have a specific behavior for forms an input fields.
It really depends what you're doing. If you're wanting to take form content submitted by the user and use AJAX to send that somewhere then you're going to want to use the form tag so your user can enter their data somewhere.
There will be other times when you're not sending data from a form and in that case, you wont have a form to be concerned about :)
So I'm working on a web app, and I want to filter search results.
A nice restful implementation might look like this:
1. mysite.com/clothes/men/hats+scarfs
But lets say we want to ajax up the filtering, like the cool kids, and we want to retain deep linking, we might use the anchor tag and parse that with Javascript to show the correct listings:
2. mysite.com/clothes#/men/hats+scarfs
However, if someone clicks the first link with JS enabled, and then changes filters, we might get:
3. mysite.com/clothes/men/hats+scarfs#/women/shoes
Urk.
Similarly, if someone does not have JS enabled, and clicks link 2 - JS will not parse the options and the correct listings will not be shown.
Are Ajax deep links and non-Ajax links incompatible? It would seem so, as servers cannot parse the # part of a url, since it is not sent to the server.
There's a monkeywrench being thrown into this issue by Google: A proposal for making Ajax crawlable. Google is including recommendations for url structure there that may give you ideas for your own application.
Here's the wrapup:
In summary, starting with a stateful
URL such as
http://example.com/dictionary.html#AJAX
, it could be available to both
crawlers and users as
http://example.com/dictionary.html#!AJAX
which could be crawled as
http://example.com/dictionary.html?_escaped_fragment_=AJAX
which in turn would be shown to users
and accessed as
http://example.com/dictionary.html#!AJAX
View Google's Presentation here (note: google docs presentation)
In general I think it's useful to simply turn off JavaScript and CSS entirely and browse your website and web application and see what ends up getting exposed. Once you get a sense of what's visible, you will understand what most search engines see and that in turn will show you what is and is not getting spidered.
If you go to mysite.com/clothes/men/hats+scarfs with JavaScript enabled then your JavaScript should automatically rewrite that to mysite.com/clothes#men/hats+scarfs - when you click on a filter, they should be controlled by JavaScript meaning you'll only change the hashtag rather than the entire URL (as you're going to have return false anyway).
The problem you have is for non-JS users going to your JS enabled deeplinks as the server can't determine that stuff. Unfortunately, the only thing you can do is take them to mysite.com/clothes and make them start their journey again (as far as I'm aware). You'll need to try and ensure that when people link to the site, they use the hardcoded deeplink rather than the hashed deeplink
I don't recommend ever using the query string as you are sending data back to the server without direct relevance to the prior specified destination. That is a corruptible security hole as malicious code can be manually added to the query string to cause a XSS or buffer overflow attack at your webserver.
I believe REST was intended to work with absolute URIs without a query string, because then your specifying only a location of a resource and it is that location that is descriptive and semantically relevant in addition to the possibility of the resource being so equally relevant. Even if there is no resource at the specified path you have still instantiated a potentially unique and descriptive location that can be processed accordingly.
Users entering the site via deep links
Nonsensical links (like /clothes/men/hats#women/shoes) can be avoided if you construct your Ajax initialisation code in such a way that users who enter the site on filtered pages (e.g. /clothes/women/shoes) are taken to the /clothes page before any Ajax filtering happens. For example, you might do something like this (using jQuery):
$("a.filter")
.each(function() {
var href = $(this).attr("href").replace("/clothes/", "/clothes#");
$(this).attr("href", href);
})
.click(function() {
update_filter($(this).attr("href").split("#")[1]);
});
Users without JavaScript
As you said in the question, there's no way for the server to know about the URL fragment so filtering would not be applied for users without JavaScript enabled if they were given a link to /clothes#filter.
However, even without filtering, these links could be made more meaningful for non-JS users by using the filter strings as IDs in your /clothes page. To prevent this messing with the Ajax experience the IDs would need to be changed (or the elements removed) with JavaScript before the Ajax links were initialised.
How practical this is depends on how many categories you have and what your /clothes page contains.