helpy4/Minecraft-Console-Client
1
0
Fork 0
mirror of https://github.com/MCCTeam/Minecraft-Console-Client synced 2025-10-14 21:22:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Basic support for minecraft 1.19 (#2084)

Browse source 
* merge commit from milutinke
* chat signature & encrypted login
* Bug fix :EncryptionResponse format error below 1.18.2
* Implemented chat command signature
* Chat message parsing and verification for 1.19
* Add signature settings
* Update Simplified Chinese Translation
* Clear up comments
* Fix wrong variable naming
* Bug fix: SignatureV2 Processing
This commit is contained in:
BruceChen 2022-08-15 23:55:44 +08:00 • committed by GitHub
parent d9f1a77ac2
commit a8bbb1ac76
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
55 changed files with 5218 additions and 1174 deletions
Download patch file Download diff file Expand all files Collapse all files

2
MinecraftClient/Command.cs
View file

@ -44,7 +44,7 @@ namespace MinecraftClient
/// <param name="command">The full command, eg: 'mycommand arg1 arg2'</param> /// <param name="command">The full command, eg: 'mycommand arg1 arg2'</param>
/// <param name="localVars">Local variables passed along with the command (may be null)</param> /// <param name="localVars">Local variables passed along with the command (may be null)</param>
/// <returns>A confirmation/error message, or "" if no message</returns> /// <returns>A confirmation/error message, or "" if no message</returns>
public abstract string Run(McClient handler, string command, Dictionary<string, object> localVars); public abstract string Run(McClient handler, string command, Dictionary<string, object>? localVars);
/// <summary> /// <summary>
/// Return a list of aliases for this command. /// Return a list of aliases for this command.

2
MinecraftClient/ConsoleIO.cs
View file

@ -58,7 +58,7 @@ namespace MinecraftClient
/// <summary> /// <summary>
/// Read a password from the standard input /// Read a password from the standard input
/// </summary> /// </summary>
public static string ReadPassword() public static string? ReadPassword()
{ {
if (BasicIO) if (BasicIO)
return Console.ReadLine(); return Console.ReadLine();

3
MinecraftClient/Crypto/CryptoHandler.cs
View file

@ -201,7 +201,8 @@ namespace MinecraftClient.Crypto
public static IAesStream getAesStream(Stream underlyingStream, byte[] AesKey) public static IAesStream getAesStream(Stream underlyingStream, byte[] AesKey)
{ {
return new Streams.RegularAesStream(underlyingStream, AesKey); // return new Streams.RegularAesStream(underlyingStream, AesKey);
return new Streams.MonoAesStream(underlyingStream, AesKey);
} }
} }
} }

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

@ -0,0 +1,855 @@
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 Normal file
View file

@ -0,0 +1,367 @@
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 Normal file
View file

@ -0,0 +1,113 @@
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 Normal file
View file

@ -0,0 +1,224 @@
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 Normal file
View file

@ -0,0 +1,25 @@
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 Normal file
View file

@ -0,0 +1,234 @@
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 Normal file
View file

@ -0,0 +1,28 @@
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 Normal file
View file

@ -0,0 +1,42 @@
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 Normal file
View file

@ -0,0 +1,36 @@
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 Normal file
View file

@ -0,0 +1,44 @@
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 Normal file
View file

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

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

@ -0,0 +1,43 @@
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 Normal file
View file

@ -0,0 +1,28 @@
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 Normal file
View file

@ -0,0 +1,266 @@
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 Normal file
View file

@ -0,0 +1,43 @@
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 Normal file
View file

@ -0,0 +1,108 @@
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;
}
}
}

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

@ -91,16 +91,16 @@ namespace MinecraftClient.Crypto.Streams
enc.Write(buffer, offset, count); enc.Write(buffer, offset, count);
} }
private RijndaelManaged GenerateAES(byte[] key) private static Aes GenerateAES(byte[] key)
{ {
RijndaelManaged cipher = new RijndaelManaged(); Aes aes = Aes.Create();
cipher.Mode = CipherMode.CFB; aes.Mode = CipherMode.CFB;
cipher.Padding = PaddingMode.None; aes.Padding = PaddingMode.None;
cipher.KeySize = 128; aes.KeySize = 128;
cipher.FeedbackSize = 8; aes.FeedbackSize = 8;
cipher.Key = key; aes.Key = key;
cipher.IV = key; aes.IV = key;
return cipher; return aes;
} }
} }
} }

4
MinecraftClient/Inventory/Item.cs
View file

@ -23,7 +23,7 @@ namespace MinecraftClient.Inventory
/// <summary> /// <summary>
/// Item Metadata /// Item Metadata
/// </summary> /// </summary>
public Dictionary<string, object> NBT; public Dictionary<string, object>? NBT;
/// <summary> /// <summary>
/// Create an item with ItemType, Count and Metadata /// Create an item with ItemType, Count and Metadata
@ -31,7 +31,7 @@ namespace MinecraftClient.Inventory
/// <param name="itemType">Type of the item</param> /// <param name="itemType">Type of the item</param>
/// <param name="count">Item Count</param> /// <param name="count">Item Count</param>
/// <param name="nbt">Item Metadata</param> /// <param name="nbt">Item Metadata</param>
public Item(ItemType itemType, int count, Dictionary<string, object> nbt) public Item(ItemType itemType, int count, Dictionary<string, object>? nbt)
{ {
this.Type = itemType; this.Type = itemType;
this.Count = count; this.Count = count;

14
MinecraftClient/Mapping/Entity.cs
View file

@ -22,7 +22,7 @@ namespace MinecraftClient.Mapping
/// <summary> /// <summary>
/// Nickname of the entity if it is a player. /// Nickname of the entity if it is a player.
/// </summary> /// </summary>
public string Name; public string? Name;
/// <summary> /// <summary>
/// CustomName of the entity. /// CustomName of the entity.
@ -66,6 +66,13 @@ namespace MinecraftClient.Mapping
/// <remarks>Untested</remarks> /// <remarks>Untested</remarks>
public float Pitch = 0; public float Pitch = 0;
/// <summary>
/// Used in Item Frame, Falling Block and Fishing Float.
/// See https://wiki.vg/Object_Data for details.
/// </summary>
/// <remarks>Untested</remarks>
public int ObjectData = -1;
/// <summary> /// <summary>
/// Health of the entity /// Health of the entity
/// </summary> /// </summary>
@ -113,7 +120,7 @@ namespace MinecraftClient.Mapping
/// <param name="ID">Entity ID</param> /// <param name="ID">Entity ID</param>
/// <param name="type">Entity Type Enum</param> /// <param name="type">Entity Type Enum</param>
/// <param name="location">Entity location</param> /// <param name="location">Entity location</param>
public Entity(int ID, EntityType type, Location location, byte yaw, byte pitch) public Entity(int ID, EntityType type, Location location, byte yaw, byte pitch, int objectData)
{ {
this.ID = ID; this.ID = ID;
this.Type = type; this.Type = type;
@ -123,6 +130,7 @@ namespace MinecraftClient.Mapping
this.Item = new Item(ItemType.Air, 0, null); this.Item = new Item(ItemType.Air, 0, null);
this.Yaw = yaw * (1 / 256) * 360; // to angle in 360 degree this.Yaw = yaw * (1 / 256) * 360; // to angle in 360 degree
this.Pitch = pitch * (1 / 256) * 360; this.Pitch = pitch * (1 / 256) * 360;
this.ObjectData = objectData;
} }
/// <summary> /// <summary>
@ -133,7 +141,7 @@ namespace MinecraftClient.Mapping
/// <param name="location">Entity location</param> /// <param name="location">Entity location</param>
/// <param name="uuid">Player uuid</param> /// <param name="uuid">Player uuid</param>
/// <param name="name">Player name</param> /// <param name="name">Player name</param>
public Entity(int ID, EntityType type, Location location, Guid uuid, string name) public Entity(int ID, EntityType type, Location location, Guid uuid, string? name)
{ {
this.ID = ID; this.ID = ID;
this.Type = type; this.Type = type;

256
MinecraftClient/McClient.cs
View file

@ -13,6 +13,7 @@ using MinecraftClient.Protocol.Handlers.Forge;
using MinecraftClient.Mapping; using MinecraftClient.Mapping;
using MinecraftClient.Inventory; using MinecraftClient.Inventory;
using MinecraftClient.Logger; using MinecraftClient.Logger;
using MinecraftClient.Protocol.Keys;
namespace MinecraftClient namespace MinecraftClient
{ {
@ -23,24 +24,24 @@ namespace MinecraftClient
{ {
public static int ReconnectionAttemptsLeft = 0; public static int ReconnectionAttemptsLeft = 0;
private static readonly List<string> cmd_names = new List<string>(); private static readonly List<string> cmd_names = new();
private static readonly Dictionary<string, Command> cmds = new Dictionary<string, Command>(); private static readonly Dictionary<string, Command> cmds = new();
private readonly Dictionary<Guid, string> onlinePlayers = new Dictionary<Guid, string>(); private readonly Dictionary<Guid, PlayerInfo> onlinePlayers = new();
private static bool commandsLoaded = false; private static bool commandsLoaded = false;
private Queue<string> chatQueue = new Queue<string>(); private Queue<string> chatQueue = new();
private static DateTime nextMessageSendTime = DateTime.MinValue; private static DateTime nextMessageSendTime = DateTime.MinValue;
private Queue<Action> threadTasks = new Queue<Action>(); private Queue<Action> threadTasks = new();
private object threadTasksLock = new object(); private object threadTasksLock = new();
private readonly List<ChatBot> bots = new List<ChatBot>(); private readonly List<ChatBot> bots = new();
private static readonly List<ChatBot> botsOnHold = new List<ChatBot>(); private static readonly List<ChatBot> botsOnHold = new();
private static Dictionary<int, Container> inventories = new Dictionary<int, Container>(); private static Dictionary<int, Container> inventories = new();
private readonly Dictionary<string, List<ChatBot>> registeredBotPluginChannels = new Dictionary<string, List<ChatBot>>(); private readonly Dictionary<string, List<ChatBot>> registeredBotPluginChannels = new();
private readonly List<string> registeredServerPluginChannels = new List<String>(); private readonly List<string> registeredServerPluginChannels = new();
private bool terrainAndMovementsEnabled; private bool terrainAndMovementsEnabled;
private bool terrainAndMovementsRequested = false; private bool terrainAndMovementsRequested = false;
@ -48,9 +49,9 @@ namespace MinecraftClient
private bool inventoryHandlingRequested = false; private bool inventoryHandlingRequested = false;
private bool entityHandlingEnabled; private bool entityHandlingEnabled;
private object locationLock = new object(); private object locationLock = new();
private bool locationReceived = false; private bool locationReceived = false;
private World world = new World(); 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;
@ -59,6 +60,7 @@ namespace MinecraftClient
private float playerYaw; private float playerYaw;
private float playerPitch; private float playerPitch;
private double motionY; private double motionY;
private int sequenceId; // User for player block synchronization (Aka. digging, placing blocks, etc..)
private string host; private string host;
private int port; private int port;
@ -66,10 +68,12 @@ namespace MinecraftClient
private string username; private string username;
private string uuid; private string uuid;
private string sessionid; private string sessionid;
private PlayerKeyPair playerKeyPair;
private DateTime lastKeepAlive; private DateTime lastKeepAlive;
private object lastKeepAliveLock = new object(); private object lastKeepAliveLock = new();
private int respawnTicks = 0; private int respawnTicks = 0;
private int gamemode = 0; private int gamemode = 0;
private bool isSupportPreviewsChat;
private int playerEntityID; private int playerEntityID;
@ -81,7 +85,7 @@ namespace MinecraftClient
private byte CurrentSlot = 0; private byte CurrentSlot = 0;
// Entity handling // Entity handling
private Dictionary<int, Entity> entities = new Dictionary<int, Entity>(); private Dictionary<int, Entity> entities = new();
// server TPS // server TPS
private long lastAge = 0; private long lastAge = 0;
@ -89,12 +93,9 @@ namespace MinecraftClient
private double serverTPS = 0; private double serverTPS = 0;
private double averageTPS = 20; private double averageTPS = 20;
private const int maxSamples = 5; private const int maxSamples = 5;
private List<double> tpsSamples = new List<double>(maxSamples); private List<double> tpsSamples = new(maxSamples);
private double sampleSum = 0; private double sampleSum = 0;
// players latency
private Dictionary<string, int> playersLatency = new Dictionary<string, int>();
// ChatBot OnNetworkPacket event // ChatBot OnNetworkPacket event
private bool networkPacketCaptureEnabled = false; private bool networkPacketCaptureEnabled = false;
@ -105,9 +106,11 @@ namespace MinecraftClient
public string GetSessionID() { return sessionid; } public string GetSessionID() { return sessionid; }
public Location GetCurrentLocation() { return location; } public Location GetCurrentLocation() { return location; }
public float GetYaw() { return playerYaw; } public float GetYaw() { return playerYaw; }
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 float GetHealth() { return playerHealth; } public float GetHealth() { return playerHealth; }
public int GetSaturation() { return playerFoodSaturation; } public int GetSaturation() { return playerFoodSaturation; }
public int GetLevel() { return playerLevel; } public int GetLevel() { return playerLevel; }
@ -122,7 +125,7 @@ namespace MinecraftClient
TcpClient client; TcpClient client;
IMinecraftCom handler; IMinecraftCom handler;
CancellationTokenSource cmdprompt = null; CancellationTokenSource? cmdprompt = null;
Tuple<Thread, CancellationTokenSource>? timeoutdetector = null; Tuple<Thread, CancellationTokenSource>? timeoutdetector = null;
public ILogger Log; public ILogger Log;
@ -136,9 +139,9 @@ namespace MinecraftClient
/// <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>
public McClient(string username, string uuid, string sessionID, int protocolversion, ForgeInfo forgeInfo, string server_ip, ushort port) public McClient(string username, string uuid, string sessionID, PlayerKeyPair playerKeyPair, int protocolversion, ForgeInfo forgeInfo, string server_ip, ushort port)
{ {
StartClient(username, uuid, sessionID, server_ip, port, protocolversion, forgeInfo, false, ""); StartClient(username, uuid, sessionID, playerKeyPair, server_ip, port, protocolversion, forgeInfo, false, "");
} }
/// <summary> /// <summary>
@ -151,9 +154,9 @@ namespace MinecraftClient
/// <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="command">The text or command to send.</param> /// <param name="command">The text or command to send.</param>
public McClient(string username, string uuid, string sessionID, string server_ip, ushort port, int protocolversion, ForgeInfo forgeInfo, string command) 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, server_ip, port, protocolversion, forgeInfo, true, command); StartClient(username, uuid, sessionID, playerKeyPair, server_ip, port, protocolversion, forgeInfo, true, command);
} }
/// <summary> /// <summary>
@ -167,7 +170,7 @@ namespace MinecraftClient
/// <param name="uuid">The player's UUID for online-mode authentication</param> /// <param name="uuid">The player's UUID for online-mode authentication</param>
/// <param name="singlecommand">If set to true, the client will send a single command and then disconnect from the server</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, string server_ip, ushort port, int protocolversion, ForgeInfo forgeInfo, bool singlecommand, string command) private void StartClient(string user, string uuid, string sessionID, PlayerKeyPair playerKeyPair, string server_ip, ushort port, int protocolversion, ForgeInfo forgeInfo, bool singlecommand, string command)
{ {
terrainAndMovementsEnabled = Settings.TerrainAndMovements; terrainAndMovementsEnabled = Settings.TerrainAndMovements;
inventoryHandlingEnabled = Settings.InventoryHandling; inventoryHandlingEnabled = Settings.InventoryHandling;
@ -180,6 +183,7 @@ namespace MinecraftClient
this.host = server_ip; this.host = server_ip;
this.port = port; this.port = port;
this.protocolversion = protocolversion; this.protocolversion = protocolversion;
this.playerKeyPair = playerKeyPair;
this.Log = Settings.LogToFile this.Log = Settings.LogToFile
? new FileLogLogger(Settings.ExpandVars(Settings.LogFile), Settings.PrependTimestamp) ? new FileLogLogger(Settings.ExpandVars(Settings.LogFile), Settings.PrependTimestamp)
@ -227,7 +231,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 (!singlecommand)
{ {
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";
@ -236,11 +240,11 @@ namespace MinecraftClient
try try
{ {
if (handler.Login()) if (handler.Login(this.playerKeyPair))
{ {
if (singlecommand) if (singlecommand)
{ {
handler.SendChatMessage(command); handler.SendChatMessage(command, playerKeyPair);
Log.Info(Translations.Get("mcc.single_cmd", command)); Log.Info(Translations.Get("mcc.single_cmd", command));
Thread.Sleep(5000); Thread.Sleep(5000);
handler.Disconnect(); handler.Disconnect();
@ -294,7 +298,7 @@ namespace MinecraftClient
ReconnectionAttemptsLeft--; ReconnectionAttemptsLeft--;
Program.Restart(); Program.Restart();
} }
else if (!singlecommand && Settings.interactiveMode) else if (!singlecommand && Settings.interactiveMode)
{ {
ConsoleInteractive.ConsoleReader.StopReadThread(); ConsoleInteractive.ConsoleReader.StopReadThread();
ConsoleInteractive.ConsoleReader.MessageReceived -= ConsoleReaderOnMessageReceived; ConsoleInteractive.ConsoleReader.MessageReceived -= ConsoleReaderOnMessageReceived;
@ -331,7 +335,7 @@ namespace MinecraftClient
if (chatQueue.Count > 0 && nextMessageSendTime < DateTime.Now) if (chatQueue.Count > 0 && nextMessageSendTime < DateTime.Now)
{ {
string text = chatQueue.Dequeue(); string text = chatQueue.Dequeue();
handler.SendChatMessage(text); handler.SendChatMessage(text, playerKeyPair);
nextMessageSendTime = DateTime.Now + Settings.messageCooldown; nextMessageSendTime = DateTime.Now + Settings.messageCooldown;
} }
} }
@ -402,23 +406,23 @@ namespace MinecraftClient
do do
{ {
Thread.Sleep(TimeSpan.FromSeconds(15)); Thread.Sleep(TimeSpan.FromSeconds(15));
if (((CancellationToken)o!).IsCancellationRequested) if (((CancellationToken)o!).IsCancellationRequested)
return; return;
lock (lastKeepAliveLock) lock (lastKeepAliveLock)
{ {
if (lastKeepAlive.AddSeconds(30) < DateTime.Now) if (lastKeepAlive.AddSeconds(30) < DateTime.Now)
{ {
if (((CancellationToken)o!).IsCancellationRequested) if (((CancellationToken)o!).IsCancellationRequested)
return; return;
OnConnectionLost(ChatBot.DisconnectReason.ConnectionLost, Translations.Get("error.timeout")); OnConnectionLost(ChatBot.DisconnectReason.ConnectionLost, Translations.Get("error.timeout"));
return; return;
} }
} }
} }
while (! ( (CancellationToken)o! ).IsCancellationRequested); while (!((CancellationToken)o!).IsCancellationRequested);
} }
/// <summary> /// <summary>
@ -448,13 +452,13 @@ namespace MinecraftClient
handler.Dispose(); handler.Dispose();
} }
if (cmdprompt != null) if (cmdprompt != null)
{ {
cmdprompt.Cancel(); cmdprompt.Cancel();
cmdprompt = null; cmdprompt = null;
} }
if (timeoutdetector != null) if (timeoutdetector != null)
{ {
timeoutdetector.Item2.Cancel(); timeoutdetector.Item2.Cancel();
timeoutdetector = null; timeoutdetector = null;
@ -521,7 +525,7 @@ namespace MinecraftClient
} }
} }
if (!will_restart) if (!will_restart)
{ {
ConsoleInteractive.ConsoleReader.StopReadThread(); ConsoleInteractive.ConsoleReader.StopReadThread();
ConsoleInteractive.ConsoleReader.MessageReceived -= ConsoleReaderOnMessageReceived; ConsoleInteractive.ConsoleReader.MessageReceived -= ConsoleReaderOnMessageReceived;
@ -533,23 +537,24 @@ namespace MinecraftClient
#endregion #endregion
#region Command prompt and internal MCC commands #region Command prompt and internal MCC commands
private void ConsoleReaderOnMessageReceived(object? sender, string e) private void ConsoleReaderOnMessageReceived(object? sender, string e)
{ {
if (client.Client == null) if (client.Client == null)
return; return;
if (client.Client.Connected) if (client.Client.Connected)
{ {
new Thread(() => { new Thread(() =>
{
InvokeOnMainThread(() => HandleCommandPromptText(e)); InvokeOnMainThread(() => HandleCommandPromptText(e));
}).Start(); }).Start();
} }
else else
return; return;
} }
/// <summary> /// <summary>
/// Allows the user to send chat messages, commands, and leave the server. /// Allows the user to send chat messages, commands, and leave the server.
/// Process text from the MCC command prompt on the main thread. /// Process text from the MCC command prompt on the main thread.
@ -640,7 +645,7 @@ namespace MinecraftClient
/// <param name="response_msg">May contain a confirmation or error message after processing the command, or "" otherwise.</param> /// <param name="response_msg">May contain a confirmation or error message after processing the command, or "" otherwise.</param>
/// <param name="localVars">Local variables passed along with the command</param> /// <param name="localVars">Local variables passed along with the command</param>
/// <returns>TRUE if the command was indeed an internal MCC command</returns> /// <returns>TRUE if the command was indeed an internal MCC command</returns>
public bool PerformInternalCommand(string command, ref string response_msg, Dictionary<string, object> localVars = null) public bool PerformInternalCommand(string command, ref string response_msg, Dictionary<string, object>? localVars = null)
{ {
/* Process the provided command */ /* Process the provided command */
@ -1012,6 +1017,9 @@ namespace MinecraftClient
/// <returns>All players latency</returns> /// <returns>All players latency</returns>
public Dictionary<string, int> GetPlayersLatency() public Dictionary<string, int> GetPlayersLatency()
{ {
Dictionary<string, int> playersLatency = new();
foreach (var player in onlinePlayers)
playersLatency.Add(player.Value.Name, player.Value.Ping);
return playersLatency; return playersLatency;
} }
@ -1047,7 +1055,11 @@ namespace MinecraftClient
{ {
lock (onlinePlayers) lock (onlinePlayers)
{ {
return onlinePlayers.Values.Distinct().ToArray(); string[] playerNames = new string[onlinePlayers.Count];
int idx = 0;
foreach (var player in onlinePlayers)
playerNames[idx++] = player.Value.Name;
return playerNames;
} }
} }
@ -1062,12 +1074,28 @@ namespace MinecraftClient
{ {
foreach (Guid key in onlinePlayers.Keys) foreach (Guid key in onlinePlayers.Keys)
{ {
uuid2Player.Add(key.ToString(), onlinePlayers[key]); uuid2Player.Add(key.ToString(), onlinePlayers[key].Name);
} }
} }
return uuid2Player; return uuid2Player;
} }
/// <summary>
/// Get player info from uuid
/// </summary>
/// <param name="uuid">Player's UUID</param>
/// <returns>Player info</returns>
public PlayerInfo? GetPlayerInfo(Guid uuid)
{
lock (onlinePlayers)
{
if (onlinePlayers.ContainsKey(uuid))
return onlinePlayers[uuid];
else
return null;
}
}
#endregion #endregion
#region Action methods: Perform an action on the Server #region Action methods: Perform an action on the Server
@ -1083,7 +1111,7 @@ namespace MinecraftClient
/// <param name="timeout">How long to wait until the path is evaluated (default: 5 seconds)</param> /// <param name="timeout">How long to wait until the path is evaluated (default: 5 seconds)</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>True if a path has been found</returns> /// <returns>True if a path has been found</returns>
public bool MoveTo(Location location, bool allowUnsafe = false, bool allowDirectTeleport = false, int maxOffset = 0, int minOffset = 0, TimeSpan? timeout=null) public bool MoveTo(Location location, bool allowUnsafe = false, bool allowDirectTeleport = false, int maxOffset = 0, int minOffset = 0, TimeSpan? timeout = null)
{ {
lock (locationLock) lock (locationLock)
{ {
@ -1244,7 +1272,7 @@ namespace MinecraftClient
/// <returns>TRUE if the item was successfully used</returns> /// <returns>TRUE if the item was successfully used</returns>
public bool UseItemOnHand() public bool UseItemOnHand()
{ {
return InvokeOnMainThread(() => handler.SendUseItem(0)); return InvokeOnMainThread(() => handler.SendUseItem(0, this.sequenceId));
} }
/// <summary> /// <summary>
@ -1548,7 +1576,7 @@ namespace MinecraftClient
/// <param name="count">Item count</param> /// <param name="count">Item count</param>
/// <param name="nbt">Item NBT</param> /// <param name="nbt">Item NBT</param>
/// <returns>TRUE if item given successfully</returns> /// <returns>TRUE if item given successfully</returns>
public bool DoCreativeGive(int slot, ItemType itemType, int count, Dictionary<string, object> nbt = null) public bool DoCreativeGive(int slot, ItemType itemType, int count, Dictionary<string, object>? nbt = null)
{ {
return InvokeOnMainThread(() => handler.SendCreativeInventoryAction(slot, itemType, count, nbt)); return InvokeOnMainThread(() => handler.SendCreativeInventoryAction(slot, itemType, count, nbt));
} }
@ -1634,7 +1662,7 @@ namespace MinecraftClient
/// <returns>TRUE if successfully placed</returns> /// <returns>TRUE if successfully placed</returns>
public bool PlaceBlock(Location location, Direction blockFace, Hand hand = Hand.MainHand) public bool PlaceBlock(Location location, Direction blockFace, Hand hand = Hand.MainHand)
{ {
return InvokeOnMainThread(() => handler.SendPlayerBlockPlacement((int)hand, location, blockFace)); return InvokeOnMainThread(() => handler.SendPlayerBlockPlacement((int)hand, location, blockFace, this.sequenceId));
} }
/// <summary> /// <summary>
@ -1660,9 +1688,9 @@ namespace MinecraftClient
// Send dig start and dig end, will need to wait for server response to know dig result // Send dig start and dig end, will need to wait for server response to know dig result
// See https://wiki.vg/How_to_Write_a_Client#Digging for more details // See https://wiki.vg/How_to_Write_a_Client#Digging for more details
return handler.SendPlayerDigging(0, location, blockFace) return handler.SendPlayerDigging(0, location, blockFace, this.sequenceId)
&& (!swingArms || DoAnimation((int)Hand.MainHand)) && (!swingArms || DoAnimation((int)Hand.MainHand))
&& handler.SendPlayerDigging(2, location, blockFace); && handler.SendPlayerDigging(2, location, blockFace, this.sequenceId);
} }
/// <summary> /// <summary>
@ -1724,7 +1752,7 @@ namespace MinecraftClient
/// Teleporting to other entityies is NOT implemented yet /// Teleporting to other entityies is NOT implemented yet
public bool Spectate(Entity entity) public bool Spectate(Entity entity)
{ {
if(entity.Type == EntityType.Player) if (entity.Type == EntityType.Player)
{ {
return SpectateByUUID(entity.UUID); return SpectateByUUID(entity.UUID);
} }
@ -1740,9 +1768,9 @@ namespace MinecraftClient
/// <param name="UUID">UUID of player/entity to teleport to</param> /// <param name="UUID">UUID of player/entity to teleport to</param>
public bool SpectateByUUID(Guid UUID) public bool SpectateByUUID(Guid UUID)
{ {
if(GetGamemode() == 3) if (GetGamemode() == 3)
{ {
if(InvokeRequired) if (InvokeRequired)
return InvokeOnMainThread(() => SpectateByUUID(UUID)); return InvokeOnMainThread(() => SpectateByUUID(UUID));
return handler.SendSpectate(UUID); return handler.SendSpectate(UUID);
} }
@ -1764,7 +1792,7 @@ namespace MinecraftClient
/// </example> /// </example>
/// <param name="action">Action to execute on each bot</param> /// <param name="action">Action to execute on each bot</param>
/// <param name="botList">Only fire the event for the specified bot list (default: all bots)</param> /// <param name="botList">Only fire the event for the specified bot list (default: all bots)</param>
private void DispatchBotEvent(Action<ChatBot> action, IEnumerable<ChatBot> botList = null) private void DispatchBotEvent(Action<ChatBot> action, IEnumerable<ChatBot>? botList = null)
{ {
ChatBot[] selectedBots; ChatBot[] selectedBots;
@ -1872,7 +1900,7 @@ namespace MinecraftClient
/// Check if the client is currently processing a Movement. /// Check if the client is currently processing a Movement.
/// </summary> /// </summary>
/// <returns>true if a movement is currently handled</returns> /// <returns>true if a movement is currently handled</returns>
public bool ClientIsMoving() public bool ClientIsMoving()
{ {
return terrainAndMovementsEnabled && locationReceived && ((steps != null && steps.Count > 0) || (path != null && path.Count > 0)); return terrainAndMovementsEnabled && locationReceived && ((steps != null && steps.Count > 0) || (path != null && path.Count > 0));
} }
@ -1969,31 +1997,40 @@ namespace MinecraftClient
} }
/// <summary> /// <summary>
/// Received some text from the server /// Received chat/system message from the server
/// </summary> /// </summary>
/// <param name="text">Text received</param> /// <param name="message">Message received</param>
/// <param name="isJson">TRUE if the text is JSON-Encoded</param> public void OnTextReceived(ChatMessage message)
public void OnTextReceived(string text, bool isJson)
{ {
UpdateKeepAlive(); UpdateKeepAlive();
List<string> links = new List<string>(); List<string> links = new();
string json = null; string messageText;
if (isJson) if (message.isJson)
{ {
json = text; if (message.isSignedChat)
text = ChatParser.ParseText(json, links); {
if (!Settings.ShowIllegalSignedChat && !message.isSystemChat && !(bool)message.isSignatureLegal!)
return;
messageText = ChatParser.ParseSignedChat(message, links);
}
else
messageText = ChatParser.ParseText(message.content, links);
}
else
{
messageText = message.content;
} }
Log.Chat(text); Log.Chat(messageText);
if (Settings.DisplayChatLinks) if (Settings.DisplayChatLinks)
foreach (string link in links) foreach (string link in links)
Log.Chat(Translations.Get("mcc.link", link)); Log.Chat(Translations.Get("mcc.link", link));
DispatchBotEvent(bot => bot.GetText(text)); DispatchBotEvent(bot => bot.GetText(messageText));
DispatchBotEvent(bot => bot.GetText(text, json)); DispatchBotEvent(bot => bot.GetText(messageText, message.content));
} }
/// <summary> /// <summary>
@ -2106,20 +2143,25 @@ namespace MinecraftClient
/// <summary> /// <summary>
/// Triggered when a new player joins the game /// Triggered when a new player joins the game
/// </summary> /// </summary>
/// <param name="uuid">UUID of the player</param> /// <param name="player">player info</param>
/// <param name="name">Name of the player</param> public void OnPlayerJoin(PlayerInfo player)
public void OnPlayerJoin(Guid uuid, string name)
{ {
//Ignore placeholders eg 0000tab# from TabListPlus //Ignore placeholders eg 0000tab# from TabListPlus
if (!ChatBot.IsValidName(name)) if (!ChatBot.IsValidName(player.Name))
return; return;
if (player.Name == username)
{
// 1.19+ offline server is possible to return different uuid
this.uuid = player.UUID.ToString().Replace("-", string.Empty);
}
lock (onlinePlayers) lock (onlinePlayers)
{ {
onlinePlayers[uuid] = name; onlinePlayers[player.UUID] = player;
} }
DispatchBotEvent(bot => bot.OnPlayerJoin(uuid, name)); DispatchBotEvent(bot => bot.OnPlayerJoin(player.UUID, player.Name));
} }
/// <summary> /// <summary>
@ -2128,13 +2170,13 @@ namespace MinecraftClient
/// <param name="uuid">UUID of the player</param> /// <param name="uuid">UUID of the player</param>
public void OnPlayerLeave(Guid uuid) public void OnPlayerLeave(Guid uuid)
{ {
string username = null; string? username = null;
lock (onlinePlayers) lock (onlinePlayers)
{ {
if (onlinePlayers.ContainsKey(uuid)) if (onlinePlayers.ContainsKey(uuid))
{ {
username = onlinePlayers[uuid]; username = onlinePlayers[uuid].Name;
onlinePlayers.Remove(uuid); onlinePlayers.Remove(uuid);
} }
} }
@ -2191,7 +2233,7 @@ namespace MinecraftClient
/// <summary> /// <summary>
/// Called when an entity effects /// Called when an entity effects
/// </summary> /// </summary>
public void OnEntityEffect(int entityid, Effects effect, int amplifier, int duration, byte flags) public void OnEntityEffect(int entityid, Effects effect, int amplifier, int duration, byte flags, bool hasFactorData, Dictionary<string, object>? factorCodec)
{ {
if (entities.ContainsKey(entityid)) if (entities.ContainsKey(entityid))
DispatchBotEvent(bot => bot.OnEntityEffect(entities[entityid], effect, amplifier, duration, flags)); DispatchBotEvent(bot => bot.OnEntityEffect(entities[entityid], effect, amplifier, duration, flags));
@ -2202,10 +2244,10 @@ namespace MinecraftClient
/// </summary> /// </summary>
public void OnSpawnPlayer(int entityID, Guid uuid, Location location, byte Yaw, byte Pitch) public void OnSpawnPlayer(int entityID, Guid uuid, Location location, byte Yaw, byte Pitch)
{ {
string playerName = null; string? playerName = null;
if (onlinePlayers.ContainsKey(uuid)) if (onlinePlayers.ContainsKey(uuid))
playerName = onlinePlayers[uuid]; playerName = onlinePlayers[uuid].Name;
Entity playerEntity = new Entity(entityID, EntityType.Player, location, uuid, playerName); Entity playerEntity = new(entityID, EntityType.Player, location, uuid, playerName);
OnSpawnEntity(playerEntity); OnSpawnEntity(playerEntity);
} }
@ -2243,7 +2285,7 @@ namespace MinecraftClient
// Further regular gamemode change events // Further regular gamemode change events
if (onlinePlayers.ContainsKey(uuid)) if (onlinePlayers.ContainsKey(uuid))
{ {
string playerName = onlinePlayers[uuid]; string playerName = onlinePlayers[uuid].Name;
if (playerName == this.username) if (playerName == this.username)
this.gamemode = gamemode; this.gamemode = gamemode;
DispatchBotEvent(bot => bot.OnGamemodeUpdate(playerName, uuid, gamemode)); DispatchBotEvent(bot => bot.OnGamemodeUpdate(playerName, uuid, gamemode));
@ -2429,11 +2471,11 @@ namespace MinecraftClient
/// <param name="latency">Latency</param> /// <param name="latency">Latency</param>
public void OnLatencyUpdate(Guid uuid, int latency) public void OnLatencyUpdate(Guid uuid, int latency)
{ {
string playerName = null;
if (onlinePlayers.ContainsKey(uuid)) if (onlinePlayers.ContainsKey(uuid))
{ {
playerName = onlinePlayers[uuid]; PlayerInfo player = onlinePlayers[uuid];
playersLatency[playerName] = latency; player.Ping = latency;
string playerName = player.Name;
foreach (KeyValuePair<int, Entity> ent in entities) foreach (KeyValuePair<int, Entity> ent in entities)
{ {
if (ent.Value.UUID == uuid && ent.Value.Name == playerName) if (ent.Value.UUID == uuid && ent.Value.Name == playerName)
@ -2599,6 +2641,52 @@ namespace MinecraftClient
DispatchBotEvent(bot => bot.OnEntityAnimation(entity, animation)); DispatchBotEvent(bot => bot.OnEntityAnimation(entity, animation));
} }
} }
/// <summary>
/// Will be called when a Synchronization sequence is recevied, this sequence need to be sent when breaking or placing blocks
/// </summary>
/// <param name="sequenceId">Sequence ID</param>
public void OnBlockChangeAck(int sequenceId)
{
this.sequenceId = sequenceId;
}
/// <summary>
/// This method is called when the protocol handler receives server data
/// </summary>
/// <param name="hasMotd">Indicates if the server has a motd message</param>
/// <param name="motd">Server MOTD message</param>
/// <param name="hasIcon">Indicates if the server has a an icon</param>
/// <param name="iconBase64">Server icon in Base 64 format</param>
/// <param name="previewsChat">Indicates if the server previews chat</param>
public void OnServerDataRecived(bool hasMotd, string motd, bool hasIcon, string iconBase64, bool previewsChat)
{
this.isSupportPreviewsChat = previewsChat;
}
/// <summary>
/// This method is called when the protocol handler receives "Set Display Chat Preview" packet
/// </summary>
/// <param name="previewsChat">Indicates if the server previews chat</param>
public void OnChatPreviewSettingUpdate(bool previewsChat)
{
this.isSupportPreviewsChat = previewsChat;
}
/// <summary>
/// This method is called when the protocol handler receives "Login Success" packet
/// </summary>
/// <param name="uuid">The player's UUID received from the server</param>
/// <param name="userName">The player's username received from the server</param>
/// <param name="playerProperty">Tuple<Name, Value, Signature(empty if there is no signature)></param>
public void OnLoginSuccess(Guid uuid, string userName, Tuple<string, string, string>[]? playerProperty)
{
//string UUID = uuid.ToString().Replace("-", String.Empty);
//Log.Info("now UUID = " + this.uuid);
//Log.Info("new UUID = " + UUID);
////handler.SetUserUUID(UUID);
}
#endregion #endregion
} }
} }

105
MinecraftClient/Program.cs
View file

@ -9,11 +9,14 @@ using System.Threading;
using MinecraftClient.Protocol.Handlers.Forge; using MinecraftClient.Protocol.Handlers.Forge;
using MinecraftClient.Protocol.Session; using MinecraftClient.Protocol.Session;
using MinecraftClient.WinAPI; using MinecraftClient.WinAPI;
using MinecraftClient.Protocol.Keys;
using System.Security.Cryptography;
using System.Xml.Linq;
namespace MinecraftClient namespace MinecraftClient
{ {
/// <summary> /// <summary>
/// Minecraft Console Client by the MCC Team (c) 2012-2021. /// Minecraft Console Client by the MCC Team (c) 2012-2022.
/// Allows to connect to any Minecraft server, send and receive text, automated scripts. /// Allows to connect to any Minecraft server, send and receive text, automated scripts.
/// This source code is released under the CDDL 1.0 License. /// This source code is released under the CDDL 1.0 License.
/// </summary> /// </summary>
@ -33,7 +36,7 @@ namespace MinecraftClient
public const string Version = MCHighestVersion; public const string Version = MCHighestVersion;
public const string MCLowestVersion = "1.4.6"; public const string MCLowestVersion = "1.4.6";
public const string MCHighestVersion = "1.18.2"; public const string MCHighestVersion = "1.19";
public static readonly string BuildInfo = null; public static readonly string BuildInfo = null;
private static Tuple<Thread, CancellationTokenSource>? offlinePrompt = null; private static Tuple<Thread, CancellationTokenSource>? offlinePrompt = null;
@ -55,14 +58,14 @@ namespace MinecraftClient
ConsoleIO.BasicIO = true; ConsoleIO.BasicIO = true;
args = args.Where(o => !Object.ReferenceEquals(o, args[args.Length - 1])).ToArray(); args = args.Where(o => !Object.ReferenceEquals(o, args[args.Length - 1])).ToArray();
} }
if (!ConsoleIO.BasicIO) if (!ConsoleIO.BasicIO)
ConsoleInteractive.ConsoleWriter.Init(); ConsoleInteractive.ConsoleWriter.Init();
ConsoleIO.WriteLine($"Minecraft Console Client v{Version} - for MC {MCLowestVersion} to {MCHighestVersion} - Github.com/MCCTeam"); ConsoleIO.WriteLine($"Minecraft Console Client v{Version} - for MC {MCLowestVersion} to {MCHighestVersion} - Github.com/MCCTeam");
//Build information to facilitate processing of bug reports //Build information to facilitate processing of bug reports
if (BuildInfo != null) if (BuildInfo != null)
{ {
ConsoleIO.WriteLineFormatted("§8" + BuildInfo); ConsoleIO.WriteLineFormatted("§8" + BuildInfo);
} }
@ -81,7 +84,8 @@ namespace MinecraftClient
if (WindowsVersion.WinMajorVersion >= 10) if (WindowsVersion.WinMajorVersion >= 10)
Console.OutputEncoding = Console.InputEncoding = Encoding.UTF8; Console.OutputEncoding = Console.InputEncoding = Encoding.UTF8;
} }
else { else
{
// Apply to all other operating systems. // Apply to all other operating systems.
Console.OutputEncoding = Console.InputEncoding = Encoding.UTF8; Console.OutputEncoding = Console.InputEncoding = Encoding.UTF8;
} }
@ -158,7 +162,7 @@ namespace MinecraftClient
ConsoleIO.WriteLine(ConsoleIO.BasicIO ? Translations.Get("mcc.login_basic_io") : Translations.Get("mcc.login")); ConsoleIO.WriteLine(ConsoleIO.BasicIO ? Translations.Get("mcc.login_basic_io") : Translations.Get("mcc.login"));
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.Login.ToLower()))
&& !useBrowser) && !useBrowser)
{ {
@ -166,14 +170,14 @@ namespace MinecraftClient
} }
// Setup exit cleaning code // Setup exit cleaning code
ExitCleanUp.Add(delegate () ExitCleanUp.Add(delegate ()
{ {
// Do NOT use Program.Exit() as creating new Thread cause program to freeze // Do NOT use Program.Exit() as creating new Thread cause program to freeze
if (client != null) { client.Disconnect(); ConsoleIO.Reset(); } if (client != null) { client.Disconnect(); ConsoleIO.Reset(); }
if (offlinePrompt != null) { offlinePrompt.Item2.Cancel(); offlinePrompt = null; ConsoleIO.Reset(); } if (offlinePrompt != null) { offlinePrompt.Item2.Cancel(); offlinePrompt = null; ConsoleIO.Reset(); }
if (Settings.playerHeadAsIcon) { ConsoleIcon.revertToMCCIcon(); } if (Settings.playerHeadAsIcon) { ConsoleIcon.revertToMCCIcon(); }
}); });
startupargs = args; startupargs = args;
InitializeClient(); InitializeClient();
@ -185,8 +189,9 @@ namespace MinecraftClient
private static void RequestPassword() private static void RequestPassword()
{ {
ConsoleIO.WriteLine(ConsoleIO.BasicIO ? Translations.Get("mcc.password_basic_io", Settings.Login) + "\n" : Translations.Get("mcc.password")); ConsoleIO.WriteLine(ConsoleIO.BasicIO ? Translations.Get("mcc.password_basic_io", Settings.Login) + "\n" : Translations.Get("mcc.password"));
Settings.Password = ConsoleIO.BasicIO ? Console.ReadLine() : ConsoleIO.ReadPassword(); string? password = ConsoleIO.BasicIO ? Console.ReadLine() : ConsoleIO.ReadPassword();
if (Settings.Password == "") { Settings.Password = "-"; } if (password == null || password == string.Empty) { password = "-"; }
Settings.Password = password;
} }
/// <summary> /// <summary>
@ -195,6 +200,7 @@ namespace MinecraftClient
private static void InitializeClient() private static void InitializeClient()
{ {
SessionToken session = new SessionToken(); SessionToken session = new SessionToken();
PlayerKeyPair? playerKeyPair = null;
ProtocolHandler.LoginResult result = ProtocolHandler.LoginResult.LoginRequired; ProtocolHandler.LoginResult result = ProtocolHandler.LoginResult.LoginRequired;
@ -220,8 +226,8 @@ namespace MinecraftClient
{ {
result = ProtocolHandler.MicrosoftLoginRefresh(session.RefreshToken, out session); result = ProtocolHandler.MicrosoftLoginRefresh(session.RefreshToken, out session);
} }
if (result != ProtocolHandler.LoginResult.Success if (result != ProtocolHandler.LoginResult.Success
&& Settings.Password == "" && Settings.Password == ""
&& Settings.AccountType == ProtocolHandler.AccountType.Mojang) && Settings.AccountType == ProtocolHandler.AccountType.Mojang)
RequestPassword(); RequestPassword();
} }
@ -242,6 +248,36 @@ namespace MinecraftClient
if (result == ProtocolHandler.LoginResult.Success) if (result == ProtocolHandler.LoginResult.Success)
{ {
if (Settings.AccountType == ProtocolHandler.AccountType.Microsoft && Settings.Password != "-" && Settings.LoginWithSecureProfile)
{
// Load cached profile key from disk if necessary
if (Settings.ProfileKeyCaching == CacheType.Disk)
{
bool cacheKeyLoaded = KeysCache.InitializeDiskCache();
if (Settings.DebugMessages)
Translations.WriteLineFormatted(cacheKeyLoaded ? "debug.keys_cache_ok" : "debug.keys_cache_fail");
}
if (Settings.ProfileKeyCaching != CacheType.None && KeysCache.Contains(Settings.Login.ToLower()))
{
playerKeyPair = KeysCache.Get(Settings.Login.ToLower());
if (playerKeyPair.NeedRefresh())
Translations.WriteLineFormatted("mcc.profile_key_invalid");
else
ConsoleIO.WriteLineFormatted(Translations.Get("mcc.profile_key_valid", session.PlayerName));
}
if (playerKeyPair == null || playerKeyPair.NeedRefresh())
{
Translations.WriteLineFormatted("mcc.fetching_key");
playerKeyPair = KeyUtils.GetKeys(session.ID);
if (Settings.ProfileKeyCaching != CacheType.None && playerKeyPair != null)
{
KeysCache.Store(Settings.Login.ToLower(), playerKeyPair);
}
}
}
Settings.Username = session.PlayerName; Settings.Username = session.PlayerName;
bool isRealms = false; bool isRealms = false;
@ -307,7 +343,7 @@ namespace MinecraftClient
//Get server version //Get server version
int protocolversion = 0; int protocolversion = 0;
ForgeInfo forgeInfo = null; ForgeInfo? forgeInfo = null;
if (Settings.ServerVersion != "" && Settings.ServerVersion.ToLower() != "auto") if (Settings.ServerVersion != "" && Settings.ServerVersion.ToLower() != "auto")
{ {
@ -362,9 +398,9 @@ namespace MinecraftClient
//Start the main TCP client //Start the main TCP client
if (Settings.SingleCommand != "") if (Settings.SingleCommand != "")
{ {
client = new McClient(session.PlayerName, session.PlayerID, session.ID, Settings.ServerIP, Settings.ServerPort, protocolversion, forgeInfo, Settings.SingleCommand); 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, protocolversion, forgeInfo, Settings.ServerIP, Settings.ServerPort); 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 != "")
@ -467,29 +503,30 @@ namespace MinecraftClient
} }
} }
if (offlinePrompt == null) if (offlinePrompt == null)
{ {
ConsoleInteractive.ConsoleReader.StopReadThread(); ConsoleInteractive.ConsoleReader.StopReadThread();
var cancellationTokenSource = new CancellationTokenSource(); var cancellationTokenSource = new CancellationTokenSource();
offlinePrompt = new(new Thread(new ThreadStart(delegate { offlinePrompt = new(new Thread(new ThreadStart(delegate
{
bool exitThread = false; bool exitThread = false;
string command = " "; string command = " ";
ConsoleIO.WriteLineFormatted(Translations.Get("mcc.disconnected", (Settings.internalCmdChar == ' ' ? "" : "" + Settings.internalCmdChar))); ConsoleIO.WriteLineFormatted(Translations.Get("mcc.disconnected", (Settings.internalCmdChar == ' ' ? "" : "" + Settings.internalCmdChar)));
Translations.WriteLineFormatted("mcc.press_exit"); Translations.WriteLineFormatted("mcc.press_exit");
while (!cancellationTokenSource.IsCancellationRequested) while (!cancellationTokenSource.IsCancellationRequested)
{ {
if (exitThread) if (exitThread)
return; return;
while (command.Length > 0) while (command.Length > 0)
{ {
if (cancellationTokenSource.IsCancellationRequested) if (cancellationTokenSource.IsCancellationRequested)
return; return;
command = ConsoleInteractive.ConsoleReader.RequestImmediateInput().Trim(); command = ConsoleInteractive.ConsoleReader.RequestImmediateInput().Trim();
if (command.Length > 0) if (command.Length > 0)
{ {
string message = ""; string message = "";
@ -497,29 +534,29 @@ namespace MinecraftClient
&& command[0] == Settings.internalCmdChar) && command[0] == Settings.internalCmdChar)
command = command.Substring(1); command = command.Substring(1);
if (command.StartsWith("reco")) if (command.StartsWith("reco"))
{ {
message = new Commands.Reco().Run(null, Settings.ExpandVars(command), null); message = new Commands.Reco().Run(null, Settings.ExpandVars(command), null);
if (message == "") if (message == "")
{ {
exitThread = true; exitThread = true;
break; break;
} }
} }
else if (command.StartsWith("connect")) else if (command.StartsWith("connect"))
{ {
message = new Commands.Connect().Run(null, Settings.ExpandVars(command), null); message = new Commands.Connect().Run(null, Settings.ExpandVars(command), null);
if (message == "") if (message == "")
{ {
exitThread = true; exitThread = true;
break; break;
} }
} }
else if (command.StartsWith("exit") || command.StartsWith("quit")) else if (command.StartsWith("exit") || command.StartsWith("quit"))
{ {
message = new Commands.Exit().Run(null, Settings.ExpandVars(command), null); message = new Commands.Exit().Run(null, Settings.ExpandVars(command), null);
} }
else if (command.StartsWith("help")) else if (command.StartsWith("help"))
{ {
ConsoleIO.WriteLineFormatted("§8MCC: " + ConsoleIO.WriteLineFormatted("§8MCC: " +
(Settings.internalCmdChar == ' ' (Settings.internalCmdChar == ' '
@ -539,12 +576,12 @@ namespace MinecraftClient
if (message != "") if (message != "")
ConsoleIO.WriteLineFormatted("§8MCC: " + message); ConsoleIO.WriteLineFormatted("§8MCC: " + message);
} }
else else
{ {
_ = new Commands.Exit().Run(null, Settings.ExpandVars(command), null); _ = new Commands.Exit().Run(null, Settings.ExpandVars(command), null);
} }
} }
if (exitThread) if (exitThread)
return; return;
} }

2
MinecraftClient/Properties/AssemblyInfo.cs
View file

@ -10,7 +10,7 @@ using System.Runtime.InteropServices;
//[assembly: AssemblyConfiguration("")] //[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("https://github.com/MCCTeam/Minecraft-Console-Client")] [assembly: AssemblyCompany("https://github.com/MCCTeam/Minecraft-Console-Client")]
[assembly: AssemblyProduct("MinecraftClient")] [assembly: AssemblyProduct("MinecraftClient")]
[assembly: AssemblyCopyright("Copyright © 2012-2021 The MCC Team")] [assembly: AssemblyCopyright("Copyright © 2012-2022 The MCC Team")]
[assembly: AssemblyTrademark("")] [assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")] [assembly: AssemblyCulture("")]

61
MinecraftClient/Protocol/ChatMessage.cs Normal file
View file

@ -0,0 +1,61 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace MinecraftClient.Protocol
{
public class ChatMessage
{
// in 1.19 and above, isSignedChat = true
public readonly bool isSignedChat;
public readonly string content;
public readonly bool isJson;
// 0: chat (chat box), 1: system message (chat box), 2: game info (above hotbar), 3: say command,
// 4: msg command, 5: team msg command, 6: emote command, 7: tellraw command
public readonly int chatType;
public readonly Guid senderUUID;
public readonly bool isSystemChat;
public readonly string? unsignedContent;
public readonly string? displayName;
public readonly string? teamName;
public readonly DateTime? timestamp;
public readonly bool? isSignatureLegal;
public ChatMessage(string content, bool isJson, int chatType, Guid senderUUID, string? unsignedContent, string displayName, string? teamName, long timestamp, bool isSignatureLegal)
{
this.isSignedChat = true;
this.isSystemChat = false;
this.content = content;
this.isJson = isJson;
this.chatType = chatType;
this.senderUUID = senderUUID;
this.unsignedContent = unsignedContent;
this.displayName = displayName;
this.teamName = teamName;
this.timestamp = DateTimeOffset.FromUnixTimeMilliseconds(timestamp).DateTime;
this.isSignatureLegal = isSignatureLegal;
}
public ChatMessage(string content, bool isJson, int chatType, Guid senderUUID, bool isSystemChat = false)
{
this.isSignedChat = isSystemChat;
this.isSystemChat = isSystemChat;
this.content = content;
this.isJson = isJson;
this.chatType = chatType;
this.senderUUID = senderUUID;
}
}
}

91
MinecraftClient/Protocol/ChatParser.cs
View file

@ -18,11 +18,98 @@ namespace MinecraftClient.Protocol
/// <param name="json">JSON serialized text</param> /// <param name="json">JSON serialized text</param>
/// <param name="links">Optional container for links from JSON serialized text</param> /// <param name="links">Optional container for links from JSON serialized text</param>
/// <returns>Returns the translated text</returns> /// <returns>Returns the translated text</returns>
public static string ParseText(string json, List<string> links = null) public static string ParseText(string json, List<string>? links = null)
{ {
return JSONData2String(Json.ParseJson(json), "", links); return JSONData2String(Json.ParseJson(json), "", links);
} }
/// <summary>
/// The main function to convert text from MC 1.9+ JSON to MC 1.5.2 formatted text
/// </summary>
/// <param name="message">Message received</param>
/// <param name="links">Optional container for links from JSON serialized text</param>
/// <returns>Returns the translated text</returns>
public static string ParseSignedChat(ChatMessage message, List<string>? links = null)
{
string content;
if (Settings.ShowModifiedChat && message.unsignedContent != null)
content = ChatParser.ParseText(message.unsignedContent, links);
else
content = ChatParser.ParseText(message.content, links);
string sender = message.displayName!;
string text;
List<string> usingData = new();
switch (message.chatType)
{
case 0: // chat (chat box)
usingData.Add(sender);
usingData.Add(content);
text = TranslateString("chat.type.text", usingData);
break;
case 1: // system message (chat box)
text = content;
break;
case 2: // game info (above hotbar)
text = content;
break;
case 3: // say command
usingData.Add(sender);
usingData.Add(content);
text = TranslateString("chat.type.announcement", usingData);
break;
case 4: // msg command
usingData.Add(sender);
usingData.Add(content);
text = TranslateString("commands.message.display.incoming", usingData);
break;
case 5: // team msg command (/teammsg)
usingData.Add(message.teamName!);
usingData.Add(sender);
usingData.Add(content);
text = TranslateString("chat.type.team.text", usingData);
break;
case 6: // emote command (/me)
usingData.Add(sender);
usingData.Add(content);
text = TranslateString("chat.type.emote", usingData);
break;
case 7: // tellraw command
text = content;
break;
default:
text = $"{sender}: {content}";
break;
}
string color = String.Empty;
if (message.isSystemChat)
{
if (Settings.MarkSystemMessage)
color = "§z §r "; // Custom: Background Gray
}
else
{
if ((bool)message.isSignatureLegal!)
{
if (Settings.ShowModifiedChat && message.unsignedContent != null)
{
if (Settings.MarkModifiedMsg)
color = "§x §r "; // Custom: Background Yellow
}
else
{
if (Settings.MarkLegallySignedMsg)
color = "§y §r "; // Custom: Background Green
}
}
else
{
if (Settings.MarkIllegallySignedMsg)
color = "§w §r "; // Custom: Background Red
}
}
return color + text;
}
/// <summary> /// <summary>
/// Get the classic color tag corresponding to a color name /// Get the classic color tag corresponding to a color name
/// </summary> /// </summary>
@ -212,7 +299,7 @@ namespace MinecraftClient.Protocol
/// <param name="colorcode">Allow parent color code to affect child elements (set to "" for function init)</param> /// <param name="colorcode">Allow parent color code to affect child elements (set to "" for function init)</param>
/// <param name="links">Container for links from JSON serialized text</param> /// <param name="links">Container for links from JSON serialized text</param>
/// <returns>returns the Minecraft-formatted string</returns> /// <returns>returns the Minecraft-formatted string</returns>
private static string JSONData2String(Json.JSONData data, string colorcode, List<string> links) private static string JSONData2String(Json.JSONData data, string colorcode, List<string>? links)
{ {
string extra_result = ""; string extra_result = "";
switch (data.Type) switch (data.Type)

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

@ -131,7 +131,7 @@ namespace MinecraftClient.Protocol.Handlers
{ {
ulong locEncoded = ReadNextULong(cache); ulong locEncoded = ReadNextULong(cache);
int x, y, z; int x, y, z;
if (protocolversion >= Protocol18Handler.MC114Version) if (protocolversion >= Protocol18Handler.MC_1_14_Version)
{ {
x = (int)(locEncoded >> 38); x = (int)(locEncoded >> 38);
y = (int)(locEncoded & 0xFFF); y = (int)(locEncoded & 0xFFF);
@ -186,7 +186,7 @@ namespace MinecraftClient.Protocol.Handlers
/// <returns>The byte array</returns> /// <returns>The byte array</returns>
public byte[] ReadNextByteArray(Queue<byte> cache) public byte[] ReadNextByteArray(Queue<byte> cache)
{ {
int len = protocolversion >= Protocol18Handler.MC18Version int len = protocolversion >= Protocol18Handler.MC_1_8_Version
? ReadNextVarInt(cache) ? ReadNextVarInt(cache)
: ReadNextShort(cache); : ReadNextShort(cache);
return ReadData(len, cache); return ReadData(len, cache);
@ -349,7 +349,7 @@ namespace MinecraftClient.Protocol.Handlers
public Item ReadNextItemSlot(Queue<byte> cache, ItemPalette itemPalette) public Item ReadNextItemSlot(Queue<byte> cache, ItemPalette itemPalette)
{ {
List<byte> slotData = new List<byte>(); List<byte> slotData = new List<byte>();
if (protocolversion > Protocol18Handler.MC113Version) if (protocolversion > Protocol18Handler.MC_1_13_Version)
{ {
// MC 1.13 and greater // MC 1.13 and greater
bool itemPresent = ReadNextBool(cache); bool itemPresent = ReadNextBool(cache);
@ -385,15 +385,13 @@ namespace MinecraftClient.Protocol.Handlers
{ {
int entityID = ReadNextVarInt(cache); int entityID = ReadNextVarInt(cache);
Guid entityUUID = Guid.Empty; Guid entityUUID = Guid.Empty;
if (protocolversion > Protocol18Handler.MC_1_8_Version)
if (protocolversion > Protocol18Handler.MC18Version)
{ {
entityUUID = ReadNextUUID(cache); entityUUID = ReadNextUUID(cache);
} }
EntityType entityType; EntityType entityType;
// Entity type data type change from byte to varint after 1.14 // Entity type data type change from byte to varint after 1.14
if (protocolversion > Protocol18Handler.MC113Version) if (protocolversion > Protocol18Handler.MC_1_13_Version)
{ {
entityType = entityPalette.FromId(ReadNextVarInt(cache), living); entityType = entityPalette.FromId(ReadNextVarInt(cache), living);
} }
@ -401,27 +399,35 @@ namespace MinecraftClient.Protocol.Handlers
{ {
entityType = entityPalette.FromId(ReadNextByte(cache), living); entityType = entityPalette.FromId(ReadNextByte(cache), living);
} }
Double entityX = ReadNextDouble(cache); Double entityX = ReadNextDouble(cache);
Double entityY = ReadNextDouble(cache); Double entityY = ReadNextDouble(cache);
Double entityZ = ReadNextDouble(cache); Double entityZ = ReadNextDouble(cache);
byte entityYaw = ReadNextByte(cache); byte entityYaw = ReadNextByte(cache);
byte entityPitch = ReadNextByte(cache); byte entityPitch = ReadNextByte(cache);
int metadata = -1;
if (living) if (living)
{ {
entityPitch = ReadNextByte(cache); if (protocolversion >= Protocol18Handler.MC_1_18_2_Version)
entityYaw = ReadNextByte(cache);
else
entityPitch = ReadNextByte(cache);
} }
else else
{ {
int metadata = ReadNextInt(cache); if (protocolversion >= Protocol18Handler.MC_1_19_Version)
{
metadata = ReadNextVarInt(cache);
entityYaw = ReadNextByte(cache);
}
else
metadata = ReadNextInt(cache);
} }
short velocityX = ReadNextShort(cache); short velocityX = ReadNextShort(cache);
short velocityY = ReadNextShort(cache); short velocityY = ReadNextShort(cache);
short velocityZ = ReadNextShort(cache); short velocityZ = ReadNextShort(cache);
return new Entity(entityID, entityType, new Location(entityX, entityY, entityZ), entityYaw, entityPitch, metadata);
return new Entity(entityID, entityType, new Location(entityX, entityY, entityZ), entityYaw, entityPitch);
} }
/// <summary> /// <summary>
@ -527,7 +533,7 @@ namespace MinecraftClient.Protocol.Handlers
// Increase type ID by 1 if // Increase type ID by 1 if
// - below 1.13 // - below 1.13
// - type ID larger than 4 // - type ID larger than 4
if (protocolversion < Protocol18Handler.MC113Version) if (protocolversion < Protocol18Handler.MC_1_13_Version)
{ {
if (type > 4) if (type > 4)
{ {
@ -949,7 +955,7 @@ namespace MinecraftClient.Protocol.Handlers
/// <returns>Array ready to send</returns> /// <returns>Array ready to send</returns>
public byte[] GetArray(byte[] array) public byte[] GetArray(byte[] array)
{ {
if (protocolversion < Protocol18Handler.MC18Version) if (protocolversion < Protocol18Handler.MC_1_8_Version)
{ {
byte[] length = BitConverter.GetBytes((short)array.Length); byte[] length = BitConverter.GetBytes((short)array.Length);
Array.Reverse(length); //Endianness Array.Reverse(length); //Endianness
@ -982,7 +988,7 @@ namespace MinecraftClient.Protocol.Handlers
public byte[] GetLocation(Location location) public byte[] GetLocation(Location location)
{ {
byte[] locationBytes; byte[] locationBytes;
if (protocolversion >= Protocol18Handler.MC114Version) if (protocolversion >= Protocol18Handler.MC_1_14_Version)
{ {
locationBytes = BitConverter.GetBytes(((((ulong)location.X) & 0x3FFFFFF) << 38) | ((((ulong)location.Z) & 0x3FFFFFF) << 12) | (((ulong)location.Y) & 0xFFF)); locationBytes = BitConverter.GetBytes(((((ulong)location.X) & 0x3FFFFFF) << 38) | ((((ulong)location.Z) & 0x3FFFFFF) << 12) | (((ulong)location.Y) & 0xFFF));
} }
@ -1000,7 +1006,7 @@ namespace MinecraftClient.Protocol.Handlers
public byte[] GetItemSlot(Item item, ItemPalette itemPalette) public byte[] GetItemSlot(Item item, ItemPalette itemPalette)
{ {
List<byte> slotData = new List<byte>(); List<byte> slotData = new List<byte>();
if (protocolversion > Protocol18Handler.MC113Version) if (protocolversion > Protocol18Handler.MC_1_13_Version)
{ {
// MC 1.13 and greater // MC 1.13 and greater
if (item == null || item.IsEmpty) if (item == null || item.IsEmpty)
@ -1069,5 +1075,10 @@ namespace MinecraftClient.Protocol.Handlers
result.AddRange(array); result.AddRange(array);
return result.ToArray(); return result.ToArray();
} }
public string ByteArrayToString(byte[] bytes)
{
return BitConverter.ToString(bytes).Replace("-", " ");
}
} }
} }

180
MinecraftClient/Protocol/Handlers/PacketPalettes/PacketPalette119.cs Normal file
View file

@ -0,0 +1,180 @@
using System.Collections.Generic;
namespace MinecraftClient.Protocol.Handlers.PacketPalettes
{
public class PacketPalette119 : PacketTypePalette
{
private Dictionary<int, PacketTypesIn> typeIn = new Dictionary<int, PacketTypesIn>()
{
{ 0x00, PacketTypesIn.SpawnEntity }, // Changed in 1.19 (Wiki name: Spawn Entity) - DONE
{ 0x01, PacketTypesIn.SpawnExperienceOrb }, //(Wiki name: Spawn Exeprience Orb)
{ 0x02, PacketTypesIn.SpawnPlayer },
{ 0x03, PacketTypesIn.EntityAnimation }, //(Wiki name: Entity Animation (clientbound))
{ 0x04, PacketTypesIn.Statistics }, //(Wiki name: Award Statistics)
{ 0x05, PacketTypesIn.BlockChangedAck }, //Added 1.19 (Wiki name: Acknowledge Block Change) - DONE
{ 0x06, PacketTypesIn.BlockBreakAnimation }, //(Wiki name: Set Block Destroy Stage)
{ 0x07, PacketTypesIn.BlockEntityData },
{ 0x08, PacketTypesIn.BlockAction },
{ 0x09, PacketTypesIn.BlockChange }, //(Wiki name: Block Update)
{ 0x0A, PacketTypesIn.BossBar },
{ 0x0B, PacketTypesIn.ServerDifficulty }, // (Wiki name: Change Difficulty)
{ 0x0C, PacketTypesIn.ChatPreview }, // Added 1.19
{ 0x0D, PacketTypesIn.ClearTiles },
{ 0x0E, PacketTypesIn.TabComplete }, // (Wiki name: Command Suggestions Response)
{ 0x0F, PacketTypesIn.DeclareCommands }, // (Wiki name: Commands)
{ 0x10, PacketTypesIn.CloseWindow }, // (Wiki name: Close Container (clientbound))
{ 0x11, PacketTypesIn.WindowItems }, // (Wiki name: Set Container Content)
{ 0x12, PacketTypesIn.WindowProperty }, // (Wiki name: Set Container Property)
{ 0x13, PacketTypesIn.SetSlot }, // (Wiki name: Set Container Slot)
{ 0x14, PacketTypesIn.SetCooldown },
{ 0x15, PacketTypesIn.PluginMessage }, // (Wiki name: Plugin Message (clientbound))
{ 0x16, PacketTypesIn.NamedSoundEffect }, // Changed in 1.19 (Added "Speed" field) (Wiki name: Custom Sound Effect) - DONE (No need to be implemented)
{ 0x17, PacketTypesIn.Disconnect },
{ 0x18, PacketTypesIn.EntityStatus }, // (Wiki name: Entity Event)
{ 0x19, PacketTypesIn.Explosion }, // Changed in 1.19 (Location fields are now Double instead of Float) (Wiki name: Explosion) - DONE
{ 0x1A, PacketTypesIn.UnloadChunk }, // (Wiki name: Forget Chunk)
{ 0x1B, PacketTypesIn.ChangeGameState }, // (Wiki name: Game Event)
{ 0x1C, PacketTypesIn.OpenHorseWindow }, // (Wiki name: Horse Screen Open)
{ 0x1D, PacketTypesIn.InitializeWorldBorder },
{ 0x1E, PacketTypesIn.KeepAlive },
{ 0x1F, PacketTypesIn.ChunkData },
{ 0x20, PacketTypesIn.Effect }, // (Wiki name: Level Event)
{ 0x21, PacketTypesIn.Particle }, // Changed in 1.19 ("Particle Data" field is now "Max Speed", it's the same Float data type) (Wiki name: Level Particle) - DONE (No need to be implemented)
{ 0x22, PacketTypesIn.UpdateLight }, // (Wiki name: Light Update)
{ 0x23, PacketTypesIn.JoinGame }, // Changed in 1.19 (lot's of changes) (Wiki name: Login (play)) - DONE
{ 0x24, PacketTypesIn.MapData }, // (Wiki name: Map Item Data)
{ 0x25, PacketTypesIn.TradeList }, // (Wiki name: Merchant Offers)
{ 0x26, PacketTypesIn.EntityPosition }, // (Wiki name: Move Entity Position)
{ 0x27, PacketTypesIn.EntityPositionAndRotation }, // (Wiki name: Move Entity Position and Rotation)
{ 0x28, PacketTypesIn.EntityRotation }, // (Wiki name: Move Entity Rotation)
{ 0x29, PacketTypesIn.VehicleMove }, // (Wiki name: Move Vehicle)
{ 0x2A, PacketTypesIn.OpenBook },
{ 0x2B, PacketTypesIn.OpenWindow }, // (Wiki name: Open Screen)
{ 0x2C, PacketTypesIn.OpenSignEditor },
{ 0x2D, PacketTypesIn.Ping }, // (Wiki name: Ping (play))
{ 0x2E, PacketTypesIn.CraftRecipeResponse }, // (Wiki name: Place Ghost Recipe)
{ 0x2F, PacketTypesIn.PlayerAbilities },
{ 0x30, PacketTypesIn.ChatMessage }, // Changed in 1.19 (Completely changed) (Wiki name: Player Chat Message)
{ 0x31, PacketTypesIn.EndCombatEvent }, // (Wiki name: Player Combat End)
{ 0x32, PacketTypesIn.EnterCombatEvent }, // (Wiki name: Player Combat Enter)
{ 0x33, PacketTypesIn.DeathCombatEvent }, // (Wiki name: Player Combat Kill)
{ 0x34, PacketTypesIn.PlayerInfo }, // Changed in 1.19 (Heavy changes) - DONE
{ 0x35, PacketTypesIn.FacePlayer }, // (Wiki name: Player Look At)
{ 0x36, PacketTypesIn.PlayerPositionAndLook }, // (Wiki name: Player Position)
{ 0x37, PacketTypesIn.UnlockRecipes }, // (Wiki name: Recipe)
{ 0x38, PacketTypesIn.DestroyEntity }, // (Wiki name: Remove Entites)
{ 0x39, PacketTypesIn.RemoveEntityEffect },
{ 0x3A, PacketTypesIn.ResourcePackSend }, // (Wiki name: Resource Pack)
{ 0x3B, PacketTypesIn.Respawn }, // Changed in 1.19 (Heavy changes) - DONE
{ 0x3C, PacketTypesIn.EntityHeadLook }, // (Wiki name: Rotate Head)
{ 0x3D, PacketTypesIn.MultiBlockChange }, // (Wiki name: Sections Block Update)
{ 0x3E, PacketTypesIn.SelectAdvancementTab },
{ 0x3F, PacketTypesIn.ServerData }, // Added in 1.19
{ 0x40, PacketTypesIn.ActionBar }, // (Wiki name: Set Action Bar Text)
{ 0x41, PacketTypesIn.WorldBorderCenter }, // (Wiki name: Set Border Center)
{ 0x42, PacketTypesIn.WorldBorderLerpSize },
{ 0x43, PacketTypesIn.WorldBorderSize }, // (Wiki name: Set World Border Size)
{ 0x44, PacketTypesIn.WorldBorderWarningDelay }, // (Wiki name: Set World Border Warning Delay)
{ 0x45, PacketTypesIn.WorldBorderWarningReach }, // (Wiki name: Set Border Warning Distance)
{ 0x46, PacketTypesIn.Camera }, // (Wiki name: Set Camera)
{ 0x47, PacketTypesIn.HeldItemChange }, // (Wiki name: Set Carried Item (clientbound))
{ 0x48, PacketTypesIn.UpdateViewPosition }, // (Wiki name: Set Chunk Cache Center)
{ 0x49, PacketTypesIn.UpdateViewDistance }, // (Wiki name: Set Chunk Cache Radius)
{ 0x4A, PacketTypesIn.SpawnPosition }, // (Wiki name: Set Default Spawn Position)
{ 0x4B, PacketTypesIn.SetDisplayChatPreview }, // Added in 1.19 (Wiki name: Set Display Chat Preview)
{ 0x4C, PacketTypesIn.DisplayScoreboard }, // (Wiki name: Set Display Objective)
{ 0x4D, PacketTypesIn.EntityMetadata }, // (Wiki name: Set Entity Metadata)
{ 0x4E, PacketTypesIn.AttachEntity }, // (Wiki name: Set Entity Link)
{ 0x4F, PacketTypesIn.EntityVelocity }, // (Wiki name: Set Entity Motion)
{ 0x50, PacketTypesIn.EntityEquipment }, // (Wiki name: Set Equipment)
{ 0x51, PacketTypesIn.SetExperience },
{ 0x52, PacketTypesIn.UpdateHealth }, // (Wiki name: Set Health)
{ 0x53, PacketTypesIn.ScoreboardObjective }, // (Wiki name: Set Objective)
{ 0x54, PacketTypesIn.SetPassengers },
{ 0x55, PacketTypesIn.Teams }, // (Wiki name: Set Player Team)
{ 0x56, PacketTypesIn.UpdateScore }, // (Wiki name: Set Score)
{ 0x57, PacketTypesIn.UpdateSimulationDistance }, // (Wiki name: Set Simulation Distance)
{ 0x58, PacketTypesIn.SetTitleSubTitle }, // (Wiki name: Set Subtitle Test)
{ 0x59, PacketTypesIn.TimeUpdate }, // (Wiki name: Set Time)
{ 0x5A, PacketTypesIn.SetTitleText }, // (Wiki name: Set Title)
{ 0x5B, PacketTypesIn.SetTitleTime }, // (Wiki name: Set Titles Animation)
{ 0x5C, PacketTypesIn.EntitySoundEffect }, // (Wiki name: Sound Entity)
{ 0x5D, PacketTypesIn.SoundEffect }, // Changed in 1.19 (Added "Seed" field) (Wiki name: Sound Effect) - DONE (No need to be implemented)
{ 0x5E, PacketTypesIn.StopSound },
{ 0x5F, PacketTypesIn.SystemChat }, // Added in 1.19 (Wiki name: System Chat Message)
{ 0x60, PacketTypesIn.PlayerListHeaderAndFooter }, // (Wiki name: Tab List)
{ 0x61, PacketTypesIn.NBTQueryResponse }, // (Wiki name: Tab Query)
{ 0x62, PacketTypesIn.CollectItem }, // (Wiki name: Take Item Entity)
{ 0x63, PacketTypesIn.EntityTeleport }, // (Wiki name: Teleport Entity)
{ 0x64, PacketTypesIn.Advancements }, // (Wiki name: Update Advancements)
{ 0x65, PacketTypesIn.EntityProperties }, // (Wiki name: Update Attributes)
{ 0x66, PacketTypesIn.EntityEffect }, // Changed in 1.19 (Added "Has Factor Data" and "Factor Codec" fields) (Wiki name: Entity Effect) - DONE
{ 0x67, PacketTypesIn.DeclareRecipes }, // (Wiki name: Update Recipes)
{ 0x68, PacketTypesIn.Tags }, // (Wiki name: Update Tags)
};
private Dictionary<int, PacketTypesOut> typeOut = new Dictionary<int, PacketTypesOut>()
{
{ 0x00, PacketTypesOut.TeleportConfirm }, // (Wiki name: Confirm Teleportation)
{ 0x01, PacketTypesOut.QueryBlockNBT }, // (Wiki name: Query Block Entity Tag)
{ 0x02, PacketTypesOut.SetDifficulty }, // (Wiki name: Change Difficutly)
{ 0x03, PacketTypesOut.ChatCommand }, // Added in 1.19
{ 0x04, PacketTypesOut.ChatMessage }, // Changed in 1.19 (Completely changed) (Wiki name: Chat)
{ 0x05, PacketTypesOut.ChatPreview }, // Added in 1.19 (Wiki name: Chat Preview (serverbound))
{ 0x06, PacketTypesOut.ClientStatus }, // (Wiki name: Client Command)
{ 0x07, PacketTypesOut.ClientSettings }, // (Wiki name: Client Information)
{ 0x08, PacketTypesOut.TabComplete }, // (Wiki name: Command Suggestions Request)
{ 0x09, PacketTypesOut.ClickWindowButton }, // (Wiki name: Click Container Button)
{ 0x0A, PacketTypesOut.ClickWindow }, // (Wiki name: Click Container)
{ 0x0B, PacketTypesOut.CloseWindow }, // (Wiki name: Close Container (serverbound))
{ 0x0C, PacketTypesOut.PluginMessage }, // (Wiki name: Plugin Message (serverbound))
{ 0x0D, PacketTypesOut.EditBook },
{ 0x0E, PacketTypesOut.EntityNBTRequest }, // (Wiki name: Query Entity Tag)
{ 0x0F, PacketTypesOut.InteractEntity }, // (Wiki name: Interact)
{ 0x10, PacketTypesOut.GenerateStructure }, // (Wiki name: Jigsaw Generate)
{ 0x11, PacketTypesOut.KeepAlive },
{ 0x12, PacketTypesOut.LockDifficulty },
{ 0x13, PacketTypesOut.PlayerPosition }, // (Wiki name: Move Player Position)
{ 0x14, PacketTypesOut.PlayerPositionAndRotation }, // (Wiki name: Set Player Position and Rotation)
{ 0x15, PacketTypesOut.PlayerRotation }, // (Wiki name: Set Player Rotation)
{ 0x16, PacketTypesOut.PlayerMovement }, // (Wiki name: Set Player On Ground)
{ 0x17, PacketTypesOut.VehicleMove }, // (Wiki name: Move Vehicle (serverbound))
{ 0x18, PacketTypesOut.SteerBoat }, // (Wiki name: Paddle Boat)
{ 0x19, PacketTypesOut.PickItem },
{ 0x1A, PacketTypesOut.CraftRecipeRequest }, // (Wiki name: Place recipe)
{ 0x1B, PacketTypesOut.PlayerAbilities },
{ 0x1C, PacketTypesOut.PlayerDigging }, // Changed in 1.19 (Added a "Sequence" field) (Wiki name: Player Action) - DONE
{ 0x1D, PacketTypesOut.EntityAction }, // (Wiki name: Player Command)
{ 0x1E, PacketTypesOut.SteerVehicle }, // (Wiki name: Player Input)
{ 0x1F, PacketTypesOut.Pong }, // (Wiki name: Pong (play))
{ 0x20, PacketTypesOut.SetDisplayedRecipe }, // (Wiki name: Recipe Book Change Settings)
{ 0x21, PacketTypesOut.SetRecipeBookState }, // (Wiki name: Recipe Book Seen Recipe)
{ 0x22, PacketTypesOut.NameItem }, // (Wiki name: Rename Item)
{ 0x23, PacketTypesOut.ResourcePackStatus }, // (Wiki name: Resource Pack (serverbound))
{ 0x24, PacketTypesOut.AdvancementTab }, // (Wiki name: Seen Advancements)
{ 0x25, PacketTypesOut.SelectTrade },
{ 0x26, PacketTypesOut.SetBeaconEffect }, // Changed in 1.19 (Added a "Secondary Effect Present" and "Secondary Effect" fields) (Wiki name: Set Beacon) - DONE - (No need to be implemented)
{ 0x27, PacketTypesOut.HeldItemChange }, // (Wiki name: Set Carried Item (serverbound))
{ 0x28, PacketTypesOut.UpdateCommandBlock }, // (Wiki name: Set Command Block)
{ 0x29, PacketTypesOut.UpdateCommandBlockMinecart },
{ 0x2A, PacketTypesOut.CreativeInventoryAction }, // (Wiki name: Set Creative Mode Slot)
{ 0x2B, PacketTypesOut.UpdateJigsawBlock }, // (Wiki name: Set Jigsaw Block)
{ 0x2C, PacketTypesOut.UpdateStructureBlock }, // (Wiki name: Set Structure Block)
{ 0x2D, PacketTypesOut.UpdateSign }, // (Wiki name: Sign Update)
{ 0x2E, PacketTypesOut.Animation }, // (Wiki name: Swing)
{ 0x2F, PacketTypesOut.Spectate }, // (Wiki name: Teleport To Entity)
{ 0x30, PacketTypesOut.PlayerBlockPlacement }, // Changed in 1.19 (Added a "Sequence" field) (Wiki name: Use Item On) - DONE
{ 0x31, PacketTypesOut.UseItem }, // Changed in 1.19 (Added a "Sequence" field) (Wiki name: Use Item) - DONE
};
protected override Dictionary<int, PacketTypesIn> GetListIn()
{
return typeIn;
}
protected override Dictionary<int, PacketTypesOut> GetListOut()
{
return typeOut;
}
}
}

26
MinecraftClient/Protocol/Handlers/PacketType18Handler.cs
View file

@ -51,30 +51,32 @@ namespace MinecraftClient.Protocol.Handlers
public PacketTypePalette GetTypeHandler(int protocol) public PacketTypePalette GetTypeHandler(int protocol)
{ {
PacketTypePalette p; PacketTypePalette p;
if (protocol > Protocol18Handler.MC1182Version) if (protocol > Protocol18Handler.MC_1_19_Version)
throw new NotImplementedException(Translations.Get("exception.palette.packet")); throw new NotImplementedException(Translations.Get("exception.palette.packet"));
if (protocol <= Protocol18Handler.MC18Version) if (protocol <= Protocol18Handler.MC_1_8_Version)
p = new PacketPalette17(); p = new PacketPalette17();
else if (protocol <= Protocol18Handler.MC1112Version) else if (protocol <= Protocol18Handler.MC_1_11_2_Version)
p = new PacketPalette110(); p = new PacketPalette110();
else if (protocol <= Protocol18Handler.MC112Version) else if (protocol <= Protocol18Handler.MC_1_12_Version)
p = new PacketPalette112(); p = new PacketPalette112();
else if (protocol <= Protocol18Handler.MC1122Version) else if (protocol <= Protocol18Handler.MC_1_12_2_Version)
p = new PacketPalette1122(); p = new PacketPalette1122();
else if (protocol <= Protocol18Handler.MC114Version) else if (protocol <= Protocol18Handler.MC_1_14_Version)
p = new PacketPalette113(); p = new PacketPalette113();
else if (protocol <= Protocol18Handler.MC115Version) else if (protocol <= Protocol18Handler.MC_1_15_Version)
p = new PacketPalette114(); p = new PacketPalette114();
else if (protocol <= Protocol18Handler.MC1152Version) else if (protocol <= Protocol18Handler.MC_1_15_2_Version)
p = new PacketPalette115(); p = new PacketPalette115();
else if (protocol <= Protocol18Handler.MC1161Version) else if (protocol <= Protocol18Handler.MC_1_16_1_Version)
p = new PacketPalette116(); p = new PacketPalette116();
else if (protocol <= Protocol18Handler.MC1165Version) else if (protocol <= Protocol18Handler.MC_1_16_5_Version)
p = new PacketPalette1162(); p = new PacketPalette1162();
else if (protocol <= Protocol18Handler.MC1171Version) else if (protocol <= Protocol18Handler.MC_1_17_1_Version)
p = new PacketPalette117(); p = new PacketPalette117();
else else if (protocol <= Protocol18Handler.MC_1_18_2_Version)
p = new PacketPalette118(); p = new PacketPalette118();
else
p = new PacketPalette119();
p.SetForgeEnabled(this.forgeEnabled); p.SetForgeEnabled(this.forgeEnabled);
return p; return p;

7
MinecraftClient/Protocol/Handlers/PacketTypesIn.cs
View file

@ -127,5 +127,12 @@ namespace MinecraftClient.Protocol.Handlers
UpdateEntityNBT, // For 1.8 or below UpdateEntityNBT, // For 1.8 or below
Unknown, // For old version packet that have been removed and not used by mcc Unknown, // For old version packet that have been removed and not used by mcc
UpdateSimulationDistance, UpdateSimulationDistance,
// 1.19 Additions
BlockChangedAck,
ChatPreview,
ServerData,
SetDisplayChatPreview,
SystemChat
} }
} }

6
MinecraftClient/Protocol/Handlers/PacketTypesOut.cs
View file

@ -62,6 +62,10 @@ namespace MinecraftClient.Protocol.Handlers
GenerateStructure, // Added in 1.16 GenerateStructure, // Added in 1.16
SetDisplayedRecipe, // Added in 1.16.2 SetDisplayedRecipe, // Added in 1.16.2
SetRecipeBookState, // Added in 1.16.2 SetRecipeBookState, // Added in 1.16.2
Unknown // For old version packet that have been removed and not used by mcc Unknown, // For old version packet that have been removed and not used by mcc
// Added in 1.19
ChatCommand,
ChatPreview,
} }
} }

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

@ -9,6 +9,7 @@ using MinecraftClient.Proxy;
using System.Security.Cryptography; using System.Security.Cryptography;
using MinecraftClient.Mapping; using MinecraftClient.Mapping;
using MinecraftClient.Inventory; using MinecraftClient.Inventory;
using MinecraftClient.Protocol.Keys;
namespace MinecraftClient.Protocol.Handlers namespace MinecraftClient.Protocol.Handlers
{ {
@ -62,12 +63,12 @@ namespace MinecraftClient.Protocol.Handlers
private void Updater(object? o) private void Updater(object? o)
{ {
if (((CancellationToken) o!).IsCancellationRequested) if (((CancellationToken)o!).IsCancellationRequested)
return; return;
try try
{ {
while (!((CancellationToken) o!).IsCancellationRequested) while (!((CancellationToken)o!).IsCancellationRequested)
{ {
do do
{ {
@ -79,9 +80,9 @@ namespace MinecraftClient.Protocol.Handlers
catch (SocketException) { } catch (SocketException) { }
catch (ObjectDisposedException) { } catch (ObjectDisposedException) { }
if (((CancellationToken) o!).IsCancellationRequested) if (((CancellationToken)o!).IsCancellationRequested)
return; return;
handler.OnConnectionLost(ChatBot.DisconnectReason.ConnectionLost, ""); handler.OnConnectionLost(ChatBot.DisconnectReason.ConnectionLost, "");
} }
@ -102,7 +103,8 @@ namespace MinecraftClient.Protocol.Handlers
int nbr = 0; int nbr = 0;
switch (id) switch (id)
{ {
case 0x00: byte[] keepalive = new byte[5] { 0, 0, 0, 0, 0 }; case 0x00:
byte[] keepalive = new byte[5] { 0, 0, 0, 0, 0 };
Receive(keepalive, 1, 4, SocketFlags.None); Receive(keepalive, 1, 4, SocketFlags.None);
handler.OnServerKeepAlive(); handler.OnServerKeepAlive();
Send(keepalive); break; Send(keepalive); break;
@ -110,7 +112,7 @@ namespace MinecraftClient.Protocol.Handlers
case 0x02: readData(1); readNextString(); readNextString(); readData(4); break; case 0x02: readData(1); readNextString(); readNextString(); readData(4); break;
case 0x03: case 0x03:
string message = readNextString(); string message = readNextString();
handler.OnTextReceived(message, protocolversion >= 72); break; handler.OnTextReceived(new ChatMessage(message, protocolversion >= 72, 0, Guid.Empty)); break;
case 0x04: readData(16); break; case 0x04: readData(16); break;
case 0x05: readData(6); readNextItemSlot(); break; case 0x05: readData(6); readNextItemSlot(); break;
case 0x06: readData(12); break; case 0x06: readData(12); break;
@ -181,7 +183,7 @@ namespace MinecraftClient.Protocol.Handlers
case 0xC9: case 0xC9:
string name = readNextString(); bool online = readNextByte() != 0x00; readData(2); string name = readNextString(); bool online = readNextByte() != 0x00; readData(2);
Guid FakeUUID = new Guid(MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(name)).Take(16).ToArray()); Guid FakeUUID = new Guid(MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(name)).Take(16).ToArray());
if (online) { handler.OnPlayerJoin(FakeUUID, name); } else { handler.OnPlayerLeave(FakeUUID); } if (online) { handler.OnPlayerJoin(new PlayerInfo(name, FakeUUID)); } else { handler.OnPlayerLeave(FakeUUID); }
break; break;
case 0xCA: if (protocolversion >= 72) { readData(9); } else readData(3); break; case 0xCA: if (protocolversion >= 72) { readData(9); } else readData(3); break;
case 0xCB: autocomplete_result = readNextString(); autocomplete_received = true; break; case 0xCB: autocomplete_result = readNextString(); autocomplete_received = true; break;
@ -191,18 +193,20 @@ namespace MinecraftClient.Protocol.Handlers
case 0xCF: if (protocolversion > 51) { readNextString(); readData(1); readNextString(); } readData(4); break; case 0xCF: if (protocolversion > 51) { readNextString(); readData(1); readNextString(); } readData(4); break;
case 0xD0: if (protocolversion > 51) { readData(1); readNextString(); } break; case 0xD0: if (protocolversion > 51) { readData(1); readNextString(); } break;
case 0xD1: if (protocolversion > 51) { readNextTeamData(); } break; case 0xD1: if (protocolversion > 51) { readNextTeamData(); } break;
case 0xFA: string channel = readNextString(); case 0xFA:
string channel = readNextString();
byte[] payload = readNextByteArray(); byte[] payload = readNextByteArray();
handler.OnPluginChannelMessage(channel, payload); handler.OnPluginChannelMessage(channel, payload);
break; break;
case 0xFF: string reason = readNextString(); case 0xFF:
string reason = readNextString();
handler.OnConnectionLost(ChatBot.DisconnectReason.InGameKick, reason); break; handler.OnConnectionLost(ChatBot.DisconnectReason.InGameKick, reason); break;
default: return false; //unknown packet! default: return false; //unknown packet!
} }
return true; //packet has been successfully skipped return true; //packet has been successfully skipped
} }
private void StartUpdating() private void StartUpdating()
{ {
netRead = new(new Thread(new ParameterizedThreadStart(Updater)), new CancellationTokenSource()); netRead = new(new Thread(new ParameterizedThreadStart(Updater)), new CancellationTokenSource());
netRead.Item1.Name = "ProtocolPacketHandler"; netRead.Item1.Name = "ProtocolPacketHandler";
@ -553,7 +557,7 @@ namespace MinecraftClient.Protocol.Handlers
} }
} }
public bool Login() public bool Login(PlayerKeyPair playerKeyPair)
{ {
if (Handshake(handler.GetUserUUID(), handler.GetUsername(), handler.GetSessionID(), handler.GetServerHost(), handler.GetServerPort())) if (Handshake(handler.GetUserUUID(), handler.GetUsername(), handler.GetSessionID(), handler.GetServerHost(), handler.GetServerPort()))
{ {
@ -639,7 +643,7 @@ namespace MinecraftClient.Protocol.Handlers
return protocolversion; return protocolversion;
} }
public bool SendChatMessage(string message) public bool SendChatMessage(string message, PlayerKeyPair? playerKeyPair)
{ {
if (String.IsNullOrEmpty(message)) if (String.IsNullOrEmpty(message))
return true; return true;
@ -674,12 +678,12 @@ namespace MinecraftClient.Protocol.Handlers
} }
catch (SocketException) { return false; } catch (SocketException) { return false; }
} }
public bool SendUpdateSign(Location location, string line1, string line2, string line3, string line4) public bool SendUpdateSign(Location location, string line1, string line2, string line3, string line4)
{ {
return false; //Currently not implemented return false; //Currently not implemented
} }
public bool SendBrandInfo(string brandInfo) public bool SendBrandInfo(string brandInfo)
{ {
return false; //Only supported since MC 1.7 return false; //Only supported since MC 1.7
@ -709,18 +713,18 @@ namespace MinecraftClient.Protocol.Handlers
{ {
return false; //Currently not implemented return false; //Currently not implemented
} }
public bool SendInteractEntity(int EntityID, int type, int hand) public bool SendInteractEntity(int EntityID, int type, int hand)
{ {
return false; //Currently not implemented return false; //Currently not implemented
} }
public bool UpdateCommandBlock(Location location, string command, CommandBlockMode mode, CommandBlockFlags flags) public bool UpdateCommandBlock(Location location, string command, CommandBlockMode mode, CommandBlockFlags flags)
{ {
return false; //Currently not implemented return false; //Currently not implemented
} }
public bool SendUseItem(int hand) public bool SendUseItem(int hand, int sequenceId)
{ {
return false; //Currently not implemented return false; //Currently not implemented
} }
@ -735,7 +739,7 @@ namespace MinecraftClient.Protocol.Handlers
return false; //Currently not implemented return false; //Currently not implemented
} }
public bool SendCreativeInventoryAction(int slot, ItemType item, int count, Dictionary<string, object> nbt) public bool SendCreativeInventoryAction(int slot, ItemType item, int count, Dictionary<string, object>? nbt)
{ {
return false; //Currently not implemented return false; //Currently not implemented
} }
@ -745,7 +749,7 @@ namespace MinecraftClient.Protocol.Handlers
return false; //Currently not implemented return false; //Currently not implemented
} }
public bool SendPlayerBlockPlacement(int hand, Location location, Direction face) public bool SendPlayerBlockPlacement(int hand, Location location, Direction face, int sequenceId)
{ {
return false; //Currently not implemented return false; //Currently not implemented
} }
@ -755,7 +759,7 @@ namespace MinecraftClient.Protocol.Handlers
return false; //Currently not implemented return false; //Currently not implemented
} }
public bool SendPlayerDigging(int status, Location location, Direction face) public bool SendPlayerDigging(int status, Location location, Direction face, int sequenceId)
{ {
return false; //Currently not implemented return false; //Currently not implemented
} }
@ -767,7 +771,8 @@ namespace MinecraftClient.Protocol.Handlers
/// <param name="data">packet Data</param> /// <param name="data">packet Data</param>
public bool SendPluginChannelPacket(string channel, byte[] data) public bool SendPluginChannelPacket(string channel, byte[] data)
{ {
try { try
{
byte[] channelLength = BitConverter.GetBytes((short)channel.Length); byte[] channelLength = BitConverter.GetBytes((short)channel.Length);
Array.Reverse(channelLength); Array.Reverse(channelLength);

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

File diff suppressed because it is too large Load diff

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

@ -179,7 +179,7 @@ namespace MinecraftClient.Protocol.Handlers
if (discriminator != FMLHandshakeDiscriminator.RegistryData) if (discriminator != FMLHandshakeDiscriminator.RegistryData)
return false; return false;
if (protocolversion < Protocol18Handler.MC18Version) if (protocolversion < Protocol18Handler.MC_1_8_Version)
{ {
// 1.7.10 and below have one registry // 1.7.10 and below have one registry
// with blocks and items. // with blocks and items.
@ -440,7 +440,7 @@ namespace MinecraftClient.Protocol.Handlers
/// <param name="jsonData">JSON data returned by the server</param> /// <param name="jsonData">JSON data returned by the server</param>
/// <param name="forgeInfo">ForgeInfo to populate</param> /// <param name="forgeInfo">ForgeInfo to populate</param>
/// <returns>True if the server is running Forge</returns> /// <returns>True if the server is running Forge</returns>
public static bool ServerInfoCheckForge(Json.JSONData jsonData, ref ForgeInfo forgeInfo) public static bool ServerInfoCheckForge(Json.JSONData jsonData, ref ForgeInfo? forgeInfo)
{ {
return ServerInfoCheckForgeSub(jsonData, ref forgeInfo, FMLVersion.FML) // MC 1.12 and lower return ServerInfoCheckForgeSub(jsonData, ref forgeInfo, FMLVersion.FML) // MC 1.12 and lower
|| ServerInfoCheckForgeSub(jsonData, ref forgeInfo, FMLVersion.FML2); // MC 1.13 and greater || ServerInfoCheckForgeSub(jsonData, ref forgeInfo, FMLVersion.FML2); // MC 1.13 and greater
@ -477,7 +477,7 @@ namespace MinecraftClient.Protocol.Handlers
/// <param name="forgeInfo">ForgeInfo to populate</param> /// <param name="forgeInfo">ForgeInfo to populate</param>
/// <param name="fmlVersion">Forge protocol version</param> /// <param name="fmlVersion">Forge protocol version</param>
/// <returns>True if the server is running Forge</returns> /// <returns>True if the server is running Forge</returns>
private static bool ServerInfoCheckForgeSub(Json.JSONData jsonData, ref ForgeInfo forgeInfo, FMLVersion fmlVersion) private static bool ServerInfoCheckForgeSub(Json.JSONData jsonData, ref ForgeInfo? forgeInfo, FMLVersion fmlVersion)
{ {
string forgeDataTag; string forgeDataTag;
string versionField; string versionField;

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

@ -40,7 +40,7 @@ namespace MinecraftClient.Protocol.Handlers
/// <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, 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)
{ {
if (protocolversion >= Protocol18Handler.MC19Version) 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
@ -49,7 +49,7 @@ namespace MinecraftClient.Protocol.Handlers
if ((chunkMask & (1 << chunkY)) != 0) if ((chunkMask & (1 << chunkY)) != 0)
{ {
// 1.14 and above Non-air block count inside chunk section, for lighting purposes // 1.14 and above Non-air block count inside chunk section, for lighting purposes
if (protocolversion >= Protocol18Handler.MC114Version) if (protocolversion >= Protocol18Handler.MC_1_14_Version)
dataTypes.ReadNextShort(cache); dataTypes.ReadNextShort(cache);
byte bitsPerBlock = dataTypes.ReadNextByte(cache); byte bitsPerBlock = dataTypes.ReadNextByte(cache);
@ -62,7 +62,7 @@ namespace MinecraftClient.Protocol.Handlers
// MC 1.9 to 1.12 will set palette length field to 0 when palette // MC 1.9 to 1.12 will set palette length field to 0 when palette
// is not used, MC 1.13+ does not send the field at all in this case // is not used, MC 1.13+ does not send the field at all in this case
int paletteLength = 0; // Assume zero when length is absent int paletteLength = 0; // Assume zero when length is absent
if (usePalette || protocolversion < Protocol18Handler.MC113Version) if (usePalette || protocolversion < Protocol18Handler.MC_1_13_Version)
paletteLength = dataTypes.ReadNextVarInt(cache); paletteLength = dataTypes.ReadNextVarInt(cache);
int[] palette = new int[paletteLength]; int[] palette = new int[paletteLength];
@ -101,7 +101,7 @@ namespace MinecraftClient.Protocol.Handlers
if ((startOffset + bitsPerBlock) > 64) if ((startOffset + bitsPerBlock) > 64)
{ {
if (protocolversion >= Protocol18Handler.MC116Version) if (protocolversion >= Protocol18Handler.MC_1_16_Version)
{ {
// 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 ]
@ -170,7 +170,7 @@ namespace MinecraftClient.Protocol.Handlers
}); });
//Pre-1.14 Lighting data //Pre-1.14 Lighting data
if (protocolversion < Protocol18Handler.MC114Version) if (protocolversion < Protocol18Handler.MC_1_14_Version)
{ {
//Skip block light //Skip block light
dataTypes.ReadData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ) / 2, cache); dataTypes.ReadData((Chunk.SizeX * Chunk.SizeY * Chunk.SizeZ) / 2, cache);
@ -186,7 +186,7 @@ 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)
} }
else if (protocolversion >= Protocol18Handler.MC18Version) else if (protocolversion >= Protocol18Handler.MC_1_8_Version)
{ {
// 1.8 chunk format // 1.8 chunk format
if (chunksContinuous && chunkMask == 0) if (chunksContinuous && chunkMask == 0)

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

@ -82,7 +82,7 @@ namespace MinecraftClient.Protocol.Handlers
Receive(cache, 0, length, SocketFlags.None); Receive(cache, 0, length, SocketFlags.None);
return cache; return cache;
} }
return new byte[] { }; return Array.Empty<byte>();
} }
/// <summary> /// <summary>

16
MinecraftClient/Protocol/IMinecraftCom.cs
View file

@ -5,6 +5,7 @@ using System.Text;
using MinecraftClient.Crypto; using MinecraftClient.Crypto;
using MinecraftClient.Mapping; using MinecraftClient.Mapping;
using MinecraftClient.Inventory; using MinecraftClient.Inventory;
using MinecraftClient.Protocol.Keys;
namespace MinecraftClient.Protocol namespace MinecraftClient.Protocol
{ {
@ -21,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(); bool Login(PlayerKeyPair playerKeyPair);
/// <summary> /// <summary>
/// Disconnect from the server /// Disconnect from the server
@ -48,7 +49,7 @@ namespace MinecraftClient.Protocol
/// </summary> /// </summary>
/// <param name="message">Text to send</param> /// <param name="message">Text to send</param>
/// <returns>True if successfully sent</returns> /// <returns>True if successfully sent</returns>
bool SendChatMessage(string message); bool SendChatMessage(string message, PlayerKeyPair? playerKeyPair = null);
/// <summary> /// <summary>
/// Allow to respawn after death /// Allow to respawn after death
@ -154,8 +155,9 @@ namespace MinecraftClient.Protocol
/// Send a use item packet to the server /// Send a use item packet to the server
/// </summary> /// </summary>
/// <param name="hand">0: main hand, 1: off hand</param> /// <param name="hand">0: main hand, 1: off hand</param>
/// <param name="sequenceId">Sequence ID used for synchronization</param>
/// <returns>True if packet was successfully sent</returns> /// <returns>True if packet was successfully sent</returns>
bool SendUseItem(int hand); bool SendUseItem(int hand, int sequenceId);
/// <summary> /// <summary>
/// Send a click window slot packet to the server /// Send a click window slot packet to the server
@ -176,7 +178,7 @@ namespace MinecraftClient.Protocol
/// <param name="count">Item count</param> /// <param name="count">Item count</param>
/// <param name="nbt">Optional item NBT</param> /// <param name="nbt">Optional item NBT</param>
/// <returns>TRUE if item given successfully</returns> /// <returns>TRUE if item given successfully</returns>
bool SendCreativeInventoryAction(int slot, ItemType itemType, int count, Dictionary<string, object> nbt); bool SendCreativeInventoryAction(int slot, ItemType itemType, int count, Dictionary<string, object>? nbt);
/// <summary> /// <summary>
/// Plays animation /// Plays animation
@ -198,8 +200,9 @@ namespace MinecraftClient.Protocol
/// <param name="hand">0: main hand, 1: off hand</param> /// <param name="hand">0: main hand, 1: off hand</param>
/// <param name="location">Location to place block at</param> /// <param name="location">Location to place block at</param>
/// <param name="face">Block face</param> /// <param name="face">Block face</param>
/// <param name="sequenceId">Sequence ID (use for synchronization)</param>
/// <returns>True if packet was successfully sent</returns> /// <returns>True if packet was successfully sent</returns>
bool SendPlayerBlockPlacement(int hand, Location location, Direction face); bool SendPlayerBlockPlacement(int hand, Location location, Direction face, int sequenceId);
/// <summary> /// <summary>
/// Send player blog digging packet to the server. This packet needs to be called at least twice: Once to begin digging, then a second time to finish digging /// Send player blog digging packet to the server. This packet needs to be called at least twice: Once to begin digging, then a second time to finish digging
@ -207,8 +210,9 @@ namespace MinecraftClient.Protocol
/// <param name="status">0 to start digging, 1 to cancel, 2 to finish ( https://wiki.vg/Protocol#Player_Digging )</param> /// <param name="status">0 to start digging, 1 to cancel, 2 to finish ( https://wiki.vg/Protocol#Player_Digging )</param>
/// <param name="location">Location</param> /// <param name="location">Location</param>
/// <param name="face">Block face</param> /// <param name="face">Block face</param>
/// <param name="sequenceId">Sequence ID (use for synchronization)</param>
/// <returns>True if packet was succcessfully sent</returns> /// <returns>True if packet was succcessfully sent</returns>
bool SendPlayerDigging(int status, Location location, Direction face); bool SendPlayerDigging(int status, Location location, Direction face, int sequenceId);
/// <summary> /// <summary>
/// Change text on a sign /// Change text on a sign

54
MinecraftClient/Protocol/IMinecraftComHandler.cs
View file

@ -26,8 +26,10 @@ namespace MinecraftClient.Protocol
string GetSessionID(); string GetSessionID();
string[] GetOnlinePlayers(); string[] GetOnlinePlayers();
Dictionary<string, string> GetOnlinePlayersWithUUID(); Dictionary<string, string> GetOnlinePlayersWithUUID();
PlayerInfo? GetPlayerInfo(Guid uuid);
Location GetCurrentLocation(); Location GetCurrentLocation();
World GetWorld(); World GetWorld();
bool GetIsSupportPreviewsChat();
bool GetTerrainEnabled(); bool GetTerrainEnabled();
bool SetTerrainEnabled(bool enabled); bool SetTerrainEnabled(bool enabled);
bool GetInventoryEnabled(); bool GetInventoryEnabled();
@ -78,11 +80,10 @@ namespace MinecraftClient.Protocol
void OnGameJoined(); void OnGameJoined();
/// <summary> /// <summary>
/// This method is called when the protocol handler receives a chat message /// Received chat/system message from the server
/// </summary> /// </summary>
/// <param name="text">Text received from the server</param> /// <param name="message">Message received</param>
/// <param name="isJson">TRUE if the text is JSON-Encoded</param> public void OnTextReceived(ChatMessage message);
void OnTextReceived(string text, bool isJson);
/// <summary> /// <summary>
/// Will be called every animations of the hit and place block /// Will be called every animations of the hit and place block
@ -91,6 +92,12 @@ namespace MinecraftClient.Protocol
/// <param name="animation">0 = LMB, 1 = RMB (RMB Corrent not work)</param> /// <param name="animation">0 = LMB, 1 = RMB (RMB Corrent not work)</param>
void OnEntityAnimation(int entityID, byte animation); void OnEntityAnimation(int entityID, byte animation);
/// <summary>
/// Will be called when a Synchronization sequence is recevied, this sequence need to be sent when breaking or placing blocks
/// </summary>
/// <param name="sequenceId">Sequence ID</param>
void OnBlockChangeAck(int sequenceId);
/// <summary> /// <summary>
/// Will be called every player break block in gamemode 0 /// Will be called every player break block in gamemode 0
/// </summary> /// </summary>
@ -109,6 +116,22 @@ namespace MinecraftClient.Protocol
/// </summary> /// </summary>
void OnServerKeepAlive(); void OnServerKeepAlive();
/// <summary>
/// This method is called when the protocol handler receives server data
/// </summary>
/// <param name="hasMotd">Indicates if the server has a motd message</param>
/// <param name="motd">Server MOTD message</param>
/// <param name="hasIcon">Indicates if the server has a an icon</param>
/// <param name="iconBase64">Server icon in Base 64 format</param>
/// <param name="previewsChat">Indicates if the server previews chat</param>
void OnServerDataRecived(bool hasMotd, string motd, bool hasIcon, string iconBase64, bool previewsChat);
/// <summary>
/// This method is called when the protocol handler receives "Set Display Chat Preview" packet
/// </summary>
/// <param name="previewsChat">Indicates if the server previews chat</param>
public void OnChatPreviewSettingUpdate(bool previewsChat);
/// <summary> /// <summary>
/// Called when an inventory is opened /// Called when an inventory is opened
/// </summary> /// </summary>
@ -125,11 +148,10 @@ namespace MinecraftClient.Protocol
void OnRespawn(); void OnRespawn();
/// <summary> /// <summary>
/// This method is called when a new player joins the game /// Triggered when a new player joins the game
/// </summary> /// </summary>
/// <param name="uuid">UUID of the player</param> /// <param name="player">player info</param>
/// <param name="name">Name of the player</param> public void OnPlayerJoin(PlayerInfo player);
void OnPlayerJoin(Guid uuid, string name);
/// <summary> /// <summary>
/// This method is called when a player has left the game /// This method is called when a player has left the game
@ -346,7 +368,7 @@ namespace MinecraftClient.Protocol
/// </summary> /// </summary>
/// <param name="EntityID">Player entity ID</param> /// <param name="EntityID">Player entity ID</param>
void OnReceivePlayerEntityID(int EntityID); void OnReceivePlayerEntityID(int EntityID);
/// <summary> /// <summary>
/// Called when the Entity use effects /// Called when the Entity use effects
/// </summary> /// </summary>
@ -355,8 +377,10 @@ namespace MinecraftClient.Protocol
/// <param name="amplifier">effect amplifier</param> /// <param name="amplifier">effect amplifier</param>
/// <param name="duration">effect duration</param> /// <param name="duration">effect duration</param>
/// <param name="flags">effect flags</param> /// <param name="flags">effect flags</param>
void OnEntityEffect(int entityid, Effects effect, int amplifier, int duration, byte flags); /// <param name="hasFactorData">has factor data</param>
/// <param name="factorCodec">factorCodec</param>
void OnEntityEffect(int entityid, Effects effect, int amplifier, int duration, byte flags, bool hasFactorData, Dictionary<String, object>? factorCodec);
/// <summary> /// <summary>
/// Called when coreboardObjective /// Called when coreboardObjective
/// </summary> /// </summary>
@ -385,5 +409,13 @@ namespace MinecraftClient.Protocol
/// <param name="isRegularVillager">True if regular villagers and false if the wandering trader.</param> /// <param name="isRegularVillager">True if regular villagers and false if the wandering trader.</param>
/// <param name="canRestock">If the villager can restock his trades at a workstation, True for regular villagers and false for the wandering trader.</param> /// <param name="canRestock">If the villager can restock his trades at a workstation, True for regular villagers and false for the wandering trader.</param>
void OnTradeList(int windowID, List<VillagerTrade> trades, VillagerInfo villagerInfo); void OnTradeList(int windowID, List<VillagerTrade> trades, VillagerInfo villagerInfo);
/// <summary>
/// This method is called when the protocol handler receives "Login Success" packet
/// </summary>
/// <param name="uuid">The player's UUID received from the server</param>
/// <param name="userName">The player's username received from the server</param>
/// <param name="playerProperty">Tuple<Name, Value, Signature(empty if there is no signature)></param>
public void OnLoginSuccess(Guid uuid, string userName, Tuple<string, string, string>[]? playerProperty);
} }
} }

5
MinecraftClient/Protocol/MicrosoftAuthentication.cs
View file

@ -51,7 +51,7 @@ namespace MinecraftClient.Protocol
} }
/// <summary> /// <summary>
/// Perform request to obtain access token by code or by refresh token /// Perform request to obtain access token by code or by refresh token
/// </summary> /// </summary>
/// <param name="postData">Complete POST data for the request</param> /// <param name="postData">Complete POST data for the request</param>
/// <returns></returns> /// <returns></returns>
@ -72,7 +72,7 @@ namespace MinecraftClient.Protocol
string accessToken = jsonData.Properties["access_token"].StringValue; string accessToken = jsonData.Properties["access_token"].StringValue;
string refreshToken = jsonData.Properties["refresh_token"].StringValue; string refreshToken = jsonData.Properties["refresh_token"].StringValue;
int expiresIn = int.Parse(jsonData.Properties["expires_in"].StringValue); int expiresIn = int.Parse(jsonData.Properties["expires_in"].StringValue);
// Extract email from JWT // Extract email from JWT
string payload = JwtPayloadDecode.GetPayload(jsonData.Properties["id_token"].StringValue); string payload = JwtPayloadDecode.GetPayload(jsonData.Properties["id_token"].StringValue);
var jsonPayload = Json.ParseJson(payload); var jsonPayload = Json.ParseJson(payload);
@ -391,6 +391,7 @@ namespace MinecraftClient.Protocol
string jsonString = response.Body; string jsonString = response.Body;
Json.JSONData json = Json.ParseJson(jsonString); Json.JSONData json = Json.ParseJson(jsonString);
return json.Properties["access_token"].StringValue; return json.Properties["access_token"].StringValue;
} }

83
MinecraftClient/Protocol/PlayerInfo.cs Normal file
View file

@ -0,0 +1,83 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MinecraftClient.Protocol.Keys;
namespace MinecraftClient.Protocol
{
public class PlayerInfo
{
public readonly Guid UUID;
public readonly string Name;
// Tuple<Name, Value, Signature(empty if there is no signature)
public readonly Tuple<string, string, string>[]? Property;
public int Gamemode;
public int Ping;
public string? DisplayName;
private readonly PublicKey? PublicKey;
private readonly DateTime? KeyExpiresAt;
public PlayerInfo(Guid uuid, string name, Tuple<string, string, string>[]? property, int gamemode, int ping, string? displayName, long? timeStamp, byte[]? publicKey, byte[]? signature)
{
UUID = uuid;
Name = name;
if (property != null)
Property = property;
Gamemode = gamemode;
Ping = ping;
DisplayName = displayName;
if (timeStamp != null && publicKey != null && signature != null)
{
DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds((long)timeStamp);
KeyExpiresAt = dateTimeOffset.UtcDateTime;
try
{
PublicKey = new PublicKey(publicKey, signature);
}
catch (System.Security.Cryptography.CryptographicException)
{
PublicKey = null;
}
}
}
public PlayerInfo(string name, Guid uuid)
{
Name = name;
UUID = uuid;
Gamemode = -1;
Ping = 0;
}
public bool IsKeyVaild()
{
return PublicKey != null && DateTime.Now.ToUniversalTime() > this.KeyExpiresAt;
}
public bool VerifyMessage(string message, Guid uuid, long timestamp, long salt, ref byte[] signature)
{
if (PublicKey == null)
return false;
else
{
string uuidString = uuid.ToString().Replace("-", string.Empty);
DateTimeOffset timeOffset = DateTimeOffset.FromUnixTimeMilliseconds(timestamp);
byte[] saltByte = BitConverter.GetBytes(salt);
Array.Reverse(saltByte);
return PublicKey.VerifyMessage(message, uuidString, timeOffset, ref saltByte, ref signature);
}
}
}
}

137
MinecraftClient/Protocol/ProfileKey/KeyUtils.cs Normal file
View file

@ -0,0 +1,137 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace MinecraftClient.Protocol.Keys
{
static class KeyUtils
{
private static string certificates = "https://api.minecraftservices.com/player/certificates";
public static PlayerKeyPair? GetKeys(string accessToken)
{
ProxiedWebRequest.Response? response = null;
try
{
var request = new ProxiedWebRequest(certificates)
{
Accept = "application/json"
};
request.Headers.Add("Authorization", string.Format("Bearer {0}", accessToken));
response = request.Post("application/json", "");
if (Settings.DebugMessages)
{
ConsoleIO.WriteLine(response.Body.ToString());
}
string jsonString = response.Body;
Json.JSONData json = Json.ParseJson(jsonString);
PublicKey publicKey = new(pemKey: json.Properties["keyPair"].Properties["publicKey"].StringValue,
sig: json.Properties["publicKeySignature"].StringValue,
sigV2: json.Properties["publicKeySignatureV2"].StringValue);
PrivateKey privateKey = new(pemKey: json.Properties["keyPair"].Properties["privateKey"].StringValue);
return new PlayerKeyPair(publicKey, privateKey,
expiresAt: json.Properties["expiresAt"].StringValue,
refreshedAfter: json.Properties["refreshedAfter"].StringValue);
}
catch (Exception e)
{
int code = (response == null) ? 0 : response.StatusCode;
ConsoleIO.WriteLineFormatted("§cFetch profile key failed: HttpCode = " + code + ", Error = " + e.Message);
if (Settings.DebugMessages)
{
ConsoleIO.WriteLineFormatted("§c" + e.StackTrace);
}
return null;
}
}
public static byte[] DecodePemKey(String key, String prefix, String suffix)
{
int i = key.IndexOf(prefix);
if (i != -1)
{
i += prefix.Length;
int j = key.IndexOf(suffix, i);
key = key[i..j];
}
key = key.Replace("\r", String.Empty);
key = key.Replace("\n", String.Empty);
return Convert.FromBase64String(key);
}
public static byte[] GetSignatureData(string message, string uuid, DateTimeOffset timestamp, ref byte[] salt)
{
List<byte> data = new();
data.AddRange(salt);
byte[] UUIDLeastSignificantBits = BitConverter.GetBytes(Convert.ToInt64(uuid[..16], 16));
Array.Reverse(UUIDLeastSignificantBits);
data.AddRange(UUIDLeastSignificantBits);
byte[] UUIDMostSignificantBits = BitConverter.GetBytes(Convert.ToInt64(uuid.Substring(16, 16), 16));
Array.Reverse(UUIDMostSignificantBits);
data.AddRange(UUIDMostSignificantBits);
byte[] timestampByte = BitConverter.GetBytes(timestamp.ToUnixTimeSeconds());
Array.Reverse(timestampByte);
data.AddRange(timestampByte);
data.AddRange(Encoding.UTF8.GetBytes(message));
return data.ToArray();
}
// https://github.com/mono/mono/blob/master/mcs/class/System.Json/System.Json/JsonValue.cs
public static string EscapeString(string src)
{
StringBuilder sb = new();
int start = 0;
for (int i = 0; i < src.Length; i++)
{
char c = src[i];
bool needEscape = c < 32 || c == '"' || c == '\\';
// Broken lead surrogate
needEscape = needEscape || (c >= '\uD800' && c <= '\uDBFF' &&
(i == src.Length - 1 || src[i + 1] < '\uDC00' || src[i + 1] > '\uDFFF'));
// Broken tail surrogate
needEscape = needEscape || (c >= '\uDC00' && c <= '\uDFFF' &&
(i == 0 || src[i - 1] < '\uD800' || src[i - 1] > '\uDBFF'));
// To produce valid JavaScript
needEscape = needEscape || c == '\u2028' || c == '\u2029';
if (needEscape)
{
sb.Append(src, start, i - start);
switch (src[i])
{
case '\b': sb.Append("\\b"); break;
case '\f': sb.Append("\\f"); break;
case '\n': sb.Append("\\n"); break;
case '\r': sb.Append("\\r"); break;
case '\t': sb.Append("\\t"); break;
case '\"': sb.Append("\\\""); break;
case '\\': sb.Append("\\\\"); break;
default:
sb.Append("\\u");
sb.Append(((int)src[i]).ToString("x04"));
break;
}
start = i + 1;
}
}
sb.Append(src, start, src.Length - start);
return sb.ToString();
}
}
}

196
MinecraftClient/Protocol/ProfileKey/KeysCache.cs Normal file
View file

@ -0,0 +1,196 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Timers;
using MinecraftClient.Protocol.Session;
namespace MinecraftClient.Protocol.Keys
{
/// <summary>
/// Handle keys caching and storage.
/// </summary>
public static class KeysCache
{
private const string KeysCacheFilePlaintext = "ProfileKeyCache.ini";
private static FileMonitor cachemonitor;
private static Dictionary<string, PlayerKeyPair> keys = new Dictionary<string, PlayerKeyPair>();
private static Timer updatetimer = new Timer(100);
private static List<KeyValuePair<string, PlayerKeyPair>> pendingadds = new List<KeyValuePair<string, PlayerKeyPair>>();
private static BinaryFormatter formatter = new BinaryFormatter();
/// <summary>
/// Retrieve whether KeysCache contains a keys for the given login.
/// </summary>
/// <param name="login">User login used with Minecraft.net</param>
/// <returns>TRUE if keys are available</returns>
public static bool Contains(string login)
{
return keys.ContainsKey(login);
}
/// <summary>
/// Store keys and save it to disk if required.
/// </summary>
/// <param name="login">User login used with Minecraft.net</param>
/// <param name="playerKeyPair">User keys</param>
public static void Store(string login, PlayerKeyPair playerKeyPair)
{
if (Contains(login))
{
keys[login] = playerKeyPair;
}
else
{
keys.Add(login, playerKeyPair);
}
if (Settings.ProfileKeyCaching == CacheType.Disk && updatetimer.Enabled == true)
{
pendingadds.Add(new KeyValuePair<string, PlayerKeyPair>(login, playerKeyPair));
}
else if (Settings.ProfileKeyCaching == CacheType.Disk)
{
SaveToDisk();
}
}
/// <summary>
/// Retrieve keys for the given login.
/// </summary>
/// <param name="login">User login used with Minecraft.net</param>
/// <returns>PlayerKeyPair for given login</returns>
public static PlayerKeyPair Get(string login)
{
return keys[login];
}
/// <summary>
/// Initialize cache monitoring to keep cache updated with external changes.
/// </summary>
/// <returns>TRUE if keys are seeded from file</returns>
public static bool InitializeDiskCache()
{
cachemonitor = new FileMonitor(AppDomain.CurrentDomain.BaseDirectory, KeysCacheFilePlaintext, new FileSystemEventHandler(OnChanged));
updatetimer.Elapsed += HandlePending;
return LoadFromDisk();
}
/// <summary>
/// Reloads cache on external cache file change.
/// </summary>
/// <param name="sender">Sender</param>
/// <param name="e">Event data</param>
private static void OnChanged(object sender, FileSystemEventArgs e)
{
updatetimer.Stop();
updatetimer.Start();
}
/// <summary>
/// Called after timer elapsed. Reads disk cache and adds new/modified keys back.
/// </summary>
/// <param name="sender">Sender</param>
/// <param name="e">Event data</param>
private static void HandlePending(object sender, ElapsedEventArgs e)
{
updatetimer.Stop();
LoadFromDisk();
foreach (KeyValuePair<string, PlayerKeyPair> pending in pendingadds.ToArray())
{
Store(pending.Key, pending.Value);
pendingadds.Remove(pending);
}
}
/// <summary>
/// Reads cache file and loads KeysInfos into KeysCache.
/// </summary>
/// <returns>True if data is successfully loaded</returns>
private static bool LoadFromDisk()
{
//User-editable keys cache file in text format
if (File.Exists(KeysCacheFilePlaintext))
{
if (Settings.DebugMessages)
ConsoleIO.WriteLineFormatted(Translations.Get("cache.loading_keys", KeysCacheFilePlaintext));
try
{
foreach (string line in FileMonitor.ReadAllLinesWithRetries(KeysCacheFilePlaintext))
{
if (!line.Trim().StartsWith("#"))
{
int separatorIdx = line.IndexOf('=');
if (separatorIdx >= 1 && line.Length > separatorIdx + 1)
{
string login = line.Substring(0, separatorIdx);
string value = line.Substring(separatorIdx + 1);
try
{
PlayerKeyPair playerKeyPair = PlayerKeyPair.FromString(value);
keys[login] = playerKeyPair;
if (Settings.DebugMessages)
ConsoleIO.WriteLineFormatted(Translations.Get("cache.loaded_keys", playerKeyPair.ExpiresAt.ToString()));
}
catch (InvalidDataException e)
{
if (Settings.DebugMessages)
ConsoleIO.WriteLineFormatted(Translations.Get("cache.ignore_string_keys", value, e.Message));
}
catch (FormatException e)
{
if (Settings.DebugMessages)
ConsoleIO.WriteLineFormatted(Translations.Get("cache.ignore_string_keys", value, e.Message));
}
catch (ArgumentNullException e)
{
if (Settings.DebugMessages)
ConsoleIO.WriteLineFormatted(Translations.Get("cache.ignore_string_keys", value, e.Message));
}
}
else if (Settings.DebugMessages)
{
ConsoleIO.WriteLineFormatted(Translations.Get("cache.ignore_line_keys", line));
}
}
}
}
catch (IOException e)
{
ConsoleIO.WriteLineFormatted(Translations.Get("cache.read_fail_plain_keys", e.Message));
}
}
return keys.Count > 0;
}
/// <summary>
/// Saves player's keypair from KeysCache into cache file.
/// </summary>
private static void SaveToDisk()
{
if (Settings.DebugMessages)
Translations.WriteLineFormatted("cache.saving_keys");
List<string> KeysCacheLines = new List<string>();
KeysCacheLines.Add("# Generated by MCC v" + Program.Version + " - Keep it secret & Edit at own risk!");
KeysCacheLines.Add("# ProfileKey=PublicKey(base64),PublicKeySignature(base64),PublicKeySignatureV2(base64),PrivateKey(base64),ExpiresAt,RefreshAfter");
foreach (KeyValuePair<string, PlayerKeyPair> entry in keys)
KeysCacheLines.Add(entry.Key + '=' + entry.Value.ToString());
try
{
FileMonitor.WriteAllLinesWithRetries(KeysCacheFilePlaintext, KeysCacheLines);
}
catch (IOException e)
{
ConsoleIO.WriteLineFormatted(Translations.Get("cache.save_fail_keys", e.Message));
}
}
}
}

79
MinecraftClient/Protocol/ProfileKey/PlayerKeyPair.cs Normal file
View file

@ -0,0 +1,79 @@
using System;
using System.Collections.Generic;
using System.IO;
namespace MinecraftClient.Protocol.Keys
{
public class PlayerKeyPair
{
public PublicKey PublicKey;
public PrivateKey PrivateKey;
public DateTime ExpiresAt;
public DateTime RefreshedAfter; // Todo: add a timer
private const string DataTimeFormat = "O";
public PlayerKeyPair(PublicKey keyPublic, PrivateKey keyPrivate, string expiresAt, string refreshedAfter)
{
PublicKey = keyPublic;
PrivateKey = keyPrivate;
ExpiresAt = DateTime.Parse(expiresAt).ToUniversalTime();
RefreshedAfter = DateTime.Parse(refreshedAfter).ToUniversalTime();
}
public bool NeedRefresh()
{
return DateTime.Now.ToUniversalTime() > this.RefreshedAfter;
}
public bool IsExpired()
{
return DateTime.Now.ToUniversalTime() > this.ExpiresAt;
}
public long GetExpirationMilliseconds()
{
DateTimeOffset timeOffset = new(ExpiresAt);
return timeOffset.ToUnixTimeMilliseconds();
}
public long GetExpirationSeconds()
{
DateTimeOffset timeOffset = new(ExpiresAt);
return timeOffset.ToUnixTimeSeconds();
}
public static PlayerKeyPair FromString(string tokenString)
{
string[] fields = tokenString.Split(',');
if (fields.Length < 6)
throw new InvalidDataException("Invalid string format");
PublicKey publicKey = new PublicKey(pemKey: fields[0].Trim(),
sig: fields[1].Trim(), sigV2: fields[2].Trim());
PrivateKey privateKey = new PrivateKey(pemKey: fields[3].Trim());
return new PlayerKeyPair(publicKey, privateKey, fields[4].Trim(), fields[5].Trim());
}
public override string ToString()
{
List<string> datas = new List<string>();
datas.Add(Convert.ToBase64String(PublicKey.Key));
datas.Add(Convert.ToBase64String(PublicKey.Signature));
if (PublicKey.SignatureV2 == null)
datas.Add(String.Empty);
else
datas.Add(Convert.ToBase64String(PublicKey.SignatureV2));
datas.Add(Convert.ToBase64String(PrivateKey.Key));
datas.Add(ExpiresAt.ToString(DataTimeFormat));
datas.Add(RefreshedAfter.ToString(DataTimeFormat));
return String.Join(",", datas.ToArray());
}
}
}

39
MinecraftClient/Protocol/ProfileKey/PrivateKey.cs Normal file
View file

@ -0,0 +1,39 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
namespace MinecraftClient.Protocol.Keys
{
public class PrivateKey
{
public byte[] Key { get; set; }
private readonly RSA rsa;
public PrivateKey(string pemKey)
{
this.Key = KeyUtils.DecodePemKey(pemKey, "-----BEGIN RSA PRIVATE KEY-----", "-----END RSA PRIVATE KEY-----");
this.rsa = RSA.Create();
rsa.ImportPkcs8PrivateKey(this.Key, out _);
}
public byte[] SignData(byte[] data)
{
return rsa.SignData(data, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
}
public byte[] SignMessage(string message, string uuid, DateTimeOffset timestamp, ref byte[] salt)
{
string messageJson = "{\"text\":\"" + KeyUtils.EscapeString(message) + "\"}";
byte[] data = KeyUtils.GetSignatureData(messageJson, uuid, timestamp, ref salt);
return SignData(data);
}
}
}

54
MinecraftClient/Protocol/ProfileKey/PublicKey.cs Normal file
View file

@ -0,0 +1,54 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
namespace MinecraftClient.Protocol.Keys
{
public class PublicKey
{
public byte[] Key { get; set; }
public byte[] Signature { get; set; }
public byte[]? SignatureV2 { get; set; }
private readonly RSA rsa;
public PublicKey(string pemKey, string sig, string? sigV2 = null)
{
this.Key = KeyUtils.DecodePemKey(pemKey, "-----BEGIN RSA PUBLIC KEY-----", "-----END RSA PUBLIC KEY-----");
this.rsa = RSA.Create();
rsa.ImportSubjectPublicKeyInfo(this.Key, out _);
this.Signature = Convert.FromBase64String(sig);
if (!string.IsNullOrEmpty(sigV2))
this.SignatureV2 = Convert.FromBase64String(sigV2!);
}
public PublicKey(byte[] key, byte[] signature)
{
this.Key = key;
this.rsa = RSA.Create();
rsa.ImportSubjectPublicKeyInfo(this.Key, out _);
this.Signature = signature;
}
public bool VerifyData(byte[] data, byte[] signature)
{
return rsa.VerifyData(data, signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
}
public bool VerifyMessage(string message, string uuid, DateTimeOffset timestamp, ref byte[] salt, ref byte[] signature)
{
byte[] data = KeyUtils.GetSignatureData(message, uuid, timestamp, ref salt);
return VerifyData(data, signature);
}
}
}

20
MinecraftClient/Protocol/ProtocolHandler.cs
View file

@ -79,11 +79,11 @@ namespace MinecraftClient.Protocol
/// <param name="serverPort">Server Port to ping</param> /// <param name="serverPort">Server Port to ping</param>
/// <param name="protocolversion">Will contain protocol version, if ping successful</param> /// <param name="protocolversion">Will contain protocol version, if ping successful</param>
/// <returns>TRUE if ping was successful</returns> /// <returns>TRUE if ping was successful</returns>
public static bool GetServerInfo(string serverIP, ushort serverPort, ref int protocolversion, ref ForgeInfo forgeInfo) public static bool GetServerInfo(string serverIP, ushort serverPort, ref int protocolversion, ref ForgeInfo? forgeInfo)
{ {
bool success = false; bool success = false;
int protocolversionTmp = 0; int protocolversionTmp = 0;
ForgeInfo forgeInfoTmp = null; ForgeInfo? forgeInfoTmp = null;
if (AutoTimeout.Perform(() => if (AutoTimeout.Perform(() =>
{ {
try try
@ -127,11 +127,15 @@ namespace MinecraftClient.Protocol
public static IMinecraftCom GetProtocolHandler(TcpClient Client, int ProtocolVersion, ForgeInfo forgeInfo, IMinecraftComHandler Handler) public static IMinecraftCom GetProtocolHandler(TcpClient Client, int ProtocolVersion, ForgeInfo forgeInfo, IMinecraftComHandler Handler)
{ {
int[] supportedVersions_Protocol16 = { 51, 60, 61, 72, 73, 74, 78 }; int[] supportedVersions_Protocol16 = { 51, 60, 61, 72, 73, 74, 78 };
if (Array.IndexOf(supportedVersions_Protocol16, ProtocolVersion) > -1) if (Array.IndexOf(supportedVersions_Protocol16, ProtocolVersion) > -1)
return new Protocol16Handler(Client, ProtocolVersion, Handler); return new Protocol16Handler(Client, ProtocolVersion, Handler);
int[] supportedVersions_Protocol18 = { 4, 5, 47, 107, 108, 109, 110, 210, 315, 316, 335, 338, 340, 393, 401, 404, 477, 480, 485, 490, 498, 573, 575, 578, 735, 736, 751, 753, 754, 755, 756, 757, 758 };
int[] supportedVersions_Protocol18 = { 4, 5, 47, 107, 108, 109, 110, 210, 315, 316, 335, 338, 340, 393, 401, 404, 477, 480, 485, 490, 498, 573, 575, 578, 735, 736, 751, 753, 754, 755, 756, 757, 758, 759 };
if (Array.IndexOf(supportedVersions_Protocol18, ProtocolVersion) > -1) if (Array.IndexOf(supportedVersions_Protocol18, ProtocolVersion) > -1)
return new Protocol18Handler(Client, ProtocolVersion, Handler, forgeInfo); return new Protocol18Handler(Client, ProtocolVersion, Handler, forgeInfo);
throw new NotSupportedException(Translations.Get("exception.version_unsupport", ProtocolVersion)); throw new NotSupportedException(Translations.Get("exception.version_unsupport", ProtocolVersion));
} }
@ -257,6 +261,8 @@ namespace MinecraftClient.Protocol
return 757; return 757;
case "1.18.2": case "1.18.2":
return 758; return 758;
case "1.19":
return 759;
default: default:
return 0; return 0;
} }
@ -322,6 +328,7 @@ namespace MinecraftClient.Protocol
case 756: return "1.17.1"; case 756: return "1.17.1";
case 757: return "1.18.1"; case 757: return "1.18.1";
case 758: return "1.18.2"; case 758: return "1.18.2";
case 759: return "1.19";
default: return "0.0"; default: return "0.0";
} }
} }
@ -815,9 +822,9 @@ namespace MinecraftClient.Protocol
/// <returns>HTTP Status code</returns> /// <returns>HTTP Status code</returns>
private static int DoHTTPSRequest(List<string> headers, string host, ref string result) private static int DoHTTPSRequest(List<string> headers, string host, ref string result)
{ {
string postResult = null; string? postResult = null;
int statusCode = 520; int statusCode = 520;
Exception exception = null; Exception? exception = null;
AutoTimeout.Perform(() => AutoTimeout.Perform(() =>
{ {
try try
@ -859,7 +866,8 @@ namespace MinecraftClient.Protocol
} }
} }
}, TimeSpan.FromSeconds(30)); }, TimeSpan.FromSeconds(30));
result = postResult; if (postResult != null)
result = postResult;
if (exception != null) if (exception != null)
throw exception; throw exception;
return statusCode; return statusCode;

4
MinecraftClient/Protocol/ReplayHandler.cs
View file

@ -307,7 +307,7 @@ namespace MinecraftClient.Protocol
if (isLogin && packetID == 0x02) if (isLogin && packetID == 0x02)
{ {
Guid uuid; Guid uuid;
if (protocolVersion < Protocol18Handler.MC116Version) if (protocolVersion < Protocol18Handler.MC_1_16_Version)
{ {
if (Guid.TryParse(dataTypes.ReadNextString(p), out uuid)) if (Guid.TryParse(dataTypes.ReadNextString(p), out uuid))
{ {
@ -350,7 +350,7 @@ namespace MinecraftClient.Protocol
playerLastPitch = pitch; playerLastPitch = pitch;
playerLastYaw = yaw; playerLastYaw = yaw;
if (protocolVersion >= Protocol18Handler.MC18Version) if (protocolVersion >= Protocol18Handler.MC_1_8_Version)
{ {
playerLastPosition.X = (locMask & 1 << 0) != 0 ? playerLastPosition.X + x : x; playerLastPosition.X = (locMask & 1 << 0) != 0 ? playerLastPosition.X + x : x;
playerLastPosition.Y = (locMask & 1 << 1) != 0 ? playerLastPosition.Y + y : y; playerLastPosition.Y = (locMask & 1 << 1) != 0 ? playerLastPosition.Y + y : y;

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

@ -251,7 +251,7 @@ namespace MinecraftClient.Protocol.Session
Translations.WriteLineFormatted("cache.saving"); Translations.WriteLineFormatted("cache.saving");
List<string> sessionCacheLines = new List<string>(); List<string> sessionCacheLines = new List<string>();
sessionCacheLines.Add("# Generated by MCC v" + Program.Version + " - 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");
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());

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

@ -36,6 +36,7 @@ terrainandmovements=false # Uses more ram, cpu, bandwidth but allows yo
inventoryhandling=false # Toggle inventory handling (beta) inventoryhandling=false # Toggle inventory handling (beta)
entityhandling=false # Toggle entity handling (beta) entityhandling=false # Toggle entity handling (beta)
sessioncache=disk # How to retain session tokens. Use 'none', 'memory' or 'disk' sessioncache=disk # How to retain session tokens. Use 'none', 'memory' or 'disk'
profilekeycache=disk # How to retain profile key. Use 'none', 'memory' or 'disk'
resolvesrvrecords=fast # Use 'false', 'fast' (5s timeout), or 'true'. Required for joining some servers. resolvesrvrecords=fast # Use 'false', 'fast' (5s timeout), or 'true'. Required for joining some servers.
accountlist=accounts.txt # See README > 'Servers and Accounts file' for more info about this file accountlist=accounts.txt # See README > 'Servers and Accounts file' for more info about this file
serverlist=servers.txt # See README > 'Servers and Accounts file' for more info about this file serverlist=servers.txt # See README > 'Servers and Accounts file' for more info about this file
@ -47,6 +48,18 @@ autorespawn=false # Toggle auto respawn if client player was de
minecraftrealms=true # Enable support for joining Minecraft Realms worlds minecraftrealms=true # 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]
# Chat settings (affects minecraft 1.19+)
login_with_secure_profile=true # Microsoft accounts only. If disabled, will not be able to sign chat and join servers configured with "enforce-secure-profile=true"
sign_chat=true # Whether to sign the chat send from MCC
sign_message_in_command=true # Whether to sign the messages contained in the commands sent by MCC. For example, the message in "/msg" and "/me"
mark_legally_signed_msg=false # Use green color block to mark chat with legitimate signatures
mark_modified_msg=true # Use yellow color block to mark chat that have been modified by the server.
mark_illegally_signed_msg=true # Use red color block to mark chat without legitimate signature
mark_system_message=false # Use gray color block to mark system message (always without signature)
show_modified_chat=true # Set to true to display messages modified by the server, false to display the original signed messages
show_illegal_signed_chat=true # Whether to display chat and messages in commands without legal signatures
[Logging] [Logging]
# Only affect the messages on console. # Only affect the messages on console.
debugmessages=false # Please enable this before submitting bug reports. Thanks! debugmessages=false # Please enable this before submitting bug reports. Thanks!

13
MinecraftClient/Resources/lang/en.ini
View file

@ -8,7 +8,10 @@ mcc.password_hidden=Password : {0}
mcc.offline=§8You chose to run in offline mode. mcc.offline=§8You chose to run in offline mode.
mcc.session_invalid=§8Cached session is invalid or expired. mcc.session_invalid=§8Cached session is invalid or expired.
mcc.session_valid=§8Cached session is still valid for {0}. mcc.session_valid=§8Cached session is still valid for {0}.
mcc.profile_key_invalid=§8Cached profile key needs to be refreshed.
mcc.profile_key_valid=§8Cached profile key is still valid for {0}.
mcc.connecting=Connecting to {0}... mcc.connecting=Connecting to {0}...
mcc.fetching_key=Fetching profile key from Microsoft.
mcc.ip=Server IP : mcc.ip=Server IP :
mcc.use_version=§8Using Minecraft version {0} (protocol v{1}) mcc.use_version=§8Using Minecraft version {0} (protocol v{1})
mcc.unknown_version=§8Unknown or not supported MC version {0}.\nSwitching to autodetection mode. mcc.unknown_version=§8Unknown or not supported MC version {0}.\nSwitching to autodetection mode.
@ -48,6 +51,8 @@ mcc.realms_join=Use realms:<index> as server IP to join a Realms world
debug.color_test=Color test: Your terminal should display {0} debug.color_test=Color test: Your terminal should display {0}
debug.session_cache_ok=§8Session data has been successfully loaded from disk. debug.session_cache_ok=§8Session data has been successfully loaded from disk.
debug.session_cache_fail=§8No sessions could be loaded from disk debug.session_cache_fail=§8No sessions could be loaded from disk
debug.keys_cache_ok=§8Profile keys has been successfully loaded from disk.
debug.keys_cache_fail=§8No profile keys could be loaded from disk
debug.session_id=Success. (session ID: {0}) debug.session_id=Success. (session ID: {0})
debug.crypto=§8Crypto keys & hash generated. debug.crypto=§8Crypto keys & hash generated.
debug.request=§8Performing request to {0} debug.request=§8Performing request to {0}
@ -173,6 +178,14 @@ cache.ignore_line=§8Ignoring invalid session token line: {0}
cache.read_fail_plain=§8Failed to read session cache from disk: {0} cache.read_fail_plain=§8Failed to read session cache from disk: {0}
cache.saving=§8Saving session cache to disk cache.saving=§8Saving session cache to disk
cache.save_fail=§8Failed to write session cache to disk: {0} cache.save_fail=§8Failed to write session cache to disk: {0}
# Profile Key Cache
cache.loading_keys=§8Loading profile key cache from disk: {0}
cache.loaded_keys=§8Loaded profile key, it will be refresh at {0}
cache.ignore_string_keys=§8Ignoring profile key token string '{0}': {1}
cache.ignore_line_keys=§8Ignoring invalid profile key token line: {0}
cache.read_fail_plain_keys=§8Failed to read profile key cache from disk: {0}
cache.saving_keys=§8Saving profile key cache to disk
cache.save_fail_keys=§8Failed to write profile key cache to disk: {0}
[proxy] [proxy]
proxy.connected=§8Connected to proxy {0}:{1} proxy.connected=§8Connected to proxy {0}:{1}

12
MinecraftClient/Resources/lang/zh-CHS.ini
View file

@ -8,6 +8,8 @@ mcc.password_hidden=密码：{0}
mcc.offline=§8您正在使用离线模式。 mcc.offline=§8您正在使用离线模式。
mcc.session_invalid=§8缓存无效或已过期。 mcc.session_invalid=§8缓存无效或已过期。
mcc.session_valid=§8{0}的缓存仍然有效。 mcc.session_valid=§8{0}的缓存仍然有效。
mcc.profile_key_invalid=§8缓存的聊天签名密钥需要刷新。
mcc.profile_key_valid=§8{0}的聊天签名密钥缓存仍然有效.
mcc.connecting=正在连接至{0}... mcc.connecting=正在连接至{0}...
mcc.ip=服务器IP： mcc.ip=服务器IP：
mcc.use_version=§8正在运行Minecraft版本{0} (v{1}协议) mcc.use_version=§8正在运行Minecraft版本{0} (v{1}协议)
@ -48,6 +50,8 @@ mcc.realms_join=请使用realms:<序号>作为服务器IP加入Realms世界
debug.color_test=颜色测试：终端应该显示的颜色是：{0} debug.color_test=颜色测试：终端应该显示的颜色是：{0}
debug.session_cache_ok=§8已成功从磁盘中加载会话数据。 debug.session_cache_ok=§8已成功从磁盘中加载会话数据。
debug.session_cache_fail=§8无法从磁盘加载会话 debug.session_cache_fail=§8无法从磁盘加载会话
debug.keys_cache_ok=§8已成功从磁盘中加载聊天签名密钥。
debug.keys_cache_fail=§8无法从磁盘中加载聊天签名密钥。
debug.session_id=成功！(会话ID：{0}) debug.session_id=成功！(会话ID：{0})
debug.crypto=§8密钥和哈希值已生成： debug.crypto=§8密钥和哈希值已生成：
debug.request=§8正在请求{0} debug.request=§8正在请求{0}
@ -173,6 +177,14 @@ cache.ignore_line=§8忽略无效的会话令牌行：{0}
cache.read_fail_plain=§8无法从磁盘读取会话缓存：{0} cache.read_fail_plain=§8无法从磁盘读取会话缓存：{0}
cache.saving=§8将会话缓存保存到磁盘 cache.saving=§8将会话缓存保存到磁盘
cache.save_fail=§8无法将会话缓存写入磁盘：{0} cache.save_fail=§8无法将会话缓存写入磁盘：{0}
# Profile Key Cache
cache.loading_keys=§8从磁盘加载聊天签名密钥缓存: {0}
cache.loaded_keys=§8已加载签名密钥，下次刷新于 {0}
cache.ignore_string_keys=§8忽略聊天签名密钥字符串 '{0}'：{1}
cache.ignore_line_keys=§8忽略无效的聊天签名密钥行：{0}
cache.read_fail_plain_keys=§8无法从磁盘读取聊天签名密钥缓存：{0}
cache.saving_keys=§8将聊天签名密钥保存到磁盘
cache.save_fail_keys=§8无法将聊天签名密钥写入磁盘：{0}
[proxy] [proxy]
proxy.connected=§8已连接到代理{0}:{1} proxy.connected=§8已连接到代理{0}:{1}

4
MinecraftClient/Scripting/ChatBot.cs
View file

@ -144,7 +144,7 @@ namespace MinecraftClient
/// </remarks> /// </remarks>
/// <param name="text">Text from the server</param> /// <param name="text">Text from the server</param>
/// <param name="json">Raw JSON from the server. This parameter will be NULL on MC 1.5 or lower!</param> /// <param name="json">Raw JSON from the server. This parameter will be NULL on MC 1.5 or lower!</param>
public virtual void GetText(string text, string json) { } public virtual void GetText(string text, string? json) { }
/// <summary> /// <summary>
/// Is called when the client has been disconnected fom the server /// Is called when the client has been disconnected fom the server
@ -359,7 +359,7 @@ namespace MinecraftClient
/// </summary> /// </summary>
/// <param name="uuid">UUID of the player</param> /// <param name="uuid">UUID of the player</param>
/// <param name="name">Name of the player</param> /// <param name="name">Name of the player</param>
public virtual void OnPlayerLeave(Guid uuid, string name) { } public virtual void OnPlayerLeave(Guid uuid, string? name) { }
/// <summary> /// <summary>
/// Called when the player deaths /// Called when the player deaths

35
MinecraftClient/Settings.cs
View file

@ -97,6 +97,7 @@ namespace MinecraftClient
public static bool InventoryHandling = false; public static bool InventoryHandling = false;
public static string PrivateMsgsCmdName = "tell"; public static string PrivateMsgsCmdName = "tell";
public static CacheType SessionCaching = CacheType.Disk; public static CacheType SessionCaching = CacheType.Disk;
public static CacheType ProfileKeyCaching = CacheType.Disk;
public static bool ResolveSrvRecords = true; public static bool ResolveSrvRecords = true;
public static bool ResolveSrvRecordsShortTimeout = true; public static bool ResolveSrvRecordsShortTimeout = true;
public static bool EntityHandling = false; public static bool EntityHandling = false;
@ -104,6 +105,17 @@ namespace MinecraftClient
public static bool MinecraftRealmsEnabled = true; public static bool MinecraftRealmsEnabled = true;
public static bool MoveHeadWhileWalking = true; public static bool MoveHeadWhileWalking = true;
// Signature
public static bool LoginWithSecureProfile = true;
public static bool SignChat = true;
public static bool SignMessageInCommand = true;
public static bool MarkLegallySignedMsg = false;
public static bool MarkModifiedMsg = true;
public static bool MarkIllegallySignedMsg = true;
public static bool MarkSystemMessage = false;
public static bool ShowModifiedChat = true;
public static bool ShowIllegalSignedChat = true;
// Logging // Logging
public enum FilterModeEnum { Blacklist, Whitelist } public enum FilterModeEnum { Blacklist, Whitelist }
public static bool DebugMessages = false; public static bool DebugMessages = false;
@ -220,7 +232,7 @@ namespace MinecraftClient
private static string ServerAliasTemp = null; private static string ServerAliasTemp = null;
//Mapping for settings sections in the INI file //Mapping for settings sections in the INI file
private enum Section { Default, Main, AppVars, Proxy, MCSettings, AntiAFK, Hangman, Alerts, ChatLog, AutoRelog, ScriptScheduler, RemoteControl, ChatFormat, AutoRespond, AutoAttack, AutoFishing, AutoEat, AutoCraft, AutoDrop, Mailer, ReplayMod, Logging }; private enum Section { Default, Main, AppVars, Proxy, MCSettings, AntiAFK, Hangman, Alerts, ChatLog, AutoRelog, ScriptScheduler, RemoteControl, ChatFormat, AutoRespond, AutoAttack, AutoFishing, AutoEat, AutoCraft, AutoDrop, Mailer, ReplayMod, Logging, Signature };
/// <summary> /// <summary>
/// Get settings section from name /// Get settings section from name
@ -398,6 +410,12 @@ namespace MinecraftClient
else if (argValue == "disk") { SessionCaching = CacheType.Disk; } else if (argValue == "disk") { SessionCaching = CacheType.Disk; }
return true; return true;
case "profilekeycache":
if (argValue == "none") { ProfileKeyCaching = CacheType.None; }
else if (argValue == "memory") { ProfileKeyCaching = CacheType.Memory; }
else if (argValue == "disk") { ProfileKeyCaching = CacheType.Disk; }
return true;
case "accountlist": case "accountlist":
if (File.Exists(argValue)) if (File.Exists(argValue))
{ {
@ -485,6 +503,21 @@ namespace MinecraftClient
} }
break; break;
case Section.Signature:
switch (argName.ToLower())
{
case "login_with_secure_profile": LoginWithSecureProfile = str2bool(argValue); return true;
case "sign_chat": SignChat = str2bool(argValue); return true;
case "sign_message_in_command": SignMessageInCommand = str2bool(argValue); return true;
case "mark_legally_signed_msg": MarkLegallySignedMsg = str2bool(argValue); return true;
case "mark_modified_msg": MarkModifiedMsg = str2bool(argValue); return true;
case "mark_illegally_signed_msg": MarkIllegallySignedMsg = str2bool(argValue); return true;
case "mark_system_message": MarkSystemMessage = str2bool(argValue); return true;
case "show_modified_chat": ShowModifiedChat = str2bool(argValue); return true;
case "show_illegal_signed_chat": ShowIllegalSignedChat = str2bool(argValue); return true;
}
break;
case Section.Logging: case Section.Logging:
switch (argName.ToLower()) switch (argName.ToLower())
{ {

4
MinecraftClient/Translations.cs
View file

@ -120,7 +120,9 @@ namespace MinecraftClient
string systemLanguage = string.IsNullOrEmpty(CultureInfo.CurrentCulture.Parent.Name) // Parent.Name might be empty string systemLanguage = string.IsNullOrEmpty(CultureInfo.CurrentCulture.Parent.Name) // Parent.Name might be empty
? CultureInfo.CurrentCulture.Name ? CultureInfo.CurrentCulture.Name
: CultureInfo.CurrentCulture.Parent.Name; : CultureInfo.CurrentCulture.Parent.Name;
string langDir = AppDomain.CurrentDomain.BaseDirectory + Path.DirectorySeparatorChar + translationFilePath + Path.DirectorySeparatorChar; string baseDir = AppDomain.CurrentDomain.BaseDirectory;
string langDir = baseDir + ((baseDir.EndsWith(Path.DirectorySeparatorChar) ? String.Empty : Path.DirectorySeparatorChar) +
translationFilePath + Path.DirectorySeparatorChar);
string langFileSystemLanguage = langDir + systemLanguage + ".ini"; string langFileSystemLanguage = langDir + systemLanguage + ".ini";
string langFileConfigLanguage = langDir + language + ".ini"; string langFileConfigLanguage = langDir + language + ".ini";