예제 #1
0
파일: wts.py 프로젝트: johnnnyrocket/hacks
def WinStationRename(hServer, oldName, newName):
    if hServer is None:
        hServer = win32ts.WTS_CURRENT_SERVER_HANDLE

    res = winsta.WinStationRenameW(HANDLE(hServer), LPWSTR(oldName),
                                   LPWSTR(newName))

    if res != 1:
        raise Win32Error(func="WinStationRename")
예제 #2
0
파일: win32.py 프로젝트: nmanumr/pcbasic
def _get_oem_encoding():
    """Get Windows OEM codepage."""
    hkey = HKEY()
    windll.advapi32.RegOpenKeyExW(
        HKEY_LOCAL_MACHINE, LPWSTR(u"SYSTEM\\CurrentControlSet\\Control\\Nls\\CodePage"),
        DWORD(0), DWORD(KEY_QUERY_VALUE), byref(hkey))
    strval = ctypes.create_unicode_buffer(255)
    # key HKLM SYSTEM\\CurrentControlSet\\Control\\Nls\\CodePage value OEMCP
    size = DWORD(0)
    windll.advapi32.RegQueryValueExW(hkey, LPWSTR(u"OEMCP"), DWORD(0), None, None, byref(size))
    windll.advapi32.RegQueryValueExW(hkey, LPWSTR(u"OEMCP"), DWORD(0), None, byref(strval), byref(size))
    windll.advapi32.RegCloseKey(hkey)
    return 'cp' + strval.value
def WlanGetProfile(hClientHandle, pInterfaceGuid, profileName):
    """
        The WlanGetProfile function retrieves all information about a specified
        wireless profile.

        DWORD WINAPI WlanGetProfile(
            _In_         HANDLE hClientHandle,
            _In_         const GUID *pInterfaceGuid,
            _In_         LPCWSTR strProfileName,
            _Reserved_   PVOID pReserved,
            _Out_        LPWSTR *pstrProfileXml,
            _Inout_opt_  DWORD *pdwFlags,
            _Out_opt_    PDWORD pdwGrantedAccess
        );
    """
    func_ref = wlanapi.WlanGetProfile
    func_ref.argtypes = [
        HANDLE,
        POINTER(GUID), LPCWSTR, c_void_p,
        POINTER(LPWSTR),
        POINTER(DWORD),
        POINTER(DWORD)
    ]
    func_ref.restype = DWORD
    pdw_granted_access = DWORD()
    xml = LPWSTR()
    flags = DWORD(WLAN_PROFILE_GET_PLAINTEXT_KEY)
    result = func_ref(hClientHandle, byref(pInterfaceGuid), profileName, None,
                      byref(xml), byref(flags), byref(pdw_granted_access))
    if result != ERROR_SUCCESS:
        raise Exception("WlanGetProfile failed.")
    return xml
예제 #4
0
def FormatError(code=None):
    """
    A replacement for ctypes.FormtError, but always returns the string
    encoded in CP1252 (ANSI Code Page).
    """
    if code is None:
        code = GetLastError()
    lpMsgBuf = LPWSTR()
    numChars = _kernel32.FormatMessageW(
        (
            FORMAT_MESSAGE_ALLOCATE_BUFFER |
            FORMAT_MESSAGE_FROM_SYSTEM |
            FORMAT_MESSAGE_IGNORE_INSERTS
        ),
        None,
        code,
        0,
        byref(lpMsgBuf),
        0,
        None
    )
    if numChars == 0:
        return "No error message available."
    #raise Exception("FormatMessage failed on 0x%X with 0x%X" % (code & 0xFFFFFFFF, GetLastError()))
    message = lpMsgBuf.value.strip()
    _kernel32.LocalFree(lpMsgBuf)
    return message.encode("CP1252", 'backslashreplace')
def get_final_path(path):
    """
    For a given path, determine the ultimate location of that path.
    Useful for resolving symlink targets.
    This functions wraps the GetFinalPathNameByHandle from the Windows
    SDK.

    Note, this function fails if a handle cannot be obtained (such as
    for C:\Pagefile.sys on a stock windows system). Consider using
    trace_symlink_target instead.
    """
    hFile = CreateFile(
        path,
        NULL,  # desired access
        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,  # share mode
        LPSECURITY_ATTRIBUTES(),  # NULL pointer
        OPEN_EXISTING,
        FILE_FLAG_BACKUP_SEMANTICS,
        NULL,
    )

    if hFile == INVALID_HANDLE_VALUE:
        raise WindowsError()

    buf_size = GetFinalPathNameByHandle(hFile, LPWSTR(), 0, VOLUME_NAME_DOS)
    handle_nonzero_success(buf_size)
    buf = create_unicode_buffer(buf_size)
    result_length = GetFinalPathNameByHandle(hFile, buf, len(buf), VOLUME_NAME_DOS)

    assert result_length < len(buf)
    handle_nonzero_success(result_length)
    handle_nonzero_success(CloseHandle(hFile))

    return buf[:result_length]
예제 #6
0
파일: pac.py 프로젝트: mgcfish/pupy
def detect_autoconfig_url_nt():
    if not WinHttpDetectAutoProxyConfigUrl:
        return None

    url = LPWSTR()
    if WinHttpDetectAutoProxyConfigUrl(3, byref(url)):
        result = str(url.value)
        GlobalFree(url)
        return result
예제 #7
0
def _get(uuid: UUID) -> Path:
    guid = _GUID(uuid)
    path = LPWSTR()
    if _GetFolderPath(byref(guid), 0, HANDLE(0), byref(path)) < 0:
        raise FileNotFoundError(f"Could not find guid with GUID {uuid}")
    try:
        return Path(path.value)
    finally:
        _CoTaskMemFree(path)
예제 #8
0
def get_error_str(error_code):
    if error_code == 0:
        return '[0] No error'
    bufptr = LPWSTR()
    FormatMessage(
        (FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS
         | FORMAT_MESSAGE_ARGUMENT_ARRAY | FORMAT_MESSAGE_ALLOCATE_BUFFER), 0,
        error_code, 0, byref(bufptr), 0, 0)

    s = bufptr.value.strip()
    return '[%d] %s' % (error_code, s)
예제 #9
0
def FormatMessageSystem(message_id, langid=LCID_ENGLISH):
    from xpra.platform.win32.constants import FORMAT_MESSAGE_ALLOCATE_BUFFER, FORMAT_MESSAGE_FROM_SYSTEM, FORMAT_MESSAGE_IGNORE_INSERTS
    sys_flag = FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS
    bufptr = LPWSTR()
    chars = kernel32.FormatMessageW(sys_flag, None, message_id, langid, byref(bufptr), 0, None)
    if not chars:
        chars = FormatMessageW(sys_flag, None, message_id, LCID_NEUTRAL, byref(bufptr), 0, None)
        if not chars:
            return str(message_id)
    val = bufptr.value[:chars]
    LocalFree(bufptr)
    return val
예제 #10
0
def CreateFile(filename, access, sharemode, attributes, creation, flags,
               template_file):
    # attributes and template_file ignored, kept for backward compat with
    # win32file
    return _FileHandle(HANDLE(ctypes.windll.kernel32.CreateFileW(
                       LPWSTR(filename),
                       DWORD(access),
                       DWORD(sharemode),
                       LPSECURITY_ATTRIBUTES(NULL),
                       DWORD(creation),
                       DWORD(flags),
                       HANDLE(NULL))))
예제 #11
0
 def create_item(self, logo, service, username, password, notes):
     cred_flags = DWORD(0)
     cred_type = self.CRED_TYPE_GENERIC
     # I make this the target_name because otherwise users with multiple
     # accounts on the same service won't be able to create those
     # credentials. They would end up just overwriting the same
     # credential for the service each time a new account is added.
     cred_target_name = LPWSTR(repr((service, username)))
     cred_comment = LPWSTR('')
     cred_last_written = FILETIME(0, 0)
     blob = repr((password, notes))
     cred_blob = ctypes.create_unicode_buffer(blob)
     cred_blob_size = ctypes.sizeof(cred_blob)
     cred_blob = LPBYTE(cred_blob)
     cred_persist = self.CRED_PERSIST_LOCAL_MACHINE
     cred_attribute_count = DWORD(1)
     logo_value = ctypes.cast(LPWSTR(logo), LPBYTE)
     cred_attributes = CredAttribute(LPWSTR(service + '_logo'),
                                     DWORD(0),
                                     ctypes.sizeof(logo_value),
                                     logo_value)
     cred_attributes = ctypes.pointer(cred_attributes)
     # I keep this alias to mark which credentials are created using
     # PassMan, the ones that aren't, won't be displayed.
     cred_target_alias = LPWSTR(self.alias)
     cred_username = LPWSTR(username)
     cred = Credential(cred_flags, cred_type, cred_target_name,
                       cred_comment, cred_last_written, cred_blob_size,
                       cred_blob, cred_persist, cred_attribute_count,
                       cred_attributes, cred_target_alias, cred_username)
     self.advapi32.CredWriteW(ctypes.byref(cred), 0)
     item = CredItem(service, username)
     self.collection.items.append(item)
     return item
예제 #12
0
파일: win32.py 프로젝트: nmanumr/pcbasic
def get_short_pathname(native_path):
    """Return Windows short path name or None if not available."""
    try:
        length = _GetShortPathName(native_path, LPWSTR(0), DWORD(0))
        wbuffer = ctypes.create_unicode_buffer(length)
        _GetShortPathName(native_path, wbuffer, DWORD(length))
    except Exception as e:
        # something went wrong - this should be a WindowsError which is an OSError
        # but not clear
        return None
    else:
        # can also be None in wbuffer.value if error
        return wbuffer.value
예제 #13
0
파일: wts.py 프로젝트: johnnnyrocket/hacks
def WinStationConnect(hServer,
                      SessionID,
                      TargetSessionID,
                      Password="",
                      Wait=False):
    if hServer is None:
        hServer = win32ts.WTS_CURRENT_SERVER_HANDLE

    if SessionID is None:
        SessionID = win32ts.WTS_CURRENT_SESSION

    if TargetSessionID is None:
        TargetSessionID = win32ts.WTS_CURRENT_SESSION

    res = winsta.WinStationConnectW(HANDLE(hServer), ULONG(SessionID),
                                    ULONG(TargetSessionID),
                                    LPWSTR(Password or ""), BOOL(Wait))

    if res != 1:
        raise Win32Error(func="WinStationConnect")
예제 #14
0
def _CreateOrOpenAppContainer(name: str):
    """Creates or opens a Windows app container.

  Args:
    name: Name of the app container.

  Returns:
    A `PySID` representing the SID of the AppContainer.

  Raises:
    Error: On failure.
  """
    with contextlib.ExitStack() as stack:
        psid = PSID()
        try:
            res = CreateAppContainerProfile(name, name, name, None, 0,
                                            ctypes.byref(psid))
            if res != winerror.S_OK:
                raise Error(f"CreateAppContainerProfile returned: {res}")
            stack.callback(FreeSid, psid)
        except OSError as e:
            if e.winerror != winerror.HRESULT_FROM_WIN32(
                    winerror.ERROR_ALREADY_EXISTS):
                raise
            res = DeriveAppContainerSidFromAppContainerName(
                name, ctypes.byref(psid))
            if res != winerror.S_OK:
                raise Error(
                    f"DeriveAppContainerSidFromAppContainerName returned: {res}"
                )
            stack.callback(FreeSid, psid)
        str_sid = LPWSTR()
        res = ConvertSidToStringSidW(psid, ctypes.byref(str_sid))
        if res == 0:
            raise Error(f"ConvertSidToStringSidW failed: {res}")
        stack.callback(LocalFree, str_sid)
        return win32security.ConvertStringSidToSid(str_sid.value)
예제 #15
0
 def unMapDrive(cls, name):
     m = LPWSTR(" " * 80)
     ok = cls._unMapDrive(LPWSTR(name), m)
     return ok, m.value
예제 #16
0
 def mapDrive(cls, name, path, username, password):
     m = LPWSTR(" " * 80)
     ok = cls._mapDrive(LPWSTR(name), LPWSTR(path), LPWSTR(username),
                        LPWSTR(password), m)
     return ok, m.value