Détecter un compte admin (différence W7 et W10)

**pascal07** · 31/12/2018, 10h49

Bonjour à tous

je cherche à faire une fonction pour savoir si l'utilisateur connecté est un compte admin.

J'ai trouvé un code ( voir plus bas ) sur le net, qui fonctionne bien sous Windows 7 avec Delphi 10.2.3 ( Tokyo ).

==> Fonction IsAdminLoggedOn.

Sur un autre de mes PC, sous Windows 10, si je compile le même code ( avec le même Delphi 10.2.3 ) il ne fonctionne pas : un compte Admin n'est pas détecté comme tel.

Pourquoi ? Utilisation d'API windows ?

Sinon, comment savoir si un compte est admin ( fiable ) ?

C'est quand même pénible ce genre de comportement...en 2018, il faut encore galérer juste pour savoir si un compte est admin...
Puis vérifier si ça marche sous tous les windows...et aussi selon l'OS du compilateur ...

Ha les joies de la prog ! ;-)

Merci & Bonne année 2019 à tous :-)

le code:

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
function IsAdminLoggedOn: Boolean;
 
 
implementation
 
function IsMemberOfGroup(const DomainAliasRid: DWORD): Boolean;
{ Returns True if the logged-on user is a member of the specified local
  group. Always returns True on Windows 9x/Me. }
 
{$DEFINE  Delphi3orHigher}
 
const
  SECURITY_NT_AUTHORITY: TSIDIdentifierAuthority =
    (Value: (0, 0, 0, 0, 0, 5));
  SECURITY_BUILTIN_DOMAIN_RID = $00000020;
  SE_GROUP_ENABLED           = $00000004;
  SE_GROUP_USE_FOR_DENY_ONLY = $00000010;
var
  Sid: PSID;
  CheckTokenMembership: function(TokenHandle: THandle; SidToCheck: PSID;
    var IsMember: BOOL): BOOL; stdcall;
  IsMember: BOOL;
  Token: THandle;
  GroupInfoSize: DWORD;
  GroupInfo: PTokenGroups;
  I: Integer;
begin
  if Win32Platform <> VER_PLATFORM_WIN32_NT then begin
    Result := True;
    Exit;
  end;
 
  Result := False;
 
  if not AllocateAndInitializeSid(SECURITY_NT_AUTHORITY, 2,
     SECURITY_BUILTIN_DOMAIN_RID, DomainAliasRid,
     0, 0, 0, 0, 0, 0, Sid) then
    Exit;
  try
    { Use CheckTokenMembership if available. MSDN states:
      "The CheckTokenMembership function should be used with Windows 2000 and
      later to determine whether a specified SID is present and enabled in an
      access token. This function eliminates potential misinterpretations of
      the active group membership if changes to access tokens are made in
      future releases." }
    CheckTokenMembership := nil;
    if Lo(GetVersion) >= 5 then
      CheckTokenMembership := GetProcAddress(GetModuleHandle(advapi32),
        'CheckTokenMembership');
    if Assigned(CheckTokenMembership) then begin
      if CheckTokenMembership(0, Sid, IsMember) then
        Result := IsMember;
    end
    else begin
      GroupInfo := nil;
      if not OpenThreadToken(GetCurrentThread, TOKEN_QUERY, True,
         {$IFDEF Delphi3orHigher}Token{$ELSE}@Token{$ENDIF}) then
        begin
        if GetLastError <> ERROR_NO_TOKEN then
          Exit;
        if not OpenProcessToken(GetCurrentProcess, TOKEN_QUERY,
           {$IFDEF Delphi3orHigher} Token {$ELSE} @Token {$ENDIF}) then
          Exit;
      end;
      try
        GroupInfoSize := 0;
        if not GetTokenInformation(Token, TokenGroups, nil, 0, GroupInfoSize) and
           (GetLastError <> ERROR_INSUFFICIENT_BUFFER) then
          Exit;
 
        GetMem(GroupInfo, GroupInfoSize);
        if not GetTokenInformation(Token, TokenGroups, GroupInfo,
           GroupInfoSize, GroupInfoSize) then
          Exit;
 
        for I := 0 to GroupInfo.GroupCount-1 do begin
          if EqualSid(Sid, GroupInfo.Groups[I].Sid) and
             (GroupInfo.Groups[I].Attributes and (SE_GROUP_ENABLED or
              SE_GROUP_USE_FOR_DENY_ONLY) = SE_GROUP_ENABLED) then begin
            Result := True;
            Break;
          end;
        end;
      finally
        FreeMem(GroupInfo);
        CloseHandle(Token);
      end;
    end;
  finally
    FreeSid(Sid);
  end;
end;
 
function IsAdminLoggedOn: Boolean;
{ Returns True if the logged-on user is a member of the Administrators local
  group. Always returns True on Windows 9x/Me. }
const
  DOMAIN_ALIAS_RID_ADMINS = $00000220;
begin
  Result := IsMemberOfGroup(DOMAIN_ALIAS_RID_ADMINS);
end;

**Andnotor** · 31/12/2018, 18h00

Tu devrais avoir le même comportement sous Win7 à moins que l'UAC soit désactivé.

Un admin n'a que des droits limités (un jeton "compte limité") tant qu'il n'y a pas eu d'élévation de privilèges. C'est seulement après l'élévation que tous les droits lui sont accordés (le jeton "administrateur").
La fonction CheckTokenMembership (comme son nom ne l'indique pas) teste le jeton actuel de l'utilisateur et non son appartenance à un groupe (mais c'était le cas avant Vista puisque l'admin n'avait qu'un seul jeton à cette époque). Elle retourne donc une information différente en fonction de l'élévation.

Ce que tu aimerais correspond à la deuxième partie de ta fonction. A l'aide de GetTokenInformation tu peux effectivement t'assurer que l'utilisateur fait partie du groupe administrateur.
Il suffit donc de scinder cette fonction en deux : IsAdmin et IsAdminGroup.

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
const
  SECURITY_NT_AUTHORITY :TSIDIdentifierAuthority = (Value: (0, 0, 0, 0, 0, 5));
  SECURITY_BUILTIN_DOMAIN_RID = $00000020;
  DOMAIN_ALIAS_RID_ADMINS     = $00000220;
 
function IsAdmin :boolean;
var
  CheckTokenMembership :function(TokenHandle: THandle; SidToCheck: PSID; var IsMember: BOOL): BOOL; stdcall;
  DLL      :THandle;
  SID      :Pointer;
  IsMember :BOOL;
 
begin
  Result := FALSE;
 
  if AllocateAndInitializeSid(SECURITY_NT_AUTHORITY, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, SID) then
  try
    DLL := LoadLibrary(advapi32);
 
    if DLL <> 0 then
    try
      CheckTokenMembership := GetProcAddress(DLL, 'CheckTokenMembership');
 
      if Assigned(CheckTokenMembership)         and
         CheckTokenMembership(0, SID, IsMember) then
        Result := IsMember;
 
    finally
      FreeLibrary(DLL);
    end;
 
  finally
    FreeSid(SID);
  end;
end;
 
function IsAdminGroup: boolean;
var
  Token  :THandle;
  Groups :PTokenGroups;
  Len    :dword;
  SID    :pointer;
  i      :integer;
 
begin
  if not OpenProcessToken(GetCurrentProcess, TOKEN_READ, Token) then Exit(FALSE);
 
  try
    GetTokenInformation(Token, TokenGroups, nil, 0, Len);
    GetMem(Groups, Len);
 
    try
      if not GetTokenInformation(Token, TokenGroups, Groups, Len, Len) then Exit(FALSE);
      if not AllocateAndInitializeSid(SECURITY_NT_AUTHORITY, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, SID) then Exit(FALSE);
 
      try
        for i := 0 to Groups.GroupCount -1 do
          if EqualSID(SID, Groups.Groups[i].Sid) then
            Exit(TRUE);
 
        Result := FALSE;
 
      finally
        FreeSID(SID);
      end;
 
    finally
      FreeMem(Groups);
    end;
 
  finally
    CloseHandle(Token);
  end;
end;

Bien sûr, si tu dois accéder à des emplacements protégés sur le disque ou en BdR, il faut obligatoirement te baser sur IsAdmin. IsAdminGroup est surtout informatif.

Bonne année à tous

**pascal07** · 02/01/2019, 11h47

Bonjour & Bonne année 2019 :-)

Que viens faire l'UAC la dedans ? Désactivé ou pas, ça ne change pas la réponse à la question " l'utilisateur connecté est il admin ? , non ?

Sinon, résultats sur ta proposition, scinder la fonction:

Sous Windows 7 ( Delphi + le code test ) : tout OK, UAC désactivé

Sous Windows 10 ( Delphi + le code test ) , UAC désactivé : IsAdmin : ne fonctionne pas, IsAdminGroup : OK

Réponse pas simple pour une question simple...

Merci, Pascal

**Andnotor** · 03/01/2019, 00h37

Envoyé par pascal07

Que viens faire l'UAC la dedans ?

C'est le douanier qui contrôle que ton visa est valide (même si toi tu le sais pertinemment)

Envoyé par pascal07

l'utilisateur connecté est il admin ?

La question ne se pose pas/plus vraiment en ces termes, ce serait plutôt " l'utilisateur connecté peut-il recevoir des droits administrateurs ? "

Envoyé par pascal07

Sous Windows 7 ( Delphi + le code test ) : tout OK, UAC désactivé
Sous Windows 10 ( Delphi + le code test ) , UAC désactivé : IsAdmin : ne fonctionne pas, IsAdminGroup : OK

Il y a effectivement une différence de comportement avec l'UAC réglé au minimum. Sans doute depuis Windows 8 et les Universal Apps qui ne fonctionnent tout simplement pas sans lui.

Mais UAC réglé au minimum ne veut pas dire désactivé. Pour cela, il faut modifier les stratégies de sécurité : gpedit.msc -> Stratégies locales -> Options de sécurité -> Contrôle de compte d’utilisateur : exécuter le comptes d'administrateurs en mode d'approbation d'administrateur (suivi d'un redémarrage bien sûr).

**pascal07** · 04/01/2019, 10h47

Bonjour

N’empêche que je ne comprend pas, pourquoi sous Windows10:

- Le compte admin utilisé pour compiler ( avec Delphi 10.2 Tokyo ) et tester est dans le groupe Admin ( fonction IsAdminGroup ) mais n'est pas admin ( fonction IsAdmin )

pour moi c'est contradictoire, non ?

Si les membres du groupe Admin ne sont pas admin...

Merci

Pascal