private void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { byte[] hash = default; using (var sha = SHA1.Create()) { hash = sha.ComputeHash(callback.Data); } _authenticationProvider.SaveSentryFileContent(Credentials, callback.Data); _steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = callback.Data.Length, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = hash }); }
private void _onUpdateMachineAuthCallback(SteamUser.UpdateMachineAuthCallback machineAuth) { byte[] hash = _sec_SHAHash(machineAuth.Data); Directory.CreateDirectory(Path.Combine(Application.StartupPath, "sentryfiles")); File.WriteAllBytes(Path.Combine("sentryfiles", string.Format( "{0}.sentryfile", logOnDetails.Username)), machineAuth.Data); var authResponse = new SteamUser.MachineAuthDetails { BytesWritten = machineAuth.BytesToWrite, FileName = machineAuth.FileName, FileSize = machineAuth.BytesToWrite, Offset = machineAuth.Offset, SentryFileHash = hash, // should be the sha1 hash of the sentry file we just wrote OneTimePassword = machineAuth.OneTimePassword, // not sure on this one yet, since we've had no examples of steam using OTPs LastError = 0, // result from win32 GetLastError Result = EResult.OK, // if everything went okay, otherwise ~who knows~ JobID = machineAuth.JobID, // so we respond to the correct server job }; // send off our response SteamUser.SendMachineAuthResponse(authResponse); Log.Debug("Sent Machine AUTH response."); }
} // Wird gecalled wenn wir ausgelogged werden static void UpdateMachineAuthCallback(SteamUser.UpdateMachineAuthCallback callback) { Console.Clear(); Console.Title = "Steam Bot - Updating Account Information"; Console.WriteLine("(STEAM GUARD) Updating Sentry File...", Color.SkyBlue); byte[] sentryHash = CryptoHelper.SHAHash(callback.Data); File.WriteAllBytes("sentry.bin", callback.Data); steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = callback.Data.Length, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash, }); Console.WriteLine("(STEAM GUARD) Done!", Color.SkyBlue); Console.Clear(); } // Wird gecalled wenn wir das erste mal Steam Guard authentifizieren
public void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { _log.Debug("Updating Steam sentry file..."); if (_sentry.Save(callback.Offset, callback.Data, callback.BytesToWrite, out var hash, out var size)) { _steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = size, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = hash }); _log.Information("Successfully updated Steam sentry file."); }
//We give it the OnMachineAuth class, named callback. This is so that we can interact with the callback. Performing specific actions. //First we need to include SystemIO //Now, what we need to do is create the function that handles the UpdateMachineAuthCallback static void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback, JobID jobID) { //inform the user we are updating the sentry file. //The sentry file is a special file steam uses to verify whether or not you are authorized. Console.WriteLine("Updating sentry file..."); //What we need to do is grab the hash of the data steam sends back //This data is what Steam sends to be put into a sentry file byte[] sentryHash = CryptoHelper.SHAHash(callback.Data); //Now, we write all the data that Steam sent to us to our new sentry file File.WriteAllBytes("sentry.bin", callback.Data); //Now we need to inform Steam that we are connecting to a Steam Guard protected account, and have the correct sentry data steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = jobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = callback.Data.Length, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash, }); //Inform the user the process is complete Console.WriteLine("Done."); //Refer to OnConnected steamUser.Logon, adding authcode and sentry hash }
private static void OnUpdateMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { Log.Instance.Debug("New sentry: " + callback.FileName + ". Writing file..."); int fileSize; using (var fs = File.Open(username + "/" + username + ".sentry", FileMode.OpenOrCreate, FileAccess.ReadWrite)) { fs.Seek(callback.Offset, SeekOrigin.Begin); fs.Write(callback.Data, 0, callback.BytesToWrite); fileSize = (int)fs.Length; fs.Seek(0, SeekOrigin.Begin); using (var sha = new SHA1CryptoServiceProvider()) { sentryHash = sha.ComputeHash(fs); } } steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = fileSize, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash }); Log.Instance.Verbose("Sent sentry response!"); }
static void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { Console.WriteLine("Updating sentryfile..."); byte[] sentryHash = CryptoHelper.SHAHash(callback.Data); // write out our sentry file // ideally we'd want to write to the filename specified in the callback // but then this sample would require more code to find the correct sentry file to read during logon // for the sake of simplicity, we'll just use "sentry.bin" File.WriteAllBytes("sentry.bin", callback.Data); // inform the steam servers that we're accepting this sentry file steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = callback.Data.Length, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash, }); Console.WriteLine("Done!"); }
void OnUpdateMachineAuthCallback(SteamUser.UpdateMachineAuthCallback machineAuth) { byte[] hash = SHAHash(machineAuth.Data); Directory.CreateDirectory(System.IO.Path.Combine(System.Windows.Forms.Application.StartupPath, "sentryfiles")); File.WriteAllBytes(System.IO.Path.Combine("sentryfiles", String.Format("{0}.sentryfile", logon.Username)), machineAuth.Data); var authResponse = new SteamUser.MachineAuthDetails { BytesWritten = machineAuth.BytesToWrite, FileName = machineAuth.FileName, FileSize = machineAuth.BytesToWrite, Offset = machineAuth.Offset, SentryFileHash = hash, OneTimePassword = machineAuth.OneTimePassword, LastError = 0, Result = EResult.OK, JobID = machineAuth.JobID, }; // send off our response user.SendMachineAuthResponse(authResponse); }
private void UpdateMachineAuthCallback(SteamUser.UpdateMachineAuthCallback machineAuth) { byte[] hash = Util.SHAHash(machineAuth.Data); Log.Info("Got Machine Auth: {0} {1} {2} {3}", machineAuth.FileName, machineAuth.Offset, machineAuth.BytesToWrite, machineAuth.Data.Length, hash); AccountSettingsStore.Instance.SentryData[logonDetails.Username] = machineAuth.Data; AccountSettingsStore.Save(); var authResponse = new SteamUser.MachineAuthDetails { BytesWritten = machineAuth.BytesToWrite, FileName = machineAuth.FileName, FileSize = machineAuth.BytesToWrite, Offset = machineAuth.Offset, SentryFileHash = hash, // should be the sha1 hash of the sentry file we just wrote OneTimePassword = machineAuth.OneTimePassword, // not sure on this one yet, since we've had no examples of steam using OTPs LastError = 0, // result from win32 GetLastError Result = EResult.OK, // if everything went okay, otherwise ~who knows~ JobID = machineAuth.JobID, // so we respond to the correct server job }; // send off our response steamUser.SendMachineAuthResponse(authResponse); }
void OnUpdateMachineAuthCallback(SteamUser.UpdateMachineAuthCallback machineAuth, JobID jobId) { byte[] hash = SHAHash(machineAuth.Data); File.WriteAllBytes(String.Format("{0}.sentryfile", logOnDetails.Username), machineAuth.Data); var authResponse = new SteamUser.MachineAuthDetails { BytesWritten = machineAuth.BytesToWrite, FileName = machineAuth.FileName, FileSize = machineAuth.BytesToWrite, Offset = machineAuth.Offset, SentryFileHash = hash, // should be the sha1 hash of the sentry file we just wrote OneTimePassword = machineAuth.OneTimePassword, // not sure on this one yet, since we've had no examples of steam using OTPs LastError = 0, // result from win32 GetLastError Result = EResult.OK, // if everything went okay, otherwise ~who knows~ JobID = jobId, // so we respond to the correct server job }; // send off our response SteamUser.SendMachineAuthResponse(authResponse); }
static void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback, JobID jobId) { Console.WriteLine("Updating sentryfile..."); byte[] sentryHash = CryptoHelper.SHAHash(callback.Data); File.WriteAllBytes("sentry.bin", callback.Data); steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = jobId, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = callback.Data.Length, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash, }); Console.WriteLine("Done!"); }
internal async void OnMachinAuth(SteamUser.UpdateMachineAuthCallback callback) { Log("Updating sentry file", LogType.Info); int fileSize; byte[] sentryHash; string Path = System.IO.Path.Combine(SMAForm.BotsData, BotName + ".bin"); using (var fs = File.Open(Path, FileMode.OpenOrCreate, FileAccess.ReadWrite)) { fs.Seek(callback.Offset, SeekOrigin.Begin); fs.Write(callback.Data, 0, callback.BytesToWrite); fileSize = (int)fs.Length; fs.Seek(0, SeekOrigin.Begin); using (var sha = new SHA1CryptoServiceProvider()) { sentryHash = sha.ComputeHash(fs); } } steamUser.SendMachineAuthResponse( new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = fileSize, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash }); Log("Updating successfully", LogType.Info); }
void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { if (callback == null) { return; } int fileSize; byte[] sentryHash; using (var fs = File.Open(sentryFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite)) { fs.Seek(callback.Offset, SeekOrigin.Begin); fs.Write(callback.Data, 0, callback.BytesToWrite); fileSize = (int)fs.Length; fs.Seek(0, SeekOrigin.Begin); using (var sha = new SHA1CryptoServiceProvider()) sentryHash = sha.ComputeHash(fs); } steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = fileSize, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash, }); }
static void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { Console.WriteLine("[" + Program.BOTNAME + "] - Updating sentryfile..."); byte[] sentryHash = CryptoHelper.SHAHash(callback.Data); File.WriteAllBytes(Program.SentryFolder + user + ".bin", callback.Data); steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = callback.Data.Length, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash, }); Console.WriteLine("[" + Program.BOTNAME + "] - Sentry updated!"); }
private void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { if (callback == null) { return; } int fileSize; String SentryFilePath = "sentry.bin"; try { using (FileStream fileStream = File.Open(SentryFilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite)) { fileStream.Seek(callback.Offset, SeekOrigin.Begin); fileStream.Write(callback.Data, 0, callback.BytesToWrite); fileSize = (int)fileStream.Length; fileStream.Seek(0, SeekOrigin.Begin); using (SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider()) { sentryHash = sha.ComputeHash(fileStream); } } } catch (Exception) { try { File.Delete(SentryFilePath); } catch { // Ignored, we can only try to delete faulted file at best } return; } // Inform the steam servers that we're accepting this sentry file steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = fileSize, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash }); }
protected void OnUpdateMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { sentry.Write(callback.Offset, callback.Data, callback.BytesToWrite); steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = sentry.Length, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentry.Hash }); }
static void UpdateMachineAuthCallBack(SteamUser.UpdateMachineAuthCallback callback) { byte[] sentryHash = CryptoHelper.SHAHash(callback.Data); File.WriteAllBytes("sentry.bin", callback.Data); steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = callback.Data.Length, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash, JobID = callback.JobID }); }
static void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { Console.WriteLine("Updating sentryfile..."); // write out our sentry file // ideally we'd want to write to the filename specified in the callback // but then this sample would require more code to find the correct sentry file to read during logon // for the sake of simplicity, we'll just use "sentry.bin" int fileSize; byte[] sentryHash; using (var fs = File.Open("sentry.bin", FileMode.OpenOrCreate, FileAccess.ReadWrite)) { fs.Seek(callback.Offset, SeekOrigin.Begin); fs.Write(callback.Data, 0, callback.BytesToWrite); fileSize = (int)fs.Length; fs.Seek(0, SeekOrigin.Begin); using (var sha = new SHA1CryptoServiceProvider()) { sentryHash = sha.ComputeHash(fs); } } // inform the steam servers that we're accepting this sentry file steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = fileSize, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash, }); Console.WriteLine("Done!"); }
private void OnUpdateMachineAuth(SteamUser.UpdateMachineAuthCallback updateMachineAuthCallback) { try { int fileSize; byte[] sentryHash; using ( var fs = File.Open( Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "data", $"{LogOnDetails.Username}.sfh"), FileMode.OpenOrCreate, FileAccess.ReadWrite)) { fs.Seek(updateMachineAuthCallback.Offset, SeekOrigin.Begin); fs.Write(updateMachineAuthCallback.Data, 0, updateMachineAuthCallback.BytesToWrite); fileSize = (int)fs.Length; fs.Seek(0, SeekOrigin.Begin); using (var sha = SHA1.Create()) { sentryHash = sha.ComputeHash(fs); } } LogOnDetails.SentryFileHash = sentryHash; _logger.Info($"#{SequenceNumber} Sentry file hash saved to {LogOnDetails.Username}.sfh."); _steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = updateMachineAuthCallback.JobID, FileName = updateMachineAuthCallback.FileName, BytesWritten = updateMachineAuthCallback.BytesToWrite, FileSize = fileSize, Offset = updateMachineAuthCallback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = updateMachineAuthCallback.OneTimePassword, SentryFileHash = sentryHash }); } catch (Exception e) { _logger.Fatal($"#{SequenceNumber} Fatal unhandled exception (OnUpdateMachineAuth) : {e.Message}"); Restart(); } }
/// <summary> /// Authorize the PC/Machine for this account, so we do not have to enter the authcode on every login /// </summary> /// <param name="_callback"></param> private void OnMachineAuth(SteamUser.UpdateMachineAuthCallback _callback) { m_logger.Info("Updateing sentryfile..."); // variables we need later in another scope int fileSize; byte[] sentryHash; // Create a filestream to a file named like the current bots username // With this filestream get all the info we got from the "_callback" // Calculate the Hashvalue of the info inside the filestream using (FileStream filestream = File.Open($"Files/Authfiles/{m_steamUserLogonDetails.Username}.sentryfile", FileMode.OpenOrCreate, FileAccess.ReadWrite)) { filestream.Seek(_callback.Offset, SeekOrigin.Begin); filestream.Write(_callback.Data, 0, _callback.BytesToWrite); fileSize = (int)filestream.Length; filestream.Seek(0, SeekOrigin.Begin); using (SHA1CryptoServiceProvider shaHash = new SHA1CryptoServiceProvider()) { sentryHash = shaHash.ComputeHash(filestream); } } // We have obtained the filesize and the Hashvalue of the given Data // The left info we need, we are going to get from the "_callback" object // If we were successful, the PC is now authorized m_steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { Result = EResult.OK, Offset = _callback.Offset, BytesWritten = _callback.BytesToWrite, FileName = _callback.FileName, FileSize = fileSize, JobID = _callback.JobID, LastError = 0, OneTimePassword = _callback.OneTimePassword, SentryFileHash = sentryHash }); m_logger.Info("Done updating sentryfile!"); }
void OnMachineAuth(SteamUser.UpdateMachineAuthCallback cb) { Log.WriteLine("Updating sentryfile..."); string sentry_name = String.Format("sentry_{0}.bin", username); int fileSize; byte[] sentryHash; using (var fs = File.Open(sentry_name, FileMode.OpenOrCreate, FileAccess.ReadWrite)) { fs.Seek(cb.Offset, SeekOrigin.Begin); fs.Write(cb.Data, 0, cb.BytesToWrite); fileSize = (int)fs.Length; fs.Seek(0, SeekOrigin.Begin); using (var sha = SHA1.Create()) { sentryHash = sha.ComputeHash(fs); } } // inform the steam servers that we're accepting this sentry file steam_user.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = cb.JobID, FileName = cb.FileName, BytesWritten = cb.BytesToWrite, FileSize = fileSize, Offset = cb.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = cb.OneTimePassword, SentryFileHash = sentryHash, }); Log.WriteLine("Finished writing SentryFile..."); }
void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { // Console.WriteLine("Updating sentryfile..."); int fileSize; byte[] sentryHash; // using (var fs = File.Open(_steamAccount.UserName + "sentry.bin", FileMode.OpenOrCreate, FileAccess.ReadWrite)) using (var fs = new MemoryStream()) { fs.Seek(callback.Offset, SeekOrigin.Begin); fs.Write(callback.Data, 0, callback.BytesToWrite); fileSize = (int)fs.Length; fs.Seek(0, SeekOrigin.Begin); using (var sha = SHA1.Create()) { sentryHash = sha.ComputeHash(fs); _steamAccount.SentryHash = sentryHash; } } _sUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = fileSize, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash, }); //Console.WriteLine("Done!"); }
static void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { SimpleLogger.SimpleLog.Info("Updating sentryfile"); Console.WriteLine("Updating sentryfile..."); int fileSize; byte[] sentryHash; using (var fs = File.Open("sentry.bin", FileMode.OpenOrCreate, FileAccess.ReadWrite)) { fs.Seek(callback.Offset, SeekOrigin.Begin); fs.Write(callback.Data, 0, callback.BytesToWrite); fileSize = (int)fs.Length; fs.Seek(0, SeekOrigin.Begin); using (var sha = new SHA1CryptoServiceProvider()) { sentryHash = sha.ComputeHash(fs); } } steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = fileSize, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash, }); Console.WriteLine("Done!"); SimpleLogger.SimpleLog.Info("Updated sentryfile"); }
private void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { Console.WriteLine("Updating sentryfile..."); int fileSize; byte[] sentryHash; using (var fs = File.Open("sentry.bin", FileMode.OpenOrCreate, FileAccess.ReadWrite)) { fs.Seek(callback.Offset, SeekOrigin.Begin); fs.Write(callback.Data, 0, callback.BytesToWrite); fileSize = (int)fs.Length; fs.Seek(0, SeekOrigin.Begin); using (var sha = SHA1.Create()) { sentryHash = sha.ComputeHash(fs); } } // inform the steam servers that we're accepting this sentry file steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = fileSize, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash, }); Console.WriteLine("Done!"); }
private static void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { Log("Updating sentryfile so that you don't need to authenticate with SteamGuard next time."); var sentryHash = CryptoHelper.SHAHash(callback.Data); File.WriteAllBytes("sentry.bin", callback.Data); User.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = callback.Data.Length, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash, }); }
public void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { _log.Debug("Checking if a sentry file exists..."); var hash = _sentry.Save(callback.Offset, callback.Data, callback.BytesToWrite, out int size); _log.Debug("Successfully opened / created sentry file. Hash: {Hash}", Encoding.UTF8.GetString(hash)); _steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = size, Offset = callback.Offset, Result = hash.Length > 0 ? EResult.OK : EResult.Fail, LastError = hash.Length > 0 ? 0 : (int)EResult.Fail, OneTimePassword = callback.OneTimePassword, SentryFileHash = hash.Length > 0 ? hash : null }); }
private void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { if (callback == null) { return; } Logging.LogGenericInfo(BotName, "Updating sentryfile..."); int fileSize; byte[] sentryHash; using (FileStream fileStream = File.Open(SentryFile, FileMode.OpenOrCreate, FileAccess.ReadWrite)) { fileStream.Seek(callback.Offset, SeekOrigin.Begin); fileStream.Write(callback.Data, 0, callback.BytesToWrite); fileSize = (int)fileStream.Length; fileStream.Seek(0, SeekOrigin.Begin); using (SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider()) { sentryHash = sha.ComputeHash(fileStream); } } // Inform the steam servers that we're accepting this sentry file SteamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = callback.FileName, BytesWritten = callback.BytesToWrite, FileSize = fileSize, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash, }); Logging.LogGenericInfo(BotName, "Sentryfile updated successfully!"); }
private void OnSteamMachineAuth(SteamUser.UpdateMachineAuthCallback callback) { int fileSize; byte[] sentryHash; Settings.Default.SentryFileLocation = callback.FileName; Settings.Default.Save(); using (var fs = File.Open(Settings.Default.SentryFileLocation, FileMode.OpenOrCreate, FileAccess.ReadWrite)) { fs.Seek(callback.Offset, SeekOrigin.Begin); fs.Write(callback.Data, 0, callback.BytesToWrite); fileSize = (int)fs.Length; fs.Seek(0, SeekOrigin.Begin); using (var sha = new SHA1CryptoServiceProvider()) { sentryHash = sha.ComputeHash(fs); } } // inform the steam servers that we're accepting this sentry file m_steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = callback.JobID, FileName = Settings.Default.SentryFileLocation, BytesWritten = callback.BytesToWrite, FileSize = fileSize, Offset = callback.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = callback.OneTimePassword, SentryFileHash = sentryHash, }); }
private void OnMachineAuth(SteamUser.UpdateMachineAuthCallback obj) { Logger.Log24Bit(ConsoleSwatch.XTermColor.Pink, false, Console.Out, string.Empty, "Updating sentry file... "); int fileSize; byte[] sentryHash; using (var fs = File.Open("sentry.bin", FileMode.OpenOrCreate, FileAccess.ReadWrite)) { fs.Seek(obj.Offset, SeekOrigin.Begin); fs.Write(obj.Data, 0, obj.BytesToWrite); fileSize = (int)fs.Length; fs.Seek(0, SeekOrigin.Begin); using (var sha = SHA1.Create()) { sentryHash = sha.ComputeHash(fs); } } // inform the steam servers that we're accepting this sentry file User.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = obj.JobID, FileName = obj.FileName, BytesWritten = obj.BytesToWrite, FileSize = fileSize, Offset = obj.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = obj.OneTimePassword, SentryFileHash = sentryHash }); Logger.Log24Bit(ConsoleSwatch.XTermColor.Pink, true, Console.Out, string.Empty, "Done!"); }
public void HandleMachineAuthCallback(SteamUser user, SteamUser.UpdateMachineAuthCallback obj) { int fileSize; byte[] sentryHash; using (var fs = Sentry.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite)) { fs.Seek(obj.Offset, SeekOrigin.Begin); fs.Write(obj.Data, 0, obj.BytesToWrite); fileSize = (int)fs.Length; fs.Seek(0, SeekOrigin.Begin); using (var sha = SHA1.Create()) { sentryHash = sha.ComputeHash(fs); } } // inform the steam servers that we're accepting this sentry file user.SendMachineAuthResponse(new SteamUser.MachineAuthDetails { JobID = obj.JobID, FileName = obj.FileName, BytesWritten = obj.BytesToWrite, FileSize = fileSize, Offset = obj.Offset, Result = EResult.OK, LastError = 0, OneTimePassword = obj.OneTimePassword, SentryFileHash = sentryHash, }); }