2017-07-11 33 views
7

मैं एक प्रॉक्सी जांचने की कोशिश कर रहा हूं जो एसएसएल हैंडशेक की अपेक्षा कर रहा है, भले ही क्लाइंट एसएसएल कनेक्ट विधि का उपयोग करने जा रहा हो। समस्या यह है कि मेरे गोलांग और पायथन परीक्षण कोड दोनों में एक ही दोष लगता है। वे स्पष्ट रूप से प्रॉक्सी से कनेक्ट होते हैं, और उसके बाद एक कनेक्शन जारी करते हैं, लेकिन प्रॉक्सी इसे अस्वीकार करता है क्योंकि यह एक एसएसएल हैंडशेक की उम्मीद कर रहा है।एचटीटीपीएस पूरी तरह एन्क्रिप्टेड प्रॉक्सी के माध्यम से, एसएसएल कनेक्ट

क्या कोई जानता है कि उपलब्ध मानक पुस्तकालयों का उपयोग करके प्रॉक्सी में एसएसएल का उपयोग करने के लिए तकनीक को कैसे मजबूर किया जाए?

धन्यवाद।

नमूना कोड इस प्रकार है:

#!/usr/bin/python 

try: 
    import urllib2 

    proxy = urllib2.ProxyHandler({'https': "myproxyip:6881"}) 
    opener = urllib2.build_opener(proxy) 
    urllib2.install_opener(opener) 
    print urllib2.urlopen('https://www.google.ca').read() 

except Exception as err: 
    print err 


try: 
    import httplib 

    c = httplib.HTTPSConnection('myproxyip', 6881) 
    c.set_tunnel('google.ca', 443) 
    c.request('GET', '/') 
    res = c.getresponse() 
    print res.status, res.reason 

except Exception as err: 
    print err 

और golang

// vim: ft=go ts=4 sw=4 et ai: 
package main 

import (
    "net/http" 
    "log" 
    "io/ioutil" 
    "time" 
    "crypto/tls" 
    "net/url" 
    ) 

var use_proxy = true 
var proxy = "https://myproxyip:6881" 
var req_url = "https://google.ca" 
var n_seconds time.Duration = 15 
var period = time.Second * n_seconds 
var n_threads = 50 
var thread_start_delay time.Duration = 1 

func http_fetch(req_url string) { 
    tr := http.Transport { 
     TLSClientConfig: &tls.Config { 
      InsecureSkipVerify: true, 
     }, 
    } 
    proxy_url, err := url.Parse(proxy) 
    if err != nil { 
     log.Fatal(err) 
    } 
    if use_proxy { 
     tr.Proxy = http.ProxyURL(proxy_url) 
    } 
    client := &http.Client{} 
    client.Transport = &tr 

    req, err := http.NewRequest("GET", req_url, nil) 
    if err != nil { 
     log.Fatal(err) 
    } 
    req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36") 

    res, err := client.Do(req) 
    if err != nil { 
     log.Fatal(err) 
    } 
    body, err := ioutil.ReadAll(res.Body) 
    defer res.Body.Close() 
    document := string(body) 
    print(document) 
} 


func main() { 
    println("main: Starting", n_threads, "threads to hammer", req_url, "every", n_seconds, "seconds, ctrl-c to quit...") 
    done := make(<-chan bool) 
    for i:= 0; i < n_threads; i++ { 
     go func(thread_id int) { 
      println("thread", thread_id, ": starting periodic_hammer") 
      for { 
       println("thread", thread_id, ": fetching", req_url) 
       http_fetch(req_url) 
       println("thread", thread_id, ": done, sleeping for", n_seconds, "seconds") 
       time.Sleep(period) 
      } 
     }(i+1) 
     println("main: delaying", thread_start_delay, "seconds before starting next thread") 
     time.Sleep(thread_start_delay * time.Second) 
    } 
    <-done 
} 
+0

ऐसा लगता है कि जाओ संस्करण हमेशा जारी करेगा ([स्रोत देखें] HTTPS के लिए "संपर्क में रहें" (https://golang.org/src/net/http/transport.go?s=10819:10884#L1030)) - मुझे HTTPS के बारे में बहुत कुछ पता नहीं है, लेकिन यदि यह मानक-अनुपालन व्यवहार नहीं है तो आपकी शक्ति [एक बग रिपोर्ट सबमिट करें] (https://github.com/golang/go/issues)। – Adrian

+0

मुझे लगता है कि यह मानकों के अनुरूप था लेकिन हम एचटीटीपीएस के लिए प्रॉक्सी पर शुद्ध एसएसएल के संक्रमण के बीच में हैं। ब्राउजर का समर्थन है, लेकिन मुझे कुछ भी नहीं मिल रहा है, लेकिन यह बहुत ही नवीनतम libcurl है जो इसका समर्थन करता है। –

+0

यदि यह मानक-अनुरूप नहीं है तो दुर्भाग्य से समर्थन सबसे अच्छा होगा। – Adrian

उत्तर

0

ProxyHandler के अलावा अजगर मानक लाइब्रेरी का उपयोग कर इस मुद्दे पर एक संभावित संकल्प तुम हो:

import ssl, urllib2 

# Set ciphers and ssl settings 
ctx = ssl.create_default_context() 
ctx.check_hostname = False 
ctx.verify_mode = ssl.CERT_NONE 
ctx.set_ciphers('HIGH:!DH:!aNULL') 

# Set proxy settings 
proxy = urllib2.ProxyHandler({'https':'<https proxy host>:443', 'http':'<http proxy host>:8080'}) 
opener = urllib2.build_opener(urllib2.HTTPSHandler(context=ctx), proxy) 
urllib2.install_opener(opener) 
+0

एक ही समस्या को प्रदर्शित करने के लिए लगता है। –

+0

इस पंक्ति के लिए: proxy = urllib2.ProxyHandler ({'https': ': 443', 'http': ': 8080'}) क्या आपने को प्रतिस्थापित किया था> अपने प्रॉक्सी कार्यान्वयन के साथ? –

+0

हां। मैं एक पैकेट ट्रेस के साथ दोबारा जांच करूंगा लेकिन मुझे लगता है कि यह अभी भी स्पष्ट रूप से जुड़ रहा है। –

0

में अंत में मुझे अपने क्लाइंट को अनिवार्य रूप से करना पड़ा।

func http_fetch(req_host string) { 
    buf := make([]byte, 1024) 
    conf := &tls.Config { 
     InsecureSkipVerify: true, 
    } 

    conn, err := tls.Dial("tcp", proxy_host, conf) 
    if err != nil { 
     //panic(err) 
     failure() 
     return 
    } 
    defer conn.Close() 

    // SSL CONNECT 
    if _, err = conn.Write([]byte("CONNECT " + req_host + " HTTP/1.0\r\n\r\n")); err != nil { 
     // FIXME: need debug logger? 
     //panic(err) 
     failure() 
     return 
    } 

    // Read response 
    if _, err = conn.Read(buf); err != nil { 
     //panic(err) 
     failure() 
     return 
    } 

    // Send http GET 
    if _, err = conn.Write([]byte("GET/HTTP/1.0\r\n")); err != nil { 
     //panic(err) 
     failure() 
     return 
    } 
    if _, err = conn.Write([]byte("User-Agent: golang\r\n\r\n")); err != nil { 
     //panic(err) 
     failure() 
     return 
    } 

    // Read response 
    if _, err = conn.Read(buf); err != nil { 
     //panic(err) 
     failure() 
     return 
    } 
    success() 
} 
संबंधित मुद्दे