freeotfe4pdaregistry.c

文件驱动加密,功能强大,可产生加密分区,支持AES,MD2,MD4,MD5MD2, MD4, MD5, RIPEMD-128, RIPEMD-160, SHA-1, SHA-224, SHA-256,

    DEBUGOUTLIB(DEBUGLEV_ENTER, (TEXT("RegDetailsGetBuiltinByKEY\n")));

    DEBUGOUTLIB(DEBUGLEV_INFO, (TEXT("a-Opening key: %s\n"), key));
    if (RegOpenKeyEx( 
                     REGHIVE,
                     key,
                     0,
                     0,
                     &hKey
                    ) == ERROR_SUCCESS)
        {
        retval = RegDetailsGetBuiltinByHKEY(hKey, detailsBuiltin);
        RegCloseKey(hKey);
        }
     
    DEBUGOUTLIB(DEBUGLEV_EXIT, (TEXT("RegDetailsGetBuiltinByKEY\n")));
    return retval;
}


// =========================================================================
BOOL RegDetailsGetBuiltinByHKEY(HKEY hKey, REGDETAILS_BUILTIN *detailsBuiltin)
{
    BOOL retval = FALSE;

    DEBUGOUTLIB(DEBUGLEV_VERBOSE_ENTER, (TEXT("RegDetailsGetBuiltinByHKEY\n")));

    if (hKey != NULL)
        {
        retval = TRUE;

        retval = retval && RegistryGetString(
                                 hKey, 
                                 REGNAME_BUILTIN_PREFIX,
                                 &(detailsBuiltin->Prefix)
                                );
        retval = retval && RegistryGetString(
                                 hKey, 
                                 REGNAME_BUILTIN_DLL,
                                 &(detailsBuiltin->Dll)
                                );
        retval = retval && RegistryGetString(
                                 hKey, 
                                 REGNAME_BUILTIN_FRIENDLYNAME,
                                 &(detailsBuiltin->FriendlyName)
                                );

        retval = retval && RegistryGetDWORD(
                                 hKey, 
                                 REGNAME_BUILTIN_ORDER,
                                 &(detailsBuiltin->Order)
                                );
        retval = retval && RegistryGetDWORD(
                                 hKey, 
                                 REGNAME_BUILTIN_IOCTL,
                                 &(detailsBuiltin->Ioctl)
                                );

        retval = retval && RegistryGetString(
                                 hKey, 
                                 REGNAME_BUILTIN_ICLASS,
                                 &(detailsBuiltin->IClass)
                                );
        retval = retval && RegistryGetString(
                                 hKey, 
                                 REGNAME_BUILTIN_PROFILE,
                                 &(detailsBuiltin->Profile)
                                );
        
        }

    DEBUGOUTLIB(DEBUGLEV_VERBOSE_EXIT, (TEXT("RegDetailsGetBuiltinByHKEY\n")));
    return retval;
}


// =========================================================================
BOOL RegDetailsGetProfileByID(
                          int id, 
                          REGDETAILS_PROFILE* detailsProfile
                         )
{
    BOOL retval = FALSE;
    WCHAR* key;

    DEBUGOUTLIB(DEBUGLEV_ENTER, (TEXT("RegDetailsGetProfileByID\n")));

    RegKeyGenerate(id, NULL, &key);

    retval = RegDetailsGetProfileByKey(key, detailsProfile);

    // Cleanup...
    SecZeroAndFreeWCHARMemory(key);
 
    DEBUGOUTLIB(DEBUGLEV_EXIT, (TEXT("RegDetailsGetProfileByID\n")));
    return retval;
}


// =========================================================================
BOOL RegDetailsGetProfileByKey(
                          WCHAR* key, 
                          REGDETAILS_PROFILE* detailsProfile
                         )
{
    BOOL retval = FALSE;
    HKEY hKey;

    DEBUGOUTLIB(DEBUGLEV_ENTER, (TEXT("RegDetailsGetProfileByKey\n")));

    DEBUGOUTLIB(DEBUGLEV_INFO, (TEXT("b-Opening key: %s\n"), key));
    if (RegOpenKeyEx( 
                     REGHIVE,
                     key,
                     0,
                     0,
                     &hKey
                    ) == ERROR_SUCCESS)
        {
        retval = RegDetailsGetProfileByHKEY(hKey, detailsProfile);
        RegCloseKey(hKey);
        }

    DEBUGOUTLIB(DEBUGLEV_EXIT, (TEXT("RegDetailsGetProfileByKey\n")));
    return retval;
}


// =========================================================================
BOOL RegDetailsGetProfileByHKEY(
                          HKEY hKey, 
                          REGDETAILS_PROFILE* detailsProfile
                         )
{
    BOOL retval = FALSE;

    DEBUGOUTLIB(DEBUGLEV_VERBOSE_ENTER, (TEXT("RegDetailsGetProfileByHKEY\n")));

    if (hKey != NULL)
        {
        retval = TRUE;

        retval = retval && RegistryGetString(
                                 hKey, 
                                 REGNAME_PROFILE_NAME,
                                 &(detailsProfile->Name)
                                );
        retval = retval && RegistryGetString(
                                 hKey, 
                                 REGNAME_PROFILE_FOLDER,
                                 &(detailsProfile->Folder)
                                );
        retval = retval && RegistryGetDWORD(
                                 hKey, 
                                 REGNAME_PROFILE_AUTOMOUNT,
                                 &(detailsProfile->AutoMount)
                                );
        retval = retval && RegistryGetDWORD(
                                 hKey, 
                                 REGNAME_PROFILE_AUTOPART,
                                 &(detailsProfile->AutoPart)
                                );
        retval = retval && RegistryGetDWORD(
                                 hKey, 
                                 REGNAME_PROFILE_AUTOFORMAT,
                                 &(detailsProfile->AutoFormat)
                                );
        retval = retval && RegistryGetDWORD(
                                 hKey, 
                                 REGNAME_PROFILE_MOUNTFLAGS,
                                 &(detailsProfile->MountFlags)
                                );
        }
 
    DEBUGOUTLIB(DEBUGLEV_VERBOSE_EXIT, (TEXT("RegDetailsGetProfileByHKEY\n")));
    return retval;
}


// =========================================================================
BOOL RegDetailsGetActiveByKey(
    WCHAR* key, 
//    BOOL mustInclHnd,
    REGDETAILS_ACTIVE* detailsActive
)
{
    BOOL retval = FALSE;
    HKEY hKey;

    DEBUGOUTLIB(DEBUGLEV_ENTER, (TEXT("RegDetailsGetActiveByKey\n")));

    DEBUGOUTLIB(DEBUGLEV_INFO, (TEXT("c-Opening key: %s\n"), key));
    if (RegOpenKeyEx( 
                     REGHIVE,
                     key,
                     0,
                     0,
                     &hKey
                    ) == ERROR_SUCCESS)
        {
        retval = RegDetailsGetActiveByHKEY(
                                           hKey, 
                                           //mustInclHnd, 
                                           detailsActive
                                          );
        RegCloseKey(hKey);
        }

    DEBUGOUTLIB(DEBUGLEV_EXIT, (TEXT("RegDetailsGetActiveByKey\n")));
    return retval;
}


// =========================================================================
// mustInclHnd - If set, those entries without a value for "Hnd" will be
//               ignored
// !NOTE!
// detailsActive->Mountpoint will be set to NULL if a FreeOTFE mountpoint
// can't be found
BOOL RegDetailsGetActiveByHKEY(
    HKEY hKey, 
//    BOOL mustInclHnd,
    REGDETAILS_ACTIVE* detailsActive
)
{
    BOOL retval = FALSE;
    REGDETAILS_BUILTIN detailsBuiltin;
    REGDETAILS_PROFILE detailsProfile;

    DEBUGOUTLIB(DEBUGLEV_VERBOSE_ENTER, (TEXT("RegDetailsGetActiveByHKEY\n")));

    if (hKey != NULL)
        {
        retval = TRUE;

        // The "Hnd" key appears to be set to the same value as returned by
        // ActivateDeviceEx, however this doesn't apear documented; hence we set the
        // handle explicitly on the device so we can retrieve it the device there
        // later
        //if (!(RegistryGetDWORD(
        //                       hKey, 
        //                       REGNAME_ACTIVE_HND,
        //                       &(detailsActive->Hnd)
        //                      )))
        //    {
        //    if (mustInclHnd) 
        //        {
        //        retval = FALSE;
        //        }
        //    }        

        retval = retval && RegistryGetString(
                                 hKey, 
                                 REGNAME_ACTIVE_KEY,
                                 &(detailsActive->Key)
                                );
        retval = retval && RegistryGetString(
                                 hKey, 
                                 REGNAME_ACTIVE_NAME,
                                 &(detailsActive->Name)
                                );

        // Identify mountpoint, if possible.
        detailsActive->Mountpoint = NULL;
        if (RegDetailsGetAllByKey(
                                  detailsActive->Key, 
                                  &detailsBuiltin,
                                  &detailsProfile
                                 ))
            {
            if (
                (wcscmp(detailsBuiltin.Prefix, DRIVER_PREFIX) == 0) &&
                (wcscmp(detailsProfile.Name, DRIVER_PROFILE_NAME) == 0)
               )
                {
                // +1 to include terminating NULL
                detailsActive->Mountpoint = calloc(
                                                   (wcslen(detailsProfile.Folder) + 1),
                                                   sizeof(*(detailsActive->Mountpoint))
                                                  );
                if (detailsActive->Mountpoint == NULL)
                    {
                    DEBUGOUTLIB(DEBUGLEV_ERROR, (TEXT("Unable to calloc memory to store mountpoint\n")));
                    retval = FALSE;
                    }
                else
                    {
                    wcscpy(detailsActive->Mountpoint, detailsProfile.Folder);
                    }

                }

            RegDetailsFree(&detailsBuiltin, &detailsProfile, NULL);
            }
        }
 
    DEBUGOUTLIB(DEBUGLEV_VERBOSE_EXIT, (TEXT("RegDetailsGetActiveByHKEY\n")));
    return retval;
}


// =========================================================================
void RegDetailsFree(
                    REGDETAILS_BUILTIN *detailsBuiltin,
                    REGDETAILS_PROFILE *detailsProfile,
                    REGDETAILS_ACTIVE *detailsActive
                   )
{
    DEBUGOUTLIB(DEBUGLEV_ENTER, (TEXT("RegDetailsFree\n")));

    // Builtin...
    if (detailsBuiltin != NULL)
        {
        SecZeroAndFreeWCHARMemory(detailsBuiltin->Prefix);
        detailsBuiltin->Prefix = NULL;
        SecZeroAndFreeWCHARMemory(detailsBuiltin->Dll);
        detailsBuiltin->Dll = NULL;
        SecZeroAndFreeWCHARMemory(detailsBuiltin->FriendlyName);
        detailsBuiltin->FriendlyName = NULL;
        detailsBuiltin->Order = 0;
        detailsBuiltin->Ioctl = 0;
        SecZeroAndFreeWCHARMemory(detailsBuiltin->IClass);
        detailsBuiltin->IClass = NULL;
        SecZeroAndFreeWCHARMemory(detailsBuiltin->Profile);
        detailsBuiltin->Profile = NULL;

        // Belt 'n braces...
        SecZeroMemory(detailsBuiltin, sizeof(*detailsBuiltin));
        }

    // Profile...
    if (detailsProfile != NULL)
        {
        SecZeroAndFreeWCHARMemory(detailsProfile->Name);
        detailsProfile->Name = NULL;
        SecZeroAndFreeWCHARMemory(detailsProfile->Folder);
        detailsProfile->Folder = NULL;
        detailsProfile->AutoMount = 0;
        detailsProfile->AutoPart = 0;
        detailsProfile->AutoFormat = 0;
        detailsProfile->MountFlags = 0;

        // Belt 'n braces...
        SecZeroMemory(detailsProfile, sizeof(*detailsProfile));
        }

    // Active...
    if (detailsActive != NULL)
        {
        // The "Hnd" key appears to be set to the same value as returned by
        // ActivateDeviceEx, however this doesn't apear documented; hence we set the
        // handle explicitly on the device so we can retrieve it the device there
        // later
        //detailsActive->Hnd = 0;

        SecZeroAndFreeWCHARMemory(detailsActive->Key);
        detailsActive->Key = NULL;
        SecZeroAndFreeWCHARMemory(detailsActive->Name);
        detailsActive->Name = NULL;
        SecZeroAndFreeWCHARMemory(detailsActive->Mountpoint);
        detailsActive->Mountpoint = NULL;

        // Belt 'n braces...
        SecZeroMemory(detailsActive, sizeof(*detailsActive));
        }

    DEBUGOUTLIB(DEBUGLEV_EXIT, (TEXT("RegDetailsFree\n")));
}


// =========================================================================
BOOL RegDetailsDeleteAllByKey(WCHAR* builtinKey, BOOL force)