Zaszyfrowana konfiguracja w środowisku ASP.NET Core

Question

Czy odszedłby oderwać się, jaki jest preferowany sposób przechowywania poufnych informacji (haseł, tokenów) w konfiguracjach aplikacji internetowej zbudowanej przy użyciu środowiska ASP.NET Core?

Czy istnieje sposób automatycznego uzyskania zaszyfrowanych sekcji konfiguracji w appsetttings.json?

Answer 1

Tajemnica użytkownika wygląda na dobre rozwiązanie do przechowywania haseł i, ogólnie, sekretów aplikacji, co najmniej podczas programowania.

Sprawdź to article lub this. Możesz również sprawdzić inne pytanie na temat WT this.

To jest po prostu sposób na "ukrycie" tajemnic podczas procesu tworzenia i unikanie ich umieszczania w drzewie źródłowym; narzędzie Secret Manager nie szyfruje zapisanych tajników i nie powinno być traktowane jako zaufany sklep.

Jeśli chcesz wprowadzić zaszyfrowany plik appsettings.json do produkcji, nie ma ograniczeń co do tego. Możesz zbudować niestandardowego dostawcę konfiguracji. Sprawdź this.

Na przykład:

public class CustomConfigProvider : ConfigurationProvider, IConfigurationSource 
    { 
     public CustomConfigProvider() 
     { 

     } 

     public override void Load() 
     { 
      Data = UnencryptMyConfiguration(); 
     } 

     private IDictionary<string, string> UnencryptMyConfiguration() 
     { 
      // do whatever you need to do here, for example load the file and unencrypt key by key 
      //Like: 
      var configValues = new Dictionary<string, string> 
      { 
       {"key1", "unencryptedValue1"}, 
       {"key2", "unencryptedValue2"} 
      }; 
      return configValues; 
     } 

     private IDictionary<string, string> CreateAndSaveDefaultValues(IDictionary<string, string> defaultDictionary) 
     { 
      var configValues = new Dictionary<string, string> 
      { 
       {"key1", "encryptedValue1"}, 
       {"key2", "encryptedValue2"} 
      }; 
      return configValues;     
     } 
     public IConfigurationProvider Build(IConfigurationBuilder builder) 
     { 
      return new CustomConfigProvider(); 
     } 
    } 

zdefiniować klasę statyczną metodę rozszerzenia dla:

public static class CustomConfigProviderExtensions 
{    
     public static IConfigurationBuilder AddEncryptedProvider(this IConfigurationBuilder builder) 
     { 
      return builder.Add(new CustomConfigProvider()); 
     } 
} 

A potem można je aktywować:

// Set up configuration sources. 
     var builder = new ConfigurationBuilder() 
      .AddJsonFile("appsettings.json") 
      .AddEncryptedProvider() 
      .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true); 

Answer 2

nie chcą Napisz niestandardowego dostawcę - o wiele za dużo pracy. Chciałem po prostu skorzystać z JsonConfigurationProvider, więc wymyśliłem sposób, który działa dla mnie, mam nadzieję, że komuś pomaga.

public class JsonConfigurationProvider2 : JsonConfigurationProvider 
{ 
    public JsonConfigurationProvider2(JsonConfigurationSource2 source) : base(source) 
    { 
    } 

    public override void Load(Stream stream) 
    { 
     // Let the base class do the heavy lifting. 
     base.Load(stream); 

     // Do decryption here, you can tap into the Data property like so: 

     Data["abc:password"] = MyEncryptionLibrary.Decrypt(Data["abc:password"]); 

     // But you have to make your own MyEncryptionLibrary, not included here 
    } 
} 

public class JsonConfigurationSource2 : JsonConfigurationSource 
{ 
    public override IConfigurationProvider Build(IConfigurationBuilder builder) 
    { 
     EnsureDefaults(builder); 
     return new JsonConfigurationProvider2(this); 
    } 
} 

public static class JsonConfigurationExtensions2 
{ 
    public static IConfigurationBuilder AddJsonFile2(this IConfigurationBuilder builder, string path, bool optional, 
     bool reloadOnChange) 
    { 
     if (builder == null) 
     { 
      throw new ArgumentNullException(nameof(builder)); 
     } 
     if (string.IsNullOrEmpty(path)) 
     { 
      throw new ArgumentException("File path must be a non-empty string."); 
     } 

     var source = new JsonConfigurationSource2 
     { 
      FileProvider = null, 
      Path = path, 
      Optional = optional, 
      ReloadOnChange = reloadOnChange 
     }; 

     source.ResolveFileProvider(); 
     builder.Add(source); 
     return builder; 
    } 
}