Pode um App.Config ser carregada a partir de uma cadeia ou de memória stream?

Question

Eu sei que eu posso carregar um arquivo app a partir de um local diferente usando a seguinte linha de código:

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

onde ConfigFile é um local caminho completo. O que eu gostaria de fazer, porém, é ser capaz de carregar um arquivo que foi criptografado para o app. Idealmente, eu gostaria de ser capaz de carregar o arquivo, decifrá-lo e carregá-lo em uma cadeia ou de memória corrente e passá-lo para o aplicativo como se fosse o app. Eu sei que eu poderia apenas carregar todos os valores dele e acessá-los manualmente, mas eu gostaria de ser capaz de acessá-los usando o construído em funcionalidade de .NET. Existe uma maneira de dizer o aplicativo para usar o arquivo de configuração a partir de algo que não seja um arquivo?

A outra opção é para abrir o arquivo, decifrá-lo, escrevê-lo para um arquivo temporário e, em seguida, usar o código acima para fazer referência a ela dessa maneira, mas se houvesse uma maneira mais fácil, idealmente, eu gostaria de encontrá-lo, para ter para evitar lidar com arquivos adicionais.

Answer 1

Embora eu nunca foi capaz de obter uma resposta para isso, até agora, eu tive que vir para cima com uma solução alternativa. Isto pode não ser a melhor solução, mas ela não funciona. Basicamente o que temos feito é encypted nosso arquivo app.config, e deu-lhe um novo nome. Quando o aplicativo é iniciado, ele vai levar o arquivo encypted, decyrpt-lo e gravá-lo em um arquivo temporário do Windows. Isso garante que o arquivo é um nome aleatório exclusivo que ninguém é provável encontrar, e não temos para gerenciar os arquivos, como o Windows irá excluí-lo para nós automaticamente. Desta maneira, cada relançamento somos capazes de re-escrever um novo arquivo e usá-lo. Aqui estão os trechos de código básicos para quem está interessado.

Este primeiro método, LoadFileAppConfig(), irá carregar o arquivo. Neste caso, uma vez que são serviços, precisamos carregar o caminho de execução, e passá-lo para o método apropriado. Voltamos o caminho do app.config descriptografado e, em seguida, usar o método SetData() configurá-lo para ser o caminho app.

/// <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;
    }
}

Neste método que está recebendo o caminho do arquivo, passando o arquivo off para ser decifrada e voltou como uma string, e em seguida, escrever o arquivo para o nosso arquivo temporário do 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 leva no caminho do app.config criptografado, usa nossa ferramenta de descriptografia para descriptografar o arquivo (assegurando que podemos decifrá-lo, e que é o tipo de arquivo à direita) e, em seguida, retornar o conteúdo descriptografado como string para o método acima.

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;
}