Batuik • バツイク

Good morning nostr

# GOOᗪ ᗯEEKEᑎᗪ ᑎOᔕTᖇ

Its not that I hadn't realized 🥭-man is an asshat. I just never expected the man to actually be retarded. News out if USA are just getting stranger and stranger by the day, and honestly, 3 more years of this shit will be very tough to go through. Let's just hope we're all even alive after 3 more years, with this guy fully willing to gamble world peace away, accompanied by lies and deceptuin, just to seem like he's a tough guy. You're a tough guy alright, don't have to prove it by destroying the world.

GM

```csharp // --------------------------------------------------------------- // Fast AES‑128 (single‑block) – stackalloc + unsafe // --------------------------------------------------------------- using System; using System.Runtime.CompilerServices; namespace FastAes { public static unsafe class Aes128Fast { // ----------------------------------------------------------------- // 1. Tables (S‑box and MixColumns multiplication tables) // ----------------------------------------------------------------- private static readonly byte[] sbox = new byte[256] { 0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76, 0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0, 0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15, 0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75, 0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84, 0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf, 0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8, 0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2, 0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73, 0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb, 0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79, 0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08, 0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a, 0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e, 0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf, 0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16 }; // Multiplication by 2 and 3 in GF(2^8) – used by MixColumns. // Pre‑computing avoids the branch in the classic xtime(). private static readonly byte[] mul2 = new byte[256]; private static readonly byte[] mul3 = new byte[256]; // Round constants (Rcon) – only the first 10 are needed for AES‑128. private static readonly uint[] rcon = new uint[11] { 0x00000000, 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0x1B000000, 0x36000000 }; // ----------------------------------------------------------------- // 2. Static constructor – fill the multiplication tables once // ----------------------------------------------------------------- static Aes128Fast() { for (int i = 0; i < 256; i++) { int x = i << 1; if ((x & 0x100) != 0) x ^= 0x11B; // reduce modulo the AES polynomial mul2[i] = (byte)(x & 0xFF); mul3[i] = (byte)(mul2[i] ^ i); } } // ----------------------------------------------------------------- // 3. Public entry point – encrypt a single 16‑byte block // ----------------------------------------------------------------- /// <summary> /// Encrypts exactly one 16‑byte block. Caller must ensure /// input, output and key are all 16 bytes long. /// </summary> public static void EncryptBlock( byte* input, // pointer to 16‑byte plaintext byte* output, // pointer to 16‑byte ciphertext buffer byte* key) // pointer to 16‑byte key { // ------------------------------------------------------------- // 3.1 Expand the key (produces 11 round keys = 44 uints) // ------------------------------------------------------------- uint* roundKeys = stackalloc uint[44]; // 44 * 4 = 176 bytes on the stack KeyExpansion(key, roundKeys); // ------------------------------------------------------------- // 3.2 Load the state matrix (column‑major) into four uints // ------------------------------------------------------------- uint* state = stackalloc uint[4]; for (int c = 0; c < 4; c++) state[c] = *(uint*)(input + 4 * c); // little‑endian load matches BitConverter // ------------------------------------------------------------- // 3.3 Initial AddRoundKey (round 0) // ------------------------------------------------------------- for (int c = 0; c < 4; c++) state[c] ^= roundKeys[c]; // ------------------------------------------------------------- // 3.4 Main rounds 1 … 9 (full round) // ------------------------------------------------------------- for (int round = 1; round < 10; round++) { SubBytes(state); ShiftRows(state); MixColumns(state); for (int c = 0; c < 4; c++) state[c] ^= roundKeys[round * 4 + c]; } // ------------------------------------------------------------- // 3.5 Final round (no MixColumns) // ------------------------------------------------------------- SubBytes(state); ShiftRows(state); for (int c = 0; c < 4; c++) state[c] ^= roundKeys[40 + c]; // round 10 // ------------------------------------------------------------- // 3.6 Store ciphertext back to the output buffer // ------------------------------------------------------------- for (int c = 0; c < 4; c++) *(uint*)(output + 4 * c) = state[c]; } // ----------------------------------------------------------------- // 4. Key schedule (expands 16‑byte key to 44 uints) // ----------------------------------------------------------------- private static void KeyExpansion(byte* keyPtr, uint* w) { // Copy the original key (big‑endian per AES spec) for (int i = 0; i < 4; i++) w[i] = ((uint)keyPtr[4 * i] << 24) | ((uint)keyPtr[4 * i + 1] << 16) | ((uint)keyPtr[4 * i + 2] << 8) | ((uint)keyPtr[4 * i + 3]); for (int i = 4; i < 44; i++) { uint temp = w[i - 1]; if ((i & 3) == 0) // i % 4 == 0 { // RotWord temp = (temp << 8) | (temp >> 24); // SubWord temp = (uint)( sbox[(temp >> 24) & 0xFF] << 24 | sbox[(temp >> 16) & 0xFF] << 16 | sbox[(temp >> 8 ) & 0xFF] << 8 | sbox[(temp ) & 0xFF]); // Rcon temp ^= rcon[i / 4]; } w[i] = w[i - 4] ^ temp; } } // ----------------------------------------------------------------- // 5. Core AES transformations (operating on the 4‑column state) // ----------------------------------------------------------------- [MethodImpl(MethodImplOptions.AggressiveInlining)] private static void SubBytes(uint* state) { for (int i = 0; i < 4; i++) { uint v = state[i]; state[i] = (uint)sbox[(v >> 24) & 0xFF] << 24 | (uint)sbox[(v >> 16) & 0xFF] << 16 | (uint)sbox[(v >> 8 ) & 0xFF] << 8 | (uint)sbox[(v ) & 0xFF]; } } // ShiftRows works on the logical 4×4 byte matrix. // Because our state is column‑major, we can implement it by // rotating the bytes inside each column appropriately. [MethodImpl(MethodImplOptions.AggressiveInlining)] private static void ShiftRows(uint* state) { // Extract the four rows into separate byte variables. // We'll rebuild the columns after the rotations. byte b00 = (byte)(state[0] >> 24); byte b01 = (byte)(state[1] >> 24); byte b02 = (byte)(state[2] >> 24); byte b03 = (byte)(state[3] >> 24); byte b10 = (byte)(state[0] >> 16); byte b11 = (byte)(state[1] >> 16); byte b12 = (byte)(state[2] >> 16); byte b13 = (byte)(state[3] >> 16); byte b20 = (byte)(state[0] >> 8); byte b21 = (byte)(state[1] >> 8); byte b22 = (byte)(state[2] >> 8); byte b23 = (byte)(state[3] >> 8); byte b30 = (byte)(state[0]); byte b31 = (byte)(state[1]); byte b32 = (byte)(state[2]); byte b33 = (byte)(state[3]); // Row 0 stays unchanged. // Row 1 rotates left by 1. byte t10 = b11, t11 = b12, t12 = b13, t13 = b10; // Row 2 rotates left by 2. byte t20 = b22, t21 = b23, t22 = b20, t23 = b21; // Row 3 rotates left by 3 (or right by 1). byte t30 = b33, t31 = b30, t32 = b31, t33 = b32; // Re‑pack columns. state[0] = (uint)(b00 << 24 | t10 << 16 | t20 << 8 | t30); state[1] = (uint)(b01 << 24 | t11 << 16 | t21 << 8 | t31); state[2] = (uint)(b02 << 24 | t12 << 16 | t22 << 8 | t32); state[3] = (uint)(b03 << 24 | t13 << 16 | t23 << 8 | t33); } // MixColumns uses the pre‑computed mul2/mul3 tables. [MethodImpl(MethodImplOptions.AggressiveInlining)] private static void MixColumns(uint* state) { for (int c = 0; c < 4; c++) { uint col = state[c]; byte a0 = (byte)(col >> 24); byte a1 = (byte)(col >> 16); byte a2 = (byte)(col >> 8); byte a3 = (byte)(col); // The AES mix‑column matrix: // [02 03 01 01] // [01 02 03 01] // [01 01 02 03] // [03 01 01 02] byte r0 = (byte)(mul2[a0] ^ mul3[a1] ^ a2 ^ a3); byte r1 = (byte)(a0 ^ mul2[a1] ^ mul3[a2] ^ a3); byte r2 = (byte)(a0 ^ a1 ^ mul2[a2] ^ mul3[a3]); byte r3 = (byte)(mul3[a0] ^ a1 ^ a2 ^ mul2[a3]); state[c] = (uint)(r0 << 24 | r1 << 16 | r2 << 8 | r3); } } } } ```

Goooood morning nostr ☀️