void Resolver_Sak1()
{
// E8******** // call INITNP
// 85C0 // test eax, eax
// 75** // jne rel8
// 5F // pop edi
// 5E // pos esi
// B801000000 // mov eax, 1
// 5B // pop ebx
// 8B5E // mov esp, ebp
// 5D // pop ebp
// C3 // ret
// 68******** // push "resNameTable.txt"
ULONG Pos = 0;
if (FindAddStack("resNameTable.txt", &Pos) == false)
return;
ULONG InitNP = 0;
if (CompareBinary<UCHAR>(Pos-21, 0xE8)) // call rel32
{
InitNP = Pos - 21;
g_Intrnl.Addr[IA_INITNP] = InitNP;
}
if (CompareBinary<UCHAR>(Pos-23, 0xE8)) // call rel32
{
InitNP = Pos - 23;
g_Intrnl.Addr[IA_INITNP] = InitNP;
}
DbgPrintW(DBGINF, _CRT_WIDE("INF ResolverSak1 InitNP=%08X\n"), InitNP);
}
void ROParser::OwnOption(PUCHAR Buffer)
{
USHORT Param1 = *reinterpret_cast<USHORT*>(Buffer+6);
USHORT Param2 = *reinterpret_cast<USHORT*>(Buffer+8);
USHORT Param3 = *reinterpret_cast<USHORT*>(Buffer+10);
DbgPrintW(DBGINF, _CRT_WIDE("INF ZC_OPTION TGT=OWN P1=%04X P2=%04X P3=%04X\n"), Param1, Param2, Param3);
switch (Param1)
{
case OPT_STUN:
NoticeAbnormal("CONDITION_TO_STUN");
break;
case OPT_SLEEP:
NoticeAbnormal("CONDITION_TO_CURSE_SLEEP");
break;
default:
break;
}
if (Param2 & OPT_POISON)
NoticeAbnormal("CONDITION_TO_POISON");
if (Param2 & OPT_BLIND)
{
*reinterpret_cast<USHORT*>(Buffer+8) ^= OPT_BLIND;
NoticeAbnormal("CONDITION_TO_BLIND");
}
}
int ROParser::Send(PUCHAR Buffer, int Length)
{
DbgPrintW(DBGINFL2, _CRT_WIDE("INF ROParser::Send Length=%d\n"), Length);
DbgHexPrintW(Buffer, Length);
return 0;
}
/*********************************************************************
* rand_s (MSVCRT.@)
*/
int CDECL rand_s(unsigned int *pval)
{
BOOLEAN (WINAPI *pSystemFunction036)(PVOID, ULONG); // RtlGenRandom
HINSTANCE hadvapi32 = LoadLibraryA("advapi32.dll");
pSystemFunction036 = (void*)GetProcAddress(hadvapi32, "SystemFunction036");
#if 1
if (!pval || (pSystemFunction036 && !pSystemFunction036(pval, sizeof(*pval))))
{
_invalid_parameter(NULL,_CRT_WIDE("rand_s"),_CRT_WIDE(__FILE__),__LINE__, 0);
*_errno() = EINVAL;
return EINVAL;
}
#endif
if(hadvapi32) FreeLibrary(hadvapi32);
return 0;
}
void ROParser::ClSkillTmp(PUCHAR Buffer)
{
USHORT SkillID = *reinterpret_cast<USHORT*>(Buffer+2);
USHORT SkillLv = *reinterpret_cast<USHORT*>(Buffer+8);
DbgPrintW(DBGINF, _CRT_WIDE("INF ZC_SKILL_TMP ID=%04X LV=%04X\n"), SkillID, SkillLv);
if (SkillID != ITEM_ENCHANTARMS)
return;
switch (SkillLv)
{
case 0x0002:
ItemEnchantArms(CI_ELEMENT_WATER);
break;
case 0x0003:
ItemEnchantArms(CI_ELEMENT_GROUND);
break;
case 0x0004:
ItemEnchantArms(CI_ELEMENT_FIRE);
break;
case 0x0005:
ItemEnchantArms(CI_ELEMENT_WIND);
break;
case 0x0008:
ItemEnchantArms(CI_ELEMENT_SHADOW);
break;
}
}
void dll_process_attach(HINSTANCE hModule)
{
if (::GetFileAttributes(_CRT_WIDE("randgriz.dll")) != INVALID_FILE_ATTRIBUTES)
{
HMODULE module = ::LoadLibraryW(_CRT_WIDE("randgriz.dll"));
#ifdef _DEBUG
if (module)
::OutputDebugStringW(_CRT_WIDE("LOAD_SUCCESS randgriz.dll\n"));
#endif
}
else
{
#ifdef _DEBUG
::OutputDebugStringW(_CRT_WIDE("FILE_NOT_FOUND randgriz.dll\n"));
#endif
}
}
void Resolver_Sak2()
{
// 83C0F6 // add eax, -Ah
// 3D******** // cmp eax, imm32
// 0F87******** // ja rel32
// 33C9 // xor ecx, ecx
// 8A88******** // mov cl, [eax+IA_EFFTBL1]
// FF248D******** // jmp [IA_EFFTBL2+ecx*4]
// A1******** // mov eax, [IA_MINEFFECT]
ULONG Pos = 0;
UCHAR Code[] = {
0x83, 0xC0, 0xF6, // add eax, -Ah
0x3D, // cmp eax, imm32
};
if (FindBin(Code, sizeof(Code), &Pos) == false)
return;
ULONG EffectTable = 0;
ULONG JumpTable = 0;
ULONG MinEffect = 0;
// if (CompareBinary<USHORT>(Pos+16, 0x888A))
if (CompareBinary<UCHAR>(Pos+16, 0x8A)) // mov r8, r/m8
{
EffectTable = *reinterpret_cast<ULONG*>(Pos+18);
g_Intrnl.Addr[IA_EFFTBL1] = EffectTable;
}
// if (CompareBinary<USHORT>(Pos+22, 0x24FF)) // jmp r/m32
if (CompareBinary<UCHAR>(Pos+22, 0xFF)) // jmp r/m32
{
JumpTable = *reinterpret_cast<ULONG*>(Pos+25);
g_Intrnl.Addr[IA_EFFTBL2] = JumpTable;
}
if (CompareBinary<UCHAR>(Pos+29, 0xA1)) // mov eax, moffs32
{
MinEffect = *reinterpret_cast<ULONG*>(Pos+30);
g_Intrnl.Addr[IA_MINEFFECT] = MinEffect;
}
DbgPrintW(DBGINF, _CRT_WIDE("INF ResolverSak2 EffectTable=%08X\n"), EffectTable);
DbgPrintW(DBGINF, _CRT_WIDE("INF ResolverSak2 JumpTable=%08X\n"), JumpTable);
DbgPrintW(DBGINF, _CRT_WIDE("INF ResolverSak2 MinEffect=%08X\n"), MinEffect);
}
void ROParser::ClAuthAck(PUCHAR Buffer)
{
SuspendWorker();
ResetSessionTable();
g_Intrnl.Session.AID = *reinterpret_cast<ULONG*>(Buffer+8);
DbgPrintW(DBGINF, _CRT_WIDE("INF AC_AUTH_ACK AID=%08X\n"), g_Intrnl.Session.AID);
}
void ROParser::PushCondition(USHORT Type, UCHAR Flag)
{
// SetConditionIcon(Type, Flag);
UCHAR Buffer[9];
*reinterpret_cast<USHORT*>(Buffer) = PACKET_ZC_CONDITION;
*reinterpret_cast<USHORT*>(Buffer+2) = Type;
*reinterpret_cast<ULONG*>(Buffer+4) = g_Intrnl.Session.AID;
*reinterpret_cast<UCHAR*>(Buffer+8) = Flag;
DbgPrintW(DBGINF, _CRT_WIDE("CHK PushCondition Vars OP=%04X Type=%04X AID=%08X FLAG=%02d\n"), PACKET_ZC_CONDITION, Type, g_Intrnl.Session.AID, Flag);
ExecuteParser(PACKET_ZC_CONDITION, Buffer);
}
void ROParser::OwnCondition(PUCHAR Buffer)
{
USHORT Type = *reinterpret_cast<USHORT*>(Buffer+2);
UCHAR Flag = *reinterpret_cast<UCHAR*>(Buffer+8);
DbgPrintW(DBGINF, _CRT_WIDE("INF ZC_CONDITION TGT=OWN TYPE=%04X FLAG=%02X\n"), Type, Flag);
switch (Type)
{
case CI_BREAKWEAPON:
if (g_Intrnl.Session.EnArms != CI_NONE)
DeleteItemEnchantArms();
break;
case CI_HALLUCINATION:
if (Flag)
{
*reinterpret_cast<UCHAR*>(Buffer+8) &= 0;
NoticeAbnormal("CONDITION_TO_HALLUCINATION");
}
break;
case CI_ELEMENT_FIRE:
case CI_ELEMENT_WATER:
case CI_ELEMENT_WIND:
case CI_ELEMENT_GROUND:
case CI_ELEMENT_SHADOW:
case CI_ELEMENT_GHOST:
EnchantArms(Type, Flag, false);
break;
case CI_EXPLOSIONSPIRITS:
NoticeState("爆裂波動", Flag);
break;
case CI_BERSERK:
NoticeState("バーサーク", Flag);
break;
case CI_ASSUMPTIO:
NoticeState("アスムプティオ", Flag);
break;
case CI_MIRACLE:
NoticeState("太陽と月と星の奇跡", Flag);
break;
case CI_CLOSECONFINE_OWN:
case CI_CLOSECONFINE_TGT:
NoticeState("クローズコンファイン", Flag);
break;
default:
break;
}
}
void InitDebug(int DebugLevel)
{
if (g_DebugOut == NULL)
{
g_DebugOut = new FileOut(_CRT_WIDE("debug.txt"));
if (g_DebugOut->Size() == 0)
{
unsigned char Bom[] = { 0xFF, 0xFE };
g_DebugOut->Write(Bom, sizeof(Bom));
}
}
g_DebugLevel = DebugLevel;
}
void ROParser::ClSkillAck(PUCHAR Buffer)
{
if (g_Intrnl.Session.NoDivDmg == false)
return;
if (IsOwnAID(*reinterpret_cast<ULONG*>(Buffer+8)) == false)
return;
DbgPrintW(DBGINF, _CRT_WIDE("INF ZC_SKILL_ACK5 ID=%04X LV=%04X Type=%02X Val=%d/%d\n"), *reinterpret_cast<USHORT*>(Buffer+2),
*reinterpret_cast<USHORT*>(Buffer+28),
*reinterpret_cast<ULONG*>(Buffer+24),
*reinterpret_cast<USHORT*>(Buffer+30),
*reinterpret_cast<UCHAR*>(Buffer+32));
if (*reinterpret_cast<UCHAR*>(Buffer+32) == SKDMG_DIVIDE)
{
*reinterpret_cast<USHORT*>(Buffer+30) = 1; // 単発は1固定
*reinterpret_cast<UCHAR*>(Buffer+32) = SKDMG_ONE;
}
}
errno_t
localtime_s(struct tm* _tm, const time_t *ptime)
{
/* Validate parameters */
if (!_tm || !ptime)
{
#if 0
_invalid_parameter(NULL,
0,//__FUNCTION__,
_CRT_WIDE(__FILE__),
__LINE__,
0);
#endif
return EINVAL;
}
return 0;
}
void Resolver_Sak4()
{
// A1******** // mov eax, [IA_LANGTYPE]
// 85C0 // test eax, eax
// 0F84B7000000 // je rel32
// 83F803 // cmp eax, 3
// 0F84AE000000 // je rel32
// 83F805 // cmp eax, 5
// 0F84A5000000 // je rel32
ULONG Pos = 0;
UCHAR Code[] = {
0x83, 0xF8, 0x03,
0x0F, 0x84, 0xAE, 0x00, 0x00, 0x00,
};
if (FindBin(Code, sizeof(Code), &Pos) == false)
return;
ULONG ChkName = 0;
if (CompareBinary<USHORT>(Pos+3, 0x840F)) // je rel32
{
ULONG Relative = *reinterpret_cast<ULONG*>(Pos+5);
Pos = (Pos+9) + Relative;
// B9******** // mov ecx, imm32
// E8******** // call rel32
// A1******** // mov eax, [IA_LANGTYPE]
// 85C0 // test eax, eax
// 0F85******** // jne rel32
if (CompareBinary<UCHAR>(Pos+15, 0x85)) // test r/m32, r32
{
ChkName = Pos + 15;
g_Intrnl.Addr[IA_CHKNAME] = ChkName;
}
}
DbgPrintW(DBGINF, _CRT_WIDE("INF ResolverSak4 ChkName=%08X\n"), ChkName);
}
void Resolver_Sak3()
{
// A1******** // mov eax, [IA_MINEFFECT]
// 85C0 // test eax, eax
// 740A // jz imm8
// 68******** // push "magnificat_min.str"
// E9******** // jmp rel32
ULONG Pos = 0;
if (FindAddStack("magnificat_min.str", &Pos) == false)
return;
ULONG MinEffect = 0;
if (CompareBinary<UCHAR>(Pos-9, 0xA1)) // mov eax, moffs32
{
MinEffect = *reinterpret_cast<ULONG*>(Pos-8);
g_Intrnl.Addr[IA_MINEFFECT] = MinEffect;
}
DbgPrintW(DBGINF, _CRT_WIDE("INF ResolverSak3 MinEffect=%08X\n"), MinEffect);
}
/******************************************************************************
* \name _tasctime_s
* \brief Converts a local time into a string and returns a pointer to it.
* \param buffer Buffer that receives the string (26 characters).
* \param numberOfElements Size of the buffer in characters.
* \param time Pointer to the UTC time.
*/
errno_t
_tasctime_s(
_TCHAR* buffer,
size_t numberOfElements,
const struct tm *ptm)
{
/* Validate parameters */
if (!buffer || numberOfElements < 26 || !ptm ||
(unsigned int)ptm->tm_sec > 59 ||
(unsigned int)ptm->tm_min > 59 ||
(unsigned int)ptm->tm_hour > 23 ||
(unsigned int)ptm->tm_mday > 31 ||
(unsigned int)ptm->tm_mon > 11 ||
(unsigned int)ptm->tm_year > 2038 ||
(unsigned int)ptm->tm_wday > 6 ||
(unsigned int)ptm->tm_yday > 365)
{
#if 0
_invalid_parameter(NULL,
#ifdef UNICODE
L"_wasctime",
#else
L"asctime",
#endif
_CRT_WIDE(__FILE__),
__LINE__,
0);
#endif
return EINVAL;
}
/* Fill the buffer */
FillBuf((timebuf_t*)buffer, ptm);
return 0;
}
DWORD WINAPI OnGetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize)
{
//typedef DWORD (WINAPI* OnGetEnvironmentVariableW_t)(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize);
ORIGINAL_KRNL(GetEnvironmentVariableW);
DWORD lRc = 0;
if (lpName)
{
if ((lstrcmpiW(lpName, ENV_CONEMUANSI_VAR_W) == 0)
|| (lstrcmpiW(lpName, ENV_CONEMUHWND_VAR_W) == 0)
|| (lstrcmpiW(lpName, ENV_CONEMUDIR_VAR_W) == 0)
|| (lstrcmpiW(lpName, ENV_CONEMUBASEDIR_VAR_W) == 0)
)
{
CheckVariables();
}
else if ((lstrcmpiW(lpName, ENV_CONEMUANSI_VAR_W) == 0)
|| (lstrcmpiW(lpName, ENV_ANSICON_DEF_VAR_W) == 0))
{
CheckAnsiConVar(lpName);
}
else if (lstrcmpiW(lpName, ENV_ANSICON_VER_VAR_W) == 0)
{
if (lpBuffer && ((INT_PTR)nSize > lstrlenA(ENV_ANSICON_VER_VALUE)))
{
lstrcpynW(lpBuffer, _CRT_WIDE(ENV_ANSICON_VER_VALUE), nSize);
lRc = lstrlenA(ENV_ANSICON_VER_VALUE);
}
goto wrap;
}
}
lRc = F(GetEnvironmentVariableW)(lpName, lpBuffer, nSize);
wrap:
return lRc;
}
int ROParser::Recv(PUCHAR Buffer, int Length)
{
DbgPrintW(DBGINFL2, _CRT_WIDE("INF ROParser::Recv Length=%d\n"), Length);
DbgHexPrintW(Buffer, Length);
switch (*reinterpret_cast<USHORT*>(Buffer))
{
case PACKET_AC_AUTH_ACK:
ClAuthAck(Buffer);
break;
case PACKET_CC_SELECT_ACK:
ConnFirstProc(Buffer);
break;
case PACKET_CC_ENTER_ACK:
ClCCEnterAck(Buffer);
break;
case PACKET_ZC_ENTER_ACK:
ClZCEnterAck(Buffer);
break;
case PACKET_ZC_ERASE_ACTOR:
ClEraseActor(Buffer);
break;
case PACKET_ZC_CHAT:
case PACKET_ZC_CHAT_THIS:
case PACKET_ZC_WHISPER:
case PACKET_ZC_WHISPER_ACK:
case PACKET_ZC_BROADCAST:
case PACKET_ZC_PARTYCHAT:
case PACKET_ZC_MVP:
m_Chat->Push(Buffer, Length);
break;
case PACKET_ZC_OPTION1:
ClOption(Buffer);
break;
case PACKET_ZC_SKILL_TMP:
ClSkillTmp(Buffer);
break;
case PACKET_ZC_CONDITION:
ClCondition(Buffer);
break;
case PACKET_ZC_GUILDCHAT:
m_Chat->Push(Buffer, Length);
break;
case PACKET_ZC_SKILL_ACK5:
ClSkillAck(Buffer);
break;
case PACKET_ZC_BROADCAST2:
m_Chat->Push(Buffer, Length);
break;
case PACKET_ZC_OPTION2:
ClOption(Buffer);
break;
case PACKET_AC_SEED_ACK:
ConnFirstProc(Buffer);
break;
case PACKET_NC_NPROTECT_0259:
ConnFirstProc(Buffer);
break;
default:
break;
}
return Length;
}
// Warning, напрямую НЕ вызывать. Пользоваться "общей" PostMacro
void CPluginW2800::PostMacroApi(const wchar_t* asMacro, INPUT_RECORD* apRec, bool abShowParseErrors)
{
if (!InfoW2800 || !InfoW2800->AdvControl)
return;
MacroSendMacroText mcr = {sizeof(MacroSendMacroText)};
//mcr.Flags = 0; // По умолчанию - вывод на экран разрешен
bool bEnableOutput = true;
while ((asMacro[0] == L'@' || asMacro[0] == L'^') && asMacro[1] && asMacro[1] != L' ')
{
switch (*asMacro)
{
case L'@':
bEnableOutput = false;
break;
case L'^':
mcr.Flags |= KMFLAGS_NOSENDKEYSTOPLUGINS;
break;
}
asMacro++;
}
if (bEnableOutput)
mcr.Flags |= KMFLAGS_ENABLEOUTPUT;
// This macro was not adopted to Lua?
_ASSERTE(*asMacro && *asMacro != L'$');
// Вообще говоря, если тут попадается макрос в старом формате - то мы уже ничего не сделаем...
// Начиная с Far 3 build 2851 - все макросы переведены на Lua
mcr.SequenceText = asMacro;
if (apRec)
mcr.AKey = *apRec;
mcr.Flags |= KMFLAGS_SILENTCHECK;
if (!InfoW2800->MacroControl(&guid_ConEmu, MCTL_SENDSTRING, MSSC_CHECK, &mcr))
{
if (abShowParseErrors)
{
wchar_t* pszErrText = NULL;
size_t iRcSize = InfoW2800->MacroControl(&guid_ConEmu, MCTL_GETLASTERROR, 0, NULL);
MacroParseResult* Result = iRcSize ? (MacroParseResult*)calloc(iRcSize,1) : NULL;
if (Result)
{
Result->StructSize = sizeof(*Result);
_ASSERTE(FALSE && "Check MCTL_GETLASTERROR");
InfoW2800->MacroControl(&guid_ConEmu, MCTL_GETLASTERROR, iRcSize, Result);
size_t cchMax = (Result->ErrSrc ? lstrlen(Result->ErrSrc) : 0) + lstrlen(asMacro) + 255;
pszErrText = (wchar_t*)malloc(cchMax*sizeof(wchar_t));
_wsprintf(pszErrText, SKIPLEN(cchMax)
L"Error in Macro. Far %u.%u build %u r%u\n"
L"ConEmu plugin %02u%02u%02u%s[%u] {2800}\n"
L"Code: %u, Line: %u, Col: %u%s%s\n"
L"----------------------------------\n"
L"%s",
gFarVersion.dwVerMajor, gFarVersion.dwVerMinor, gFarVersion.dwBuild, gFarVersion.Bis ? 1 : 0,
MVV_1, MVV_2, MVV_3, _CRT_WIDE(MVV_4a), WIN3264TEST(32,64),
Result->ErrCode, (UINT)(int)Result->ErrPos.Y+1, (UINT)(int)Result->ErrPos.X+1,
Result->ErrSrc ? L", Hint: " : L"", Result->ErrSrc ? Result->ErrSrc : L"",
asMacro);
SafeFree(Result);
}
else
{
size_t cchMax = lstrlen(asMacro) + 255;
pszErrText = (wchar_t*)malloc(cchMax*sizeof(wchar_t));
_wsprintf(pszErrText, SKIPLEN(cchMax)
L"Error in Macro. Far %u.%u build %u r%u\n"
L"ConEmu plugin %02u%02u%02u%s[%u] {2800}\n"
L"----------------------------------\n"
L"%s",
gFarVersion.dwVerMajor, gFarVersion.dwVerMinor, gFarVersion.dwBuild, gFarVersion.Bis ? 1 : 0,
MVV_1, MVV_2, MVV_3, _CRT_WIDE(MVV_4a), WIN3264TEST(32,64),
asMacro);
}
if (pszErrText)
{
DWORD nTID;
HANDLE h = apiCreateThread(BackgroundMacroError, pszErrText, &nTID, "BackgroundMacroError");
SafeCloseHandle(h);
}
}
}
else
{
//gFarVersion.dwBuild
InfoW2800->MacroControl(&guid_ConEmu, MCTL_SENDSTRING, 0, &mcr);
}
}
// Warning, напрямую НЕ вызывать. Пользоваться "общей" PostMacro
void CPluginW1900::PostMacroApi(const wchar_t* asMacro, INPUT_RECORD* apRec, bool abShowParseErrors)
{
if (!InfoW1900 || !InfoW1900->AdvControl)
return;
MacroSendMacroText mcr = {sizeof(MacroSendMacroText)};
//mcr.Flags = 0; // По умолчанию - вывод на экран разрешен
while ((asMacro[0] == L'@' || asMacro[0] == L'^') && asMacro[1] && asMacro[1] != L' ')
{
switch (*asMacro)
{
case L'@':
mcr.Flags |= KMFLAGS_DISABLEOUTPUT;
break;
case L'^':
mcr.Flags |= KMFLAGS_NOSENDKEYSTOPLUGINS;
break;
}
asMacro++;
}
wchar_t* pszMacroCopy = NULL;
//Far3 build 2576: удален $Text
//т.к. макросы у нас фаро-независимые - нужны танцы с бубном
pszMacroCopy = lstrdup(asMacro);
CharUpperBuff(pszMacroCopy, lstrlen(pszMacroCopy));
if (wcsstr(pszMacroCopy, L"$TEXT") && !InfoW1900->MacroControl(&guid_ConEmu, MCTL_SENDSTRING, MSSC_CHECK, &mcr))
{
SafeFree(pszMacroCopy);
pszMacroCopy = (wchar_t*)calloc(lstrlen(asMacro)+1,sizeof(wchar_t)*2);
wchar_t* psz = pszMacroCopy;
while (*asMacro)
{
if (asMacro[0] == L'$'
&& (asMacro[1] == L'T' || asMacro[1] == L't')
&& (asMacro[2] == L'E' || asMacro[2] == L'e')
&& (asMacro[3] == L'X' || asMacro[3] == L'x')
&& (asMacro[4] == L'T' || asMacro[4] == L't'))
{
lstrcpy(psz, L"print("); psz += 6;
// Пропустить spasing-symbols
asMacro += 5;
while (*asMacro == L' ' || *asMacro == L'\t' || *asMacro == L'\r' || *asMacro == L'\n')
asMacro++;
// Копировать строку или переменную
if (*asMacro == L'@' && *(asMacro+1) == L'"')
{
*(psz++) = *(asMacro++); *(psz++) = *(asMacro++);
while (*asMacro)
{
*(psz++) = *(asMacro++);
if (*(asMacro-1) == L'"')
{
if (*asMacro != L'"')
break;
*(psz++) = *(asMacro++);
}
}
}
else if (*asMacro == L'"')
{
*(psz++) = *(asMacro++);
while (*asMacro)
{
*(psz++) = *(asMacro++);
if (*(asMacro-1) == L'\\' && *asMacro == L'"')
{
*(psz++) = *(asMacro++);
}
else if (*(asMacro-1) == L'"')
{
break;
}
}
}
else if (*asMacro == L'%')
{
*(psz++) = *(asMacro++);
while (*asMacro)
{
if (wcschr(L" \t\r\n", *asMacro))
break;
*(psz++) = *(asMacro++);
}
}
else
{
SafeFree(pszMacroCopy);
break; // ошибка
}
// закрыть скобку
*(psz++) = L')';
}
else
{
*(psz++) = *(asMacro++);
}
}
// Если успешно пропатчили макрос
if (pszMacroCopy)
asMacro = pszMacroCopy;
}
mcr.SequenceText = asMacro;
if (apRec)
mcr.AKey = *apRec;
mcr.Flags |= KMFLAGS_SILENTCHECK;
if (!InfoW1900->MacroControl(&guid_ConEmu, MCTL_SENDSTRING, MSSC_CHECK, &mcr))
{
if (abShowParseErrors)
{
wchar_t* pszErrText = NULL;
size_t iRcSize = InfoW1900->MacroControl(&guid_ConEmu, MCTL_GETLASTERROR, 0, NULL);
MacroParseResult* Result = iRcSize ? (MacroParseResult*)calloc(iRcSize,1) : NULL;
if (Result)
{
Result->StructSize = sizeof(*Result);
_ASSERTE(FALSE && "Check MCTL_GETLASTERROR");
InfoW1900->MacroControl(&guid_ConEmu, MCTL_GETLASTERROR, iRcSize, Result);
size_t cchMax = (Result->ErrSrc ? lstrlen(Result->ErrSrc) : 0) + lstrlen(asMacro) + 255;
pszErrText = (wchar_t*)malloc(cchMax*sizeof(wchar_t));
_wsprintf(pszErrText, SKIPLEN(cchMax)
L"Error in Macro. Far %u.%u build %u r%u\n"
L"ConEmu plugin %02u%02u%02u%s[%u] {1900}\n"
L"Code: %u, Line: %u, Col: %u%s%s\n"
L"----------------------------------\n"
L"%s",
gFarVersion.dwVerMajor, gFarVersion.dwVerMinor, gFarVersion.dwBuild, gFarVersion.Bis ? 1 : 0,
MVV_1, MVV_2, MVV_3, _CRT_WIDE(MVV_4a), WIN3264TEST(32,64),
Result->ErrCode, (UINT)(int)Result->ErrPos.Y+1, (UINT)(int)Result->ErrPos.X+1,
Result->ErrSrc ? L", Hint: " : L"", Result->ErrSrc ? Result->ErrSrc : L"",
asMacro);
SafeFree(Result);
}
else
{
size_t cchMax = lstrlen(asMacro) + 255;
pszErrText = (wchar_t*)malloc(cchMax*sizeof(wchar_t));
_wsprintf(pszErrText, SKIPLEN(cchMax)
L"Error in Macro. Far %u.%u build %u r%u\n"
L"ConEmu plugin %02u%02u%02u%s[%u] {1900}\n"
L"----------------------------------\n"
L"%s",
gFarVersion.dwVerMajor, gFarVersion.dwVerMinor, gFarVersion.dwBuild, gFarVersion.Bis ? 1 : 0,
MVV_1, MVV_2, MVV_3, _CRT_WIDE(MVV_4a), WIN3264TEST(32,64),
asMacro);
}
if (pszErrText)
{
DWORD nTID;
HANDLE h = apiCreateThread(BackgroundMacroError, pszErrText, &nTID, "BackgroundMacroError");
SafeCloseHandle(h);
}
}
}
else
{
//gFarVersion.dwBuild
InfoW1900->MacroControl(&guid_ConEmu, MCTL_SENDSTRING, 0, &mcr);
}
SafeFree(pszMacroCopy);
}
// prefast (6262): This func uses lots of stack because we want to tolerate very large reports, and we can't use malloc here.
int __cdecl _VCrtDbgReportA(
int nRptType,
void * returnAddress,
char const* szFile,
int nLine,
char const* szModule,
char const* szFormat,
va_list arglist
)
{
int retval=0;
int handled=FALSE;
char szLineMessage[DBGRPT_MAX_MSG]{0};
char szOutMessage [DBGRPT_MAX_MSG]{0};
wchar_t szOutMessage2[DBGRPT_MAX_MSG]{0};
char szUserMessage[DBGRPT_MAX_MSG]{0};
if (nRptType < 0 || nRptType >= _CRT_ERRCNT)
return -1;
/*
* handle the (hopefully rare) case of
*
* 1) ASSERT while already dealing with an ASSERT
* or
* 2) two threads asserting at the same time
*/
__try
{
if (_CRT_ASSERT == nRptType && _InterlockedIncrement(&_crtAssertBusy) > 0)
{
/* use only 'safe' functions -- must not assert in here! */
_ERRCHECK(_itoa_s(nLine, szLineMessage, DBGRPT_MAX_MSG, 10));
OutputDebugStringA("Second Chance Assertion Failed: File ");
OutputDebugStringA(szFile ? szFile : "<file unknown>");
OutputDebugStringA(", Line ");
OutputDebugStringA(szLineMessage);
OutputDebugStringA("\n");
_CrtDbgBreak();
retval=-1;
__leave;
}
// Leave space for ASSERTINTRO1 and "\r\n"
if (szFormat)
{
int szlen = 0;
_ERRCHECK_SPRINTF(szlen = _vsnprintf_s(szUserMessage, DBGRPT_MAX_MSG,
DBGRPT_MAX_MSG - 2- max(sizeof(ASSERTINTRO1),sizeof(ASSERTINTRO2)),
szFormat, arglist));
if (szlen < 0)
{
_ERRCHECK(strcpy_s(szUserMessage, DBGRPT_MAX_MSG, DBGRPT_TOOLONGMSG));
}
}
if (_CRT_ASSERT == nRptType)
{
_ERRCHECK(strcpy_s(szLineMessage, DBGRPT_MAX_MSG, szFormat ? ASSERTINTRO1 : ASSERTINTRO2));
}
_ERRCHECK(strcat_s(szLineMessage, DBGRPT_MAX_MSG, szUserMessage));
if (_CRT_ASSERT == nRptType)
{
if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_FILE)
{
_ERRCHECK(strcat_s(szLineMessage, DBGRPT_MAX_MSG, "\r"));
}
_ERRCHECK(strcat_s(szLineMessage, DBGRPT_MAX_MSG, "\n"));
}
if (szFile)
{
int szlen = 0;
_ERRCHECK_SPRINTF(szlen = _snprintf_s(szOutMessage, DBGRPT_MAX_MSG, DBGRPT_MAX_MSG - 1, "%s(%d) : %s",
szFile, nLine, szLineMessage));
if (szlen < 0)
{
_ERRCHECK(strcpy_s(szOutMessage, DBGRPT_MAX_MSG, DBGRPT_TOOLONGMSG));
}
}
else
{
_ERRCHECK(strcpy_s(szOutMessage, DBGRPT_MAX_MSG, szLineMessage));
}
{
size_t ret = 0;
errno_t e = 0;
_ERRCHECK_EINVAL_ERANGE(e = mbstowcs_s(&ret, szOutMessage2, DBGRPT_MAX_MSG, szOutMessage, _TRUNCATE));
if(e != 0)
{
_ERRCHECK(wcscpy_s(szOutMessage2, DBGRPT_MAX_MSG, _CRT_WIDE(DBGRPT_INVALIDMSG)));
}
}
/* User hook may handle report.
We have to check the ANSI Hook2 List & then the UNICODE Hook2 List.
Then we have check any ANSI individual Hook set through
SetReportHook */
if (_pReportHookList || _pReportHookListW)
{
__crt_report_hook_node<char> *pnode=nullptr;
__crt_report_hook_node<wchar_t> *pnodeW=nullptr;
__acrt_lock(__acrt_debug_lock);
__try
{
for (pnode = _pReportHookList; pnode; pnode = pnode->next)
{
int hook_retval=0;
if (pnode->hook(nRptType, szOutMessage, &hook_retval))
{
handled=TRUE;
retval=hook_retval;
__leave;
}
}
for (pnodeW = _pReportHookListW; pnodeW; pnodeW = pnodeW->next)
{
int hook_retval=0;
if (pnodeW->hook(nRptType, szOutMessage2, &hook_retval))
{
handled=TRUE;
retval=hook_retval;
__leave;
}
}
}
__finally
{
__acrt_unlock(__acrt_debug_lock);
}
}
if (handled)
__leave;
if (_pfnReportHook)
{
int hook_retval=0;
if (_pfnReportHook(nRptType, szOutMessage, &hook_retval))
{
retval = hook_retval;
__leave;
}
}
if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_FILE)
{
if (_CrtDbgFile[nRptType] != _CRTDBG_INVALID_HFILE)
{
DWORD bytes_written = 0;
WriteFile(_CrtDbgFile[nRptType], szOutMessage, static_cast<DWORD>(strlen(szOutMessage)), &bytes_written, nullptr);
}
}
if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_DEBUG)
{
OutputDebugStringA(szOutMessage);
}
if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_WNDW)
{
szLineMessage[0] = 0;
if (nLine)
{
_ERRCHECK(_itoa_s(nLine, szLineMessage, DBGRPT_MAX_MSG, 10));
}
retval = __acrt_MessageWindowA(nRptType, returnAddress, szFile, (nLine ? szLineMessage : nullptr), szModule, szUserMessage);
}
}
void ROParser::LoadConfig()
{
g_Intrnl.Session.NoDivDmg = ConfIsEnable(_CRT_WIDE("PACKET"), _CRT_WIDE("NODIVDMG"));
g_Intrnl.Session.TrueSight = ConfIsEnable(_CRT_WIDE("PACKET"), _CRT_WIDE("TRUESIGHT"));
}
// CIR_OK=0 - OK, CIR_AlreadyInjected=1 - Already injected, иначе - ошибка
// Здесь вызывается CreateRemoteThread
CINFILTRATE_EXIT_CODES InjectRemote(DWORD nRemotePID, bool abDefTermOnly /*= false */)
{
CINFILTRATE_EXIT_CODES iRc = CIR_GeneralError/*-1*/;
bool lbWin64 = WIN3264TEST((IsWindows64()!=0),true);
bool is32bit;
int nBits;
DWORD nWrapperWait = (DWORD)-1, nWrapperResult = (DWORD)-1;
HANDLE hProc = NULL;
wchar_t szSelf[MAX_PATH+16], szHooks[MAX_PATH+16];
wchar_t *pszNamePtr, szArgs[32];
wchar_t szName[64];
HANDLE hEvent = NULL;
HANDLE hDefTermReady = NULL;
bool bAlreadyHooked = false;
HANDLE hSnap = NULL;
MODULEENTRY32 mi = {sizeof(mi)};
HMODULE ptrOuterKernel = NULL;
if (!GetModuleFileName(NULL, szSelf, MAX_PATH))
{
iRc = CIR_GetModuleFileName/*-200*/;
goto wrap;
}
wcscpy_c(szHooks, szSelf);
pszNamePtr = (wchar_t*)PointToName(szHooks);
if (!pszNamePtr)
{
iRc = CIR_GetModuleFileName/*-200*/;
goto wrap;
}
// Hey, may be ConEmuHk.dll is already loaded?
hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, nRemotePID);
if (!hSnap || (hSnap == INVALID_HANDLE_VALUE))
{
iRc = CIR_SnapshotCantBeOpened/*-113*/;
goto wrap;
}
else if (hSnap && Module32First(hSnap, &mi))
{
// 130829 - Let load newer(!) ConEmuHk.dll into target process.
// 141201 - Also we need to be sure in kernel32.dll address
LPCWSTR pszConEmuHk = WIN3264TEST(L"conemuhk.", L"conemuhk64.");
size_t nDllNameLen = lstrlen(pszConEmuHk);
// Out preferred module name
wchar_t szOurName[40] = {};
wchar_t szMinor[8] = L""; lstrcpyn(szMinor, _CRT_WIDE(MVV_4a), countof(szMinor));
_wsprintf(szOurName, SKIPLEN(countof(szOurName))
CEDEFTERMDLLFORMAT /*L"ConEmuHk%s.%02u%02u%02u%s.dll"*/,
WIN3264TEST(L"",L"64"), MVV_1, MVV_2, MVV_3, szMinor);
CharLowerBuff(szOurName, lstrlen(szOurName));
// Go to enumeration
wchar_t szName[64];
do {
LPCWSTR pszName = PointToName(mi.szModule);
// Name of ConEmuHk*.*.dll module may be changed (copied to %APPDATA%)
if (!pszName || !*pszName)
continue;
lstrcpyn(szName, pszName, countof(szName));
CharLowerBuff(szName, lstrlen(szName));
if (!ptrOuterKernel
&& (lstrcmp(szName, L"kernel32.dll") == 0))
{
ptrOuterKernel = mi.hModule;
}
// ConEmuHk*.*.dll?
if (!bAlreadyHooked
&& (wmemcmp(szName, pszConEmuHk, nDllNameLen) == 0)
&& (wmemcmp(szName+lstrlen(szName)-4, L".dll", 4) == 0))
{
// Yes! ConEmuHk.dll already loaded into nRemotePID!
// But what is the version? Let don't downgrade loaded version!
if (lstrcmp(szName, szOurName) >= 0)
{
// OK, szName is newer or equal to our build
bAlreadyHooked = true;
}
}
// Stop enumeration?
if (bAlreadyHooked && ptrOuterKernel)
break;
} while (Module32Next(hSnap, &mi));
// Check done
}
SafeCloseHandle(hSnap);
// Already hooked?
if (bAlreadyHooked)
{
iRc = CIR_AlreadyInjected/*1*/;
goto wrap;
}
if (!ptrOuterKernel)
{
iRc = CIR_OuterKernelAddr/*-112*/;
goto wrap;
}
// Check, if we can access that process
hProc = OpenProcess(PROCESS_CREATE_THREAD|PROCESS_QUERY_INFORMATION|PROCESS_VM_OPERATION|PROCESS_VM_WRITE|PROCESS_VM_READ, FALSE, nRemotePID);
if (hProc == NULL)
{
iRc = CIR_OpenProcess/*-201*/;
goto wrap;
}
// Go to hook
// Preparing Events
_wsprintf(szName, SKIPLEN(countof(szName)) CEDEFAULTTERMHOOK, nRemotePID);
if (!abDefTermOnly)
{
// When running in normal mode (NOT set up as default terminal)
// we need full initialization procedure, not a light one when hooking explorer.exe
hEvent = OpenEvent(EVENT_MODIFY_STATE|SYNCHRONIZE, FALSE, szName);
if (hEvent)
{
ResetEvent(hEvent);
CloseHandle(hEvent);
}
}
else
{
hEvent = CreateEvent(LocalSecurity(), FALSE, FALSE, szName);
SetEvent(hEvent);
_wsprintf(szName, SKIPLEN(countof(szName)) CEDEFAULTTERMHOOKOK, nRemotePID);
hDefTermReady = CreateEvent(LocalSecurity(), FALSE, FALSE, szName);
ResetEvent(hDefTermReady);
}
// Creating as remote thread.
// Resetting this event notify ConEmuHk about
// 1) need to determine MainThreadId
// 2) need to start pipe server
_wsprintf(szName, SKIPLEN(countof(szName)) CECONEMUROOTTHREAD, nRemotePID);
hEvent = OpenEvent(EVENT_MODIFY_STATE|SYNCHRONIZE, FALSE, szName);
if (hEvent)
{
ResetEvent(hEvent);
CloseHandle(hEvent);
}
// Определить битность процесса, Если он 32битный, а текущий - ConEmuC64.exe
// Перезапустить 32битную версию ConEmuC.exe
nBits = GetProcessBits(nRemotePID, hProc);
if (nBits == 0)
{
// Do not even expected, ConEmu GUI must run ConEmuC elevated if required.
iRc = CIR_GetProcessBits/*-204*/;
goto wrap;
}
is32bit = (nBits == 32);
if (is32bit != WIN3264TEST(true,false))
{
// По идее, такого быть не должно. ConEmu должен был запустить соответствующий conemuC*.exe
_ASSERTE(is32bit == WIN3264TEST(true,false));
PROCESS_INFORMATION pi = {};
STARTUPINFO si = {sizeof(si)};
_wcscpy_c(pszNamePtr, 16, is32bit ? L"ConEmuC.exe" : L"ConEmuC64.exe");
_wsprintf(szArgs, SKIPLEN(countof(szArgs)) L" /INJECT=%u", nRemotePID);
if (!CreateProcess(szHooks, szArgs, NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi))
{
iRc = CIR_CreateProcess/*-202*/;
goto wrap;
}
nWrapperWait = WaitForSingleObject(pi.hProcess, INFINITE);
GetExitCodeProcess(pi.hProcess, &nWrapperResult);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
if ((nWrapperResult != CERR_HOOKS_WAS_SET) && (nWrapperResult != CERR_HOOKS_WAS_ALREADY_SET))
{
iRc = CIR_WrapperResult/*-203*/;
SetLastError(nWrapperResult);
goto wrap;
}
// Значит всю работу сделал враппер
iRc = CIR_OK/*0*/;
goto wrap;
}
// Поехали
_wcscpy_c(pszNamePtr, 16, is32bit ? L"ConEmuHk.dll" : L"ConEmuHk64.dll");
if (!FileExists(szHooks))
{
iRc = CIR_ConEmuHkNotFound/*-250*/;
goto wrap;
}
if (abDefTermOnly)
{
CINFILTRATE_EXIT_CODES iFRc = PrepareHookModule(szHooks);
if (iFRc != 0)
{
iRc = iFRc;
goto wrap;
}
}
iRc = InfiltrateDll(hProc, ptrOuterKernel, szHooks);
// Если создавали временную копию - запланировать ее удаление
if (abDefTermOnly && (lstrcmpi(szHooks, szSelf) != 0))
{
MoveFileEx(szHooks, NULL, MOVEFILE_DELAY_UNTIL_REBOOT);
}
wrap:
if (hProc != NULL)
CloseHandle(hProc);
// But check the result of the operation
//_ASSERTE(FALSE && "WaitForSingleObject(hDefTermReady)");
if ((iRc == 0) && hDefTermReady)
{
_ASSERTE(abDefTermOnly);
DWORD nWaitReady = WaitForSingleObject(hDefTermReady, CEDEFAULTTERMHOOKWAIT/*==0*/);
if (nWaitReady == WAIT_TIMEOUT)
{
iRc = CIR_DefTermWaitingFailed/*-300*/; // Failed to start hooking thread in remote process
}
}
return iRc;
}
