Vinculação a um objeto usando um SID

No Windows Server 2003, é possível vincular a um objeto usando o SID (identificador de segurança) do objeto, bem como um GUID. O objeto SID é armazenado no atributo objectSID . A vinculação a um SID não funciona no Windows 2000.

O provedor LDAP para Serviços de Domínio Active Directory fornece um método para vincular a um objeto usando o SID do objeto. O formato de cadeia de caracteres de vinculação é:

LDAP://servername/<SID=XXXXX>

Neste exemplo, "nome_do_servidor" é o nome do servidor de diretório e "XXXXX" é a representação de cadeia de caracteres do valor hexadecimal do SID. O "nome_do_servidor" é opcional. A cadeia de caracteres SID é especificada em um formulário onde cada caractere na cadeia de caracteres é a representação hexadecimal de cada byte do SID. Por exemplo, se a matriz for:

0xAB 0x14 0xE2

a cadeia de caracteres de ligação SID seria "<SID=AB14E2>". A função ADsEncodeBinaryData não deve ser usada para converter a matriz SID em uma cadeia de caracteres porque ela precede cada caractere de byte com uma barra invertida, que não é um formato de cadeia de caracteres de ligação válido.

A cadeia de caracteres SID também pode assumir a forma "SID=S-X-X-XX-XXXXXXXXXX-XXXXXXXXXX-XXXXXXXXX-XXXXX", ONDE A PARTE "S-X-X-XX-XXXXXXXXXX-XXXXXXXXXX-XXXXXXXXX-XXXXXX"< é a mesma que a cadeia de caracteres retornada pela função ConvertSidToStringSid.>

Ao vincular usando o objeto SID, alguns métodos e propriedades IADs e IADsContainer não são suportados. As seguintes propriedades de IADs não são suportadas por objetos obtidos por associação usando o objeto SID:

• ADsPath
• Nome
• Pai

Os seguintes métodos IADsContainer não são suportados por objetos obtidos por associação usando o objeto SID:

• GetObject
• Criar
• Delete (excluir)
• CopieAqui
• Mexa-seAqui

Para usar esses métodos e propriedades depois de vincular a um objeto usando o SID do objeto, use o método IADs.Get para recuperar o nome distinto do objeto e, em seguida, use o nome distinto para vincular ao objeto novamente.

O exemplo de código a seguir mostra como converter um objectSid em uma cadeia de caracteres vinculável.

HRESULT VariantArrayToBytes(VARIANT Variant, 
    LPBYTE *ppBytes, 
    DWORD *pdwBytes);

/********

    GetSIDBindStringFromVariant()

    Converts a SID in VARIANT form, such as an objectSid value, and 
    converts it into a bindable string in the form:

    LDAP://<SID=xxxxxxx...>

    The returned string is allocated with AllocADsMem and must be 
    freed by the caller with FreeADsMem.

*********/

LPWSTR GetSIDBindStringFromVariant(VARIANT vSID)
{
    LPWSTR pwszReturn = NULL;

    if(VT_ARRAY & vSID.vt) 
    {
        HRESULT hr;
        LPBYTE pByte;
        DWORD dwBytes = 0;

        hr = VariantArrayToBytes(vSID, &pByte, &dwBytes);
        if(S_OK == hr)
        {
            // Convert the BYTE array into a string of hex 
            // characters.
            CComBSTR sbstrTemp = "LDAP://<SID=";

            for(DWORD i = 0; i < dwBytes; i++)
            {
                WCHAR wszByte[3];

                swprintf_s(wszByte, L"%02x", pByte[i]);
                sbstrTemp += wszByte;
            }

            sbstrTemp += ">";
            pwszReturn = 
               (LPWSTR)AllocADsMem((sbstrTemp.Length() + 1) * 
                sizeof(WCHAR));
            if(pwszReturn)
            {
                wcscpy_s(pwszReturn, sbstrTemp.m_str);
            }

            FreeADsMem(pByte);
        }
    }

    return pwszReturn;
}

/*********

    VariantArrayToBytes()

    This function converts a VARIANT array into an array of BYTES. 
    This function allocates the buffer using AllocADsMem. The 
    caller must free this memory with FreeADsMem when it is no 
    longer required.

**********/

HRESULT VariantArrayToBytes(VARIANT Variant, 
    LPBYTE *ppBytes, 
    DWORD *pdwBytes)
{
    if(!(Variant.vt & VT_ARRAY) ||
        !Variant.parray ||
        !ppBytes ||
        !pdwBytes)
    {
        return E_INVALIDARG;
    }

    *ppBytes = NULL;
    *pdwBytes = 0;

    HRESULT hr = E_FAIL;
    SAFEARRAY *pArrayVal = NULL;
    CHAR HUGEP *pArray = NULL;
    
    // Retrieve the safe array.
    pArrayVal = Variant.parray;
    DWORD dwBytes = pArrayVal->rgsabound[0].cElements;
    *ppBytes = (LPBYTE)AllocADsMem(dwBytes);
    if(NULL == *ppBytes) 
    {
        return E_OUTOFMEMORY;
    }

    hr = SafeArrayAccessData(pArrayVal, (void HUGEP * FAR *) &pArray);
    if(SUCCEEDED(hr))
    {
        // Copy the bytes to the safe array.
        CopyMemory(*ppBytes, pArray, dwBytes);
        SafeArrayUnaccessData( pArrayVal );
        *pdwBytes = dwBytes;
    }
    
    return hr;
}