diff --git a/ctypes_generation/definitions/functions/internet.txt b/ctypes_generation/definitions/functions/internet.txt new file mode 100644 index 0000000..a4ac2cd --- /dev/null +++ b/ctypes_generation/definitions/functions/internet.txt @@ -0,0 +1,175 @@ +BOOL InternetCheckConnectionA( + LPCSTR lpszUrl, + DWORD dwFlags, + DWORD dwReserved +); + +BOOL InternetCheckConnectionW( + LPCWSTR lpszUrl, + DWORD dwFlags, + DWORD dwReserved +); + + +HINTERNET InternetOpenA( + LPCSTR lpszAgent, + DWORD dwAccessType, + LPCSTR lpszProxy, + LPCSTR lpszProxyBypass, + DWORD dwFlags +); + +HINTERNET InternetOpenW( + LPCWSTR lpszAgent, + DWORD dwAccessType, + LPCWSTR lpszProxy, + LPCWSTR lpszProxyBypass, + DWORD dwFlags +); + +HINTERNET InternetOpenUrlA( + HINTERNET hInternet, + LPCSTR lpszUrl, + LPCSTR lpszHeaders, + DWORD dwHeadersLength, + DWORD dwFlags, + DWORD_PTR dwContext +); + +HINTERNET InternetOpenUrlW( + HINTERNET hInternet, + LPCWSTR lpszUrl, + LPCWSTR lpszHeaders, + DWORD dwHeadersLength, + DWORD dwFlags, + DWORD_PTR dwContext +); + +HINTERNET InternetConnectA( + HINTERNET hInternet, + LPCSTR lpszServerName, + INTERNET_PORT nServerPort, + LPCSTR lpszUserName, + LPCSTR lpszPassword, + DWORD dwService, + DWORD dwFlags, + DWORD_PTR dwContext +); + + +HINTERNET InternetConnectW( + HINTERNET hInternet, + LPCWSTR lpszServerName, + INTERNET_PORT nServerPort, + LPCWSTR lpszUserName, + LPCWSTR lpszPassword, + DWORD dwService, + DWORD dwFlags, + DWORD_PTR dwContext +); + +HINTERNET HttpOpenRequestA( + HINTERNET hConnect, + LPCSTR lpszVerb, + LPCSTR lpszObjectName, + LPCSTR lpszVersion, + LPCSTR lpszReferrer, + LPCSTR *lplpszAcceptTypes, + DWORD dwFlags, + DWORD_PTR dwContext +); + +HINTERNET HttpOpenRequestW( + HINTERNET hConnect, + LPCWSTR lpszVerb, + LPCWSTR lpszObjectName, + LPCWSTR lpszVersion, + LPCWSTR lpszReferrer, + LPCWSTR *lplpszAcceptTypes, + DWORD dwFlags, + DWORD_PTR dwContext +); + +BOOL InternetSetOptionA( + HINTERNET hInternet, + DWORD dwOption, + LPVOID lpBuffer, + DWORD dwBufferLength +); + +BOOL InternetSetOptionW( + HINTERNET hInternet, + DWORD dwOption, + LPVOID lpBuffer, + DWORD dwBufferLength +); + +BOOL HttpSendRequestA( + HINTERNET hRequest, + LPCSTR lpszHeaders, + DWORD dwHeadersLength, + LPVOID lpOptional, + DWORD dwOptionalLength +); + +BOOL HttpSendRequestW( + HINTERNET hRequest, + LPCWSTR lpszHeaders, + DWORD dwHeadersLength, + LPVOID lpOptional, + DWORD dwOptionalLength +); + +BOOL InternetReadFile( + HINTERNET hFile, + LPVOID lpBuffer, + DWORD dwNumberOfBytesToRead, + LPDWORD lpdwNumberOfBytesRead +); + + +BOOL InternetReadFileExA( + HINTERNET hFile, + LPINTERNET_BUFFERSA lpBuffersOut, + DWORD dwFlags, + DWORD_PTR dwContext +); + +BOOL InternetReadFileExW( + HINTERNET hFile, + LPINTERNET_BUFFERSW lpBuffersOut, + DWORD dwFlags, + DWORD_PTR dwContext +); + +BOOL HttpQueryInfoA( + HINTERNET hRequest, + DWORD dwInfoLevel, + LPVOID lpBuffer, + LPDWORD lpdwBufferLength, + LPDWORD lpdwIndex +); + +BOOL HttpQueryInfoW( + HINTERNET hRequest, + DWORD dwInfoLevel, + LPVOID lpBuffer, + LPDWORD lpdwBufferLength, + LPDWORD lpdwIndex +); + +BOOL HttpSendRequestA( + HINTERNET hRequest, + LPCSTR lpszHeaders, + DWORD dwHeadersLength, + LPVOID lpOptional, + DWORD dwOptionalLength +); + +BOOL HttpSendRequestW( + HINTERNET hRequest, + LPCWSTR lpszHeaders, + DWORD dwHeadersLength, + LPVOID lpOptional, + DWORD dwOptionalLength +); \ No newline at end of file diff --git a/ctypes_generation/definitions/functions/service.txt b/ctypes_generation/definitions/functions/service.txt index 643d66a..d689a19 100644 --- a/ctypes_generation/definitions/functions/service.txt +++ b/ctypes_generation/definitions/functions/service.txt @@ -264,4 +264,12 @@ SC_HANDLE CreateServiceW( BOOL DeleteService( SC_HANDLE hService +); + +BOOL StartServiceCtrlDispatcherA( + SERVICE_TABLE_ENTRYA *lpServiceStartTable +); + +BOOL StartServiceCtrlDispatcherW( + SERVICE_TABLE_ENTRYW *lpServiceStartTable ); \ No newline at end of file diff --git a/ctypes_generation/definitions/simple_types.txt b/ctypes_generation/definitions/simple_types.txt index df3da0d..3ff6bd4 100644 --- a/ctypes_generation/definitions/simple_types.txt +++ b/ctypes_generation/definitions/simple_types.txt @@ -20,6 +20,7 @@ LONG_PTR = PVOID DWORD_PTR = ULONG_PTR KAFFINITY = ULONG_PTR KPRIORITY = LONG +INTERNET_PORT = WORD CHAR = c_char PCHAR = POINTER(CHAR) @@ -140,6 +141,7 @@ PLSA_HANDLE = POINTER(LSA_HANDLE) HDSKSPC = HANDLE // Define type for reference to device information set HDEVINFO = HANDLE +HINTERNET = PVOID /* Network */ @@ -234,6 +236,8 @@ ENUMRESNAMEPROCA = PVOID # Resources ENUMRESNAMEPROCW = PVOID # Resources ENUMRESTYPEPROCA = PVOID # Resources ENUMRESTYPEPROCW = PVOID # Resources +LPSERVICE_MAIN_FUNCTIONA = PVOID +LPSERVICE_MAIN_FUNCTIONW = PVOID // Will be changed at import time diff --git a/ctypes_generation/definitions/structures/internet.txt b/ctypes_generation/definitions/structures/internet.txt new file mode 100644 index 0000000..b356f39 --- /dev/null +++ b/ctypes_generation/definitions/structures/internet.txt @@ -0,0 +1,25 @@ +typedef struct _INTERNET_BUFFERSA { + DWORD dwStructSize; + struct _INTERNET_BUFFERSA *Next; + LPCSTR lpcszHeader; + DWORD dwHeadersLength; + DWORD dwHeadersTotal; + LPVOID lpvBuffer; + DWORD dwBufferLength; + DWORD dwBufferTotal; + DWORD dwOffsetLow; + DWORD dwOffsetHigh; +} INTERNET_BUFFERSA, *LPINTERNET_BUFFERSA; + +typedef struct _INTERNET_BUFFERSW { + DWORD dwStructSize; + struct _INTERNET_BUFFERSW *Next; + LPCWSTR lpcszHeader; + DWORD dwHeadersLength; + DWORD dwHeadersTotal; + LPVOID lpvBuffer; + DWORD dwBufferLength; + DWORD dwBufferTotal; + DWORD dwOffsetLow; + DWORD dwOffsetHigh; +} INTERNET_BUFFERSW, *LPINTERNET_BUFFERSW; \ No newline at end of file diff --git a/ctypes_generation/definitions/structures/service.txt b/ctypes_generation/definitions/structures/service.txt index a0d1c99..9e1cd2e 100644 --- a/ctypes_generation/definitions/structures/service.txt +++ b/ctypes_generation/definitions/structures/service.txt @@ -82,4 +82,16 @@ typedef struct _QUERY_SERVICE_CONFIGW { LPWSTR lpDependencies; LPWSTR lpServiceStartName; LPWSTR lpDisplayName; -} QUERY_SERVICE_CONFIGW, *LPQUERY_SERVICE_CONFIGW; \ No newline at end of file +} QUERY_SERVICE_CONFIGW, *LPQUERY_SERVICE_CONFIGW; + + +typedef struct _SERVICE_TABLE_ENTRYA { + LPSTR lpServiceName; + LPSERVICE_MAIN_FUNCTIONA lpServiceProc; +} SERVICE_TABLE_ENTRYA, *LPSERVICE_TABLE_ENTRYA; + + +typedef struct _SERVICE_TABLE_ENTRYW { + LPWSTR lpServiceName; + LPSERVICE_MAIN_FUNCTIONW lpServiceProc; +} SERVICE_TABLE_ENTRYW, *LPSERVICE_TABLE_ENTRYW; \ No newline at end of file diff --git a/docs/source/winstructs_generated.rst b/docs/source/winstructs_generated.rst index 0a300cd..ce2ba7c 100644 --- a/docs/source/winstructs_generated.rst +++ b/docs/source/winstructs_generated.rst @@ -8360,6 +8360,128 @@ _GUID :class:`BYTE` ``[8]`` +_INTERNET_BUFFERSA +'''''''''''''''''' +.. class:: INTERNET_BUFFERSA + + Alias for :class:`_INTERNET_BUFFERSA` + +.. class:: LPINTERNET_BUFFERSA + + Pointer to :class:`_INTERNET_BUFFERSA` + +.. class:: _INTERNET_BUFFERSA + + .. attribute:: dwStructSize + + :class:`DWORD` + + + .. attribute:: Next + + :class:`_INTERNET_BUFFERSA` + + + .. attribute:: lpcszHeader + + :class:`LPCSTR` + + + .. attribute:: dwHeadersLength + + :class:`DWORD` + + + .. attribute:: dwHeadersTotal + + :class:`DWORD` + + + .. attribute:: lpvBuffer + + :class:`LPVOID` + + + .. attribute:: dwBufferLength + + :class:`DWORD` + + + .. attribute:: dwBufferTotal + + :class:`DWORD` + + + .. attribute:: dwOffsetLow + + :class:`DWORD` + + + .. attribute:: dwOffsetHigh + + :class:`DWORD` + +_INTERNET_BUFFERSW +'''''''''''''''''' +.. class:: LPINTERNET_BUFFERSW + + Pointer to :class:`_INTERNET_BUFFERSW` + +.. class:: INTERNET_BUFFERSW + + Alias for :class:`_INTERNET_BUFFERSW` + +.. class:: _INTERNET_BUFFERSW + + .. attribute:: dwStructSize + + :class:`DWORD` + + + .. attribute:: Next + + :class:`_INTERNET_BUFFERSW` + + + .. attribute:: lpcszHeader + + :class:`LPCWSTR` + + + .. attribute:: dwHeadersLength + + :class:`DWORD` + + + .. attribute:: dwHeadersTotal + + :class:`DWORD` + + + .. attribute:: lpvBuffer + + :class:`LPVOID` + + + .. attribute:: dwBufferLength + + :class:`DWORD` + + + .. attribute:: dwBufferTotal + + :class:`DWORD` + + + .. attribute:: dwOffsetLow + + :class:`DWORD` + + + .. attribute:: dwOffsetHigh + + :class:`DWORD` + _LSA_OBJECT_ATTRIBUTES '''''''''''''''''''''' .. class:: PLSA_OBJECT_ATTRIBUTES @@ -12763,6 +12885,48 @@ _QUERY_SERVICE_CONFIGW :class:`LPWSTR` +_SERVICE_TABLE_ENTRYA +''''''''''''''''''''' +.. class:: LPSERVICE_TABLE_ENTRYA + + Pointer to :class:`_SERVICE_TABLE_ENTRYA` + +.. class:: SERVICE_TABLE_ENTRYA + + Alias for :class:`_SERVICE_TABLE_ENTRYA` + +.. class:: _SERVICE_TABLE_ENTRYA + + .. attribute:: lpServiceName + + :class:`LPSTR` + + + .. attribute:: lpServiceProc + + :class:`LPSERVICE_MAIN_FUNCTIONA` + +_SERVICE_TABLE_ENTRYW +''''''''''''''''''''' +.. class:: SERVICE_TABLE_ENTRYW + + Alias for :class:`_SERVICE_TABLE_ENTRYW` + +.. class:: LPSERVICE_TABLE_ENTRYW + + Pointer to :class:`_SERVICE_TABLE_ENTRYW` + +.. class:: _SERVICE_TABLE_ENTRYW + + .. attribute:: lpServiceName + + :class:`LPWSTR` + + + .. attribute:: lpServiceProc + + :class:`LPSERVICE_MAIN_FUNCTIONW` + _SP_DEVICE_INTERFACE_DATA ''''''''''''''''''''''''' .. class:: PSP_DEVICE_INTERFACE_DATA @@ -22951,6 +23115,8 @@ Simple types .. autoclass:: KPRIORITY +.. autoclass:: INTERNET_PORT + .. autoclass:: CHAR .. class:: PCHAR @@ -23181,6 +23347,8 @@ Simple types .. autoclass:: HDEVINFO +.. autoclass:: HINTERNET + .. autoclass:: IP4_ADDRESS .. autoclass:: PSECURITY_DESCRIPTOR @@ -23335,6 +23503,10 @@ Simple types .. autoclass:: ENUMRESTYPEPROCW +.. autoclass:: LPSERVICE_MAIN_FUNCTIONA + +.. autoclass:: LPSERVICE_MAIN_FUNCTIONW + .. autoclass:: LPCONTEXT .. autoclass:: HCERTSTORE diff --git a/windows/generated_def/meta.py b/windows/generated_def/meta.py index ebba923..2689442 100644 --- a/windows/generated_def/meta.py +++ b/windows/generated_def/meta.py @@ -11762,6 +11762,8 @@ structs = set(['ACCESS_ALLOWED_ACE', 'IMAGE_OPTIONAL_HEADER32', 'IMAGE_OPTIONAL_HEADER64', 'IMAGE_SECTION_HEADER', + 'INTERNET_BUFFERSA', + 'INTERNET_BUFFERSW', 'IO_DES', 'IO_Des_s', 'IO_RANGE', @@ -11823,6 +11825,8 @@ structs = set(['ACCESS_ALLOWED_ACE', 'LPFUNCDESC', 'LPGUID', 'LPIDLDESC', + 'LPINTERNET_BUFFERSA', + 'LPINTERNET_BUFFERSW', 'LPJIT_DEBUG_INFO', 'LPLOAD_DLL_DEBUG_INFO', 'LPOSVERSIONINFOA', @@ -11844,6 +11848,8 @@ structs = set(['ACCESS_ALLOWED_ACE', 'LPSECURITY_ATTRIBUTES', 'LPSERVICE_STATUS', 'LPSERVICE_STATUS_PROCESS', + 'LPSERVICE_TABLE_ENTRYA', + 'LPSERVICE_TABLE_ENTRYW', 'LPSHFILEOPSTRUCTA', 'LPSTACKFRAME', 'LPSTACKFRAME64', @@ -12512,6 +12518,8 @@ structs = set(['ACCESS_ALLOWED_ACE', 'SECURITY_QUALITY_OF_SERVICE', 'SERVICE_STATUS', 'SERVICE_STATUS_PROCESS', + 'SERVICE_TABLE_ENTRYA', + 'SERVICE_TABLE_ENTRYW', 'SHFILEOPSTRUCTA', 'SHITEMID', 'SID_AND_ATTRIBUTES', @@ -12908,6 +12916,8 @@ structs = set(['ACCESS_ALLOWED_ACE', '_IMAGE_OPTIONAL_HEADER', '_IMAGE_OPTIONAL_HEADER64', '_IMAGE_SECTION_HEADER', + '_INTERNET_BUFFERSA', + '_INTERNET_BUFFERSW', '_IO_STATUS_BLOCK', '_IP_ADAPTER_INDEX_MAP', '_IP_INTERFACE_INFO', @@ -13025,6 +13035,8 @@ structs = set(['ACCESS_ALLOWED_ACE', '_SECURITY_QUALITY_OF_SERVICE', '_SERVICE_STATUS', '_SERVICE_STATUS_PROCESS', + '_SERVICE_TABLE_ENTRYA', + '_SERVICE_TABLE_ENTRYW', '_SHFILEOPSTRUCTA', '_SHITEMID', '_SID_AND_ATTRIBUTES', @@ -13794,9 +13806,28 @@ functions = set(['AccessCheck', 'GlobalLock', 'GlobalUnlock', 'HeapAlloc', + 'HttpOpenRequestA', + 'HttpOpenRequestW', + 'HttpQueryInfoA', + 'HttpQueryInfoW', + 'HttpSendRequestA', + 'HttpSendRequestW', 'InitializeAcl', 'InitializeProcThreadAttributeList', 'InitializeSecurityDescriptor', + 'InternetCheckConnectionA', + 'InternetCheckConnectionW', + 'InternetConnectA', + 'InternetConnectW', + 'InternetOpenA', + 'InternetOpenUrlA', + 'InternetOpenUrlW', + 'InternetOpenW', + 'InternetReadFile', + 'InternetReadFileExA', + 'InternetReadFileExW', + 'InternetSetOptionA', + 'InternetSetOptionW', 'IsDebuggerPresent', 'IsOS', 'IsValidSecurityDescriptor', @@ -14033,6 +14064,8 @@ functions = set(['AccessCheck', 'StackWalk64', 'StackWalkEx', 'StartServiceA', + 'StartServiceCtrlDispatcherA', + 'StartServiceCtrlDispatcherW', 'StartServiceW', 'StartTraceA', 'StartTraceW', diff --git a/windows/generated_def/winfuncs.py b/windows/generated_def/winfuncs.py index ebe2e22..5ab6bd5 100644 --- a/windows/generated_def/winfuncs.py +++ b/windows/generated_def/winfuncs.py @@ -1055,6 +1055,111 @@ FindCloseParams = ((1, 'hFindFile'),) HeapAllocPrototype = WINFUNCTYPE(LPVOID, HANDLE, DWORD, SIZE_T) HeapAllocParams = ((1, 'hHeap'), (1, 'dwFlags'), (1, 'dwBytes')) +#def InternetCheckConnectionA(lpszUrl, dwFlags, dwReserved): +# return InternetCheckConnectionA.ctypes_function(lpszUrl, dwFlags, dwReserved) +InternetCheckConnectionAPrototype = WINFUNCTYPE(BOOL, LPCSTR, DWORD, DWORD) +InternetCheckConnectionAParams = ((1, 'lpszUrl'), (1, 'dwFlags'), (1, 'dwReserved')) + +#def InternetCheckConnectionW(lpszUrl, dwFlags, dwReserved): +# return InternetCheckConnectionW.ctypes_function(lpszUrl, dwFlags, dwReserved) +InternetCheckConnectionWPrototype = WINFUNCTYPE(BOOL, LPCWSTR, DWORD, DWORD) +InternetCheckConnectionWParams = ((1, 'lpszUrl'), (1, 'dwFlags'), (1, 'dwReserved')) + +#def InternetOpenA(lpszAgent, dwAccessType, lpszProxy, lpszProxyBypass, dwFlags): +# return InternetOpenA.ctypes_function(lpszAgent, dwAccessType, lpszProxy, lpszProxyBypass, dwFlags) +InternetOpenAPrototype = WINFUNCTYPE(HINTERNET, LPCSTR, DWORD, LPCSTR, LPCSTR, DWORD) +InternetOpenAParams = ((1, 'lpszAgent'), (1, 'dwAccessType'), (1, 'lpszProxy'), (1, 'lpszProxyBypass'), (1, 'dwFlags')) + +#def InternetOpenW(lpszAgent, dwAccessType, lpszProxy, lpszProxyBypass, dwFlags): +# return InternetOpenW.ctypes_function(lpszAgent, dwAccessType, lpszProxy, lpszProxyBypass, dwFlags) +InternetOpenWPrototype = WINFUNCTYPE(HINTERNET, LPCWSTR, DWORD, LPCWSTR, LPCWSTR, DWORD) +InternetOpenWParams = ((1, 'lpszAgent'), (1, 'dwAccessType'), (1, 'lpszProxy'), (1, 'lpszProxyBypass'), (1, 'dwFlags')) + +#def InternetOpenUrlA(hInternet, lpszUrl, lpszHeaders, dwHeadersLength, dwFlags, dwContext): +# return InternetOpenUrlA.ctypes_function(hInternet, lpszUrl, lpszHeaders, dwHeadersLength, dwFlags, dwContext) +InternetOpenUrlAPrototype = WINFUNCTYPE(HINTERNET, HINTERNET, LPCSTR, LPCSTR, DWORD, DWORD, DWORD_PTR) +InternetOpenUrlAParams = ((1, 'hInternet'), (1, 'lpszUrl'), (1, 'lpszHeaders'), (1, 'dwHeadersLength'), (1, 'dwFlags'), (1, 'dwContext')) + +#def InternetOpenUrlW(hInternet, lpszUrl, lpszHeaders, dwHeadersLength, dwFlags, dwContext): +# return InternetOpenUrlW.ctypes_function(hInternet, lpszUrl, lpszHeaders, dwHeadersLength, dwFlags, dwContext) +InternetOpenUrlWPrototype = WINFUNCTYPE(HINTERNET, HINTERNET, LPCWSTR, LPCWSTR, DWORD, DWORD, DWORD_PTR) +InternetOpenUrlWParams = ((1, 'hInternet'), (1, 'lpszUrl'), (1, 'lpszHeaders'), (1, 'dwHeadersLength'), (1, 'dwFlags'), (1, 'dwContext')) + +#def InternetConnectA(hInternet, lpszServerName, nServerPort, lpszUserName, lpszPassword, dwService, dwFlags, dwContext): +# return InternetConnectA.ctypes_function(hInternet, lpszServerName, nServerPort, lpszUserName, lpszPassword, dwService, dwFlags, dwContext) +InternetConnectAPrototype = WINFUNCTYPE(HINTERNET, HINTERNET, LPCSTR, INTERNET_PORT, LPCSTR, LPCSTR, DWORD, DWORD, DWORD_PTR) +InternetConnectAParams = ((1, 'hInternet'), (1, 'lpszServerName'), (1, 'nServerPort'), (1, 'lpszUserName'), (1, 'lpszPassword'), (1, 'dwService'), (1, 'dwFlags'), (1, 'dwContext')) + +#def InternetConnectW(hInternet, lpszServerName, nServerPort, lpszUserName, lpszPassword, dwService, dwFlags, dwContext): +# return InternetConnectW.ctypes_function(hInternet, lpszServerName, nServerPort, lpszUserName, lpszPassword, dwService, dwFlags, dwContext) +InternetConnectWPrototype = WINFUNCTYPE(HINTERNET, HINTERNET, LPCWSTR, INTERNET_PORT, LPCWSTR, LPCWSTR, DWORD, DWORD, DWORD_PTR) +InternetConnectWParams = ((1, 'hInternet'), (1, 'lpszServerName'), (1, 'nServerPort'), (1, 'lpszUserName'), (1, 'lpszPassword'), (1, 'dwService'), (1, 'dwFlags'), (1, 'dwContext')) + +#def HttpOpenRequestA(hConnect, lpszVerb, lpszObjectName, lpszVersion, lpszReferrer, lplpszAcceptTypes, dwFlags, dwContext): +# return HttpOpenRequestA.ctypes_function(hConnect, lpszVerb, lpszObjectName, lpszVersion, lpszReferrer, lplpszAcceptTypes, dwFlags, dwContext) +HttpOpenRequestAPrototype = WINFUNCTYPE(HINTERNET, HINTERNET, LPCSTR, LPCSTR, LPCSTR, LPCSTR, POINTER(LPCSTR), DWORD, DWORD_PTR) +HttpOpenRequestAParams = ((1, 'hConnect'), (1, 'lpszVerb'), (1, 'lpszObjectName'), (1, 'lpszVersion'), (1, 'lpszReferrer'), (1, 'lplpszAcceptTypes'), (1, 'dwFlags'), (1, 'dwContext')) + +#def HttpOpenRequestW(hConnect, lpszVerb, lpszObjectName, lpszVersion, lpszReferrer, lplpszAcceptTypes, dwFlags, dwContext): +# return HttpOpenRequestW.ctypes_function(hConnect, lpszVerb, lpszObjectName, lpszVersion, lpszReferrer, lplpszAcceptTypes, dwFlags, dwContext) +HttpOpenRequestWPrototype = WINFUNCTYPE(HINTERNET, HINTERNET, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR, POINTER(LPCWSTR), DWORD, DWORD_PTR) +HttpOpenRequestWParams = ((1, 'hConnect'), (1, 'lpszVerb'), (1, 'lpszObjectName'), (1, 'lpszVersion'), (1, 'lpszReferrer'), (1, 'lplpszAcceptTypes'), (1, 'dwFlags'), (1, 'dwContext')) + +#def InternetSetOptionA(hInternet, dwOption, lpBuffer, dwBufferLength): +# return InternetSetOptionA.ctypes_function(hInternet, dwOption, lpBuffer, dwBufferLength) +InternetSetOptionAPrototype = WINFUNCTYPE(BOOL, HINTERNET, DWORD, LPVOID, DWORD) +InternetSetOptionAParams = ((1, 'hInternet'), (1, 'dwOption'), (1, 'lpBuffer'), (1, 'dwBufferLength')) + +#def InternetSetOptionW(hInternet, dwOption, lpBuffer, dwBufferLength): +# return InternetSetOptionW.ctypes_function(hInternet, dwOption, lpBuffer, dwBufferLength) +InternetSetOptionWPrototype = WINFUNCTYPE(BOOL, HINTERNET, DWORD, LPVOID, DWORD) +InternetSetOptionWParams = ((1, 'hInternet'), (1, 'dwOption'), (1, 'lpBuffer'), (1, 'dwBufferLength')) + +#def HttpSendRequestA(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength): +# return HttpSendRequestA.ctypes_function(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength) +HttpSendRequestAPrototype = WINFUNCTYPE(BOOL, HINTERNET, LPCSTR, DWORD, LPVOID, DWORD) +HttpSendRequestAParams = ((1, 'hRequest'), (1, 'lpszHeaders'), (1, 'dwHeadersLength'), (1, 'lpOptional'), (1, 'dwOptionalLength')) + +#def HttpSendRequestW(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength): +# return HttpSendRequestW.ctypes_function(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength) +HttpSendRequestWPrototype = WINFUNCTYPE(BOOL, HINTERNET, LPCWSTR, DWORD, LPVOID, DWORD) +HttpSendRequestWParams = ((1, 'hRequest'), (1, 'lpszHeaders'), (1, 'dwHeadersLength'), (1, 'lpOptional'), (1, 'dwOptionalLength')) + +#def InternetReadFile(hFile, lpBuffer, dwNumberOfBytesToRead, lpdwNumberOfBytesRead): +# return InternetReadFile.ctypes_function(hFile, lpBuffer, dwNumberOfBytesToRead, lpdwNumberOfBytesRead) +InternetReadFilePrototype = WINFUNCTYPE(BOOL, HINTERNET, LPVOID, DWORD, LPDWORD) +InternetReadFileParams = ((1, 'hFile'), (1, 'lpBuffer'), (1, 'dwNumberOfBytesToRead'), (1, 'lpdwNumberOfBytesRead')) + +#def InternetReadFileExA(hFile, lpBuffersOut, dwFlags, dwContext): +# return InternetReadFileExA.ctypes_function(hFile, lpBuffersOut, dwFlags, dwContext) +InternetReadFileExAPrototype = WINFUNCTYPE(BOOL, HINTERNET, LPINTERNET_BUFFERSA, DWORD, DWORD_PTR) +InternetReadFileExAParams = ((1, 'hFile'), (1, 'lpBuffersOut'), (1, 'dwFlags'), (1, 'dwContext')) + +#def InternetReadFileExW(hFile, lpBuffersOut, dwFlags, dwContext): +# return InternetReadFileExW.ctypes_function(hFile, lpBuffersOut, dwFlags, dwContext) +InternetReadFileExWPrototype = WINFUNCTYPE(BOOL, HINTERNET, LPINTERNET_BUFFERSW, DWORD, DWORD_PTR) +InternetReadFileExWParams = ((1, 'hFile'), (1, 'lpBuffersOut'), (1, 'dwFlags'), (1, 'dwContext')) + +#def HttpQueryInfoA(hRequest, dwInfoLevel, lpBuffer, lpdwBufferLength, lpdwIndex): +# return HttpQueryInfoA.ctypes_function(hRequest, dwInfoLevel, lpBuffer, lpdwBufferLength, lpdwIndex) +HttpQueryInfoAPrototype = WINFUNCTYPE(BOOL, HINTERNET, DWORD, LPVOID, LPDWORD, LPDWORD) +HttpQueryInfoAParams = ((1, 'hRequest'), (1, 'dwInfoLevel'), (1, 'lpBuffer'), (1, 'lpdwBufferLength'), (1, 'lpdwIndex')) + +#def HttpQueryInfoW(hRequest, dwInfoLevel, lpBuffer, lpdwBufferLength, lpdwIndex): +# return HttpQueryInfoW.ctypes_function(hRequest, dwInfoLevel, lpBuffer, lpdwBufferLength, lpdwIndex) +HttpQueryInfoWPrototype = WINFUNCTYPE(BOOL, HINTERNET, DWORD, LPVOID, LPDWORD, LPDWORD) +HttpQueryInfoWParams = ((1, 'hRequest'), (1, 'dwInfoLevel'), (1, 'lpBuffer'), (1, 'lpdwBufferLength'), (1, 'lpdwIndex')) + +#def HttpSendRequestA(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength): +# return HttpSendRequestA.ctypes_function(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength) +HttpSendRequestAPrototype = WINFUNCTYPE(BOOL, HINTERNET, LPCSTR, DWORD, LPVOID, DWORD) +HttpSendRequestAParams = ((1, 'hRequest'), (1, 'lpszHeaders'), (1, 'dwHeadersLength'), (1, 'lpOptional'), (1, 'dwOptionalLength')) + +#def HttpSendRequestW(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength): +# return HttpSendRequestW.ctypes_function(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength) +HttpSendRequestWPrototype = WINFUNCTYPE(BOOL, HINTERNET, LPCWSTR, DWORD, LPVOID, DWORD) +HttpSendRequestWParams = ((1, 'hRequest'), (1, 'lpszHeaders'), (1, 'dwHeadersLength'), (1, 'lpOptional'), (1, 'dwOptionalLength')) + #def LsaOpenPolicy(SystemName, ObjectAttributes, DesiredAccess, PolicyHandle): # return LsaOpenPolicy.ctypes_function(SystemName, ObjectAttributes, DesiredAccess, PolicyHandle) LsaOpenPolicyPrototype = WINFUNCTYPE(NTSTATUS, PLSA_UNICODE_STRING, PLSA_OBJECT_ATTRIBUTES, ACCESS_MASK, PLSA_HANDLE) @@ -1770,6 +1875,16 @@ CreateServiceWParams = ((1, 'hSCManager'), (1, 'lpServiceName'), (1, 'lpDisplayN DeleteServicePrototype = WINFUNCTYPE(BOOL, SC_HANDLE) DeleteServiceParams = ((1, 'hService'),) +#def StartServiceCtrlDispatcherA(lpServiceStartTable): +# return StartServiceCtrlDispatcherA.ctypes_function(lpServiceStartTable) +StartServiceCtrlDispatcherAPrototype = WINFUNCTYPE(BOOL, POINTER(SERVICE_TABLE_ENTRYA)) +StartServiceCtrlDispatcherAParams = ((1, 'lpServiceStartTable'),) + +#def StartServiceCtrlDispatcherW(lpServiceStartTable): +# return StartServiceCtrlDispatcherW.ctypes_function(lpServiceStartTable) +StartServiceCtrlDispatcherWPrototype = WINFUNCTYPE(BOOL, POINTER(SERVICE_TABLE_ENTRYW)) +StartServiceCtrlDispatcherWParams = ((1, 'lpServiceStartTable'),) + #def SetupDiClassNameFromGuidA(ClassGuid, ClassName, ClassNameSize, RequiredSize): # return SetupDiClassNameFromGuidA.ctypes_function(ClassGuid, ClassName, ClassNameSize, RequiredSize) SetupDiClassNameFromGuidAPrototype = WINFUNCTYPE(BOOL, POINTER(GUID), PSTR, DWORD, PDWORD) diff --git a/windows/generated_def/winstructs.py b/windows/generated_def/winstructs.py index 20ae306..74851af 100644 --- a/windows/generated_def/winstructs.py +++ b/windows/generated_def/winstructs.py @@ -75,6 +75,7 @@ LONG_PTR = PVOID DWORD_PTR = ULONG_PTR KAFFINITY = ULONG_PTR KPRIORITY = LONG +INTERNET_PORT = WORD CHAR = c_char PCHAR = POINTER(CHAR) UCHAR = c_char @@ -169,6 +170,7 @@ LSA_HANDLE = HANDLE PLSA_HANDLE = POINTER(LSA_HANDLE) HDSKSPC = HANDLE HDEVINFO = HANDLE +HINTERNET = PVOID IP4_ADDRESS = DWORD PSECURITY_DESCRIPTOR = PVOID SECURITY_DESCRIPTOR_CONTROL = WORD @@ -282,6 +284,8 @@ ENUMRESNAMEPROCA = PVOID#Resources ENUMRESNAMEPROCW = PVOID#Resources ENUMRESTYPEPROCA = PVOID#Resources ENUMRESTYPEPROCW = PVOID#Resources +LPSERVICE_MAIN_FUNCTIONA = PVOID +LPSERVICE_MAIN_FUNCTIONW = PVOID LPCONTEXT = PVOID HCERTSTORE = PVOID HCRYPTMSG = PVOID @@ -1160,6 +1164,40 @@ class _ATTACH_VIRTUAL_DISK_PARAMETERS(Structure): ATTACH_VIRTUAL_DISK_PARAMETERS = _ATTACH_VIRTUAL_DISK_PARAMETERS PATTACH_VIRTUAL_DISK_PARAMETERS = POINTER(_ATTACH_VIRTUAL_DISK_PARAMETERS) +# Self referencing struct tricks +class _INTERNET_BUFFERSA(Structure): pass +INTERNET_BUFFERSA = _INTERNET_BUFFERSA +LPINTERNET_BUFFERSA = POINTER(_INTERNET_BUFFERSA) +_INTERNET_BUFFERSA._fields_ = [ + ("dwStructSize", DWORD), + ("Next", POINTER(_INTERNET_BUFFERSA)), + ("lpcszHeader", LPCSTR), + ("dwHeadersLength", DWORD), + ("dwHeadersTotal", DWORD), + ("lpvBuffer", LPVOID), + ("dwBufferLength", DWORD), + ("dwBufferTotal", DWORD), + ("dwOffsetLow", DWORD), + ("dwOffsetHigh", DWORD), +] + +# Self referencing struct tricks +class _INTERNET_BUFFERSW(Structure): pass +LPINTERNET_BUFFERSW = POINTER(_INTERNET_BUFFERSW) +INTERNET_BUFFERSW = _INTERNET_BUFFERSW +_INTERNET_BUFFERSW._fields_ = [ + ("dwStructSize", DWORD), + ("Next", POINTER(_INTERNET_BUFFERSW)), + ("lpcszHeader", LPCWSTR), + ("dwHeadersLength", DWORD), + ("dwHeadersTotal", DWORD), + ("lpvBuffer", LPVOID), + ("dwBufferLength", DWORD), + ("dwBufferTotal", DWORD), + ("dwOffsetLow", DWORD), + ("dwOffsetHigh", DWORD), +] + ProcessDEPPolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessDEPPolicy", 0x0) ProcessASLRPolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessASLRPolicy", 0x1) ProcessDynamicCodePolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessDynamicCodePolicy", 0x2) @@ -2517,6 +2555,22 @@ class _QUERY_SERVICE_CONFIGW(Structure): LPQUERY_SERVICE_CONFIGW = POINTER(_QUERY_SERVICE_CONFIGW) QUERY_SERVICE_CONFIGW = _QUERY_SERVICE_CONFIGW +class _SERVICE_TABLE_ENTRYA(Structure): + _fields_ = [ + ("lpServiceName", LPSTR), + ("lpServiceProc", LPSERVICE_MAIN_FUNCTIONA), + ] +LPSERVICE_TABLE_ENTRYA = POINTER(_SERVICE_TABLE_ENTRYA) +SERVICE_TABLE_ENTRYA = _SERVICE_TABLE_ENTRYA + +class _SERVICE_TABLE_ENTRYW(Structure): + _fields_ = [ + ("lpServiceName", LPWSTR), + ("lpServiceProc", LPSERVICE_MAIN_FUNCTIONW), + ] +SERVICE_TABLE_ENTRYW = _SERVICE_TABLE_ENTRYW +LPSERVICE_TABLE_ENTRYW = POINTER(_SERVICE_TABLE_ENTRYW) + class _SP_DEVICE_INTERFACE_DATA(Structure): _fields_ = [ ("cbSize", DWORD), diff --git a/windows/winproxy/apis/__init__.py b/windows/winproxy/apis/__init__.py index dfbad8c..a218ce7 100644 --- a/windows/winproxy/apis/__init__.py +++ b/windows/winproxy/apis/__init__.py @@ -19,4 +19,5 @@ from .user32 import * from .version import * from .virtdisk import * from .wevtapi import * +from .wininet import * from .wintrust import * \ No newline at end of file diff --git a/windows/winproxy/apis/wininet.py b/windows/winproxy/apis/wininet.py new file mode 100644 index 0000000..0f4117e --- /dev/null +++ b/windows/winproxy/apis/wininet.py @@ -0,0 +1,95 @@ +import ctypes +import windows.generated_def as gdef + +from ..apiproxy import ApiProxy, NeededParameter + +from ..error import (fail_on_zero) + + +class WinInetProxy(ApiProxy): + APIDLL = "wininet" + default_error_check = staticmethod(fail_on_zero) + +@WinInetProxy() +def InternetCheckConnectionA(lpszUrl, dwFlags, dwReserved): + return InternetCheckConnectionA.ctypes_function(lpszUrl, dwFlags, dwReserved) + +@WinInetProxy() +def InternetCheckConnectionW(lpszUrl, dwFlags, dwReserved): + return InternetCheckConnectionW.ctypes_function(lpszUrl, dwFlags, dwReserved) + +@WinInetProxy() +def InternetOpenA(lpszAgent, dwAccessType, lpszProxy, lpszProxyBypass, dwFlags): + return InternetOpenA.ctypes_function(lpszAgent, dwAccessType, lpszProxy, lpszProxyBypass, dwFlags) + +@WinInetProxy() +def InternetOpenW(lpszAgent, dwAccessType, lpszProxy, lpszProxyBypass, dwFlags): + return InternetOpenW.ctypes_function(lpszAgent, dwAccessType, lpszProxy, lpszProxyBypass, dwFlags) + +@WinInetProxy() +def InternetOpenUrlA(hInternet, lpszUrl, lpszHeaders, dwHeadersLength, dwFlags, dwContext): + return InternetOpenUrlA.ctypes_function(hInternet, lpszUrl, lpszHeaders, dwHeadersLength, dwFlags, dwContext) + +@WinInetProxy() +def InternetOpenUrlW(hInternet, lpszUrl, lpszHeaders, dwHeadersLength, dwFlags, dwContext): + return InternetOpenUrlW.ctypes_function(hInternet, lpszUrl, lpszHeaders, dwHeadersLength, dwFlags, dwContext) + +@WinInetProxy() +def InternetConnectA(hInternet, lpszServerName, nServerPort, lpszUserName, lpszPassword, dwService, dwFlags, dwContext): + return InternetConnectA.ctypes_function(hInternet, lpszServerName, nServerPort, lpszUserName, lpszPassword, dwService, dwFlags, dwContext) + +@WinInetProxy() +def InternetConnectW(hInternet, lpszServerName, nServerPort, lpszUserName, lpszPassword, dwService, dwFlags, dwContext): + return InternetConnectW.ctypes_function(hInternet, lpszServerName, nServerPort, lpszUserName, lpszPassword, dwService, dwFlags, dwContext) + +@WinInetProxy() +def HttpOpenRequestA(hConnect, lpszVerb, lpszObjectName, lpszVersion, lpszReferrer, lplpszAcceptTypes, dwFlags, dwContext): + return HttpOpenRequestA.ctypes_function(hConnect, lpszVerb, lpszObjectName, lpszVersion, lpszReferrer, lplpszAcceptTypes, dwFlags, dwContext) + +@WinInetProxy() +def HttpOpenRequestW(hConnect, lpszVerb, lpszObjectName, lpszVersion, lpszReferrer, lplpszAcceptTypes, dwFlags, dwContext): + return HttpOpenRequestW.ctypes_function(hConnect, lpszVerb, lpszObjectName, lpszVersion, lpszReferrer, lplpszAcceptTypes, dwFlags, dwContext) + +@WinInetProxy() +def InternetSetOptionA(hInternet, dwOption, lpBuffer, dwBufferLength): + return InternetSetOptionA.ctypes_function(hInternet, dwOption, lpBuffer, dwBufferLength) + +@WinInetProxy() +def InternetSetOptionW(hInternet, dwOption, lpBuffer, dwBufferLength): + return InternetSetOptionW.ctypes_function(hInternet, dwOption, lpBuffer, dwBufferLength) + +@WinInetProxy() +def HttpSendRequestA(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength): + return HttpSendRequestA.ctypes_function(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength) + +@WinInetProxy() +def HttpSendRequestW(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength): + return HttpSendRequestW.ctypes_function(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength) + +@WinInetProxy() +def InternetReadFile(hFile, lpBuffer, dwNumberOfBytesToRead, lpdwNumberOfBytesRead): + return InternetReadFile.ctypes_function(hFile, lpBuffer, dwNumberOfBytesToRead, lpdwNumberOfBytesRead) + +@WinInetProxy() +def InternetReadFileExA(hFile, lpBuffersOut, dwFlags, dwContext): + return InternetReadFileExA.ctypes_function(hFile, lpBuffersOut, dwFlags, dwContext) + +@WinInetProxy() +def InternetReadFileExW(hFile, lpBuffersOut, dwFlags, dwContext): + return InternetReadFileExW.ctypes_function(hFile, lpBuffersOut, dwFlags, dwContext) + +@WinInetProxy() +def HttpQueryInfoA(hRequest, dwInfoLevel, lpBuffer, lpdwBufferLength, lpdwIndex): + return HttpQueryInfoA.ctypes_function(hRequest, dwInfoLevel, lpBuffer, lpdwBufferLength, lpdwIndex) + +@WinInetProxy() +def HttpQueryInfoW(hRequest, dwInfoLevel, lpBuffer, lpdwBufferLength, lpdwIndex): + return HttpQueryInfoW.ctypes_function(hRequest, dwInfoLevel, lpBuffer, lpdwBufferLength, lpdwIndex) + +@WinInetProxy() +def HttpSendRequestA(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength): + return HttpSendRequestA.ctypes_function(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength) + +@WinInetProxy() +def HttpSendRequestW(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength): + return HttpSendRequestW.ctypes_function(hRequest, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength)