Réponse différente entre Win32 et Win64 !

**der§en** · 18/07/2024, 16h22

Bonjour j'ai un résultat différent en fonction si je compile en Win32 ou en Win64 sur l'API GetTokenInformation dans la fonction suivante !

Auriez-vous une idée du pourquoi de ce étrange phénomène ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
function TForm1.IsProcessOwnedByUser(ProcessID: Cardinal): Boolean;
var
  hToken: NativeUInt;
  TokenInformation: array[0..1023] of Byte;
  TokenUser: PTokenUser;
  dwSize: Cardinal;
  hProcess: NativeUInt;
  UserSID: SID_NAME_USE;
  LResult: LongBool;
  AccountName: array[0..255] of WideChar;
  DomainName: array[0..255] of WideChar;
  cbAccountName, cbDomainName: Cardinal;
  CurrentUserName: String;
begin
  Result := False;
 
  hProcess := OpenProcess(PROCESS_QUERY_INFORMATION, False, ProcessID);
 
  if hProcess = 0 then
    Exit;
 
  try
    if OpenProcessToken(hProcess, TOKEN_QUERY, hToken) then
    try
      dwSize := SizeOf(TokenInformation);
 
      LResult := GetTokenInformation(hToken, TTokenInformationClass.TokenUser, @TokenInformation, dwSize, dwSize);
 
      if LResult then
      begin
        TokenUser     := PTokenUser(@TokenInformation);
        cbAccountName := SizeOf(AccountName);
        cbDomainName  := SizeOf(DomainName);
 
        LookupAccountSid(nil, TokenUser.User.Sid, AccountName, cbAccountName, DomainName, cbDomainName, UserSID);
 
        CurrentUserName := GetCurrentUserName;
        Result          := CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE, AccountName, -1, PChar(CurrentUserName), -1) = CSTR_EQUAL;
      end;
    finally
      CloseHandle(hToken);
    end;
  finally
    CloseHandle(hProcess);
  end;
end;

**ShaiLeTroll** · 18/07/2024, 17h30

je n'utiliserais pas dwSize pour TokenInformationLength et ReturnLength, par exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
function IsServiceProcess(): Boolean;
var
  TokenHandle: THandle;
  TokenSessionId: DWORD;
  TokenInformationLength: DWORD;
begin
  Result := False;
  TokenInformationLength := SizeOf(TokenSessionId);
  ReturnLength := 0;
  if not OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, TokenHandle) then
    Exit;
 
  try
    if not GetTokenInformation(TokenHandle, TTokenInformationClass.TokenSessionId, @TokenSessionId, TokenInformationLength, ReturnLength) then
      RaiseLastOSError();
 
    if ReturnLength = 0 then
      Exit;
 
    Result := TokenSessionId = 0;
  finally
    CloseHandle(TokenHandle);
  end;
end;

Mais c'est quoi différent ?
Après tout, le 32bit est émulé, qu'il y ait une différence, n'est pas si surprenant, cela peut émuler des valeurs telles qu'elles étaient dans une version antérieure de l'OS

**Andnotor** · 18/07/2024, 18h33

Je laisserais GetTokenInformation retourner la taille nécessaire plutôt que la fixer en dur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if GetTokenInformation(hToken, TokenUser, nil, 0, dwSize) or (GetLastError = ERROR_INSUFFICIENT_BUFFER) then

et ensuite seulement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
TokenInformation := GetMem(dwSize);
 
if not GetTokenInformation(hToken, TokenUser, TokenInformation, dwSize, dwSize) then Exit;
 
...

**sergio_is_back** · 18/07/2024, 19h46

Comme le demande ShaiLeTroll en quoi le résultat est-il différent, ce serai intéressant que tu nous donnes l'information...

**der§en** · 18/07/2024, 20h30

Sur les mêmes processus, en WIN32, la réponse LRresult est à TRUE et en Win64, LRresult est à FALSE !

Mon système est en Win64, et mon Delphi est le 11.2.

Je vais regarder à améliorer mon code avec vos remontées.

**ShaiLeTroll** · 19/07/2024, 09h27

Envoyé par der§en

Sur les mêmes processus, en WIN32, la réponse LRresult est à TRUE et en Win64, LRresult est à FALSE !

d'où le RaiseLastOSError(); pour avoir une information complémentaire

et la variante en deux temps avec ERROR_INSUFFICIENT_BUFFER pour vérifier la taille du buffer, si pour TokenSessionId qui est toujours un DWORD pour TokenUser qui retourne un TOKEN_USER, ce n'est pas une mauvaise idée même si en utilisant directement un TTokenUser

**Andnotor** · 19/07/2024, 09h34

Un petit essai ce matin et effectivement il y a un problème d'accès à la pile en 64 bits. Donc passer par GetMem.

Juste pour confirmation, déclarer TokenInformation en variable globale et là ça passe.

**ShaiLeTroll** · 19/07/2024, 10h03

Envoyé par Andnotor

Un petit essai ce matin et effectivement il y a un problème d'accès à la pile en 64 bits. Donc passer par GetMem

Et a noter que le buffer allouée fait 36 et 44 selon 32/64 bits, cela doit être la place pour allouer le pointer de type PSID : https://learn.microsoft.com/fr-fr/wi...t/ns-winnt-sid

Dans ce cas ça devient (j'ai utilisé ma version de GetCurrentUserName n'ayant pas celle utilisée par der§en)

On peut directement le pointer PTokenUser mais en l'allouant manuellement à la taille requise pour les pointeurs imbriqués

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
function IsProcessOwnedByUser(ProcessID: Cardinal): Boolean;
 
  function GetTokenUser(ATokenHandle: THandle): PTokenUser;
  var
    TokenInformationLength, ReturnLength: DWORD;
    LastError: DWORD ;
  begin
    TokenInformationLength := SizeOf(Result);
    ReturnLength := 0;
    GetTokenInformation(ATokenHandle, TTokenInformationClass.TokenUser, nil, 0, ReturnLength);
    LastError := GetLastError();
    if (LastError = ERROR_INSUFFICIENT_BUFFER) and (TokenInformationLength <= ReturnLength) then
    begin
      GetMem(Result, ReturnLength);
      try
        if not GetTokenInformation(ATokenHandle, TTokenInformationClass.TokenUser, Result, ReturnLength, ReturnLength) then
          RaiseLastOSError();
      except
        FreeMem(Result);
        raise;
      end;
    end
    else
      RaiseLastOSError(LastError);
  end;
 
  procedure ReleaseTokenUser(var ATokenUser: PTokenUser);
  begin
    FreeMem(ATokenUser);
    ATokenUser := nil;
  end;
 
  type
    _USER_NAME_FORMAT = (NameUnknown,
      NameFullyQualifiedDN, NameSamCompatible,
      NameDisplay, NameUniqueId = 6,
      NameCanonical, NameUserPrincipal,
      NameCanonicalEx, NameServicePrincipal,
      NameDnsDomain = 12);
    TUserNameFormat = _USER_NAME_FORMAT;
 
  const
    Secur32 = 'Secur32.dll';
    UNLEN = 256; // A buffer size of (UNLEN + 1) characters will hold the maximum length user name including the terminating null character. UNLEN is defined in Lmcons.h.
 
  function GetCurrentUserName(NameFormat: TUserNameFormat = NameUnknown): string;
  var
    AccountName: array[0..UNLEN] of WideChar;
    cbAccountName: DWORD;
    Secur32H: HMODULE;
    GetUserNameEx: function(NameFormat: TUserNameFormat; lpBuffer: PWideChar; var nSize: DWORD): BOOL; stdcall;
  begin
    Result := '';
    cbAccountName := MAX_PATH;
    if NameFormat <> NameUnknown then
    begin
      Secur32H := LoadLibrary(Secur32);
      if Secur32H <> 0 then
      try
        GetUserNameEx := GetProcAddress(Secur32H, 'GetUserNameExW');
        if Assigned(GetUserNameEx) and GetUserNameEx(NameFormat, AccountName, cbAccountName) then
          Result := AccountName;
      finally
        FreeLibrary(Secur32H);
      end;
    end
    else
      if GetUserName(AccountName, cbAccountName) then
        Result := AccountName;
  end;
 
 
var
  hProcess: THandle;
  hToken: THandle;
  TokenUser: PTokenUser;
 
  UserSID: SID_NAME_USE;
  AccountName: array[0..255] of WideChar;
  DomainName: array[0..255] of WideChar;
  cbAccountName, cbDomainName: Cardinal;
  CurrentUserName: String;
begin
  Result := False;
 
  hProcess := OpenProcess(PROCESS_QUERY_INFORMATION, False, ProcessID);
  if hProcess = 0 then
    Exit;
 
  try
    if OpenProcessToken(hProcess, TOKEN_QUERY, hToken) then
    try
      TokenUser := GetTokenUser(hToken);
      try
        cbAccountName := SizeOf(AccountName);
        cbDomainName  := SizeOf(DomainName);
 
        LookupAccountSid(nil, TokenUser.User.Sid, AccountName, cbAccountName, DomainName, cbDomainName, UserSID);
 
        CurrentUserName := GetCurrentUserName();
        Result          := CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE, AccountName, -1, PChar(CurrentUserName), -1) = CSTR_EQUAL;
      finally
        ReleaseTokenUser(TokenUser);
      end;
    finally
      CloseHandle(hToken);
    end;
  finally
    CloseHandle(hProcess);
  end;
end;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
procedure TForm1.Button3Click(Sender: TObject);
begin
  ShowMessage(BoolToStr(IsProcessOwnedByUser(GetCurrentProcessId()), True));
end;

Une autre variante un peu plus simple mais j'ai peur que cela invalide les pointeurs imbriqués comme SID

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
function IsProcessOwnedByUser(ProcessID: Cardinal): Boolean;
 
  function GetTokenUser(TokenHandle: THandle): TTokenUser;
  var
    TokenInformationLength, ReturnLength: DWORD;
    TokenInformation: Pointer;
    LastError: DWORD ;
  begin
    TokenInformationLength := SizeOf(Result);
    ReturnLength := 0;
    GetTokenInformation(TokenHandle, TTokenInformationClass.TokenUser, nil, 0, ReturnLength);
    LastError := GetLastError();
    if (LastError = ERROR_INSUFFICIENT_BUFFER) and (TokenInformationLength <= ReturnLength) then
    begin
      GetMem(TokenInformation, ReturnLength);
      try
        if GetTokenInformation(TokenHandle, TTokenInformationClass.TokenUser, TokenInformation, ReturnLength, ReturnLength) then
          Result := PTokenUser(TokenInformation)^
        else
          RaiseLastOSError();
      finally
        FreeMem(TokenInformation);
      end;
    end
    else
      RaiseLastOSError(LastError);
  end;
 
  type
    _USER_NAME_FORMAT = (NameUnknown,
      NameFullyQualifiedDN, NameSamCompatible,
      NameDisplay, NameUniqueId = 6,
      NameCanonical, NameUserPrincipal,
      NameCanonicalEx, NameServicePrincipal,
      NameDnsDomain = 12);
    TUserNameFormat = _USER_NAME_FORMAT;
 
  const
    Secur32 = 'Secur32.dll';
    UNLEN = 256; // A buffer size of (UNLEN + 1) characters will hold the maximum length user name including the terminating null character. UNLEN is defined in Lmcons.h.
 
  function GetCurrentUserName(NameFormat: TUserNameFormat = NameUnknown): string;
  var
    AccountName: array[0..UNLEN] of WideChar;
    cbAccountName: DWORD;
    Secur32H: HMODULE;
    GetUserNameEx: function(NameFormat: TUserNameFormat; lpBuffer: PWideChar; var nSize: DWORD): BOOL; stdcall;
  begin
    Result := '';
    cbAccountName := MAX_PATH;
    if NameFormat <> NameUnknown then
    begin
      Secur32H := LoadLibrary(Secur32);
      if Secur32H <> 0 then
      try
        GetUserNameEx := GetProcAddress(Secur32H, 'GetUserNameExW');
        if Assigned(GetUserNameEx) and GetUserNameEx(NameFormat, AccountName, cbAccountName) then
          Result := AccountName;
      finally
        FreeLibrary(Secur32H);
      end;
    end
    else
      if GetUserName(AccountName, cbAccountName) then
        Result := AccountName;
  end;
 
 
var
  hProcess: THandle;
  hToken: THandle;
  TokenUser: TTokenUser;
 
  UserSID: SID_NAME_USE;
  AccountName: array[0..255] of WideChar;
  DomainName: array[0..255] of WideChar;
  cbAccountName, cbDomainName: Cardinal;
  CurrentUserName: String;
begin
  Result := False;
 
  hProcess := OpenProcess(PROCESS_QUERY_INFORMATION, False, ProcessID);
  if hProcess = 0 then
    Exit;
 
  try
    if OpenProcessToken(hProcess, TOKEN_QUERY, hToken) then
    try
      TokenUser     := GetTokenUser(hToken);
      cbAccountName := SizeOf(AccountName);
      cbDomainName  := SizeOf(DomainName);
 
      LookupAccountSid(nil, TokenUser.User.Sid, AccountName, cbAccountName, DomainName, cbDomainName, UserSID);
 
      CurrentUserName := GetCurrentUserName();
      Result          := CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE, AccountName, -1, PChar(CurrentUserName), -1) = CSTR_EQUAL;
    finally
      CloseHandle(hToken);
    end;
  finally
    CloseHandle(hProcess);
  end;
end;

**der§en** · 19/07/2024, 14h53

Merci a vous 3 pour l'aide apporté a la résolution de mon problème

Réponse différente entre Win32 et Win64 !

Delphi

Discussions similaires

Partager

Partager