Fortnite camera decryption

decrypt.cpp

		typedef uint8_t _BYTE;
		typedef uint16_t _OWORD;
		typedef uint32_t _DWORD;
		typedef uint64_t _QWORD;	


		template<typename T>
		auto read(uintptr_t addr) -> T
		{
			return *(T*)(addr);
		}
		template<typename T>
		auto write(uintptr_t addr, T what) -> T
		{
			return *(T*)(addr) = what;
		}

		char __fastcall sub_5D1E2EC(_BYTE* a1, __int64 a2)
		{
			_BYTE* v2; // r8
			_BYTE* v3; // r9
			__int64 v4; // r10
			__int64 v5; // rdx
			unsigned __int8 v6; // cl
			char result; // al
			__int64 v8; // rdx

			v2 = a1 + 9;
			v3 = a1;
			v4 = 28i64;
			byte byte_B47D448 = read<byte>(fn::base + 0xB47D448);

			if (byte_B47D448)
			{
				v5 = a2 - (_QWORD)a1;
				do
				{
					v6 = v3[9];
					result = 16 * v6;
					v3[v5] = (16 * v6) | (*v3 ^ (v6 >> 4)) & 0xF;
					++v3;
					--v4;
				} while (v4);
			}
			else
			{
				v8 = a2 - (_QWORD)v2;
				do
				{
					result = *v2 ^ *(v2 - 9);
					(v2++)[v8] = result;
					--v4;
				} while (v4);
			}
			return result;
		}
		void __fastcall decrypt_camera(__int64 a1, __int64 a2)
		{
			char v2; // al
			__int64 v4; // r8
			int v5; // eax
			int v6; // ebx
			__int64 v7; // rax
			int v8; // edx
			__int64 v9; // r9
			_BYTE* v10; // rcx
			__int64 v11; // r8
			char v12; // al
			__int64 v13; // rax
			int v14; // edx
			__int64 v15; // r9
			_BYTE* v16; // rcx
			__int64 v17; // r8
			char v18; // al
			int v19; // ecx
			_BYTE* v20; // rdx
			__int64 v21; // r8
			char v22; // al
			int v23; // ecx
			__int64 v24; // r9
			char v25; // r10
			_BYTE* v26; // r11
			int v27; // eax
			char v28; // cl
			int v29; // eax
			__int64 v30; // rax
			int v31; // ecx
			__int64 v32; // r9
			_BYTE* v33; // rdx
			char v34; // al
			char v35; // al
			__int64 v36; // rdx
			void* v37; // r9
			_BYTE* v38; // r10
			int v39; // eax

			v2 = read<_BYTE>(a1 + 0x3120);
			write<_BYTE>(a1 + 0x3121, read<_BYTE>(a1 + 0x3121) + 9);
			v4 = (v2 + 1) & 3;
			v5 = read<_BYTE>(a1 + 0x3121) - 0x417E;
			write<_BYTE>(a1 + 0x3120, v4);
			write<_DWORD>(a1 + 4 * v4 + 0x3110, (v5 | 6) ^ 3);
			/* copy data */
			for (int i = 0; i < 0x1504; i++)
				((char*)a2)[i] = read<char>(a1 + 0x1c30 + i);
			v6 = 0;
			auto byte_B47D491 = read<char>(fn::base + 0xB47D491);
			auto byte_B543550 = read<_BYTE>(fn::base + 0xB543550);
			auto byte_B543551 = read<char>(fn::base + 0xB543551);
			auto qword_B543554 = read<_QWORD>(fn::base + 0xB543554);
			auto unk_B543574 = read<_BYTE>(fn::base + 0xB543574);
			auto unk_8F34C71 = read<_QWORD>(fn::base + 0x8F34C71);

			if (byte_B47D491 = read<char>(fn::base + 0xB47D491))
			{
				switch (byte_B47D491)
				{
				case 1:
					if ((byte_B543550 & 8) != 0 && (byte_B543551 & 0x40) != 0)
					{
						v30 = qword_B543554;
					}
					else
					{
						byte_B543550 |= 8u;
						byte_B543551 |= 0x40u;
						v30 = (uintptr_t)malloc(84i64);
						qword_B543554 = v30;
					}
					v31 = 0x234431;
					v32 = v30 + 28 - a2;
					v33 = (_BYTE*)a2;
					do
					{
						v34 = v31;
						v31 ^= v6 ^ 0xFEDCBA98;
						v35 = (v33[v32] ^ v34) - v6++;
						*v33++ = v35;
					} while (v6 < 28);
					break;
				case 2:
					if ((byte_B543550 & 8) != 0 && (byte_B543551 & 0x40) != 0)
					{
						v24 = qword_B543554;
					}
					else
					{
						byte_B543550 |= 8u;
						byte_B543551 |= 0x40u;
						v24 = (uintptr_t)malloc(84i64);
						qword_B543554 = v24;
					}
					v25 = -116;
					v26 = (_BYTE*)a2;
					do
					{
						v27 = 28;
						v28 = v25;
						if (v6 % 3u != 1)
							v27 = 56;
						v25 += 17;
						v29 = v6 + v27;
						++v6;
						*v26++ = read<_BYTE>(v29 + v24) ^ v28;
					} while (v6 < 28);
					break;
				case 3:
					v19 = 76270177;
					v20 = &unk_B543574;
					v21 = 0i64;
					do
					{
						v22 = *v20-- + v19;
						write<_BYTE>(v21 + a2, v22);
						v23 = (4 * v6++) ^ v19;
						v19 = v23 ^ 1;
						++v21;
					} while ((__int64)v20 > (__int64)&qword_B543554 + 4);
					break;
				case 4:
					if ((byte_B543550 & 8) != 0 && (byte_B543551 & 0x40) != 0)
					{
						v13 = qword_B543554;
					}
					else
					{
						byte_B543550 |= 8u;
						byte_B543551 |= 0x40u;
						v13 = (_QWORD)malloc(84i64);
						qword_B543554 = v13;
					}
					v14 = -1074344051;
					v15 = v13 + 56 - a2;
					v16 = (_BYTE*)a2;
					v17 = 28i64;
					do
					{
						v18 = v16[v15] - v14;
						v14 += 5;
						*v16++ = ~v18;
						--v17;
					} while (v17);
					break;
				case 5:
					if ((byte_B543550 & 8) != 0 && (byte_B543551 & 0x40) != 0)
					{
						v7 = qword_B543554;
					}
					else
					{
						byte_B543550 |= 8u;
						byte_B543551 |= 0x40u;
						v7 = (uintptr_t)malloc(84i64);
						qword_B543554 = v7;
					}
					v8 = 425671100;
					v9 = v7 + 28 - a2;
					v10 = (_BYTE*)a2;
					v11 = 28i64;
					do
					{
						v12 = v8;
						v8 += v6;
						v6 += 16;
						*v10 = v10[v9] ^ v12;
						++v10;
						--v11;
					} while (v11);
					break;
				default:
					sub_5D1E2EC(&byte_B543550, a2);
					break;
				}
			}
			else
			{
				if ((byte_B543550 & 8) != 0 && (byte_B543551 & 0x40) != 0)
				{
					v36 = qword_B543554;
				}
				else
				{
					byte_B543550 |= 8u;
					byte_B543551 |= 0x40u;
					v36 = (uintptr_t)malloc(0x54i64);
					qword_B543554 = v36;
				}
				v37 = &unk_8F34C71;
				v38 = (_BYTE*)a2;
				do
				{
					*v38 = read<_BYTE>(14 * ((v6 & 1u) + 1) - (unsigned __int64)(unsigned int)v6 + v36 + 28) - (_BYTE)v37;
					v39 = 16 * v6++;
					++v38;
					(v37) = (PVOID)(~v39 ^ (unsigned int)v37);
				} while (v6 < 28);
			}
		}