public bool AuthentificateUser(ulong steamID, byte[] sessionKey, byte[] loginKey, out KeyValue result) { result = null; try { using (dynamic steamUserAuth = WebAPI.GetAsyncInterface("ISteamUserAuth", _keyManager.SWAKey)) { result = steamUserAuth.AuthenticateUser( steamid: steamID, sessionkey: Encoding.ASCII.GetString(WebUtility.UrlEncodeToBytes(sessionKey, 0, sessionKey.Length)), encrypted_loginkey: Encoding.ASCII.GetString(WebUtility.UrlEncodeToBytes(loginKey, 0, loginKey.Length)), method: WebRequestMethods.Http.Post, secure: true ); } } catch (Exception ex) { Log.Error("Could not authentificate with Steam Web API: {Error}", ex.Message); return(false); } return(result != null); }
public async Task <string> GetSteamLevel(string steamid) { using (dynamic playerService = WebAPI.GetAsyncInterface("IPlayerService", steamKey)) { KeyValue kvLevel = await playerService.GetSteamLevel1(steamid : steamid); return(kvLevel["player_level"].AsString()); } }
public static async Task <WebSession> AuthenticateWebSession( this SteamClient client, string userNonce ) { // Generate random SessionId var sessionId = Guid.NewGuid().ToString("N"); // Generate an AES SessionKey. var sessionKey = CryptoHelper.GenerateRandomBlock(32); // rsa encrypt it with the public key for the universe we're on byte[] encryptedSessionKey; using (var rsa = new RSACrypto(KeyDictionary.GetPublicKey(client.Universe))) { encryptedSessionKey = rsa.Encrypt(sessionKey); } // AES encrypt the loginkey with our session key. var encryptedLoginKey = CryptoHelper.SymmetricEncrypt( Encoding.ASCII.GetBytes(userNonce), sessionKey ); try { using (var steamUserAuth = WebAPI.GetAsyncInterface("ISteamUserAuth")) { var result = await steamUserAuth.CallAsync( HttpMethod.Post, "AuthenticateUser", 1, new Dictionary <string, object> { { "steamid", client.SteamID.ConvertToUInt64().ToString() }, { "sessionkey", encryptedSessionKey }, { "encrypted_loginkey", encryptedLoginKey } } ).ConfigureAwait(false); return(new WebSession( client.SteamID.ConvertToUInt64(), result["token"]?.Value?.ToUpper(), result["tokensecure"]?.Value?.ToUpper(), sessionId, null, null )); } } catch { return(null); } }
public async Task <long> ResolveVanityURL(string vanityName) { using (dynamic steamUser = WebAPI.GetAsyncInterface("ISteamUser", steamKey)) { KeyValue kvVanity = await steamUser.ResolveVanityURL(vanityurl : vanityName); if (kvVanity["success"].AsInteger() == 1) { return(kvVanity["steamid"].AsLong()); } else { return(0); } } }
public async Task ThrowsHttpRequestExceptionIfRequestUnsuccessful() { var listener = new TcpListener(new IPEndPoint(IPAddress.Loopback, 28123)); listener.Start(); try { AcceptAndAutoReplyNextSocket(listener); var baseUri = "http://localhost:28123"; dynamic iface = WebAPI.GetAsyncInterface(new Uri(baseUri), "IFooService"); await Assert.ThrowsAsync(typeof(HttpRequestException), () => (Task)iface.PerformFooOperation()); } finally { listener.Stop(); } }
public async Task <PlayerCountDetails> RequestPlayerCountWeb(uint appId) { using (dynamic api = WebAPI.GetAsyncInterface("ICommunityService", Settings.Current.WebAPIKey)) { KeyValue resultKv; try { resultKv = await api.GetPlayerCount(appIds : new[] { appId }); } catch (WebException ex) { Log.WriteError(nameof(PlayerCountHandler), "Unable to retreive player count from WebAPI: {0}", ex); return(new PlayerCountDetails { AppID = appId, Result = EResult.Fail, }); } KeyValue playerCount = resultKv["apps_played"].Children .FirstOrDefault(c => c["appid"].AsInteger() == appId); if (playerCount == null) { return(new PlayerCountDetails { AppID = appId, Result = EResult.NoMatch, }); } return(new PlayerCountDetails { AppID = appId, Result = EResult.OK, Count = playerCount["players"].AsUnsignedInteger(), }); } }
public async Task <SteamUserInfo> GetSteamUser(string id) { bool isVanity = !long.TryParse(id, out long steamid); if (isVanity) { steamid = await ResolveVanityURL(id); } using (dynamic steamUser = WebAPI.GetAsyncInterface("ISteamUser", steamKey)) { KeyValue kvUser = await steamUser.GetPlayerSummaries2(steamids : steamid); if (kvUser["players"].Children.Count > 0) { return(new SteamUserInfo(kvUser["players"].Children[0])); } return(null); } }
public static async Task <bool> AuthenticateUser() { SteamUser.WebAPIUserNonceCallback nonce; try { nonce = await Steam.Instance.User.RequestWebAPIUserNonce(); } catch (Exception e) { IsAuthorized = false; Log.WriteWarn("WebAuth", "Failed to get nonce: {0}", e.Message); return(false); } // 32 byte random blob of data var sessionKey = CryptoHelper.GenerateRandomBlock(32); byte[] encryptedSessionKey; // ... which is then encrypted with RSA using the Steam system's public key using (var rsa = new RSACrypto(KeyDictionary.GetPublicKey(Steam.Instance.Client.Universe))) { encryptedSessionKey = rsa.Encrypt(sessionKey); } // users hashed loginkey, AES encrypted with the sessionkey var encryptedLoginKey = CryptoHelper.SymmetricEncrypt(Encoding.ASCII.GetBytes(nonce.Nonce), sessionKey); using (dynamic userAuth = WebAPI.GetAsyncInterface("ISteamUserAuth")) { KeyValue result; try { result = await userAuth.AuthenticateUser( steamid : Steam.Instance.Client.SteamID.ConvertToUInt64(), sessionkey : WebHelpers.UrlEncode(encryptedSessionKey), encrypted_loginkey : WebHelpers.UrlEncode(encryptedLoginKey), method : "POST", secure : true ); } catch (HttpRequestException e) { IsAuthorized = false; Log.WriteWarn("WebAuth", "Failed to authenticate: {0}", e.Message); return(false); } File.WriteAllText(Path.Combine(Application.Path, "files", ".support", "cookie.txt"), $"steamLogin={result["token"].AsString()}; steamLoginSecure={result["tokensecure"].AsString()}"); Cookies = new CookieContainer(); Cookies.Add(new Cookie("steamLogin", result["token"].AsString(), "/", "store.steampowered.com")); Cookies.Add(new Cookie("steamLoginSecure", result["tokensecure"].AsString(), "/", "store.steampowered.com")); } IsAuthorized = true; Log.WriteInfo("WebAuth", "Authenticated"); if (!Settings.IsFullRun) { await AccountInfo.RefreshAppsToIdle(); } return(true); }
public void WebAPIAsyncHasDefaultTimeout() { var iface = WebAPI.GetAsyncInterface(new Uri("https://whatever/"), "ISteamWhatever"); Assert.Equal(iface.Timeout, TimeSpan.FromSeconds(100)); }
private async Task SearchWorkshop(CommandContext ctx, string SearchQuery, int gameid) { await ctx.RespondAsync("Querying workshop... (This might take a minute)"); using (dynamic SteamWorkshopQuery = WebAPI.GetAsyncInterface("IPublishedFileService", SettingsFile.steamwebapikey)) { SteamWorkshopQuery.Timeout = TimeSpan.FromSeconds(5); var searchResultIDList = new List <string>(); int totalSearchResults = 0; string next_cursor = ""; KeyValue kvResults = await SteamWorkshopQuery.QueryFiles( query_type : 0, cursor : "*", appid : gameid, search_text : SearchQuery, method : HttpMethod.Get ); // Get the total search results foreach (var child in kvResults.Children) { if (child.Name == "total") { totalSearchResults = Int32.Parse(child.Value); break; } } // Clamp results if (totalSearchResults > 5) { totalSearchResults = 5; } while (searchResultIDList.Count < totalSearchResults) { foreach (var child in kvResults.Children) { if (child.Name == "publishedfiledetails") { foreach (var child2 in child.Children) { foreach (var child3 in child2.Children) { if (child3.Name == "publishedfileid") { if (!searchResultIDList.Contains(child3.Value)) { searchResultIDList.Add(child3.Value); } } } } } if (child.Name == "next_cursor") { next_cursor = child.Value; } } kvResults = await SteamWorkshopQuery.QueryFiles( query_type : 0, appid : gameid, cursor : next_cursor, search_text : SearchQuery, method : HttpMethod.Get ); } var listresults = await SteamWorkshopModule.GetPublishedFileDetails(searchResultIDList); var embed = new DiscordEmbedBuilder { Title = $"`{SearchQuery}` search results", Color = new DiscordColor(0x171A21) }; foreach (var workshopitem in listresults) { if (gameid == 730 && workshopitem.FileURL == null) { continue; } embed.AddField($"{workshopitem.Title}", $"https://steamcommunity.com/sharedfiles/filedetails/?id={workshopitem.PublishedFileID}"); } await ctx.RespondAsync(embed : embed); } }
static public async Task <List <WorkshopReturnInformation> > GetPublishedFileDetails(List <string> itemids) { var kvlist = new List <KeyValue>(); using (dynamic SteamPublishedFileDetails = WebAPI.GetAsyncInterface("ISteamRemoteStorage")) { var basedict = new Dictionary <string, object> { ["itemcount"] = 1, ["method"] = HttpMethod.Post, ["publishedfileids[0]"] = "" }; foreach (var itemid in itemids) { basedict["publishedfileids[0]"] = itemid; try { KeyValue kvResults = await SteamPublishedFileDetails.GetPublishedFileDetails(basedict); kvlist.Add(kvResults); } catch (Exception ex) { Console.WriteLine(ex.Message); return(null); } } } // Parse out the information we want var returninfo = new List <WorkshopReturnInformation>(); foreach (var kvitem in kvlist) { foreach (var child in kvitem.Children) { foreach (var child2 in child.Children) { if (child2.Name == "0") { var thisreturninfo = new WorkshopReturnInformation(); foreach (var child3 in child2.Children) { switch (child3.Name) { case "publishedfileid": thisreturninfo.PublishedFileID = child3.Value; break; case "creator": thisreturninfo.CreatorID = child3.Value; break; case "file_url": thisreturninfo.FileURL = child3.Value; break; case "preview_url": thisreturninfo.PreviewURL = child3.Value; break; case "title": thisreturninfo.Title = child3.Value; break; case "description": thisreturninfo.Description = child3.Value; break; case "time_created": thisreturninfo.TimeCreated = Int64.Parse(child3.Value); break; case "time_updated": thisreturninfo.TimeCreated = Int64.Parse(child3.Value); break; case "filename": thisreturninfo.Filename = child3.Value; break; default: break; } } returninfo.Add(thisreturninfo); } } } } return(returninfo); }
/// <summary> /// 重新获取新 Cookies,如果是第一次调用本方法,会同时启用定时检测计时器 /// </summary> public async Task Refresh() { if (!_checkTimer.Enabled) { _logger.Info($"#{BotSequenceNumber} Cookies check timer started."); _checkTimer.Start(); } if (string.IsNullOrWhiteSpace(WebApiUserNonce)) { return; } // generate an AES session key var sessionKey = CryptoHelper.GenerateRandomBlock(32); // RSA encrypt it with the public key for the universe we're on byte[] encryptedSessionKey; using (var rsa = new RSACrypto(KeyDictionary.GetPublicKey(ConnectedUniverse))) { encryptedSessionKey = rsa.Encrypt(sessionKey); } var loginKey = new byte[20]; Array.Copy(Encoding.ASCII.GetBytes(WebApiUserNonce), loginKey, WebApiUserNonce.Length); // AES encrypt the loginkey with our session key var encryptedLoginKey = CryptoHelper.SymmetricEncrypt(loginKey, sessionKey); try { await _retryPolicy.ExecuteAsync(async() => { using (dynamic userAuth = WebAPI.GetAsyncInterface("ISteamUserAuth")) { KeyValue authResult = await userAuth.AuthenticateUser(steamid: SteamId.ConvertToUInt64(), sessionkey: HttpUtility.UrlEncode(encryptedSessionKey), encrypted_loginkey: HttpUtility.UrlEncode(encryptedLoginKey), method: "POST", secure: true); _cookieContainer.Add(new Cookie("sessionid", Convert.ToBase64String(Encoding.UTF8.GetBytes(LoginKeyUniqueId.ToString())), string.Empty, "steamcommunity.com")); _cookieContainer.Add(new Cookie("steamLogin", authResult["token"].AsString(), string.Empty, "steamcommunity.com")); _cookieContainer.Add(new Cookie("steamLoginSecure", authResult["tokensecure"].AsString(), string.Empty, "steamcommunity.com")); _logger.Info($"#{BotSequenceNumber} Cookies refreshed."); } }); } catch (Exception e) { _logger.Warn($"#{BotSequenceNumber} Cookies refresh failed.", e); } }