精华内容
下载资源
问答
  • 它侦听TCPUDP传输,并透明地代理DNS流量到可配置的启用TLS的上游服务器。 dotproxy旨在位于专用网络的边缘,对通过受信任的通道往返于外部公共DNS服务器(如或流量进行加密。 作为纯文本到TLS的代理,dotproxy...
  • 通过HTTPS进行Firejail DNS代理服务器 HTTPS上的DNS(DoH)是下一代通信协议,成为主要的Internet标准( )。 通过向良好的旧DNS协议添加强大的加密身份验证,DoH试图消除DNS从一开始就存在的一些最大问题:审查,...
  • 支持通配符的DNS代理

    2011-05-05 22:23:05
    hosts文件可以手动配置一些域名的IP地址,它的优先级最高,有些网站的IP地址能被正确的解析...解决办法就是在本地建个DNS代理服务器,它负责解析hosts文件中的通配符域名,有一些开源的dns服务器,比如binddnsma...
    hosts文件可以手动配置一些域名的IP地址,它的优先级最高,有些网站的IP地址不能被正确的解析,这么情形在我国比较常见,可以直接在hosts文件直接指定网站的IP地址来解决。hosts文件的一个缺点是不支持通配符,要为所有的blogspot网站指定IP地址几乎不可能。解决办法就是在本地建个DNS代理服务器,它负责解析hosts文件中的通配符域名,有一些开源的dns服务器,比如bind和dnsmasq,bind主要是充当DNS服务器,我不清楚它是否支持代理功能,另外它太重了。dnsmasq支持代理,也很简单,但是却不支持[url=http://www.alibuybuy.com/posts/14352.html]IPv6[/url]。我就python写了一个,支持IPv6,带缓存,源代码在[url=http://code.google.com/p/marlon-tools/source/browse/tools/dnsproxy/dnsproxy.py]这里[/url],并不长,不到200行。

    用法:修改/etc/hosts,添加:

    127.0.0.1 *.local
    2404:6800:8005::62 *.blogspot.com


    然后使用:

    sudo python dnsproxy.py -s 8.8.8.8


    上面使用8.8.8.8(即google的DNS服务器)作为实际代理服务器。然后将本机的DNS服务器设置成127.0.0.1就可以了。

    可以用dig来测试,例如:

    $ dig test.local

    $ dig test.blogspot.com


    p.s. 作为副产品,我还写了一个DNS包的解析器,源代码在[url=http://code.google.com/p/marlon-tools/source/browse/tools/dnsproxy/dnsparser.py]这里[/url],有兴趣的同学可以看一下。
    展开全文
  • DNS是域名系统的缩写。...本文讲述如何动手制作一个DNS代理。 你可能要问我:满世界都是DNS服务器,为什么要写一个DNS代理? 答案很简单: 1、某些网络为了节约成本没有架设DNS服务器,需要一个...

        DNS域名系统的缩写。DNS支持使用TCPUDP协议,使用53号端口。可能是国产教科书的缘故,许多人都不知道DNS还可以在TCP协议上传输。当然,国内的绝大多数DNS服务器都不支持TCP协议。本文讲述如何动手制作一个DNS代理。

        你可能要问我:满世界都是DNS服务器,为什么要写一个DNS代理?

        答案很简单:

        1、某些网络为了节约成本没有架设DNS服务器,需要一个轻量级的解决方案;

        2、升级的DNS代理可以实现一些企业需要的管理功能;

        3、我们国家防火墙看不懂TCP封装的DNS数据;

        4、学习网络协议。

        如果你需要一个增强版的DNS代理,比如可以修改DNS请求和回答,可以参考使用此开源类库:ARSoft.Tools.Net

        至于这个DNS代理能给你带来什么,还要由你自己决定。

     

        本文目标:制作一个稳定的、支持TCP和UDP协议的、可强制使用TCP协议请求的、支持IPv6的DNS代理。

     

        既然提到了要支持TCP协议,就简单提一下TCP协议封装和UDP协议封装的差异:UDP是直接传送消息;TCP封装的消息在消息前增加了所跟随消息的长度数据,其占用两个字节,使用大端序作为其字节序

     

        那么我们需要做的事情是:

        1、同时监听TCP和UDP的53号端口;

        2、接收到数据就原封不动的转发给外部的DNS服务器;

        3、把DNS服务器返回的数据原封不动的返回给请求者;

        4、继续监听。

     

        实现代码:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Net;
    using System.Net.Sockets;
    
    namespace SimpleDnsProxy
    {
        public class DnsProxy : IDisposable
        {
            private const int DNS_PORT = 53;
            private const int BUFFER_SIZE = 4096;
            private const int RETRY_TIMES = 3;
    
            private readonly IPAddress[] _dnsServers;
            private readonly AddressFamily _addressFamily;
            private readonly int _listenerCount;
            private readonly bool _forceTcp;
            private readonly object _aysncRoot = new object();
    
            private Socket _udpSocket = null;
            private Socket _tcpSocket = null;
            private Socket _udpQuerySocket = null;
            private Socket _tcpQuerySocket = null;
            private int _serverIndex = 0;
    
            static DnsProxy()
            {
                DefaultV4 = new DnsProxy(new[] {
                        IPAddress.Parse("8.8.4.4"),         //google
                        IPAddress.Parse("208.67.220.220"),  //opendns
                        IPAddress.Parse("8.8.8.8"),         //google
                        IPAddress.Parse("208.67.222.222"),  //opendns
                    }, AddressFamily.InterNetwork, 10, true);
                DefaultV6 = new DnsProxy(new[] {
                        IPAddress.Parse("2001:4860:4860::8844"),//google
                        IPAddress.Parse("2620:0:ccd::2"),       //opendns
                        IPAddress.Parse("2001:4860:4860::8888"),//google
                        IPAddress.Parse("2620:0:ccc::2"),       //opendns
                    }, AddressFamily.InterNetworkV6, 10, true);
            }
            public static DnsProxy DefaultV4 { get; private set; }
            public static DnsProxy DefaultV6 { get; private set; }
    
            public DnsProxy(IPAddress[] dnsServers, AddressFamily addressFamily, int listenerCount, bool forceTcp = false)
            {
                if (dnsServers == null)
                    throw new ArgumentNullException("dnsServers");
                if (dnsServers.Length == 0)
                    throw new ArgumentException("at least need one server address");
                if (dnsServers.Any(s => s.AddressFamily != addressFamily))
                    throw new ArgumentException("some dns servers address not belong to specified address family");
    
                _dnsServers = dnsServers;
                _addressFamily = addressFamily;
                _listenerCount = listenerCount;
                _forceTcp = forceTcp;
    
                if (!Socket.OSSupportsIPv4 && addressFamily == AddressFamily.InterNetwork)
                    throw new NotSupportedException("OS not supports IPv4 address family");
                if (!Socket.OSSupportsIPv6 && addressFamily == AddressFamily.InterNetworkV6)
                    throw new NotSupportedException("OS not supports IPv6 address family");
    
                _udpSocket = new Socket(addressFamily, SocketType.Dgram, ProtocolType.Udp);
                _tcpSocket = new Socket(addressFamily, SocketType.Stream, ProtocolType.Tcp);
                _udpQuerySocket = new Socket(addressFamily, SocketType.Dgram, ProtocolType.Udp);
                _tcpQuerySocket = new Socket(addressFamily, SocketType.Stream, ProtocolType.Tcp);
            }
    
            public void Start()
            {
                EndPoint ep = new IPEndPoint(_addressFamily == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any, DNS_PORT);
                _udpSocket.Bind(ep);
                for (int i = 0; i < _listenerCount; i++)
                {
                    AsyncState state = new AsyncState
                    {
                        Buffer = new byte[BUFFER_SIZE],
                        EndPoint = new IPEndPoint(_addressFamily == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any, DNS_PORT),
                    };
                    StartUdpListen(state);
                }
                _tcpSocket.Bind(ep);
                _tcpSocket.Listen(_listenerCount);
                for (int i = 0; i < _listenerCount; i++)
                {
                    StartTcpListen();
                }
            }
    
            private void TcpAccept_Completed(object sender, SocketAsyncEventArgs e)
            {
                try
                {
                    byte[] buf = new byte[BUFFER_SIZE];
                    int size = e.AcceptSocket.Receive(buf);
    
                    buf = TcpQuery(buf.Take(size).ToArray());
    
                    e.AcceptSocket.Send(buf);
                    e.AcceptSocket.Disconnect(false);
                    e.AcceptSocket.Dispose();
                }
                catch { }
                StartTcpListen();
            }
    
            private void UdpAsyncCallback(IAsyncResult ar)
            {
                var state = ar.AsyncState as AsyncState;
                try
                {
                    int size = _udpSocket.EndReceiveFrom(ar, ref state.EndPoint);
                    byte[] buf = state.Buffer;
    
                    IEnumerable<byte> data = BitConverter.GetBytes((short)size);
                    if (BitConverter.IsLittleEndian)
                        data = data.Reverse();
    
                    buf = _forceTcp
                        ? TcpQuery(data.Concat(buf.Take(size)).ToArray()).Skip(2).ToArray()
                        : UdpQuery(buf.Take(size).ToArray());
    
                    _udpSocket.SendTo(buf, state.EndPoint);
                    state.EndPoint = new IPEndPoint(_addressFamily == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any, DNS_PORT);
                }
                catch { }
                StartUdpListen(state);
            }
    
            private byte[] UdpQuery(byte[] message)
            {
                EndPoint ep = CreateServerEndPoint();
                byte[] buf = new byte[BUFFER_SIZE];
                int size = -1;
                int retry = 0;
                try
                {
                    lock (_aysncRoot)
                        do
                        {
                            _udpQuerySocket.SendTo(message, ep);
                            size = _udpQuerySocket.ReceiveFrom(buf, ref ep);
                        } while (size == 0 && retry++ < RETRY_TIMES);
                }
                catch
                {
                    _serverIndex = (_serverIndex + 1) % _dnsServers.Length;
                }
                return buf.Take(size).ToArray();
            }
    
            private byte[] TcpQuery(byte[] message)
            {
                EndPoint ep = CreateServerEndPoint();
                byte[] buf = new byte[BUFFER_SIZE];
                int size = -1;
                int retry = 0;
                try
                {
                    lock (_aysncRoot)
                        do
                        {
                            if (size == 0 || !_tcpQuerySocket.Connected && _tcpQuerySocket.IsBound)
                            {
                                _tcpQuerySocket.Dispose();
                                _tcpQuerySocket = new Socket(_addressFamily, SocketType.Stream, ProtocolType.Tcp);
                            }
                            if (!_tcpQuerySocket.Connected)
                                _tcpQuerySocket.Connect(ep);
                            _tcpQuerySocket.Send(message);
                            size = _tcpQuerySocket.Receive(buf);
                        } while (size == 0 && retry++ < RETRY_TIMES);
                }
                catch
                {
                    _serverIndex = (_serverIndex + 1) % _dnsServers.Length;
                }
                return buf.Take(size).ToArray();
            }
    
            private EndPoint CreateServerEndPoint()
            {
                return new IPEndPoint(_dnsServers[_serverIndex], DNS_PORT);
            }
    
            private SocketAsyncEventArgs CreateSocketAsyncEventArgs()
            {
                var args = new SocketAsyncEventArgs();
                args.Completed += new EventHandler<SocketAsyncEventArgs>(TcpAccept_Completed);
                return args;
            }
    
            private void StartUdpListen(AsyncState state)
            {
                try
                {
                    _udpSocket.BeginReceiveFrom(state.Buffer, 0, state.Buffer.Length, SocketFlags.None, ref state.EndPoint, UdpAsyncCallback, state);
                }
                catch (ObjectDisposedException)
                {
                    return;
                }
                catch
                {
                    StartUdpListen(state);
                }
            }
    
            private void StartTcpListen()
            {
                try
                {
                    _tcpSocket.AcceptAsync(CreateSocketAsyncEventArgs());
                }
                catch (ObjectDisposedException)
                {
                    return;
                }
                catch
                {
                    StartTcpListen();
                }
            }
    
            public void Stop()
            {
                _udpSocket.Shutdown(SocketShutdown.Both);
                _tcpSocket.Shutdown(SocketShutdown.Both);
            }
    
            #region IDisposable.Dispose
            void IDisposable.Dispose()
            {
                _udpSocket.Dispose();
                _tcpSocket.Dispose();
                _udpQuerySocket.Dispose();
                _tcpQuerySocket.Dispose();
            }
            #endregion
    
            private class AsyncState
            {
                public byte[] Buffer;
                public EndPoint EndPoint;
            }
        }
    }
    

        调用代码:

    using System.Threading;
    
    namespace SimpleDnsProxy
    {
        class Program
        {
            static void Main(string[] args)
            {
                DnsProxy.DefaultV4.Start();
                DnsProxy.DefaultV6.Start();
                new ManualResetEvent(false).WaitOne();
            }
        }
    }
    

        经过了许多测试,目前此版本比较稳定。

        如果能得到类似如下的结果,说明本机的DNS代理服务执行正确。

    image

    转载于:https://www.cnblogs.com/Aimeast/archive/2011/12/22/2298672.html

    展开全文
  • BlackHolePy是一个迷你型的DNS代理)服务器。 它的主要特色:支持TCP DNS并支持白名单,从而在防止DNS污染的同时支持了内部私有域名解析。 如果你的企业或组织在内部架设了自己的DNS Server,那么可以配置 config....
  • 为什么80%的码农都做了架构师?>>> ...

    BlackHolePy
    ===========


    BlackHolePy是一个迷你型的DNS(代理)服务器。
    它的主要特色:

    1) 支持TCP DNS并支持白名单,从而在防止DNS污染的同时支持了内部私有域名解析。
    如果你的企业或组织在内部架设了自己的DNS Server,那么可以配置 config.py 里面的 WHITE_DNSS 。
    2) 内置了Cache, 带给你飞一般的感觉。尤其是访问国外网站的时候。





    运行需求
    ===========
    Python 2.7 或者 PyPy 2.0.2
    如果能安装 GEvent 和 dnspython 那就最好了。不装也能跑。
    安装GEvent以后,BlackHolePy运行在单线程模式,快捷并节约系统资源。
    在 PyPy 2.0.2 下测试通过。但是PyPy的coroutine暂时还没有支持。


    运行
    ===========
    sudo python dnsproxy.py


    然后把你的DNS服务器配置到 127.0.0.1 即可。


    感谢
    ===========
    本项目是基于以下两个项目的思路,重新编写的。
    https://github.com/henices/Tcp-DNS-proxy
    https://github.com/code4craft/blackhole
    在此感谢这两个项目的作者!


    转载于:https://my.oschina.net/linker/blog/137215

    展开全文
  • 在我们日常工作中,由于办公网络的限制,连接外网访问时需要指定...于是根据java.net.URL的api整理了设置代理服务器自定义Host头绕过DNS解析的方法: 代码如下: public static void main(String[] args) thr

    在我们日常工作中,由于办公网络的限制,连接外网访问时需要指定代理,

    而访问某些虚拟主机域名的服务器时,并不存在对应的dns解析记录,因此需要手工配置hosts文件来进行映射,非常麻烦。

    于是根据java.net.URL的api整理了设置代理服务器和自定义Host头绕过DNS解析的方法:

    代码如下:


    public static void main(String[] args) throws IOException {
    /**
    * 下面这种方法是全局方式的设置 ,不建议使用。
    * System.setProperty("proxySet", "true");
    * System.setProperty("proxyHost", "proxy.proxyHost.com");
    * System.setProperty("proxyPort", "8010");
    */
    String urlStr = "http://www.aerchi.com";
    urlStr = "http://blog.csdn.net/aerchi";
    HttpURLConnection httpConn = null;
    StringBuilder sb = new StringBuilder();
    URL url = new URL(urlStr);
    String hostName = url.getHost();
    // 根据配置自定义url里的ip地址
    if (hostName.toLowerCase().endsWith(".mqq.im")) {
    url = new URL(urlStr.replace(hostName, "127.0.0.1"));
    }
    System.out.println(url);
    Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy.proxyHost.com", 8010));
    // 只针对当前这个连接使用http代理
    httpConn = (HttpURLConnection) url.openConnection(proxy);
    httpConn.setRequestMethod("GET");
    // 手工设置Host头信息以支持虚拟主机,通过这样的方式,可以避免去手工配置/etc/hosts来绕过dns解析的麻烦,尤其是程序经常在不同服务器上运行的时候,非常实用
    httpConn.setRequestProperty("Host", hostName);
    httpConn.setConnectTimeout(5000);
    httpConn.connect();
    InputStream is = httpConn.getInputStream();
    BufferedReader br = new BufferedReader(new InputStreamReader(is,
    "UTF-8"));
    String line = null;
    while ((line = br.readLine()) != null) {
    sb.append(line).append('\n');
    }
    // 关闭连接
    httpConn.disconnect();
    System.out.println(sb);
    }

    原文地址: http://blog.csdn.net/aerchi/article/details/7921198

    展开全文
  • 从什么地方抄来的已经记清了,为了防止丢失,做个备份。 这段代码第一部分设置ip地址为自动获取,然后设置代理服务器为"porxy:80"; @echo off cls color 0A Echo The program is running... Echo Setting the ip ...
  • 您需要在BurpSuite中创建可见的代理侦听器,以便Burp拦截HTTP流量,或者您可以使用此扩展的第二个功能来拦截二进制/非HTTP协议。 非HTTP MiTM拦截代理。 通过此扩展,您可以创建可用于MiTM服务器端服务的多个...
  • Python DNS64 代理 这是 Python 3 中 DNS64 代理的一个非常脏且快速的实验性实现。... TOTD 似乎已经死了(找到任何代码),我想运行 BIND 只是为了做 DNS64。 这让我可以继续使用 DNSMasq。 执照 麻省理工学院
  • 在實際工作中,由于办公网络的限制,连接外网访问时需要指定代理, ...于是根据java.net.URL的api整理了设置代理服务器自定义Host头绕过DNS解析的方法: 代码如下: [code] public static void main(String
  • *dns常见dns记录类型介绍* DNS()(Domain NAME SYSTEM,...DNS代理:用于代理域名的服务器,对于客户端查询请求进行响应(一般是本地查找,查找到在向代理的服务器转发客户端的查询请求)。 DNS记录类型介绍:
  • 在windows下实现基于dns的自动全局代理。 本方法需要监听本地80443端口,所以如果你有程序占用了这两个端口,请关闭相应的程序。 本文提供了两种方式:1.使用CDN作为中间传输层 2.使用CDN;根据自己情况二选一...
  • 一个真正了不起的多平台(lin,win,mac,android)本地缓存和代理dns服务器! 在此获取最新版本(v2.1.1): : {版本2.1.3} 超时状态得到改善(中间状态以确认超时) {版本2.1.2} 添加了断开连接/无响应超时...
  • 反向代理和正向代理

    千次阅读 2016-09-01 20:50:56
    参考图解代理 一、正向代理说正向代理的概念...看图:正向代理原理图用户A能直接访问服务器B,有可能是DNS解析了,也有可能是被墙了。这时用户A想了个办法,它去联系代理服务Z,告诉Z,我想访问服务器B,Z说好
  • 本教程作用 在搭建本地测试环境时,希望各项配置线上服务器一直,如nginx,编译地址,...基于这个需求,经过咨询一些同事在网上查找,发现了代理DNS这个服务,它能使你自定义域名进行访问。如test.dev.com指向...
  • 浏览器代理设置取消代理

    千次阅读 2019-05-23 15:45:00
    网络能够正常访问,但是浏览器打开,QQ 可以正常上网。可以 ping的通网络。浏览器没有出现报错情况下 第一种 判首先查看浏览器是否开启了代理, (如果是,就取消代理):操作...第二种:可能是DNS缓存问题 (...
  • 然而随着项目的增多,对于开发测试人员记住如此多的内网地址,无疑是一件头疼的事情(当然你也可以使用浏览器书签管理器或者记录在某个地方)。但是你永远不会确定,那天由于升级突然改了IP,我们可能又要重新撸一...
  • AFHTTPSessionManager AFHTTPRequestOperationManager 两个相比在代码实现方式及请求原理上差太多(包括在RAC的支持上). 但在代理服务上AFHTTPSessionManager支持很好,AFHTTPRequestOperationManager目前...
  • DNS隧道ICMP隧道

    千次阅读 2017-01-17 15:12:06
    这意味着我们能使用公司的代理向外传输数据。同时,如果我们没有连接到互联网,也无法泄露敏感信息。因此,在这种情况下,隧道技术就能发挥非常重要的作用。 隧道技术不是通过网络直接发送数据包,而是通过封装...
  • Nginx 负载均衡反向代理配置优化 DNS 轮询方式: 介绍: DNS 轮询是指一个域名可以绑定到多个的 ip 服务器上, 用户在访问的时候 dns轮询访问这几个 ip 的服务器, 达到负载均衡的目的. 可以使用 linux 命令 dig ...
  • IP协议相关技术与网络总结DNSDNS与域名域名服务器域名的解析流程ICMPpingNAT/NAPTNATNAPTNAT的缺陷代理服务DHCP通信流程浏览器中输入url后,发生的事情通过QQ进行发送一条消息时,发生的事情当内网设备与外网通信时...
  • DNS劫持 DNS污染 介绍 与 公共DNS 推荐

    千次阅读 2015-08-05 11:45:31
    我们知道,某些网络运营商为了某些...一般情况下输入一个错误或存在的 URL 后,本应该出现404页面,而我们看到的却都是电信、联通等运营商的网址导航页面,正常访问网站时出现电信的小广告,使用了代理却依然无法正
  • DHCPDHCP中继代理原理实验DHCP概述:DHCP工作流程 DHCP概述: DHCP,动态主机配置协议,是一个局域网的网络协议,使用UDP协议工作,常用的2个端口:67(DHCP server),68(DHCP client)。DHCP通常被用于局域网环境...
  • 就是说我们上网的时候访问一个网站都是通过英文的形式访问的吗,可是这只是为了方便人们对这个网站的理解而已。其实真正的网站是以数字的形式作为ip地址的。所以这时候我们就需要一个服务器:域名服务器来把英文...
  • 今天打开电脑,上网正常,唯独网页打开,显示DNS服务器未响应,如果你的电脑也是win10的系统,可以看看我是如何解决的。 首先,如果用过VPN访问外网,那么有可能是代理服务器修改了你的IP地址,导致你的IP地址不对...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 674
精华内容 269
关键字:

dns代理和不代理