Exemple #1
0
        /// <summary>
        /// 将HttpWebResponse转换为HttpResponse
        /// </summary>
        public static HttpResponse ToHttpResponse(this HttpWebResponse webResponse, Encoding encoding)
        {
            HttpResponse response = new HttpResponse()
            {
                CookieCollection  = webResponse.Cookies,
                Header            = webResponse.Headers,
                ResponseUri       = webResponse.ResponseUri.ToString(),
                ResultByte        = webResponse.GetBytes(),
                StatusCode        = webResponse.StatusCode,
                StatusDescription = webResponse.StatusDescription,
                CharacterSet      = webResponse.CharacterSet,
                Encoding          = encoding
            };

            return(response);
        }
Exemple #2
0
        private void SendHttpResponse(HttpPacket httpReq, EthernetPacket orgEthPacket, ushort sourcePort, ushort destinationPort, uint ackNumber, uint expectedSeqNumber)
        {
            IPv6Packet ipv6 = (IPv6Packet)orgEthPacket.PayloadPacket;
            TcpPacket  tcp  = new TcpPacket(sourcePort, destinationPort);

            IPAddress       destAddress   = ipv6.SourceAddress;
            IPAddress       sourceAddress = ipv6.DestinationAddress;
            PhysicalAddress sourceMac     = device.MacAddress;
            PhysicalAddress destMac       = orgEthPacket.SourceHwAddress;
            string          urlRequest    = string.IsNullOrEmpty(httpReq.Host) ? string.Format("http://{0}{1}", Ipv6To4Addr(ipv6.DestinationAddress.ToString()), httpReq.ResourceRequest) : httpReq.FullUrlRequest;
            bool            validRequest  = false;

            HttpWebRequest  req            = null;
            HttpWebResponse response       = null;
            IPv6Packet      ipv6Ack        = null;
            EthernetPacket  eth            = null;
            CookieContainer lastCookies    = httpReq.Cookies;
            string          userAgent      = httpReq.UserAgent;
            int             repeatRedirect = 0;

            //Fix no Google's javascript redirect
            if (httpReq.Host.Contains("google") && httpReq.FullUrlRequest.Contains("/xjs/_/js/"))
            {
                validRequest = true;
            }

            while (!validRequest)
            {
                req = HttpWebRequest.Create(urlRequest) as HttpWebRequest;

                req.Host      = req.Address.Host;
                req.UserAgent = userAgent;
                req.Method    = httpReq.Method;
                //req.Accept = httpReq.Accept;
                req.Headers[HttpRequestHeader.AcceptLanguage] = httpReq.AcceptLanguage;
                req.Referer           = httpReq.Referer;
                req.AllowAutoRedirect = false;

                if (lastCookies == null)
                {
                    lastCookies = new CookieContainer();
                }
                req.CookieContainer = lastCookies;

                if (httpReq.Method.ToLower() == "post" && httpReq.Data != null)
                {
                    req.ContentType   = httpReq.ContentType;
                    req.ContentLength = httpReq.Data.Length;

                    using (Stream dataStream = req.GetRequestStream())
                    {
                        using (BinaryWriter writer = new BinaryWriter(dataStream))
                        {
                            writer.Write(httpReq.Data);
                        }
                    }
                }

                try
                {
                    response = req.GetResponse() as HttpWebResponse;
                    if ((response.StatusCode == HttpStatusCode.Found || response.StatusCode == HttpStatusCode.Moved) && response.Headers[HttpResponseHeader.Location].StartsWith("https"))
                    {
                        throw new WebException("302", null, WebExceptionStatus.UnknownError, response);
                    }
                    else
                    {
                        validRequest = true;
                    }
                }
                catch (WebException ex404)
                {
                    if (ex404.Message.Contains("404") && ex404.Response != null)
                    {
                        if ((ex404.Response as HttpWebResponse) != null)
                        {
                            response = (ex404.Response as HttpWebResponse);
                        }
                        validRequest = true;
                    }
                    else if (ex404.Message.Contains("403") && ex404.Response.ResponseUri.AbsoluteUri.StartsWith("http:"))
                    {
                        validRequest = false;
                        urlRequest   = string.Format("https{0}", ex404.Response.ResponseUri.AbsoluteUri.Substring(4));
                        if (!string.IsNullOrEmpty(ex404.Response.Headers[HttpResponseHeader.SetCookie]))
                        {
                            CookieCollection col = HttpPacket.ParseSetCookies(ex404.Response.Headers[HttpResponseHeader.SetCookie]);
                            if (col.Count > 0)
                            {
                                if (!string.IsNullOrEmpty(col[0].Domain))
                                {
                                    string domain = col[0].Domain;
                                    if (domain.StartsWith("."))
                                    {
                                        domain = domain.Remove(0, 1);
                                    }
                                    lastCookies.Add(new Uri(string.Format("http://{0}", domain)), col);
                                }
                                else
                                {
                                    lastCookies.Add(ex404.Response.ResponseUri, col);
                                }
                            }
                        }
                    }
                    else if (ex404.Message.Contains("302"))
                    {
                        if (repeatRedirect < REDIRECTCOUNT)
                        {
                            validRequest = false;
                            urlRequest   = ex404.Response.Headers[HttpResponseHeader.Location];
                            if (!string.IsNullOrEmpty(ex404.Response.Headers[HttpResponseHeader.SetCookie]))
                            {
                                CookieCollection col = HttpPacket.ParseSetCookies(ex404.Response.Headers[HttpResponseHeader.SetCookie]);
                                if (col.Count > 0)
                                {
                                    if (!string.IsNullOrEmpty(col[0].Domain))
                                    {
                                        string domain = col[0].Domain;
                                        if (domain.StartsWith("."))
                                        {
                                            domain = domain.Remove(0, 1);
                                        }
                                        if (urlRequest.StartsWith("https"))
                                        {
                                            lastCookies.Add(new Uri(string.Format("https://{0}", domain)), col);
                                        }
                                        else
                                        {
                                            lastCookies.Add(new Uri(string.Format("http://{0}", domain)), col);
                                        }
                                    }
                                    else
                                    {
                                        lastCookies.Add(ex404.Response.ResponseUri, col);
                                    }
                                }
                            }
                            repeatRedirect++;
                        }
                        else
                        {
                            validRequest = true;
                            response     = null;
                        }
                    }
                    else
                    {
                        validRequest = true;
                    }
                }
                catch (Exception)
                {
                }
            }
            int previousLength = 0;

            uint ackValue = expectedSeqNumber;
            uint sequence = ackNumber;

            if (response != null)
            {
                try
                {
                    foreach (var item in response.GetBytes(1300))
                    {
                        tcp.Psh = false;
                        tcp.Fin = false;
                        tcp.Ack = true;
                        tcp.AcknowledgmentNumber = ackValue;
                        tcp.SequenceNumber       = sequence + (uint)previousLength;
                        sequence       = tcp.SequenceNumber;
                        previousLength = item.Length;

                        tcp.WindowSize  = 1600;
                        tcp.PayloadData = item;

                        ipv6Ack = new IPv6Packet(sourceAddress, destAddress);
                        ipv6Ack.PayloadPacket = tcp;
                        eth = new EthernetPacket(sourceMac, destMac, EthernetPacketType.IpV6);
                        eth.PayloadPacket = ipv6Ack;
                        (eth.PayloadPacket.PayloadPacket as TcpPacket).UpdateTCPChecksum();
                        Program.CurrentProject.data.SendPacket(eth);
                    }
                }
                catch (Exception e)
                {
                    e.ToString();
                }


                tcp.Psh = true;
                tcp.Fin = true;
                tcp.Ack = true;
                tcp.AcknowledgmentNumber = ackValue;
                tcp.SequenceNumber       = sequence + (uint)previousLength;

                tcp.WindowSize  = 1600;
                tcp.PayloadData = new byte[0];

                ipv6Ack = new IPv6Packet(sourceAddress, destAddress);
                ipv6Ack.PayloadPacket = tcp;
                eth = new EthernetPacket(sourceMac, destMac, EthernetPacketType.IpV6);
                eth.PayloadPacket = ipv6Ack;
                (eth.PayloadPacket.PayloadPacket as TcpPacket).UpdateTCPChecksum();
                Program.CurrentProject.data.SendPacket(eth);
            }
            else
            {
                tcp.Psh = true;
                tcp.Fin = true;
                tcp.Ack = true;
                tcp.AcknowledgmentNumber = ackValue;
                tcp.SequenceNumber       = sequence + (uint)previousLength;
                tcp.WindowSize           = 1600;
                tcp.PayloadData          = HttpPacket.Get404Packet();

                ipv6Ack = new IPv6Packet(sourceAddress, destAddress);
                ipv6Ack.PayloadPacket = tcp;
                eth = new EthernetPacket(sourceMac, destMac, EthernetPacketType.IpV6);
                eth.PayloadPacket = ipv6Ack;
                (eth.PayloadPacket.PayloadPacket as TcpPacket).UpdateTCPChecksum();
                Program.CurrentProject.data.SendPacket(eth);
            }
        }
        /// <summary>
        ///     获取响应字符串
        /// </summary>
        internal static string GetString(this HttpWebResponse response)
        {
            var bytes = response.GetBytes();

            return(CharacterSetCache.ContainsKey(response.ResponseUri.Host) ? CharacterSetCache[response.ResponseUri.Host].GetString(bytes) : response.GetString(bytes));
        }