Comment faire des requêtes urllib2 via Tor en Python?

vous essayez de vous connecter à un port de chaussettes - Tor rejette tout trafic non-chaussettes. Vous pouvez vous connecter via un intermédiaire-Privoxy-en utilisant le Port 8118.

exemple:

proxy_support = urllib2.ProxyHandler({"http" : "127.0.0.1:8118"})
opener = urllib2.build_opener(proxy_support) 
opener.addheaders = [('User-agent', 'Mozilla/5.0')]
print opener.open('http://www.google.com').read()

veuillez noter également les propriétés passées à ProxyHandler, pas de préfixe http à l'adresse ip: port

pip install PySocks

puis:

import socket
import socks
import urllib2

ipcheck_url = 'http://checkip.amazonaws.com/'

# Actual IP.
print(urllib2.urlopen(ipcheck_url).read())

# Tor IP.
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, '127.0.0.1', 9050)
socket.socket = socks.socksocket
print(urllib2.urlopen(ipcheck_url).read())

en utilisant juste urllib2.ProxyHandler comme dans https://stackoverflow.com/a/2015649/895245 échoue avec:

Tor is not an HTTP Proxy

mentionné à: Comment puis-je utiliser un proxy SOCKS 4/5 avec urllib2?

testé sur Ubuntu 15.10, Tor 0.2.6.10, Python 2.7.10.

utiliser privoxy comme mandataire http devant tor fonctionne pour moi - voici un crawler-template:

import urllib2
import httplib

from BeautifulSoup import BeautifulSoup
from time import sleep

class Scraper(object):
    def __init__(self, options, args):
        if options.proxy is None:
            options.proxy = "http://localhost:8118/"
        self._open = self._get_opener(options.proxy)

    def _get_opener(self, proxy):
        proxy_handler = urllib2.ProxyHandler({'http': proxy})
        opener = urllib2.build_opener(proxy_handler)
        return opener.open

    def get_soup(self, url):
        soup = None
        while soup is None:
            try:
                request = urllib2.Request(url)
                request.add_header('User-Agent', 'foo bar useragent')
                soup = BeautifulSoup(self._open(request))
            except (httplib.IncompleteRead, httplib.BadStatusLine,
                    urllib2.HTTPError, ValueError, urllib2.URLError), err:
                sleep(1)
        return soup

class PageType(Scraper):
    _URL_TEMPL = "http://foobar.com/baz/%s"

    def items_from_page(self, url):
        nextpage = None
        soup = self.get_soup(url)

        items = []
        for item in soup.findAll("foo"):
            items.append(item["bar"])
            nexpage = item["href"]

        return nextpage, items

    def get_items(self):
        nextpage, items = self._categories_from_page(self._START_URL % "start.html")
        while nextpage is not None:
            nextpage, newitems = self.items_from_page(self._URL_TEMPL % nextpage)
            items.extend(newitems)
        return items()

pt = PageType()
print pt.get_items()

voici un code pour télécharger des fichiers en utilisant TOR proxy en python: (mettre à jour l'url)

import urllib2

url = "http://www.disneypicture.net/data/media/17/Donald_Duck2.gif"

proxy = urllib2.ProxyHandler({'http': '127.0.0.1:8118'})
opener = urllib2.build_opener(proxy)
urllib2.install_opener(opener)

file_name = url.split('/')[-1]
u = urllib2.urlopen(url)
f = open(file_name, 'wb')
meta = u.info()
file_size = int(meta.getheaders("Content-Length")[0])
print "Downloading: %s Bytes: %s" % (file_name, file_size)

file_size_dl = 0
block_sz = 8192
while True:
    buffer = u.read(block_sz)
    if not buffer:
        break

    file_size_dl += len(buffer)
    f.write(buffer)
    status = r"%10d  [%3.2f%%]" % (file_size_dl, file_size_dl * 100. / file_size)
    status = status + chr(8)*(len(status)+1)
    print status,

f.close()

le code suivant fonctionne à 100% Sur Python 3.4

(vous devez garder le navigateur ouvert wil en utilisant ce code)

ce script se connecte à TOR via socks5 checkip.dyn.com, change identity and resend the request to get a The new IP (loops 10 times)

vous devez installer les bibliothèques appropriées pour que cela fonctionne. (De profiter et de ne pas abuser)

import socks
import socket
import time
from stem.control import Controller
from stem import Signal
import requests
from bs4 import BeautifulSoup
err = 0
counter = 0
url = "checkip.dyn.com"
with Controller.from_port(port = 9151) as controller:
    try:
        controller.authenticate()
        socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9150)
        socket.socket = socks.socksocket
        while counter < 10:
            r = requests.get("http://checkip.dyn.com")
            soup = BeautifulSoup(r.content)
            print(soup.find("body").text)
            counter = counter + 1
            #wait till next identity will be available
            controller.signal(Signal.NEWNYM)
            time.sleep(controller.get_newnym_wait())
    except requests.HTTPError:
        print("Could not reach URL")
        err = err + 1
print("Used " + str(counter) + " IPs and got " + str(err) + " errors")

la solution suivante fonctionne pour moi dans Python 3 . Adapté de réponse de CiroSantilli :

avec urllib (nom d'urllib2 en Python 3):

import socks
import socket
from urllib.request import urlopen

url = 'http://icanhazip.com/'

socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, '127.0.0.1', 9150)
socket.socket = socks.socksocket

response = urlopen(url)
print(response.read())

avec requests :

import socks
import socket
import requests

url = 'http://icanhazip.com/'

socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, '127.0.0.1', 9150)
socket.socket = socks.socksocket

response = requests.get(url)
print(response.text)

Avec Selenium + PhantomJS:

from selenium import webdriver

url = 'http://icanhazip.com/'

service_args = [ '--proxy=localhost:9150', '--proxy-type=socks5', ]
phantomjs_path = '/your/path/to/phantomjs'

driver = webdriver.PhantomJS(
    executable_path=phantomjs_path, 
    service_args=service_args)

driver.get(url)
print(driver.page_source)
driver.close()

Note : si vous prévoyez d'utiliser Tor souvent, envisager de faire un don à l'appui de leur travail impressionnant!

mise à Jour - La dernière (à la hausse de v2.10.0) requests bibliothèque prend en charge chaussettes proxies avec une exigence supplémentaire de requests[socks] .

Installation -

pip install requests requests[socks]

usage de base -

import requests
session = requests.session()
# Tor uses the 9050 port as the default socks port
session.proxies = {'http':  'socks5://127.0.0.1:9050',
                   'https': 'socks5://127.0.0.1:9050'}

# Make a request through the Tor connection
# IP visible through Tor
print session.get("http://httpbin.org/ip").text
# Above should print an IP different than your public IP

# Following prints your normal public IP
print requests.get("http://httpbin.org/ip").text

ancienne réponse - Même s'il s'agit d'un vieux post, répondant parce que personne ne semble avoir mentionné la bibliothèque requesocks .

il s'agit essentiellement d'un port de la bibliothèque requests . Veuillez noter que la Bibliothèque est une ancienne fourchette (dernière mise à jour 2013-03-25) et peut ne pas avoir les mêmes fonctionnalités que la bibliothèque des dernières requêtes.

Installation -

pip install requesocks

usage de base -

# Assuming that Tor is up & running
import requesocks
session = requesocks.session()
# Tor uses the 9050 port as the default socks port
session.proxies = {'http':  'socks5://127.0.0.1:9050',
                   'https': 'socks5://127.0.0.1:9050'}
# Make a request through the Tor connection
# IP visible through Tor
print session.get("http://httpbin.org/ip").text
# Above should print an IP different than your public IP
# Following prints your normal public IP
import requests
print requests.get("http://httpbin.org/ip").text

peut-être avez-vous des problèmes de connectivité réseau? Le script ci-dessus a fonctionné pour moi (j'ai substitué une URL différente - j'ai utilisé http://stackoverflow.com/ - et j'obtiens la page comme prévu:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd" >
 <html> <head>

<title>Stack Overflow</title>        
<link rel="stylesheet" href="/content/all.css?v=3856">

(etc.)

Tor est un proxy de chaussettes. Se connecter directement avec l'exemple que vous citez ne fonctionne pas avec"urlopen error Tunnel connection failed: 501 Tor n'est pas un Proxy HTTP". Comme d'autres l'ont mentionné, vous pouvez contourner ce problème avec Privoxy.

vous pouvez également utiliser pycurl ou SocksiPy. Pour des exemples d'utilisation avec tor voir...

https://stem.torproject.org/tutorials/to_russia_with_love.html

vous pouvez utiliser torréfaction

exécutez votre programme avec

~$torify python your_program.py

pensait que je partagerais juste une solution qui a fonctionné pour moi (python3, windows10):

Etape 1: Activez votre port de contrôle Tor à 9151 .

Tor service fonctionne au port par défaut 9150 et ControlPort sur 9151 . Vous devriez être en mesure de voir l'adresse locale 127.0.0.1:9150 et 127.0.0.1:9151 lorsque vous lancez netstat -an .

[go to windows terminal]
cd ...\Tor Browser\Browser\TorBrowser\Tor
tor --service remove
tor --service install -options ControlPort 9151
netstat -an 

Étape 2: script Python comme suit.

# library to launch and kill Tor process
import os
import subprocess

# library for Tor connection
import socket
import socks
import http.client
import time
import requests
from stem import Signal
from stem.control import Controller

# library for scraping
import csv
import urllib
from bs4 import BeautifulSoup
import time

def launchTor():
    # start Tor (wait 30 sec for Tor to load)
    sproc = subprocess.Popen(r'.../Tor Browser/Browser/firefox.exe')
    time.sleep(30)
    return sproc

def killTor(sproc):
    sproc.kill()

def connectTor():
    socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9150, True)
    socket.socket = socks.socksocket
    print("Connected to Tor")

def set_new_ip():
    # disable socks server and enabling again
    socks.setdefaultproxy()
    """Change IP using TOR"""
    with Controller.from_port(port=9151) as controller:
        controller.authenticate()
        socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9150, True)
        socket.socket = socks.socksocket
        controller.signal(Signal.NEWNYM)

def checkIP():
    conn = http.client.HTTPConnection("icanhazip.com")
    conn.request("GET", "/")
    time.sleep(3)
    response = conn.getresponse()
    print('current ip address :', response.read())

# Launch Tor and connect to Tor network
sproc = launchTor()
connectTor()

# list of url to scrape
url_list = [list of all the urls you want to scrape]

for url in url_list:
    # set new ip and check ip before scraping for each new url
    set_new_ip()
    # allow some time for IP address to refresh
    time.sleep(5)
    checkIP()

    '''
    [insert your scraping code here: bs4, urllib, your usual thingy]
    '''

# remember to kill process 
killTor(sproc)

ce script ci-dessus va renouveler l'adresse IP pour chaque URL que vous voulez gratter. Assurez-vous de le dormir assez longtemps pour que IP change. Dernière testé hier. Espérons que cette aide!

pour développer le commentaire ci-dessus sur l'utilisation de torify et du navigateur Tor (et n'a pas besoin de Privoxy):

pip install PySocks
pip install pyTorify

(installer Tor browser et le démarrer)

utilisation en ligne de commande:

python -mtorify -p 127.0.0.1:9150 your_script.py

ou intégré dans un script:

import torify
torify.set_tor_proxy("127.0.0.1", 9150)
torify.disable_tor_check()
torify.use_tor_proxy()

# use urllib as normal
import urllib.request
req = urllib.request.Request("http://....")
req.add_header("Referer", "http://...") # etc
res = urllib.request.urlopen(req)
html = res.read().decode("utf-8")

Note, le navigateur Tor utilise le port 9150, pas 9050