盗賊団の日常

_bstr_t(L"ntlmdomain:domain")

_bstr_t(L"ntlmdomain:任意のドメイン名")

::CoInitializeSecurity(NULL, -1, NULL, NULL,
RPC_C_AUTHN_LEVEL_DEFAULT,
RPC_C_IMP_LEVEL_IMPERSONATE,
NULL, EOAC_NONE, NULL);

// Auth Identity structure
SEC_WINNT_AUTH_IDENTITY_W auth_identity;
SOLE_AUTHENTICATION_INFO auth_info[2];
::SecureZeroMemory(&auth_identity, sizeof(auth_identity));

auth_identity.User = L"ユーザー名";
auth_identity.UserLength = wcslen(auth_identity.User);
auth_identity.Domain = L"ドメイン名";
auth_identity.DomainLength = wcslen(auth_identity.Domain);
auth_identity.Password = L"パスワード";
auth_identity.PasswordLength = wcslen(auth_identity.Password);
auth_identity.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;

::SecureZeroMemory(auth_info, sizeof(SOLE_AUTHENTICATION_INFO)*2);

// NTLM Settings
auth_info[0].dwAuthnSvc = RPC_C_AUTHN_WINNT;
auth_info[0].dwAuthzSvc = RPC_C_AUTHZ_NONE;
auth_info[0].pAuthInfo = &auth_identity;

// Kerberos Settings
auth_info[1].dwAuthnSvc = RPC_C_AUTHN_GSS_KERBEROS ;
auth_info[1].dwAuthzSvc = RPC_C_AUTHZ_NONE;
auth_info[1].pAuthInfo = &auth_identity;

SOLE_AUTHENTICATION_LIST auth_list;

auth_list.cAuthInfo = 2;
auth_list.aAuthInfo = auth_info;

::CoInitializeSecurity(NULL, -1, NULL, NULL,
RPC_C_AUTHN_LEVEL_CALL,
RPC_C_IMP_LEVEL_IMPERSONATE,
&auth_list, EOAC_NONE, NULL);

IDD_IP_ADDRESS DIALOG DISCARDABLE 0, 0, 183, 225
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "IP Address の列挙"
FONT 9, "ＭＳ Ｐゴシック"
BEGIN
LTEXT "ドメイン",IDC_STATIC,5,10,22,8
LTEXT "ユーザー",IDC_STATIC,5,35,28,8
LTEXT "パスワード",IDC_STATIC,5,60,32,8
EDITTEXT IDC_DOMAIN,40,5,70,15,ES_AUTOHSCROLL
EDITTEXT IDC_USER,40,30,70,15,ES_AUTOHSCROLL
EDITTEXT IDC_PASSWORD,40,55,70,15,ES_PASSWORD |
ES_AUTOHSCROLL
EDITTEXT IDC_LIST,5,80,175,140,ES_MULTILINE |
ES_AUTOHSCROLL | ES_WANTRETURN | WS_VSCROLL
PUSHBUTTON "取得",IDC_GET,135,5,40,15
PUSHBUTTON "閉じる",IDCANCEL,135,55,40,15
END

#define _WIN32_DCOM
#include
#include
#include
#include "resource.h"
using namespace std;

#pragma comment(lib, "wbemuuid.lib")
#pragma comment(lib, "Mpr.lib")

// IP Address の列挙
void IPAddressEnumerator(HWND hWnd, char *domain,
char *user, char *password)
{
IWbemLocator *wbem_locator = NULL;

// 各種初期化
::CoInitializeSecurity(NULL, -1, NULL, NULL,
RPC_C_AUTHN_LEVEL_DEFAULT,
RPC_C_IMP_LEVEL_IMPERSONATE,
NULL, EOAC_NONE, NULL);

::CoCreateInstance(CLSID_WbemLocator, 0,
CLSCTX_INPROC_SERVER,
IID_IWbemLocator,
reinterpret_cast(&wbem_locator));

NETRESOURCE net_resource;
LPNETRESOURCE enum_resoruce;
HANDLE enum_handle;
DWORD buffer_size = 1000;
DWORD count = 1;

::SecureZeroMemory(&net_resource, sizeof(NETRESOURCE));
net_resource.dwScope = RESOURCE_GLOBALNET;
net_resource.dwType = RESOURCETYPE_ANY;
net_resource.dwDisplayType = RESOURCEDISPLAYTYPE_DOMAIN;
net_resource.dwUsage = RESOURCEUSAGE_CONTAINER;
net_resource.lpRemoteName = domain;
net_resource.lpProvider = "Microsoft Windows Network";

enum_resoruce =
(LPNETRESOURCE)::GlobalAlloc(GMEM_FIXED, buffer_size);
// ネットワークリソースの取得
::WNetOpenEnum(RESOURCE_GLOBALNET,
RESOURCETYPE_ANY,
0, &net_resource, &enum_handle);

// 取得したネットワークリソースの列挙
string ip_list;
while(::WNetEnumResource(enum_handle, &count,
enum_resoruce,
&buffer_size) == NO_ERROR)
{
IWbemServices *wbem_services = NULL;
IEnumWbemClassObject *wbem_enumerator = NULL;
IWbemClassObject *wbem_object = NULL;

char pc_name[256] = "";
wsprintf(pc_name, "%s\\ROOT\\CIMV2",
enum_resoruce->lpRemoteName);
char domain_name[256] = "";
wsprintf(domain_name, "ntlmdomain:%s", domain);

// 接続開始
mbstowcs(buffer2, buffer, length);
if(wbem_locator->ConnectServer(_bstr_t(pc_name),
_bstr_t(user),
_bstr_t(password),
0, NULL, domain_name,
0, &wbem_services) != S_OK)
{
::SendDlgItemMessage(hWnd, IDC_LIST, WM_SETTEXT, 9,
reinterpret_cast("connect failed..."));
return continue;
}

::CoSetProxyBlanket(wbem_services,
RPC_C_AUTHN_WINNT,
RPC_C_AUTHZ_NONE, NULL,
RPC_C_AUTHN_LEVEL_CALL,
RPC_C_IMP_LEVEL_IMPERSONATE,
NULL, EOAC_NONE);

wbem_services->ExecQuery(_bstr_t("WQL"),
_bstr_t("SELECT * FROM
Win32_NetworkAdapterConfiguration
WHERE IPEnabled='TRUE'"),
WBEM_FLAG_RETURN_IMMEDIATELY |
WBEM_FLAG_FORWARD_ONLY,
NULL, &wbem_enumerator);

// プロパティ読み込み
ULONG returned = 0;
char cr[3] = {0x0d, 0x0a, 0x00};

while(wbem_enumerator)
{
wbem_enumerator->Next(WBEM_INFINITE, 1,
&wbem_object, &returned);

if(0 == returned) break;

VARIANT property_value;
_bstr_t display_name;
::VariantInit(&property_value);
wbem_object->Get(L"IPAddress", 0L,
&property_value, NULL, NULL);

ip_list += "IPAddress : ";
// SAFEARRAY データの取得
if(property_value.vt == (VT_ARRAY | VT_BSTR))
{
long lLower = 0, lUpper = 0;
::SAFEARRAY *property_array = property_value.parray;
::SafeArrayGetLBound(property_array, 1, &lLower);
::SafeArrayGetUBound(property_array, 1, &lUpper);

string property_string;
for(long i = lLower; i <= lUpper; ++i)
{
BSTR data;
if(::SafeArrayGetElement(property_array,
&i, &data) != S_OK)
{
if(property_array != NULL)
::SafeArrayDestroy(property_array);
}

char buffer[256] = "";
wcstombs(buffer, data, 255);
property_string += buffer;
}

if(property_array != NULL)
::SafeArrayDestroy(property_array);

ip_list += property_string;
ip_list += cr;
}

::VariantClear(&property_value);
}

// オブジェクトの開放
if(wbem_object != NULL)
wbem_object->Release();

if(wbem_enumerator != NULL)
wbem_enumerator->Release();

if(wbem_services != NULL)
wbem_services->Release();
}

::SendDlgItemMessage(hWnd, IDC_LIST, WM_SETTEXT,
ip_list.length(),
reinterpret_cast(ip_list.c_str()));

// 各種開放
::WNetCloseEnum(enum_handle);
::GlobalFree(enum_resoruce);
wbem_locator->Release();
}

/* ダイアログ プロシージャ */
INT_PTR CALLBACK IPDlgProc(HWND hWnd, UINT uMsg,
WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_GET:
{
char domain[256] = "";
char user[256] = "";
char password[256] = "";
::SendDlgItemMessage(hWnd, IDC_DOMAIN,
WM_GETTEXT, 255,
reinterpret_cast(domain));
::SendDlgItemMessage(hWnd, IDC_USER,
WM_GETTEXT, 255,
reinterpret_cast(user));
::SendDlgItemMessage(hWnd, IDC_PASSWORD,
WM_GETTEXT, 255,
reinterpret_cast(password));
IPAddressEnumerator(hWnd, domain, user, password);
break;
}

case IDCANCEL:
::EndDialog(hWnd, 0);
::PostQuitMessage(0);
break;
}

return 0;
}

return FALSE;
}


/* メイン */
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
HWND hWnd;
MSG msg;

::CoInitializeEx(0, COINIT_MULTITHREADED);
hWnd = ::CreateDialog(hInstance,
MAKEINTRESOURCE(IDD_IP_ADDRESS),
0, IPDlgProc);

::ShowWindow(hWnd, SW_SHOW);

while(::GetMessage(&msg, NULL, 0, 0))
{
if(hWnd == 0 || !::IsDialogMessage(hWnd, &msg)){
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}

::CoUninitialize();
return TRUE;
}

#define _WIN32_DCOM
#include
#include
#include
using namespace std;

#pragma comment(lib, "wbemuuid.lib")

int main(int argc, char **argv)
{
IWbemLocator *wbem_locator = NULL;
IWbemServices *wbem_services = NULL;
IEnumWbemClassObject *wbem_enumerator = NULL;

// 各種初期化
CoInitializeEx(0, COINIT_MULTITHREADED);

CoInitializeSecurity(NULL, -1, NULL, NULL,
RPC_C_AUTHN_LEVEL_DEFAULT,
RPC_C_IMP_LEVEL_IMPERSONATE,
NULL, EOAC_NONE, NULL);

CoCreateInstance(CLSID_WbemLocator, 0,
CLSCTX_INPROC_SERVER, IID_IWbemLocator,
reinterpret_cast(&wbem_locator));

// 接続開始
wbem_locator->ConnectServer(_bstr_t(L"\\\\.\\ROOT\\CIMV2"),
NULL, NULL, 0, NULL,
0, 0, &wbem_services);

CoSetProxyBlanket(wbem_services,
RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL,
RPC_C_AUTHN_LEVEL_CALL,
RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE);

wbem_services->ExecQuery(bstr_t("WQL"),
bstr_t("SELECT * FROM Win32_ComputerSystem"),
WBEM_FLAG_RETURN_IMMEDIATELY |
WBEM_FLAG_FORWARD_ONLY ,
NULL, &wbem_enumerator);

// プロパティ読み込み
IWbemClassObject *wbem_object;
ULONG returned = 0;

while(wbem_enumerator)
{
wbem_enumerator->Next(WBEM_INFINITE, 1,
&wbem_object, &returned);

if(0 == returned)
break;

_bstr_t property_name[] = {L"Name", L"UserName", L"Domain"};

for(int item = 0; item < 3; item++)
{
VARIANT property_value;
_bstr_t display_name;
VariantInit(&property_value);
wbem_object->Get(property_name[item], 0,
&property_value, 0, 0);
display_name = property_value;
cout << static_cast(property_name[item]) <<
" : " << static_cast(display_name) << endl;
VariantClear(&property_value);
}
}

wbem_services->Release();
wbem_locator->Release();
wbem_enumerator->Release();
wbem_object->Release();

CoUninitialize();

return 0;
}

#include "StdAfx.h"
#include "IEEventSink.h"

int main(int argc, char *argv[])
{
IWebBrowser2 *web_browser;

CoInitialize(NULL);
CoCreateInstance(CLSID_InternetExplorer, NULL, CLSCTX_ALL,
IID_IWebBrowser2, (void **)&web_browser);

_variant_t url = "http://www.google.co.jp";

web_browser->put_Visible(VARIANT_TRUE);
web_browser->Navigate2(&url, &_variant_t(), &_variant_t(),
&_variant_t(), &_variant_t());

READYSTATE state;
// HTML ドキュメントがすべて表示されるまで待つ
while(true)
{
if(web_browser->get_ReadyState(&state) != S_OK){
printf("document read error!\n");
web_browser->Quit();
web_browser->Release();
CoUninitialize();
return -1;
}
if(state == READYSTATE_COMPLETE)
break;
}

HRESULT hr;
IConnectionPointContainer *cpc;
IConnectionPoint *cp;
IDispatch *advice_dispatch;
DWORD cookie;

// オブジェクトがイベントを発行できるかチェック
hr = web_browser->QueryInterface(IID_IConnectionPointContainer,
(void**)&cpc);

if(SUCCEEDED(hr))
{
// 接続ポイントの要求
hr = cpc->FindConnectionPoint(DIID_DWebBrowserEvents2, &cp);

if(SUCCEEDED(hr))
{
IEEventSink *ie_event;
ie_event = new IEEventSink();

ie_event->QueryInterface(IID_IDispatch,
(void **)&advice_dispatch);
// 接続～
hr = cp->Advise(advice_dispatch, &cookie);

if(SUCCEEDED(hr))
{
printf("advice success!\n");
}

cp = NULL;
}

cpc = NULL;
}

advice_dispatch->Release();
web_browser->Quit();
web_browser->Release();
CoUninitialize();

return 0;
}

#pragma once
#include <comdef.h>
#include <shlobj.h>
#include <exdispid.h>

#include "stdafx.h"
#include "IEEventSink.h"

IEEventSink::IEEventSink() : m_nRefCnt(0)
{
}


IEEventSink::~IEEventSink()
{
m_nRefCnt = 0;
}


HRESULT STDMETHODCALLTYPE
IEEventSink::QueryInterface(REFIID riid, void **ppvObject)
{
if(IsEqualIID(riid, IID_IUnknown) ||
IsEqualIID(riid, IID_IDispatch))
*ppvObject = static_cast(this);
else
{
*ppvObject = NULL;
return E_NOINTERFACE;
}

// 参照カウンタをインクリメント
AddRef();
return S_OK;
}


ULONG STDMETHODCALLTYPE IEEventSink::AddRef(void)
{
m_nRefCnt++;
return m_nRefCnt;
}


ULONG STDMETHODCALLTYPE IEEventSink::Release(void)
{
m_nRefCnt--;
if(m_nRefCnt > 0)
return m_nRefCnt;

delete this;
return 0;
}


HRESULT STDMETHODCALLTYPE
IEEventSink::GetTypeInfoCount(unsigned int *pCount)
{
if(pCount == NULL){
return E_INVALIDARG;
}

*pCount = 1;
return NOERROR;
}


HRESULT STDMETHODCALLTYPE
IEEventSink::GetTypeInfo(unsigned int iTInfo,
LCID lcid,
ITypeInfo **ppTInfo)
{
if (ppTInfo == NULL)
return E_INVALIDARG;

*ppTInfo = NULL;

if(iTInfo != 0)
return DISP_E_BADINDEX;

m_pTInfo->AddRef();

*ppTInfo = m_pTInfo;
return NOERROR;
}


HRESULT STDMETHODCALLTYPE
IEEventSink::GetIDsOfNames(REFIID riid, OLECHAR **rgszNames,
unsigned int cNames,
LCID lcid, DISPID *rgDispId)
{
return DispGetIDsOfNames(m_pTInfo, rgszNames, cNames, rgDispId);
}


HRESULT STDMETHODCALLTYPE
IEEventSink::Invoke(DISPID dispIdMember,
REFIID riid, LCID lcid,
WORD wFlags,
DISPPARAMS *pDispParams,
VARIANT *pVarResult,
EXCEPINFO *pExcepInfo,
unsigned int *puArgErr)
{
switch(dispIdMember)
{
/* HTML ドキュメントの表示完了 */
case DISPID_DOCUMENTCOMPLETE:
::MessageBox(NULL, "読み込み終了", "メッセージ", MB_OK);
break;

/* ステータス変更時 */
case DISPID_STATUSTEXTCHANGE:
{
char buffer[256] = "";
wcstombs(buffer, pDispParams->rgvarg[0].bstrVal, 256);
if(strcmp(buffer , ""))
::MessageBox(NULL, buffer, "URL", MB_OK);

break;
}

/* IE のクローズ */
case DISPID_ONQUIT:
::MessageBox(NULL, "IE の終了", "メッセージ", MB_OK);
break;

default:
break;
}

return S_OK;
}


void IEEventSink::CreateInstance(IDispatch **ppDispatch)
{
IEEventSink *ie_event;
ie_event = new IEEventSink;
ie_event->QueryInterface(IID_IDispatch, (void **)ppDispatch);
}

class IEEventSink : public IDispatch
{
public:
IEEventSink();
virtual ~IEEventSink();

// IUnknown
virtual HRESULT STDMETHODCALLTYPE
QueryInterface(REFIID riid, void **ppvObject);
virtual ULONG STDMETHODCALLTYPE AddRef(void);
virtual ULONG STDMETHODCALLTYPE Release(void);

virtual HRESULT STDMETHODCALLTYPE
GetTypeInfoCount(unsigned int *pCount);
virtual HRESULT STDMETHODCALLTYPE
GetTypeInfo(unsigned int iTInfo,
LCID lcid, ITypeInfo **ppTInfo);
virtual HRESULT STDMETHODCALLTYPE
GetIDsOfNames(REFIID riid,
OLECHAR **rgszNames,
unsigned int cNames,
LCID lcid, DISPID *rgDispId );
// IDispatch
virtual HRESULT STDMETHODCALLTYPE
Invoke(DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS *pDispParams,
VARIANT *pVarResult,
EXCEPINFO *pExcepInfo,
unsigned int *puArgErr);

static void CreateInstance(IDispatch **ppDispatch);

public:
long m_nRefCnt;
ITypeInfo *m_pTInfo;
};