Eu estive examinando vários exemplos de criptografia connectionStrings (Web.config) em um aplicativo ASP.NET MVC (.NET 4.0) e parece que existem duas maneiras gerais de alcançá-lo (Exemplo 1 e os relacionadosexemplo 2):

Use a ferramenta aspnet_regiis.

O principal problema com o uso do aspnet_regiis é que eu posso executar a ferramenta localmente (na minha máquina de desenvolvimento), mas o site realmente hospedado no Arvixe e como qualquer outro host da Web: não há como executar comandos no servidor. Pelo que entendi, se eu criptografar o Web.config connectionStrings na minha máquina e publicar o Web.config, eles não poderão ser descriptografados no servidor (corrija-me se isso estiver errado).

Nota: usei apenas oRSAProtectedConfigurationProvider, mas presumo que oDataProtectionConfigurationProvider terá o mesmo problema, pois é específico ao usuário / máquina.

Criptografar programaticamente a cadeia de conexão.

Criptografar programaticamente o connectionStrings também tem uma desvantagem: toda vez que eu publico meu site, o Web.config é atualizado (com o connectionStrings não criptografado) e isso significa que, por algum período, o Web.config não será criptografado. Mesmo se eu garantir que o Web.config seja publicado apenas quando houver alterações, o problema poderá ser minimizado, mas não mitigado.

Eu pensei que o uso de uma classe estática pode ajudar a reduzir ainda mais o tempo que o connectionStrings não é criptografado. Infelizmente, criptografar o connectionStrings requer o caminho do aplicativo e parece que a única maneira de obter o caminho do aplicativo é a partir da solicitação (Request.ApplicationPath) e em uma classe estática (obviamente) não há solicitação.

private void ProtectSection(string sectionName,
                                   string provider)
{
    Configuration config =
        WebConfigurationManager.
            OpenWebConfiguration(Request.ApplicationPath);

    ConfigurationSection section =
                 config.GetSection(sectionName);

    if (section != null &&
              !section.SectionInformation.IsProtected)
    {
        section.SectionInformation.ProtectSection(provider);
        config.Save();
    }
}

private void UnProtectSection(string sectionName)
{
    Configuration config =
        WebConfigurationManager.
            OpenWebConfiguration(Request.ApplicationPath);

    ConfigurationSection section =
              config.GetSection(sectionName);

    if (section != null &&
          section.SectionInformation.IsProtected)
    {
        section.SectionInformation.UnprotectSection();
        config.Save();
    }
}

UnProtectSection("appSettings");

ProtectSection("appSettings",
    "DataProtectionConfigurationProvider");

Qual é a maneira correta de criptografar a connectionString e eliminar / reduzir a quantidade de tempo que a seção Web.config não é criptografada? Você escreve algum tipo de invólucro ao redor doOpenWebConfiguration método que verifica se a seção está criptografada e usa apenas esse invólucro? Os usuários podem acessarqualquer página em seu site, então como adiar a criptografia até que eles solicitem alguns dados de um banco de dados ou verificar se eles foram criptografados na primeira oportunidade?