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);
}
private void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback)
{
Log.WriteInfo("Steam", "Updating sentry file...");
byte[] sentryHash = CryptoHelper.SHAHash(callback.Data);
if (callback.Data.Length != callback.BytesToWrite)
{
ErrorReporter.Notify(new InvalidDataException(string.Format("Data.Length ({0}) != BytesToWrite ({1}) in OnMachineAuth", callback.Data.Length, callback.BytesToWrite)));
}
using (var file = File.OpenWrite(SentryFile))
{
file.Seek(callback.Offset, SeekOrigin.Begin);
file.Write(callback.Data, 0, callback.BytesToWrite);
}
Steam.Instance.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
});
}
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.");
}
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", 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);
}
private void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback)
{
// Write sentry hash
int fileSize;
byte[] sentryHash;
using (var file = File.Open("sentryhash", FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
file.Seek(callback.Offset, SeekOrigin.Begin);
file.Write(callback.Data, 0, callback.BytesToWrite);
fileSize = (int)file.Length;
file.Seek(0, SeekOrigin.Begin);
using (var hash = new SHA1CryptoServiceProvider())
sentryHash = hash.ComputeHash(file);
}
// Tell Steam we're accepting the sentry file
kraxbot.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
});
}
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,
});
}
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!");
}
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.");
}
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);
}
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
});
}
//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
}
public static void WriteSentryFile(SteamUser.UpdateMachineAuthCallback data, string username)
{
EnsureDirectoryExists();
var filePath = Path.Combine("sentry", $"sentry_{username}");
int fileSize;
using (var file = File.Open(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
file.Seek(data.Offset, SeekOrigin.Begin);
file.Write(data.Data, 0, data.BytesToWrite);
fileSize = (int)file.Length;
}
var sentryHash = GetSentryHash(File.ReadAllBytes(filePath));
var user = Globals.SteamSession.Client.GetHandler <SteamUser>();
user.SendMachineAuthResponse(new SteamUser.MachineAuthDetails
{
JobID = data.JobID,
FileName = data.FileName,
BytesWritten = data.BytesToWrite,
FileSize = fileSize,
Offset = data.Offset,
Result = EResult.OK,
LastError = 0,
OneTimePassword = data.OneTimePassword,
SentryFileHash = sentryHash
});
}
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 OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback, JobID jobId)
{
Log.WriteInfo("Steam", "Updating sentry file...");
byte[] sentryHash = CryptoHelper.SHAHash(callback.Data);
File.WriteAllBytes("sentry.bin", callback.Data);
User.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
});
}
} // 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
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
});
}
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)
{
Log.WriteInfo("Steam", "Updating sentry file... {0}", callback.FileName);
if (callback.Data.Length != callback.BytesToWrite)
{
ErrorReporter.Notify(new InvalidDataException(string.Format("Data.Length ({0}) != BytesToWrite ({1}) in OnMachineAuth", callback.Data.Length, callback.BytesToWrite)));
}
int fileSize;
byte[] sentryHash;
using (var stream = new MemoryStream(LocalConfig.Sentry ?? new byte[callback.BytesToWrite]))
{
stream.Seek(callback.Offset, SeekOrigin.Begin);
stream.Write(callback.Data, 0, callback.BytesToWrite);
stream.Seek(0, SeekOrigin.Begin);
fileSize = (int)stream.Length;
using (var sha = new SHA1CryptoServiceProvider())
{
sentryHash = sha.ComputeHash(stream);
}
LocalConfig.Sentry = stream.ToArray();
}
LocalConfig.SentryFileName = callback.FileName;
LocalConfig.Save();
Steam.Instance.User.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
});
}
private 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
_steamNerd.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!");
}
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
});
}
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!");
}
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
});
}
