├── .vs
    └── LowDig
    │   └── v14
    │       └── .suo
├── LowDig
    ├── Newtonsoft.Json.dll
    ├── App.config
    ├── Program.cs
    ├── Properties
    │   └── AssemblyInfo.cs
    ├── Functions.cs
    ├── Settings.cs
    ├── Config.cs
    ├── Log.cs
    ├── LowDig.csproj
    ├── Steam.cs
    ├── Hotmail.cs
    └── Session.cs
├── LowDig.sln
├── LICENSE.md
└── README.md


/.vs/LowDig/v14/.suo:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ezzpify/FindLowDigAccounts/HEAD/.vs/LowDig/v14/.suo


--------------------------------------------------------------------------------
/LowDig/Newtonsoft.Json.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ezzpify/FindLowDigAccounts/HEAD/LowDig/Newtonsoft.Json.dll


--------------------------------------------------------------------------------
/LowDig/App.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8" ?>
2 | <configuration>
3 |     <startup> 
4 |         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
5 |     </startup>
6 | </configuration>


--------------------------------------------------------------------------------
/LowDig.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 14
 4 | VisualStudioVersion = 14.0.23107.0
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LowDig", "LowDig\LowDig.csproj", "{367AE931-F53C-4A3A-89E3-9DCFE69319ED}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Release|Any CPU = Release|Any CPU
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{367AE931-F53C-4A3A-89E3-9DCFE69319ED}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15 | 		{367AE931-F53C-4A3A-89E3-9DCFE69319ED}.Debug|Any CPU.Build.0 = Debug|Any CPU
16 | 		{367AE931-F53C-4A3A-89E3-9DCFE69319ED}.Release|Any CPU.ActiveCfg = Release|Any CPU
17 | 		{367AE931-F53C-4A3A-89E3-9DCFE69319ED}.Release|Any CPU.Build.0 = Release|Any CPU
18 | 	EndGlobalSection
19 | 	GlobalSection(SolutionProperties) = preSolution
20 | 		HideSolutionNode = FALSE
21 | 	EndGlobalSection
22 | EndGlobal
23 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Casper
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/LowDig/Program.cs:
--------------------------------------------------------------------------------
 1 | using System.Threading;
 2 | using System;
 3 | 
 4 | namespace LowDig
 5 | {
 6 |     class Program
 7 |     {
 8 |         /// <summary>
 9 |         /// Private variables
10 |         /// </summary>
11 |         private static Session mSession;
12 |         private static Config.Settings mSettings;
13 | 
14 | 
15 |         /// <summary>
16 |         /// Main functions
17 |         /// Set settings and start session
18 |         /// </summary>
19 |         /// <param name="args">No args</param>
20 |         static void Main(string[] args)
21 |         {
22 |             /*Read settings*/
23 |             mSettings = Settings.Read();
24 |             if (mSettings == null)
25 |                 return;
26 | 
27 |             /*Start session*/
28 |             mSession = new Session(mSettings);
29 | 
30 |             /*Keep us alive*/
31 |             while (true)
32 |             {
33 |                 /*Update title with number of account found from session*/
34 |                 Console.Title = string.Format("Zute | LowDig | Accounts found: {0}", mSession.mAccountsFound);
35 |                 Thread.Sleep(100);
36 |             }
37 |         }
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/LowDig/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following 
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | [assembly: AssemblyTitle("LowDig")]
 9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("")]
12 | [assembly: AssemblyProduct("LowDig")]
13 | [assembly: AssemblyCopyright("Copyright ©  2016")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // Setting ComVisible to false makes the types in this assembly not visible 
18 | // to COM components.  If you need to access a type in this assembly from 
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 | 
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid("367ae931-f53c-4a3a-89e3-9dcfe69319ed")]
24 | 
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | //      Major Version
28 | //      Minor Version 
29 | //      Build Number
30 | //      Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers 
33 | // by using the '*' as shown below:
34 | // [assembly: AssemblyVersion("1.0.*")]
35 | [assembly: AssemblyVersion("1.0.0.0")]
36 | [assembly: AssemblyFileVersion("1.0.0.0")]
37 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # This is an old project
 2 | 
 3 | Sorry to dissapoint in case you arrived late to the party, but do not expect this to work. While I haven't ran this program in about 6 years, I assume it can still scan for accounts; however I don't expect that you can do much with the output.
 4 | 
 5 | # FindLowDigAccounts
 6 | 
 7 | [![License](https://img.shields.io/github/license/Ezzpify/FindLowDigAccounts.svg?label=License&maxAge=86400)](./LICENSE)
 8 | [![GitHub Release](https://img.shields.io/github/release/Ezzpify/FindLowDigAccounts.svg?label=Latest&maxAge=60)](https://github.com/Ezzpify/HourBoostr/releases/latest)
 9 | [![Github Downloads](https://img.shields.io/github/downloads/Ezzpify/FindLowDigAccounts/latest/total.svg?label=Downloads&maxAge=60)](https://github.com/Ezzpify/FindLowDigAccounts/releases/latest)
10 | 
11 | This will scan Steam accounts within a certain range and if they have no set up their Steam Community profile then it will log that account Steam id. I am not responsible for what you do with this.
12 | 
13 | Credits for the original idea goes to lukeryuri/phoenixdoom. They have their own project that I recommend you also check out! https://github.com/hvze/steam-gen
14 | 
15 | ![Version 2](http://i.imgur.com/7rWbmJl.gif)
16 | 
17 | Log file example:
18 | ```
19 | ChrisRPG
20 | ChrisRPG@hotmail.com
21 | STEAM_0:0:5004
22 | 
23 | lee2leee
24 | lee2leee@hotmail.com
25 | STEAM_0:0:5007
26 | 
27 | ShoTTy
28 | ShoTTy@hotmail.com
29 | STEAM_0:0:5011
30 | 
31 | eclipze
32 | eclipze@hotmail.com
33 | STEAM_0:0:5013
34 | 
35 | scorpion_lgg
36 | scorpion_lgg@hotmail.com
37 | STEAM_0:0:5022
38 | ```
39 | 


--------------------------------------------------------------------------------
/LowDig/Functions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace LowDig
 5 | {
 6 |     static class Functions
 7 |     {
 8 |         /// <summary>
 9 |         /// Converts from SteamId to SteamId64
10 |         /// </summary>
11 |         /// <param name="steamId">SteamId to convert</param>
12 |         /// <returns>Returns a converted SteamId64</returns>
13 |         public static string ConvertToSteam64(string steamId)
14 |         {
15 |             steamId.Replace("STEAM_", "");
16 |             string[] split = steamId.Split(':');
17 |             return "765611979" + ((Convert.ToInt64(split[2]) * 2) + 60265728 + Convert.ToInt64(split[1])).ToString();
18 |         }
19 | 
20 | 
21 |         /// <summary>
22 |         /// Gets a string inbetween two strings
23 |         /// </summary>
24 |         /// <param name="source">Source string</param>
25 |         /// <param name="start">Start string</param>
26 |         /// <param name="end">End string</param>
27 |         /// <returns>Returns string if found</returns>
28 |         public static string GetStringBetween(string source, string start, string end)
29 |         {
30 |             int startIndex = source.IndexOf(start);
31 |             if (startIndex != -1)
32 |             {
33 |                 int endIndex = source.IndexOf(end, startIndex + 1);
34 |                 if (endIndex != -1)
35 |                 {
36 |                     return source.Substring(startIndex + start.Length, endIndex - startIndex - start.Length);
37 |                 }
38 |             }
39 |             return string.Empty;
40 |         }
41 | 
42 | 
43 |         /// <summary>
44 |         /// Checks if an email adress looks okay
45 |         /// </summary>
46 |         /// <param name="str">String to check</param>
47 |         /// <returns>Returns true if email looks ok</returns>
48 |         public static bool IsProperEmail(string str)
49 |         {
50 |             return Regex.IsMatch(str, @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z",
51 |                 RegexOptions.IgnoreCase);
52 |         }
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/LowDig/Settings.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Threading;
 3 | using System.IO;
 4 | using Newtonsoft.Json;
 5 | 
 6 | namespace LowDig
 7 | {
 8 |     static class Settings
 9 |     {
10 |         /// <summary>
11 |         /// Read or write settings for application
12 |         /// </summary>
13 |         /// <returns>Returns null if settings was not read</returns>
14 |         public static Config.Settings Read()
15 |         {
16 |             string fileName = "Settings.json";
17 |             if (File.Exists(fileName))
18 |             {
19 |                 /*File exist, so we'll parse the information here*/
20 |                 string setJson = File.ReadAllText(fileName);
21 |                 if (!string.IsNullOrWhiteSpace(setJson))
22 |                 {
23 |                     try
24 |                     {
25 |                         /*Return deserialized json string*/
26 |                         return JsonConvert.DeserializeObject<Config.Settings>(setJson);
27 |                     }
28 |                     catch (JsonException jEx)
29 |                     {
30 |                         /*Incorrect format probably*/
31 |                         Console.WriteLine("Error parsing {0}\n{1}", fileName, jEx.ToString());
32 |                         File.Delete(fileName);
33 |                         Thread.Sleep(1500);
34 |                     }
35 |                 }
36 |             }
37 |             else
38 |             {
39 |                 /*File doesn't exist, we'll create it here*/
40 |                 var settingsClass = new Config.Settings()
41 |                 {
42 |                     /*Temp values*/
43 |                     startId = 5000,
44 |                     endId = 10000,
45 |                     requestLimit = 50,
46 |                     checkHotmail = true
47 |                 };
48 | 
49 |                 /*Write file*/
50 |                 string djson = JsonConvert.SerializeObject(settingsClass, Formatting.Indented);
51 |                 Console.WriteLine("{0} has been written. Edit the settings and launch the program again.", fileName);
52 |                 File.WriteAllText(fileName, djson);
53 |                 Thread.Sleep(1500);
54 |             }
55 |             
56 |             return null;
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/LowDig/Config.cs:
--------------------------------------------------------------------------------
 1 | namespace LowDig
 2 | {
 3 |     public class Config
 4 |     {
 5 |         /// <summary>
 6 |         /// Holds settings for application
 7 |         /// </summary>
 8 |         public class Settings
 9 |         {
10 |             public int startId { get; set; }
11 |             public int endId { get; set; }
12 |             public int requestLimit { get; set; }
13 |             public bool checkHotmail { get; set; }
14 |         }
15 | 
16 | 
17 |         /// <summary>
18 |         /// Holds information about a steam account
19 |         /// </summary>
20 |         public class Account
21 |         {
22 |             public string username { get; set; }
23 |             public string email { get; set; }
24 |             public string steamid { get; set; }
25 |         }
26 | 
27 | 
28 |         /// <summary>
29 |         /// Hotmail error class
30 |         /// </summary>
31 |         public class Error
32 |         {
33 |             public string code { get; set; }
34 |             public string data { get; set; }
35 |             public bool showError { get; set; }
36 |             public string stackTrace { get; set; }
37 |         }
38 | 
39 | 
40 |         /// <summary>
41 |         /// Hotmail reponse class
42 |         /// </summary>
43 |         public class HotmailResponse
44 |         {
45 |             public Error error { get; set; }
46 |             public string apiCanary { get; set; }
47 |             public bool isAvailable { get; set; }
48 |             public string type { get; set; }
49 |         }
50 | 
51 | 
52 |         /// <summary>
53 |         /// Steam response class
54 |         /// </summary>
55 |         public class SteamResponse
56 |         {
57 |             public bool needCaptcha { get; set; } = true;
58 |             public string hash { get; set; }
59 |             public string errorMsg { get; set; }
60 |         }
61 | 
62 | 
63 |         /// <summary>
64 |         /// Class for holding proxies and how many uses they've had
65 |         /// </summary>
66 |         public class Proxy
67 |         {
68 |             public string host { get; set; }
69 |             public int port { get; set; }
70 |             public int uses { get; set; }
71 |             public string steamSessionId { get; set; }
72 |         }
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/LowDig/Log.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Threading;
 4 | using System.IO;
 5 | 
 6 | namespace LowDig
 7 | {
 8 |     class Log
 9 |     {
10 |         /// <summary>
11 |         /// Private log variables
12 |         /// </summary>
13 |         private string          logPath;
14 |         private int             logQueueSize;
15 |         private List<string>    logQueue;
16 | 
17 | 
18 |         /// <summary>
19 |         /// Class constructor
20 |         /// </summary>
21 |         /// <param name="LogPath">Path to log file</param>
22 |         public Log(string LogPath, int QueueSize)
23 |         {
24 |             /*Initialize log variables*/
25 |             logQueue = new List<string>();
26 |             logPath = LogPath;
27 |             logQueueSize = QueueSize;
28 | 
29 |             /*Create log file if it doesn't exist already*/
30 |             if (!File.Exists(logPath))
31 |             {
32 |                 File.Create(logPath).Close();
33 |                 Console.WriteLine("Log file created");
34 |                 Thread.Sleep(250);
35 |             }
36 |         }
37 | 
38 | 
39 |         /// <summary>
40 |         /// Write an account to queue to be flushed and written to file later
41 |         /// </summary>
42 |         /// <param name="account">Account to log</param>
43 |         public void Write(Config.Account account)
44 |         {
45 |             /*Write notice*/
46 |             Console.WriteLine("Found account: {0}", account.username);
47 | 
48 |             /*Add account to queue*/
49 |             string logMessage = string.Format("{0}\n{1}\n{2}\n", 
50 |                 account.username, 
51 |                 account.email, 
52 |                 account.steamid);
53 |             logQueue.Add(logMessage);
54 |             FlushLog();
55 |         }
56 | 
57 | 
58 |         /// <summary>
59 |         /// Flushed the log queue to file
60 |         /// </summary>
61 |         /// <param name="ignoreCondition">If true, flush regardless of queue sie</param>
62 |         public void FlushLog(bool ignoreCondition = false)
63 |         {
64 |             /*If we don't have enough entries to flush, return*/
65 |             if (ignoreCondition || logQueue.Count < logQueueSize)
66 |                 return;
67 | 
68 |             /*Log entries*/
69 |             lock (logQueue)
70 |             {
71 |                 using (FileStream fs = File.Open(logPath, FileMode.Append, FileAccess.Write))
72 |                 {
73 |                     using (StreamWriter sw = new StreamWriter(fs))
74 |                     {
75 |                         foreach (var str in logQueue)
76 |                         {
77 |                             sw.WriteLine(str);
78 |                         }
79 | 
80 |                         logQueue.Clear();
81 |                     }
82 |                 }
83 |             }
84 |         }
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/LowDig/LowDig.csproj:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
 4 |   <PropertyGroup>
 5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
 6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
 7 |     <ProjectGuid>{367AE931-F53C-4A3A-89E3-9DCFE69319ED}</ProjectGuid>
 8 |     <OutputType>Exe</OutputType>
 9 |     <AppDesignerFolder>Properties</AppDesignerFolder>
10 |     <RootNamespace>LowDig</RootNamespace>
11 |     <AssemblyName>LowDig</AssemblyName>
12 |     <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
13 |     <FileAlignment>512</FileAlignment>
14 |     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
15 |   </PropertyGroup>
16 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
17 |     <PlatformTarget>AnyCPU</PlatformTarget>
18 |     <DebugSymbols>true</DebugSymbols>
19 |     <DebugType>full</DebugType>
20 |     <Optimize>false</Optimize>
21 |     <OutputPath>bin\Debug\</OutputPath>
22 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
23 |     <ErrorReport>prompt</ErrorReport>
24 |     <WarningLevel>4</WarningLevel>
25 |   </PropertyGroup>
26 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
27 |     <PlatformTarget>AnyCPU</PlatformTarget>
28 |     <DebugType>pdbonly</DebugType>
29 |     <Optimize>true</Optimize>
30 |     <OutputPath>bin\Release\</OutputPath>
31 |     <DefineConstants>TRACE</DefineConstants>
32 |     <ErrorReport>prompt</ErrorReport>
33 |     <WarningLevel>4</WarningLevel>
34 |   </PropertyGroup>
35 |   <ItemGroup>
36 |     <Reference Include="Newtonsoft.Json, Version=4.5.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
37 |       <SpecificVersion>False</SpecificVersion>
38 |       <HintPath>.\Newtonsoft.Json.dll</HintPath>
39 |     </Reference>
40 |     <Reference Include="System" />
41 |     <Reference Include="System.Core" />
42 |     <Reference Include="System.Xml.Linq" />
43 |     <Reference Include="System.Data.DataSetExtensions" />
44 |     <Reference Include="Microsoft.CSharp" />
45 |     <Reference Include="System.Data" />
46 |     <Reference Include="System.Net.Http" />
47 |     <Reference Include="System.Xml" />
48 |   </ItemGroup>
49 |   <ItemGroup>
50 |     <Compile Include="Config.cs" />
51 |     <Compile Include="Functions.cs" />
52 |     <Compile Include="Hotmail.cs" />
53 |     <Compile Include="Log.cs" />
54 |     <Compile Include="Program.cs" />
55 |     <Compile Include="Properties\AssemblyInfo.cs" />
56 |     <Compile Include="Session.cs" />
57 |     <Compile Include="Settings.cs" />
58 |     <Compile Include="Steam.cs" />
59 |   </ItemGroup>
60 |   <ItemGroup>
61 |     <None Include="App.config" />
62 |   </ItemGroup>
63 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
64 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
65 |        Other similar extension points exist, see Microsoft.Common.targets.
66 |   <Target Name="BeforeBuild">
67 |   </Target>
68 |   <Target Name="AfterBuild">
69 |   </Target>
70 |   -->
71 | </Project>


--------------------------------------------------------------------------------
/LowDig/Steam.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Net;
  3 | using System.IO;
  4 | using Newtonsoft.Json;
  5 | 
  6 | namespace LowDig
  7 | {
  8 |     static class Steam
  9 |     {
 10 |         /// <summary>
 11 |         /// Private variables
 12 |         /// </summary>
 13 |         private static CookieContainer mCookies = new CookieContainer();
 14 | 
 15 | 
 16 |         /// <summary>
 17 |         /// Gets the steam session
 18 |         /// </summary>
 19 |         public static string GetSession(Config.Proxy proxy)
 20 |         {
 21 |             /*Start the request*/
 22 |             var webAdd = "https://help.steampowered.com";
 23 |             var webReq = (HttpWebRequest)WebRequest.Create(webAdd);
 24 | 
 25 |             /*Add nessesary information to the request so it will be accepted as a legit request*/
 26 |             webReq.ContentType = "application/json; charset=utf-8";
 27 |             webReq.Method = "GET";
 28 |             webReq.Host = "help.steampowered.com";
 29 |             webReq.Accept = "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8";
 30 |             webReq.UserAgent = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Safari/537.36";
 31 |             webReq.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
 32 |             webReq.KeepAlive = true;
 33 |             webReq.CookieContainer = mCookies;
 34 |             webReq.Proxy = new WebProxy(proxy.host, proxy.port);
 35 | 
 36 |             /*Read the response*/
 37 |             var httpResponse = (HttpWebResponse)webReq.GetResponse();
 38 |             using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
 39 |             {
 40 |                 /*Scrape all the session details we need to make dirty api requests*/
 41 |                 var result = streamReader.ReadToEnd();
 42 |                 return Functions.GetStringBetween(result, "g_sessionID = \"", "\";");
 43 |             }
 44 |         }
 45 | 
 46 | 
 47 |         /// <summary>
 48 |         /// If a steam account is available
 49 |         /// </summary>
 50 |         /// <param name="address">email to check</param>
 51 |         /// <returns>0 = unavailable, 1 = need captcha, 2 = success, 3 = timeout, 4 = error</returns>
 52 |         public static int IsAvailable(string address, Config.Proxy proxy)
 53 |         {
 54 |             try
 55 |             {
 56 |                 /*Start the request*/
 57 |                 var webAdd = string.Format("https://help.steampowered.com/wizard/AjaxLoginInfoSearch?nav=&search={0}&captchagid=&captcha_text=&sessionid={1}", address, proxy.steamSessionId);
 58 |                 var webReq = (HttpWebRequest)WebRequest.Create(webAdd);
 59 | 
 60 |                 /*Add nessesary information to the request so it will be accepted as a legit request*/
 61 |                 webReq.ContentType = "application/json; charset=utf-8";
 62 |                 webReq.Method = "GET";
 63 |                 webReq.Host = "help.steampowered.com";
 64 |                 webReq.Accept = "*/*";
 65 |                 webReq.Referer = "https://help.steampowered.com/";
 66 |                 webReq.UserAgent = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Safari/537.36";
 67 |                 webReq.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
 68 |                 webReq.KeepAlive = true;
 69 |                 webReq.CookieContainer = mCookies;
 70 |                 webReq.Timeout = 10000;
 71 |                 webReq.Proxy = new WebProxy(proxy.host, proxy.port);
 72 | 
 73 |                 /*Parse the json response we receive here*/
 74 |                 var httpResponse = (HttpWebResponse)webReq.GetResponse();
 75 |                 using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
 76 |                 {
 77 |                     /*Deserialize the response and return if the email is available or not*/
 78 |                     var result = streamReader.ReadToEnd();
 79 |                     var resp = JsonConvert.DeserializeObject<Config.SteamResponse>(result);
 80 | 
 81 |                     /*We need captcha, so we'll keep the account in queue and try with a different ip*/
 82 |                     if (resp.needCaptcha) { return 1; }
 83 | 
 84 |                     /*No error, that means the account is available*/
 85 |                     if (string.IsNullOrWhiteSpace(resp.errorMsg)) { return 2; }
 86 | 
 87 |                     /*Account not available*/
 88 |                     return 0;
 89 |                 }
 90 |             }
 91 |             catch(WebException e)
 92 |             {
 93 |                 if (e.Status == WebExceptionStatus.Timeout)
 94 |                 {
 95 |                     return 3;
 96 |                 }
 97 |                 
 98 |                 return 4;
 99 |             }
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/LowDig/Hotmail.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Text.RegularExpressions;
  3 | using System.Net;
  4 | using System.IO;
  5 | using Newtonsoft.Json;
  6 | 
  7 | namespace LowDig
  8 | {
  9 |     static class Hotmail
 10 |     {
 11 |         /// <summary>
 12 |         /// Request class
 13 |         /// This holds all the information nessesary to talk to hotmail
 14 |         /// </summary>
 15 |         private class request
 16 |         {
 17 |             public string signInName { get; set; }
 18 |             public string uaid { get; set; }
 19 |             public bool performDisambigCheck { get; set; } = true;
 20 |             public bool includeSuggestions { get; set; } = true;
 21 |             public int uiflvr { get; set; }
 22 |             public int scid { get; set; }
 23 |             public int hpgid { get; set; }
 24 |         }
 25 | 
 26 | 
 27 |         /// <summary>
 28 |         /// Private variables
 29 |         /// </summary>
 30 |         private static CookieContainer mCookies = new CookieContainer();
 31 |         private static request mRequest = new request();
 32 |         private static string mApiCanary;
 33 | 
 34 | 
 35 |         /// <summary>
 36 |         /// Gets the session from hotmail
 37 |         /// </summary>
 38 |         public static void GetSession()
 39 |         {
 40 |             /*Start the request*/
 41 |             var webAdd = "https://signup.live.com/signup.aspx?lic=1";
 42 |             var webReq = (HttpWebRequest)WebRequest.Create(webAdd);
 43 | 
 44 |             /*Add nessesary information to the request so it will be accepted as a legit request*/
 45 |             webReq.ContentType = "application/json; charset=utf-8";
 46 |             webReq.Method = "GET";
 47 |             webReq.Host = "signup.live.com";
 48 |             webReq.Accept = "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8";
 49 |             webReq.UserAgent = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Safari/537.36";
 50 |             webReq.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
 51 |             webReq.KeepAlive = true;
 52 |             webReq.CookieContainer = mCookies;
 53 | 
 54 |             /*Read the response*/
 55 |             var httpResponse = (HttpWebResponse)webReq.GetResponse();
 56 |             using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
 57 |             {
 58 |                 /*Scrape all the session details we need to make dirty api requests*/
 59 |                 var result = streamReader.ReadToEnd();
 60 |                 mRequest.uaid = Functions.GetStringBetween(result, "\"uaid\":\"", "\",");
 61 |                 mRequest.uiflvr = Convert.ToInt32(Functions.GetStringBetween(result, "\"uiflvr\":", ","));
 62 |                 mRequest.scid = Convert.ToInt32(Functions.GetStringBetween(result, "\"scid\":", ","));
 63 |                 mRequest.hpgid = Convert.ToInt32(Functions.GetStringBetween(result, "\"hpgid\":", ","));
 64 |                 mApiCanary = Regex.Unescape(Functions.GetStringBetween(result, "\"apiCanary\":\"", "\","));
 65 |                 Console.WriteLine("Got Hotmail session");
 66 |             }
 67 |         }
 68 | 
 69 | 
 70 |         /// <summary>
 71 |         /// Searches if the 
 72 |         /// </summary>
 73 |         /// <param name="address">hotmail address to check</param>
 74 |         /// <returns>Returns true if available</returns>
 75 |         public static bool IsAvailable(string address)
 76 |         {
 77 |             try
 78 |             {
 79 |                 /*Start the request*/
 80 |                 Config.HotmailResponse resp = null;
 81 |                 int attempts = 0;
 82 | 
 83 |                 do
 84 |                 {
 85 |                     var webAdd = string.Format("https://signup.live.com/API/CheckAvailableSigninNames?uaid={0}&lic=1", mRequest.uaid);
 86 |                     var webReq = (HttpWebRequest)WebRequest.Create(webAdd);
 87 | 
 88 |                     /*Add nessesary information to the request so it will be accepted as a legit request*/
 89 |                     webReq.ContentType = "application/json; charset=utf-8";
 90 |                     webReq.Method = "POST";
 91 |                     webReq.Host = "signup.live.com";
 92 |                     webReq.Accept = "application/json";
 93 |                     webReq.UserAgent = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Safari/537.36";
 94 |                     webReq.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
 95 |                     webReq.KeepAlive = true;
 96 |                     webReq.CookieContainer = mCookies;
 97 |                     webReq.Headers["canary"] = mApiCanary;
 98 |                     webReq.Timeout = 10000;
 99 | 
100 |                     /*We'll write the deserialized request class here*/
101 |                     using (var streamWriter = new StreamWriter(webReq.GetRequestStream()))
102 |                     {
103 |                         /*Set up new request class with email*/
104 |                         var req = new request();
105 |                         req = mRequest;
106 |                         req.signInName = address;
107 | 
108 |                         /*Write the values*/
109 |                         string json = JsonConvert.SerializeObject(req);
110 |                         streamWriter.Write(json);
111 |                         streamWriter.Flush();
112 |                     }
113 | 
114 |                     /*Parse the json response we receive here*/
115 |                     var httpResponse = (HttpWebResponse)webReq.GetResponse();
116 |                     using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
117 |                     {
118 |                         /*Deserialize the response and return if the email is available or not*/
119 |                         var result = streamReader.ReadToEnd();
120 |                         resp = JsonConvert.DeserializeObject<Config.HotmailResponse>(result);
121 |                         if (resp.error != null)
122 |                         {
123 |                             /*Need to refresh our session*/
124 |                             GetSession();
125 |                             attempts++;
126 |                             resp = null;
127 |                         }
128 |                         else
129 |                         {
130 |                             /*Set the new api string and return if account is free*/
131 |                             mApiCanary = resp.apiCanary;
132 |                         }
133 |                     }
134 |                 }
135 |                 while (resp == null && attempts <= 3);
136 |                 return resp.isAvailable;
137 |             }
138 |             catch
139 |             {
140 |                 return false;
141 |             }
142 |         }
143 |     }
144 | }
145 | 


--------------------------------------------------------------------------------
/LowDig/Session.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Net;
  3 | using System.Threading;
  4 | using System.Collections.Generic;
  5 | using System.IO;
  6 | using System.Linq;
  7 | 
  8 | namespace LowDig
  9 | {
 10 |     class Session
 11 |     {
 12 |         /// <summary>
 13 |         /// Private variables
 14 |         /// </summary>
 15 |         private List<Config.Account> mAccountQueue = new List<Config.Account>();
 16 |         private List<Config.Proxy> mProxies = new List<Config.Proxy>();
 17 |         private static Random mRandom = new Random();
 18 |         private Config.Settings mSettings;
 19 |         private Thread mSearchThread;
 20 |         private Semaphore mSem;
 21 |         private Log mLog;
 22 | 
 23 | 
 24 |         /// <summary>
 25 |         /// Public variables
 26 |         /// </summary>
 27 |         public int mAccountsFound;
 28 | 
 29 | 
 30 |         /// <summary>
 31 |         /// Class constructor
 32 |         /// </summary>
 33 |         public Session(Config.Settings settings)
 34 |         {
 35 |             /*Initialize globals*/
 36 |             mSettings = settings;
 37 |             mLog = new Log("accounts.txt", 1);
 38 |             //LoadProxies(); not needed for hotmail only
 39 | 
 40 |             /*Start our main thread*/
 41 |             mSearchThread = new Thread(Work);
 42 |             mSearchThread.Start();
 43 |         }
 44 | 
 45 | 
 46 |         /// <summary>
 47 |         /// Loads all proxies from proxies.txt
 48 |         /// </summary>
 49 |         private void LoadProxies()
 50 |         {
 51 |             string content = File.ReadAllText("proxies.txt");
 52 |             using (StringReader reader = new StringReader(content))
 53 |             {
 54 |                 string line;
 55 |                 while ((line = reader.ReadLine()) != null)
 56 |                 {
 57 |                     if (line.Length < 4 || !line.Contains(":"))
 58 |                         continue;
 59 | 
 60 |                     string[] split = line.Split(':');
 61 |                     mProxies.Add(new Config.Proxy()
 62 |                     {
 63 |                         host = split[0],
 64 |                         port = Convert.ToInt32(split[1]),
 65 |                         uses = 2 /*We get 2 tries per proxy*/
 66 |                     });
 67 |                 }
 68 |             }
 69 |         }
 70 | 
 71 | 
 72 |         /// <summary>
 73 |         /// Search thread function
 74 |         /// This will search for accounts using three seperate threads
 75 |         /// </summary>
 76 |         private void Work()
 77 |         {
 78 |             /*Initialize our semapore with the settings that was passed*/
 79 |             mSem = new Semaphore(mSettings.requestLimit, mSettings.requestLimit);
 80 |             Hotmail.GetSession();
 81 | 
 82 |             /*Go through the steam accounts*/
 83 |             for (int i = mSettings.startId; i < mSettings.endId; i++)
 84 |             {
 85 |                 mSem.WaitOne();
 86 |                 QueryProfile(0, i);
 87 |                 QueryProfile(1, i);
 88 |             }
 89 | 
 90 |             /*Done checking*/
 91 |             Console.WriteLine("\n\nFinished");
 92 |             mLog.FlushLog(true);
 93 |         }
 94 | 
 95 | 
 96 |         /// <summary>
 97 |         /// Queries a steam profile async
 98 |         /// Passes response to ParseResponse()
 99 |         /// </summary>
100 |         /// <param name="server">Steam account server (0 or 1)</param>
101 |         /// <param name="steamDigit">Steam Digit to query (ex 6000)</param>
102 |         private void QueryProfile(int server, int steamDigit)
103 |         {
104 |             try
105 |             {
106 |                 /*Set up local vars for request*/
107 |                 string steamId = string.Format("STEAM_0:{0}:{1}", server, steamDigit);
108 |                 string steamId64 = Functions.ConvertToSteam64(steamId);
109 |                 string communityUrl = string.Format("http://steamcommunity.com/profiles/{0}", steamId64);
110 | 
111 |                 /*Download page async*/
112 |                 Console.WriteLine("Checking {0} ...", steamId);
113 |                 using (WebClient wc = new WebClient())
114 |                 {
115 |                     wc.DownloadStringCompleted += (sender, e) => { ParseResponse(sender, e, steamId); };
116 |                     wc.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
117 |                     wc.Headers.Add("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; .NET CLR 1.0.3705;)");
118 |                     wc.DownloadStringAsync(new Uri(communityUrl));
119 |                 }
120 |             }
121 |             catch(WebException ex)
122 |             {
123 |                 Console.WriteLine("WebException: {0}", ex.Message);
124 |             }
125 |         }
126 | 
127 | 
128 |         /// <summary>
129 |         /// Checks if an e-mail address is okay
130 |         /// </summary>
131 |         /// <param name="address">address to check</param>
132 |         /// <returns></returns>
133 |         private bool IsEmailGood(string address)
134 |         {
135 |             if (!Functions.IsProperEmail(address))
136 |                 return false;
137 |             
138 |             if (mSettings.checkHotmail && !Hotmail.IsAvailable(address))
139 |                 return false;
140 | 
141 |             return true;
142 |         }
143 | 
144 | 
145 |         /// <summary>
146 |         /// Parses the response from query
147 |         /// </summary>
148 |         /// <param name="o">Sender</param>
149 |         /// <param name="e">EventArgs - we get page source from result</param>
150 |         private void ParseResponse(object o, DownloadStringCompletedEventArgs e, string steamId)
151 |         {
152 |             try
153 |             {
154 |                 string pageSource = e.Result;
155 |                 if (pageSource.Contains("This user has not yet set up their Steam Community profile."))
156 |                 {
157 |                     /*Get the account name from page title*/
158 |                     string accountName = Functions.GetStringBetween(pageSource, "<title>", "</title>")
159 |                         .Replace("Steam Community :: ", "");
160 | 
161 |                     if (!string.IsNullOrEmpty(accountName) && accountName.Length >= 3)
162 |                     {
163 |                         /*Format email and check if it looks okay*/
164 |                         string accountEmail = string.Format("{0}@hotmail.com", accountName);
165 | 
166 |                         /*If the email is valid and not taken*/
167 |                         if (IsEmailGood(accountEmail))
168 |                         {
169 |                             /*Set up the account*/
170 |                             var account = new Config.Account()
171 |                             {
172 |                                 steamid = steamId,
173 |                                 username = accountName,
174 |                                 email = accountEmail
175 |                             };
176 | 
177 |                             mLog.Write(account);
178 |                             mAccountsFound++;
179 |                         }
180 |                     }
181 |                 }
182 |             }
183 |             catch(Exception ex)
184 |             {
185 |                 Console.WriteLine("Exception: {0}", ex.Message);
186 |             }
187 | 
188 |             /*Release queue position*/
189 |             mSem.Release();
190 |         }
191 |     }
192 | }
193 | 


--------------------------------------------------------------------------------