| public static SymmetricEncrypt ( byte input, byte key ) : byte[] | ||
| input | byte | |
| key | byte | |
| return | byte[] | |
/// <summary>
/// Authenticate a CDNClient to a depot in the connected session
/// </summary>
/// <param name="depotid">The id of the depot being accessed.</param>
/// <param name="depotKey">
/// The optional depot decryption key for the depot that will be downloaded.
/// This is used for decrypting filenames (if needed) in depot manifests, and processing depot chunks.
/// </param>
/// <param name="cdnAuthToken">CDN auth token for CDN content server endpoints.</param>
/// <exception cref="HttpRequestException">An network error occurred when performing the request.</exception>
/// <exception cref="SteamKitWebRequestException">A network error occurred when performing the request.</exception>
public async Task AuthenticateDepotAsync(uint depotid, byte[] depotKey = null, string cdnAuthToken = null)
{
if (depotIds.ContainsKey(depotid))
{
return;
}
string data;
if (connectedServer.Type != "CDN" || cdnAuthToken == null)
{
if (appTicket == null)
{
data = string.Format("depotid={0}", depotid);
}
else
{
byte[] encryptedAppTicket = CryptoHelper.SymmetricEncrypt(appTicket, sessionKey);
data = string.Format("appticket={0}", WebHelpers.UrlEncode(encryptedAppTicket));
}
await DoCommandAsync(connectedServer, HttpMethod.Post, "authdepot", data, doAuth : true).ConfigureAwait(false);
}
depotIds[depotid] = true;
depotKeys[depotid] = depotKey;
depotCdnAuthKeys[depotid] = cdnAuthToken;
}
/// <summary>
/// Authenticate a CDNClient to a depot in the connected session
/// </summary>
/// <param name="depotid">The id of the depot being accessed.</param>
/// <param name="depotKey">
/// The optional depot decryption key for the depot that will be downloaded.
/// This is used for decrypting filenames (if needed) in depot manifests, and processing depot chunks.
/// </param>
/// <param name="cdnAuthToken">CDN auth token for CDN content server endpoints.</param>
public void AuthenticateDepot(uint depotid, byte[] depotKey = null, string cdnAuthToken = null)
{
if (depotIds.ContainsKey(depotid))
{
return;
}
string data;
if (connectedServer.Type != "CDN" || cdnAuthToken == null)
{
if (appTicket == null)
{
data = string.Format("depotid={0}", depotid);
}
else
{
byte[] encryptedAppTicket = CryptoHelper.SymmetricEncrypt(appTicket, sessionKey);
data = string.Format("appticket={0}", WebHelpers.UrlEncode(encryptedAppTicket));
}
DoCommand(connectedServer, "authdepot", data, WebRequestMethods.Http.Post, true);
}
depotIds[depotid] = true;
depotKeys[depotid] = depotKey;
depotCdnAuthKeys[depotid] = cdnAuthToken;
}
/// <summary>
/// Connects this instance to the server.
/// </summary>
/// <returns><c>true</c> if the connection was a success; otherwise, <c>false</c>.</returns>
public bool Connect()
{
byte[] encryptedKey = null;
// TODO: handle other universes?
byte[] universeKey = KeyDictionary.GetPublicKey(EUniverse.Public);
using (var rsa = new RSACrypto(universeKey))
{
encryptedKey = rsa.Encrypt(sessionKey);
}
string payload;
if (appTicket == null)
{
payload = String.Format("sessionkey={0}&anonymoususer=1&steamid={1}", WebHelpers.UrlEncode(encryptedKey), steamID.ConvertToUInt64());
}
else
{
byte[] encryptedTicket = CryptoHelper.SymmetricEncrypt(appTicket, sessionKey);
payload = String.Format("sessionkey={0}&appticket={1}", WebHelpers.UrlEncode(encryptedKey), WebHelpers.UrlEncode(encryptedTicket));
}
webClient.Headers.Clear();
webClient.Headers.Add("Content-Type", "application/x-www-form-urlencoded");
string response;
try
{
response = webClient.UploadString(BuildCommand(endPoint, "initsession"), payload);
}
catch (WebException e)
{
LogWebException("Connect", e);
return(false);
}
var responsekv = KeyValue.LoadFromString(response);
var sessionidn = responsekv.Children.Where(c => c.Name == "sessionid").First();
var reqcountern = responsekv.Children.Where(c => c.Name == "req-counter").First();
sessionID = (ulong)(sessionidn.AsLong(0));
reqcounter = reqcountern.AsLong(0);
try
{
AuthDepot();
}
catch (WebException e)
{
LogWebException("AuthDepot", e);
return(false);
}
return(true);
}
private void AuthDepot()
{
Uri authURI = BuildCommand(endPoint, "authdepot");
PrepareAuthHeader(ref webClient, authURI);
webClient.Headers.Add("Content-Type", "application/x-www-form-urlencoded");
byte[] encryptedTicket = CryptoHelper.SymmetricEncrypt(appTicket, sessionKey);
string payload = String.Format("appticket={0}", WebHelpers.UrlEncode(encryptedTicket));
string response = webClient.UploadString(authURI, payload);
}
void OnLoginKey(SteamUser.LoginKeyCallback callback)
{
string SessionID = WebHelpers.EncodeBase64(callback.UniqueID.ToString());
using (dynamic userAuth = WebAPI.GetInterface("ISteamUserAuth"))
{
// generate an AES session key
var sessionKey = CryptoHelper.GenerateRandomBlock(32);
// rsa encrypt it with the public key for the universe we're on
byte[] cryptedSessionKey = null;
using (var rsa = new RSACrypto(KeyDictionary.GetPublicKey(Client.ConnectedUniverse)))
{
cryptedSessionKey = rsa.Encrypt(sessionKey);
}
byte[] loginKey = new byte[20];
Array.Copy(Encoding.ASCII.GetBytes(callback.LoginKey), loginKey, callback.LoginKey.Length);
// AES encrypt the loginkey with our session key.
byte[] cryptedLoginKey = CryptoHelper.SymmetricEncrypt(loginKey, sessionKey);
KeyValue authResult = null;
EResult result = EResult.OK;
try
{
authResult = userAuth.AuthenticateUser(
steamid: Client.SteamID.ConvertToUInt64(),
sessionkey: WebHelpers.UrlEncode(cryptedSessionKey),
encrypted_loginkey: WebHelpers.UrlEncode(cryptedLoginKey),
method: "POST"
);
}
catch (Exception)
{
result = EResult.Fail;
}
Login.SessionId = SessionID;
if (authResult != null)
{
Login.Token = authResult["token"].AsString();
}
this.Client.PostCallback(new WebLoggedOnCallback()
{
Result = result,
Login = Login
});
}
}
/// <summary>
/// Connects and authenticates to the specified content server.
/// </summary>
/// <param name="csServer">The content server to connect to.</param>
/// <exception cref="System.ArgumentNullException">csServer was null.</exception>
public void Connect(Server csServer)
{
DebugLog.Assert(steamClient.IsConnected, "CDNClient", "CMClient is not connected!");
if (csServer == null)
{
throw new ArgumentNullException("csServer");
}
byte[] pubKey = KeyDictionary.GetPublicKey(steamClient.ConnectedUniverse);
sessionKey = CryptoHelper.GenerateRandomBlock(32);
byte[] cryptedSessKey = null;
using (var rsa = new RSACrypto(pubKey))
{
cryptedSessKey = rsa.Encrypt(sessionKey);
}
string data;
if (appTicket == null)
{
// no appticket, doing anonymous connection
data = string.Format("sessionkey={0}&anonymoususer=1&steamid={1}", WebHelpers.UrlEncode(cryptedSessKey), steamClient.SteamID.ConvertToUInt64());
}
else
{
byte[] encryptedAppTicket = CryptoHelper.SymmetricEncrypt(appTicket, sessionKey);
data = string.Format("sessionkey={0}&appticket={1}", WebHelpers.UrlEncode(cryptedSessKey), WebHelpers.UrlEncode(encryptedAppTicket));
}
KeyValue initKv = DoCommand(csServer, "initsession", data, WebRequestMethods.Http.Post);
sessionId = ( ulong )initKv["sessionid"].AsLong();
reqCounter = initKv["req-counter"].AsLong();
if (appTicket == null)
{
data = string.Format("depotid={0}", depotId);
}
else
{
byte[] encryptedAppTicket = CryptoHelper.SymmetricEncrypt(appTicket, sessionKey);
data = string.Format("appticket={0}", WebHelpers.UrlEncode(encryptedAppTicket));
}
DoCommand(csServer, "authdepot", data, WebRequestMethods.Http.Post, true);
connectedServer = csServer;
}
/// <summary>
/// Connects and initializes a session to the specified content server.
/// </summary>
/// <param name="csServer">The content server to connect to.</param>
/// <exception cref="System.ArgumentNullException">csServer was null.</exception>
/// <exception cref="HttpRequestException">An network error occurred when performing the request.</exception>
/// <exception cref="SteamKitWebRequestException">A network error occurred when performing the request.</exception>
public async Task ConnectAsync(Server csServer)
{
DebugLog.Assert(steamClient.IsConnected, "CDNClient", "CMClient is not connected!");
if (csServer == null)
{
throw new ArgumentNullException(nameof(csServer));
}
// Nothing needs to be done to initialize a session to a CDN server
if (csServer.Type == "CDN")
{
connectedServer = csServer;
return;
}
byte[] pubKey = KeyDictionary.GetPublicKey(steamClient.Universe);
sessionKey = CryptoHelper.GenerateRandomBlock(32);
byte[] cryptedSessKey = null;
using (var rsa = new RSACrypto(pubKey))
{
cryptedSessKey = rsa.Encrypt(sessionKey);
}
string data;
if (appTicket == null)
{
// no appticket, doing anonymous connection
data = string.Format("sessionkey={0}&anonymoususer=1&steamid={1}", WebHelpers.UrlEncode(cryptedSessKey), steamClient.SteamID.ConvertToUInt64());
}
else
{
byte[] encryptedAppTicket = CryptoHelper.SymmetricEncrypt(appTicket, sessionKey);
data = string.Format("sessionkey={0}&appticket={1}", WebHelpers.UrlEncode(cryptedSessKey), WebHelpers.UrlEncode(encryptedAppTicket));
}
var initKv = await DoCommandAsync(csServer, HttpMethod.Post, "initsession", data).ConfigureAwait(false);
sessionId = initKv["sessionid"].AsUnsignedLong();
reqCounter = initKv["req-counter"].AsLong();
connectedServer = csServer;
}
public byte[] ProcessOutgoing(byte[] ms)
{
return(CryptoHelper.SymmetricEncrypt(ms, sessionKey));
}
