├── .gitattributes
├── .gitignore
├── Marbler
    ├── IScramble.cpp
    ├── IScramble.h
    ├── MBL_CLASS_BUMP1.cpp
    ├── MBL_CLASS_BUMP1.h
    ├── MBL_CLASS_BUMP10.cpp
    ├── MBL_CLASS_BUMP10.h
    ├── MBL_CLASS_BUMP11.cpp
    ├── MBL_CLASS_BUMP11.h
    ├── MBL_CLASS_BUMP12.cpp
    ├── MBL_CLASS_BUMP12.h
    ├── MBL_CLASS_BUMP2.cpp
    ├── MBL_CLASS_BUMP2.h
    ├── MBL_CLASS_BUMP3.cpp
    ├── MBL_CLASS_BUMP3.h
    ├── MBL_CLASS_BUMP4.cpp
    ├── MBL_CLASS_BUMP4.h
    ├── MBL_CLASS_BUMP5.cpp
    ├── MBL_CLASS_BUMP5.h
    ├── MBL_CLASS_BUMP6.cpp
    ├── MBL_CLASS_BUMP6.h
    ├── MBL_CLASS_BUMP7.cpp
    ├── MBL_CLASS_BUMP7.h
    ├── MBL_CLASS_BUMP8.cpp
    ├── MBL_CLASS_BUMP8.h
    ├── MBL_CLASS_BUMP9.cpp
    ├── MBL_CLASS_BUMP9.h
    ├── MBL_CLASS_RBUMP1.cpp
    ├── MBL_CLASS_RBUMP1.h
    ├── MBL_CLASS_RBUMP10.cpp
    ├── MBL_CLASS_RBUMP10.h
    ├── MBL_CLASS_RBUMP11.cpp
    ├── MBL_CLASS_RBUMP11.h
    ├── MBL_CLASS_RBUMP12.cpp
    ├── MBL_CLASS_RBUMP12.h
    ├── MBL_CLASS_RBUMP2.cpp
    ├── MBL_CLASS_RBUMP2.h
    ├── MBL_CLASS_RBUMP3.cpp
    ├── MBL_CLASS_RBUMP3.h
    ├── MBL_CLASS_RBUMP4.cpp
    ├── MBL_CLASS_RBUMP4.h
    ├── MBL_CLASS_RBUMP5.cpp
    ├── MBL_CLASS_RBUMP5.h
    ├── MBL_CLASS_RBUMP6.cpp
    ├── MBL_CLASS_RBUMP6.h
    ├── MBL_CLASS_RBUMP7.cpp
    ├── MBL_CLASS_RBUMP7.h
    ├── MBL_CLASS_RBUMP8.cpp
    ├── MBL_CLASS_RBUMP8.h
    ├── MBL_CLASS_RBUMP9.cpp
    ├── MBL_CLASS_RBUMP9.h
    ├── MBL_CLASS_RXOR1.cpp
    ├── MBL_CLASS_RXOR1.h
    ├── MBL_CLASS_RXOR10.cpp
    ├── MBL_CLASS_RXOR10.h
    ├── MBL_CLASS_RXOR11.cpp
    ├── MBL_CLASS_RXOR11.h
    ├── MBL_CLASS_RXOR12.cpp
    ├── MBL_CLASS_RXOR12.h
    ├── MBL_CLASS_RXOR2.cpp
    ├── MBL_CLASS_RXOR2.h
    ├── MBL_CLASS_RXOR3.cpp
    ├── MBL_CLASS_RXOR3.h
    ├── MBL_CLASS_RXOR4.cpp
    ├── MBL_CLASS_RXOR4.h
    ├── MBL_CLASS_RXOR5.cpp
    ├── MBL_CLASS_RXOR5.h
    ├── MBL_CLASS_RXOR6.cpp
    ├── MBL_CLASS_RXOR6.h
    ├── MBL_CLASS_RXOR7.cpp
    ├── MBL_CLASS_RXOR7.h
    ├── MBL_CLASS_RXOR8.cpp
    ├── MBL_CLASS_RXOR8.h
    ├── MBL_CLASS_RXOR9.cpp
    ├── MBL_CLASS_RXOR9.h
    ├── MBL_CLASS_XOR1.cpp
    ├── MBL_CLASS_XOR1.h
    ├── MBL_CLASS_XOR10.cpp
    ├── MBL_CLASS_XOR10.h
    ├── MBL_CLASS_XOR11.cpp
    ├── MBL_CLASS_XOR11.h
    ├── MBL_CLASS_XOR12.cpp
    ├── MBL_CLASS_XOR12.h
    ├── MBL_CLASS_XOR2.cpp
    ├── MBL_CLASS_XOR2.h
    ├── MBL_CLASS_XOR3.cpp
    ├── MBL_CLASS_XOR3.h
    ├── MBL_CLASS_XOR4.cpp
    ├── MBL_CLASS_XOR4.h
    ├── MBL_CLASS_XOR5.cpp
    ├── MBL_CLASS_XOR5.h
    ├── MBL_CLASS_XOR6.cpp
    ├── MBL_CLASS_XOR6.h
    ├── MBL_CLASS_XOR7.cpp
    ├── MBL_CLASS_XOR7.h
    ├── MBL_CLASS_XOR8.cpp
    ├── MBL_CLASS_XOR8.h
    ├── MBL_CLASS_XOR9.cpp
    ├── MBL_CLASS_XOR9.h
    ├── MBL_FORLOOP_BUMP1.cpp
    ├── MBL_FORLOOP_BUMP1.h
    ├── MBL_FORLOOP_BUMP10.cpp
    ├── MBL_FORLOOP_BUMP10.h
    ├── MBL_FORLOOP_BUMP11.cpp
    ├── MBL_FORLOOP_BUMP11.h
    ├── MBL_FORLOOP_BUMP12.cpp
    ├── MBL_FORLOOP_BUMP12.h
    ├── MBL_FORLOOP_BUMP2.cpp
    ├── MBL_FORLOOP_BUMP2.h
    ├── MBL_FORLOOP_BUMP3.cpp
    ├── MBL_FORLOOP_BUMP3.h
    ├── MBL_FORLOOP_BUMP4.cpp
    ├── MBL_FORLOOP_BUMP4.h
    ├── MBL_FORLOOP_BUMP5.cpp
    ├── MBL_FORLOOP_BUMP5.h
    ├── MBL_FORLOOP_BUMP6.cpp
    ├── MBL_FORLOOP_BUMP6.h
    ├── MBL_FORLOOP_BUMP7.cpp
    ├── MBL_FORLOOP_BUMP7.h
    ├── MBL_FORLOOP_BUMP8.cpp
    ├── MBL_FORLOOP_BUMP8.h
    ├── MBL_FORLOOP_BUMP9.cpp
    ├── MBL_FORLOOP_BUMP9.h
    ├── MBL_FORLOOP_FUNC_BUMP1.cpp
    ├── MBL_FORLOOP_FUNC_BUMP1.h
    ├── MBL_FORLOOP_FUNC_BUMP10.cpp
    ├── MBL_FORLOOP_FUNC_BUMP10.h
    ├── MBL_FORLOOP_FUNC_BUMP11.cpp
    ├── MBL_FORLOOP_FUNC_BUMP11.h
    ├── MBL_FORLOOP_FUNC_BUMP12.cpp
    ├── MBL_FORLOOP_FUNC_BUMP12.h
    ├── MBL_FORLOOP_FUNC_BUMP2.cpp
    ├── MBL_FORLOOP_FUNC_BUMP2.h
    ├── MBL_FORLOOP_FUNC_BUMP3.cpp
    ├── MBL_FORLOOP_FUNC_BUMP3.h
    ├── MBL_FORLOOP_FUNC_BUMP4.cpp
    ├── MBL_FORLOOP_FUNC_BUMP4.h
    ├── MBL_FORLOOP_FUNC_BUMP5.cpp
    ├── MBL_FORLOOP_FUNC_BUMP5.h
    ├── MBL_FORLOOP_FUNC_BUMP6.cpp
    ├── MBL_FORLOOP_FUNC_BUMP6.h
    ├── MBL_FORLOOP_FUNC_BUMP7.cpp
    ├── MBL_FORLOOP_FUNC_BUMP7.h
    ├── MBL_FORLOOP_FUNC_BUMP8.cpp
    ├── MBL_FORLOOP_FUNC_BUMP8.h
    ├── MBL_FORLOOP_FUNC_BUMP9.cpp
    ├── MBL_FORLOOP_FUNC_BUMP9.h
    ├── MBL_FORLOOP_FUNC_RBUMP1.cpp
    ├── MBL_FORLOOP_FUNC_RBUMP1.h
    ├── MBL_FORLOOP_FUNC_RBUMP2.cpp
    ├── MBL_FORLOOP_FUNC_RBUMP2.h
    ├── MBL_FORLOOP_FUNC_RBUMP3.cpp
    ├── MBL_FORLOOP_FUNC_RBUMP3.h
    ├── MBL_FORLOOP_FUNC_RBUMP4.cpp
    ├── MBL_FORLOOP_FUNC_RBUMP4.h
    ├── MBL_FORLOOP_FUNC_RBUMP5.cpp
    ├── MBL_FORLOOP_FUNC_RBUMP5.h
    ├── MBL_FORLOOP_FUNC_RBUMP6.cpp
    ├── MBL_FORLOOP_FUNC_RBUMP6.h
    ├── MBL_FORLOOP_FUNC_RBUMP7.cpp
    ├── MBL_FORLOOP_FUNC_RBUMP7.h
    ├── MBL_FORLOOP_FUNC_RBUMP8.cpp
    ├── MBL_FORLOOP_FUNC_RBUMP8.h
    ├── MBL_FORLOOP_FUNC_RXOR1.cpp
    ├── MBL_FORLOOP_FUNC_RXOR1.h
    ├── MBL_FORLOOP_FUNC_RXOR2.cpp
    ├── MBL_FORLOOP_FUNC_RXOR2.h
    ├── MBL_FORLOOP_FUNC_RXOR3.cpp
    ├── MBL_FORLOOP_FUNC_RXOR3.h
    ├── MBL_FORLOOP_FUNC_RXOR4.cpp
    ├── MBL_FORLOOP_FUNC_RXOR4.h
    ├── MBL_FORLOOP_FUNC_XOR1.cpp
    ├── MBL_FORLOOP_FUNC_XOR1.h
    ├── MBL_FORLOOP_FUNC_XOR2.cpp
    ├── MBL_FORLOOP_FUNC_XOR2.h
    ├── MBL_FORLOOP_FUNC_XOR3.cpp
    ├── MBL_FORLOOP_FUNC_XOR3.h
    ├── MBL_FORLOOP_FUNC_XOR4.cpp
    ├── MBL_FORLOOP_FUNC_XOR4.h
    ├── MBL_FORLOOP_FUNC_XOR5.cpp
    ├── MBL_FORLOOP_FUNC_XOR5.h
    ├── MBL_FORLOOP_FUNC_XOR6.cpp
    ├── MBL_FORLOOP_FUNC_XOR6.h
    ├── MBL_FORLOOP_RBUMP1.cpp
    ├── MBL_FORLOOP_RBUMP1.h
    ├── MBL_FORLOOP_RBUMP2.cpp
    ├── MBL_FORLOOP_RBUMP2.h
    ├── MBL_FORLOOP_RBUMP3.cpp
    ├── MBL_FORLOOP_RBUMP3.h
    ├── MBL_FORLOOP_RBUMP4.cpp
    ├── MBL_FORLOOP_RBUMP4.h
    ├── MBL_FORLOOP_RBUMP5.cpp
    ├── MBL_FORLOOP_RBUMP5.h
    ├── MBL_FORLOOP_RBUMP6.cpp
    ├── MBL_FORLOOP_RBUMP6.h
    ├── MBL_FORLOOP_RBUMP7.cpp
    ├── MBL_FORLOOP_RBUMP7.h
    ├── MBL_FORLOOP_RBUMP8.cpp
    ├── MBL_FORLOOP_RBUMP8.h
    ├── MBL_FORLOOP_RXOR1.cpp
    ├── MBL_FORLOOP_RXOR1.h
    ├── MBL_FORLOOP_RXOR2.cpp
    ├── MBL_FORLOOP_RXOR2.h
    ├── MBL_FORLOOP_RXOR3.cpp
    ├── MBL_FORLOOP_RXOR3.h
    ├── MBL_FORLOOP_RXOR4.cpp
    ├── MBL_FORLOOP_RXOR4.h
    ├── MBL_FORLOOP_XOR1.cpp
    ├── MBL_FORLOOP_XOR1.h
    ├── MBL_FORLOOP_XOR2.cpp
    ├── MBL_FORLOOP_XOR2.h
    ├── MBL_FORLOOP_XOR3.cpp
    ├── MBL_FORLOOP_XOR3.h
    ├── MBL_FORLOOP_XOR4.cpp
    ├── MBL_FORLOOP_XOR4.h
    ├── Marbler.ico
    ├── Marbler.rc
    ├── Marbler.vcxproj
    ├── Marbler.vcxproj.filters
    ├── Mibster.cpp
    ├── Mibster.h
    └── small.ico
├── Mender
    ├── Mender.cpp
    ├── Mender.vcxproj
    └── Mender.vcxproj.filters
├── README.md
├── Shared
    ├── Deobfuscators
    │   ├── MBL_CLASS_BUMP10D.cpp
    │   ├── MBL_CLASS_BUMP10D.h
    │   ├── MBL_CLASS_BUMP11D.cpp
    │   ├── MBL_CLASS_BUMP11D.h
    │   ├── MBL_CLASS_BUMP12D.cpp
    │   ├── MBL_CLASS_BUMP12D.h
    │   ├── MBL_CLASS_BUMP1D.cpp
    │   ├── MBL_CLASS_BUMP1D.h
    │   ├── MBL_CLASS_BUMP2D.cpp
    │   ├── MBL_CLASS_BUMP2D.h
    │   ├── MBL_CLASS_BUMP3D.cpp
    │   ├── MBL_CLASS_BUMP3D.h
    │   ├── MBL_CLASS_BUMP4D.cpp
    │   ├── MBL_CLASS_BUMP4D.h
    │   ├── MBL_CLASS_BUMP5D.cpp
    │   ├── MBL_CLASS_BUMP5D.h
    │   ├── MBL_CLASS_BUMP6D.cpp
    │   ├── MBL_CLASS_BUMP6D.h
    │   ├── MBL_CLASS_BUMP7D.cpp
    │   ├── MBL_CLASS_BUMP7D.h
    │   ├── MBL_CLASS_BUMP8D.cpp
    │   ├── MBL_CLASS_BUMP8D.h
    │   ├── MBL_CLASS_BUMP9D.cpp
    │   ├── MBL_CLASS_BUMP9D.h
    │   ├── MBL_CLASS_RBUMP10D.cpp
    │   ├── MBL_CLASS_RBUMP10D.h
    │   ├── MBL_CLASS_RBUMP11D.cpp
    │   ├── MBL_CLASS_RBUMP11D.h
    │   ├── MBL_CLASS_RBUMP12D.cpp
    │   ├── MBL_CLASS_RBUMP12D.h
    │   ├── MBL_CLASS_RBUMP1D.cpp
    │   ├── MBL_CLASS_RBUMP1D.h
    │   ├── MBL_CLASS_RBUMP2D.cpp
    │   ├── MBL_CLASS_RBUMP2D.h
    │   ├── MBL_CLASS_RBUMP3D.cpp
    │   ├── MBL_CLASS_RBUMP3D.h
    │   ├── MBL_CLASS_RBUMP4D.cpp
    │   ├── MBL_CLASS_RBUMP4D.h
    │   ├── MBL_CLASS_RBUMP5D.cpp
    │   ├── MBL_CLASS_RBUMP5D.h
    │   ├── MBL_CLASS_RBUMP6D.cpp
    │   ├── MBL_CLASS_RBUMP6D.h
    │   ├── MBL_CLASS_RBUMP7D.cpp
    │   ├── MBL_CLASS_RBUMP7D.h
    │   ├── MBL_CLASS_RBUMP8D.cpp
    │   ├── MBL_CLASS_RBUMP8D.h
    │   ├── MBL_CLASS_RBUMP9D.cpp
    │   ├── MBL_CLASS_RBUMP9D.h
    │   ├── MBL_CLASS_RXOR10D.cpp
    │   ├── MBL_CLASS_RXOR10D.h
    │   ├── MBL_CLASS_RXOR11D.cpp
    │   ├── MBL_CLASS_RXOR11D.h
    │   ├── MBL_CLASS_RXOR12D.cpp
    │   ├── MBL_CLASS_RXOR12D.h
    │   ├── MBL_CLASS_RXOR1D.cpp
    │   ├── MBL_CLASS_RXOR1D.h
    │   ├── MBL_CLASS_RXOR2D.cpp
    │   ├── MBL_CLASS_RXOR2D.h
    │   ├── MBL_CLASS_RXOR3D.cpp
    │   ├── MBL_CLASS_RXOR3D.h
    │   ├── MBL_CLASS_RXOR4D.cpp
    │   ├── MBL_CLASS_RXOR4D.h
    │   ├── MBL_CLASS_RXOR5D.cpp
    │   ├── MBL_CLASS_RXOR5D.h
    │   ├── MBL_CLASS_RXOR6D.cpp
    │   ├── MBL_CLASS_RXOR6D.h
    │   ├── MBL_CLASS_RXOR7D.cpp
    │   ├── MBL_CLASS_RXOR7D.h
    │   ├── MBL_CLASS_RXOR8D.cpp
    │   ├── MBL_CLASS_RXOR8D.h
    │   ├── MBL_CLASS_RXOR9D.cpp
    │   ├── MBL_CLASS_RXOR9D.h
    │   ├── MBL_CLASS_XOR10D.cpp
    │   ├── MBL_CLASS_XOR10D.h
    │   ├── MBL_CLASS_XOR11D.cpp
    │   ├── MBL_CLASS_XOR11D.h
    │   ├── MBL_CLASS_XOR12D.cpp
    │   ├── MBL_CLASS_XOR12D.h
    │   ├── MBL_CLASS_XOR1D.cpp
    │   ├── MBL_CLASS_XOR1D.h
    │   ├── MBL_CLASS_XOR2D.cpp
    │   ├── MBL_CLASS_XOR2D.h
    │   ├── MBL_CLASS_XOR3D.cpp
    │   ├── MBL_CLASS_XOR3D.h
    │   ├── MBL_CLASS_XOR4D.cpp
    │   ├── MBL_CLASS_XOR4D.h
    │   ├── MBL_CLASS_XOR5D.cpp
    │   ├── MBL_CLASS_XOR5D.h
    │   ├── MBL_CLASS_XOR6D.cpp
    │   ├── MBL_CLASS_XOR6D.h
    │   ├── MBL_CLASS_XOR7D.cpp
    │   ├── MBL_CLASS_XOR7D.h
    │   ├── MBL_CLASS_XOR8D.cpp
    │   ├── MBL_CLASS_XOR8D.h
    │   ├── MBL_CLASS_XOR9D.cpp
    │   ├── MBL_CLASS_XOR9D.h
    │   ├── MBL_FORLOOP_BUMP10D.h
    │   ├── MBL_FORLOOP_BUMP11D.h
    │   ├── MBL_FORLOOP_BUMP12D.h
    │   ├── MBL_FORLOOP_BUMP1D.h
    │   ├── MBL_FORLOOP_BUMP2D.h
    │   ├── MBL_FORLOOP_BUMP3D.h
    │   ├── MBL_FORLOOP_BUMP4D.h
    │   ├── MBL_FORLOOP_BUMP5D.h
    │   ├── MBL_FORLOOP_BUMP6D.h
    │   ├── MBL_FORLOOP_BUMP7D.h
    │   ├── MBL_FORLOOP_BUMP8D.h
    │   ├── MBL_FORLOOP_BUMP9D.h
    │   ├── MBL_FORLOOP_FUNC_BUMP10D.h
    │   ├── MBL_FORLOOP_FUNC_BUMP11D.h
    │   ├── MBL_FORLOOP_FUNC_BUMP12D.h
    │   ├── MBL_FORLOOP_FUNC_BUMP1D.h
    │   ├── MBL_FORLOOP_FUNC_BUMP2D.h
    │   ├── MBL_FORLOOP_FUNC_BUMP3D.h
    │   ├── MBL_FORLOOP_FUNC_BUMP4D.h
    │   ├── MBL_FORLOOP_FUNC_BUMP5D.h
    │   ├── MBL_FORLOOP_FUNC_BUMP6D.h
    │   ├── MBL_FORLOOP_FUNC_BUMP7D.h
    │   ├── MBL_FORLOOP_FUNC_BUMP8D.h
    │   ├── MBL_FORLOOP_FUNC_BUMP9D.h
    │   ├── MBL_FORLOOP_FUNC_RBUMP1D.h
    │   ├── MBL_FORLOOP_FUNC_RBUMP2D.h
    │   ├── MBL_FORLOOP_FUNC_RBUMP3D.h
    │   ├── MBL_FORLOOP_FUNC_RBUMP4D.h
    │   ├── MBL_FORLOOP_FUNC_RBUMP5D.h
    │   ├── MBL_FORLOOP_FUNC_RBUMP6D.h
    │   ├── MBL_FORLOOP_FUNC_RBUMP7D.h
    │   ├── MBL_FORLOOP_FUNC_RBUMP8D.h
    │   ├── MBL_FORLOOP_FUNC_RXOR1D.h
    │   ├── MBL_FORLOOP_FUNC_RXOR2D.h
    │   ├── MBL_FORLOOP_FUNC_RXOR3D.h
    │   ├── MBL_FORLOOP_FUNC_RXOR4D.h
    │   ├── MBL_FORLOOP_FUNC_XOR1D.h
    │   ├── MBL_FORLOOP_FUNC_XOR2D.h
    │   ├── MBL_FORLOOP_FUNC_XOR3D.h
    │   ├── MBL_FORLOOP_FUNC_XOR4D.h
    │   ├── MBL_FORLOOP_FUNC_XOR5D.h
    │   ├── MBL_FORLOOP_FUNC_XOR6D.h
    │   ├── MBL_FORLOOP_RBUMP1D.h
    │   ├── MBL_FORLOOP_RBUMP2D.h
    │   ├── MBL_FORLOOP_RBUMP3D.h
    │   ├── MBL_FORLOOP_RBUMP4D.h
    │   ├── MBL_FORLOOP_RBUMP5D.h
    │   ├── MBL_FORLOOP_RBUMP6D.h
    │   ├── MBL_FORLOOP_RBUMP7D.h
    │   ├── MBL_FORLOOP_RBUMP8D.h
    │   ├── MBL_FORLOOP_RXOR1D.h
    │   ├── MBL_FORLOOP_RXOR2D.h
    │   ├── MBL_FORLOOP_RXOR3D.h
    │   ├── MBL_FORLOOP_RXOR4D.h
    │   ├── MBL_FORLOOP_XOR1D.h
    │   ├── MBL_FORLOOP_XOR2D.h
    │   ├── MBL_FORLOOP_XOR3D.h
    │   └── MBL_FORLOOP_XOR4D.h
    └── Marble.h
├── StringScrambling.sln
├── Submodules
    └── Misc
    │   ├── FileTyping
    │       ├── MISCTextFileTyper_ENC.cpp
    │       └── MISCTextFileTyper_ENC.h
    │   ├── MemoryScan
    │       ├── MISCMemorySearch_NSS.cpp
    │       └── MISCMemorySearch_NSS.h
    │   ├── Misc.vcxproj
    │   └── Misc.vcxproj.filters
├── Validator
    ├── Validator.cpp
    ├── Validator.vcxproj
    └── Validator.vcxproj.filters
├── docs
    ├── Marble Framework.docx
    ├── Marble Framework.pdf
    └── Marble Framework.pptx
└── props
    ├── Kernel_Debug_x64.props
    ├── Kernel_Debug_x86.props
    ├── Kernel_Release_x64.props
    ├── Kernel_Release_x86.props
    ├── User_Debug_x64.props
    ├── User_Debug_x86.props
    ├── User_Dynamic_Release_LIB_x64.props
    ├── User_Dynamic_Release_LIB_x86.props
    ├── User_Dynamic_Release_x64.props
    ├── User_Dynamic_Release_x86.props
    ├── User_Static_Release_x64.props
    ├── User_Static_Release_x86.props
    └── internal
        ├── Common.props
        ├── Console.props
        ├── DLL.props
        ├── Debug.props
        ├── GUI.props
        ├── GUI_x64.props
        ├── GUI_x86.props
        ├── Kernel_Common.props
        ├── Kernel_x64.props
        ├── Kernel_x86.props
        ├── LIB.props
        ├── Release.props
        ├── SYS.props
        ├── User_Common.props
        ├── User_x64.props
        └── User_x86.props


/Marbler/MBL_CLASS_BUMP1.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_BUMP1 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_BUMP1(void);
 9 | 	~MBL_CLASS_BUMP1(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_BUMP2.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_BUMP2 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_BUMP2(void);
 9 | 	~MBL_CLASS_BUMP2(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_BUMP3.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_BUMP3 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_BUMP3(void);
 9 | 	~MBL_CLASS_BUMP3(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_BUMP4.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_BUMP4 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_BUMP4(void);
 9 | 	~MBL_CLASS_BUMP4(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_BUMP5.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_BUMP5 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_BUMP5(void);
 9 | 	~MBL_CLASS_BUMP5(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_BUMP6.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_BUMP6 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_BUMP6(void);
 9 | 	~MBL_CLASS_BUMP6(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_BUMP7.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_BUMP7 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_BUMP7(void);
 9 | 	~MBL_CLASS_BUMP7(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_BUMP8.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_BUMP8 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_BUMP8(void);
 9 | 	~MBL_CLASS_BUMP8(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RBUMP1.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RBUMP1 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RBUMP1(void);
 9 | 	~MBL_CLASS_RBUMP1(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RBUMP10.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RBUMP10 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RBUMP10(void);
 9 | 	~MBL_CLASS_RBUMP10(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RBUMP11.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RBUMP11 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RBUMP11(void);
 9 | 	~MBL_CLASS_RBUMP11(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RBUMP12.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RBUMP12 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RBUMP12(void);
 9 | 	~MBL_CLASS_RBUMP12(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RBUMP2.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RBUMP2 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RBUMP2(void);
 9 | 	~MBL_CLASS_RBUMP2(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RBUMP3.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RBUMP3 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RBUMP3(void);
 9 | 	~MBL_CLASS_RBUMP3(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RBUMP4.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RBUMP4 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RBUMP4(void);
 9 | 	~MBL_CLASS_RBUMP4(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RBUMP5.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RBUMP5 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RBUMP5(void);
 9 | 	~MBL_CLASS_RBUMP5(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RBUMP6.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RBUMP6 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RBUMP6(void);
 9 | 	~MBL_CLASS_RBUMP6(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RBUMP7.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RBUMP7 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RBUMP7(void);
 9 | 	~MBL_CLASS_RBUMP7(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RBUMP8.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RBUMP8 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RBUMP8(void);
 9 | 	~MBL_CLASS_RBUMP8(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RBUMP9.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RBUMP9 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RBUMP9(void);
 9 | 	~MBL_CLASS_RBUMP9(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RXOR1.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RXOR1 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RXOR1(void);
 9 | 	~MBL_CLASS_RXOR1(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RXOR10.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RXOR10 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RXOR10(void);
 9 | 	~MBL_CLASS_RXOR10(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RXOR11.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RXOR11 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RXOR11(void);
 9 | 	~MBL_CLASS_RXOR11(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RXOR12.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RXOR12 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RXOR12(void);
 9 | 	~MBL_CLASS_RXOR12(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RXOR2.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RXOR2 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RXOR2(void);
 9 | 	~MBL_CLASS_RXOR2(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RXOR3.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RXOR3 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RXOR3(void);
 9 | 	~MBL_CLASS_RXOR3(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RXOR4.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RXOR4 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RXOR4(void);
 9 | 	~MBL_CLASS_RXOR4(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RXOR5.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RXOR5 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RXOR5(void);
 9 | 	~MBL_CLASS_RXOR5(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RXOR6.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RXOR6 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RXOR6(void);
 9 | 	~MBL_CLASS_RXOR6(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RXOR7.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RXOR7 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RXOR7(void);
 9 | 	~MBL_CLASS_RXOR7(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RXOR8.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RXOR8 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RXOR8(void);
 9 | 	~MBL_CLASS_RXOR8(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_RXOR9.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_RXOR9 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_RXOR9(void);
 9 | 	~MBL_CLASS_RXOR9(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_XOR1.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_XOR1 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_XOR1(void);
 9 | 	~MBL_CLASS_XOR1(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_XOR2.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_XOR2 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_XOR2(void);
 9 | 	~MBL_CLASS_XOR2(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_XOR3.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_XOR3 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_XOR3(void);
 9 | 	~MBL_CLASS_XOR3(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_XOR4.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_XOR4 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_XOR4(void);
 9 | 	~MBL_CLASS_XOR4(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_XOR5.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_XOR5 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_XOR5(void);
 9 | 	~MBL_CLASS_XOR5(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_XOR6.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_XOR6 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_XOR6(void);
 9 | 	~MBL_CLASS_XOR6(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_XOR7.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_XOR7 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_XOR7(void);
 9 | 	~MBL_CLASS_XOR7(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_CLASS_XOR8.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_CLASS_XOR8 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_CLASS_XOR8(void);
 9 | 	~MBL_CLASS_XOR8(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_FORLOOP_BUMP1.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_FORLOOP_BUMP1 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_FORLOOP_BUMP1(void);
 9 | 	~MBL_FORLOOP_BUMP1(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_FORLOOP_FUNC_XOR2.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_FORLOOP_FUNC_XOR2 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_FORLOOP_FUNC_XOR2(void);
 9 | 	~MBL_FORLOOP_FUNC_XOR2(void);
10 | 
11 | 	/*
12 | 	Args:
13 | 	wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 	iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 	Args:
20 | 	cToScramble[in]: is the buffer containing a char string to scramble
21 | 	iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 	Args:
28 | 	cVarName[in]: the name of the variable being replaced
29 | 	cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 	iNumOfChars[in]: the number of characters in the buffer
31 | 	cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 	Args:
37 | 	cVarName[in]: the name of the variable being replaced
38 | 	wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 	iNumOfChars[in]: the number of characters in the buffer
40 | 	cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_FORLOOP_XOR1.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_FORLOOP_XOR1 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_FORLOOP_XOR1(void);
 9 | 	~MBL_FORLOOP_XOR1(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/MBL_FORLOOP_XOR2.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "IScramble.h"
 3 | 
 4 | class MBL_FORLOOP_XOR2 : public IScramble
 5 | {
 6 | public:
 7 | 
 8 | 	MBL_FORLOOP_XOR2(void);
 9 | 	~MBL_FORLOOP_XOR2(void);
10 | 
11 | 	/*
12 | 		Args:
13 | 			wcToScramble[in]: is the buffer containing a Wide Char string to scramble
14 | 			iNumOfChars[in]: the number of WCHARs in the buffer
15 | 	*/
16 | 	int ScrambleW(wchar_t *wcToScramble, unsigned int iNumOfChars);
17 | 
18 | 	/*
19 | 		Args:
20 | 			cToScramble[in]: is the buffer containing a char string to scramble
21 | 			iNumOfChars[in]: the number of CHARs in the buffer
22 | 	*/
23 | 	int ScrambleA(char *cToScramble, unsigned int NumOfChars);
24 | 
25 | 
26 | 	/*
27 | 		Args:
28 | 			cVarName[in]: the name of the variable being replaced
29 | 			cStringLiteral[in]: the string literal to be added to the insert (after scrambling)
30 | 			iNumOfChars[in]: the number of characters in the buffer
31 | 			cInsert[out]: the insert to replace CARBLE\BARBLE declaration in the c/cpp file
32 | 	*/
33 | 	int GenerateInsertA(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
34 | 
35 | 	/*
36 | 		Args:
37 | 			cVarName[in]: the name of the variable being replaced
38 | 			wcStringLiteral[in]: the string literal to be added to the insert (after scrambling)
39 | 			iNumOfChars[in]: the number of characters in the buffer
40 | 			cInsert[out]: the insert to replace WARBLE declaration in the c/cpp file
41 | 	*/
42 | 	int GenerateInsertW(char *cVarName, char *cStringLiteral, unsigned int iNumOfChars, char *&cInsert);
43 | 
44 | protected:
45 | 	wchar_t wcKey;
46 | 	unsigned char cKey;
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/Marbler/Marbler.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Marbler/Marbler.ico


--------------------------------------------------------------------------------
/Marbler/small.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Marbler/small.ico


--------------------------------------------------------------------------------
/Mender/Mender.vcxproj.filters:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <!-- This project created via the OSB Project Template by Josh S, Keith T. -->
3 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
4 |   <ItemGroup>
5 |     <ClCompile Include="Mender.cpp" />
6 |   </ItemGroup>
7 | </Project>
8 | <!-- This project created via the OSB Project Template by Josh S, Keith T. -->


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP10D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_BUMP10D.h"
 4 | 
 5 | MBL_CLASS_BUMP10D::MBL_CLASS_BUMP10D(char *cXorKey, char *cString, int iNumOfChars)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Xor
14 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
15 | 		cString[i] -= cXorKey[i % 8];
16 | }
17 | 
18 | MBL_CLASS_BUMP10D::MBL_CLASS_BUMP10D(wchar_t *wcXorKey, wchar_t *wcString, int iNumOfChars)
19 | {
20 | 	wcStringPointer = wcString;
21 | 	iWStringPointerLen = iNumOfChars;
22 | 
23 | 	cStringPointer = NULL;
24 | 	iCStringPointerLen = NULL;
25 | 
26 | 	//Xor
27 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
28 | 		wcString[i] -= wcXorKey[i % 8];
29 | }
30 | 
31 | MBL_CLASS_BUMP10D::~MBL_CLASS_BUMP10D(void)
32 | {
33 | 
34 | 	if (cStringPointer)
35 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
36 | 
37 | 
38 | 	if (wcStringPointer)
39 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
40 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP10D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_BUMP10D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_BUMP10D(char *cXorKey, char *cString, int iNumOfChars);
 8 | 	MBL_CLASS_BUMP10D(wchar_t *wcXorKey, wchar_t *wcString, int iNumOfChars);
 9 | 	~MBL_CLASS_BUMP10D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP11D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_BUMP11D.h"
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <time.h>
 7 | 
 8 | MBL_CLASS_BUMP11D::MBL_CLASS_BUMP11D(char *cXorKey, char *cString, int iNumOfChars)
 9 | {
10 | 	cStringPointer = cString;
11 | 	iCStringPointerLen = iNumOfChars;
12 | 
13 | 	wcStringPointer = NULL;
14 | 	iWStringPointerLen = NULL;
15 | 
16 | 	//Xor
17 | 	for (int i = 0; i < iNumOfChars; i++)
18 | 		cString[i] += cXorKey[i % 8];
19 | }
20 | 
21 | MBL_CLASS_BUMP11D::MBL_CLASS_BUMP11D(wchar_t *wcXorKey, wchar_t *wcString, int iNumOfChars)
22 | {
23 | 	wcStringPointer = wcString;
24 | 	iWStringPointerLen = iNumOfChars;
25 | 
26 | 	cStringPointer = NULL;
27 | 	iCStringPointerLen = NULL;
28 | 
29 | 	//Xor
30 | 	for (int i = 0; i < iNumOfChars; i++)
31 | 		wcString[i] += wcXorKey[i % 8];
32 | }
33 | 
34 | MBL_CLASS_BUMP11D::~MBL_CLASS_BUMP11D(void)
35 | {
36 | 	srand((DWORD) time(NULL));
37 | 
38 | 	if (cStringPointer)
39 | 	{
40 | 		for (int i = 0; i < iCStringPointerLen; i++)
41 | 			cStringPointer[i] = (unsigned char)rand() % 255;
42 | 	}
43 | 
44 | 
45 | 	if (wcStringPointer)
46 | 	{
47 | 		for (int i = 0; i < iWStringPointerLen; i++)
48 | 			wcStringPointer[i] = rand() % 65534;
49 | 	}
50 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP11D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_BUMP11D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_BUMP11D(char *cXorKey, char *cString, int iNumOfChars);
 8 | 	MBL_CLASS_BUMP11D(wchar_t *wcXorKey, wchar_t *wcString, int iNumOfChars);
 9 | 	~MBL_CLASS_BUMP11D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP12D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_BUMP12D.h"
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <time.h>
 7 | 
 8 | MBL_CLASS_BUMP12D::MBL_CLASS_BUMP12D(char *cXorKey, char *cString, int iNumOfChars)
 9 | {
10 | 	cStringPointer = cString;
11 | 	iCStringPointerLen = iNumOfChars;
12 | 
13 | 	wcStringPointer = NULL;
14 | 	iWStringPointerLen = NULL;
15 | 
16 | 	//Xor
17 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
18 | 		cString[i] += cXorKey[i % 8];
19 | }
20 | 
21 | MBL_CLASS_BUMP12D::MBL_CLASS_BUMP12D(wchar_t *wcXorKey, wchar_t *wcString, int iNumOfChars)
22 | {
23 | 	wcStringPointer = wcString;
24 | 	iWStringPointerLen = iNumOfChars;
25 | 
26 | 	cStringPointer = 0;
27 | 	iCStringPointerLen = 0;
28 | 
29 | 	//Xor
30 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
31 | 		wcString[i] += wcXorKey[i % 8];
32 | }
33 | 
34 | MBL_CLASS_BUMP12D::~MBL_CLASS_BUMP12D(void)
35 | {
36 | 	srand((DWORD) time(NULL));
37 | 
38 | 	if (cStringPointer)
39 | 	{
40 | 		for (int i = iCStringPointerLen - 1; i >= 0; i--)
41 | 			cStringPointer[i] = (unsigned char)rand() % 255;
42 | 	}
43 | 
44 | 
45 | 	if (wcStringPointer)
46 | 	{
47 | 		for (int i = iWStringPointerLen - 1; i >= 0; i--)
48 | 			wcStringPointer[i] = rand() % 65534;
49 | 	}
50 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP12D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_BUMP12D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_BUMP12D(char *cXorKey, char *cString, int iNumOfChars);
 8 | 	MBL_CLASS_BUMP12D(wchar_t *wcXorKey, wchar_t *wcString, int iNumOfChars);
 9 | 	~MBL_CLASS_BUMP12D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP1D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_BUMP1D.h"
 4 | 
 5 | MBL_CLASS_BUMP1D::MBL_CLASS_BUMP1D(char cXorKey, int iNumOfChars, char *cString)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Xor
14 | 	for (int i = 0; i < iNumOfChars; i++)
15 | 		cString[i] -= cXorKey;
16 | }
17 | 
18 | MBL_CLASS_BUMP1D::MBL_CLASS_BUMP1D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
19 | {
20 | 	wcStringPointer = wcString;
21 | 	iWStringPointerLen = iNumOfChars;
22 | 
23 | 	cStringPointer = 0;
24 | 	iCStringPointerLen = 0;
25 | 
26 | 	//Xor
27 | 	for (int i = 0; i < iNumOfChars; i++)
28 | 		wcString[i] -= wcXorKey;
29 | }
30 | 
31 | MBL_CLASS_BUMP1D::~MBL_CLASS_BUMP1D(void)
32 | {
33 | 	if (cStringPointer)
34 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
35 | 
36 | 	if (wcStringPointer)
37 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
38 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP1D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_BUMP1D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_BUMP1D(char cXorKey, int iNumOfChars, char *cString);
 8 | 	MBL_CLASS_BUMP1D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
 9 | 	~MBL_CLASS_BUMP1D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP2D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_BUMP2D.h"
 4 | 
 5 | MBL_CLASS_BUMP2D::MBL_CLASS_BUMP2D(char cXorKey, int iNumOfChars, char *cString)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Xor
14 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
15 | 		cString[i] -= cXorKey;
16 | }
17 | 
18 | MBL_CLASS_BUMP2D::MBL_CLASS_BUMP2D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
19 | {
20 | 	wcStringPointer = wcString;
21 | 	iWStringPointerLen = iNumOfChars;
22 | 
23 | 	cStringPointer = 0;
24 | 	iCStringPointerLen = 0;
25 | 
26 | 	//Xor
27 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
28 | 		wcString[i] -= wcXorKey;
29 | }
30 | 
31 | MBL_CLASS_BUMP2D::~MBL_CLASS_BUMP2D(void)
32 | {
33 | 	if (cStringPointer)
34 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
35 | 
36 | 	if (wcStringPointer)
37 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
38 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP2D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_BUMP2D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_BUMP2D(char cXorKey, int iNumOfChars, char *cString);
 8 | 	MBL_CLASS_BUMP2D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
 9 | 	~MBL_CLASS_BUMP2D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP3D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_BUMP3D.h"
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <time.h>
 7 | 
 8 | MBL_CLASS_BUMP3D::MBL_CLASS_BUMP3D(char cXorKey, int iNumOfChars, char *cString)
 9 | {
10 | 	cStringPointer = cString;
11 | 	iCStringPointerLen = iNumOfChars;
12 | 
13 | 	wcStringPointer = NULL;
14 | 	iWStringPointerLen = NULL;
15 | 
16 | 	//Xor
17 | 	for (int i = 0; i < iNumOfChars; i++)
18 | 		cString[i] += cXorKey;
19 | }
20 | 
21 | MBL_CLASS_BUMP3D::MBL_CLASS_BUMP3D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
22 | {
23 | 	wcStringPointer = wcString;
24 | 	iWStringPointerLen = iNumOfChars;
25 | 
26 | 	cStringPointer = 0;
27 | 	iCStringPointerLen = 0;
28 | 
29 | 	//Xor
30 | 	for (int i = 0; i < iNumOfChars; i++)
31 | 		wcString[i] += wcXorKey;
32 | }
33 | 
34 | MBL_CLASS_BUMP3D::~MBL_CLASS_BUMP3D(void)
35 | {
36 | 	srand((DWORD) time(NULL));
37 | 	
38 | 	if (cStringPointer)
39 | 	{
40 | 		for (int i = 0; i < iCStringPointerLen; i++)
41 | 			cStringPointer[i] = (unsigned char)rand() % 255;
42 | 	}
43 | 
44 | 
45 | 	if (wcStringPointer)
46 | 	{
47 | 		for (int i = 0; i < iWStringPointerLen; i++)
48 | 			wcStringPointer[i] = rand() % 65534;
49 | 	}
50 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP3D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_BUMP3D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_BUMP3D(char cXorKey, int iNumOfChars, char *cString);
 8 | 	MBL_CLASS_BUMP3D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
 9 | 	~MBL_CLASS_BUMP3D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP4D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_BUMP4D.h"
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <time.h>
 7 | 
 8 | MBL_CLASS_BUMP4D::MBL_CLASS_BUMP4D(char cXorKey, int iNumOfChars, char *cString)
 9 | {
10 | 	cStringPointer = cString;
11 | 	iCStringPointerLen = iNumOfChars;
12 | 
13 | 	wcStringPointer = NULL;
14 | 	iWStringPointerLen = NULL;
15 | 
16 | 	//Xor
17 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
18 | 		cString[i] += cXorKey;
19 | }
20 | 
21 | MBL_CLASS_BUMP4D::MBL_CLASS_BUMP4D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
22 | {
23 | 	wcStringPointer = wcString;
24 | 	iWStringPointerLen = iNumOfChars;
25 | 
26 | 	cStringPointer = 0;
27 | 	iCStringPointerLen = 0;
28 | 
29 | 	//Xor
30 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
31 | 		wcString[i] += wcXorKey;
32 | }
33 | 
34 | MBL_CLASS_BUMP4D::~MBL_CLASS_BUMP4D(void)
35 | {
36 | 	srand((DWORD) time(NULL));
37 | 
38 | 	if (cStringPointer)
39 | 	{
40 | 		for (int i = iCStringPointerLen - 1; i >= 0; i--)
41 | 			cStringPointer[i] = (unsigned char)rand() % 255;
42 | 	}
43 | 
44 | 
45 | 	if (wcStringPointer)
46 | 	{
47 | 		for (int i = iWStringPointerLen - 1; i >= 0; i--)
48 | 			wcStringPointer[i] = rand() % 65534;
49 | 	}
50 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP4D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_BUMP4D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_BUMP4D(char cXorKey, int iNumOfChars, char *cString);
 8 | 	MBL_CLASS_BUMP4D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
 9 | 	~MBL_CLASS_BUMP4D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP5D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_BUMP5D.h"
 4 | 
 5 | MBL_CLASS_BUMP5D::MBL_CLASS_BUMP5D(void)
 6 | {
 7 | 	wcStringPointer = NULL;
 8 | 	iWStringPointerLen = NULL;
 9 | 
10 | 	cStringPointer = NULL;
11 | 	iCStringPointerLen = NULL;
12 | }
13 | 
14 | MBL_CLASS_BUMP5D::~MBL_CLASS_BUMP5D(void)
15 | {
16 | 	if (cStringPointer)
17 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
18 | 
19 | 	if (wcStringPointer)
20 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
21 | }
22 | 
23 | void MBL_CLASS_BUMP5D::Scramble(char *cString, int iNumOfChars, char cXorKey)
24 | {
25 | 	cStringPointer = cString;
26 | 	iCStringPointerLen = iNumOfChars;
27 | 
28 | 	//Xor
29 | 	for (int i = 0; i < iNumOfChars; i++)
30 | 		cString[i] -= cXorKey;
31 | }
32 | 
33 | void MBL_CLASS_BUMP5D::Scramble(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
34 | {
35 | 	wcStringPointer = wcString;
36 | 	iWStringPointerLen = iNumOfChars;
37 | 
38 | 	//Xor
39 | 	for (int i = 0; i < iNumOfChars; i++)
40 | 		wcString[i] -= wcXorKey;
41 | }
42 | 
43 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP5D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_BUMP5D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_BUMP5D(void);
 8 | 	~MBL_CLASS_BUMP5D(void);
 9 | 	void Scramble(char *cString, int iNumOfChars, char cXorKey);
10 | 	void Scramble(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey);
11 | 	
12 | protected:
13 | 	char *cStringPointer;
14 | 	int iCStringPointerLen;
15 | 	wchar_t *wcStringPointer;
16 | 	int iWStringPointerLen;
17 | 
18 | };
19 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP6D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_BUMP6D.h"
 4 | 
 5 | MBL_CLASS_BUMP6D::MBL_CLASS_BUMP6D(void)
 6 | {
 7 | 	wcStringPointer = NULL;
 8 | 	iWStringPointerLen = NULL;
 9 | 
10 | 	cStringPointer = NULL;
11 | 	iCStringPointerLen = NULL;
12 | }
13 | 
14 | MBL_CLASS_BUMP6D::~MBL_CLASS_BUMP6D(void)
15 | {
16 | 	if (cStringPointer)
17 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
18 | 
19 | 	if (wcStringPointer)
20 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
21 | }
22 | 
23 | void MBL_CLASS_BUMP6D::Scramble(char *cString, int iNumOfChars, char cXorKey)
24 | {
25 | 	cStringPointer = cString;
26 | 	iCStringPointerLen = iNumOfChars;
27 | 
28 | 	//Xor
29 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
30 | 		cString[i] -= cXorKey;
31 | }
32 | 
33 | void MBL_CLASS_BUMP6D::Scramble(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
34 | {
35 | 	wcStringPointer = wcString;
36 | 	iWStringPointerLen = iNumOfChars;
37 | 
38 | 	//Xor
39 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
40 | 		wcString[i] -= wcXorKey;
41 | }
42 | 
43 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP6D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_BUMP6D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_BUMP6D(void);
 8 | 	~MBL_CLASS_BUMP6D(void);
 9 | 	void Scramble(char *cString, int iNumOfChars, char cXorKey);
10 | 	void Scramble(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey);
11 | 
12 | protected:
13 | 	char *cStringPointer;
14 | 	int iCStringPointerLen;
15 | 	wchar_t *wcStringPointer;
16 | 	int iWStringPointerLen;
17 | 
18 | };
19 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP7D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_BUMP7D.h"
 4 | #include <stdlib.h>
 5 | #include <time.h>
 6 | 
 7 | MBL_CLASS_BUMP7D::MBL_CLASS_BUMP7D(void)
 8 | {
 9 | 	wcStringPointer = NULL;
10 | 	iWStringPointerLen = NULL;
11 | 
12 | 	cStringPointer = 0;
13 | 	iCStringPointerLen = 0;
14 | }
15 | 
16 | MBL_CLASS_BUMP7D::~MBL_CLASS_BUMP7D(void)
17 | {
18 | 	srand((DWORD) time(NULL));
19 | 
20 | 	if (cStringPointer)
21 | 	{
22 | 		for (int i = 0; i < iCStringPointerLen; i++)
23 | 			cStringPointer[i] = (unsigned char)rand() % 255;
24 | 	}
25 | 
26 | 
27 | 	if (wcStringPointer)
28 | 	{
29 | 		for (int i = 0; i < iWStringPointerLen; i++)
30 | 			wcStringPointer[i] = rand() % 65534;
31 | 	}
32 | }
33 | 
34 | void MBL_CLASS_BUMP7D::Scramble(char *cString, int iNumOfChars, char cXorKey)
35 | {
36 | 	cStringPointer = cString;
37 | 	iCStringPointerLen = iNumOfChars;
38 | 
39 | 	//Xor
40 | 	for (int i = 0; i < iNumOfChars; i++)
41 | 		cString[i] += cXorKey;
42 | }
43 | 
44 | void MBL_CLASS_BUMP7D::Scramble(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
45 | {
46 | 	wcStringPointer = wcString;
47 | 	iWStringPointerLen = iNumOfChars;
48 | 
49 | 	//Xor
50 | 	for (int i = 0; i < iNumOfChars; i++)
51 | 		wcString[i] += wcXorKey;
52 | }
53 | 
54 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP7D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_BUMP7D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_BUMP7D(void);
 8 | 	~MBL_CLASS_BUMP7D(void);
 9 | 	void Scramble(char *cString, int iNumOfChars, char cXorKey);
10 | 	void Scramble(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey);
11 | 
12 | protected:
13 | 	char *cStringPointer;
14 | 	int iCStringPointerLen;
15 | 	wchar_t *wcStringPointer;
16 | 	int iWStringPointerLen;
17 | 
18 | };
19 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP8D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_BUMP8D.h"
 4 | #include <stdlib.h>
 5 | #include <time.h>
 6 | 
 7 | MBL_CLASS_BUMP8D::MBL_CLASS_BUMP8D(void)
 8 | {
 9 | 	wcStringPointer = NULL;
10 | 	iWStringPointerLen = NULL;
11 | 
12 | 	cStringPointer = NULL;
13 | 	iCStringPointerLen = NULL;
14 | }
15 | 
16 | MBL_CLASS_BUMP8D::~MBL_CLASS_BUMP8D(void)
17 | {
18 | 	srand((DWORD) time(NULL));
19 | 
20 | 	if (cStringPointer)
21 | 	{
22 | 		for (int i = iCStringPointerLen - 1; i >= 0; i--)
23 | 			cStringPointer[i] = (unsigned char)rand() % 255;
24 | 	}
25 | 
26 | 
27 | 	if (wcStringPointer)
28 | 	{
29 | 		for (int i = iWStringPointerLen - 1; i >= 0; i--)
30 | 			wcStringPointer[i] = rand() % 65534;
31 | 	}
32 | }
33 | 
34 | void MBL_CLASS_BUMP8D::Scramble(char *cString, int iNumOfChars, char cXorKey)
35 | {
36 | 	cStringPointer = cString;
37 | 	iCStringPointerLen = iNumOfChars;
38 | 
39 | 	//Xor
40 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
41 | 		cString[i] += cXorKey;
42 | }
43 | 
44 | void MBL_CLASS_BUMP8D::Scramble(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
45 | {
46 | 	wcStringPointer = wcString;
47 | 	iWStringPointerLen = iNumOfChars;
48 | 
49 | 	//Xor
50 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
51 | 		wcString[i] += wcXorKey;
52 | }
53 | 
54 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP8D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_BUMP8D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_BUMP8D(void);
 8 | 	~MBL_CLASS_BUMP8D(void);
 9 | 	void Scramble(char *cString, int iNumOfChars, char cXorKey);
10 | 	void Scramble(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey);
11 | 
12 | protected:
13 | 	char *cStringPointer;
14 | 	int iCStringPointerLen;
15 | 	wchar_t *wcStringPointer;
16 | 	int iWStringPointerLen;
17 | 
18 | };
19 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP9D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_BUMP9D.h"
 4 | 
 5 | MBL_CLASS_BUMP9D::MBL_CLASS_BUMP9D(char *cXorKey, char *cString, int iNumOfChars)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Xor
14 | 	for (int i = 0; i < iNumOfChars; i++)
15 | 		cString[i] -= cXorKey[i % 8];
16 | }
17 | 
18 | MBL_CLASS_BUMP9D::MBL_CLASS_BUMP9D(wchar_t *wcXorKey, wchar_t *wcString, int iNumOfChars)
19 | {
20 | 	wcStringPointer = wcString;
21 | 	iWStringPointerLen = iNumOfChars;
22 | 
23 | 	cStringPointer = NULL;
24 | 	iCStringPointerLen = NULL;
25 | 
26 | 	//Xor
27 | 	for (int i = 0; i < iNumOfChars; i++)
28 | 		wcString[i] -= wcXorKey[i % 8];
29 | }
30 | 
31 | MBL_CLASS_BUMP9D::~MBL_CLASS_BUMP9D(void)
32 | {
33 | 	
34 | 	if (cStringPointer)
35 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
36 | 
37 | 
38 | 	if (wcStringPointer)
39 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
40 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_BUMP9D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_BUMP9D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_BUMP9D(char *cXorKey, char *cString, int iNumOfChars);
 8 | 	MBL_CLASS_BUMP9D(wchar_t *wcXorKey, wchar_t *wcString, int iNumOfChars);
 9 | 	~MBL_CLASS_BUMP9D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP10D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RBUMP10D.h"
 4 | 
 5 | MBL_CLASS_RBUMP10D::MBL_CLASS_RBUMP10D(char *cString, int iNumOfChars, char cXorKey)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Bump
14 | 	for (int i = iNumOfChars - 1; i > 0; i--)
15 | 		cString[i] -= cString[i - 1];
16 | 	cString[0] += cXorKey;
17 | }
18 | 
19 | MBL_CLASS_RBUMP10D::MBL_CLASS_RBUMP10D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
20 | {
21 | 	wcStringPointer = wcString;
22 | 	iWStringPointerLen = iNumOfChars;
23 | 
24 | 	cStringPointer = 0;
25 | 	iCStringPointerLen = 0;
26 | 
27 | 	//Bump
28 | 	for (int i = iNumOfChars - 1; i > 0; i--)
29 | 		wcString[i] -= wcString[i - 1];
30 | 	wcString[0] += wcXorKey;
31 | 
32 | }
33 | 
34 | MBL_CLASS_RBUMP10D::~MBL_CLASS_RBUMP10D(void)
35 | {
36 | 	if (cStringPointer)
37 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
38 | 
39 | 	if (wcStringPointer)
40 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
41 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP10D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RBUMP10D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RBUMP10D(char *cString, int iNumOfChars, char cXorKey);
 8 | 	MBL_CLASS_RBUMP10D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey);
 9 | 	~MBL_CLASS_RBUMP10D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP11D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RBUMP11D.h"
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <time.h>
 7 | 
 8 | MBL_CLASS_RBUMP11D::MBL_CLASS_RBUMP11D(char *cString, int iNumOfChars, char cXorKey)
 9 | {
10 | 	cStringPointer = cString;
11 | 	iCStringPointerLen = iNumOfChars;
12 | 
13 | 	wcStringPointer = NULL;
14 | 	iWStringPointerLen = NULL;
15 | 
16 | 	//Bump
17 | 	char cBump = cString[0];
18 | 	for (int i = 1; i < iNumOfChars; i++)
19 | 	{
20 | 		char cTempChar = cString[i];
21 | 		cString[i] += cBump;
22 | 		cBump = cTempChar;
23 | 
24 | 	}
25 | 	cString[0] -= cXorKey;
26 | }
27 | 
28 | MBL_CLASS_RBUMP11D::MBL_CLASS_RBUMP11D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
29 | {
30 | 	wcStringPointer = wcString;
31 | 	iWStringPointerLen = iNumOfChars;
32 | 
33 | 	cStringPointer = 0;
34 | 	iCStringPointerLen = 0;
35 | 
36 | 	//Bump
37 | 	wchar_t wcBump = wcString[0];
38 | 	for (int i = 1; i < iNumOfChars; i++)
39 | 	{
40 | 		wchar_t wcTempChar = wcString[i];
41 | 		wcString[i] += wcBump;
42 | 		wcBump = wcTempChar;
43 | 
44 | 	}
45 | 	wcString[0] -= wcXorKey;
46 | 
47 | }
48 | 
49 | MBL_CLASS_RBUMP11D::~MBL_CLASS_RBUMP11D(void)
50 | {
51 | 	srand((DWORD) time(NULL));
52 | 
53 | 	if (cStringPointer)
54 | 	{
55 | 		for (int i = 0; i < iCStringPointerLen; i++)
56 | 			cStringPointer[i] = (unsigned char)rand() % 255;
57 | 	}
58 | 
59 | 
60 | 	if (wcStringPointer)
61 | 	{
62 | 		for (int i = 0; i < iWStringPointerLen; i++)
63 | 			wcStringPointer[i] = rand() % 65534;
64 | 	}
65 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP11D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RBUMP11D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RBUMP11D(char *cString, int iNumOfChars, char cXorKey);
 8 | 	MBL_CLASS_RBUMP11D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey);
 9 | 	~MBL_CLASS_RBUMP11D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP12D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RBUMP12D.h"
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <time.h>
 7 | 
 8 | MBL_CLASS_RBUMP12D::MBL_CLASS_RBUMP12D(char *cString, int iNumOfChars, char cXorKey)
 9 | {
10 | 	cStringPointer = cString;
11 | 	iCStringPointerLen = iNumOfChars;
12 | 
13 | 	wcStringPointer = NULL;
14 | 	iWStringPointerLen = NULL;
15 | 
16 | 	//Bump
17 | 	for (int i = iNumOfChars - 1; i > 0; i--)
18 | 		cString[i] -= cString[i - 1];
19 | 	cString[0] += cXorKey;
20 | }
21 | 
22 | MBL_CLASS_RBUMP12D::MBL_CLASS_RBUMP12D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
23 | {
24 | 	wcStringPointer = wcString;
25 | 	iWStringPointerLen = iNumOfChars;
26 | 
27 | 	cStringPointer = 0;
28 | 	iCStringPointerLen = 0;
29 | 
30 | 	//Bump
31 | 	for (int i = iNumOfChars - 1; i > 0; i--)
32 | 		wcString[i] -= wcString[i - 1];
33 | 	wcString[0] += wcXorKey;
34 | 
35 | }
36 | 
37 | MBL_CLASS_RBUMP12D::~MBL_CLASS_RBUMP12D(void)
38 | {
39 | 	srand((DWORD) time(NULL));
40 | 
41 | 	if (cStringPointer)
42 | 	{
43 | 		for (int i = iCStringPointerLen - 1; i >= 0; i--)
44 | 			cStringPointer[i] = (unsigned char)rand() % 255;
45 | 	}
46 | 
47 | 
48 | 	if (wcStringPointer)
49 | 	{
50 | 		for (int i = iWStringPointerLen - 1; i >= 0; i--)
51 | 			wcStringPointer[i] = rand() % 65534;
52 | 	}
53 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP12D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RBUMP12D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RBUMP12D(char *cString, int iNumOfChars, char cXorKey);
 8 | 	MBL_CLASS_RBUMP12D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey);
 9 | 	~MBL_CLASS_RBUMP12D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP1D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RBUMP1D.h"
 4 | 
 5 | MBL_CLASS_RBUMP1D::MBL_CLASS_RBUMP1D(char cXorKey, int iNumOfChars, char *cString)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Bump
14 | 	char cBump = cString[0];
15 | 	for (int i = 1; i < iNumOfChars; i++)
16 | 	{
17 | 		char cTempChar = cString[i];
18 | 		cString[i] -= cBump;
19 | 		cBump = cTempChar;
20 | 
21 | 	}
22 | 	cString[0] -= cXorKey;
23 | }
24 | 
25 | MBL_CLASS_RBUMP1D::MBL_CLASS_RBUMP1D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
26 | {
27 | 	wcStringPointer = wcString;
28 | 	iWStringPointerLen = iNumOfChars;
29 | 
30 | 	cStringPointer = 0;
31 | 	iCStringPointerLen = 0;
32 | 
33 | 	//Bump
34 | 	wchar_t wcBump = wcString[0];
35 | 	for (int i = 1; i < iNumOfChars; i++)
36 | 	{
37 | 		wchar_t wcTempChar = wcString[i];
38 | 		wcString[i] -= wcBump;
39 | 		wcBump = wcTempChar;
40 | 
41 | 	}
42 | 	wcString[0] -= wcXorKey;
43 | 	
44 | }
45 | 
46 | MBL_CLASS_RBUMP1D::~MBL_CLASS_RBUMP1D(void)
47 | {
48 | 	if (cStringPointer)
49 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
50 | 
51 | 	if (wcStringPointer)
52 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
53 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP1D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RBUMP1D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RBUMP1D(char cXorKey, int iNumOfChars, char *cString);
 8 | 	MBL_CLASS_RBUMP1D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
 9 | 	~MBL_CLASS_RBUMP1D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP2D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RBUMP2D.h"
 4 | 
 5 | MBL_CLASS_RBUMP2D::MBL_CLASS_RBUMP2D(char cXorKey, int iNumOfChars, char *cString)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Bump
14 | 	for (int i = iNumOfChars - 1; i > 0; i--)
15 | 		cString[i] -= cString[i - 1];
16 | 	cString[0] -= cXorKey;
17 | }
18 | 
19 | MBL_CLASS_RBUMP2D::MBL_CLASS_RBUMP2D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
20 | {
21 | 	wcStringPointer = wcString;
22 | 	iWStringPointerLen = iNumOfChars;
23 | 
24 | 	cStringPointer = 0;
25 | 	iCStringPointerLen = 0;
26 | 
27 | 	//Bump
28 | 	for (int i = iNumOfChars - 1; i > 0; i--)
29 | 		wcString[i] -= wcString[i - 1];
30 | 	wcString[0] -= wcXorKey;
31 | 
32 | }
33 | 
34 | MBL_CLASS_RBUMP2D::~MBL_CLASS_RBUMP2D(void)
35 | {
36 | 	if (cStringPointer)
37 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
38 | 
39 | 	if (wcStringPointer)
40 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
41 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP2D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RBUMP2D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RBUMP2D(char cXorKey, int iNumOfChars, char *cString);
 8 | 	MBL_CLASS_RBUMP2D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
 9 | 	~MBL_CLASS_RBUMP2D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP3D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RBUMP3D.h"
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <time.h>
 7 | 
 8 | MBL_CLASS_RBUMP3D::MBL_CLASS_RBUMP3D(char cXorKey, int iNumOfChars, char *cString)
 9 | {
10 | 	cStringPointer = cString;
11 | 	iCStringPointerLen = iNumOfChars;
12 | 
13 | 	wcStringPointer = NULL;
14 | 	iWStringPointerLen = NULL;
15 | 
16 | 	//Bump
17 | 	for (int i = 0; i < iNumOfChars - 1; i++)
18 | 		cString[i] += cString[i + 1];
19 | 	cString[iNumOfChars - 1] += cXorKey;
20 | }
21 | 
22 | MBL_CLASS_RBUMP3D::MBL_CLASS_RBUMP3D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
23 | {
24 | 	wcStringPointer = wcString;
25 | 	iWStringPointerLen = iNumOfChars;
26 | 
27 | 	cStringPointer = 0;
28 | 	iCStringPointerLen = 0;
29 | 
30 | 	//Bump
31 | 	for (int i = 0; i < iNumOfChars - 1; i++)
32 | 		wcString[i] += wcString[i + 1];
33 | 	wcString[iNumOfChars - 1] += wcXorKey;
34 | 
35 | }
36 | 
37 | MBL_CLASS_RBUMP3D::~MBL_CLASS_RBUMP3D(void)
38 | {
39 | 	srand((DWORD) time(NULL));
40 | 	
41 | 	if (cStringPointer)
42 | 	{
43 | 		for (int i = 0; i < iCStringPointerLen; i++)
44 | 			cStringPointer[i] = (unsigned char)rand() % 255;
45 | 	}
46 | 
47 | 
48 | 	if (wcStringPointer)
49 | 	{
50 | 		for (int i = 0; i < iWStringPointerLen; i++)
51 | 			wcStringPointer[i] = rand() % 65534;
52 | 	}
53 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP3D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RBUMP3D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RBUMP3D(char cXorKey, int iNumOfChars, char *cString);
 8 | 	MBL_CLASS_RBUMP3D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
 9 | 	~MBL_CLASS_RBUMP3D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP4D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RBUMP4D.h"
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <time.h>
 7 | 
 8 | MBL_CLASS_RBUMP4D::MBL_CLASS_RBUMP4D(char cXorKey, int iNumOfChars, char *cString)
 9 | {
10 | 	cStringPointer = cString;
11 | 	iCStringPointerLen = iNumOfChars;
12 | 
13 | 	wcStringPointer = NULL;
14 | 	iWStringPointerLen = NULL;
15 | 
16 | 	//Bump
17 | 	char cBump = cString[iNumOfChars - 1];
18 | 	for (int i = iNumOfChars - 2; i >= 0; i--)
19 | 	{
20 | 		char cTempChar = cString[i];
21 | 		cString[i] += cBump;
22 | 		cBump = cTempChar;
23 | 
24 | 	}
25 | 	cString[iNumOfChars - 1] += cXorKey;
26 | }
27 | 
28 | MBL_CLASS_RBUMP4D::MBL_CLASS_RBUMP4D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
29 | {
30 | 	wcStringPointer = wcString;
31 | 	iWStringPointerLen = iNumOfChars;
32 | 
33 | 	cStringPointer = 0;
34 | 	iCStringPointerLen = 0;
35 | 
36 | 	//Bump
37 | 	wchar_t wcBump = wcString[iNumOfChars - 1];
38 | 	for (int i = iNumOfChars - 2; i >= 0; i--)
39 | 	{
40 | 		wchar_t wcTempChar = wcString[i];
41 | 		wcString[i] += wcBump;
42 | 		wcBump = wcTempChar;
43 | 
44 | 	}
45 | 	wcString[iNumOfChars - 1] += wcXorKey;
46 | 
47 | }
48 | 
49 | MBL_CLASS_RBUMP4D::~MBL_CLASS_RBUMP4D(void)
50 | {
51 | 	srand((DWORD) time(NULL));
52 | 
53 | 	if (cStringPointer)
54 | 	{
55 | 		for (int i = iCStringPointerLen - 1; i >= 0; i--)
56 | 			cStringPointer[i] = (unsigned char)rand() % 255;
57 | 	}
58 | 
59 | 
60 | 	if (wcStringPointer)
61 | 	{
62 | 		for (int i = iWStringPointerLen - 1; i >= 0; i--)
63 | 			wcStringPointer[i] = rand() % 65534;
64 | 	}
65 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP4D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RBUMP4D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RBUMP4D(char cXorKey, int iNumOfChars, char *cString);
 8 | 	MBL_CLASS_RBUMP4D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
 9 | 	~MBL_CLASS_RBUMP4D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP5D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RBUMP5D.h"
 4 | 
 5 | MBL_CLASS_RBUMP5D::MBL_CLASS_RBUMP5D(void)
 6 | {
 7 | 	wcStringPointer = NULL;
 8 | 	iWStringPointerLen = NULL;
 9 | 
10 | 	cStringPointer = NULL;
11 | 	iCStringPointerLen = NULL;
12 | }
13 | 
14 | MBL_CLASS_RBUMP5D::~MBL_CLASS_RBUMP5D(void)
15 | {
16 | 	if (cStringPointer)
17 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
18 | 
19 | 	if (wcStringPointer)
20 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
21 | }
22 | 
23 | void MBL_CLASS_RBUMP5D::Scramble(char cXorKey, char *cString, int iNumOfChars)
24 | {
25 | 	cStringPointer = cString;
26 | 	iCStringPointerLen = iNumOfChars;
27 | 
28 | 	//Bump
29 | 	char cBump = cString[0];
30 | 	for (int i = 1; i < iNumOfChars; i++)
31 | 	{
32 | 		char cTempChar = cString[i];
33 | 		cString[i] -= cBump;
34 | 		cBump = cTempChar;
35 | 
36 | 	}
37 | 	cString[0] -= cXorKey;
38 | }
39 | 
40 | void MBL_CLASS_RBUMP5D::Scramble(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars)
41 | {
42 | 	wcStringPointer = wcString;
43 | 	iWStringPointerLen = iNumOfChars;
44 | 
45 | 	//Bump
46 | 	wchar_t wcBump = wcString[0];
47 | 	for (int i = 1; i < iNumOfChars; i++)
48 | 	{
49 | 		wchar_t wcTempChar = wcString[i];
50 | 		wcString[i] -= wcBump;
51 | 		wcBump = wcTempChar;
52 | 
53 | 	}
54 | 	wcString[0] -= wcXorKey;
55 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP5D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RBUMP5D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RBUMP5D(void);
 8 | 	void Scramble(char cXorKey, char *cString, int iNumOfChars);
 9 | 	void Scramble(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars);
10 | 	~MBL_CLASS_RBUMP5D(void);
11 | 
12 | protected:
13 | 	char *cStringPointer;
14 | 	int iCStringPointerLen;
15 | 	wchar_t *wcStringPointer;
16 | 	int iWStringPointerLen;
17 | 
18 | };
19 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP6D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RBUMP6D.h"
 4 | 
 5 | MBL_CLASS_RBUMP6D::MBL_CLASS_RBUMP6D(void)
 6 | {
 7 | 	wcStringPointer = NULL;
 8 | 	iWStringPointerLen = NULL;
 9 | 
10 | 	cStringPointer = NULL;
11 | 	iCStringPointerLen = NULL;
12 | }
13 | 
14 | MBL_CLASS_RBUMP6D::~MBL_CLASS_RBUMP6D(void)
15 | {
16 | 	if (cStringPointer)
17 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
18 | 
19 | 	if (wcStringPointer)
20 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
21 | }
22 | 
23 | void MBL_CLASS_RBUMP6D::Scramble(char cXorKey, char *cString, int iNumOfChars)
24 | {
25 | 	cStringPointer = cString;
26 | 	iCStringPointerLen = iNumOfChars;
27 | 
28 | 	//Bump
29 | 	for (int i = iNumOfChars - 1; i > 0; i--)
30 | 		cString[i] -= cString[i - 1];
31 | 	cString[0] -= cXorKey;
32 | }
33 | 
34 | void MBL_CLASS_RBUMP6D::Scramble(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars)
35 | {
36 | 	wcStringPointer = wcString;
37 | 	iWStringPointerLen = iNumOfChars;
38 | 
39 | 	//Bump
40 | 	for (int i = iNumOfChars - 1; i > 0; i--)
41 | 		wcString[i] -= wcString[i - 1];
42 | 	wcString[0] -= wcXorKey;
43 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP6D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RBUMP6D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RBUMP6D(void);
 8 | 	void Scramble(char cXorKey, char *cString, int iNumOfChars);
 9 | 	void Scramble(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars);
10 | 	~MBL_CLASS_RBUMP6D(void);
11 | 
12 | protected:
13 | 	char *cStringPointer;
14 | 	int iCStringPointerLen;
15 | 	wchar_t *wcStringPointer;
16 | 	int iWStringPointerLen;
17 | 
18 | };
19 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP7D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RBUMP7D.h"
 4 | #include <stdlib.h>
 5 | #include <time.h>
 6 | 
 7 | MBL_CLASS_RBUMP7D::MBL_CLASS_RBUMP7D(void)
 8 | {
 9 | 	wcStringPointer = NULL;
10 | 	iWStringPointerLen = NULL;
11 | 
12 | 	cStringPointer = 0;
13 | 	iCStringPointerLen = 0;
14 | }
15 | 
16 | MBL_CLASS_RBUMP7D::~MBL_CLASS_RBUMP7D(void)
17 | {
18 | 	srand((DWORD) time(NULL));
19 | 
20 | 	if (cStringPointer)
21 | 	{
22 | 		for (int i = 0; i < iCStringPointerLen; i++)
23 | 			cStringPointer[i] = (unsigned char)rand() % 255;
24 | 	}
25 | 
26 | 
27 | 	if (wcStringPointer)
28 | 	{
29 | 		for (int i = 0; i < iWStringPointerLen; i++)
30 | 			wcStringPointer[i] = rand() % 65534;
31 | 	}
32 | }
33 | 
34 | void MBL_CLASS_RBUMP7D::Scramble(char cXorKey, char *cString, int iNumOfChars)
35 | {
36 | 	cStringPointer = cString;
37 | 	iCStringPointerLen = iNumOfChars;
38 | 
39 | 	//Bump
40 | 	for (int i = 0; i < iNumOfChars - 1; i++)
41 | 		cString[i] += cString[i + 1];
42 | 	cString[iNumOfChars - 1] += cXorKey;
43 | }
44 | 
45 | void MBL_CLASS_RBUMP7D::Scramble(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars)
46 | {
47 | 	wcStringPointer = wcString;
48 | 	iWStringPointerLen = iNumOfChars;
49 | 
50 | 	//Bump
51 | 	for (int i = 0; i < iNumOfChars - 1; i++)
52 | 		wcString[i] += wcString[i + 1];
53 | 	wcString[iNumOfChars - 1] += wcXorKey;
54 | }
55 | 
56 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP7D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RBUMP7D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RBUMP7D(void);
 8 | 	void Scramble(char cXorKey, char *cString, int iNumOfChars);
 9 | 	void Scramble(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars);
10 | 	~MBL_CLASS_RBUMP7D(void);
11 | 
12 | protected:
13 | 	char *cStringPointer;
14 | 	int iCStringPointerLen;
15 | 	wchar_t *wcStringPointer;
16 | 	int iWStringPointerLen;
17 | 
18 | };
19 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP8D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RBUMP8D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RBUMP8D(void);
 8 | 	void Scramble(char cXorKey, char *cString, int iNumOfChars);
 9 | 	void Scramble(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars);
10 | 	~MBL_CLASS_RBUMP8D(void);
11 | 
12 | protected:
13 | 	char *cStringPointer;
14 | 	int iCStringPointerLen;
15 | 	wchar_t *wcStringPointer;
16 | 	int iWStringPointerLen;
17 | 
18 | };
19 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP9D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RBUMP9D.h"
 4 | 
 5 | MBL_CLASS_RBUMP9D::MBL_CLASS_RBUMP9D(char *cString, int iNumOfChars, char cXorKey)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Bump
14 | 	char cBump = cString[0];
15 | 	for (int i = 1; i < iNumOfChars; i++)
16 | 	{
17 | 		char cTempChar = cString[i];
18 | 		cString[i] += cBump;
19 | 		cBump = cTempChar;
20 | 
21 | 	}
22 | 	cString[0] -= cXorKey;
23 | }
24 | 
25 | MBL_CLASS_RBUMP9D::MBL_CLASS_RBUMP9D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
26 | {
27 | 	wcStringPointer = wcString;
28 | 	iWStringPointerLen = iNumOfChars;
29 | 
30 | 	cStringPointer = 0;
31 | 	iCStringPointerLen = 0;
32 | 
33 | 	//Bump
34 | 	wchar_t wcBump = wcString[0];
35 | 	for (int i = 1; i < iNumOfChars; i++)
36 | 	{
37 | 		wchar_t wcTempChar = wcString[i];
38 | 		wcString[i] += wcBump;
39 | 		wcBump = wcTempChar;
40 | 
41 | 	}
42 | 	wcString[0] -= wcXorKey;
43 | 
44 | }
45 | 
46 | MBL_CLASS_RBUMP9D::~MBL_CLASS_RBUMP9D(void)
47 | {
48 | 	if (cStringPointer)
49 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
50 | 
51 | 	if (wcStringPointer)
52 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
53 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RBUMP9D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RBUMP9D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RBUMP9D(char *cString, int iNumOfChars, char cXorKey);
 8 | 	MBL_CLASS_RBUMP9D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey);
 9 | 	~MBL_CLASS_RBUMP9D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR10D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RXOR10D.h"
 4 | 
 5 | MBL_CLASS_RXOR10D::MBL_CLASS_RXOR10D(char cXorKey, char *cString, int iNumOfChars)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Xor
14 | 	CHAR cXorByte = cString[iNumOfChars - 1];
15 | 	cString[iNumOfChars - 1] ^= cXorKey;
16 | 	for (int i = iNumOfChars - 2; i >= 0; i--)
17 | 	{
18 | 		CHAR cTemp = cString[i];
19 | 		cString[i] ^= cXorByte;
20 | 		cXorByte = cTemp;
21 | 	}
22 | 	
23 | }
24 | 
25 | MBL_CLASS_RXOR10D::MBL_CLASS_RXOR10D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars)
26 | {
27 | 	wcStringPointer = wcString;
28 | 	iWStringPointerLen = iNumOfChars;
29 | 
30 | 	cStringPointer = 0;
31 | 	iCStringPointerLen = 0;
32 | 
33 | 	//Xor
34 | 	WCHAR wcXorByte = wcString[iNumOfChars - 1];
35 | 	wcString[iNumOfChars - 1] ^= wcXorKey;
36 | 	for (int i = iNumOfChars - 2; i >= 0; i--)
37 | 	{
38 | 		WCHAR wcTemp = wcString[i];
39 | 		wcString[i] ^= wcXorByte;
40 | 		wcXorByte = wcTemp;
41 | 	}
42 | }
43 | 
44 | MBL_CLASS_RXOR10D::~MBL_CLASS_RXOR10D(void)
45 | {
46 | 	if (cStringPointer)
47 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
48 | 
49 | 	if (wcStringPointer)
50 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
51 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR10D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RXOR10D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RXOR10D(char cXorKey, char *cString, int iNumOfChars);
 8 | 	MBL_CLASS_RXOR10D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars);
 9 | 	~MBL_CLASS_RXOR10D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR11D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RXOR11D.h"
 4 | #include <stdlib.h>
 5 | #include <time.h>
 6 | 
 7 | MBL_CLASS_RXOR11D::MBL_CLASS_RXOR11D(char cXorKey, char *cString, int iNumOfChars)
 8 | {
 9 | 	cStringPointer = cString;
10 | 	iCStringPointerLen = iNumOfChars;
11 | 
12 | 	wcStringPointer = NULL;
13 | 	iWStringPointerLen = NULL;
14 | 
15 | 	//Xor
16 | 	for (int i = 0; i < iNumOfChars - 1; i++)
17 | 	{
18 | 		cString[i] ^= cString[i + 1];
19 | 	}
20 | 	cString[iNumOfChars - 1] ^= cXorKey;
21 | }
22 | 
23 | MBL_CLASS_RXOR11D::MBL_CLASS_RXOR11D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars)
24 | {
25 | 	wcStringPointer = wcString;
26 | 	iWStringPointerLen = iNumOfChars;
27 | 
28 | 	cStringPointer = 0;
29 | 	iCStringPointerLen = 0;
30 | 
31 | 	//Xor
32 | 	for (int i = 0; i < iNumOfChars - 1; i++)
33 | 	{
34 | 		wcString[i] ^= wcString[i + 1];
35 | 	}
36 | 	wcString[iNumOfChars - 1] ^= wcXorKey;
37 | }
38 | 
39 | MBL_CLASS_RXOR11D::~MBL_CLASS_RXOR11D(void)
40 | {
41 | 	srand((DWORD) time(NULL));
42 | 
43 | 	if (cStringPointer)
44 | 	{
45 | 		for (int i = 0; i < iCStringPointerLen; i++)
46 | 			cStringPointer[i] = (unsigned char)rand() % 255;
47 | 	}
48 | 
49 | 
50 | 	if (wcStringPointer)
51 | 	{
52 | 		for (int i = 0; i < iWStringPointerLen; i++)
53 | 			wcStringPointer[i] = rand() % 65534;
54 | 	}
55 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR11D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RXOR11D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RXOR11D(char cXorKey, char *cString, int iNumOfChars);
 8 | 	MBL_CLASS_RXOR11D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars);
 9 | 	~MBL_CLASS_RXOR11D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR12D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RXOR12D.h"
 4 | #include <stdlib.h>
 5 | #include <time.h>
 6 | 
 7 | MBL_CLASS_RXOR12D::MBL_CLASS_RXOR12D(char cXorKey, char *cString, int iNumOfChars)
 8 | {
 9 | 	cStringPointer = cString;
10 | 	iCStringPointerLen = iNumOfChars;
11 | 
12 | 	wcStringPointer = NULL;
13 | 	iWStringPointerLen = NULL;
14 | 
15 | 	//Xor
16 | 	CHAR cXorByte = cString[iNumOfChars - 1];
17 | 	cString[iNumOfChars - 1] ^= cXorKey;
18 | 	for (int i = iNumOfChars - 2; i >= 0; i--)
19 | 	{
20 | 		CHAR cTemp = cString[i];
21 | 		cString[i] ^= cXorByte;
22 | 		cXorByte = cTemp;
23 | 	}
24 | }
25 | 
26 | MBL_CLASS_RXOR12D::MBL_CLASS_RXOR12D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars)
27 | {
28 | 	wcStringPointer = wcString;
29 | 	iWStringPointerLen = iNumOfChars;
30 | 
31 | 	cStringPointer = 0;
32 | 	iCStringPointerLen = 0;
33 | 
34 | 	//Xor
35 | 	WCHAR wcXorByte = wcString[iNumOfChars - 1];
36 | 	wcString[iNumOfChars - 1] ^= wcXorKey;
37 | 	for (int i = iNumOfChars - 2; i >= 0; i--)
38 | 	{
39 | 		WCHAR wcTemp = wcString[i];
40 | 		wcString[i] ^= wcXorByte;
41 | 		wcXorByte = wcTemp;
42 | 	}
43 | }
44 | 
45 | MBL_CLASS_RXOR12D::~MBL_CLASS_RXOR12D(void)
46 | {
47 | 	srand((DWORD) time(NULL));
48 | 
49 | 	if (cStringPointer)
50 | 	{
51 | 		for (int i = iCStringPointerLen - 1; i >= 0; i--)
52 | 			cStringPointer[i] = (unsigned char)rand() % 255;
53 | 	}
54 | 
55 | 
56 | 	if (wcStringPointer)
57 | 	{
58 | 		for (int i = iWStringPointerLen - 1; i >= 0; i--)
59 | 			wcStringPointer[i] = rand() % 65534;
60 | 	}
61 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR12D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RXOR12D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RXOR12D(char cXorKey, char *cString, int iNumOfChars);
 8 | 	MBL_CLASS_RXOR12D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars);
 9 | 	~MBL_CLASS_RXOR12D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR1D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RXOR1D.h"
 4 | 
 5 | MBL_CLASS_RXOR1D::MBL_CLASS_RXOR1D(char cXorKey, int iNumOfChars, char *cString)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Xor
14 | 	for (int i = iNumOfChars - 1; i > 0; i--)
15 | 		cString[i] ^= cString[i - 1];
16 | 	cString[0] ^= cXorKey;
17 | }
18 | 
19 | MBL_CLASS_RXOR1D::MBL_CLASS_RXOR1D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
20 | {
21 | 	wcStringPointer = wcString;
22 | 	iWStringPointerLen = iNumOfChars;
23 | 
24 | 	cStringPointer = 0;
25 | 	iCStringPointerLen = 0;
26 | 
27 | 	//Xor
28 | 	for (int i = iNumOfChars - 1; i > 0; i--)
29 | 		wcString[i] ^= wcString[i - 1];
30 | 	wcString[0] ^= wcXorKey;
31 | }
32 | 
33 | MBL_CLASS_RXOR1D::~MBL_CLASS_RXOR1D(void)
34 | {
35 | 	if (cStringPointer)
36 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
37 | 
38 | 	if (wcStringPointer)
39 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
40 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR1D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RXOR1D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RXOR1D(char cXorKey, int iNumOfChars, char *cString);
 8 | 	MBL_CLASS_RXOR1D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
 9 | 	~MBL_CLASS_RXOR1D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR2D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RXOR2D.h"
 4 | 
 5 | MBL_CLASS_RXOR2D::MBL_CLASS_RXOR2D(char cXorKey, int iNumOfChars, char *cString)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Xor
14 | 	char cXor =  cString[0];
15 | 	for (int i = 1; i < iNumOfChars; i++)
16 | 	{
17 | 		char cTemp = cString[i];
18 | 		cString[i] ^= cXor;
19 | 		cXor = cTemp;
20 | 	}
21 | 	cString[0] ^= cXorKey;
22 | }
23 | 
24 | MBL_CLASS_RXOR2D::MBL_CLASS_RXOR2D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
25 | {
26 | 	wcStringPointer = wcString;
27 | 	iWStringPointerLen = iNumOfChars;
28 | 
29 | 	cStringPointer = 0;
30 | 	iCStringPointerLen = 0;
31 | 
32 | 	//Xor
33 | 	wchar_t wcXor = wcString[0];
34 | 	for (int i = 1; i < iNumOfChars; i++)
35 | 	{
36 | 		wchar_t wcTemp = wcString[i];
37 | 		wcString[i] ^= wcXor;
38 | 		wcXor = wcTemp;
39 | 	}
40 | 	wcString[0] ^= wcXorKey;
41 | }
42 | 
43 | MBL_CLASS_RXOR2D::~MBL_CLASS_RXOR2D(void)
44 | {
45 | 	if (cStringPointer)
46 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
47 | 
48 | 	if (wcStringPointer)
49 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
50 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR2D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RXOR2D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RXOR2D(char cXorKey, int iNumOfChars, char *cString);
 8 | 	MBL_CLASS_RXOR2D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
 9 | 	~MBL_CLASS_RXOR2D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR3D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RXOR3D.h"
 4 | #include <stdlib.h>
 5 | #include <time.h>
 6 | 
 7 | MBL_CLASS_RXOR3D::MBL_CLASS_RXOR3D(char cXorKey, int iNumOfChars, char *cString)
 8 | {
 9 | 	cStringPointer = cString;
10 | 	iCStringPointerLen = iNumOfChars;
11 | 
12 | 	wcStringPointer = NULL;
13 | 	iWStringPointerLen = NULL;
14 | 
15 | 	//Xor
16 | 	for (int i = iNumOfChars - 1; i > 0; i--)
17 | 		cString[i] ^= cString[i - 1];
18 | 	cString[0] ^= cXorKey;
19 | }
20 | 
21 | MBL_CLASS_RXOR3D::MBL_CLASS_RXOR3D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
22 | {
23 | 	wcStringPointer = wcString;
24 | 	iWStringPointerLen = iNumOfChars;
25 | 
26 | 	cStringPointer = 0;
27 | 	iCStringPointerLen = 0;
28 | 
29 | 	//Xor
30 | 	for (int i = iNumOfChars - 1; i > 0; i--)
31 | 		wcString[i] ^= wcString[i - 1];
32 | 	wcString[0] ^= wcXorKey;
33 | }
34 | 
35 | MBL_CLASS_RXOR3D::~MBL_CLASS_RXOR3D(void)
36 | {
37 | 	srand((DWORD) time(NULL));
38 | 
39 | 	if (cStringPointer)
40 | 	{
41 | 		for (int i = 0; i < iCStringPointerLen; i++)
42 | 			cStringPointer[i] = (unsigned char)rand() % 255;
43 | 	}
44 | 
45 | 
46 | 	if (wcStringPointer)
47 | 	{
48 | 		for (int i = 0; i < iWStringPointerLen; i++)
49 | 			wcStringPointer[i] = rand() % 65534;
50 | 	}
51 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR3D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RXOR3D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RXOR3D(char cXorKey, int iNumOfChars, char *cString);
 8 | 	MBL_CLASS_RXOR3D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
 9 | 	~MBL_CLASS_RXOR3D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR4D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RXOR4D.h"
 4 | #include <stdlib.h>
 5 | #include <time.h>
 6 | 
 7 | MBL_CLASS_RXOR4D::MBL_CLASS_RXOR4D(char cXorKey, int iNumOfChars, char *cString)
 8 | {
 9 | 	cStringPointer = cString;
10 | 	iCStringPointerLen = iNumOfChars;
11 | 
12 | 	wcStringPointer = NULL;
13 | 	iWStringPointerLen = NULL;
14 | 
15 | 	//Xor
16 | 	char cXor = cString[0];
17 | 	for (int i = 1; i < iNumOfChars; i++)
18 | 	{
19 | 		char cTemp = cString[i];
20 | 		cString[i] ^= cXor;
21 | 		cXor = cTemp;
22 | 	}
23 | 	cString[0] ^= cXorKey;
24 | }
25 | 
26 | MBL_CLASS_RXOR4D::MBL_CLASS_RXOR4D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
27 | {
28 | 	wcStringPointer = wcString;
29 | 	iWStringPointerLen = iNumOfChars;
30 | 
31 | 	cStringPointer = 0;
32 | 	iCStringPointerLen = 0;
33 | 
34 | 	//Xor
35 | 	wchar_t wcXor = wcString[0];
36 | 	for (int i = 1; i < iNumOfChars; i++)
37 | 	{
38 | 		wchar_t wcTemp = wcString[i];
39 | 		wcString[i] ^= wcXor;
40 | 		wcXor = wcTemp;
41 | 	}
42 | 	wcString[0] ^= wcXorKey;
43 | }
44 | 
45 | MBL_CLASS_RXOR4D::~MBL_CLASS_RXOR4D(void)
46 | {
47 | 	srand((DWORD) time(NULL));
48 | 
49 | 	if (cStringPointer)
50 | 	{
51 | 		for (int i = iCStringPointerLen - 1; i >= 0; i--)
52 | 			cStringPointer[i] = (unsigned char)rand() % 255;
53 | 	}
54 | 
55 | 
56 | 	if (wcStringPointer)
57 | 	{
58 | 		for (int i = iWStringPointerLen - 1; i >= 0; i--)
59 | 			wcStringPointer[i] = rand() % 65534;
60 | 	}
61 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR4D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RXOR4D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RXOR4D(char cXorKey, int iNumOfChars, char *cString);
 8 | 	MBL_CLASS_RXOR4D(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
 9 | 	~MBL_CLASS_RXOR4D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR5D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RXOR5D.h"
 4 | 
 5 | MBL_CLASS_RXOR5D::MBL_CLASS_RXOR5D(void)
 6 | {
 7 | 	wcStringPointer = NULL;
 8 | 	iWStringPointerLen = NULL;
 9 | 
10 | 	cStringPointer = NULL;
11 | 	iCStringPointerLen = NULL;
12 | }
13 | 
14 | MBL_CLASS_RXOR5D::~MBL_CLASS_RXOR5D(void)
15 | {
16 | 	if (cStringPointer)
17 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
18 | 
19 | 	if (wcStringPointer)
20 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
21 | }
22 | 
23 | void MBL_CLASS_RXOR5D::Scramble(char *cString, char cXorKey, int iNumOfChars)
24 | {
25 | 	cStringPointer = cString;
26 | 	iCStringPointerLen = iNumOfChars;
27 | 
28 | 	//Xor
29 | 	for (int i = iNumOfChars - 1; i > 0; i--)
30 | 		cString[i] ^= cString[i - 1];
31 | 	cString[0] ^= cXorKey;
32 | }
33 | 
34 | void MBL_CLASS_RXOR5D::Scramble(wchar_t *wcString, wchar_t wcXorKey, int iNumOfChars)
35 | {
36 | 	wcStringPointer = wcString;
37 | 	iWStringPointerLen = iNumOfChars;
38 | 
39 | 	//Xor
40 | 	for (int i = iNumOfChars - 1; i > 0; i--)
41 | 		wcString[i] ^= wcString[i - 1];
42 | 	wcString[0] ^= wcXorKey;
43 | }
44 | 
45 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR5D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RXOR5D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RXOR5D(void);
 8 | 	~MBL_CLASS_RXOR5D(void);
 9 | 
10 | 	void Scramble(char *cString, char cXorKey, int iNumOfChars);
11 | 	void Scramble(wchar_t *wcString, wchar_t wcXorKey, int iNumOfChars);
12 | 
13 | protected:
14 | 	char *cStringPointer;
15 | 	int iCStringPointerLen;
16 | 	wchar_t *wcStringPointer;
17 | 	int iWStringPointerLen;
18 | 
19 | };
20 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR6D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RXOR6D.h"
 4 | 
 5 | MBL_CLASS_RXOR6D::MBL_CLASS_RXOR6D(void)
 6 | {
 7 | 
 8 | }
 9 | 
10 | MBL_CLASS_RXOR6D::~MBL_CLASS_RXOR6D(void)
11 | {
12 | 	if (cStringPointer)
13 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
14 | 
15 | 	if (wcStringPointer)
16 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
17 | }
18 | 
19 | void MBL_CLASS_RXOR6D::Scramble(char *cString, char cXorKey, int iNumOfChars)
20 | {
21 | 	cStringPointer = cString;
22 | 	iCStringPointerLen = iNumOfChars;
23 | 
24 | 	wcStringPointer = NULL;
25 | 	iWStringPointerLen = NULL;
26 | 
27 | 	//Xor
28 | 	char cXor =  cString[0];
29 | 	for (int i = 1; i < iNumOfChars; i++)
30 | 	{
31 | 		char cTemp = cString[i];
32 | 		cString[i] ^= cXor;
33 | 		cXor = cTemp;
34 | 	}
35 | 	cString[0] ^= cXorKey;
36 | }
37 | 
38 | void MBL_CLASS_RXOR6D::Scramble(wchar_t *wcString, wchar_t wcXorKey, int iNumOfChars)
39 | {
40 | 	wcStringPointer = wcString;
41 | 	iWStringPointerLen = iNumOfChars;
42 | 
43 | 	cStringPointer = 0;
44 | 	iCStringPointerLen = 0;
45 | 
46 | 	//Xor
47 | 	wchar_t wcXor = wcString[0];
48 | 	for (int i = 1; i < iNumOfChars; i++)
49 | 	{
50 | 		wchar_t wcTemp = wcString[i];
51 | 		wcString[i] ^= wcXor;
52 | 		wcXor = wcTemp;
53 | 	}
54 | 	wcString[0] ^= wcXorKey;
55 | }
56 | 
57 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR6D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RXOR6D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RXOR6D(void);
 8 | 	~MBL_CLASS_RXOR6D(void);
 9 | 
10 | 	void Scramble(char *cString, char cXorKey, int iNumOfChars);
11 | 	void Scramble(wchar_t *wcString, wchar_t wcXorKey, int iNumOfChars);
12 | 
13 | protected:
14 | 	char *cStringPointer;
15 | 	int iCStringPointerLen;
16 | 	wchar_t *wcStringPointer;
17 | 	int iWStringPointerLen;
18 | 
19 | };
20 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR7D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RXOR7D.h"
 4 | #include <stdlib.h>
 5 | #include <time.h>
 6 | 
 7 | MBL_CLASS_RXOR7D::MBL_CLASS_RXOR7D(void)
 8 | {
 9 | 	wcStringPointer = NULL;
10 | 	iWStringPointerLen = NULL;
11 | 
12 | 	cStringPointer = NULL;
13 | 	iCStringPointerLen = NULL;
14 | }
15 | 
16 | MBL_CLASS_RXOR7D::~MBL_CLASS_RXOR7D(void)
17 | {
18 | 	srand((DWORD) time(NULL));
19 | 
20 | 	if (cStringPointer)
21 | 	{
22 | 		for (int i = 0; i < iCStringPointerLen; i++)
23 | 			cStringPointer[i] = (unsigned char)rand() % 255;
24 | 	}
25 | 
26 | 
27 | 	if (wcStringPointer)
28 | 	{
29 | 		for (int i = 0; i < iWStringPointerLen; i++)
30 | 			wcStringPointer[i] = rand() % 65534;
31 | 	}
32 | }
33 | 
34 | void MBL_CLASS_RXOR7D::Scramble(char *cString, char cXorKey, int iNumOfChars)
35 | {
36 | 	cStringPointer = cString;
37 | 	iCStringPointerLen = iNumOfChars;
38 | 
39 | 	//Xor
40 | 	for (int i = iNumOfChars - 1; i > 0; i--)
41 | 		cString[i] ^= cString[i - 1];
42 | 	cString[0] ^= cXorKey;
43 | }
44 | 
45 | void MBL_CLASS_RXOR7D::Scramble(wchar_t *wcString, wchar_t wcXorKey, int iNumOfChars)
46 | {
47 | 	wcStringPointer = wcString;
48 | 	iWStringPointerLen = iNumOfChars;
49 | 
50 | 	//Xor
51 | 	for (int i = iNumOfChars - 1; i > 0; i--)
52 | 		wcString[i] ^= wcString[i - 1];
53 | 	wcString[0] ^= wcXorKey;
54 | }
55 | 
56 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR7D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RXOR7D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RXOR7D(void);
 8 | 	~MBL_CLASS_RXOR7D(void);
 9 | 
10 | 	void Scramble(char *cString, char cXorKey, int iNumOfChars);
11 | 	void Scramble(wchar_t *wcString, wchar_t wcXorKey, int iNumOfChars);
12 | 
13 | protected:
14 | 	char *cStringPointer;
15 | 	int iCStringPointerLen;
16 | 	wchar_t *wcStringPointer;
17 | 	int iWStringPointerLen;
18 | 
19 | };
20 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR8D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RXOR8D.h"
 4 | #include <stdlib.h>
 5 | #include <time.h>
 6 | 
 7 | 
 8 | MBL_CLASS_RXOR8D::MBL_CLASS_RXOR8D(void)
 9 | {
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	cStringPointer = NULL;
14 | 	iCStringPointerLen = NULL;
15 | }
16 | 
17 | MBL_CLASS_RXOR8D::~MBL_CLASS_RXOR8D(void)
18 | {
19 | 	srand((DWORD) time(NULL));
20 | 
21 | 	if (cStringPointer)
22 | 	{
23 | 		for (int i = iCStringPointerLen - 1; i >= 0; i--)
24 | 			cStringPointer[i] = (unsigned char)rand() % 255;
25 | 	}
26 | 
27 | 
28 | 	if (wcStringPointer)
29 | 	{
30 | 		for (int i = iWStringPointerLen - 1; i >= 0; i--)
31 | 			wcStringPointer[i] = rand() % 65534;
32 | 	}
33 | }
34 | 
35 | void MBL_CLASS_RXOR8D::Scramble(char *cString, char cXorKey, int iNumOfChars)
36 | {
37 | 	cStringPointer = cString;
38 | 	iCStringPointerLen = iNumOfChars;
39 | 
40 | 	//Xor
41 | 	char cXor = cString[0];
42 | 	for (int i = 1; i < iNumOfChars; i++)
43 | 	{
44 | 		char cTemp = cString[i];
45 | 		cString[i] ^= cXor;
46 | 		cXor = cTemp;
47 | 	}
48 | 	cString[0] ^= cXorKey;
49 | }
50 | 
51 | void MBL_CLASS_RXOR8D::Scramble(wchar_t *wcString, wchar_t wcXorKey, int iNumOfChars)
52 | {
53 | 	wcStringPointer = wcString;
54 | 	iWStringPointerLen = iNumOfChars;
55 | 
56 | 	//Xor
57 | 	wchar_t wcXor = wcString[0];
58 | 	for (int i = 1; i < iNumOfChars; i++)
59 | 	{
60 | 		wchar_t wcTemp = wcString[i];
61 | 		wcString[i] ^= wcXor;
62 | 		wcXor = wcTemp;
63 | 	}
64 | 	wcString[0] ^= wcXorKey;
65 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR8D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RXOR8D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RXOR8D(void);
 8 | 	~MBL_CLASS_RXOR8D(void);
 9 | 
10 | 	void Scramble(char *cString, char cXorKey, int iNumOfChars);
11 | 	void Scramble(wchar_t *wcString, wchar_t wcXorKey, int iNumOfChars);
12 | 
13 | protected:
14 | 	char *cStringPointer;
15 | 	int iCStringPointerLen;
16 | 	wchar_t *wcStringPointer;
17 | 	int iWStringPointerLen;
18 | 
19 | };
20 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR9D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_RXOR9D.h"
 4 | 
 5 | MBL_CLASS_RXOR9D::MBL_CLASS_RXOR9D(char cXorKey, char *cString, int iNumOfChars)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Xor
14 | 	for (int i = 0; i < iNumOfChars - 1; i++)
15 | 	{
16 | 		cString[i] ^= cString[i + 1];
17 | 	}
18 | 	cString[iNumOfChars - 1] ^= cXorKey;
19 | }
20 | 
21 | MBL_CLASS_RXOR9D::MBL_CLASS_RXOR9D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars)
22 | {
23 | 	wcStringPointer = wcString;
24 | 	iWStringPointerLen = iNumOfChars;
25 | 
26 | 	cStringPointer = 0;
27 | 	iCStringPointerLen = 0;
28 | 
29 | 	//Xor
30 | 	for (int i = 0; i < iNumOfChars - 1; i++)
31 | 	{
32 | 		wcString[i] ^= wcString[i + 1];
33 | 	}
34 | 	wcString[iNumOfChars - 1] ^= wcXorKey;
35 | }
36 | 
37 | MBL_CLASS_RXOR9D::~MBL_CLASS_RXOR9D(void)
38 | {
39 | 	if (cStringPointer)
40 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
41 | 
42 | 	if (wcStringPointer)
43 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
44 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_RXOR9D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_RXOR9D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_RXOR9D(char cXorKey, char *cString, int iNumOfChars);
 8 | 	MBL_CLASS_RXOR9D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars);
 9 | 	~MBL_CLASS_RXOR9D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR10D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_XOR10D.h"
 4 | 
 5 | MBL_CLASS_XOR10D::MBL_CLASS_XOR10D(char *cString, int iNumOfChars, char *cXorKey)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Xor
14 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
15 | 		cString[i] ^= cXorKey[i % 8];
16 | }
17 | 
18 | MBL_CLASS_XOR10D::MBL_CLASS_XOR10D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
19 | {
20 | 	wcStringPointer = wcString;
21 | 	iWStringPointerLen = iNumOfChars;
22 | 
23 | 	cStringPointer = NULL;
24 | 	iCStringPointerLen = NULL;
25 | 
26 | 	//Xor
27 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
28 | 		wcString[i] ^= wcXorKey[i % 8];
29 | }
30 | 
31 | MBL_CLASS_XOR10D::~MBL_CLASS_XOR10D(void)
32 | {
33 | 
34 | 	if (cStringPointer)
35 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
36 | 
37 | 
38 | 	if (wcStringPointer)
39 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
40 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR10D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_XOR10D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_XOR10D(char *cString, int iNumOfChars, char *cXorKey);
 8 | 	MBL_CLASS_XOR10D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey);
 9 | 	~MBL_CLASS_XOR10D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR11D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_XOR11D.h"
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <time.h>
 7 | 
 8 | MBL_CLASS_XOR11D::MBL_CLASS_XOR11D(char *cString, int iNumOfChars, char *cXorKey)
 9 | {
10 | 	cStringPointer = cString;
11 | 	iCStringPointerLen = iNumOfChars;
12 | 
13 | 	wcStringPointer = NULL;
14 | 	iWStringPointerLen = NULL;
15 | 
16 | 	//Xor
17 | 	for (int i = 0; i < iNumOfChars; i++)
18 | 		cString[i] ^= cXorKey[i % 8];
19 | }
20 | 
21 | MBL_CLASS_XOR11D::MBL_CLASS_XOR11D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
22 | {
23 | 	wcStringPointer = wcString;
24 | 	iWStringPointerLen = iNumOfChars;
25 | 
26 | 	cStringPointer = 0;
27 | 	iCStringPointerLen = 0;
28 | 
29 | 	//Xor
30 | 	for (int i = 0; i < iNumOfChars; i++)
31 | 		wcString[i] ^= wcXorKey[i % 8];
32 | }
33 | 
34 | MBL_CLASS_XOR11D::~MBL_CLASS_XOR11D(void)
35 | {
36 | 	srand((DWORD) time(NULL));
37 | 
38 | 	if (cStringPointer)
39 | 	{
40 | 		for (int i = 0; i < iCStringPointerLen; i++)
41 | 			cStringPointer[i] = (unsigned char)rand() % 255;
42 | 	}
43 | 
44 | 
45 | 	if (wcStringPointer)
46 | 	{
47 | 		for (int i = 0; i < iWStringPointerLen; i++)
48 | 			wcStringPointer[i] = rand() % 65534;
49 | 	}
50 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR11D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_XOR11D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_XOR11D(char *cString, int iNumOfChars, char *cXorKey);
 8 | 	MBL_CLASS_XOR11D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey);
 9 | 	~MBL_CLASS_XOR11D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR12D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_XOR12D.h"
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <time.h>
 7 | 
 8 | MBL_CLASS_XOR12D::MBL_CLASS_XOR12D(char *cString, int iNumOfChars, char *cXorKey)
 9 | {
10 | 	cStringPointer = cString;
11 | 	iCStringPointerLen = iNumOfChars;
12 | 
13 | 	wcStringPointer = NULL;
14 | 	iWStringPointerLen = NULL;
15 | 
16 | 	//Xor
17 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
18 | 		cString[i] ^= cXorKey[i % 8];
19 | }
20 | 
21 | MBL_CLASS_XOR12D::MBL_CLASS_XOR12D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
22 | {
23 | 	wcStringPointer = wcString;
24 | 	iWStringPointerLen = iNumOfChars;
25 | 
26 | 	cStringPointer = 0;
27 | 	iCStringPointerLen = 0;
28 | 
29 | 	//Xor
30 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
31 | 		wcString[i] ^= wcXorKey[i % 8];
32 | }
33 | 
34 | MBL_CLASS_XOR12D::~MBL_CLASS_XOR12D(void)
35 | {
36 | 	srand((DWORD) time(NULL));
37 | 
38 | 	if (cStringPointer)
39 | 	{
40 | 		for (int i = iCStringPointerLen - 1; i >= 0; i--)
41 | 			cStringPointer[i] = (unsigned char)rand() % 255;
42 | 	}
43 | 
44 | 
45 | 	if (wcStringPointer)
46 | 	{
47 | 		for (int i = iWStringPointerLen - 1; i >= 0; i--)
48 | 			wcStringPointer[i] = rand() % 65534;
49 | 	}
50 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR12D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_XOR12D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_XOR12D(char *cString, int iNumOfChars, char *cXorKey);
 8 | 	MBL_CLASS_XOR12D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey);
 9 | 	~MBL_CLASS_XOR12D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR1D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_XOR1D.h"
 4 | 
 5 | MBL_CLASS_XOR1D::MBL_CLASS_XOR1D(char cXorKey, char *cString, int iNumOfChars)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Xor
14 | 	for (int i = 0; i < iNumOfChars; i++)
15 | 		cString[i] ^= cXorKey;
16 | }
17 | 
18 | MBL_CLASS_XOR1D::MBL_CLASS_XOR1D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars)
19 | {
20 | 	wcStringPointer = wcString;
21 | 	iWStringPointerLen = iNumOfChars;
22 | 
23 | 	cStringPointer = 0;
24 | 	iCStringPointerLen = 0;
25 | 
26 | 	//Xor
27 | 	for (int i = 0; i < iNumOfChars; i++)
28 | 		wcString[i] ^= wcXorKey;
29 | }
30 | 
31 | MBL_CLASS_XOR1D::~MBL_CLASS_XOR1D(void)
32 | {
33 | 	if (cStringPointer)
34 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
35 | 
36 | 	if (wcStringPointer)
37 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
38 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR1D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_XOR1D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_XOR1D(char cXorKey, char *cString, int iNumOfChars);
 8 | 	MBL_CLASS_XOR1D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars);
 9 | 	~MBL_CLASS_XOR1D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR2D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_XOR2D.h"
 4 | 
 5 | MBL_CLASS_XOR2D::MBL_CLASS_XOR2D(char cXorKey, char *cString, int iNumOfChars)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Xor
14 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
15 | 		cString[i] ^= cXorKey;
16 | }
17 | 
18 | MBL_CLASS_XOR2D::MBL_CLASS_XOR2D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars)
19 | {
20 | 	wcStringPointer = wcString;
21 | 	iWStringPointerLen = iNumOfChars;
22 | 
23 | 	cStringPointer = 0;
24 | 	iCStringPointerLen = 0;
25 | 
26 | 	//Xor
27 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
28 | 		wcString[i] ^= wcXorKey;
29 | }
30 | 
31 | MBL_CLASS_XOR2D::~MBL_CLASS_XOR2D(void)
32 | {
33 | 	if (cStringPointer)
34 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
35 | 
36 | 	if (wcStringPointer)
37 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
38 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR2D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_XOR2D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_XOR2D(char cXorKey, char *cString, int iNumOfChars);
 8 | 	MBL_CLASS_XOR2D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars);
 9 | 	~MBL_CLASS_XOR2D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR3D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_XOR3D.h"
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <time.h>
 7 | 
 8 | MBL_CLASS_XOR3D::MBL_CLASS_XOR3D(char cXorKey, char *cString, int iNumOfChars)
 9 | {
10 | 	cStringPointer = cString;
11 | 	iCStringPointerLen = iNumOfChars;
12 | 
13 | 	wcStringPointer = NULL;
14 | 	iWStringPointerLen = NULL;
15 | 
16 | 	//Xor
17 | 	for (int i = 0; i < iNumOfChars; i++)
18 | 		cString[i] ^= cXorKey;
19 | }
20 | 
21 | MBL_CLASS_XOR3D::MBL_CLASS_XOR3D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars)
22 | {
23 | 	wcStringPointer = wcString;
24 | 	iWStringPointerLen = iNumOfChars;
25 | 
26 | 	cStringPointer = 0;
27 | 	iCStringPointerLen = 0;
28 | 
29 | 	//Xor
30 | 	for (int i = 0; i < iNumOfChars; i++)
31 | 		wcString[i] ^= wcXorKey;
32 | }
33 | 
34 | MBL_CLASS_XOR3D::~MBL_CLASS_XOR3D(void)
35 | {
36 | 	srand((DWORD) time(NULL));
37 | 	
38 | 	if (cStringPointer)
39 | 	{
40 | 		for (int i = 0; i < iCStringPointerLen; i++)
41 | 			cStringPointer[i] = (unsigned char)rand() % 255;
42 | 	}
43 | 
44 | 
45 | 	if (wcStringPointer)
46 | 	{
47 | 		for (int i = 0; i < iWStringPointerLen; i++)
48 | 			wcStringPointer[i] = rand() % 65534;
49 | 	}
50 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR3D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_XOR3D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_XOR3D(char cXorKey, char *cString, int iNumOfChars);
 8 | 	MBL_CLASS_XOR3D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars);
 9 | 	~MBL_CLASS_XOR3D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR4D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_XOR4D.h"
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <time.h>
 7 | 
 8 | MBL_CLASS_XOR4D::MBL_CLASS_XOR4D(char cXorKey, char *cString, int iNumOfChars)
 9 | {
10 | 	cStringPointer = cString;
11 | 	iCStringPointerLen = iNumOfChars;
12 | 
13 | 	wcStringPointer = NULL;
14 | 	iWStringPointerLen = NULL;
15 | 
16 | 	//Xor
17 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
18 | 		cString[i] ^= cXorKey;
19 | }
20 | 
21 | MBL_CLASS_XOR4D::MBL_CLASS_XOR4D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars)
22 | {
23 | 	wcStringPointer = wcString;
24 | 	iWStringPointerLen = iNumOfChars;
25 | 
26 | 	cStringPointer = 0;
27 | 	iCStringPointerLen = 0;
28 | 
29 | 	//Xor
30 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
31 | 		wcString[i] ^= wcXorKey;
32 | }
33 | 
34 | MBL_CLASS_XOR4D::~MBL_CLASS_XOR4D(void)
35 | {
36 | 	srand((DWORD) time(NULL));
37 | 
38 | 	if (cStringPointer)
39 | 	{
40 | 		for (int i = 0; i < iCStringPointerLen; i++)
41 | 			cStringPointer[i] = (unsigned char)rand() % 255;
42 | 	}
43 | 
44 | 
45 | 	if (wcStringPointer)
46 | 	{
47 | 		for (int i = 0; i < iWStringPointerLen; i++)
48 | 			wcStringPointer[i] = rand() % 65534;
49 | 	}
50 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR4D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_XOR4D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_XOR4D(char cXorKey, char *cString, int iNumOfChars);
 8 | 	MBL_CLASS_XOR4D(wchar_t wcXorKey, wchar_t *wcString, int iNumOfChars);
 9 | 	~MBL_CLASS_XOR4D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR5D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_XOR5D.h"
 4 | 
 5 | MBL_CLASS_XOR5D::MBL_CLASS_XOR5D(void)
 6 | {
 7 | 	wcStringPointer = NULL;
 8 | 	iWStringPointerLen = NULL;
 9 | 
10 | 	cStringPointer = NULL;
11 | 	iCStringPointerLen = NULL;
12 | }
13 | 
14 | MBL_CLASS_XOR5D::~MBL_CLASS_XOR5D(void)
15 | {
16 | 	if (cStringPointer)
17 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
18 | 
19 | 	if (wcStringPointer)
20 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
21 | }
22 | 
23 | void MBL_CLASS_XOR5D::Scramble(char cXorKey, int iNumOfChars, char *cString)
24 | {
25 | 	cStringPointer = cString;
26 | 	iCStringPointerLen = iNumOfChars;
27 | 
28 | 	//Xor
29 | 	for (int i = 0; i < iNumOfChars; i++)
30 | 		cString[i] ^= cXorKey;
31 | }
32 | 
33 | void MBL_CLASS_XOR5D::Scramble(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
34 | {
35 | 	wcStringPointer = wcString;
36 | 	iWStringPointerLen = iNumOfChars;
37 | 
38 | 	//Xor
39 | 	for (int i = 0; i < iNumOfChars; i++)
40 | 		wcString[i] ^= wcXorKey;
41 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR5D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_XOR5D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_XOR5D(void);
 8 | 	~MBL_CLASS_XOR5D(void);
 9 | 
10 | 	void Scramble(char cXorKey, int iNumOfChars, char *cString);
11 | 	void Scramble(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
12 | 
13 | protected:
14 | 	char *cStringPointer;
15 | 	int iCStringPointerLen;
16 | 	wchar_t *wcStringPointer;
17 | 	int iWStringPointerLen;
18 | 
19 | };
20 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR6D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_XOR6D.h"
 4 | 
 5 | MBL_CLASS_XOR6D::MBL_CLASS_XOR6D(void)
 6 | {
 7 | 	wcStringPointer = NULL;
 8 | 	iWStringPointerLen = NULL;
 9 | 
10 | 	cStringPointer = NULL;
11 | 	iCStringPointerLen = NULL;
12 | }
13 | 
14 | MBL_CLASS_XOR6D::~MBL_CLASS_XOR6D(void)
15 | {
16 | 	if (cStringPointer)
17 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
18 | 
19 | 	if (wcStringPointer)
20 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
21 | }
22 | 
23 | void MBL_CLASS_XOR6D::Scramble(char cXorKey, int iNumOfChars, char *cString)
24 | {
25 | 	cStringPointer = cString;
26 | 	iCStringPointerLen = iNumOfChars;
27 | 
28 | 	//Xor
29 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
30 | 		cString[i] ^= cXorKey;
31 | }
32 | 
33 | void MBL_CLASS_XOR6D::Scramble(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
34 | {
35 | 	wcStringPointer = wcString;
36 | 	iWStringPointerLen = iNumOfChars;
37 | 
38 | 	//Xor
39 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
40 | 		wcString[i] ^= wcXorKey;
41 | }
42 | 
43 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR6D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_XOR6D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_XOR6D(void);
 8 | 	~MBL_CLASS_XOR6D(void);
 9 | 
10 | 	void Scramble(char cXorKey, int iNumOfChars, char *cString);
11 | 	void Scramble(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
12 | 
13 | protected:
14 | 	char *cStringPointer;
15 | 	int iCStringPointerLen;
16 | 	wchar_t *wcStringPointer;
17 | 	int iWStringPointerLen;
18 | 
19 | };
20 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR7D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_XOR7D.h"
 4 | #include <stdlib.h>
 5 | #include <time.h>
 6 | 
 7 | MBL_CLASS_XOR7D::MBL_CLASS_XOR7D(void)
 8 | {
 9 | 	wcStringPointer = NULL;
10 | 	iWStringPointerLen = NULL;
11 | 
12 | 	cStringPointer = 0;
13 | 	iCStringPointerLen = 0;
14 | }
15 | 
16 | MBL_CLASS_XOR7D::~MBL_CLASS_XOR7D(void)
17 | {
18 | 	srand((DWORD) time(NULL));
19 | 
20 | 	if (cStringPointer)
21 | 	{
22 | 		for (int i = 0; i < iCStringPointerLen; i++)
23 | 			cStringPointer[i] = (unsigned char)rand() % 255;
24 | 	}
25 | 
26 | 
27 | 	if (wcStringPointer)
28 | 	{
29 | 		for (int i = 0; i < iWStringPointerLen; i++)
30 | 			wcStringPointer[i] = rand() % 65534;
31 | 	}
32 | }
33 | 
34 | void MBL_CLASS_XOR7D::Scramble(char cXorKey, int iNumOfChars, char *cString)
35 | {
36 | 	cStringPointer = cString;
37 | 	iCStringPointerLen = iNumOfChars;
38 | 
39 | 	//Xor
40 | 	for (int i = 0; i < iNumOfChars; i++)
41 | 		cString[i] ^= cXorKey;
42 | }
43 | 
44 | void MBL_CLASS_XOR7D::Scramble(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
45 | {
46 | 	wcStringPointer = wcString;
47 | 	iWStringPointerLen = iNumOfChars;
48 | 
49 | 	//Xor
50 | 	for (int i = 0; i < iNumOfChars; i++)
51 | 		wcString[i] ^= wcXorKey;
52 | }
53 | 
54 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR7D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_XOR7D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_XOR7D(void);
 8 | 	~MBL_CLASS_XOR7D(void);
 9 | 
10 | 	void Scramble(char cXorKey, int iNumOfChars, char *cString);
11 | 	void Scramble(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
12 | 
13 | protected:
14 | 	char *cStringPointer;
15 | 	int iCStringPointerLen;
16 | 	wchar_t *wcStringPointer;
17 | 	int iWStringPointerLen;
18 | 
19 | };
20 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR8D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_XOR8D.h"
 4 | #include <stdlib.h>
 5 | #include <time.h>
 6 | 
 7 | MBL_CLASS_XOR8D::MBL_CLASS_XOR8D(void)
 8 | {
 9 | 	wcStringPointer = NULL;
10 | 	iWStringPointerLen = NULL;
11 | 
12 | 	cStringPointer = NULL;
13 | 	iCStringPointerLen = NULL;
14 | }
15 | 
16 | MBL_CLASS_XOR8D::~MBL_CLASS_XOR8D(void)
17 | {
18 | 	srand((DWORD) time(NULL));
19 | 
20 | 	if (cStringPointer)
21 | 	{
22 | 		for (int i = iCStringPointerLen - 1; i >= 0; i--)
23 | 			cStringPointer[i] = (unsigned char)rand() % 255;
24 | 	}
25 | 
26 | 
27 | 	if (wcStringPointer)
28 | 	{
29 | 		for (int i = iWStringPointerLen - 1; i >= 0; i--)
30 | 			wcStringPointer[i] = rand() % 65534;
31 | 	}
32 | }
33 | 
34 | void MBL_CLASS_XOR8D::Scramble(char cXorKey, int iNumOfChars, char *cString)
35 | {
36 | 	cStringPointer = cString;
37 | 	iCStringPointerLen = iNumOfChars;
38 | 
39 | 	//Xor
40 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
41 | 		cString[i] ^= cXorKey;
42 | }
43 | 
44 | void MBL_CLASS_XOR8D::Scramble(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString)
45 | {
46 | 	wcStringPointer = wcString;
47 | 	iWStringPointerLen = iNumOfChars;
48 | 
49 | 	//Xor
50 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
51 | 		wcString[i] ^= wcXorKey;
52 | }
53 | 
54 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR8D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_XOR8D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_XOR8D(void);
 8 | 	~MBL_CLASS_XOR8D(void);
 9 | 
10 | 	void Scramble(char cXorKey, int iNumOfChars, char *cString);
11 | 	void Scramble(wchar_t wcXorKey, int iNumOfChars, wchar_t *wcString);
12 | 
13 | protected:
14 | 	char *cStringPointer;
15 | 	int iCStringPointerLen;
16 | 	wchar_t *wcStringPointer;
17 | 	int iWStringPointerLen;
18 | 
19 | };
20 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR9D.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <Windows.h>
 3 | #include "MBL_CLASS_XOR9D.h"
 4 | 
 5 | MBL_CLASS_XOR9D::MBL_CLASS_XOR9D(char *cString, int iNumOfChars, char *cXorKey)
 6 | {
 7 | 	cStringPointer = cString;
 8 | 	iCStringPointerLen = iNumOfChars;
 9 | 
10 | 	wcStringPointer = NULL;
11 | 	iWStringPointerLen = NULL;
12 | 
13 | 	//Xor
14 | 	for (int i = 0; i < iNumOfChars; i++)
15 | 		cString[i] ^= cXorKey[i % 8];
16 | }
17 | 
18 | MBL_CLASS_XOR9D::MBL_CLASS_XOR9D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
19 | {
20 | 	wcStringPointer = wcString;
21 | 	iWStringPointerLen = iNumOfChars;
22 | 
23 | 	cStringPointer = NULL;
24 | 	iCStringPointerLen = NULL;
25 | 
26 | 	//Xor
27 | 	for (int i = 0; i < iNumOfChars; i++)
28 | 		wcString[i] ^= wcXorKey[i % 8];
29 | }
30 | 
31 | MBL_CLASS_XOR9D::~MBL_CLASS_XOR9D(void)
32 | {
33 | 	
34 | 	if (cStringPointer)
35 | 		SecureZeroMemory(cStringPointer, iCStringPointerLen);
36 | 
37 | 
38 | 	if (wcStringPointer)
39 | 		SecureZeroMemory(wcStringPointer, iWStringPointerLen);
40 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_CLASS_XOR9D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class MBL_CLASS_XOR9D
 4 | {
 5 | public:
 6 | 
 7 | 	MBL_CLASS_XOR9D(char *cString, int iNumOfChars, char *cXorKey);
 8 | 	MBL_CLASS_XOR9D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey);
 9 | 	~MBL_CLASS_XOR9D(void);
10 | 
11 | protected:
12 | 	char *cStringPointer;
13 | 	int iCStringPointerLen;
14 | 	wchar_t *wcStringPointer;
15 | 	int iWStringPointerLen;
16 | 
17 | };
18 | 


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_BUMP10D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_BUMP10D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_BUMP11D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_BUMP11D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_BUMP12D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_BUMP12D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_BUMP1D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_BUMP1D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_BUMP2D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_BUMP2D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_BUMP3D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_BUMP3D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_BUMP4D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_BUMP4D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_BUMP5D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_BUMP5D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_BUMP6D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_BUMP6D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_BUMP7D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_BUMP7D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_BUMP8D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_BUMP8D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_BUMP9D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_BUMP9D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_BUMP10D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_BUMP10D(char *cString, int iNumOfChars, char *cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
 9 | 		cString[i] -= cXorKey[i % 16];
10 | 
11 | }
12 | 
13 | static void MBL_FORLOOP_FUNC_BUMP10D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
14 | {
15 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
16 | 		return;
17 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
18 | 		wcString[i] -= wcXorKey[i % 16];
19 | 
20 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_BUMP11D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_BUMP11D(char *cString, int iNumOfChars, char *cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = 0; i < iNumOfChars; i++)
 9 | 		cString[i] += cXorKey[i % 16];
10 | 
11 | }
12 | 
13 | static void MBL_FORLOOP_FUNC_BUMP11D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
14 | {
15 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
16 | 		return;
17 | 	for (int i = 0; i < iNumOfChars; i++)
18 | 		wcString[i] += wcXorKey[i % 16];
19 | 
20 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_BUMP12D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_BUMP12D(char *cString, int iNumOfChars, char *cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
 9 | 		cString[i] += cXorKey[i % 16];
10 | 
11 | }
12 | 
13 | static void MBL_FORLOOP_FUNC_BUMP12D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
14 | {
15 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
16 | 		return;
17 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
18 | 		wcString[i] += wcXorKey[i % 16];
19 | 
20 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_BUMP1D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_BUMP1D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 	
 8 | 	for (int i = 0; i < iNumOfChars; i++)
 9 | 		cString[i] -= cXorKey;
10 | 
11 | }
12 | 
13 | static void MBL_FORLOOP_FUNC_BUMP1D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
14 | {
15 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
16 | 		return;
17 | 	for (int i = 0; i < iNumOfChars; i++)
18 | 		wcString[i] -= wcXorKey;
19 | 
20 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_BUMP2D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_BUMP2D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
 9 | 		cString[i] -= cXorKey;
10 | 
11 | }
12 | 
13 | static void MBL_FORLOOP_FUNC_BUMP2D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
14 | {
15 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
16 | 		return;
17 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
18 | 		wcString[i] -= wcXorKey;
19 | 
20 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_BUMP3D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_BUMP3D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = 0; i < iNumOfChars; i++)
 9 | 		cString[i] += cXorKey;
10 | 
11 | }
12 | 
13 | static void MBL_FORLOOP_FUNC_BUMP3D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
14 | {
15 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
16 | 		return;
17 | 	for (int i = 0; i < iNumOfChars; i++)
18 | 		wcString[i] += wcXorKey;
19 | 
20 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_BUMP4D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_BUMP4D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
 9 | 		cString[i] += cXorKey;
10 | 
11 | }
12 | 
13 | static void MBL_FORLOOP_FUNC_BUMP4D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
14 | {
15 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
16 | 		return;
17 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
18 | 		wcString[i] += wcXorKey;
19 | 
20 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_BUMP5D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_BUMP5D(char *cString, int iNumOfChars, char *cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = 0; i < iNumOfChars; i++)
 9 | 		cString[i] -= cXorKey[i % 8];
10 | 
11 | }
12 | 
13 | static void MBL_FORLOOP_FUNC_BUMP5D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
14 | {
15 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
16 | 		return;
17 | 	for (int i = 0; i < iNumOfChars; i++)
18 | 		wcString[i] -= wcXorKey[i % 8];
19 | 
20 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_BUMP6D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_BUMP6D(char *cString, int iNumOfChars, char *cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
 9 | 		cString[i] -= cXorKey[i % 8];
10 | 
11 | }
12 | 
13 | static void MBL_FORLOOP_FUNC_BUMP6D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
14 | {
15 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
16 | 		return;
17 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
18 | 		wcString[i] -= wcXorKey[i % 8];
19 | 
20 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_BUMP7D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_BUMP7D(char *cString, int iNumOfChars, char *cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = 0; i < iNumOfChars; i++)
 9 | 		cString[i] += cXorKey[i % 8];
10 | 
11 | }
12 | 
13 | static void MBL_FORLOOP_FUNC_BUMP7D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
14 | {
15 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
16 | 		return;
17 | 	for (int i = 0; i < iNumOfChars; i++)
18 | 		wcString[i] += wcXorKey[i % 8];
19 | 
20 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_BUMP8D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_BUMP8D(char *cString, int iNumOfChars, char *cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
 9 | 		cString[i] += cXorKey[i % 8];
10 | 
11 | }
12 | 
13 | static void MBL_FORLOOP_FUNC_BUMP8D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
14 | {
15 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
16 | 		return;
17 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
18 | 		wcString[i] += wcXorKey[i % 8];
19 | 
20 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_BUMP9D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_BUMP9D(char *cString, int iNumOfChars, char *cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = 0; i < iNumOfChars; i++)
 9 | 		cString[i] -= cXorKey[i % 16];
10 | 
11 | }
12 | 
13 | static void MBL_FORLOOP_FUNC_BUMP9D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
14 | {
15 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
16 | 		return;
17 | 	for (int i = 0; i < iNumOfChars; i++)
18 | 		wcString[i] -= wcXorKey[i % 16];
19 | 
20 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_RBUMP1D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_RBUMP1D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = iNumOfChars - 1; i > 0; i--)
 9 | 		cString[i] -= cString[i - 1];
10 | 
11 | 	cString[0] -= cXorKey;
12 | 
13 | }
14 | 
15 | static void MBL_FORLOOP_FUNC_RBUMP1D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
16 | {
17 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
18 | 		return;
19 | 
20 | 	for (int i = iNumOfChars - 1; i > 0; i--)
21 | 		wcString[i] -= wcString[i - 1];
22 | 
23 | 	wcString[0] -= wcXorKey;
24 | 
25 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_RBUMP2D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_RBUMP2D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = iNumOfChars - 1; i > 0; i--)
 9 | 		cString[i] += cString[i - 1];
10 | 
11 | 	cString[0] += cXorKey;
12 | 
13 | }
14 | 
15 | static void MBL_FORLOOP_FUNC_RBUMP2D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
16 | {
17 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
18 | 		return;
19 | 
20 | 	for (int i = iNumOfChars - 1; i > 0; i--)
21 | 		wcString[i] += wcString[i - 1];
22 | 
23 | 	wcString[0] += wcXorKey;
24 | 
25 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_RBUMP3D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_RBUMP3D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = 0; i < iNumOfChars - 1; i++)
 9 | 		cString[i] -= cString[i + 1];
10 | 
11 | 	cString[iNumOfChars - 1] -= cXorKey;
12 | 
13 | }
14 | 
15 | static void MBL_FORLOOP_FUNC_RBUMP3D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
16 | {
17 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
18 | 		return;
19 | 
20 | 	for (int i = 0; i < iNumOfChars - 1; i++)
21 | 		wcString[i] -= wcString[i + 1];
22 | 
23 | 	wcString[iNumOfChars - 1] -= wcXorKey;
24 | 
25 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_RBUMP4D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_RBUMP4D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = 0; i < iNumOfChars - 1; i++)
 9 | 		cString[i] += cString[i + 1];
10 | 
11 | 	cString[iNumOfChars - 1] += cXorKey;
12 | 
13 | }
14 | 
15 | static void MBL_FORLOOP_FUNC_RBUMP4D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
16 | {
17 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
18 | 		return;
19 | 
20 | 	for (int i = 0; i < iNumOfChars - 1; i++)
21 | 		wcString[i] += wcString[i + 1];
22 | 
23 | 	wcString[iNumOfChars - 1] += wcXorKey;
24 | 
25 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_RBUMP5D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_RBUMP5D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = iNumOfChars - 1; i > 0; i--)
 9 | 		cString[i] -= cString[i - 1];
10 | 
11 | 	cString[0] += cXorKey;
12 | 
13 | }
14 | 
15 | static void MBL_FORLOOP_FUNC_RBUMP5D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
16 | {
17 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
18 | 		return;
19 | 
20 | 	for (int i = iNumOfChars - 1; i > 0; i--)
21 | 		wcString[i] -= wcString[i - 1];
22 | 
23 | 	wcString[0] += wcXorKey;
24 | 
25 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_RBUMP6D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_RBUMP6D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = iNumOfChars - 1; i > 0; i--)
 9 | 		cString[i] += cString[i - 1];
10 | 
11 | 	cString[0] -= cXorKey;
12 | 
13 | }
14 | 
15 | static void MBL_FORLOOP_FUNC_RBUMP6D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
16 | {
17 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
18 | 		return;
19 | 
20 | 	for (int i = iNumOfChars - 1; i > 0; i--)
21 | 		wcString[i] += wcString[i - 1];
22 | 
23 | 	wcString[0] -= wcXorKey;
24 | 
25 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_RBUMP7D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_RBUMP7D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = 0; i < iNumOfChars - 1; i++)
 9 | 		cString[i] -= cString[i + 1];
10 | 
11 | 	cString[iNumOfChars - 1] += cXorKey;
12 | 
13 | }
14 | 
15 | static void MBL_FORLOOP_FUNC_RBUMP7D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
16 | {
17 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
18 | 		return;
19 | 
20 | 	for (int i = 0; i < iNumOfChars - 1; i++)
21 | 		wcString[i] -= wcString[i + 1];
22 | 
23 | 	wcString[iNumOfChars - 1] += wcXorKey;
24 | 
25 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_RBUMP8D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_RBUMP8D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = 0; i < iNumOfChars - 1; i++)
 9 | 		cString[i] += cString[i + 1];
10 | 
11 | 	cString[iNumOfChars - 1] -= cXorKey;
12 | 
13 | }
14 | 
15 | static void MBL_FORLOOP_FUNC_RBUMP8D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
16 | {
17 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
18 | 		return;
19 | 
20 | 	for (int i = 0; i < iNumOfChars - 1; i++)
21 | 		wcString[i] += wcString[i + 1];
22 | 
23 | 	wcString[iNumOfChars - 1] -= wcXorKey;
24 | 
25 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_RXOR1D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_RXOR1D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	char cXor = cString[0];
 9 | 	cString[0] ^= cXorKey;
10 | 	for (int i = 1; i < iNumOfChars; i++)
11 | 	{
12 | 		char cTemp = cString[i];
13 | 		cString[i] ^= cXor;
14 | 		cXor = cTemp;
15 | 	}
16 | }
17 | 
18 | static void MBL_FORLOOP_FUNC_RXOR1D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
19 | {
20 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
21 | 		return;
22 | 
23 | 	wchar_t wcXor = wcString[0];
24 | 	wcString[0] ^= wcXorKey;
25 | 	for (int i = 1; i < iNumOfChars; i++)
26 | 	{
27 | 		wchar_t wcTemp = wcString[i];
28 | 		wcString[i] ^= wcXor;
29 | 		wcXor = wcTemp;
30 | 	}
31 | 
32 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_RXOR2D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_RXOR2D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = iNumOfChars - 1; i > 0; i--)
 9 | 		cString[i] ^= cString[i - 1];
10 | 
11 | 	cString[0] ^= cXorKey;
12 | }
13 | 
14 | static void MBL_FORLOOP_FUNC_RXOR2D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
15 | {
16 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
17 | 		return;
18 | 
19 | 	for (int i = iNumOfChars - 1; i > 0; i--)
20 | 		wcString[i] ^= wcString[i - 1];
21 | 
22 | 	wcString[0] ^= wcXorKey;
23 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_RXOR3D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_RXOR3D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	for (int i = 0; i < iNumOfChars - 1; i++)
 9 | 		cString[i] ^= cString[i + 1];
10 | 
11 | 	cString[iNumOfChars - 1] ^= cXorKey;
12 | }
13 | 
14 | static void MBL_FORLOOP_FUNC_RXOR3D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
15 | {
16 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
17 | 		return;
18 | 
19 | 	for (int i = 0; i < iNumOfChars - 1; i++)
20 | 		wcString[i] ^= wcString[i + 1];
21 | 
22 | 	wcString[iNumOfChars - 1] ^= wcXorKey;
23 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_RXOR4D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_RXOR4D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 
 8 | 	char cXor = cString[iNumOfChars - 1];
 9 | 
10 | 	for (int i = iNumOfChars - 2; i >= 0; i--)
11 | 	{
12 | 		char cTemp = cString[i];
13 | 		cString[i] ^= cXor;
14 | 		cXor = cTemp;
15 | 	}
16 | 
17 | 	cString[iNumOfChars - 1] ^= cXorKey;
18 | }
19 | 
20 | static void MBL_FORLOOP_FUNC_RXOR4D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
21 | {
22 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
23 | 		return;
24 | 
25 | 	wchar_t wcXor = wcString[iNumOfChars - 1];
26 | 
27 | 	for (int i = iNumOfChars - 2; i >= 0; i--)
28 | 	{
29 | 		wchar_t wcTemp = wcString[i];
30 | 		wcString[i] ^= wcXor;
31 | 		wcXor = wcTemp;
32 | 	}
33 | 
34 | 	wcString[iNumOfChars - 1] ^= wcXorKey;
35 | 
36 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_XOR1D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_XOR1D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 	for (int i = 0; i < iNumOfChars; i++)
 8 | 		cString[i] ^= cXorKey;
 9 | 
10 | }
11 | 
12 | static void MBL_FORLOOP_FUNC_XOR1D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
13 | {
14 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
15 | 		return;
16 | 	for (int i = 0; i < iNumOfChars; i++)
17 | 		wcString[i] ^= wcXorKey;
18 | 
19 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_XOR2D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_XOR2D(char *cString, int iNumOfChars, char cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
 8 | 		cString[i] ^= cXorKey;
 9 | 
10 | }
11 | 
12 | static void MBL_FORLOOP_FUNC_XOR2D(wchar_t *wcString, int iNumOfChars, wchar_t wcXorKey)
13 | {
14 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
15 | 		return;
16 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
17 | 		wcString[i] ^= wcXorKey;
18 | 
19 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_XOR3D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_XOR3D(char *cString, int iNumOfChars, char *cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 	for (int i = 0; i < iNumOfChars; i++)
 8 | 		cString[i] ^= cXorKey[i % 8];
 9 | 
10 | }
11 | 
12 | static void MBL_FORLOOP_FUNC_XOR3D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
13 | {
14 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
15 | 		return;
16 | 	for (int i = 0; i < iNumOfChars; i++)
17 | 		wcString[i] ^= wcXorKey[i % 8];
18 | 
19 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_XOR4D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_XOR4D(char *cString, int iNumOfChars, char *cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
 8 | 		cString[i] ^= cXorKey[i % 8];
 9 | 
10 | }
11 | 
12 | static void MBL_FORLOOP_FUNC_XOR4D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
13 | {
14 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
15 | 		return;
16 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
17 | 		wcString[i] ^= wcXorKey[i % 8];
18 | 
19 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_XOR5D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_XOR5D(char *cString, int iNumOfChars, char *cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 	for (int i = 0; i < iNumOfChars; i++)
 8 | 		cString[i] ^= cXorKey[i % 16];
 9 | 
10 | }
11 | 
12 | static void MBL_FORLOOP_FUNC_XOR5D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
13 | {
14 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
15 | 		return;
16 | 	for (int i = 0; i < iNumOfChars; i++)
17 | 		wcString[i] ^= wcXorKey[i % 16];
18 | 
19 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_FUNC_XOR6D.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static void MBL_FORLOOP_FUNC_XOR6D(char *cString, int iNumOfChars, char *cXorKey)
 4 | {
 5 | 	if (cString == 0 || iNumOfChars <= 0 || cXorKey == 0)
 6 | 		return;
 7 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
 8 | 		cString[i] ^= cXorKey[i % 16];
 9 | 
10 | }
11 | 
12 | static void MBL_FORLOOP_FUNC_XOR6D(wchar_t *wcString, int iNumOfChars, wchar_t *wcXorKey)
13 | {
14 | 	if (wcString == 0 || iNumOfChars <= 0 || wcXorKey == 0)
15 | 		return;
16 | 	for (int i = iNumOfChars - 1; i >= 0; i--)
17 | 		wcString[i] ^= wcXorKey[i % 16];
18 | 
19 | }


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_RBUMP1D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_RBUMP1D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_RBUMP2D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_RBUMP2D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_RBUMP3D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_RBUMP3D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_RBUMP4D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_RBUMP4D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_RBUMP5D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_RBUMP5D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_RBUMP6D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_RBUMP6D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_RBUMP7D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_RBUMP7D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_RBUMP8D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_RBUMP8D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_RXOR1D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_RXOR1D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_RXOR2D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_RXOR2D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_RXOR3D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_RXOR3D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_RXOR4D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_RXOR4D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_XOR1D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_XOR1D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_XOR2D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_XOR2D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_XOR3D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_XOR3D.h


--------------------------------------------------------------------------------
/Shared/Deobfuscators/MBL_FORLOOP_XOR4D.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/Shared/Deobfuscators/MBL_FORLOOP_XOR4D.h


--------------------------------------------------------------------------------
/Submodules/Misc/FileTyping/MISCTextFileTyper_ENC.cpp:
--------------------------------------------------------------------------------
 1 | // MISCTextFileTyper_ENC.cpp
 2 | #include "MISCTextFileTyper_ENC.h"
 3 | #include <fstream>
 4 | 
 5 | TextEncoding MISCTextFileTyper_ENC::GetTextEncoding(WCHAR* wcFileName) {
 6 |     std::ifstream file(wcFileName, std::ios::binary);
 7 |     char buffer[4] = { 0 };
 8 |     file.read(buffer, 4);
 9 |     file.close();
10 | 
11 |     if (buffer[0] == '\xFF' && buffer[1] == '\xFE') {
12 |         if (buffer[2] == '\x00' && buffer[3] == '\x00') {
13 |             return Unicode;
14 |         }
15 |         else {
16 |             return UnicodeBigEndian;
17 |         }
18 |     }
19 |     else if (buffer[0] == '\xEF' && buffer[1] == '\xBB' && buffer[2] == '\xBF') {
20 |         return UTF8;
21 |     }
22 |     else {
23 |         return ANSI;
24 |     }
25 | }


--------------------------------------------------------------------------------
/Submodules/Misc/FileTyping/MISCTextFileTyper_ENC.h:
--------------------------------------------------------------------------------
 1 | // MISCTextFileTyper_ENC.h
 2 | #ifndef MISC_TEXT_FILE_TYPER_ENC_H
 3 | #define MISC_TEXT_FILE_TYPER_ENC_H
 4 | 
 5 | #include <windows.h>
 6 | 
 7 | enum TextEncoding {
 8 |     UnkownEncoding = -1,
 9 |     ANSI = 0,
10 |     Unicode,
11 |     UTF8,
12 |     UnicodeBigEndian
13 | };
14 | 
15 | class MISCTextFileTyper_ENC {
16 | public:
17 |     TextEncoding GetTextEncoding(WCHAR* wcFileName);
18 | };
19 | 
20 | #endif // MISC_TEXT_FILE_TYPER_ENC_H


--------------------------------------------------------------------------------
/Submodules/Misc/MemoryScan/MISCMemorySearch_NSS.cpp:
--------------------------------------------------------------------------------
 1 | // MISCMemorySearch_NSS.cpp
 2 | #include "MISCMemorySearch_NSS.h"
 3 | 
 4 | INT64 MISCMemorySearch_NSS::FindIndexOfSequenceInMemory(CHAR* cMemToSearch, DWORD dwMemLen, CHAR* cSequence, DWORD dwSeqLen) {
 5 |     for (DWORD i = 0; i <= dwMemLen - dwSeqLen; i++) {
 6 |         if (memcmp(cMemToSearch + i, cSequence, dwSeqLen) == 0) {
 7 |             return i;
 8 |         }
 9 |     }
10 |     return ERROR_SEQUENCE_DOESNT_EXIST;
11 | }
12 | 
13 | INT64 MISCMemorySearch_NSS::FindIndexOfSequenceInMemoryReverse(CHAR* cMemToSearch, DWORD dwMemLen, CHAR* cSequence, DWORD dwSeqLen) {
14 |     for (DWORD i = dwMemLen - dwSeqLen; i != -1; i--) {
15 |         if (memcmp(cMemToSearch + i, cSequence, dwSeqLen) == 0) {
16 |             return i;
17 |         }
18 |     }
19 |     return ERROR_SEQUENCE_DOESNT_EXIST;
20 | }


--------------------------------------------------------------------------------
/Submodules/Misc/MemoryScan/MISCMemorySearch_NSS.h:
--------------------------------------------------------------------------------
 1 | // MISCMemorySearch_NSS.h
 2 | #ifndef MISC_MEMORY_SEARCH_NSS_H
 3 | #define MISC_MEMORY_SEARCH_NSS_H
 4 | 
 5 | #include <windows.h>
 6 | 
 7 | #define ERROR_SEQUENCE_DOESNT_EXIST -1
 8 | 
 9 | class MISCMemorySearch_NSS {
10 | public:
11 |     static INT64 FindIndexOfSequenceInMemory(CHAR* cMemToSearch, DWORD dwMemLen, CHAR* cSequence, DWORD dwSeqLen);
12 |     static INT64 FindIndexOfSequenceInMemoryReverse(CHAR* cMemToSearch, DWORD dwMemLen, CHAR* cSequence, DWORD dwSeqLen);
13 | };
14 | 
15 | #endif // MISC_MEMORY_SEARCH_NSS_H


--------------------------------------------------------------------------------
/Validator/Validator.vcxproj.filters:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <!-- This project created via the OSB Project Template by ???, ??? -->
3 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
4 |   <ItemGroup>
5 |     <ClCompile Include="Validator.cpp" />
6 |   </ItemGroup>
7 | </Project>
8 | <!-- This project created via the OSB Project Template by ???, ??? -->
9 | 


--------------------------------------------------------------------------------
/docs/Marble Framework.docx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/docs/Marble Framework.docx


--------------------------------------------------------------------------------
/docs/Marble Framework.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/docs/Marble Framework.pdf


--------------------------------------------------------------------------------
/docs/Marble Framework.pptx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hackerhouse-opensource/Marble/1a22b3c847ccec5a50682fbb184fc51c53fefc5a/docs/Marble Framework.pptx


--------------------------------------------------------------------------------
/props/Kernel_Debug_x64.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="internal\Kernel_x64.props" />
 6 |     <Import Project="internal\Debug.props" />
 7 |   </ImportGroup>
 8 |   <PropertyGroup>
 9 |     <LinkIncremental>false</LinkIncremental>
10 |   </PropertyGroup>
11 |   <ItemDefinitionGroup>
12 |     <ClCompile>
13 |       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
14 |       <SmallerTypeCheck>false</SmallerTypeCheck>
15 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
16 |     </ClCompile>
17 |   </ItemDefinitionGroup>
18 | </Project>
19 | <!-- This project created via the OSB Project Template by ???, ??? -->
20 | 


--------------------------------------------------------------------------------
/props/Kernel_Debug_x86.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="internal\Kernel_x86.props" />
 6 |     <Import Project="internal\Debug.props" />
 7 |   </ImportGroup>
 8 |   <PropertyGroup>
 9 |     <LinkIncremental>false</LinkIncremental>
10 |   </PropertyGroup>
11 |   <ItemDefinitionGroup>
12 |     <ClCompile>
13 |       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
14 |       <SmallerTypeCheck>false</SmallerTypeCheck>
15 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
16 |     </ClCompile>
17 |   </ItemDefinitionGroup>
18 | </Project>
19 | <!-- This project created via the OSB Project Template by ???, ??? -->
20 | 


--------------------------------------------------------------------------------
/props/Kernel_Release_x64.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="internal\Kernel_x64.props" />
 6 |     <Import Project="internal\Release.props" />
 7 |   </ImportGroup>
 8 |   <ItemDefinitionGroup>
 9 |     <ClCompile>
10 |       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
11 |     </ClCompile>
12 |   </ItemDefinitionGroup>
13 | </Project>
14 | <!-- This project created via the OSB Project Template by ???, ??? -->
15 | 


--------------------------------------------------------------------------------
/props/Kernel_Release_x86.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="internal\Kernel_x86.props" />
 6 |     <Import Project="internal\Release.props" />
 7 |   </ImportGroup>
 8 |   <ItemDefinitionGroup>
 9 |     <ClCompile>
10 |       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
11 |     </ClCompile>
12 |   </ItemDefinitionGroup>
13 | </Project>
14 | <!-- This project created via the OSB Project Template by ???, ??? -->
15 | 


--------------------------------------------------------------------------------
/props/User_Debug_x64.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="internal\User_x64.props" />
 6 |     <Import Project="internal\Debug.props" />
 7 |   </ImportGroup>
 8 |   <ItemDefinitionGroup>
 9 |     <ClCompile>
10 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
11 |     </ClCompile>
12 |   </ItemDefinitionGroup>
13 | </Project>
14 | <!-- This project created via the OSB Project Template by ???, ??? -->
15 | 


--------------------------------------------------------------------------------
/props/User_Debug_x86.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="internal\User_x86.props" />
 6 |     <Import Project="internal\Debug.props" />
 7 |   </ImportGroup>
 8 |   <ItemDefinitionGroup>
 9 |     <ClCompile>
10 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
11 |     </ClCompile>
12 |   </ItemDefinitionGroup>
13 | </Project>
14 | <!-- This project created via the OSB Project Template by ???, ??? -->
15 | 


--------------------------------------------------------------------------------
/props/User_Dynamic_Release_LIB_x64.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="internal\User_x64.props" />
 6 |     <Import Project="internal\Release.props" />
 7 |   </ImportGroup>
 8 |   <ItemDefinitionGroup>
 9 |     <ClCompile>
10 | 	  <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
11 |       <Optimization>MinSpace</Optimization>
12 |       <FavorSizeOrSpeed>Size</FavorSizeOrSpeed>
13 | 	  <OmitDefaultLibName>true</OmitDefaultLibName>
14 |     </ClCompile>
15 |   </ItemDefinitionGroup>
16 | </Project>
17 | <!-- This project created via the OSB Project Template by ???, ??? -->
18 | 


--------------------------------------------------------------------------------
/props/User_Dynamic_Release_LIB_x86.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="internal\User_x86.props" />
 6 |     <Import Project="internal\Release.props" />
 7 |   </ImportGroup>
 8 |   <ItemDefinitionGroup>
 9 |     <ClCompile>
10 | 	  <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
11 |       <Optimization>MinSpace</Optimization>
12 |       <FavorSizeOrSpeed>Size</FavorSizeOrSpeed>
13 | 	  <OmitDefaultLibName>true</OmitDefaultLibName>
14 |     </ClCompile>
15 |   </ItemDefinitionGroup>
16 | </Project>
17 | <!-- This project created via the OSB Project Template by ???, ??? -->
18 | 


--------------------------------------------------------------------------------
/props/User_Dynamic_Release_x64.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="internal\User_x64.props" />
 6 |     <Import Project="internal\Release.props" />
 7 |   </ImportGroup>
 8 |   <ItemDefinitionGroup>
 9 |     <ClCompile>
10 |       <AdditionalIncludeDirectories>$(Subs)Dynamic_Libs\inc\api;$(Subs)Dynamic_Libs\inc\crt;$(Subs)Dynamic_Libs\inc\crt\atl71;$(Subs)Dynamic_Libs\inc\ddk;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
11 |       <Optimization>MinSpace</Optimization>
12 |       <FavorSizeOrSpeed>Size</FavorSizeOrSpeed>
13 |       <IgnoreStandardIncludePath>true</IgnoreStandardIncludePath>
14 |     </ClCompile>
15 |     <Link>
16 |       <AdditionalLibraryDirectories>$(Subs)\Dynamic_Libs\amd64;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
17 |       <AdditionalDependencies>msvcrt_win2003.obj;msvcrt.lib;%(AdditionalDependencies)</AdditionalDependencies>
18 |       <MinimumRequiredVersion>5.2</MinimumRequiredVersion>
19 |     </Link>
20 |   </ItemDefinitionGroup>
21 | </Project>
22 | <!-- This project created via the OSB Project Template by ???, ??? -->
23 | 


--------------------------------------------------------------------------------
/props/User_Dynamic_Release_x86.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="internal\User_x86.props" />
 6 |     <Import Project="internal\Release.props" />
 7 |   </ImportGroup>
 8 |   <ItemDefinitionGroup>
 9 |     <ClCompile>
10 |       <AdditionalIncludeDirectories>$(Subs)Dynamic_Libs\inc\api;$(Subs)Dynamic_Libs\inc\crt;$(Subs)Dynamic_Libs\inc\crt\atl71;$(Subs)Dynamic_Libs\inc\ddk;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
11 |       <Optimization>MinSpace</Optimization>
12 |       <FavorSizeOrSpeed>Size</FavorSizeOrSpeed>
13 |       <IgnoreStandardIncludePath>true</IgnoreStandardIncludePath>
14 |     </ClCompile>
15 |     <Link>
16 |       <AdditionalLibraryDirectories>$(Subs)\Dynamic_Libs\i386;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
17 |       <AdditionalDependencies>msvcrt_win2000.obj;msvcrt.lib;%(AdditionalDependencies)</AdditionalDependencies>
18 |       <MinimumRequiredVersion>5.0</MinimumRequiredVersion>
19 |     </Link>
20 |   </ItemDefinitionGroup>
21 | </Project>
22 | <!-- This project created via the OSB Project Template by ???, ??? -->
23 | 


--------------------------------------------------------------------------------
/props/User_Static_Release_x64.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="internal\User_x64.props" />
 6 |     <Import Project="internal\Release.props" />
 7 |   </ImportGroup>
 8 |   <ItemDefinitionGroup>
 9 |     <ClCompile>
10 |       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
11 |     </ClCompile>
12 |   </ItemDefinitionGroup>
13 | </Project>
14 | <!-- This project created via the OSB Project Template by ???, ??? -->
15 | 


--------------------------------------------------------------------------------
/props/User_Static_Release_x86.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="internal\User_x86.props" />
 6 |     <Import Project="internal\Release.props" />
 7 |   </ImportGroup>
 8 |   <ItemDefinitionGroup>
 9 |     <ClCompile>
10 |       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
11 |     </ClCompile>
12 |   </ItemDefinitionGroup>
13 | </Project>
14 | <!-- This project created via the OSB Project Template by ???, ??? -->
15 | 


--------------------------------------------------------------------------------
/props/internal/Console.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets" />
 5 |   <ItemDefinitionGroup>
 6 |     <ClCompile>
 7 |       <PreprocessorDefinitions>_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 8 |     </ClCompile>
 9 |     <Link>
10 |       <SubSystem>Console</SubSystem>
11 |     </Link>
12 |   </ItemDefinitionGroup>
13 | </Project>
14 | <!-- This project created via the OSB Project Template by ???, ??? -->
15 | 


--------------------------------------------------------------------------------
/props/internal/DLL.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets" />
 5 |   <ItemDefinitionGroup>
 6 |     <ClCompile>
 7 |       <PreprocessorDefinitions>_WINDOWS;_USRDLL;DLLAPPTEMPLATE_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 8 |     </ClCompile>
 9 |     <Link>
10 |       <ModuleDefinitionFile>Exports.def</ModuleDefinitionFile>
11 |       <SubSystem>Windows</SubSystem>
12 |       <AdditionalOptions>/ignore:4070 %(AdditionalOptions)</AdditionalOptions>
13 |     </Link>
14 |   </ItemDefinitionGroup>
15 | </Project>
16 | <!-- This project created via the OSB Project Template by ???, ??? -->
17 | 


--------------------------------------------------------------------------------
/props/internal/Debug.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <PropertyGroup>
 5 |     <LinkIncremental>true</LinkIncremental>
 6 |   </PropertyGroup>
 7 |   <ItemDefinitionGroup>
 8 |     <ClCompile>
 9 |       <Optimization>Disabled</Optimization>
10 |       <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
11 |       <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
12 |       <BufferSecurityCheck>true</BufferSecurityCheck>
13 |       <RuntimeTypeInfo>true</RuntimeTypeInfo>
14 |     </ClCompile>
15 |     <Link>
16 |       <GenerateDebugInformation>true</GenerateDebugInformation>
17 |       <OptimizeReferences>false</OptimizeReferences>
18 |       <EnableCOMDATFolding>false</EnableCOMDATFolding>
19 |     </Link>
20 |   </ItemDefinitionGroup>
21 | </Project>
22 | <!-- This project created via the OSB Project Template by ???, ??? -->
23 | 


--------------------------------------------------------------------------------
/props/internal/GUI.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets" />
 5 |   <ItemDefinitionGroup>
 6 |     <ClCompile>
 7 |       <PreprocessorDefinitions>_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 8 |     </ClCompile>
 9 |     <Link>
10 |       <SubSystem>Windows</SubSystem>
11 |     </Link>
12 |   </ItemDefinitionGroup>
13 | </Project>
14 | <!-- This project created via the OSB Project Template by ???, ??? -->
15 | 


--------------------------------------------------------------------------------
/props/internal/GUI_x64.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="GUI.props" />
 6 |   </ImportGroup>
 7 |   <ItemDefinitionGroup>
 8 |     <Link>
 9 |       <AdditionalManifestDependencies>"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'"</AdditionalManifestDependencies>
10 |     </Link>
11 |   </ItemDefinitionGroup>
12 | </Project>
13 | <!-- This project created via the OSB Project Template by ???, ??? -->
14 | 


--------------------------------------------------------------------------------
/props/internal/GUI_x86.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="GUI.props" />
 6 |   </ImportGroup>
 7 |   <ItemDefinitionGroup>
 8 |     <Link>
 9 |       <AdditionalManifestDependencies>"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'"</AdditionalManifestDependencies>
10 |     </Link>
11 |   </ItemDefinitionGroup>
12 | </Project>
13 | <!-- This project created via the OSB Project Template by ???, ??? -->
14 | 


--------------------------------------------------------------------------------
/props/internal/Kernel_x64.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="Kernel_Common.props" />
 6 |   </ImportGroup>
 7 |   <ItemDefinitionGroup>
 8 |     <ClCompile>
 9 |       <PreprocessorDefinitions>_WIN64;_AMD64_;AMD64;_WIN32_WINNT=0x0502;WINVER=0x0502;_WIN32_IE=0x0603;NTDDI_VERSION=0x05020000;%(PreprocessorDefinitions)</PreprocessorDefinitions>
10 |     </ClCompile>
11 |     <Link>
12 |       <AdditionalLibraryDirectories>$(Subs)Kernel_Libs\wnet\amd64;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
13 |       <MinimumRequiredVersion>5.2</MinimumRequiredVersion>
14 |       <TargetMachine>MachineX64</TargetMachine>
15 |     </Link>
16 |   </ItemDefinitionGroup>
17 | </Project>
18 | <!-- This project created via the OSB Project Template by ???, ??? -->
19 | 


--------------------------------------------------------------------------------
/props/internal/Kernel_x86.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="Kernel_Common.props" />
 6 |   </ImportGroup>
 7 |   <ItemDefinitionGroup>
 8 |     <ClCompile>
 9 |       <PreprocessorDefinitions>_X86_=1;X86=1;i386=1;STD_CALL;_WIN32_WINNT=0x0500;WINVER=0x0500;_WIN32_IE=0x0501;NTDDI_VERSION=0x05000000;FPO=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
10 |     </ClCompile>
11 |     <Link>
12 |       <AdditionalLibraryDirectories>$(Subs)Kernel_Libs\w2k\i386;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
13 |       <AdditionalDependencies>sehupd.lib;%(AdditionalDependencies)</AdditionalDependencies>
14 |       <MinimumRequiredVersion>5.0</MinimumRequiredVersion>
15 |       <TargetMachine>MachineX86</TargetMachine>
16 |     </Link>
17 |   </ItemDefinitionGroup>
18 | </Project>
19 | <!-- This project created via the OSB Project Template by ???, ??? -->
20 | 


--------------------------------------------------------------------------------
/props/internal/LIB.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets" />
 5 |   <PropertyGroup>
 6 |     <OutDir>$(Libs)$(Configuration)\$(Platform)\</OutDir>
 7 |   </PropertyGroup>
 8 |   <ItemDefinitionGroup>
 9 |     <ClCompile>
10 |       <PreprocessorDefinitions>_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
11 |     </ClCompile>
12 |   </ItemDefinitionGroup>
13 | </Project>
14 | <!-- This project created via the OSB Project Template by ???, ??? -->
15 | 


--------------------------------------------------------------------------------
/props/internal/Release.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <PropertyGroup>
 5 |     <LinkIncremental>false</LinkIncremental>
 6 |   </PropertyGroup>
 7 |   <ItemDefinitionGroup>
 8 |     <ClCompile>
 9 |       <Optimization>MaxSpeed</Optimization>
10 |       <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
11 |       <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
12 |       <BufferSecurityCheck>false</BufferSecurityCheck>
13 |       <RuntimeTypeInfo>false</RuntimeTypeInfo>
14 |       <WholeProgramOptimization>true</WholeProgramOptimization>
15 |       <DebugInformationFormat>
16 |       </DebugInformationFormat>
17 |       <StringPooling>true</StringPooling>
18 |       <FunctionLevelLinking>true</FunctionLevelLinking>
19 |       <IntrinsicFunctions>true</IntrinsicFunctions>
20 |     </ClCompile>
21 |     <Link>
22 |       <GenerateDebugInformation>false</GenerateDebugInformation>
23 |       <ProgramDatabaseFile>
24 |       </ProgramDatabaseFile>
25 |       <OptimizeReferences>true</OptimizeReferences>
26 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
27 |       <SetChecksum>true</SetChecksum>
28 |     </Link>
29 |   </ItemDefinitionGroup>
30 | </Project>
31 | <!-- This project created via the OSB Project Template by ???, ??? -->
32 | 


--------------------------------------------------------------------------------
/props/internal/SYS.props:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <!-- This project created via the OSB Project Template by ???, ??? -->
3 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
4 |   <ImportGroup Label="PropertySheets" />
5 | </Project>
6 | <!-- This project created via the OSB Project Template by ???, ??? -->
7 | 


--------------------------------------------------------------------------------
/props/internal/User_Common.props:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <!-- This project created via the OSB Project Template by ???, ??? -->
3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
4 |   <ImportGroup Label="PropertySheets">
5 |     <Import Project="Common.props" />
6 |   </ImportGroup>
7 | </Project>
8 | <!-- This project created via the OSB Project Template by ???, ??? -->
9 | 


--------------------------------------------------------------------------------
/props/internal/User_x64.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="User_Common.props" />
 6 |   </ImportGroup>
 7 |   <ItemDefinitionGroup>
 8 |     <ClCompile>
 9 |       <PreprocessorDefinitions>X64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
10 |     </ClCompile>
11 |     <Link>
12 |       <TargetMachine>MachineX64</TargetMachine>
13 |     </Link>
14 |   </ItemDefinitionGroup>
15 | </Project>
16 | <!-- This project created via the OSB Project Template by ???, ??? -->
17 | 


--------------------------------------------------------------------------------
/props/internal/User_x86.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- This project created via the OSB Project Template by ???, ??? -->
 3 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 4 |   <ImportGroup Label="PropertySheets">
 5 |     <Import Project="User_Common.props" />
 6 |   </ImportGroup>
 7 |   <ItemDefinitionGroup>
 8 |     <ClCompile>
 9 |       <PreprocessorDefinitions>X86;%(PreprocessorDefinitions)</PreprocessorDefinitions>
10 |     </ClCompile>
11 |     <Link>
12 |       <TargetMachine>MachineX86</TargetMachine>
13 |     </Link>
14 |   </ItemDefinitionGroup>
15 | </Project>
16 | <!-- This project created via the OSB Project Template by ???, ??? -->
17 | 


--------------------------------------------------------------------------------