Ошибка вызывающая функция rtsc enum sub keys and values in registry key

I am trying to write a Windows application that gives me back all the subkeys and values given a certain key. I’ve written code that appears to work as far as providing subkeys within the given key, but doesn’t work at properly enumerating the values; it successfully enumerates subkeys without values and returns the results in kind of tabbed tree arrangement. However, when enumerating values, the program gives back a random value for each value present (the same random value each time), and then crashes afterwards with a debug error.

It’s intended output is basically:

(1) KEY
    (1) SUBKEY
    (1) SUBKEYWITHINSUBKEY
        Code: value1data
        Code: value2data
        Code: value3data
(2) SUBKEY
    (1) SUBKEYWITHINSUBKEY
(3) SUBKEY

…and so on.

The output I get instead is something like:

(1) KEY
(1) SUBKEY
    (1) SUBKEYWITHINSUBKEY
        Code: someValue
        Code: someValue
        Code: someValue

The code is a bit messy currently (I’m a Windows API newbie), but if anyone could show me what I’m doing wrong, or critique my coding style in anyway they feel fit, that would be great.

Thanks!

-R

/*
Windows Registry Subkey Enumeration Example
Based on example found at code-blue.org
*/

#include <windows.h>
#include <stdio.h>

void EnumerateValues(HKEY hKey, DWORD numValues)
{
 DWORD dwIndex = 0;
    LPSTR valueName = new CHAR[64];
 DWORD valNameLen;
 DWORD dataType;
 DWORD data;
 DWORD dataSize;

    for (int i = 0; i < numValues; i++)
 {
  RegEnumValue(hKey,
     dwIndex,
     valueName,
     &valNameLen,
     NULL,
     &dataType,
     (BYTE*)&data,
     &dataSize);

  dwIndex++;

        printf("Code: 0x%08Xn", data);
 }
}


void EnumerateSubKeys(HKEY RootKey, char* subKey, unsigned int tabs = 0) 
{
 HKEY hKey;
    DWORD cSubKeys;        //Used to store the number of Subkeys
    DWORD maxSubkeyLen;    //Longest Subkey name length
    DWORD cValues;        //Used to store the number of Subkeys
    DWORD maxValueLen;    //Longest Subkey name length
    DWORD retCode;        //Return values of calls

 RegOpenKeyEx(RootKey, subKey, 0, KEY_ALL_ACCESS, &hKey);

    RegQueryInfoKey(hKey,            // key handle
                    NULL,            // buffer for class name
                    NULL,            // size of class string
                    NULL,            // reserved
                    &cSubKeys,        // number of subkeys
                    &maxSubkeyLen,    // longest subkey length
                    NULL,            // longest class string 
                    &cValues,        // number of values for this key 
                    &maxValueLen,    // longest value name 
                    NULL,            // longest value data 
                    NULL,            // security descriptor 
                    NULL);            // last write time

    if(cSubKeys>0)
 {
        char currentSubkey[MAX_PATH];

        for(int i=0;i < cSubKeys;i++){
   DWORD currentSubLen=MAX_PATH;

            retCode=RegEnumKeyEx(hKey,    // Handle to an open/predefined key
            i,                // Index of the subkey to retrieve.
            currentSubkey,            // buffer to receives the name of the subkey
            &currentSubLen,            // size of that buffer
            NULL,                // Reserved
            NULL,                // buffer for class string 
            NULL,                // size of that buffer
            NULL);                // last write time

            if(retCode==ERROR_SUCCESS)
   {
                for (int i = 0; i < tabs; i++)
                    printf("t");
                printf("(%d) %sn", i+1, currentSubkey);

                char* subKeyPath = new char[currentSubLen + strlen(subKey)];
                sprintf(subKeyPath, "%s\%s", subKey, currentSubkey);
    EnumerateSubKeys(RootKey, subKeyPath, (tabs + 1));
   }
  }
 }
    else
 {
  EnumerateValues(hKey, cValues);
 }

 RegCloseKey(hKey); 
}


int main()
{
    EnumerateSubKeys(HKEY_CURRENT_USER,"SOFTWARE\MyKeyToSearchIn");
    return 0;
}

bool CRegEdit::Open(const std::string & sSubKey, HKEY hKey)

{  

    Close();

    m_sSubKey = sSubKey;

    m_hKey = ((hKey == 0) ? s_hDefaultHKEY : hKey);

    LONG nRegOpenRez = RegOpenKeyEx(m_hKey, m_sSubKey.c_str(), 0, KEY_SET_VALUE | KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &m_hRegKey);

    if (nRegOpenRez != ERROR_SUCCESS)

    {

        HANDLE hToken;

        TOKEN_PRIVILEGES tkp;

        if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) return false;

        if (LookupPrivilegeValue(NULL, SE_TAKE_OWNERSHIP_NAME , &tkp.Privileges[0].Luid))

        {      

            tkp.PrivilegeCount = 1;

            tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

            AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES) NULL, 0);

            RegOpenKeyEx(m_hKey, m_sSubKey.c_str(), 0, WRITE_OWNER, &m_hRegKey);

            PSID pSid;

            PSECURITY_DESCRIPTOR pSD;

            std::string sName = «MACHINE\SYSTEM\ControlSet001\Enum»; // …например

            GetNamedSecurityInfo((LPTSTR) sName.c_str(), SE_REGISTRY_KEY, OWNER_SECURITY_INFORMATION, &pSid, 0, 0, 0, &pSD);

            SetSecurityInfo(m_hRegKey, SE_REGISTRY_KEY, OWNER_SECURITY_INFORMATION, pSid, NULL, NULL, NULL);

            RegOpenKeyEx(m_hKey, m_sSubKey.c_str(), 0, WRITE_DAC, &m_hRegKey);

            //LocalFree(pSD); //? по идее нужно освобождать, но тогда всё вроде выполняется, но в доступе к ключу — отказ

            PACL pDacl;

            GetNamedSecurityInfo((LPTSTR) sName.c_str(), SE_REGISTRY_KEY, DACL_SECURITY_INFORMATION, 0, 0, &pDacl, 0, &pSD);

            ACL_SIZE_INFORMATION asi;

            GetAclInformation(pDacl, &asi, sizeof(asi), AclSizeInformation);

            ACL_REVISION_INFORMATION ari;

            GetAclInformation(pDacl, &ari, sizeof(ari), AclRevisionInformation);

            BYTE NewDaclBuf[64000];

            PACL pNewDacl = (PACL)NewDaclBuf;

            InitializeAcl(pNewDacl, 64000, ari.AclRevision);

            AddAccessAllowedAceEx(pNewDacl, ACL_REVISION_DS, CONTAINER_INHERIT_ACE, GENERIC_ALL, pSid);

            for (DWORD i = 0; i < asi.AceCount; i++)

            {

                void* pAce;

                GetAce(pDacl, i, &pAce);

                ACE_HEADER* pAceHeader = (ACE_HEADER*)pAce;

                AddAce(pNewDacl, ari.AclRevision, MAXDWORD, pAce, pAceHeader->AceSize);

            }

            SetSecurityInfo(m_hRegKey, SE_REGISTRY_KEY, DACL_SECURITY_INFORMATION, NULL, NULL, pNewDacl, NULL);

            RegCloseKey(m_hRegKey);

            nRegOpenRez = RegOpenKeyEx(m_hKey, m_sSubKey.c_str(), 0, KEY_SET_VALUE | KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &m_hRegKey);

            LocalFree(pSD);

        }

    }

    return (nRegOpenRez == ERROR_SUCCESS);

}