static UdpConnectionProviderTests()
{
var crypto = new RSACrypto();
serverKey = crypto.ExportKey (true);
crypto = new RSACrypto();
localKey = crypto.ExportKey (true);
}
private void buttonDecrypta_Click(object sender, EventArgs e)
{
try
{
var encryptedText = new RSACrypto().DecryptaData(textBoxText.Text, textBoxPrivateKey.Text);
textBoxText.Text = encryptedText;
}
catch (Exception)
{
MessageBox.Show("Failed decrypting");
}
}
public override void AddRecipes()
{
base.AddRecipes();
if (Loaded)
{
return;
}
//_messageChecker = new MessageChecker();
ShowTooltip = "";
_packetHandler = new PacketHandler();
_sscPacketHandler = new SSCPacketHandler();
if (!Main.dedServ)
{
// 加载资源只有在非服务器端才会执行
// MethodSwapper.SwapMethods();
MainPlayerGroup = new Group("default");
ToolBarServiceManager = new ToolBarServiceManager();
ResourceLoader.LoadAll();
GuiManager = new GUIManager(this);
IsLoginClientSide = false;
ClientUnion = null;
if (DEBUGMODE)
{
ClientUnion = new Union("裙中世界");
ClientUnion.Owner = "我不是裙子";
}
}
else
{
// 生成玩家存档，这里用json文件存储玩家信息
// 顺序一定不能错
PlayerCollection = new PlayerCollection();
PlayerDoc = new PlayersDocument("players.json");
PlayerDoc.ExtractPlayersData();
GroupManager = new GroupManager();
GroupManager.SetGroups();
UnionManager = new UnionManager();
RegionManager = new RegionManager();
MailManager = new MailManager();
// 服务器端生成RSA私钥
RSACrypto.GenKey();
ConfigLoader.Load();
MarketManager = new MarketManager();
MatchingSystem = new MatchingSystem();
AddUnionRegions();
}
Loaded = true;
if (!Main.dedServ)
{
GuiManager.SetNPCDefaults();
}
}
///<summary>
/// Authenticate using SteamKit2 and ISteamUserAuth.
/// This does the same as SteamWeb.DoLogin(), but without contacting the Steam Website.
/// </summary>
/// <remarks>Should this one doesnt work anymore, use <see cref="SteamWeb.DoLogin"/></remarks>
public bool Authenticate(string myUniqueId, SteamClient client, string myLoginKey)
{
Token = TokenSecure = "";
SessionId = Convert.ToBase64String(Encoding.UTF8.GetBytes(myUniqueId));
_cookies = new CookieContainer();
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 (RSACrypto rsa = new RSACrypto(KeyDictionary.GetPublicKey(client.ConnectedUniverse)))
{
cryptedSessionKey = rsa.Encrypt(sessionKey);
}
byte[] loginKey = new byte[20];
Array.Copy(Encoding.ASCII.GetBytes(myLoginKey), loginKey, myLoginKey.Length);
// aes encrypt the loginkey with our session key
byte[] cryptedLoginKey = CryptoHelper.SymmetricEncrypt(loginKey, sessionKey);
KeyValue authResult;
try
{
authResult = userAuth.AuthenticateUser(
steamid: client.SteamID.ConvertToUInt64(),
sessionkey: HttpUtility.UrlEncode(cryptedSessionKey),
encrypted_loginkey: HttpUtility.UrlEncode(cryptedLoginKey),
method: "POST",
secure: true
);
}
catch (Exception)
{
Token = TokenSecure = null;
return(false);
}
Token = authResult["token"].AsString();
TokenSecure = authResult["tokensecure"].AsString();
_cookies.Add(new Cookie("sessionid", SessionId, String.Empty, SteamCommunityDomain));
_cookies.Add(new Cookie("steamLogin", Token, String.Empty, SteamCommunityDomain));
_cookies.Add(new Cookie("steamLoginSecure", TokenSecure, String.Empty, SteamCommunityDomain));
return(true);
}
}
protected override void Recycle()
{
if (AutoSizeSendBufferLimit)
{
Interlocked.Add(ref sendBufferLimit, AutoSizeFactor * -1);
}
this.serverEncryption = null;
this.serverEncryptionKey = null;
this.serverAuthenticationKey = null;
base.Recycle();
}
private void DecryptButton_Click(object sender, RoutedEventArgs e)
{
if (ReceivedMessagesListView.SelectedItems.Count < 1)
{
MessageBox.Show("U have to select a message first!", "Warning!", MessageBoxButton.OK,
MessageBoxImage.Information);
}
else if (ReceivedMessagesListView.SelectedItems.Count > 1)
{
MessageBox.Show("U can only read one message!", "Warning!", MessageBoxButton.OK,
MessageBoxImage.Information);
}
else
{
MessageTextBlock.Visibility = Visibility.Visible;
this.Height = 600;
Message msg = (Message)ReceivedMessagesListView.SelectedItem;
var fromUserPuK = msg.From.PuK;
var currUserPvk = currUser.PvK;
var file1 = msg.File1;
var file2 = msg.File2;
var file3 = msg.File3;
var IV = msg.IV;
var key = RSACrypto.DecryptBytes(file2, currUserPvk);
MessageTextBlock.Text = "\n\n########AES KEY DECRYPT ########\n\n";
UnicodeEncoding _encoder = new UnicodeEncoding();
MessageTextBlock.Text += _encoder.GetString(key);
var message = AESCrypto.DecryptStringFromBytes(file1, key, IV);
MessageTextBlock.Text += "\n\n######## MESSAGE ########\n\n";
MessageTextBlock.Text += message;
var oldHash = RSACrypto.DecryptBytes(file3, currUserPvk);
string strOldHash = Encoding.UTF8.GetString(oldHash);
MessageTextBlock.Text += "\n\n######## Decrypted hash ########\n\n";
MessageTextBlock.Text += strOldHash;
if (BCrypt.CheckPassword(message, strOldHash))
{
MessageTextBlock.Text += "\n\n######## HASHES ARE EQUAL! ########\n\n";
}
else
{
MessageTextBlock.Text += "\n\n######## HASHES ARE NOT EQUAL! ########\n\n";
}
}
}
internal UdpServerConnection(int connectionId, EndPoint remoteEndpoint, UdpConnectionProvider provider, RSACrypto remoteCrypto, RSACrypto localCrypto, RSAAsymmetricKey key)
: base(provider.protocols.Values)
{
this.remoteCrypto = remoteCrypto;
this.localCrypto = localCrypto;
LocalKey = key;
ConnectionId = connectionId;
IPEndPoint = (IPEndPoint)remoteEndpoint;
RemoteTarget = remoteEndpoint.ToTarget();
this.provider = provider;
this.socket = this.provider.GetSocket (remoteEndpoint);
}
private void file_keys_rsa_Click(object sender, EventArgs e)
{
OpenFileDialog get_file = new OpenFileDialog();
string file_name = "";
if (get_file.ShowDialog() == DialogResult.OK)
{
file_name = get_file.FileName;
}
string[] keys = new string[6];
try
{
using (StreamReader sr = new StreamReader(file_name))
{
string line;
int count = 0;
while ((line = sr.ReadLine()) != null)
{
keys[count++] = line;
}
if (keys[3].Length <= 320)
{
key_size_rsa.Text = 1024.ToString();
size_rsa = 1024;
}
else
{
key_size_rsa.Text = 2048.ToString();
size_rsa = 2048;
}
P_RSA = BigInteger.Parse(keys[0]);
Q_RSA = BigInteger.Parse(keys[1]);
N = BigInteger.Parse(keys[2]);
PHI_N = BigInteger.Parse(keys[3]);
PK_RSA = BigInteger.Parse(keys[4]);
SK_RSA = BigInteger.Parse(keys[5]);
}
p_rsa.Text = P_RSA.ToString();
q_rsa.Text = Q_RSA.ToString();
n_rsa.Text = N.ToString();
phin_rsa.Text = PHI_N.ToString();
pk_rsa.Text = PK_RSA.ToString();
sk_rsa.Text = SK_RSA.ToString();
rsa = new RSACrypto(PK_RSA, N, PHI_N, SK_RSA, size_rsa);
}
catch
{
return;
}
}
private static void TestHabboEncryption(bool consoleOutput, int dhBitLength, int rsaBitLength)
{
RSACrypto serverRsa = new RSACrypto(RSACParameters.FromXmlFile(@"rsa.keys"));
DiffieHellman serverDh = DiffieHellman.CreateInstance(dhBitLength);
string serverDhPrimeRsa = signDiffieHellmanKeys(serverDh.P, serverRsa);
string serverDhGenRsa = signDiffieHellmanKeys(serverDh.G, serverRsa);
RSACrypto clientRsa = new RSACrypto(new RSACParameters(_modules, _exponent));
BigInteger clientDhPrime = verifyDiffieHellmanKeys(serverDhPrimeRsa, clientRsa);
BigInteger clientDhGen = verifyDiffieHellmanKeys(serverDhGenRsa, clientRsa);
DiffieHellman clientDh = new DiffieHellman(dhBitLength, clientDhPrime, clientDhGen);
if (!clientDh.P.Equals(serverDh.P))
{
throw new Exception("HabboEncryption test FAILED, P keys are not equal!");
}
if (!clientDh.G.Equals(serverDh.G))
{
throw new Exception("HabboEncryption test FAILED, G keys are not equal!");
}
string serverDhPublicRsa = signDiffieHellmanKeys(serverDh.PublicKey, serverRsa);
string clientDhPublicRsa = encryptDiffieHellmanKeys(clientDh.PublicKey, clientRsa);
BigInteger serverDhClientPublic = decryptDiffieHellmanKeys(clientDhPublicRsa, serverRsa);
BigInteger clientDhServerPublic = verifyDiffieHellmanKeys(serverDhPublicRsa, clientRsa);
if (!clientDhServerPublic.Equals(serverDh.PublicKey))
{
throw new Exception("HabboEncryption test FAILED, server -> client public keys are not equal!");
}
if (!serverDhClientPublic.Equals(clientDh.PublicKey))
{
throw new Exception("HabboEncryption test FAILED, server <- client public keys are not equal!");
}
BigInteger serverDhShared = serverDh.CalculateSharedKey(serverDhClientPublic);
BigInteger clientDhShared = clientDh.CalculateSharedKey(clientDhServerPublic);
if (!serverDhShared.Equals(clientDhShared))
{
throw new Exception("HabboEncryption test FAILED, shared keys are not equal!");
}
}
public SharePasswordController()
{
_repository = new PasswordJsonRepository(System.Web.HttpContext.Current);
if (System.Web.HttpContext.Current.Session["rsa"] == null)
{
_rsaCrypto = new RSACrypto();
System.Web.HttpContext.Current.Session["rsa"] = _rsaCrypto;
}
else
{
_rsaCrypto = (RSACrypto)System.Web.HttpContext.Current.Session["rsa"];
}
}
public string[] GetPublicKey()
{
RSACrypto crypto = new RSACrypto();
RSAItem item = new RSAItem();
string privateKey = "", publicKey = "";
crypto.CreateKeys(out privateKey, out publicKey);
item.PrivateKey = privateKey;
item.PublickKey = publicKey;
item.Guid = Guid.NewGuid().ToString();
item.CreateTime = DateTime.Now;
RedisHelper.Add(item.Guid, item);
string[] arry = new string[2];
arry[0] = item.Guid;
arry[1] = RSAConvert.PemPublicKeyByXml(item.PrivateKey);
return(arry);
}
public JsonResult Validate()
{
#region 公钥 私钥
//-----BEGIN PUBLIC KEY-----
//MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC4mZ8DLLwSMETsoQTKdu4efwhd
//fTY/rxhsGA5EittII0/SeDQlRC4IzpxzMTKQSMWvnRlvD7V4Z2u1KBGhE++i/T5K
//RdNCBXdo/G0pUdP2Nf4DpMP30HF54GwP8iZoXWVLy/tWtdZx9DUvajCn6GmgnjqK
//NPTiCQsARLvYAou18wIDAQAB
//-----END PUBLIC KEY-----
//-----BEGIN RSA PRIVATE KEY-----
//MIICXAIBAAKBgQC4mZ8DLLwSMETsoQTKdu4efwhdfTY/rxhsGA5EittII0/SeDQl
//RC4IzpxzMTKQSMWvnRlvD7V4Z2u1KBGhE++i/T5KRdNCBXdo/G0pUdP2Nf4DpMP3
//0HF54GwP8iZoXWVLy/tWtdZx9DUvajCn6GmgnjqKNPTiCQsARLvYAou18wIDAQAB
//AoGAHjwbDTwQebIqN8+Pp1GfYqNPzXAqqHeXOm0eOR+9Fq2h70j80XW/THX6retK
//6tLgfgjvF3+tK1FVFNDBQm6veuzRQjUO5JE0uRs4LSlRECa0ENxPgxFtELtTzRdJ
//u/KXY3DB+ke+RLG0azylcwGeCtNbijYEneCqpCK5Fpjh8yECQQC/YWl4VCbqAUKE
//GBipUdg9C8l/Aq/0H1vnS9jepvi5lYmSMNY60/r9h89qNbTB5FOn6LZC0n/TDmFL
//YSr1MTiZAkEA9u4e5i2lJUG4w5IQGRKDrAzmto9a0ooQatPKoW4XiEHmwnZWFTUD
//3eUc0IDlh+WYGi41Bg1+dzn9h0blq+Q+awJAR5Lo3QWr4AxEkh5o6rofQwVrgELD
//B2vK9T/ahbqwfse8QZ5eIHYzAiqOmcwoI/N+jedscqVDBO312Tkn1bdo0QJBAOQC
//HpAGh96uIBCeN7UfDmx5ATSDjKaqC9zIset7/8i2qYDYykYMzQRBAelZjBh/HYLX
//Nejf3u3yozMdeQfO2v8CQD/uSS5BeJerr4pnF4suTzaqpIW66D2HVI3JxssBJWwt
//fdVFi1a6EbZc0mHTzY/zLVX/ApTXbQZSFF/rwG0P8Dk=
//-----END RSA PRIVATE KEY-----
#endregion
string publicKey = @"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC4mZ8DLLwSMETsoQTKdu4efwhdfTY/rxhsGA5EittII0/SeDQlRC4IzpxzMTKQSMWvnRlvD7V4Z2u1KBGhE++i/T5KRdNCBXdo/G0pUdP2Nf4DpMP30HF54GwP8iZoXWVLy/tWtdZx9DUvajCn6GmgnjqKNPTiCQsARLvYAou18wIDAQAB";
string privateKey = @"MIICXAIBAAKBgQC4mZ8DLLwSMETsoQTKdu4efwhdfTY/rxhsGA5EittII0/SeDQlRC4IzpxzMTKQSMWvnRlvD7V4Z2u1KBGhE++i/T5KRdNCBXdo/G0pUdP2Nf4DpMP30HF54GwP8iZoXWVLy/tWtdZx9DUvajCn6GmgnjqKNPTiCQsARLvYAou18wIDAQABAoGAHjwbDTwQebIqN8+Pp1GfYqNPzXAqqHeXOm0eOR+9Fq2h70j80XW/THX6retK6tLgfgjvF3+tK1FVFNDBQm6veuzRQjUO5JE0uRs4LSlRECa0ENxPgxFtELtTzRdJu/KXY3DB+ke+RLG0azylcwGeCtNbijYEneCqpCK5Fpjh8yECQQC/YWl4VCbqAUKEGBipUdg9C8l/Aq/0H1vnS9jepvi5lYmSMNY60/r9h89qNbTB5FOn6LZC0n/TDmFLYSr1MTiZAkEA9u4e5i2lJUG4w5IQGRKDrAzmto9a0ooQatPKoW4XiEHmwnZWFTUD3eUc0IDlh+WYGi41Bg1+dzn9h0blq+Q+awJAR5Lo3QWr4AxEkh5o6rofQwVrgELDB2vK9T/ahbqwfse8QZ5eIHYzAiqOmcwoI/N+jedscqVDBO312Tkn1bdo0QJBAOQCHpAGh96uIBCeN7UfDmx5ATSDjKaqC9zIset7/8i2qYDYykYMzQRBAelZjBh/HYLXNejf3u3yozMdeQfO2v8CQD/uSS5BeJerr4pnF4suTzaqpIW66D2HVI3JxssBJWwtfdVFi1a6EbZc0mHTzY/zLVX/ApTXbQZSFF/rwG0P8Dk=";
RSACrypto rsaCrypto = new RSACrypto(privateKey, publicKey);
//获取参数
string usernameEncode = Request["username"];
string pwdEncode = Request["passwd"];
string name1 = CommonHelper.GetPostValue("username", 100, true, true, true);
string pwd2 = CommonHelper.GetPostValue("passwd", 100, true, true, true);
//解密 RSA
string username = rsaCrypto.Decrypt(usernameEncode);
string pwd = rsaCrypto.Decrypt(pwdEncode);
string username3 = rsaCrypto.Decrypt(name1);
string pwd3 = rsaCrypto.Decrypt(pwd2);
return(null);
}
public void Test()
{
using (var rsaCrypto = new RSACrypto())
{
rsaCrypto.Initialize(new Dictionary <string, object>
{
{ "Algorithm", "RSA" },
{ "PublicKey", "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQD2KXcCt30MrOOt4F1vhtfNViBGapFRmxaOnSVK9FMPV63Pr8Y3EzFpLFH58TzbNtwoB5aWRy4zjImbwsy5S2eqmSkJQWbWZiyxMLEYy1+dQDr27SihLp7BvrDUj8uy+LIO6fwCDMKJ2sQtXh+Uk6AO9meqdpA5riUEDVQKbpw6IQIDAQAB" },
{ "PrivateKey", "MIICXQIBAAKBgQD2KXcCt30MrOOt4F1vhtfNViBGapFRmxaOnSVK9FMPV63Pr8Y3EzFpLFH58TzbNtwoB5aWRy4zjImbwsy5S2eqmSkJQWbWZiyxMLEYy1+dQDr27SihLp7BvrDUj8uy+LIO6fwCDMKJ2sQtXh+Uk6AO9meqdpA5riUEDVQKbpw6IQIDAQABAoGBAL0EW+kPIgtgmjdCaByiKwT11DSd0dYawzhg/GjQsRK/3avzKb3SlAdRS+UjUvp05poqMXxVTemxSVz8OJ0zhHYePa+wE0E31sBfnMxpOo5LIraTQuKGhE5IXNgUB0xYyAkG4vLLmoGDFCUHWPHYw5591C66eNyhJMSkPcqSCbMNAkEA+8HXhp3Ut1LVqBFnSpUIoRkUfXotWvfJjat6GGtmyglSRqTcUkVwIlBabVEMDyoMS9/LQcXM2QQ3bJiTKpDY3wJBAPpPe8Tfjm2o1Oxz8aGjnt+u2b4SZ9WXXkbZY1qsMNAkrP7ZFF5MTIm9L18V+yrvZ0mU7YC5Mck+F5eEbIxOTP8CQQDf0X1i2H58XNBGEvLZg5WgY0OsKiqYbSJrKL/rZdCEXbUfyQF2wvTmDLnX5e3qrV8xNUzmtIthhDYh/aMYfJ3RAkAMy39SIvNO27B2nb6eOpTmbjOnKZ2xJ1mkWXxgqCiemyFUrZgC8fd/mvIO9DqwiShIdJpnWBAZb1kZX6WEzoPVAkAz0CHiCH5JGdf71zCifbfFfcXA9+IXqQxvU9+3yGLAQW1S7xd94f8uOX+CsWsUchOpwmgzXYpvMLEtu822WqfF" }
});
var plainText = "SmartSql";
var cipherText = rsaCrypto.Encrypt(plainText);
var decryptText = rsaCrypto.Decrypt(cipherText);
Assert.Equal(plainText, decryptText);
}
}
public async Task <IVRConfig> GetItemAsync()
{
IVRConfig config = await DataProvider.GetAsync(KEY);
if (config == null)
{
config = new IVRConfig();
string publicKey, privateKey;
RSACrypto.MakeNewKeys(out publicKey, out privateKey);
config.PrivateKey = privateKey;
config.PublicKey = publicKey;
await AddConfigAsync(config);
}
return(config);
}
public byte[] EnPwd_UTF8(List <byte[]> data)
{
string input_str = Encoding.UTF8.GetString(data[0]);
string public_key = Encoding.UTF8.GetString(data[1]);
try
{
RSACrypto rsaCrypto = new RSACrypto("", public_key);
// StartWith -----BEGIN PUBLIC KEY----- 216 EndWith -----END PUBLIC KEY-----
return(Encoding.UTF8.GetBytes(rsaCrypto.Encrypt(input_str)));
}
catch (Exception)
{
return(Encoding.UTF8.GetBytes(""));
}
}
///<summary>
/// Authenticate using SteamKit2 and ISteamUserAuth.
/// This does the same as SteamWeb.DoLogin(), but without contacting the Steam Website.
/// </summary>
/// <remarks>Should this one doesnt work anymore, use <see cref="SteamWeb.DoLogin"/></remarks>
public static bool Authenticate(SteamUser.LoginKeyCallback callback, SteamClient client, out string sessionId, out string token)
{
sessionId = Convert.ToBase64String(Encoding.UTF8.GetBytes(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 (RSACrypto 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;
try
{
authResult = userAuth.AuthenticateUser(
steamid: client.SteamID.ConvertToUInt64(),
sessionkey: HttpUtility.UrlEncode(cryptedSessionKey),
encrypted_loginkey: HttpUtility.UrlEncode(cryptedLoginKey),
method: "POST"
);
}
catch (Exception)
{
token = null;
return(false);
}
token = authResult ["token"].AsString();
return(true);
}
}
void Start()
{
RSACrypto.GenKey();
//Create a UnicodeEncoder to convert between byte array and string.
UnicodeEncoding ByteConverter = new UnicodeEncoding();
//Create byte arrays to hold original, encrypted, and decrypted data.
byte[] dataBytes = ByteConverter.GetBytes("Data to Encrypt,hahaha");
byte[] encryptedData;
byte[] decryptedData;
encryptedData = RSACrypto.RSAEncrypt(dataBytes, RSACrypto.m_publickey, false);
decryptedData = RSACrypto.RSADecrypt(encryptedData, RSACrypto.m_privateKey, false);
Debug.Log("message:" + ByteConverter.GetString(decryptedData));
}
public ActionResult Encrypt(string passwd)
{
string PrivateKey = @"-----BEGIN RSA PRIVATE KEY-----
MIICXQIBAAKBgQCZoXqoJktTWSTolirHAFpLdK3w1eaawiKu9q7VQeqghF7S90IJ
FKlawmuLhiEmrOLOqG0AYQOSdX0WSEcRlGH/VKwz5XNOsLutQWSfG2xt4bXT+nAm
qp/nWpeSlNuFYhsCWSjFydAtoUjLBXi0gusaBDpwfgq4zBGXAA7M3uVmTwIDAQAB
AoGBAIZ0khHJ+hDHKws4KdYik+QICReHTRzSnWI9WUQhPYQgdZDzf2LNJ27cSx1A
VZEwrAur0kILpgGvO7udpD1ZfO2Lg3lcBN+CVjp97oJPFCYQdD1yuRRjpvCsrLLu
zzfuSNatYbgS8lCh6HloSB7XThck8W6GbmNJsiYscn6GztUJAkEAvCeDzQKjZxvc
1+VS+dPzOAq8nBVuQES9V5PZM0tHfNuA1J04l0Y4c9mMWsh6YOBsTz46vs5yuCKk
Ptwg6pLlNQJBANEHGdCZJOgKWUg6Xraz38RBM1cPHKzYEmOu1HiNl30wGCuM1b61
8xsDntaHXYHJxYgiudVwzH5Sj2iRVn2CIfMCQALAGR8gEL9rGtlVEtdwD7gcABHQ
BmKOHq5vDNfBG/RpSQLSoYckkaKv5WtWTuOnpC2sXTN41Rh3+SqqERkcuJkCQAFW
HUkjIYRGRKncjax3W+/iRtTAqPtF6mAuxvb6WMSZIR5uKROuEB7VGBfhB60DwDqN
lkiSDwyjtH0DqNzmjxcCQQCvIhCkietd1YSG1Jl7zSmuT3NksNwj4HGYSfMLdkBV
ag8pleWkHqBf9Z1d/qbOkealNgmmiE8JO/vGuM7T0uDw
-----END RSA PRIVATE KEY-----
";
string PublicKey = @"-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCZoXqoJktTWSTolirHAFpLdK3w
1eaawiKu9q7VQeqghF7S90IJFKlawmuLhiEmrOLOqG0AYQOSdX0WSEcRlGH/VKwz
5XNOsLutQWSfG2xt4bXT+nAmqp/nWpeSlNuFYhsCWSjFydAtoUjLBXi0gusaBDpw
fgq4zBGXAA7M3uVmTwIDAQAB
-----END PUBLIC KEY-----";
PrivateKey = PrivateKey.Replace("-----BEGIN RSA PRIVATE KEY-----", "")
.Replace("-----END RSA PRIVATE KEY-----", "");
PublicKey = PublicKey.Replace("-----BEGIN PUBLIC KEY-----", "")
.Replace("-----END PUBLIC KEY-----", "");
RSACrypto rsaCrypto = new RSACrypto(PrivateKey, PublicKey);
//解密 RSA
string pwd = rsaCrypto.Decrypt(passwd);
return(Json(pwd));
}
public UdpConnectionProvider(int port, Protocol protocol, RSAAsymmetricKey authKey)
: base(new[] { protocol }, port)
{
if (protocol == null)
throw new ArgumentNullException ("protocol");
if (authKey == null)
throw new ArgumentNullException ("authKey");
if (port <= 0)
throw new ArgumentOutOfRangeException ("port");
this.crypto = new RSACrypto();
this.crypto.ImportKey (authKey);
this.pkEncryption = new RSACrypto();
this.pkEncryption.ImportKey (authKey);
this.authKey = authKey;
ValidateProtocols (this.protocols.Values);
}
static void Test1()
{
var rsa = new RSACryptoServiceProvider(2048);
var pubKey = rsa.ExportCspBlob(false);
var privateKey = rsa.ExportCspBlob(true);
var b = new RSACrypto().Encrypt(pubKey, System.Text.Encoding.UTF8.GetBytes("hello."));
var c = new RSACrypto().Decrypt(privateKey, b);
string s = string.Empty;
//var rsa1 = new RSACryptoServiceProvider(1024);
//rsa1.ImportCspBlob(pubKey);
//var secret = rsa1.Encrypt(System.Text.Encoding.UTF8.GetBytes("hello."), false);
//var rsa2 = new RSACryptoServiceProvider(1024);
//rsa2.ImportCspBlob(privateKey);
//var plain = rsa2.Decrypt(secret, false);
}
public RequestManager(ServerClass serverClass)
{
this.serverClass = serverClass;
utf8 = new UTF8Encoding();
Log.Write("Starting to generate public/private key pair.");
waitForKeyGeneration = new EventWaitHandle(false, EventResetMode.ManualReset);
rsa = new RSACrypto();
rsa.OnKeysGenerated += new RSACrypto.KeysGenerated(KeyGenerated);
rsa.GenerateKeys(2048);
aes = new AesManaged();
listener = new HttpListener();
listener.Prefixes.Add("http://*:80/");
alive = false;
Log.Write("Request manager created, and ready to start server.");
}
public QuarterServer(ServerConfig config)
{
DefaultAllow = config.DefaultAllow;
Flags = config.Flags;
Host = config.Host;
Port = config.Port;
RSACrypto = new RSACrypto();
LatestClient = null;
Clients = new List <QuarterClient>();
ClientCount = 1;
try
{
Listener = new TcpListener(Host, Port);
Listener.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
Listener.Start();
} catch (Exception ex)
{
throw ex;
}
}
private void ParseResponse(byte[] result)
{
string message = Encoding.Default.GetString(result);
Operation msg = JsonConvert.DeserializeObject <Operation>(message);
switch (msg.op)
{
case "auth":
rsa = new RSACrypto(File.ReadAllText("pri.key"), true);
break;
case "list_file":
lvFileBrowser.Items.Clear();
int id = 1;
foreach (string i in msg.param)
{
ListViewItem tmp = new ListViewItem(new string[] { id.ToString(), i, "Not Download" });
lvFileBrowser.Items.Add(tmp);
id++;
}
break;
case "send_file":
string path = "data/" + msg.param[0];
File.WriteAllBytes(path, rsa.DecodeOrNull(RSA_Unit.Base64DecodeBytes(msg.param[1])));
if (HashTool.SHA256File(new FileStream(path, FileMode.Open)) == msg.param[2])
{
lvFileBrowser.SelectedItems[0].SubItems[2].Text = "Verified";
}
else
{
lvFileBrowser.SelectedItems[0].SubItems[2].Text = "Error";
}
break;
default:
break;
}
}
private string CommonLogin(HttpContext context)
{
RSACrypto rsaCrypto = new RSACrypto(ConstValue.AES_KEY_PRIVATE, ConstValue.AES_KEY_PUBLIC);
var username = rsaCrypto.Decrypt(context.Request["username"]);
var password = rsaCrypto.Decrypt(context.Request["password"]);
var login_result = sso_facade.DoLogin(username, password);
//登录成功
if (login_result.IsSucess)
{
var cookie = new HttpCookie(ConstValue.COOKIE_KEY_CURRENT_LOGIN_USER, username);
cookie.Expires = DateTime.Now.AddMinutes(60 * 8);
HttpContext.Current.Response.Cookies.Add(cookie);
var ret_model = login_result.Datas as DZAFCPortal.ViewModel.Client.SSOModel.LoginResult_VM;
//FormsAuthentication..SetAuthCookie(username, false);
HttpContext.Current.Session.Add($"{ConstValue.SSO.APPLICATION_AUTH_PREFIX_URL}{username}", ret_model.applicationAuths);
}
return(JsonConvert.SerializeObject(login_result));
}
public void Handle(BinaryReader reader, int playerNumber)
{
// 服务器端
if (Main.netMode == 2)
{
var encrypted = reader.ReadString();
var player = Main.player[playerNumber];
var splayer = player.GetServerPlayer();
string res;
if (!RSACrypto.DecryptWithTag(encrypted, "ddl", out res))
{
CommandBoardcast.ConsoleError($"玩家 {player.name} 发来的封包 数据异常，可能已被篡改");
return;
}
long amount;
long.TryParse(res, out amount);
if (splayer.Union == null)
{
splayer.SendMessageBox("你没有加入任何一个公会", 120, Color.Yellow);
return;
}
if (amount <= 0)
{
splayer.SendMessageBox("捐献数量不合法", 120, Color.Red);
CommandBoardcast.ConsoleError($"玩家 {player.name} 发来的封包 数据异常，可能已被篡改");
return;
}
if (amount > splayer.GuCoin)
{
splayer.SendMessageBox("你没有足够的咕币进行捐献", 120, Color.Red);
return;
}
var union = splayer.Union;
union.Donate(splayer, amount);
CommandBoardcast.ConsoleMessage($"玩家 {splayer.Name} 给公会 {union.Name} 捐献了 {amount} 财富");
}
}
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);
}
private static RSAAsymmetricKey GetKey(string keypath)
{
if (!File.Exists(keypath))
{
var rsa = new RSACrypto();
RSAParameters parameters = rsa.ExportKey(true);
using (var stream = File.OpenWrite(keypath)) {
var writer = new StreamValueWriter(stream);
RSAParametersSerializer.Serialize(writer, parameters);
}
}
RSAAsymmetricKey key;
using (var stream = File.OpenRead(keypath)) {
var reader = new StreamValueReader(stream);
RSAParameters parameters = RSAParametersSerializer.Deserialize(reader);
key = new RSAAsymmetricKey(parameters);
}
return(key);
}
public static Task <RSAAsymmetricKey> GetCryptoKeyAsync(CancellationToken cancelToken = default(CancellationToken))
{
return(Task.Run(() => {
RSAAsymmetricKey key = null;
if (KeyFile.Exists)
{
try {
using (var stream = File.OpenRead(KeyFile.FullName)) {
var reader = new StreamValueReader(stream);
RSAParameters parameters = RSAParametersSerializer.Deserialize(reader);
key = new RSAAsymmetricKey(parameters);
}
} catch (Exception ex) {
Trace.TraceWarning("Failed to read key: {0}", ex);
KeyFile.Delete();
}
}
cancelToken.ThrowIfCancellationRequested();
if (!KeyFile.Exists)
{
var rsa = new RSACrypto();
RSAParameters parameters = rsa.ExportKey(true);
key = new RSAAsymmetricKey(parameters);
cancelToken.ThrowIfCancellationRequested();
using (var stream = File.OpenWrite(KeyFile.FullName)) {
var writer = new StreamValueWriter(stream);
RSAParametersSerializer.Serialize(writer, parameters);
}
}
return key;
}, cancelToken));
}
private string CommonLoginBeta(HttpContext context)
{
RSACrypto rsaCrypto = new RSACrypto(ConstValue.AES_KEY_PRIVATE, ConstValue.AES_KEY_PUBLIC);
var username = rsaCrypto.Decrypt(context.Request["username"]);
var password = rsaCrypto.Decrypt(context.Request["password"]);
var model = sso_facade.DoLoginBeta(username, password);
//登录成功
if (model.errorNumber == 0 && model.errors.Count == 0)
{
var cookie = new HttpCookie(ConstValue.COOKIE_KEY_CURRENT_LOGIN_USER, username);
cookie.Expires = DateTime.Now.AddMinutes(60 * 8);
HttpContext.Current.Response.Cookies.Add(cookie);
//FormsAuthentication..SetAuthCookie(username, false);
HttpContext.Current.Session.Add($"{ConstValue.SSO.APPLICATION_AUTH_PREFIX_URL}{username}", model.applicationAuths);
return(JsonConvert.SerializeObject(new { IsSucess = true }));
}
else
{
return(JsonConvert.SerializeObject(new { IsSucess = false, Message = $"[{model.errorNumber}]{string.Join(";", model.errors)}" }));
}
}
public void EncryptDecryptTests()
{
// Arrange
var sectionText = $@"{{
""RSA"": {{
""PublicKey"": ""{publicKey}"",
""PrivateKey"": ""{privateKey}""
}}
}}";
using var stream = new MemoryStream(Encoding.UTF8.GetBytes(sectionText));
var section = new ConfigurationBuilder().AddJsonStream(stream).Build().GetSection("RSA");
var crypto = new RSACrypto(section);
var input = "Hello, Etsoo";
// Act
var result = crypto.Encrypt(input);
var decryptResult = Encoding.UTF8.GetString(crypto.Decrypt(result));
// Assert
Assert.AreEqual(input, decryptResult);
}
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;
}
public void Serialize(IValueWriter writer, RSACrypto crypto, bool includePrivate)
{
}
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);
}
/// <summary>
/// Encrypts a string with the server's public key and convert it to base64.
/// </summary>
/// <param name="s">The string to be encrypted.</param>
/// <returns>The encrypted string in base64 format.</returns>
private String PpEncryptAndBase64(String s)
{
Contract.Requires(!ReferenceEquals(s, null));
RSACrypto rsa = new RSACrypto();
rsa.ImportCspBlob(_publicKey);
byte[] sEncrypted = rsa.Encrypt(_utf8.GetBytes(s));
return Convert.ToBase64String(sEncrypted);
}
public void Deserialize(IValueReader reader, RSACrypto crypto)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="NetworkConnectionProvider" /> class.
/// </summary>
/// <param name="target">The target to listen to.</param>
/// <param name="maxConnections">Maximum number of connections to allow.</param>
/// <param name="protocols">The protocols to accept.</param>
/// <param name="enabledHashAlgs">
/// The signature hash algorithms (in order of preference) to enable.
/// <c>null</c> or an empty collection will enable all of the signature hash algorithms.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="target"/> or <paramref name="protocols" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="maxConnections"/> is <= 0</exception>
public NetworkConnectionProvider(IEnumerable<Protocol> protocols, Target target, int maxConnections, IEnumerable<string> enabledHashAlgs = null)
{
if (protocols == null)
throw new ArgumentNullException ("protocols");
if (target == null)
throw new ArgumentNullException ("target");
if (maxConnections <= 0)
throw new ArgumentOutOfRangeException ("maxConnections");
this.protocols = protocols;
this.target = target;
MaxConnections = maxConnections;
this.serverConnections = new List<NetworkServerConnection> (maxConnections);
if (protocols.Any (p => p != null && p.RequiresHandshake))
{
ThreadPool.QueueUserWorkItem (s =>
{
Task encryptKeyGen = Task.Factory.StartNew (() =>
{
this.pkEncryption = new RSACrypto();
this.publicEncryptionKey = this.pkEncryption.ExportKey (false);
});
Task authKeyGen = Task.Factory.StartNew (() =>
{
this.authentication = new RSACrypto();
if (this.authenticationKey == null)
this.authenticationKey = this.authentication.ExportKey (true);
else
this.authentication.ImportKey (this.authenticationKey);
this.publicAuthenticationKey = this.authentication.ExportKey (false);
if (enabledHashAlgs == null || !enabledHashAlgs.Any())
this.enabledHashAlgorithms.AddRange (this.authentication.SupportedHashAlgs);
else // Need to maintain preference order
this.enabledHashAlgorithms.AddRange (enabledHashAlgs.Where (a => this.authentication.SupportedHashAlgs.Contains (a)));
});
authKeyGen.Wait();
encryptKeyGen.Wait();
this.keyWait.Set();
});
}
else
this.keyWait.Set();
}
protected override void OnTempestMessageReceived(MessageEventArgs e)
{
switch (e.Message.MessageType)
{
case (ushort)TempestMessageType.Ping:
var ping = (PingMessage)e.Message;
if (PingFrequency == 0 || this.activityTimer == null)
{
if (this.activityTimer != null)
this.activityTimer.Dispose();
if (ping.Interval != 0)
{
this.activityTimer = new Tempest.Timer (100);
this.activityTimer.TimesUp += OnActivityTimer;
this.activityTimer.Start();
}
}
else if (ping.Interval != PingFrequency)
this.activityTimer.Interval = ping.Interval;
base.OnTempestMessageReceived (e);
break;
case (ushort)TempestMessageType.AcknowledgeConnect:
var msg = (AcknowledgeConnectMessage)e.Message;
this.protocols = this.protocols.Values.Intersect (msg.EnabledProtocols).ToDictionary (pr => pr.id);
ConnectionId = msg.ConnectionId;
this.serverEncryption = new RSACrypto();
this.serverEncryption.ImportKey (msg.PublicEncryptionKey);
this.serverEncryptionKey = msg.PublicEncryptionKey;
var encryption = new AesManaged { KeySize = 256 };
encryption.GenerateKey();
BufferValueWriter authKeyWriter = new BufferValueWriter (new byte[1600]);
this.publicAuthenticationKey.Serialize (authKeyWriter, this.serverEncryption);
this.serializer.AES = encryption;
this.serializer.HMAC = new HMACSHA256 (encryption.Key);
SendAsync (new FinalConnectMessage
{
AESKey = this.serverEncryption.Encrypt (encryption.Key),
PublicAuthenticationKeyType = this.publicAuthenticationKey.GetType(),
PublicAuthenticationKey = authKeyWriter.ToArray()
});
break;
case (ushort)TempestMessageType.Connected:
var connected = (ConnectedMessage) e.Message;
ConnectionId = connected.ConnectionId;
OnConnected (new ClientConnectionEventArgs (this));
var tcs = Interlocked.Exchange (ref this.connectCompletion, null);
if (tcs != null)
tcs.TrySetResult (new ClientConnectionResult (ConnectionResult.Success, this.serverAuthenticationKey));
break;
default:
base.OnTempestMessageReceived(e);
break;
}
}
////////////////////////////////////////////////////
// STEAM WEB INTERFACE
////////////////////////////////////////////////////
// Copied this shit straight from ArchisSteamFarm, credit to him
public override async void LoginWebInterface(ulong steamID)
{
if (!IsAuthenticated)
{
SteamUser.WebAPIUserNonceCallback callback;
try
{
callback = await _steamUser.RequestWebAPIUserNonce();
}
catch (Exception ex)
{
_log.Error(ex, "Unable to request Web API Nonce. Titan won't be able to execute Web API actions.");
return;
}
if (string.IsNullOrWhiteSpace(callback?.Nonce))
{
_log.Error("Received empty Web API Nonce. Titan won't be able to execute Web API actions.");
return;
}
var sessionID = Convert.ToBase64String(Encoding.UTF8.GetBytes(steamID.ToString()));
var sessionKey = CryptoHelper.GenerateRandomBlock(32);
byte[] cryptedSessionKey;
using (var rsa = new RSACrypto(KeyDictionary.GetPublicKey(_steamClient.Universe)))
{
cryptedSessionKey = rsa.Encrypt(sessionKey);
}
var loginKey = new byte[callback.Nonce.Length];
Array.Copy(Encoding.ASCII.GetBytes(callback.Nonce), loginKey, callback.Nonce.Length);
// AES encrypt the login key with our session key
var cryptedLoginKey = CryptoHelper.SymmetricEncrypt(loginKey, sessionKey);
if (!Titan.Instance.WebHandle.AuthentificateUser(
steamID, cryptedLoginKey, cryptedSessionKey, out var result
))
{
_log.Error("Failed to authentificate with Web API Nonce. " +
"Titan won't be able to execute Web API actions.");
return;
}
var token = result["token"].Value;
var secureToken = result["tokensecure"].Value;
if (string.IsNullOrWhiteSpace(token) || string.IsNullOrWhiteSpace(secureToken))
{
_log.Error("Failed to authentificate with Web API Nonce. " +
"Titan won't be able to execute Web API actions.");
return;
}
Cookies.Add("sessionid", sessionID);
Cookies.Add("steamLogin", token);
Cookies.Add("steamLoginSecure", secureToken);
if (!Titan.Instance.Options.Secure)
{
_log.Debug("Authorized with Steam Web API. Session ID: {id}", sessionID);
}
_log.Information("Successfully authorized with Steam Web API.");
IsAuthenticated = 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))
{
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);
}
public UdpConnectionProvider(int port, IEnumerable<Protocol> protocols, RSAAsymmetricKey authKey)
: base(protocols, port)
{
if (protocols == null)
throw new ArgumentNullException ("protocols");
if (authKey == null)
throw new ArgumentNullException ("authKey");
if (port <= 0)
throw new ArgumentOutOfRangeException ("port");
this.crypto = new RSACrypto();
this.crypto.ImportKey (authKey);
this.authKey = authKey;
ValidateProtocols (this.protocols.Values);
}
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 );
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 );
}
static NetworkProviderTests()
{
var rsa = new RSACrypto();
key = rsa.ExportKey (true);
}
protected override void Recycle()
{
if (AutoSizeSendBufferLimit)
Interlocked.Add (ref sendBufferLimit, AutoSizeFactor * -1);
this.serverEncryption = null;
this.serverEncryptionKey = null;
this.serverAuthenticationKey = null;
base.Recycle();
}
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);
}
