public void InstancedSet(AccountId accountId, uint unInstance, EUniverse eUniverse, EAccountType eAccountType)
{
SetAccountId(accountId);
SetEUniverse(eUniverse);
SetEAccountType(eAccountType);
SetAccountInstance(unInstance);
}
public static byte[] GetPublicKey( EUniverse eUniverse )
{
if ( keys.ContainsKey( eUniverse ) )
return keys[ eUniverse ];
return keys[ EUniverse.Invalid ];
}
public void InstancedSet( UInt32 unAccountID, UInt32 unInstance, EUniverse eUniverse, EAccountType eAccountType )
{
this.AccountID = unAccountID;
this.AccountUniverse = eUniverse;
this.AccountType = eAccountType;
this.AccountInstance = unInstance;
}
public void UnknownAccountUniversesAreInvalid(EUniverse universe)
{
SteamID sid = 76561198074261126;
sid.AccountUniverse = universe;
Assert.False(sid.IsValid);
}
/// <summary>
/// Sets the various components of this SteamID from a Steam2 "STEAM_" rendered form and universe.
/// </summary>
/// <param name="steamId">A "STEAM_" rendered form of the SteamID.</param>
/// <param name="eUniverse">The universe the SteamID belongs to.</param>
/// <returns><c>true</c> if this instance was successfully assigned; otherwise, <c>false</c> if the given string was in an invalid format.</returns>
public bool SetFromString(string steamId, EUniverse eUniverse)
{
if (string.IsNullOrEmpty(steamId))
{
return(false);
}
Match m = Steam2Regex.Match(steamId);
if (!m.Success)
{
return(false);
}
uint accId, authServer;
if (!uint.TryParse(m.Groups["accountid"].Value, out accId) ||
!uint.TryParse(m.Groups["authserver"].Value, out authServer))
{
return(false);
}
this.AccountUniverse = eUniverse;
this.AccountInstance = 1;
this.AccountType = EAccountType.Individual;
this.AccountID = (accId << 1) | authServer;
return(true);
}
/// <summary>
/// Sets the various components of this SteamID instance.
/// </summary>
/// <param name="unAccountID">The account ID.</param>
/// <param name="unInstance">The instance.</param>
/// <param name="eUniverse">The universe.</param>
/// <param name="eAccountType">The account type.</param>
public void InstancedSet(UInt32 unAccountID, UInt32 unInstance, EUniverse eUniverse, EAccountType eAccountType)
{
this.AccountID = unAccountID;
this.AccountUniverse = eUniverse;
this.AccountType = eAccountType;
this.AccountInstance = unInstance;
}
public void KnownAccountUniversesAreValid(EUniverse universe)
{
SteamID sid = 76561198074261126;
sid.AccountUniverse = universe;
Assert.True(sid.IsValid);
}
public CSteamID(AccountID_t unAccountID, uint unAccountInstance, EUniverse eUniverse, EAccountType eAccountType) {
m_SteamID = 0;
#if _SERVER && Assert
Assert( ! ( ( EAccountType.k_EAccountTypeIndividual == eAccountType ) && ( unAccountInstance > k_unSteamUserWebInstance ) ) ); // enforce that for individual accounts, instance is always 1
#endif // _SERVER
InstancedSet(unAccountID, unAccountInstance, eUniverse, eAccountType);
}
public void CreateBlankAnonUserLogon(EUniverse eUniverse)
{
SetAccountID(new AccountID_t(0));
SetEUniverse(eUniverse);
SetEAccountType(EAccountType.k_EAccountTypeAnonUser);
SetAccountInstance(0);
}
public void CreateBlankAnonLogon(EUniverse eUniverse)
{
this.SetAccountID(new AccountID_t(0u));
this.SetEUniverse(eUniverse);
this.SetEAccountType(EAccountType.k_EAccountTypeAnonGameServer);
this.SetAccountInstance(0u);
}
public void InstancedSet(AccountID_t unAccountID, uint unInstance, EUniverse eUniverse, EAccountType eAccountType)
{
SetAccountID(unAccountID);
SetEUniverse(eUniverse);
SetEAccountType(eAccountType);
SetAccountInstance(unInstance);
}
public void CreateBlankAnonLogon(EUniverse eUniverse)
{
SetAccountId(new AccountId(0));
SetEUniverse(eUniverse);
SetEAccountType(EAccountType.AnonGameServer);
SetAccountInstance(0);
}
public SteamId(AccountId accountId, uint unAccountInstance, EUniverse eUniverse, EAccountType eAccountType)
{
Id = 0;
#if _SERVER && Assert
Assert(!((EAccountType.Individual == eAccountType) && (unAccountInstance > SteamUserWebInstance))); // enforce that for individual accounts, instance is always 1
#endif // _SERVER
InstancedSet(accountId, unAccountInstance, eUniverse, eAccountType);
}
public EnvelopeEncryptedConnection(IConnection inner, EUniverse universe)
{
this.inner = inner ?? throw new ArgumentNullException(nameof(inner));
this.universe = universe;
inner.NetMsgReceived += OnNetMsgReceived;
inner.Connected += OnConnected;
inner.Disconnected += OnDisconnected;
}
public static byte[] GetPublicKey(EUniverse eUniverse)
{
if (keys.ContainsKey(eUniverse))
{
return(keys[eUniverse]);
}
return(keys[EUniverse.Invalid]);
}
/// <summary>
/// Gets the public key for the given universe.
/// </summary>
/// <returns>The public key.</returns>
/// <param name="eUniverse">The universe.</param>
public static byte[]? GetPublicKey(EUniverse eUniverse)
{
if (keys.TryGetValue(eUniverse, out var key))
{
return(key);
}
return(keys[EUniverse.Invalid]);
}
public EnvelopeEncryptedConnection( IConnection inner, EUniverse universe, ILogContext log, IDebugNetworkListener? debugNetworkListener )
{
this.inner = inner ?? throw new ArgumentNullException( nameof(inner) );
this.universe = universe;
this.log = log ?? throw new ArgumentNullException( nameof( log ) );
this.debugNetworkListener = debugNetworkListener;
inner.NetMsgReceived += OnNetMsgReceived;
inner.Connected += OnConnected;
inner.Disconnected += OnDisconnected;
}
public void Set(AccountID_t unAccountID, EUniverse eUniverse, EAccountType eAccountType) {
SetAccountID(unAccountID);
SetEUniverse(eUniverse);
SetEAccountType(eAccountType);
if (eAccountType == EAccountType.k_EAccountTypeClan || eAccountType == EAccountType.k_EAccountTypeGameServer) {
SetAccountInstance(0);
}
else {
SetAccountInstance(Constants.k_unSteamUserDefaultInstance);
}
}
// Token: 0x060000BA RID: 186 RVA: 0x00002767 File Offset: 0x00000967
public void Set(AccountID_t unAccountID, EUniverse eUniverse, EAccountType eAccountType)
{
SetAccountID(unAccountID);
SetEUniverse(eUniverse);
SetEAccountType(eAccountType);
if (eAccountType == EAccountType.k_EAccountTypeClan || eAccountType == EAccountType.k_EAccountTypeGameServer)
{
SetAccountInstance(0u);
return;
}
SetAccountInstance(1u);
}
public void Set(AccountID_t unAccountID, EUniverse eUniverse, EAccountType eAccountType)
{
this.SetAccountID(unAccountID);
this.SetEUniverse(eUniverse);
this.SetEAccountType(eAccountType);
if (eAccountType == EAccountType.k_EAccountTypeClan || eAccountType == EAccountType.k_EAccountTypeGameServer)
{
this.SetAccountInstance(0u);
}
else
{
this.SetAccountInstance(1u);
}
}
/// <summary>
/// Sets the various components of this SteamID instance.
/// </summary>
/// <param name="unAccountID">The account ID.</param>
/// <param name="eUniverse">The universe.</param>
/// <param name="eAccountType">The account type.</param>
public void Set(UInt32 unAccountID, EUniverse eUniverse, EAccountType eAccountType)
{
this.AccountID = unAccountID;
this.AccountUniverse = eUniverse;
this.AccountType = eAccountType;
if (eAccountType == EAccountType.Clan || eAccountType == EAccountType.GameServer)
{
this.AccountInstance = 0;
}
else
{
this.AccountInstance = DesktopInstance;
}
}
public void Set(UInt32 unAccountID, EUniverse eUniverse, EAccountType eAccountType)
{
this.AccountID = unAccountID;
this.AccountUniverse = eUniverse;
this.AccountType = eAccountType;
if (eAccountType == EAccountType.k_EAccountTypeClan)
{
this.AccountInstance = 0;
}
else
{
this.AccountInstance = 1;
}
}
public void Set( UInt32 unAccountID, EUniverse eUniverse, EAccountType eAccountType )
{
this.AccountID = unAccountID;
this.AccountUniverse = eUniverse;
this.AccountType = eAccountType;
if ( eAccountType == EAccountType.k_EAccountTypeClan )
{
this.AccountInstance = 0;
}
else
{
this.AccountInstance = 1;
}
}
public void Set(AccountId accountId, EUniverse eUniverse, EAccountType eAccountType)
{
SetAccountId(accountId);
SetEUniverse(eUniverse);
SetEAccountType(eAccountType);
if (eAccountType == EAccountType.Clan || eAccountType == EAccountType.GameServer)
{
SetAccountInstance(0);
}
else
{
// by default we pick the desktop instance
SetAccountInstance(Constants.SteamUserDesktopInstance);
}
}
public void ParseFromBuffer(BinaryReader reader)
{
if (_headerType != null)
{
// Version and universe are not present
// on pure binary VDF files e.g coplay, so only read them here
Version = reader.ReadUInt32();
UniverseType = (EUniverse)reader.ReadUInt32();
// Ensure there is a supported version for the type
if (!SupportedVersionMappings.Select(t => t.Key == _headerType && t.Value == Version).Any())
{
throw new InvalidOperationException($"Unsupported binary VDF version: {Version}");
}
while (reader.BaseStream.Position != reader.BaseStream.Length)
{
// If we have a terminator with 0 (for appinfo.vdf)
// or -1 (for packageinfo.vdf), no more sections to read
var terminator = reader.ReadUInt32();
if (_headerType == typeof(BinaryVdfAppHeader) &&
terminator == BinaryVdfAppHeader.Terminator)
{
break;
}
if (_headerType == typeof(BinaryVdfPackageHeader) &&
terminator == BinaryVdfPackageHeader.Terminator)
{
break;
}
// Rewind stream after peek
reader.BaseStream.Position = reader.BaseStream.Position - sizeof(uint);
// Create the node instance
var node = (IBinaryParseable)Activator.CreateInstance(_headerType);
node.ParseFromBuffer(reader);
Add(node);
}
}
else
{
// No header type? Skip this entirely and parse raw keyvalues1.
Add(KvSerializer.Create(KvSerializationFormat.KeyValues1Binary).Deserialize(new NonClosingStream(reader.BaseStream)));
}
}
void HandleEncryptRequest(IPacketMsg packetMsg)
{
var encRequest = new Msg <MsgChannelEncryptRequest>(packetMsg);
EUniverse eUniv = encRequest.Body.Universe;
uint protoVersion = encRequest.Body.ProtocolVersion;
DebugLog.WriteLine("CMClient", "Got encryption request. Universe: {0} Protocol ver: {1}", eUniv, protoVersion);
DebugLog.Assert(protoVersion == 1, "CMClient", "Encryption handshake protocol version mismatch!");
byte[] pubKey = KeyDictionary.GetPublicKey(eUniv);
if (pubKey == null)
{
DebugLog.WriteLine("CMClient", "HandleEncryptionRequest got request for invalid universe! Universe: {0} Protocol ver: {1}", eUniv, protoVersion);
return;
}
ConnectedUniverse = eUniv;
var encResp = new Msg <MsgChannelEncryptResponse>();
tempSessionKey = CryptoHelper.GenerateRandomBlock(32);
byte[] cryptedSessKey = null;
using (var rsa = new RSACrypto(pubKey))
{
cryptedSessKey = rsa.Encrypt(tempSessionKey);
}
byte[] keyCrc = CryptoHelper.CRCHash(cryptedSessKey);
encResp.Write(cryptedSessKey);
encResp.Write(keyCrc);
encResp.Write(( uint )0);
this.Send(encResp);
}
/// <summary>
/// Sets the various components of this SteamID from a Steam2 "STEAM_" rendered form and universe.
/// </summary>
/// <param name="steamId">A "STEAM_" rendered form of the SteamID.</param>
/// <param name="eUniverse">The universe the SteamID belongs to.</param>
/// <returns><c>true</c> if this instance was successfully assigned; otherwise, <c>false</c> if the given string was in an invalid format.</returns>
public bool SetFromString( string steamId, EUniverse eUniverse )
{
if ( string.IsNullOrEmpty( steamId ) )
return false;
Match m = SteamIDRegex.Match( steamId );
if ( !m.Success )
return false;
uint accId, authServer;
if ( !uint.TryParse( m.Groups[ "accountid" ].Value, out accId ) ||
!uint.TryParse( m.Groups[ "authserver" ].Value, out authServer ) )
return false;
this.AccountUniverse = eUniverse;
this.AccountInstance = 1;
this.AccountType = EAccountType.Individual;
this.AccountID = ( accId << 1 ) | authServer;
return true;
}
/// <summary>
/// Initializes a new instance of the <see cref="SteamID"/> class from a Steam2 "STEAM_" rendered form and universe.
/// </summary>
/// <param name="steamId">A "STEAM_" rendered form of the SteamID.</param>
/// <param name="eUniverse">The universe the SteamID belongs to.</param>
public SteamID( string steamId, EUniverse eUniverse )
: this()
{
SetFromString( steamId, eUniverse );
}
/// <summary>
/// Initializes a new instance of the <see cref="SteamID"/> class.
/// </summary>
/// <param name="unAccountID">The account ID.</param>
/// <param name="unInstance">The instance.</param>
/// <param name="eUniverse">The universe.</param>
/// <param name="eAccountType">The account type.</param>
public SteamID( UInt32 unAccountID, UInt32 unInstance, EUniverse eUniverse, EAccountType eAccountType )
: this()
{
InstancedSet( unAccountID, unInstance, eUniverse, eAccountType );
}
/// <summary>
/// Initializes a new instance of the <see cref="SteamID"/> class.
/// </summary>
/// <param name="unAccountID">The account ID.</param>
/// <param name="eUniverse">The universe.</param>
/// <param name="eAccountType">The account type.</param>
public SteamID( UInt32 unAccountID, EUniverse eUniverse, EAccountType eAccountType )
: this()
{
Set( unAccountID, eUniverse, eAccountType );
}
bool HandleEncryptRequest(IPacketMsg packetMsg)
{
var encRequest = new Msg <MsgChannelEncryptRequest>(packetMsg);
EUniverse eUniv = encRequest.Body.Universe;
uint protoVersion = encRequest.Body.ProtocolVersion;
DebugLog.WriteLine("CMClient", "Got encryption request. Universe: {0} Protocol ver: {1}", eUniv, protoVersion);
DebugLog.Assert(protoVersion == 1, "CMClient", "Encryption handshake protocol version mismatch!");
byte[] randomChallenge;
if (encRequest.Payload.Length >= 16)
{
randomChallenge = encRequest.Payload.ToArray();
}
else
{
randomChallenge = null;
}
byte[] pubKey = KeyDictionary.GetPublicKey(eUniv);
if (pubKey == null)
{
connection.Disconnect();
DebugLog.WriteLine("CMClient", "HandleEncryptionRequest got request for invalid universe! Universe: {0} Protocol ver: {1}", eUniv, protoVersion);
return(false);
}
ConnectedUniverse = eUniv;
var encResp = new Msg <MsgChannelEncryptResponse>();
var tempSessionKey = CryptoHelper.GenerateRandomBlock(32);
byte[] encryptedHandshakeBlob = null;
using (var rsa = new RSACrypto(pubKey))
{
if (randomChallenge != null)
{
var blobToEncrypt = new byte[tempSessionKey.Length + randomChallenge.Length];
Array.Copy(tempSessionKey, blobToEncrypt, tempSessionKey.Length);
Array.Copy(randomChallenge, 0, blobToEncrypt, tempSessionKey.Length, randomChallenge.Length);
encryptedHandshakeBlob = rsa.Encrypt(blobToEncrypt);
}
else
{
encryptedHandshakeBlob = rsa.Encrypt(tempSessionKey);
}
}
var keyCrc = CryptoHelper.CRCHash(encryptedHandshakeBlob);
encResp.Write(encryptedHandshakeBlob);
encResp.Write(keyCrc);
encResp.Write(( uint )0);
if (randomChallenge != null)
{
pendingNetFilterEncryption = new NetFilterEncryptionWithHMAC(tempSessionKey);
}
else
{
pendingNetFilterEncryption = new NetFilterEncryption(tempSessionKey);
}
this.Send(encResp);
return(true);
}
internal async Task<bool> Init(ulong steamID, EUniverse universe, string webAPIUserNonce, string parentalPin) {
if ((steamID == 0) || (universe == EUniverse.Invalid) || string.IsNullOrEmpty(webAPIUserNonce) || string.IsNullOrEmpty(parentalPin)) {
Bot.ArchiLogger.LogNullError(nameof(steamID) + " || " + nameof(universe) + " || " + nameof(webAPIUserNonce) + " || " + nameof(parentalPin));
return false;
}
SteamID = steamID;
string sessionID = Convert.ToBase64String(Encoding.UTF8.GetBytes(steamID.ToString()));
// Generate an AES session key
byte[] sessionKey = SteamKit2.CryptoHelper.GenerateRandomBlock(32);
// RSA encrypt it with the public key for the universe we're on
byte[] cryptedSessionKey;
using (RSACrypto rsa = new RSACrypto(KeyDictionary.GetPublicKey(universe))) {
cryptedSessionKey = rsa.Encrypt(sessionKey);
}
// Copy our login key
byte[] loginKey = new byte[webAPIUserNonce.Length];
Array.Copy(Encoding.ASCII.GetBytes(webAPIUserNonce), loginKey, webAPIUserNonce.Length);
// AES encrypt the loginkey with our session key
byte[] cryptedLoginKey = SteamKit2.CryptoHelper.SymmetricEncrypt(loginKey, sessionKey);
// Do the magic
Bot.ArchiLogger.LogGenericInfo("Logging in to ISteamUserAuth...");
KeyValue authResult;
using (dynamic iSteamUserAuth = WebAPI.GetInterface("ISteamUserAuth")) {
iSteamUserAuth.Timeout = Timeout;
try {
authResult = iSteamUserAuth.AuthenticateUser(steamid: steamID, sessionkey: Encoding.ASCII.GetString(WebUtility.UrlEncodeToBytes(cryptedSessionKey, 0, cryptedSessionKey.Length)), encrypted_loginkey: Encoding.ASCII.GetString(WebUtility.UrlEncodeToBytes(cryptedLoginKey, 0, cryptedLoginKey.Length)), method: WebRequestMethods.Http.Post, secure: !Program.GlobalConfig.ForceHttp);
} catch (Exception e) {
Bot.ArchiLogger.LogGenericException(e);
return false;
}
}
if (authResult == null) {
Bot.ArchiLogger.LogNullError(nameof(authResult));
return false;
}
string steamLogin = authResult["token"].Value;
if (string.IsNullOrEmpty(steamLogin)) {
Bot.ArchiLogger.LogNullError(nameof(steamLogin));
return false;
}
string steamLoginSecure = authResult["tokensecure"].Value;
if (string.IsNullOrEmpty(steamLoginSecure)) {
Bot.ArchiLogger.LogNullError(nameof(steamLoginSecure));
return false;
}
WebBrowser.CookieContainer.Add(new Cookie("sessionid", sessionID, "/", "." + SteamCommunityHost));
WebBrowser.CookieContainer.Add(new Cookie("sessionid", sessionID, "/", "." + SteamStoreHost));
WebBrowser.CookieContainer.Add(new Cookie("steamLogin", steamLogin, "/", "." + SteamCommunityHost));
WebBrowser.CookieContainer.Add(new Cookie("steamLogin", steamLogin, "/", "." + SteamStoreHost));
WebBrowser.CookieContainer.Add(new Cookie("steamLoginSecure", steamLoginSecure, "/", "." + SteamCommunityHost));
WebBrowser.CookieContainer.Add(new Cookie("steamLoginSecure", steamLoginSecure, "/", "." + SteamStoreHost));
Bot.ArchiLogger.LogGenericInfo("Success!");
// Unlock Steam Parental if needed
if (!parentalPin.Equals("0")) {
if (!await UnlockParentalAccount(parentalPin).ConfigureAwait(false)) {
return false;
}
}
Ready = true;
LastSessionRefreshCheck = DateTime.Now;
return true;
}
/// <summary>
/// Initializes a new instance of the <see cref="SteamID"/> class from a Steam2 "STEAM_" rendered form and universe.
/// </summary>
/// <param name="steamId">A "STEAM_" rendered form of the SteamID.</param>
/// <param name="eUniverse">The universe the SteamID belongs to.</param>
public SteamID(string steamId, EUniverse eUniverse)
: this()
{
SetFromString(steamId, eUniverse);
}
public void SetEUniverse(EUniverse other)
{
m_SteamID = (m_SteamID & ~(0xFFul << (ushort)56)) | (((ulong)(other) & 0xFFul) << (ushort)56);
}
public CSteamID(AccountID_t unAccountID, EUniverse eUniverse, EAccountType eAccountType)
{
m_SteamID = 0;
Set(unAccountID, eUniverse, eAccountType);
}
public ISteamConfigurationBuilder WithUniverse(EUniverse universe)
{
state.Universe = universe;
return(this);
}
public MsgChannelEncryptRequest()
{
ProtocolVersion = MsgChannelEncryptRequest.PROTOCOL_VERSION;
Universe = EUniverse.Invalid;
}
public void Deserialize( Stream stream )
{
BinaryReader br = new BinaryReader( stream );
ProtocolVersion = br.ReadUInt32();
Universe = (EUniverse)br.ReadInt32();
}
/// <summary>
/// Sets the various components of this SteamID instance.
/// </summary>
/// <param name="unAccountID">The account ID.</param>
/// <param name="eUniverse">The universe.</param>
/// <param name="eAccountType">The account type.</param>
public void Set( UInt32 unAccountID, EUniverse eUniverse, EAccountType eAccountType )
{
this.AccountID = unAccountID;
this.AccountUniverse = eUniverse;
this.AccountType = eAccountType;
if ( eAccountType == EAccountType.Clan || eAccountType == EAccountType.GameServer )
{
this.AccountInstance = 0;
}
else
{
this.AccountInstance = DesktopInstance;
}
}
internal async Task <bool> Init(ulong steamID, EUniverse universe, string webAPIUserNonce, string parentalPin)
{
if ((steamID == 0) || (universe == EUniverse.Invalid) || string.IsNullOrEmpty(webAPIUserNonce) || string.IsNullOrEmpty(parentalPin))
{
Logging.LogNullError(nameof(steamID) + " || " + nameof(universe) + " || " + nameof(webAPIUserNonce) + " || " + nameof(parentalPin), Bot.BotName);
return(false);
}
SteamID = steamID;
string sessionID = Convert.ToBase64String(Encoding.UTF8.GetBytes(steamID.ToString()));
// Generate an AES session key
byte[] sessionKey = SteamKit2.CryptoHelper.GenerateRandomBlock(32);
// RSA encrypt it with the public key for the universe we're on
byte[] cryptedSessionKey;
using (RSACrypto rsa = new RSACrypto(KeyDictionary.GetPublicKey(universe))) {
cryptedSessionKey = rsa.Encrypt(sessionKey);
}
// Copy our login key
byte[] loginKey = new byte[webAPIUserNonce.Length];
Array.Copy(Encoding.ASCII.GetBytes(webAPIUserNonce), loginKey, webAPIUserNonce.Length);
// AES encrypt the loginkey with our session key
byte[] cryptedLoginKey = SteamKit2.CryptoHelper.SymmetricEncrypt(loginKey, sessionKey);
// Do the magic
Logging.LogGenericInfo("Logging in to ISteamUserAuth...", Bot.BotName);
KeyValue authResult;
using (dynamic iSteamUserAuth = WebAPI.GetInterface("ISteamUserAuth")) {
iSteamUserAuth.Timeout = Timeout;
try {
authResult = iSteamUserAuth.AuthenticateUser(
steamid: steamID,
sessionkey: Encoding.ASCII.GetString(WebUtility.UrlEncodeToBytes(cryptedSessionKey, 0, cryptedSessionKey.Length)),
encrypted_loginkey: Encoding.ASCII.GetString(WebUtility.UrlEncodeToBytes(cryptedLoginKey, 0, cryptedLoginKey.Length)),
method: WebRequestMethods.Http.Post,
secure: !Program.GlobalConfig.ForceHttp
);
} catch (Exception e) {
Logging.LogGenericException(e, Bot.BotName);
return(false);
}
}
if (authResult == null)
{
Logging.LogNullError(nameof(authResult), Bot.BotName);
return(false);
}
string steamLogin = authResult["token"].Value;
if (string.IsNullOrEmpty(steamLogin))
{
Logging.LogNullError(nameof(steamLogin), Bot.BotName);
return(false);
}
string steamLoginSecure = authResult["tokensecure"].Value;
if (string.IsNullOrEmpty(steamLoginSecure))
{
Logging.LogNullError(nameof(steamLoginSecure), Bot.BotName);
return(false);
}
WebBrowser.CookieContainer.Add(new Cookie("sessionid", sessionID, "/", "." + SteamCommunityHost));
WebBrowser.CookieContainer.Add(new Cookie("steamLogin", steamLogin, "/", "." + SteamCommunityHost));
WebBrowser.CookieContainer.Add(new Cookie("steamLoginSecure", steamLoginSecure, "/", "." + SteamCommunityHost));
Logging.LogGenericInfo("Success!", Bot.BotName);
// Unlock Steam Parental if needed
if (!parentalPin.Equals("0"))
{
if (!await UnlockParentalAccount(parentalPin).ConfigureAwait(false))
{
return(false);
}
}
Ready = true;
LastSessionRefreshCheck = DateTime.Now;
return(true);
}
internal FriendMsgHistoryCallback( CMsgClientFSGetFriendMessageHistoryResponse msg, EUniverse universe )
{
Result = ( EResult )msg.success;
SteamID = msg.steamid;
var messages = msg.messages
.Select( m =>
{
SteamID senderID = new SteamID( m.accountid, universe, EAccountType.Individual );
DateTime timestamp = DateUtils.DateTimeFromUnixTime( m.timestamp );
return new FriendMessage( senderID, m.unread, m.message, timestamp );
}
)
.ToList();
Messages = new ReadOnlyCollection<FriendMessage>( messages );
}
/// <summary>
/// Initializes a new instance of the <see cref="SteamID"/> class.
/// </summary>
/// <param name="unAccountID">The account ID.</param>
/// <param name="unInstance">The instance.</param>
/// <param name="eUniverse">The universe.</param>
/// <param name="eAccountType">The account type.</param>
public SteamID(UInt32 unAccountID, UInt32 unInstance, EUniverse eUniverse, EAccountType eAccountType)
: this()
{
InstancedSet(unAccountID, unInstance, eUniverse, eAccountType);
}
