using System; using System.Collections.Generic; using System.Security.Cryptography; using MediaBrowser.Common.Extensions; using MediaBrowser.Model.Cryptography; using static MediaBrowser.Common.Cryptography.Constants; namespace Emby.Server.Implementations.Cryptography { /// /// Class providing abstractions over cryptographic functions. /// public class CryptographyProvider : ICryptoProvider, IDisposable { private static readonly HashSet _supportedHashMethods = new HashSet() { "MD5", "System.Security.Cryptography.MD5", "SHA", "SHA1", "System.Security.Cryptography.SHA1", "SHA256", "SHA-256", "System.Security.Cryptography.SHA256", "SHA384", "SHA-384", "System.Security.Cryptography.SHA384", "SHA512", "SHA-512", "System.Security.Cryptography.SHA512" }; private RandomNumberGenerator _randomNumberGenerator; private bool _disposed; /// /// Initializes a new instance of the class. /// public CryptographyProvider() { // FIXME: When we get DotNet Standard 2.1 we need to revisit how we do the crypto // Currently supported hash methods from https://docs.microsoft.com/en-us/dotnet/api/system.security.cryptography.cryptoconfig?view=netcore-2.1 // there might be a better way to autogenerate this list as dotnet updates, but I couldn't find one // Please note the default method of PBKDF2 is not included, it cannot be used to generate hashes cleanly as it is actually a pbkdf with sha1 _randomNumberGenerator = RandomNumberGenerator.Create(); } /// public string DefaultHashMethod => "PBKDF2"; /// public IEnumerable GetSupportedHashMethods() => _supportedHashMethods; private byte[] PBKDF2(string method, byte[] bytes, byte[] salt, int iterations) { // downgrading for now as we need this library to be dotnetstandard compliant // with this downgrade we'll add a check to make sure we're on the downgrade method at the moment if (method != DefaultHashMethod) { throw new CryptographicException($"Cannot currently use PBKDF2 with requested hash method: {method}"); } using var r = new Rfc2898DeriveBytes(bytes, salt, iterations); return r.GetBytes(32); } /// public byte[] ComputeHash(string hashMethod, byte[] bytes, byte[] salt) { if (hashMethod == DefaultHashMethod) { return PBKDF2(hashMethod, bytes, salt, DefaultIterations); } if (!_supportedHashMethods.Contains(hashMethod)) { throw new CryptographicException($"Requested hash method is not supported: {hashMethod}"); } using var h = HashAlgorithm.Create(hashMethod) ?? throw new ResourceNotFoundException($"Unknown hash method: {hashMethod}."); if (salt.Length == 0) { return h.ComputeHash(bytes); } byte[] salted = new byte[bytes.Length + salt.Length]; Array.Copy(bytes, salted, bytes.Length); Array.Copy(salt, 0, salted, bytes.Length, salt.Length); return h.ComputeHash(salted); } /// public byte[] ComputeHashWithDefaultMethod(byte[] bytes, byte[] salt) => PBKDF2(DefaultHashMethod, bytes, salt, DefaultIterations); /// public byte[] GenerateSalt() => GenerateSalt(DefaultSaltLength); /// public byte[] GenerateSalt(int length) { byte[] salt = new byte[length]; _randomNumberGenerator.GetBytes(salt); return salt; } /// public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } /// /// Releases unmanaged and - optionally - managed resources. /// /// true to release both managed and unmanaged resources; false to release only unmanaged resources. protected virtual void Dispose(bool disposing) { if (_disposed) { return; } if (disposing) { _randomNumberGenerator.Dispose(); } _disposed = true; } } }