¿Se puede cargar un App.Config desde una cadena o secuencia de memoria?

Question

Sé que puedo cargar un archivo app.config desde una ubicación diferente usando la siguiente línea de código:

AppDomain.CurrentDomain.SetData("APP_CONFIG_FILE", ConfigFile);

donde ConfigFile es una ubicación de ruta completa. Sin embargo, lo que me gustaría hacer es poder cargar un archivo que ha sido encriptado para la app.config. Idealmente, me gustaría poder cargar el archivo, descifrarlo, cargarlo en una cadena o secuencia de memoria y pasarlo a la aplicación como si fuera la app.config. Sé que podría cargar todos los valores y acceder a ellos manualmente, pero me gustaría poder acceder a ellos utilizando la funcionalidad integrada de .NET. ¿Hay alguna manera de decirle a la aplicación que use el archivo de configuración de algo que no sea un archivo?

La otra opción es abrir el archivo, descifrarlo, escribirlo en un archivo temporal y luego usar el código anterior para referenciarlo de esa manera, pero si hubiera una manera más fácil, idealmente, me gustaría búscalo para evitar tener que lidiar con archivos adicionales.

Answer 1

Aunque hasta ahora nunca pude obtener una respuesta para esto, tuve que encontrar una solución alternativa. Puede que esta no sea la mejor solución, pero funciona. Básicamente, lo que hemos hecho es cifrar nuestro archivo app.config y darle un nuevo nombre. Cuando se inicia la aplicación, tomará el archivo cifrado, lo descifrará y lo escribirá en un archivo temporal de Windows. Esto garantiza que el archivo tenga un nombre aleatorio único que nadie pueda encontrar, y no tenemos que administrar los archivos, ya que Windows lo eliminará automáticamente. De esta manera, cada relanzamiento podemos reescribir un nuevo archivo y usarlo. Aquí están los fragmentos de código básicos para cualquier persona interesada.

Este primer método, LoadFileAppConfig () , cargará el archivo. En este caso, dado que son servicios, necesitamos cargar la ruta de ejecución y pasarla al método apropiado. Recuperamos la ruta del app.config descifrado, y luego usamos el método SetData () para configurarlo como la ruta app.config.

/// <summary>
/// Loads the Local App.Config file, and sets it to be the local app.config file
/// </summary>
/// <param name="p_ConfigFilePath">The path of the config file to load, i.e. \Logs\</param>
public void LoadFileAppConfig(string p_ConfigFilePath)
{
    try
    {
        // The app.config path is the passed in path + Application Name + .config
        m_LocalAppConfigFile = ProcessLocalAppConfig(p_ConfigFilePath + this.ApplicationName + ".config");

        // This sets the service's app.config property
        AppDomain.CurrentDomain.SetData("APP_CONFIG_FILE", m_LocalAppConfigFile);
    }
    catch (Exception ex)
    {
        throw ex;
    }
}

En este método estamos obteniendo la ruta del archivo, pasando ese archivo para que se descifre y se devuelva como una cadena, y luego escribamos ese archivo en nuestro archivo temporal de Windows.

public string ProcessLocalAppConfig(string p_ConfigFilePath)
{
    try
    {
        string fileName = Path.GetTempFileName();
        string unencryptedConfig = DecryptConfigData(p_ConfigFilePath);

        FileStream fileStream = new FileStream(fileName, FileMode.Create, FileAccess.Write);
        StreamWriter streamWriter = new StreamWriter(fileStream);

        if (!string.IsNullOrEmpty(unencryptedConfig))
        {
            try
            {
                streamWriter.BaseStream.Seek(0, SeekOrigin.End);
                streamWriter.WriteLine(unencryptedConfig);
            }

            catch (IOException ex)
            {
                Debug.Assert(false, ex.ToString());
            }
            finally
            {
                streamWriter.Close();
            }
            return fileName;
        }
        return null;
    }
    catch (Exception)
    {
        throw;
    }
}

Este método final toma la ruta de acceso de la aplicación cifrada.config, utiliza nuestra herramienta de descifrado para descifrar el archivo (asegurando que podamos descifrarlo y que es el tipo de archivo correcto) y luego devolver el contenido descifrado como cadena al método anterior.

private string DecryptConfigData(string p_AppConfigFile)
{
    string decryptedData = null;
    TMS.Pearl.SystemFramework.CryptographyManager.CryptographyManager cryptManager = new TMS.Pearl.SystemFramework.CryptographyManager.CryptographyManager();
    try
    {
        //Attempt to load the file.
        if (File.Exists(p_AppConfigFile))
        {
            //Load the file's contents and decrypt them if they are encrypted.
            string rawData = File.ReadAllText(p_AppConfigFile);

            if (!string.IsNullOrEmpty(rawData))
            {
                if (!rawData.Contains("<?xml"))  //assuming that all unencrypted config files will start with an xml tag...
                {
                    decryptedData = cryptManager.Decrypt(rawData);
                }
                else
                {
                    decryptedData = rawData;
                }
            }
        }
    }
    catch (Exception)
    {
        throw;
    }

    return decryptedData;
}