CHAINE EN HEXA (WIN32)

Commentaire de exar le 12/03/2008 09:38:48

En fait, cette source aurait plus sa place dans la partie "assembler"...  Ce n'est plus du C, si ?

Commentaire de exar le 12/03/2008 20:20:07

MAX12: tout-à-fait d'accord, mais sur un code qui ne fait que transformer une chaîne de caractères en hexadécimal, je ne vois pas bien où se situe la gain par rapport au C classique...
J'approuve aussi ta note, parce que techniquement, c'est le top !  Mais je ne vois pas bien l'utilité...
J'utilise aussi parfois l'ASM (bien que rarement), mais pas directement dans le code C (ou C++, que j'utilise plus).
Allez, je vais aussi mettre une excellente note, parce que ce n'est pas la première fois que je vois des codes de BruNews, j'ai vu pas mal de ses commentaires et conseils, et je dois dire que je ne connais PERSONNE qui code aussi bien et aussi proprement.  Je rêverai d'avoir des collègues comme lui ;o)  Au moins, j'apprendrais pas mal de choses, je pense, contrairement aux développeurs chez le client chez qui je suis pour l'instant, qui me font recoder pas mal de choses (code qui fonctionne), simplement parce que, malgré les commentaires, ils ne comprennent rien...  Alors, si je mettais de l'ASM...  Ils m'ont demandé ce que c'était une classe et un objet, parce que j'en ai parlé dans des specs.  Ils n'avaient jamais entendu ce terme...
Bon, j'arrête de causer...  Je suis trop bavard... ;o)
Bonne continuation !

Commentaire de BruNews le 25/03/2008 10:46:13 administrateur CS

à tester: delete [] bufferCpy;

Commentaire de BruNews le 25/03/2008 11:39:52 administrateur CS

Les params passent en registre (ECX et EDX) à tout coup pour cette fonction, le prob ne peut pas venir de cela.
'naked' ne spécifie pas 'inline' donc pas d'exécution DANS l'appelant. Il empêche simplement le compilo d'y toucher (prologue, épilogue et autres arguties).

Dans tous les cas, faut trouver le prob dans ton code appelant. J'ai ce genre de fonction qui tourne en prod sur de gros serveurs depuis fort longtemps sans l'ombre d'un soucis.

Commentaire de BruNews le 25/03/2008 14:21:41 administrateur CS

Si tu me mets tout cela en PSEUDO code avec exemple de ce qu'il faut obtenir, je te le refais en vrai code (plus de stream, string et autres couches d'interprétation qui ont peu à faire dans du Windows).

Commentaire de BruNews le 25/03/2008 15:38:15 administrateur CS

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Medialive\Agent]
"Version"="3.1"
"BBPath"="C:\azerty.bb"
"MedialiveAgent"="C:\azerty.dll"
"BB1"=hex:string_hex("_Ahryman__40000_", 16)
"BB2"=hex:string_hex("_Ahryman__40000_", 16)
"InitialKey"=hex:00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
"DefaultID"=hex:00,00,00,00

CODE POUR OBTENIR CELA:
const char szREGEDIT[] = "Windows Registry Editor Version 5.00\r\n\r\n"; // len = 40
const char szHKLMMDLV[] = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Medialive\\Agent]\r\n"; // len = 47
const char szVERSION31[] = "\"Version\"=\"3.1\"\r\n"; // len = 17
const char szBBPATH[] = "\"BBPath\"=\"C:\\azerty.bb\"\r\n"; // len = 25
const char szMDLV[] = "\"MedialiveAgent\"=\"C:\\azerty.dll\"\r\n"; // len = 34
const char szBB1HEX[] = "\"BB1\"=hex:";

int __stdcall FaireFichierReg()
{
  HANDLE hfl;
  char szhex[36], buf[100], *c, *d;
  DWORD v, i;
  
  hfl = CreateFile("D:\\Config.reg", GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);
  if(hfl == INVALID_HANDLE_VALUE) return 0;
  WriteFile(hfl, szREGEDIT, 40, &v, 0);
  WriteFile(hfl, szHKLMMDLV, 47, &v, 0);
  WriteFile(hfl, szVERSION31, 17, &v, 0);
  WriteFile(hfl, szBBPATH, 25, &v, 0);
  WriteFile(hfl, szMDLV, 34, &v, 0);
  
  bnStrToHex("_Ahryman__40000_", szhex); // 1 SEULE FOIS, SORT 32 OCTETS ICI
  
  c = (char*) szBB1HEX;
  d = buf;
  while(*d = *c) {d++; c++;} // RECOPIE, d EST POINTEUR D'ECRITURE
  c = szhex;
  i = 16; // strlen("_Ahryman__40000_")
  do { // COPIE DE 2 OCTETS DE szhex A CHAQUE TOUR
    *d++ = *c++;
    *d++ = *c++;
    *d++ = ',';
  } while(--i);
  *(d-1) = '\r';  // ON SORT AVEC 1 VIRGULE EN TROP, ON ECRASE
  *d++ = '\n';
  WriteFile(hfl, buf, d - buf, &v, 0);
  
  // POUR BB2 QUI EST IDEM
  buf[3] = '2';
  WriteFile(hfl, buf, d - buf, &v, 0);
  
  // JE STOPPE ICI, LE RESTE EST TRIVIAL ET DEJA FAIT PLUS HAUT
  return CloseHandle(hfl);
}

En quoi est-ce plus compliqué de coder un peu ?
Quand on réalise qu'on peut tout maitriser et qu'il y a énorme benef de perfs et taille code, il n'y a plus à se poser la question.

Commentaire de Ahryman40k le 25/03/2008 16:49:10

Merci, grace à ton exemple j'ai mis en evidence le probleme avec ta methode bnStrToHex.

Le premier exemple provient de ton exemple et fonctionne
//*******************************************************************//
char* szhex = new char[36];
char* buf = new char[100];
bnStrToHex("_Ahryman__40000_", szhex); // 1 SEULE FOIS, SORT 32 OCTETS ICI
delete[] szhex;
delete[] buf;
//*******************************************************************//

Celui-ci est pratiquement identique mis a part le fait que je ne passe pas une chaine constante mais un pointeur contenant ma chaine:
*******************************************************************//
char* szhex = new char[36];
char* bufferCpy = new char[16];
::memcpy( bufferCpy, "__Ahryman_40000_", 16 );
bnStrToHex( bufferCpy, szhex ); // Ici ma chaine n'est pas terminée par '\0' d'ou le crash !!! J'ai donc besoin d'un tableau de taille 17 et d'inserer le caractere de fin de chaine.
delete[] bufferCpy;
delete[] szhex;

Donc finalement pour que cela fonctionne correctement, il faut appeler la methode comme suis en s'assurant que le parametre d'entrée est bien une chaine avec caractere de fin.
//************************************************************************************//
char* szhex = new char[36];
char* bufferCpy = new char[17];
::memcpy( bufferCpy, "_Ahryman__40000_", 17 );
bufferCpy[16] = '\0';
bnStrToHex( bufferCpy, szhex );
delete[] bufferCpy; // ca ne pete plus -_-''
delete[] szhex;

J'ai donc une derniere question à te poser,
mon besoin final est d'avoir la même methode bnStrToHex prenant en plus la taille de la chaine que je veux traiter (plutot que de s'arreter au caracetre de fin de chaine). Dans mon prog bufferCpy pourra contenir en plein milieu ce caractere de fin de chaine, car c'est une valeur sur 16 caracteres generée aleatoirement. Or j'ai besoin de recuperer le code hexa de l'integralité de ces caracteres.

Merci.

Commentaire de BruNews le 25/03/2008 17:10:00 administrateur CS

A TESTER mais devrait aller:
__declspec(naked) char* __fastcall bnStrToHex(char *szsrc, char* szdst, DWORD lensrc)
{ // ECX = szsrc, EDX = szdst, [esp+4] = lensrc
  __asm {
    mov       [esp-4], esi
    mov       [esp-8], ebx
    mov       esi, ecx
    mov       ebx, [esp+4]
fromSRC:
    mov       al, [esi]
    mov       cl, al
    add       edx, 2
    and       cl, 15
    shr       al, 4
    add       cl, 48
    add       al, 48
    cmp       cl, 57
    jbe       short L1
    add       cl, 7
L1:
    cmp       al, 57
    jbe       short L2
    add       al, 7
L2:
    add       esi, 1
    mov       byte ptr[edx-2], al
    mov       byte ptr[edx-1], cl
    sub       ebx, 1
    jne       short fromSRC
strEXIT:
    mov       byte ptr[edx], 0
    mov       esi, [esp-4]
    mov       ebx, [esp-8]
    mov       eax, edx
    ret       4
  }
}

ATTENTION que je ne teste pas si lensrc > 0 en entrée.