windows-xp/Source/XPSP1/NT/net/rras/cm/cmsecure/cmsecure.cpp

//+----------------------------------------------------------------------------
//
// File:     cmsecure.cpp
//
// Module:   CMSECURE.LIB
//
// Synopsis: CM Crypto APIs
//           Three methods are support for decryption:
//              CBCEncryption         CMSECURE_ET_CBC_CIPHER
//              Simple xor encryption CMSECURE_ET_STREAM_CIPHER
//              CryptoApi             CMSECURE_ET_RC2
//           Two methods are supported for encryption
//              CBCEncryption
//              CryptoApi
//
//           CBCEncryption algorithm: Cipher Block Chaining Mode with initializing variable
//                EnCipher: C[i] = E[k](p[i] XOR C[i-1])
//                DeCipher: P[i] = C[i-1] XOR D[k](C[i])
//                   P: Plain text
//                   C: Cipher text
//                   E[k]: Encryption function with key
//                   D[k]: Decryption function with key
//
// Copyright (c) 1996-1998 Microsoft Corporation
//
// Author:   henryt     created                         05/21/97
//           fengsun    changed encryption algorithm    08/21/97
//
//+----------------------------------------------------------------------------
#include "cryptfnc.h"
#include "userinfo_str.h"

//////////////////////////////////////////////////////////////////////////
// defines
//////////////////////////////////////////////////////////////////////////

// we want 40-bit encryption exactly for pre-shared key
const DWORD c_dwEncryptKeyLength = 40;

//
// the max len for the const string for session key generation
//
#define MAX_KEY_STRING_LEN                      40
#define EXTRA_UUDECODE_BUF_LEN                  10

//////////////////////////////////////////////////////////////////////////
// Globals
//////////////////////////////////////////////////////////////////////////

static CCryptFunctions*  g_pCryptFnc = NULL;
static long g_nRefCount=0;   // the reference count, CryptoApi is unloaded when the count is 0
static BOOL g_fFastEncryption;

//
// the const string for session key generation
//
static const TCHAR gc_szKeyStr[] = TEXT("Please enter your password");

//////////////////////////////////////////////////////////////////////////
// Func prototypes
//////////////////////////////////////////////////////////////////////////

static int CBCEncipherData(const char* pszKey, const BYTE* pbData, int dwDataLength, 
                       BYTE* pbOut, int dwOutBufferLength);
static int CBCDecipherData(const char* pszKey, const BYTE* pbData, int dwDataLength, 
                       BYTE* pbOut, int dwOutBufferLength);
inline int CBCDecipherBufferSize(int dataSize);
inline int CBCEncipherBufferSize(int dataSize);


static BOOL 
StreamCipherEncryptData(
    LPTSTR          pszKey,              // password    
    LPBYTE          pbData,              // Data to be encrypted
    DWORD           dwDataLength,        // Length of data in bytes
    LPBYTE          *ppbEncryptedData,     // Encrypted secret key will be stored here
    DWORD           *pdwEncryptedBufferLen, // Length of this buffer
    PFN_CMSECUREALLOC  pfnAlloc,
    PFN_CMSECUREFREE   pfnFree
);

static BOOL 
StreamCipherDecryptData(
    LPTSTR          pszKey,              // password    
    LPBYTE          pbEncryptedData,     // Encrypted data
    DWORD           dwEncrytedDataLen,   // Length of encrypted data
    LPBYTE          *ppbData,            // Decrypted Data will be stored here
    DWORD           *pdwDataBufferLength,// Length of the above buffer in bytes
    PFN_CMSECUREALLOC  pfnAlloc,
    PFN_CMSECUREFREE   pfnFree,
    DWORD           dwEncryptionType
);

static LPTSTR 
reverse(
    LPTSTR  s
);

static void
GenerateKeyString(
    IN OUT  LPTSTR  pszBuf,
    IN      DWORD   dwBufLen
);

static BOOL SetKeyString(IN OUT  LPTSTR  pszBuf, IN DWORD dwBufLen, IN DWORD dwEncryptionType,
                         IN  PFN_CMSECUREALLOC  pfnAlloc,
                         IN  PFN_CMSECUREFREE   pfnFree,
                         IN LPSTR pszUserKey,
                         OUT BOOL *pfMoreSecure);

static BOOL GetKeyString(IN OUT  LPTSTR  pszBuf, IN DWORD * pdwBufLen, IN DWORD dwEncryptionType, 
                         IN  PFN_CMSECUREALLOC  pfnAlloc,
                         IN  PFN_CMSECUREFREE   pfnFree,
                         IN LPSTR pszUserKey,
                         OUT BOOL *pfMoreSecure);

static BOOL GetCurrentKey(PTCHAR szTempKeyStr, DWORD dwTempKeyStrMaxLen, 
                   IN  PFN_CMSECUREALLOC  pfnAlloc,
                   IN  PFN_CMSECUREFREE   pfnFree);

//////////////////////////////////////////////////////////////////////////
// Implementations
//////////////////////////////////////////////////////////////////////////

//+---------------------------------------------------------------------------
//
//  Function:   InitCryptoApi
//
//  Synopsis:   Initialize the CryptoApi.
//
//  Arguments:  
//
//  Returns:    Pointer to  CCryptFunctions, if success
//              NULL if failure
//
//  History:    fengsun Created     8/22/97
//
//----------------------------------------------------------------------------

static CCryptFunctions* InitCryptoApi()
{
    CCryptFunctions* pCryptFnc = new CCryptFunctions();

    if (pCryptFnc == NULL)
        return NULL;

    if (pCryptFnc->InitCrypt()) 
    {
        return pCryptFnc;
    }
    else
    {
        delete pCryptFnc;
        return NULL;
    }

}

//+---------------------------------------------------------------------------
//
//  Function:   InitSecure
//
//  Synopsis:   Initialize the security/encryption routines.
//
//  Arguments:  fFastEncryption : TRUE will use a faster algorithm vs a more secure one
//
//  Returns:    TRUE if success, always return TRUE
//              FALSE if failure
//
//  History:    henryt  Created     5/20/97
//              fengsun modified 
//
//----------------------------------------------------------------------------

BOOL
InitSecure(
    BOOL fFastEncryption
)
{
    MYDBGASSERT(g_nRefCount>=0);
    InterlockedIncrement(&g_nRefCount);

    //
    // If already initialized, increase the RefCount and return
    //
    if (g_nRefCount>1)
    {
        return TRUE;
    }

    MYDBGASSERT(g_pCryptFnc == NULL); // not initialized yet

    g_fFastEncryption = fFastEncryption;

    if (!fFastEncryption)
    {
        //
        // CryptoApi is slow on Win95
        // If more secure is desired, try the CryptoApi
        // Ignore return value of InitCrypt()
        //
        g_pCryptFnc = InitCryptoApi();
    }

    //
    // CryptoApi is not available for Win95 Gold
    // we'll use stream cipher.
    //

    return TRUE; 
}



//+---------------------------------------------------------------------------
//
//  Function:   DeInitSecure
//
//  Synopsis:   Clean up function for the security/encryption routines.
//
//  Arguments:  NONE
//
//  Returns:    NONE
//
//  History:    henryt  Created     5/20/97
//
//----------------------------------------------------------------------------

void
DeInitSecure(
    void
)
{
    MYDBGASSERT(g_nRefCount>=1);

    //
    // DeInit the CryptoApi if RefCount is down to 0
    //
    if (InterlockedDecrement(&g_nRefCount) <=0)    // if ( (--g_nRefCount) <=0 )
    {
        if (g_pCryptFnc)
        {
            delete g_pCryptFnc;
            g_pCryptFnc = NULL;
        }
    }
}



//+---------------------------------------------------------------------------
//
//  Function:   StreamCipherEncryptData
//
//  Synopsis:   data encryption using stream cipher algorithm.
//
//  Arguments:  NONE
//
//  Returns:    NONE
//
//  History:    henryt  Created     6/9/97
//              fengsun modified    8/21/97 
//                                  to use Cipher Block Chaning Mode Algorithm
//
//----------------------------------------------------------------------------

static BOOL 
StreamCipherEncryptData(
    LPTSTR          pszKey,              // password    
    LPBYTE          pbData,              // Data to be encrypted
    DWORD           dwDataLength,        // Length of data in bytes
    LPBYTE          *ppbEncryptedData,     // Encrypted secret key will be stored here
    DWORD           *pdwEncryptedBufferLen, // Length of this buffer
    PFN_CMSECUREALLOC  pfnAlloc,
    PFN_CMSECUREFREE   pfnFree
)
{

    LPBYTE  pbTmpBuf = NULL;
    BOOL    fOk = FALSE;
    BOOL    fRet;

    if (!pszKey || !pbData || !dwDataLength || !ppbEncryptedData || !pdwEncryptedBufferLen)
    {
        CMASSERTMSG(FALSE, TEXT("StreamCipherEncryptData - invalid input params"));
        return FALSE;
    }

    //
    // Alloc a buffer to hold enciphered data
    //
    DWORD dwEncipherBufferLen = CBCEncipherBufferSize(dwDataLength);

    if (pfnAlloc)
    {
        pbTmpBuf = (LPBYTE)pfnAlloc(dwEncipherBufferLen);
    }
    else
    {
        pbTmpBuf = (LPBYTE)HeapAlloc(GetProcessHeap(), 
                                     HEAP_ZERO_MEMORY,
                                     dwEncipherBufferLen);
    }
    if (!pbTmpBuf)
    {
        goto cleanup;
    }


    //
    // encipher the data
    //

    dwEncipherBufferLen = CBCEncipherData(pszKey, pbData, dwDataLength, pbTmpBuf, dwEncipherBufferLen);

    //
    // we now have the data encrypted.  we need to uuencode it.
    //
    DWORD   cbBuf;
    cbBuf = 2*dwEncipherBufferLen + EXTRA_UUDECODE_BUF_LEN;     // enough for uuencode

    if (pfnAlloc)
    {
        *ppbEncryptedData = (LPBYTE)pfnAlloc(cbBuf);
    }
    else
    {
        *ppbEncryptedData = (LPBYTE)HeapAlloc(GetProcessHeap(), 
                                              HEAP_ZERO_MEMORY,
                                              cbBuf);
    }
    if (!*ppbEncryptedData)
    {
        goto cleanup;
    }

    
    fRet = uuencode(pbTmpBuf, dwEncipherBufferLen, (CHAR*)*ppbEncryptedData, cbBuf);

    MYDBGASSERT(fRet);

    if (!fRet)
    {
        if (pfnFree)
        {
            pfnFree(*ppbEncryptedData);
        }
        else
        {
            HeapFree(GetProcessHeap(), 0, *ppbEncryptedData);
        }
        *ppbEncryptedData = NULL;

        goto cleanup;
    }

    //
    // set the encrypted buffer len
    //
    *pdwEncryptedBufferLen = lstrlen((LPSTR)*ppbEncryptedData);

    fOk = TRUE;

cleanup:
    if (pbTmpBuf)
    {
        if (pfnFree)
        {
            pfnFree(pbTmpBuf);
        }
        else
        {
            HeapFree(GetProcessHeap(), 0, pbTmpBuf);
        }
    }

    return fOk;
}



//+---------------------------------------------------------------------------
//
//  Function:   StreamCipherDecryptData
//
//  Synopsis:   data decryption using stream cipher algorithm.
//
//  Arguments:  NONE
//
//  Returns:    NONE
//
//  History:    henryt  Created     6/9/97
//              fengsun modified    8/21/97 
//                                  to use Cipher Block Chaning Modem Algorithm
//
//----------------------------------------------------------------------------

static BOOL 
StreamCipherDecryptData(
    LPTSTR          pszKey,              // password    
    LPBYTE          pbEncryptedData,     // Encrypted data
    DWORD           dwEncryptedDataLen,   // Length of encrypted data
    LPBYTE          *ppbData,            // Decrypted Data will be stored here
    DWORD           *pdwDataBufferLength,// Length of the above buffer in bytes
    PFN_CMSECUREALLOC  pfnAlloc,
    PFN_CMSECUREFREE   pfnFree,
    DWORD           dwEncryptionType
)
{
    BOOL    fRet = FALSE;
    DWORD   dwUUDecodeBufLen;

    if (!pszKey || !pbEncryptedData || !dwEncryptedDataLen || !pdwDataBufferLength)
    {
        CMASSERTMSG(FALSE, TEXT("StreamCipherDecryptData - invalid input params"));
        return FALSE;
    }

    //
    // set uudecode output buf size
    //
    dwUUDecodeBufLen = dwEncryptedDataLen + EXTRA_UUDECODE_BUF_LEN;

    //
    // alloc memory for output buffer
    //
    if (pfnAlloc)
    {
        *ppbData = (LPBYTE)pfnAlloc(dwUUDecodeBufLen);
    }
    else
    {
        *ppbData = (LPBYTE)HeapAlloc(GetProcessHeap(),
                                     HEAP_ZERO_MEMORY,
                                     dwUUDecodeBufLen);
    }
    if (!*ppbData)
    {
        goto cleanup;
    }

    //
    // uudecode it first
    //

    fRet = uudecode((char*)pbEncryptedData, (CHAR*)*ppbData, &dwUUDecodeBufLen);

    MYDBGASSERT(fRet);

    if (!fRet)
    {
        if (pfnFree)
        {
            pfnFree(*ppbData);
        }
        else
        {
            HeapFree(GetProcessHeap(), 0, *ppbData);
        }
        *ppbData = NULL;

        goto cleanup;
    }

    switch(dwEncryptionType)
    {
    case CMSECURE_ET_STREAM_CIPHER:
        {
            //
            //  Simple decipher algorithm used in old version
            //

            DWORD   dwLen = lstrlen(pszKey);

            if (dwLen)
            {
                for (DWORD dwIdx = 0; dwIdx < dwUUDecodeBufLen; dwIdx++)
                {
                    *(*ppbData + dwIdx) ^= pszKey[dwIdx % dwLen];
                }

                *pdwDataBufferLength = dwUUDecodeBufLen;

                fRet = TRUE;
            }
        }
        break;

    case CMSECURE_ET_CBC_CIPHER:
        //
        // Inplace decipher  
        //
        *pdwDataBufferLength = CBCDecipherData(pszKey, *ppbData, dwUUDecodeBufLen, 
                                            *ppbData, dwUUDecodeBufLen);
        fRet = TRUE;

        break;
    default:
        MYDBGASSERT(FALSE);
    }

cleanup:
    return fRet;
}



//+---------------------------------------------------------------------------
//
//  Function:   EncryptData
//
//  Synopsis:   Encrypt the data buffer.
//
//  Arguments:  IN  PBYTE   pbData,                 // Data to be encrypted                    
//              IN  DWORD   dwDataLength,           // Length of data in bytes                 
//              OUT PBYTE   pbEncryptedData,        // Encrypted secret key will be stored here
//              OUT DWORD   *pdwEncrytedBufferLen   // Length of this buffer                   
//              IN  PCMSECUREALLOC  pfnAlloc        // memory allocator(if NULL, then the default is used.   
//                                                  //      Win32 - HeapAlloc(GetProcessHeap(), ...)         
//              IN  PCMSECUREFREE   pfnFree         // memory deallocator(if NULL, then the default is used. 
//                                                  //      Win32 - HeapFree(GetProcessHeap(), ...)          
//              IN  LPTSTR  pszUserKey              // Reg key where to store encrypted key
//
//  Returns:    TRUE if success
//              FALSE if failure
//
//  History:    henryt  Created     5/20/97
//
//----------------------------------------------------------------------------

BOOL
EncryptData(
    IN  LPBYTE  pbData,                 // Data to be encrypted
    IN  DWORD   dwDataLength,           // Length of data in bytes
    OUT LPBYTE  *ppbEncryptedData,      // Encrypted secret key will be stored here
    OUT LPDWORD pdwEncrytedBufferLen,  // Length of this buffer
    OUT LPDWORD pEncryptionType,        // type of the encryption used
    IN  PFN_CMSECUREALLOC  pfnAlloc,
    IN  PFN_CMSECUREFREE   pfnFree,
    IN  LPSTR   pszUserKey
)
{
    BOOL    fOk = FALSE;
    TCHAR   szKeyStr[MAX_KEY_STRING_LEN + 1]={0};
    BOOL    fMoreSecure = FALSE;

    DWORD dwUseKey = *pEncryptionType;

    //
    // get a key string for session key generation
    //
    SetKeyString(szKeyStr, MAX_KEY_STRING_LEN, dwUseKey, pfnAlloc, pfnFree, pszUserKey, &fMoreSecure);

    *pEncryptionType = CMSECURE_ET_NOT_ENCRYPTED;
   
    //
    // If user want use CryptoApi and it is available
    //
    if (!g_fFastEncryption && g_pCryptFnc)
    {
        //
        // encrypt the data with the key string
        //
        if (fOk = g_pCryptFnc->EncryptDataWithKey(
            szKeyStr,                       // Key
            pbData,                         // Secret key
            dwDataLength,                   // Length of secret key
            ppbEncryptedData,               // Encrypted data will be stored here
            pdwEncrytedBufferLen,           // Length of this buffer
            pfnAlloc,                       // mem allocator
            pfnFree,                        // mem deallocator
            0))                             // not specifying keylength
        {
            *pEncryptionType = CMSECURE_ET_RC2;

            //
            // If the key is randomly generated then we want to make sure we 
            // set the random key mask
            //
            if (fMoreSecure)
            {
                *pEncryptionType |= CMSECURE_ET_RANDOM_KEY_MASK;
            }
        }
    }

    if (!fOk)
    {
        if (fOk = StreamCipherEncryptData(
            szKeyStr,                       // Key
            pbData,                         // Secret key
            dwDataLength,                   // Length of secret key
            ppbEncryptedData,               // Encrypted data will be stored here
            pdwEncrytedBufferLen,           // Length of this buffer
            pfnAlloc,                       // mem allocator
            pfnFree))                       // mem deallocator
        {
            *pEncryptionType = CMSECURE_ET_CBC_CIPHER;
            
            //
            // If the key is randomly generated then we want to make sure we 
            // set the random key mask
            //
            if (fMoreSecure)
            {
                *pEncryptionType |= CMSECURE_ET_RANDOM_KEY_MASK;
            }
        }
    }

    ZeroMemory((LPVOID)szKeyStr, sizeof(szKeyStr));

    return fOk;
}


//+---------------------------------------------------------------------------
//
//  Function:   DecryptData
//
//  Synopsis:   Decrypt the data buffer.
//
//  Arguments:  IN  PBYTE   pbEncryptedData,        // Encrypted data                      
//              IN  DWORD   dwEncrytedDataLen       // Length of encrypted data            
//              OUT PBYTE   *ppbData,               // Decrypted Data will be stored here  
//              OUT DWORD   *pdwDataBufferLength,   // Length of the above buffer in bytes 
//              IN  PCMSECUREALLOC  pfnAlloc        // memory allocator(if NULL, then the default is used.   
//                                                  //      Win32 - HeapAlloc(GetProcessHeap(), ...)         
//              IN  PCMSECUREFREE   pfnFree         // memory deallocator(if NULL, then the default is used. 
//                                                  //      Win32 - HeapFree(GetProcessHeap(), ...)          
//              IN  LPTSTR  pszUserKey              // Reg key where to store encrypted key
//
//  Returns:    TRUE if success
//              FALSE if failure
//
//  History:    henryt  Created     5/20/97
//
//----------------------------------------------------------------------------

BOOL
DecryptData(
    IN  LPBYTE          pbEncryptedData,        // Encrypted data
    IN  DWORD           dwEncrytedDataLen,      // Length of encrypted data
    OUT LPBYTE          *ppbData,               // Decrypted Data will be stored here
    OUT LPDWORD         pdwDataBufferLength,    // Length of the above buffer in bytes
    IN  DWORD           dwEncryptionType,       // encryption type for decryption
    IN  PFN_CMSECUREALLOC  pfnAlloc,
    IN  PFN_CMSECUREFREE   pfnFree,
    IN  LPSTR           pszUserKey
)
{
    TCHAR   szKeyStr[MAX_KEY_STRING_LEN + 1]={0}; // Plus NULL
    DWORD   dwRet = 0xf;        // some non-zero value
    BOOL fMoreSecure = FALSE;

    //
    // To speed things up we only want to generate a key
    // in case the data is encrypted
    //
    if (CMSECURE_ET_NOT_ENCRYPTED != dwEncryptionType)
    {
        //
        // get a key string for session key generation
        //

        //
        // Here we don't care if the pszUserKey is NULL, the called function will determine
        // this and set fMoreSecure appropriately. Right now we don't check for the random key mask 
        // in dwEncryptionType, but if it isn't set the blob (encrypted key) will not be in the registry 
        // thus it will try to default to using the hardcoded key. This should probably be made more explicit
        // in the code at a later time.
        //
        DWORD dwMaxSize = MAX_KEY_STRING_LEN;
        GetKeyString(szKeyStr, &dwMaxSize, dwEncryptionType, pfnAlloc, pfnFree, pszUserKey, &fMoreSecure);
    
        //
        // If the random key bit mask is set, we better have have fMoreSecure flag set to true.
        // This has to be always true in order for decryption to work
        // 
        CMASSERTMSG(((dwEncryptionType & CMSECURE_ET_RANDOM_KEY_MASK) && fMoreSecure), TEXT("DecryptData - Trying to use mismatched keys"));
    }

    // 
    // Clear the random key mask 
    //
    dwEncryptionType &= ~CMSECURE_ET_RANDOM_KEY_MASK;
    dwEncryptionType &= ~CMSECURE_ET_USE_SECOND_RND_KEY;

    switch (dwEncryptionType)
    {
        case CMSECURE_ET_RC2:
            if (g_fFastEncryption && !g_pCryptFnc)
            {
                //
                // if we want fast encryption initially,
                // We have to initialize the CryptoApi now
                //
                g_pCryptFnc = InitCryptoApi();
            }

            if (g_pCryptFnc)
            {
                dwRet = g_pCryptFnc->DecryptDataWithKey(
                            szKeyStr,                // Key
                            pbEncryptedData,         // Encrypted data
                            dwEncrytedDataLen,       // Length of encrypted data
                            ppbData,                 // decrypted data
                            pdwDataBufferLength,     // Length of decrypted data
                            pfnAlloc,                // mem allocator
                            pfnFree,                 // mem deallocator
                            0);                      // not specifying keylength
                            
            }
            break;

        case CMSECURE_ET_STREAM_CIPHER:
        case CMSECURE_ET_CBC_CIPHER:
            //
            // Use our own encryption algorithm
            //
            dwRet = (DWORD)!StreamCipherDecryptData(
                        szKeyStr,                // Key
                        pbEncryptedData,         // Encrypted data
                        dwEncrytedDataLen,       // Length of encrypted data
                        ppbData,                 // decrypted data
                        pdwDataBufferLength,     // Length of decrypted data
                        pfnAlloc,                // mem allocator
                        pfnFree,                 // mem deallocator
                        dwEncryptionType         // Encryption type used
                        );
            break;

        case CMSECURE_ET_NOT_ENCRYPTED:
            // 
            // Just copy the exact contents into the OUT buffer
            //
            if (pbEncryptedData && dwEncrytedDataLen && 
                ppbData && pdwDataBufferLength)
            {
                if (pfnAlloc)
                {
                    *ppbData = (LPBYTE)pfnAlloc(dwEncrytedDataLen);
                }
                else
                {
                    *ppbData = (LPBYTE)HeapAlloc(GetProcessHeap(), 
                                                 HEAP_ZERO_MEMORY,
                                                 dwEncrytedDataLen);
                }
                
                if (*ppbData)
                {
                    CopyMemory(*ppbData, pbEncryptedData, dwEncrytedDataLen);
                    *pdwDataBufferLength = dwEncrytedDataLen;
                    dwRet = 0; // the return statement correctly returns TRUE 
                }
            }

            break;

        default:
            MYDBGASSERT(FALSE);
            break;
    }
    
    ZeroMemory((LPVOID)szKeyStr, sizeof(szKeyStr));

    return (!dwRet);
}


//+----------------------------------------------------------------------------
//
// Func:    EncryptString
//
// Desc:    encrypt a given (Ansi) string using RC2 encryption
//
// Args:    pszToEncrypt         -- Ansi string to be encrypted
//          pszUserKey           -- Key to use for Encryption
//          ppbEncryptedData     -- Encrypted secret key will be stored here(memory will be allocated)
//          pdwEncrytedBufferLen -- Length of this buffer
//
// Return:  BOOL (FALSE if a fatal error occurred, else TRUE)
//
// Notes:   The encryption type must be at least RC2, and exactly 40-bit
//
//-----------------------------------------------------------------------------
BOOL
EncryptString(
    IN  LPSTR           pszToEncrypt,           // Ansi string to be encrypted
    IN  LPSTR           pszUserKey,             // Key to use for Encryption
    OUT LPBYTE *        ppbEncryptedData,       // Encrypted secret key will be stored here(memory will be allocated)
    OUT LPDWORD         pdwEncrytedBufferLen,   // Length of this buffer
    IN  PFN_CMSECUREALLOC  pfnAlloc,
    IN  PFN_CMSECUREFREE   pfnFree
)
{
    BOOL fOk = FALSE;

    CMASSERTMSG(pszToEncrypt, TEXT("EncryptData - first arg must be a valid string"));
    CMASSERTMSG(pszUserKey,  TEXT("EncryptData - second arg must be a valid user key"));

    DWORD dwDataLength = lstrlen(pszToEncrypt) + 1; // get the NULL in as well.

    if (!g_fFastEncryption && g_pCryptFnc)
    {
        if (fOk = g_pCryptFnc->EncryptDataWithKey(
            pszUserKey,                     // Key
            (LPBYTE)pszToEncrypt,           // Secret key
            dwDataLength,                   // Length of secret key
            ppbEncryptedData,               // Encrypted data will be stored here
            pdwEncrytedBufferLen,           // Length of this buffer
            pfnAlloc,
            pfnFree,
            c_dwEncryptKeyLength))
        {
            CMTRACE(TEXT("EncryptString - succeeded."));
        }
    }

    return fOk;
}


//+----------------------------------------------------------------------------
//
// Func:    DecryptString
//
// Desc:    encrypt a given (Ansi) string using RC2 encryption
//
// Args:    pszToEncrypt         -- Ansi string to be encrypted
//          pszUserKey           -- Key to use for Encryption
//          ppbEncryptedData     -- Encrypted secret key will be stored here(memory will be allocated)
//          pdwEncrytedBufferLen -- Length of this buffer
//
// Return:  BOOL (FALSE if a fatal error occurred, else TRUE)
//
// Notes:   The encryption type must be at least RC2, and exactly 40-bit
//
//-----------------------------------------------------------------------------
BOOL
DecryptString(
    IN  LPBYTE          pbEncryptedData,        // Encrypted data
    IN  DWORD           dwEncrytedDataLen,      // Length of encrypted data
    IN  LPSTR           pszUserKey,             // Registry key to store encrypted key for passwords
    OUT LPBYTE *        ppbData,                // Decrypted Data will be stored here
    OUT LPDWORD         pdwDataBufferLength,    // Length of the above buffer in bytes
    IN  PFN_CMSECUREALLOC  pfnAlloc,
    IN  PFN_CMSECUREFREE   pfnFree

)
{
    DWORD   dwRet = 0xf;        // some non-zero value

    if (!g_fFastEncryption && g_pCryptFnc)
    {
        dwRet = g_pCryptFnc->DecryptDataWithKey(
                    pszUserKey,              // Key
                    pbEncryptedData,         // Encrypted data
                    dwEncrytedDataLen,       // Length of encrypted data
                    ppbData,                 // decrypted data
                    pdwDataBufferLength,     // Length of decrypted data
                    pfnAlloc,
                    pfnFree,
                    c_dwEncryptKeyLength);   // 40-bit
    }

    return (!dwRet);
}


//+---------------------------------------------------------------------------
//
//  Function:   CBCEncipherBufferSize
//
//  Synopsis:   Get the buffer size needed for Enciphering
//
//  Arguments:  dataSize sizeof data to be enciphered
//
//  Returns:    Encipher buffer size needed
//
//  History:    fengsun Created     8/21/97
//
//----------------------------------------------------------------------------

inline int CBCEncipherBufferSize(int dataSize)
{
    MYDBGASSERT(dataSize > 0);    

    //
    // We need one byte to hold the initializing variable
    //

    return dataSize + 1;
}

//+---------------------------------------------------------------------------
//
//  Function:   CBCDecipherBufferSize
//
//  Synopsis:   Get the buffer size needed for Deciphering
//
//  Arguments:  dataSize sizeof data to be Deciphered
//
//  Returns:    Decipher buffer size needed
//
//  History:    fengsun Created     8/21/97
//
//----------------------------------------------------------------------------
inline int CBCDecipherBufferSize(int dataSize)
{
    MYDBGASSERT(dataSize > 1);    
    return dataSize - 1;
}

//+---------------------------------------------------------------------------
//
//  Function:   EncryptByte
//
//  Synopsis:   Encrypt a single byte
//
//  Arguments:  pszKey  key string
//              byteSource byte to be encrypted
//              param   aditional parameter for encryption
//
//  Returns:    byte encrypted
//
//  History:    fengsun Created     8/21/97
//
//----------------------------------------------------------------------------

inline BYTE EncryptByte(LPCTSTR pszKey, BYTE byteSource, BYTE Param)
{
    if (NULL == pszKey)
    {
        return NULL;
    }

    DWORD   dwLen = lstrlen(pszKey);

    if (0 == dwLen)
    {
        return NULL;
    }

    return ((byteSource ^ (BYTE)pszKey[Param % dwLen]) + Param);
}

//+---------------------------------------------------------------------------
//
//  Function:   DecryptByte
//
//  Synopsis:   Decrypt a single byte
//
//  Arguments:  pszKey  key string
//              byteSource byte to be Decrypted
//              param   aditional parameter for encryption
//
//  Returns:    byte decrypted
//
//  History:    fengsun Created     8/21/97
//
//----------------------------------------------------------------------------

inline BYTE DecryptByte(LPCTSTR pszKey, BYTE byteSource, BYTE Param)
{
    if (NULL == pszKey)
    {
        return NULL;
    }

    DWORD   dwLen = lstrlen(pszKey);

    if (0 == dwLen)
    {
        return NULL;
    }

    return ((byteSource - Param) ^ (BYTE)pszKey[Param % dwLen]);
}

//+---------------------------------------------------------------------------
//
//  Function:   CBCEncipherData
//
//  Synopsis:   Encipher a block of data
//
//  Arguments:  pszKey  key string
//              pbData  Data to be enciphered
//              dwDataLength size of pbData
//              pbOut   Buffer for encipher result
//              dwOutBufferLength size of pbOut, must be >= CBCEncipherBufferSize(dwDataLength)
//
//  Returns:    size of encipher byte in pbOut, 0 means failed
//
//  History:    fengsun Created     8/21/97
//
//----------------------------------------------------------------------------
static int CBCEncipherData(const char* pszKey, const BYTE* pbData, int dwDataLength, 
                       BYTE* pbOut, int dwOutBufferLength)
{
    MYDBGASSERT(pszKey != NULL);    
    MYDBGASSERT(pbData != NULL);    
    MYDBGASSERT(pbOut != NULL);    
    MYDBGASSERT(dwDataLength > 0);    
    MYDBGASSERT(pbData != pbOut);

    if (dwDataLength <= 0)
        return 0;

    if (dwOutBufferLength < CBCEncipherBufferSize(dwDataLength))
        return 0;

    dwOutBufferLength = CBCEncipherBufferSize(dwDataLength);

    //
    // Add a random number as the initializing variable (first byte)
    //
    pbOut[0] = (BYTE)((GetTickCount() >> 4 ) % 256);


    //
    // encipher it
    //
    // EnCipher: C[i] = E[k](p[i] XOR C[i-1])
    //

    BYTE lastPlainText = pbOut[0];   //first initilizing byte
    pbOut[0] = EncryptByte(pszKey, pbOut[0], 0);
    for (int dwIdx=1; dwIdx<dwOutBufferLength; dwIdx++)
    {
        pbOut[dwIdx] = EncryptByte(pszKey, pbData[dwIdx-1]^pbOut[dwIdx-1], lastPlainText);
        lastPlainText = pbData[dwIdx-1];
    }

    return dwOutBufferLength;

}

//+---------------------------------------------------------------------------
//
//  Function:   CBCDecipherData
//
//  Synopsis:   Decipher a block of data,  inplace deciper is supported
//
//  Arguments:  pszKey  key string
//              pbData  Data to be Deciphered
//              dwDataLength size of pbData
//              pbOut   Buffer for decipher result
//              dwOutBufferLength size of pbOut, must be >= CBCDecipherBufferSize(dwDataLength)
//
//  Returns:    size of decipher byte in pbOut, 0 means failed
//
//  History:    fengsun Created     8/21/97
//
//----------------------------------------------------------------------------
static int CBCDecipherData(const char* pszKey, const BYTE* pbData, int dwDataLength, 
                       BYTE* pbOut, int dwOutBufferLength)
{
    MYDBGASSERT(pszKey != NULL);    
    MYDBGASSERT(pbData != NULL);    
    MYDBGASSERT(pbOut != NULL);    
    MYDBGASSERT(dwDataLength > 1);    

    if (dwDataLength <= 1)
        return 0;

    if (dwOutBufferLength < CBCDecipherBufferSize(dwDataLength))
        return 0;

    dwOutBufferLength = CBCDecipherBufferSize(dwDataLength);

    //
    // decipher data
    //
    // DeCipher: P[i] = C[i-1] XOR D[k](C[i]), 
    //
    
    BYTE lastPlainText = DecryptByte(pszKey, pbData[0], 0);   //first initilizing byte
    for (int dwIdx=0; dwIdx<dwOutBufferLength; dwIdx++)
    {
        pbOut[dwIdx] = pbData[dwIdx] ^ DecryptByte(pszKey, pbData[dwIdx+1], lastPlainText);
        lastPlainText = pbOut[dwIdx];
    }

    return dwOutBufferLength; 
}

////////////////////////////////////////////////////////////////////////////////
// Helper functions
////////////////////////////////////////////////////////////////////////////////

//+---------------------------------------------------------------------------
//
//  Function:   reverse
//
//  Synopsis:   reverse the given strings.
//
//  Arguments:  s   the string.
//
//  Returns:    the reversed string
//
//  History:    henryt  Created     5/20/97
//
//----------------------------------------------------------------------------
static LPTSTR 
reverse(
    LPTSTR  s
)
{
    int     i = 0;
    int     j = lstrlen(s) - 1;
    TCHAR   ch;

    while (i < j)
    {
        ch = s[i];
        s[i++] = s[j];
        s[j--] = ch;
    }
    return s;
}


//+---------------------------------------------------------------------------
//
//  Function:   GenerateKeyString
//
//  Synopsis:   reverse the key str and use it as a password to generate a session key.
//
//  Arguments:  OUT LPTSTR  pszBuf,   The buffer
//              IN  DWORD   dwBufLen     size of the buffer in # of chars.
//              
//              
//
//  Returns:    TRUE if success
//              FALSE if failure
//
//  History:    henryt  Created     5/20/97
//
//----------------------------------------------------------------------------
static void
GenerateKeyString(
    IN OUT  LPTSTR  pszBuf,
    IN      DWORD   dwBufLen
)
{
    lstrcpyn(pszBuf, gc_szKeyStr, dwBufLen);
    pszBuf[dwBufLen - 1] = 0;
    reverse(pszBuf);
}


//+---------------------------------------------------------------------------
//
//  Function:   SetKeyString
//
//  Synopsis:   Generates a random key that will be used to create the
//              session key that is used to encrypt the password. Once the key
//              created it is encrypted and stored in the registry so that we
//              can use the key to decrypt the password again. The key used to 
//              encrypt and decrypt is generated in GetCurrentKey(). If 
//              anything fails we default to using a hardcoded key by calling
//              GenerateKeyString.
//
//  Arguments:  pszBuf      The buffer
//              dwBufLen    size of the buffer in # of chars.
//              dwEncryptionType - selects which reg key to use
//              pfnAlloc    memory allocator(if NULL, then the default is used.   
//                           Win32 - HeapAlloc(GetProcessHeap(), ...)         
//              pfnFree     memory deallocator(if NULL, then the default is used. 
//                           Win32 - HeapFree(GetProcessHeap(), ...)          
//              pszUserKey  reg key used to store the encrypted key, if not 
//                          provided (NULL), it will default to GenerateKeyString
//              pfMoreSecure TRUE if we are using the randomly generated key
//                           FALSE if using the hardcoded key  
//
//  Returns:    TRUE if success
//              FALSE if failure
//
//  History:    03/14/2001  tomkel      Created
//
//----------------------------------------------------------------------------
static BOOL SetKeyString(IN OUT LPTSTR  pszBuf,
                         IN     DWORD dwBufLen,
                         IN     DWORD dwEncryptionType,
                         IN     PFN_CMSECUREALLOC  pfnAlloc,
                         IN     PFN_CMSECUREFREE   pfnFree,
                         IN     LPSTR pszUserKey,
                         OUT    BOOL *pfMoreSecure)
{
    BOOL fReturn = FALSE;
    BOOL fFuncRet = FALSE;
    BOOL fOk = FALSE;
    TCHAR szTempKeyStr[MAX_KEY_STRING_LEN]={0};
    DWORD cbEncryptedData = 0; 
    PBYTE pbEncryptedData = NULL;

    //
    // Don't check for pszUserKey here
    //
    if (NULL == pszBuf || NULL == pfMoreSecure)
    {
        return fReturn;
    }
    
    *pfMoreSecure = FALSE;

    //
    // Check to see if we should try to generate a random key and then store it 
    // into the reg key supplied by the caller. If not, then use the hardcoded key.
    //
    if (pszUserKey)
    {
        //
        // Try to generate random key otherwise use the hardcoded string. GenerateRandomKey
        // takes a PBYTE pointer and a count in bytes, thus we have to convert the character count
        // to bytes by multiplying it by sizeof(TCHAR)
        //
        if (g_pCryptFnc->GenerateRandomKey((PBYTE)pszBuf, dwBufLen*sizeof(TCHAR)))
        {
            // Now that we have the randomkey, we need to store it in the registry so 
            // we can use it when decrypting. In order to store it, we have 
            // to encrypt it first. 
        
            //
            // Generate a machine specific key that's used to encrypt the random number 
            // used for the session key
            //
            fFuncRet = GetCurrentKey(szTempKeyStr, MAX_KEY_STRING_LEN, pfnAlloc, pfnFree);
            if (fFuncRet)
            {
                //
                // If user want use CryptoApi and it is available
                //
                if (!g_pCryptFnc)
                {
                    g_pCryptFnc = InitCryptoApi();
                }

                if (g_pCryptFnc)
                {
                    //
                    // encrypt the data with the key string
                    //
                    fOk = g_pCryptFnc->EncryptDataWithKey(
                        szTempKeyStr,                // Key
                        (PBYTE)pszBuf,               // Secret key to encrypt
                        dwBufLen,                    // Length of secret key
                        &pbEncryptedData,            // Encrypted data will be stored here
                        &cbEncryptedData,            // Length of this buffer
                        pfnAlloc,                    // mem allocator
                        pfnFree,                     // mem deallocator
                        0);                          // not specifying keylength
                }

                if (fOk)
                {
                    //
                    // Store the encrypted key in the registry so we can use it later
                    // for decryption
                    // 
                    HKEY hKeyCm;
    
                    //
                    // Try to open the key for writing
                    //

                    LONG lRes = RegOpenKeyEx(HKEY_CURRENT_USER,
                                              pszUserKey,
                                              0,
                                              KEY_SET_VALUE ,
                                              &hKeyCm);

                    //
                    // If we can't open it the key may not be there, try to create it.
                    //

                    if (ERROR_SUCCESS != lRes)
                    {
                        DWORD dwDisposition;
                        lRes = RegCreateKeyEx(HKEY_CURRENT_USER,
                                               pszUserKey,
                                               0,
                                               TEXT(""),
                                               REG_OPTION_NON_VOLATILE,
                                               KEY_SET_VALUE,
                                               NULL,
                                               &hKeyCm,
                                               &dwDisposition);     
                    }

                    //
                    // On success, update the value, then close
                    //

                    if (ERROR_SUCCESS == lRes)
                    {
                        if (dwEncryptionType & CMSECURE_ET_USE_SECOND_RND_KEY)
                        {
                            lRes = RegSetValueEx(hKeyCm, c_pszCmRegKeyEncryptedInternetPasswordKey, NULL, REG_BINARY,
                                          pbEncryptedData, cbEncryptedData);
                        }
                        else
                        {
                            lRes = RegSetValueEx(hKeyCm, c_pszCmRegKeyEncryptedPasswordKey, NULL, REG_BINARY,
                                          pbEncryptedData, cbEncryptedData);
                        }
                        
                        RegCloseKey(hKeyCm);
                    
                        if (ERROR_SUCCESS == lRes)
                        {
                            fReturn = TRUE;
                            *pfMoreSecure = TRUE;
                        }
                    }
                }
            }
        }
    }

    //
    // Check if we need to default to the old key
    //
    if (FALSE == fReturn)
    {
        GenerateKeyString(pszBuf, dwBufLen);
        fReturn = TRUE;
    }

    if (pfnFree)
    {
        pfnFree(pbEncryptedData);
    }
    else
    {
        HeapFree(GetProcessHeap(), 0, pbEncryptedData);
    }
    
    ZeroMemory((LPVOID)szTempKeyStr, sizeof(szTempKeyStr));
    
    return fReturn;
}

//+---------------------------------------------------------------------------
//
//  Function:   GetKeyString
//
//  Synopsis:   Gets the key that is used to create a session key for
//              decrypting the password. Reads the encrypted key from the 
//              registry. Get the key used for decrypting by calling GetCurrentKey.
//              Decrypts the data and returns the key. If anything fails we 
//              default to using a hardcoded key by calling GenerateKeyString.
//
//  Arguments:  pszBuf      The buffer
//              pdwBufLen   pointer to the size of the buffer in # of chars.
//              dwEncryptionType - selects which reg key to use
//              pfnAlloc    memory allocator(if NULL, then the default is used.   
//                           Win32 - HeapAlloc(GetProcessHeap(), ...)         
//              pfnFree     memory deallocator(if NULL, then the default is used. 
//                           Win32 - HeapFree(GetProcessHeap(), ...)          
//              pszUserKey  reg key used to store the encrypted key, if not 
//                          provided (NULL), it will default to GenerateKeyString
//              pfMoreSecure TRUE if we are using the randomly generated key
//                           FALSE if using the hardcoded key  
//
//  Returns:    TRUE if success
//              FALSE if failure
//
//  History:    03/14/2001  tomkel      Created
//
//----------------------------------------------------------------------------
static BOOL GetKeyString(IN OUT  LPTSTR  pszBuf, IN DWORD *pdwBufLen, IN DWORD dwEncryptionType,
                         IN PFN_CMSECUREALLOC  pfnAlloc,
                         IN PFN_CMSECUREFREE   pfnFree,
                         IN LPSTR pszUserKey,
                         OUT BOOL *pfMoreSecure)
{
    BOOL fReturn = FALSE;
    BOOL fFuncRet = FALSE;
    HKEY hKeyCm;
    TCHAR szTempKeyStr[MAX_KEY_STRING_LEN]={0};
    DWORD dwRet = 0;
    DWORD cbEncryptedData = 0;
    PBYTE pbEncryptedData = NULL; 
    PBYTE pbData = NULL;
    DWORD dwDataBufferLength = 0;

    //
    // Don't Check for pszUserKey here
    //
    if (NULL == pszBuf || NULL == pdwBufLen || NULL == pfMoreSecure)
    {
        return fReturn;
    }

    *pfMoreSecure = FALSE;
    
    //
    // If we have the user key then we are using the randomly generated key. 
    // Try to get it from the reg.
    //
    if (pszUserKey)
    {
        //
        // Try to open the key for writing
        //

        LONG lRes = RegOpenKeyEx(HKEY_CURRENT_USER,
                                  pszUserKey,
                                  0,
                                  KEY_READ ,
                                  &hKeyCm);

        //
        // On success, read the value, then close
        //
        if (ERROR_SUCCESS == lRes)
        {
            DWORD dwType = REG_BINARY;
            //
            // Get the size first
            //
            if (dwEncryptionType & CMSECURE_ET_USE_SECOND_RND_KEY)
            {
                lRes = RegQueryValueEx(hKeyCm, c_pszCmRegKeyEncryptedInternetPasswordKey, NULL, &dwType,
                              NULL, &cbEncryptedData); 
            }
            else
            {
                lRes = RegQueryValueEx(hKeyCm, c_pszCmRegKeyEncryptedPasswordKey, NULL, &dwType,
                              NULL, &cbEncryptedData); 
            }

            //
            // Alloc the appropriate sized buffer. Need to add a space for null,
            // otherwise decrypt doesn't work.
            //
            if (pfnAlloc)
            {
                pbEncryptedData = (PBYTE)pfnAlloc(cbEncryptedData + sizeof(TCHAR));
            }
            else
            {
                pbEncryptedData = (PBYTE)HeapAlloc(GetProcessHeap(), 
                                         HEAP_ZERO_MEMORY,
                                         cbEncryptedData + sizeof(TCHAR));
            }
            
            if (pbEncryptedData)
            {
                if (dwEncryptionType & CMSECURE_ET_USE_SECOND_RND_KEY)
                {
                    lRes = RegQueryValueEx(hKeyCm, c_pszCmRegKeyEncryptedInternetPasswordKey, NULL, &dwType,
                                  pbEncryptedData, &cbEncryptedData); 
                }
                else
                {
                    lRes = RegQueryValueEx(hKeyCm, c_pszCmRegKeyEncryptedPasswordKey, NULL, &dwType,
                                  pbEncryptedData, &cbEncryptedData); 
                }
            }
            RegCloseKey(hKeyCm);
    
            // 
            // If we find the value decrypt it, otherwise we fall through and use the default key
            //
            if (ERROR_SUCCESS == lRes && pbEncryptedData)
            {
                //
                // Decrypt it using the machine specific key
                //
                fFuncRet = GetCurrentKey(szTempKeyStr, MAX_KEY_STRING_LEN, pfnAlloc, pfnFree);
                if (fFuncRet)
                {
                    if (!g_pCryptFnc)
                    {
                        g_pCryptFnc = InitCryptoApi();
                    }

                    if (g_pCryptFnc)
                    {
                        dwRet = g_pCryptFnc->DecryptDataWithKey(
                                    szTempKeyStr,            // Key
                                    pbEncryptedData,         // Encrypted data
                                    cbEncryptedData,         // Length of encrypted data
                                    &pbData,                 // decrypted data
                                    &dwDataBufferLength,     // Length of decrypted data
                                    pfnAlloc,                // mem allocator
                                    pfnFree,                 // mem deallocator
                                    0);                      // not specifying keylength

                        if (ERROR_SUCCESS == dwRet)
                        {
                            fReturn = TRUE;
                            *pfMoreSecure = TRUE;           // Using the random key
                        }
                    }
                }
            }
        }
    }

    if (fReturn)
    {
        DWORD dwLen = *pdwBufLen;
        if (dwDataBufferLength < *pdwBufLen)
        {
            dwLen = dwDataBufferLength;
        }

        //
        // Copy into out param
        //
        CopyMemory((LPVOID)pszBuf, pbData, dwLen);
    }
    else
    {
        GenerateKeyString(pszBuf, *pdwBufLen);
        fReturn = TRUE;
    }

    if (pfnFree)
    {
        pfnFree(pbEncryptedData);
        pfnFree(pbData);
    }
    else
    {
        HeapFree(GetProcessHeap(), 0, pbEncryptedData);
        HeapFree(GetProcessHeap(), 0, pbData);
    }

    ZeroMemory((LPVOID)szTempKeyStr, sizeof(szTempKeyStr));

    return fReturn;
}

//+---------------------------------------------------------------------------
//
//  Function:   GetCurrentKey
//
//  Synopsis:   Creates a machine dependent key by using the Hard Drive's 
//              serial number. This serial number is then used to fil lup the
//              output buffer. If the hard drive is replaced then this of course
//              will not generate the same serial number. 
//
//  Arguments:  szTempKeyStr        The buffer
//              dwTempKeyStrMaxLen  max length of the buffer in # of chars.
//              pfnAlloc  memory allocator(if NULL, then the default is used.   
//                        Win32 - HeapAlloc(GetProcessHeap(), ...)         
//              pfnFree   memory deallocator(if NULL, then the default is used. 
//                        Win32 - HeapFree(GetProcessHeap(), ...)          
//
//  Returns:    TRUE if success
//              FALSE if failure
//
//  History:    03/14/2001  tomkel      Created
//
//----------------------------------------------------------------------------
static BOOL GetCurrentKey(PTCHAR szTempKeyStr, DWORD dwTempKeyStrMaxLen, 
                   IN  PFN_CMSECUREALLOC  pfnAlloc,
                   IN  PFN_CMSECUREFREE   pfnFree)
{
    BOOL fFuncRet = FALSE;
    DWORD dwVolumeSerialNumber = 0;
    DWORD dwMaxComponentLen = 0;
    DWORD dwFileSysFlags = 0;
    LPTSTR pszSerialNum = NULL;
    
    if (NULL == szTempKeyStr)
    {
        return fFuncRet;
    }

    //
    // Lets generate the key from the HD serial number. This means that encrypted
    // passwords and keys will only be valid on this machine. If the user replaces
    // the drive, then the decryption will fail.
    //
    fFuncRet = GetVolumeInformation(NULL, NULL, 0, &dwVolumeSerialNumber, 
                                    &dwMaxComponentLen, &dwFileSysFlags, NULL, 0);
    if (fFuncRet)
    {
        DWORD dwLen = 0;
        
        //
        // Make sure we have a buffer large enough to hold the value. 
        // Allocate a string based on the number of bits, thus a decimal number
        // will always fit. Maybe an exaggeration, but the length isn't hardcoded.
        //
        if (pfnAlloc)
        {
            pszSerialNum = (LPTSTR)pfnAlloc(sizeof(dwVolumeSerialNumber)*8*sizeof(TCHAR));
        }
        else
        {
            pszSerialNum = (LPTSTR)HeapAlloc(GetProcessHeap(), 
                                     HEAP_ZERO_MEMORY,
                                     sizeof(dwVolumeSerialNumber)*8*sizeof(TCHAR));
        }
        
        if (pszSerialNum)
        {
            DWORD dwSNLen = 0;

            wsprintf(pszSerialNum, TEXT("%u"), dwVolumeSerialNumber);

            //
            // See how many times the serial number string will fit into our buffer
            // Need to check the length due to PREFIX. If the length is 0, just return. 
            //
            dwSNLen = lstrlen(pszSerialNum);

            if (dwSNLen)
            {
                dwLen = (dwTempKeyStrMaxLen - 1) / dwSNLen;
            }
            else
            {
                fFuncRet = FALSE;
                goto done;
            }

            if (0 < dwLen)
            {
                DWORD i = 0;
            
                lstrcpy(szTempKeyStr, pszSerialNum);
                //
                // Fill up the buffer. Start at 1 because we already copied the first 
                // serial number into the buffer
                //
                for (i = 1; i<dwLen; i++)
                {
                    lstrcat(szTempKeyStr, pszSerialNum);
                }
            }
            else
            {
                //
                // the length is larger than the buffer so just copy what fits into the buffer
                //
                lstrcpyn(szTempKeyStr, pszSerialNum, dwTempKeyStrMaxLen-1);
            }
        }
        else
        {
            fFuncRet = FALSE;
        }
    }

done:
    if (pfnFree)
    {
        pfnFree(pszSerialNum);
    }
    else
    {
        HeapFree(GetProcessHeap(), 0, (LPVOID)pszSerialNum);
    }

    return fFuncRet;
}