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

Question

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

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

donde ConfigFile es una ubicación de la ruta completa. Lo que me gustaría hacer es poder cargar un archivo que haya sido encriptado para el app.config. Idealmente, me gustaría poder cargar el archivo, descifrarlo y cargarlo en una secuencia o secuencia de memoria y pasarlo a la aplicación como si fuera el app.config. Sé que podría simplemente cargar todos los valores y acceder a ellos de forma manual, pero me gustaría poder acceder a ellos utilizando la funcionalidad incorporada 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 hacer referencia de esa manera, pero si hubiera una manera más sencilla, idealmente, me gustaría para encontrarlo, tener que evitar tratar con archivos adicionales.

Answer 1

Si bien nunca pude obtener una respuesta para esto hasta ahora, tuve que idear una solución alternativa. Esta puede no ser la mejor solución, pero funciona. Básicamente, lo que hemos hecho es codificar nuestro archivo app.config y darle un nuevo nombre. Cuando se inicia la aplicación, tomará el archivo cifrado, lo desencriptará y lo escribirá en un archivo temporal de Windows. Esto asegura que el archivo es un nombre aleatorio único que nadie encontrará, y no tenemos que administrar los archivos, ya que Windows lo eliminará automáticamente. De esta forma, cada relanzamiento podemos volver a escribir un nuevo archivo y usarlo. Aquí están los fragmentos de código básicos para cualquier persona que esté interesada.

Este primer método, LoadFileAppConfig(), cargará el archivo. En este caso, dado que son servicios, debemos 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 para que sea 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 recibiendo la ruta del archivo, pasando ese archivo fuera a ser descifrados y se devuelve como una cadena, y luego escribir ese archivo a 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 último método toma en el camino de la app.config cifrado, utiliza nuestra herramienta de descifrado para descifrar el archivo (asegurando que podemos descifrarlo, y que es el tipo de archivo correcto) y luego devolver el contenido descifrado como una cadena para el 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; 
}