Discussion :

[thenaoh]

Bonjour,

Je cherche désespérément à faire fonctionner un hook souris basique réalisé en C++. Le hook doit fonctionner sous Windows 7 64 bits, où on peut donc y rencontrer des applications 32 et 64 bits.

Après plusieurs recherches, il me faut donc en gros réaliser 2 hooks, un compilé en 32 bits pour les applications 32 bits, un autre compilé en 64 bits pour les applications 64 bits.

J'ai trouvé un bout de code me permettant de faire la distinction entre les applications 32 et 64 bits, mais mon problème est que je ne sais pas comment le mettre en place ...

Le code faisant cette distinction d'applis est le suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
HWND hwnd;
DWORD ProcID;
HANDLE hProc;
BOOL bWOW64Proc = FALSE;

GetWindowThreadProcessId(hwnd, &ProcID);
hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcID);
IsWow64Process(hProc, &bWOW64Proc);
CloseHandle(hProc);

Le code de ma DLL où est codé mon hook, tout ce qu'il y a de plus classique (il ne fait rien, c'est juste pour l'exemple) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <windows.h>
#include <stdio.h>

HANDLE MemPartagee;
HINSTANCE thismod;
HHOOK hhk;

/**
 * Init DLL.
 */
extern "C" __declspec(dllexport) BOOL WINAPI DllMain(HINSTANCE hDll, DWORD dwReason, LPVOID Reserved)
{
    if(dwReason == DLL_PROCESS_ATTACH)
    {
        thismod = hDll;
    }
    return 1;
}

/**
 * Fonction hook.
 */
LRESULT CALLBACK wndProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    if (nCode >= 0)
    {
        if (wParam == WM_LBUTTONDOWN)
        {
            // Traitements du hook ...
        }
    }
    
    return CallNextHookEx(hhk, nCode, wParam, lParam);
}

/**
 * Démarrage du hook.
 */
extern "C" __declspec(dllexport) int __stdcall Intercepte()
{
    if(!hhk)
    {
        hhk  = SetWindowsHookEx(WH_MOUSE, wndProc, thismod, 0);
    }
    
    return (int) hhk;
}

/**
 * Arrêt du hook.
 */
extern "C" __declspec(dllexport) void __stdcall Relache()
{
    if(hhk)
    {
        UnhookWindowsHookEx(hhk);
        hhk = 0;
    }
}

Quelqu'un saurait-il comment faire, ou plus généralement, comment réaliser un (ou 2) hook(s) souris fonctionnant sous Windows 7 64 bits ?

Merci par avance pour votre aide

[wxXav]

Salut.

Je déterre ce topic pour savoir où tu en es ?
Est-ce que tu as résolu ton problème ?

J'ai en fait le même genre de soucis.
Je suis développeur pour cette application.
Actuellement, seule une version 32 bits existe.
L'une de ses fonctionnalités (nommée Drag'n'Go) permet de déplacer une fenêtre vers une zone spécifique de l'écran en adaptant sa taille au passage (il y a une petite vidéo dans la partie "Screenshots / Demos).
Cela se fait à l'aide de plusieurs hooks installés au démarrage de l'application.
Tout fonctionne correctement, sauf sur une version 64bits de Windows.
En fait, les fenêtres des processus 32bits sont bien prises en compte, mais pas les fenêtres des processus 64 bits.
J'ai fait le test en compilant l'application en 64 bits, et là, c'est l'inverse qui se produit (seules les fenêtres des processus 64 bits sont prises en compte).

D'après tout ce que j'ai pu lire sur le net à ce sujet, il va falloir mettre en place deux dll différentes (une pour chaque architecture).
Le plus gros problème est en fait l'intégration de ces deux dll au sein de la même application :

• Tout d'abord, comment lancer la dll 32bits depuis un exécutable 64bits
• Comment faire "communiquer" la dll 32 bits avec l'exécutable (il faut que la dll puisse connaitre les différents réglages effectués au sein de l'application, et ce sans redémarrage de cette dernière)

Merci d'avance pour toute piste qui pourrait être évoquée.

@+
Xav'

[thenaoh]

Salut,

Hélas je n'ai pas plus d'infos à ce sujet pour le moment.
Si qqn sait, je suis toujours preneur.

[Neitsa]

Bonjour,

Le plus gros problème est en fait l'intégration de ces deux dll au sein de la même application :

• Tout d'abord, comment lancer la dll 32bits depuis un exécutable 64bits
• Comment faire "communiquer" la dll 32 bits avec l'exécutable (il faut que la dll puisse connaitre les différents réglages effectués au sein de l'application, et ce sans redémarrage de cette dernière)

Il n'est pas possible d'avoir un programme 32 bits avec une DLL 64 bits (et vice-versa).

Pour la question des hooks, la DLL est injectée dans les processus, donc un programme 32 bits ne peut injecter que des programmes 32 bits (même combat pour le 64 bits). Il faut donc créer deux applications.

Je cite: SetWindowHookEx() [MSDN] (section "Remarks")

A 32-bit DLL cannot be injected into a 64-bit process, and a 64-bit DLL cannot be injected into a 32-bit process. If an application requires the use of hooks in other processes, it is required that a 32-bit application call SetWindowsHookEx to inject a 32-bit DLL into 32-bit processes, and a 64-bit application call SetWindowsHookEx to inject a 64-bit DLL into 64-bit processes. The 32-bit and 64-bit DLLs must have different names.

Deux exceptions toutefois: WH_MOUSE_LL et WH_KEYBOARD_LL puisque la DLL n'est pas injectée.

Je cite: LowLevelMouseProc Callback Function [MSDN] (section "Remarks")

However, the WH_MOUSE_LL hook is not injected into another process. Instead, the context switches back to the process that installed the hook and it is called in its original context. Then the context switches back to the application that generated the event.

[wxXav]

Salut, et merci pour la réponse.

Il n'est pas possible d'avoir un programme 32 bits avec une DLL 64 bits (et vice-versa).

Pour la question des hooks, la DLL est injectée dans les processus, donc un programme 32 bits ne peut injecter que des programmes 32 bits (même combat pour le 64 bits). Il faut donc créer deux applications.

Ça, je suis bien d'accord.
Il faut donc que je fasse :

• un petit exécutable et sa dll associée pour installer un hook 32bits
• la même chose pour le 64 bits

Le problème est de pouvoir faire communiquer ces deux dll avec une seule et même application (et de plus, la communication devrait pouvoir se faire dans les deux sens).

Ou alors (c'est juste une idée, au passage), une dll "maître" ayant la même architecture que l'application, et une seconde dll pour l'autre architecture qui arriverait à communiquer avec la première.

Je me dis que ça ne doit pas être impossible à faire (d'ailleurs, il y en a qui y sont apparemment arrivés : EasyHook mais il s'agit d'API Hooking, et le code source est en CSharp)

Donc, ma question est maintenant : comment arriver à faire communiquer les deux dlls entre elles, ou comment les faire communiquer avec l'application principale ?

Merci encore.
@+
Xav'

[wxXav]

Hello tout le monde.

Je pense avoir trouvé une solution acceptable, et surtout assez simple à mettre en oeuvre.

Comme il a été dit dans les posts précédents, il faut à tout prix avoir deux dll.
Et comme une application ne peut pas à la fois charger une dll 32 bits et une dll 64 bits, il faudra que ces deux dll aient leur propre "lanceur" (une simple application qui chargera la dll et appellera la fonction d'installation des hook).

Ces fameux lanceurs seront constitués d'une petite fenêtre (qui ne sera pas visible par l'utilisateur final).
Il suffit donc de connaître la classe de la fenêtre, ainsi qu'éventuellement son titre pour pouvoir la retrouver avec un simple "FindWindow" depuis l'application principale.

A partir du moment où l'application principale possède le handle (HWND) de chaque fenêtre cachée, elle va pouvoir lui envoyer des messages de la façon la plus classique qui soit : avec SendMessage.

Et j'ai découvert un message spécialement dédié à l'échange de données entre deux processus : WM_COPYDATA.

L'application n'aura donc qu'à envoyer les données au lanceur qui les transmettra à la dll.
Pour la communication de données dans l'autre sens, cela peut se faire de la même manière, que ce soit depuis la dll ou depuis le lanceur.

Il ne reste plus qu'à mettre tout ça en pratique.

@thenaoh : J'espère que cette solution pourra t'aider.
Sinon, il y a apparement d'autres solutions pour la communication entre deux processus, mais je pense que tu ne pourras pas non plus échapper à la méthode des "exécutables multiples".

@+
Xav'

[Andnotor]

A partir du moment où l'application principale possède le handle (HWND) de chaque fenêtre cachée, elle va pouvoir lui envoyer des messages de la façon la plus classique qui soit : avec SendMessage.

Depuis Vista et dû à l'UIPI, SendMessage va échoué lamentablement dans certains contextes si le message est supérieur à WM_USER. Il faudra prendre soin d'accepter chacun de ces messages avec ChangeWindowMessageFilter