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

Question

Eu tenho que usar o Teclado Virtual do Windows 7 para digitar:

(Caso ainda não o tenha usado, você pode obtê-lo via: Todos os programas - Acessórios - > Facilidade de acesso - > Teclado no ecrã

ou simplesmente procure por "osk.exe")

Eleofereceumrecursopara"pairar" sobre os botões. A Microsoft descreve o seguinte:

No modo de focalização, você usa um mouse ou joystick para apontar para uma tecla por um período de tempo predefinido, e o caractere selecionado é digitado automaticamente.

Existe o meu problema específico. O período de tempo predefinido é muito longo para ser útil para mim. A quantidade mínima de tempo é de 0,5 segundos (máx. 3 segundos).

Existe alguma maneira de alterar esse valor para algo < 0,5? Por exemplo, editando o registro?

Editar: A entrada HKEY_CURRENT_USER\Software\Microsoft\Osk\HoverPeriod não pode ser definida abaixo de 500 ms.

Edit (2): 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. Esse procedimento é viável? Que coisas poderiam falhar?

Qualquer dica útil seria ótima!

    

Answer 1

Onde no código ele encontra nossa chave?

Usando o Process Monitor, acessando o evento ETL, esse rastreio da 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::GetOskSetting lê o valor.

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

Examinando essa função com o WinDBG, ela acessa essa chave do registro logo antes de 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 esse local, não consigo mais digitar nada porque osk.exe se adiciona aos drivers de entrada. Isso pode ser facilmente visto segurando uma tecla modificadora como Alt no teclado, isso acende em osk.exe .

Examinando o código para adições ou subtrações, vejo apenas algo acontecer com 40 hexadecimal, que é 64 decimal. Então, isso também não é nada relacionado ao número.

Pode estar em uma das quatro instruções cmp (compare), mas isso exigiria informações de depuração. Ou poderia acontecer em uma função mais alta, o que exigiria mais investigação. Mas sem a capacidade de depurá-lo sem perder as capacidades de entrada, isso é 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 está muito lento devido à sobrecarga da depuração. Como atualmente não tenho um laptop com porta 1943, não posso depurar isso sozinho. Ele seria capaz de fazer isso e, literalmente, congelaria seu sistema operacional. Depurar um sistema operacional em vez de um aplicativo é divertido ... ^^

Espere, nós 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 passarmos por essa função, primeiro vemos:

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á aí?

pop     ebp
retn    8

Então, se a condição decidir que deve pular, apenas sairá da função e não mudará nada.

Então, como fazemos sempre deixar a função?

Altere a instrução jz para uma instrução jmp que sempre faz o salto, você pode encontrá-lo no deslocamento relativo 41BC10 . Caso seu programa calcule deslocamentos diferentes, você precisa saber que ele usa 401000 como base, portanto, a subtração nos dá o deslocamento absoluto 1AC10 .

Por favor, note que a mudança 74 ( JZ ) no editor hexadecimal para E9 ( JMP ) não funcionará. Você não pode fazer isso em um editor hexadecimal, você precisará de algo que desmonta e remonta o código, mas isso não é necessariamente fácil de encontrar (por exemplo, IDA Professional que as pessoas realmente pagam, não pode produzir código c ou executável. O OllyDBG, comumente usado na comunidade de patches, não pode nem abrir o executável. E então, até mesmo, a Microsoft poderia estar protegendo seu executável contra adulterações, porque isso poderia ser considerado contra o EULA; então boa sorte!

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

Você deve definitivamente verificar Dasher que é muito mais rápido do que um teclado virtual. Simplesmente funciona movendo o mouse para as letras; movimento horizontal determina a velocidade e movimento vertical selecione as letras. Com um dicionário embutido pode até dimensionar as letras mais prováveis para serem maiores, ele também tenta aprender com seus movimentos de forma que a velocidade e as letras estejam realmente acostumadas com o seu uso.

Umaimagemfalamaisdemilpalavras...

Éclaroqueissoéumpoucopequenoenãomuitorápido,jáqueéumexemplo,masvocêpoderedimensioná-loparaficardoladodireitodatela,demodoqueelenãointerfiranasuatela.Issopermitequevocêdigiteomaisrápidopossível...

Esteéumbomexemplodecomoasprevisõespermitemquevocêdigitequalqueridiomamaisrapidamente:

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 o meio ou para baixo) escolhe entre os diferentes tipos (minúsculas, maiúsculas, números e pontuação); e então dentro de tal direção maior, sua direção menor escolherá entre A-Z, a-z, 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 tem alguma configuração, então você pode ajustar algo que não gosta.

    

Answer 2

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

A descompilação só pode ajudar a identificar a área em que HKEY_CURRENT_USER\Software\Microsoft\Osk\HoverPeriod é usado, para descobrir onde esse valor é lido e onde o limite de 500 ms é aplicado.

Uma vez localizado, você deve corrigir o código binário para desativar o teste e impor que o HoverPeriod seja menor. Corrigir o binário é muito mais viável do que recompilar.

Você pode precisar repetir o esforço se o osk.exe for substituído pelo Windows Update (o que eu realmente não espero que aconteça).

[EDITAR]

Para te ajudar mais no caminho, aqui estão algumas palavras sobre utilidades e seu uso.

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

projeto fenris anuncia-se como "conjunto de ferramentas adequadas para análise de código, depuração, análise de protocolo, engenharia reversa , forense, diagnósticos, auditorias de segurança, pesquisa de vulnerabilidades e muitas outras finalidades ". Soa bem e é recomendado por muitos, mas eu não tenho experiência com isso.

O

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

O Boomerang é um descompilador geral, de código-fonte aberto e retargetable de programas de código de máquina.

Muitos desses utilitários podem ser encontrados no googling ou em:

wikibooks x86 Desmontagem / Ferramentas de análise

Um passo preliminar é desmontar o osk. A listagem resultante pode ser volumosa e requer um bom editor de texto (normalmente o notepad ++ é suficiente).

Procure a string "HoverPeriod" (não diferencia maiúsculas de minúsculas). Se você tiver sorte, o desmontador identificou-o como uma string e você pode encontrá-lo como está. Se não, você precisará procurar por byte a byte. Como uma string Unicode, ela se parecerá com 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 dele. Use o nome desse rótulo gerado para procurar onde ele é usado, para identificar onde ele é recuperado do registro e em qual variável global é o resultado armazenado.

Depois de localizar a variável que contém a contagem, pesquise 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 você deseja.

Por exemplo, você pode querer usar o editor hexadecimal para substituir em osk.exe um comando como:

move AX,<HoverPeriod milliseconds count variable>

em

mov AX,200       (your count of 200 milliseconds)

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

A localização do comando para patch no osk.exe pode exigir uma pesquisa se os deslocamentos fornecidos pelo desmontador estiverem no código, e não no arquivo exe. Se o editor hexadecimal não oferecer suporte à pesquisa do montador, faça a desmontagem ao listar os bytes da instrução original para saber quais bytes binários pesquisar. Evite procurar instruções que contenham endereços, uma vez que os endereços podem ser realocados no exe, portanto, procure por uma seqüência de bytes próxima a essa instrução.

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

    

Answer 3

Posso sugerir o uso do AutoIt para automatizar o clique?

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

Batida engenharia reversa e um .exe.

    

Answer 4

Talvez você não precise recompilar tudo. No mundo do jogo é comum usar treinadores, que manipulam um valor na memória quando o programa está em execução. Se você encontrar o valor mínimo na memória (0.5) e programar algo como um carregador para tornar esse número menor, pode funcionar.