17 respuestas en este tema

[escafandra]

He continuado jugando con la APINative Wifi y se me ocurrió una interesante aplicación que extrajese las Password de las redes Wifi configuradas en el PC. ¿A quién no se le ha olvidado uno y le interesa conectarse desde un smartphone o tablet?. Aquí está la solución.
Debo comentar que la dificultad está en S.O. anteriores a Vista, pues en los posteriores no estamos obligados a desencriptar la pasword pues existe una opción para que la API nos devuelva la clave plana. Pero como no he querido olvidar al viejo XP, me he puesto a desencriptar, para lo que debemos suplantar el contexto de seguridad de winlogon.exe y esto requiere ejecutar la aplicación como administrador.

Aprovechando algunas definiciones y APIs descritas aquí y añadiendo algunas más, el código queda como sigue:

delphi

function EnablePrivilege(name: String; Enable: boolean = true): boolean;
var
  hToken: THANDLE;
  priv: TOKEN_PRIVILEGES;
begin
  priv.PrivilegeCount:= 1;
  priv.Privileges[0].Attributes:= 0;
  if Enable then priv.Privileges[0].Attributes:= SE_PRIVILEGE_ENABLED;
  LookupPrivilegeValue(nil, PCHAR(name), priv.Privileges[0].Luid);
  OpenProcessToken(GetCurrentProcess, TOKEN_ADJUST_PRIVILEGES, hToken);
  AdjustTokenPrivileges (hToken, FALSE, priv, sizeof(priv), nil, PDWORD(nil)^);
  Result:= (GetLastError = ERROR_SUCCESS);
  CloseHandle (hToken);
end;
 
function GetProcessId(FileName: String): DWORD;
var
   proc: TProcessEntry32;
   hSysSnapshot: THandle;
begin
   proc.dwSize := SizeOf(TProcessEntry32);
   hSysSnapshot:= CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
   if (hSysSnapshot <> INVALID_HANDLE_VALUE) and Process32First(hSysSnapshot, proc) then
   begin
     repeat
       if String(proc.szExeFile) = FileName then
       begin
         Result:= proc.th32ProcessID;
         break;
       end;
     until not (Process32Next(hSysSnapshot, proc));
   end;
   CloseHandle(hSysSnapshot);
end;
 
function ImpersonateToLoginUser: BOOL;
var
  hProcess, hToken: THANDLE ;
  ID: DWORD;
begin
  Result:= false;
  ID:= GetProcessID ('winlogon.exe');
  if ID > 0 then
  begin
    hProcess:= OpenProcess (MAXIMUM_ALLOWED, FALSE, ID);
    if hProcess <> INVALID_HANDLE_VALUE then
    begin
      Result:= OpenProcessToken(hProcess, MAXIMUM_ALLOWED, hToken);
      if Result then
      begin
        EnablePrivilege('SeDebugPrivilege');
        Result:= ImpersonateLoggedOnUser(hToken);
        CloseHandle(hToken);
      end;
      CloseHandle (hProcess);
    end;
  end;
end;
 
function ExtractKey(XMLText: String): String;
var
  ini, fin: integer;
begin
  Result:= '';
  ini:= Pos('<keyMaterial>', XMLText);
  fin:= Pos('</keyMaterial>', XMLText);
  if (ini <> -1) and (fin <> -1) then
  begin
    ini:= ini + Length('<keyMaterial>');
    Result:= Copy(XMLText, ini, fin-ini);
  end;
end;
 
function DecryptData(Key: String): String;
var
  Buffer: array [0..1023] of BYTE;
  Len: DWORD;
  DataIn, DataOut: TDATA_BLOB;
begin
  Result:= Key;
  Len:= 1024;
  ImpersonateToLoginUser;
  if CryptStringToBinary(PCHAR(Key), Length(Key), CRYPT_STRING_HEX, @Buffer[0], @Len, 0, 0) then
  begin
    DataIn.cbData:= Len;
    DataIn.pbData:= @Buffer[0];
    DataOut.cbData:= 0;
    DataOut.pbData:= nil;
    if CryptUnprotectData (@DataIn, nil, nil, nil, nil, 0, @DataOut) then
      Result:= PCHAR(DataOut.pbData);
  end;
  RevertToSelf;
end;
 
function WifiGetPassWords: String;
var
  hClient: THandle;
  dwVersion: DWORD;
  pInterfaceInfoList: PWLAN_INTERFACE_INFO_LIST;
  pInterfaceGuid: PGUID;
  pProfileList: PWLAN_PROFILE_INFO_LIST;
  pstrProfileXml: PWCHAR;
  dwFlags: DWORD;
  dwGrantedAccess: DWORD;
  i,j: integer;
begin
  Result:= '';
  if ERROR_SUCCESS = WlanOpenHandle(1, nil, @dwVersion, @hClient) then
  begin
    if ERROR_SUCCESS = WlanEnumInterfaces(hClient, nil, @pInterfaceInfoList) then
    begin
      for i:= 0 to pInterfaceInfoList^.dwNumberOfItems - 1 do
      begin
        pInterfaceGuid:= @pInterfaceInfoList^.InterfaceInfo[pInterfaceInfoList^.dwIndex].InterfaceGuid;
        if ERROR_SUCCESS = WlanGetProfileList(hClient, pInterfaceGuid, nil, @pProfileList) then
        begin
          for j:=0 to pProfileList.dwNumberOfItems-1 do
          begin
            if ERROR_SUCCESS = WlanGetProfile(hClient,	pInterfaceGuid, pProfileList.ProfileInfo[j].strProfileName, nil, @pstrProfileXml, @dwFlags, @dwGrantedAccess) then
            begin
              Result:= Result + String(pProfileList.ProfileInfo[j].strProfileName) + ': '+ DecryptData(ExtractKey(String(pstrProfileXml))) + #13 + #10;
              WlanFreeMemory(pstrProfileXml);
            end;
          end;
        end;
        WlanFreeMemory(pProfileList);
      end;
      WlanFreeMemory(pInterfaceInfoList);
    end;
    WlanCloseHandle(hClient, nil);
  end;
end;

La forma de uso:

delphi

var
  Keys: String;
begin
  Keys:= WifiGetPassWords;
end;

Espero que sea de utilidad.
Subo un proyecto completo.
 
 
Saludos.

PD: he actualizado el código aquí.

Archivos adjuntos

•  GetWifiPass.rar   162,37KB   56 descargas

[enecumene]

Bravo Maestro!!

[Wilson]

Descargado ...  Muchas gracias maestro.

 

Un cordial saludo.

[poliburro]

Que interesante código nos has compartido amigo.

 

Muchas gracias por ello. Saludos

[escafandra]

Con una pequeña modificación podemos ejecutar como usuario no administrador en S.O. mayores de Vista y nos dará las claves directamente sin necesidad de desencriptarlas.

delphi

function WifiGetPassWords: String;
var
  hClient: THandle;
  dwVersion: DWORD;
  pInterfaceInfoList: PWLAN_INTERFACE_INFO_LIST;
  pInterfaceGuid: PGUID;
  pProfileList: PWLAN_PROFILE_INFO_LIST;
  pstrProfileXml: PWCHAR;
  dwFlags: DWORD;
  dwGrantedAccess: DWORD;
  i,j: integer;
begin
  Result:= '';
  dwFlags:= 0;
  dwGrantedAccess:= 0;
 
  if ERROR_SUCCESS = WlanOpenHandle(1, nil, @dwVersion, @hClient) then
  begin
    if ERROR_SUCCESS = WlanEnumInterfaces(hClient, nil, @pInterfaceInfoList) then
    begin
      for i:= 0 to pInterfaceInfoList^.dwNumberOfItems - 1 do
      begin
        pInterfaceGuid:= @pInterfaceInfoList^.InterfaceInfo[pInterfaceInfoList^.dwIndex].InterfaceGuid;
        if ERROR_SUCCESS = WlanGetProfileList(hClient, pInterfaceGuid, nil, @pProfileList) then
        begin
          for j:=0 to pProfileList.dwNumberOfItems-1 do
          begin
            dwFlags:= WLAN_PROFILE_GET_PLAINTEXT_KEY;
            if ERROR_SUCCESS = WlanGetProfile(hClient,	pInterfaceGuid, pProfileList.ProfileInfo[j].strProfileName, nil, @pstrProfileXml, @dwFlags, @dwGrantedAccess) then
            begin
              Result:= Result + String(pProfileList.ProfileInfo[j].strProfileName) + ': '+ DecryptData(ExtractKey(String(pstrProfileXml))) + #13 + #10;
              WlanFreeMemory(pstrProfileXml);
            end;
          end;
        end;
        WlanFreeMemory(pProfileList);
      end;
      WlanFreeMemory(pInterfaceInfoList);
    end;
    WlanCloseHandle(hClient, nil);
  end;
end;

Subo la actualización, que lo disfrutéis.
 
Saludos.

Archivos adjuntos

•  GetWifiPass2.rar   164,36KB   81 descargas

[egostar]

jojo, a mi me pasa que tengo 3 redes en mi casa (2 repetidores de señal y el router para que alcance en toda la casa la señal) y me preguntan la contraseña de cada una y no me la sé, tengo que sacar mi hoja de contraseñas jajajaja

 

Excelente aporte amigo y sobre todo muy útil

 

Saludos

[escafandra]

jojo, a mi me pasa que tengo 3 redes en mi casa (2 repetidores de señal y el router para que alcance en toda la casa la señal) y me preguntan la contraseña de cada una y no me la sé, tengo que sacar mi hoja de contraseñas jajajaja
 
Excelente aporte amigo y sobre todo muy útil
 
Saludos

Yo también tengo tres, pero los "repetidores Wifi" están configurados como puntos de acceso y conectados al router por cable. Todos los puntos tienen el mismo SSID y la misma clave, así nadie tiene líos esté donde esté dentro de casa y solo tengo una red real desde la que accedo a cualquier PC o dispositivo.

El asunto se me ocurrió para aquellas redes a las que se conectó determinado portátil, fuera de casa, y cuya clave no recuerdo. Obtengo la lista y listo.

 

 

Saludos.

[egostar]

Yo también tengo tres, pero los "repetidores Wifi" están configurados como puntos de acceso y conectados al router por cable. Todos los puntos tienen el mismo SSID y la misma clave, así nadie tiene líos esté donde esté dentro de casa y solo tengo una red real desde la que accedo a cualquier PC o dispositivo.

El asunto se me ocurrió para aquellas redes a las que se conectó determinado portátil, fuera de casa, y cuya clave no recuerdo. Obtengo la lista y listo.

 

 

Saludos.

 

Los que yo tengo son a través de la corriente eléctrica, no se si se puede colocar el mismo SSID, la clave pudiera ponerle la misma a todas, pero cuando las conecté no tenia la contraseña del router a la mano

 

Saludos

[genriquez]

Excelente, felicitaciones y muchas gracias por compartir.

 

Saludos.

[monchito_elroro]

Buenas amigo Escafadra, ante todo muy buen código gracias por compartir , también le solicitaría su ayuda para poder usarlo en lazarus, pues me sale error cuando lo quiero usar. Estos son los errores que me sale:

 

En:

php

AdjustTokenPrivileges (hToken, FALSE, priv, sizeof(priv), nil, PDWORD(nil)^);

Se detiene en "nil" y Sale error:

unit1.pas(104,64) Error: Call by var for arg no. 5 has to match exactly: Got "Pointer" expected "TOKEN_PRIVILEGES"

 

En:

php

if CryptStringToBinary(PCHAR(Key), Length(Key), CRYPT_STRING_HEX, @Buffer[0], @Len, 0, 0) then

Apunta a los "0" y sale:

unit1.pas(177,91) Error: Incompatible type for arg no. 7: Got "ShortInt", expected "PDWord"

 

En:

php

for j:=0 to pProfileList.dwNumberOfItems-1 do

selecciona "dwNumberOfItems" y sale error:

unit1.pas(214,36) Error: Illegal qualifier

 

Por favor si me pueden ayudar.

[escafandra]

Buenas amigo Escafadra, ante todo muy buen código gracias por compartir , también le solicitaría su ayuda para poder usarlo en lazarus, pues me sale error cuando lo quiero usar. Estos son los errores que me sale:
 
En:

delphi

AdjustTokenPrivileges (hToken, FALSE, priv, sizeof(priv), nil, PDWORD(nil)^);

Se detiene en "nil" y Sale error:
unit1.pas(104,64) Error: Call by var for arg no. 5 has to match exactly: Got "Pointer" expected "TOKEN_PRIVILEGES"

 

 
El problema está en la diferente declaración de AdjustTokenPrivileges entre delphi y Lazarus. Hazlo así: 

delphi

AdjustTokenPrivileges (hToken, FALSE, priv, sizeof(priv), PTOKEN_PRIVILEGES(nil)^, PDWORD(nil)^);

 
 

En:

delphi

if CryptStringToBinary(PCHAR(Key), Length(Key), CRYPT_STRING_HEX, @Buffer[0], @Len, 0, 0) then

Apunta a los "0" y sale:
unit1.pas(177,91) Error: Incompatible type for arg no. 7: Got "ShortInt", expected "PDWord"

 

Hazlo de esta manera:

delphi

CryptStringToBinary(PCHAR(Key), Length(Key), CRYPT_STRING_HEX, @Buffer[0], @Len, nil, nil)

En:

delphi

for j:=0 to pProfileList.dwNumberOfItems-1 do

selecciona "dwNumberOfItems" y sale error:
unit1.pas(214,36) Error: Illegal qualifier
 
Por favor si me pueden ayudar.

 

Se debe a que no activaste la compatibilidad con delphi, si no lo quieres hacer, utiliza los miembros de punteros a estructuras o clases con ^.

delphi

for j:=0 to pProfileList^.dwNumberOfItems-1 do

Subo un proyecto Lazarus

 

Saludos.

Archivos adjuntos

•  Lazarus WiffiPass_SCR.rar   125,47KB   32 descargas

[monchito_elroro]

Guauuuuu, amigo Escafandra es usted un GENIO me funciona a la perfección, lo he probado en Win8.1x64 y me funciona perfecto, muchisimas Gracias amigo     .

 

PD: también he visto que ha publicado un post sobre conexiones wifi, me voy a dar el tiempo para poder leerlo con detenimiento y aplicarlo en Lazarus también, saludos con todos.

[escafandra]

Aprovechando que he revisado el tema tras la pregunta de monchito_elroro, voy a subir el mismo proyecto, pero esta vez en C/C++

 

El archivo cabecera C++ es un poco amplio y quizás sobran cosas, pero por pereza he hecho un copy-paste de otro proyecto más amplio y no me apetece borrar cosas 

 
 unit1.h

cpp

//---------------------------------------------------------------------------
 
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
 
 
 
#define WLAN_REASON_CODE_SUCCESS  0
 
#define WLAN_MAX_NAME_LENGTH      256
#define DOT11_SSID_MAX_LENGTH     32
#define WLAN_MAX_PHY_TYPE_NUMBER  8
#define WLAN_AVAILABLE_NETWORK_INCLUDE_ALL_ADHOC_PROFILES  0x00000001
#define WLAN_AVAILABLE_NETWORK_INCLUDE_ALL_MANUAL_HIDDEN_PROFILES  0x00000002
#define WLAN_AVAILABLE_NETWORK_CONNECTED     0x00000001
#define WLAN_AVAILABLE_NETWORK_HAS_PROFILE   0x00000002
#define WLAN_NOTIFICATION_SOURCE_ALL         0x0000FFFF
#define WLAN_NOTIFICATION_SOURCE_ONEX        0x00000004
#define WLAN_NOTIFICATION_SOURCE_ACM         0x00000008
 
#define WLAN_PROFILE_GROUP_POLICY            0x00000001
#define WLAN_PROFILE_USER                    0x00000002
#define WLAN_PROFILE_GET_PLAINTEXT_KEY		   0x00000004
// the following flags are only used for WlanSaveTemporaryProfile API
#define WLAN_PROFILE_CONNECTION_MODE_SET_BY_CLIENT  0x00010000
#define WLAN_PROFILE_CONNECTION_MODE_AUTO           0x00020000
 
 
typedef enum _WLAN_INTERFACE_STATE {
  wlan_interface_state_not_ready              = 0,
  wlan_interface_state_connected              = 1,
  wlan_interface_state_ad_hoc_network_formed  = 2,
  wlan_interface_state_disconnecting          = 3,
  wlan_interface_state_disconnected           = 4,
  wlan_interface_state_associating            = 5,
  wlan_interface_state_discovering            = 6,
  wlan_interface_state_authenticating         = 7
} WLAN_INTERFACE_STATE, *PWLAN_INTERFACE_STATE;
 
 
typedef enum _DOT11_PHY_TYPE {
  dot11_phy_type_unknown     = 0,
  dot11_phy_type_any         = 0,
  dot11_phy_type_fhss        = 1,
  dot11_phy_type_dsss        = 2,
  dot11_phy_type_irbaseband  = 3,
  dot11_phy_type_ofdm        = 4,
  dot11_phy_type_hrdsss      = 5,
  dot11_phy_type_erp         = 6,
  dot11_phy_type_ht          = 7,
  dot11_phy_type_vht         = 8,
  dot11_phy_type_IHV_start   = 0x80000000,
  dot11_phy_type_IHV_end     = 0xffffffff
} DOT11_PHY_TYPE, *PDOT11_PHY_TYPE;
 
typedef enum _DOT11_AUTH_ALGORITHM {
  DOT11_AUTH_ALGO_80211_OPEN        = 1,
  DOT11_AUTH_ALGO_80211_SHARED_KEY  = 2,
  DOT11_AUTH_ALGO_WPA               = 3,
  DOT11_AUTH_ALGO_WPA_PSK           = 4,
  DOT11_AUTH_ALGO_WPA_NONE          = 5,
  DOT11_AUTH_ALGO_RSNA              = 6,
  DOT11_AUTH_ALGO_RSNA_PSK          = 7,
  DOT11_AUTH_ALGO_IHV_START         = 0x80000000,
  DOT11_AUTH_ALGO_IHV_END           = 0xffffffff
} DOT11_AUTH_ALGORITHM, *PDOT11_AUTH_ALGORITHM;
 
typedef enum _DOT11_CIPHER_ALGORITHM {
  DOT11_CIPHER_ALGO_NONE           = 0x00,
  DOT11_CIPHER_ALGO_WEP40          = 0x01,
  DOT11_CIPHER_ALGO_TKIP           = 0x02,
  DOT11_CIPHER_ALGO_CCMP           = 0x04,
  DOT11_CIPHER_ALGO_WEP104         = 0x05,
  DOT11_CIPHER_ALGO_WPA_USE_GROUP  = 0x100,
  DOT11_CIPHER_ALGO_RSN_USE_GROUP  = 0x100,
  DOT11_CIPHER_ALGO_WEP            = 0x101,
  DOT11_CIPHER_ALGO_IHV_START      = 0x80000000,
  DOT11_CIPHER_ALGO_IHV_END        = 0xffffffff
} DOT11_CIPHER_ALGORITHM, *PDOT11_CIPHER_ALGORITHM;
 
typedef struct _DOT11_SSID {
  ULONG uSSIDLength;
  UCHAR ucSSID[DOT11_SSID_MAX_LENGTH];
} DOT11_SSID, *PDOT11_SSID;
 
typedef enum _DOT11_BSS_TYPE {
  dot11_BSS_type_infrastructure  = 1,
  dot11_BSS_type_independent     = 2,
  dot11_BSS_type_any             = 3
} DOT11_BSS_TYPE, *PDOT11_BSS_TYPE;
 
typedef enum _WLAN_CONNECTION_MODE {
  wlan_connection_mode_profile,
  wlan_connection_mode_temporary_profile,
  wlan_connection_mode_discovery_secure,
  wlan_connection_mode_discovery_unsecure,
  wlan_connection_mode_auto,
  wlan_connection_mode_invalid
} WLAN_CONNECTION_MODE, *PWLAN_CONNECTION_MODE;
 
typedef DWORD WLAN_REASON_CODE, *PWLAN_REASON_CODE;
 
//#pragma pack( push )
//#pragma pack( 8 )
typedef struct _WLAN_CONNECTION_NOTIFICATION_DATA {
  WLAN_CONNECTION_MODE wlanConnectionMode;
//  DWORD                wlanConnectionMode;
  WCHAR                strProfileName[WLAN_MAX_NAME_LENGTH];
  DOT11_SSID           dot11Ssid;
  DOT11_BSS_TYPE       dot11BssType;
  BOOL                 bSecurityEnabled;
  WLAN_REASON_CODE     wlanReasonCode;
  DWORD                dwFlags;
  WCHAR                strProfileXml[1];
} WLAN_CONNECTION_NOTIFICATION_DATA, *PWLAN_CONNECTION_NOTIFICATION_DATA;
 
typedef struct _WLAN_INTERFACE_INFO {
  GUID                 InterfaceGuid;
  WCHAR                strInterfaceDescription[256];
  WLAN_INTERFACE_STATE isState;
} WLAN_INTERFACE_INFO, *PWLAN_INTERFACE_INFO;
 
typedef struct _WLAN_INTERFACE_INFO_LIST {
  DWORD               dwNumberOfItems;
  DWORD               dwIndex;
  WLAN_INTERFACE_INFO InterfaceInfo[];
} WLAN_INTERFACE_INFO_LIST, *PWLAN_INTERFACE_INFO_LIST;
 
typedef struct _WLAN_AVAILABLE_NETWORK {
  WCHAR                  strProfileName[256];
  DOT11_SSID             dot11Ssid;
  DOT11_BSS_TYPE         dot11BssType;        //DWORD
  ULONG                  uNumberOfBssids;
  BOOL                   bNetworkConnectable;
  WLAN_REASON_CODE       wlanNotConnectableReason;  //DWORD
  ULONG                  uNumberOfPhyTypes;
  DOT11_PHY_TYPE         dot11PhyTypes[WLAN_MAX_PHY_TYPE_NUMBER];  //DWORD
  BOOL                   bMorePhyTypes;
  //WLAN_SIGNAL_QUALITY    wlanSignalQuality;
  ULONG                  wlanSignalQuality;
  BOOL                   bSecurityEnabled;
  DOT11_AUTH_ALGORITHM   dot11DefaultAuthAlgorithm;    //DWORD
  DOT11_CIPHER_ALGORITHM dot11DefaultCipherAlgorithm;  //DWORD
  DWORD                  dwFlags;
  DWORD                  dwReserved;
} WLAN_AVAILABLE_NETWORK, *PWLAN_AVAILABLE_NETWORK;
 
typedef struct _WLAN_AVAILABLE_NETWORK_LIST {
  DWORD                  dwNumberOfItems;
  DWORD                  dwIndex;
  WLAN_AVAILABLE_NETWORK Network[1];
} WLAN_AVAILABLE_NETWORK_LIST, *PWLAN_AVAILABLE_NETWORK_LIST;
 
typedef struct _NDIS_OBJECT_HEADER {
  UCHAR  Type;
  UCHAR  Revision;
  USHORT Size;
} NDIS_OBJECT_HEADER, *PNDIS_OBJECT_HEADER;
 
typedef UCHAR DOT11_MAC_ADDRESS[6];
typedef DOT11_MAC_ADDRESS* PDOT11_MAC_ADDRESS;
 
typedef struct _DOT11_BSSID_LIST {
  NDIS_OBJECT_HEADER Header;
  ULONG              uNumOfEntries;
  ULONG              uTotalNumOfEntries;
  DOT11_MAC_ADDRESS  BSSIDs[1];
} DOT11_BSSID_LIST, *PDOT11_BSSID_LIST;
 
typedef struct _WLAN_CONNECTION_PARAMETERS {
  WLAN_CONNECTION_MODE wlanConnectionMode; //DWORD
  LPCWSTR              strProfile;         //PWCHAR
  PDOT11_SSID          pDot11Ssid;
  PDOT11_BSSID_LIST    pDesiredBssidList;  //PVOID
  DOT11_BSS_TYPE       dot11BssType;       //DWORD
  DWORD                dwFlags;
} WLAN_CONNECTION_PARAMETERS, *PWLAN_CONNECTION_PARAMETERS;
 
typedef struct _WLAN_NOTIFICATION_DATA {
  DWORD NotificationSource;
  DWORD NotificationCode;
  GUID  InterfaceGuid;
  DWORD dwDataSize;
  PVOID pData;
} WLAN_NOTIFICATION_DATA, *PWLAN_NOTIFICATION_DATA;
 
typedef struct _WLAN_PROFILE_INFO {
  WCHAR strProfileName[256];
  DWORD dwFlags;
} WLAN_PROFILE_INFO, *PWLAN_PROFILE_INFO;
 
typedef struct _WLAN_PROFILE_INFO_LIST {
  DWORD             dwNumberOfItems;
  DWORD             dwIndex;
  WLAN_PROFILE_INFO ProfileInfo[1];
} WLAN_PROFILE_INFO_LIST, *PWLAN_PROFILE_INFO_LIST;
//#pragma pack( pop )
 
 
typedef VOID  (WINAPI *WLAN_NOTIFICATION_CALLBACK)(PWLAN_NOTIFICATION_DATA data,  PVOID context);
 
typedef DWORD (WINAPI *PWlanOpenHandle)(DWORD dwClientVersion, PVOID pReserved, PDWORD  pdwNegotiatedVersion, PHANDLE phClientHandle);
typedef DWORD (WINAPI *PWlanCloseHandle)(HANDLE hClientHandle, PVOID pReserved);
typedef DWORD (WINAPI *PWlanEnumInterfaces)(HANDLE hClientHandle, PVOID pReserved, PWLAN_INTERFACE_INFO_LIST *ppInterfaceList);
typedef DWORD (WINAPI *PWlanGetAvailableNetworkList)(HANDLE hClientHandle, const GUID *pInterfaceGuid, DWORD dwFlags, PVOID pReserved, PWLAN_AVAILABLE_NETWORK_LIST *ppAvailableNetworkList);
typedef PVOID (WINAPI *PWlanAllocateMemory)(DWORD dwMemorySize);
typedef VOID  (WINAPI *PWlanFreeMemory)(PVOID pMemory);
typedef DWORD (WINAPI *PWlanConnect)(HANDLE hClientHandle, const GUID *pInterfaceGuid, const PWLAN_CONNECTION_PARAMETERS pConnectionParameters, PVOID pReserved);
typedef DWORD (WINAPI *PWlanDisconnect)(HANDLE hClientHandle, const GUID *pInterfaceGuid, PVOID pReserved);
typedef DWORD (WINAPI *PWlanRegisterNotification)(HANDLE hClientHandle, DWORD dwNotifSource, BOOL bIgnoreDuplicate, WLAN_NOTIFICATION_CALLBACK funcCallback, PVOID pCallbackContext, PVOID pReserved, PDWORD pdwPrevNotifSource);
typedef DWORD (WINAPI *PWlanSetProfile)(HANDLE hClientHandle, const GUID *pInterfaceGuid, DWORD dwFlags, LPCWSTR strProfileXml, LPCWSTR strAllUserProfileSecurity, BOOL bOverwrite, PVOID pReserved, PDWORD dwReasonCode);
typedef DWORD (WINAPI *PWlanDeleteProfile)(HANDLE hClientHandle, const GUID *pInterfaceGuid, LPCWSTR strProfileName, PVOID pReserved);
typedef DWORD (WINAPI *PWlanGetProfile)(HANDLE hClientHandle, const GUID *pInterfaceGuid, LPCWSTR strProfileName, PVOID pReserved, LPWSTR* pstrProfileXml, PDWORD pdwFlags, PDWORD pdwGrantedAccess);
typedef DWORD (WINAPI *PWlanReasonCodeToString)(DWORD dwReasonCode, DWORD dwBufferSize, PWCHAR pStringBuffer, PVOID pReserved);
typedef DWORD (WINAPI *PWlanGetProfileList)(HANDLE hClientHandle, const GUID *pInterfaceGuid, PVOID pReserved, PWLAN_PROFILE_INFO_LIST *ppProfileList);
 
typedef DWORD (WINAPI *PWlanScan)(HANDLE hClientHandle, const GUID *pInterfaceGuid, PDOT11_SSID pDot11Ssid, PVOID pIeData, PVOID pReserved);
 
 
 
 
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// IDE-managed Components
  TLabel *Label1;
  TLabel *Label2;
  TMemo *Memo1;
  TButton *Button1;
  void __fastcall Button1Click(TObject *Sender);
private:	// User declarations
public:		// User declarations
  __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

 

 
 unit1.cpp

cpp

//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
#include <tlhelp32.h>
 
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
 
 
 
PWlanOpenHandle              WlanOpenHandle;
PWlanCloseHandle             WlanCloseHandle;
PWlanEnumInterfaces          WlanEnumInterfaces;
PWlanGetAvailableNetworkList WlanGetAvailableNetworkList;
PWlanAllocateMemory          WlanAllocateMemory;
PWlanFreeMemory              WlanFreeMemory;
PWlanConnect                 WlanConnect;
PWlanDisconnect              WlanDisconnect;
PWlanRegisterNotification    WlanRegisterNotification;
PWlanSetProfile              WlanSetProfile;
PWlanDeleteProfile           WlanDeleteProfile;
PWlanGetProfile              WlanGetProfile;
PWlanReasonCodeToString      WlanReasonCodeToString;
PWlanGetProfileList          WlanGetProfileList;
 
BOOL InitWLanAPI()
{
  HMODULE hWlanapi = LoadLibrary("Wlanapi.dll");
  if(hWlanapi){
    WlanOpenHandle  = (PWlanOpenHandle)GetProcAddress(hWlanapi, "WlanOpenHandle");
    WlanCloseHandle = (PWlanCloseHandle)GetProcAddress(hWlanapi, "WlanCloseHandle");
    WlanEnumInterfaces = (PWlanEnumInterfaces)GetProcAddress(hWlanapi, "WlanEnumInterfaces");
    WlanGetAvailableNetworkList = (PWlanGetAvailableNetworkList)GetProcAddress(hWlanapi, "WlanGetAvailableNetworkList");
    WlanAllocateMemory = (PWlanAllocateMemory)GetProcAddress(hWlanapi, "WlanAllocateMemory");
    WlanFreeMemory = (PWlanFreeMemory)GetProcAddress(hWlanapi, "WlanFreeMemory");
    WlanConnect = (PWlanConnect)GetProcAddress(hWlanapi, "WlanConnect");
    WlanDisconnect = (PWlanDisconnect)GetProcAddress(hWlanapi, "WlanDisconnect");
    WlanRegisterNotification = (PWlanRegisterNotification)GetProcAddress(hWlanapi, "WlanRegisterNotification");
    WlanSetProfile = (PWlanSetProfile)GetProcAddress(hWlanapi, "WlanSetProfile");
    WlanDeleteProfile = (PWlanDeleteProfile)GetProcAddress(hWlanapi, "WlanDeleteProfile");
    WlanGetProfile = (PWlanGetProfile)GetProcAddress(hWlanapi, "WlanGetProfile");
    WlanReasonCodeToString =(PWlanReasonCodeToString)GetProcAddress(hWlanapi, "WlanReasonCodeToString");
    WlanGetProfileList = (PWlanGetProfileList)GetProcAddress(hWlanapi, "WlanGetProfileList");
    
    return WlanOpenHandle && WlanCloseHandle && WlanCloseHandle && WlanGetAvailableNetworkList &&
           WlanAllocateMemory && WlanFreeMemory && WlanConnect && WlanDisconnect &&
           WlanRegisterNotification && WlanSetProfile && WlanDeleteProfile && WlanGetProfile;
  }
  return false;
}
 
//----------------------------------------------------------------------------------
// Constantes y funciones de apoyo
 
// devuelbe el Pid de un proceso conociendo el nombre del exe
DWORD GetProcessID(char* FileName)
{
  DWORD Result = 0;
  PROCESSENTRY32 proc = { sizeof(proc) };
  HANDLE hSysSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
//  if(hSysSnapshot != reinterpret_cast<HANDLE>(-1) && Process32First(hSysSnapshot, &proc)){
  if(hSysSnapshot != INVALID_HANDLE_VALUE && Process32First(hSysSnapshot, &proc)){
    do{
      if(!stricmp(proc.szExeFile, FileName)){
        Result = proc.th32ProcessID;
      }
    }while(Process32Next(hSysSnapshot, &proc));
  }
  CloseHandle(hSysSnapshot);
  return Result;
}
 
BOOL EnablePrivilege(PCSTR name, BOOL Enable = true)
{
  BOOL Result;
  HANDLE hToken;
  TOKEN_PRIVILEGES priv = {1, {0, 0, SE_PRIVILEGE_ENABLED}};
  if(!Enable) priv.Privileges[0].Attributes = 0;
  LookupPrivilegeValue(0, name, &priv.Privileges[0].Luid);
  OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken);
  AdjustTokenPrivileges (hToken, FALSE, &priv, sizeof priv, 0, 0);
  Result = (GetLastError() == ERROR_SUCCESS);
  CloseHandle (hToken);
  return Result;
}
 
BOOL ImpersonateToLoginUser()
{
  HANDLE hProcess, hToken;
  DWORD  ID;
  BOOL   Result = false;
 
  ID = GetProcessID("winlogon.exe");
  if(ID > 0){
    hProcess = OpenProcess (MAXIMUM_ALLOWED, FALSE, ID);
    if(hProcess != INVALID_HANDLE_VALUE){
      Result = OpenProcessToken(hProcess, MAXIMUM_ALLOWED, &hToken);
      if(Result){
        EnablePrivilege("SeDebugPrivilege");
        Result = ImpersonateLoggedOnUser(hToken);
        CloseHandle(hToken);
      }
      CloseHandle (hProcess);
    }
  }
}
 
String ExtractKey(String XMLText)
{
  int ini, fin;
  String Result = "";
 
  ini = XMLText.Pos("<keyMaterial>");
  fin = XMLText.Pos("</keyMaterial>");
  if(ini != -1 && fin != -1){
    ini = ini + lstrlen("<keyMaterial>");
    Result = XMLText.SubString(ini, fin-ini);
  }
  return Result;
}
 
String DecryptData(String Key)
{
  #define CRYPT_STRING_HEX  0x00000004
 
  typedef BOOL (WINAPI *PCryptStringToBinary)(LPCTSTR pszString, DWORD cchString, DWORD dwFlags, BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags);
  typedef BOOL (WINAPI *PCryptUnprotectData)(DATA_BLOB *pDataIn, LPWSTR *ppszDataDescr, DATA_BLOB *pOptionalEntropy, PVOID pvReserved, CRYPTPROTECT_PROMPTSTRUCT *pPromptStruct, DWORD dwFlags, DATA_BLOB *pDataOut);
 
 
  BYTE Buffer[1024];
  DWORD Len;
  DATA_BLOB DataIn, DataOut;
  PCryptStringToBinary _CryptStringToBinary = (PCryptStringToBinary)GetProcAddress(LoadLibrary("Crypt32.dll"), "CryptStringToBinaryA");
  PCryptUnprotectData  _CryptUnprotectData  = (PCryptUnprotectData)GetProcAddress(LoadLibrary("Crypt32.dll"), "CryptUnprotectData");
  String Result = Key;
  Len = 1024;
  ImpersonateToLoginUser();
  if(_CryptStringToBinary(Key.c_str(), Key.Length(), CRYPT_STRING_HEX, Buffer, &Len, 0, 0)){
    DataIn.cbData = Len;
    DataIn.pbData = Buffer;
    DataOut.cbData = 0;
    DataOut.pbData = NULL;
    if(_CryptUnprotectData(&DataIn, NULL, NULL, NULL, NULL, 0, &DataOut))
      Result = String((PCHAR)DataOut.pbData);
  }
  RevertToSelf();
  return Result;
}
 
String WifiGetPassWords()
{
  HANDLE hClient;
  DWORD dwVersion;
  PWLAN_INTERFACE_INFO_LIST pInterfaceInfoList;
  PGUID pInterfaceGuid;
  PWLAN_PROFILE_INFO_LIST pProfileList;
  PWCHAR pstrProfileXml;
  DWORD dwFlags;
  DWORD dwGrantedAccess;
  String Result = "";
 
  if(ERROR_SUCCESS == WlanOpenHandle(1, NULL, &dwVersion, &hClient)){
    if(ERROR_SUCCESS == WlanEnumInterfaces(hClient, NULL, &pInterfaceInfoList)){
      for(int i = 0; i<pInterfaceInfoList->dwNumberOfItems; i++){
        pInterfaceGuid = &pInterfaceInfoList->InterfaceInfo[pInterfaceInfoList->dwIndex].InterfaceGuid;
        if(ERROR_SUCCESS == WlanGetProfileList(hClient, pInterfaceGuid, NULL, &pProfileList)){
          for(int j =0; j < pProfileList->dwNumberOfItems; j++){
            dwFlags = WLAN_PROFILE_GET_PLAINTEXT_KEY;
            if(ERROR_SUCCESS == WlanGetProfile(hClient, pInterfaceGuid, pProfileList->ProfileInfo[j].strProfileName, NULL, &pstrProfileXml, &dwFlags, &dwGrantedAccess)){
              Result = Result + String(pProfileList->ProfileInfo[j].strProfileName) + ": "+ DecryptData(ExtractKey(String(pstrProfileXml))) + "\r\n";
              WlanFreeMemory(pstrProfileXml);
            }
          }
        }
        WlanFreeMemory(pProfileList);
      }
      WlanFreeMemory(pInterfaceInfoList);
    }
    WlanCloseHandle(hClient, NULL);
  }
  return Result;
}
 
 
 
 
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
  : TForm(Owner)
{
  InitWLanAPI();
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Button1Click(TObject *Sender)
{
  Memo1->Lines->Clear();
  Memo1->Lines->Add(WifiGetPassWords());
}
//---------------------------------------------------------------------------

Saludos.

Archivos adjuntos

•  Builder_WiffiPass.rar   165,94KB   20 descargas

[monchito_elroro]

Excelente Maestro se que a muchos les será muy útil

[tmsanchez]

Excelente aporte, gracias!

[sir.dev.a.lot]

Tambien si te sabes el perfil y te la han puesto dificil para conectar un USB, usar Internet o cualquier Restriccion.

 

puedes usar este comando:

 

netsh wlan show profile name=”Aqui.va.el.nombre.del.perfil” key=clear

 

Saludos!

[johe_valencia]

Con una pequeña modificación podemos ejecutar como usuario no administrador en S.O. mayores de Vista y nos dará las claves directamente sin necesidad de desencriptarlas.

delphi

function WifiGetPassWords: String;
var
  hClient: THandle;
  dwVersion: DWORD;
  pInterfaceInfoList: PWLAN_INTERFACE_INFO_LIST;
  pInterfaceGuid: PGUID;
  pProfileList: PWLAN_PROFILE_INFO_LIST;
  pstrProfileXml: PWCHAR;
  dwFlags: DWORD;
  dwGrantedAccess: DWORD;
  i,j: integer;
begin
  Result:= '';
  dwFlags:= 0;
  dwGrantedAccess:= 0;
 
  if ERROR_SUCCESS = WlanOpenHandle(1, nil, @dwVersion, @hClient) then
  begin
    if ERROR_SUCCESS = WlanEnumInterfaces(hClient, nil, @pInterfaceInfoList) then
    begin
      for i:= 0 to pInterfaceInfoList^.dwNumberOfItems - 1 do
      begin
        pInterfaceGuid:= @pInterfaceInfoList^.InterfaceInfo[pInterfaceInfoList^.dwIndex].InterfaceGuid;
        if ERROR_SUCCESS = WlanGetProfileList(hClient, pInterfaceGuid, nil, @pProfileList) then
        begin
          for j:=0 to pProfileList.dwNumberOfItems-1 do
          begin
            dwFlags:= WLAN_PROFILE_GET_PLAINTEXT_KEY;
            if ERROR_SUCCESS = WlanGetProfile(hClient,	pInterfaceGuid, pProfileList.ProfileInfo[j].strProfileName, nil, @pstrProfileXml, @dwFlags, @dwGrantedAccess) then
            begin
              Result:= Result + String(pProfileList.ProfileInfo[j].strProfileName) + ': '+ DecryptData(ExtractKey(String(pstrProfileXml))) + #13 + #10;
              WlanFreeMemory(pstrProfileXml);
            end;
          end;
        end;
        WlanFreeMemory(pProfileList);
      end;
      WlanFreeMemory(pInterfaceInfoList);
    end;
    WlanCloseHandle(hClient, nil);
  end;
end;

Subo la actualización, que lo disfrutéis.
 
Saludos.

 

disculpa eh querido ejecutar en windows 7, pero me sale cifrada, colo si ejecuto como administrador me sale texto plano, como podria ejecutar sin administrador y que salga de igual manera en texto plano

[escafandra]

disculpa eh querido ejecutar en windows 7, pero me sale cifrada, colo si ejecuto como administrador me sale texto plano, como podria ejecutar sin administrador y que salga de igual manera en texto plano

 
La API WlanGetProfile admite WLAN_PROFILE_GET_PLAINTEXT_KEY desde Win7 pero para que en este S.O. tenga efectividad, el proceso debe tener permiso wlan_secure_get_plaintext_key ese permiso lo tienen los administradores por defecto. LA API WlanSetSecuritySettings permite otorgar el permiso mediante un complejo proceso que no he experimentado pero sospecho que debe hacerse con permisos de administrador.

 

Sin embargo en Win10 y creo que en Win8 y 8.1 (ahora no recuerdo si lo probé en ellos, aunque estoy casi seguro de que si lo hice), cualquier usuario puede acceder al texto plano de las claves Wifi.

 

 

Saludos.