Как в ХП запретит вызав таскменеджера?

[PSD]

Есть такая необходиммость запретить вызав таск менеджера или верней адаптировать блокировку для хп.
В ранних весиях я просто подменял taskmng.exe своим файлом, но эта скатина его автоматически выстанавливает, как это можно отключить(выстановление) или как запретит вызов?

Есть чтонибудь такое в реестре?

[GlukSoft]

Есть ли в реестре запрет вызова не знаю, но можно попробовать программно – через хуки.

[Джон]

Если поможет. Как - не знаю. Но через хуки точно можно - у нас одному надо было, он на моём компе её проверял. Видел воочию. Затыкается везде, кроме Ctrl+Alt+Del диалога. Тут оп свою gina.dll делал. Вот такая вот инфа.
 :?

[PSD]

Есть ли в реестре запрет вызова не знаю, но можно попробовать программно – через хуки.

Это как поподробней можно я с ними никогда не работал....

[GlukSoft]

PSD, Смотри в MSDN Hooks, ниже, пример от туда. А если коротко, то на системные события (WH_CALLWNDPROC WH_CBT WH_DEBUG WH_GETMESSAGE WH_KEYBOARD WH_MOUSE WH_MSGFILTER) ты можешь поставить хук (свою функцию).

#define NUMHOOKS 7
 
// Global variables
 
typedef struct _MYHOOKDATA
{
    int nType;
    HOOKPROC hkprc;
    HHOOK hhook;
} MYHOOKDATA;
 
MYHOOKDATA myhookdata[NUMHOOKS];
 
LRESULT WINAPI MainWndProc(HWND hwndMain, UINT uMsg, WPARAM wParam,
    LPARAM lParam)
{
    static BOOL afHooks[NUMHOOKS];
    int index;
    static HMENU hmenu;
 
    switch (uMsg)
    {
        case WM_CREATE:
 
            // Save the menu handle.
 
            hmenu = GetMenu(hwndMain);
 
            // Initialize structures with hook data. The menu-item
            // identifiers are defined as 0 through 6 in the
            // header file. They can be used to identify array
            // elements both here and during the WM_COMMAND
            // message.
 
            myhookdata[IDM_CALLWNDPROC].nType = WH_CALLWNDPROC;
            myhookdata[IDM_CALLWNDPROC].hkprc = CallWndProc;
            myhookdata[IDM_CBT].nType = WH_CBT;
            myhookdata[IDM_CBT].hkprc = CBTProc;
            myhookdata[IDM_DEBUG].nType = WH_DEBUG;
            myhookdata[IDM_DEBUG].hkprc = DebugProc;
            myhookdata[IDM_GETMESSAGE].nType = WH_GETMESSAGE;
            myhookdata[IDM_GETMESSAGE].hkprc = GetMsgProc;
            myhookdata[IDM_KEYBOARD].nType = WH_KEYBOARD;
            myhookdata[IDM_KEYBOARD].hkprc = KeyboardProc;
            myhookdata[IDM_MOUSE].nType = WH_MOUSE;
            myhookdata[IDM_MOUSE].hkprc = MouseProc;
            myhookdata[IDM_MSGFILTER].nType = WH_MSGFILTER;
            myhookdata[IDM_MSGFILTER].hkprc = MessageProc;
 
            // Initialize all flags in the array to FALSE.
 
            memset(afHooks, FALSE, sizeof(afHooks));
 
            return 0;
 
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                 // The user selected a hook command from the menu.
 
                case IDM_CALLWNDPROC:
                case IDM_CBT:
                case IDM_DEBUG:
                case IDM_GETMESSAGE:
                case IDM_KEYBOARD:
                case IDM_MOUSE:
                case IDM_MSGFILTER:
 
                    // Use the menu-item identifier as an index
                    // into the array of structures with hook data.
 
                    index = LOWORD(wParam);
 
                    // If the selected type of hook procedure isn't
                    // installed yet, install it and check the
                    // associated menu item.
 
                    if (!afHooks[index])
                    {
                        myhookdata[index].hhook = SetWindowsHookEx(
                            myhookdata[index].nType,
                            myhookdata[index].hkprc,
                            (HINSTANCE) NULL, GetCurrentThreadId());
                        CheckMenuItem(hmenu, index,
                            MF_BYCOMMAND | MF_CHECKED);
                        afHooks[index] = TRUE;
                    }
 
                    // If the selected type of hook procedure is
                    // already installed, remove it and remove the
                    // check mark from the associated menu item.
 
                    else
                    {
                        UnhookWindowsHookEx(myhookdata[index].hhook);
                        CheckMenuItem(hmenu, index,
                            MF_BYCOMMAND | MF_UNCHECKED);
                        afHooks[index] = FALSE;
                    }
 
                default:
                    return (DefWindowProc(hwndMain, uMsg, wParam,
                        lParam));
            }
            break;
 
            //
            // Process other messages.
            //
 
        default:
            return DefWindowProc(hwndMain, uMsg, wParam, lParam);
    }
    return NULL;
}
 
/****************************************************************
  WH_CALLWNDPROC hook procedure
 ****************************************************************/
 
LRESULT WINAPI CallWndProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    CHAR szCWPBuf[256];
    CHAR szMsg[16];
    HDC hdc;
    static int c = 0;
    size_t cch;
   size_t * pcch;
   HRESULT hResult;
 
    if (nCode < 0)  // do not process message
        return CallNextHookEx(myhookdata[CALLWNDPROC].hhook, nCode,
                wParam, lParam);
 
    // Call an application-defined function that converts a message
    // constant to a string and copies it to a buffer.
 
    LookUpTheMessage((PMSG) lParam, szMsg);
 
    hdc = GetDC(hwndMain);
 
    switch (nCode)
    {
        case HC_ACTION:
         hResult = StringCchPrintf(szCWPBuf, 256/sizeof(TCHAR),  
               "CALLWNDPROC - tsk: %ld, msg: %s, %d times   ",
                wParam, szMsg, c++);
         if (FAILED(hResult))
         {
         // TODO: writer error handler
         }
         hResult = StringCchLength(szCWPBuf, 256/sizeof(TCHAR), pcch);
         if (FAILED(hResult))
         {
         // TODO: write error handler
         }
            TextOut(hdc, 2, 15, szCWPBuf, *pcch);
            break;
 
        default:
            break;
    }
 
    ReleaseDC(hwndMain, hdc);
    return CallNextHookEx(myhookdata[CALLWNDPROC].hhook, nCode,
        wParam, lParam);
}
 
/****************************************************************
  WH_GETMESSAGE hook procedure
 ****************************************************************/
 
LRESULT CALLBACK GetMsgProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    CHAR szMSGBuf[256];
    CHAR szRem[16];
    CHAR szMsg[16];
    HDC hdc;
    static int c = 0;
    size_t cch;
   size_t * pcch;
   HRESULT hResult;
 
    if (nCode < 0) // do not process message
        return CallNextHookEx(myhookdata[GETMESSAGE].hhook, nCode,
            wParam, lParam);
 
    switch (nCode)
    {
        case HC_ACTION:
            switch (wParam)
            {
                case PM_REMOVE:
               hResult = StringCchCopy(szRem, 16/sizeof(TCHAR), "PM_REMOVE");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
                    break;
 
                case PM_NOREMOVE:
               hResult = StringCchCopy(szRem, 16/sizeof(TCHAR), "PM_NOREMOVE");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
                    break;
 
                default:
               hResult = StringCchCopy(szRem, 16/sizeof(TCHAR), "Unknown");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
                    break;
            }
 
            // Call an application-defined function that converts a
            // message constant to a string and copies it to a
            // buffer.
 
            LookUpTheMessage((PMSG) lParam, szMsg);
 
            hdc = GetDC(hwndMain);
         hResult = StringCchPrintf(szMSGBuf, 256/sizeof(TCHAR),
                "GETMESSAGE - wParam: %s, msg: %s, %d times   ",
                szRem, szMsg, c++);
         if (FAILED(hResult))
         {
         // TODO: write error handler
         }
         hResult = StringCchLength(szMSGBuf, 256/sizeof(TCHAR), pcch);
         if (FAILED(hResult))
         {
         // TODO: write error handler
         }
            TextOut(hdc, 2, 35, szMSGBuf, *pcch);
            break;
 
        default:
            break;
    }
 
    ReleaseDC(hwndMain, hdc);
    return CallNextHookEx(myhookdata[GETMESSAGE].hhook, nCode,
        wParam, lParam);
}
 
/****************************************************************
  WH_DEBUG hook procedure
 ****************************************************************/
 
LRESULT CALLBACK DebugProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    CHAR szBuf[128];
    HDC hdc;
    static int c = 0;
    size_t cch;
   size_t * pcch;
   HRESULT hResult;
 
    if (nCode < 0)  // do not process message
        return CallNextHookEx(myhookdata[DEBUG].hhook, nCode,
            wParam, lParam);
 
    hdc = GetDC(hwndMain);
 
    switch (nCode)
    {
        case HC_ACTION:
         hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR),  
                "DEBUG - nCode: %d, tsk: %ld, %d times   ",
                nCode,wParam, c++);
         if (FAILED(hResult))
         {
         // TODO: write error handler
         }
         hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
         if (FAILED(hResult))
         {
         // TODO: write error handler
         }
            TextOut(hdc, 2, 55, szBuf, *pcch);
            break;
 
        default:
            break;
    }
 
    ReleaseDC(hwndMain, hdc);
    return CallNextHookEx(myhookdata[DEBUG].hhook, nCode, wParam,
        lParam);
}
 
/****************************************************************
  WH_CBT hook procedure
 ****************************************************************/
 
LRESULT CALLBACK CBTProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    CHAR szBuf[128];
    CHAR szCode[128];
    HDC hdc;
    static int c = 0;
    size_t cch;
   size_t * pcch;
   HRESULT hResult;
 
    if (nCode < 0)  // do not process message
        return CallNextHookEx(myhookdata[CBT].hhook, nCode, wParam,
            lParam);
 
    hdc = GetDC(hwndMain);
 
    switch (nCode)
    {
        case HCBT_ACTIVATE:
         hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_ACTIVATE");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
            break;
 
        case HCBT_CLICKSKIPPED:
         hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_CLICKSKIPPED");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
            break;
 
        case HCBT_CREATEWND:
         hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_CREATEWND");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
            break;
 
        case HCBT_DESTROYWND:
         hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_DESTROYWND");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
            break;
 
        case HCBT_KEYSKIPPED:
         hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_KEYSKIPPED");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
            break;
 
        case HCBT_MINMAX:
         hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_MINMAX");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
            break;
 
        case HCBT_MOVESIZE:
         hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_MOVESIZE");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
            break;
 
        case HCBT_QS:
         hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_QS");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
            break;
 
        case HCBT_SETFOCUS:
         hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_SETFOCUS");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
            break;
 
        case HCBT_SYSCOMMAND:
         hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_SYSCOMMAND");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
            break;
 
        default:
         hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "Unknown");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
            break;
    }
   hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR), "CBT -  nCode: %s, tsk: %ld, %d times   ",
        szCode, wParam, c++);
   if (FAILED(hResult))
   {
   // TODO: write error handler
   }
   hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
   if (FAILED(hResult))
   {
   // TODO: write error handler
   }
    TextOut(hdc, 2, 75, szBuf, *pcch);
    ReleaseDC(hwndMain, hdc);
    return CallNextHookEx(myhookdata[CBT].hhook, nCode, wParam,
        lParam);
}
 
/****************************************************************
  WH_MOUSE hook procedure
 ****************************************************************/
 
LRESULT CALLBACK MouseProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    CHAR szBuf[128];
    CHAR szMsg[16];
    HDC hdc;
    static int c = 0;
    size_t cch;
   size_t * pcch;
   HRESULT hResult;
 
    if (nCode < 0)  // do not process the message
        return CallNextHookEx(myhookdata[MOUSE].hhook, nCode,
            wParam, lParam);
 
    // Call an application-defined function that converts a message
    // constant to a string and copies it to a buffer.
 
    LookUpTheMessage((PMSG) lParam, szMsg);
 
    hdc = GetDC(hwndMain);
   hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR),
        "MOUSE - nCode: %d, msg: %s, x: %d, y: %d, %d times   ",
        nCode, szMsg, LOWORD(lParam), HIWORD(lParam), c++);
   if (FAILED(hResult))
   {
   // TODO: write error handler
   }
   hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
   if (FAILED(hResult))
   {
   // TODO: write error handler
   }
    TextOut(hdc, 2, 95, szBuf, *pcch);
    ReleaseDC(hwndMain, hdc);
    return CallNextHookEx(myhookdata[MOUSE].hhook, nCode, wParam,
        lParam);
}
 
/****************************************************************
  WH_KEYBOARD hook procedure
 ****************************************************************/
 
LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    CHAR szBuf[128];
    HDC hdc;
    static int c = 0;
    size_t cch;
   size_t * pcch;
   HRESULT hResult;
 
    if (nCode < 0)  // do not process message
        return CallNextHookEx(myhookdata[KEYBOARD].hhook, nCode,
            wParam, lParam);
 
    hdc = GetDC(hwndMain);
   hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR), "KEYBOARD - nCode: %d, vk: %d, %d times ", nCode, wParam, c++);
   if (FAILED(hResult))
   {
   // TODO: write error handler
   }
   hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
   if (FAILED(hResult))
   {
   // TODO: write error handler
   }
    TextOut(hdc, 2, 115, szBuf, *pcch);
    ReleaseDC(hwndMain, hdc);
    return CallNextHookEx(myhookdata[KEYBOARD].hhook, nCode, wParam,
        lParam);
}
 
/****************************************************************
  WH_MSGFILTER hook procedure
 ****************************************************************/
 
LRESULT CALLBACK MessageProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    CHAR szBuf[128];
    CHAR szMsg[16];
    CHAR szCode[32];
    HDC hdc;
    static int c = 0;
    size_t cch;
   size_t * pcch;
   HRESULT hResult;
 
    if (nCode < 0)  // do not process message
        return CallNextHookEx(myhookdata[MSGFILTER].hhook, nCode,
            wParam, lParam);
 
    switch (nCode)
    {
        case MSGF_DIALOGBOX:
         hResult = StringCchCopy(szCode, 32/sizeof(TCHAR), "MSGF_DIALOGBOX");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
            break;
 
        case MSGF_MENU:
         hResult = StringCchCopy(szCode, 32/sizeof(TCHAR), "MSGF_MENU");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
            break;
 
        case MSGF_SCROLLBAR:
         hResult = StringCchCopy(szCode, 32/sizeof(TCHAR), "MSGF_SCROLLBAR");
               if (FAILED(hResult))
               {
               // TODO: write error handler
               }
            break;
 
        default:
         hResult = StringCchPrintf(szCode, 128/sizeof(TCHAR), "Unknown: %d", nCode);
   if (FAILED(hResult))
   {
   // TODO: write error handler
   }
            break;
    }
 
    // Call an application-defined function that converts a message
    // constant to a string and copies it to a buffer.
 
    LookUpTheMessage((PMSG) lParam, szMsg);
 
    hdc = GetDC(hwndMain);
   hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR),  
        "MSGFILTER  nCode: %s, msg: %s, %d times    ",
        szCode, szMsg, c++);
   if (FAILED(hResult))
   {
   // TODO: write error handler
   }
   hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
   if (FAILED(hResult))
   {
   // TODO: write error handler
   }
    TextOut(hdc, 2, 135, szBuf, *pcch);
    ReleaseDC(hwndMain, hdc);
    return CallNextHookEx(myhookdata[MSGFILTER].hhook, nCode,
        wParam, lParam);
}

[HandKot]

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\System
"DisableTaskMgr" — отключает возможность пользователя запускать Администратор задач для наблюдения за процессами, выполнением программ, а также созданием изменений в приоритете или в состоянии индивидуальных процессов.

   Данный совет составлен на основе источника:
   Simon Clausen  http://www.regedit.com

[Джон]

Хм, а ежели такого ключа нет по указанному адресу?    Попробовал вставить DisableTaskMgr как DWORD c 0. Не помогло.

[Джон]

Aaaaa c 1 работает!

[PSD]

Мой респекр HandKot,

[Джон]

Мой респект тоже.

[Джон]

Дико извиняюсь. Всё, что я выше описывал, относилось к диалогу, который выпрыгивает при нажатии Ctrl+Alt+Del.  

Может кто знает как ЭТО сделать без хуков?

[HandKot]

Инфу взял из работы Алексея Шашкова, который собрал 650 советов по виндам.
Если надо, то могу скинуть весь файл

[Джон]

Спрашиваешь! Конечно кидай! Инфа да ещё халявная!

Я покопался по ссылке, там тоже ничего не нашёл.  

[HandKot]

по Ctrl+Alt+Del сразу ничего не нашел
но одно время использовал программу WinBoost там такая возможность  вроде была. Просто посмотреть, как она это делает

[Джон]

Чел, который это сделал кричит, что только через gina.dll можно.

[Coreolis]

Чё-то у меня под XP не заработал DisableTaskMgr...

[HandKot]

Coreolis, да вроде должно, проверь по-лучше

[Coreolis]

О!
Заработало!
Просто я в local machine пихал, а там не хочет.
странно... всегда думал, что HKLM и HKCU одно и тоже, токо локал машин будет для вех юзеров, ан нет...