Método eficaz para ocultar email de bots de spam

Na minha página inicial, estou usando esse método para ocultar meu email de bots de spam:

<a href="admin [at] example.com"
   rel="nofollow"
   onclick="this.href='mailto:' + 'admin' + '@' + 'example.com'">Contact me</a>

O que você acha disso? É eficaz? Que outros métodos você conhece ou usa?

Este é o método que eu usei, com uma inclusão no servidor, por exemplo, <!--#include file="emailObfuscator.include" -->onde emailObfuscator.includecontém o seguinte:

<!-- // http://lists.evolt.org/archive/Week-of-Mon-20040202/154813.html -->
<script type="text/javascript">
    function gen_mail_to_link(lhs,rhs,subject) {
        document.write("<a href=\"mailto");
        document.write(":" + lhs + "@");
        document.write(rhs + "?subject=" + subject + "\">" + lhs + "@" + rhs + "<\/a>");
    }
</script>

Para incluir um endereço, eu uso JavaScript:

<script type="text/javascript"> 
    gen_mail_to_link('john.doe','example.com','Feedback about your site...');
</script>
<noscript>
  <em>Email address protected by JavaScript. Activate JavaScript to see the email.</em>
</noscript>

Como recebo e-mails via Gmail desde 2005, o spam é praticamente um problema. Portanto, não posso falar de quão eficaz é esse método. Você pode ler este estudo (embora seja antigo) que produziu este gráfico:

Trabalhando com conteúdo e attr em CSS:

.cryptedmail:after {
  content: attr(data-name) "@" attr(data-domain) "." attr(data-tld); 
}

<a href="#" class="cryptedmail"
   data-name="info"
   data-domain="example"
   data-tld="org"
   onclick="window.location.href = 'mailto:' + this.dataset.name + '@' + this.dataset.domain + '.' + this.dataset.tld; return false;"></a>

Quando o javascript está desativado, apenas o evento click não funciona, o email ainda é exibido.

Outra abordagem interessante (pelo menos sem um evento de clique) seria usar a marca da direita para a esquerda para substituir a direção da escrita. mais sobre isso: https://en.wikipedia.org/wiki/Right-to-left_mark

Dê uma olhada dessa maneira , bastante inteligente e usando css.

CSS

span.reverse {
  unicode-bidi: bidi-override;
  direction: rtl;
}

HTML

<span class="reverse">moc.rehtrebttam@retsambew</span>

O CSS acima substituirá a direção da leitura e apresentará o texto ao usuário na ordem correta.

Espero que ajude

Felicidades

Eu tenho uma opinião completamente diferente sobre isso. Eu uso o MailHide para isso.

MailHide é um sistema do Google em que o usuário precisa concluir um teste reCAPTCHA para depois revelar o e-mail a eles.

Não foi minha ideia originalmente, mas não consigo encontrar o autor:

<a href="mailto:[email protected]"
    onmouseover="this.href=this.href.replace(/x/g,'');">link</a>

Adicione quantos x's desejar. Funciona perfeitamente para ler, copiar e colar e não pode ser lido por um bot.

Acho que o único método infalível que você pode ter é criar uma página Entre em contato comigo, que é um formulário que é enviado para um script enviado para o seu endereço de e-mail. Dessa forma, seu endereço nunca é exposto ao público. Isso pode ser indesejável por algum motivo, mas acho que é uma solução muito boa. Muitas vezes me incomoda quando sou forçado a copiar / colar o endereço de email de alguém do site no cliente de email e enviar uma mensagem; Prefiro fazê-lo através de um formulário no site deles. Além disso, essa abordagem permite que você envie comentários anônimos para você, etc. Certifique-se de proteger seu formulário usando algum tipo de esquema anti-bot, como um captcha. Existem muitos deles discutidos aqui no SO.

Consulte Como proteger endereços de email contra bots em uma página da web?

Gosto da maneira como o Facebook e outras pessoas renderizam uma imagem do seu endereço de e-mail.

Eu também usei o Enkoder no passado - achei muito bom ser honesto!

Se você possui suporte a php, pode fazer algo assim:

<img src="scriptname.php">

E o scriptname.php:

<?php
header("Content-type: image/png");
// Your email address which will be shown in the image
$email    =    "[email protected]";
$length    =    (strlen($email)*8);
$im = @ImageCreate ($length, 20)
     or die ("Kann keinen neuen GD-Bild-Stream erzeugen");
$background_color = ImageColorAllocate ($im, 255, 255, 255); // White: 255,255,255
$text_color = ImageColorAllocate ($im, 55, 103, 122);
imagestring($im, 3,5,2,$email, $text_color);
imagepng ($im);
?>

Sei que minha resposta não será apreciada por muitos, mas considere os pontos descritos aqui antes de fazer o polegar para baixo.

Qualquer coisa facilmente legível por máquina será facilmente legível por máquina pelos spammers. Embora suas ações nos pareçam estúpidas, elas não são pessoas estúpidas. Eles são inovadores e engenhosos. Eles não usam apenas robôs para coletar e-mails, eles têm uma infinidade de métodos à sua disposição e, além disso, eles simplesmente pagam por boas novas listas de e-mails. O que isso significa é que eles conseguiram milhares de hackers de chapéu preto em todo o mundo para executar seus trabalhos. Pessoas prontas para codificar malware que raspa as telas dos navegadores de outras pessoas, o que eventualmente torna inútil qualquer método que você está tentando obter. Este tópico já foi lido por mais de 10 pessoas e elas estão rindo de nós. Alguns deles podem até ficar entediados às lágrimas para descobrir que não podemos colocar um novo desafio para eles.

Lembre-se de que você não está tentando economizar seu tempo, mas o tempo dos outros. Por esse motivo, considere passar um tempo extra aqui. Não existe uma bala mágica fácil de executar que funcione. Se você trabalha em uma empresa que publica e-mails de 100 pessoas no site e pode reduzir 1 e-mail de spam por dia por pessoa, estamos falando de 36500 e-mails de spam por ano. Se a exclusão de um e-mail leva, em média, 5 segundos, estamos falando de 50 horas de trabalho por ano. Sem mencionar a quantidade reduzida de aborrecimento. Então, por que não passar algumas horas nisso?

Não são apenas você e as pessoas que recebem o email que consideram o tempo um ativo. Portanto, você deve encontrar uma maneira de ofuscar os endereços de e-mail dessa maneira, de modo que não compense em decifrá-lo. Se você usar algum método amplamente usado para ofuscar os e-mails, realmente vale a pena decifrá-lo. Como resultado, o cracker terá em mãos milhares, senão dezenas ou centenas de milhares de novos e-mails. E para eles, eles receberão dinheiro.

Então, vá em frente e codifique seu próprio método. Este é um caso raro em que a reinvenção da roda realmente compensa. Use um método que não seja legível por máquina e que, de preferência, exija alguma interação do usuário sem sacrificar a experiência do usuário.

Passei cerca de 20 minutos para codificar um exemplo do que quero dizer. No exemplo, usei o KnockoutJS simplesmente porque gosto e sei que você provavelmente não o usará. Mas é irrelevante de qualquer maneira. É uma solução personalizada que não é amplamente usada. Quebrá-lo não representará uma recompensa por fazê-lo, pois o método de fazê-lo funcionaria apenas em uma única página na vasta Internet.

Aqui está o violino: http://jsfiddle.net/hzaw6/

O código abaixo não pretende ser um exemplo de bom código. Mas apenas uma amostra rápida de código, que é muito difícil para a máquina descobrir, nós até lidamos com e-mails aqui. E mesmo que isso possa ser feito, não vai valer a pena executar em larga escala.

E sim, eu sei que ele não funciona no IE = lte8 por causa de 'Não é possível obter a propriedade' atributos 'de referência indefinida ou nula', mas simplesmente não me importo porque é apenas uma demonstração do método, não uma implementação real, e não se destina a ser usado na produção como é. Sinta-se livre para codificar o seu, que é mais legal, tecnicamente mais sólido etc.

Ah, e nunca nomeie algo como email ou email em html ou javascript. É muito fácil raspar o DOM e o objeto de janela para qualquer coisa chamada email ou email e verificar se ele contém algo que corresponda a um email. É por isso que você não deseja nenhuma variável que contenha email em seu formato completo e também é por isso que você deseja que o usuário interaja com a página antes de atribuir essas variáveis. Se o seu modelo de objeto javascript contiver algum endereço de email no estado pronto para DOM, você os estará expondo aos spammers.

O HTML:

<div data-bind="foreach: contacts">
    <div class="contact">
        <div>
            <h5 data-bind="text: firstName + ' ' + lastName + ' / ' + department"></h5>
            <ul>
                <li>Phone: <span data-bind="text: phone"></span></li>
                <li><a href="#999" data-bind="click:$root.reveal">E-mail</a> <span data-bind="visible: $root.msgMeToThis() != ''"><input class="merged" data-bind="value: mPrefix" readonly="readonly" /><span data-bind="text: '@' + domain"></span></span></li>
            </ul>
        </div>
    </div>
</div>

O JS

function ViewModel(){
    var self = this;

    self.contacts = ko.observableArray([
        { firstName:'John', mPrefix: 'john.doe', domain: 'domain.com', lastName: 'Doe', department: 'Sales', phone: '+358 12 345 6789' },
        { firstName:'Joe', mPrefix: 'joe.w', domain: 'wonder.com', lastName: 'Wonder', department: 'Time wasting', phone: '+358 98 765 4321' },
        { firstName:'Mike', mPrefix: 'yo', domain: 'rappin.com', lastName: 'Rophone', department: 'Audio', phone: '+358 11 222 3333' }
    ]);
    self.msgMeToThis = ko.observable('');
    self.reveal = function(m, e){
        var name = e.target.attributes.href.value;
        name = name.replace('#', '');
        self.msgMeToThis(name);
    };
}
var viewModel = new ViewModel();
ko.applyBindings(viewModel);

Um dos meus métodos favoritos é ofuscar o endereço de email usando php, um exemplo clássico é converter os caracteres em valores HEX da seguinte forma:

function myobfiscate($emailaddress){
 $email= $emailaddress;                
 $length = strlen($email);                         
 for ($i = 0; $i < $length; $i++){                
 $obfuscatedEmail .= "&#" . ord($email[$i]).";";
 }
 echo $obfuscatedEmail;
}

E então, na minha marcação, chamarei da seguinte maneira:

  <a href="mailto:<?php echo myobfiscate('[email protected]'); ?>"
title="Email me!"><?php echo myobfiscate('[email protected]');?> </a>

Em seguida, examine sua fonte, você ficará surpreso!

Você pode tentar ocultar caracteres usando entidades html em hexa (ex: & # x40 para @). Essa é uma solução conveniente, pois um navegador correto irá traduzi-lo e você pode ter um link normal. A desvantagem é que um bot pode traduzi-lo teoricamente, mas é um pouco incomum. Eu uso isso para proteger meu email no meu blog.

Outra solução é usar javascript para montar parte do endereço e decodificar o endereço imediatamente. A desvantagem é que um navegador desabilitado para javascript não mostra seu endereço.

A solução mais eficaz é usar uma imagem , mas é difícil para o usuário copiar o endereço manualmente.

Sua solução é muito boa , pois você apenas adiciona uma desvantagem (escrevendo manualmente o @) apenas para usuários com o javascript desativado. Você também pode estar mais seguro com:

onclick="this.href='mailto:' + 'admin' + '@' + 'domain.com'"

Spambots não interpretará isso, porque é um método menos conhecido :)

Primeiro, defina o css:

email:before {
    content: "admin";
}

email:after {
    content: "@example.com";
}

Agora, onde você quiser exibir seu email, basta inserir o seguinte HTML:

<div id="email"></div>

E tada!

Eu uso uma combinação muito simples de CSS e jQuery, que exibe o endereço de email corretamente para o usuário e também funciona quando a âncora é clicada ou pairada:

HTML:

<a href="mailto:[email protected]" id="lnkMail">moc.elpmaxe@em</a>

CSS:

#lnkMail {
    unicode-bidi: bidi-override;
    direction: rtl;
}

jQuery:

$('#lnkMail').hover(function(){
    // here you can use whatever replace you want
    var newHref = $(this).attr('href').replace('spam', 'com');
    $(this).attr('href', newHref);
});

Aqui está um exemplo de trabalho.

! - Adicionando isso para referência, não sei o quão desatualizada as informações podem estar, mas são apresentadas algumas soluções simples que não exigem o uso de nenhum script

Depois de procurar por mim, me deparei com esta página, mas também estas páginas:

http://nadeausoftware.com/articles/2007/05/stop_spammer_email_harvesters_obfuscating_email_addresses

tente reverter a emailadress

Exemplo de HTML simples:

<bdo dir="rtl">moc.elpmaxe@nosrep</bdo>
Result : [email protected]

O mesmo efeito usando CSS

CSS:
.reverse { unicode-bidi:bidi-override; direction:rtl; }
HTML:
<span class="reverse">moc.elpmaxe@nosrep</span>
Result : person@example.com

Combinar isso com qualquer um dos métodos mencionados anteriormente pode até torná-lo mais eficaz

Uma solução fácil é usar entidades HTML em vez de caracteres reais. Por exemplo, o "[email protected]" será convertido em:

<a href="&#109;&#97;&#105;&#108;&#116;&#111;&#58;&#109;&#101;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;">email me</A>

Aqui está a minha versão de trabalho:

Crie em algum lugar um contêiner com um texto de fallback:

<div id="knock_knock">Activate JavaScript, please.</div>

E adicione na parte inferior do DOM (escrita a renderização) o seguinte trecho:

<script>
  (function(d,id,lhs,rhs){
    d.getElementById(id).innerHTML = "<a rel=\"nofollow\" href=\"mailto"+":"+lhs+"@"+rhs+"\">"+"Mail"+"<\/a>";
  })(window.document, "knock_knock", "your.name", "example.com");
</script>

Ele adiciona o hiperlink gerado ao contêiner especificado:

<div id="knock_knock"><a rel="nofollow" href="[email protected]">Mail</a></div>

Além disso, aqui está uma versão minificada:

<script>(function(d,i,l,r){d.getElementById(i).innerHTML="<a rel=\"nofollow\" href=\"mailto"+":"+l+"@"+r+"\">"+"Mail"+"<\/a>";})(window.document,"knock_knock","your.name","example.com");</script>

O melhor método para ocultar endereços de e-mail é bom apenas até que o programador bot descubra essa "codificação" e implemente um algoritmo de descriptografia.

A opção JavaScript não funcionará muito, porque há muitos rastreadores interpretando JavaScript.

Não há resposta, imho.

Provavelmente existem robôs que reconhecem o [at]e outros disfarces como @símbolo. Portanto, este não é um método realmente eficaz.

Claro que você pode usar algumas codificações, como codificação de URL ou referências de caracteres HTML (ou ambas):

// PHP example
// encodes every character using URL encoding (%hh)
function foo($str) {
    $retVal = '';
    $length = strlen($str);
    for ($i=0; $i<$length; $i++) $retVal.=sprintf('%%%X', ord($str[$i]));
    return $retVal;
}
// encodes every character into HTML character references (&#xhh;)
function bar($str) {
    $retVal = '';
    $length = strlen($str);
    for ($i=0; $i<$length; $i++) $retVal.=sprintf('&#x%X;', ord($str[$i]));
    return $retVal;
}

$email = '[email protected]';
echo '<a href="'.bar('mailto:?to=' . foo(','.$email.'')).'">mail me</a>';

// output
// <a href="&#x6D;&#x61;&#x69;&#x6C;&#x74;&#x6F;&#x3A;&#x3F;&#x74;&#x6F;&#x3D;&#x25;&#x32;&#x43;&#x25;&#x37;&#x35;&#x25;&#x37;&#x33;&#x25;&#x36;&#x35;&#x25;&#x37;&#x32;&#x25;&#x34;&#x30;&#x25;&#x36;&#x35;&#x25;&#x37;&#x38;&#x25;&#x36;&#x31;&#x25;&#x36;&#x44;&#x25;&#x37;&#x30;&#x25;&#x36;&#x43;&#x25;&#x36;&#x35;&#x25;&#x32;&#x45;&#x25;&#x36;&#x33;&#x25;&#x36;&#x46;&#x25;&#x36;&#x44;">mail me</a>

Mas como é legal usá-los, todo navegador / cliente de email também deve lidar com essas codificações.

Sou fã do SpamSpan - ele é ofuscado, mas ainda é decifrável se o JS estiver desativado. Parece funcionar também, embora eu só o use há cerca de um ano em um site de baixo tráfego.

Também existe um módulo para o Drupal transformar automaticamente emails em SpamSpans, se você precisar.

Funciona se eu clicar com o botão direito do mouse no link e escolher "copiar URL"? Caso contrário, não é uma situação ideal (raramente clico no link mailto, preferindo copiar o endereço de e-mail e colá-lo no meu aplicativo de e-mail ou em qualquer outro lugar que eu precisar em um momento específico).

Eu costumava ser bastante paranóico protegendo meu endereço de e-mail on-line (UseNet, web e similares), mas atualmente suspeito que mais "possíveis alvos de spam" sejam gerados correspondendo partes locais a domínios programaticamente. Basro isso em ter, ocasionalmente, examinado meus logs do servidor de correio. Há muitas tentativas de entrega para endereços inexistentes (incluindo versões truncadas da isca de spam que eu usei na UseNet no final dos anos 90, quando a raspagem de endereço era muito prevalente).

depois de usar tantas técnicas, achei uma maneira fácil e muito amigável, os bots pesquisam @ Símbolo e recentemente eles buscam [na] sua variação, então eu uso 2 técnicas

1. escrevo meu email em uma imagem como os domaintolls usam e funciona perfeitamente ou
2. para substituir o Símbolo (@) por uma imagem dele como

e a imagem alt será alt = "@", para que o bot encontre uma imagem e qualquer ser humano a veja como um endereço normal. Se ele a copiar, copiará o e-mail e o trabalho será concluído, de modo que o código será

<p>myname<img src="http://www.traidnt.net/vb/images/mail2.gif" width="11" height="9" alt="@" />domain.com</p>

Existe um script PHP de licença aberta que gera javascript que codifica o email: http://www.maurits.vdschee.nl/php_hide_email/ . Você pode chamar facilmente a função php com o email específico como argumento.

Primeiro, verifique se o endereço de e-mail é exibido apenas quando você tem o javascript ativado. Dessa forma, não há texto simples que possa ser lido sem javascript.

Em segundo lugar, uma maneira de implementar um recurso seguro é ficar longe da <button>etiqueta. Essa tag precisa de uma inserção de texto entre as tags, o que a torna legível por computador. Em vez disso, tente o <input type="button">com um manipulador de javascript para um onClick. Em seguida, use todas as técnicas mencionadas por outras pessoas para implementar uma notação de email segura.

Uma outra opção é ter um botão com "Clique para ver o endereço de email". Depois de clicar, isso muda para um email codificado (os caracteres nos códigos HTML). Em outro clique, isso redireciona para a função 'mailto: email'

Uma versão não codificada da última ideia, com endereços de email selecionáveis ​​e não selecionáveis:

<html>
<body>
<script type="text/javascript">
      e1="@domain";
      e2="me";
      e3=".extension";
email_link="mailto:"+e2+e1+e3;
</script>
<input type="text" onClick="this.onClick=window.open(email_link);" value="Click for mail"/>
<input type="text" onClick="this.value=email;" value="Click for mail-address"/>
<input type="button" onClick="this.onClick=window.open(email_link);" value="Click for mail"/>
<input type="button" onClick="this.value=email;" value="Click for mail-address"/>
</body></html>

Veja se isso é algo que você deseja e combine-o com as idéias dos outros. Você nunca pode ter tanta certeza.

E a minha função. Eu o criei olhando para as respostas colocadas neste tópico.

 function antiboteEmail($email)
 {
        $html = '';

        $email = strrev($email);
        $randId = rand(1, 500);

        $html .= '<span id="addr-'.$randId.'" class="addr">[turn javascript on to see the e-mail]</span>';
        $html .= <<<EOD
                <script>
                $(document).ready(function(){

                    var addr = "$email";
                    addr = addr.split("").reverse().join("");
                    $("#addr-$randId").html("<a href=\"mailto:" + addr + "\">" + addr + " </a>");
                });
                </script>
EOD;

        return $html;
    }

Ele usa dois métodos: dir da direita para a esquerda e colocação de javascript.

Opção 1: divida o endereço de email em várias partes e crie uma matriz em JavaScript a partir dessas partes. Em seguida, junte essas partes na ordem correta e use a propriedade .innerHTML para adicionar o endereço de email à página da web.

 <span id="email">  </span>   // blank tag

 <script>
 var parts = ["info", "XXXXabc", "com", "&#46;", "&#64;"];
 var email = parts[0] + parts[4] + parts[1] + parts[3] + parts[2];
 document.getElementById("email").innerHTML=email; 
 </script>

Opção 2: use imagem em vez de texto de email

Site do criador da imagem a partir do texto: http://www.chxo.com/labelgen/

Opção 3: podemos usar AT em vez de "@" e DOT em vez de "."

ou seja:

 info(AT)XXXabc(DOT)com 

Não gosto que JavaScript e HTML sejam misturados, é por isso que uso esta solução. Funciona bem para mim, por enquanto.

Idéia : você pode complicar ainda mais, fornecendo informações criptografadas nos dataatributos-e descriptografando-as no JS. Isso é feito simplesmente substituindo as letras ou apenas revertendo-as.

HTML :

<span class="generate-email" data-part1="john" data-part2="gmail" data-part3="com">placeholder</span>

JS :

$(function() {
    $('.generate-email').each(function() {
        var that = $(this);
        that.html(
            that.data('part1') + '@' + that.data('part2') + '.' + that.data('part3')
        );
    });  
});

Experimente: http://jsfiddle.net/x6g9L817/

e quanto a HTML_CHARACTER ?:

joe@mail.com

saídas

joe@mail.com

Aqui está uma solução simples de jquery para esse problema:

<script type="text/javascript">
$(document).ready(function() {
    str1="mailto:";
    str2="info";
    str3="@test.com";
    $("#email_a").attr("href", str1+str2+str3);

});
</script>

<a href="#" id="email_a"><img src="sample.png"/></a>

Eu gosto mais da resposta do ofaurax, mas gostaria de modificar isso para um e-mail um pouco mais oculto:

onclick="p1='admin'; p2='domain.com'; this.href='mailto:' + p1 + '& #x40;' + p2"

Eu só tenho que dar uma outra resposta. Acabei de criar algo divertido para brincar.

Descobri que em muitas tabelas de caracteres comuns, as letras @ e az reaparecem mais de uma vez. Você pode mapear os caracteres originais para os novos mapeamentos e dificultar que os bots de spam descubram qual é o email.

Se você percorrer a string e obter o código de caractere de uma letra, adicione 65248 a ela e crie uma entidade html com base no número, você criará um endereço de email legível por humanos.

var str = '[email protected]';
str = str.toLowerCase().replace(/[\.@a-z]/gi, function(match, position, str){
    var num = str.charCodeAt(position);
    return ('&#' + (num + 65248) + ';');
});

Aqui está um violino de trabalho: http://jsfiddle.net/EhtSC/8/

Você pode melhorar essa abordagem criando um conjunto mais completo de mapeamentos entre caracteres com a mesma aparência. Mas se você copiar / colar o email no bloco de notas, por exemplo, você receberá muitas caixas.

Para superar alguns dos problemas de experiência do usuário, criei o email como link. Quando você clica nele, ele remapeia os caracteres de volta aos originais.

Para melhorar isso, você pode criar mapeamentos de caracteres mais complexos, se desejar. Se você pode encontrar vários caracteres que podem ser usados, por exemplo, no lugar de 'a', por que não mapear aleatoriamente para eles.

Provavelmente não é a abordagem mais segura de todas, mas eu realmente me diverti brincando com ela: D