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