/*++

Copyright (c) 2000  Microsoft Corporation

Module Name:

    crconv.c

Abstract:

    This module contains credential conversion routines shared between advapi32.dll and crtest.exe

Author:

    Cliff Van Dyke (CliffV)    February 25, 2000

Revision History:

--*/


DWORD
CredpConvertStringSize (
    IN WTOA_ENUM WtoA,
    IN LPWSTR String OPTIONAL
    )

/*++

Routine Description:

    Determines the size of the converted string

Arguments:

    WtoA - Specifies the direction of the string conversion.

    String - The string to convert

Return Values:

    Returns the size (in bytes) of the converted string.

--*/

{
    ULONG Size = 0;
    UNICODE_STRING UnicodeString;
    ANSI_STRING AnsiString;

    if ( String == NULL ) {
        return Size;
    }

    switch ( WtoA ) {
    case DoWtoA:
        RtlInitUnicodeString( &UnicodeString, String );
        Size = RtlUnicodeStringToAnsiSize( &UnicodeString );
        break;

    case DoAtoW:
        RtlInitAnsiString( &AnsiString, (LPSTR)String );
        Size = RtlAnsiStringToUnicodeSize( &AnsiString );
        break;
    case DoWtoW:
        Size = (wcslen( String ) + 1) * sizeof(WCHAR);
        break;
    }

    return Size;

}

DWORD
CredpConvertString (
    IN WTOA_ENUM WtoA,
    IN LPWSTR String OPTIONAL,
    OUT LPWSTR *OutString,
    IN OUT LPBYTE *WherePtr
    )

/*++

Routine Description:

    Determines the size of the converted string

Arguments:

    WtoA - Specifies the direction of the string conversion.

    String - The string to convert

    OutString - Returns the pointer to the marshaled string

    WherePtr - Specifies the address of the first byte to write the string to.
        Returns a pointer to the first byte after the marshaled string

Return Values:

    Returns the status of the conversion


--*/

{
    NTSTATUS Status;

    ULONG Size;

    UNICODE_STRING UnicodeString;
    ANSI_STRING AnsiString;
    LPBYTE Where = *WherePtr;

    if ( String == NULL ) {
        *OutString = NULL;
        return NO_ERROR;
    }

    *OutString = (LPWSTR)Where;

    switch ( WtoA ) {
    case DoWtoA:
        RtlInitUnicodeString( &UnicodeString, String );
        AnsiString.Buffer = (PCHAR)Where;
        AnsiString.MaximumLength = 0xFFFF;
        Status = RtlUnicodeStringToAnsiString( &AnsiString, &UnicodeString, FALSE );

        if ( !NT_SUCCESS(Status) ) {
            return RtlNtStatusToDosError( Status );
        }

        Where += AnsiString.Length + sizeof(CHAR);
        break;

    case DoAtoW:
        RtlInitAnsiString( &AnsiString, (LPSTR)String );
        UnicodeString.Buffer = (LPWSTR)Where;
        UnicodeString.MaximumLength = 0xFFFF;

        Status = RtlAnsiStringToUnicodeString( &UnicodeString, &AnsiString, FALSE );

        if ( !NT_SUCCESS(Status) ) {
            return RtlNtStatusToDosError( Status );
        }

        Where += UnicodeString.Length + sizeof(WCHAR);

        break;
    case DoWtoW:
        Size = (wcslen( String ) + 1) * sizeof(WCHAR);

        RtlCopyMemory( Where, String, Size );
        Where += Size;
        break;
    }

    *WherePtr = Where;
    return NO_ERROR;

}

DWORD
CredpConvertOneCredentialSize (
    IN WTOA_ENUM WtoA,
    IN PCREDENTIALW InCredential
    )

/*++

Routine Description:

    Computes the size of a converted credential

Arguments:

    WtoA - Specifies the direction of the string conversion.

    InCredential - Input credential

Return Values:

    Returns the size (in bytes) the CredpConvertOneCredential will need to
        copy this credential into a buffer.

--*/

{
    DWORD WinStatus;
    ULONG Size;

    ULONG i;

    //
    // Compute the initial size
    //

    Size = ROUND_UP_COUNT( sizeof(ENCRYPTED_CREDENTIALW), ALIGN_WORST ) +
           ROUND_UP_COUNT( InCredential->AttributeCount * sizeof(CREDENTIAL_ATTRIBUTEW), ALIGN_WORST );

    if ( InCredential->CredentialBlobSize != 0 ) {
        ULONG CredBlobSize;

        // Leave room for the encoding over the wire
        CredBlobSize = AllocatedCredBlobSize( InCredential->CredentialBlobSize );

        // Align the data following the credential blob
        Size += ROUND_UP_COUNT( CredBlobSize, ALIGN_WORST );
    }


    //
    // Compute the size of the strings in the right character set.
    //

    Size += CredpConvertStringSize( WtoA, InCredential->TargetName );
    Size += CredpConvertStringSize( WtoA, InCredential->Comment );
    Size += CredpConvertStringSize( WtoA, InCredential->TargetAlias );
    Size += CredpConvertStringSize( WtoA, InCredential->UserName );

    //
    // Compute the size of the attributes
    //

    if ( InCredential->AttributeCount != 0 ) {

        for ( i=0; i<InCredential->AttributeCount; i++ ) {

            Size += CredpConvertStringSize( WtoA, InCredential->Attributes[i].Keyword );

            Size += ROUND_UP_COUNT(InCredential->Attributes[i].ValueSize, ALIGN_WORST);

        }
    }

    Size = ROUND_UP_COUNT( Size, ALIGN_WORST );

    return Size;

}

DWORD
CredpConvertOneCredential (
    IN WTOA_ENUM WtoA,
    IN ENCODE_BLOB_ENUM DoDecode,
    IN PCREDENTIALW InCredential,
    IN OUT LPBYTE *WherePtr
    )

/*++

Routine Description:

    Converts one credential from Ansi to Unicode or vice-versa.

Arguments:

    WtoA - Specifies the direction of the string conversion.

    DoDecode - Specifies whether CredentialBlob should be encoded, decoded, or neither.
        If DoBlobDecode, then InCredential really points to a PENCRYPTED_CREDENTIALW.

    InCredential - Input credentials

    WherePtr - Specifies the address of the first byte to write the credential to.
        On input, the strucure should be aligned ALIGN_WORST.
        Returns a pointer to the first byte after the marshaled credential.
        The output credential is actually a ENCRYPTED_CREDENTIALW.  The caller
        can use it as a CREDENTIALW depending on the DoDecode value.


Return Values:

    Window status code

--*/

{
    DWORD WinStatus;

    ULONG i;
    LPBYTE Where = *WherePtr;
    LPBYTE OldWhere;
    PENCRYPTED_CREDENTIALW OutCredential;


    //
    // Initialize the base structure
    //

    OutCredential = (PENCRYPTED_CREDENTIALW) Where;

    RtlZeroMemory( OutCredential, sizeof(*OutCredential) );
    Where += sizeof(*OutCredential);

    // Align the running pointer again
    OldWhere = Where;
    Where = (PUCHAR) ROUND_UP_POINTER( OldWhere, ALIGN_WORST );
    RtlZeroMemory( OldWhere, Where-OldWhere );


    //
    // Copy the fixed size data
    //

    OutCredential->Cred.Flags = InCredential->Flags;
    OutCredential->Cred.Type = InCredential->Type;
    OutCredential->Cred.LastWritten = InCredential->LastWritten;
    OutCredential->Cred.CredentialBlobSize = InCredential->CredentialBlobSize;
    OutCredential->Cred.Persist = InCredential->Persist;
    OutCredential->Cred.AttributeCount = InCredential->AttributeCount;

    //
    // Copy the data we don't know the alignment for.
    //  (ALIGN_WORST so our caller can't blame us.)
    //

    if ( InCredential->CredentialBlobSize != 0 ) {
        ULONG CredBlobSize;

        OutCredential->Cred.CredentialBlob = Where;
        RtlCopyMemory( Where, InCredential->CredentialBlob, InCredential->CredentialBlobSize );
        Where += InCredential->CredentialBlobSize;

        // Leave room for the encoding over the wire
        CredBlobSize = AllocatedCredBlobSize( InCredential->CredentialBlobSize );

        // Align the running pointer again
        OldWhere = Where;
        // Align the data following the credential blob
        Where = (LPBYTE) ROUND_UP_POINTER( OldWhere+(CredBlobSize-InCredential->CredentialBlobSize), ALIGN_WORST );
        RtlZeroMemory( OldWhere, Where-OldWhere );

        //
        //  Encode or decode the Credential blob as requested
        //

        switch (DoDecode) {
        case DoBlobDecode:
            OutCredential->ClearCredentialBlobSize = ((PENCRYPTED_CREDENTIALW)InCredential)->ClearCredentialBlobSize;
#ifndef _CRTEST_EXE_
            CredpDecodeCredential( OutCredential );
#endif // _CRTEST_EXE_
            break;
        case DoBlobEncode:
            OutCredential->ClearCredentialBlobSize = InCredential->CredentialBlobSize;
#ifndef _CRTEST_EXE_
            if (!CredpEncodeCredential( OutCredential ) ) {
                return ERROR_INVALID_PARAMETER;
            }
#endif // _CRTEST_EXE_
            break;
        case DoBlobNeither:
            OutCredential->ClearCredentialBlobSize = InCredential->CredentialBlobSize;
            break;
        default:
            return ERROR_INVALID_PARAMETER;
        }
    }

    if ( InCredential->AttributeCount != 0 ) {

        //
        // Push an array of attribute structs
        //
        OutCredential->Cred.Attributes = (PCREDENTIAL_ATTRIBUTEW) Where;
        Where += InCredential->AttributeCount * sizeof(CREDENTIAL_ATTRIBUTEW);

        // Align the running pointer again
        OldWhere = Where;
        Where = (PUCHAR) ROUND_UP_POINTER( OldWhere, ALIGN_WORST );
        RtlZeroMemory( OldWhere, Where-OldWhere );

        //
        // Fill it in.
        //

        for ( i=0; i<InCredential->AttributeCount; i++ ) {

            OutCredential->Cred.Attributes[i].Flags = InCredential->Attributes[i].Flags;
            OutCredential->Cred.Attributes[i].ValueSize = InCredential->Attributes[i].ValueSize;

            if ( InCredential->Attributes[i].ValueSize != 0 ) {
                OutCredential->Cred.Attributes[i].Value = Where;
                RtlCopyMemory( Where, InCredential->Attributes[i].Value, InCredential->Attributes[i].ValueSize );
                Where += InCredential->Attributes[i].ValueSize;

                // Align the running pointer again
                OldWhere = Where;
                Where = (PUCHAR) ROUND_UP_POINTER( OldWhere, ALIGN_WORST );
                RtlZeroMemory( OldWhere, Where-OldWhere );
            } else {
                OutCredential->Cred.Attributes[i].Value = NULL;
            }

        }
    }


    //
    // Convert the strings to the right character set.
    //

    WinStatus = CredpConvertString( WtoA, InCredential->TargetName, &OutCredential->Cred.TargetName, &Where );

    if ( WinStatus != NO_ERROR ) {
        goto Cleanup;
    }

    WinStatus = CredpConvertString( WtoA, InCredential->Comment, &OutCredential->Cred.Comment, &Where );

    if ( WinStatus != NO_ERROR ) {
        goto Cleanup;
    }

    WinStatus = CredpConvertString( WtoA, InCredential->TargetAlias, &OutCredential->Cred.TargetAlias, &Where );

    if ( WinStatus != NO_ERROR ) {
        goto Cleanup;
    }

    WinStatus = CredpConvertString( WtoA, InCredential->UserName, &OutCredential->Cred.UserName, &Where );

    if ( WinStatus != NO_ERROR ) {
        goto Cleanup;
    }

    if ( InCredential->AttributeCount != 0 ) {

        for ( i=0; i<InCredential->AttributeCount; i++ ) {

            WinStatus = CredpConvertString( WtoA, InCredential->Attributes[i].Keyword, &OutCredential->Cred.Attributes[i].Keyword, &Where );

            if ( WinStatus != NO_ERROR ) {
                goto Cleanup;
            }

        }
    }

    // Align the running pointer again
    OldWhere = Where;
    Where = (PUCHAR) ROUND_UP_POINTER( OldWhere, ALIGN_WORST );
    RtlZeroMemory( OldWhere, Where-OldWhere );

    *WherePtr = Where;
    WinStatus = NO_ERROR;

    //
    // Be tidy
    //
Cleanup:

    return WinStatus;

}

#ifndef _CRTEST_EXE_
DWORD
APIENTRY
CredpConvertCredential (
    IN WTOA_ENUM WtoA,
    IN ENCODE_BLOB_ENUM DoDecode,
    IN PCREDENTIALW InCredential,
    OUT PCREDENTIALW *OutCredential
    )

/*++

Routine Description:

    Converts a credential from Ansi to Unicode or vice-versa.

Arguments:

    WtoA - Specifies the direction of the string conversion.

    DoDecode - Specifies whether CredentialBlob should be encoded, decoded, or neither.

    InCredential - Input credentials

    OutCredential - Output credential
        This credential should be freed using MIDL_user_free.

Return Values:

    Window status code

--*/

{
    DWORD WinStatus;
    ULONG Size = 0;

    LPBYTE Where;

    //
    // BVTs pass NULL explicitly.  We could let the AV be caught in the try/except, but
    //  that would prevent them from being able to run under a debugger.  So, handle NULL
    //  explicitly.
    //

    if ( InCredential == NULL ) {
        return ERROR_INVALID_PARAMETER;
    }

    //
    // Use an exception handle to prevent bad user parameter from AVing in our code.
    //

#ifndef _CRTEST_EXE_
    try {
#endif // _CRTEST_EXE_

        //
        // Compute the size needed for the output credential
        //

        Size = CredpConvertOneCredentialSize( WtoA, InCredential );


        //
        // Allocate a buffer for the resultant credential
        //

        *OutCredential = (PCREDENTIALW) MIDL_user_allocate( Size );

        if ( *OutCredential == NULL ) {
            WinStatus = ERROR_NOT_ENOUGH_MEMORY;
            goto Cleanup;
        }

        //
        // Convert the credential into the allocated buffer
        //

        Where = (LPBYTE) *OutCredential;

        WinStatus = CredpConvertOneCredential( WtoA, DoDecode, InCredential, &Where );

        if ( WinStatus != NO_ERROR ) {
            MIDL_user_free( *OutCredential );
            *OutCredential = NULL;
        } else {
            ASSERT( (ULONG)(Where - ((LPBYTE)*OutCredential)) == Size );
        }
Cleanup: NOTHING;
#ifndef _CRTEST_EXE_
    } except( EXCEPTION_EXECUTE_HANDLER ) {
        WinStatus = ERROR_INVALID_PARAMETER;
    }
#endif // _CRTEST_EXE_

    return WinStatus;

}

DWORD
APIENTRY
CredpConvertTargetInfo (
    IN WTOA_ENUM WtoA,
    IN PCREDENTIAL_TARGET_INFORMATIONW InTargetInfo,
    OUT PCREDENTIAL_TARGET_INFORMATIONW *OutTargetInfo,
    OUT PULONG OutTargetInfoSize OPTIONAL
    )

/*++

Routine Description:

    Converts a target info from Ansi to Unicode or vice-versa.

Arguments:

    WtoA - Specifies the direction of the string conversion.

    InTargetInfo - Input TargetInfo

    OutTargetInfo - Output TargetInfo
        This TargetInfo should be freed using CredFree.

    OutTargetInfoSize - Size (in bytes) of the buffer returned in OutTargetInfo

Return Values:

    Window status code

--*/

{
    DWORD WinStatus;
    ULONG Size;

    LPBYTE Where;

    *OutTargetInfo = NULL;

    //
    // BVTs pass NULL explicitly.  We could let the AV be caught in the try/except, but
    //  that would prevent them from being able to run under a debugger.  So, handle NULL
    //  explicitly.
    //

    if ( InTargetInfo == NULL ) {
        return ERROR_INVALID_PARAMETER;
    }


    //
    // Use an exception handle to prevent bad user parameter from AVing in our code.
    //
#ifndef _CRTEST_EXE_
    try {
#endif // _CRTEST_EXE_
        //
        // Compute the size needed for the output target info
        //

        Size = sizeof(CREDENTIAL_TARGET_INFORMATIONW);


        //
        // Compute the size of the strings in the right character set.
        //

        Size += CredpConvertStringSize( WtoA, InTargetInfo->TargetName );
        Size += CredpConvertStringSize( WtoA, InTargetInfo->NetbiosServerName );
        Size += CredpConvertStringSize( WtoA, InTargetInfo->DnsServerName );
        Size += CredpConvertStringSize( WtoA, InTargetInfo->NetbiosDomainName );
        Size += CredpConvertStringSize( WtoA, InTargetInfo->DnsDomainName );
        Size += CredpConvertStringSize( WtoA, InTargetInfo->DnsTreeName );
        Size += CredpConvertStringSize( WtoA, InTargetInfo->PackageName );
        Size += InTargetInfo->CredTypeCount * sizeof(DWORD);


        //
        // Allocate a buffer for the resultant credential
        //

        *OutTargetInfo = (PCREDENTIAL_TARGET_INFORMATIONW) MIDL_user_allocate( Size );

        if ( *OutTargetInfo == NULL ) {
            WinStatus = ERROR_NOT_ENOUGH_MEMORY;
            goto Cleanup;
        }

        if ( ARGUMENT_PRESENT(OutTargetInfoSize) ) {
            *OutTargetInfoSize = Size;
        }
        Where = (LPBYTE)((*OutTargetInfo) + 1);


        //
        // Copy the fixed size data
        //

        (*OutTargetInfo)->Flags = InTargetInfo->Flags;

        //
        // Copy the DWORD aligned data
        //

        (*OutTargetInfo)->CredTypeCount = InTargetInfo->CredTypeCount;
        if ( InTargetInfo->CredTypeCount != 0 ) {
            (*OutTargetInfo)->CredTypes = (LPDWORD) Where;
            RtlCopyMemory( Where, InTargetInfo->CredTypes, InTargetInfo->CredTypeCount * sizeof(DWORD) );
            Where += InTargetInfo->CredTypeCount * sizeof(DWORD);
        } else {
            (*OutTargetInfo)->CredTypes = NULL;
        }


        //
        // Convert the strings to the right character set.
        //

        WinStatus = CredpConvertString( WtoA, InTargetInfo->TargetName, &(*OutTargetInfo)->TargetName, &Where );

        if ( WinStatus != NO_ERROR ) {
            goto Cleanup;
        }

        WinStatus = CredpConvertString( WtoA, InTargetInfo->NetbiosServerName, &(*OutTargetInfo)->NetbiosServerName, &Where );

        if ( WinStatus != NO_ERROR ) {
            goto Cleanup;
        }

        WinStatus = CredpConvertString( WtoA, InTargetInfo->DnsServerName, &(*OutTargetInfo)->DnsServerName, &Where );

        if ( WinStatus != NO_ERROR ) {
            goto Cleanup;
        }

        WinStatus = CredpConvertString( WtoA, InTargetInfo->NetbiosDomainName, &(*OutTargetInfo)->NetbiosDomainName, &Where );

        if ( WinStatus != NO_ERROR ) {
            goto Cleanup;
        }

        WinStatus = CredpConvertString( WtoA, InTargetInfo->DnsDomainName, &(*OutTargetInfo)->DnsDomainName, &Where );

        if ( WinStatus != NO_ERROR ) {
            goto Cleanup;
        }

        WinStatus = CredpConvertString( WtoA, InTargetInfo->DnsTreeName, &(*OutTargetInfo)->DnsTreeName, &Where );

        if ( WinStatus != NO_ERROR ) {
            goto Cleanup;
        }

        WinStatus = CredpConvertString( WtoA, InTargetInfo->PackageName, &(*OutTargetInfo)->PackageName, &Where );

        if ( WinStatus != NO_ERROR ) {
            goto Cleanup;
        }

        ASSERT( (ULONG)(Where - ((LPBYTE)*OutTargetInfo)) == Size );
Cleanup: NOTHING;
#ifndef _CRTEST_EXE_
    } except( EXCEPTION_EXECUTE_HANDLER ) {
        WinStatus = ERROR_INVALID_PARAMETER;
    }
#endif // _CRTEST_EXE_

    //
    // Be tidy
    //
    if ( WinStatus != NO_ERROR ) {
        if ( *OutTargetInfo != NULL ) {
            MIDL_user_free( *OutTargetInfo );
            *OutTargetInfo = NULL;
        }
    }

    return WinStatus;

}
#endif // _CRTEST_EXE_

DWORD
CredpConvertCredentials (
    IN WTOA_ENUM WtoA,
    IN ENCODE_BLOB_ENUM DoDecode,
    IN PCREDENTIALW *InCredential,
    IN ULONG InCredentialCount,
    OUT PCREDENTIALW **OutCredential
    )

/*++

Routine Description:

    Converts a set of credentials from Ansi to Unicode or vice-versa.

Arguments:

    WtoA - Specifies the direction of the string conversion.

    DoDecode - Specifies whether CredentialBlob should be encoded, decoded, or neither.

    InCredential - Input credentials

    OutCredential - Output credential
        This credential should be freed using MIDL_user_free.

Return Values:

    Window status code

--*/

{
    DWORD WinStatus;
    ULONG Size = 0;
    ULONG i;

    LPBYTE Where;
    LPBYTE OldWhere;

    *OutCredential = NULL;

    //
    // Use an exception handle to prevent bad user parameter from AVing in our code.
    //
#ifndef _CRTEST_EXE_
    try {
#endif // _CRTEST_EXE_

        //
        // Compute the size needed for the output credentials
        //

        for ( i=0; i<InCredentialCount; i++ ) {
            Size += CredpConvertOneCredentialSize( WtoA, InCredential[i] );
        }


        //
        // Allocate a buffer for the resultant credential array
        //

        Size += ROUND_UP_COUNT( InCredentialCount * sizeof(PCREDENTIALW), ALIGN_WORST );

        *OutCredential = (PCREDENTIALW *)MIDL_user_allocate( Size );

        if ( *OutCredential == NULL ) {
            WinStatus = ERROR_NOT_ENOUGH_MEMORY;
            goto Cleanup;
        }

        //
        // Convert the credential into the allocated buffer
        //

        Where = (LPBYTE) *OutCredential;
        Where += InCredentialCount * sizeof(PCREDENTIALW);

        // Align the running pointer again
        OldWhere = Where;
        Where = (PUCHAR) ROUND_UP_POINTER( OldWhere, ALIGN_WORST );
        RtlZeroMemory( OldWhere, Where-OldWhere );

        for ( i=0; i<InCredentialCount; i++ ) {

            //
            // Save a pointer to this credential
            //

            (*OutCredential)[i] = (PCREDENTIALW) Where;

            //
            // Marshal the credential
            //

            WinStatus = CredpConvertOneCredential( WtoA, DoDecode, InCredential[i], &Where );

            if ( WinStatus != NO_ERROR ) {
                goto Cleanup;
            }
        }

        ASSERT( (ULONG)(Where - ((LPBYTE)*OutCredential)) == Size );
        WinStatus = NO_ERROR;

Cleanup: NOTHING;
#ifndef _CRTEST_EXE_
    } except( EXCEPTION_EXECUTE_HANDLER ) {
        WinStatus = ERROR_INVALID_PARAMETER;
    }
#endif // _CRTEST_EXE_

    if ( WinStatus != NO_ERROR ) {
        if ( *OutCredential != NULL ) {
            MIDL_user_free( *OutCredential );
            *OutCredential = NULL;
        }
    }

    return WinStatus;

}