protected override void Encode(IChannelHandlerContext context, IPacket message, IByteBuffer output)
{
var socket = context.Channel.GetAttribute(AbstractSocket.SocketKey).Get();
var dataLen = (short)message.Length;
var buffer = new byte[dataLen];
Array.Copy(message.Buffer, buffer, dataLen);
if (socket != null)
{
var seqSend = socket.SeqSend;
var rawSeq = (short)((seqSend >> 16) ^ -(95 + 1));
if (socket.EncryptData)
{
dataLen ^= rawSeq;
ShandaCipher.EncryptTransform(buffer);
AESCipher.Transform(buffer, seqSend);
}
output.WriteShortLE(rawSeq);
output.WriteShortLE(dataLen);
output.WriteBytes(buffer);
socket.SeqSend = IGCipher.InnoHash(seqSend, 4, 0);
}
else
{
output.WriteShortLE(dataLen);
output.WriteBytes(buffer);
}
}
public void TransformResultIsAccurate()
{
const int data = 0xABCDEF;
const uint key = 0x100;
var result = AESCipher.Transform(BitConverter.GetBytes(data), key);
Assert.Equal(0x5883F451, BitConverter.ToInt32(result));
Assert.NotEqual(data, BitConverter.ToInt32(result));
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
string message = xmlCommonUtil.QueryString["msg"];
AESCipher aes = new AESCipher("427d0a5839078c2ba379ecc9772aefa8");
string dec =
aes.Decrypt(message);
xmlCommonUtil.ResponseWriteErrorMSG(dec);
}
}
public object Convert(object value, Type targetType, object parameter, string language)
{
if (string.IsNullOrEmpty((string)value))
{
return("");
}
else
{
return(AESCipher.AES_Decrypt((string)value));
}
}
public void TestDecrypt()
{
var key = "MyPassword!1234";
var text = "test of encrytion";
var encryptedText = "VNGO76kMiac6VhO1PhMnlHfT0m7Je7zV4u4Pau68iG/0xuVZ7mugtqeiF4RMfGFx";
var decryptedText = AESCipher.DecryptString(key, encryptedText);
Assert.IsNotNull(decryptedText);
Assert.AreNotEqual(decryptedText, "");
Assert.AreEqual(decryptedText, text);
}
public string EncryptionOracle()
{
PlainText message = new PlainText(RandomizeMessageLength(_plainText));
string randKey = GetRandomKey(16).ToASCIIString();
Random random = new Random();
Mode = (random.Next(2) == 0) ? CipherMode.ECB : CipherMode.CBC;
AESCipher aes = new AESCipher(Mode, PaddingMode.PKCS7);
return(aes.Encrypt(message, randKey, CipherTextFormat.HEXADECIMAL));
}
public void TestEncrypt()
{
var text = "lorem ipsum dolor siamet";
var key = "MySecretKey";
var encryptedText = AESCipher.EncryptString(key, text);
var decryptedText = AESCipher.DecryptString(key, encryptedText);
Assert.IsNotNull(encryptedText);
Assert.IsNotNull(decryptedText);
Assert.AreNotEqual(encryptedText, "");
Assert.AreNotEqual(decryptedText, "");
Assert.AreEqual(decryptedText, text);
}
public void TestReceiveResponse()
{
TestWebServiceProxy testProxy = new TestWebServiceProxy();
ITransportProxy proxy = testProxy;
FolaighKeyStore keyStore = new FolaighKeyStore(KEYSTORE, "bird8top".ToCharArray());
RSACipher encryptorVerifier = new RSACipher(
keyStore,
"stateKey",
false);
RSACipher signerDecryptor = new RSACipher(
keyStore,
"countyKey",
true);
SecureTransport transport = new SecureTransport(proxy, encryptorVerifier, signerDecryptor);
String sender = "stateKey";
string result = transport.receive(encryptedMessage, signature,
encryptedAesKey, encryptedIV, sender);
// The result should be an XML document with an encrypted AES key
// and
// IV,
// an AES-encrypted response string, and a signed hash of the
// encrypted
// response string.
ResponseInfo objResponseInfo = ResponseInfo.decode(result);
encryptorVerifier = new RSACipher(
keyStore,
"countyKey",
false);
signerDecryptor = new RSACipher(
keyStore,
"stateKey",
true);
byte[] sig = Convert.FromBase64String(objResponseInfo.Signature);
byte[] hash = encryptorVerifier.decrypt(sig);
byte[] encryptedResponse = Convert.FromBase64String(objResponseInfo.Response);
byte[] expectedHash = Hash.getHash(encryptedResponse);
Assert.AreEqual(hash, expectedHash);
byte[] key = signerDecryptor.decrypt(Convert.FromBase64String(objResponseInfo.Key));
byte[] iv = signerDecryptor.decrypt(Convert.FromBase64String(objResponseInfo.IV));
AESCipher cipher = new AESCipher(key, iv);
Assert.AreEqual(TestWebServiceProxy.THIS_IS_THE_RESPONSE, cipher
.decrypt(encryptedResponse));
}
public NettyPacketEncoder(
ITransport transport,
AESCipher aesCipher,
IGCipher igCipher
)
{
Debug.Assert(transport != null);
Debug.Assert(aesCipher != null);
Debug.Assert(igCipher != null);
_transport = transport;
_aesCipher = aesCipher;
_igCipher = igCipher;
}
public NettyPacketDecoder(
ITransport transport,
AESCipher aesCipher,
IGCipher igCipher
) : base(NettyPacketState.DecodingHeader)
{
Debug.Assert(transport != null);
Debug.Assert(aesCipher != null);
Debug.Assert(igCipher != null);
_transport = transport;
_aesCipher = aesCipher;
_igCipher = igCipher;
}
public WalletConnect(ClientMeta clientMeta, ITransport transport = null,
ICipher cipher = null,
int?chainId = 1,
string bridgeUrl = "https://bridge.walletconnect.org",
EventDelegator eventDelegator = null
)
{
if (eventDelegator == null)
{
eventDelegator = new EventDelegator();
}
this.Events = eventDelegator;
this.ClientMetadata = clientMeta;
this.ChainId = chainId;
if (bridgeUrl.StartsWith("https"))
{
bridgeUrl = bridgeUrl.Replace("https", "wss");
}
else if (bridgeUrl.StartsWith("http"))
{
bridgeUrl = bridgeUrl.Replace("http", "ws");
}
var topicGuid = Guid.NewGuid();
_handshakeTopic = topicGuid.ToString();
clientId = Guid.NewGuid().ToString();
if (transport == null)
{
transport = new WebsocketTransport(eventDelegator);
}
this._bridgeUrl = bridgeUrl;
this.Transport = transport;
if (cipher == null)
{
cipher = new AESCipher();
}
this.Cipher = cipher;
GenerateKey();
}
protected void encryptBtn_Click(object sender, EventArgs e)
{
//get the users data and pin code input
String pass = passText.Text;
String passname = passName.Text;
String pin = pinText.Text;
//server side input validation
if (passname.Length < 1)
{
Label2.ForeColor = System.Drawing.Color.Red;
Label2.Text = "Please Enter a Password Name";
return;
}
if (pass.Length < 1)
{
Label2.ForeColor = System.Drawing.Color.Red;
Label2.Text = "Please Enter a Password";
return;
}
if (pin.Length < 1)
{
Label2.ForeColor = System.Drawing.Color.Red;
Label2.Text = "Please Enter a Pin Code";
return;
}
//hash the user inputted pincode
String key = Bouncy.Hash(pin);
//get instance of AESCipher internal class
AESCipher AESCipher = new AESCipher();
//generate a 16 byte random IV
byte[] ivBytes = AESCipher.GenerateRandomIV(16);
//convert IV to string
String iv = Convert.ToBase64String(ivBytes);
//encrypt the password using the pin code and the IV
String encrypted = AESCipher.encrypt(pass, key, iv);
Debug.WriteLine("encrypted text..................................." + encrypted);
//set the encrypted password and hashed pin code on screen
passText.Text = encrypted;
pinText.Text = key;
}
public OutputStreamEncryption(Stream outc, byte[] key, int off, int len, int revision)
{
this.outc = outc;
aes = (revision == AES_128 || revision == AES_256);
if (aes)
{
byte[] iv = IVGenerator.GetIV();
byte[] nkey = new byte[len];
System.Array.Copy(key, off, nkey, 0, len);
cipher = new AESCipher(true, nkey, iv);
Write(iv, 0, iv.Length);
}
else
{
arcfour = new ARCFOUREncryption();
arcfour.PrepareARCFOURKey(key, off, len);
}
}
/// <summary>
/// Builds the encrypted message.
/// </summary>
/// <returns>The encrypted message.</returns>
/// <param name="data">Data.</param>
/// <param name="key">Key.</param>
/// <param name="cipherAlgo">Algorithm used to encrypt.</param>
/// <param name="algo">Algorithm ID.</param>
/// <param name="iv">Iv.</param>
static byte[] BuildEncryptedMessage(byte[] data, byte[] key, CipherAlgo cipherAlgo, out Int16 algo, byte[] iv = null)
{
switch (cipherAlgo)
{
case CipherAlgo.AES256:
algo = 1;
if (iv == null)
{
throw new PacketGenerationException("Invalid IV for AES256");
}
return(AESCipher.EncryptData(data, key, iv));
case CipherAlgo.NOALGO:
algo = -1;
return(null);
default:
throw new PacketGenerationException("Cipher Algorithm not implemented");
}
}
public void TestAES128_Unaligned()
{
var key = "e88aeefe8ea9b95a1faeee762eeca23b";
var iv = "12153524c0895e81b2c28465";
var aad = "d609b1f056637a0d46df998d88e52e00b2c2846512153524c0895e81";
var plaintext = "08000f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a";
var ciphertext = "11a985767b4173be2760737176244b74e7eb06593380b1260931ae226918d18d9cbfb469e7589829d2246fba4425";
var tag = "4b320d8d2809e7573221ceea07b29a12";
var aes = new AESCipher(128);
var gcm = new GCMCipher(aes);
var keyParam = new AESKeyParameter(HexConverter.FromHex(key));
var ivParam = new IVParameter(keyParam, HexConverter.FromHex(iv));
var aadParam = new AADParameter(ivParam, HexConverter.FromHex(aad));
// encryption
gcm.Init(aadParam);
var encryptInput = HexConverter.FromHex(plaintext);
var encryptOutput = new byte[encryptInput.Length + gcm.TagLength];
var encryptCipherText = encryptOutput.AsSpan(0, encryptInput.Length);
var encryptTag = encryptOutput.AsSpan(encryptInput.Length, gcm.TagLength);
gcm.EncryptAll(encryptInput, encryptOutput);
Assert.Equal(ciphertext, HexConverter.ToHex(encryptCipherText));
Assert.Equal(tag, HexConverter.ToHex(encryptTag));
// decryption
gcm.Init(aadParam);
var decryptInput = HexConverter.FromHex(ciphertext + tag);
var decryptOutput = new byte[decryptInput.Length - encryptTag.Length];
gcm.DecryptAll(decryptInput, decryptOutput);
Assert.Equal(plaintext, HexConverter.ToHex(decryptOutput));
}
protected override void Encode(IChannelHandlerContext context, Packet message, IByteBuffer output)
{
var socket = context.Channel.GetAttribute(Socket.SocketKey).Get();
if (socket != null)
{
lock (socket.LockSend)
{
var seqSend = socket.SeqSend;
var rawSeq = (short)((seqSend >> 16) ^ -(AESCipher.Version + 1));
var dataLen = (short)message.Length;
var buffer = new byte[dataLen];
Unpooled.CopiedBuffer(message.Buffer).ReadBytes(buffer);
if (socket.EncryptData)
{
dataLen ^= rawSeq;
buffer = ShandaCipher.EncryptTransform(buffer);
buffer = AESCipher.Transform(buffer, seqSend);
}
output.WriteShortLE(rawSeq);
output.WriteShortLE(dataLen);
output.WriteBytes(buffer);
socket.SeqSend = IGCipher.InnoHash(seqSend, 4, 0);
}
}
else
{
var length = message.Length;
var buffer = new byte[length];
message.Buffer.ReadBytes(buffer);
output.WriteShortLE(length);
output.WriteBytes(buffer);
}
}
public void TestAES128_Aligned()
{
var key = "ad7a2bd03eac835a6f620fdcb506b345";
var iv = "12153524c0895e81b2c28465";
var aad = "d609b1f056637a0d46df998d88e52e00b2c2846512153524c0895e81";
var plaintext = "08000f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a0002";
var ciphertext = "701afa1cc039c0d765128a665dab69243899bf7318ccdc81c9931da17fbe8edd7d17cb8b4c26fc81e3284f2b7fba713d";
var tag = "4f8d55e7d3f06fd5a13c0c29b9d5b880";
var aes = new AESCipher(128);
var gcm = new GCMCipher(aes);
var keyParam = new AESKeyParameter(HexConverter.FromHex(key));
var ivParam = new IVParameter(keyParam, HexConverter.FromHex(iv));
var aadParam = new AADParameter(ivParam, HexConverter.FromHex(aad));
// encryption
gcm.Init(aadParam);
var encryptInput = HexConverter.FromHex(plaintext);
var encryptOutput = new byte[encryptInput.Length + gcm.TagLength];
var encryptCipherText = encryptOutput.AsSpan(0, encryptInput.Length);
var encryptTag = encryptOutput.AsSpan(encryptInput.Length, gcm.TagLength);
gcm.EncryptAll(encryptInput, encryptOutput);
Assert.Equal(ciphertext, HexConverter.ToHex(encryptCipherText));
Assert.Equal(tag, HexConverter.ToHex(encryptTag));
// decryption
gcm.Init(aadParam);
var decryptInput = HexConverter.FromHex(ciphertext + tag);
var decryptOutput = new byte[decryptInput.Length - encryptTag.Length];
gcm.DecryptAll(decryptInput, decryptOutput);
Assert.Equal(plaintext, HexConverter.ToHex(decryptOutput));
}
public void TestAESCipher()
{
AESCipher aesCipher = new AESCipher();
byte[] key = aesCipher.Key;
Assert.AreEqual(32, key.Length);
byte[] iv = aesCipher.IV;
// AES block size is 16 bytes
Assert.AreEqual(16, iv.Length);
Console.WriteLine("AES Key: " + Convert.ToBase64String(key));
Console.WriteLine("AES IV: " + Convert.ToBase64String(iv));
string cleartext = "<?xml version=\"1.0\" encoding=\"utf-8\"?><FolaighMethodCall><methodName>methodOne</methodName><arg0>arg0</arg0><arg1>arg1</arg1></FolaighMethodCall>";
byte[] encryptedText = aesCipher.encrypt(cleartext);
Console.WriteLine("Encrypted text:" + Convert.ToBase64String(encryptedText));
aesCipher = new AESCipher(key, iv);
string decryptedText = aesCipher.decrypt(encryptedText);
Assert.AreEqual(cleartext, decryptedText);
Console.WriteLine("Decrypted Text: <" + decryptedText + ">");
}
protected void decryptBtn_Click(object sender, EventArgs e)
{
//get the users data and pin code input
String pass = passwordTxt.Text;
String pin = pincodeInput.Text;
String OGpin = Text1.Text;
//validate the entered pin code with the one stored in the database
bool match = ValidateHash(pin, OGpin);
//if the pin codes match
if (match)
{
String iv = "";
//get instance of AESCipher internal class
AESCipher AESCipher = new AESCipher();
//decrypt the password
String decrypted = AESCipher.decrypt(pass, OGpin, iv);
//set the text view with the decrypted password
passwordTxt.Text = decrypted;
//set pin code input to blank
pincodeInput.Text = "";
String success = "Decryption Successful!";
Label1.Text = success;
}
//pin code does not match so show error message
else
{
String error = "Please enter the correct password!";
Label1.ForeColor = System.Drawing.Color.Red;
Label1.Text = error;
}
}
public WalletConnect(ClientMeta clientMeta, ITransport transport = null,
ICipher cipher = null,
int?chainId = 1,
string bridgeUrl = "https://bridge.walletconnect.org",
EventDelegator eventDelegator = null
)
{
if (clientMeta == null)
{
throw new ArgumentException("clientMeta cannot be null!");
}
if (string.IsNullOrWhiteSpace(clientMeta.Description))
{
throw new ArgumentException("clientMeta must include a valid Description");
}
if (string.IsNullOrWhiteSpace(clientMeta.Name))
{
throw new ArgumentException("clientMeta must include a valid Name");
}
if (string.IsNullOrWhiteSpace(clientMeta.URL))
{
throw new ArgumentException("clientMeta must include a valid URL");
}
if (clientMeta.Icons == null || clientMeta.Icons.Length == 0)
{
throw new ArgumentException("clientMeta must include an array of Icons the Wallet app can use. These Icons must be URLs to images. You must include at least one image URL to use");
}
if (eventDelegator == null)
{
eventDelegator = new EventDelegator();
}
this.Events = eventDelegator;
this.ClientMetadata = clientMeta;
this.ChainId = chainId;
if (bridgeUrl.StartsWith("https"))
{
bridgeUrl = bridgeUrl.Replace("https", "wss");
}
else if (bridgeUrl.StartsWith("http"))
{
bridgeUrl = bridgeUrl.Replace("http", "ws");
}
var topicGuid = Guid.NewGuid();
_handshakeTopic = topicGuid.ToString();
clientId = Guid.NewGuid().ToString();
if (transport == null)
{
transport = new WebsocketTransport(eventDelegator);
}
this._bridgeUrl = bridgeUrl;
this.Transport = transport;
if (cipher == null)
{
cipher = new AESCipher();
}
this.Cipher = cipher;
GenerateKey();
}
static void Main(string[] args)
{
if (!ParseInput(args))
{
return;
}
if (Params.verbose)
{
System.Console.WriteLine(Params.decrypt ? "Running in decryption mode." : "Running in endryption mode.");
System.Console.WriteLine(Params.useCBC ? "Using CBC." : "Using ECB.");
System.Console.WriteLine(Params.usePadding ? "Using PKCS5 padding." : "Not using padding. (Will fail if text length is not mod 16 byte.)");
System.Console.WriteLine("Key: ({0})", Params.key);
System.Console.WriteLine(BytesToFormatedString(Encoding.UTF8.GetBytes(Params.key)));
System.Console.WriteLine();
System.Console.WriteLine("Text: '{0}'", Params.text);
System.Console.WriteLine(BytesToFormatedString(Encoding.UTF8.GetBytes(Params.text)));
System.Console.WriteLine();
}
var cipher = new AESCipher(
new AESParameters(
Encoding.UTF8.GetBytes(Params.key),
Params.keySize,
Params.useCBC,
Params.usePadding,
Params.useKeyPadding,
Encoding.UTF8.GetBytes(Params.initVector),
Params.verbose
)
);
byte[] result;
if (Params.decrypt)
{
result = cipher.Decrypt(Convert.FromBase64String(Params.text));
}
else
{
result = cipher.Encrypt(Encoding.UTF8.GetBytes(Params.text));
}
if (Params.hex)
{
if (Params.useLabels || Params.verbose)
{
System.Console.WriteLine("Result (Hex):");
}
System.Console.WriteLine(BytesToFormatedString(result));
}
if (Params.base64)
{
if (Params.useLabels || Params.verbose)
{
System.Console.WriteLine("Result (base64):");
}
System.Console.WriteLine(Convert.ToBase64String(result));
}
if (Params.decrypt)
{
if (Params.useLabels || Params.verbose)
{
System.Console.WriteLine("Result (utf-8):");
}
System.Console.WriteLine(Encoding.UTF8.GetString(result));
}
}
public void TestSecureTransport()
{
String methodName = "methodOne";
String arg0 = "arg0";
String arg1 = "arg1";
TestWebServiceProxy testProxy = new TestWebServiceProxy();
ITransportProxy proxy = testProxy;
FolaighKeyStore keyStore = new FolaighKeyStore(KEYSTORE, "bird8top".ToCharArray());
RSACipher encryptorVerifier = new RSACipher(
keyStore,
"countyKey",
false);
RSACipher signerDecryptor = new RSACipher(
keyStore,
"stateKey",
true);
SecureTransport transport = new SecureTransport(
proxy,
encryptorVerifier,
signerDecryptor);
// Test for the proxy method
String message = "message";
String signature = "signature";
String aesKey = "key";
String iv = "iv";
String senderAlias = "alias";
String retval = proxy.send(message, signature, aesKey, iv, senderAlias);
String returnVal = transport.send(methodName, new String[] { arg0, arg1 });
// First, just check to see if something got to the proxy.
Assert.IsNotNull(returnVal);
Assert.IsNotNull(testProxy.m_aesKey);
Assert.IsNotNull(testProxy.m_iv);
Assert.IsNotNull(testProxy.m_message);
Assert.IsNotNull(testProxy.m_senderAlias);
Assert.IsNotNull(testProxy.m_signature);
Console.WriteLine("Encrypted AES Key:" + testProxy.m_aesKey);
Console.WriteLine("Encrypted IV:" + testProxy.m_iv);
Console.WriteLine("Encrypted Message:" + testProxy.m_message);
Console.WriteLine("Sender Alias:" + testProxy.m_senderAlias);
Console.WriteLine("Signature:" + testProxy.m_signature);
// Decrypt the AES Key
RSACipher testDecryptor = new RSACipher(
keyStore,
"countyKey",
true);
byte[] testKey = testDecryptor.decrypt(Convert.FromBase64String(testProxy.m_aesKey));
byte[] testIV = testDecryptor.decrypt(Convert.FromBase64String(testProxy.m_iv));
Console.WriteLine("Decrypted Key:" + Convert.ToBase64String(testKey));
Console.WriteLine("Decrypted IV:" + Convert.ToBase64String(testIV));
AESCipher cipher = new AESCipher(testKey, testIV);
// Independently encrypt the message and make sure they're the same
MethodInfo mInfo = new MethodInfo(methodName, new String[] { arg0, arg1 });
String xml = mInfo.encode();
String testEncryptedMessage = Convert.ToBase64String(cipher.encrypt(xml));
Assert.AreEqual(xml, cipher.decrypt(Convert.FromBase64String(testEncryptedMessage)));
Assert.AreEqual(testEncryptedMessage, testProxy.m_message);
string decryptedMessage = cipher.decrypt(Convert.FromBase64String(testProxy.m_message));
string expectedMessage = expectedMethodInfo.encode();
Assert.AreEqual(expectedMessage, decryptedMessage);
}
public static async Task <string> GetCCTVType(IOTOI.Model.CCTV cctv)
{
foreach (var IPCameraUri in IPCameraUris)
{
try
{
using (HttpClient httpClient = new HttpClient())
{
httpClient.Timeout = TimeSpan.FromMilliseconds(2000);
httpClient.BaseAddress = new Uri("http://" + cctv.IpAddress);
string requestUri = String.Format(IPCameraUri.Value, cctv.AccountId, AESCipher.AES_Decrypt(cctv.AccountPass));
Debug.WriteLine("requestUri :: " + httpClient.BaseAddress + requestUri);
//Send the GET request
HttpResponseMessage httpResponse = await httpClient.GetAsync(requestUri);
if (httpResponse != null && httpResponse.StatusCode == HttpStatusCode.OK)
{
string ResponseText = await httpResponse.Content.ReadAsStringAsync();
XmlDocument xml = new XmlDocument();
xml.LoadXml(ResponseText);
if (xml.GetElementsByTagName("result")[0].InnerText == "0")
{
return(IPCameraUri.Key);
}
}
}
}
catch (Exception ex)
{
Debug.WriteLine("GetCCTVType Exception " + ex.Message);
continue;
}
}
return("");
}
protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List <object> output)
{
var socket = context.Channel.GetAttribute(Socket.SocketKey).Get();
try
{
switch (State)
{
case PacketState.Header:
if (socket != null)
{
var sequence = input.ReadShortLE();
var length = input.ReadShortLE();
if (socket.EncryptData)
{
length ^= sequence;
}
_sequence = sequence;
_length = length;
}
else
{
_length = input.ReadShortLE();
}
Checkpoint(PacketState.Payload);
return;
case PacketState.Payload:
var buffer = new byte[_length];
input.ReadBytes(buffer);
Checkpoint(PacketState.Header);
if (_length < 0x2)
{
return;
}
if (_length > 0x10000)
{
return;
}
if (socket != null)
{
lock (socket.LockRecv)
{
var seqRecv = socket.SeqRecv;
var version = (short)(seqRecv >> 16) ^ _sequence;
if (!(version == -(AESCipher.Version + 1) ||
version == AESCipher.Version))
{
return;
}
if (socket.EncryptData)
{
buffer = AESCipher.Transform(buffer, seqRecv);
buffer = ShandaCipher.DecryptTransform(buffer);
}
socket.SeqRecv = IGCipher.InnoHash(seqRecv, 4, 0);
}
}
output.Add(new InPacket(Unpooled.CopiedBuffer(buffer)));
return;
}
}
catch (IndexOutOfRangeException)
{
RequestReplay();
}
}
public string SolveChallenge()
{
AESCipher aes = new AESCipher(CipherMode.ECB, PaddingMode.None);
return(aes.Decrypt(new CipherText(_cipherText, CipherTextFormat.BASE64), _key));
}
