Alterando valores de configuração específicos no teclado virtual do Windows 7

Preciso usar o teclado virtual do Windows 7 para digitar:

(Caso ainda não o tenha usado, você pode obtê-lo através de: Todos os programas -> Acessórios -> Facilidade de acesso -> Teclado na tela

ou simplesmente pesquise "osk.exe")

Ele oferece um recurso para "pairar" sobre os botões. A Microsoft descreve o seguinte:

No modo de foco, use o mouse ou o joystick para apontar para uma tecla por um período predefinido e o caractere selecionado é digitado automaticamente.

Esse é o meu problema específico. O período de tempo predefinido é muito longo para ser útil para mim. O tempo mínimo é de 0,5 segundos (máximo de 3 segundos).

Existe alguma maneira de alterar esse valor para algo < 0,5? Por exemplo, através da edição do registro?

Editar: a entrada HKEY_CURRENT_USER\Software\Microsoft\Osk\HoverPeriodnão pode ser definida como inferior a 500 ms.

Edit (2): Eu acho que a única maneira de corrigir o meu problema é descompilar o arquivo .exe (acho que está escrito em C ou?) E alterar o tempo mínimo. Então eu tenho que compilá-lo novamente. Este procedimento é viável? Que coisas poderiam falhar?

Qualquer dica útil seria ótima!

Onde no código ele encontra nossa chave?

Usando o Process Monitor, pesquisar no evento ETL lendo esse rastreamento de pilha de valores nos fornece:

"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"

Podemos ver que OSKSettingsManager::GetOskSettinglê o valor.

Então, como é essa parte? Podemos depurar?

Examinando essa função com o WinDBG, ele acessa a chave do registro logo antes 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]
...

Agora, o problema aqui é que, quando tento interromper nesse local, não consigo mais digitar nada, porque se osk.exeadiciona aos drivers de entrada. Isso pode ser facilmente visto pressionando uma tecla modificadora, como Altno teclado, isso acende osk.exe.

Olhando através do código para adições ou subtrações, só vejo algo acontecer com 40hexadecimal, que é 64decimal. Então, isso também não está relacionado ao número.

Pode estar em uma das quatro cmpinstruções (comparar), mas isso exigiria informações de depuração. Ou isso poderia acontecer em uma função superior, o que exigiria mais investigação. Mas sem a capacidade de depurá-lo sem perder os recursos de entrada, isso é algo muito difícil de fazer ...

Parece que encontrar o local correto exigirá um cabo de depuração, pois o computador no qual você depura perde seus recursos de entrada ou é muito lento devido à sobrecarga da depuração. Como atualmente não tenho um laptop com uma porta de 1943, não consigo fazer isso depurando sozinho. Seria capaz de fazer isso e, sim, literalmente congelaria seu sistema operacional. Depurar um SO em vez de um aplicativo é divertido ... ^^

Espere, temos acesso aos símbolos! Podemos encontrar o código incorreto?

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)

Olhando mais de perto, você notará a função ofensiva:

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

Se percorrermos essa função, veremos primeiro:

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        

Ok, isso compara algo e depois pula para outro local. O que há?

pop     ebp
retn    8

Portanto, se a condição decidir que deve pular, ela deixará a função e não mudará nada.

Então, como fazemos com que ela sempre saia da função?

Mude a jzinstrução para uma jmpinstrução que sempre salte; você pode encontrá-la em deslocamento relativo 41BC10. Caso seu programa calcule deslocamentos diferentes, você precisa saber que ele usa 401000como base, para subtrair nos fornece o deslocamento absoluto 1AC10.

Observe que alterar 74( JZ) no editor hexadecimal para E9( JMP) não funcionará. Você não pode fazer isso em um editor hexadecimal, precisará de algo que desmonte e remonte o código, mas isso não é necessariamente fácil de encontrar (por exemplo, o IDA Professional pelo qual as pessoas realmente pagam, não podem produzir o código c ou um executável adequado. O OllyDBG, comumente usado na comunidade de patches, nem consegue abrir o executável.). E mesmo assim, a Microsoft pode estar protegendo seu executável contra adulteração, porque isso pode ser considerado contra o EULA; então boa sorte!

Meh! Isso é difícil, eu só quero digitar rápido usando o mouse / olhos / ...

Você deve definitivamente conferir o Dasher, que é muito mais rápido que um teclado na tela. Simplesmente funciona movendo o mouse em direção a letras; o movimento horizontal determina a velocidade e o movimento vertical seleciona as letras. Com um dicionário incorporado, ele pode até dimensionar as letras mais prováveis ​​de serem maiores, mas também tenta aprender com o seu movimento, de modo que a velocidade e as letras estejam realmente acostumadas ao seu uso.

Uma imagem fala mais que mil palavras ...

É claro que isso é pequeno e não é muito rápido, como exemplo, mas você pode redimensioná-lo para ficar no lado direito da tela, de modo que não interfira na tela. Isso permite que você digite o mais rápido possível ...

Aqui está um bom exemplo de como as previsões permitem que você digite qualquer idioma mais rapidamente:

Observe também que as letras à direita são classificadas em uma ordem específica, de modo que a direção principal (para cima, para cima ou para baixo) escolha entre os diferentes tipos (minúsculas, maiúsculas, números e pontuação); e, nessa direção principal, sua direção menor escolherá entre AZ, az, 0-9 e assim por diante. Eu usei isso no passado e fiquei realmente impressionado com o quão fluente isso é comparado a outros concorrentes ...

Observe também que o Dasher possui alguma configuração; portanto, você pode ajustar algo que não gosta.

Receio que a maioria dos descompiladores não produza um resultado bom o suficiente que possa ser recompilado.

A descompilação pode ajudar apenas a identificar a área HKEY_CURRENT_USER\Software\Microsoft\Osk\HoverPeriodusada, para descobrir onde esse valor é lido e onde o limite de 500 ms é imposto.

Uma vez localizado, você deve corrigir o código binário para desativar o teste e fazer com que o HoverPeriod seja menor. A correção do binário é muito mais viável do que recompilar.

Pode ser necessário repetir o esforço se o osk.exe for substituído pelo Windows Update (o que realmente não espero que aconteça).

[EDITAR]

Para ajudá-lo mais no caminho, aqui estão algumas palavras sobre utilitários e seu uso.

Você pode usar um descompilador C ou um desmontador. O tipo posterior pode ser mais útil, embora exija pouco conhecimento do conjunto de instruções da Intel. Você também precisará de um bom editor hexadecimal e há alguns que anunciam recursos de desmontagem (veja o link abaixo).

O projeto fenris se anuncia como "conjunto de ferramentas adequadas para análise de código, depuração, análise de protocolo, engenharia reversa, forense, diagnóstico, auditorias de segurança, pesquisa de vulnerabilidades e muitos outros propósitos". Parece bom e recomendado por muitos, mas não tenho experiência com isso.

O REC Studio Decompiler tenta produzir uma representação semelhante ao C do código e dados usados ​​para criar o arquivo executável.

O Boomerang é um decompilador geral, de código aberto e não segmentável, de programas de código de máquina.

Muitos outros utilitários podem ser encontrados no Google, ou em:

Ferramentas de análise / desmontagem do
wikibooks x86 wikibooks Desmontagem / desmontagem e descompilação do wikibooks x86
Open Directory: Desmontadores

Uma etapa preliminar é desmontar o osk. A listagem resultante pode ser volumosa e exigir um bom editor de texto (normalmente o bloco de notas ++ é suficiente).

Procure a sequência "HoverPeriod" (sem distinção entre maiúsculas e minúsculas). Se você tiver sorte, o desmontador identificou-o como uma string e você pode encontrá-lo como está. Caso contrário, será necessário procurá-lo byte a byte. Como uma string Unicode, parecerá H,0,o,0,v,0...onde as letras devem ser substituídas por seus códigos numéricos.

Depois de encontrar a string "HoverPeriod", o desmontador deve ter colocado um rótulo em algum lugar antes dela. Use o nome desse rótulo gerado para procurar onde é usado, para identificar onde é recuperado do registro e em qual variável global é o resultado armazenado.

Depois de localizar a variável que contém a contagem, procure onde ela é usada. O que você fará depende do formato do código que você encontrará. Você pode então decidir sobre o patch que deseja.

Por exemplo, convém usar o editor hexadecimal para substituir no osk.exe um comando como:

move AX,<HoverPeriod milliseconds count variable>

para dentro

mov AX,200       (your count of 200 milliseconds)

Tenha cuidado com diferentes comprimentos de comando, pois se o novo comando for mais curto, ele precisará ser preenchido com instruções NOP de um byte (sem operação) com o comprimento da instrução antiga.

Localizar o comando para corrigir o arquivo osk.exe pode exigir uma pesquisa se as compensações fornecidas pelo desmontador estão no código e não no arquivo exe. Se o editor hexadecimal não suportar a pesquisa de assembler, faça a desmontagem ao listar os bytes de instruções originais para saber quais bytes binários procurar. Evite procurar instruções que contenham endereços, pois os endereços podem ser realocados no exe; portanto, procure uma sequência de bytes próxima a essa instrução.

Você pode criar os novos bytes de patch diretamente no editor hexadecimal, se ele suportar o assembler. Ou, se isso não acontecer e você não se sentir à vontade com o código de máquina Intel, encontre um montador para compilar seu novo código e use sua listagem para obter os bytes compilados a serem utilizados para aplicação de patches.

Posso sugerir o uso do AutoIt para automatizar o clique?

A idéia seria monitorar a ociosidade do mouse quando o cursor estiver dentro da janela da tela (por exemplo, em um loop de controle, verificando regularmente se o cursor mudou de posição) e clicar automaticamente (função de chamada SendClick) após, digamos, 100 ms de inatividade.

Bate engenharia reversa um .exe.

Talvez você não precise recompilar tudo. No mundo do jogo, é comum o uso de treinadores, que manipulam um valor na memória quando o programa está sendo executado. Se você encontrar o valor mínimo na memória (0,5) e programar algo como um carregador para diminuir esse número, ele poderá funcionar.