Conversion C++ vers Delphi

Version imprimable

Bonjour,

J'aurais besoin d'aide pour convertir le code suivant vers delphi
Sachant que les fonctions "AcquireToken", "InputFromPort" et "OutputToPort" sont connues et fonctionnent déjà sous Delphi. Elles sont mises en commentaires
Merci d'avance a tous ceux qui pourront m'aider

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
unsigned ReturnValue1, ReturnValue2;
char A1, A2L, A2H, A3L, A3H, A4L, A4H;
 
char RotateLeft8(char Target, char rotateCount)
{
    return ( ((Target << rotateCount) & 0xff) |
             ((Target & 0xff) >> (8 - rotateCount))
           );
}
 
//**************************** KTASK ************************************
void KTASK(int CommandCode, int Argument2, int Argument3, int Argument4)
{
    unsigned long int ReturnValue=0;
    char RV1Lo, RV1Hi, RV2Lo, RV2Hi, Temp1Lo, Temp1Hi, Temp2Lo, Temp2Hi;
    char R1, R2;            // Random Numbers
    char S1, S2;        // Byte rotation counts
    char Xor1, Xor2;        // XOR Values
 
    Xor1 = (char) 0xd5;
    Xor2 = (char) 0x2d;
    S1 = 0x6;
    S2 = 0x7;
    R1 = (CHAR)rand();
    R2 = (CHAR)rand();
    EncodeArguments( CommandCode, Argument2, Argument3, Argument4, R1, R2);
//    AcquireToken(A1);
//    OutputToPort(hSerial, R1);
//    OutputToPort(hSerial, R2);
//    OutputToPort(hSerial, A2L);
//    OutputToPort(hSerial, A2H);
//    OutputToPort(hSerial, A3L);
//    OutputToPort(hSerial, A3H);
//    OutputToPort(hSerial, A4L);
//    OutputToPort(hSerial, A4H);
 
//    InputFromPort(hSerial, &Temp1Lo);
    RV1Lo = RotateLeft8(Temp1Lo, S2) ^ R1;
//    InputFromPort(hSerial, &Temp1Hi);
    RV1Hi = RotateLeft8(Temp1Hi, S1) ^ R2;
//    InputFromPort(hSerial, &Temp2Lo);
    RV2Lo = RotateLeft8((char)(Temp2Lo ^ Xor2 ^ R1), S1);
//    InputFromPort(hSerial, &Temp2Hi);
    RV2Hi = RotateLeft8((char)(Temp2Hi ^ Xor1 ^ R2), S2);
    ReturnValue1 = (((WORD)(RV1Hi) << 8) | ((WORD)RV1Lo & 0xff)) & 0xffff;
    ReturnValue2 = (((WORD)(RV2Hi) << 8) | ((WORD)RV2Lo & 0xff)) & 0xffff;
}
 
void EncodeArguments(int CommandCode, int Argument2, int Argument3, int Argument4, char R1, char R2)
{
    char Xor1, Xor2;    // XOR Values
    char S1, S2;    // Slide (rotate left) bit positions of Value
 
    Xor1 = (char) 0xd5;
    Xor2 = (char) 0x2d;
    S1 = 0x6;
    S2 = 0x7;
    A1 = LOBYTE(LOWORD(CommandCode)) | ((R2 & 0xe) << 4);  // Top 3 bit random
    A2L = RotateLeft8((char)(Argument2 ^ (ULONG)Xor1), S1);
    A2H = RotateLeft8(HIBYTE(LOWORD(Argument2)),(char)(Xor2 & 0x7)) ^ Xor2 ^ R1;
    A3L = RotateLeft8((char)(Argument3 ^ (ULONG)R2 ^ (ULONG)R1), S2);
    A3H = RotateLeft8( R1, S2) ^ (HIBYTE(LOWORD(Argument3))) ^ Xor1;
    A4L = RotateLeft8( R2, S1) ^ (LOBYTE(LOWORD(Argument4))) ^ Xor2;
    A4H = RotateLeft8((char)(Xor1 ^ Xor2), S1) ^ (HIBYTE(LOWORD(Argument4)));
}

Tu pourrais nous donner ta tentative que l'on ne se repaluche pas tout

Code:

1
2
3
4
5
6
char RotateLeft8(char Target, char rotateCount)
{
    return ( ((Target << rotateCount) & 0xff) |
             ((Target & 0xff) >> (8 - rotateCount))
           );
}

Code:

1
2
3
4
5
6
 
function RotateLeft8(ATarget: Byte; ARotateCount: Byte): Byte;
begin
  Result := ((ATarget shl ARotateCount) and $FF) or
            ((ATarget and $FF) shr (8 - ARotateCount));
end;

Bon normalement c'est EAX et EDX mais un Byte ne doit occuper que AL et DL (Edit : En tout cas, cela donne le même résultat que la version pascal)

Code:

1
2
3
4
5
function RotateLeft8A(ATarget: Byte; ARotateCount: Byte): Byte;
asm
  MOV CL, DL
  ROL AL, CL
end;

Code:

1
2
3
4
5
 
    RV2Lo = RotateLeft8((char)(Temp2Lo ^ Xor2 ^ R1), S1);
    RV2Hi = RotateLeft8((char)(Temp2Hi ^ Xor1 ^ R2), S2);
    ReturnValue1 = (((WORD)(RV1Hi) << 8) | ((WORD)RV1Lo & 0xff)) & 0xffff;
    ReturnValue2 = (((WORD)(RV2Hi) << 8) | ((WORD)RV2Lo & 0xff)) & 0xffff;

Traduit bêtement, tous ces masques pour s'assurer de l'étendue des valeurs c'est lourd et montre que l'on a pas confiance dans ses calculs ou ses types (un char << 8 ne pourra jamais excédé ta la taille du word, ceinture et bretelle)

Code:

1
2
3
4
    RV2Lo := RotateLeft8(Byte(Temp2Lo xor Xor2 xor R1), S1);
    RV2Hi := RotateLeft8(Byte(Temp2Hi xor Xor1 xor R2), S2);
    ReturnValue1 := ((Word(RV1Hi) shl 8) or (Word(RV1Lo) and $FF)) and $FFFF;
    ReturnValue2 := ((Word(RV2Hi) shl 8) or (Word(RV2Lo) and $FF)) and $FFFF;

on peut utiliser MAKEWORD et RotateLeft8 retourne un Byte le and $FF est inutile tout comme le and $FFFF

Code:

1
2
3
4
    RV2Lo := RotateLeft8(Byte(Temp2Lo xor Xor2 xor R1), S1);
    RV2Hi := RotateLeft8(Byte(Temp2Hi xor Xor1 xor R2), S2);
    ReturnValue1 := MAKEWORD(RV1Lo, RV1Hi);
    ReturnValue2 := MAKEWORD(RV2Lo, RV2Hi);

Merci. Tes quelques lignes me rassure déjà. Disons que je suis sur la bonne voie.

Pour éclaircir un peu : il s'agit de fonctions permettant de lire un dongle connecté au port série. J'ai reçu le dongle avec un SDK en C++ et un programme de test EXE.
Il me faut absolument une version en Delphi. La conversion parait simple mais ce code est imbuvable et en effet très lourd. Je n'ai pas d'autre solution pour l'instant.

Voici ce que j'ai fait. J'ai essayé de ne rien supprimer du tout de la source pour minimiser le risque d'erreurs.
Le résultat en Delphi ne fonctionne pas : les "ReturnValue1 " et "ReturnValue2" ne correspondent pas aux valeurs attendues.

Je persévère car il n'y a pas trop de code à traduire. Donc je pense que en comparant plusieurs versions traduites par plusieurs personnes j'arriverai au bout ;-)

Code:

1
2
3
4
 
var
  ReturnValue1, ReturnValue2: Word;
  A1, A2L, A2H, A3L, A3H, A4L, A4H : byte;

Code:

1
2
3
4
5
6
 
function RotateLeft8(Target, rotateCount : byte) : byte;
begin
    result:=  ( ((Target shl rotateCount) and $ff) or
             ((Target and $ff) shr (8 - rotateCount))     );
end;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
procedure EncodeArguments(CommandCode, Argument2, Argument3, Argument4 : integer; R1, R2 : byte);
var  Xor1, Xor2 : byte;    // XOR Values
    S1, S2 : byte;    // Slide (rotate left) bit positions of Value
begin
    Xor1 := $d5;
    Xor2 := $2d;
    S1 := $6;
    S2 := $7;
    A1 := LOBYTE(LOWORD(CommandCode)) or ((R2 and $e) shl 4);  // Top 3 bit random
    A2L := RotateLeft8(byte(Argument2 xor ULONG(Xor1)), S1);
    A2H := RotateLeft8(HIBYTE(LOWORD(Argument2)),byte(Xor2 and $7)) xor Xor2 xor R1;
    A3L := RotateLeft8(byte(Argument3 xor ULONG(R2) xor ULONG(R1)), S2);
    A3H := RotateLeft8( R1, S2) xor (HIBYTE(LOWORD(Argument3))) xor Xor1;
    A4L := RotateLeft8( R2, S1) xor (LOBYTE(LOWORD(Argument4))) xor Xor2;
    A4H := RotateLeft8(byte(Xor1 xor Xor2), S1) xor (HIBYTE(LOWORD(Argument4)));
end;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
procedure KTASK(CommandCode, Argument2, Argument3, Argument4 : integer);
var    ReturnValue : LongInt;
    RV1Lo, RV1Hi, RV2Lo, RV2Hi, Temp1Lo, Temp1Hi, Temp2Lo, Temp2Hi : byte;
    R1, R2 : byte;            // Random Numbers
    S1, S2 : byte;        // Byte rotation counts
    Xor1, Xor2 : byte ;        // XOR Values
begin
    Xor1 := $d5;
    Xor2 := $2d;
    S1 := $6;
    S2 := $7;
    R1 := random(255);
    R2 := random(255);
    EncodeArguments( CommandCode, Argument2, Argument3, Argument4, R1, R2);
    RV1Lo := RotateLeft8(Temp1Lo, S2) xor R1;
    RV1Hi := RotateLeft8(Temp1Hi, S1) xor R2;
    RV2Lo := RotateLeft8(byte(Temp2Lo xor Xor2 xor R1), S1);
    RV2Hi := RotateLeft8(byte(Temp2Hi xor Xor1 xor R2), S2);
    ReturnValue1 := ((word(RV1Hi) shl 8) or (word(RV1Lo) and $ff)) and $ffff;
    ReturnValue2 := ((word(RV2Hi) shl 8) or (word(RV2Lo) and $ff)) and $ffff;
end;

19/07/2018, 11h00
ShaiLeTroll

Citation:

Envoyé par Guilli777

Le résultat en Delphi ne fonctionne pas : les "ReturnValue1 " et "ReturnValue2" ne correspondent pas aux valeurs attendues.

En même temps, tester un code qui utilise des valeurs aléatoires comme base de calcul, ce n'est pas gagné
19/07/2018, 16h35
Guilli777

Solution ultime et certainement plus fiable et simple : j'ai écrit une DLL en C++ que j'appelle à partir de Delphi.