Um site pode detectar quando você está usando selênio com o chromedriver?

Eu testei o Selenium com o Chromedriver e notei que algumas páginas podem detectar que você está usando o Selenium, mesmo que não haja automação. Mesmo quando estou apenas navegando manualmente, usando o Chrome através do Selenium e do Xephyr, muitas vezes recebo uma página dizendo que atividades suspeitas foram detectadas. Verifiquei meu agente de usuário e a impressão digital do navegador, e todos são exatamente idênticos ao navegador Chrome normal.

Quando eu navego para esses sites no chrome normal, tudo funciona bem, mas no momento em que uso o Selenium sou detectado.

Em teoria, o chromedriver e o chrome devem parecer literalmente exatamente o mesmo para qualquer servidor da web, mas de alguma forma eles podem detectá-lo.

Se você quiser algum código de teste, tente o seguinte:

from pyvirtualdisplay import Display
from selenium import webdriver

display = Display(visible=1, size=(1600, 902))
display.start()
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--disable-extensions')
chrome_options.add_argument('--profile-directory=Default')
chrome_options.add_argument("--incognito")
chrome_options.add_argument("--disable-plugins-discovery");
chrome_options.add_argument("--start-maximized")
driver = webdriver.Chrome(chrome_options=chrome_options)
driver.delete_all_cookies()
driver.set_window_size(800,800)
driver.set_window_position(0,0)
print 'arguments done'
driver.get('http://stubhub.com')

Se você navegar pelo stubhub, será redirecionado e "bloqueado" em uma ou duas solicitações. Estou investigando isso e não consigo descobrir como eles podem dizer que um usuário está usando o Selenium.

Como eles fazem isso?

EDIT UPDATE:

Instalei o plugin Selenium IDE no Firefox e fui banido quando visitei o stubhub.com no navegador normal do Firefox, apenas com o plug-in adicional.

EDITAR:

Quando uso o Fiddler para visualizar as solicitações HTTP enviadas e recebidas, notei que as solicitações de 'navegador falso' geralmente têm 'sem cache' no cabeçalho da resposta.

EDITAR:

resultados como este Existe uma maneira de detectar que estou em uma página do Selenium Webdriver em Javascript sugerir que não deve haver maneira de detectar quando você estiver usando um webdriver. Mas essa evidência sugere o contrário.

EDITAR:

O site carrega uma impressão digital em seus servidores, mas eu verifiquei e a impressão digital do selênio é idêntica à impressão digital ao usar o chrome.

EDITAR:

Essa é uma das cargas úteis de impressão digital que eles enviam para seus servidores

{"appName":"Netscape","platform":"Linuxx86_64","cookies":1,"syslang":"en-US","userlang":"en-US","cpu":"","productSub":"20030107","setTimeout":1,"setInterval":1,"plugins":{"0":"ChromePDFViewer","1":"ShockwaveFlash","2":"WidevineContentDecryptionModule","3":"NativeClient","4":"ChromePDFViewer"},"mimeTypes":{"0":"application/pdf","1":"ShockwaveFlashapplication/x-shockwave-flash","2":"FutureSplashPlayerapplication/futuresplash","3":"WidevineContentDecryptionModuleapplication/x-ppapi-widevine-cdm","4":"NativeClientExecutableapplication/x-nacl","5":"PortableNativeClientExecutableapplication/x-pnacl","6":"PortableDocumentFormatapplication/x-google-chrome-pdf"},"screen":{"width":1600,"height":900,"colorDepth":24},"fonts":{"0":"monospace","1":"DejaVuSerif","2":"Georgia","3":"DejaVuSans","4":"TrebuchetMS","5":"Verdana","6":"AndaleMono","7":"DejaVuSansMono","8":"LiberationMono","9":"NimbusMonoL","10":"CourierNew","11":"Courier"}}

É idêntico no selênio e no cromo

EDITAR:

As VPNs funcionam para um único uso, mas são detectadas depois que eu carrego a primeira página. Claramente, algum javascript está sendo executado para detectar o Selenium.

Para usuários de Mac

Substituindo cdc_variável usando Vim ou Perl

Você pode usar vim, ou como o @Vic Seedoubleyew apontou na resposta de @ Erti-Chris Eelmaa perl, para substituir a cdc_variável chromedriver( consulte a postagem de @ Erti-Chris Eelmaa para saber mais sobre essa variável ). Usar vimou perlimpedir que você precise recompilar o código-fonte ou usar um editor hexadecimal. Certifique-se de fazer uma cópia do original chromedriverantes de tentar editá-lo. Além disso, os métodos abaixo foram testados chromedriver version 2.41.578706.

Usando o Vim

vim /path/to/chromedriver

Depois de executar a linha acima, você provavelmente verá várias bobagens. Faça o seguinte:

1. Procure cdc_digitando /cdc_e pressionando return.
2. Ative a edição pressionando a.
3. Exclua qualquer quantidade $cdc_lasutopfhvcZLmcfle substitua o que foi excluído por caracteres com uma quantidade igual. Caso contrário, chromedriverfalhará.
4. Depois de terminar a edição, pressione esc.
5. Para salvar as alterações e sair, digite :wq!e pressione return.
6. Se você não deseja salvar as alterações, mas deseja sair, digite :q!e pressione return.
7. Você Terminou.

Vá para o alterado chromedrivere clique duas vezes nele. Uma terminaljanela deve abrir. Se você não vê killedna saída, alterou o driver com sucesso.

Usando Perl

A linha abaixo substitui cdc_por dog_:

perl -pi -e 's/cdc_/dog_/g' /path/to/chromedriver

Certifique-se de que a sequência de substituição tenha o mesmo número de caracteres que a sequência de pesquisa, caso contrário chromedriverela falhará.

Explicação Perl

s///g indica que você deseja procurar uma sequência e substituí-la globalmente por outra (substitui todas as ocorrências).

por exemplo, s/string/replacment/g

Assim,

s/// denota pesquisando e substituindo uma sequência.

cdc_ é a string de pesquisa.

dog_ é a sequência de substituição.

g é a chave global, que substitui todas as ocorrências da sequência.

Como verificar se a substituição do Perl funcionou

A seguinte linha imprimirá todas as ocorrências da sequência de pesquisa cdc_:

perl -ne 'while(/cdc_/g){print "$&\n";}' /path/to/chromedriver

Se isso não retornar nada, cdc_foi substituído.

Por outro lado, você pode usar o seguinte:

perl -ne 'while(/dog_/g){print "$&\n";}' /path/to/chromedriver

para ver se sua sequência de substituição,, dog_agora está no chromedriverbinário. Se for, a sequência de substituição será impressa no console.

Vá para o alterado chromedrivere clique duas vezes nele. Uma terminaljanela deve abrir. Se você não vê killedna saída, alterou o driver com sucesso.

Empacotando

Depois de alterar o chromedriverbinário, verifique se o nome do chromedriverbinário alterado é chromedrivere se o binário original é movido de seu local original ou renomeado.

Minha experiência com este método

Eu estava sendo detectado anteriormente em um site enquanto tentava efetuar login, mas depois de substituir cdc_por uma sequência de tamanho igual, consegui efetuar login. Como outros já disseram, se você já foi detectado, pode ser bloqueado por um erro. muitos outros motivos, mesmo depois de usar esse método. Portanto, talvez você precise acessar o site que estava detectando você usando uma VPN, rede diferente ou o que você possui.

Basicamente, a maneira como a detecção de selênio funciona é que eles testam variáveis ​​javascript predefinidas que aparecem quando executadas com selênio. Os scripts de detecção de bots geralmente exibem qualquer coisa que contenha a palavra "selênio" / "webdriver" em qualquer uma das variáveis ​​(no objeto janela) e também documentam as variáveis ​​denominadas $cdc_e $wdc_. Obviamente, tudo isso depende do navegador em que você está. Todos os navegadores diferentes expõem coisas diferentes.

Para mim, usei o chrome, então tudo o que eu precisava fazer era garantir que $cdc_não existisse mais como variável de documento e pronto (faça o download do código-fonte do chromedriver, modifique o chromedriver e recompile $cdc_com um nome diferente).

esta é a função que modifiquei no chromedriver:

call_function.js:

function getPageCache(opt_doc) {
  var doc = opt_doc || document;
  //var key = '$cdc_asdjflasutopfhvcZLmcfl_';
  var key = 'randomblabla_';
  if (!(key in doc))
    doc[key] = new Cache();
  return doc[key];
}

(note o comentário, tudo o que fiz eu virei $cdc_para randomblabla_.

Aqui está um pseudo-código que demonstra algumas das técnicas que as redes de bot podem usar:

runBotDetection = function () {
    var documentDetectionKeys = [
        "__webdriver_evaluate",
        "__selenium_evaluate",
        "__webdriver_script_function",
        "__webdriver_script_func",
        "__webdriver_script_fn",
        "__fxdriver_evaluate",
        "__driver_unwrapped",
        "__webdriver_unwrapped",
        "__driver_evaluate",
        "__selenium_unwrapped",
        "__fxdriver_unwrapped",
    ];

    var windowDetectionKeys = [
        "_phantom",
        "__nightmare",
        "_selenium",
        "callPhantom",
        "callSelenium",
        "_Selenium_IDE_Recorder",
    ];

    for (const windowDetectionKey in windowDetectionKeys) {
        const windowDetectionKeyValue = windowDetectionKeys[windowDetectionKey];
        if (window[windowDetectionKeyValue]) {
            return true;
        }
    };
    for (const documentDetectionKey in documentDetectionKeys) {
        const documentDetectionKeyValue = documentDetectionKeys[documentDetectionKey];
        if (window['document'][documentDetectionKeyValue]) {
            return true;
        }
    };

    for (const documentKey in window['document']) {
        if (documentKey.match(/\$[a-z]dc_/) && window['document'][documentKey]['cache_']) {
            return true;
        }
    }

    if (window['external'] && window['external'].toString() && (window['external'].toString()['indexOf']('Sequentum') != -1)) return true;

    if (window['document']['documentElement']['getAttribute']('selenium')) return true;
    if (window['document']['documentElement']['getAttribute']('webdriver')) return true;
    if (window['document']['documentElement']['getAttribute']('driver')) return true;

    return false;
};

de acordo com o usuário @szx, também é possível simplesmente abrir o chromedriver.exe no editor hexadecimal e fazer a substituição manualmente, sem realmente fazer qualquer compilação.

Como já descobrimos na pergunta e nas respostas postadas, há um serviço anti-raspagem na Web e um serviço de detecção de bot chamado "Distil Networks" em jogo aqui. E, de acordo com a entrevista do CEO da empresa :

Mesmo que eles possam criar novos bots, descobrimos uma maneira de identificar o Selenium a ferramenta que eles estão usando, por isso estamos bloqueando o Selenium, não importa quantas vezes eles iterem nesse bot . Estamos fazendo isso agora com Python e muitas tecnologias diferentes. Quando vemos um padrão emergir de um tipo de bot, trabalhamos para fazer engenharia reversa da tecnologia que eles usam e identificá-lo como malicioso.

Levará tempo e desafios adicionais para entender exatamente como eles estão detectando o Selenium, mas o que podemos dizer com certeza no momento:

• não está relacionado às ações que você executa com selênio - depois de navegar para o site, você é imediatamente detectado e banido. Tentei adicionar atrasos aleatórios artificiais entre as ações, fazer uma pausa após o carregamento da página - nada ajudou
• também não trata da impressão digital do navegador - tentei em vários navegadores com perfis limpos e não no modo de navegação anônima - nada ajudou
• Como, de acordo com a dica da entrevista, isso era "engenharia reversa", suspeito que isso seja feito com algum código JS sendo executado no navegador, revelando que este é um navegador automatizado via selenium webdriver

Decidiu publicá-lo como resposta, uma vez que claramente:

Um site pode detectar quando você está usando selênio com o chromedriver?

Sim.

Além disso, o que eu não experimentei é o selênio mais antigo e as versões mais antigas do navegador - em teoria, poderia haver algo implementado / adicionado ao selênio em um determinado ponto no qual o detector de bot da Distil Networks atualmente conta. Então, se esse for o caso, poderemos detectar (sim, vamos detectar o detector) em que ponto / versão uma alteração relevante foi feita, examinar o changelog e o changesets e, por exemplo, isso pode nos dar mais informações sobre onde procurar e o que eles usam para detectar um navegador acionado por webdriver. É apenas uma teoria que precisa ser testada.

Exemplo de como é implementado no wellsfargo.com:

try {
 if (window.document.documentElement.getAttribute("webdriver")) return !+[]
} catch (IDLMrxxel) {}
try {
 if ("_Selenium_IDE_Recorder" in window) return !+""
} catch (KknKsUayS) {}
try {
 if ("__webdriver_script_fn" in document) return !+""

Ofuscando o resultado JavaScripts

Eu verifiquei o código fonte do chromedriver. Isso injeta alguns arquivos javascript no navegador.
Todo arquivo javascript neste link é injetado nas páginas da Web: https://chromium.googlesource.com/chromium/src/+/master/chrome/test/chromedriver/js/

Então, eu usei engenharia reversa e ofusquei os arquivos js pela edição Hex. Agora eu tinha certeza de que não mais variáveis ​​javascript, nomes de funções e seqüências de caracteres fixas eram usadas para descobrir a atividade de selênio. Mas ainda alguns sites e o reCaptcha detectam selênio!
Talvez eles verifiquem as modificações causadas pela execução do chromedriver js :)

Editar 1:

Modificação de parâmetros do 'navegador' do Chrome

Eu descobri que existem alguns parâmetros no 'navegador' que descobrem brevemente o uso do chromedriver. Estes são os parâmetros:

• "navigator.webdriver" No modo não automatizado, é 'indefinido'. No modo automatizado, é 'verdadeiro'.
• "navigator.plugins" No chrome sem cabeça tem 0 comprimento. Então eu adicionei alguns elementos falsos para enganar o processo de verificação do comprimento do plugin.
• " navigator.languages" foi definido como o valor padrão do chrome '["en-US", "en", "es"]'.

Então, o que eu precisava era de uma extensão do chrome para executar o javascript nas páginas da web. Fiz uma extensão com o código js fornecido no artigo e usei outro artigo para adicionar a extensão compactada ao meu projeto. Eu mudei com sucesso os valores; Mas ainda nada mudou!

Não encontrei outras variáveis ​​como essas, mas isso não significa que elas não existem. Ainda o reCaptcha detecta o chromedriver, portanto, deve haver mais variáveis ​​a serem alteradas. O próximo passo deve ser a engenharia reversa dos serviços de detecção que eu não quero fazer.

Agora não tenho certeza se vale a pena gastar mais tempo nesse processo de automação ou procurar métodos alternativos!

Tente usar o selênio com um perfil de usuário específico do chrome. Dessa forma, você pode usá-lo como usuário específico e definir o que quiser. Ao fazer isso, ele será executado como um usuário "real", veja o processo do chrome com algum explorador de processo e você verá a diferença com as tags.

Por exemplo:

username = os.getenv("USERNAME")
userProfile = "C:\\Users\\" + username + "\\AppData\\Local\\Google\\Chrome\\User Data\\Default"
options = webdriver.ChromeOptions()
options.add_argument("user-data-dir={}".format(userProfile))
# add here any tag you want.
options.add_experimental_option("excludeSwitches", ["ignore-certificate-errors", "safebrowsing-disable-download-protection", "safebrowsing-disable-auto-update", "disable-client-side-phishing-detection"])
chromedriver = "C:\Python27\chromedriver\chromedriver.exe"
os.environ["webdriver.chrome.driver"] = chromedriver
browser = webdriver.Chrome(executable_path=chromedriver, chrome_options=options)

lista de tags do chrome aqui

partial interface Navigator { readonly attribute boolean webdriver; };

O atributo IDL do driver da web da interface do Navegador deve retornar o valor do sinalizador ativo do driver da web, que inicialmente é falso.

Essa propriedade permite que os sites determinem que o agente do usuário está sob controle do WebDriver e pode ser usado para ajudar a mitigar ataques de negação de serviço.

Extraído diretamente do Draft do WebDriver do editor do W3C 2017 . Isso implica fortemente que, no mínimo, iterações futuras dos drivers do selênio serão identificáveis ​​para evitar o uso indevido. Por fim, é difícil dizer, sem o código-fonte, o que exatamente faz com que o driver chrome, em específico, seja detectável.

Diz- window.navigator.webdriver === truese que o Firefox definirá se estiver trabalhando com um driver de web. Isso estava de acordo com uma das especificações mais antigas (por exemplo: archive.org ), mas não consegui encontrá-la na nova, exceto por algumas palavras muito vagas nos apêndices.

Um teste para isso está no código de selênio no arquivo fingerprint_test.js, no qual o comentário no final diz "Atualmente implementado apenas no firefox", mas não consegui identificar nenhum código nessa direção com algumas informações simples grep, nem no atual (41.0.2), árvore de lançamento do Firefox nem na árvore de cromo.

Também encontrei um comentário para uma confirmação mais antiga sobre impressão digital no driver firefox b82512999938 de janeiro de 2015 . Esse código ainda está no Selenium GIT-master baixado ontem javascript/firefox-driver/extension/content/server.jscom um comentário vinculado ao apêndice ligeiramente diferente na especificação atual do driver da web w3c.

Além da ótima resposta de @ Erti-Chris Eelmaa - é irritante window.navigator.webdrivere é somente leitura. Evento se você alterar o valor dele para falseele ainda terá true. É por isso que o navegador acionado por software automatizado ainda pode ser detectado. MDN

A variável é gerenciada pela bandeira --enable-automationno chrome. O chromedriver inicia o chrome com esse sinalizador e o chrome define window.navigator.webdrivercomo true. Você pode encontrá-lo aqui . Você precisa adicionar para "excluir opções" a bandeira. Por exemplo (golang):

package main

import (
    "github.com/tebeka/selenium"
    "github.com/tebeka/selenium/chrome"
)

func main() {

caps := selenium.Capabilities{
    "browserName": "chrome",
}

chromeCaps := chrome.Capabilities{
    Path:            "/path/to/chrome-binary",
    ExcludeSwitches: []string{"enable-automation"},
}
caps.AddChrome(chromeCaps)

wd, err := selenium.NewRemote(caps, fmt.Sprintf("http://localhost:%d/wd/hub", 4444))
}

Parece que eles estão protegidos por um firewall de aplicativo da web. Dê uma olhada no modsecurity e veja como eles funcionam. Na realidade, o que você está perguntando é como evitar a detecção de bots. Não é para isso que serve o driver da web selênio. É para testar seu aplicativo Web e não atingir outros aplicativos Web. É possível, mas basicamente, você teria que analisar o que uma WAF procura em seu conjunto de regras e, especificamente, evitá-la com selênio, se puder. Mesmo assim, ainda pode não funcionar, porque você não sabe qual WAF eles estão usando. Você deu o primeiro passo certo, que está fingindo o agente do usuário. Se isso não funcionou, existe um WAF e você provavelmente precisará ser mais complicado.

Editar: Ponto retirado de outra resposta. Verifique se o seu agente de usuário está sendo definido corretamente primeiro. Talvez ele atinja um servidor da web local ou cheire o tráfego que sai.

Mesmo que você esteja enviando todos os dados corretos (por exemplo, o Selenium não aparece como uma extensão, você possui uma resolução / profundidade de bits razoável etc.), existem vários serviços e ferramentas que analisam o comportamento do visitante para determinar se o ator é um usuário ou um sistema automatizado.

Por exemplo, visitar um site e imediatamente executar alguma ação movendo o mouse diretamente para o botão relevante, em menos de um segundo, é algo que nenhum usuário realmente faria.

Também pode ser útil como ferramenta de depuração usar um site como https://panopticlick.eff.org/ para verificar o quão exclusivo é o seu navegador; também ajudará a verificar se existem parâmetros específicos que indicam que você está executando o Selenium.

A detecção de bot que eu vi parece mais sofisticada ou pelo menos diferente do que eu li nas respostas abaixo.

EXPERIÊNCIA 1:

1. Abro um navegador e uma página da web com o Selenium em um console Python.
2. O mouse já está em um local específico, onde eu sei que um link aparecerá assim que a página for carregada. Eu nunca movo o mouse.
3. Pressiono o botão esquerdo do mouse uma vez (isso é necessário para focar no console em que o Python está sendo executado no navegador).
4. Pressiono o botão esquerdo do mouse novamente (lembre-se, o cursor está acima de um determinado link).
5. O link abre normalmente, como deveria.

Experiência 2:

1. Como antes, abro um navegador e a página da Web com o Selenium em um console Python.

2. Desta vez, em vez de clicar com o mouse, uso o Selenium (no console do Python) para clicar no mesmo elemento com um deslocamento aleatório.

3. O link não abre, mas eu sou direcionado para uma página de inscrição.

IMPLICAÇÕES:

• abrir um navegador via Selenium não me impede de parecer humano
• mover o mouse como um humano não é necessário para ser classificado como humano
• clicar em algo via Selenium com um deslocamento ainda dispara o alarme

Parece misterioso, mas acho que eles podem apenas determinar se uma ação se origina do Selenium ou não, enquanto não se importam se o navegador em si foi aberto via Selenium ou não. Ou eles podem determinar se a janela está focada? Seria interessante saber se alguém tem alguma ideia.

Mais uma coisa que descobri é que alguns sites usam uma plataforma que verifica o User Agent. Se o valor contiver: "HeadlessChrome", o comportamento pode ser estranho ao usar o modo sem cabeça.

A solução alternativa para isso será substituir o valor do agente do usuário, por exemplo, em Java:

chromeOptions.addArguments("--user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36");

Alguns sites estão detectando isso:

function d() {
try {
    if (window.document.$cdc_asdjflasutopfhvcZLmcfl_.cache_)
        return !0
} catch (e) {}

try {
    //if (window.document.documentElement.getAttribute(decodeURIComponent("%77%65%62%64%72%69%76%65%72")))
    if (window.document.documentElement.getAttribute("webdriver"))
        return !0
} catch (e) {}

try {
    //if (decodeURIComponent("%5F%53%65%6C%65%6E%69%75%6D%5F%49%44%45%5F%52%65%63%6F%72%64%65%72") in window)
    if ("_Selenium_IDE_Recorder" in window)
        return !0
} catch (e) {}

try {
    //if (decodeURIComponent("%5F%5F%77%65%62%64%72%69%76%65%72%5F%73%63%72%69%70%74%5F%66%6E") in document)
    if ("__webdriver_script_fn" in document)
        return !0
} catch (e) {}

Escreva uma página html com o seguinte código. Você verá que no DOM selenium aplica um atributo webdriver no outerHTML

<html>
<head>
  <script type="text/javascript">
  <!--
    function showWindow(){
      javascript:(alert(document.documentElement.outerHTML));
    }
  //-->
  </script>
</head>
<body>
  <form>
    <input type="button" value="Show outerHTML" onclick="showWindow()">
  </form>
</body>
</html>

Eu encontrei alterando a variável javascript "key" assim:

//Fools the website into believing a human is navigating it
        ((JavascriptExecutor)driver).executeScript("window.key = \"blahblah\";");

funciona em alguns sites ao usar o Selenium Webdriver junto com o Google Chrome, já que muitos sites procuram essa variável para evitar serem descartados pelo Selenium.

Parece-me que a maneira mais simples de fazer isso com o Selenium é interceptar o XHR que envia de volta a impressão digital do navegador.

Mas, como esse é um problema apenas de selênio, é melhor usar outra coisa. O selênio deve facilitar coisas assim, não muito mais difíceis.

Você pode tentar usar o parâmetro "enable-automation"

var options = new ChromeOptions();

// hide selenium
options.AddExcludedArguments(new List<string>() { "enable-automation" });

var driver = new ChromeDriver(ChromeDriverService.CreateDefaultService(), options);

Mas quero avisar que essa capacidade foi corrigida no ChromeDriver 79.0.3945.16 . Então provavelmente você deve usar versões mais antigas do chrome.

Além disso, como outra opção, você pode tentar usar o InternetExplorerDriver em vez do Chrome. Quanto a mim, o IE não bloqueia nada sem hacks.

E para mais informações, tente dar uma olhada aqui:

Chave de selênio: modificando o sinalizador navigator.webdriver para impedir a detecção de selênio

Não foi possível ocultar a infobar "O Chrome está sendo controlado por software automatizado" no Chrome v76