helpy4/Minecraft-Console-Client
1
0
Fork 0
mirror of https://github.com/MCCTeam/Minecraft-Console-Client synced 2025-11-07 17:36:07 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Major performance optimization and bug fixes

Browse source 
Bug fix & Performance Optimization
This commit is contained in:
Anon 2022-09-05 11:57:17 +00:00 • committed by GitHub
commit e56139a56d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
56 changed files with 1094 additions and 3168 deletions
Download patch file Download diff file Expand all files Collapse all files

2
MinecraftClient/ChatBots/ChatLog.cs
View file

@ -70,7 +70,7 @@ namespace MinecraftClient.ChatBots
public static MessageFilter str2filter(string filtername) public static MessageFilter str2filter(string filtername)
{ {
switch (filtername.ToLower()) switch (Settings.ToLowerIfNeed(filtername))
{ {
case "all": return MessageFilter.AllText; case "all": return MessageFilter.AllText;
case "messages": return MessageFilter.AllMessages; case "messages": return MessageFilter.AllMessages;

15
MinecraftClient/Commands/Move.cs
View file

@ -71,9 +71,16 @@ namespace MinecraftClient.Commands
case "get": return handler.GetCurrentLocation().ToString(); case "get": return handler.GetCurrentLocation().ToString();
default: return Translations.Get("cmd.look.unknown", args[0]); default: return Translations.Get("cmd.look.unknown", args[0]);
} }
Location goal = Movement.Move(handler.GetCurrentLocation(), direction);
ChunkColumn? chunkColumn = handler.GetWorld().GetChunkColumn(goal);
if (chunkColumn == null || chunkColumn.FullyLoaded == false)
return Translations.Get("cmd.move.chunk_not_loaded");
if (Movement.CanMove(handler.GetWorld(), handler.GetCurrentLocation(), direction)) if (Movement.CanMove(handler.GetWorld(), handler.GetCurrentLocation(), direction))
{ {
if (handler.MoveTo(Movement.Move(handler.GetCurrentLocation(), direction), allowUnsafe: takeRisk)) if (handler.MoveTo(goal, allowUnsafe: takeRisk))
return Translations.Get("cmd.move.moving", args[0]); return Translations.Get("cmd.move.moving", args[0]);
else return takeRisk ? Translations.Get("cmd.move.dir_fail") : Translations.Get("cmd.move.suggestforce"); else return takeRisk ? Translations.Get("cmd.move.dir_fail") : Translations.Get("cmd.move.suggestforce");
} }
@ -88,12 +95,12 @@ namespace MinecraftClient.Commands
int z = int.Parse(args[2]); int z = int.Parse(args[2]);
Location goal = new Location(x, y, z); Location goal = new Location(x, y, z);
if (handler.GetWorld().GetChunkColumn(goal) == null || handler.GetWorld().GetChunkColumn(goal).FullyLoaded == false) ChunkColumn? chunkColumn = handler.GetWorld().GetChunkColumn(goal);
if (chunkColumn == null || chunkColumn.FullyLoaded == false)
return Translations.Get("cmd.move.chunk_not_loaded"); return Translations.Get("cmd.move.chunk_not_loaded");
Location current = handler.GetCurrentLocation(); Location current = handler.GetCurrentLocation();
Location currentCenter = new Location(Math.Floor(current.X) + 0.5, current.Y, Math.Floor(current.Z) + 0.5); handler.MoveTo(current.ToCenter(), allowDirectTeleport: true);
handler.MoveTo(currentCenter, allowDirectTeleport: true);
if (handler.MoveTo(goal, allowUnsafe: takeRisk)) if (handler.MoveTo(goal, allowUnsafe: takeRisk))
return Translations.Get("cmd.move.walk", goal, current); return Translations.Get("cmd.move.walk", goal, current);

2
MinecraftClient/ConsoleIO.cs
View file

@ -163,7 +163,7 @@ namespace MinecraftClient
{ {
if (!acceptnewlines) if (!acceptnewlines)
text = text.Replace('\n', ' '); text = text.Replace('\n', ' ');
WriteLineFormatted(LogPrefix + text); WriteLineFormatted(LogPrefix + text, acceptnewlines);
} }
#region Subfunctions #region Subfunctions

210
MinecraftClient/Crypto/AesCfb8Stream.cs Normal file
View file

@ -0,0 +1,210 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Security.Cryptography;
using System.IO;
using System.Collections.Concurrent;
using System.Runtime.CompilerServices;
namespace MinecraftClient.Crypto
{
public class AesCfb8Stream : Stream
{
public static readonly int blockSize = 16;
private readonly Aes? Aes = null;
private readonly FastAes? FastAes = null;
private bool inStreamEnded = false;
private byte[] ReadStreamIV = new byte[16];
private byte[] WriteStreamIV = new byte[16];
public Stream BaseStream { get; set; }
public AesCfb8Stream(Stream stream, byte[] key)
{
BaseStream = stream;
if (FastAes.IsSupported())
FastAes = new FastAes(key);
else
{
Aes = Aes.Create();
Aes.BlockSize = 128;
Aes.KeySize = 128;
Aes.Key = key;
Aes.Mode = CipherMode.ECB;
Aes.Padding = PaddingMode.None;
}
Array.Copy(key, ReadStreamIV, 16);
Array.Copy(key, WriteStreamIV, 16);
}
public override bool CanRead
{
get { return true; }
}
public override bool CanSeek
{
get { return false; }
}
public override bool CanWrite
{
get { return true; }
}
public override void Flush()
{
BaseStream.Flush();
}
public override long Length
{
get { throw new NotSupportedException(); }
}
public override long Position
{
get
{
throw new NotSupportedException();
}
set
{
throw new NotSupportedException();
}
}
public override int ReadByte()
{
if (inStreamEnded)
return -1;
int inputBuf = BaseStream.ReadByte();
if (inputBuf == -1)
{
inStreamEnded = true;
return -1;
}
Span<byte> blockOutput = stackalloc byte[blockSize];
if (FastAes != null)
FastAes.EncryptEcb(ReadStreamIV, blockOutput);
else
Aes!.EncryptEcb(ReadStreamIV, blockOutput, PaddingMode.None);
// Shift left
Array.Copy(ReadStreamIV, 1, ReadStreamIV, 0, blockSize - 1);
ReadStreamIV[blockSize - 1] = (byte)inputBuf;
return (byte)(blockOutput[0] ^ inputBuf);
}
[MethodImpl(MethodImplOptions.AggressiveOptimization)]
public override int Read(byte[] buffer, int outOffset, int required)
{
if (inStreamEnded)
return 0;
Span<byte> blockOutput = FastAes != null ? stackalloc byte[blockSize] : null;
byte[] inputBuf = new byte[blockSize + required];
Array.Copy(ReadStreamIV, inputBuf, blockSize);
for (int readed = 0, curRead; readed < required; readed += curRead)
{
curRead = BaseStream.Read(inputBuf, blockSize + readed, required - readed);
if (curRead == 0)
{
inStreamEnded = true;
return readed;
}
int processEnd = readed + curRead;
if (FastAes != null)
{
for (int idx = readed; idx < processEnd; idx++)
{
ReadOnlySpan<byte> blockInput = new(inputBuf, idx, blockSize);
FastAes.EncryptEcb(blockInput, blockOutput);
buffer[outOffset + idx] = (byte)(blockOutput[0] ^ inputBuf[idx + blockSize]);
}
}
else
{
OrderablePartitioner<Tuple<int, int>> rangePartitioner = curRead <= 256 ?
Partitioner.Create(readed, processEnd, 32) : Partitioner.Create(readed, processEnd);
Parallel.ForEach(rangePartitioner, (range, loopState) =>
{
Span<byte> blockOutput = stackalloc byte[blockSize];
for (int idx = range.Item1; idx < range.Item2; idx++)
{
ReadOnlySpan<byte> blockInput = new(inputBuf, idx, blockSize);
Aes!.EncryptEcb(blockInput, blockOutput, PaddingMode.None);
buffer[outOffset + idx] = (byte)(blockOutput[0] ^ inputBuf[idx + blockSize]);
}
});
}
}
Array.Copy(inputBuf, required, ReadStreamIV, 0, blockSize);
return required;
}
public override long Seek(long offset, SeekOrigin origin)
{
throw new NotSupportedException();
}
public override void SetLength(long value)
{
throw new NotSupportedException();
}
public override void WriteByte(byte b)
{
Span<byte> blockOutput = stackalloc byte[blockSize];
if (FastAes != null)
FastAes.EncryptEcb(WriteStreamIV, blockOutput);
else
Aes!.EncryptEcb(WriteStreamIV, blockOutput, PaddingMode.None);
byte outputBuf = (byte)(blockOutput[0] ^ b);
BaseStream.WriteByte(outputBuf);
// Shift left
Array.Copy(WriteStreamIV, 1, WriteStreamIV, 0, blockSize - 1);
WriteStreamIV[blockSize - 1] = outputBuf;
}
[MethodImpl(MethodImplOptions.AggressiveOptimization)]
public override void Write(byte[] input, int offset, int required)
{
byte[] outputBuf = new byte[blockSize + required];
Array.Copy(WriteStreamIV, outputBuf, blockSize);
Span<byte> blockOutput = stackalloc byte[blockSize];
for (int wirtten = 0; wirtten < required; ++wirtten)
{
ReadOnlySpan<byte> blockInput = new(outputBuf, wirtten, blockSize);
if (FastAes != null)
FastAes.EncryptEcb(blockInput, blockOutput);
else
Aes!.EncryptEcb(blockInput, blockOutput, PaddingMode.None);
outputBuf[blockSize + wirtten] = (byte)(blockOutput[0] ^ input[offset + wirtten]);
}
BaseStream.WriteAsync(outputBuf, blockSize, required);
Array.Copy(outputBuf, required, WriteStreamIV, 0, blockSize);
}
}
}

17
MinecraftClient/Crypto/CryptoHandler.cs
View file

@ -11,8 +11,10 @@ namespace MinecraftClient.Crypto
/// Methods for handling all the crypto stuff: RSA (Encryption Key Request), AES (Encrypted Stream), SHA-1 (Server Hash). /// Methods for handling all the crypto stuff: RSA (Encryption Key Request), AES (Encrypted Stream), SHA-1 (Server Hash).
/// </summary> /// </summary>
public class CryptoHandler public static class CryptoHandler
{ {
public static byte[]? ClientAESPrivateKey = null;
/// <summary> /// <summary>
/// Get a cryptographic service for encrypting data using the server's RSA public key /// Get a cryptographic service for encrypting data using the server's RSA public key
/// </summary> /// </summary>
@ -191,18 +193,5 @@ namespace MinecraftClient.Crypto
} }
return p; return p;
} }
/// <summary>
/// Get a new AES-encrypted stream for wrapping a non-encrypted stream.
/// </summary>
/// <param name="underlyingStream">Stream to encrypt</param>
/// <param name="AesKey">Key to use</param>
/// <returns>Return an appropriate stream depending on the framework being used</returns>
public static IAesStream getAesStream(Stream underlyingStream, byte[] AesKey)
{
// return new Streams.RegularAesStream(underlyingStream, AesKey);
return new Streams.MonoAesStream(underlyingStream, AesKey);
}
} }
} }

99
MinecraftClient/Crypto/FastAes.cs Normal file
View file

@ -0,0 +1,99 @@
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;
namespace MinecraftClient.Crypto
{
// Using the AES-NI instruction set
// https://gist.github.com/Thealexbarney/9f75883786a9f3100408ff795fb95d85
public class FastAes
{
private Vector128<byte>[] RoundKeys { get; }
public FastAes(Span<byte> key)
{
RoundKeys = KeyExpansion(key);
}
/// <summary>
/// Detects if the required instruction set is supported
/// </summary>
/// <returns>Is it supported</returns>
public static bool IsSupported()
{
return Sse2.IsSupported && Aes.IsSupported;
}
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public void EncryptEcb(ReadOnlySpan<byte> plaintext, Span<byte> destination)
{
Vector128<byte>[] keys = RoundKeys;
ReadOnlySpan<Vector128<byte>> blocks = MemoryMarshal.Cast<byte, Vector128<byte>>(plaintext);
Span<Vector128<byte>> dest = MemoryMarshal.Cast<byte, Vector128<byte>>(destination);
// Makes the JIT remove all the other range checks on keys
_ = keys[10];
for (int i = 0; i < blocks.Length; i++)
{
Vector128<byte> b = blocks[i];
b = Sse2.Xor(b, keys[0]);
b = Aes.Encrypt(b, keys[1]);
b = Aes.Encrypt(b, keys[2]);
b = Aes.Encrypt(b, keys[3]);
b = Aes.Encrypt(b, keys[4]);
b = Aes.Encrypt(b, keys[5]);
b = Aes.Encrypt(b, keys[6]);
b = Aes.Encrypt(b, keys[7]);
b = Aes.Encrypt(b, keys[8]);
b = Aes.Encrypt(b, keys[9]);
b = Aes.EncryptLast(b, keys[10]);
dest[i] = b;
}
}
private static Vector128<byte>[] KeyExpansion(Span<byte> key)
{
var keys = new Vector128<byte>[20];
keys[0] = Unsafe.ReadUnaligned<Vector128<byte>>(ref key[0]);
MakeRoundKey(keys, 1, 0x01);
MakeRoundKey(keys, 2, 0x02);
MakeRoundKey(keys, 3, 0x04);
MakeRoundKey(keys, 4, 0x08);
MakeRoundKey(keys, 5, 0x10);
MakeRoundKey(keys, 6, 0x20);
MakeRoundKey(keys, 7, 0x40);
MakeRoundKey(keys, 8, 0x80);
MakeRoundKey(keys, 9, 0x1b);
MakeRoundKey(keys, 10, 0x36);
for (int i = 1; i < 10; i++)
{
keys[10 + i] = Aes.InverseMixColumns(keys[i]);
}
return keys;
}
private static void MakeRoundKey(Vector128<byte>[] keys, int i, byte rcon)
{
Vector128<byte> s = keys[i - 1];
Vector128<byte> t = keys[i - 1];
t = Aes.KeygenAssist(t, rcon);
t = Sse2.Shuffle(t.AsUInt32(), 0xFF).AsByte();
s = Sse2.Xor(s, Sse2.ShiftLeftLogical128BitLane(s, 4));
s = Sse2.Xor(s, Sse2.ShiftLeftLogical128BitLane(s, 8));
keys[i] = Sse2.Xor(s, t);
}
}
}

18
MinecraftClient/Crypto/IAesStream.cs
View file

@ -1,18 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace MinecraftClient.Crypto
{
/// <summary>
/// Interface for AES stream
/// Allows to use a different implementation depending on the framework being used.
/// </summary>
public interface IAesStream
{
int Read(byte[] buffer, int offset, int count);
void Write(byte[] buffer, int offset, int count);
}
}

855
MinecraftClient/Crypto/Streams/BouncyAes/AesFastEngine.cs
View file

@ -1,855 +0,0 @@
using System;
using System.Diagnostics;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Crypto.Utilities;
namespace Org.BouncyCastle.Crypto.Engines
{
/**
* an implementation of the AES (Rijndael)), from FIPS-197.
* <p>
* For further details see: <a href="http://csrc.nist.gov/encryption/aes/">http://csrc.nist.gov/encryption/aes/</a>.
*
* This implementation is based on optimizations from Dr. Brian Gladman's paper and C code at
* <a href="http://fp.gladman.plus.com/cryptography_technology/rijndael/">http://fp.gladman.plus.com/cryptography_technology/rijndael/</a>
*
* There are three levels of tradeoff of speed vs memory
* Because java has no preprocessor), they are written as three separate classes from which to choose
*
* The fastest uses 8Kbytes of static tables to precompute round calculations), 4 256 word tables for encryption
* and 4 for decryption.
*
* The middle performance version uses only one 256 word table for each), for a total of 2Kbytes),
* adding 12 rotate operations per round to compute the values contained in the other tables from
* the contents of the first
*
* The slowest version uses no static tables at all and computes the values in each round
* </p>
* <p>
* This file contains the fast version with 8Kbytes of static tables for round precomputation
* </p>
*/
public class AesFastEngine
: IBlockCipher
{
// The S box
private static readonly byte[] S =
{
99, 124, 119, 123, 242, 107, 111, 197,
48, 1, 103, 43, 254, 215, 171, 118,
202, 130, 201, 125, 250, 89, 71, 240,
173, 212, 162, 175, 156, 164, 114, 192,
183, 253, 147, 38, 54, 63, 247, 204,
52, 165, 229, 241, 113, 216, 49, 21,
4, 199, 35, 195, 24, 150, 5, 154,
7, 18, 128, 226, 235, 39, 178, 117,
9, 131, 44, 26, 27, 110, 90, 160,
82, 59, 214, 179, 41, 227, 47, 132,
83, 209, 0, 237, 32, 252, 177, 91,
106, 203, 190, 57, 74, 76, 88, 207,
208, 239, 170, 251, 67, 77, 51, 133,
69, 249, 2, 127, 80, 60, 159, 168,
81, 163, 64, 143, 146, 157, 56, 245,
188, 182, 218, 33, 16, 255, 243, 210,
205, 12, 19, 236, 95, 151, 68, 23,
196, 167, 126, 61, 100, 93, 25, 115,
96, 129, 79, 220, 34, 42, 144, 136,
70, 238, 184, 20, 222, 94, 11, 219,
224, 50, 58, 10, 73, 6, 36, 92,
194, 211, 172, 98, 145, 149, 228, 121,
231, 200, 55, 109, 141, 213, 78, 169,
108, 86, 244, 234, 101, 122, 174, 8,
186, 120, 37, 46, 28, 166, 180, 198,
232, 221, 116, 31, 75, 189, 139, 138,
112, 62, 181, 102, 72, 3, 246, 14,
97, 53, 87, 185, 134, 193, 29, 158,
225, 248, 152, 17, 105, 217, 142, 148,
155, 30, 135, 233, 206, 85, 40, 223,
140, 161, 137, 13, 191, 230, 66, 104,
65, 153, 45, 15, 176, 84, 187, 22,
};
// The inverse S-box
private static readonly byte[] Si =
{
82, 9, 106, 213, 48, 54, 165, 56,
191, 64, 163, 158, 129, 243, 215, 251,
124, 227, 57, 130, 155, 47, 255, 135,
52, 142, 67, 68, 196, 222, 233, 203,
84, 123, 148, 50, 166, 194, 35, 61,
238, 76, 149, 11, 66, 250, 195, 78,
8, 46, 161, 102, 40, 217, 36, 178,
118, 91, 162, 73, 109, 139, 209, 37,
114, 248, 246, 100, 134, 104, 152, 22,
212, 164, 92, 204, 93, 101, 182, 146,
108, 112, 72, 80, 253, 237, 185, 218,
94, 21, 70, 87, 167, 141, 157, 132,
144, 216, 171, 0, 140, 188, 211, 10,
247, 228, 88, 5, 184, 179, 69, 6,
208, 44, 30, 143, 202, 63, 15, 2,
193, 175, 189, 3, 1, 19, 138, 107,
58, 145, 17, 65, 79, 103, 220, 234,
151, 242, 207, 206, 240, 180, 230, 115,
150, 172, 116, 34, 231, 173, 53, 133,
226, 249, 55, 232, 28, 117, 223, 110,
71, 241, 26, 113, 29, 41, 197, 137,
111, 183, 98, 14, 170, 24, 190, 27,
252, 86, 62, 75, 198, 210, 121, 32,
154, 219, 192, 254, 120, 205, 90, 244,
31, 221, 168, 51, 136, 7, 199, 49,
177, 18, 16, 89, 39, 128, 236, 95,
96, 81, 127, 169, 25, 181, 74, 13,
45, 229, 122, 159, 147, 201, 156, 239,
160, 224, 59, 77, 174, 42, 245, 176,
200, 235, 187, 60, 131, 83, 153, 97,
23, 43, 4, 126, 186, 119, 214, 38,
225, 105, 20, 99, 85, 33, 12, 125,
};
// vector used in calculating key schedule (powers of x in GF(256))
private static readonly byte[] rcon =
{
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91
};
// precomputation tables of calculations for rounds
private static readonly uint[] T0 =
{
0xa56363c6, 0x847c7cf8, 0x997777ee, 0x8d7b7bf6, 0x0df2f2ff,
0xbd6b6bd6, 0xb16f6fde, 0x54c5c591, 0x50303060, 0x03010102,
0xa96767ce, 0x7d2b2b56, 0x19fefee7, 0x62d7d7b5, 0xe6abab4d,
0x9a7676ec, 0x45caca8f, 0x9d82821f, 0x40c9c989, 0x877d7dfa,
0x15fafaef, 0xeb5959b2, 0xc947478e, 0x0bf0f0fb, 0xecadad41,
0x67d4d4b3, 0xfda2a25f, 0xeaafaf45, 0xbf9c9c23, 0xf7a4a453,
0x967272e4, 0x5bc0c09b, 0xc2b7b775, 0x1cfdfde1, 0xae93933d,
0x6a26264c, 0x5a36366c, 0x413f3f7e, 0x02f7f7f5, 0x4fcccc83,
0x5c343468, 0xf4a5a551, 0x34e5e5d1, 0x08f1f1f9, 0x937171e2,
0x73d8d8ab, 0x53313162, 0x3f15152a, 0x0c040408, 0x52c7c795,
0x65232346, 0x5ec3c39d, 0x28181830, 0xa1969637, 0x0f05050a,
0xb59a9a2f, 0x0907070e, 0x36121224, 0x9b80801b, 0x3de2e2df,
0x26ebebcd, 0x6927274e, 0xcdb2b27f, 0x9f7575ea, 0x1b090912,
0x9e83831d, 0x742c2c58, 0x2e1a1a34, 0x2d1b1b36, 0xb26e6edc,
0xee5a5ab4, 0xfba0a05b, 0xf65252a4, 0x4d3b3b76, 0x61d6d6b7,
0xceb3b37d, 0x7b292952, 0x3ee3e3dd, 0x712f2f5e, 0x97848413,
0xf55353a6, 0x68d1d1b9, 0x00000000, 0x2cededc1, 0x60202040,
0x1ffcfce3, 0xc8b1b179, 0xed5b5bb6, 0xbe6a6ad4, 0x46cbcb8d,
0xd9bebe67, 0x4b393972, 0xde4a4a94, 0xd44c4c98, 0xe85858b0,
0x4acfcf85, 0x6bd0d0bb, 0x2aefefc5, 0xe5aaaa4f, 0x16fbfbed,
0xc5434386, 0xd74d4d9a, 0x55333366, 0x94858511, 0xcf45458a,
0x10f9f9e9, 0x06020204, 0x817f7ffe, 0xf05050a0, 0x443c3c78,
0xba9f9f25, 0xe3a8a84b, 0xf35151a2, 0xfea3a35d, 0xc0404080,
0x8a8f8f05, 0xad92923f, 0xbc9d9d21, 0x48383870, 0x04f5f5f1,
0xdfbcbc63, 0xc1b6b677, 0x75dadaaf, 0x63212142, 0x30101020,
0x1affffe5, 0x0ef3f3fd, 0x6dd2d2bf, 0x4ccdcd81, 0x140c0c18,
0x35131326, 0x2fececc3, 0xe15f5fbe, 0xa2979735, 0xcc444488,
0x3917172e, 0x57c4c493, 0xf2a7a755, 0x827e7efc, 0x473d3d7a,
0xac6464c8, 0xe75d5dba, 0x2b191932, 0x957373e6, 0xa06060c0,
0x98818119, 0xd14f4f9e, 0x7fdcdca3, 0x66222244, 0x7e2a2a54,
0xab90903b, 0x8388880b, 0xca46468c, 0x29eeeec7, 0xd3b8b86b,
0x3c141428, 0x79dedea7, 0xe25e5ebc, 0x1d0b0b16, 0x76dbdbad,
0x3be0e0db, 0x56323264, 0x4e3a3a74, 0x1e0a0a14, 0xdb494992,
0x0a06060c, 0x6c242448, 0xe45c5cb8, 0x5dc2c29f, 0x6ed3d3bd,
0xefacac43, 0xa66262c4, 0xa8919139, 0xa4959531, 0x37e4e4d3,
0x8b7979f2, 0x32e7e7d5, 0x43c8c88b, 0x5937376e, 0xb76d6dda,
0x8c8d8d01, 0x64d5d5b1, 0xd24e4e9c, 0xe0a9a949, 0xb46c6cd8,
0xfa5656ac, 0x07f4f4f3, 0x25eaeacf, 0xaf6565ca, 0x8e7a7af4,
0xe9aeae47, 0x18080810, 0xd5baba6f, 0x887878f0, 0x6f25254a,
0x722e2e5c, 0x241c1c38, 0xf1a6a657, 0xc7b4b473, 0x51c6c697,
0x23e8e8cb, 0x7cdddda1, 0x9c7474e8, 0x211f1f3e, 0xdd4b4b96,
0xdcbdbd61, 0x868b8b0d, 0x858a8a0f, 0x907070e0, 0x423e3e7c,
0xc4b5b571, 0xaa6666cc, 0xd8484890, 0x05030306, 0x01f6f6f7,
0x120e0e1c, 0xa36161c2, 0x5f35356a, 0xf95757ae, 0xd0b9b969,
0x91868617, 0x58c1c199, 0x271d1d3a, 0xb99e9e27, 0x38e1e1d9,
0x13f8f8eb, 0xb398982b, 0x33111122, 0xbb6969d2, 0x70d9d9a9,
0x898e8e07, 0xa7949433, 0xb69b9b2d, 0x221e1e3c, 0x92878715,
0x20e9e9c9, 0x49cece87, 0xff5555aa, 0x78282850, 0x7adfdfa5,
0x8f8c8c03, 0xf8a1a159, 0x80898909, 0x170d0d1a, 0xdabfbf65,
0x31e6e6d7, 0xc6424284, 0xb86868d0, 0xc3414182, 0xb0999929,
0x772d2d5a, 0x110f0f1e, 0xcbb0b07b, 0xfc5454a8, 0xd6bbbb6d,
0x3a16162c
};
private static readonly uint[] T1 =
{
0x6363c6a5, 0x7c7cf884, 0x7777ee99, 0x7b7bf68d, 0xf2f2ff0d,
0x6b6bd6bd, 0x6f6fdeb1, 0xc5c59154, 0x30306050, 0x01010203,
0x6767cea9, 0x2b2b567d, 0xfefee719, 0xd7d7b562, 0xabab4de6,
0x7676ec9a, 0xcaca8f45, 0x82821f9d, 0xc9c98940, 0x7d7dfa87,
0xfafaef15, 0x5959b2eb, 0x47478ec9, 0xf0f0fb0b, 0xadad41ec,
0xd4d4b367, 0xa2a25ffd, 0xafaf45ea, 0x9c9c23bf, 0xa4a453f7,
0x7272e496, 0xc0c09b5b, 0xb7b775c2, 0xfdfde11c, 0x93933dae,
0x26264c6a, 0x36366c5a, 0x3f3f7e41, 0xf7f7f502, 0xcccc834f,
0x3434685c, 0xa5a551f4, 0xe5e5d134, 0xf1f1f908, 0x7171e293,
0xd8d8ab73, 0x31316253, 0x15152a3f, 0x0404080c, 0xc7c79552,
0x23234665, 0xc3c39d5e, 0x18183028, 0x969637a1, 0x05050a0f,
0x9a9a2fb5, 0x07070e09, 0x12122436, 0x80801b9b, 0xe2e2df3d,
0xebebcd26, 0x27274e69, 0xb2b27fcd, 0x7575ea9f, 0x0909121b,
0x83831d9e, 0x2c2c5874, 0x1a1a342e, 0x1b1b362d, 0x6e6edcb2,
0x5a5ab4ee, 0xa0a05bfb, 0x5252a4f6, 0x3b3b764d, 0xd6d6b761,
0xb3b37dce, 0x2929527b, 0xe3e3dd3e, 0x2f2f5e71, 0x84841397,
0x5353a6f5, 0xd1d1b968, 0x00000000, 0xededc12c, 0x20204060,
0xfcfce31f, 0xb1b179c8, 0x5b5bb6ed, 0x6a6ad4be, 0xcbcb8d46,
0xbebe67d9, 0x3939724b, 0x4a4a94de, 0x4c4c98d4, 0x5858b0e8,
0xcfcf854a, 0xd0d0bb6b, 0xefefc52a, 0xaaaa4fe5, 0xfbfbed16,
0x434386c5, 0x4d4d9ad7, 0x33336655, 0x85851194, 0x45458acf,
0xf9f9e910, 0x02020406, 0x7f7ffe81, 0x5050a0f0, 0x3c3c7844,
0x9f9f25ba, 0xa8a84be3, 0x5151a2f3, 0xa3a35dfe, 0x404080c0,
0x8f8f058a, 0x92923fad, 0x9d9d21bc, 0x38387048, 0xf5f5f104,
0xbcbc63df, 0xb6b677c1, 0xdadaaf75, 0x21214263, 0x10102030,
0xffffe51a, 0xf3f3fd0e, 0xd2d2bf6d, 0xcdcd814c, 0x0c0c1814,
0x13132635, 0xececc32f, 0x5f5fbee1, 0x979735a2, 0x444488cc,
0x17172e39, 0xc4c49357, 0xa7a755f2, 0x7e7efc82, 0x3d3d7a47,
0x6464c8ac, 0x5d5dbae7, 0x1919322b, 0x7373e695, 0x6060c0a0,
0x81811998, 0x4f4f9ed1, 0xdcdca37f, 0x22224466, 0x2a2a547e,
0x90903bab, 0x88880b83, 0x46468cca, 0xeeeec729, 0xb8b86bd3,
0x1414283c, 0xdedea779, 0x5e5ebce2, 0x0b0b161d, 0xdbdbad76,
0xe0e0db3b, 0x32326456, 0x3a3a744e, 0x0a0a141e, 0x494992db,
0x06060c0a, 0x2424486c, 0x5c5cb8e4, 0xc2c29f5d, 0xd3d3bd6e,
0xacac43ef, 0x6262c4a6, 0x919139a8, 0x959531a4, 0xe4e4d337,
0x7979f28b, 0xe7e7d532, 0xc8c88b43, 0x37376e59, 0x6d6ddab7,
0x8d8d018c, 0xd5d5b164, 0x4e4e9cd2, 0xa9a949e0, 0x6c6cd8b4,
0x5656acfa, 0xf4f4f307, 0xeaeacf25, 0x6565caaf, 0x7a7af48e,
0xaeae47e9, 0x08081018, 0xbaba6fd5, 0x7878f088, 0x25254a6f,
0x2e2e5c72, 0x1c1c3824, 0xa6a657f1, 0xb4b473c7, 0xc6c69751,
0xe8e8cb23, 0xdddda17c, 0x7474e89c, 0x1f1f3e21, 0x4b4b96dd,
0xbdbd61dc, 0x8b8b0d86, 0x8a8a0f85, 0x7070e090, 0x3e3e7c42,
0xb5b571c4, 0x6666ccaa, 0x484890d8, 0x03030605, 0xf6f6f701,
0x0e0e1c12, 0x6161c2a3, 0x35356a5f, 0x5757aef9, 0xb9b969d0,
0x86861791, 0xc1c19958, 0x1d1d3a27, 0x9e9e27b9, 0xe1e1d938,
0xf8f8eb13, 0x98982bb3, 0x11112233, 0x6969d2bb, 0xd9d9a970,
0x8e8e0789, 0x949433a7, 0x9b9b2db6, 0x1e1e3c22, 0x87871592,
0xe9e9c920, 0xcece8749, 0x5555aaff, 0x28285078, 0xdfdfa57a,
0x8c8c038f, 0xa1a159f8, 0x89890980, 0x0d0d1a17, 0xbfbf65da,
0xe6e6d731, 0x424284c6, 0x6868d0b8, 0x414182c3, 0x999929b0,
0x2d2d5a77, 0x0f0f1e11, 0xb0b07bcb, 0x5454a8fc, 0xbbbb6dd6,
0x16162c3a
};
private static readonly uint[] T2 =
{
0x63c6a563, 0x7cf8847c, 0x77ee9977, 0x7bf68d7b, 0xf2ff0df2,
0x6bd6bd6b, 0x6fdeb16f, 0xc59154c5, 0x30605030, 0x01020301,
0x67cea967, 0x2b567d2b, 0xfee719fe, 0xd7b562d7, 0xab4de6ab,
0x76ec9a76, 0xca8f45ca, 0x821f9d82, 0xc98940c9, 0x7dfa877d,
0xfaef15fa, 0x59b2eb59, 0x478ec947, 0xf0fb0bf0, 0xad41ecad,
0xd4b367d4, 0xa25ffda2, 0xaf45eaaf, 0x9c23bf9c, 0xa453f7a4,
0x72e49672, 0xc09b5bc0, 0xb775c2b7, 0xfde11cfd, 0x933dae93,
0x264c6a26, 0x366c5a36, 0x3f7e413f, 0xf7f502f7, 0xcc834fcc,
0x34685c34, 0xa551f4a5, 0xe5d134e5, 0xf1f908f1, 0x71e29371,
0xd8ab73d8, 0x31625331, 0x152a3f15, 0x04080c04, 0xc79552c7,
0x23466523, 0xc39d5ec3, 0x18302818, 0x9637a196, 0x050a0f05,
0x9a2fb59a, 0x070e0907, 0x12243612, 0x801b9b80, 0xe2df3de2,
0xebcd26eb, 0x274e6927, 0xb27fcdb2, 0x75ea9f75, 0x09121b09,
0x831d9e83, 0x2c58742c, 0x1a342e1a, 0x1b362d1b, 0x6edcb26e,
0x5ab4ee5a, 0xa05bfba0, 0x52a4f652, 0x3b764d3b, 0xd6b761d6,
0xb37dceb3, 0x29527b29, 0xe3dd3ee3, 0x2f5e712f, 0x84139784,
0x53a6f553, 0xd1b968d1, 0x00000000, 0xedc12ced, 0x20406020,
0xfce31ffc, 0xb179c8b1, 0x5bb6ed5b, 0x6ad4be6a, 0xcb8d46cb,
0xbe67d9be, 0x39724b39, 0x4a94de4a, 0x4c98d44c, 0x58b0e858,
0xcf854acf, 0xd0bb6bd0, 0xefc52aef, 0xaa4fe5aa, 0xfbed16fb,
0x4386c543, 0x4d9ad74d, 0x33665533, 0x85119485, 0x458acf45,
0xf9e910f9, 0x02040602, 0x7ffe817f, 0x50a0f050, 0x3c78443c,
0x9f25ba9f, 0xa84be3a8, 0x51a2f351, 0xa35dfea3, 0x4080c040,
0x8f058a8f, 0x923fad92, 0x9d21bc9d, 0x38704838, 0xf5f104f5,
0xbc63dfbc, 0xb677c1b6, 0xdaaf75da, 0x21426321, 0x10203010,
0xffe51aff, 0xf3fd0ef3, 0xd2bf6dd2, 0xcd814ccd, 0x0c18140c,
0x13263513, 0xecc32fec, 0x5fbee15f, 0x9735a297, 0x4488cc44,
0x172e3917, 0xc49357c4, 0xa755f2a7, 0x7efc827e, 0x3d7a473d,
0x64c8ac64, 0x5dbae75d, 0x19322b19, 0x73e69573, 0x60c0a060,
0x81199881, 0x4f9ed14f, 0xdca37fdc, 0x22446622, 0x2a547e2a,
0x903bab90, 0x880b8388, 0x468cca46, 0xeec729ee, 0xb86bd3b8,
0x14283c14, 0xdea779de, 0x5ebce25e, 0x0b161d0b, 0xdbad76db,
0xe0db3be0, 0x32645632, 0x3a744e3a, 0x0a141e0a, 0x4992db49,
0x060c0a06, 0x24486c24, 0x5cb8e45c, 0xc29f5dc2, 0xd3bd6ed3,
0xac43efac, 0x62c4a662, 0x9139a891, 0x9531a495, 0xe4d337e4,
0x79f28b79, 0xe7d532e7, 0xc88b43c8, 0x376e5937, 0x6ddab76d,
0x8d018c8d, 0xd5b164d5, 0x4e9cd24e, 0xa949e0a9, 0x6cd8b46c,
0x56acfa56, 0xf4f307f4, 0xeacf25ea, 0x65caaf65, 0x7af48e7a,
0xae47e9ae, 0x08101808, 0xba6fd5ba, 0x78f08878, 0x254a6f25,
0x2e5c722e, 0x1c38241c, 0xa657f1a6, 0xb473c7b4, 0xc69751c6,
0xe8cb23e8, 0xdda17cdd, 0x74e89c74, 0x1f3e211f, 0x4b96dd4b,
0xbd61dcbd, 0x8b0d868b, 0x8a0f858a, 0x70e09070, 0x3e7c423e,
0xb571c4b5, 0x66ccaa66, 0x4890d848, 0x03060503, 0xf6f701f6,
0x0e1c120e, 0x61c2a361, 0x356a5f35, 0x57aef957, 0xb969d0b9,
0x86179186, 0xc19958c1, 0x1d3a271d, 0x9e27b99e, 0xe1d938e1,
0xf8eb13f8, 0x982bb398, 0x11223311, 0x69d2bb69, 0xd9a970d9,
0x8e07898e, 0x9433a794, 0x9b2db69b, 0x1e3c221e, 0x87159287,
0xe9c920e9, 0xce8749ce, 0x55aaff55, 0x28507828, 0xdfa57adf,
0x8c038f8c, 0xa159f8a1, 0x89098089, 0x0d1a170d, 0xbf65dabf,
0xe6d731e6, 0x4284c642, 0x68d0b868, 0x4182c341, 0x9929b099,
0x2d5a772d, 0x0f1e110f, 0xb07bcbb0, 0x54a8fc54, 0xbb6dd6bb,
0x162c3a16
};
private static readonly uint[] T3 =
{
0xc6a56363, 0xf8847c7c, 0xee997777, 0xf68d7b7b, 0xff0df2f2,
0xd6bd6b6b, 0xdeb16f6f, 0x9154c5c5, 0x60503030, 0x02030101,
0xcea96767, 0x567d2b2b, 0xe719fefe, 0xb562d7d7, 0x4de6abab,
0xec9a7676, 0x8f45caca, 0x1f9d8282, 0x8940c9c9, 0xfa877d7d,
0xef15fafa, 0xb2eb5959, 0x8ec94747, 0xfb0bf0f0, 0x41ecadad,
0xb367d4d4, 0x5ffda2a2, 0x45eaafaf, 0x23bf9c9c, 0x53f7a4a4,
0xe4967272, 0x9b5bc0c0, 0x75c2b7b7, 0xe11cfdfd, 0x3dae9393,
0x4c6a2626, 0x6c5a3636, 0x7e413f3f, 0xf502f7f7, 0x834fcccc,
0x685c3434, 0x51f4a5a5, 0xd134e5e5, 0xf908f1f1, 0xe2937171,
0xab73d8d8, 0x62533131, 0x2a3f1515, 0x080c0404, 0x9552c7c7,
0x46652323, 0x9d5ec3c3, 0x30281818, 0x37a19696, 0x0a0f0505,
0x2fb59a9a, 0x0e090707, 0x24361212, 0x1b9b8080, 0xdf3de2e2,
0xcd26ebeb, 0x4e692727, 0x7fcdb2b2, 0xea9f7575, 0x121b0909,
0x1d9e8383, 0x58742c2c, 0x342e1a1a, 0x362d1b1b, 0xdcb26e6e,
0xb4ee5a5a, 0x5bfba0a0, 0xa4f65252, 0x764d3b3b, 0xb761d6d6,
0x7dceb3b3, 0x527b2929, 0xdd3ee3e3, 0x5e712f2f, 0x13978484,
0xa6f55353, 0xb968d1d1, 0x00000000, 0xc12ceded, 0x40602020,
0xe31ffcfc, 0x79c8b1b1, 0xb6ed5b5b, 0xd4be6a6a, 0x8d46cbcb,
0x67d9bebe, 0x724b3939, 0x94de4a4a, 0x98d44c4c, 0xb0e85858,
0x854acfcf, 0xbb6bd0d0, 0xc52aefef, 0x4fe5aaaa, 0xed16fbfb,
0x86c54343, 0x9ad74d4d, 0x66553333, 0x11948585, 0x8acf4545,
0xe910f9f9, 0x04060202, 0xfe817f7f, 0xa0f05050, 0x78443c3c,
0x25ba9f9f, 0x4be3a8a8, 0xa2f35151, 0x5dfea3a3, 0x80c04040,
0x058a8f8f, 0x3fad9292, 0x21bc9d9d, 0x70483838, 0xf104f5f5,
0x63dfbcbc, 0x77c1b6b6, 0xaf75dada, 0x42632121, 0x20301010,
0xe51affff, 0xfd0ef3f3, 0xbf6dd2d2, 0x814ccdcd, 0x18140c0c,
0x26351313, 0xc32fecec, 0xbee15f5f, 0x35a29797, 0x88cc4444,
0x2e391717, 0x9357c4c4, 0x55f2a7a7, 0xfc827e7e, 0x7a473d3d,
0xc8ac6464, 0xbae75d5d, 0x322b1919, 0xe6957373, 0xc0a06060,
0x19988181, 0x9ed14f4f, 0xa37fdcdc, 0x44662222, 0x547e2a2a,
0x3bab9090, 0x0b838888, 0x8cca4646, 0xc729eeee, 0x6bd3b8b8,
0x283c1414, 0xa779dede, 0xbce25e5e, 0x161d0b0b, 0xad76dbdb,
0xdb3be0e0, 0x64563232, 0x744e3a3a, 0x141e0a0a, 0x92db4949,
0x0c0a0606, 0x486c2424, 0xb8e45c5c, 0x9f5dc2c2, 0xbd6ed3d3,
0x43efacac, 0xc4a66262, 0x39a89191, 0x31a49595, 0xd337e4e4,
0xf28b7979, 0xd532e7e7, 0x8b43c8c8, 0x6e593737, 0xdab76d6d,
0x018c8d8d, 0xb164d5d5, 0x9cd24e4e, 0x49e0a9a9, 0xd8b46c6c,
0xacfa5656, 0xf307f4f4, 0xcf25eaea, 0xcaaf6565, 0xf48e7a7a,
0x47e9aeae, 0x10180808, 0x6fd5baba, 0xf0887878, 0x4a6f2525,
0x5c722e2e, 0x38241c1c, 0x57f1a6a6, 0x73c7b4b4, 0x9751c6c6,
0xcb23e8e8, 0xa17cdddd, 0xe89c7474, 0x3e211f1f, 0x96dd4b4b,
0x61dcbdbd, 0x0d868b8b, 0x0f858a8a, 0xe0907070, 0x7c423e3e,
0x71c4b5b5, 0xccaa6666, 0x90d84848, 0x06050303, 0xf701f6f6,
0x1c120e0e, 0xc2a36161, 0x6a5f3535, 0xaef95757, 0x69d0b9b9,
0x17918686, 0x9958c1c1, 0x3a271d1d, 0x27b99e9e, 0xd938e1e1,
0xeb13f8f8, 0x2bb39898, 0x22331111, 0xd2bb6969, 0xa970d9d9,
0x07898e8e, 0x33a79494, 0x2db69b9b, 0x3c221e1e, 0x15928787,
0xc920e9e9, 0x8749cece, 0xaaff5555, 0x50782828, 0xa57adfdf,
0x038f8c8c, 0x59f8a1a1, 0x09808989, 0x1a170d0d, 0x65dabfbf,
0xd731e6e6, 0x84c64242, 0xd0b86868, 0x82c34141, 0x29b09999,
0x5a772d2d, 0x1e110f0f, 0x7bcbb0b0, 0xa8fc5454, 0x6dd6bbbb,
0x2c3a1616
};
private static readonly uint[] Tinv0 =
{
0x50a7f451, 0x5365417e, 0xc3a4171a, 0x965e273a, 0xcb6bab3b,
0xf1459d1f, 0xab58faac, 0x9303e34b, 0x55fa3020, 0xf66d76ad,
0x9176cc88, 0x254c02f5, 0xfcd7e54f, 0xd7cb2ac5, 0x80443526,
0x8fa362b5, 0x495ab1de, 0x671bba25, 0x980eea45, 0xe1c0fe5d,
0x02752fc3, 0x12f04c81, 0xa397468d, 0xc6f9d36b, 0xe75f8f03,
0x959c9215, 0xeb7a6dbf, 0xda595295, 0x2d83bed4, 0xd3217458,
0x2969e049, 0x44c8c98e, 0x6a89c275, 0x78798ef4, 0x6b3e5899,
0xdd71b927, 0xb64fe1be, 0x17ad88f0, 0x66ac20c9, 0xb43ace7d,
0x184adf63, 0x82311ae5, 0x60335197, 0x457f5362, 0xe07764b1,
0x84ae6bbb, 0x1ca081fe, 0x942b08f9, 0x58684870, 0x19fd458f,
0x876cde94, 0xb7f87b52, 0x23d373ab, 0xe2024b72, 0x578f1fe3,
0x2aab5566, 0x0728ebb2, 0x03c2b52f, 0x9a7bc586, 0xa50837d3,
0xf2872830, 0xb2a5bf23, 0xba6a0302, 0x5c8216ed, 0x2b1ccf8a,
0x92b479a7, 0xf0f207f3, 0xa1e2694e, 0xcdf4da65, 0xd5be0506,
0x1f6234d1, 0x8afea6c4, 0x9d532e34, 0xa055f3a2, 0x32e18a05,
0x75ebf6a4, 0x39ec830b, 0xaaef6040, 0x069f715e, 0x51106ebd,
0xf98a213e, 0x3d06dd96, 0xae053edd, 0x46bde64d, 0xb58d5491,
0x055dc471, 0x6fd40604, 0xff155060, 0x24fb9819, 0x97e9bdd6,
0xcc434089, 0x779ed967, 0xbd42e8b0, 0x888b8907, 0x385b19e7,
0xdbeec879, 0x470a7ca1, 0xe90f427c, 0xc91e84f8, 0x00000000,
0x83868009, 0x48ed2b32, 0xac70111e, 0x4e725a6c, 0xfbff0efd,
0x5638850f, 0x1ed5ae3d, 0x27392d36, 0x64d90f0a, 0x21a65c68,
0xd1545b9b, 0x3a2e3624, 0xb1670a0c, 0x0fe75793, 0xd296eeb4,
0x9e919b1b, 0x4fc5c080, 0xa220dc61, 0x694b775a, 0x161a121c,
0x0aba93e2, 0xe52aa0c0, 0x43e0223c, 0x1d171b12, 0x0b0d090e,
0xadc78bf2, 0xb9a8b62d, 0xc8a91e14, 0x8519f157, 0x4c0775af,
0xbbdd99ee, 0xfd607fa3, 0x9f2601f7, 0xbcf5725c, 0xc53b6644,
0x347efb5b, 0x7629438b, 0xdcc623cb, 0x68fcedb6, 0x63f1e4b8,
0xcadc31d7, 0x10856342, 0x40229713, 0x2011c684, 0x7d244a85,
0xf83dbbd2, 0x1132f9ae, 0x6da129c7, 0x4b2f9e1d, 0xf330b2dc,
0xec52860d, 0xd0e3c177, 0x6c16b32b, 0x99b970a9, 0xfa489411,
0x2264e947, 0xc48cfca8, 0x1a3ff0a0, 0xd82c7d56, 0xef903322,
0xc74e4987, 0xc1d138d9, 0xfea2ca8c, 0x360bd498, 0xcf81f5a6,
0x28de7aa5, 0x268eb7da, 0xa4bfad3f, 0xe49d3a2c, 0x0d927850,
0x9bcc5f6a, 0x62467e54, 0xc2138df6, 0xe8b8d890, 0x5ef7392e,
0xf5afc382, 0xbe805d9f, 0x7c93d069, 0xa92dd56f, 0xb31225cf,
0x3b99acc8, 0xa77d1810, 0x6e639ce8, 0x7bbb3bdb, 0x097826cd,
0xf418596e, 0x01b79aec, 0xa89a4f83, 0x656e95e6, 0x7ee6ffaa,
0x08cfbc21, 0xe6e815ef, 0xd99be7ba, 0xce366f4a, 0xd4099fea,
0xd67cb029, 0xafb2a431, 0x31233f2a, 0x3094a5c6, 0xc066a235,
0x37bc4e74, 0xa6ca82fc, 0xb0d090e0, 0x15d8a733, 0x4a9804f1,
0xf7daec41, 0x0e50cd7f, 0x2ff69117, 0x8dd64d76, 0x4db0ef43,
0x544daacc, 0xdf0496e4, 0xe3b5d19e, 0x1b886a4c, 0xb81f2cc1,
0x7f516546, 0x04ea5e9d, 0x5d358c01, 0x737487fa, 0x2e410bfb,
0x5a1d67b3, 0x52d2db92, 0x335610e9, 0x1347d66d, 0x8c61d79a,
0x7a0ca137, 0x8e14f859, 0x893c13eb, 0xee27a9ce, 0x35c961b7,
0xede51ce1, 0x3cb1477a, 0x59dfd29c, 0x3f73f255, 0x79ce1418,
0xbf37c773, 0xeacdf753, 0x5baafd5f, 0x146f3ddf, 0x86db4478,
0x81f3afca, 0x3ec468b9, 0x2c342438, 0x5f40a3c2, 0x72c31d16,
0x0c25e2bc, 0x8b493c28, 0x41950dff, 0x7101a839, 0xdeb30c08,
0x9ce4b4d8, 0x90c15664, 0x6184cb7b, 0x70b632d5, 0x745c6c48,
0x4257b8d0
};
private static readonly uint[] Tinv1 =
{
0xa7f45150, 0x65417e53, 0xa4171ac3, 0x5e273a96, 0x6bab3bcb,
0x459d1ff1, 0x58faacab, 0x03e34b93, 0xfa302055, 0x6d76adf6,
0x76cc8891, 0x4c02f525, 0xd7e54ffc, 0xcb2ac5d7, 0x44352680,
0xa362b58f, 0x5ab1de49, 0x1bba2567, 0x0eea4598, 0xc0fe5de1,
0x752fc302, 0xf04c8112, 0x97468da3, 0xf9d36bc6, 0x5f8f03e7,
0x9c921595, 0x7a6dbfeb, 0x595295da, 0x83bed42d, 0x217458d3,
0x69e04929, 0xc8c98e44, 0x89c2756a, 0x798ef478, 0x3e58996b,
0x71b927dd, 0x4fe1beb6, 0xad88f017, 0xac20c966, 0x3ace7db4,
0x4adf6318, 0x311ae582, 0x33519760, 0x7f536245, 0x7764b1e0,
0xae6bbb84, 0xa081fe1c, 0x2b08f994, 0x68487058, 0xfd458f19,
0x6cde9487, 0xf87b52b7, 0xd373ab23, 0x024b72e2, 0x8f1fe357,
0xab55662a, 0x28ebb207, 0xc2b52f03, 0x7bc5869a, 0x0837d3a5,
0x872830f2, 0xa5bf23b2, 0x6a0302ba, 0x8216ed5c, 0x1ccf8a2b,
0xb479a792, 0xf207f3f0, 0xe2694ea1, 0xf4da65cd, 0xbe0506d5,
0x6234d11f, 0xfea6c48a, 0x532e349d, 0x55f3a2a0, 0xe18a0532,
0xebf6a475, 0xec830b39, 0xef6040aa, 0x9f715e06, 0x106ebd51,
0x8a213ef9, 0x06dd963d, 0x053eddae, 0xbde64d46, 0x8d5491b5,
0x5dc47105, 0xd406046f, 0x155060ff, 0xfb981924, 0xe9bdd697,
0x434089cc, 0x9ed96777, 0x42e8b0bd, 0x8b890788, 0x5b19e738,
0xeec879db, 0x0a7ca147, 0x0f427ce9, 0x1e84f8c9, 0x00000000,
0x86800983, 0xed2b3248, 0x70111eac, 0x725a6c4e, 0xff0efdfb,
0x38850f56, 0xd5ae3d1e, 0x392d3627, 0xd90f0a64, 0xa65c6821,
0x545b9bd1, 0x2e36243a, 0x670a0cb1, 0xe757930f, 0x96eeb4d2,
0x919b1b9e, 0xc5c0804f, 0x20dc61a2, 0x4b775a69, 0x1a121c16,
0xba93e20a, 0x2aa0c0e5, 0xe0223c43, 0x171b121d, 0x0d090e0b,
0xc78bf2ad, 0xa8b62db9, 0xa91e14c8, 0x19f15785, 0x0775af4c,
0xdd99eebb, 0x607fa3fd, 0x2601f79f, 0xf5725cbc, 0x3b6644c5,
0x7efb5b34, 0x29438b76, 0xc623cbdc, 0xfcedb668, 0xf1e4b863,
0xdc31d7ca, 0x85634210, 0x22971340, 0x11c68420, 0x244a857d,
0x3dbbd2f8, 0x32f9ae11, 0xa129c76d, 0x2f9e1d4b, 0x30b2dcf3,
0x52860dec, 0xe3c177d0, 0x16b32b6c, 0xb970a999, 0x489411fa,
0x64e94722, 0x8cfca8c4, 0x3ff0a01a, 0x2c7d56d8, 0x903322ef,
0x4e4987c7, 0xd138d9c1, 0xa2ca8cfe, 0x0bd49836, 0x81f5a6cf,
0xde7aa528, 0x8eb7da26, 0xbfad3fa4, 0x9d3a2ce4, 0x9278500d,
0xcc5f6a9b, 0x467e5462, 0x138df6c2, 0xb8d890e8, 0xf7392e5e,
0xafc382f5, 0x805d9fbe, 0x93d0697c, 0x2dd56fa9, 0x1225cfb3,
0x99acc83b, 0x7d1810a7, 0x639ce86e, 0xbb3bdb7b, 0x7826cd09,
0x18596ef4, 0xb79aec01, 0x9a4f83a8, 0x6e95e665, 0xe6ffaa7e,
0xcfbc2108, 0xe815efe6, 0x9be7bad9, 0x366f4ace, 0x099fead4,
0x7cb029d6, 0xb2a431af, 0x233f2a31, 0x94a5c630, 0x66a235c0,
0xbc4e7437, 0xca82fca6, 0xd090e0b0, 0xd8a73315, 0x9804f14a,
0xdaec41f7, 0x50cd7f0e, 0xf691172f, 0xd64d768d, 0xb0ef434d,
0x4daacc54, 0x0496e4df, 0xb5d19ee3, 0x886a4c1b, 0x1f2cc1b8,
0x5165467f, 0xea5e9d04, 0x358c015d, 0x7487fa73, 0x410bfb2e,
0x1d67b35a, 0xd2db9252, 0x5610e933, 0x47d66d13, 0x61d79a8c,
0x0ca1377a, 0x14f8598e, 0x3c13eb89, 0x27a9ceee, 0xc961b735,
0xe51ce1ed, 0xb1477a3c, 0xdfd29c59, 0x73f2553f, 0xce141879,
0x37c773bf, 0xcdf753ea, 0xaafd5f5b, 0x6f3ddf14, 0xdb447886,
0xf3afca81, 0xc468b93e, 0x3424382c, 0x40a3c25f, 0xc31d1672,
0x25e2bc0c, 0x493c288b, 0x950dff41, 0x01a83971, 0xb30c08de,
0xe4b4d89c, 0xc1566490, 0x84cb7b61, 0xb632d570, 0x5c6c4874,
0x57b8d042
};
private static readonly uint[] Tinv2 =
{
0xf45150a7, 0x417e5365, 0x171ac3a4, 0x273a965e, 0xab3bcb6b,
0x9d1ff145, 0xfaacab58, 0xe34b9303, 0x302055fa, 0x76adf66d,
0xcc889176, 0x02f5254c, 0xe54ffcd7, 0x2ac5d7cb, 0x35268044,
0x62b58fa3, 0xb1de495a, 0xba25671b, 0xea45980e, 0xfe5de1c0,
0x2fc30275, 0x4c8112f0, 0x468da397, 0xd36bc6f9, 0x8f03e75f,
0x9215959c, 0x6dbfeb7a, 0x5295da59, 0xbed42d83, 0x7458d321,
0xe0492969, 0xc98e44c8, 0xc2756a89, 0x8ef47879, 0x58996b3e,
0xb927dd71, 0xe1beb64f, 0x88f017ad, 0x20c966ac, 0xce7db43a,
0xdf63184a, 0x1ae58231, 0x51976033, 0x5362457f, 0x64b1e077,
0x6bbb84ae, 0x81fe1ca0, 0x08f9942b, 0x48705868, 0x458f19fd,
0xde94876c, 0x7b52b7f8, 0x73ab23d3, 0x4b72e202, 0x1fe3578f,
0x55662aab, 0xebb20728, 0xb52f03c2, 0xc5869a7b, 0x37d3a508,
0x2830f287, 0xbf23b2a5, 0x0302ba6a, 0x16ed5c82, 0xcf8a2b1c,
0x79a792b4, 0x07f3f0f2, 0x694ea1e2, 0xda65cdf4, 0x0506d5be,
0x34d11f62, 0xa6c48afe, 0x2e349d53, 0xf3a2a055, 0x8a0532e1,
0xf6a475eb, 0x830b39ec, 0x6040aaef, 0x715e069f, 0x6ebd5110,
0x213ef98a, 0xdd963d06, 0x3eddae05, 0xe64d46bd, 0x5491b58d,
0xc471055d, 0x06046fd4, 0x5060ff15, 0x981924fb, 0xbdd697e9,
0x4089cc43, 0xd967779e, 0xe8b0bd42, 0x8907888b, 0x19e7385b,
0xc879dbee, 0x7ca1470a, 0x427ce90f, 0x84f8c91e, 0x00000000,
0x80098386, 0x2b3248ed, 0x111eac70, 0x5a6c4e72, 0x0efdfbff,
0x850f5638, 0xae3d1ed5, 0x2d362739, 0x0f0a64d9, 0x5c6821a6,
0x5b9bd154, 0x36243a2e, 0x0a0cb167, 0x57930fe7, 0xeeb4d296,
0x9b1b9e91, 0xc0804fc5, 0xdc61a220, 0x775a694b, 0x121c161a,
0x93e20aba, 0xa0c0e52a, 0x223c43e0, 0x1b121d17, 0x090e0b0d,
0x8bf2adc7, 0xb62db9a8, 0x1e14c8a9, 0xf1578519, 0x75af4c07,
0x99eebbdd, 0x7fa3fd60, 0x01f79f26, 0x725cbcf5, 0x6644c53b,
0xfb5b347e, 0x438b7629, 0x23cbdcc6, 0xedb668fc, 0xe4b863f1,
0x31d7cadc, 0x63421085, 0x97134022, 0xc6842011, 0x4a857d24,
0xbbd2f83d, 0xf9ae1132, 0x29c76da1, 0x9e1d4b2f, 0xb2dcf330,
0x860dec52, 0xc177d0e3, 0xb32b6c16, 0x70a999b9, 0x9411fa48,
0xe9472264, 0xfca8c48c, 0xf0a01a3f, 0x7d56d82c, 0x3322ef90,
0x4987c74e, 0x38d9c1d1, 0xca8cfea2, 0xd498360b, 0xf5a6cf81,
0x7aa528de, 0xb7da268e, 0xad3fa4bf, 0x3a2ce49d, 0x78500d92,
0x5f6a9bcc, 0x7e546246, 0x8df6c213, 0xd890e8b8, 0x392e5ef7,
0xc382f5af, 0x5d9fbe80, 0xd0697c93, 0xd56fa92d, 0x25cfb312,
0xacc83b99, 0x1810a77d, 0x9ce86e63, 0x3bdb7bbb, 0x26cd0978,
0x596ef418, 0x9aec01b7, 0x4f83a89a, 0x95e6656e, 0xffaa7ee6,
0xbc2108cf, 0x15efe6e8, 0xe7bad99b, 0x6f4ace36, 0x9fead409,
0xb029d67c, 0xa431afb2, 0x3f2a3123, 0xa5c63094, 0xa235c066,
0x4e7437bc, 0x82fca6ca, 0x90e0b0d0, 0xa73315d8, 0x04f14a98,
0xec41f7da, 0xcd7f0e50, 0x91172ff6, 0x4d768dd6, 0xef434db0,
0xaacc544d, 0x96e4df04, 0xd19ee3b5, 0x6a4c1b88, 0x2cc1b81f,
0x65467f51, 0x5e9d04ea, 0x8c015d35, 0x87fa7374, 0x0bfb2e41,
0x67b35a1d, 0xdb9252d2, 0x10e93356, 0xd66d1347, 0xd79a8c61,
0xa1377a0c, 0xf8598e14, 0x13eb893c, 0xa9ceee27, 0x61b735c9,
0x1ce1ede5, 0x477a3cb1, 0xd29c59df, 0xf2553f73, 0x141879ce,
0xc773bf37, 0xf753eacd, 0xfd5f5baa, 0x3ddf146f, 0x447886db,
0xafca81f3, 0x68b93ec4, 0x24382c34, 0xa3c25f40, 0x1d1672c3,
0xe2bc0c25, 0x3c288b49, 0x0dff4195, 0xa8397101, 0x0c08deb3,
0xb4d89ce4, 0x566490c1, 0xcb7b6184, 0x32d570b6, 0x6c48745c,
0xb8d04257
};
private static readonly uint[] Tinv3 =
{
0x5150a7f4, 0x7e536541, 0x1ac3a417, 0x3a965e27, 0x3bcb6bab,
0x1ff1459d, 0xacab58fa, 0x4b9303e3, 0x2055fa30, 0xadf66d76,
0x889176cc, 0xf5254c02, 0x4ffcd7e5, 0xc5d7cb2a, 0x26804435,
0xb58fa362, 0xde495ab1, 0x25671bba, 0x45980eea, 0x5de1c0fe,
0xc302752f, 0x8112f04c, 0x8da39746, 0x6bc6f9d3, 0x03e75f8f,
0x15959c92, 0xbfeb7a6d, 0x95da5952, 0xd42d83be, 0x58d32174,
0x492969e0, 0x8e44c8c9, 0x756a89c2, 0xf478798e, 0x996b3e58,
0x27dd71b9, 0xbeb64fe1, 0xf017ad88, 0xc966ac20, 0x7db43ace,
0x63184adf, 0xe582311a, 0x97603351, 0x62457f53, 0xb1e07764,
0xbb84ae6b, 0xfe1ca081, 0xf9942b08, 0x70586848, 0x8f19fd45,
0x94876cde, 0x52b7f87b, 0xab23d373, 0x72e2024b, 0xe3578f1f,
0x662aab55, 0xb20728eb, 0x2f03c2b5, 0x869a7bc5, 0xd3a50837,
0x30f28728, 0x23b2a5bf, 0x02ba6a03, 0xed5c8216, 0x8a2b1ccf,
0xa792b479, 0xf3f0f207, 0x4ea1e269, 0x65cdf4da, 0x06d5be05,
0xd11f6234, 0xc48afea6, 0x349d532e, 0xa2a055f3, 0x0532e18a,
0xa475ebf6, 0x0b39ec83, 0x40aaef60, 0x5e069f71, 0xbd51106e,
0x3ef98a21, 0x963d06dd, 0xddae053e, 0x4d46bde6, 0x91b58d54,
0x71055dc4, 0x046fd406, 0x60ff1550, 0x1924fb98, 0xd697e9bd,
0x89cc4340, 0x67779ed9, 0xb0bd42e8, 0x07888b89, 0xe7385b19,
0x79dbeec8, 0xa1470a7c, 0x7ce90f42, 0xf8c91e84, 0x00000000,
0x09838680, 0x3248ed2b, 0x1eac7011, 0x6c4e725a, 0xfdfbff0e,
0x0f563885, 0x3d1ed5ae, 0x3627392d, 0x0a64d90f, 0x6821a65c,
0x9bd1545b, 0x243a2e36, 0x0cb1670a, 0x930fe757, 0xb4d296ee,
0x1b9e919b, 0x804fc5c0, 0x61a220dc, 0x5a694b77, 0x1c161a12,
0xe20aba93, 0xc0e52aa0, 0x3c43e022, 0x121d171b, 0x0e0b0d09,
0xf2adc78b, 0x2db9a8b6, 0x14c8a91e, 0x578519f1, 0xaf4c0775,
0xeebbdd99, 0xa3fd607f, 0xf79f2601, 0x5cbcf572, 0x44c53b66,
0x5b347efb, 0x8b762943, 0xcbdcc623, 0xb668fced, 0xb863f1e4,
0xd7cadc31, 0x42108563, 0x13402297, 0x842011c6, 0x857d244a,
0xd2f83dbb, 0xae1132f9, 0xc76da129, 0x1d4b2f9e, 0xdcf330b2,
0x0dec5286, 0x77d0e3c1, 0x2b6c16b3, 0xa999b970, 0x11fa4894,
0x472264e9, 0xa8c48cfc, 0xa01a3ff0, 0x56d82c7d, 0x22ef9033,
0x87c74e49, 0xd9c1d138, 0x8cfea2ca, 0x98360bd4, 0xa6cf81f5,
0xa528de7a, 0xda268eb7, 0x3fa4bfad, 0x2ce49d3a, 0x500d9278,
0x6a9bcc5f, 0x5462467e, 0xf6c2138d, 0x90e8b8d8, 0x2e5ef739,
0x82f5afc3, 0x9fbe805d, 0x697c93d0, 0x6fa92dd5, 0xcfb31225,
0xc83b99ac, 0x10a77d18, 0xe86e639c, 0xdb7bbb3b, 0xcd097826,
0x6ef41859, 0xec01b79a, 0x83a89a4f, 0xe6656e95, 0xaa7ee6ff,
0x2108cfbc, 0xefe6e815, 0xbad99be7, 0x4ace366f, 0xead4099f,
0x29d67cb0, 0x31afb2a4, 0x2a31233f, 0xc63094a5, 0x35c066a2,
0x7437bc4e, 0xfca6ca82, 0xe0b0d090, 0x3315d8a7, 0xf14a9804,
0x41f7daec, 0x7f0e50cd, 0x172ff691, 0x768dd64d, 0x434db0ef,
0xcc544daa, 0xe4df0496, 0x9ee3b5d1, 0x4c1b886a, 0xc1b81f2c,
0x467f5165, 0x9d04ea5e, 0x015d358c, 0xfa737487, 0xfb2e410b,
0xb35a1d67, 0x9252d2db, 0xe9335610, 0x6d1347d6, 0x9a8c61d7,
0x377a0ca1, 0x598e14f8, 0xeb893c13, 0xceee27a9, 0xb735c961,
0xe1ede51c, 0x7a3cb147, 0x9c59dfd2, 0x553f73f2, 0x1879ce14,
0x73bf37c7, 0x53eacdf7, 0x5f5baafd, 0xdf146f3d, 0x7886db44,
0xca81f3af, 0xb93ec468, 0x382c3424, 0xc25f40a3, 0x1672c31d,
0xbc0c25e2, 0x288b493c, 0xff41950d, 0x397101a8, 0x08deb30c,
0xd89ce4b4, 0x6490c156, 0x7b6184cb, 0xd570b632, 0x48745c6c,
0xd04257b8
};
private static uint Shift(uint r, int shift)
{
return (r >> shift) | (r << (32 - shift));
}
/* multiply four bytes in GF(2^8) by 'x' {02} in parallel */
private const uint m1 = 0x80808080;
private const uint m2 = 0x7f7f7f7f;
private const uint m3 = 0x0000001b;
private static uint FFmulX(uint x)
{
return ((x & m2) << 1) ^ (((x & m1) >> 7) * m3);
}
/*
The following defines provide alternative definitions of FFmulX that might
give improved performance if a fast 32-bit multiply is not available.
private int FFmulX(int x) { int u = x & m1; u |= (u >> 1); return ((x & m2) << 1) ^ ((u >>> 3) | (u >>> 6)); }
private static final int m4 = 0x1b1b1b1b;
private int FFmulX(int x) { int u = x & m1; return ((x & m2) << 1) ^ ((u - (u >>> 7)) & m4); }
*/
private static uint Inv_Mcol(uint x)
{
uint f2 = FFmulX(x);
uint f4 = FFmulX(f2);
uint f8 = FFmulX(f4);
uint f9 = x ^ f8;
return f2 ^ f4 ^ f8 ^ Shift(f2 ^ f9, 8) ^ Shift(f4 ^ f9, 16) ^ Shift(f9, 24);
}
private static uint SubWord(uint x)
{
return (uint)S[x&255]
| (((uint)S[(x>>8)&255]) << 8)
| (((uint)S[(x>>16)&255]) << 16)
| (((uint)S[(x>>24)&255]) << 24);
}
/**
* Calculate the necessary round keys
* The number of calculations depends on key size and block size
* AES specified a fixed block size of 128 bits and key sizes 128/192/256 bits
* This code is written assuming those are the only possible values
*/
private uint[][] GenerateWorkingKey(
byte[] key,
bool forEncryption)
{
int KC = key.Length / 4; // key length in words
if (((KC != 4) && (KC != 6) && (KC != 8)) || ((KC * 4) != key.Length))
throw new ArgumentException("Key length not 128/192/256 bits.");
ROUNDS = KC + 6; // This is not always true for the generalized Rijndael that allows larger block sizes
uint[][] W = new uint[ROUNDS + 1][]; // 4 words in a block
for (int i = 0; i <= ROUNDS; ++i)
{
W[i] = new uint[4];
}
//
// copy the key into the round key array
//
int t = 0;
for (int i = 0; i < key.Length; t++)
{
W[t >> 2][t & 3] = Pack.LE_To_UInt32(key, i);
i+=4;
}
//
// while not enough round key material calculated
// calculate new values
//
int k = (ROUNDS + 1) << 2;
for (int i = KC; (i < k); i++)
{
uint temp = W[(i-1)>>2][(i-1)&3];
if ((i % KC) == 0) {
temp = SubWord(Shift(temp, 8)) ^ rcon[(i / KC)-1];
} else if ((KC > 6) && ((i % KC) == 4)) {
temp = SubWord(temp);
}
W[i>>2][i&3] = W[(i - KC)>>2][(i-KC)&3] ^ temp;
}
if (!forEncryption)
{
for (int j = 1; j < ROUNDS; j++)
{
uint[] w = W[j];
for (int i = 0; i < 4; i++)
{
w[i] = Inv_Mcol(w[i]);
}
}
}
return W;
}
private int ROUNDS;
private uint[][] WorkingKey;
private uint C0, C1, C2, C3;
private bool forEncryption;
private const int BLOCK_SIZE = 16;
/**
* default constructor - 128 bit block size.
*/
public AesFastEngine()
{
}
/**
* initialise an AES cipher.
*
* @param forEncryption whether or not we are for encryption.
* @param parameters the parameters required to set up the cipher.
* @exception ArgumentException if the parameters argument is
* inappropriate.
*/
public virtual void Init(
bool forEncryption,
ICipherParameters parameters)
{
KeyParameter keyParameter = parameters as KeyParameter;
if (keyParameter == null)
throw new ArgumentException("invalid parameter passed to AES init - " + parameters.GetType().Name);
WorkingKey = GenerateWorkingKey(keyParameter.GetKey(), forEncryption);
this.forEncryption = forEncryption;
}
public virtual string AlgorithmName
{
get { return "AES"; }
}
public virtual bool IsPartialBlockOkay
{
get { return false; }
}
public virtual int GetBlockSize()
{
return BLOCK_SIZE;
}
public virtual int ProcessBlock(
byte[] input,
int inOff,
byte[] output,
int outOff)
{
if (WorkingKey == null)
throw new InvalidOperationException("AES engine not initialised");
Check.DataLength(input, inOff, 16, "input buffer too short");
Check.OutputLength(output, outOff, 16, "output buffer too short");
UnPackBlock(input, inOff);
if (forEncryption)
{
EncryptBlock(WorkingKey);
}
else
{
DecryptBlock(WorkingKey);
}
PackBlock(output, outOff);
return BLOCK_SIZE;
}
public virtual void Reset()
{
}
private void UnPackBlock(
byte[] bytes,
int off)
{
C0 = Pack.LE_To_UInt32(bytes, off);
C1 = Pack.LE_To_UInt32(bytes, off + 4);
C2 = Pack.LE_To_UInt32(bytes, off + 8);
C3 = Pack.LE_To_UInt32(bytes, off + 12);
}
private void PackBlock(
byte[] bytes,
int off)
{
Pack.UInt32_To_LE(C0, bytes, off);
Pack.UInt32_To_LE(C1, bytes, off + 4);
Pack.UInt32_To_LE(C2, bytes, off + 8);
Pack.UInt32_To_LE(C3, bytes, off + 12);
}
private void EncryptBlock(uint[][] KW)
{
uint[] kw = KW[0];
uint t0 = this.C0 ^ kw[0];
uint t1 = this.C1 ^ kw[1];
uint t2 = this.C2 ^ kw[2];
uint r0, r1, r2, r3 = this.C3 ^ kw[3];
int r = 1;
while (r < ROUNDS - 1)
{
kw = KW[r++];
r0 = T0[t0 & 255] ^ T1[(t1 >> 8) & 255] ^ T2[(t2 >> 16) & 255] ^ T3[r3 >> 24] ^ kw[0];
r1 = T0[t1 & 255] ^ T1[(t2 >> 8) & 255] ^ T2[(r3 >> 16) & 255] ^ T3[t0 >> 24] ^ kw[1];
r2 = T0[t2 & 255] ^ T1[(r3 >> 8) & 255] ^ T2[(t0 >> 16) & 255] ^ T3[t1 >> 24] ^ kw[2];
r3 = T0[r3 & 255] ^ T1[(t0 >> 8) & 255] ^ T2[(t1 >> 16) & 255] ^ T3[t2 >> 24] ^ kw[3];
kw = KW[r++];
t0 = T0[r0 & 255] ^ T1[(r1 >> 8) & 255] ^ T2[(r2 >> 16) & 255] ^ T3[r3 >> 24] ^ kw[0];
t1 = T0[r1 & 255] ^ T1[(r2 >> 8) & 255] ^ T2[(r3 >> 16) & 255] ^ T3[r0 >> 24] ^ kw[1];
t2 = T0[r2 & 255] ^ T1[(r3 >> 8) & 255] ^ T2[(r0 >> 16) & 255] ^ T3[r1 >> 24] ^ kw[2];
r3 = T0[r3 & 255] ^ T1[(r0 >> 8) & 255] ^ T2[(r1 >> 16) & 255] ^ T3[r2 >> 24] ^ kw[3];
}
kw = KW[r++];
r0 = T0[t0 & 255] ^ T1[(t1 >> 8) & 255] ^ T2[(t2 >> 16) & 255] ^ T3[r3 >> 24] ^ kw[0];
r1 = T0[t1 & 255] ^ T1[(t2 >> 8) & 255] ^ T2[(r3 >> 16) & 255] ^ T3[t0 >> 24] ^ kw[1];
r2 = T0[t2 & 255] ^ T1[(r3 >> 8) & 255] ^ T2[(t0 >> 16) & 255] ^ T3[t1 >> 24] ^ kw[2];
r3 = T0[r3 & 255] ^ T1[(t0 >> 8) & 255] ^ T2[(t1 >> 16) & 255] ^ T3[t2 >> 24] ^ kw[3];
// the final round's table is a simple function of S so we don't use a whole other four tables for it
kw = KW[r];
this.C0 = (uint)S[r0 & 255] ^ (((uint)S[(r1 >> 8) & 255]) << 8) ^ (((uint)S[(r2 >> 16) & 255]) << 16) ^ (((uint)S[r3 >> 24]) << 24) ^ kw[0];
this.C1 = (uint)S[r1 & 255] ^ (((uint)S[(r2 >> 8) & 255]) << 8) ^ (((uint)S[(r3 >> 16) & 255]) << 16) ^ (((uint)S[r0 >> 24]) << 24) ^ kw[1];
this.C2 = (uint)S[r2 & 255] ^ (((uint)S[(r3 >> 8) & 255]) << 8) ^ (((uint)S[(r0 >> 16) & 255]) << 16) ^ (((uint)S[r1 >> 24]) << 24) ^ kw[2];
this.C3 = (uint)S[r3 & 255] ^ (((uint)S[(r0 >> 8) & 255]) << 8) ^ (((uint)S[(r1 >> 16) & 255]) << 16) ^ (((uint)S[r2 >> 24]) << 24) ^ kw[3];
}
private void DecryptBlock(uint[][] KW)
{
uint[] kw = KW[ROUNDS];
uint t0 = this.C0 ^ kw[0];
uint t1 = this.C1 ^ kw[1];
uint t2 = this.C2 ^ kw[2];
uint r0, r1, r2, r3 = this.C3 ^ kw[3];
int r = ROUNDS - 1;
while (r > 1)
{
kw = KW[r--];
r0 = Tinv0[t0 & 255] ^ Tinv1[(r3 >> 8) & 255] ^ Tinv2[(t2 >> 16) & 255] ^ Tinv3[t1 >> 24] ^ kw[0];
r1 = Tinv0[t1 & 255] ^ Tinv1[(t0 >> 8) & 255] ^ Tinv2[(r3 >> 16) & 255] ^ Tinv3[t2 >> 24] ^ kw[1];
r2 = Tinv0[t2 & 255] ^ Tinv1[(t1 >> 8) & 255] ^ Tinv2[(t0 >> 16) & 255] ^ Tinv3[r3 >> 24] ^ kw[2];
r3 = Tinv0[r3 & 255] ^ Tinv1[(t2 >> 8) & 255] ^ Tinv2[(t1 >> 16) & 255] ^ Tinv3[t0 >> 24] ^ kw[3];
kw = KW[r--];
t0 = Tinv0[r0 & 255] ^ Tinv1[(r3 >> 8) & 255] ^ Tinv2[(r2 >> 16) & 255] ^ Tinv3[r1 >> 24] ^ kw[0];
t1 = Tinv0[r1 & 255] ^ Tinv1[(r0 >> 8) & 255] ^ Tinv2[(r3 >> 16) & 255] ^ Tinv3[r2 >> 24] ^ kw[1];
t2 = Tinv0[r2 & 255] ^ Tinv1[(r1 >> 8) & 255] ^ Tinv2[(r0 >> 16) & 255] ^ Tinv3[r3 >> 24] ^ kw[2];
r3 = Tinv0[r3 & 255] ^ Tinv1[(r2 >> 8) & 255] ^ Tinv2[(r1 >> 16) & 255] ^ Tinv3[r0 >> 24] ^ kw[3];
}
kw = KW[1];
r0 = Tinv0[t0 & 255] ^ Tinv1[(r3 >> 8) & 255] ^ Tinv2[(t2 >> 16) & 255] ^ Tinv3[t1 >> 24] ^ kw[0];
r1 = Tinv0[t1 & 255] ^ Tinv1[(t0 >> 8) & 255] ^ Tinv2[(r3 >> 16) & 255] ^ Tinv3[t2 >> 24] ^ kw[1];
r2 = Tinv0[t2 & 255] ^ Tinv1[(t1 >> 8) & 255] ^ Tinv2[(t0 >> 16) & 255] ^ Tinv3[r3 >> 24] ^ kw[2];
r3 = Tinv0[r3 & 255] ^ Tinv1[(t2 >> 8) & 255] ^ Tinv2[(t1 >> 16) & 255] ^ Tinv3[t0 >> 24] ^ kw[3];
// the final round's table is a simple function of Si so we don't use a whole other four tables for it
kw = KW[0];
this.C0 = (uint)Si[r0 & 255] ^ (((uint)Si[(r3 >> 8) & 255]) << 8) ^ (((uint)Si[(r2 >> 16) & 255]) << 16) ^ (((uint)Si[r1 >> 24]) << 24) ^ kw[0];
this.C1 = (uint)Si[r1 & 255] ^ (((uint)Si[(r0 >> 8) & 255]) << 8) ^ (((uint)Si[(r3 >> 16) & 255]) << 16) ^ (((uint)Si[r2 >> 24]) << 24) ^ kw[1];
this.C2 = (uint)Si[r2 & 255] ^ (((uint)Si[(r1 >> 8) & 255]) << 8) ^ (((uint)Si[(r0 >> 16) & 255]) << 16) ^ (((uint)Si[r3 >> 24]) << 24) ^ kw[2];
this.C3 = (uint)Si[r3 & 255] ^ (((uint)Si[(r2 >> 8) & 255]) << 8) ^ (((uint)Si[(r1 >> 16) & 255]) << 16) ^ (((uint)Si[r0 >> 24]) << 24) ^ kw[3];
}
}
}

367
MinecraftClient/Crypto/Streams/BouncyAes/BufferedBlockCipher.cs
View file

@ -1,367 +0,0 @@
using System;
using System.Diagnostics;
using Org.BouncyCastle.Crypto.Parameters;
namespace Org.BouncyCastle.Crypto
{
/**
* A wrapper class that allows block ciphers to be used to process data in
* a piecemeal fashion. The BufferedBlockCipher outputs a block only when the
* buffer is full and more data is being added, or on a doFinal.
* <p>
* Note: in the case where the underlying cipher is either a CFB cipher or an
* OFB one the last block may not be a multiple of the block size.
* </p>
*/
public class BufferedBlockCipher
: BufferedCipherBase
{
internal byte[] buf;
internal int bufOff;
internal bool forEncryption;
internal IBlockCipher cipher;
/**
* constructor for subclasses
*/
protected BufferedBlockCipher()
{
}
/**
* Create a buffered block cipher without padding.
*
* @param cipher the underlying block cipher this buffering object wraps.
* false otherwise.
*/
public BufferedBlockCipher(
IBlockCipher cipher)
{
if (cipher == null)
throw new ArgumentNullException("cipher");
this.cipher = cipher;
buf = new byte[cipher.GetBlockSize()];
bufOff = 0;
}
public override string AlgorithmName
{
get { return cipher.AlgorithmName; }
}
/**
* initialise the cipher.
*
* @param forEncryption if true the cipher is initialised for
* encryption, if false for decryption.
* @param param the key and other data required by the cipher.
* @exception ArgumentException if the parameters argument is
* inappropriate.
*/
// Note: This doubles as the Init in the event that this cipher is being used as an IWrapper
public override void Init(
bool forEncryption,
ICipherParameters parameters)
{
this.forEncryption = forEncryption;
//ParametersWithRandom pwr = parameters as ParametersWithRandom;
//if (pwr != null)
// parameters = pwr.Parameters;
Reset();
cipher.Init(forEncryption, parameters);
}
/**
* return the blocksize for the underlying cipher.
*
* @return the blocksize for the underlying cipher.
*/
public override int GetBlockSize()
{
return cipher.GetBlockSize();
}
/**
* return the size of the output buffer required for an update
* an input of len bytes.
*
* @param len the length of the input.
* @return the space required to accommodate a call to update
* with len bytes of input.
*/
public override int GetUpdateOutputSize(
int length)
{
int total = length + bufOff;
int leftOver = total % buf.Length;
return total - leftOver;
}
/**
* return the size of the output buffer required for an update plus a
* doFinal with an input of len bytes.
*
* @param len the length of the input.
* @return the space required to accommodate a call to update and doFinal
* with len bytes of input.
*/
public override int GetOutputSize(
int length)
{
// Note: Can assume IsPartialBlockOkay is true for purposes of this calculation
return length + bufOff;
}
/**
* process a single byte, producing an output block if necessary.
*
* @param in the input byte.
* @param out the space for any output that might be produced.
* @param outOff the offset from which the output will be copied.
* @return the number of output bytes copied to out.
* @exception DataLengthException if there isn't enough space in out.
* @exception InvalidOperationException if the cipher isn't initialised.
*/
public override int ProcessByte(
byte input,
byte[] output,
int outOff)
{
buf[bufOff++] = input;
if (bufOff == buf.Length)
{
if ((outOff + buf.Length) > output.Length)
throw new DataLengthException("output buffer too short");
bufOff = 0;
return cipher.ProcessBlock(buf, 0, output, outOff);
}
return 0;
}
public override byte[] ProcessByte(
byte input)
{
int outLength = GetUpdateOutputSize(1);
byte[] outBytes = outLength > 0 ? new byte[outLength] : null;
int pos = ProcessByte(input, outBytes, 0);
if (outLength > 0 && pos < outLength)
{
byte[] tmp = new byte[pos];
Array.Copy(outBytes, 0, tmp, 0, pos);
outBytes = tmp;
}
return outBytes;
}
public override byte[] ProcessBytes(
byte[] input,
int inOff,
int length)
{
if (input == null)
throw new ArgumentNullException("input");
if (length < 1)
return null;
int outLength = GetUpdateOutputSize(length);
byte[] outBytes = outLength > 0 ? new byte[outLength] : null;
int pos = ProcessBytes(input, inOff, length, outBytes, 0);
if (outLength > 0 && pos < outLength)
{
byte[] tmp = new byte[pos];
Array.Copy(outBytes, 0, tmp, 0, pos);
outBytes = tmp;
}
return outBytes;
}
/**
* process an array of bytes, producing output if necessary.
*
* @param in the input byte array.
* @param inOff the offset at which the input data starts.
* @param len the number of bytes to be copied out of the input array.
* @param out the space for any output that might be produced.
* @param outOff the offset from which the output will be copied.
* @return the number of output bytes copied to out.
* @exception DataLengthException if there isn't enough space in out.
* @exception InvalidOperationException if the cipher isn't initialised.
*/
public override int ProcessBytes(
byte[] input,
int inOff,
int length,
byte[] output,
int outOff)
{
if (length < 1)
{
if (length < 0)
throw new ArgumentException("Can't have a negative input length!");
return 0;
}
int blockSize = GetBlockSize();
int outLength = GetUpdateOutputSize(length);
if (outLength > 0)
{
Check.OutputLength(output, outOff, outLength, "output buffer too short");
}
int resultLen = 0;
int gapLen = buf.Length - bufOff;
if (length > gapLen)
{
Array.Copy(input, inOff, buf, bufOff, gapLen);
resultLen += cipher.ProcessBlock(buf, 0, output, outOff);
bufOff = 0;
length -= gapLen;
inOff += gapLen;
while (length > buf.Length)
{
resultLen += cipher.ProcessBlock(input, inOff, output, outOff + resultLen);
length -= blockSize;
inOff += blockSize;
}
}
Array.Copy(input, inOff, buf, bufOff, length);
bufOff += length;
if (bufOff == buf.Length)
{
resultLen += cipher.ProcessBlock(buf, 0, output, outOff + resultLen);
bufOff = 0;
}
return resultLen;
}
public override byte[] DoFinal()
{
byte[] outBytes = EmptyBuffer;
int length = GetOutputSize(0);
if (length > 0)
{
outBytes = new byte[length];
int pos = DoFinal(outBytes, 0);
if (pos < outBytes.Length)
{
byte[] tmp = new byte[pos];
Array.Copy(outBytes, 0, tmp, 0, pos);
outBytes = tmp;
}
}
else
{
Reset();
}
return outBytes;
}
public override byte[] DoFinal(
byte[] input,
int inOff,
int inLen)
{
if (input == null)
throw new ArgumentNullException("input");
int length = GetOutputSize(inLen);
byte[] outBytes = EmptyBuffer;
if (length > 0)
{
outBytes = new byte[length];
int pos = (inLen > 0)
? ProcessBytes(input, inOff, inLen, outBytes, 0)
: 0;
pos += DoFinal(outBytes, pos);
if (pos < outBytes.Length)
{
byte[] tmp = new byte[pos];
Array.Copy(outBytes, 0, tmp, 0, pos);
outBytes = tmp;
}
}
else
{
Reset();
}
return outBytes;
}
/**
* Process the last block in the buffer.
*
* @param out the array the block currently being held is copied into.
* @param outOff the offset at which the copying starts.
* @return the number of output bytes copied to out.
* @exception DataLengthException if there is insufficient space in out for
* the output, or the input is not block size aligned and should be.
* @exception InvalidOperationException if the underlying cipher is not
* initialised.
* @exception InvalidCipherTextException if padding is expected and not found.
* @exception DataLengthException if the input is not block size
* aligned.
*/
public override int DoFinal(
byte[] output,
int outOff)
{
try
{
if (bufOff != 0)
{
Check.DataLength(!cipher.IsPartialBlockOkay, "data not block size aligned");
Check.OutputLength(output, outOff, bufOff, "output buffer too short for DoFinal()");
// NB: Can't copy directly, or we may write too much output
cipher.ProcessBlock(buf, 0, buf, 0);
Array.Copy(buf, 0, output, outOff, bufOff);
}
return bufOff;
}
finally
{
Reset();
}
}
/**
* Reset the buffer and cipher. After resetting the object is in the same
* state as it was after the last init (if there was one).
*/
public override void Reset()
{
Array.Clear(buf, 0, buf.Length);
bufOff = 0;
cipher.Reset();
}
}
}

113
MinecraftClient/Crypto/Streams/BouncyAes/BufferedCipherBase.cs
View file

@ -1,113 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
public abstract class BufferedCipherBase
: IBufferedCipher
{
protected static readonly byte[] EmptyBuffer = new byte[0];
public abstract string AlgorithmName { get; }
public abstract void Init(bool forEncryption, ICipherParameters parameters);
public abstract int GetBlockSize();
public abstract int GetOutputSize(int inputLen);
public abstract int GetUpdateOutputSize(int inputLen);
public abstract byte[] ProcessByte(byte input);
public virtual int ProcessByte(
byte input,
byte[] output,
int outOff)
{
byte[] outBytes = ProcessByte(input);
if (outBytes == null)
return 0;
if (outOff + outBytes.Length > output.Length)
throw new DataLengthException("output buffer too short");
outBytes.CopyTo(output, outOff);
return outBytes.Length;
}
public virtual byte[] ProcessBytes(
byte[] input)
{
return ProcessBytes(input, 0, input.Length);
}
public abstract byte[] ProcessBytes(byte[] input, int inOff, int length);
public virtual int ProcessBytes(
byte[] input,
byte[] output,
int outOff)
{
return ProcessBytes(input, 0, input.Length, output, outOff);
}
public virtual int ProcessBytes(
byte[] input,
int inOff,
int length,
byte[] output,
int outOff)
{
byte[] outBytes = ProcessBytes(input, inOff, length);
if (outBytes == null)
return 0;
if (outOff + outBytes.Length > output.Length)
throw new DataLengthException("output buffer too short");
outBytes.CopyTo(output, outOff);
return outBytes.Length;
}
public abstract byte[] DoFinal();
public virtual byte[] DoFinal(
byte[] input)
{
return DoFinal(input, 0, input.Length);
}
public abstract byte[] DoFinal(
byte[] input,
int inOff,
int length);
public virtual int DoFinal(
byte[] output,
int outOff)
{
byte[] outBytes = DoFinal();
if (outOff + outBytes.Length > output.Length)
throw new DataLengthException("output buffer too short");
outBytes.CopyTo(output, outOff);
return outBytes.Length;
}
public virtual int DoFinal(
byte[] input,
byte[] output,
int outOff)
{
return DoFinal(input, 0, input.Length, output, outOff);
}
public virtual int DoFinal(
byte[] input,
int inOff,
int length,
byte[] output,
int outOff)
{
int len = ProcessBytes(input, inOff, length, output, outOff);
len += DoFinal(output, outOff + len);
return len;
}
public abstract void Reset();
}
}

224
MinecraftClient/Crypto/Streams/BouncyAes/CfbBlockCipher.cs
View file

@ -1,224 +0,0 @@
using System;
using Org.BouncyCastle.Crypto.Parameters;
namespace Org.BouncyCastle.Crypto.Modes
{
/**
* implements a Cipher-FeedBack (CFB) mode on top of a simple cipher.
*/
public class CfbBlockCipher
: IBlockCipher
{
private byte[] IV;
private byte[] cfbV;
private byte[] cfbOutV;
private bool encrypting;
private readonly int blockSize;
private readonly IBlockCipher cipher;
/**
* Basic constructor.
*
* @param cipher the block cipher to be used as the basis of the
* feedback mode.
* @param blockSize the block size in bits (note: a multiple of 8)
*/
public CfbBlockCipher(
IBlockCipher cipher,
int bitBlockSize)
{
this.cipher = cipher;
this.blockSize = bitBlockSize / 8;
this.IV = new byte[cipher.GetBlockSize()];
this.cfbV = new byte[cipher.GetBlockSize()];
this.cfbOutV = new byte[cipher.GetBlockSize()];
}
/**
* return the underlying block cipher that we are wrapping.
*
* @return the underlying block cipher that we are wrapping.
*/
public IBlockCipher GetUnderlyingCipher()
{
return cipher;
}
/**
* Initialise the cipher and, possibly, the initialisation vector (IV).
* If an IV isn't passed as part of the parameter, the IV will be all zeros.
* An IV which is too short is handled in FIPS compliant fashion.
*
* @param forEncryption if true the cipher is initialised for
* encryption, if false for decryption.
* @param param the key and other data required by the cipher.
* @exception ArgumentException if the parameters argument is
* inappropriate.
*/
public void Init(
bool forEncryption,
ICipherParameters parameters)
{
this.encrypting = forEncryption;
if (parameters is ParametersWithIV)
{
ParametersWithIV ivParam = (ParametersWithIV) parameters;
byte[] iv = ivParam.GetIV();
int diff = IV.Length - iv.Length;
Array.Copy(iv, 0, IV, diff, iv.Length);
Array.Clear(IV, 0, diff);
parameters = ivParam.Parameters;
}
Reset();
// if it's null, key is to be reused.
if (parameters != null)
{
cipher.Init(true, parameters);
}
}
/**
* return the algorithm name and mode.
*
* @return the name of the underlying algorithm followed by "/CFB"
* and the block size in bits.
*/
public string AlgorithmName
{
get { return cipher.AlgorithmName + "/CFB" + (blockSize * 8); }
}
public bool IsPartialBlockOkay
{
get { return true; }
}
/**
* return the block size we are operating at.
*
* @return the block size we are operating at (in bytes).
*/
public int GetBlockSize()
{
return blockSize;
}
/**
* Process one block of input from the array in and write it to
* the out array.
*
* @param in the array containing the input data.
* @param inOff offset into the in array the data starts at.
* @param out the array the output data will be copied into.
* @param outOff the offset into the out array the output will start at.
* @exception DataLengthException if there isn't enough data in in, or
* space in out.
* @exception InvalidOperationException if the cipher isn't initialised.
* @return the number of bytes processed and produced.
*/
public int ProcessBlock(
byte[] input,
int inOff,
byte[] output,
int outOff)
{
return (encrypting)
? EncryptBlock(input, inOff, output, outOff)
: DecryptBlock(input, inOff, output, outOff);
}
/**
* Do the appropriate processing for CFB mode encryption.
*
* @param in the array containing the data to be encrypted.
* @param inOff offset into the in array the data starts at.
* @param out the array the encrypted data will be copied into.
* @param outOff the offset into the out array the output will start at.
* @exception DataLengthException if there isn't enough data in in, or
* space in out.
* @exception InvalidOperationException if the cipher isn't initialised.
* @return the number of bytes processed and produced.
*/
public int EncryptBlock(
byte[] input,
int inOff,
byte[] outBytes,
int outOff)
{
if ((inOff + blockSize) > input.Length)
{
throw new DataLengthException("input buffer too short");
}
if ((outOff + blockSize) > outBytes.Length)
{
throw new DataLengthException("output buffer too short");
}
cipher.ProcessBlock(cfbV, 0, cfbOutV, 0);
//
// XOR the cfbV with the plaintext producing the ciphertext
//
for (int i = 0; i < blockSize; i++)
{
outBytes[outOff + i] = (byte)(cfbOutV[i] ^ input[inOff + i]);
}
//
// change over the input block.
//
Array.Copy(cfbV, blockSize, cfbV, 0, cfbV.Length - blockSize);
Array.Copy(outBytes, outOff, cfbV, cfbV.Length - blockSize, blockSize);
return blockSize;
}
/**
* Do the appropriate processing for CFB mode decryption.
*
* @param in the array containing the data to be decrypted.
* @param inOff offset into the in array the data starts at.
* @param out the array the encrypted data will be copied into.
* @param outOff the offset into the out array the output will start at.
* @exception DataLengthException if there isn't enough data in in, or
* space in out.
* @exception InvalidOperationException if the cipher isn't initialised.
* @return the number of bytes processed and produced.
*/
public int DecryptBlock(
byte[] input,
int inOff,
byte[] outBytes,
int outOff)
{
if ((inOff + blockSize) > input.Length)
{
throw new DataLengthException("input buffer too short");
}
if ((outOff + blockSize) > outBytes.Length)
{
throw new DataLengthException("output buffer too short");
}
cipher.ProcessBlock(cfbV, 0, cfbOutV, 0);
//
// change over the input block.
//
Array.Copy(cfbV, blockSize, cfbV, 0, cfbV.Length - blockSize);
Array.Copy(input, inOff, cfbV, cfbV.Length - blockSize, blockSize);
//
// XOR the cfbV with the ciphertext producing the plaintext
//
for (int i = 0; i < blockSize; i++)
{
outBytes[outOff + i] = (byte)(cfbOutV[i] ^ input[inOff + i]);
}
return blockSize;
}
/**
* reset the chaining vector back to the IV and reset the underlying
* cipher.
*/
public void Reset()
{
Array.Copy(IV, 0, cfbV, 0, IV.Length);
cipher.Reset();
}
}
}

25
MinecraftClient/Crypto/Streams/BouncyAes/Check.cs
View file

@ -1,25 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
internal class Check
{
internal static void DataLength(bool condition, string msg)
{
if (condition)
throw new DataLengthException(msg);
}
internal static void DataLength(byte[] buf, int off, int len, string msg)
{
if (off + len > buf.Length)
throw new DataLengthException(msg);
}
internal static void OutputLength(byte[] buf, int off, int len, string msg)
{
if (off + len > buf.Length)
throw new OutputLengthException(msg);
}
}
}

234
MinecraftClient/Crypto/Streams/BouncyAes/CipherStream.cs
View file

@ -1,234 +0,0 @@
using System;
using System.Diagnostics;
using System.IO;
using Org.BouncyCastle.Crypto;
namespace Org.BouncyCastle.Crypto.IO
{
public class CipherStream
: Stream
{
internal Stream stream;
internal IBufferedCipher inCipher, outCipher;
private byte[] mInBuf;
private int mInPos;
private bool inStreamEnded;
public CipherStream(
Stream stream,
IBufferedCipher readCipher,
IBufferedCipher writeCipher)
{
this.stream = stream;
if (readCipher != null)
{
this.inCipher = readCipher;
mInBuf = null;
}
if (writeCipher != null)
{
this.outCipher = writeCipher;
}
}
public IBufferedCipher ReadCipher
{
get { return inCipher; }
}
public IBufferedCipher WriteCipher
{
get { return outCipher; }
}
public override int ReadByte()
{
if (inCipher == null)
return stream.ReadByte();
if (mInBuf == null || mInPos >= mInBuf.Length)
{
if (!FillInBuf())
return -1;
}
return mInBuf[mInPos++];
}
public override int Read(
byte[] buffer,
int offset,
int count)
{
if (inCipher == null)
return stream.Read(buffer, offset, count);
int num = 0;
while (num < count)
{
if (mInBuf == null || mInPos >= mInBuf.Length)
{
if (!FillInBuf())
break;
}
int numToCopy = System.Math.Min(count - num, mInBuf.Length - mInPos);
Array.Copy(mInBuf, mInPos, buffer, offset + num, numToCopy);
mInPos += numToCopy;
num += numToCopy;
}
return num;
}
private bool FillInBuf()
{
if (inStreamEnded)
return false;
mInPos = 0;
do
{
mInBuf = ReadAndProcessBlock();
}
while (!inStreamEnded && mInBuf == null);
return mInBuf != null;
}
private byte[] ReadAndProcessBlock()
{
int blockSize = inCipher.GetBlockSize();
int readSize = (blockSize == 0) ? 256 : blockSize;
byte[] block = new byte[readSize];
int numRead = 0;
do
{
int count = stream.Read(block, numRead, block.Length - numRead);
if (count < 1)
{
inStreamEnded = true;
break;
}
numRead += count;
}
while (numRead < block.Length);
Debug.Assert(inStreamEnded || numRead == block.Length);
byte[] bytes = inStreamEnded
? inCipher.DoFinal(block, 0, numRead)
: inCipher.ProcessBytes(block);
if (bytes != null && bytes.Length == 0)
{
bytes = null;
}
return bytes;
}
public override void Write(
byte[] buffer,
int offset,
int count)
{
Debug.Assert(buffer != null);
Debug.Assert(0 <= offset && offset <= buffer.Length);
Debug.Assert(count >= 0);
int end = offset + count;
Debug.Assert(0 <= end && end <= buffer.Length);
if (outCipher == null)
{
stream.Write(buffer, offset, count);
return;
}
byte[] data = outCipher.ProcessBytes(buffer, offset, count);
if (data != null)
{
stream.Write(data, 0, data.Length);
}
}
public override void WriteByte(
byte b)
{
if (outCipher == null)
{
stream.WriteByte(b);
return;
}
byte[] data = outCipher.ProcessByte(b);
if (data != null)
{
stream.Write(data, 0, data.Length);
}
}
public override bool CanRead
{
get { return stream.CanRead && (inCipher != null); }
}
public override bool CanWrite
{
get { return stream.CanWrite && (outCipher != null); }
}
public override bool CanSeek
{
get { return false; }
}
public sealed override long Length
{
get { throw new NotSupportedException(); }
}
public sealed override long Position
{
get { throw new NotSupportedException(); }
set { throw new NotSupportedException(); }
}
public override void Close()
{
if (outCipher != null)
{
byte[] data = outCipher.DoFinal();
stream.Write(data, 0, data.Length);
stream.Flush();
}
stream.Close();
}
public override void Flush()
{
// Note: outCipher.DoFinal is only called during Close()
stream.Flush();
}
public sealed override long Seek(
long offset,
SeekOrigin origin)
{
throw new NotSupportedException();
}
public sealed override void SetLength(
long length)
{
throw new NotSupportedException();
}
}
}

28
MinecraftClient/Crypto/Streams/BouncyAes/CryptoException.cs
View file

@ -1,28 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
#if !(NETCF_1_0 || NETCF_2_0 || SILVERLIGHT)
[Serializable]
#endif
public class CryptoException
: Exception
{
public CryptoException()
{
}
public CryptoException(
string message)
: base(message)
{
}
public CryptoException(
string message,
Exception exception)
: base(message, exception)
{
}
}
}

42
MinecraftClient/Crypto/Streams/BouncyAes/DataLengthException.cs
View file

@ -1,42 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
/**
* this exception is thrown if a buffer that is meant to have output
* copied into it turns out to be too short, or if we've been given
* insufficient input. In general this exception will Get thrown rather
* than an ArrayOutOfBounds exception.
*/
#if !(NETCF_1_0 || NETCF_2_0 || SILVERLIGHT)
[Serializable]
#endif
public class DataLengthException
: CryptoException
{
/**
* base constructor.
*/
public DataLengthException()
{
}
/**
* create a DataLengthException with the given message.
*
* @param message the message to be carried with the exception.
*/
public DataLengthException(
string message)
: base(message)
{
}
public DataLengthException(
string message,
Exception exception)
: base(message, exception)
{
}
}
}

36
MinecraftClient/Crypto/Streams/BouncyAes/IBlockCipher.cs
View file

@ -1,36 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
/// <remarks>Base interface for a symmetric key block cipher.</remarks>
public interface IBlockCipher
{
/// <summary>The name of the algorithm this cipher implements.</summary>
string AlgorithmName { get; }
/// <summary>Initialise the cipher.</summary>
/// <param name="forEncryption">Initialise for encryption if true, for decryption if false.</param>
/// <param name="parameters">The key or other data required by the cipher.</param>
void Init(bool forEncryption, ICipherParameters parameters);
/// <returns>The block size for this cipher, in bytes.</returns>
int GetBlockSize();
/// <summary>Indicates whether this cipher can handle partial blocks.</summary>
bool IsPartialBlockOkay { get; }
/// <summary>Process a block.</summary>
/// <param name="inBuf">The input buffer.</param>
/// <param name="inOff">The offset into <paramref>inBuf</paramref> that the input block begins.</param>
/// <param name="outBuf">The output buffer.</param>
/// <param name="outOff">The offset into <paramref>outBuf</paramref> to write the output block.</param>
/// <exception cref="DataLengthException">If input block is wrong size, or outBuf too small.</exception>
/// <returns>The number of bytes processed and produced.</returns>
int ProcessBlock(byte[] inBuf, int inOff, byte[] outBuf, int outOff);
/// <summary>
/// Reset the cipher to the same state as it was after the last init (if there was one).
/// </summary>
void Reset();
}
}

44
MinecraftClient/Crypto/Streams/BouncyAes/IBufferedCipher.cs
View file

@ -1,44 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
/// <remarks>Block cipher engines are expected to conform to this interface.</remarks>
public interface IBufferedCipher
{
/// <summary>The name of the algorithm this cipher implements.</summary>
string AlgorithmName { get; }
/// <summary>Initialise the cipher.</summary>
/// <param name="forEncryption">If true the cipher is initialised for encryption,
/// if false for decryption.</param>
/// <param name="parameters">The key and other data required by the cipher.</param>
void Init(bool forEncryption, ICipherParameters parameters);
int GetBlockSize();
int GetOutputSize(int inputLen);
int GetUpdateOutputSize(int inputLen);
byte[] ProcessByte(byte input);
int ProcessByte(byte input, byte[] output, int outOff);
byte[] ProcessBytes(byte[] input);
byte[] ProcessBytes(byte[] input, int inOff, int length);
int ProcessBytes(byte[] input, byte[] output, int outOff);
int ProcessBytes(byte[] input, int inOff, int length, byte[] output, int outOff);
byte[] DoFinal();
byte[] DoFinal(byte[] input);
byte[] DoFinal(byte[] input, int inOff, int length);
int DoFinal(byte[] output, int outOff);
int DoFinal(byte[] input, byte[] output, int outOff);
int DoFinal(byte[] input, int inOff, int length, byte[] output, int outOff);
/// <summary>
/// Reset the cipher. After resetting the cipher is in the same state
/// as it was after the last init (if there was one).
/// </summary>
void Reset();
}
}

11
MinecraftClient/Crypto/Streams/BouncyAes/ICipherParameters.cs
View file

@ -1,11 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
/**
* all parameter classes implement this.
*/
public interface ICipherParameters
{
}
}

43
MinecraftClient/Crypto/Streams/BouncyAes/KeyParameter.cs
View file

@ -1,43 +0,0 @@
using System;
using Org.BouncyCastle.Crypto;
namespace Org.BouncyCastle.Crypto.Parameters
{
public class KeyParameter
: ICipherParameters
{
private readonly byte[] key;
public KeyParameter(
byte[] key)
{
if (key == null)
throw new ArgumentNullException("key");
this.key = (byte[]) key.Clone();
}
public KeyParameter(
byte[] key,
int keyOff,
int keyLen)
{
if (key == null)
throw new ArgumentNullException("key");
if (keyOff < 0 || keyOff > key.Length)
throw new ArgumentOutOfRangeException("keyOff");
if (keyLen < 0 || (keyOff + keyLen) > key.Length)
throw new ArgumentOutOfRangeException("keyLen");
this.key = new byte[keyLen];
Array.Copy(key, keyOff, this.key, 0, keyLen);
}
public byte[] GetKey()
{
return (byte[]) key.Clone();
}
}
}

28
MinecraftClient/Crypto/Streams/BouncyAes/OutputLengthException.cs
View file

@ -1,28 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
#if !(NETCF_1_0 || NETCF_2_0 || SILVERLIGHT)
[Serializable]
#endif
public class OutputLengthException
: DataLengthException
{
public OutputLengthException()
{
}
public OutputLengthException(
string message)
: base(message)
{
}
public OutputLengthException(
string message,
Exception exception)
: base(message, exception)
{
}
}
}

266
MinecraftClient/Crypto/Streams/BouncyAes/Pack.cs
View file

@ -1,266 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto.Utilities
{
internal sealed class Pack
{
private Pack()
{
}
internal static void UInt16_To_BE(ushort n, byte[] bs)
{
bs[0] = (byte)(n >> 8);
bs[1] = (byte)(n);
}
internal static void UInt16_To_BE(ushort n, byte[] bs, int off)
{
bs[off] = (byte)(n >> 8);
bs[off + 1] = (byte)(n);
}
internal static ushort BE_To_UInt16(byte[] bs)
{
uint n = (uint)bs[0] << 8
| (uint)bs[1];
return (ushort)n;
}
internal static ushort BE_To_UInt16(byte[] bs, int off)
{
uint n = (uint)bs[off] << 8
| (uint)bs[off + 1];
return (ushort)n;
}
internal static byte[] UInt32_To_BE(uint n)
{
byte[] bs = new byte[4];
UInt32_To_BE(n, bs, 0);
return bs;
}
internal static void UInt32_To_BE(uint n, byte[] bs)
{
bs[0] = (byte)(n >> 24);
bs[1] = (byte)(n >> 16);
bs[2] = (byte)(n >> 8);
bs[3] = (byte)(n);
}
internal static void UInt32_To_BE(uint n, byte[] bs, int off)
{
bs[off] = (byte)(n >> 24);
bs[off + 1] = (byte)(n >> 16);
bs[off + 2] = (byte)(n >> 8);
bs[off + 3] = (byte)(n);
}
internal static byte[] UInt32_To_BE(uint[] ns)
{
byte[] bs = new byte[4 * ns.Length];
UInt32_To_BE(ns, bs, 0);
return bs;
}
internal static void UInt32_To_BE(uint[] ns, byte[] bs, int off)
{
for (int i = 0; i < ns.Length; ++i)
{
UInt32_To_BE(ns[i], bs, off);
off += 4;
}
}
internal static uint BE_To_UInt32(byte[] bs)
{
return (uint)bs[0] << 24
| (uint)bs[1] << 16
| (uint)bs[2] << 8
| (uint)bs[3];
}
internal static uint BE_To_UInt32(byte[] bs, int off)
{
return (uint)bs[off] << 24
| (uint)bs[off + 1] << 16
| (uint)bs[off + 2] << 8
| (uint)bs[off + 3];
}
internal static void BE_To_UInt32(byte[] bs, int off, uint[] ns)
{
for (int i = 0; i < ns.Length; ++i)
{
ns[i] = BE_To_UInt32(bs, off);
off += 4;
}
}
internal static byte[] UInt64_To_BE(ulong n)
{
byte[] bs = new byte[8];
UInt64_To_BE(n, bs, 0);
return bs;
}
internal static void UInt64_To_BE(ulong n, byte[] bs)
{
UInt32_To_BE((uint)(n >> 32), bs);
UInt32_To_BE((uint)(n), bs, 4);
}
internal static void UInt64_To_BE(ulong n, byte[] bs, int off)
{
UInt32_To_BE((uint)(n >> 32), bs, off);
UInt32_To_BE((uint)(n), bs, off + 4);
}
internal static ulong BE_To_UInt64(byte[] bs)
{
uint hi = BE_To_UInt32(bs);
uint lo = BE_To_UInt32(bs, 4);
return ((ulong)hi << 32) | (ulong)lo;
}
internal static ulong BE_To_UInt64(byte[] bs, int off)
{
uint hi = BE_To_UInt32(bs, off);
uint lo = BE_To_UInt32(bs, off + 4);
return ((ulong)hi << 32) | (ulong)lo;
}
internal static void UInt16_To_LE(ushort n, byte[] bs)
{
bs[0] = (byte)(n);
bs[1] = (byte)(n >> 8);
}
internal static void UInt16_To_LE(ushort n, byte[] bs, int off)
{
bs[off] = (byte)(n);
bs[off + 1] = (byte)(n >> 8);
}
internal static ushort LE_To_UInt16(byte[] bs)
{
uint n = (uint)bs[0]
| (uint)bs[1] << 8;
return (ushort)n;
}
internal static ushort LE_To_UInt16(byte[] bs, int off)
{
uint n = (uint)bs[off]
| (uint)bs[off + 1] << 8;
return (ushort)n;
}
internal static byte[] UInt32_To_LE(uint n)
{
byte[] bs = new byte[4];
UInt32_To_LE(n, bs, 0);
return bs;
}
internal static void UInt32_To_LE(uint n, byte[] bs)
{
bs[0] = (byte)(n);
bs[1] = (byte)(n >> 8);
bs[2] = (byte)(n >> 16);
bs[3] = (byte)(n >> 24);
}
internal static void UInt32_To_LE(uint n, byte[] bs, int off)
{
bs[off] = (byte)(n);
bs[off + 1] = (byte)(n >> 8);
bs[off + 2] = (byte)(n >> 16);
bs[off + 3] = (byte)(n >> 24);
}
internal static byte[] UInt32_To_LE(uint[] ns)
{
byte[] bs = new byte[4 * ns.Length];
UInt32_To_LE(ns, bs, 0);
return bs;
}
internal static void UInt32_To_LE(uint[] ns, byte[] bs, int off)
{
for (int i = 0; i < ns.Length; ++i)
{
UInt32_To_LE(ns[i], bs, off);
off += 4;
}
}
internal static uint LE_To_UInt32(byte[] bs)
{
return (uint)bs[0]
| (uint)bs[1] << 8
| (uint)bs[2] << 16
| (uint)bs[3] << 24;
}
internal static uint LE_To_UInt32(byte[] bs, int off)
{
return (uint)bs[off]
| (uint)bs[off + 1] << 8
| (uint)bs[off + 2] << 16
| (uint)bs[off + 3] << 24;
}
internal static void LE_To_UInt32(byte[] bs, int off, uint[] ns)
{
for (int i = 0; i < ns.Length; ++i)
{
ns[i] = LE_To_UInt32(bs, off);
off += 4;
}
}
internal static void LE_To_UInt32(byte[] bs, int bOff, uint[] ns, int nOff, int count)
{
for (int i = 0; i < count; ++i)
{
ns[nOff + i] = LE_To_UInt32(bs, bOff);
bOff += 4;
}
}
internal static byte[] UInt64_To_LE(ulong n)
{
byte[] bs = new byte[8];
UInt64_To_LE(n, bs, 0);
return bs;
}
internal static void UInt64_To_LE(ulong n, byte[] bs)
{
UInt32_To_LE((uint)(n), bs);
UInt32_To_LE((uint)(n >> 32), bs, 4);
}
internal static void UInt64_To_LE(ulong n, byte[] bs, int off)
{
UInt32_To_LE((uint)(n), bs, off);
UInt32_To_LE((uint)(n >> 32), bs, off + 4);
}
internal static ulong LE_To_UInt64(byte[] bs)
{
uint lo = LE_To_UInt32(bs);
uint hi = LE_To_UInt32(bs, 4);
return ((ulong)hi << 32) | (ulong)lo;
}
internal static ulong LE_To_UInt64(byte[] bs, int off)
{
uint lo = LE_To_UInt32(bs, off);
uint hi = LE_To_UInt32(bs, off + 4);
return ((ulong)hi << 32) | (ulong)lo;
}
}
}

43
MinecraftClient/Crypto/Streams/BouncyAes/ParametersWithIV.cs
View file

@ -1,43 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto.Parameters
{
public class ParametersWithIV
: ICipherParameters
{
private readonly ICipherParameters parameters;
private readonly byte[] iv;
public ParametersWithIV(
ICipherParameters parameters,
byte[] iv)
: this(parameters, iv, 0, iv.Length)
{
}
public ParametersWithIV(
ICipherParameters parameters,
byte[] iv,
int ivOff,
int ivLen)
{
// NOTE: 'parameters' may be null to imply key re-use
if (iv == null)
throw new ArgumentNullException("iv");
this.parameters = parameters;
this.iv = new byte[ivLen];
Array.Copy(iv, ivOff, this.iv, 0, ivLen);
}
public byte[] GetIV()
{
return (byte[]) iv.Clone();
}
public ICipherParameters Parameters
{
get { return parameters; }
}
}
}

108
MinecraftClient/Crypto/Streams/MonoAesStream.cs
View file

@ -1,108 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
using System.IO;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Modes;
using Org.BouncyCastle.Crypto.IO;
namespace MinecraftClient.Crypto.Streams
{
/// <summary>
/// An encrypted stream using AES, used for encrypting network data on the fly using AES.
/// This is a mono-compatible adaptation which uses AES engine from the BouncyCastle project.
/// </summary>
public class MonoAesStream : Stream, IAesStream
{
CipherStream cstream;
public MonoAesStream(System.IO.Stream stream, byte[] key)
{
BaseStream = stream;
BufferedBlockCipher enc = GenerateAES(key, true);
BufferedBlockCipher dec = GenerateAES(key, false);
cstream = new CipherStream(stream, dec, enc);
}
public System.IO.Stream BaseStream { get; set; }
public override bool CanRead
{
get { return true; }
}
public override bool CanSeek
{
get { return false; }
}
public override bool CanWrite
{
get { return true; }
}
public override void Flush()
{
BaseStream.Flush();
}
public override long Length
{
get { throw new NotSupportedException(); }
}
public override long Position
{
get
{
throw new NotSupportedException();
}
set
{
throw new NotSupportedException();
}
}
public override int ReadByte()
{
byte[] temp = new byte[1];
Read(temp, 0, 1);
return temp[0];
}
public override int Read(byte[] buffer, int offset, int count)
{
return cstream.Read(buffer, offset, count);
}
public override long Seek(long offset, System.IO.SeekOrigin origin)
{
throw new NotSupportedException();
}
public override void SetLength(long value)
{
throw new NotSupportedException();
}
public override void WriteByte(byte b)
{
Write(new byte[] { b }, 0, 1);
}
public override void Write(byte[] buffer, int offset, int count)
{
cstream.Write(buffer, offset, count);
}
private BufferedBlockCipher GenerateAES(byte[] key, bool forEncryption)
{
BufferedBlockCipher cipher = new BufferedBlockCipher(new CfbBlockCipher(new AesFastEngine(), 8));
cipher.Init(forEncryption, new ParametersWithIV(new KeyParameter(key), key));
return cipher;
}
}
}

106
MinecraftClient/Crypto/Streams/RegularAesStream.cs
View file

@ -1,106 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
using System.IO;
namespace MinecraftClient.Crypto.Streams
{
/// <summary>
/// An encrypted stream using AES, used for encrypting network data on the fly using AES.
/// This is the regular AesStream class used with the regular .NET framework from Microsoft.
/// </summary>
public class RegularAesStream : Stream, IAesStream
{
CryptoStream enc;
CryptoStream dec;
public RegularAesStream(Stream stream, byte[] key)
{
BaseStream = stream;
enc = new CryptoStream(stream, GenerateAES(key).CreateEncryptor(), CryptoStreamMode.Write);
dec = new CryptoStream(stream, GenerateAES(key).CreateDecryptor(), CryptoStreamMode.Read);
}
public System.IO.Stream BaseStream { get; set; }
public override bool CanRead
{
get { return true; }
}
public override bool CanSeek
{
get { return false; }
}
public override bool CanWrite
{
get { return true; }
}
public override void Flush()
{
BaseStream.Flush();
}
public override long Length
{
get { throw new NotSupportedException(); }
}
public override long Position
{
get
{
throw new NotSupportedException();
}
set
{
throw new NotSupportedException();
}
}
public override int ReadByte()
{
return dec.ReadByte();
}
public override int Read(byte[] buffer, int offset, int count)
{
return dec.Read(buffer, offset, count);
}
public override long Seek(long offset, System.IO.SeekOrigin origin)
{
throw new NotSupportedException();
}
public override void SetLength(long value)
{
throw new NotSupportedException();
}
public override void WriteByte(byte b)
{
enc.WriteByte(b);
}
public override void Write(byte[] buffer, int offset, int count)
{
enc.Write(buffer, offset, count);
}
private static Aes GenerateAES(byte[] key)
{
Aes aes = Aes.Create();
aes.Mode = CipherMode.CFB;
aes.Padding = PaddingMode.None;
aes.KeySize = 128;
aes.FeedbackSize = 8;
aes.Key = key;
aes.IV = key;
return aes;
}
}
}

2
MinecraftClient/Mapping/Block.cs
View file

@ -1,6 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.CompilerServices;
using System.Text; using System.Text;
using MinecraftClient.Mapping.BlockPalettes; using MinecraftClient.Mapping.BlockPalettes;
@ -106,6 +107,7 @@ namespace MinecraftClient.Mapping
/// Get a block of the specified type and metadata OR block state /// Get a block of the specified type and metadata OR block state
/// </summary> /// </summary>
/// <param name="typeAndMeta">Type and metadata packed in the same value OR block state</param> /// <param name="typeAndMeta">Type and metadata packed in the same value OR block state</param>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public Block(ushort typeAndMeta) public Block(ushort typeAndMeta)
{ {
this.blockIdAndMeta = typeAndMeta; this.blockIdAndMeta = typeAndMeta;

52
MinecraftClient/Mapping/Chunk.cs
View file

@ -1,6 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.CompilerServices;
using System.Text; using System.Text;
using System.Threading; using System.Threading;
@ -18,12 +19,8 @@ namespace MinecraftClient.Mapping
/// <summary> /// <summary>
/// Blocks contained into the chunk /// Blocks contained into the chunk
/// </summary> /// </summary>
private readonly Block[,,] blocks = new Block[SizeX, SizeY, SizeZ]; private readonly Block[] blocks = new Block[SizeY * SizeZ * SizeX];
/// <summary>
/// Lock for thread safety
/// </summary>
private readonly ReaderWriterLockSlim blockLock = new ReaderWriterLockSlim();
/// <summary> /// <summary>
/// Read, or set the specified block /// Read, or set the specified block
@ -37,41 +34,38 @@ namespace MinecraftClient.Mapping
get get
{ {
if (blockX < 0 || blockX >= SizeX) if (blockX < 0 || blockX >= SizeX)
throw new ArgumentOutOfRangeException("blockX", "Must be between 0 and " + (SizeX - 1) + " (inclusive)"); throw new ArgumentOutOfRangeException(nameof(blockX), "Must be between 0 and " + (SizeX - 1) + " (inclusive)");
if (blockY < 0 || blockY >= SizeY) if (blockY < 0 || blockY >= SizeY)
throw new ArgumentOutOfRangeException("blockY", "Must be between 0 and " + (SizeY - 1) + " (inclusive)"); throw new ArgumentOutOfRangeException(nameof(blockY), "Must be between 0 and " + (SizeY - 1) + " (inclusive)");
if (blockZ < 0 || blockZ >= SizeZ) if (blockZ < 0 || blockZ >= SizeZ)
throw new ArgumentOutOfRangeException("blockZ", "Must be between 0 and " + (SizeZ - 1) + " (inclusive)"); throw new ArgumentOutOfRangeException(nameof(blockZ), "Must be between 0 and " + (SizeZ - 1) + " (inclusive)");
blockLock.EnterReadLock(); return blocks[(blockY << 8) | (blockZ << 4) | blockX];
try
{
return blocks[blockX, blockY, blockZ];
}
finally
{
blockLock.ExitReadLock();
}
} }
set set
{ {
if (blockX < 0 || blockX >= SizeX) if (blockX < 0 || blockX >= SizeX)
throw new ArgumentOutOfRangeException("blockX", "Must be between 0 and " + (SizeX - 1) + " (inclusive)"); throw new ArgumentOutOfRangeException(nameof(blockX), "Must be between 0 and " + (SizeX - 1) + " (inclusive)");
if (blockY < 0 || blockY >= SizeY) if (blockY < 0 || blockY >= SizeY)
throw new ArgumentOutOfRangeException("blockY", "Must be between 0 and " + (SizeY - 1) + " (inclusive)"); throw new ArgumentOutOfRangeException(nameof(blockY), "Must be between 0 and " + (SizeY - 1) + " (inclusive)");
if (blockZ < 0 || blockZ >= SizeZ) if (blockZ < 0 || blockZ >= SizeZ)
throw new ArgumentOutOfRangeException("blockZ", "Must be between 0 and " + (SizeZ - 1) + " (inclusive)"); throw new ArgumentOutOfRangeException(nameof(blockZ), "Must be between 0 and " + (SizeZ - 1) + " (inclusive)");
blockLock.EnterWriteLock(); blocks[(blockY << 8) | (blockZ << 4) | blockX] = value;
try }
}
/// <summary>
/// Used when parsing chunks
/// </summary>
/// <param name="blockX">Block X</param>
/// <param name="blockY">Block Y</param>
/// <param name="blockZ">Block Z</param>
/// <param name="block">Block</param>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public void SetWithoutCheck(int blockX, int blockY, int blockZ, Block block)
{ {
blocks[blockX, blockY, blockZ] = value; blocks[(blockY << 8) | (blockZ << 4) | blockX] = block;
}
finally
{
blockLock.ExitWriteLock();
}
}
} }
/// <summary> /// <summary>

29
MinecraftClient/Mapping/ChunkColumn.cs
View file

@ -18,12 +18,7 @@ namespace MinecraftClient.Mapping
/// <summary> /// <summary>
/// Blocks contained into the chunk /// Blocks contained into the chunk
/// </summary> /// </summary>
private readonly Chunk[] chunks; private readonly Chunk?[] chunks;
/// <summary>
/// Lock for thread safety
/// </summary>
private readonly ReaderWriterLockSlim chunkLock = new ReaderWriterLockSlim();
/// <summary> /// <summary>
/// Create a new ChunkColumn /// Create a new ChunkColumn
@ -31,7 +26,7 @@ namespace MinecraftClient.Mapping
public ChunkColumn(int size = 16) public ChunkColumn(int size = 16)
{ {
ColumnSize = size; ColumnSize = size;
chunks = new Chunk[size]; chunks = new Chunk?[size];
} }
/// <summary> /// <summary>
@ -40,32 +35,16 @@ namespace MinecraftClient.Mapping
/// <param name="chunkX">ChunkColumn X</param> /// <param name="chunkX">ChunkColumn X</param>
/// <param name="chunkY">ChunkColumn Y</param> /// <param name="chunkY">ChunkColumn Y</param>
/// <returns>chunk at the given location</returns> /// <returns>chunk at the given location</returns>
public Chunk this[int chunkY] public Chunk? this[int chunkY]
{ {
get get
{
chunkLock.EnterReadLock();
try
{ {
return chunks[chunkY]; return chunks[chunkY];
} }
finally
{
chunkLock.ExitReadLock();
}
}
set set
{
chunkLock.EnterWriteLock();
try
{ {
chunks[chunkY] = value; chunks[chunkY] = value;
} }
finally
{
chunkLock.ExitWriteLock();
}
}
} }
/// <summary> /// <summary>
@ -73,7 +52,7 @@ namespace MinecraftClient.Mapping
/// </summary> /// </summary>
/// <param name="location">Location, a modulo will be applied</param> /// <param name="location">Location, a modulo will be applied</param>
/// <returns>The chunk, or null if not loaded</returns> /// <returns>The chunk, or null if not loaded</returns>
public Chunk GetChunk(Location location) public Chunk? GetChunk(Location location)
{ {
try try
{ {

25
MinecraftClient/Mapping/Location.cs
View file

@ -1,6 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.CompilerServices;
using System.Text; using System.Text;
namespace MinecraftClient.Mapping namespace MinecraftClient.Mapping
@ -54,6 +55,7 @@ namespace MinecraftClient.Mapping
/// <param name="blockX">Location of the block into the chunk</param> /// <param name="blockX">Location of the block into the chunk</param>
/// <param name="blockY">Location of the block into the world</param> /// <param name="blockY">Location of the block into the world</param>
/// <param name="blockZ">Location of the block into the chunk</param> /// <param name="blockZ">Location of the block into the chunk</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Location(int chunkX, int chunkZ, int blockX, int blockY, int blockZ) public Location(int chunkX, int chunkZ, int blockX, int blockY, int blockZ)
{ {
X = chunkX * Chunk.SizeX + blockX; X = chunkX * Chunk.SizeX + blockX;
@ -61,6 +63,29 @@ namespace MinecraftClient.Mapping
Z = chunkZ * Chunk.SizeZ + blockZ; Z = chunkZ * Chunk.SizeZ + blockZ;
} }
/// <summary>
/// Round coordinates
/// </summary>
/// <returns>itself</returns>
public Location ToFloor()
{
this.X = Math.Floor(this.X);
this.Y = Math.Floor(this.Y);
this.Z = Math.Floor(this.Z);
return this;
}
/// <summary>
/// Get the center coordinates
/// </summary>
/// <returns>itself</returns>
public Location ToCenter()
{
this.X = Math.Floor(this.X) + 0.5;
this.Z = Math.Floor(this.Z) + 0.5;
return this;
}
/// <summary> /// <summary>
/// The X index of the corresponding chunk in the world /// The X index of the corresponding chunk in the world
/// </summary> /// </summary>

9
MinecraftClient/Mapping/Movement.cs
View file

@ -134,10 +134,10 @@ namespace MinecraftClient.Mapping
/// <param name="timeout">How long to wait before stopping computation</param> /// <param name="timeout">How long to wait before stopping computation</param>
/// <remarks>When location is unreachable, computation will reach timeout, then optionally fallback to a close location within maxOffset</remarks> /// <remarks>When location is unreachable, computation will reach timeout, then optionally fallback to a close location within maxOffset</remarks>
/// <returns>A list of locations, or null if calculation failed</returns> /// <returns>A list of locations, or null if calculation failed</returns>
public static Queue<Location> CalculatePath(World world, Location start, Location goal, bool allowUnsafe, int maxOffset, int minOffset, TimeSpan timeout) public static Queue<Location>? CalculatePath(World world, Location start, Location goal, bool allowUnsafe, int maxOffset, int minOffset, TimeSpan timeout)
{ {
CancellationTokenSource cts = new CancellationTokenSource(); CancellationTokenSource cts = new CancellationTokenSource();
Task<Queue<Location>> pathfindingTask = Task.Factory.StartNew(() => Movement.CalculatePath(world, start, goal, allowUnsafe, maxOffset, minOffset, cts.Token)); Task<Queue<Location>?> pathfindingTask = Task.Factory.StartNew(() => Movement.CalculatePath(world, start, goal, allowUnsafe, maxOffset, minOffset, cts.Token));
pathfindingTask.Wait(timeout); pathfindingTask.Wait(timeout);
if (!pathfindingTask.IsCompleted) if (!pathfindingTask.IsCompleted)
{ {
@ -161,14 +161,15 @@ namespace MinecraftClient.Mapping
/// <param name="minOffset">Do not get closer of destination than specified distance</param> /// <param name="minOffset">Do not get closer of destination than specified distance</param>
/// <param name="ct">Token for stopping computation after a certain time</param> /// <param name="ct">Token for stopping computation after a certain time</param>
/// <returns>A list of locations, or null if calculation failed</returns> /// <returns>A list of locations, or null if calculation failed</returns>
public static Queue<Location> CalculatePath(World world, Location start, Location goal, bool allowUnsafe, int maxOffset, int minOffset, CancellationToken ct) public static Queue<Location>? CalculatePath(World world, Location start, Location goal, bool allowUnsafe, int maxOffset, int minOffset, CancellationToken ct)
{ {
// This is a bad configuration // This is a bad configuration
if (minOffset > maxOffset) if (minOffset > maxOffset)
throw new ArgumentException("minOffset must be lower or equal to maxOffset", "minOffset"); throw new ArgumentException("minOffset must be lower or equal to maxOffset", "minOffset");
// Round start coordinates for easier calculation // Round start coordinates for easier calculation
start = new Location(Math.Floor(start.X), Math.Floor(start.Y), Math.Floor(start.Z)); start.ToFloor();
goal.ToFloor();
// We always use distance squared so our limits must also be squared. // We always use distance squared so our limits must also be squared.
minOffset *= minOffset; minOffset *= minOffset;

100
MinecraftClient/Mapping/World.cs
View file

@ -1,4 +1,5 @@
using System; using System;
using System.Collections.Concurrent;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
@ -13,8 +14,9 @@ namespace MinecraftClient.Mapping
{ {
/// <summary> /// <summary>
/// The chunks contained into the Minecraft world /// The chunks contained into the Minecraft world
/// Tuple<int, int>: Tuple<chunkX, chunkZ>
/// </summary> /// </summary>
private Dictionary<int, Dictionary<int, ChunkColumn>> chunks = new Dictionary<int, Dictionary<int, ChunkColumn>>(); private ConcurrentDictionary<Tuple<int, int>, ChunkColumn> chunks = new();
/// <summary> /// <summary>
/// The dimension info of the world /// The dimension info of the world
@ -23,11 +25,6 @@ namespace MinecraftClient.Mapping
private static Dictionary<string, Dimension>? dimensionList = null; private static Dictionary<string, Dimension>? dimensionList = null;
/// <summary>
/// Lock for thread safety
/// </summary>
private readonly ReaderWriterLockSlim chunksLock = new ReaderWriterLockSlim();
/// <summary> /// <summary>
/// Chunk data parsing progress /// Chunk data parsing progress
/// </summary> /// </summary>
@ -38,56 +35,22 @@ namespace MinecraftClient.Mapping
/// Read, set or unload the specified chunk column /// Read, set or unload the specified chunk column
/// </summary> /// </summary>
/// <param name="chunkX">ChunkColumn X</param> /// <param name="chunkX">ChunkColumn X</param>
/// <param name="chunkY">ChunkColumn Y</param> /// <param name="chunkZ">ChunkColumn Z</param>
/// <returns>chunk at the given location</returns> /// <returns>chunk at the given location</returns>
public ChunkColumn this[int chunkX, int chunkZ] public ChunkColumn? this[int chunkX, int chunkZ]
{ {
get get
{ {
chunksLock.EnterReadLock(); chunks.TryGetValue(new(chunkX, chunkZ), out ChunkColumn? chunkColumn);
try return chunkColumn;
{
//Read a chunk
if (chunks.ContainsKey(chunkX))
if (chunks[chunkX].ContainsKey(chunkZ))
return chunks[chunkX][chunkZ];
return null;
}
finally
{
chunksLock.ExitReadLock();
}
} }
set set
{ {
chunksLock.EnterWriteLock(); Tuple<int, int> chunkCoord = new(chunkX, chunkZ);
try if (value == null)
{ chunks.TryRemove(chunkCoord, out _);
if (value != null)
{
//Update a chunk column
if (!chunks.ContainsKey(chunkX))
chunks[chunkX] = new Dictionary<int, ChunkColumn>();
chunks[chunkX][chunkZ] = value;
}
else else
{ chunks.AddOrUpdate(chunkCoord, value, (_, _) => value);
//Unload a chunk column
if (chunks.ContainsKey(chunkX))
{
if (chunks[chunkX].ContainsKey(chunkZ))
{
chunks[chunkX].Remove(chunkZ);
if (chunks[chunkX].Count == 0)
chunks.Remove(chunkX);
}
}
}
}
finally
{
chunksLock.ExitWriteLock();
}
} }
} }
@ -129,12 +92,29 @@ namespace MinecraftClient.Mapping
return curDimension; return curDimension;
} }
/// <summary>
/// Set chunk column at the specified location
/// </summary>
/// <param name="chunkX">ChunkColumn X</param>
/// <param name="chunkY">ChunkColumn Y</param>
/// <param name="chunkZ">ChunkColumn Z</param>
/// <param name="chunkColumnSize">ChunkColumn size</param>
/// <param name="chunk">Chunk data</param>
/// <param name="loadCompleted">Whether the ChunkColumn has been fully loaded</param>
public void StoreChunk(int chunkX, int chunkY, int chunkZ, int chunkColumnSize, Chunk? chunk, bool loadCompleted)
{
ChunkColumn chunkColumn = chunks.GetOrAdd(new(chunkX, chunkZ), (_) => new(chunkColumnSize));
chunkColumn[chunkY] = chunk;
if (loadCompleted)
chunkColumn.FullyLoaded = true;
}
/// <summary> /// <summary>
/// Get chunk column at the specified location /// Get chunk column at the specified location
/// </summary> /// </summary>
/// <param name="location">Location to retrieve chunk column</param> /// <param name="location">Location to retrieve chunk column</param>
/// <returns>The chunk column</returns> /// <returns>The chunk column</returns>
public ChunkColumn GetChunkColumn(Location location) public ChunkColumn? GetChunkColumn(Location location)
{ {
return this[location.ChunkX, location.ChunkZ]; return this[location.ChunkX, location.ChunkZ];
} }
@ -146,10 +126,10 @@ namespace MinecraftClient.Mapping
/// <returns>Block at specified location or Air if the location is not loaded</returns> /// <returns>Block at specified location or Air if the location is not loaded</returns>
public Block GetBlock(Location location) public Block GetBlock(Location location)
{ {
ChunkColumn column = GetChunkColumn(location); ChunkColumn? column = GetChunkColumn(location);
if (column != null) if (column != null)
{ {
Chunk chunk = column.GetChunk(location); Chunk? chunk = column.GetChunk(location);
if (chunk != null) if (chunk != null)
return chunk.GetBlock(location); return chunk.GetBlock(location);
} }
@ -208,10 +188,10 @@ namespace MinecraftClient.Mapping
/// <param name="block">Block to set</param> /// <param name="block">Block to set</param>
public void SetBlock(Location location, Block block) public void SetBlock(Location location, Block block)
{ {
ChunkColumn column = this[location.ChunkX, location.ChunkZ]; ChunkColumn? column = this[location.ChunkX, location.ChunkZ];
if (column != null) if (column != null && column.ColumnSize >= location.ChunkY)
{ {
Chunk chunk = column[location.ChunkY]; Chunk? chunk = column.GetChunk(location);
if (chunk == null) if (chunk == null)
column[location.ChunkY] = chunk = new Chunk(); column[location.ChunkY] = chunk = new Chunk();
chunk[location.ChunkBlockX, location.ChunkBlockY, location.ChunkBlockZ] = block; chunk[location.ChunkBlockX, location.ChunkBlockY, location.ChunkBlockZ] = block;
@ -223,15 +203,9 @@ namespace MinecraftClient.Mapping
/// </summary> /// </summary>
public void Clear() public void Clear()
{ {
chunksLock.EnterWriteLock(); chunks = new();
try chunkCnt = 0;
{ chunkLoadNotCompleted = 0;
chunks = new Dictionary<int, Dictionary<int, ChunkColumn>>();
}
finally
{
chunksLock.ExitWriteLock();
}
} }
/// <summary> /// <summary>

131
MinecraftClient/McClient.cs
View file

@ -14,6 +14,7 @@ using MinecraftClient.Mapping;
using MinecraftClient.Inventory; using MinecraftClient.Inventory;
using MinecraftClient.Logger; using MinecraftClient.Logger;
using MinecraftClient.Protocol.Keys; using MinecraftClient.Protocol.Keys;
using MinecraftClient.Protocol.Session;
using MinecraftClient.Protocol.Message; using MinecraftClient.Protocol.Message;
namespace MinecraftClient namespace MinecraftClient
@ -54,7 +55,7 @@ namespace MinecraftClient
private bool locationReceived = false; private bool locationReceived = false;
private World world = new(); private World world = new();
private Queue<Location> steps; private Queue<Location> steps;
private Queue<Location> path; private Queue<Location>? path;
private Location location; private Location location;
private float? _yaw; // Used for calculation ONLY!!! Doesn't reflect the client yaw private float? _yaw; // Used for calculation ONLY!!! Doesn't reflect the client yaw
private float? _pitch; // Used for calculation ONLY!!! Doesn't reflect the client pitch private float? _pitch; // Used for calculation ONLY!!! Doesn't reflect the client pitch
@ -114,7 +115,7 @@ namespace MinecraftClient
public int GetSequenceId() { return sequenceId; } public int GetSequenceId() { return sequenceId; }
public float GetPitch() { return playerPitch; } public float GetPitch() { return playerPitch; }
public World GetWorld() { return world; } public World GetWorld() { return world; }
public Double GetServerTPS() { return averageTPS; } public double GetServerTPS() { return averageTPS; }
public bool GetIsSupportPreviewsChat() { return isSupportPreviewsChat; } public bool GetIsSupportPreviewsChat() { return isSupportPreviewsChat; }
public float GetHealth() { return playerHealth; } public float GetHealth() { return playerHealth; }
public int GetSaturation() { return playerFoodSaturation; } public int GetSaturation() { return playerFoodSaturation; }
@ -135,58 +136,28 @@ namespace MinecraftClient
public ILogger Log; public ILogger Log;
/// <summary>
/// Starts the main chat client
/// </summary>
/// <param name="username">The chosen username of a premium Minecraft Account</param>
/// <param name="uuid">The player's UUID for online-mode authentication</param>
/// <param name="sessionID">A valid sessionID obtained after logging in</param>
/// <param name="server_ip">The server IP</param>
/// <param name="port">The server port to use</param>
/// <param name="protocolversion">Minecraft protocol version to use</param>
public McClient(string username, string uuid, string sessionID, PlayerKeyPair? playerKeyPair, int protocolversion, ForgeInfo forgeInfo, string server_ip, ushort port)
{
StartClient(username, uuid, sessionID, playerKeyPair, server_ip, port, protocolversion, forgeInfo, false, "");
}
/// <summary>
/// Starts the main chat client in single command sending mode
/// </summary>
/// <param name="username">The chosen username of a premium Minecraft Account</param>
/// <param name="uuid">The player's UUID for online-mode authentication</param>
/// <param name="sessionID">A valid sessionID obtained after logging in</param>
/// <param name="server_ip">The server IP</param>
/// <param name="port">The server port to use</param>
/// <param name="protocolversion">Minecraft protocol version to use</param>
/// <param name="command">The text or command to send.</param>
public McClient(string username, string uuid, string sessionID, PlayerKeyPair? playerKeyPair, string server_ip, ushort port, int protocolversion, ForgeInfo forgeInfo, string command)
{
StartClient(username, uuid, sessionID, playerKeyPair, server_ip, port, protocolversion, forgeInfo, true, command);
}
/// <summary> /// <summary>
/// Starts the main chat client, wich will login to the server using the MinecraftCom class. /// Starts the main chat client, wich will login to the server using the MinecraftCom class.
/// </summary> /// </summary>
/// <param name="user">The chosen username of a premium Minecraft Account</param> /// <param name="session">A valid session obtained with MinecraftCom.GetLogin()</param>
/// <param name="sessionID">A valid sessionID obtained with MinecraftCom.GetLogin()</param> /// <param name="playerKeyPair">Key for message signing</param>
/// <param name="server_ip">The server IP</param> /// <param name="server_ip">The server IP</param>
/// <param name="port">The server port to use</param> /// <param name="port">The server port to use</param>
/// <param name="protocolversion">Minecraft protocol version to use</param> /// <param name="protocolversion">Minecraft protocol version to use</param>
/// <param name="uuid">The player's UUID for online-mode authentication</param> /// <param name="forgeInfo">ForgeInfo item stating that Forge is enabled</param>
/// <param name="singlecommand">If set to true, the client will send a single command and then disconnect from the server</param>
/// <param name="command">The text or command to send. Will only be sent if singlecommand is set to true.</param> /// <param name="command">The text or command to send. Will only be sent if singlecommand is set to true.</param>
private void StartClient(string user, string uuid, string sessionID, PlayerKeyPair? playerKeyPair, string server_ip, ushort port, int protocolversion, ForgeInfo forgeInfo, bool singlecommand, string command) public McClient(SessionToken session, PlayerKeyPair? playerKeyPair, string server_ip, ushort port, int protocolversion, ForgeInfo? forgeInfo, string? command)
{ {
terrainAndMovementsEnabled = Settings.TerrainAndMovements; terrainAndMovementsEnabled = Settings.TerrainAndMovements;
inventoryHandlingEnabled = Settings.InventoryHandling; inventoryHandlingEnabled = Settings.InventoryHandling;
entityHandlingEnabled = Settings.EntityHandling; entityHandlingEnabled = Settings.EntityHandling;
bool retry = false; bool retry = false;
this.sessionid = sessionID; this.sessionid = session.ID;
if (!Guid.TryParse(uuid, out this.uuid)) if (!Guid.TryParse(session.PlayerID, out this.uuid))
this.uuid = Guid.Empty; this.uuid = Guid.Empty;
this.uuidStr = uuid; this.uuidStr = session.PlayerID;
this.username = user; this.username = session.PlayerName;
this.host = server_ip; this.host = server_ip;
this.port = port; this.port = port;
this.protocolversion = protocolversion; this.protocolversion = protocolversion;
@ -201,7 +172,7 @@ namespace MinecraftClient
Log.WarnEnabled = Settings.WarningMessages; Log.WarnEnabled = Settings.WarningMessages;
Log.ErrorEnabled = Settings.ErrorMessages; Log.ErrorEnabled = Settings.ErrorMessages;
if (!singlecommand) if (command == null)
{ {
/* Load commands from Commands namespace */ /* Load commands from Commands namespace */
LoadCommands(); LoadCommands();
@ -238,7 +209,7 @@ namespace MinecraftClient
handler = Protocol.ProtocolHandler.GetProtocolHandler(client, protocolversion, forgeInfo, this); handler = Protocol.ProtocolHandler.GetProtocolHandler(client, protocolversion, forgeInfo, this);
Log.Info(Translations.Get("mcc.version_supported")); Log.Info(Translations.Get("mcc.version_supported"));
if (!singlecommand) if (command == null)
{ {
timeoutdetector = new(new Thread(new ParameterizedThreadStart(TimeoutDetector)), new CancellationTokenSource()); timeoutdetector = new(new Thread(new ParameterizedThreadStart(TimeoutDetector)), new CancellationTokenSource());
timeoutdetector.Item1.Name = "MCC Connection timeout detector"; timeoutdetector.Item1.Name = "MCC Connection timeout detector";
@ -247,9 +218,9 @@ namespace MinecraftClient
try try
{ {
if (handler.Login(this.playerKeyPair)) if (handler.Login(this.playerKeyPair, session))
{ {
if (singlecommand) if (command != null)
{ {
handler.SendChatMessage(command, playerKeyPair); handler.SendChatMessage(command, playerKeyPair);
Log.Info(Translations.Get("mcc.single_cmd", command)); Log.Info(Translations.Get("mcc.single_cmd", command));
@ -305,7 +276,7 @@ namespace MinecraftClient
ReconnectionAttemptsLeft--; ReconnectionAttemptsLeft--;
Program.Restart(); Program.Restart();
} }
else if (!singlecommand && Settings.interactiveMode) else if (command == null && Settings.interactiveMode)
{ {
ConsoleInteractive.ConsoleReader.StopReadThread(); ConsoleInteractive.ConsoleReader.StopReadThread();
ConsoleInteractive.ConsoleReader.MessageReceived -= ConsoleReaderOnMessageReceived; ConsoleInteractive.ConsoleReader.MessageReceived -= ConsoleReaderOnMessageReceived;
@ -315,6 +286,20 @@ namespace MinecraftClient
} }
} }
/// <summary>
/// Retrieve messages from the queue and send.
/// Note: requires external locking.
/// </summary>
private void TrySendMessageToServer()
{
while (chatQueue.Count > 0 && nextMessageSendTime < DateTime.Now)
{
string text = chatQueue.Dequeue();
handler.SendChatMessage(text, playerKeyPair);
nextMessageSendTime = DateTime.Now + Settings.messageCooldown;
}
}
/// <summary> /// <summary>
/// Called ~10 times per second by the protocol handler /// Called ~10 times per second by the protocol handler
/// </summary> /// </summary>
@ -329,22 +314,16 @@ namespace MinecraftClient
} }
catch (Exception e) catch (Exception e)
{ {
if (!(e is ThreadAbortException)) if (e is not ThreadAbortException)
{
Log.Warn("Update: Got error from " + bot.ToString() + ": " + e.ToString()); Log.Warn("Update: Got error from " + bot.ToString() + ": " + e.ToString());
} else
else throw; //ThreadAbortException should not be caught throw; //ThreadAbortException should not be caught
} }
} }
lock (chatQueue) lock (chatQueue)
{ {
if (chatQueue.Count > 0 && nextMessageSendTime < DateTime.Now) TrySendMessageToServer();
{
string text = chatQueue.Dequeue();
handler.SendChatMessage(text, playerKeyPair);
nextMessageSendTime = DateTime.Now + Settings.messageCooldown;
}
} }
if (terrainAndMovementsEnabled && locationReceived) if (terrainAndMovementsEnabled && locationReceived)
@ -480,6 +459,8 @@ namespace MinecraftClient
/// </summary> /// </summary>
public void OnConnectionLost(ChatBot.DisconnectReason reason, string message) public void OnConnectionLost(ChatBot.DisconnectReason reason, string message)
{ {
handler.Dispose();
world.Clear(); world.Clear();
if (timeoutdetector != null) if (timeoutdetector != null)
@ -571,7 +552,7 @@ namespace MinecraftClient
if (ConsoleIO.BasicIO && text.Length > 0 && text[0] == (char)0x00) if (ConsoleIO.BasicIO && text.Length > 0 && text[0] == (char)0x00)
{ {
//Process a request from the GUI //Process a request from the GUI
string[] command = text.Substring(1).Split((char)0x00); string[] command = text[1..].Split((char)0x00);
switch (command[0].ToLower()) switch (command[0].ToLower())
{ {
case "autocomplete": case "autocomplete":
@ -716,10 +697,10 @@ namespace MinecraftClient
try try
{ {
Command cmd = (Command)Activator.CreateInstance(type); Command cmd = (Command)Activator.CreateInstance(type);
cmds[cmd.CmdName.ToLower()] = cmd; cmds[Settings.ToLowerIfNeed(cmd.CmdName)] = cmd;
cmd_names.Add(cmd.CmdName.ToLower()); cmd_names.Add(Settings.ToLowerIfNeed(cmd.CmdName));
foreach (string alias in cmd.getCMDAliases()) foreach (string alias in cmd.getCMDAliases())
cmds[alias.ToLower()] = cmd; cmds[Settings.ToLowerIfNeed(alias)] = cmd;
} }
catch (Exception e) catch (Exception e)
{ {
@ -773,6 +754,17 @@ namespace MinecraftClient
InvokeOnMainThread(() => { task(); return true; }); InvokeOnMainThread(() => { task(); return true; });
} }
/// <summary>
/// Clear all tasks
/// </summary>
public void ClearTasks()
{
lock (threadTasksLock)
{
threadTasks.Clear();
}
}
/// <summary> /// <summary>
/// Check if running on a different thread and InvokeOnMainThread is required /// Check if running on a different thread and InvokeOnMainThread is required
/// </summary> /// </summary>
@ -784,7 +776,7 @@ namespace MinecraftClient
int callingThreadId = Thread.CurrentThread.ManagedThreadId; int callingThreadId = Thread.CurrentThread.ManagedThreadId;
if (handler != null) if (handler != null)
{ {
return handler.GetNetReadThreadId() != callingThreadId; return handler.GetNetMainThreadId() != callingThreadId;
} }
else else
{ {
@ -1143,18 +1135,20 @@ namespace MinecraftClient
/// </summary> /// </summary>
/// <param name="text">Text to send to the server</param> /// <param name="text">Text to send to the server</param>
public void SendText(string text) public void SendText(string text)
{
lock (chatQueue)
{ {
if (String.IsNullOrEmpty(text)) if (String.IsNullOrEmpty(text))
return; return;
int maxLength = handler.GetMaxChatMessageLength(); int maxLength = handler.GetMaxChatMessageLength();
lock (chatQueue)
{
if (text.Length > maxLength) //Message is too long? if (text.Length > maxLength) //Message is too long?
{ {
if (text[0] == '/') if (text[0] == '/')
{ {
//Send the first 100/256 chars of the command //Send the first 100/256 chars of the command
text = text.Substring(0, maxLength); text = text[..maxLength];
chatQueue.Enqueue(text); chatQueue.Enqueue(text);
} }
else else
@ -1162,13 +1156,16 @@ namespace MinecraftClient
//Split the message into several messages //Split the message into several messages
while (text.Length > maxLength) while (text.Length > maxLength)
{ {
chatQueue.Enqueue(text.Substring(0, maxLength)); chatQueue.Enqueue(text[..maxLength]);
text = text.Substring(maxLength, text.Length - maxLength); text = text[maxLength..];
} }
chatQueue.Enqueue(text); chatQueue.Enqueue(text);
} }
} }
else chatQueue.Enqueue(text); else
chatQueue.Enqueue(text);
TrySendMessageToServer();
} }
} }
@ -1927,6 +1924,8 @@ namespace MinecraftClient
/// </summary> /// </summary>
public void OnRespawn() public void OnRespawn()
{ {
ClearTasks();
if (terrainAndMovementsRequested) if (terrainAndMovementsRequested)
{ {
terrainAndMovementsEnabled = true; terrainAndMovementsEnabled = true;

1
MinecraftClient/MinecraftClient.csproj
View file

@ -36,6 +36,7 @@
</PackageReference> </PackageReference>
<PackageReference Include="Microsoft.Windows.Compatibility" Version="5.0.2" /> <PackageReference Include="Microsoft.Windows.Compatibility" Version="5.0.2" />
<PackageReference Include="SingleFileExtractor.Core" Version="1.0.1" /> <PackageReference Include="SingleFileExtractor.Core" Version="1.0.1" />
<PackageReference Include="System.Text.Encoding.CodePages" Version="6.0.0" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<Compile Remove="config\ChatBots\AutoLook.cs" /> <Compile Remove="config\ChatBots\AutoLook.cs" />

80
MinecraftClient/Program.cs
View file

@ -16,6 +16,7 @@ using MinecraftClient.WinAPI;
using MinecraftClient.Protocol.Keys; using MinecraftClient.Protocol.Keys;
using System.Security.Cryptography; using System.Security.Cryptography;
using System.Xml.Linq; using System.Xml.Linq;
using System.Threading.Tasks;
namespace MinecraftClient namespace MinecraftClient
{ {
@ -51,6 +52,28 @@ namespace MinecraftClient
/// </summary> /// </summary>
static void Main(string[] args) static void Main(string[] args)
{ {
new Thread(() =>
{
//Take advantage of Windows 10 / Mac / Linux UTF-8 console
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// If we're on windows, check if our version is Win10 or greater.
if (WindowsVersion.WinMajorVersion >= 10)
Console.OutputEncoding = Console.InputEncoding = Encoding.UTF8;
}
else
{
// Apply to all other operating systems.
Console.OutputEncoding = Console.InputEncoding = Encoding.UTF8;
}
// Fix issue #2119
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
// "ToLower" require "CultureInfo" to be initialized on first run, which can take a lot of time.
_ = "a".ToLower();
}).Start();
//Setup ConsoleIO //Setup ConsoleIO
ConsoleIO.LogPrefix = "§8[MCC] "; ConsoleIO.LogPrefix = "§8[MCC] ";
if (args.Length >= 1 && args[args.Length - 1] == "BasicIO" || args.Length >= 1 && args[args.Length - 1] == "BasicIO-NoColor") if (args.Length >= 1 && args[args.Length - 1] == "BasicIO" || args.Length >= 1 && args[args.Length - 1] == "BasicIO-NoColor")
@ -81,21 +104,8 @@ namespace MinecraftClient
ConsoleIO.DebugReadInput(); ConsoleIO.DebugReadInput();
} }
//Take advantage of Windows 10 / Mac / Linux UTF-8 console
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// If we're on windows, check if our version is Win10 or greater.
if (WindowsVersion.WinMajorVersion >= 10)
Console.OutputEncoding = Console.InputEncoding = Encoding.UTF8;
}
else
{
// Apply to all other operating systems.
Console.OutputEncoding = Console.InputEncoding = Encoding.UTF8;
}
//Process ini configuration file //Process ini configuration file
if (args.Length >= 1 && System.IO.File.Exists(args[0]) && System.IO.Path.GetExtension(args[0]).ToLower() == ".ini") if (args.Length >= 1 && System.IO.File.Exists(args[0]) && Settings.ToLowerIfNeed(Path.GetExtension(args[0])) == ".ini")
{ {
Settings.LoadFile(args[0]); Settings.LoadFile(args[0]);
@ -156,7 +166,7 @@ namespace MinecraftClient
} }
} }
if (string.IsNullOrEmpty(dataGenerator) || !(dataGenerator.ToLower().Equals("entity") || dataGenerator.ToLower().Equals("item") || dataGenerator.ToLower().Equals("block"))) if (string.IsNullOrEmpty(dataGenerator) || !(Settings.ToLowerIfNeed(dataGenerator).Equals("entity") || Settings.ToLowerIfNeed(dataGenerator).Equals("item") || Settings.ToLowerIfNeed(dataGenerator).Equals("block")))
{ {
Console.WriteLine(Translations.Get("error.generator.invalid")); Console.WriteLine(Translations.Get("error.generator.invalid"));
Console.WriteLine(Translations.Get("error.usage") + " MinecraftClient.exe --data-generator=<entity|item|block> --data-path=\"<path to resources.json>\""); Console.WriteLine(Translations.Get("error.usage") + " MinecraftClient.exe --data-generator=<entity|item|block> --data-path=\"<path to resources.json>\"");
@ -243,7 +253,7 @@ namespace MinecraftClient
Settings.Login = ConsoleIO.ReadLine(); Settings.Login = ConsoleIO.ReadLine();
} }
if (Settings.Password == "" if (Settings.Password == ""
&& (Settings.SessionCaching == CacheType.None || !SessionCache.Contains(Settings.Login.ToLower())) && (Settings.SessionCaching == CacheType.None || !SessionCache.Contains(Settings.ToLowerIfNeed(Settings.Login)))
&& !useBrowser) && !useBrowser)
{ {
RequestPassword(); RequestPassword();
@ -284,6 +294,7 @@ namespace MinecraftClient
ProtocolHandler.LoginResult result = ProtocolHandler.LoginResult.LoginRequired; ProtocolHandler.LoginResult result = ProtocolHandler.LoginResult.LoginRequired;
string loginLower = Settings.ToLowerIfNeed(Settings.Login);
if (Settings.Password == "-") if (Settings.Password == "-")
{ {
Translations.WriteLineFormatted("mcc.offline"); Translations.WriteLineFormatted("mcc.offline");
@ -294,18 +305,27 @@ namespace MinecraftClient
else else
{ {
// Validate cached session or login new session. // Validate cached session or login new session.
if (Settings.SessionCaching != CacheType.None && SessionCache.Contains(Settings.Login.ToLower())) if (Settings.SessionCaching != CacheType.None && SessionCache.Contains(loginLower))
{ {
session = SessionCache.Get(Settings.Login.ToLower()); session = SessionCache.Get(loginLower);
result = ProtocolHandler.GetTokenValidation(session); result = ProtocolHandler.GetTokenValidation(session);
if (result != ProtocolHandler.LoginResult.Success) if (result != ProtocolHandler.LoginResult.Success)
{ {
Translations.WriteLineFormatted("mcc.session_invalid"); Translations.WriteLineFormatted("mcc.session_invalid");
// Try to refresh access token // Try to refresh access token
if (!string.IsNullOrWhiteSpace(session.RefreshToken)) if (!string.IsNullOrWhiteSpace(session.RefreshToken))
{
try
{ {
result = ProtocolHandler.MicrosoftLoginRefresh(session.RefreshToken, out session); result = ProtocolHandler.MicrosoftLoginRefresh(session.RefreshToken, out session);
} }
catch (Exception ex)
{
ConsoleIO.WriteLine("Refresh access token fail: " + ex.Message);
result = ProtocolHandler.LoginResult.InvalidResponse;
}
}
if (result != ProtocolHandler.LoginResult.Success if (result != ProtocolHandler.LoginResult.Success
&& Settings.Password == "" && Settings.Password == ""
&& Settings.AccountType == ProtocolHandler.AccountType.Mojang) && Settings.AccountType == ProtocolHandler.AccountType.Mojang)
@ -322,9 +342,10 @@ namespace MinecraftClient
} }
if (result == ProtocolHandler.LoginResult.Success && Settings.SessionCaching != CacheType.None) if (result == ProtocolHandler.LoginResult.Success && Settings.SessionCaching != CacheType.None)
{ SessionCache.Store(loginLower, session);
SessionCache.Store(Settings.Login.ToLower(), session);
} if (result == ProtocolHandler.LoginResult.Success)
session.SessionPreCheckTask = Task.Factory.StartNew(() => session.SessionPreCheck());
if (result == ProtocolHandler.LoginResult.Success) if (result == ProtocolHandler.LoginResult.Success)
{ {
@ -338,9 +359,9 @@ namespace MinecraftClient
Translations.WriteLineFormatted(cacheKeyLoaded ? "debug.keys_cache_ok" : "debug.keys_cache_fail"); Translations.WriteLineFormatted(cacheKeyLoaded ? "debug.keys_cache_ok" : "debug.keys_cache_fail");
} }
if (Settings.ProfileKeyCaching != CacheType.None && KeysCache.Contains(Settings.Login.ToLower())) if (Settings.ProfileKeyCaching != CacheType.None && KeysCache.Contains(loginLower))
{ {
playerKeyPair = KeysCache.Get(Settings.Login.ToLower()); playerKeyPair = KeysCache.Get(loginLower);
if (playerKeyPair.NeedRefresh()) if (playerKeyPair.NeedRefresh())
Translations.WriteLineFormatted("mcc.profile_key_invalid"); Translations.WriteLineFormatted("mcc.profile_key_invalid");
else else
@ -350,10 +371,10 @@ namespace MinecraftClient
if (playerKeyPair == null || playerKeyPair.NeedRefresh()) if (playerKeyPair == null || playerKeyPair.NeedRefresh())
{ {
Translations.WriteLineFormatted("mcc.fetching_key"); Translations.WriteLineFormatted("mcc.fetching_key");
playerKeyPair = KeyUtils.GetKeys(session.ID); playerKeyPair = KeyUtils.GetNewProfileKeys(session.ID);
if (Settings.ProfileKeyCaching != CacheType.None && playerKeyPair != null) if (Settings.ProfileKeyCaching != CacheType.None && playerKeyPair != null)
{ {
KeysCache.Store(Settings.Login.ToLower(), playerKeyPair); KeysCache.Store(loginLower, playerKeyPair);
} }
} }
} }
@ -425,7 +446,7 @@ namespace MinecraftClient
int protocolversion = 0; int protocolversion = 0;
ForgeInfo? forgeInfo = null; ForgeInfo? forgeInfo = null;
if (Settings.ServerVersion != "" && Settings.ServerVersion.ToLower() != "auto") if (Settings.ServerVersion != "" && Settings.ToLowerIfNeed(Settings.ServerVersion) != "auto")
{ {
protocolversion = Protocol.ProtocolHandler.MCVer2ProtocolVersion(Settings.ServerVersion); protocolversion = Protocol.ProtocolHandler.MCVer2ProtocolVersion(Settings.ServerVersion);
@ -476,11 +497,8 @@ namespace MinecraftClient
try try
{ {
//Start the main TCP client //Start the main TCP client
if (Settings.SingleCommand != "") string? command = String.IsNullOrEmpty(Settings.SingleCommand) ? null : Settings.SingleCommand;
{ client = new McClient(session, playerKeyPair, Settings.ServerIP, Settings.ServerPort, protocolversion, forgeInfo, command);
client = new McClient(session.PlayerName, session.PlayerID, session.ID, playerKeyPair, Settings.ServerIP, Settings.ServerPort, protocolversion, forgeInfo, Settings.SingleCommand);
}
else client = new McClient(session.PlayerName, session.PlayerID, session.ID, playerKeyPair, protocolversion, forgeInfo, Settings.ServerIP, Settings.ServerPort);
//Update console title //Update console title
if (Settings.ConsoleTitle != "") if (Settings.ConsoleTitle != "")

6
MinecraftClient/Protocol/Handlers/Compression/Inflate.cs
View file

@ -63,6 +63,8 @@
using System; using System;
using System.Runtime.CompilerServices;
namespace Ionic.Zlib namespace Ionic.Zlib
{ {
sealed class InflateBlocks sealed class InflateBlocks
@ -139,7 +141,6 @@ namespace Ionic.Zlib
return oldCheck; return oldCheck;
} }
internal int Process(int r) internal int Process(int r)
{ {
int t; // temporary storage int t; // temporary storage
@ -799,6 +800,7 @@ namespace Ionic.Zlib
tree = null; tree = null;
} }
internal int Process(InflateBlocks blocks, int r) internal int Process(InflateBlocks blocks, int r)
{ {
int j; // temporary storage int j; // temporary storage
@ -1160,7 +1162,7 @@ namespace Ionic.Zlib
// (the maximum string length) and number of input bytes available // (the maximum string length) and number of input bytes available
// at least ten. The ten bytes are six bytes for the longest length/ // at least ten. The ten bytes are six bytes for the longest length/
// distance pair plus four bytes for overloading the bit buffer. // distance pair plus four bytes for overloading the bit buffer.
[MethodImpl(MethodImplOptions.AggressiveOptimization)]
internal int InflateFast(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index, InflateBlocks s, ZlibCodec z) internal int InflateFast(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index, InflateBlocks s, ZlibCodec z)
{ {
int t; // temporary pointer int t; // temporary pointer

2
MinecraftClient/Protocol/Handlers/Compression/Zlib.cs
View file

@ -89,6 +89,7 @@
using System; using System;
using System.Runtime.CompilerServices;
using Interop=System.Runtime.InteropServices; using Interop=System.Runtime.InteropServices;
namespace Ionic.Zlib namespace Ionic.Zlib
@ -491,6 +492,7 @@ namespace Ionic.Zlib
/// adler = Adler.Adler32(adler, buffer, index, length); /// adler = Adler.Adler32(adler, buffer, index, length);
/// </code> /// </code>
/// </example> /// </example>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public static uint Adler32(uint adler, byte[] buf, int index, int len) public static uint Adler32(uint adler, byte[] buf, int index, int len)
{ {
if (buf == null) if (buf == null)

2
MinecraftClient/Protocol/Handlers/Compression/ZlibBaseStream.cs
View file

@ -26,6 +26,7 @@
using System; using System;
using System.IO; using System.IO;
using System.Runtime.CompilerServices;
namespace Ionic.Zlib namespace Ionic.Zlib
{ {
@ -413,7 +414,6 @@ namespace Ionic.Zlib
} }
public override System.Int32 Read(System.Byte[] buffer, System.Int32 offset, System.Int32 count) public override System.Int32 Read(System.Byte[] buffer, System.Int32 offset, System.Int32 count)
{ {
// According to MS documentation, any implementation of the IO.Stream.Read function must: // According to MS documentation, any implementation of the IO.Stream.Read function must:

1
MinecraftClient/Protocol/Handlers/Compression/ZlibCodec.cs
View file

@ -65,6 +65,7 @@
using System; using System;
using System.Runtime.CompilerServices;
using Interop=System.Runtime.InteropServices; using Interop=System.Runtime.InteropServices;
namespace Ionic.Zlib namespace Ionic.Zlib

1
MinecraftClient/Protocol/Handlers/Compression/ZlibStream.cs
View file

@ -27,6 +27,7 @@
using System; using System;
using System.IO; using System.IO;
using System.Runtime.CompilerServices;
namespace Ionic.Zlib namespace Ionic.Zlib
{ {

140
MinecraftClient/Protocol/Handlers/DataTypes.cs
View file

@ -8,6 +8,7 @@ using MinecraftClient.Crypto;
using MinecraftClient.Inventory; using MinecraftClient.Inventory;
using MinecraftClient.Mapping.EntityPalettes; using MinecraftClient.Mapping.EntityPalettes;
using MinecraftClient.Inventory.ItemPalettes; using MinecraftClient.Inventory.ItemPalettes;
using System.Runtime.CompilerServices;
namespace MinecraftClient.Protocol.Handlers namespace MinecraftClient.Protocol.Handlers
{ {
@ -36,6 +37,7 @@ namespace MinecraftClient.Protocol.Handlers
/// <param name="offset">Amount of bytes to read</param> /// <param name="offset">Amount of bytes to read</param>
/// <param name="cache">Cache of bytes to read from</param> /// <param name="cache">Cache of bytes to read from</param>
/// <returns>The data read from the cache as an array</returns> /// <returns>The data read from the cache as an array</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public byte[] ReadData(int offset, Queue<byte> cache) public byte[] ReadData(int offset, Queue<byte> cache)
{ {
byte[] result = new byte[offset]; byte[] result = new byte[offset];
@ -44,11 +46,36 @@ namespace MinecraftClient.Protocol.Handlers
return result; return result;
} }
/// <summary>
/// Read some data from a cache of bytes and remove it from the cache
/// </summary>
/// <param name="cache">Cache of bytes to read from</param>
/// <param name="dest">Storage results</param>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public void ReadDataReverse(Queue<byte> cache, Span<byte> dest)
{
for (int i = (dest.Length - 1); i >= 0; --i)
dest[i] = cache.Dequeue();
}
/// <summary>
/// Remove some data from the cache
/// </summary>
/// <param name="offset">Amount of bytes to drop</param>
/// <param name="cache">Cache of bytes to drop</param>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public void DropData(int offset, Queue<byte> cache)
{
while (offset-- > 0)
cache.Dequeue();
}
/// <summary> /// <summary>
/// Read a string from a cache of bytes and remove it from the cache /// Read a string from a cache of bytes and remove it from the cache
/// </summary> /// </summary>
/// <param name="cache">Cache of bytes to read from</param> /// <param name="cache">Cache of bytes to read from</param>
/// <returns>The string</returns> /// <returns>The string</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public string ReadNextString(Queue<byte> cache) public string ReadNextString(Queue<byte> cache)
{ {
int length = ReadNextVarInt(cache); int length = ReadNextVarInt(cache);
@ -59,10 +86,21 @@ namespace MinecraftClient.Protocol.Handlers
else return ""; else return "";
} }
/// <summary>
/// Skip a string from a cache of bytes and remove it from the cache
/// </summary>
/// <param name="cache">Cache of bytes to read from</param>
public void SkipNextString(Queue<byte> cache)
{
int length = ReadNextVarInt(cache);
DropData(length, cache);
}
/// <summary> /// <summary>
/// Read a boolean from a cache of bytes and remove it from the cache /// Read a boolean from a cache of bytes and remove it from the cache
/// </summary> /// </summary>
/// <returns>The boolean value</returns> /// <returns>The boolean value</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public bool ReadNextBool(Queue<byte> cache) public bool ReadNextBool(Queue<byte> cache)
{ {
return ReadNextByte(cache) != 0x00; return ReadNextByte(cache) != 0x00;
@ -72,55 +110,65 @@ namespace MinecraftClient.Protocol.Handlers
/// Read a short integer from a cache of bytes and remove it from the cache /// Read a short integer from a cache of bytes and remove it from the cache
/// </summary> /// </summary>
/// <returns>The short integer value</returns> /// <returns>The short integer value</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public short ReadNextShort(Queue<byte> cache) public short ReadNextShort(Queue<byte> cache)
{ {
byte[] rawValue = ReadData(2, cache); Span<byte> rawValue = stackalloc byte[2];
Array.Reverse(rawValue); //Endianness for (int i = (2 - 1); i >= 0; --i) //Endianness
return BitConverter.ToInt16(rawValue, 0); rawValue[i] = cache.Dequeue();
return BitConverter.ToInt16(rawValue);
} }
/// <summary> /// <summary>
/// Read an integer from a cache of bytes and remove it from the cache /// Read an integer from a cache of bytes and remove it from the cache
/// </summary> /// </summary>
/// <returns>The integer value</returns> /// <returns>The integer value</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public int ReadNextInt(Queue<byte> cache) public int ReadNextInt(Queue<byte> cache)
{ {
byte[] rawValue = ReadData(4, cache); Span<byte> rawValue = stackalloc byte[4];
Array.Reverse(rawValue); //Endianness for (int i = (4 - 1); i >= 0; --i) //Endianness
return BitConverter.ToInt32(rawValue, 0); rawValue[i] = cache.Dequeue();
return BitConverter.ToInt32(rawValue);
} }
/// <summary> /// <summary>
/// Read a long integer from a cache of bytes and remove it from the cache /// Read a long integer from a cache of bytes and remove it from the cache
/// </summary> /// </summary>
/// <returns>The unsigned long integer value</returns> /// <returns>The unsigned long integer value</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public long ReadNextLong(Queue<byte> cache) public long ReadNextLong(Queue<byte> cache)
{ {
byte[] rawValue = ReadData(8, cache); Span<byte> rawValue = stackalloc byte[8];
Array.Reverse(rawValue); //Endianness for (int i = (8 - 1); i >= 0; --i) //Endianness
return BitConverter.ToInt64(rawValue, 0); rawValue[i] = cache.Dequeue();
return BitConverter.ToInt64(rawValue);
} }
/// <summary> /// <summary>
/// Read an unsigned short integer from a cache of bytes and remove it from the cache /// Read an unsigned short integer from a cache of bytes and remove it from the cache
/// </summary> /// </summary>
/// <returns>The unsigned short integer value</returns> /// <returns>The unsigned short integer value</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public ushort ReadNextUShort(Queue<byte> cache) public ushort ReadNextUShort(Queue<byte> cache)
{ {
byte[] rawValue = ReadData(2, cache); Span<byte> rawValue = stackalloc byte[2];
Array.Reverse(rawValue); //Endianness for (int i = (2 - 1); i >= 0; --i) //Endianness
return BitConverter.ToUInt16(rawValue, 0); rawValue[i] = cache.Dequeue();
return BitConverter.ToUInt16(rawValue);
} }
/// <summary> /// <summary>
/// Read an unsigned long integer from a cache of bytes and remove it from the cache /// Read an unsigned long integer from a cache of bytes and remove it from the cache
/// </summary> /// </summary>
/// <returns>The unsigned long integer value</returns> /// <returns>The unsigned long integer value</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public ulong ReadNextULong(Queue<byte> cache) public ulong ReadNextULong(Queue<byte> cache)
{ {
byte[] rawValue = ReadData(8, cache); Span<byte> rawValue = stackalloc byte[8];
Array.Reverse(rawValue); //Endianness for (int i = (8 - 1); i >= 0; --i) //Endianness
return BitConverter.ToUInt64(rawValue, 0); rawValue[i] = cache.Dequeue();
return BitConverter.ToUInt64(rawValue);
} }
/// <summary> /// <summary>
@ -143,12 +191,12 @@ namespace MinecraftClient.Protocol.Handlers
y = (int)((locEncoded >> 26) & 0xFFF); y = (int)((locEncoded >> 26) & 0xFFF);
z = (int)(locEncoded << 38 >> 38); z = (int)(locEncoded << 38 >> 38);
} }
if (x >= 33554432) if (x >= 0x02000000) // 33,554,432
x -= 67108864; x -= 0x04000000; // 67,108,864
if (y >= 2048) if (y >= 0x00000800) // 2,048
y -= 4096; y -= 0x00001000; // 4,096
if (z >= 33554432) if (z >= 0x02000000) // 33,554,432
z -= 67108864; z -= 0x04000000; // 67,108,864
return new Location(x, y, z); return new Location(x, y, z);
} }
@ -172,7 +220,9 @@ namespace MinecraftClient.Protocol.Handlers
/// <returns>The uuid</returns> /// <returns>The uuid</returns>
public Guid ReadNextUUID(Queue<byte> cache) public Guid ReadNextUUID(Queue<byte> cache)
{ {
byte[] javaUUID = ReadData(16, cache); Span<byte> javaUUID = stackalloc byte[16];
for (int i = 0; i < 16; ++i)
javaUUID[i] = cache.Dequeue();
Guid guid = new Guid(javaUUID); Guid guid = new Guid(javaUUID);
if (BitConverter.IsLittleEndian) if (BitConverter.IsLittleEndian)
guid = guid.ToLittleEndian(); guid = guid.ToLittleEndian();
@ -184,6 +234,7 @@ namespace MinecraftClient.Protocol.Handlers
/// </summary> /// </summary>
/// <param name="cache">Cache of bytes to read from</param> /// <param name="cache">Cache of bytes to read from</param>
/// <returns>The byte array</returns> /// <returns>The byte array</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public byte[] ReadNextByteArray(Queue<byte> cache) public byte[] ReadNextByteArray(Queue<byte> cache)
{ {
int len = protocolversion >= Protocol18Handler.MC_1_8_Version int len = protocolversion >= Protocol18Handler.MC_1_8_Version
@ -196,6 +247,7 @@ namespace MinecraftClient.Protocol.Handlers
/// Reads a length-prefixed array of unsigned long integers and removes it from the cache /// Reads a length-prefixed array of unsigned long integers and removes it from the cache
/// </summary> /// </summary>
/// <returns>The unsigned long integer values</returns> /// <returns>The unsigned long integer values</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public ulong[] ReadNextULongArray(Queue<byte> cache) public ulong[] ReadNextULongArray(Queue<byte> cache)
{ {
int len = ReadNextVarInt(cache); int len = ReadNextVarInt(cache);
@ -209,39 +261,44 @@ namespace MinecraftClient.Protocol.Handlers
/// Read a double from a cache of bytes and remove it from the cache /// Read a double from a cache of bytes and remove it from the cache
/// </summary> /// </summary>
/// <returns>The double value</returns> /// <returns>The double value</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public double ReadNextDouble(Queue<byte> cache) public double ReadNextDouble(Queue<byte> cache)
{ {
byte[] rawValue = ReadData(8, cache); Span<byte> rawValue = stackalloc byte[8];
Array.Reverse(rawValue); //Endianness for (int i = (8 - 1); i >= 0; --i) //Endianness
return BitConverter.ToDouble(rawValue, 0); rawValue[i] = cache.Dequeue();
return BitConverter.ToDouble(rawValue);
} }
/// <summary> /// <summary>
/// Read a float from a cache of bytes and remove it from the cache /// Read a float from a cache of bytes and remove it from the cache
/// </summary> /// </summary>
/// <returns>The float value</returns> /// <returns>The float value</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public float ReadNextFloat(Queue<byte> cache) public float ReadNextFloat(Queue<byte> cache)
{ {
byte[] rawValue = ReadData(4, cache); Span<byte> rawValue = stackalloc byte[4];
Array.Reverse(rawValue); //Endianness for (int i = (4 - 1); i >= 0; --i) //Endianness
return BitConverter.ToSingle(rawValue, 0); rawValue[i] = cache.Dequeue();
return BitConverter.ToSingle(rawValue);
} }
/// <summary> /// <summary>
/// Read an integer from the network /// Read an integer from the network
/// </summary> /// </summary>
/// <returns>The integer</returns> /// <returns>The integer</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int ReadNextVarIntRAW(SocketWrapper socket) public int ReadNextVarIntRAW(SocketWrapper socket)
{ {
int i = 0; int i = 0;
int j = 0; int j = 0;
int k = 0; byte b;
while (true) while (true)
{ {
k = socket.ReadDataRAW(1)[0]; b = socket.ReadDataRAW(1)[0];
i |= (k & 0x7F) << j++ * 7; i |= (b & 0x7F) << j++ * 7;
if (j > 5) throw new OverflowException("VarInt too big"); if (j > 5) throw new OverflowException("VarInt too big");
if ((k & 0x80) != 128) break; if ((b & 0x80) != 128) break;
} }
return i; return i;
} }
@ -251,19 +308,18 @@ namespace MinecraftClient.Protocol.Handlers
/// </summary> /// </summary>
/// <param name="cache">Cache of bytes to read from</param> /// <param name="cache">Cache of bytes to read from</param>
/// <returns>The integer</returns> /// <returns>The integer</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public int ReadNextVarInt(Queue<byte> cache) public int ReadNextVarInt(Queue<byte> cache)
{ {
string rawData = BitConverter.ToString(cache.ToArray());
int i = 0; int i = 0;
int j = 0; int j = 0;
int k = 0; byte b;
while (true) do
{ {
k = ReadNextByte(cache); b = cache.Dequeue();
i |= (k & 0x7F) << j++ * 7; i |= (b & 0x7F) << j++ * 7;
if (j > 5) throw new OverflowException("VarInt too big " + rawData); if (j > 5) throw new OverflowException("VarInt too big");
if ((k & 0x80) != 128) break; } while ((b & 0x80) == 128);
}
return i; return i;
} }
@ -271,14 +327,13 @@ namespace MinecraftClient.Protocol.Handlers
/// Skip a VarInt from a cache of bytes with better performance /// Skip a VarInt from a cache of bytes with better performance
/// </summary> /// </summary>
/// <param name="cache">Cache of bytes to read from</param> /// <param name="cache">Cache of bytes to read from</param>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public void SkipNextVarInt(Queue<byte> cache) public void SkipNextVarInt(Queue<byte> cache)
{ {
while (true) while (true)
{
if ((ReadNextByte(cache) & 0x80) != 128) if ((ReadNextByte(cache) & 0x80) != 128)
break; break;
} }
}
/// <summary> /// <summary>
/// Read an "extended short", which is actually an int of some kind, from the cache of bytes. /// Read an "extended short", which is actually an int of some kind, from the cache of bytes.
@ -328,6 +383,7 @@ namespace MinecraftClient.Protocol.Handlers
/// Read a single byte from a cache of bytes and remove it from the cache /// Read a single byte from a cache of bytes and remove it from the cache
/// </summary> /// </summary>
/// <returns>The byte that was read</returns> /// <returns>The byte that was read</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public byte ReadNextByte(Queue<byte> cache) public byte ReadNextByte(Queue<byte> cache)
{ {
byte result = cache.Dequeue(); byte result = cache.Dequeue();

44
MinecraftClient/Protocol/Handlers/Protocol16.cs
View file

@ -10,6 +10,7 @@ using System.Security.Cryptography;
using MinecraftClient.Mapping; using MinecraftClient.Mapping;
using MinecraftClient.Inventory; using MinecraftClient.Inventory;
using MinecraftClient.Protocol.Keys; using MinecraftClient.Protocol.Keys;
using MinecraftClient.Protocol.Session;
using MinecraftClient.Protocol.Message; using MinecraftClient.Protocol.Message;
namespace MinecraftClient.Protocol.Handlers namespace MinecraftClient.Protocol.Handlers
@ -26,7 +27,7 @@ namespace MinecraftClient.Protocol.Handlers
private bool encrypted = false; private bool encrypted = false;
private int protocolversion; private int protocolversion;
private Tuple<Thread, CancellationTokenSource>? netRead = null; private Tuple<Thread, CancellationTokenSource>? netRead = null;
Crypto.IAesStream s; Crypto.AesCfb8Stream s;
TcpClient c; TcpClient c;
public Protocol16Handler(TcpClient Client, int ProtocolVersion, IMinecraftComHandler Handler) public Protocol16Handler(TcpClient Client, int ProtocolVersion, IMinecraftComHandler Handler)
@ -218,7 +219,7 @@ namespace MinecraftClient.Protocol.Handlers
/// Get net read thread (main thread) ID /// Get net read thread (main thread) ID
/// </summary> /// </summary>
/// <returns>Net read thread ID</returns> /// <returns>Net read thread ID</returns>
public int GetNetReadThreadId() public int GetNetMainThreadId()
{ {
return netRead != null ? netRead.Item1.ManagedThreadId : -1; return netRead != null ? netRead.Item1.ManagedThreadId : -1;
} }
@ -440,7 +441,7 @@ namespace MinecraftClient.Protocol.Handlers
else c.Client.Send(buffer); else c.Client.Send(buffer);
} }
private bool Handshake(string uuid, string username, string sessionID, string host, int port) private bool Handshake(string uuid, string username, string sessionID, string host, int port, SessionToken session)
{ {
//array //array
byte[] data = new byte[10 + (username.Length + host.Length) * 2]; byte[] data = new byte[10 + (username.Length + host.Length) * 2];
@ -494,7 +495,7 @@ namespace MinecraftClient.Protocol.Handlers
else if (Settings.DebugMessages) else if (Settings.DebugMessages)
ConsoleIO.WriteLineFormatted(Translations.Get("mcc.handshake", serverID)); ConsoleIO.WriteLineFormatted(Translations.Get("mcc.handshake", serverID));
return StartEncryption(uuid, username, sessionID, token, serverID, PublicServerkey); return StartEncryption(uuid, username, sessionID, token, serverID, PublicServerkey, session);
} }
else else
{ {
@ -503,10 +504,10 @@ namespace MinecraftClient.Protocol.Handlers
} }
} }
private bool StartEncryption(string uuid, string username, string sessionID, byte[] token, string serverIDhash, byte[] serverKey) private bool StartEncryption(string uuid, string username, string sessionID, byte[] token, string serverIDhash, byte[] serverPublicKey, SessionToken session)
{ {
System.Security.Cryptography.RSACryptoServiceProvider RSAService = CryptoHandler.DecodeRSAPublicKey(serverKey); RSACryptoServiceProvider RSAService = CryptoHandler.DecodeRSAPublicKey(serverPublicKey);
byte[] secretKey = CryptoHandler.GenerateAESPrivateKey(); byte[] secretKey = CryptoHandler.ClientAESPrivateKey ?? CryptoHandler.GenerateAESPrivateKey();
if (Settings.DebugMessages) if (Settings.DebugMessages)
Translations.WriteLineFormatted("debug.crypto"); Translations.WriteLineFormatted("debug.crypto");
@ -514,12 +515,33 @@ namespace MinecraftClient.Protocol.Handlers
if (serverIDhash != "-") if (serverIDhash != "-")
{ {
Translations.WriteLine("mcc.session"); Translations.WriteLine("mcc.session");
if (!ProtocolHandler.SessionCheck(uuid, sessionID, CryptoHandler.getServerHash(serverIDhash, serverKey, secretKey))) string serverHash = CryptoHandler.getServerHash(serverIDhash, serverPublicKey, secretKey);
bool needCheckSession = true;
if (session.ServerPublicKey != null && session.SessionPreCheckTask != null
&& serverIDhash == session.ServerIDhash && Enumerable.SequenceEqual(serverPublicKey, session.ServerPublicKey))
{
session.SessionPreCheckTask.Wait();
if (session.SessionPreCheckTask.Result) // PreCheck Successed
needCheckSession = false;
}
if (needCheckSession)
{
if (ProtocolHandler.SessionCheck(uuid, sessionID, serverHash))
{
session.ServerIDhash = serverIDhash;
session.ServerPublicKey = serverPublicKey;
SessionCache.Store(Settings.Login.ToLower(), session);
}
else
{ {
handler.OnConnectionLost(ChatBot.DisconnectReason.LoginRejected, Translations.Get("mcc.session_fail")); handler.OnConnectionLost(ChatBot.DisconnectReason.LoginRejected, Translations.Get("mcc.session_fail"));
return false; return false;
} }
} }
}
//Encrypt the data //Encrypt the data
byte[] key_enc = RSAService.Encrypt(secretKey, false); byte[] key_enc = RSAService.Encrypt(secretKey, false);
@ -547,7 +569,7 @@ namespace MinecraftClient.Protocol.Handlers
if (pid[0] == 0xFC) if (pid[0] == 0xFC)
{ {
readData(4); readData(4);
s = CryptoHandler.getAesStream(c.GetStream(), secretKey); s = new AesCfb8Stream(c.GetStream(), secretKey);
encrypted = true; encrypted = true;
return true; return true;
} }
@ -558,9 +580,9 @@ namespace MinecraftClient.Protocol.Handlers
} }
} }
public bool Login(PlayerKeyPair playerKeyPair) public bool Login(PlayerKeyPair? playerKeyPair, SessionToken session)
{ {
if (Handshake(handler.GetUserUuidStr(), handler.GetUsername(), handler.GetSessionID(), handler.GetServerHost(), handler.GetServerPort())) if (Handshake(handler.GetUserUuidStr(), handler.GetUsername(), handler.GetSessionID(), handler.GetServerHost(), handler.GetServerPort(), session))
{ {
Send(new byte[] { 0xCD, 0 }); Send(new byte[] { 0xCD, 0 });
try try

240
MinecraftClient/Protocol/Handlers/Protocol18.cs
View file

@ -19,6 +19,8 @@ using MinecraftClient.Logger;
using System.Threading.Tasks; using System.Threading.Tasks;
using MinecraftClient.Protocol.Keys; using MinecraftClient.Protocol.Keys;
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
using MinecraftClient.Protocol.Session;
using System.Collections.Concurrent;
using MinecraftClient.Protocol.Message; using MinecraftClient.Protocol.Message;
namespace MinecraftClient.Protocol.Handlers namespace MinecraftClient.Protocol.Handlers
@ -67,6 +69,7 @@ namespace MinecraftClient.Protocol.Handlers
private int protocolVersion; private int protocolVersion;
private int currentDimension; private int currentDimension;
private bool isOnlineMode = false; private bool isOnlineMode = false;
private readonly BlockingCollection<Tuple<int, Queue<byte>>> packetQueue = new();
private int pendingAcknowledgments = 0; private int pendingAcknowledgments = 0;
private LastSeenMessagesCollector lastSeenMessagesCollector = new(5); private LastSeenMessagesCollector lastSeenMessagesCollector = new(5);
@ -80,7 +83,8 @@ namespace MinecraftClient.Protocol.Handlers
PacketTypePalette packetPalette; PacketTypePalette packetPalette;
SocketWrapper socketWrapper; SocketWrapper socketWrapper;
DataTypes dataTypes; DataTypes dataTypes;
Tuple<Thread, CancellationTokenSource>? netRead = null; // main thread Tuple<Thread, CancellationTokenSource>? netMain = null; // main thread
Tuple<Thread, CancellationTokenSource>? netReader = null; // reader thread
ILogger log; ILogger log;
RandomNumberGenerator randomGen; RandomNumberGenerator randomGen;
@ -204,64 +208,76 @@ namespace MinecraftClient.Protocol.Handlers
/// </summary> /// </summary>
private void Updater(object? o) private void Updater(object? o)
{ {
CancellationToken cancelToken = (CancellationToken)o!;
if (((CancellationToken)o!).IsCancellationRequested) if (cancelToken.IsCancellationRequested)
return; return;
try try
{ {
Stopwatch stopWatch = new();
bool keepUpdating = true; while (!packetQueue.IsAddingCompleted)
Stopwatch stopWatch = new Stopwatch();
while (keepUpdating)
{ {
cancelToken.ThrowIfCancellationRequested();
((CancellationToken)o!).ThrowIfCancellationRequested(); handler.OnUpdate();
stopWatch.Restart();
stopWatch.Start(); while (packetQueue.TryTake(out Tuple<int, Queue<byte>>? packetInfo))
keepUpdating = Update(); {
stopWatch.Stop(); (int packetID, Queue<byte> packetData) = packetInfo;
int elapsed = stopWatch.Elapsed.Milliseconds; HandlePacket(packetID, packetData);
stopWatch.Reset();
if (elapsed < 100) if (stopWatch.Elapsed.Milliseconds >= 100)
Thread.Sleep(100 - elapsed); {
handler.OnUpdate();
stopWatch.Restart();
}
}
int sleepLength = 100 - stopWatch.Elapsed.Milliseconds;
if (sleepLength > 0)
Thread.Sleep(sleepLength);
} }
} }
catch (System.IO.IOException) { }
catch (SocketException) { }
catch (ObjectDisposedException) { } catch (ObjectDisposedException) { }
catch (OperationCanceledException) { } catch (OperationCanceledException) { }
if (((CancellationToken)o!).IsCancellationRequested) if (cancelToken.IsCancellationRequested)
return; return;
handler.OnConnectionLost(ChatBot.DisconnectReason.ConnectionLost, ""); handler.OnConnectionLost(ChatBot.DisconnectReason.ConnectionLost, "");
} }
/// <summary> /// <summary>
/// Read data from the network. Should be called on a separate thread. /// Read and decompress packets.
/// </summary> /// </summary>
/// <returns>FALSE if an error occured, TRUE otherwise.</returns> internal void PacketReader(object? o)
private bool Update() {
CancellationToken cancelToken = (CancellationToken)o!;
while (socketWrapper.IsConnected() && !cancelToken.IsCancellationRequested)
{ {
handler.OnUpdate();
if (!socketWrapper.IsConnected())
return false;
try try
{ {
while (socketWrapper.HasDataAvailable()) while (socketWrapper.HasDataAvailable())
{ {
int packetID = 0; packetQueue.Add(ReadNextPacket());
Queue<byte> packetData = new Queue<byte>();
ReadNextPacket(ref packetID, packetData); if (cancelToken.IsCancellationRequested)
HandlePacket(packetID, new Queue<byte>(packetData)); break;
} }
} }
catch (System.IO.IOException) { return false; } catch (System.IO.IOException) { break; }
catch (SocketException) { return false; } catch (SocketException) { break; }
catch (NullReferenceException) { return false; } catch (NullReferenceException) { break; }
catch (Ionic.Zlib.ZlibException) { return false; } catch (Ionic.Zlib.ZlibException) { break; }
return true;
if (cancelToken.IsCancellationRequested)
break;
Thread.Sleep(10);
}
packetQueue.CompleteAdding();
} }
/// <summary> /// <summary>
@ -269,14 +285,10 @@ namespace MinecraftClient.Protocol.Handlers
/// </summary> /// </summary>
/// <param name="packetID">will contain packet ID</param> /// <param name="packetID">will contain packet ID</param>
/// <param name="packetData">will contain raw packet Data</param> /// <param name="packetData">will contain raw packet Data</param>
internal void ReadNextPacket(ref int packetID, Queue<byte> packetData) internal Tuple<int, Queue<byte>> ReadNextPacket()
{ {
packetData.Clear();
int size = dataTypes.ReadNextVarIntRAW(socketWrapper); //Packet size int size = dataTypes.ReadNextVarIntRAW(socketWrapper); //Packet size
byte[] rawpacket = socketWrapper.ReadDataRAW(size); //Packet contents Queue<byte> packetData = new(socketWrapper.ReadDataRAW(size)); //Packet contents
for (int i = 0; i < rawpacket.Length; i++)
packetData.Enqueue(rawpacket[i]);
//Handle packet decompression //Handle packet decompression
if (protocolVersion >= MC_1_8_Version if (protocolVersion >= MC_1_8_Version
@ -287,19 +299,19 @@ namespace MinecraftClient.Protocol.Handlers
{ {
byte[] toDecompress = packetData.ToArray(); byte[] toDecompress = packetData.ToArray();
byte[] uncompressed = ZlibUtils.Decompress(toDecompress, sizeUncompressed); byte[] uncompressed = ZlibUtils.Decompress(toDecompress, sizeUncompressed);
packetData.Clear(); packetData = new(uncompressed);
for (int i = 0; i < uncompressed.Length; i++)
packetData.Enqueue(uncompressed[i]);
} }
} }
packetID = dataTypes.ReadNextVarInt(packetData); //Packet ID int packetID = dataTypes.ReadNextVarInt(packetData); //Packet ID
if (handler.GetNetworkPacketCaptureEnabled()) if (handler.GetNetworkPacketCaptureEnabled())
{ {
List<byte> clone = packetData.ToList(); List<byte> clone = packetData.ToList();
handler.OnNetworkPacket(packetID, clone, login_phase, true); handler.OnNetworkPacket(packetID, clone, login_phase, true);
} }
return new(packetID, packetData);
} }
/// <summary> /// <summary>
@ -335,10 +347,13 @@ namespace MinecraftClient.Protocol.Handlers
else switch (packetPalette.GetIncommingTypeById(packetID)) else switch (packetPalette.GetIncommingTypeById(packetID))
{ {
case PacketTypesIn.KeepAlive: case PacketTypesIn.KeepAlive:
//log.Info("KeepAlive");
SendPacket(PacketTypesOut.KeepAlive, packetData); SendPacket(PacketTypesOut.KeepAlive, packetData);
handler.OnServerKeepAlive(); handler.OnServerKeepAlive();
break; break;
case PacketTypesIn.Ping:
int ID = dataTypes.ReadNextInt(packetData);
SendPacket(PacketTypesOut.Pong, dataTypes.GetInt(ID));
break;
case PacketTypesIn.JoinGame: case PacketTypesIn.JoinGame:
handler.OnGameJoined(); handler.OnGameJoined();
int playerEntityID = dataTypes.ReadNextInt(packetData); int playerEntityID = dataTypes.ReadNextInt(packetData);
@ -396,7 +411,7 @@ namespace MinecraftClient.Protocol.Handlers
else else
dataTypes.ReadNextByte(packetData); // Max Players - 1.16.1 and below dataTypes.ReadNextByte(packetData); // Max Players - 1.16.1 and below
if (protocolVersion < MC_1_16_Version) if (protocolVersion < MC_1_16_Version)
dataTypes.ReadNextString(packetData); // Level Type - 1.15 and below dataTypes.SkipNextString(packetData); // Level Type - 1.15 and below
if (protocolVersion >= MC_1_14_Version) if (protocolVersion >= MC_1_14_Version)
dataTypes.ReadNextVarInt(packetData); // View distance - 1.14 and above dataTypes.ReadNextVarInt(packetData); // View distance - 1.14 and above
if (protocolVersion >= MC_1_18_1_Version) if (protocolVersion >= MC_1_18_1_Version)
@ -415,7 +430,7 @@ namespace MinecraftClient.Protocol.Handlers
bool hasDeathLocation = dataTypes.ReadNextBool(packetData); // Has death location bool hasDeathLocation = dataTypes.ReadNextBool(packetData); // Has death location
if (hasDeathLocation) if (hasDeathLocation)
{ {
dataTypes.ReadNextString(packetData); // Death dimension name: Identifier dataTypes.SkipNextString(packetData); // Death dimension name: Identifier
dataTypes.ReadNextLocation(packetData); // Death location dataTypes.ReadNextLocation(packetData); // Death location
} }
} }
@ -557,6 +572,7 @@ namespace MinecraftClient.Protocol.Handlers
byte[] bodyDigest = dataTypes.ReadNextByteArray(packetData); byte[] bodyDigest = dataTypes.ReadNextByteArray(packetData);
bool verifyResult; bool verifyResult;
if (!isOnlineMode) if (!isOnlineMode)
verifyResult = false; verifyResult = false;
else if (senderUUID == handler.GetUserUuid()) else if (senderUUID == handler.GetUserUuid())
@ -564,6 +580,7 @@ namespace MinecraftClient.Protocol.Handlers
else else
{ {
PlayerInfo? player = handler.GetPlayerInfo(senderUUID); PlayerInfo? player = handler.GetPlayerInfo(senderUUID);
if (player == null || !player.IsMessageChainLegal()) if (player == null || !player.IsMessageChainLegal())
verifyResult = false; verifyResult = false;
else else
@ -571,7 +588,7 @@ namespace MinecraftClient.Protocol.Handlers
bool lastVerifyResult = player.IsMessageChainLegal(); bool lastVerifyResult = player.IsMessageChainLegal();
verifyResult = player.VerifyMessageHead(ref precedingSignature, ref headerSignature, ref bodyDigest); verifyResult = player.VerifyMessageHead(ref precedingSignature, ref headerSignature, ref bodyDigest);
if (lastVerifyResult && !verifyResult) if (lastVerifyResult && !verifyResult)
log.Warn("Player " + player.DisplayName + "'s message chain is broken!"); log.Warn("Player " + player.Name + "'s message chain is broken!");
} }
} }
} }
@ -606,7 +623,7 @@ namespace MinecraftClient.Protocol.Handlers
if (protocolVersion >= MC_1_16_Version) if (protocolVersion >= MC_1_16_Version)
dataTypes.ReadNextByte(packetData); // Previous Game mode - 1.16 and above dataTypes.ReadNextByte(packetData); // Previous Game mode - 1.16 and above
if (protocolVersion < MC_1_16_Version) if (protocolVersion < MC_1_16_Version)
dataTypes.ReadNextString(packetData); // Level Type - 1.15 and below dataTypes.SkipNextString(packetData); // Level Type - 1.15 and below
if (protocolVersion >= MC_1_16_Version) if (protocolVersion >= MC_1_16_Version)
{ {
dataTypes.ReadNextBool(packetData); // Is Debug - 1.16 and above dataTypes.ReadNextBool(packetData); // Is Debug - 1.16 and above
@ -660,6 +677,9 @@ namespace MinecraftClient.Protocol.Handlers
case PacketTypesIn.ChunkData: case PacketTypesIn.ChunkData:
if (handler.GetTerrainEnabled()) if (handler.GetTerrainEnabled())
{ {
Interlocked.Increment(ref handler.GetWorld().chunkCnt);
Interlocked.Increment(ref handler.GetWorld().chunkLoadNotCompleted);
int chunkX = dataTypes.ReadNextInt(packetData); int chunkX = dataTypes.ReadNextInt(packetData);
int chunkZ = dataTypes.ReadNextInt(packetData); int chunkZ = dataTypes.ReadNextInt(packetData);
if (protocolVersion >= MC_1_17_Version) if (protocolVersion >= MC_1_17_Version)
@ -667,7 +687,7 @@ namespace MinecraftClient.Protocol.Handlers
ulong[]? verticalStripBitmask = null; ulong[]? verticalStripBitmask = null;
if (protocolVersion == MC_1_17_Version || protocolVersion == MC_1_17_1_Version) if (protocolVersion == MC_1_17_Version || protocolVersion == MC_1_17_1_Version)
verticalStripBitmask = dataTypes.ReadNextULongArray(packetData); // Bit Mask Le:ngth and Primary Bit Mask verticalStripBitmask = dataTypes.ReadNextULongArray(packetData); // Bit Mask Length and Primary Bit Mask
dataTypes.ReadNextNbt(packetData); // Heightmaps dataTypes.ReadNextNbt(packetData); // Heightmaps
@ -675,20 +695,16 @@ namespace MinecraftClient.Protocol.Handlers
{ {
int biomesLength = dataTypes.ReadNextVarInt(packetData); // Biomes length int biomesLength = dataTypes.ReadNextVarInt(packetData); // Biomes length
for (int i = 0; i < biomesLength; i++) for (int i = 0; i < biomesLength; i++)
{
dataTypes.SkipNextVarInt(packetData); // Biomes dataTypes.SkipNextVarInt(packetData); // Biomes
} }
}
int dataSize = dataTypes.ReadNextVarInt(packetData); // Size int dataSize = dataTypes.ReadNextVarInt(packetData); // Size
Interlocked.Increment(ref handler.GetWorld().chunkCnt);
Interlocked.Increment(ref handler.GetWorld().chunkLoadNotCompleted);
new Task(() =>
{
pTerrain.ProcessChunkColumnData(chunkX, chunkZ, verticalStripBitmask, packetData); pTerrain.ProcessChunkColumnData(chunkX, chunkZ, verticalStripBitmask, packetData);
Interlocked.Decrement(ref handler.GetWorld().chunkLoadNotCompleted); Interlocked.Decrement(ref handler.GetWorld().chunkLoadNotCompleted);
}).Start();
// Block Entity data: ignored
// Light data: ignored
} }
else else
{ {
@ -704,10 +720,9 @@ namespace MinecraftClient.Protocol.Handlers
int compressedDataSize = dataTypes.ReadNextInt(packetData); int compressedDataSize = dataTypes.ReadNextInt(packetData);
byte[] compressed = dataTypes.ReadData(compressedDataSize, packetData); byte[] compressed = dataTypes.ReadData(compressedDataSize, packetData);
byte[] decompressed = ZlibUtils.Decompress(compressed); byte[] decompressed = ZlibUtils.Decompress(compressed);
new Task(() =>
{
pTerrain.ProcessChunkColumnData(chunkX, chunkZ, chunkMask, addBitmap, currentDimension == 0, chunksContinuous, currentDimension, new Queue<byte>(decompressed)); pTerrain.ProcessChunkColumnData(chunkX, chunkZ, chunkMask, addBitmap, currentDimension == 0, chunksContinuous, currentDimension, new Queue<byte>(decompressed));
}).Start(); Interlocked.Decrement(ref handler.GetWorld().chunkLoadNotCompleted);
} }
else else
{ {
@ -728,13 +743,12 @@ namespace MinecraftClient.Protocol.Handlers
dataTypes.SkipNextVarInt(packetData); dataTypes.SkipNextVarInt(packetData);
} }
} }
else dataTypes.ReadData(1024 * 4, packetData); // Biomes - 1.15 and above else dataTypes.DropData(1024 * 4, packetData); // Biomes - 1.15 and above
} }
int dataSize = dataTypes.ReadNextVarInt(packetData); int dataSize = dataTypes.ReadNextVarInt(packetData);
new Task(() =>
{
pTerrain.ProcessChunkColumnData(chunkX, chunkZ, chunkMask, 0, false, chunksContinuous, currentDimension, packetData); pTerrain.ProcessChunkColumnData(chunkX, chunkZ, chunkMask, 0, false, chunksContinuous, currentDimension, packetData);
}).Start(); Interlocked.Decrement(ref handler.GetWorld().chunkLoadNotCompleted);
} }
} }
} }
@ -991,7 +1005,11 @@ namespace MinecraftClient.Protocol.Handlers
//Process chunk records //Process chunk records
for (int chunkColumnNo = 0; chunkColumnNo < chunkCount; chunkColumnNo++) for (int chunkColumnNo = 0; chunkColumnNo < chunkCount; chunkColumnNo++)
{
pTerrain.ProcessChunkColumnData(chunkXs[chunkColumnNo], chunkZs[chunkColumnNo], chunkMasks[chunkColumnNo], addBitmaps[chunkColumnNo], hasSkyLight, true, currentDimension, chunkData); pTerrain.ProcessChunkColumnData(chunkXs[chunkColumnNo], chunkZs[chunkColumnNo], chunkMasks[chunkColumnNo], addBitmaps[chunkColumnNo], hasSkyLight, true, currentDimension, chunkData);
Interlocked.Decrement(ref handler.GetWorld().chunkLoadNotCompleted);
}
} }
break; break;
case PacketTypesIn.UnloadChunk: case PacketTypesIn.UnloadChunk:
@ -1080,7 +1098,13 @@ namespace MinecraftClient.Protocol.Handlers
break; break;
case 0x03: //Update display name case 0x03: //Update display name
if (dataTypes.ReadNextBool(packetData)) if (dataTypes.ReadNextBool(packetData))
dataTypes.ReadNextString(packetData); {
PlayerInfo? player = handler.GetPlayerInfo(uuid);
if (player != null)
player.DisplayName = dataTypes.ReadNextString(packetData);
else
dataTypes.SkipNextString(packetData);
}
break; break;
case 0x04: //Player Leave case 0x04: //Player Leave
handler.OnPlayerLeave(uuid); handler.OnPlayerLeave(uuid);
@ -1120,7 +1144,7 @@ namespace MinecraftClient.Protocol.Handlers
{ {
// Skip optional tooltip for each tab-complete result // Skip optional tooltip for each tab-complete result
if (dataTypes.ReadNextBool(packetData)) if (dataTypes.ReadNextBool(packetData))
dataTypes.ReadNextString(packetData); dataTypes.SkipNextString(packetData);
} }
} }
@ -1238,8 +1262,9 @@ namespace MinecraftClient.Protocol.Handlers
{ {
forced = dataTypes.ReadNextBool(packetData); forced = dataTypes.ReadNextBool(packetData);
string forcedMessage = ChatParser.ParseText(dataTypes.ReadNextString(packetData)); string forcedMessage = ChatParser.ParseText(dataTypes.ReadNextString(packetData));
dataTypes.ReadNextBool(packetData); // Has Prompt Message (Boolean) - 1.17 and above bool hasPromptMessage = dataTypes.ReadNextBool(packetData); // Has Prompt Message (Boolean) - 1.17 and above
dataTypes.ReadNextString(packetData); // Prompt Message (Optional Chat) - 1.17 and above if (hasPromptMessage)
dataTypes.SkipNextString(packetData); // Prompt Message (Optional Chat) - 1.17 and above
} }
// Some server plugins may send invalid resource packs to probe the client and we need to ignore them (issue #1056) // Some server plugins may send invalid resource packs to probe the client and we need to ignore them (issue #1056)
if (!url.StartsWith("http") && hash.Length != 40) // Some server may have null hash value if (!url.StartsWith("http") && hash.Length != 40) // Some server may have null hash value
@ -1314,7 +1339,9 @@ namespace MinecraftClient.Protocol.Handlers
{ {
int entityid = dataTypes.ReadNextVarInt(packetData); int entityid = dataTypes.ReadNextVarInt(packetData);
Inventory.Effects effect = Effects.Speed; Inventory.Effects effect = Effects.Speed;
if (Enum.TryParse(dataTypes.ReadNextByte(packetData).ToString(), out effect)) int effectId = protocolVersion >= MC_1_18_2_Version ?
dataTypes.ReadNextVarInt(packetData) : dataTypes.ReadNextByte(packetData);
if (Enum.TryParse(effectId.ToString(), out effect))
{ {
int amplifier = dataTypes.ReadNextByte(packetData); int amplifier = dataTypes.ReadNextByte(packetData);
int duration = dataTypes.ReadNextVarInt(packetData); int duration = dataTypes.ReadNextVarInt(packetData);
@ -1326,6 +1353,7 @@ namespace MinecraftClient.Protocol.Handlers
if (protocolVersion >= MC_1_19_Version) if (protocolVersion >= MC_1_19_Version)
{ {
hasFactorData = dataTypes.ReadNextBool(packetData); hasFactorData = dataTypes.ReadNextBool(packetData);
if (hasFactorData)
factorCodec = dataTypes.ReadNextNbt(packetData); factorCodec = dataTypes.ReadNextNbt(packetData);
} }
@ -1571,19 +1599,24 @@ namespace MinecraftClient.Protocol.Handlers
/// </summary> /// </summary>
private void StartUpdating() private void StartUpdating()
{ {
Thread threadUpdater = new Thread(new ParameterizedThreadStart(Updater));
threadUpdater.Name = "ProtocolPacketHandler";
netMain = new Tuple<Thread, CancellationTokenSource>(threadUpdater, new CancellationTokenSource());
threadUpdater.Start(netMain.Item2.Token);
netRead = new Tuple<Thread, CancellationTokenSource>(new Thread(new ParameterizedThreadStart(Updater)), new CancellationTokenSource()); Thread threadReader = new Thread(new ParameterizedThreadStart(PacketReader));
netRead.Item1.Name = "ProtocolPacketHandler"; threadReader.Name = "ProtocolPacketReader";
netRead.Item1.Start(netRead.Item2.Token); netReader = new Tuple<Thread, CancellationTokenSource>(threadReader, new CancellationTokenSource());
threadReader.Start(netReader.Item2.Token);
} }
/// <summary> /// <summary>
/// Get net read thread (main thread) ID /// Get net read thread (main thread) ID
/// </summary> /// </summary>
/// <returns>Net read thread ID</returns> /// <returns>Net read thread ID</returns>
public int GetNetReadThreadId() public int GetNetMainThreadId()
{ {
return netRead != null ? netRead.Item1.ManagedThreadId : -1; return netMain != null ? netMain.Item1.ManagedThreadId : -1;
} }
/// <summary> /// <summary>
@ -1593,9 +1626,12 @@ namespace MinecraftClient.Protocol.Handlers
{ {
try try
{ {
if (netRead != null) if (netMain != null)
{ {
netRead.Item2.Cancel(); netMain.Item2.Cancel();
}
if (netReader != null){
netReader.Item2.Cancel();
socketWrapper.Disconnect(); socketWrapper.Disconnect();
} }
} }
@ -1651,7 +1687,7 @@ namespace MinecraftClient.Protocol.Handlers
/// Do the Minecraft login. /// Do the Minecraft login.
/// </summary> /// </summary>
/// <returns>True if login successful</returns> /// <returns>True if login successful</returns>
public bool Login(PlayerKeyPair? playerKeyPair) public bool Login(PlayerKeyPair? playerKeyPair, SessionToken session)
{ {
byte[] protocol_version = dataTypes.GetVarInt(protocolVersion); byte[] protocol_version = dataTypes.GetVarInt(protocolVersion);
string server_address = pForge.GetServerAddress(handler.GetServerHost()); string server_address = pForge.GetServerAddress(handler.GetServerHost());
@ -1690,11 +1726,9 @@ namespace MinecraftClient.Protocol.Handlers
} }
SendPacket(0x00, fullLoginPacket); SendPacket(0x00, fullLoginPacket);
int packetID = -1;
Queue<byte> packetData = new();
while (true) while (true)
{ {
ReadNextPacket(ref packetID, packetData); (int packetID, Queue<byte> packetData) = ReadNextPacket();
if (packetID == 0x00) //Login rejected if (packetID == 0x00) //Login rejected
{ {
handler.OnConnectionLost(ChatBot.DisconnectReason.LoginRejected, ChatParser.ParseText(dataTypes.ReadNextString(packetData))); handler.OnConnectionLost(ChatBot.DisconnectReason.LoginRejected, ChatParser.ParseText(dataTypes.ReadNextString(packetData)));
@ -1706,7 +1740,7 @@ namespace MinecraftClient.Protocol.Handlers
string serverID = dataTypes.ReadNextString(packetData); string serverID = dataTypes.ReadNextString(packetData);
byte[] serverPublicKey = dataTypes.ReadNextByteArray(packetData); byte[] serverPublicKey = dataTypes.ReadNextByteArray(packetData);
byte[] token = dataTypes.ReadNextByteArray(packetData); byte[] token = dataTypes.ReadNextByteArray(packetData);
return StartEncryption(handler.GetUserUuidStr(), handler.GetSessionID(), token, serverID, serverPublicKey, playerKeyPair); return StartEncryption(handler.GetUserUuidStr(), handler.GetSessionID(), token, serverID, serverPublicKey, playerKeyPair, session);
} }
else if (packetID == 0x02) //Login successful else if (packetID == 0x02) //Login successful
{ {
@ -1730,23 +1764,43 @@ namespace MinecraftClient.Protocol.Handlers
/// Start network encryption. Automatically called by Login() if the server requests encryption. /// Start network encryption. Automatically called by Login() if the server requests encryption.
/// </summary> /// </summary>
/// <returns>True if encryption was successful</returns> /// <returns>True if encryption was successful</returns>
private bool StartEncryption(string uuid, string sessionID, byte[] token, string serverIDhash, byte[] serverPublicKey, PlayerKeyPair? playerKeyPair) private bool StartEncryption(string uuid, string sessionID, byte[] token, string serverIDhash, byte[] serverPublicKey, PlayerKeyPair? playerKeyPair, SessionToken session)
{ {
System.Security.Cryptography.RSACryptoServiceProvider RSAService = CryptoHandler.DecodeRSAPublicKey(serverPublicKey); RSACryptoServiceProvider RSAService = CryptoHandler.DecodeRSAPublicKey(serverPublicKey);
byte[] secretKey = CryptoHandler.GenerateAESPrivateKey(); byte[] secretKey = CryptoHandler.ClientAESPrivateKey ?? CryptoHandler.GenerateAESPrivateKey();
log.Debug(Translations.Get("debug.crypto")); log.Debug(Translations.Get("debug.crypto"));
if (serverIDhash != "-") if (serverIDhash != "-")
{ {
log.Info(Translations.Get("mcc.session")); log.Info(Translations.Get("mcc.session"));
if (!ProtocolHandler.SessionCheck(uuid, sessionID, CryptoHandler.getServerHash(serverIDhash, serverPublicKey, secretKey)))
bool needCheckSession = true;
if (session.ServerPublicKey != null && session.SessionPreCheckTask != null
&& serverIDhash == session.ServerIDhash && Enumerable.SequenceEqual(serverPublicKey, session.ServerPublicKey))
{
session.SessionPreCheckTask.Wait();
if (session.SessionPreCheckTask.Result) // PreCheck Successed
needCheckSession = false;
}
if (needCheckSession)
{
string serverHash = CryptoHandler.getServerHash(serverIDhash, serverPublicKey, secretKey);
if (ProtocolHandler.SessionCheck(uuid, sessionID, serverHash))
{
session.ServerIDhash = serverIDhash;
session.ServerPublicKey = serverPublicKey;
SessionCache.Store(Settings.Login.ToLower(), session);
}
else
{ {
handler.OnConnectionLost(ChatBot.DisconnectReason.LoginRejected, Translations.Get("mcc.session_fail")); handler.OnConnectionLost(ChatBot.DisconnectReason.LoginRejected, Translations.Get("mcc.session_fail"));
return false; return false;
} }
} }
}
// Encryption Response packet // Encryption Response packet
List<byte> encryptionResponse = new(); List<byte> encryptionResponse = new();
@ -1775,15 +1829,13 @@ namespace MinecraftClient.Protocol.Handlers
SendPacket(0x01, encryptionResponse); SendPacket(0x01, encryptionResponse);
//Start client-side encryption //Start client-side encryption
socketWrapper.SwitchToEncrypted(secretKey); socketWrapper.SwitchToEncrypted(secretKey); // pre switch
//Process the next packet //Process the next packet
int loopPrevention = UInt16.MaxValue; int loopPrevention = UInt16.MaxValue;
while (true) while (true)
{ {
int packetID = -1; (int packetID, Queue<byte> packetData) = ReadNextPacket();
Queue<byte> packetData = new Queue<byte>();
ReadNextPacket(ref packetID, packetData);
if (packetID < 0 || loopPrevention-- < 0) // Failed to read packet or too many iterations (issue #1150) if (packetID < 0 || loopPrevention-- < 0) // Failed to read packet or too many iterations (issue #1150)
{ {
handler.OnConnectionLost(ChatBot.DisconnectReason.ConnectionLost, Translations.Get("error.invalid_encrypt")); handler.OnConnectionLost(ChatBot.DisconnectReason.ConnectionLost, Translations.Get("error.invalid_encrypt"));
@ -1796,7 +1848,11 @@ namespace MinecraftClient.Protocol.Handlers
} }
else if (packetID == 0x02) //Login successful else if (packetID == 0x02) //Login successful
{ {
Guid uuidReceived = dataTypes.ReadNextUUID(packetData); Guid uuidReceived;
if (protocolVersion >= Protocol18Handler.MC_1_16_Version)
uuidReceived = dataTypes.ReadNextUUID(packetData);
else
uuidReceived = Guid.Parse(dataTypes.ReadNextString(packetData));
string userName = dataTypes.ReadNextString(packetData); string userName = dataTypes.ReadNextString(packetData);
Tuple<string, string, string>[]? playerProperty = null; Tuple<string, string, string>[]? playerProperty = null;
if (protocolVersion >= Protocol18Handler.MC_1_19_Version) if (protocolVersion >= Protocol18Handler.MC_1_19_Version)
@ -1898,7 +1954,7 @@ namespace MinecraftClient.Protocol.Handlers
/// Ping a Minecraft server to get information about the server /// Ping a Minecraft server to get information about the server
/// </summary> /// </summary>
/// <returns>True if ping was successful</returns> /// <returns>True if ping was successful</returns>
public static bool doPing(string host, int port, ref int protocolversion, ref ForgeInfo? forgeInfo) public static bool doPing(string host, int port, ref int protocolVersion, ref ForgeInfo? forgeInfo)
{ {
string version = ""; string version = "";
TcpClient tcp = ProxyHandler.newTcpClient(host, port); TcpClient tcp = ProxyHandler.newTcpClient(host, port);
@ -1950,12 +2006,12 @@ namespace MinecraftClient.Protocol.Handlers
//Retrieve protocol version number for handling this server //Retrieve protocol version number for handling this server
if (versionData.Properties.ContainsKey("protocol")) if (versionData.Properties.ContainsKey("protocol"))
protocolversion = int.Parse(versionData.Properties["protocol"].StringValue); protocolVersion = int.Parse(versionData.Properties["protocol"].StringValue);
// Check for forge on the server. // Check for forge on the server.
Protocol18Forge.ServerInfoCheckForge(jsonData, ref forgeInfo); Protocol18Forge.ServerInfoCheckForge(jsonData, ref forgeInfo);
ConsoleIO.WriteLineFormatted(Translations.Get("mcc.server_protocol", version, protocolversion + (forgeInfo != null ? Translations.Get("mcc.with_forge") : ""))); ConsoleIO.WriteLineFormatted(Translations.Get("mcc.server_protocol", version, protocolVersion + (forgeInfo != null ? Translations.Get("mcc.with_forge") : "")));
return true; return true;
} }

5
MinecraftClient/Protocol/Handlers/Protocol18Forge.cs
View file

@ -56,12 +56,9 @@ namespace MinecraftClient.Protocol.Handlers
{ {
if (ForgeEnabled() && forgeInfo.Version == FMLVersion.FML) if (ForgeEnabled() && forgeInfo.Version == FMLVersion.FML)
{ {
int packetID = -1;
Queue<byte> packetData = new Queue<byte>();
while (fmlHandshakeState != FMLHandshakeClientState.DONE) while (fmlHandshakeState != FMLHandshakeClientState.DONE)
{ {
protocol18.ReadNextPacket(ref packetID, packetData); (int packetID, Queue<byte> packetData) = protocol18.ReadNextPacket();
if (packetID == 0x40) // Disconnect if (packetID == 0x40) // Disconnect
{ {

173
MinecraftClient/Protocol/Handlers/Protocol18Terrain.cs
View file

@ -1,5 +1,10 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
//using System.Linq; //using System.Linq;
//using System.Text; //using System.Text;
using MinecraftClient.Mapping; using MinecraftClient.Mapping;
@ -30,9 +35,9 @@ namespace MinecraftClient.Protocol.Handlers
/// <summary> /// <summary>
/// Reading the "Block states" field: consists of 4096 entries, representing all the blocks in the chunk section. /// Reading the "Block states" field: consists of 4096 entries, representing all the blocks in the chunk section.
/// </summary> /// </summary>
/// <param name="chunk">Blocks will store in this chunk</param>
/// <param name="cache">Cache for reading data</param> /// <param name="cache">Cache for reading data</param>
private Chunk ReadBlockStatesField(ref Chunk chunk, Queue<byte> cache) [MethodImpl(MethodImplOptions.AggressiveOptimization)]
private Chunk? ReadBlockStatesField(Queue<byte> cache)
{ {
// read Block states (Type: Paletted Container) // read Block states (Type: Paletted Container)
byte bitsPerEntry = dataTypes.ReadNextByte(cache); byte bitsPerEntry = dataTypes.ReadNextByte(cache);
@ -41,24 +46,22 @@ namespace MinecraftClient.Protocol.Handlers
if (bitsPerEntry == 0 && protocolversion >= Protocol18Handler.MC_1_18_1_Version) if (bitsPerEntry == 0 && protocolversion >= Protocol18Handler.MC_1_18_1_Version)
{ {
// Palettes: Single valued - 1.18(1.18.1) and above // Palettes: Single valued - 1.18(1.18.1) and above
ushort value = (ushort)dataTypes.ReadNextVarInt(cache); ushort blockId = (ushort)dataTypes.ReadNextVarInt(cache);
Block block = new(blockId);
dataTypes.SkipNextVarInt(cache); // Data Array Length will be zero dataTypes.SkipNextVarInt(cache); // Data Array Length will be zero
// Empty chunks will not be stored // Empty chunks will not be stored
if (new Block(value).Type == Material.Air) if (block.Type == Material.Air)
return null; return null;
// Warning: If you need to support modification of block data, you need to create 4096 objects here
Chunk chunk = new();
for (int blockY = 0; blockY < Chunk.SizeY; blockY++) for (int blockY = 0; blockY < Chunk.SizeY; blockY++)
{
for (int blockZ = 0; blockZ < Chunk.SizeZ; blockZ++) for (int blockZ = 0; blockZ < Chunk.SizeZ; blockZ++)
{
for (int blockX = 0; blockX < Chunk.SizeX; blockX++) for (int blockX = 0; blockX < Chunk.SizeX; blockX++)
{ chunk.SetWithoutCheck(blockX, blockY, blockZ, block);
chunk[blockX, blockY, blockZ] = new Block(value); return chunk;
}
}
}
} }
else else
{ {
@ -72,44 +75,38 @@ namespace MinecraftClient.Protocol.Handlers
// EG, if bitsPerEntry = 5, valueMask = 00011111 in binary // EG, if bitsPerEntry = 5, valueMask = 00011111 in binary
uint valueMask = (uint)((1 << bitsPerEntry) - 1); uint valueMask = (uint)((1 << bitsPerEntry) - 1);
int paletteLength = 0; // Assume zero when length is absent int paletteLength = usePalette ? dataTypes.ReadNextVarInt(cache) : 0; // Assume zero when length is absent
if (usePalette) paletteLength = dataTypes.ReadNextVarInt(cache);
int[] palette = new int[paletteLength]; Span<uint> palette = paletteLength < 256 ? stackalloc uint[paletteLength] : new uint[paletteLength];
for (int i = 0; i < paletteLength; i++) for (int i = 0; i < paletteLength; i++)
palette[i] = dataTypes.ReadNextVarInt(cache); palette[i] = (uint)dataTypes.ReadNextVarInt(cache);
// Block IDs are packed in the array of 64-bits integers //// Block IDs are packed in the array of 64-bits integers
ulong[] dataArray = dataTypes.ReadNextULongArray(cache); dataTypes.SkipNextVarInt(cache); // Entry length
Span<byte> entryDataByte = stackalloc byte[8];
Span<long> entryDataLong = MemoryMarshal.Cast<byte, long>(entryDataByte); // Faster than MemoryMarshal.Read<long>
int longIndex = 0; Chunk chunk = new();
int startOffset = 0 - bitsPerEntry; int startOffset = 64; // Read the first data immediately
for (int blockY = 0; blockY < Chunk.SizeY; blockY++) for (int blockY = 0; blockY < Chunk.SizeY; blockY++)
{ {
for (int blockZ = 0; blockZ < Chunk.SizeZ; blockZ++) for (int blockZ = 0; blockZ < Chunk.SizeZ; blockZ++)
{ {
for (int blockX = 0; blockX < Chunk.SizeX; blockX++) for (int blockX = 0; blockX < Chunk.SizeX; blockX++)
{ {
// NOTICE: In the future a single ushort may not store the entire block id;
// the Block class may need to change if block state IDs go beyond 65535
ushort blockId;
// Calculate location of next block ID inside the array of Longs // Calculate location of next block ID inside the array of Longs
startOffset += bitsPerEntry; if ((startOffset += bitsPerEntry) > (64 - bitsPerEntry))
if ((startOffset + bitsPerEntry) > 64)
{ {
// In MC 1.16+, padding is applied to prevent overlapping between Longs: // In MC 1.16+, padding is applied to prevent overlapping between Longs:
// [ LONG INTEGER ][ LONG INTEGER ] // [ LONG INTEGER ][ LONG INTEGER ]
// [Block][Block][Block]XXXXX[Block][Block][Block]XXXXX // [Block][Block][Block]XXX[Block][Block][Block]XXX
// When overlapping, move forward to the beginning of the next Long // When overlapping, move forward to the beginning of the next Long
startOffset = 0; startOffset = 0;
longIndex++; dataTypes.ReadDataReverse(cache, entryDataByte); // read long
} }
// Extract Block ID uint blockId = (uint)(entryDataLong[0] >> startOffset) & valueMask;
blockId = (ushort)((dataArray[longIndex] >> startOffset) & valueMask);
// Map small IDs to actual larger block IDs // Map small IDs to actual larger block IDs
if (usePalette) if (usePalette)
@ -124,18 +121,21 @@ namespace MinecraftClient.Protocol.Handlers
blockNumber)); blockNumber));
} }
blockId = (ushort)palette[blockId]; blockId = palette[(int)blockId];
} }
// NOTICE: In the future a single ushort may not store the entire block id;
// the Block class may need to change if block state IDs go beyond 65535
Block block = new((ushort)blockId);
// We have our block, save the block into the chunk // We have our block, save the block into the chunk
chunk[blockX, blockY, blockZ] = new Block(blockId); chunk.SetWithoutCheck(blockX, blockY, blockZ, block);
} }
} }
} }
}
return chunk; return chunk;
} }
}
/// <summary> /// <summary>
/// Process chunk column data from the server and (un)load the chunk from the Minecraft world - 1.17 and above /// Process chunk column data from the server and (un)load the chunk from the Minecraft world - 1.17 and above
@ -144,9 +144,11 @@ namespace MinecraftClient.Protocol.Handlers
/// <param name="chunkZ">Chunk Z location</param> /// <param name="chunkZ">Chunk Z location</param>
/// <param name="verticalStripBitmask">Chunk mask for reading data, store in bitset, used in 1.17 and 1.17.1</param> /// <param name="verticalStripBitmask">Chunk mask for reading data, store in bitset, used in 1.17 and 1.17.1</param>
/// <param name="cache">Cache for reading chunk data</param> /// <param name="cache">Cache for reading chunk data</param>
public void ProcessChunkColumnData(int chunkX, int chunkZ, ulong[] verticalStripBitmask, Queue<byte> cache) /// <param name="cancellationToken">token to cancel the task</param>
[MethodImpl(MethodImplOptions.AggressiveOptimization)]
public void ProcessChunkColumnData(int chunkX, int chunkZ, ulong[]? verticalStripBitmask, Queue<byte> cache)
{ {
var world = handler.GetWorld(); World world = handler.GetWorld();
int chunkColumnSize = (World.GetDimension().height + 15) / 16; // Round up int chunkColumnSize = (World.GetDimension().height + 15) / 16; // Round up
@ -154,29 +156,40 @@ namespace MinecraftClient.Protocol.Handlers
{ {
// 1.17 and above chunk format // 1.17 and above chunk format
// Unloading chunks is handled by a separate packet // Unloading chunks is handled by a separate packet
for (int chunkY = 0; chunkY < chunkColumnSize; chunkY++) for (int chunkY = 0; chunkY < chunkColumnSize; chunkY++)
{ {
int lastChunkY;
if (protocolversion == Protocol18Handler.MC_1_17_Version || protocolversion == Protocol18Handler.MC_1_17_1_Version)
{
lastChunkY = 0;
for (int i = verticalStripBitmask!.Length - 1; i >= 0; --i)
{
if (verticalStripBitmask![i] != 0)
{
lastChunkY = (sizeof(ulong) * 8 * i) + (sizeof(ulong) * 8 - 1 - BitOperations.LeadingZeroCount(verticalStripBitmask![i]));
break;
}
}
}
else
{
lastChunkY = chunkColumnSize - 1;
}
// 1.18 and above always contains all chunk section in data // 1.18 and above always contains all chunk section in data
// 1.17 and 1.17.1 need vertical strip bitmask to know if the chunk section is included // 1.17 and 1.17.1 need vertical strip bitmask to know if the chunk section is included
if ((protocolversion >= Protocol18Handler.MC_1_18_1_Version) || if ((protocolversion >= Protocol18Handler.MC_1_18_1_Version) ||
(((protocolversion == Protocol18Handler.MC_1_17_Version) || ((verticalStripBitmask![chunkY / 64] & (1UL << (chunkY % 64))) != 0))
(protocolversion == Protocol18Handler.MC_1_17_1_Version)) &&
((verticalStripBitmask[chunkY / 64] & (1UL << (chunkY % 64))) != 0)))
{ {
// Non-air block count inside chunk section, for lighting purposes // Non-air block count inside chunk section, for lighting purposes
int blockCnt = dataTypes.ReadNextShort(cache); int blockCnt = dataTypes.ReadNextShort(cache);
// Read Block states (Type: Paletted Container) // Read Block states (Type: Paletted Container)
Chunk chunk = new Chunk(); Chunk? chunk = ReadBlockStatesField(cache);
ReadBlockStatesField(ref chunk, cache);
//We have our chunk, save the chunk into the world //We have our chunk, save the chunk into the world
handler.InvokeOnMainThread(() => world.StoreChunk(chunkX, chunkY, chunkZ, chunkColumnSize, chunk, chunkY == lastChunkY);
{
if (handler.GetWorld()[chunkX, chunkZ] == null)
handler.GetWorld()[chunkX, chunkZ] = new ChunkColumn(chunkColumnSize);
handler.GetWorld()[chunkX, chunkZ][chunkY] = chunk;
});
// Skip Read Biomes (Type: Paletted Container) - 1.18(1.18.1) and above // Skip Read Biomes (Type: Paletted Container) - 1.18(1.18.1) and above
if (protocolversion >= Protocol18Handler.MC_1_18_1_Version) if (protocolversion >= Protocol18Handler.MC_1_18_1_Version)
@ -197,7 +210,7 @@ namespace MinecraftClient.Protocol.Handlers
dataTypes.SkipNextVarInt(cache); // Palette dataTypes.SkipNextVarInt(cache); // Palette
} }
int dataArrayLength = dataTypes.ReadNextVarInt(cache); // Data Array Length int dataArrayLength = dataTypes.ReadNextVarInt(cache); // Data Array Length
dataTypes.ReadData(dataArrayLength * 8, cache); // Data Array dataTypes.DropData(dataArrayLength * 8, cache); // Data Array
} }
} }
} }
@ -205,7 +218,6 @@ namespace MinecraftClient.Protocol.Handlers
// Don't worry about skipping remaining data since there is no useful data afterwards in 1.9 // Don't worry about skipping remaining data since there is no useful data afterwards in 1.9
// (plus, it would require parsing the tile entity lists' NBT) // (plus, it would require parsing the tile entity lists' NBT)
} }
handler.GetWorld()[chunkX, chunkZ].FullyLoaded = true;
} }
/// <summary> /// <summary>
@ -219,14 +231,19 @@ namespace MinecraftClient.Protocol.Handlers
/// <param name="chunksContinuous">Are the chunk continuous</param> /// <param name="chunksContinuous">Are the chunk continuous</param>
/// <param name="currentDimension">Current dimension type (0 = overworld)</param> /// <param name="currentDimension">Current dimension type (0 = overworld)</param>
/// <param name="cache">Cache for reading chunk data</param> /// <param name="cache">Cache for reading chunk data</param>
/// <param name="cancellationToken">token to cancel the task</param>
[MethodImpl(MethodImplOptions.AggressiveOptimization)]
public void ProcessChunkColumnData(int chunkX, int chunkZ, ushort chunkMask, ushort chunkMask2, bool hasSkyLight, bool chunksContinuous, int currentDimension, Queue<byte> cache) public void ProcessChunkColumnData(int chunkX, int chunkZ, ushort chunkMask, ushort chunkMask2, bool hasSkyLight, bool chunksContinuous, int currentDimension, Queue<byte> cache)
{ {
World world = handler.GetWorld();
const int chunkColumnSize = 16; const int chunkColumnSize = 16;
if (protocolversion >= Protocol18Handler.MC_1_9_Version) if (protocolversion >= Protocol18Handler.MC_1_9_Version)
{ {
// 1.9 and above chunk format // 1.9 and above chunk format
// Unloading chunks is handled by a separate packet // Unloading chunks is handled by a separate packet
for (int chunkY = 0; chunkY < chunkColumnSize; chunkY++) int maxChunkY = sizeof(int) * 8 - 1 - BitOperations.LeadingZeroCount(chunkMask);
for (int chunkY = 0; chunkY <= maxChunkY; chunkY++)
{ {
if ((chunkMask & (1 << chunkY)) != 0) if ((chunkMask & (1 << chunkY)) != 0)
{ {
@ -337,30 +354,25 @@ namespace MinecraftClient.Protocol.Handlers
} }
// We have our block, save the block into the chunk // We have our block, save the block into the chunk
chunk[blockX, blockY, blockZ] = new Block(blockId); chunk.SetWithoutCheck(blockX, blockY, blockZ, new Block(blockId));
} }
} }
} }
} }
//We have our chunk, save the chunk into the world //We have our chunk, save the chunk into the world
handler.InvokeOnMainThread(() => world.StoreChunk(chunkX, chunkY, chunkZ, chunkColumnSize, chunk, chunkY == maxChunkY);
{
if (handler.GetWorld()[chunkX, chunkZ] == null)
handler.GetWorld()[chunkX, chunkZ] = new ChunkColumn();
handler.GetWorld()[chunkX, chunkZ][chunkY] = chunk;
});
//Pre-1.14 Lighting data //Pre-1.14 Lighting data
if (protocolversion < Protocol18Handler.MC_1_14_Version) if (protocolversion < Protocol18Handler.MC_1_14_Version)
{ {
//Skip block light //Skip block light
dataTypes.ReadData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ) / 2, cache); dataTypes.DropData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ) / 2, cache);
//Skip sky light //Skip sky light
if (currentDimension == 0) if (currentDimension == 0)
// Sky light is not sent in the nether or the end // Sky light is not sent in the nether or the end
dataTypes.ReadData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ) / 2, cache); dataTypes.DropData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ) / 2, cache);
} }
} }
} }
@ -376,13 +388,14 @@ namespace MinecraftClient.Protocol.Handlers
//Unload the entire chunk column //Unload the entire chunk column
handler.InvokeOnMainThread(() => handler.InvokeOnMainThread(() =>
{ {
handler.GetWorld()[chunkX, chunkZ] = null; world[chunkX, chunkZ] = null;
}); });
} }
else else
{ {
//Load chunk data from the server //Load chunk data from the server
for (int chunkY = 0; chunkY < chunkColumnSize; chunkY++) int maxChunkY = sizeof(int) * 8 - 1 - BitOperations.LeadingZeroCount(chunkMask);
for (int chunkY = 0; chunkY <= maxChunkY; chunkY++)
{ {
if ((chunkMask & (1 << chunkY)) != 0) if ((chunkMask & (1 << chunkY)) != 0)
{ {
@ -393,15 +406,10 @@ namespace MinecraftClient.Protocol.Handlers
for (int blockY = 0; blockY < Chunk.SizeY; blockY++) for (int blockY = 0; blockY < Chunk.SizeY; blockY++)
for (int blockZ = 0; blockZ < Chunk.SizeZ; blockZ++) for (int blockZ = 0; blockZ < Chunk.SizeZ; blockZ++)
for (int blockX = 0; blockX < Chunk.SizeX; blockX++) for (int blockX = 0; blockX < Chunk.SizeX; blockX++)
chunk[blockX, blockY, blockZ] = new Block(queue.Dequeue()); chunk.SetWithoutCheck(blockX, blockY, blockZ, new Block(queue.Dequeue()));
//We have our chunk, save the chunk into the world //We have our chunk, save the chunk into the world
handler.InvokeOnMainThread(() => world.StoreChunk(chunkX, chunkY, chunkZ, chunkColumnSize, chunk, chunkY == maxChunkY);
{
if (handler.GetWorld()[chunkX, chunkZ] == null)
handler.GetWorld()[chunkX, chunkZ] = new ChunkColumn();
handler.GetWorld()[chunkX, chunkZ][chunkY] = chunk;
});
} }
} }
@ -411,17 +419,17 @@ namespace MinecraftClient.Protocol.Handlers
if ((chunkMask & (1 << chunkY)) != 0) if ((chunkMask & (1 << chunkY)) != 0)
{ {
//Skip block light //Skip block light
dataTypes.ReadData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ) / 2, cache); dataTypes.DropData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ) / 2, cache);
//Skip sky light //Skip sky light
if (hasSkyLight) if (hasSkyLight)
dataTypes.ReadData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ) / 2, cache); dataTypes.DropData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ) / 2, cache);
} }
} }
//Skip biome metadata //Skip biome metadata
if (chunksContinuous) if (chunksContinuous)
dataTypes.ReadData(Chunk.SizeX * Chunk.SizeZ, cache); dataTypes.DropData(Chunk.SizeX * Chunk.SizeZ, cache);
} }
} }
else else
@ -432,7 +440,7 @@ namespace MinecraftClient.Protocol.Handlers
//Unload the entire chunk column //Unload the entire chunk column
handler.InvokeOnMainThread(() => handler.InvokeOnMainThread(() =>
{ {
handler.GetWorld()[chunkX, chunkZ] = null; world[chunkX, chunkZ] = null;
}); });
} }
else else
@ -460,15 +468,16 @@ namespace MinecraftClient.Protocol.Handlers
} }
//Skip data we don't need //Skip data we don't need
dataTypes.ReadData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ * sectionCount) / 2, cache); //Block light dataTypes.DropData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ * sectionCount) / 2, cache); //Block light
if (hasSkyLight) if (hasSkyLight)
dataTypes.ReadData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ * sectionCount) / 2, cache); //Sky light dataTypes.DropData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ * sectionCount) / 2, cache); //Sky light
dataTypes.ReadData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ * addDataSectionCount) / 2, cache); //BlockAdd dataTypes.DropData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ * addDataSectionCount) / 2, cache); //BlockAdd
if (chunksContinuous) if (chunksContinuous)
dataTypes.ReadData(Chunk.SizeX * Chunk.SizeZ, cache); //Biomes dataTypes.DropData(Chunk.SizeX * Chunk.SizeZ, cache); //Biomes
//Load chunk data //Load chunk data
for (int chunkY = 0; chunkY < chunkColumnSize; chunkY++) int maxChunkY = sizeof(int) * 8 - 1 - BitOperations.LeadingZeroCount(chunkMask);
for (int chunkY = 0; chunkY <= maxChunkY; chunkY++)
{ {
if ((chunkMask & (1 << chunkY)) != 0) if ((chunkMask & (1 << chunkY)) != 0)
{ {
@ -477,19 +486,13 @@ namespace MinecraftClient.Protocol.Handlers
for (int blockY = 0; blockY < Chunk.SizeY; blockY++) for (int blockY = 0; blockY < Chunk.SizeY; blockY++)
for (int blockZ = 0; blockZ < Chunk.SizeZ; blockZ++) for (int blockZ = 0; blockZ < Chunk.SizeZ; blockZ++)
for (int blockX = 0; blockX < Chunk.SizeX; blockX++) for (int blockX = 0; blockX < Chunk.SizeX; blockX++)
chunk[blockX, blockY, blockZ] = new Block(blockTypes.Dequeue(), blockMeta.Dequeue()); chunk.SetWithoutCheck(blockX, blockY, blockZ, new Block(blockTypes.Dequeue(), blockMeta.Dequeue()));
handler.InvokeOnMainThread(() => world.StoreChunk(chunkX, chunkY, chunkZ, chunkColumnSize, chunk, chunkY == maxChunkY);
{
if (handler.GetWorld()[chunkX, chunkZ] == null)
handler.GetWorld()[chunkX, chunkZ] = new ChunkColumn();
handler.GetWorld()[chunkX, chunkZ][chunkY] = chunk;
});
} }
} }
} }
} }
handler.GetWorld()[chunkX, chunkZ].FullyLoaded = true;
} }
} }
} }

4
MinecraftClient/Protocol/Handlers/SocketWrapper.cs
View file

@ -10,7 +10,7 @@ namespace MinecraftClient.Protocol.Handlers
class SocketWrapper class SocketWrapper
{ {
TcpClient c; TcpClient c;
IAesStream s; AesCfb8Stream s;
bool encrypted = false; bool encrypted = false;
/// <summary> /// <summary>
@ -49,7 +49,7 @@ namespace MinecraftClient.Protocol.Handlers
{ {
if (encrypted) if (encrypted)
throw new InvalidOperationException("Stream is already encrypted!?"); throw new InvalidOperationException("Stream is already encrypted!?");
this.s = CryptoHandler.getAesStream(c.GetStream(), secretKey); this.s = new AesCfb8Stream(c.GetStream(), secretKey);
this.encrypted = true; this.encrypted = true;
} }

1
MinecraftClient/Protocol/Handlers/ZlibUtils.cs
View file

@ -1,6 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.CompilerServices;
using System.Text; using System.Text;
using Ionic.Zlib; using Ionic.Zlib;

4
MinecraftClient/Protocol/IMinecraftCom.cs
View file

@ -22,7 +22,7 @@ namespace MinecraftClient.Protocol
/// Start the login procedure once connected to the server /// Start the login procedure once connected to the server
/// </summary> /// </summary>
/// <returns>True if login was successful</returns> /// <returns>True if login was successful</returns>
bool Login(PlayerKeyPair? playerKeyPair); bool Login(PlayerKeyPair? playerKeyPair, Session.SessionToken session);
/// <summary> /// <summary>
/// Disconnect from the server /// Disconnect from the server
@ -252,6 +252,6 @@ namespace MinecraftClient.Protocol
/// Get net read thread (main thread) ID /// Get net read thread (main thread) ID
/// </summary> /// </summary>
/// <returns>Net read thread ID</returns> /// <returns>Net read thread ID</returns>
int GetNetReadThreadId(); int GetNetMainThreadId();
} }
} }

3
MinecraftClient/Protocol/Message/ChatParser.cs
View file

@ -240,8 +240,7 @@ namespace MinecraftClient.Protocol
//Load the external dictionnary of translation rules or display an error message //Load the external dictionnary of translation rules or display an error message
if (File.Exists(Language_File)) if (File.Exists(Language_File))
{ {
string[] translations = File.ReadAllLines(Language_File); foreach (var line in File.ReadLines(Language_File))
foreach (string line in translations)
{ {
if (line.Length > 0) if (line.Length > 0)
{ {

2
MinecraftClient/Protocol/PlayerInfo.cs
View file

@ -148,7 +148,7 @@ namespace MinecraftClient.Protocol
if (this.precedingSignature != null && !this.precedingSignature.SequenceEqual(precedingSignature!)) if (this.precedingSignature != null && !this.precedingSignature.SequenceEqual(precedingSignature!))
return false; return false;
bool res = PublicKey.VerifyHeader(ref bodyDigest, ref headerSignature); bool res = PublicKey.VerifyHeader(Uuid, ref bodyDigest, ref headerSignature, ref precedingSignature);
this.lastMessageVerified = res; this.lastMessageVerified = res;
this.precedingSignature = headerSignature; this.precedingSignature = headerSignature;

2
MinecraftClient/Protocol/ProfileKey/KeyUtils.cs
View file

@ -15,7 +15,7 @@ namespace MinecraftClient.Protocol.Keys
private static readonly string certificates = "https://api.minecraftservices.com/player/certificates"; private static readonly string certificates = "https://api.minecraftservices.com/player/certificates";
public static PlayerKeyPair? GetKeys(string accessToken) public static PlayerKeyPair? GetNewProfileKeys(string accessToken)
{ {
ProxiedWebRequest.Response? response = null; ProxiedWebRequest.Response? response = null;
try try

6
MinecraftClient/Protocol/ProfileKey/KeysCache.cs
View file

@ -121,14 +121,14 @@ namespace MinecraftClient.Protocol.Keys
{ {
foreach (string line in FileMonitor.ReadAllLinesWithRetries(KeysCacheFilePlaintext)) foreach (string line in FileMonitor.ReadAllLinesWithRetries(KeysCacheFilePlaintext))
{ {
if (!line.Trim().StartsWith("#")) if (!line.TrimStart().StartsWith("#"))
{ {
int separatorIdx = line.IndexOf('='); int separatorIdx = line.IndexOf('=');
if (separatorIdx >= 1 && line.Length > separatorIdx + 1) if (separatorIdx >= 1 && line.Length > separatorIdx + 1)
{ {
string login = line.Substring(0, separatorIdx); string login = line[..separatorIdx];
string value = line.Substring(separatorIdx + 1); string value = line[(separatorIdx + 1)..];
try try
{ {
PlayerKeyPair playerKeyPair = PlayerKeyPair.FromString(value); PlayerKeyPair playerKeyPair = PlayerKeyPair.FromString(value);

10
MinecraftClient/Protocol/ProfileKey/PlayerKeyPair.cs
View file

@ -14,15 +14,23 @@ namespace MinecraftClient.Protocol.Keys
public DateTime RefreshedAfter; // Todo: add a timer public DateTime RefreshedAfter; // Todo: add a timer
private const string DataTimeFormat = "O"; private const string DataTimeFormat = "yyyy-MM-ddTHH:mm:ss.ffffffZ";
public PlayerKeyPair(PublicKey keyPublic, PrivateKey keyPrivate, string expiresAt, string refreshedAfter) public PlayerKeyPair(PublicKey keyPublic, PrivateKey keyPrivate, string expiresAt, string refreshedAfter)
{ {
PublicKey = keyPublic; PublicKey = keyPublic;
PrivateKey = keyPrivate; PrivateKey = keyPrivate;
try
{
ExpiresAt = DateTime.ParseExact(expiresAt, DataTimeFormat, System.Globalization.CultureInfo.InvariantCulture).ToUniversalTime();
RefreshedAfter = DateTime.ParseExact(refreshedAfter, DataTimeFormat, System.Globalization.CultureInfo.InvariantCulture).ToUniversalTime();
}
catch
{
ExpiresAt = DateTime.Parse(expiresAt).ToUniversalTime(); ExpiresAt = DateTime.Parse(expiresAt).ToUniversalTime();
RefreshedAfter = DateTime.Parse(refreshedAfter).ToUniversalTime(); RefreshedAfter = DateTime.Parse(refreshedAfter).ToUniversalTime();
} }
}
public bool NeedRefresh() public bool NeedRefresh()
{ {

7
MinecraftClient/Protocol/ProfileKey/PublicKey.cs
View file

@ -88,9 +88,12 @@ namespace MinecraftClient.Protocol.Keys
/// <param name="bodyDigest">Message body hash</param> /// <param name="bodyDigest">Message body hash</param>
/// <param name="signature">Message signature</param> /// <param name="signature">Message signature</param>
/// <returns>Is this message header vaild</returns> /// <returns>Is this message header vaild</returns>
public bool VerifyHeader(ref byte[] bodyDigest, ref byte[] signature) public bool VerifyHeader(Guid uuid, ref byte[] bodyDigest, ref byte[] signature, ref byte[]? precedingSignature)
{ {
return VerifyData(bodyDigest, signature);
byte[] msgSignData = KeyUtils.GetSignatureData(precedingSignature, uuid, bodyDigest);
return VerifyData(msgSignData, signature);
} }
} }

6
MinecraftClient/Protocol/Session/SessionCache.cs
View file

@ -148,7 +148,7 @@ namespace MinecraftClient.Protocol.Session
&& sessionItem.ContainsKey("username") && sessionItem.ContainsKey("username")
&& sessionItem.ContainsKey("uuid")) && sessionItem.ContainsKey("uuid"))
{ {
string login = sessionItem["username"].StringValue.ToLower(); string login = Settings.ToLowerIfNeed(sessionItem["username"].StringValue);
try try
{ {
SessionToken session = SessionToken.FromString(String.Join(",", SessionToken session = SessionToken.FromString(String.Join(",",
@ -214,7 +214,7 @@ namespace MinecraftClient.Protocol.Session
{ {
try try
{ {
string login = keyValue[0].ToLower(); string login = Settings.ToLowerIfNeed(keyValue[0]);
SessionToken session = SessionToken.FromString(keyValue[1]); SessionToken session = SessionToken.FromString(keyValue[1]);
if (Settings.DebugMessages) if (Settings.DebugMessages)
ConsoleIO.WriteLineFormatted(Translations.Get("cache.loaded", login, session.ID)); ConsoleIO.WriteLineFormatted(Translations.Get("cache.loaded", login, session.ID));
@ -252,7 +252,7 @@ namespace MinecraftClient.Protocol.Session
List<string> sessionCacheLines = new List<string>(); List<string> sessionCacheLines = new List<string>();
sessionCacheLines.Add("# Generated by MCC v" + Program.Version + " - Keep it secret & Edit at own risk!"); sessionCacheLines.Add("# Generated by MCC v" + Program.Version + " - Keep it secret & Edit at own risk!");
sessionCacheLines.Add("# Login=SessionID,PlayerName,UUID,ClientID"); sessionCacheLines.Add("# Login=SessionID,PlayerName,UUID,ClientID,RefreshToken,ServerIDhash,ServerPublicKey");
foreach (KeyValuePair<string, SessionToken> entry in sessions) foreach (KeyValuePair<string, SessionToken> entry in sessions)
sessionCacheLines.Add(entry.Key + '=' + entry.Value.ToString()); sessionCacheLines.Add(entry.Key + '=' + entry.Value.ToString());

39
MinecraftClient/Protocol/Session/SessionToken.cs
View file

@ -2,6 +2,7 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
using System.IO; using System.IO;
using System.Threading.Tasks;
namespace MinecraftClient.Protocol.Session namespace MinecraftClient.Protocol.Session
{ {
@ -15,6 +16,10 @@ namespace MinecraftClient.Protocol.Session
public string PlayerID { get; set; } public string PlayerID { get; set; }
public string ClientID { get; set; } public string ClientID { get; set; }
public string RefreshToken { get; set; } public string RefreshToken { get; set; }
public string ServerIDhash { get; set; }
public byte[]? ServerPublicKey { get; set; }
public Task<bool>? SessionPreCheckTask = null;
public SessionToken() public SessionToken()
{ {
@ -23,11 +28,26 @@ namespace MinecraftClient.Protocol.Session
PlayerID = String.Empty; PlayerID = String.Empty;
ClientID = String.Empty; ClientID = String.Empty;
RefreshToken = String.Empty; RefreshToken = String.Empty;
ServerIDhash = String.Empty;
ServerPublicKey = null;
}
public bool SessionPreCheck()
{
if (this.ID == string.Empty || this.PlayerID == String.Empty || this.ServerPublicKey == null)
return false;
if (Crypto.CryptoHandler.ClientAESPrivateKey == null)
Crypto.CryptoHandler.ClientAESPrivateKey = Crypto.CryptoHandler.GenerateAESPrivateKey();
string serverHash = Crypto.CryptoHandler.getServerHash(ServerIDhash, ServerPublicKey, Crypto.CryptoHandler.ClientAESPrivateKey);
if (ProtocolHandler.SessionCheck(PlayerID, ID, serverHash))
return true;
return false;
} }
public override string ToString() public override string ToString()
{ {
return String.Join(",", ID, PlayerName, PlayerID, ClientID, RefreshToken); return String.Join(",", ID, PlayerName, PlayerID, ClientID, RefreshToken, ServerIDhash,
(ServerPublicKey == null) ? String.Empty : Convert.ToBase64String(ServerPublicKey));
} }
public static SessionToken FromString(string tokenString) public static SessionToken FromString(string tokenString)
@ -46,6 +66,23 @@ namespace MinecraftClient.Protocol.Session
session.RefreshToken = fields[4]; session.RefreshToken = fields[4];
else else
session.RefreshToken = String.Empty; session.RefreshToken = String.Empty;
if (fields.Length > 5)
session.ServerIDhash = fields[5];
else
session.ServerIDhash = String.Empty;
if (fields.Length > 6)
{
try
{
session.ServerPublicKey = Convert.FromBase64String(fields[6]);
}
catch
{
session.ServerPublicKey = null;
}
}
else
session.ServerPublicKey = null;
Guid temp; Guid temp;
if (!JwtRegex.IsMatch(session.ID)) if (!JwtRegex.IsMatch(session.ID))

2
MinecraftClient/Resources/config/MinecraftClient.ini
View file

@ -45,7 +45,7 @@ exitonfailure=false # Disable pauses on error, for using MCC in n
scriptcache=true # Cache compiled scripts for faster load on low-end devices scriptcache=true # Cache compiled scripts for faster load on low-end devices
timestamps=false # Prepend timestamps to chat messages timestamps=false # Prepend timestamps to chat messages
autorespawn=false # Toggle auto respawn if client player was dead (make sure your spawn point is safe) autorespawn=false # Toggle auto respawn if client player was dead (make sure your spawn point is safe)
minecraftrealms=true # Enable support for joining Minecraft Realms worlds minecraftrealms=false # Enable support for joining Minecraft Realms worlds
moveheadwhilewalking=true # Enable head movement while walking to avoid anti-cheat triggers moveheadwhilewalking=true # Enable head movement while walking to avoid anti-cheat triggers
[Signature] [Signature]

151
MinecraftClient/Settings.cs
View file

@ -7,6 +7,9 @@ using System.Text.RegularExpressions;
using MinecraftClient.Protocol.Session; using MinecraftClient.Protocol.Session;
using MinecraftClient.Protocol; using MinecraftClient.Protocol;
using MinecraftClient.Mapping; using MinecraftClient.Mapping;
using System.Threading.Tasks;
using System.Collections.Concurrent;
using System.Runtime.CompilerServices;
namespace MinecraftClient namespace MinecraftClient
{ {
@ -255,31 +258,27 @@ namespace MinecraftClient
/// <param name="file">File to load</param> /// <param name="file">File to load</param>
public static void LoadFile(string file) public static void LoadFile(string file)
{ {
ConsoleIO.WriteLogLine("[Settings] Loading Settings from " + Path.GetFullPath(file)); Task.Factory.StartNew(() => ConsoleIO.WriteLogLine("[Settings] Loading Settings from " + Path.GetFullPath(file)));
if (File.Exists(file)) if (File.Exists(file))
{ {
try try
{ {
string[] Lines = File.ReadAllLines(file);
Section section = Section.Default; Section section = Section.Default;
foreach (string lineRAW in Lines) foreach (var lineRAW in File.ReadLines(file))
{ {
string line = section == Section.Main && lineRAW.ToLower().Trim().StartsWith("password") string line = lineRAW.Split('#')[0].Trim();
? lineRAW.Trim() //Do not strip # in passwords if (line.Length > 1)
: lineRAW.Split('#')[0].Trim();
if (line.Length > 0)
{ {
if (line[0] == '[' && line[line.Length - 1] == ']') if (line.Length > 2 && line[0] == '[' && line[^1] == ']')
{ section = GetSection(line[1..^1]);
section = GetSection(line.Substring(1, line.Length - 2).ToLower());
}
else else
{ {
string argName = line.Split('=')[0]; string argName = line.Split('=')[0];
if (section == Section.Main && argName == "password")
line = lineRAW.Trim(); //Do not strip # in passwords
if (line.Length > (argName.Length + 1)) if (line.Length > (argName.Length + 1))
{ {
string argValue = line.Substring(argName.Length + 1); string argValue = line[(argName.Length + 1)..];
LoadSingleSetting(section, argName, argValue); LoadSingleSetting(section, argName, argValue);
} }
} }
@ -351,16 +350,16 @@ namespace MinecraftClient
switch (section) switch (section)
{ {
case Section.Main: case Section.Main:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "login": Login = argValue; return true; case "login": Login = argValue; return true;
case "password": Password = argValue; return true; case "password": Password = argValue; return true;
case "type": AccountType = argValue == "mojang" case "type": AccountType = argValue == "mojang"
? ProtocolHandler.AccountType.Mojang ? ProtocolHandler.AccountType.Mojang
: ProtocolHandler.AccountType.Microsoft; return true; : ProtocolHandler.AccountType.Microsoft; return true;
case "method": LoginMethod = argValue.ToLower() == "browser" case "method":
? "browser" argValue = ToLowerIfNeed(argValue);
: "mcc"; return true; LoginMethod = argValue == "browser" ? "browser" : "mcc"; return true;
case "serverip": if (!SetServerIP(argValue)) ServerAliasTemp = argValue; return true; case "serverip": if (!SetServerIP(argValue)) ServerAliasTemp = argValue; return true;
case "singlecommand": SingleCommand = argValue; return true; case "singlecommand": SingleCommand = argValue; return true;
case "language": Language = argValue; return true; case "language": Language = argValue; return true;
@ -380,7 +379,7 @@ namespace MinecraftClient
case "entityhandling": EntityHandling = str2bool(argValue); return true; case "entityhandling": EntityHandling = str2bool(argValue); return true;
case "enableentityhandling": EntityHandling = str2bool(argValue); return true; case "enableentityhandling": EntityHandling = str2bool(argValue); return true;
case "inventoryhandling": InventoryHandling = str2bool(argValue); return true; case "inventoryhandling": InventoryHandling = str2bool(argValue); return true;
case "privatemsgscmdname": PrivateMsgsCmdName = argValue.ToLower().Trim(); return true; case "privatemsgscmdname": PrivateMsgsCmdName = ToLowerIfNeed(argValue).Trim(); return true;
case "autorespawn": AutoRespawn = str2bool(argValue); return true; case "autorespawn": AutoRespawn = str2bool(argValue); return true;
// Backward compatible so people can still enable debug with old config format // Backward compatible so people can still enable debug with old config format
case "debugmessages": DebugMessages = str2bool(argValue); return true; case "debugmessages": DebugMessages = str2bool(argValue); return true;
@ -389,8 +388,9 @@ namespace MinecraftClient
case "botowners": case "botowners":
Bots_Owners.Clear(); Bots_Owners.Clear();
string[] names = argValue.ToLower().Split(','); string lowerArgValue = ToLowerIfNeed(argValue);
if (!argValue.Contains(",") && argValue.ToLower().EndsWith(".txt") && File.Exists(argValue)) string[] names = lowerArgValue.Split(',');
if (!argValue.Contains(",") && lowerArgValue.EndsWith(".txt") && File.Exists(argValue))
names = File.ReadAllLines(argValue); names = File.ReadAllLines(argValue);
foreach (string name in names) foreach (string name in names)
if (!String.IsNullOrWhiteSpace(name)) if (!String.IsNullOrWhiteSpace(name))
@ -398,7 +398,8 @@ namespace MinecraftClient
return true; return true;
case "internalcmdchar": case "internalcmdchar":
switch (argValue.ToLower()) argValue = ToLowerIfNeed(argValue);
switch (argValue)
{ {
case "none": internalCmdChar = ' '; break; case "none": internalCmdChar = ' '; break;
case "slash": internalCmdChar = '/'; break; case "slash": internalCmdChar = '/'; break;
@ -426,7 +427,7 @@ namespace MinecraftClient
//Each line contains account data: 'Alias,Login,Password' //Each line contains account data: 'Alias,Login,Password'
string[] account_data = account_line.Split('#')[0].Trim().Split(','); string[] account_data = account_line.Split('#')[0].Trim().Split(',');
if (account_data.Length == 3) if (account_data.Length == 3)
Accounts[account_data[0].ToLower()] Accounts[ToLowerIfNeed(account_data[0])]
= new KeyValuePair<string, string>(account_data[1], account_data[2]); = new KeyValuePair<string, string>(account_data[1], account_data[2]);
} }
@ -446,7 +447,7 @@ namespace MinecraftClient
{ {
//Each line contains server data: 'Alias,Host:Port' //Each line contains server data: 'Alias,Host:Port'
string[] server_data = server_line.Split('#')[0].Trim().Split(','); string[] server_data = server_line.Split('#')[0].Trim().Split(',');
server_data[0] = server_data[0].ToLower(); server_data[0] = ToLowerIfNeed(server_data[0]);
if (server_data.Length == 2 if (server_data.Length == 2
&& server_data[0] != "localhost" && server_data[0] != "localhost"
&& !server_data[0].Contains('.') && !server_data[0].Contains('.')
@ -469,7 +470,7 @@ namespace MinecraftClient
return true; return true;
case "brandinfo": case "brandinfo":
switch (argValue.Trim().ToLower()) switch (ToLowerIfNeed(argValue.Trim()))
{ {
case "mcc": BrandInfo = MCCBrandInfo; break; case "mcc": BrandInfo = MCCBrandInfo; break;
case "vanilla": BrandInfo = "vanilla"; break; case "vanilla": BrandInfo = "vanilla"; break;
@ -478,7 +479,7 @@ namespace MinecraftClient
return true; return true;
case "resolvesrvrecords": case "resolvesrvrecords":
if (argValue.Trim().ToLower() == "fast") if (ToLowerIfNeed(argValue.Trim()) == "fast")
{ {
ResolveSrvRecords = true; ResolveSrvRecords = true;
ResolveSrvRecordsShortTimeout = true; ResolveSrvRecordsShortTimeout = true;
@ -491,7 +492,7 @@ namespace MinecraftClient
return true; return true;
case "mcforge": case "mcforge":
if (argValue.ToLower() == "auto") if (ToLowerIfNeed(argValue) == "auto")
{ {
ServerAutodetectForge = true; ServerAutodetectForge = true;
ServerForceForge = false; ServerForceForge = false;
@ -506,7 +507,7 @@ namespace MinecraftClient
break; break;
case Section.Signature: case Section.Signature:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "login_with_secure_profile": LoginWithSecureProfile = str2bool(argValue); return true; case "login_with_secure_profile": LoginWithSecureProfile = str2bool(argValue); return true;
case "sign_chat": SignChat = str2bool(argValue); return true; case "sign_chat": SignChat = str2bool(argValue); return true;
@ -521,7 +522,7 @@ namespace MinecraftClient
break; break;
case Section.Logging: case Section.Logging:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "debugmessages": DebugMessages = str2bool(argValue); return true; case "debugmessages": DebugMessages = str2bool(argValue); return true;
case "chatmessages": ChatMessages = str2bool(argValue); return true; case "chatmessages": ChatMessages = str2bool(argValue); return true;
@ -531,7 +532,7 @@ namespace MinecraftClient
case "chatfilter": ChatFilter = new Regex(argValue); return true; case "chatfilter": ChatFilter = new Regex(argValue); return true;
case "debugfilter": DebugFilter = new Regex(argValue); return true; case "debugfilter": DebugFilter = new Regex(argValue); return true;
case "filtermode": case "filtermode":
if (argValue.ToLower().StartsWith("white")) if (ToLowerIfNeed(argValue).StartsWith("white"))
FilterMode = FilterModeEnum.Whitelist; FilterMode = FilterModeEnum.Whitelist;
else else
FilterMode = FilterModeEnum.Blacklist; FilterMode = FilterModeEnum.Blacklist;
@ -544,7 +545,7 @@ namespace MinecraftClient
break; break;
case Section.Alerts: case Section.Alerts:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": Alerts_Enabled = str2bool(argValue); return true; case "enabled": Alerts_Enabled = str2bool(argValue); return true;
case "alertsfile": Alerts_MatchesFile = argValue; return true; case "alertsfile": Alerts_MatchesFile = argValue; return true;
@ -554,7 +555,7 @@ namespace MinecraftClient
break; break;
case Section.AntiAFK: case Section.AntiAFK:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": AntiAFK_Enabled = str2bool(argValue); return true; case "enabled": AntiAFK_Enabled = str2bool(argValue); return true;
case "delay": AntiAFK_Delay = str2int(argValue); return true; case "delay": AntiAFK_Delay = str2int(argValue); return true;
@ -563,7 +564,7 @@ namespace MinecraftClient
break; break;
case Section.AutoRelog: case Section.AutoRelog:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": AutoRelog_Enabled = str2bool(argValue); return true; case "enabled": AutoRelog_Enabled = str2bool(argValue); return true;
case "retries": AutoRelog_Retries = str2int(argValue); return true; case "retries": AutoRelog_Retries = str2int(argValue); return true;
@ -587,7 +588,7 @@ namespace MinecraftClient
break; break;
case Section.ChatLog: case Section.ChatLog:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": ChatLog_Enabled = str2bool(argValue); return true; case "enabled": ChatLog_Enabled = str2bool(argValue); return true;
case "timestamps": ChatLog_DateTime = str2bool(argValue); return true; case "timestamps": ChatLog_DateTime = str2bool(argValue); return true;
@ -597,7 +598,7 @@ namespace MinecraftClient
break; break;
case Section.Hangman: case Section.Hangman:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": Hangman_Enabled = str2bool(argValue); return true; case "enabled": Hangman_Enabled = str2bool(argValue); return true;
case "english": Hangman_English = str2bool(argValue); return true; case "english": Hangman_English = str2bool(argValue); return true;
@ -607,7 +608,7 @@ namespace MinecraftClient
break; break;
case Section.ScriptScheduler: case Section.ScriptScheduler:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": ScriptScheduler_Enabled = str2bool(argValue); return true; case "enabled": ScriptScheduler_Enabled = str2bool(argValue); return true;
case "tasksfile": ScriptScheduler_TasksFile = argValue; return true; case "tasksfile": ScriptScheduler_TasksFile = argValue; return true;
@ -615,7 +616,7 @@ namespace MinecraftClient
break; break;
case Section.RemoteControl: case Section.RemoteControl:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": RemoteCtrl_Enabled = str2bool(argValue); return true; case "enabled": RemoteCtrl_Enabled = str2bool(argValue); return true;
case "autotpaccept": RemoteCtrl_AutoTpaccept = str2bool(argValue); return true; case "autotpaccept": RemoteCtrl_AutoTpaccept = str2bool(argValue); return true;
@ -624,7 +625,7 @@ namespace MinecraftClient
break; break;
case Section.ChatFormat: case Section.ChatFormat:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "builtins": ChatFormat_Builtins = str2bool(argValue); return true; case "builtins": ChatFormat_Builtins = str2bool(argValue); return true;
case "public": ChatFormat_Public = new Regex(argValue); return true; case "public": ChatFormat_Public = new Regex(argValue); return true;
@ -634,15 +635,15 @@ namespace MinecraftClient
break; break;
case Section.Proxy: case Section.Proxy:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": case "enabled":
ProxyEnabledLogin = ProxyEnabledIngame = str2bool(argValue); ProxyEnabledLogin = ProxyEnabledIngame = str2bool(argValue);
if (argValue.Trim().ToLower() == "login") if (ToLowerIfNeed(argValue.Trim()) == "login")
ProxyEnabledLogin = true; ProxyEnabledLogin = true;
return true; return true;
case "type": case "type":
argValue = argValue.ToLower(); argValue = ToLowerIfNeed(argValue);
if (argValue == "http") { proxyType = Proxy.ProxyHandler.Type.HTTP; } if (argValue == "http") { proxyType = Proxy.ProxyHandler.Type.HTTP; }
else if (argValue == "socks4") { proxyType = Proxy.ProxyHandler.Type.SOCKS4; } else if (argValue == "socks4") { proxyType = Proxy.ProxyHandler.Type.SOCKS4; }
else if (argValue == "socks4a") { proxyType = Proxy.ProxyHandler.Type.SOCKS4a; } else if (argValue == "socks4a") { proxyType = Proxy.ProxyHandler.Type.SOCKS4a; }
@ -671,7 +672,7 @@ namespace MinecraftClient
return true; return true;
case Section.AutoRespond: case Section.AutoRespond:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": AutoRespond_Enabled = str2bool(argValue); return true; case "enabled": AutoRespond_Enabled = str2bool(argValue); return true;
case "matchesfile": AutoRespond_Matches = argValue; return true; case "matchesfile": AutoRespond_Matches = argValue; return true;
@ -679,13 +680,13 @@ namespace MinecraftClient
break; break;
case Section.AutoAttack: case Section.AutoAttack:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": AutoAttack_Enabled = str2bool(argValue); return true; case "enabled": AutoAttack_Enabled = str2bool(argValue); return true;
case "mode": AutoAttack_Mode = argValue.ToLower(); return true; case "mode": AutoAttack_Mode = ToLowerIfNeed(argValue); return true;
case "priority": AutoAttack_Priority = argValue.ToLower(); return true; case "priority": AutoAttack_Priority = ToLowerIfNeed(argValue); return true;
case "cooldownseconds": case "cooldownseconds":
if (argValue.ToLower() == "auto") if (ToLowerIfNeed(argValue) == "auto")
{ {
AutoAttack_OverrideAttackSpeed = false; AutoAttack_OverrideAttackSpeed = false;
} }
@ -701,7 +702,7 @@ namespace MinecraftClient
break; break;
case Section.AutoFishing: case Section.AutoFishing:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": AutoFishing_Enabled = str2bool(argValue); return true; case "enabled": AutoFishing_Enabled = str2bool(argValue); return true;
case "antidespawn": AutoFishing_Antidespawn = str2bool(argValue); return true; case "antidespawn": AutoFishing_Antidespawn = str2bool(argValue); return true;
@ -709,7 +710,7 @@ namespace MinecraftClient
break; break;
case Section.AutoEat: case Section.AutoEat:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": AutoEat_Enabled = str2bool(argValue); return true; case "enabled": AutoEat_Enabled = str2bool(argValue); return true;
case "threshold": AutoEat_hungerThreshold = str2int(argValue); return true; case "threshold": AutoEat_hungerThreshold = str2int(argValue); return true;
@ -717,7 +718,7 @@ namespace MinecraftClient
break; break;
case Section.AutoCraft: case Section.AutoCraft:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": AutoCraft_Enabled = str2bool(argValue); return true; case "enabled": AutoCraft_Enabled = str2bool(argValue); return true;
case "configfile": AutoCraft_configFile = argValue; return true; case "configfile": AutoCraft_configFile = argValue; return true;
@ -725,7 +726,7 @@ namespace MinecraftClient
break; break;
case Section.AutoDrop: case Section.AutoDrop:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": AutoDrop_Enabled = str2bool(argValue); return true; case "enabled": AutoDrop_Enabled = str2bool(argValue); return true;
case "mode": AutoDrop_Mode = argValue; return true; case "mode": AutoDrop_Mode = argValue; return true;
@ -734,12 +735,12 @@ namespace MinecraftClient
break; break;
case Section.MCSettings: case Section.MCSettings:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": MCSettings_Enabled = str2bool(argValue); return true; case "enabled": MCSettings_Enabled = str2bool(argValue); return true;
case "locale": MCSettings_Locale = argValue; return true; case "locale": MCSettings_Locale = argValue; return true;
case "difficulty": case "difficulty":
switch (argValue.ToLower()) switch (ToLowerIfNeed(argValue))
{ {
case "peaceful": MCSettings_Difficulty = 0; break; case "peaceful": MCSettings_Difficulty = 0; break;
case "easy": MCSettings_Difficulty = 1; break; case "easy": MCSettings_Difficulty = 1; break;
@ -755,7 +756,7 @@ namespace MinecraftClient
} }
else else
{ {
switch (argValue.ToLower()) switch (ToLowerIfNeed(argValue))
{ {
case "tiny": MCSettings_RenderDistance = 2; break; case "tiny": MCSettings_RenderDistance = 2; break;
case "short": MCSettings_RenderDistance = 4; break; case "short": MCSettings_RenderDistance = 4; break;
@ -765,7 +766,7 @@ namespace MinecraftClient
} }
return true; return true;
case "chatmode": case "chatmode":
switch (argValue.ToLower()) switch (ToLowerIfNeed(argValue))
{ {
case "enabled": MCSettings_ChatMode = 0; break; case "enabled": MCSettings_ChatMode = 0; break;
case "commands": MCSettings_ChatMode = 1; break; case "commands": MCSettings_ChatMode = 1; break;
@ -781,7 +782,7 @@ namespace MinecraftClient
case "skin_pants_right": MCSettings_Skin_Pants_Right = str2bool(argValue); return true; case "skin_pants_right": MCSettings_Skin_Pants_Right = str2bool(argValue); return true;
case "skin_hat": MCSettings_Skin_Hat = str2bool(argValue); return true; case "skin_hat": MCSettings_Skin_Hat = str2bool(argValue); return true;
case "main_hand": case "main_hand":
switch (argValue.ToLower()) switch (ToLowerIfNeed(argValue))
{ {
case "left": MCSettings_MainHand = 0; break; case "left": MCSettings_MainHand = 0; break;
case "right": MCSettings_MainHand = 1; break; case "right": MCSettings_MainHand = 1; break;
@ -791,7 +792,7 @@ namespace MinecraftClient
break; break;
case Section.Mailer: case Section.Mailer:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": Mailer_Enabled = str2bool(argValue); return true; case "enabled": Mailer_Enabled = str2bool(argValue); return true;
case "database": Mailer_DatabaseFile = argValue; return true; case "database": Mailer_DatabaseFile = argValue; return true;
@ -804,7 +805,7 @@ namespace MinecraftClient
break; break;
case Section.ReplayMod: case Section.ReplayMod:
switch (argName.ToLower()) switch (ToLowerIfNeed(argName))
{ {
case "enabled": ReplayMod_Enabled = str2bool(argValue); return true; case "enabled": ReplayMod_Enabled = str2bool(argValue); return true;
case "backupinterval": ReplayMod_BackupInterval = str2int(argValue); return true; case "backupinterval": ReplayMod_BackupInterval = str2int(argValue); return true;
@ -879,13 +880,43 @@ namespace MinecraftClient
return str == "true" || str == "1"; return str == "true" || str == "1";
} }
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public static string ToLowerIfNeed(string str)
{
const string lookupStringL =
"---------------------------------!-#$%&-()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[-]^_`abcdefghijklmnopqrstuvwxyz{|}~-";
bool needLower = false;
foreach (Char c in str)
{
if (Char.IsUpper(c))
{
needLower = true;
break;
}
}
if (needLower)
{
StringBuilder sb = new(str);
for (int i = 0; i < str.Length; ++i)
if (char.IsUpper(sb[i]))
sb[i] = lookupStringL[sb[i]];
return sb.ToString();
}
else
{
return str;
}
}
/// <summary> /// <summary>
/// Load login/password using an account alias /// Load login/password using an account alias
/// </summary> /// </summary>
/// <returns>True if the account was found and loaded</returns> /// <returns>True if the account was found and loaded</returns>
public static bool SetAccount(string accountAlias) public static bool SetAccount(string accountAlias)
{ {
accountAlias = accountAlias.ToLower(); accountAlias = Settings.ToLowerIfNeed(accountAlias);
if (Accounts.ContainsKey(accountAlias)) if (Accounts.ContainsKey(accountAlias))
{ {
Settings.Login = Accounts[accountAlias].Key; Settings.Login = Accounts[accountAlias].Key;
@ -901,7 +932,7 @@ namespace MinecraftClient
/// <returns>True if the server IP was valid and loaded, false otherwise</returns> /// <returns>True if the server IP was valid and loaded, false otherwise</returns>
public static bool SetServerIP(string server) public static bool SetServerIP(string server)
{ {
server = server.ToLower(); server = ToLowerIfNeed(server);
string[] sip = server.Split(':'); string[] sip = server.Split(':');
string host = sip[0]; string host = sip[0];
ushort port = 25565; ushort port = 25565;
@ -946,7 +977,7 @@ namespace MinecraftClient
{ {
lock (AppVars) lock (AppVars)
{ {
varName = new string(varName.TakeWhile(char.IsLetterOrDigit).ToArray()).ToLower(); varName = Settings.ToLowerIfNeed(new string(varName.TakeWhile(char.IsLetterOrDigit).ToArray()));
if (varName.Length > 0) if (varName.Length > 0)
{ {
AppVars[varName] = varData; AppVars[varName] = varData;
@ -998,7 +1029,7 @@ namespace MinecraftClient
if (varname_ok) if (varname_ok)
{ {
string varname = var_name.ToString(); string varname = var_name.ToString();
string varname_lower = varname.ToLower(); string varname_lower = Settings.ToLowerIfNeed(varname);
i = i + varname.Length + 1; i = i + varname.Length + 1;
switch (varname_lower) switch (varname_lower)