SteamAuth sync

SteamAuth/SteamGuardAccount.cs

@@ -6,6 +6,7 @@ using System.Net;
 using System.Security.Cryptography;
 using System.Text;
 using System.Text.RegularExpressions;
+using System.Threading.Tasks;
 
 namespace SteamAuth
 {
@@ -171,6 +172,56 @@ namespace SteamAuth
             return ret.ToArray();
         }
 
+        public async Task<Confirmation[]> FetchConfirmationsAsync()
+        {
+            string url = this.GenerateConfirmationURL();
+
+            CookieContainer cookies = new CookieContainer();
+            this.Session.AddCookies(cookies);
+
+            string response = await SteamWeb.RequestAsync(url, "GET", null, cookies);
+
+            /*So you're going to see this abomination and you're going to be upset.
+              It's understandable. But the thing is, regex for HTML -- while awful -- makes this way faster than parsing a DOM, plus we don't need another library.
+              And because the data is always in the same place and same format... It's not as if we're trying to naturally understand HTML here. Just extract strings.
+              I'm sorry. */
+
+            Regex confIDRegex = new Regex("data-confid=\"(\\d+)\"");
+            Regex confKeyRegex = new Regex("data-key=\"(\\d+)\"");
+            Regex confDescRegex = new Regex("<div>((Confirm|Trade with|Sell -) .+)</div>");
+
+            if (response == null || !(confIDRegex.IsMatch(response) && confKeyRegex.IsMatch(response) && confDescRegex.IsMatch(response)))
+            {
+                if (response == null || !response.Contains("<div>Nothing to confirm</div>"))
+                {
+                    throw new WGTokenInvalidException();
+                }
+
+                return new Confirmation[0];
+            }
+
+            MatchCollection confIDs = confIDRegex.Matches(response);
+            MatchCollection confKeys = confKeyRegex.Matches(response);
+            MatchCollection confDescs = confDescRegex.Matches(response);
+
+            List<Confirmation> ret = new List<Confirmation>();
+            for (int i = 0; i < confIDs.Count; i++)
+            {
+                string confID = confIDs[i].Groups[1].Value;
+                string confKey = confKeys[i].Groups[1].Value;
+                string confDesc = confDescs[i].Groups[1].Value;
+                Confirmation conf = new Confirmation()
+                {
+                    ConfirmationDescription = confDesc,
+                    ConfirmationID = confID,
+                    ConfirmationKey = confKey
+                };
+                ret.Add(conf);
+            }
+
+            return ret.ToArray();
+        }
+
         public bool AcceptConfirmation(Confirmation conf)
         {
             return _sendConfirmationAjax(conf, "allow");
@@ -213,6 +264,38 @@ namespace SteamAuth
             }
         }
 
+        /// <summary>
+        /// Refreshes the Steam session. Necessary to perform confirmations if your session has expired or changed.
+        /// </summary>
+        /// <returns></returns>
+        public async Task<bool> RefreshSessionAsync()
+        {
+            string url = APIEndpoints.MOBILEAUTH_GETWGTOKEN;
+            NameValueCollection postData = new NameValueCollection();
+            postData.Add("access_token", this.Session.OAuthToken);
+
+            string response = await SteamWeb.RequestAsync(url, "POST", postData);
+            if (response == null) return false;
+
+            try
+            {
+                var refreshResponse = JsonConvert.DeserializeObject<RefreshSessionDataResponse>(response);
+                if (refreshResponse == null || refreshResponse.Response == null || String.IsNullOrEmpty(refreshResponse.Response.Token))
+                    return false;
+
+                string token = this.Session.SteamID + "%7C%7C" + refreshResponse.Response.Token;
+                string tokenSecure = this.Session.SteamID + "%7C%7C" + refreshResponse.Response.TokenSecure;
+
+                this.Session.SteamLogin = token;
+                this.Session.SteamLoginSecure = tokenSecure;
+                return true;
+            }
+            catch (Exception e)
+            {
+                return false;
+            }
+        }
+
         private bool _sendConfirmationAjax(Confirmation conf, string op)
         {
             string url = APIEndpoints.COMMUNITY_BASE + "/mobileconf/ajaxop";

SteamAuth/SteamWeb.cs

@@ -2,6 +2,7 @@
 using System.Collections.Specialized;
 using System.IO;
 using System.Net;
+using System.Threading.Tasks;
 
 namespace SteamAuth
 {
@@ -67,12 +68,67 @@ namespace SteamAuth
                     using (StreamReader responseStream = new StreamReader(response.GetResponseStream()))
                     {
                         string responseData = responseStream.ReadToEnd();
-
                         return responseData;
                     }
                 }
             }
-            catch (WebException ex)
+            catch (WebException)
+            {
+                return null;
+            }
+        }
+
+        public static async Task<string> RequestAsync(string url, string method, NameValueCollection data = null, CookieContainer cookies = null, NameValueCollection headers = null, string referer = APIEndpoints.COMMUNITY_BASE)
+        {
+            string query = (data == null ? string.Empty : string.Join("&", Array.ConvertAll(data.AllKeys, key => String.Format("{0}={1}", WebUtility.UrlEncode(key), WebUtility.UrlEncode(data[key])))));
+            if (method == "GET")
+            {
+                url += (url.Contains("?") ? "&" : "?") + query;
+            }
+
+            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
+            request.Method = method;
+            request.Accept = "text/javascript, text/html, application/xml, text/xml, */*";
+            request.UserAgent = "Mozilla/5.0 (Linux; U; Android 4.1.1; en-us; Google Nexus 4 - 4.1.1 - API 16 - 768x1280 Build/JRO03S) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30";
+            request.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;
+            request.Referer = referer;
+
+            if (headers != null)
+            {
+                request.Headers.Add(headers);
+            }
+
+            if (cookies != null)
+            {
+                request.CookieContainer = cookies;
+            }
+
+            if (method == "POST")
+            {
+                request.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
+                request.ContentLength = query.Length;
+
+                StreamWriter requestStream = new StreamWriter(request.GetRequestStream());
+                requestStream.Write(query);
+                requestStream.Close();
+            }
+
+            try
+            {
+                HttpWebResponse response = (HttpWebResponse) await request.GetResponseAsync();
+
+                if (response.StatusCode != HttpStatusCode.OK)
+                {
+                    return null;
+                }
+
+                using (StreamReader responseStream = new StreamReader(response.GetResponseStream()))
+                {
+                    string responseData = responseStream.ReadToEnd();
+                    return responseData;
+                }
+            }
+            catch (WebException)
             {
                 return null;
             }

SteamAuth/TimeAligner.cs

@@ -1,4 +1,6 @@
-using System.Net;
+using System;
+using System.Threading.Tasks;
+using System.Net;
 using Newtonsoft.Json;
 
 namespace SteamAuth
@@ -21,6 +23,15 @@ namespace SteamAuth
             return Util.GetSystemUnixTime() + _timeDifference;
         }
 
+        public static async Task<long> GetSteamTimeAsync()
+        {
+            if (!TimeAligner._aligned)
+            {
+                await TimeAligner.AlignTimeAsync();
+            }
+            return Util.GetSystemUnixTime() + _timeDifference;
+        }
+
         public static void AlignTime()
         {
             long currentTime = Util.GetSystemUnixTime();
@@ -33,13 +44,30 @@ namespace SteamAuth
                     TimeAligner._timeDifference = (int)(query.Response.ServerTime - currentTime);
                     TimeAligner._aligned = true;
                 }
-                catch (WebException e)
+                catch (WebException)
                 {
                     return;
                 }
             }
         }
 
+        public static async Task AlignTimeAsync()
+        {
+            long currentTime = Util.GetSystemUnixTime();
+            WebClient client = new WebClient();
+            try
+            {
+                string response = await client.UploadStringTaskAsync(new Uri(APIEndpoints.TWO_FACTOR_TIME_QUERY), "steamid=0");
+                TimeQuery query = JsonConvert.DeserializeObject<TimeQuery>(response);
+                TimeAligner._timeDifference = (int)(query.Response.ServerTime - currentTime);
+                TimeAligner._aligned = true;
+            }
+            catch (WebException)
+            {
+                return;
+            }
+        }
+
         internal class TimeQuery
         {
             [JsonProperty("response")]