//158 - "SETBADGE": "B^"
public void Listener158()
{
int badgeLen = Base64Encoding.DecodeInt(mPacketBody.Substring(0, 2));
string badge = mPacketBody.Substring(2, badgeLen);
if (ArgumentEncoding.decodeInt(mPacketBody.Substring(mPacketBody.Length - 1, 1)) == 1)
{
if (mUserInfo.Badges.Contains(badge))
{
mUserInfo.sBadge = badge;
}
}
else
{
if (mUserInfo.sBadge == badge)
{
mUserInfo.sBadge = "";
}
}
InstanceManager.Game.Users.SetBadge(mUserInfo.userId, mUserInfo.sBadge);
mUserInfo = InstanceManager.Game.Users.GetUser(mUserInfo.userId);
mMessage.Init(228); //Cd
mMessage.appendArgumentInt(mRoomInstance.GetUser(mSessionID).RoomUserID);
mMessage.appendString(mUserInfo.sBadge);
mMessage.appendChar(2);
mRoomInstance.RoomBroadcast(mMessage);
}
//75 - "MOVE": "AK"
public void Listener75()
{
int x = Base64Encoding.DecodeInt(mPacketBody.Substring(0, 2));
int y = Base64Encoding.DecodeInt(mPacketBody.Substring(2));
mRoomInstance.Interactor.RequestMovePlayer(mSessionID, x, y, null, false);
}
private void WriteBase64Text(byte[] buffer, int offset, int count)
{
if (this.base64Chars == null)
{
this.base64Chars = new byte[0x200];
}
Base64Encoding encoding = XmlConverter.Base64Encoding;
while (count >= 3)
{
int byteCount = Math.Min((int)((this.base64Chars.Length / 4) * 3), (int)(count - (count % 3)));
int num2 = (byteCount / 3) * 4;
encoding.GetChars(buffer, offset, byteCount, this.base64Chars, 0);
this.signingWriter.WriteText(this.base64Chars, 0, num2);
if (this.text)
{
this.writer.WriteText(this.base64Chars, 0, num2);
}
offset += byteCount;
count -= byteCount;
}
if (count > 0)
{
encoding.GetChars(buffer, offset, count, this.base64Chars, 0);
this.signingWriter.WriteText(this.base64Chars, 0, 4);
if (this.text)
{
this.writer.WriteText(this.base64Chars, 0, 4);
}
}
}
private async Task InternalWriteBase64TextAsync(byte[] buffer, int offset, int count)
{
Base64Encoding encoding = XmlConverter.Base64Encoding;
while (count >= 3)
{
int byteCount = Math.Min(bufferLength / 4 * 3, count - count % 3);
int charCount = byteCount / 3 * 4;
int charOffset;
BytesWithOffset bufferResult = await GetBufferAsync(charCount).ConfigureAwait(false);
byte[] chars = bufferResult.Bytes;
charOffset = bufferResult.Offset;
Advance(encoding.GetChars(buffer, offset, byteCount, chars, charOffset));
offset += byteCount;
count -= byteCount;
}
if (count > 0)
{
int charOffset;
BytesWithOffset bufferResult = await GetBufferAsync(4).ConfigureAwait(false);
byte[] chars = bufferResult.Bytes;
charOffset = bufferResult.Offset;
Advance(encoding.GetChars(buffer, offset, count, chars, charOffset));
}
}
static void OnGetBufferComplete(IAsyncEventArgs state)
{
GetBufferEventResult result = ((GetBufferAsyncEventArgs)state).Result;
InternalWriteBase64TextAsyncWriter thisPtr = (InternalWriteBase64TextAsyncWriter)state.AsyncState;
XmlWriteBase64AsyncArguments writerArgs = thisPtr.writerState.Arguments;
Exception completionException = null;
bool completeSelf = false;
try
{
if (state.Exception != null)
{
completionException = state.Exception;
completeSelf = true;
}
else
{
byte[] chars = result.Buffer;
int offset = result.Offset;
Base64Encoding encoding = XmlConverter.Base64Encoding;
int byteCount = Math.Min(bufferLength / 4 * 3, writerArgs.Count - writerArgs.Count % 3);
int charCount = byteCount / 3 * 4;
thisPtr.writer.Advance(encoding.GetChars(
writerArgs.Buffer,
writerArgs.Offset,
byteCount,
chars,
offset));
if (byteCount >= 3)
{
writerArgs.Offset += byteCount;
writerArgs.Count -= byteCount;
}
if (thisPtr.InternalWriteBase64TextAsync(thisPtr.writerState) == AsyncCompletionResult.Completed)
{
completeSelf = true;
}
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
completionException = exception;
completeSelf = true;
}
if (completeSelf)
{
thisPtr.writerState.Complete(false, completionException);
}
}
public override void ChannelRead(IChannelHandlerContext ctx, object msg)
{
Client client = Engine.Locator.ClientController.GetClient(ctx.Channel);
IByteBuffer message = msg as IByteBuffer;
if (message.GetByte(0) == 60)
{
string policy =
"<?xml version=\"1.0\"?>\r\n<!DOCTYPE cross-domain-policy SYSTEM \"/xml/dtds/cross-domain-policy.dtd\">\r\n<cross-domain-policy>\r\n <allow-access-from domain=\"*\" to-ports=\"1-65535\" />\r\n</cross-domain-policy>\0";
ctx.Channel.WriteAndFlushAsync(Unpooled.CopiedBuffer(Encoding.GetEncoding(0).GetBytes(policy))).Wait();
}
else
{
while (message.ReadableBytes >= 5)
{
int length = Base64Encoding.DecodeInt32(message.ReadBytes(3).ToArray());
if (length > 0)
{
IByteBuffer packet = message.ReadBytes(length);
Engine.Locator.PacketController.Handle(client, packet);
}
}
}
base.ChannelRead(ctx, msg);
}
public void newData(string data)
{
switch (state)
{
case 0: //New stack
sb = new StringBuilder();
state = 1;
newData(data);
break;
case 1: //Message Header
sb.Append(data);
if (sb.Length == headersize)
{
waitFor = Base64Encoding.DecodeInt(sb.ToString());
sb = new StringBuilder();
state = 2;
}
break;
case 2: //Message
sb.Append(data);
if (sb.Length == waitFor)
{
stackDone = true;
state = 0;
}
break;
}
}
public static void HandleBytes(Session Session, ref byte[] Bytes)
{
if (Encoding.ASCII.GetString(Bytes) == "<policy-file-request/>\x0")
{
Session.Send(PolicyFileRequest);
return;
}
var Pointer = new int();
try
{
for (; Pointer < Bytes.Length;)
{
var MessageLength = Base64Encoding.DecodeInt32(new byte[] { Bytes[Pointer++], Bytes[Pointer++], Bytes[Pointer++] });
var MessageId = Base64Encoding.DecodeInt32(new byte[] { Bytes[Pointer++], Bytes[Pointer++] });
var ContextLength = (MessageLength - 2);
var Context = new byte[ContextLength];
Array.Copy(Bytes, Pointer, Context, 0, ContextLength);
Pointer += ContextLength;
var InMessage = new InMessage(MessageId, Context);
HandleEvent(Session, InMessage);
}
}
catch { }
}
public void Verify_Decode()
{
var e = new Base64Encoding();
var decoded = e.GetBytes(EncodedMessage);
Assert.AreEqual(Message, decoded);
}
private ClientMessage TryParseAsOldCrypto(byte[] packet)
{
try
{
int i = 0;
while (i < packet.Length)
{
int lenght = Base64Encoding.DecodeInt32(new byte[] { (byte)packet[i++], (byte)packet[i++], (byte)packet[i++] });
if (lenght > 0)
{
uint id = Base64Encoding.DecodeUInt32(new byte[] { (byte)packet[i++], (byte)packet[i++] });
if (id > 0)
{
byte[] bytes = new byte[lenght - 2];
for (int j = 0; j < bytes.Length; j++)
{
bytes[j] = packet[i++];
}
OldCryptoClientMessage crypto = new OldCryptoClientMessage();
crypto.Init(id, bytes);
return(crypto);
}
}
}
}
catch
{
return(null);
}
return(null);
}
private void WriteBase64Text(byte[] buffer, int offset, int count)
{
if (_base64Chars == null)
{
_base64Chars = new byte[512];
}
Base64Encoding encoding = XmlConverter.Base64Encoding;
while (count >= 3)
{
int byteCount = Math.Min(_base64Chars.Length / 4 * 3, count - count % 3);
int charCount = byteCount / 3 * 4;
encoding.GetChars(buffer, offset, byteCount, _base64Chars, 0);
_signingWriter.WriteText(_base64Chars, 0, charCount);
if (_text)
{
_writer.WriteText(_base64Chars, 0, charCount);
}
offset += byteCount;
count -= byteCount;
}
if (count > 0)
{
encoding.GetChars(buffer, offset, count, _base64Chars, 0);
_signingWriter.WriteText(_base64Chars, 0, 4);
if (_text)
{
_writer.WriteText(_base64Chars, 0, 4);
}
}
}
public void handlePacketData(byte[] data)
{
int pos = 0;
while (pos < data.Length)
{
try
{
int MessageLength = Base64Encoding.DecodeInt32(new byte[] { data[pos++], data[pos++], data[pos++] });
int MessageId = Base64Encoding.DecodeInt32(new byte[] { data[pos++], data[pos++] });
byte[] Content = new byte[MessageLength - 2];
for (int i = 0; i < Content.Length && pos < data.Length; i++)
{
Content[i] = data[pos++];
}
if (onNewPacket != null)
{
using (ClientMessage message = ClientMessageFactory.GetClientMessage(MessageId, Content))
{
onNewPacket.Invoke(message);
}
}
}
catch (Exception e)
{
Logging.HandleException(e, "packet handling");
con.Dispose();
}
}
}
public bool TryReadBase64(byte[] buffer, int offset, int count, out int actual)
{
if (this.type == ValueHandleType.Base64)
{
actual = Math.Min(this.length, count);
this.GetBase64(buffer, offset, actual);
this.offset += actual;
this.length -= actual;
return(true);
}
if (((this.type == ValueHandleType.UTF8) && (count >= 3)) && ((this.length % 4) == 0))
{
try
{
int charCount = Math.Min((count / 3) * 4, this.length);
actual = Base64Encoding.GetBytes(this.bufferReader.Buffer, this.offset, charCount, buffer, offset);
this.offset += charCount;
this.length -= charCount;
return(true);
}
catch (FormatException)
{
}
}
actual = 0;
return(false);
}
[Test] public void Base64()
{
// All bytes from 0 to ff
byte[] sbuf = new byte[256]; for (int i = 0; i != 256; ++i)
{
sbuf[i] = (byte)i;
}
byte[] dbuf = Encoding.ASCII.GetBytes("AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIj" +
"JCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZH" +
"SElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWpr" +
"bG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6P" +
"kJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKz" +
"tLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX" +
"2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7" +
"/P3+/w==");
int len = Base64Encoding.EncodeSize(sbuf.Length);
Assert.Equal(dbuf.Length, len);
int dst_length;
byte[] dst = new byte[len];
Base64Encoding.Encode(sbuf, dst, out dst_length);
Assert.Equal(dbuf.Length, dst_length);
for (int i = 0; i != dbuf.Length; ++i)
{
Assert.Equal(dbuf[i], dst[i]);
}
len = Base64Encoding.DecodeSize(dbuf.Length);
Assert.True(len >= sbuf.Length);
int src_length;
byte[] src = new byte[len];
Base64Encoding.Decode(dst, src, out src_length);
Assert.Equal(sbuf.Length, src_length);
for (int i = 0; i != sbuf.Length; ++i)
{
Assert.Equal(sbuf[i], src[i]);
}
// Random binary data
Random r = new Random();
for (int i = 0; i != sbuf.Length; ++i)
{
sbuf[i] = (byte)(r.Next(0xFF));
}
Base64Encoding.Encode(sbuf, dst, out dst_length);
Base64Encoding.Decode(dst, src, out src_length);
Assert.Equal(sbuf.Length, src_length);
for (int i = 0; i != sbuf.Length; ++i)
{
Assert.Equal(sbuf[i], src[i]);
}
}
public void Encode()
{
Base64Encoding e = new Base64Encoding();
i = "test";
o = e.Encode(i);
Assert.Equal(o, "dGVzdA==");
i = "test0";
o = e.Encode(i);
Assert.Equal(o, "dGVzdDA=");
i = "test00";
o = e.Encode(i);
Assert.Equal(o, "dGVzdDAw");
i = "test01";
o = e.Encode(i);
Assert.Equal(o, "dGVzdDAx");
i = "test000";
o = e.Encode(i);
Assert.Equal(o, "dGVzdDAwMA==");
o = e.Encode(new byte[] { 0, });
Assert.Equal(o, "AA==");
o = e.Encode(new byte[] { 0, 0, });
Assert.Equal(o, "AAA=");
o = e.Encode(new byte[] { 0, 0, 0, });
Assert.Equal(o, "AAAA");
i =
"Man is distinguished, not only by his reason, but by this singular passion from "
+
"other animals, which is a lust of the mind, that by a perseverance of delight "
+
"in the continued and indefatigable generation of knowledge, exceeds the short"
+
"vehemence of any carnal pleasure."
;
string o_encoded =
"TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz"
+
"IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg"
+
"dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu"
+
"dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRo"
+
"ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4="
;
o = e.Encode(i);
//Assert.Equal(o, o_encoded);
return;
}
public static string DecryptCookie(string str)
{
var base64 = Crypt.Decrypt(str, cookieKey);
string result = Base64Encoding.DecodeBase64(base64);
return(result);
}
/// <summary>
/// Handles a given amount of data in a given byte array, by attempting to parse messages from the received data and process them in the message handler.
/// </summary>
/// <param name="Data">The byte array with the data to process.</param>
/// <param name="numBytesToProcess">The actual amount of bytes in the byte array to process.</param>
public void HandleConnectionData(ref byte[] data)
{
// Gameclient protocol or policyrequest?
if (data[0] != 64)
{
IonEnvironment.GetLog().WriteInformation("Client " + mID + " sent non-gameclient message: " + IonEnvironment.GetDefaultTextEncoding().GetString(data));
string xmlPolicy =
"<?xml version=\"1.0\"?>\r\n" +
"<!DOCTYPE cross-domain-policy SYSTEM \"/xml/dtds/cross-domain-policy.dtd\">\r\n" +
"<cross-domain-policy>\r\n" +
"<allow-access-from domain=\"*\" to-ports=\"1-31111\" />\r\n" +
"</cross-domain-policy>\x0";
IonEnvironment.GetLog().WriteInformation("Client " + mID + ": sending XML cross domain policy file: " + xmlPolicy);
mConnection.SendData(xmlPolicy);
mMessageHandler.GetResponse().Initialize(ResponseOpcodes.SecretKey); // "@A"
mMessageHandler.GetResponse().Append("ION/Deltar");
mMessageHandler.SendResponse();
}
else
{
int pos = 0;
while (pos < data.Length)
{
try
{
// Total length of message (without this): 3 Base64 bytes
int messageLength = Base64Encoding.DecodeInt32(new byte[] { data[pos++], data[pos++], data[pos++] });
// ID of message: 2 Base64 bytes
uint messageID = Base64Encoding.DecodeUInt32(new byte[] { data[pos++], data[pos++] });
// Data of message: (messageLength - 2) bytes
byte[] Content = new byte[messageLength - 2];
for (int i = 0; i < Content.Length; i++)
{
Content[i] = data[pos++];
}
// Create message object
ClientMessage message = new ClientMessage(messageID, Content);
// Handle message object
mMessageHandler.HandleRequest(message);
}
catch (IndexOutOfRangeException) // Bad formatting!
{
IonEnvironment.GetHabboHotel().GetClients().StopClient(mID);
}
catch (Exception ex)
{
IonEnvironment.GetLog().WriteUnhandledExceptionError("GameClient.HandleConnectionData", ex);
}
}
}
}
public bool SendModCommandToServer(string command, int issuer, int target, string message)
{
StringBuilder sb = new StringBuilder();
sb.Append(Base64Encoding.EncodeInt(999, 2));
sb.Append(Base64Encoding.EncodeInt(command.Length, 2));
sb.Append(command);
sb.Append(Base64Encoding.EncodeInt(issuer.ToString().Length, 2));
sb.Append(issuer);
sb.Append(Base64Encoding.EncodeInt(target.ToString().Length, 2));
sb.Append(target);
sb.Append(Base64Encoding.EncodeInt(message.Length, 2));
sb.Append(message);
string packet = Base64Encoding.EncodeInt(sb.Length, 3) + sb.ToString();
IPEndPoint ip = new IPEndPoint(IPAddress.Parse("127.0.0.1"), int.Parse(Settings.ListenPort));
Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
server.Connect(ip);
}
catch
{
return(false);
}
byte[] data = new byte[1024];
int receivedDataLength = server.Receive(data);
string stringData = Encoding.ASCII.GetString(data, 0, receivedDataLength);
if (stringData == "@@" + Convert.ToChar(1))
{
server.Send(Encoding.ASCII.GetBytes(packet));
data = new byte[1024];
receivedDataLength = server.Receive(data);
stringData = Encoding.ASCII.GetString(data, 0, receivedDataLength);
}
server.Shutdown(SocketShutdown.Both);
server.Close();
if (stringData == "ACK")
{
return(true);
}
return(false);
}
public void HandleConnectionData(ref byte[] data)
{
if (data[0] == 64)
{
int pos = 0;
while (pos < data.Length)
{
try
{
int MessageLength = Base64Encoding.DecodeInt32(new byte[] { data[pos++], data[pos++], data[pos++] });
uint MessageId = Base64Encoding.DecodeUInt32(new byte[] { data[pos++], data[pos++] });
byte[] Content = new byte[MessageLength - 2];
for (int j = 0; j < Content.Length; j++)
{
Content[j] = data[pos++];
}
if (this.MessageHandler == null)
{
this.InitHandler();
}
ClientMessage Message = new ClientMessage(MessageId, Content);
if (Message != null)
{
try
{
if (int.Parse(PhoenixEnvironment.GetConfig().data["debug"]) == 1)
{
Logging.WriteLine(string.Concat(new object[] { "[", ClientId, "] --> [", Message.Id, "] ", Message.Header, Message.GetBody() }));
}
}
catch
{
}
MessageEvent MessageHandler;
if (PhoenixEnvironment.GetPacketManager().Get(Message.Id, out MessageHandler))
{
MessageHandler.parse(this, Message);
}
}
}
catch (Exception ex)
{
Logging.LogException("Error: " + ex.ToString());
this.Disconnect();
}
}
}
else
{
if (true)
{
this.Connection.SendData(CrossdomainPolicy.GetXmlPolicy());
this.Connection.Dispose();
}
}
}
public bool ReadByte(byte byte_) //returns if packet is fully readed
{
if (this.Lenght != null)
{
if (this.Packet == null)
{
this.Packet = new byte[(int)this.Lenght];
}
this.Packet[this.Pointer++] = byte_;
}
else
{
if (this.LenghtBytes == null)
{
if (this.RC4 == null)
{
this.LenghtBytes = new byte?[3] {
null, null, null
};
}
else
{
this.LenghtBytes = new byte?[6] {
null, null, null, null, null, null
};
}
}
int i = 0;
for (; i < this.LenghtBytes.Length; i++)
{
if (this.LenghtBytes[i] == null)
{
this.LenghtBytes[i] = byte_;
break;
}
}
if (i == this.LenghtBytes.Length - 1)
{
if (this.RC4 == null)
{
this.Lenght = Base64Encoding.DecodeInt32(this.LenghtBytes.Select(j => (byte)j).ToArray());
}
else
{
this.Lenght = Base64Encoding.DecodeInt32(this.RC4.Decipher(this.LenghtBytes.Select(j => (byte)j).ToArray(), false)) * 2;
}
}
return(false);
}
return(this.Pointer == this.Packet.Length);
}
private void btnB64Encode_Click(object sender, EventArgs e)
{
try
{
txtB64Output.Text = Base64Encoding.EncodeInt(int.Parse(txtBase64Input.Text), 2);
}
catch
{
MessageBox.Show("Invalid input.");
}
}
private void btnDecode64_Click(object sender, EventArgs e)
{
try
{
txtB64Output.Text = Base64Encoding.DecodeInt(txtBase64Input.Text).ToString();
}
catch
{
MessageBox.Show("Invalid input.");
}
}
public byte[] GetBytes()
{
byte[] buffer = new byte[this.Length + 3];
byte[] buffer2 = Base64Encoding.Encodeuint(this.MessageId, 2);
buffer[0] = buffer2[0];
buffer[1] = buffer2[1];
for (int i = 0; i < this.Length; i++)
{
buffer[i + 2] = this.Body[i];
}
buffer[buffer.Length - 1] = 1;
return(buffer);
}
public override byte[] GetBytes()
{
byte[] Data = new byte[this.GetLenght() + 3];
byte[] Header = Base64Encoding.Encodeuint(this.ID, 2);
Data[0] = Header[0];
Data[1] = Header[1];
for (int i = 0; i < this.GetLenght(); i++)
{
Data[i + 2] = this.Data[i];
}
Data[Data.Length - 1] = 1;
return(Data);
}
public byte[] GetBytes()
{
byte[] numArray1 = new byte[this.Length + 3];
byte[] numArray2 = Base64Encoding.Encodeuint(this.MessageId, 2);
numArray1[0] = numArray2[0];
numArray1[1] = numArray2[1];
for (int index = 0; index < this.Length; ++index)
{
numArray1[index + 2] = this.Body[index];
}
numArray1[numArray1.Length - 1] = (byte)1;
return(numArray1);
}
public void ConvertToString_Should_EncodeWhenProvidedWithBytes()
{
// Arrange
var expected = "TgBvAHcAIABpAHMAIAB0AGgAZQAgAHQAaQBtAGUAIABmAG8AcgAgAG" +
"EAbABsACAAZwBvAG8AZAAgAG0AZQBuACAAdABvACAAYwBvAG0AZQA=";
var b = Encoding.Unicode.GetBytes("Now is the time for all good men to come");
// Act
var actual = Base64Encoding.ToString(b);
// Assert
Assert.Equal(expected, actual);
}
public byte[] GetBytes()
{
byte[] Data = new byte[this.Length + 3];
byte[] Header = Base64Encoding.Encodeuint(this.MessageId, 2);
Data[0] = Header[0];
Data[1] = Header[1];
for (int i = 0; i < this.Length; i++)
{
Data[i + 2] = this.Body[i];
}
Data[Data.Length - 1] = 1;
return(Data);
}
private async Task AddObjectsToNode(string id)
{
IObjectsApi objectsApi =
GeneralTokenConfigurationSettings <IObjectsApi> .SetToken(new ObjectsApi(),
await _authServiceAdapter.GetSecondaryTokenTask());
var objectList = objectsApi.GetObjects(id);
foreach (KeyValuePair <string, dynamic> objInfo in new DynamicDictionaryItems(objectList.items))
{
nodes.Add(new TreeNode(Base64Encoding.Encode((string)objInfo.Value.objectId),
objInfo.Value.objectKey, "object", false));
}
}
private void NewMessage(string data)
{
string header = data.Substring(0, 2);
int headerId = Base64Encoding.DecodeInt(header);
string body = "";
if (data.Length > 2)
{
body = data.Substring(2);
}
mHeaderBody = header;
mHeaderID = headerId;
mPacketBody = body;
ProcessMessage();
}
/// <summary>
/// Converts this private key to an RSAParameters object.
/// </summary>
/// <returns>A RSAParameters instance containing the parameters from this key.</returns>
public RSAParameters ToParameters()
{
var parameters = new RSAParameters
{
InverseQ = Base64Encoding.ToBytes(Coefficient),
Exponent = Base64Encoding.ToBytes(Exponent),
Modulus = Base64Encoding.ToBytes(Modulus),
DP = Base64Encoding.ToBytes(PrimeExponentP),
DQ = Base64Encoding.ToBytes(PrimeExponentQ),
P = Base64Encoding.ToBytes(PrimeP),
Q = Base64Encoding.ToBytes(PrimeQ),
D = Base64Encoding.ToBytes(PrivateExponent)
};
return(parameters);
}
public void TestCtor()
{
try // null alphabet
{
var x = new Base64Encoding(null, Base64Encoding.Mime.LookupTable, '=');
Assert.Fail(typeof(ArgumentNullException).ToString());
}
catch (ArgumentNullException)
{
}
try // bad length alphabet
{
var x = new Base64Encoding("1245645", Base64Encoding.Mime.LookupTable, null);
Assert.Fail(typeof(ArgumentException).ToString());
}
catch (ArgumentException)
{
}
try // look-up table null
{
var x = new Base64Encoding(Base64Encoding.Mime.Alphabet, null, '=');
Assert.Fail(typeof(ArgumentNullException).ToString());
}
catch (ArgumentNullException)
{
}
try // look-up table bad length
{
var x = new Base64Encoding(Base64Encoding.Mime.Alphabet, new Byte[20], null);
Assert.Fail(typeof(ArgumentNullException).ToString());
}
catch (ArgumentException)
{
}
}
/// <summary>
/// <see>http://nodejs.org/docs/v0.4.8/api/streams.html#stream.end</see>
/// </summary>
public override void end(string data, string encoding)
{
Encoding e = null;
switch (encoding)
{
case "ascii":
e = Encoding.ASCII;
break;
case "utf8":
e = Encoding.UTF8;
break;
case "base64":
e = new Base64Encoding();
break;
}
if (e == null)
throw new NotSupportedException(); // TODO: Should this raise OnError?
// Send it across via a NodeBuffer.
byte[] encoded = e.GetBytes(data);
this.end(new NodeBuffer(this.Env, encoded, 0, encoded.Length));
}
public Vigenere64()
: base()
{
_b64 = new Base64Encoding();
}
public static TryResult<String> TryToBase64String(Value128 data, Base64Encoding base64Encoding)
{
if (base64Encoding == null)
{
return encodeFailResult;
}
Char[] result;
// Get padding symbol
var paddingSymbol = base64Encoding.PaddingSymbol;
if (paddingSymbol.HasValue)
{
result = new Char[24];
result[22] = result[23] = paddingSymbol.Value;
}
else
{
result = new Char[22];
}
var higherHalf = data.HigherHalf;
var lowerHalf = data.LowerHalf;
// Get alphabet
var alphabet = base64Encoding.Alphabet;
for (Int32 indexH = 0, indexL = 11, shiftH = 58, shiftL = 56; indexH < 10; indexH++, indexL++, shiftH -= 6, shiftL -= 6)
{
result[indexH] = alphabet[(Int32) (higherHalf >> shiftH) & 0x3F];
result[indexL] = alphabet[(Int32) (lowerHalf >> shiftL) & 0x3F];
}
result[10] = alphabet[(Int32) (((higherHalf << 2) & 0x3C) | ((lowerHalf >> 62) & 0x03))];
result[21] = alphabet[(Int32) ((lowerHalf << 4) & 0x30)];
return TryResult<String>.CreateSuccess(new String(result));
}
public static TryResult<Value128> TryFromBase64String(String data, Int32 offset, Base64Encoding base64Encoding)
{
// Check input values
if ((data == null) || (offset > data.Length - base64EncodedSymbolsCount) || (base64Encoding == null))
{
return convertFailResult;
}
// Get look-up table
var lookupTable = base64Encoding.LookupTable;
var lastIndex = offset + 10;
var symbol10 = (UInt64) lookupTable[data[lastIndex] & 0x7F];
var symbol21 = (UInt64) lookupTable[data[offset + 21] & 0x7F];
// Check symbol
if ((symbol10 | symbol21) == 0xFF)
{
return convertFailResult;
}
// Calculate higher half
var higherHalf = symbol10 >> 2;
// Calculate lower half
var lowerHalf = symbol10 << 62 | symbol21 >> 4;
// Decode symbols
for (Int32 indexH = offset, indexL = offset + 11, shiftH = 58, shiftL = 56; indexH < lastIndex; indexH++, indexL++, shiftH -= 6, shiftL -= 6)
{
// Get symbols
var symbolH = data[indexH] & 0x7F;
var symbolL = data[indexL] & 0x7F;
// Get symbols values
var symbolHValue = (UInt64) lookupTable[symbolH];
var symbolLValue = (UInt64) lookupTable[symbolL];
// Check symbol
if ((symbolHValue | symbolLValue) == 0xFF)
{
return convertFailResult;
}
higherHalf |= symbolHValue << shiftH;
lowerHalf |= symbolLValue << shiftL;
}
// Initialize a new instance
var result = new Value128(higherHalf, lowerHalf);
return TryResult<Value128>.CreateSuccess(result);
}
