Como obter informações de um PC pela rede?

[Eduardo - São Paulo]

Bom dia. Por favor alguém poderia me auxiliar na seguinte questão:

Desenvolvi um processo no qual eu localizo todos os PC´S que estão na rede e os coloco em um TreeView.

Quando seleciono o PC no TreeView, eu obtenho os seguintes dados:

IP do PC selecionado

Nome do PC selecionado

Minha questão é a seguinte, precisava obter os seguintes dados:

Nome do usuário do PC selecionado

Número de Série do HD (físico) do PC selecionado

Número de Série da CPU do PC selecionado

Sistema Operacional do PC selecionado

estes dados eu consigo apenas do PC que estou utilizando a rotina e não dos que eu selecionei... alguém sabe como faço para obter essas informações

[paulobergo]

Ô Eduardo...

Esses dados, obvia e naturalmente, você não pode obter... a não ser que invada os computadores...

Então, o que você tem que fazer é criar seu próprio Trojan para obter os dados que precisa...

Onde trabalho, os computadores, usuários, softwares instalados e alterações no hardware são monitorados pelo TraumaZero... e alguns antivirus (Avira e McAfee, p.e.) o consideram como um Trojan...

Esse monitoramento permite até saber se um computador "andou" de um prédio para outro ou de um andar para outro, através do cruzamento do IP x mac x roteador...

Procurando saber mais sobre esse programa (e outros... o Landesk também oferece esses recursos), você poderá dimensionar melhor aquilo que pretende e a idéia de criar o programa como um serviço, parece válida...

Ok?

[Eduardo - São Paulo]

Paulo, Obrigado pela sua ciatção.

Acontece que se formos pela lógica, eu tambem consigo diferente do que você citou, dados como recursos que estão sendo utilizados nos micros que eu selecionar através de API do Windows, então seguindo este raciocínio, creio que deva haver uma rotina na qual eu possa indicar o endereço como IP ou Nome do Micro que desejo obter as informações como Nº de série do HD do PC selecionado. Esta lógica deve-se pelo seguinte motivo principal se esta sendo localizado o nº serial do HD no micro onde se tem o processo em execução, este deve indicar um caminho para a busca desta informação, então quer dizer que se eu alterar este caminho deve me resultar em um processo do modo que necessito.

Mesmo assim agradeço sua citação vou pesquisar a respeito. Mas ficarei no aguardo de alguém mais poder me auxiliar para tentarmos solucionar este processo.

[Jhonas]

Seu tópico < Obrigado pela sua ciatção > foi deletado, pois já está contido neste.

Quanto ao seu questionamento:

creio que deva haver uma rotina na qual eu possa indicar o endereço como IP ou Nome do Micro que desejo obter as informações como Nº de série do HD do PC selecionado. Esta lógica deve-se pelo seguinte motivo principal se esta sendo localizado o nº serial do HD no micro onde se tem o processo em execução, este deve indicar um caminho para a busca desta informação, então quer dizer que se eu alterar este caminho deve me resultar em um processo do modo que necessito.

Voce está certo, e já existem softwares prontos para tal finalidade ... mas vou ver se acho alguma coisa mais acessível.

abraço

[Eduardo - São Paulo]

Seu tópico < Obrigado pela sua ciatção > foi deletado, pois já está contido neste.

Quanto ao seu questionamento:

creio que deva haver uma rotina na qual eu possa indicar o endereço como IP ou Nome do Micro que desejo obter as informações como Nº de série do HD do PC selecionado. Esta lógica deve-se pelo seguinte motivo principal se esta sendo localizado o nº serial do HD no micro onde se tem o processo em execução, este deve indicar um caminho para a busca desta informação, então quer dizer que se eu alterar este caminho deve me resultar em um processo do modo que necessito.

Voce está certo, e já existem softwares prontos para tal finalidade ... mas vou ver se acho alguma coisa mais acessível.

abraço

Jhonas, agradeço sua ciatação e o seu auxilio, fico no aguardo de uma possível resposta

Abraço e Obrigado

[Jhonas]

Eduardo ... vou te dar algumas rotinas para obter dados do micro .... entretanto dependerá de voce complementar o codigo para obter os mesmos dados de outros micros na rede.

OBS: coloque em um form 10 Labels e um botão.

uses
  WinSock;

function GetCPUSpeed: Double;
const
  DelayTime = 500;
var
  TimerHi, TimerLo: DWORD;
  PriorityClass, Priority: Integer;
begin
  try
    PriorityClass := GetPriorityClass(GetCurrentProcess);
    Priority := GetThreadPriority(GetCurrentThread);
    SetPriorityClass(GetCurrentProcess, REALTIME_PRIORITY_CLASS);
    SetThreadPriority(GetCurrentThread, THREAD_PRIORITY_TIME_CRITICAL);
    Sleep(10);
    asm 
      dw 310Fh // rdtsc 
      mov TimerLo, eax
      mov TimerHi, edx 
    end; 
    Sleep(DelayTime); 
    asm 
      dw 310Fh // rdtsc 
      sub eax, TimerLo
      sbb edx, TimerHi 
      mov TimerLo, eax 
      mov TimerHi, edx 
    end; 
    SetThreadPriority(GetCurrentThread, Priority); 
    SetPriorityClass(GetCurrentProcess, PriorityClass); 
    Result := TimerLo / (1000.0 * DelayTime); 
  except
  end; 
end; 

function Retorna_IP: string;
var 
  p: PHostEnt; 
  s: array[0..128] of char; 
  p2: pchar;
  wVersionRequested: WORD; 
  wsaData: TWSAData; 
begin 
  wVersionRequested := MAKEWORD(1, 1); 
  WSAStartup(wVersionRequested, wsaData); 
  GetHostName(@s, 128); 
  p := GetHostByName(@s); 
  p2 := iNet_ntoa(PInAddr(p^.h_addr_list^)^);
  Result := p2; 
  WSACleanup; 
end; 

function Retorna_Nome: string;
var 
  p: PHostEnt; 
  s: array[0..128] of char;
  p2: pchar; 
  wVersionRequested: WORD; 
  wsaData: TWSAData; 
begin 
  wVersionRequested := MAKEWORD(1, 1); 
  WSAStartup(wVersionRequested, wsaData); 
  GetHostName(@s, 128); 
  p := GetHostByName(@s);
  Result := p^.h_Name; 
end; 

function Retorna_Dominio: string;
var 
  hProcesso, hTokenAcesso: THandle; 
  Buffer: PChar; 
  Usuario: array[0..31] of char;
  Dominio: array[0..31] of char; 

  TamanhoBufferInfo: Cardinal; 
  TamanhoUsuario: Cardinal; 
  TamanhoDominio: Cardinal; 
  snu: SID_NAME_USE; 

begin
  TamanhoBufferInfo := 1000; 
  TamanhoUsuario := sizeof(Usuario); 
  TamanhoDominio := sizeof(Dominio); 

  hProcesso := GetCurrentProcess; 
  if OpenProcessToken(hProcesso, TOKEN_READ, hTokenAcesso) then 
  try 
    GetMem(Buffer, TamanhoBufferInfo);
    try 
      if GetTokenInformation(hTokenAcesso, TokenUser, Buffer, TamanhoBufferInfo, 
        TamanhoBufferInfo) then 
        LookupAccountSid(nil, PSIDAndAttributes(Buffer)^.sid, Usuario, 
          TamanhoUsuario, Dominio, TamanhoDominio, snu) 
      else 
        //RaiseLastOSError;
    finally
      FreeMem(Buffer); 
    end; 
    result := Dominio; 
  finally 
    CloseHandle(hTokenAcesso); 
  end 
end; 

function Retorna_Usuario: string;
var 
  cUser: array[0..144] of Char; 
  BufferSize: DWord; 
  cUserName: string; 

begin 
  BufferSize := SizeOf(cUser);
  GetUserName(cUser, BufferSize); 
  cUserName := Trim(StrPas(cUser)); 
  Result := cUserName; 
end; 

function Retorna_Memoria: string;
var 
  MemoryStatus: TMemoryStatus;
begin 
  MemoryStatus.dwLength := sizeof(MemoryStatus); 
  GlobalMemoryStatus(MemoryStatus); 
  Result := 'Total de memória física : ' + FormatFloat('#0,000', 
    MemoryStatus.dwTotalPhys); 
  (* 
  {typedef struct _MEMORYSTATUS} 
  DWORD dwLength; // sizeof(MEMORYSTATUS)
  DWORD dwMemoryLoad; // percentual de memória em uso 
  DWORD dwTotalPhys; // bytes de memória física 
  DWORD dwAvailPhys; // bytes livres de memória física 
  DWORD dwTotalPageFile; // bytes de paginação de arquivo 
  DWORD dwAvailPageFile; // bytes livres de paginação de arquivo 
  DWORD dwTotalVirtual; // bytes em uso de espaço de endereço 
  DWORD dwAvailVirtual; // bytes livres} 
  *)
end;

procedure ChangeByteOrder( var Data; Size : Integer );
var
  ptr : PChar;
  i : Integer;
  c : Char;
begin
  ptr := @Data;
  for i := 0 to (Size shr 1)-1 do
  begin
    c := ptr^;
    ptr^ := (ptr+1)^;
    (ptr+1)^ := c;
    Inc(ptr,2);
  end;
end;

{ função que pega o serial number FÍSICO do HD e retorna string }

function GetIdeDiskSerialNumber : String;
   type
    TSrbIoControl = packed record
      HeaderLength: ULONG;
      Signature: Array[0..7] of Char;
      Timeout: ULONG;
      ControlCode: ULONG;
      ReturnCode: ULONG;
      Length: ULONG;
   end;
   SRB_IO_CONTROL = TSrbIoControl;
   PSrbIoControl = ^TSrbIoControl;

    TIDERegs = packed record
      bFeaturesReg : Byte; // especificar "comandos" SMART
      bSectorCountReg : Byte; // registro de contador de setor
      bSectorNumberReg : Byte; // registro de número de setores
      bCylLowReg : Byte; // valor de cilindro (byte mais baixo)
      bCylHighReg : Byte; // valor de cilindro (byte mais alto)
      bDriveHeadReg : Byte; // registro de drive/cabeça
      bCommandReg : Byte; // comando IDE
      bReserved : Byte; // reservado- tem que ser zero
   end;
    IDEREGS = TIDERegs;
    PIDERegs = ^TIDERegs;

   TSendCmdInParams = packed record
      cBufferSize : DWORD;
      irDriveRegs : TIDERegs;
      bDriveNumber : Byte;
      bReserved : Array[0..2] of Byte;
      dwReserved : Array[0..3] of DWORD;
      bBuffer : Array[0..0] of Byte;
    end;
    SENDCMDINPARAMS = TSendCmdInParams;
    PSendCmdInParams = ^TSendCmdInParams;

    TIdSector = packed record
      wGenConfig : Word;
      wNumCyls : Word;
      wReserved : Word;
      wNumHeads : Word;
      wBytesPerTrack : Word;
      wBytesPerSector : Word;
      wSectorsPerTrack : Word;
      wVendorUnique : Array[0..2] of Word;
      sSerialNumber : Array[0..19] of Char;
      wBufferType : Word;
      wBufferSize : Word;
      wECCSize : Word;
      sFirmwareRev : Array[0..7] of Char;
      sModelNumber : Array[0..39] of Char;
      wMoreVendorUnique : Word;
      wDoubleWordIO : Word;
      wCapabilities : Word;
      wReserved1 : Word;
      wPIOTiming : Word;
      wDMATiming : Word;
      wBS : Word;
      wNumCurrentCyls : Word;
      wNumCurrentHeads : Word;
      wNumCurrentSectorsPerTrack : Word;
      ulCurrentSectorCapacity : ULONG;
      wMultSectorStuff : Word;
      ulTotalAddressableSectors : ULONG;
      wSingleWordDMA : Word;
      wMultiWordDMA : Word;
      bReserved : Array[0..127] of Byte;
    end;
    PIdSector = ^TIdSector;

  const
    IDE_ID_FUNCTION = $EC;
    IDENTIFY_BUFFER_SIZE = 512;
    DFP_RECEIVE_DRIVE_DATA = $0007c088;
    IOCTL_SCSI_MINIPORT = $0004d008;
    IOCTL_SCSI_MINIPORT_IDENTIFY = $001b0501;
    DataSize = sizeof(TSendCmdInParams)-1+IDENTIFY_BUFFER_SIZE;
    BufferSize = SizeOf(SRB_IO_CONTROL)+DataSize;
    W9xBufferSize = IDENTIFY_BUFFER_SIZE+16;
  var
    hDevice : THandle;
    cbBytesReturned : DWORD;
    pInData : PSendCmdInParams;
    pOutData : Pointer; // PSendCmdOutParams
    Buffer : Array[0..BufferSize-1] of Byte;
    srbControl : TSrbIoControl absolute Buffer;
  
  begin
    Result := '';
    FillChar(Buffer,BufferSize,#0);

    if Win32Platform=VER_PLATFORM_WIN32_NT then
    // Windows NT, Windows 2000, Windows XP
    begin
      // recuperar handle da porta SCSI
      hDevice := CreateFile('\\.\Scsi0:',
      // Nota: '\\.\C:' precisa de privilégios administrativos
      GENERIC_READ or GENERIC_WRITE, FILE_SHARE_READ or FILE_SHARE_WRITE,  nil, OPEN_EXISTING, 0, 0);
      if hDevice=INVALID_HANDLE_VALUE then Exit;
      try
        srbControl.HeaderLength := SizeOf(SRB_IO_CONTROL);
        System.Move('SCSIDISK',srbControl.Signature,8);
        srbControl.Timeout := 2;
        srbControl.Length := DataSize;
        srbControl.ControlCode := IOCTL_SCSI_MINIPORT_IDENTIFY;
        pInData := PSendCmdInParams(PChar(@Buffer)
        +SizeOf(SRB_IO_CONTROL));
        pOutData := pInData;
       with pInData^ do
       begin
         cBufferSize := IDENTIFY_BUFFER_SIZE;
         bDriveNumber := 0;
         with irDriveRegs do
         begin
           bFeaturesReg := 0;
           bSectorCountReg := 1;
           bSectorNumberReg := 1;
           bCylLowReg := 0;
           bCylHighReg := 0;
           bDriveHeadReg := $A0;
           bCommandReg := IDE_ID_FUNCTION;
         end;
      end;
      if not DeviceIoControl( hDevice, IOCTL_SCSI_MINIPORT, @Buffer, BufferSize, @Buffer, BufferSize, cbBytesReturned, nil ) then Exit;
     finally
       CloseHandle(hDevice);
     end;
   end
   else
   begin
      // Windows 95 OSR2, Windows 98, Windows ME
      hDevice := CreateFile( '\\.\SMARTVSD', 0, 0, nil, CREATE_NEW, 0, 0 );
      if hDevice=INVALID_HANDLE_VALUE then Exit;
      try
        pInData := PSendCmdInParams(@Buffer);
        pOutData := @pInData^.bBuffer;
        with pInData^ do
        begin
           cBufferSize := IDENTIFY_BUFFER_SIZE;
           bDriveNumber := 0;
           with irDriveRegs do
           begin
             bFeaturesReg := 0;
             bSectorCountReg := 1;
             bSectorNumberReg := 1;
             bCylLowReg := 0;
             bCylHighReg := 0;
             bDriveHeadReg := $A0;
             bCommandReg := IDE_ID_FUNCTION;
           end;
         end;
         if not DeviceIoControl( hDevice, DFP_RECEIVE_DRIVE_DATA, pInData, SizeOf(TSendCmdInParams)-1, pOutData, W9xBufferSize, cbBytesReturned, nil ) then Exit;
        finally
          CloseHandle(hDevice);
        end;
     end;
     with PIdSector(PChar(pOutData)+16)^ do
     begin
        ChangeByteOrder(sSerialNumber,SizeOf(sSerialNumber));
        SetString(Result,sSerialNumber,SizeOf(sSerialNumber));
     end;
  end;

procedure TForm1.Button1Click(Sender: TObject);
var
  Temp, Platform , Version : String;
  osInfo : TOSVersionInfo;
  cpuspeed: string;
begin

  osInfo.dwOSVersionInfoSize:=SizeOf(osInfo);
  GetVersionEx(osInfo);
  Version :=IntToStr(osInfo.dwMinorVersion);
  Temp:=IntToStr(osInfo.dwBuildNumber and $0ffff);
  Temp:=String(osInfo.szCSDVersion);
  if (Length(Temp) > 0) then
    if (Temp[1] <> ' ') then
      Temp:=' ' + Temp;
  Version:= Version + Temp;

  label10.caption := Version;

  case osInfo.dwPlatformId of
    VER_PLATFORM_WIN32s :
      Platform:='Win32s';
    VER_PLATFORM_WIN32_WINDOWS : begin
      if (osInfo.dwMinorVersion = 0) then
        Platform:='Windows 95'
      else if (osInfo.dwMinorVersion = 10) then
        Platform:='Windows 98'
      else
        Platform:='Windows Me';
    end;
    VER_PLATFORM_WIN32_NT :
      case osInfo.dwMajorVersion of
        3 : Platform:='Windows NT 3';
        4 : Platform:='Windows NT 4.0';
        5 : case osInfo.dwMinorVersion of
              0: Platform:='Windows 2000, Windows Vista ou Windows Server 2008';
              1: Platform:='Windows XP';
              2: Platform:='Windows Server 2003 R2, 2003 ou XP Professional X64 Edition';
            else
              Platform:='Windows Version +';
            end;
      end;
  end;

  cpuspeed := Format('%f MHz', [GetCPUSpeed]);
  Label1.Caption := 'Nome máquina: ' + Retorna_Nome;
  Label2.Caption := 'IP: ' + Retorna_IP;
  Label3.Caption := 'Domínio: ' + Retorna_Dominio;
  Label4.Caption := 'Velocidade do CPU: ' + cpuspeed +
    ' (valor aproximado)';
  Label5.Caption := 'Nome do usuário na rede: ' + Retorna_Usuario;
  Label6.Caption := 'Memória RAM: ' + Retorna_Memoria;
  Label8.Caption := 'Tamanho do Disco: ' + FormatFloat('#0,000',DiskSize(0) div 1024);
  Label7.Caption := 'Espaço Livre: ' + FormatFloat('#0,000',DiskFree(0) div 1024);
  Label9.Caption := 'Serial Físico do HD: ' + Trim(GetIdeDiskSerialNumber);

  label11.caption := Platform;

end;

O resto agora é com voce.

abraço