API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 20th, 2018
121
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 19.00 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <comdef.h>
  3. #include <Wbemidl.h>
  4. #include <wincred.h>
  5. #include <strsafe.h>
  6. #include <conio.h>
  7. #pragma comment(lib, "wbemuuid.lib")
  8. #pragma comment(lib, "credui.lib")
  9. #pragma comment(lib, "comsuppw.lib")
  10. #define _WIN32_DCOM
  11. #define UNICODE
  12. using namespace std;
  13. int __cdecl main(int argc, char **argv)
  14. {
  15.     setlocale(LC_ALL, ""); 
  16.     HRESULT hres;
  17.     // Шаг 1: --------------------------------------------------    
  18.     // Инициализация COM. ------------------------------------------    
  19.     hres = CoInitializeEx(0, COINIT_MULTITHREADED);    
  20.     if (FAILED(hres))
  21.     {
  22.         cout << "Failed to initialize COM library. Error code = 0x"
  23.             << hex << hres << endl;      
  24.         return 1;
  25.     }
  26.     // Шаг 2: --------------------------------------------------    
  27.     // Установка уровней безопасности COM --------------------------
  28.     hres = CoInitializeSecurity(
  29.         NULL, -1,
  30.         NULL,
  31.         NULL,
  32.         RPC_C_AUTHN_LEVEL_DEFAULT,
  33.         RPC_C_IMP_LEVEL_IDENTIFY,
  34.         NULL,
  35.         EOAC_NONE,
  36.         NULL);
  37.     if (FAILED(hres))
  38.     {
  39.         cout << "Failed to initialize security. Error code = 0x"
  40.             << hex << hres << endl;      
  41.         CoUninitialize();        
  42.         return 1;
  43.     }
  44.     // Шаг 3: ---------------------------------------------------
  45.     // Создание локатора WMI -------------------------
  46.     IWbemLocator *pLoc = NULL;     hres = CoCreateInstance(
  47.         CLSID_WbemLocator,
  48.         0,
  49.         CLSCTX_INPROC_SERVER,
  50.         IID_IWbemLocator, (LPVOID *)&pLoc);  
  51.     if (FAILED(hres))
  52.     {
  53.         cout << "Failed to create IWbemLocator object."
  54.             << " Err code = 0x"
  55.             << hex << hres << endl;    
  56.         CoUninitialize();      
  57.         return 1;
  58.     }
  59.     // Шаг 4: -----------------------------------------------------
  60.     // Подключение к WMI через IWbemLocator::ConnectServer
  61.     IWbemServices *pSvc = NULL;
  62.     // Получение реквизитов доступа к удаленному компьютеру
  63.     CREDUI_INFO cui;
  64.     bool useToken = false;  
  65.     bool useNTLM = true;
  66.     wchar_t pszName[CREDUI_MAX_USERNAME_LENGTH + 1] = { 0 };  
  67.     wchar_t pszPwd[CREDUI_MAX_PASSWORD_LENGTH + 1] = { 0 };  
  68.     wchar_t pszDomain[CREDUI_MAX_USERNAME_LENGTH + 1];  
  69.     wchar_t pszUserName[CREDUI_MAX_USERNAME_LENGTH + 1];  
  70.     wchar_t pszAuthority[CREDUI_MAX_USERNAME_LENGTH + 1];
  71.     BOOL fSave;  
  72.     DWORD dwErr;
  73.     memset(&cui, 0, sizeof(CREDUI_INFO));  
  74.     cui.cbSize = sizeof(CREDUI_INFO);
  75.     cui.hwndParent = NULL;
  76.     cui.pszMessageText = TEXT("Press cancel to use process token");    
  77.     cui.pszCaptionText = TEXT("Enter Account Information");    
  78.     cui.hbmBanner = NULL;    
  79.     fSave = FALSE;
  80.     dwErr = CredUIPromptForCredentials(
  81.         &cui,
  82.         TEXT(""),
  83.         NULL, 0, pszName,
  84.         CREDUI_MAX_USERNAME_LENGTH + 1, pszPwd,
  85.         CREDUI_MAX_PASSWORD_LENGTH + 1,
  86.         &fSave,
  87.         CREDUI_FLAGS_GENERIC_CREDENTIALS |
  88.         CREDUI_FLAGS_ALWAYS_SHOW_UI | CREDUI_FLAGS_DO_NOT_PERSIST);     if (dwErr == ERROR_CANCELLED)
  89.     {
  90.         useToken = true;
  91.     }
  92.         else if (dwErr)
  93.     {
  94.         cout << "Did not get credentials " << dwErr << endl;
  95.         pLoc->Release();      
  96.         CoUninitialize();      
  97.         return 1;
  98.     }
  99.  
  100.     if (!useNTLM)
  101.     {
  102.         StringCchPrintf(pszAuthority, CREDUI_MAX_USERNAME_LENGTH + 1, L"kERBEROS:%s", L"WIN-3ENUE7MV9J4");
  103.     }
  104.     // Подключение к пространству имен root\cimv2
  105.     //---------------------------------------------------------    
  106.     hres = pLoc->ConnectServer(
  107.     _bstr_t(L"\\\\WIN-3ENUE7MV9J4\\root\\SecurityCenter2"),
  108.         _bstr_t(useToken ? NULL : pszName),
  109.         _bstr_t(useToken ? NULL : pszPwd),
  110.         NULL,
  111.         NULL,
  112.         _bstr_t(useNTLM ? NULL : pszAuthority),
  113.         NULL,
  114.         &pSvc   );
  115.         if (FAILED(hres))
  116.         {
  117.             cout << "Could not connect. Error code = 0x"
  118.                 << hex << hres << endl;    
  119.             pLoc->Release();
  120.             CoUninitialize();
  121.             return 1;
  122.         }   cout << "Connected to ROOT\\SecurityCenter2 WMI namespace" << endl;
  123.         // Шаг 5: --------------------------------------------------
  124.         // Создание структуры COAUTHIDENTITY
  125.         COAUTHIDENTITY *userAcct = NULL;  
  126.         COAUTHIDENTITY authIdent;  
  127.         if (!useToken)
  128.         {
  129.             memset(&authIdent, 0, sizeof(COAUTHIDENTITY));      
  130.             authIdent.PasswordLength = wcslen(pszPwd);      
  131.             authIdent.Password = (USHORT*)pszPwd;        
  132.             LPWSTR slash = wcschr(pszName, L'\\');        
  133.             if (slash == NULL)
  134.             {
  135.                 cout << "Could not create Auth identity. No domain specified\n";
  136.                 pSvc->Release();            
  137.                 pLoc->Release();            
  138.                 CoUninitialize();            
  139.                 return 1;
  140.             }
  141.             StringCchCopy(pszUserName, CREDUI_MAX_USERNAME_LENGTH + 1, slash + 1);    
  142.             authIdent.User = (USHORT*)pszUserName;      
  143.             authIdent.UserLength = wcslen(pszUserName);
  144.             StringCchCopyN(pszDomain, CREDUI_MAX_USERNAME_LENGTH + 1, pszName, slash - pszName);
  145.             authIdent.Domain = (USHORT*)pszDomain;  
  146.             authIdent.DomainLength = slash - pszName;  
  147.             authIdent.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;    
  148.             userAcct = &authIdent;
  149.         }
  150.         // Шаг 6: --------------------------------------------------  
  151.         // Установка защиты прокси сервера ------------------  
  152.         hres = CoSetProxyBlanket(         pSvc,
  153.         RPC_C_AUTHN_DEFAULT,
  154.             RPC_C_AUTHZ_DEFAULT,
  155.             COLE_DEFAULT_PRINCIPAL,
  156.             RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE,
  157.             userAcct, EOAC_NONE
  158.             );
  159.             if (FAILED(hres))
  160.             {
  161.                 cout << "Could not set proxy blanket. Error code = 0x"
  162.                     << hex << hres << endl;        
  163.                 pSvc->Release();    
  164.                 pLoc->Release();      
  165.                 CoUninitialize();        
  166.                 return 1;
  167.             }
  168.             // Шаг 7: --------------------------------------------------
  169.             // Получение данных через WMI ----
  170.             // Например, получим имя ОС
  171.             IEnumWbemClassObject * pEnumerator = NULL, *pEnumerator2 = NULL, *pEnumerator3 = NULL;  
  172.             hres = pSvc->ExecQuery(bstr_t("WQL"),
  173.                 bstr_t("Select * from AntivirusProduct"),
  174.                 WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
  175.                 NULL, &pEnumerator);
  176.             hres = pSvc->ExecQuery(bstr_t("WQL"),
  177.                     bstr_t("Select * from AntiSpywareProduct"),
  178.                     WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
  179.                     NULL,
  180.                     &pEnumerator2);
  181.             hres = pSvc->ExecQuery(bstr_t("WQL"), bstr_t("Select * from FirewallProduct"),
  182.                         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
  183.                         NULL, &pEnumerator3);   if (FAILED(hres))
  184.             {
  185.                 cout << "Query for operating system name failed."
  186.                     << " Error code = 0x" << hex << hres << endl;    
  187.                 pSvc->Release();    
  188.                 pLoc->Release();      
  189.                 CoUninitialize();      
  190.                 return 1;
  191.             }    
  192.             hres = CoSetProxyBlanket(pEnumerator, RPC_C_AUTHN_DEFAULT,
  193.                 RPC_C_AUTHZ_DEFAULT,
  194.                 COLE_DEFAULT_PRINCIPAL,
  195.                 RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE,
  196.                 userAcct, EOAC_NONE);
  197.             hres = CoSetProxyBlanket(pEnumerator2, RPC_C_AUTHN_DEFAULT,
  198.                 RPC_C_AUTHZ_DEFAULT,
  199.                 COLE_DEFAULT_PRINCIPAL,
  200.                 RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE,
  201.                 userAcct, EOAC_NONE);
  202.             hres = CoSetProxyBlanket(pEnumerator3, RPC_C_AUTHN_DEFAULT,
  203.                 RPC_C_AUTHZ_DEFAULT,
  204.                 COLE_DEFAULT_PRINCIPAL,
  205.                 RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE,
  206.                 userAcct, EOAC_NONE);
  207.             if (FAILED(hres))
  208.             {
  209.                 cout << "Could not set proxy blanket on enumerator. Error code = 0x"
  210.                     << hex << hres << endl;    
  211.                 pEnumerator->Release();    
  212.                 pSvc->Release();  
  213.                 pLoc->Release();    
  214.                 CoUninitialize();      
  215.                 return 1;
  216.             }
  217.             // Шаг 9: -------------------------------------------------
  218.             // Получение данных из запроса в шаге 7 -------------------
  219.             IWbemClassObject *pclsObj = NULL, *pclsObj2 = NULL, *pclsObj3 = NULL;
  220.             ULONG uReturn = 0;  
  221.             while (pEnumerator)
  222.             {
  223.                 HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
  224.                     &pclsObj, &uReturn);    
  225.                 if (0 == uReturn)
  226.                 {
  227.                     break;
  228.                 }
  229.                 VARIANT vtProp;
  230.                 // Выбираем поле Name  
  231.                 hr = pclsObj->Get(L"displayName", 0, &vtProp, 0, 0);  
  232.                 wcout << "Antivirus: " << endl << " Name : " << vtProp.bstrVal << endl;  
  233.                 hr = pclsObj->Get(L"instanceGuid", 0, &vtProp, 0, 0);    
  234.                 wcout << " Instance Guid : " << vtProp.bstrVal << endl;
  235.                 VariantClear(&vtProp);    
  236.                 pclsObj->Release();    
  237.                 pclsObj = NULL;
  238.             }
  239.             while (pEnumerator2)
  240.             {
  241.                 HRESULT hr2 = pEnumerator2->Next(WBEM_INFINITE, 1,
  242.                     &pclsObj2, &uReturn);  
  243.                 if (0 == uReturn)
  244.                 {
  245.                     break;
  246.                 }
  247.                 VARIANT vtProp;        
  248.                 hr2 = pclsObj2->Get(L"displayName", 0, &vtProp, 0, 0);
  249.                 wcout << "Antispyware:" << endl << " Name : " << vtProp.bstrVal << endl;    
  250.                 hr2 = pclsObj2->Get(L"pathToSignedProductExe", 0, &vtProp, 0, 0);    
  251.                 wcout << " Path To Signed Product Exe : " << vtProp.bstrVal << endl;
  252.                 VariantClear(&vtProp);        
  253.                 pclsObj2->Release();      
  254.                 pclsObj2 = NULL;
  255.             }
  256.             while (pEnumerator3)
  257.             {
  258.                 HRESULT hr3 = pEnumerator3->Next(WBEM_INFINITE, 1,
  259.                     &pclsObj3, &uReturn);  
  260.                 if (0 == uReturn)
  261.                 {
  262.                     break;
  263.                 }
  264.                 VARIANT vtProp;      
  265.                 hr3 = pclsObj3->Get(L"displayName", 0, &vtProp, 0, 0);  
  266.                 wcout << " Firewall Name : " << vtProp.bstrVal << endl;
  267.                 VariantClear(&vtProp);    
  268.                 pclsObj3->Release();      
  269.                 pclsObj3 = NULL;
  270.             }
  271.  
  272.             HRESULT hres1;
  273.             // Шаг 3: ---------------------------------------------------
  274.             // Создание локатора WMI -------------------------
  275.             IWbemLocator *pLoc1 = NULL;    
  276.             hres1 = CoCreateInstance(
  277.                 CLSID_WbemLocator,
  278.                 0,
  279.                 CLSCTX_INPROC_SERVER,
  280.                 IID_IWbemLocator, (LPVOID *)&pLoc1);     if (FAILED(hres1))
  281.             {
  282.                 cout << "Failed to create IWbemLocator object."
  283.                     << " Err code = 0x"
  284.                     << hex << hres1 << endl;
  285.                 CoUninitialize();    
  286.                 return 1;
  287.             }
  288.             // Шаг 4: -----------------------------------------------------
  289.             // Подключение к WMI через IWbemLocator::ConnectServer
  290.             IWbemServices *pSvc1 = NULL;
  291.             // Получение реквизитов доступа к удаленному компьютеру
  292.             if (!useNTLM)
  293.             {
  294.                 StringCchPrintf(pszAuthority, CREDUI_MAX_USERNAME_LENGTH + 1,
  295.                     L"kERBEROS:%s", L"WIN-3ENUE7MV9J4");
  296.             }
  297.             // Подключение к пространству имен root\cimv2
  298.             //---------------------------------------------------------  
  299.             hres1 = pLoc1->ConnectServer(
  300.             _bstr_t(L"\\\\WIN-3ENUE7MV9J4\\root\\cimv2"),
  301.                 _bstr_t(useToken ? NULL : pszName),
  302.                 _bstr_t(useToken ? NULL : pszPwd),
  303.                 NULL,
  304.                 NULL,
  305.                 _bstr_t(useNTLM ? NULL : pszAuthority),
  306.                 NULL,
  307.                 &pSvc1     );
  308.                 if (FAILED(hres1))
  309.                 {
  310.                     cout << "Could not connect. Error code = 0x"
  311.                         << hex << hres1 << endl;  
  312.                     pLoc1->Release();        
  313.                     CoUninitialize();      
  314.                     return 1;
  315.                 }     cout << endl << "Connected to ROOT\\CIMV2 WMI namespace" << endl;
  316.                 // Шаг 5: --------------------------------------------------
  317.                 // Создание структуры COAUTHIDENTITY
  318.  
  319.                 COAUTHIDENTITY *userAcct1 = NULL;    
  320.                 COAUTHIDENTITY authIdent1;    
  321.                 if (!useToken)
  322.                 {
  323.                     memset(&authIdent1, 0, sizeof(COAUTHIDENTITY));      
  324.                     authIdent1.PasswordLength = wcslen(pszPwd);        
  325.                     authIdent1.Password = (USHORT*)pszPwd;      
  326.                     LPWSTR slash = wcschr(pszName, L'\\');      
  327.                     if (slash == NULL)
  328.                     {
  329.                         cout << "Could not create Auth identity. No domain specified\n";      
  330.                         pSvc1->Release();          
  331.                         pLoc1->Release();          
  332.                         CoUninitialize();        
  333.                         return 1;
  334.                     }
  335.                     StringCchCopy(pszUserName, CREDUI_MAX_USERNAME_LENGTH + 1, slash + 1);  
  336.                     authIdent1.User = (USHORT*)pszUserName;    
  337.                     authIdent1.UserLength = wcslen(pszUserName);
  338.                     StringCchCopyN(pszDomain, CREDUI_MAX_USERNAME_LENGTH + 1, pszName, slash - pszName);
  339.                     authIdent1.Domain = (USHORT*)pszDomain;    
  340.                     authIdent1.DomainLength = slash - pszName;  
  341.                     authIdent1.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;  
  342.                     userAcct1 = &authIdent;
  343.                 }
  344.                 // Шаг 6: --------------------------------------------------
  345.                 // Установка защиты прокси сервера ------------------  
  346.                 hres1 = CoSetProxyBlanket(       pSvc1,
  347.                 RPC_C_AUTHN_DEFAULT,
  348.                     RPC_C_AUTHZ_DEFAULT,
  349.                     COLE_DEFAULT_PRINCIPAL,
  350.                     RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE,
  351.                     userAcct1,
  352.                     EOAC_NONE
  353.                     ); if (FAILED(hres1))
  354.                 {
  355.                     cout << "Could not set proxy blanket. Error code = 0x"
  356.                         << hex << hres1 << endl;  
  357.                     pSvc1->Release();    
  358.                     pLoc1->Release();    
  359.                     CoUninitialize();    
  360.                     return 1;
  361.                 }
  362.                 // Шаг 7: --------------------------------------------------
  363.                 // Получение данных через WMI ----
  364.                 // Например, получим имя ОС
  365.                 IEnumWbemClassObject* pEnumerator1 = NULL, *pEnumerator1_1 = NULL, *pEnumerator1_2 = NULL, *pEnumerator1_3 = NULL;
  366.                 hres1 = pSvc1->ExecQuery(bstr_t("WQL"),
  367.                     bstr_t("Select * from Win32_OperatingSystem"), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
  368.                     NULL, &pEnumerator1);  
  369.                 hres1 = pSvc1->ExecQuery(bstr_t("WQL"),
  370.                         bstr_t("Select * from Win32_Product"),
  371.                         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
  372.                         NULL,
  373.                         &pEnumerator1_1);
  374.                 hres1 = pSvc1->ExecQuery(bstr_t("WQL"),
  375.                     bstr_t("Select * from Win32_Process"),
  376.                     WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
  377.                     NULL,
  378.                     &pEnumerator1_2);
  379.                 hres1 = pSvc1->ExecQuery(bstr_t("WQL"),
  380.                     bstr_t("Select * from Win32_BIOS"),
  381.                     WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
  382.                     NULL,
  383.                     &pEnumerator1_3);
  384.            
  385.                 if (FAILED(hres1))
  386.                 {
  387.                     cout << "Query for operating system name failed."
  388.                         << " Error code = 0x" << hex << hres1 << endl;
  389.                     pSvc1->Release();      
  390.                     pLoc1->Release();    
  391.                     CoUninitialize();    
  392.                     return 1;
  393.                 }    
  394.                 hres1 = CoSetProxyBlanket(pEnumerator1, RPC_C_AUTHN_DEFAULT,
  395.                     RPC_C_AUTHZ_DEFAULT,
  396.                     COLE_DEFAULT_PRINCIPAL,
  397.                     RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE,
  398.                     userAcct1,
  399.                     EOAC_NONE);
  400.                 hres1 = CoSetProxyBlanket(pEnumerator1_1, RPC_C_AUTHN_DEFAULT,
  401.                     RPC_C_AUTHZ_DEFAULT,
  402.                     COLE_DEFAULT_PRINCIPAL,
  403.                     RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE,
  404.                     userAcct1,
  405.                     EOAC_NONE);
  406.                 hres1 = CoSetProxyBlanket(pEnumerator1_2, RPC_C_AUTHN_DEFAULT,
  407.                     RPC_C_AUTHZ_DEFAULT,
  408.                     COLE_DEFAULT_PRINCIPAL,
  409.                     RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE,
  410.                     userAcct1,
  411.                     EOAC_NONE);
  412.                 hres1 = CoSetProxyBlanket(pEnumerator1_3, RPC_C_AUTHN_DEFAULT,
  413.                     RPC_C_AUTHZ_DEFAULT,
  414.                     COLE_DEFAULT_PRINCIPAL,
  415.                     RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE,
  416.                     userAcct1,
  417.                     EOAC_NONE);
  418.                 if (FAILED(hres1))
  419.                 {
  420.                     cout << "Could not set proxy blanket on enumerator. Error code = 0x"
  421.                         << hex << hres1 << endl;  
  422.                     pEnumerator1->Release();      
  423.                     pSvc1->Release();    
  424.                     pLoc1->Release();    
  425.                     CoUninitialize();      
  426.                     return 1;
  427.                 }
  428.                 SecureZeroMemory(pszName, sizeof(pszName));
  429.                 SecureZeroMemory(pszPwd, sizeof(pszPwd));
  430.                 SecureZeroMemory(pszUserName, sizeof(pszUserName));
  431.                 SecureZeroMemory(pszDomain, sizeof(pszDomain));
  432.                 // Шаг 9: -------------------------------------------------
  433.                 // Получение данных из запроса в шаге 7 -------------------
  434.                 IWbemClassObject *pclsObj1 = NULL;
  435.                 ULONG uReturn1 = 0;  
  436.                 while (pEnumerator1)
  437.                 {
  438.                     HRESULT hr1 = pEnumerator1->Next(WBEM_INFINITE, 1,
  439.                         &pclsObj1, &uReturn1);  
  440.                     if (0 == uReturn1)
  441.                     {
  442.                         break;
  443.                     }
  444.                     VARIANT vtProp1;  
  445.                     hr1 = pclsObj1->Get(L"CSName", 0, &vtProp1, 0, 0);
  446.                     wcout << " Computer Name : " << vtProp1.bstrVal << endl << endl;      
  447.                     hr1 = pclsObj1->Get(L"Caption", 0, &vtProp1, 0, 0);      
  448.                     wcout << " OS Name : " << vtProp1.bstrVal << endl;
  449.                     hr1 = pclsObj1->Get(L"RegisteredUser", 0, &vtProp1, 0, 0);  
  450.                     wcout << " Registered User : " << vtProp1.bstrVal << endl;
  451.                     hr1 = pclsObj1->Get(L"BootDevice", 0, &vtProp1, 0, 0);      
  452.                     wcout << " Boot Device : " << vtProp1.bstrVal << endl;
  453.                     hr1 = pclsObj1->Get(L"SystemDevice", 0, &vtProp1, 0, 0);    
  454.                     wcout << " System Device : " << vtProp1.bstrVal << endl;
  455.                     hr1 = pclsObj1->Get(L"SerialNumber", 0, &vtProp1, 0, 0);  
  456.                     wcout << " Serial Number : " << vtProp1.bstrVal << endl;
  457.                     hr1 = pclsObj1->Get(L"BuildNumber", 0, &vtProp1, 0, 0);  
  458.                     wcout << " Build Number : " << vtProp1.bstrVal << endl;
  459.                     hr1 = pclsObj1->Get(L"BuildType", 0, &vtProp1, 0, 0);
  460.                     wcout << " Build Type : " << vtProp1.bstrVal << endl;
  461.                     hr1 = pclsObj1->Get(L"OSArchitecture", 0, &vtProp1, 0, 0);  
  462.                     wcout << " OS Architecture : " << vtProp1.bstrVal << endl << endl;
  463.  
  464.                     VariantClear(&vtProp1);      
  465.                     pclsObj1->Release();      
  466.                     pclsObj1 = NULL;
  467.                 }
  468.                 IWbemClassObject *pclsObj1_1 = NULL;  
  469.                 uReturn1 = 0;
  470.                 wcout << "Installed Programs : " << endl;  
  471.                 while (pEnumerator1_1)
  472.                 {
  473.                     HRESULT hr1 = pEnumerator1_1->Next(WBEM_INFINITE, 1,
  474.                         &pclsObj1_1, &uReturn1);  
  475.                     if (0 == uReturn1)
  476.                     {
  477.                         break;
  478.                     }
  479.                     VARIANT vtProp1;    
  480.                     hr1 = pclsObj1_1->Get(L"Name", 0, &vtProp1, 0, 0);
  481.                     wcout << " " << vtProp1.bstrVal << endl;
  482.                     VariantClear(&vtProp1);        
  483.                     pclsObj1_1->Release();      
  484.                     pclsObj1_1 = NULL;
  485.                 }
  486.  
  487.            
  488.                 IWbemClassObject *pclsObj1_2 = NULL;
  489.                 ULONG uReturn2 = 0;
  490.                 wcout << endl << "Active Processes : " << endl;
  491.                 while (pEnumerator1_2)
  492.                 {
  493.                     HRESULT hr1_2 = pEnumerator1_2->Next(WBEM_INFINITE, 1,
  494.                         &pclsObj1_2, &uReturn2);
  495.                     if (0 == uReturn2)
  496.                     {
  497.                         break;
  498.                     }
  499.                     VARIANT vtProp2;
  500.                     hr1_2 = pclsObj1_2->Get(L"Caption", 0, &vtProp2, 0, 0);
  501.                     wcout << " " << vtProp2.bstrVal << endl;
  502.  
  503.                     VariantClear(&vtProp2);
  504.                     pclsObj1_2->Release();
  505.                     pclsObj1_2 = NULL;
  506.                 }
  507.                
  508.  
  509.                 IWbemClassObject *pclsObj1_3 = NULL;
  510.                 uReturn1 = 0;
  511.                 wcout << endl << "BIOS : " << endl;
  512.                 while (pEnumerator1_3)
  513.                 {
  514.                     HRESULT hr1 = pEnumerator1_3->Next(WBEM_INFINITE, 1,
  515.                         &pclsObj1_3, &uReturn1);
  516.                     if (0 == uReturn1)
  517.                     {
  518.                         break;
  519.                     }
  520.                     VARIANT vtProp3;    
  521.                     hr1 = pclsObj1_3->Get(L"Name", 0, &vtProp3, 0, 0);
  522.                     wcout << " Name: " << vtProp3.bstrVal << endl;
  523.                     hr1 = pclsObj1_3->Get(L"Manufacturer", 0, &vtProp3, 0, 0);
  524.                     wcout << " Manufacturer:" << vtProp3.bstrVal << endl;
  525.                     hr1 = pclsObj1_3->Get(L"Version", 0, &vtProp3, 0, 0);
  526.                     wcout << " Version:" << vtProp3.bstrVal << endl;
  527.                     hr1 = pclsObj1_3->Get(L"SerialNumber", 0, &vtProp3, 0, 0);
  528.                     wcout << " Serial Number:" << vtProp3.bstrVal << endl;
  529.  
  530.                     VariantClear(&vtProp3);
  531.                     pclsObj1_3->Release();
  532.                     pclsObj1_3 = NULL;
  533.                 }
  534.  
  535.  
  536.                 // Очистка    // ========  
  537.                 pSvc1->Release();  
  538.                 pLoc1->Release();  
  539.                 pEnumerator1->Release();  
  540.                 if (pclsObj1)    {
  541.                 pclsObj1->Release();
  542. }
  543. CoUninitialize();  
  544. _getch();
  545. return 0;
  546. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!