/// <summary> /// Generates db tables and inserts some dummy data. /// </summary> /// <param name="app"></param> public static void Seed(IApplicationBuilder app) { AppDbContext context = app.ApplicationServices.GetRequiredService <AppDbContext>(); context.Database.Migrate(); if (!context.Users.Any()) { var hash = new Sha512Hash(); var salt = hash.GetSalt(); var userHash = hash.GetHash("*****@*****.**" + "password", salt); context.Users.Add(new User() { IsActive = true, Salt = salt, Hash = userHash, Created = DateTime.Now, Email = "*****@*****.**", FirstName = "Ahmet", LastName = "Sönmez", UserName = "******", }); context.SaveChanges(); } }
public void FromEmptyArray_Should_Succeed() { // Arrange // Act // Assert Sha512Hash.Compute(new byte[0]).Hash .SequenceEqual(Sha512Hash.Compute(new byte[0]).Hash).Should().BeTrue(); }
public void Sha512Hash_GetHash_Null_3() { IHash hashAlgo = new Sha512Hash(); Action action = () => hashAlgo.GetHash(null as FileInfo); action.Should().Throw <ArgumentNullException>(); }
public void Sha512Hash_GetHash_Empty() { IHash hashAlgo = new Sha512Hash(); Action action = () => hashAlgo.GetHash(string.Empty); action.Should().Throw <ArgumentNullException>(); }
public void CreateInstance_Should_CreateInstance() { // Arrange // Act var obj = new Sha512Hash(hash: new byte[64]).CreateAlgorithm(); // Assert obj.Should().BeAssignableTo <SHA512>(); }
/// <exception cref="System.ArgumentNullException"></exception> public static string ComputeHash(string password, string salt) { Expect.ArgumentNotNull(password, nameof(password)); Expect.ArgumentNotNull(salt, nameof(salt)); IHashAlgorithm hashAlgorithm = new Sha512Hash(); return(hashAlgorithm.CalculateHash(password + salt)); }
public void Sha512Hash_GetHash_Valid_2() { IHash hashAlgo = new Sha512Hash(); HashResult hashResult = hashAlgo.GetHash(Data.ExpectedHashFilePath); hashResult.Algorithm.Should().Be(Hashing.ExpectedSha512Algorithm); hashResult.Value.Should().Be(Hashing.ExpectedSha512Hash); }
public void FromArray_Should_Succeed() { // Arrange // Act var obj = Sha512Hash.Compute(Encoding.UTF8.GetBytes("test")); // Assert obj.Hash.SequenceEqual(Sha512Hash.Compute(Encoding.UTF8.GetBytes("test")).Hash).Should().BeTrue(); obj.Name.Should().Be(HashAlgorithmName.SHA512); }
public void DifferentHashes_ShouldReturn_DifferentHashCodes() { // Arrange var hash1 = Sha512Hash.Compute(Encoding.UTF8.GetBytes("test")); var hash2 = Sha512Hash.Compute(Encoding.UTF8.GetBytes("TEST")); // Act // Assert hash1.GetHashCode().Should().NotBe(hash2.GetHashCode()); }
public void DifferentHashes_ShouldReturn_False() { // Arrange var hash1 = Sha512Hash.Compute(Encoding.UTF8.GetBytes("test")); var hash2 = Sha512Hash.Compute(Encoding.UTF8.GetBytes("TEST")); // Act // Assert hash1.Equals((IHash)hash2).Should().BeFalse(); hash1.Equals((object)hash2).Should().BeFalse(); }
public void SameHashes_ShouldReturn_True() { // Arrange var hash1 = Sha512Hash.Compute(Encoding.UTF8.GetBytes("test")); var hash2 = Sha512Hash.Compute(Encoding.UTF8.GetBytes("test")); // Act // Assert hash1.Equals((IHash)hash2).Should().BeTrue(); hash1.Equals((object)hash2).Should().BeTrue(); }
public void Sha512Hash_GetHash_Valid_1() { IHash hashAlgo = new Sha512Hash(); using FileStream fileStream = new(Data.ExpectedHashFilePath, FileMode.Open, FileAccess.Read, FileShare.Read); HashResult hashResult = hashAlgo.GetHash(fileStream); hashResult.Algorithm.Should().Be(Hashing.ExpectedSha512Algorithm); hashResult.Value.Should().Be(Hashing.ExpectedSha512Hash); }
public void Constructor_Should_SetProperties() { // Arrange var hash = Sha512Hash.Compute(new byte[64]); // Act var obj = new Sha512Hash(hash.Hash); // Assert obj.Hash.SequenceEqual(hash.Hash).Should().BeTrue(); obj.Name.Should().Be(HashAlgorithmName.SHA512); }
public void FromArrayWithInputBlockSizeLength_Should_Succeed() { // Arrange int inputBlockSize; using (var sha512 = SHA512Managed.Create()) inputBlockSize = sha512.InputBlockSize; // Act // Assert Sha512Hash.Compute(new byte[inputBlockSize]).Hash .SequenceEqual(Sha512Hash.Compute(new byte[inputBlockSize]).Hash).Should().BeTrue(); }
public void VerifySignatureForDifferentHash_ShouldThrow_TrustException() { // Arrange var key = RsaKey.Generate(); var certificate = key.DeriveCertificate(); var hashToSign = Sha512Hash.Compute(new byte[] { 0x1f, 0x2e, 0x3d, 0x4c }); var otherHash = Sha512Hash.Compute(new byte[] { 0x01, 0x00, 0x03, 0x02 }); // Act // Assert var signature = key.Sign(hashToSign); Assert.Throws <TrustException>(() => certificate.Verify(otherHash, signature)); }
public void SignHashAndVerify_Should_Succeed() { // Arrange var key = RsaKey.Generate(); var hash = Sha512Hash.Compute(new byte[] { 0x10, 0x20, 0x30, 0x40 }); // Act var signature = key.Sign(hash: hash); // Assert signature.Should().BeOfType <RsaSignature>(); signature.SignerCertificateHash.Equals(key.Hash).Should().BeTrue(); key.DeriveCertificate().Verify(hash, signature); }
public void FromArrayAndStream_Should_BeEqual() { // Arrange var data = Encoding.UTF8.GetBytes("test"); using (var stream = new MemoryStream(data)) { // Act var arrayHash = Sha512Hash.Compute(data); var streamHash = Sha512Hash.Compute(stream); // Assert arrayHash.Hash.SequenceEqual(streamHash.Hash).Should().BeTrue(); } }
public void SameParametersAndSignature_ShouldReturn_True() { // Arrange var signature = new RsaSignature(Sha512Hash.Compute(new byte[] { 0x00 }), new byte[] { 0x01 }); var certificate1 = new RsaCertificate( parameters: ScenarioRsa1.RsaParameters, signature: signature); var certificate2 = new RsaCertificate( parameters: ScenarioRsa1.RsaParameters, signature: signature); // Act // Assert certificate1.Equals(certificate2).Should().BeTrue(); }
static ScenarioRsa() { DefaultData = new byte[] { 0x00, 0x01, 0x02, 0x03 }; DefaultDataHash = Sha512Hash.Compute(DefaultData); DefaultEmbeddedData = new byte[] { 0xff, 0xee, 0xdd, 0xcc }; DefaultKey = RsaKey.Generate(); DefaultRsa = DefaultKey.CreateRsa(); DefaultRsaParameters = DefaultRsa.ExportParameters(true); DefaultCertificateSignature = new RsaSignature(Sha512Hash.Compute(new byte[] { 0x12, 0x34, 0xaa, 0xbb }), new byte[] { 0xa1, 0xb2, 0xc3, 0xd4 }); DefaultCertificate = new RsaCertificate(DefaultRsaParameters, DefaultCertificateSignature); DefaultSignerKey = RsaKey.Generate(); DefaultSignerCertificate = (RsaCertificate)DefaultSignerKey.DeriveCertificate(); DefaultSignatureData = new byte[] { 0x1f, 0x2f, 0x3f, 0x4f }; DefaultSignature = new RsaSignature(DefaultSignerCertificate.Hash, DefaultSignatureData); DefaultChain = new ChainOfTrust(DefaultSignerCertificate); }
public void SameParametersAndDifferentSignature_ShouldReturn_False() { // Arrange var signature1 = createRsaSignature(); var certificate1 = new RsaCertificate( parameters: ScenarioRsa1.RsaParameters, signature: signature1); var signature2 = createRsaSignature( signerCertificateHash: Sha512Hash.Compute(new byte[] { 0x00 }), signature: new byte[] { 0x01 }); var certificate2 = new RsaCertificate( parameters: ScenarioRsa1.RsaParameters, signature: signature2); // Act // Assert certificate1.Equals(certificate2).Should().BeFalse(); }
public void DifferentSignatures_ShouldReturn_DifferentHashes() { // Arrange var hash1 = Helpers.ComputeRsaHashWithSignature( rsaParameters: ScenarioRsa.DefaultRsaParameters, includePrivateParameters: true, embeddedData: ScenarioRsa.DefaultEmbeddedData, signature: ScenarioRsa.DefaultSignature); var hash2 = Helpers.ComputeRsaHashWithSignature( rsaParameters: ScenarioRsa.DefaultRsaParameters, includePrivateParameters: true, embeddedData: ScenarioRsa.DefaultEmbeddedData, signature: new RsaSignature(Sha512Hash.Compute(new byte[] { 0xaa, 0xbb, 0xcc, 0xdd }), new byte[] { 0x1a, 0x2b, 0x3c, 0x4d })); // Act // Assert hash1.Hash.SequenceEqual(hash2.Hash).Should().BeFalse(); }
public void CertificatesWithDifferentSignatures_Should_HaveSameHashesButDifferentHashWithSignatures() { // Arrange var signature1 = createRsaSignature(); var certificate1 = new RsaCertificate( parameters: ScenarioRsa1.RsaParameters, signature: signature1); var signature2 = createRsaSignature( signerCertificateHash: Sha512Hash.Compute(new byte[] { 0x00 }), signature: new byte[] { 0x01 }); var certificate2 = new RsaCertificate( parameters: ScenarioRsa1.RsaParameters, signature: signature2); // Act // Assert certificate1.Hash.Equals(certificate2.Hash).Should().BeTrue(); certificate1.HashWithSignature.Equals(certificate2.HashWithSignature).Should().BeFalse(); }
public void FromEmptyStream_Should_Succeed() { // Arrange IHash hash1 = null; IHash hash2 = null; // Act using (var stream = new MemoryStream(new byte[0])) { hash1 = Sha512Hash.Compute(stream); } using (var stream = new MemoryStream(new byte[0])) { hash2 = Sha512Hash.Compute(stream); } // Assert hash1.Hash.SequenceEqual(hash2.Hash).Should().BeTrue(); }
public void Stream_Should_Succeed() { // Arrange var data = Encoding.UTF8.GetBytes("test"); IHash hash1 = null; IHash hash2 = null; // Act using (var stream = new MemoryStream(data)) { hash1 = Sha512Hash.Compute(stream); } using (var stream = new MemoryStream(data)) { hash2 = Sha512Hash.Compute(stream); } // Assert hash1.Hash.SequenceEqual(hash2.Hash).Should().BeTrue(); hash1.Name.Should().Be(HashAlgorithmName.SHA512); }
/// <summary> /// 散列服务创造器 /// </summary> /// <param name="type"></param> /// <returns></returns> public IHash CreateHash(Type type) { IHash hash; switch (type) { case Type.Md5: hash = new MD5Hash(); break; case Type.Sha1: hash = new Sha1Hash(); break; case Type.Sha256: hash = new Sha256Hash(); break; case Type.Sha384: hash = new Sha384Hash(); break; case Type.Sha512: hash = new Sha512Hash(); break; case Type.RipEmd160: hash = new RipEmd160Hash(); break; default: hash = new MD5Hash(); break; } return(hash); }
static void Main(string[] args) { Console.WriteLine("Hello!"); Console.WriteLine("Let me show you the basics of cryptography with the TrustMe library for Dotnet Core."); Console.WriteLine(); var key = RsaKey.Generate(); Console.WriteLine($"Generated sample private key (abbr.): {toHex(key.Hash.Hash).Substring(0, 8)}"); Console.WriteLine("This is used to sign data and thus prove its integrity. Usually this is pre-generated and stored in a file kept secret\nand never to be included in publicly available applications."); Console.WriteLine(); var certificate = key.DeriveCertificate(); Console.WriteLine($"This public key (or certificate) is derived from it (abbr.): {toHex(certificate.Hash.Hash).Substring(0, 8)}"); Console.WriteLine("It may be included as a \"hidden\" constant (by means of hard to find and replace in decompiled or disassembled code) in\nany application willing to test the integrity of data expected to come from a known and trusted party."); Console.WriteLine(); Console.Write("Enter some text: "); var input = Console.ReadLine(); var inputHash = Sha512Hash.Compute(Encoding.UTF8.GetBytes(input)); Console.WriteLine($"The hash value of the input is (abbr.): {toHex(inputHash.Hash).Substring(0, 8)}"); Console.WriteLine("The hash value is always exactly the same for the same input."); Console.WriteLine(); var signature = key.Sign(inputHash); Console.WriteLine($"Signed with the private key, the signature of the input is (abbr.): {toHex(signature.Signature).Substring(0, 8)}"); Console.WriteLine(); Console.Write("Checking the signature against the public key (or certificate), should be valid: "); try { certificate.Verify(inputHash, signature); Console.WriteLine("valid"); } catch (TrustException ex) { Console.WriteLine($"invalid,\n{ex.Message}"); } Console.WriteLine(); Console.Write("Checking the signature against some different arbitrary public key (or certificate), should be invalid: "); try { RsaKey.Generate().DeriveCertificate().Verify(inputHash, signature); Console.WriteLine("valid"); } catch (TrustException ex) { Console.WriteLine($"invalid,\n{ex.Message}"); } Console.WriteLine(); var maximumAllowedPlainTextLength = ((RsaCertificate)certificate).GetMaximumPlainTextLengthForEncryption(); Console.Write($"Enter some text to encrypt using the public key (max. {maximumAllowedPlainTextLength} chars): "); var plainText = Console.ReadLine(); Console.WriteLine("Encrypted the plain text with the public key:"); var cipher = certificate.Encrypt(plainText: Encoding.UTF8.GetBytes(plainText)); Console.WriteLine(toHex(cipher)); Console.Write("Decrypted cipher with the private key is: "); Console.WriteLine(Encoding.UTF8.GetString(key.Decrypt(cipher: cipher).ToArray())); }
public void FromArrayNull_ShouldThrow_ArgumentNullException() { // Arrange // Act & Assert Assert.Throws <ArgumentNullException>(() => Sha512Hash.Compute((byte[])null)); }