Modification de valeurs de configuration spécifiques dans le clavier à l'écran de Windows 7

Je dois utiliser le clavier à l'écran de Windows 7 pour taper:

(Si vous ne l'avez pas encore utilisé, vous pouvez l'obtenir via: Tous les programmes -> Accessoires -> Facilité d'accès -> Clavier à l'écran

ou recherchez simplement "osk.exe")

Il offre une fonctionnalité pour "survoler" les boutons. Microsoft le décrit comme suit:

En mode stationnaire, vous utilisez une souris ou un joystick pour pointer sur une touche pendant une période de temps prédéfinie et le caractère sélectionné est tapé automatiquement.

Il y a mon problème spécifique. La période prédéfinie est trop longue pour être utile pour moi. La durée minimale est de 0,5 seconde (max.3 secondes).

Existe-t-il un moyen de modifier cette valeur en quelque chose de < 0,5? Par exemple via la modification du registre?

Modifier: l'entrée HKEY_CURRENT_USER\Software\Microsoft\Osk\HoverPeriodne peut pas être définie en dessous de 500 ms.

Edit (2): Je pense que la seule façon de résoudre mon problème est de décompiler le .exe (je suppose qu'il est écrit en C ou?) Et de changer le temps minimum. Ensuite, je dois le compiler à nouveau. Cette procédure est-elle même réalisable? Quelles choses pourraient échouer?

Tout conseil utile serait génial!

Où dans le code trouve-t-il notre clé?

En utilisant Process Monitor, creuser dans l'événement ETL en lisant cette trace de pile de valeurs nous donne:

"Frame","Module","Location","Address","Path"
...
"3","ntdll.dll","NtQueryValueKey + 0xa","0x7fbce17344a","C:\Windows\SYSTEM32\ntdll.dll"
"4","KERNELBASE.dll","LocalBaseRegQueryValue + 0x15d","0x7fbcb1a3e1d","C:\Windows\system32\KERNELBASE.dll"
"5","KERNELBASE.dll","RegQueryValueExW + 0xe9","0x7fbcb1a3c19","C:\Windows\system32\KERNELBASE.dll"
"6","ADVAPI32.dll","RegQueryValueExWStub + 0x1e","0x7fbcba412fe","C:\Windows\system32\ADVAPI32.dll"
"7","osk.exe","OSKSettingsManager::GetOskSetting + 0xc7","0x7f72356057f","C:\Windows\System32\osk.exe"
"8","osk.exe","OSKSettingsManager::Initialize + 0x6e","0x7f72355ffe2","C:\Windows\System32\osk.exe"
"9","osk.exe","OSKSettingsManager::GetOSKSettingsManager + 0x64","0x7f72355fee4","C:\Windows\System32\osk.exe"
"10","osk.exe","COskNativeHWNDHost::DetermineOSKWindowSizeAndLimits + 0x5a","0x7f72355d4fa","C:\Windows\System32\osk.exe"
"11","osk.exe","COskNativeHWNDHost::Initialize + 0xaa","0x7f72355d28e","C:\Windows\System32\osk.exe"
"12","osk.exe","PresentOSK + 0x112","0x7f723557882","C:\Windows\System32\osk.exe"
"13","osk.exe","wWinMain + 0x356","0x7f723557f16","C:\Windows\System32\osk.exe"
"14","osk.exe","operator new[] + 0x37a","0x7f723564b12","C:\Windows\System32\osk.exe"
"15","KERNEL32.DLL","BaseThreadInitThunk + 0x1a","0x7fbcd24298e","C:\Windows\system32\KERNEL32.DLL"
"16","ntdll.dll","RtlUserThreadStart + 0x1d","0x7fbce19e229","C:\Windows\SYSTEM32\ntdll.dll"

Nous pouvons voir que OSKSettingsManager::GetOskSettinglit la valeur.

Alors, à quoi ressemble cette portion? Pouvons-nous le déboguer?

En examinant cette fonction avec WinDBG, il accède à cette clé de registre juste avant 000007f7 23560517.

osk!OSKSettingsManager::GetOskSetting:
...
000007f7`2356050e ff15440bfeff    call    qword ptr [osk!_imp_RegOpenKeyExW (000007f7`23541058)]
000007f7`23560514 448bd8          mov     r11d,eax
000007f7`23560517 85c0            test    eax,eax
000007f7`23560519 751f            jne     osk!OSKSettingsManager::GetOskSetting+0x82 (000007f7`2356053a)
000007f7`2356051b 488b0b          mov     rcx,qword ptr [rbx]
...

Maintenant, le problème ici est que lorsque j'essaie de créer un point d'arrêt à cet emplacement, je ne peux plus taper quoi que ce soit car il osk.exes'ajoute aux pilotes d'entrée. Cela peut facilement être vu en maintenant une touche de modification comme Altsur votre clavier, cela l'illumine osk.exe.

En parcourant le code pour les ajouts ou les soustractions, je ne vois que quelque chose se produire avec 40hexadécimal qui est 64décimal. Ce n'est donc rien non plus lié au nombre.

Il pourrait être dans l'une des quatre cmpinstructions (comparer), mais cela nécessiterait des informations de débogage. Ou cela pourrait se produire dans une fonction plus élevée, ce qui nécessiterait plus d'investigations. Mais sans la possibilité de le déboguer sans perdre les capacités d'entrée, c'est une chose très difficile à faire ...

Semble que trouver le bon emplacement nécessitera un câble de débogage car l'ordinateur sur lequel vous déboguez perd ses capacités d'entrée, ou est beaucoup trop lent en raison de la surcharge de débogage. Comme je n'ai pas actuellement d'ordinateur portable avec un port 1943, je ne peux pas faire ce débogage moi-même. Il pourrait le faire, et oui, il gèlerait littéralement votre système d'exploitation. Déboguer un OS au lieu d'une application est amusant ... ^^

Attendez, nous avons accès aux symboles! Pouvons-nous trouver le code incriminé?

OSKSettingsManager::ClearTransferKey(void)
OSKSettingsManager::GetOSKSettingsManager(OSKSettingsManager * *)
OSKSettingsManager::GetOskSetting(ulong,ulong *)
OSKSettingsManager::GetOskSetting(ulong,ulong *,int)
OSKSettingsManager::Initialize(void)
OSKSettingsManager::NotifyListeners(ulong,ulong)
OSKSettingsManager::RegisterListener(void (*)(ulong,ulong))
OSKSettingsManager::SQMStartupSettings(void)
OSKSettingsManager::SetOskSetting(ulong,ulong)
OSKSettingsManager::SetOskSetting(ulong,ulong,int)
OSKSettingsManager::_HandleUpdateAllListeners(void)
OSKSettingsManager::_KeepSettingValueInBounds(ulong,ulong *,int)
OSKSettingsManager::`scalar deleting destructor'(uint)

En y regardant de plus près, vous remarquerez la fonction incriminée:

OSKSettingsManager::_KeepSettingValueInBounds(ulong,ulong *,int)

Si nous parcourons cette fonction, nous voyons d'abord:

mov     edi, edi
push    ebp
mov     ebp, esp
mov     eax, [ebp+arg_4]
imul    eax, 14h
cmp     dword_4B7598[eax], 0
jz      short loc_41BC36        

D'accord, cela compare quelque chose et passe ensuite à un autre emplacement. Qu'y a-t-il là?

pop     ebp
retn    8

Donc, si la condition décide qu'elle doit sauter, elle quittera simplement la fonction et ne changera rien.

Alors, comment faire en sorte qu'il quitte toujours la fonction?

Transformez l' jzinstruction en une jmpinstruction qui fait toujours le saut, vous pouvez la trouver à un décalage relatif 41BC10. Dans le cas où votre programme calcule des décalages différents, vous devez savoir qu'il utilise 401000comme base, donc la soustraction nous donne le décalage absolu 1AC10.

Veuillez noter que changer 74( JZ) dans l'éditeur hexadécimal en E9( JMP) ne fonctionnera pas. Vous ne pouvez pas le faire dans un éditeur hexadécimal, vous aurez besoin de quelque chose qui désassemble et réassemble le code, mais ce n'est pas nécessairement facile à trouver (par exemple, IDA Professional pour lequel les gens paient réellement, ne peut pas produire le bon code c ou un exécutable. OllyDBG, couramment utilisé dans la communauté des correctifs, ne peut même pas ouvrir l'exécutable.). Et même alors, Microsoft pourrait protéger son exécutable contre la falsification, car cela pourrait être considéré contre le CLUF; alors bonne chance!

Meh! C'est dur, je veux juste taper vite avec ma souris / mes yeux / ...

Vous devriez certainement vérifier Dasher qui est beaucoup plus rapide qu'un clavier à l'écran. Cela fonctionne simplement en déplaçant votre souris vers les lettres; le mouvement horizontal détermine la vitesse et le mouvement vertical sélectionne les lettres. Avec un dictionnaire intégré, il peut même dimensionner les lettres les plus susceptibles d'être plus grandes, il essaie également d'apprendre de votre mouvement de telle sorte que la vitesse et les lettres soient vraiment habituées à votre utilisation.

Une image en dit plus que mille mots ...

Bien sûr, c'est plutôt petit et pas vraiment rapide car c'est un exemple, mais vous pouvez le redimensionner pour qu'il soit sur le côté droit de votre écran afin qu'il n'interfère pas avec votre écran. Cela vous permet de taper aussi vite que possible ...

Voici un bon exemple de la façon dont les prédictions vous permettent de taper n'importe quelle langue plus rapidement:

Notez également que les lettres de droite sont triées dans un ordre spécifique, de sorte que la direction principale (haut, milieu ou bas) choisit entre les différents types (minuscules, majuscules, chiffres et ponctuation); puis dans une telle direction principale, votre direction secondaire choisira entre AZ, az, 0-9 et ainsi de suite. Je l'ai utilisé dans le passé et j'ai été étonné de voir à quel point cela est comparable à celui d'autres concurrents ...

Notez également que Dasher a une certaine configuration, vous pourrez donc peut-être ajuster quelque chose que vous n'aimez pas.

Je crains que la plupart des décompilateurs ne produisent pas un résultat suffisamment bon qui puisse être recompilé.

La décompilation peut seulement aider à localiser la zone HKEY_CURRENT_USER\Software\Microsoft\Osk\HoverPeriodutilisée, afin de savoir où cette valeur est lue et où la limite de 500 ms est appliquée.

Une fois localisé, vous devez patcher le code binaire afin de désactiver le test et de faire en sorte que HoverPeriod soit plus petit. Patcher le binaire est beaucoup plus réalisable que recompiler.

Vous devrez peut-être répéter l'effort si osk.exe est jamais remplacé par Windows Update (ce que je ne m'attends pas vraiment à arriver).

[ÉDITER]

Pour vous aider davantage sur le chemin, voici quelques mots sur les utilitaires et leur utilisation.

Vous pouvez soit utiliser un décompilateur C ou un désassembleur. Le dernier type peut être plus utile, bien qu'il nécessite une petite connaissance du jeu d'instructions Intel. Vous aurez également besoin d'un bon éditeur hexadécimal, et certains annoncent les capacités de désassemblage (voir le lien ci-dessous).

Le projet fenris se présente comme "une suite d'outils adaptés à l'analyse de code, au débogage, à l'analyse de protocole, à la rétro-ingénierie, à la criminalistique, aux diagnostics, aux audits de sécurité, à la recherche de vulnérabilités et à bien d'autres fins". Sonne bien et recommandé par beaucoup, mais je n'ai aucune expérience avec.

REC Studio Decompiler tente de produire une représentation de type C du code et des données utilisés pour créer le fichier exécutable.

Boomerang est un décompilateur général, open source, reciblable de programmes de code machine.

De nombreux autres utilitaires de ce type peuvent être trouvés sur Google ou dans:

wikibooks x86 Outils de démontage / analyse
wikibooks x86 Disassembly / Disassemblers and Decompilers
Open Directory: Disassemblers

Une étape préliminaire consiste à démonter l'osk. La liste résultante peut être volumineuse et nécessiter un bon éditeur de texte (normalement notepad ++ suffit).

Recherchez la chaîne "HoverPeriod" (insensible à la casse). Si vous êtes chanceux, le désassembleur l'a identifié comme une chaîne et vous pouvez le retrouver tel quel. Sinon, vous devrez le rechercher octet par octet. En tant que chaîne Unicode, elle ressemblera à l' H,0,o,0,v,0...endroit où les lettres doivent être remplacées par leurs codes numériques.

Une fois que vous avez trouvé la chaîne "HoverPeriod", le désassembleur doit avoir placé une étiquette quelque part devant lui. Utilisez le nom de cette étiquette générée pour rechercher où il est utilisé, pour identifier où il est extrait du registre et dans quelle variable globale le résultat est stocké.

Une fois que vous avez localisé la variable qui contient le nombre, recherchez où elle est utilisée. Ce que vous ferez dépendra du format du code que vous trouverez. Vous pouvez alors décider du patch que vous souhaitez.

Par exemple, vous pouvez utiliser l'éditeur hexadécimal pour remplacer dans osk.exe une commande telle que:

move AX,<HoverPeriod milliseconds count variable>

dans

mov AX,200       (your count of 200 milliseconds)

Soyez prudent avec différentes longueurs de commande, où si la nouvelle commande est plus courte, elle devra être complétée avec des instructions NOP à un octet (sans opération) à la longueur de l'ancienne instruction.

La localisation de la commande à corriger dans osk.exe peut nécessiter une recherche si les décalages fournis par le désassembleur se trouvent dans le code plutôt que dans le fichier exe. Si l'éditeur hexadécimal ne prend pas en charge la recherche d'assembleur, effectuez le démontage tout en répertoriant les octets d'instructions d'origine afin de savoir quels octets binaires rechercher. Évitez de rechercher des instructions contenant des adresses, car les adresses peuvent être déplacées dans l'exe, alors recherchez plutôt une séquence d'octets à proximité d'une telle instruction.

Vous pouvez créer les nouveaux octets de correctif directement dans l'éditeur hexadécimal s'il prend en charge l'assembleur. Ou si ce n'est pas le cas et que vous ne vous sentez pas à l'aise avec le code machine Intel, trouvez un assembleur pour compiler votre nouveau code et utilisez sa liste pour obtenir les octets compilés à utiliser pour les correctifs.

Puis-je suggérer d'utiliser AutoIt pour automatiser le clic?

L'idée serait de surveiller la marche au ralenti de la souris lorsque le curseur se trouve dans la fenêtre à l'écran (par exemple dans une boucle de contrôle, de vérifier à intervalles réguliers si le curseur a changé de position) et de cliquer automatiquement (fonction d'appel SendClick) après, disons, 100 ms d'inactivité.

Beats reverse engineering an .exe.

Vous n'avez peut-être pas à tout recompiler. Dans le monde du jeu, il est courant d'utiliser des entraîneurs, qui manipulent une valeur en mémoire lorsque le programme est en cours d'exécution. Si vous trouvez la valeur minimale en mémoire (0,5) et programmez quelque chose comme un chargeur pour réduire ce nombre, cela pourrait fonctionner.