Example #1
0
func run(ctx context.Context, rendID *[32]byte, seed []byte, identifiable bool) error {
	tr, err := torch.New(ctx, proxy.FromEnvironment())
	if err != nil {
		return err
	}
	defer tr.Stop()

	rendNode := tr.WithDirectory(func(dir *directory.Directory) interface{} {
		shortInfos := make([]*directory.ShortNodeInfo, len(dir.Routers))
		for i, r := range dir.Routers {
			shortInfos[i] = r.ShortNodeInfo
		}
		rendShort := nd.Pick(shortInfos, rendID)
		for _, r := range dir.Routers {
			if r.ShortNodeInfo == rendShort {
				return r
			}
		}
		panic("unreachable")
	}).(*directory.NodeInfo)

	// when we talk to a website over TOR, the website knows what the third hop
	// is. Therefore our converstion partner may as well.
	nodes := make([]*directory.NodeInfo, 0, 3)
	if !identifiable {
		nodes = append(nodes, tr.Pick(weighRelayWith, nil))
		nodes = append(nodes, tr.Pick(weighRelayWith, nil))
	}
	nodes = append(nodes, rendNode)

	tc1, c1, err := torch.BuildCircuit(ctx, proxy.FromEnvironment(), nodes)
	if err != nil {
		return err
	}
	defer tc1.Close()
	tc2, c2, err := torch.BuildCircuit(ctx, proxy.FromEnvironment(), nodes)
	if err != nil {
		return err
	}
	defer tc2.Close()

	ndc, err := nd.Handshake(ctx, c1, c2, seed)
	var _ fnet.FrameConn = (ndc)

	fmt.Printf("%#v\n", ndc.Bit)

	return nil
}
Example #2
0
// HTTPClient returns a net/http client that respects proxy settings from the
// environmnent. Supported environmnent variables:
// "http_proxy", "https_proxy", "all_proxy", and "no_proxy".
func HTTPClient() *http.Client {
	if os.Getenv("all_proxy") != "" {
		return &http.Client{
			Transport: &http.Transport{Dial: proxy.FromEnvironment().Dial},
		}
	}

	return http.DefaultClient
}
Example #3
0
// Connect connects to the host by using the specified port or the default one if the value is <=0.
func (ftp *FTP) Connect(host string, port int, socks5ProxyUrl string) (resp *Response, err error) {

	if len(host) == 0 {
		return nil, errors.New("The host must be specified")
	}
	ftp.Host = host

	if port <= 0 {
		port = DefaultFtpPort
	}

	addr := fmt.Sprintf("%s:%d", ftp.Host, ftp.Port)

	// use the system proxy if emtpy
	if socks5ProxyUrl == "" {
		ftp.writeInfo("using environment proxy, url: ", os.Getenv("all_proxy"))
		ftp.dialer = proxy.FromEnvironment()
	} else {
		ftp.dialer = proxy.Direct

		if u, err1 := url.Parse(socks5ProxyUrl); err1 == nil {
			p, err2 := proxy.FromURL(u, proxy.Direct)
			if err2 == nil {
				ftp.dialer = p
			}
		}

	}

	err = ftp.NewConn(addr)
	if err != nil {
		return
	}

	ftp.writeInfo("host:", ftp.Host, " port:", strconv.Itoa(ftp.Port), " proxy enabled:", ftp.dialer != proxy.Direct)

	// NOTE: this is an absolute time that needs refreshing after each READ/WRITE net operation
	//ftp.conn.conn.SetDeadline(getTimeoutInMsec(ftp.timeoutInMsec))

	if resp, err = ftp.Read(NONE_FTP_CMD); err != nil {
		return
	}
	ftp.welcome = resp.Message
	ftp.writeInfo("Successfully connected on local address:", ftp.conn.LocalAddr())
	return
}
Example #4
0
func Socks5Client(timeout time.Duration, user, password, ip string) *http.Client { // ip like that 1.1.1.1:29840
	auth := &proxy.Auth{
		User:     user,
		Password: password,
	}
	forward := proxy.FromEnvironment()
	dailer, err := proxy.SOCKS5("tcp", ip, auth, forward)
	if err != nil {
		log.Println("proxy socks5 client error: ", err)
		return nil
	}
	return &http.Client{
		Transport: &http.Transport{
			Dial:                  dailer.Dial,
			DisableKeepAlives:     false,
			ResponseHeaderTimeout: timeout,
			DisableCompression:    false,
		},
	}
}
Example #5
0
func main() {

	var smx, socks, body, file_location, file_name, from, from_name, marker, head, html, attachment, subject, to, to_name string
	var mx []*net.MX
	var conn net.Conn

	ief, _ := net.Interfaces()
	fmt.Printf("%s \r\n", ief[1].HardwareAddr)

	//ief, _ := net.InterfaceByName("eth1")

	addrs, _ := ief[1].Addrs()

	tcpAddr := &net.TCPAddr{
		IP: addrs[0].(*net.IPNet).IP,
	}
	fmt.Println(tcpAddr)

	//set necessary variables
	socks = "62.109.20.93:3678"
	from = "*****@*****.**"
	from_name = "Nissan"
	to = "*****@*****.**"
	to_name = "Foryou"
	subject = "Check out my test email"
	body = "Это тестовое письмо. На него отвечать не нужно.\r\n"
	file_location = "/home/aagafonov/PhpstormProjects/ly/public/img/cake/"
	file_name = "StickAndCarrot.jpg"

	// -------------------------------------------------------------------------------

	//s := net.Dialer{LocalAddr: addrs[0]}

	s, err := proxy.SOCKS5("tcp", socks, nil, proxy.FromEnvironment())
	if err != nil {
		fmt.Printf("Socks failed: %v\r\n", err)
	}

	domain := strings.Split(to, "@")[1]
	fmt.Printf("Domain: %s\r\n", domain)

	mx, err = net.LookupMX(domain)
	if err != nil {
		fmt.Printf("LookupMX failed: %v\r\n", err)
	} else {

		for i := range mx {
			smx := net.JoinHostPort(mx[i].Host, "25")
			fmt.Printf("Connect to %v ...\r\n", smx)

			// Set ip (from MX records) and port mail server
			conn, err = s.Dial("tcp", smx)
			if err != nil {
				fmt.Printf("Dial failed: %v\r\n", err)
			} else {
				break
			}
		}
	}

	if err != nil {
		fmt.Printf("Connect: %v\r\n", err)
	}

	host, _, _ := net.SplitHostPort(smx)
	c, err := smtp.NewClient(conn, host)
	if err != nil {
		fmt.Printf("New client failed: %v\r\n", err)
	}

	myHost, _, _ := net.SplitHostPort(socks)
	if err := c.Hello(myHost); err != nil {
		fmt.Printf("Hello: %v\r\n", err)
	}

	marker = makeMarker()

	// Set the sender and recipient first
	if err := c.Mail(from); err != nil {
		fmt.Printf("Mail: %v\r\n", err)
	}

	if err := c.Rcpt(to); err != nil {
		fmt.Printf("Rcpt: %v\r\n", err)
	}

	hd := mailHead{
		from,
		from_name,
		to,
		to_name,
		subject,
	}

	head = buildHead(hd, marker)

	//part 2 will be the body of the email (text or HTML)
	html = buildBody(body, marker)

	att := mailAttachment{
		file_location,
		file_name,
	}

	attachment = buildAttachment(att, marker)

	msg := head + html + attachment

	//dkim.New()

	w, err := c.Data()
	if err != nil {
		fmt.Println("Data: %v", err)
	}
	_, err = fmt.Fprintf(w, msg)
	if err != nil {
		fmt.Println("Fprintf: %v", err)
	}

	err = w.Close()
	if err != nil {
		fmt.Println("Close: %v", err)
	}

	// Send the QUIT command and close the connection.
	err = c.Quit()
	if err != nil {
		fmt.Println("Quit: %v", err)
	}
}
Example #6
0
func run(ctx context.Context, rendID *[32]byte, seed []byte, identifiable bool, numStreams int, udpSourceListen, udpDestinationSend string) error {
	tr, err := torch.New(ctx, proxy.FromEnvironment())
	if err != nil {
		return err
	}
	defer tr.Stop()

	rendNode := tr.WithDirectory(func(dir *directory.Directory) interface{} {
		shortInfos := make([]*directory.ShortNodeInfo, 0, len(dir.Routers))
		for _, n := range dir.Routers {
			if n.Fast && n.Running && n.Stable && n.Valid && (n.Port == 443 || n.Port == 80) {
				shortInfos = append(shortInfos, n.ShortNodeInfo)
			}
		}
		rendShort := nd.Pick(shortInfos, rendID)
		for _, r := range dir.Routers {
			if r.ShortNodeInfo == rendShort {
				return r
			}
		}
		panic("unreachable")
	}).(*directory.NodeInfo)

	// when we talk to a website over TOR, the website knows what the third hop
	// is. Therefore our converstion partner may as well.
	nodes := make([]*directory.NodeInfo, 0, 3)
	if !identifiable {
		nodes = append(nodes, tr.Pick(weigh, nil))
		nodes = append(nodes, tr.Pick(weigh, nil))
	}
	nodes = append(nodes, rendNode)

	rr := fnet.NewRoundRobin(nd.FRAMESIZE)
	defer rr.Close()

	for i := 0; i < numStreams; i++ {
		seed_i := sha256.Sum256(append(append([]byte{}, seed...), byte(i)))
		tc1, c1, err := torch.BuildCircuit(ctx, proxy.FromEnvironment(), nodes)
		if err != nil {
			return err
		}
		defer tc1.Close()
		tc2, c2, err := torch.BuildCircuit(ctx, proxy.FromEnvironment(), nodes)
		if err != nil {
			return err
		}
		defer tc2.Close()

		ndc, err := nd.Handshake(ctx, c1, c2, seed_i[:])
		if err != nil {
			return err
		}
		rr.AddConn(ndc)
	}

	udpFront, err := udp4rrtcp.Start(ctx, udpSourceListen, udpDestinationSend, rr)
	if err != nil {
		return err
	}
	defer udpFront.Stop()

	println("connected and running")
	<-ctx.Done()
	return nil
}
Example #7
0
func handleConnection(conn *ss.Conn) {
	var host string

	connCnt++ // this maybe not accurate, but should be enough
	if connCnt-nextLogConnCnt >= 0 {
		// XXX There's no xadd in the atomic package, so it's difficult to log
		// the message only once with low cost. Also note nextLogConnCnt maybe
		// added twice for current peak connection number level.
		log.Printf("Number of client connections reaches %d\n", nextLogConnCnt)
		nextLogConnCnt += logCntDelta
	}

	// function arguments are always evaluated, so surround debug statement
	// with if statement
	if debug {
		debug.Printf("new client %s->%s\n", conn.RemoteAddr().String(), conn.LocalAddr())
	}
	closed := false
	defer func() {
		if debug {
			debug.Printf("closed pipe %s<->%s\n", conn.RemoteAddr(), host)
		}
		connCnt--
		if !closed {
			conn.Close()
		}
	}()

	host, extra, err := getRequest(conn)
	if err != nil {
		log.Println("error getting request", conn.RemoteAddr(), conn.LocalAddr(), err)
		return
	}
	debug.Println("connecting", host)
	var dialer proxy.Dialer
	dialer = proxy.FromEnvironment()
	remote, err := dialer.Dial("tcp", host)
	if err != nil {
		if ne, ok := err.(*net.OpError); ok && (ne.Err == syscall.EMFILE || ne.Err == syscall.ENFILE) {
			// log too many open file error
			// EMFILE is process reaches open file limits, ENFILE is system limit
			log.Println("dial error:", err)
		} else {
			log.Println("error connecting to:", host, err)
		}
		return
	}
	defer func() {
		if !closed {
			remote.Close()
		}
	}()
	// write extra bytes read from
	if extra != nil {
		// debug.Println("getRequest read extra data, writing to remote, len", len(extra))
		if _, err = remote.Write(extra); err != nil {
			debug.Println("write request extra error:", err)
			return
		}
	}
	if debug {
		debug.Printf("piping %s<->%s", conn.RemoteAddr(), host)
	}
	go ss.PipeThenClose(conn, remote)
	ss.PipeThenClose(remote, conn)
	closed = true
	return
}
Example #8
0
func dialerFromFlags() (proxy.Dialer, error) {
	if len(*proxyAddress) > 0 {
		return proxy.SOCKS5("tcp", string(*proxyAddress), nil, &proxy.Direct)
	}
	return proxy.FromEnvironment(), nil
}
Example #9
0
func run(ctx context.Context, rendID *[32]byte, seed []byte, identifiable bool, numStreams int, rnd *mathrand.Rand) error {
	tr, err := torch.New(ctx, proxy.FromEnvironment())
	if err != nil {
		return err
	}
	defer tr.Stop()

	rendNode := tr.WithDirectory(func(dir *directory.Directory) interface{} {
		shortInfos := make([]*directory.ShortNodeInfo, 0, len(dir.Routers))
		for _, n := range dir.Routers {
			if n.Fast && n.Running && n.Stable && n.Valid && (n.Port == 443 || n.Port == 80) {
				shortInfos = append(shortInfos, n.ShortNodeInfo)
			}
		}
		rendShort := nd.Pick(shortInfos, rendID)
		for _, r := range dir.Routers {
			if r.ShortNodeInfo == rendShort {
				return r
			}
		}
		panic("unreachable")
	}).(*directory.NodeInfo)

	// when we talk to a website over TOR, the website knows what the third hop
	// is. Therefore our converstion partner may as well.
	nodes := make([]*directory.NodeInfo, 0, 3)
	if !identifiable {
		nodes = append(nodes, tr.Pick(weigh, rnd))
		nodes = append(nodes, tr.Pick(weigh, rnd))
	}
	nodes = append(nodes, rendNode)

	rr := fnet.NewRoundRobin(nd.FRAMESIZE)
	defer rr.Close()

	fmt.Println("plan:")
	for _, n := range nodes {
		fmt.Printf("%d\n", n.IP)
	}

	sending := false

	for i := 0; i < numStreams; i++ {
		seed_i := sha256.Sum256(append(append([]byte{}, seed...), byte(i)))
		tc1, c1, err := torch.BuildCircuit(ctx, proxy.FromEnvironment(), nodes)
		if err != nil {
			return err
		}
		defer tc1.Close()
		tc2, c2, err := torch.BuildCircuit(ctx, proxy.FromEnvironment(), nodes)
		if err != nil {
			return err
		}
		defer tc2.Close()

		ndc, err := nd.Handshake(ctx, c1, c2, seed_i[:])
		// Arbitrarily choose one of the sides of the TOR connection to be the sender of the test data
		// By choosing the first ndc.bit
		if i == 0 {
			sending = ndc.Bit
		}
		if err != nil {
			return err
		}
		rr.AddConn(ndc)
	}

	println("connected and running")

	if sending {
		if err = clockstation.Run(ctx, rr, time.Tick(50*time.Millisecond)); err != nil {
			return fmt.Errorf("clockstation.Run: %s\n", err.Error())
		}
	} else {
		if err = clockprinter.Run(ctx, rr); err != nil {
			fmt.Errorf("clockprinter.Run: %s\n", err.Error())
		}
	}
	return nil

	<-ctx.Done()
	return nil
}
Example #10
0
import (
	"net"
	"net/http"
	"os"
	"strings"
	"time"

	"golang.org/x/net/proxy"

	"github.com/syncthing/syncthing/lib/logger"
	"github.com/syncthing/syncthing/lib/osutil"
)

var (
	l          = logger.DefaultLogger.NewFacility("dialer", "Dialing connections")
	dialer     = proxy.FromEnvironment()
	usingProxy = dialer != proxy.Direct
)

func init() {
	l.SetDebug("dialer", strings.Contains(os.Getenv("STTRACE"), "dialer") || os.Getenv("STTRACE") == "all")
	if usingProxy {
		http.DefaultTransport = &http.Transport{
			Dial:                Dial,
			Proxy:               http.ProxyFromEnvironment,
			TLSHandshakeTimeout: 10 * time.Second,
		}

		// Defer this, so that logging gets setup.
		go func() {
			time.Sleep(500 * time.Millisecond)
Example #11
0
func (m *MailData) SendMail() error {
	var smx string
	var mx []*net.MX
	var conn net.Conn

	if m.Iface == "" {
		// default interface
		m.n = net.Dialer{}
	} else {
		if m.Iface[0:8] == "socks://" {
			m.Iface = m.Iface[8:]
			var err error
			m.s, err = proxy.SOCKS5("tcp", m.Iface, nil, proxy.FromEnvironment())
			if err != nil {
				return err
			}
		} else {
			connectAddr := net.ParseIP(m.Iface)
			tcpAddr := &net.TCPAddr{
				IP: connectAddr,
			}
			m.n = net.Dialer{LocalAddr: tcpAddr}
		}
	}

	//ToDo cache MX servers
	// punycode convert
	domain, err := idna.ToASCII(strings.Split(m.To, "@")[1])
	if err != nil {
		return errors.New(fmt.Sprintf("Domain name failed: %v\r\n", err))
	}
	m.To = strings.Split(m.To, "@")[0] + "@" + domain

	mx, err = net.LookupMX(domain)
	if err != nil {
		return errors.New(fmt.Sprintf("LookupMX failed: %v\r\n", err))
	} else {
		for i := range mx {
			smx := net.JoinHostPort(mx[i].Host, "25")
			// Set ip (from MX records) and port mail server
			if m.s != nil {
				conn, err = m.s.Dial("tcp", smx)
			} else {
				conn, err = m.n.Dial("tcp", smx)
			}
			if err == nil {
				defer conn.Close()
				break
			}
		}
	}
	if err != nil {
		return err
	}

	host, _, _ := net.SplitHostPort(smx)
	c, err := smtp.NewClient(conn, host)
	if err != nil {
		return err
	}

	if err := c.Hello(m.Host); err != nil {
		return err
	}

	// Set the sender and recipient first
	if err := c.Mail(m.From); err != nil {
		return err
	}

	if err := c.Rcpt(m.To); err != nil {
		return err
	}

	msg := m.makeMail()

	//dkim.New()

	w, err := c.Data()
	if err != nil {
		return err
	}
	_, err = fmt.Fprintf(w, msg)
	if err != nil {
		return err
	}

	err = w.Close()
	if err != nil {
		return err
	}

	// Send the QUIT command and close the connection.
	return c.Quit()
}
Example #12
0
// Send email
func (m *MailData) Send() error {

	// trim space
	m.To_email = strings.TrimSpace(m.To_email)
	// punycode convert
	splitEmail := strings.Split(m.To_email, "@")
	if len(splitEmail) != 2 {
		return errors.New(fmt.Sprintf("Bad email"))
	}
	domain, err := idna.ToASCII(splitEmail[1])
	if err != nil {
		return errors.New(fmt.Sprintf("Domain name failed: %v", err))
	}
	m.To_email = strings.Split(m.To_email, "@")[0] + "@" + domain

	if m.Iface == "" {
		// default interface
		m.netConn = net.Dialer{}
	} else {
		if m.Iface[0:8] == "socks://" {
			m.Iface = m.Iface[8:]
			var err error
			m.socksConn, err = proxy.SOCKS5("tcp", m.Iface, nil, proxy.FromEnvironment())
			if err != nil {
				return err
			}
		} else {
			connectAddr := net.ParseIP(m.Iface)
			tcpAddr := &net.TCPAddr{
				IP: connectAddr,
			}
			m.netConn = net.Dialer{LocalAddr: tcpAddr}
		}
	}
	start := time.Now()
	//record, err := net.LookupMX(c.domain)
	record, err := models.DomainGetMX(domain)
	if err != nil {
		return err
	}
	lookupTime := time.Since(start)

	start = time.Now()
	var serverMx string
	for i := range record {
		smx := net.JoinHostPort(record[i].Host, "25")
		if m.socksConn != nil {
			m.conn, err = m.socksConn.Dial("tcp", smx)
		} else {
			m.conn, err = m.netConn.Dial("tcp", smx)
		}
		if err == nil {
			serverMx = record[i].Host
			connTime := time.Since(start)
			fmt.Printf("Connect time to %s %s. Lookup time %s.\n\r", domain, connTime, lookupTime)
			break
		}
	}
	if err != nil {
		return err
	}
	defer m.conn.Close()

	// 5 minute by RFC
	m.conn.SetDeadline(time.Now().Add(5 * time.Minute))

	c, err := smtp.NewClient(m.conn, serverMx)
	if err != nil {
		return errors.New(fmt.Sprintf("%v (NewClient)", err))
	}

	if err := c.Hello(m.Host); err != nil {
		return errors.New(fmt.Sprintf("%v (Hello)", err))
	}

	// Set the sender and recipient first
	if err := c.Mail(m.From_email); err != nil {
		return errors.New(fmt.Sprintf("%v (Mail)", err))
	}

	if err := c.Rcpt(m.To_email); err != nil {
		return errors.New(fmt.Sprintf("%v (Rcpt)", err))
	}

	w, err := c.Data()
	if err != nil {
		return errors.New(fmt.Sprintf("%v (Data)", err))
	}
	_, err = fmt.Fprint(w, m.Data())
	if err != nil {
		return errors.New(fmt.Sprintf("%v (SendData)", err))
	}

	err = w.Close()
	if err != nil {
		return errors.New(fmt.Sprintf("%v (Close)", err))
	}

	return c.Quit()
}