Remove constrains to AttributeCount and Attribute

This is a cleanup commit. The code is still not fully functional.

Author: itziakos

win32ctypes/core/ctypes/_authentication.py

@@ -10,15 +10,8 @@
 from ctypes.wintypes import (
     BOOL, DWORD, FILETIME, LPCWSTR)
 
-from win32ctypes.core.compat import is_text
 from ._common import LPBYTE, _PyBytes_FromStringAndSize
 from ._util import function_factory, check_zero_factory, dlls
-from ._nl_support import _GetACP
-
-
-SUPPORTED_CREDKEYS = set((
-    u'Type', u'TargetName', u'Persist',
-    u'UserName', u'Comment', u'CredentialBlob'))
 
 
 class CREDENTIAL(Structure):
@@ -31,68 +24,58 @@ class CREDENTIAL(Structure):
         ("CredentialBlobSize", DWORD),
         ("CredentialBlob", LPBYTE),
         ("Persist", DWORD),
-        ("_DO_NOT_USE_AttributeCount", DWORD),
-        ("__DO_NOT_USE_Attribute", c_void_p),
+        ("AttributeCount", DWORD),
+        ("Attribute", c_void_p),
         ("TargetAlias", c_wchar_p),
         ("UserName", c_wchar_p)]
 
     @classmethod
-    def fromdict(cls, credential, flags=0):
-        unsupported = set(credential.keys()) - SUPPORTED_CREDKEYS
-        if len(unsupported):
-            raise ValueError("Unsupported keys: {0}".format(unsupported))
-        if flags != 0:
-            raise ValueError("flag != 0 not yet supported")
-
+    def fromdict(cls, credential):
         c_creds = cls()
         c_pcreds = PCREDENTIAL(c_creds)
 
         # zero-out memory
         ctypes.memset(c_pcreds, 0, ctypes.sizeof(c_creds))
 
-        for key in SUPPORTED_CREDKEYS:
-            if key in credential:
-                if key != 'CredentialBlob':
-                    setattr(c_creds, key, credential[key])
-                else:
-                    blob = make_unicode(credential['CredentialBlob'])
-                    blob_data = ctypes.create_unicode_buffer(blob)
-                    # Create_unicode_buffer adds a NULL at the end of the
-                    # string we do not want that.
-                    c_creds.CredentialBlobSize = \
-                        ctypes.sizeof(blob_data) - \
-                        ctypes.sizeof(ctypes.c_wchar)
-                    c_creds.CredentialBlob = ctypes.cast(blob_data, LPBYTE)
+        for key in credential:
+            if key == 'CredentialBlob':
+                blob_data, blob_size = _make_blob(credential['CredentialBlob'])
+                c_creds.CredentialBlob = ctypes.cast(blob_data, LPBYTE)
+                c_creds.CredentialBlobSize = blob_size
+            else:
+                setattr(c_creds, key, credential[key])
         return c_creds
 
 
 PCREDENTIAL = POINTER(CREDENTIAL)
 
 
-def make_unicode(password):
-    """ Convert the input string to unicode.
-
-    """
-    if is_text(password):
-        return password
-    else:
-        code_page = _GetACP()
-        return password.decode(encoding=str(code_page), errors='strict')
-
-
 def credential2dict(creds):
     credential = {}
-    for key in SUPPORTED_CREDKEYS:
-        if key != u'CredentialBlob':
-            credential[key] = getattr(creds, key)
-        else:
+    for key, type_ in CREDENTIAL._fields_:
+        if key == u'CredentialBlob':
             blob = _PyBytes_FromStringAndSize(
                 cast(creds.CredentialBlob, c_char_p),
                 creds.CredentialBlobSize)
             credential[u'CredentialBlob'] = blob
+        else:
+            credential[key] = getattr(creds, key)
     return credential
 
 
+def _make_blob(data):
+    """ Convert a string to credential compatible blob dict values
+
+    """
+    blob_data = ctypes.create_unicode_buffer(data)
+    # Create_unicode_buffer adds a NULL at the end of the
+    # string we do not want that.
+    blob_size = (
+        ctypes.sizeof(blob_data) - ctypes.sizeof(ctypes.c_wchar))
+    blob_pointer = ctypes.cast(blob_data, LPBYTE)
+    return blob_pointer, blob_size
+
+
 _CredWrite = function_factory(
     dlls.advapi32.CredWriteW,
     [PCREDENTIAL, DWORD],

win32ctypes/pywin32/win32cred.py

@@ -28,7 +28,7 @@ def CredWrite(Credential, Flags=0):
         ``CRED_PRESERVE_CREDENTIAL_BLOB`` or 0. Default is 0.
 
     """
-    c_creds = _authentication.CREDENTIAL.fromdict(Credential, Flags)
+    c_creds = _authentication.CREDENTIAL.fromdict(Credential)
     c_pcreds = _authentication.PCREDENTIAL(c_creds)
     with _pywin32error():
         _authentication._CredWrite(c_pcreds, 0)

win32ctypes/tests/test_win32cred.py

@@ -52,6 +52,9 @@ def test_write_to_pywin32(self):
         res = win32cred.CredRead(
             TargetName=target, Type=CRED_TYPE_GENERIC)
 
+        # XXX: the fact that we have to decode the password when reading, but
+        # not encode when writing is a bit strange, but that's what pywin32
+        # seems to do as well, and we try to be backward compatible here.
         self.assertEqual(res["Type"], CRED_TYPE_GENERIC)
         self.assertEqual(res["UserName"], username)
         self.assertEqual(res["TargetName"], target)