public void SetUp()
{
hashProviders = new Dictionary<string, IHashProvider>();
symmetricCrytoProviders = new Dictionary<string, ISymmetricCryptoProvider>();
CreateKeyFile(symmetricKeyFile);
CreateKeyFile(keyedHashKeyFile);
configSource = ConfigurationSourceFactory.Create();
HashProviderFactory factory = new HashProviderFactory(configSource);
defaultHashProvider = factory.Create(hashInstance);
hashProviders.Add(hashInstance, defaultHashProvider);
SymmetricCryptoProviderFactory symmfactory = new SymmetricCryptoProviderFactory(configSource);
defaultSymmetricCryptoProvider = symmfactory.Create(symmInstance);
algorithSymmetricCryptoProvider = symmfactory.Create(symmetricAlgorithm1);
symmetricCrytoProviders.Add(symmInstance, defaultSymmetricCryptoProvider);
symmetricCrytoProviders.Add(symmetricAlgorithm1, algorithSymmetricCryptoProvider);
var container = EnterpriseLibraryContainer.CreateDefaultContainer(configSource);
cryptographyManager = container.GetInstance<CryptographyManager>();
}
public SecurityAuthenticationProvider(IStorageApplication<User> userStorageApplication, IHashProvider hashProvider, ISecurityAccessTokenProvider securityAccessTokenProvider, ISessionProvider sessionProvider)
{
_userStorageApplication = userStorageApplication;
_hashProvider = hashProvider;
_securityAccessTokenProvider = securityAccessTokenProvider;
_sessionProvider = sessionProvider;
}
public static FastZipPackage Open(string originalFilePath, IHashProvider hashProvider)
{
var result = new FastZipPackage(originalFilePath);
using (var package = Package.Open(originalFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
var packageRelationship = package.GetRelationshipsByType("http://schemas.microsoft.com/packaging/2010/07/manifest").SingleOrDefault();
if (packageRelationship == null)
throw new InvalidOperationException("Package does not contain a manifest");
var part = package.GetPart(packageRelationship.TargetUri);
using (var stream2 = part.GetStream())
result.ReadManifest(stream2);
}
using (var stream = new FileStream(originalFilePath, FileMode.Open, FileAccess.Read))
{
result.Hash = hashProvider.CalculateHash(stream);
}
var info = new FileInfo(originalFilePath);
result.Created = info.CreationTimeUtc;
result.Size = info.Length;
return result;
}
public static string GetHash(this IPackage package, IHashProvider hashProvider)
{
using (Stream stream = package.GetStream()) {
byte[] packageBytes = stream.ReadAllBytes();
return Convert.ToBase64String(hashProvider.CalculateHash(packageBytes));
}
}
public DefaultServiceResolver()
{
_hashProvider = new CryptoHashProvider(Constants.HashAlgorithm);
_packageRepository = new ServerPackageRepository(PackageUtility.PackagePhysicalPath, _hashProvider, new TraceLogger());
_packageService = new PackageService(_packageRepository, new PackageAuthenticationService());
}
public SecurityUserProvider(IUserSecurityStorageProvider userSecurityStorageProvider, ISecurityAccessTokenProvider securityAccessTokenProvider, IHashProvider hashProvider, ISecurityContext securityContext, ISessionProvider sessionProvider)
{
_userSecurityStorageProvider = userSecurityStorageProvider;
_securityAccessTokenProvider = securityAccessTokenProvider;
_hashProvider = hashProvider;
_securityContext = securityContext;
_sessionProvider = sessionProvider;
}
public HashProviderHelper(IHashProvider defaultHashProvider, IHashProvider saltedHashProvider)
{
this.defaultHashProvider = defaultHashProvider;
BindNewInstrumentationListener(this.defaultHashProvider, out this.defaultHashProviderListener);
this.saltedHashProvider = saltedHashProvider;
BindNewInstrumentationListener(this.saltedHashProvider, out this.saltedHashProviderListener);
}
public TokenService(IHashProvider hashProvider, IUnitOfWork unitOfWork)
{
_hashProvider = hashProvider;
_tokenRespository = unitOfWork.GetRepository<ITokenRepository>();
_tokenRespository.OnAdd += (sender, args) => unitOfWork.Commit();
_tokenRespository.OnDelete += (sender, args) => unitOfWork.Commit();
}
public static IFastZipPackage Open(string fileLocation, IHashProvider hashProvider)
{
using (var stream = new FileStream(fileLocation, FileMode.Open, FileAccess.Read))
{
var hash = hashProvider.CalculateHash(stream);
stream.Seek(0, SeekOrigin.Begin);
return Open(fileLocation, stream, hash);
}
}
public UserServices(ICustomerRepository customerRepository, IRepository repository,IUserRepository userRepository,
IHashProvider hashProvider, IDtoCreator<UserIdentity,UserIdentityDto> identityCreator)
{
_customerRepository = customerRepository;
_userRepository = userRepository;
_repository = repository;
_hashProvider = hashProvider;
_userIdentityDtoCreator = identityCreator;
}
public CustomMembershipProvider(IUserRepository userRepository,
IHashProvider hashProvider,
IUserProfileRepository userProfileRepository,
IShoppingCartRepository shoppingCartRepository)
{
_userRepository = userRepository;
_hashProvider = hashProvider;
_userProfileRepository = userProfileRepository;
_shoppingCartRepository = shoppingCartRepository;
}
public UserController(IUserService userService, IHashProvider hashProvider)
{
if (userService == null)
{
throw new ArgumentNullException("userService");
}
_userService = userService;
_hashProvider = hashProvider;
}
public HashProviderHelper(Func<IHashAlgorithmInstrumentationProvider, IHashProvider> defaultHashProviderFunc,
Func<IHashAlgorithmInstrumentationProvider, IHashProvider> saltedHashProviderFunc)
{
defaultHashProviderListener = new MockHashInstrumentationListener();
this.defaultHashProvider = defaultHashProviderFunc(defaultHashProviderListener);
saltedHashProviderListener = new MockHashInstrumentationListener();
this.saltedHashProvider = saltedHashProviderFunc(saltedHashProviderListener);
}
public CryptoUtils()
{
_crypt = new EncryptProvider(); //thread safe
_hash = new HashProvider(); //thread safe
_hmac = new HMACProvider(); //thread safe
_rsa = new RSAProvider(); //thread safe
_rng = new RNGCryptoServiceProvider(); //This type is thread safe
_encoding = Util.DefaultEncoding; //must be thread safe
_rndLocalCounter = 100678;
}
public CustomMembershipUser(string providerName, object providerUserKey, string email,
IUserRepository userRepository, IHashProvider hashProvider)
{
_userRepository = userRepository;
_hashProvider = hashProvider;
_isLockedOut = false;
_isApproved = true;
_providerName = providerName;
_email = email;
_providerUserKey = providerUserKey;
}
public UserForm(DbAuthenticationProviderData dbAuthenticationProvider, ConfigurationContext context)
{
this.dbAuthenticationProvider = dbAuthenticationProvider;
InitializeComponent();
this.userRoleMgr = new UserRoleManager(dbAuthenticationProvider.Database, context);
HashProviderFactory hashProviderFactory = new HashProviderFactory(context);
this.hashProvider = hashProviderFactory.CreateHashProvider(dbAuthenticationProvider.HashProvider);
UpdateSaveButtonEnabled();
}
public PackageDownloader(IPackageFactory packageFactory, IHashProvider hashProvider)
{
if (packageFactory == null)
{
throw new ArgumentNullException("packageFactory");
}
if (hashProvider == null)
{
throw new ArgumentNullException("hashProvider");
}
_packageFactory = packageFactory;
_hashProvider = hashProvider;
}
public HttpProxyHandlerFactory(IHttpParser parser, IHttpRequestSender requestSender, IHashProvider hashProvider, ICache<string, byte[]> cache, IRequestLogger requestLogger)
{
Requires.NotNull(parser, "parser");
_parser = parser;
Requires.NotNull(requestSender, "requestSender");
_requestSender = requestSender;
Requires.NotNull(hashProvider, "hashProvider");
_hashProvider = hashProvider;
Requires.NotNull(cache, "cache");
_cache = cache;
Requires.NotNull(requestLogger, "requestLogger");
_requestLogger = requestLogger;
}
public PackageDownloader(IHttpClient httpClient, IPackageFactory packageFactory, IHashProvider hashProvider) {
if (httpClient == null) {
throw new ArgumentNullException("httpClient");
}
if (packageFactory == null) {
throw new ArgumentNullException("packageFactory");
}
if (hashProvider == null) {
throw new ArgumentNullException("hashProvider");
}
_httpClient = httpClient;
_packageFactory = packageFactory;
_hashProvider = hashProvider;
_httpClient.UserAgent = HttpUtility.CreateUserAgentString(DefaultUserAgentClient);
}
public unsafe int SignHash(IHashProvider provider, SignatureScheme scheme, ref WritableBuffer writer, byte *message, int messageLength)
{
var hash = provider.GetHashInstance(_hashType);
hash.HashData(message, messageLength);
var digest = new byte[hash.HashSize];
fixed(byte *dPtr = digest)
{
hash.InterimHash(dPtr, digest.Length);
}
var result = _privateKey.SignHash(digest);
var enc = new System.Security.Cryptography.AsnEncodedData(_certificate.SignatureAlgorithm, result);
writer.Write(result);
return(result.Length);
}
public unsafe int SignHash(IHashProvider provider, SignatureScheme scheme, ref WritableBuffer writer, byte *message, int messageLength)
{
var hash = provider.GetHashInstance(_hashType);
hash.HashData(message, messageLength);
var digest = new byte[hash.HashSize];
fixed(byte *dPtr = digest)
{
hash.InterimHash(dPtr, digest.Length);
}
writer.Ensure(_privateKey.KeySize);
var result = _privateKey.SignHash(digest);
writer.Write(result);
return(result.Length);
}
public DeltaVoterTests()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_cache = Substitute.For <IMemoryCache>();
_previousDeltaHash = _hashProvider.ComputeMultiHash(ByteUtil.GenerateRandomByteArray(32));
_producerIds = "1234"
.Select((c, i) => PeerIdHelper.GetPeerId(c.ToString()))
.Shuffle();
_producersProvider = Substitute.For <IDeltaProducersProvider>();
_producersProvider.GetDeltaProducersFromPreviousDelta(Arg.Any <MultiHash>())
.Returns(_producerIds);
_localIdentifier = PeerIdHelper.GetPeerId("myself, a producer");
_peerSettings = _localIdentifier.ToSubstitutedPeerSettings();
_logger = Substitute.For <ILogger>();
}
public bool IsValidPassword(string password, IHashProvider hashProvider)
{
var hash = hashProvider.Hash(Encoding.UTF8.GetBytes(password), Salt);
if (PasswordHash.Length != hash.Length)
{
return(false);
}
for (int i = 0; i < PasswordHash.Length; i++)
{
if (PasswordHash[i] != hash[i])
{
return(false);
}
}
return(true);
}
public unsafe void DeriveSecret(IHashProvider hashProvider, HashType hashType, void *salt, int saltSize, void *output, int outputSize)
{
var ctx = EVP_PKEY_CTX_new(_publicPrivateKey, IntPtr.Zero);
try
{
ThrowOnError(EVP_PKEY_derive_init(ctx));
ThrowOnError(EVP_PKEY_derive_set_peer(ctx, _peerKey));
var length = IntPtr.Zero;
ThrowOnError(EVP_PKEY_derive(ctx, null, ref length));
var data = stackalloc byte[length.ToInt32()];
ThrowOnError(EVP_PKEY_derive(ctx, data, ref length));
hashProvider.HmacData(hashType, salt, saltSize, data, length.ToInt32(), output, outputSize);
}
finally
{
ctx.Free();
Dispose();
}
}
public void RoundTripCheck(IHashProvider hashProvider, IBlockObjectTypeProvider typeProvider)
{
// Serialize a first time
var firstMemoryStream = new MemoryStream();
var firstSerializeContext = new BlockSerializeContext(new BinaryWriter(firstMemoryStream), typeProvider);
Serialize(firstSerializeContext);
var originalData = firstMemoryStream.ToArray();
// Then deserialize that data
var br = new BinaryReader(new MemoryStream(originalData));
var deserializeContext = new BlockDeserializeContext(br, typeProvider);
var deserialized = new Block(deserializeContext, hashProvider);
// Then serialize that deserialized data and see if it matches
var secondMemoryStream = new MemoryCompareStream(originalData);
var secondSerializeContext = new BlockSerializeContext(new BinaryWriter(secondMemoryStream), typeProvider);
deserialized.Serialize(secondSerializeContext);
}
public GetDeltaRequestObserverTests()
{
var builder = new ContainerBuilder();
builder.RegisterModule <HashingModule>();
var container = builder.Build();
container.BeginLifetimeScope();
_hashProvider = container.Resolve <IHashProvider>();
_testScheduler = new TestScheduler();
var logger = Substitute.For <ILogger>();
var peerIdentifier = PeerIdHelper.GetPeerId("responder");
var peerSettings = peerIdentifier.ToSubstitutedPeerSettings();
_deltaCache = Substitute.For <IDeltaCache>();
_observer = new GetDeltaRequestObserver(_hashProvider, _deltaCache, peerSettings, logger);
_fakeContext = Substitute.For <IChannelHandlerContext>();
}
public void CanBuildCustomHashProviderFromGivenConfiguration()
{
CustomHashProviderData customData
= new CustomHashProviderData("custom", typeof(MockCustomHashProvider));
customData.SetAttributeValue(MockCustomProviderBase.AttributeKey, "value1");
CryptographySettings settings = new CryptographySettings();
settings.HashProviders.Add(customData);
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(CryptographyConfigurationView.SectionName, settings);
IHashProvider custom
= EnterpriseLibraryFactory.BuildUp <IHashProvider>("custom", configurationSource);
Assert.IsNotNull(custom);
Assert.AreSame(typeof(MockCustomHashProvider), custom.GetType());
Assert.AreEqual("value1", ((MockCustomHashProvider)custom).customValue);
}
public DfsTests(ITestOutputHelper output) : base(output)
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_output = output;
var passwordReader = Substitute.For <IPasswordManager>();
passwordReader.RetrieveOrPromptAndAddPasswordToRegistry(Arg.Any <PasswordRegistryTypes>(), Arg.Any <string>())
.Returns(TestPasswordReader.BuildSecureStringPassword("abcd"));
_logger = Substitute.For <ILogger>();
_ipfs = new IpfsAdapter(passwordReader, FileSystem, _logger);
// Starting IPFS takes a few seconds. Do it here, so that individual
// test times are not affected.
_ipfs.Generic.IdAsync()
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
}
public DeltaCache(IHashProvider hashProvider,
IMemoryCache memoryCache,
IDeltaDfsReader dfsReader,
IDeltaCacheChangeTokenProvider changeTokenProvider,
IStorageProvider storageProvider,
IStateProvider stateProvider,
ISnapshotableDb stateDb,
IDeltaIndexService deltaIndexService,
ILogger logger)
{
_deltaIndexService = deltaIndexService;
stateProvider.CreateAccount(TruffleTestAccount, 1_000_000_000.Kat());
stateProvider.CreateAccount(CatalystTruffleTestAccount, 1_000_000_000.Kat());
storageProvider.Commit();
stateProvider.Commit(CatalystGenesisSpec.Instance);
storageProvider.CommitTrees();
stateProvider.CommitTree();
stateDb.Commit();
var genesisDelta = new Delta
{
TimeStamp = Timestamp.FromDateTime(DateTime.UnixEpoch),
StateRoot = ByteString.CopyFrom(stateProvider.StateRoot.Bytes),
};
GenesisHash = hashProvider.ComputeMultiHash(genesisDelta).ToCid();
_dfsReader = dfsReader;
_logger = logger;
_entryOptions = () => new MemoryCacheEntryOptions()
.AddExpirationToken(changeTokenProvider.GetChangeToken())
.RegisterPostEvictionCallback(EvictionCallback);
_memoryCache = memoryCache;
_memoryCache.Set(GenesisHash, genesisDelta);
}
public ServerPackageRepository(string path, IHashProvider hashProvider, Logging.ILogger logger)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
if (hashProvider == null)
{
throw new ArgumentNullException("hashProvider");
}
_fileSystem = new PhysicalFileSystem(path);
_runBackgroundTasks = true;
_logger = logger ?? new TraceLogger();
_expandedPackageRepository = new ExpandedPackageRepository(_fileSystem, hashProvider);
_serverPackageStore = new ServerPackageStore(_fileSystem, Environment.MachineName.ToLowerInvariant() + ".cache.bin");
_getSetting = GetBooleanAppSetting;
}
public Consensus(IDeltaBuilder deltaBuilder,
IDeltaVoter deltaVoter,
IDeltaElector deltaElector,
IDeltaCache deltaCache,
IDeltaHub deltaHub,
ICycleEventsProvider cycleEventsProvider,
IDeltaHashProvider deltaHashProvider,
IHashProvider hashProvider,
ILogger logger)
{
_deltaVoter = deltaVoter;
_deltaElector = deltaElector;
_cycleEventsProvider = cycleEventsProvider;
_deltaHashProvider = deltaHashProvider;
_hashProvider = hashProvider;
_deltaBuilder = deltaBuilder;
_deltaHub = deltaHub;
_deltaCache = deltaCache;
_logger = logger;
logger.Information("Consensus service initialised.");
}
/// <summary>
/// Serializes the <paramref name="message"/>, appends suffix and returns the hash of it.
/// </summary>
/// <param name="provider">The hash provider.</param>
/// <param name="message">The protocol message.</param>
/// <param name="suffix">The suffix that should be appended to the message. </param>
/// <returns></returns>
public static MultiHash ComputeMultiHash(this IHashProvider provider, IMessage message, byte[] suffix)
{
ProtoPreconditions.CheckNotNull(message, nameof(message));
var calculateSize = message.CalculateSize();
var required = calculateSize + suffix.Length;
var array = ArrayPool <byte> .Shared.Rent(required);
using (var output = new CodedOutputStream(array))
{
message.WriteTo(output);
}
suffix.CopyTo(array, calculateSize);
var result = provider.ComputeMultiHash(array, 0, required);
ArrayPool <byte> .Shared.Return(array);
return(result);
}
public DevDfs(IFileSystem fileSystem,
IHashProvider hashProvider,
string baseFolder = null)
{
Guard.Argument(hashProvider.HashingAlgorithm, nameof(hashProvider.HashingAlgorithm))
.Require(h => h.DigestSize <= 159, h =>
"The hashing algorithm needs to produce file names smaller than 255 base 32 characters or 160 bytes" +
$"but the default length for {hashProvider.HashingAlgorithm.GetType().Name} is {h.DigestSize}.");
var dfsBaseFolder = baseFolder ?? Path.Combine(fileSystem.GetCatalystDataDir().FullName,
Constants.DfsDataSubDir);
_baseFolder = new DirectoryInfo(dfsBaseFolder);
if (!_baseFolder.Exists)
{
_baseFolder.Create();
}
_fileSystem = fileSystem;
_hashProvider = hashProvider;
}
/// <overrides>
/// Compares plain text input with a computed hash using the given hash provider instance.
/// </overrides>
/// <summary>
/// Compares plain text input with a computed hash using the given hash provider instance.
/// </summary>
/// <remarks>
/// Use this method to compare hash values. Since hashes may contain a random "salt" value, two seperately generated
/// hashes of the same plain text may result in different values.
/// </remarks>
/// <param name="hashInstance">A hash instance from configuration.</param>
/// <param name="plaintext">The input for which you want to compare the hash to.</param>
/// <param name="hashedText">The hash value for which you want to compare the input to.</param>
/// <returns><c>true</c> if plainText hashed is equal to the hashedText. Otherwise, <c>false</c>.</returns>
public static bool CompareHash(string hashInstance, byte[] plaintext, byte[] hashedText)
{
if (string.IsNullOrEmpty(hashInstance))
{
throw new ArgumentException(Resources.ExceptionNullOrEmptyString, "hashInstance");
}
try
{
HashProviderFactory factory = new HashProviderFactory(ConfigurationSourceFactory.Create());
IHashProvider hashProvider = factory.Create(hashInstance);
return(hashProvider.CompareHash(plaintext, hashedText));
}
catch (ConfigurationErrorsException configurationException)
{
TryLogHashConfigurationError(configurationException, hashInstance);
throw;
}
}
public ServerPackageRepository(string path, IHashProvider hashProvider, Logging.ILogger logger)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
if (hashProvider == null)
{
throw new ArgumentNullException("hashProvider");
}
_fileSystem = new PhysicalFileSystem(path);
_runBackgroundTasks = true;
_logger = logger ?? new TraceLogger();
_expandedPackageRepository = new ExpandedPackageRepository(_fileSystem, hashProvider);
_serverPackageStore = new ServerPackageStore(_fileSystem, Environment.MachineName.ToLowerInvariant() + ".cache.bin");
_getSetting = GetBooleanAppSetting;
}
public static Delta GetDelta(IHashProvider hashProvider,
MultiHash previousDeltaHash = null,
byte[] merkleRoot = default,
byte[] merklePoda = default,
DateTime?timestamp = default)
{
var previousHash = previousDeltaHash ?? hashProvider.ComputeMultiHash(ByteUtil.GenerateRandomByteArray(32));
var root = merkleRoot ?? ByteUtil.GenerateRandomByteArray(32);
var poda = merklePoda ?? ByteUtil.GenerateRandomByteArray(32);
var nonNullTimestamp = Timestamp.FromDateTime(timestamp?.ToUniversalTime() ?? DateTime.Now.ToUniversalTime());
var delta = new Delta
{
PreviousDeltaDfsHash = previousHash.ToArray().ToByteString(),
MerkleRoot = root.ToByteString(),
MerklePoda = poda.ToByteString(),
TimeStamp = nonNullTimestamp
};
return(delta);
}
public DeltaCache(IHashProvider hashProvider,
IMemoryCache memoryCache,
IDeltaDfsReader dfsReader,
IDeltaCacheChangeTokenProvider changeTokenProvider,
ILogger logger)
{
var genesisDelta = new Delta {
TimeStamp = Timestamp.FromDateTime(DateTime.MinValue.ToUniversalTime())
};
GenesisHash = hashProvider.ComputeMultiHash(genesisDelta).CreateCid();
_dfsReader = dfsReader;
_logger = logger;
_entryOptions = () => new MemoryCacheEntryOptions()
.AddExpirationToken(changeTokenProvider.GetChangeToken())
.RegisterPostEvictionCallback(EvictionCallback);
_memoryCache = memoryCache;
_memoryCache.Set(GenesisHash, genesisDelta);
}
public PoaDeltaProducersProviderTests()
{
var hashingAlgorithm = HashingAlgorithm.GetAlgorithmMetadata("blake2b-256");
_hashProvider = new HashProvider(hashingAlgorithm);
var peerSettings = PeerIdHelper.GetPeerId("TEST").ToSubstitutedPeerSettings();
_selfAsPeer = new Peer {
PeerId = peerSettings.PeerId
};
var rand = new Random();
_peers = Enumerable.Range(0, 5)
.Select(_ =>
{
var peerIdentifier = PeerIdHelper.GetPeerId(rand.Next().ToString());
var peer = new Peer {
PeerId = peerIdentifier
};
return(peer);
}).ToList();
var logger = Substitute.For <ILogger>();
var peerRepository = Substitute.For <IPeerRepository>();
peerRepository.GetAll().Returns(_ => _peers);
_previousDeltaHash = _hashProvider.ComputeMultiHash(ByteUtil.GenerateRandomByteArray(32));
_previousDeltaHashString = _previousDeltaHash.ToBase32();
_producersByPreviousDelta = Substitute.For <IMemoryCache>();
_poaDeltaProducerProvider = new PoaDeltaProducersProvider(peerRepository,
peerSettings,
_producersByPreviousDelta,
_hashProvider,
logger);
}
public DeltaBuilder(IDeltaTransactionRetriever transactionRetriever,
IDeterministicRandomFactory randomFactory,
IHashProvider hashProvider,
IPeerSettings peerSettings,
IDeltaCache deltaCache,
IDateTimeProvider dateTimeProvider,
IStateProvider stateProvider,
IDeltaExecutor deltaExecutor,
ILogger logger)
{
_transactionRetriever = transactionRetriever;
_randomFactory = randomFactory;
_hashProvider = hashProvider;
_producerUniqueId = peerSettings.PeerId;
_deltaCache = deltaCache;
_dateTimeProvider = dateTimeProvider;
_stateProvider = stateProvider;
_deltaExecutor = deltaExecutor;
_logger = logger;
PrepareSteps();
}
/// <summary>
/// Serializes the <paramref name="message"/> returns the hash of it.
/// </summary>
/// <param name="provider">The hash provider.</param>
/// <param name="message">The protocol message.</param>
/// <returns></returns>
public static MultiHash ComputeMultiHash(this IHashProvider provider, IMessage message)
{
ProtoPreconditions.CheckNotNull(message, nameof(message));
var required = message.CalculateSize();
var array = ArrayPool <byte> .Shared.Rent(required);
try
{
using (var output = new CodedOutputStream(array))
{
message.WriteTo(output);
}
var result = provider.ComputeMultiHash(array, 0, required);
return(result);
}
finally
{
ArrayPool <byte> .Shared.Return(array);
}
}
public PackageDownloader(IHttpClient httpClient, IPackageFactory packageFactory, IHashProvider hashProvider)
{
if (httpClient == null)
{
throw new ArgumentNullException("httpClient");
}
if (packageFactory == null)
{
throw new ArgumentNullException("packageFactory");
}
if (hashProvider == null)
{
throw new ArgumentNullException("hashProvider");
}
_httpClient = httpClient;
_packageFactory = packageFactory;
_hashProvider = hashProvider;
_httpClient.UserAgent = HttpUtility.CreateUserAgentString(DefaultUserAgentClient);
}
public void Init()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
var peerSettings = PeerIdHelper.GetPeerId("TEST").ToSubstitutedPeerSettings();
_selfAsPeer = new Peer {
PeerId = peerSettings.PeerId
};
var rand = new Random();
_peers = Enumerable.Range(0, 5)
.Select(_ =>
{
var peerIdentifier = PeerIdHelper.GetPeerId(rand.Next().ToString());
var peer = new Peer {
PeerId = peerIdentifier, LastSeen = DateTime.UtcNow
};
return(peer);
}).ToList();
var logger = Substitute.For <ILogger>();
var peerRepository = Substitute.For <IPeerRepository>();
peerRepository.GetActivePoaPeers().Returns(_ => _peers);
_previousDeltaHash =
_hashProvider.ComputeMultiHash(ByteUtil.GenerateRandomByteArray(32)).ToCid();
_producersByPreviousDelta = Substitute.For <IMemoryCache>();
_poaDeltaProducerProvider = new PoaDeltaProducersProvider(peerRepository,
peerSettings,
_producersByPreviousDelta,
_hashProvider,
logger);
}
public LedgerTests()
{
_testScheduler = new TestScheduler();
_fakeRepository = Substitute.For <IAccountRepository>();
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_mapperProvider = new TestMapperProvider();
_logger = Substitute.For <ILogger>();
_mempool = Substitute.For <IMempool <PublicEntryDao> >();
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_ledgerSynchroniser = Substitute.For <ILedgerSynchroniser>();
_genesisHash = _hashProvider.ComputeUtf8MultiHash("genesis").CreateCid();
_ledgerSynchroniser.DeltaCache.GenesisHash.Returns(_genesisHash);
_executor = Substitute.For <IDeltaExecutor>();
_stateProvider = Substitute.For <IStateProvider>();
_storageProvider = Substitute.For <IStorageProvider>();
_cryptoContext = new FfiWrapper();
_signingContext = new SigningContext
{
NetworkType = NetworkType.Devnet,
SignatureType = SignatureType.TransactionPublic
};
}
public void CanBuildCustomHashProviderFromSavedConfiguration()
{
CustomHashProviderData customData
= new CustomHashProviderData("custom", typeof(MockCustomHashProvider));
customData.SetAttributeValue(MockCustomProviderBase.AttributeKey, "value1");
CryptographySettings settings = new CryptographySettings();
settings.HashProviders.Add(customData);
IDictionary <string, ConfigurationSection> sections = new Dictionary <string, ConfigurationSection>(1);
sections[CryptographyConfigurationView.SectionName] = settings;
IConfigurationSource configurationSource
= ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);
IHashProvider custom
= EnterpriseLibraryFactory.BuildUp <IHashProvider>("custom", configurationSource);
Assert.IsNotNull(custom);
Assert.AreSame(typeof(MockCustomHashProvider), custom.GetType());
Assert.AreEqual("value1", ((MockCustomHashProvider)custom).customValue);
}
public unsafe void DeriveMasterSecretTls12(IHashProvider hashProvider, HashType hashType, void *seed, int seedLength, void *output, int outputLength)
{
uint version = 0x0303;
var buffDescription = new BCryptBufferDesc();
var bufferArray = stackalloc BCryptBuffer[4];
var algId = Encoding.Unicode.GetBytes(hashType.ToString() + "\0");
fixed(void *algPtr = algId)
{
bufferArray[0] = new BCryptBuffer()
{
BufferType = NCryptBufferDescriptors.KDF_HASH_ALGORITHM, cbBuffer = algId.Length, pvBuffer = algPtr
};
bufferArray[1] = new BCryptBuffer()
{
BufferType = NCryptBufferDescriptors.KDF_TLS_PRF_LABEL, cbBuffer = Tls13.Internal.Tls1_2Consts.MasterSecretLabelSize, pvBuffer = (void *)Tls13.Internal.Tls1_2Consts.MasterSecretLabelPointer
};
bufferArray[2] = new BCryptBuffer()
{
BufferType = NCryptBufferDescriptors.KDF_TLS_PRF_SEED, cbBuffer = seedLength, pvBuffer = seed
};
bufferArray[3] = new BCryptBuffer()
{
BufferType = NCryptBufferDescriptors.KDF_TLS_PRF_PROTOCOL, cbBuffer = 4, pvBuffer = &version
};
buffDescription.cBuffers = 4;
buffDescription.pBuffers = (IntPtr)bufferArray;
int sizeOfResult;
SafeBCryptSecretHandle secretPointer;
ExceptionHelper.CheckReturnCode(BCryptSecretAgreement(_key, _peerKey, out secretPointer, 0));
ExceptionHelper.CheckReturnCode(
BCryptDeriveKey(secretPointer, BCRYPT_KDF_TLS_PRF, &buffDescription, (IntPtr)output, outputLength, out sizeOfResult, 0));
secretPointer.Dispose();
Dispose();
}
}
//https://tools.ietf.org/html/rfc5246#section-4.7
//TLS 1.2 Secret Expansion into an n length run of bytes
// P_hash(secret, seed) = HMAC_hash(secret, A(1) + seed) +
// HMAC_hash(secret, A(2) + seed) +
// A() is defined as:
// A(0) = seed
// A(i) = HMAC_hash(secret, A(i-1))
public static void Tls12Prf(this IHashProvider hashProvider, HashType hashType, ReadOnlySpan <byte> secret, ReadOnlySpan <byte> label, ReadOnlySpan <byte> seed, Span <byte> keyMaterial)
{
var hashSize = hashProvider.HashSize(hashType);
var aLength = hashSize + seed.Length + label.Length;
var a1 = new Span <byte>(new byte[aLength]);
label.CopyTo(a1.Slice(hashSize));
seed.CopyTo(a1.Slice(hashSize + label.Length));
hashProvider.HmacData(hashType, secret, a1.Slice(hashSize), a1.Slice(0, hashSize));
var currentKeyData = new Span <byte>(new byte[hashSize]);
while (keyMaterial.Length > 0)
{
//HMAC_hash(secret, A(n) + seed)
hashProvider.HmacData(hashType, secret, a1, currentKeyData);
//Copy required bytes into the output keymaterial and reduce size remaining
var amountToCopy = Math.Min(keyMaterial.Length, currentKeyData.Length);
currentKeyData.Slice(0, amountToCopy).CopyTo(keyMaterial);
keyMaterial = keyMaterial.Slice(amountToCopy);
//A(n) = HMAC_hash(secret, A(n-1))
hashProvider.HmacData(hashType, secret, a1.Slice(0, hashSize), a1.Slice(0, hashSize));
}
}
public ConsensusTests()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_cycleEventProvider = new TestCycleEventProvider();
_deltaBuilder = Substitute.For <IDeltaBuilder>();
_deltaVoter = Substitute.For <IDeltaVoter>();
_deltaElector = Substitute.For <IDeltaElector>();
_deltaCache = Substitute.For <IDeltaCache>();
_deltaHub = Substitute.For <IDeltaHub>();
var deltaHashProvider = Substitute.For <IDeltaHashProvider>();
var logger = Substitute.For <ILogger>();
_consensus = new Consensus(
_deltaBuilder,
_deltaVoter,
_deltaElector,
_deltaCache,
_deltaHub,
_cycleEventProvider,
deltaHashProvider,
logger);
_consensus.StartProducing();
}
public unsafe int SignHash(IHashProvider provider, SignatureScheme scheme, ref WritableBuffer writer, byte *message, int messageLength)
{
var hash = provider.GetHashInstance(_hashType);
hash.HashData(message, messageLength);
var digest = new byte[hash.HashSize];
fixed(byte *dPtr = digest)
{
hash.InterimHash(dPtr, digest.Length);
}
writer.Ensure(ECDSA_size(_ecKey));
GCHandle handle;
var output = writer.Memory.GetPointer(out handle);
try
{
fixed(byte *iPtr = digest)
{
var sigSize = writer.Memory.Length;
ThrowOnError(ECDSA_sign(0, iPtr, digest.Length, output, ref sigSize, _ecKey));
writer.Advance(sigSize);
return(sigSize);
}
}
finally
{
if (handle.IsAllocated)
{
handle.Free();
}
}
}
public Item(IHashProvider hashProvider)
{
this.hashProvider = hashProvider;
this.Tags = new string[0];
}
/// <summary>
/// Mask generation function.
/// </summary>
/// <param name="seed">Seed</param>
/// <param name="maskLen">Length of generated mask</param>
/// <param name="hashLength">Length of the hash produced by the supplied hash provider</param>
/// <param name="hashProvider">Hash provider to use in mask generation</param>
/// <returns>Generated mask of specified length</returns>
static internal byte[] OAEPMGF(byte[] seed, int maskLen, int hashLength, IHashProvider hashProvider)
{
byte[] result = new byte[maskLen];
//Determine how many interations we have to do. We'll be appending
//m_hLen (hash length) bytes for every iteration, so the size of the generated byte array
//will be m_hLen * iNum (number of iterations).
int iNum = (int)Math.Floor(maskLen / hashLength) + 1;
//Mask that will be truncated to create the final
//resulting mask returned by this function.
byte[] bytLongMask = new byte[(iNum * hashLength)];
byte[] bytAppend = new byte[4];
byte[] bytTmp = null;
int iPadLen = 0;
byte[] bytSeedHash = new byte[hashLength];
//Padded pseudorandom seed to be hashed.
byte[] bytPadSeed = new byte[(seed.Length + 4)];
seed.CopyTo(bytPadSeed, 0);
for (int i = 0; i <= iNum - 1; i++)
{
//Convert the iterator to an Octet String byte array
bytTmp = Mathematics.I2OSP(i, 4);
//Calculate the needed padding zeros, and add
//them to the resulting Array. Result must be 4 bytes long.
iPadLen = bytAppend.Length - bytTmp.Length;
bytTmp.CopyTo(bytAppend, 0);
//Hash the pseudorandom padded seed and append it to the
//long version of the mask.
bytAppend.CopyTo(bytPadSeed, seed.Length);
bytSeedHash = hashProvider.ComputeHash(bytPadSeed);
bytSeedHash.CopyTo(bytLongMask, i * hashLength);
}
//Copy the first maskLen bytes of bytLongMask to the result
//and return the result.
Array.Copy(bytLongMask, result, maskLen);
return result;
}
public FilesService(IXmlService xmlService, IFileSystem fileSystem, IHashProvider hashProvider)
{
_xmlService = xmlService;
_fileSystem = fileSystem;
_hashProvider = hashProvider;
}
/// <summary>
/// Creates an instance with a specified key.
/// </summary>
/// <param name="key">The key used for cryptographic functions.</param>
public SecureQueryString(string key)
: base()
{
// If no key is provided then use the default key...
if ((key == String.Empty) || (key == "") || (key == null))
key = defaultKey;
// Convert key to 16-byte hash...
UTF8Encoding encoder = new UTF8Encoding();
System.Security.Cryptography.MD5CryptoServiceProvider hasher = new System.Security.Cryptography.MD5CryptoServiceProvider();
symmetricCryptoProvider = new SymmetricAlgorithmProvider(hasher.ComputeHash(encoder.GetBytes(key)));
hashProvider = new HashAlgorithmProvider();
this.key = hasher.ComputeHash(encoder.GetBytes(key));
}
public AuthenticationPolicyProvider(IHashProvider hash, ISaltProvider salt)
: base(hash, salt)
{ }
public override void Context()
{
HashProvider = new CryptoHashProvider(FileSystem);
Service = new FilesService(new XmlService(FileSystem, HashProvider), FileSystem, HashProvider);
}
public VBulletinScavenger(IHashProvider hashProvider, NishkriyaContext db)
{
_db = db;
_hashProvider = hashProvider;
_log = LogManager.GetLogger("ScavengerLord");
}
/// <summary>Initializes a new instance of the NServiceKit.ServiceInterface.Auth.OrmLiteAuthRepository class.</summary>
///
/// <param name="dbFactory"> The database factory.</param>
/// <param name="passwordHasher">The password hasher.</param>
public OrmLiteAuthRepository(IDbConnectionFactory dbFactory, IHashProvider passwordHasher)
{
this.dbFactory = dbFactory;
this.passwordHasher = passwordHasher;
}
public CryptoService(IApplicationSettings settings, IHashProvider hashProvider)
{
this.settings = settings;
this.hashProvider = hashProvider;
}
private static ServerPackageRepository CreateServerPackageRepository(Mock<MockProjectSystem> mockProjectSystem, IHashProvider hashProvider = null, IDictionary<string, bool> settings = null)
{
Func<string, bool, bool> settingsFunc = null;
if (settings != null)
{
settingsFunc = (key, defaultValue) =>
{
bool ret;
return settings.TryGetValue(key, out ret) ? ret : defaultValue;
};
}
return new ServerPackageRepository(new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object, settingsFunc)
{
HashProvider = hashProvider ?? GetHashProvider().Object
};
}
public override void Context()
{
HashProvider = new CryptoHashProvider(FileSystem);
Service = new FilesService(new XmlService(FileSystem, HashProvider), FileSystem, HashProvider);
}
/// <summary>
/// Creates an instance with a specified key.
/// </summary>
/// <param name="key">The key used for cryptographic functions.</param>
public SecureQueryString(byte[] key)
: base()
{
// If no key is provided then use the default key...
if ((key == null) || (key.Length == 0))
{
UTF8Encoding encoder = new UTF8Encoding();
key = encoder.GetBytes(defaultKey);
}
// Convert key to 16-byte hash...
System.Security.Cryptography.MD5CryptoServiceProvider hasher = new System.Security.Cryptography.MD5CryptoServiceProvider();
symmetricCryptoProvider = new SymmetricAlgorithmProvider(hasher.ComputeHash(key));
hashProvider = new HashAlgorithmProvider();
this.key = hasher.ComputeHash(key);
}
