Ejemplo n.º 1
0
 public async void WorkWithImageFileTestAsync()
 {
     var progressEncrypt = new Progress<StreamCryptorTaskAsyncProgress>();
     var progressDecrypt = new Progress<StreamCryptorTaskAsyncProgress>();
     progressEncrypt.ProgressChanged +=
         (s, e) => { Console.WriteLine("Encrypting: " + e.ProgressPercentage + "%\n"); };
     progressDecrypt.ProgressChanged +=
         (s, e) => { Console.WriteLine("Decrypting: " + e.ProgressPercentage + "%\n"); };
     var RAW_FILE = Path.Combine("Testfiles", "MyAwesomeChipmunkKiller.jpg");
     var OUTPUT_DIRECTORY = Path.Combine("Testfiles", "decrypted");
     const string PRIVATE_KEY = "31d9040b00a170532929b37db0afcb989e4175f96e5f9667ee8cbf5706679a71";
     const string PUBLIC_KEY = "6d0deec730700f9f60687a4e6e8755157ca22ea2f3815b9bf14b1fe9ae6a0b4d";
     var keyPair = new KeyPair(Utilities.HexToBinary(PUBLIC_KEY), Utilities.HexToBinary(PRIVATE_KEY));
     Console.Write("Encrypting testfile . . .\n");
     var encryptedFile =
         await
             Cryptor.EncryptFileWithStreamAsync(keyPair.PrivateKey, keyPair.PublicKey,
                 Utilities.HexToBinary(PUBLIC_KEY), RAW_FILE, progressEncrypt, OUTPUT_DIRECTORY, ".test", true);
     Console.Write("Decrypting testfile . . .\n");
     var decryptedFile =
         await
             Cryptor.DecryptFileWithStreamAsync(keyPair.PrivateKey, Path.Combine(OUTPUT_DIRECTORY, encryptedFile),
                 OUTPUT_DIRECTORY, progressDecrypt);
     Console.Write("Get checksum of testfiles . . .\n");
     Assert.AreEqual(Utils.GetChecksum(RAW_FILE),
         Utils.GetChecksum(Path.Combine(OUTPUT_DIRECTORY, decryptedFile)));
     //clear garbage 
     File.Delete(Path.Combine(OUTPUT_DIRECTORY, encryptedFile));
     File.Delete(Path.Combine(OUTPUT_DIRECTORY, decryptedFile));
 }
		public void DecryptionCancellationTestAsync()
		{
			var cancellationTokenSource = new CancellationTokenSource();
			var progressEncrypt = new Progress<StreamCryptorTaskAsyncProgress>();
			var progressDecrypt = new Progress<StreamCryptorTaskAsyncProgress>();
			progressEncrypt.ProgressChanged +=
				(s, e) => { Console.WriteLine("Encrypting: " + e.ProgressPercentage + "%\n"); };
			progressDecrypt.ProgressChanged +=
				(s, e) =>
				{
					if (e.ProgressPercentage > 10)
					{
						cancellationTokenSource.Cancel();
					}
					Console.WriteLine("Decrypting: " + e.ProgressPercentage + "%\n");
				};
			var rawFile = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "MyAwesomeChipmunkKiller.jpg");
			var outputDirectory = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "decrypted");
			const string privateKey = "31d9040b00a170532929b37db0afcb989e4175f96e5f9667ee8cbf5706679a71";
			const string publicKey = "6d0deec730700f9f60687a4e6e8755157ca22ea2f3815b9bf14b1fe9ae6a0b4d";
			var keyPair = new KeyPair(Utilities.HexToBinary(publicKey), Utilities.HexToBinary(privateKey));
			Console.Write("Encrypting testfile . . .\n");
			var encryptedFile = Cryptor.EncryptFileWithStream(keyPair.PrivateKey, keyPair.PublicKey,
				Utilities.HexToBinary(publicKey), rawFile, outputDirectory, ".test", true);
			Console.Write("Decrypting testfile . . .\n");
			Assert.ThrowsAsync<TaskCanceledException>(async () => await
				Cryptor.DecryptFileWithStreamAsync(keyPair.PrivateKey, Path.Combine(outputDirectory, encryptedFile),
					outputDirectory, progressDecrypt, cancellationToken: cancellationTokenSource.Token));
		}
Ejemplo n.º 3
0
		public async Task WorkWithImageFileAndWrongKeyTestAsync()
		{
			var rawFile = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "MyAwesomeChipmunkKiller.jpg");
			var outputDirectory = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "decrypted");
			const string privateKey = "31d9040b00a170532929b37db0afcb989e4175f96e5f9667ee8cbf5706679a71";
			const string publicKey = "6d0deec730700f9f60687a4e6e8755157ca22ea2f3815b9bf14b1fe9ae6a0b4d";
			var keyPair = new KeyPair(Utilities.HexToBinary(publicKey), Utilities.HexToBinary(privateKey));
			var testKeyPair = PublicKeyBox.GenerateKeyPair();
			Console.Write("Encrypting testfile . . .\n");
			//encrypt the file with an ephmeral key
			var encryptedFile =
				await
					Cryptor.EncryptFileWithStreamAsync(keyPair, testKeyPair.PublicKey, rawFile, null, outputDirectory,
						".test", true);
			Console.Write("Decrypting testfile . . .\n");
			//try to decrypt with an wrong key
			var decryptedFile =
				Assert.ThrowsAsync<CryptographicException>(
					async () => await
						Cryptor.DecryptFileWithStreamAsync(keyPair,
							Path.Combine(TestContext.CurrentContext.TestDirectory, outputDirectory, encryptedFile),
							outputDirectory));


			File.Delete(Path.Combine(TestContext.CurrentContext.TestDirectory, outputDirectory, encryptedFile));
		}
		public void EncryptionNoPublicKeyInPairTest()
		{
			const string privateKey = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
			var testKeyPair = new KeyPair(null, Utilities.HexToBinary(privateKey));
			Assert.Throws<NullReferenceException>(
				() => { Cryptor.EncryptFileWithStream(testKeyPair, "badfile"); });
		}
 public async void DecryptionInputFileNotFoundTestAsync()
 {
     const string PRIVATE_KEY = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
     const string PUBLIC_KEY = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
     var testKeyPair = new KeyPair(Utilities.HexToBinary(PUBLIC_KEY), Utilities.HexToBinary(PRIVATE_KEY));
     await Cryptor.DecryptFileWithStreamAsync(testKeyPair, "badfile", Path.Combine("Testfiles", "decrypted"));
 }
Ejemplo n.º 6
0
 public void EncryptionInputFileNotFoundTest()
 {
     const string PRIVATE_KEY = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
     const string PUBLIC_KEY = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
     var testKeyPair = new KeyPair(Utilities.HexToBinary(PUBLIC_KEY), Utilities.HexToBinary(PRIVATE_KEY));
     Cryptor.EncryptFileWithStream(testKeyPair, "badfile");
 }
Ejemplo n.º 7
0
 public async void WorkWithImageFileAndWrongKeyTestAsync()
 {
     var RAW_FILE = Path.Combine("Testfiles", "MyAwesomeChipmunkKiller.jpg");
     var OUTPUT_DIRECTORY = Path.Combine("Testfiles", "decrypted");
     const string PRIVATE_KEY = "31d9040b00a170532929b37db0afcb989e4175f96e5f9667ee8cbf5706679a71";
     const string PUBLIC_KEY = "6d0deec730700f9f60687a4e6e8755157ca22ea2f3815b9bf14b1fe9ae6a0b4d";
     var keyPair = new KeyPair(Utilities.HexToBinary(PUBLIC_KEY), Utilities.HexToBinary(PRIVATE_KEY));
     var testKeyPair = PublicKeyBox.GenerateKeyPair();
     Console.Write("Encrypting testfile . . .\n");
     //encrypt the file with an ephmeral key
     var encryptedFile =
         await
             Cryptor.EncryptFileWithStreamAsync(keyPair, testKeyPair.PublicKey, RAW_FILE, null, OUTPUT_DIRECTORY,
                 ".test", true);
     Console.Write("Decrypting testfile . . .\n");
     //try to decrypt with an wrong key
     var decryptedFile =
         await
             Cryptor.DecryptFileWithStreamAsync(keyPair, Path.Combine(OUTPUT_DIRECTORY, encryptedFile),
                 OUTPUT_DIRECTORY);
     Console.Write("Get checksum of testfiles . . .\n");
     Assert.AreEqual(Utils.GetChecksum(RAW_FILE),
         Utils.GetChecksum(Path.Combine(OUTPUT_DIRECTORY, decryptedFile)));
     //clear garbage 
     File.Delete(Path.Combine(OUTPUT_DIRECTORY, encryptedFile));
     File.Delete(Path.Combine(OUTPUT_DIRECTORY, decryptedFile));
 }
Ejemplo n.º 8
0
		public async Task WorkWithImageFileByteArrayTestAsync()
		{
			var progressEncrypt = new Progress<StreamCryptorTaskAsyncProgress>();
			var progressDecrypt = new Progress<StreamCryptorTaskAsyncProgress>();
			progressEncrypt.ProgressChanged +=
				(s, e) => { Console.WriteLine("Encrypting: " + e.ProgressPercentage + "%\n"); };
			progressDecrypt.ProgressChanged +=
				(s, e) => { Console.WriteLine("Decrypting: " + e.ProgressPercentage + "%\n"); };
			var rawFile = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "MyAwesomeChipmunkKiller.jpg");
			var outputDirectory = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "decrypted");
			const string privateKey = "31d9040b00a170532929b37db0afcb989e4175f96e5f9667ee8cbf5706679a71";
			const string publicKey = "6d0deec730700f9f60687a4e6e8755157ca22ea2f3815b9bf14b1fe9ae6a0b4d";
			var keyPair = new KeyPair(Utilities.HexToBinary(publicKey), Utilities.HexToBinary(privateKey));
			Console.Write("Encrypting testfile . . .\n");
			var encryptedFile =
				await
					Cryptor.EncryptFileWithStreamAsync(keyPair.PrivateKey, keyPair.PublicKey,
						Utilities.HexToBinary(publicKey), rawFile, progressEncrypt, outputDirectory, ".test", true);
			Console.Write("Decrypting testfile . . .\n");
			var decryptedFileObject =
				await
					Cryptor.DecryptFileWithStreamAsync(keyPair.PrivateKey,
						Path.Combine(TestContext.CurrentContext.TestDirectory, outputDirectory, encryptedFile),
						progressDecrypt);
			Console.Write("Get checksum of testfiles . . .\n");
			Assert.AreEqual(Utils.GetChecksum(rawFile), Utils.GetChecksum(decryptedFileObject.FileData));
			//clear garbage 
			File.Delete(Path.Combine(TestContext.CurrentContext.TestDirectory, outputDirectory, encryptedFile));
		}
Ejemplo n.º 9
0
 public void EncryptionInvalidPrivateKeyInPairTest()
 {
     const string PRIVATE_KEY =
         "863df54207c285feac2c22235c336869fee8dba6605b8e1bc45cc8aa5e1be3fd7e53781865717d686cb3fee427823ffd8c71ea6a4d8f79c0b410457c9f881fa3";
     const string PUBLIC_KEY = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
     var testKeyPair = new KeyPair(Utilities.HexToBinary(PUBLIC_KEY), Utilities.HexToBinary(PRIVATE_KEY));
     Cryptor.EncryptFileWithStream(testKeyPair, "badfile");
 }
		public void DecryptionInputFileNotFoundTestAsync()
		{
			const string privateKey = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
			const string publicKey = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
			var testKeyPair = new KeyPair(Utilities.HexToBinary(publicKey), Utilities.HexToBinary(privateKey));
			Assert.ThrowsAsync<FileNotFoundException>(
				async () => await Cryptor.DecryptFileWithStreamAsync(testKeyPair, "badfile", Path.Combine("Testfiles", "decrypted")));
		}
 public async void DecryptioInvalidPublicKeyInPairTestAsync()
 {
     const string PRIVATE_KEY =
         "863df54207c285feac2c22235c336869fee8dba6605b8e1bc45cc8aa5e1be3fd7e53781865717d686cb3fee427823ffd8c71ea6a4d8f79c0b410457c9f881fa3";
     const string PUBLIC_KEY = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
     var testKeyPair = new KeyPair(Utilities.HexToBinary(PUBLIC_KEY), Utilities.HexToBinary(PRIVATE_KEY));
     await Cryptor.DecryptFileWithStreamAsync(testKeyPair, "badfile", Path.Combine("Testfiles", "decrypted"));
 }
 public async void DecryptionOutputFolderNotFoundTestAsync()
 {
     var TESTFILE_RAW = Path.Combine("Testfiles", "MyAwesomeChipmunkKiller.jpg");
     const string PRIVATE_KEY = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
     const string PUBLIC_KEY = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
     var testKeyPair = new KeyPair(Utilities.HexToBinary(PUBLIC_KEY), Utilities.HexToBinary(PRIVATE_KEY));
     await Cryptor.DecryptFileWithStreamAsync(testKeyPair, TESTFILE_RAW, "badfolder");
 }
Ejemplo n.º 13
0
        /// <summary>
        ///  Sign the specified message with the private key. 
        /// </summary>
        /// <param name='privateKey'>
        ///  The private key. 
        /// </param>
        /// <param name='message'>
        ///  The message. 
        /// </param>
        /// <returns>
        ///  The message that has been signed (encrypted) by the private key. 
        /// </returns>
        public byte[] Sign(byte[] privateKey, byte[] message)
        {
            if(Keys == null)
            {
                Keys = PublicKeyAuth.GenerateKeyPair(privateKey);
            }

            return PublicKeyAuth.Sign(message, Keys.PrivateKey);
        }
		public void DecryptioInvalidPublicKeyInPairTestAsync()
		{
			const string privateKey =
				"863df54207c285feac2c22235c336869fee8dba6605b8e1bc45cc8aa5e1be3fd7e53781865717d686cb3fee427823ffd8c71ea6a4d8f79c0b410457c9f881fa3";
			const string publicKey = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
			var testKeyPair = new KeyPair(Utilities.HexToBinary(publicKey), Utilities.HexToBinary(privateKey));
			Assert.ThrowsAsync<ArgumentOutOfRangeException>(
				async () => await Cryptor.DecryptFileWithStreamAsync(testKeyPair, "badfile", Path.Combine("Testfiles", "decrypted")));
		}
        public void GenerateKeySeedTest()
        {
            var expected = new KeyPair(Utilities.HexToBinary("76a1592044a6e4f511265bca73a604d90b0529d1df602be30a19a9257660d1f5"),
            Utilities.HexToBinary("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff76a1592044a6e4f511265bca73a604d90b0529d1df602be30a19a9257660d1f5"));
              var actual = PublicKeyAuth.GenerateKeyPair(Utilities.HexToBinary("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));

              CollectionAssert.AreEqual(expected.PublicKey, actual.PublicKey);
              CollectionAssert.AreEqual(expected.PrivateKey, actual.PrivateKey);
        }
Ejemplo n.º 16
0
		public void EncryptionBadFileExtensionTest()
		{
			var testfileRaw = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "MyAwesomeChipmunkKiller.jpg");
			const string privateKey = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
			const string publicKey = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
			var testKeyPair = new KeyPair(Utilities.HexToBinary(publicKey), Utilities.HexToBinary(privateKey));
			Assert.Throws<ArgumentOutOfRangeException>(
				() => { Cryptor.EncryptFileWithStream(testKeyPair, testfileRaw, Path.Combine("Testfiles", "decrypted"), "hulk"); });
		}
Ejemplo n.º 17
0
		public void EncryptionInputFileNotFoundTest()
		{
			const string privateKey = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
			const string publicKey = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
			var testKeyPair = new KeyPair(Utilities.HexToBinary(publicKey), Utilities.HexToBinary(privateKey));

			Assert.Throws<FileNotFoundException>(
				() => { Cryptor.EncryptFileWithStream(testKeyPair, "badfile"); });
		}
Ejemplo n.º 18
0
		public void DecryptionOutputFolderNotFoundTest()
		{
			var testfileRaw = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "MyAwesomeChipmunkKiller.jpg");
			const string privateKey = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
			const string publicKey = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
			var testKeyPair = new KeyPair(Utilities.HexToBinary(publicKey), Utilities.HexToBinary(privateKey));
			Assert.Throws<DirectoryNotFoundException>(
				() => { Cryptor.DecryptFileWithStream(testKeyPair, testfileRaw, "badfolder"); });
		}
Ejemplo n.º 19
0
        /// <summary>
        ///     Constructor to prepare the communication.
        /// </summary>
        /// <param name="clientPrivateKey">The clients 32 byte private key (hex format)</param>
        /// <exception cref="NotSupportedException"></exception>
        public KnownPasswords(string clientPrivateKey)
        {
            SignaurKeyPair =
                new KeyPair(
                    PublicKeyAuth.ExtractEd25519PublicKeyFromEd25519SecretKey(Utilities.HexToBinary(clientPrivateKey)),
                    Utilities.HexToBinary(clientPrivateKey));

            EncryptionKeyPair = PublicKeyBox.GenerateKeyPair();

            // the API only accepts TLS 1.2 connections
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
            _restClient = new RestClient(ServerApiUrl);
        }
Ejemplo n.º 20
0
        /// <summary>
        /// Initializes a new instance of the <see cref="CoCKeyPair"/> class with the
        /// specified public key and private key.
        /// </summary>
        /// <param name="publicKey">Public key.</param>
        /// <param name="privateKey">Private key.</param>
        /// <exception cref="ArgumentNullException"><paramref name="publicKey"/> is null.</exception>
        /// <exception cref="ArgumentNullException"><paramref name="privateKey"/> is null.</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="publicKey"/> length is not 32.</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="privateKey"/> length is not 32.</exception>
        public CoCKeyPair(byte[] publicKey, byte[] privateKey)
        {
            if (publicKey == null)
                throw new ArgumentNullException("publicKey");
            if (publicKey.Length != PublicKeyBox.PublicKeyBytes)
                throw new ArgumentOutOfRangeException("publicKey", "publicKey must be 32 bytes in length.");

            if (privateKey == null)
                throw new ArgumentNullException("privateKey");
            if (privateKey.Length != PublicKeyBox.SecretKeyBytes)
                throw new ArgumentOutOfRangeException("privateKey", "publicKey must be 32 bytes in length.");

            _keyPair = new KeyPair(publicKey, privateKey);
        }
Ejemplo n.º 21
0
 public void WorkWithImageFileTest()
 {
     var rawFile = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "MyAwesomeChipmunkKiller.jpg");
     var outputDirectory = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "decrypted");
     const string privateKey = "31d9040b00a170532929b37db0afcb989e4175f96e5f9667ee8cbf5706679a71";
     const string publicKey = "6d0deec730700f9f60687a4e6e8755157ca22ea2f3815b9bf14b1fe9ae6a0b4d";
     var keyPair = new KeyPair(Utilities.HexToBinary(publicKey), Utilities.HexToBinary(privateKey));
     Console.Write("Encrypting testfile . . .\n");
     var encryptedFile = Cryptor.EncryptFileWithStream(keyPair, Utilities.HexToBinary(publicKey), rawFile,
         outputDirectory, ".test", true);
     Console.Write("Decrypting testfile . . .\n");
     var decryptedFile = Cryptor.DecryptFileWithStream(keyPair, Path.Combine(outputDirectory, encryptedFile),
         outputDirectory);
     Console.Write("Get checksum of testfiles . . .\n");
     Assert.AreEqual(Utils.GetChecksum(rawFile),
         Utils.GetChecksum(Path.Combine(outputDirectory, decryptedFile)));
     //clear garbage 
     File.Delete(Path.Combine(outputDirectory, encryptedFile));
     File.Delete(Path.Combine(outputDirectory, decryptedFile));
 }
Ejemplo n.º 22
0
        public void KeyPairModuloTest()
        {
            //Don`t copy bobSk for other tests (bad key)!
              //30 byte
              var bobSk = new byte[] {
                0x5d,0xab,0x08,0x7e,0x62,0x4a,0x8a,0x4b,
                0x79,0xe1,0x7f,0x8b,0x83,0x80,0x0e,0xe6,
                0x6f,0x3b,0xb1,0x29,0x26,0x18,0xb6,0xfd,
                0x1c,0x2f,0x8b,0x27,0xff,0x88
            };

              //32 byte
              var bobPk = new byte[] {
                0xde,0x9e,0xdb,0x7d,0x7b,0x7d,0xc1,0xb4,
                0xd3,0x5b,0x61,0xc2,0xec,0xe4,0x35,0x37,
                0x3f,0x83,0x43,0xc8,0x5b,0x78,0x67,0x4d,
                0xad,0xfc,0x7e,0x14,0x6f,0x88,0x2b,0x4f
            };

              var kp = new KeyPair(bobPk, bobSk);

              //we should never get here
              Assert.IsNull(kp);
        }
		public void EncryptionCancellationTestAsync()
		{
			var cancellationTokenSource = new CancellationTokenSource();
			var progressEncrypt = new Progress<StreamCryptorTaskAsyncProgress>();
			progressEncrypt.ProgressChanged +=
				(s, e) =>
				{
					if (e.ProgressPercentage > 10)
					{
						cancellationTokenSource.Cancel();
					}
					Console.WriteLine("Encrypting: " + e.ProgressPercentage + "%\n");
				};

			var testfileRaw = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "MyAwesomeChipmunkKiller.jpg");
			const string privateKey = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
			const string publicKey = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";

			var testKeyPair = new KeyPair(Utilities.HexToBinary(publicKey), Utilities.HexToBinary(privateKey));
			Assert.ThrowsAsync<TaskCanceledException>(async () => await
				Cryptor.EncryptFileWithStreamAsync(testKeyPair, testfileRaw, progressEncrypt,
					Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "decrypted"), ".sccef",
					cancellationToken: cancellationTokenSource.Token));
		}
Ejemplo n.º 24
0
 public void EncryptionNoPrivateKeyInPairTest()
 {
     const string PUBLIC_KEY = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
     var testKeyPair = new KeyPair(Utilities.HexToBinary(PUBLIC_KEY), null);
     Cryptor.EncryptFileWithStream(testKeyPair, "badfile");
 }
Ejemplo n.º 25
0
 /// <summary>
 ///  Makes the public key from the provider private key. 
 /// </summary>
 /// <returns>
 ///  The public key. 
 /// </returns>
 /// <param name='privateKey'>
 ///  Private key. 
 /// </param>
 public byte[] MakePublicKey(byte[] privateKey)
 {
     Keys = PublicKeyAuth.GenerateKeyPair(privateKey);
     return Keys.PublicKey;
 }
Ejemplo n.º 26
0
 /// <summary>
 /// Decrypts a file asynchron into memory with libsodium and protobuf-net.
 /// </summary>
 /// <param name="keyPair">The KeyPair to decrypt the ephemeralKey.</param>
 /// <param name="inputFile">An encrypted file.</param>
 /// <param name="decryptionProgress">StreamCryptorTaskAsyncProgress object.</param>
 /// <param name="cancellationToken">Token to request task cancellation.</param>
 /// <returns>A DecryptedFile object.</returns>
 /// <remarks>This method can throw an OutOfMemoryException when there is not enough ram to hold the DecryptedFile!</remarks>
 /// <exception cref="ArgumentOutOfRangeException"></exception>
 /// <exception cref="FileNotFoundException"></exception>
 /// <exception cref="BadLastFileChunkException"></exception>
 /// <exception cref="BadFileChunkException"></exception>
 /// <exception cref="BadFileFooterException"></exception>
 /// <exception cref="BadFileHeaderException"></exception>
 /// <exception cref="IOException"></exception>
 /// <exception cref="OutOfMemoryException"></exception>
 /// <exception cref="OperationCanceledException"></exception>
 public static async Task<DecryptedFile> DecryptFileWithStreamAsync(KeyPair keyPair, string inputFile, IProgress<StreamCryptorTaskAsyncProgress> decryptionProgress = null, CancellationToken cancellationToken = default(CancellationToken))
 {
     //validate the keyPair
     if (!ValidateKeyPair(keyPair))
     {
         throw new ArgumentOutOfRangeException("keypair", "invalid keypair");
     }
     return await DecryptFileWithStreamAsync(keyPair.PrivateKey, inputFile, decryptionProgress, cancellationToken).ConfigureAwait(false);
 }
Ejemplo n.º 27
0
 public void EncryptionBadFileExtensionTest()
 {
     var TESTFILE_RAW = Path.Combine("Testfiles", "MyAwesomeChipmunkKiller.jpg");
     const string PRIVATE_KEY = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
     const string PUBLIC_KEY = "1158b1ea7d45919968b87dab6cab27eff5871304ea9856588e9ec02a6d93c42e";
     var testKeyPair = new KeyPair(Utilities.HexToBinary(PUBLIC_KEY), Utilities.HexToBinary(PRIVATE_KEY));
     Cryptor.EncryptFileWithStream(testKeyPair, TESTFILE_RAW, Path.Combine("Testfiles", "decrypted"), "hulk");
 }
        public async void DecryptionCancellationTestAsync()
        {
            var cancellationTokenSource = new CancellationTokenSource();
            var progressEncrypt = new Progress<StreamCryptorTaskAsyncProgress>();
            var progressDecrypt = new Progress<StreamCryptorTaskAsyncProgress>();
            progressEncrypt.ProgressChanged +=
                (s, e) => { Console.WriteLine("Encrypting: " + e.ProgressPercentage + "%\n"); };
            progressDecrypt.ProgressChanged +=
                (s, e) =>
                {
                    if (e.ProgressPercentage > 10)
                    {
                        cancellationTokenSource.Cancel();
                    }
                    Console.WriteLine("Decrypting: " + e.ProgressPercentage + "%\n");
                };
            var RAW_FILE = Path.Combine("Testfiles", "MyAwesomeChipmunkKiller.jpg");
            var OUTPUT_DIRECTORY = Path.Combine("Testfiles", "decrypted");
            const string PRIVATE_KEY = "31d9040b00a170532929b37db0afcb989e4175f96e5f9667ee8cbf5706679a71";
            const string PUBLIC_KEY = "6d0deec730700f9f60687a4e6e8755157ca22ea2f3815b9bf14b1fe9ae6a0b4d";
            var keyPair = new KeyPair(Utilities.HexToBinary(PUBLIC_KEY), Utilities.HexToBinary(PRIVATE_KEY));
            Console.Write("Encrypting testfile . . .\n");
            var encryptedFile =
                await
                    Cryptor.EncryptFileWithStreamAsync(keyPair.PrivateKey, keyPair.PublicKey,
                        Utilities.HexToBinary(PUBLIC_KEY), RAW_FILE, progressEncrypt, OUTPUT_DIRECTORY, ".test", true, cancellationTokenSource.Token);
            Console.Write("Decrypting testfile . . .\n");
            var decryptedFile =
                await
                    Cryptor.DecryptFileWithStreamAsync(keyPair.PrivateKey, Path.Combine(OUTPUT_DIRECTORY, encryptedFile),
                        OUTPUT_DIRECTORY, progressDecrypt, cancellationToken: cancellationTokenSource.Token);

        }
Ejemplo n.º 29
0
		public async Task WorkWithStreamTestSmallAsync()
		{
			var progressEncrypt = new Progress<StreamCryptorTaskAsyncProgress>();
			var progressDecrypt = new Progress<StreamCryptorTaskAsyncProgress>();
			progressEncrypt.ProgressChanged +=
				(s, e) => { Console.WriteLine("Encrypting: " + e.ProgressPercentage + "%\n"); };
			progressDecrypt.ProgressChanged +=
				(s, e) => { Console.WriteLine("Decrypting: " + e.ProgressPercentage + "%\n"); };

			const string privateKey = "31d9040b00a170532929b37db0afcb989e4175f96e5f9667ee8cbf5706679a71";
			const string publicKey = "6d0deec730700f9f60687a4e6e8755157ca22ea2f3815b9bf14b1fe9ae6a0b4d";
			var outputDirectory = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "decrypted");
			var keyPair = new KeyPair(Utilities.HexToBinary(publicKey), Utilities.HexToBinary(privateKey));

			var TESTFILE_RAW = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "verysmallfile.dat");
			const long TESTFILE_SIZE_KB = 1;

			Console.Write("Generating {0} KB testfile . . .\n", TESTFILE_SIZE_KB);
			var fs = new FileStream(TESTFILE_RAW, FileMode.CreateNew);
			fs.Seek(TESTFILE_SIZE_KB*1024, SeekOrigin.Begin);
			fs.WriteByte(0);
			fs.Close();

			var data = File.ReadAllBytes(TESTFILE_RAW);
			var stream = new MemoryStream(data);
			Console.Write("Encrypting MemoryStream . . .\n");
			var encryptedFile =
				await
					Cryptor.EncrypMemoryStreamAsync(keyPair.PrivateKey, keyPair.PublicKey,
						Utilities.HexToBinary(publicKey), TESTFILE_RAW, stream, outputDirectory, ".test", true, progressEncrypt)
						.ConfigureAwait(false);

			Console.Write("Decrypting testfile (" + encryptedFile + ") . . .\n");
			var decryptedFileObject =
				await
					Cryptor.DecryptFileWithStreamAsync(keyPair.PrivateKey, Path.Combine(outputDirectory, encryptedFile),
						progressDecrypt).ConfigureAwait(false);
			Console.Write("Get checksum of testfiles . . .\n");
			Assert.AreEqual(Utils.GetChecksum(TESTFILE_RAW), Utils.GetChecksum(decryptedFileObject.FileData));
			//clear garbage 
			File.Delete(Path.Combine(TestContext.CurrentContext.TestDirectory, outputDirectory, encryptedFile));
			File.Delete(TESTFILE_RAW);
		}
Ejemplo n.º 30
0
		public async Task WorkWithVerySmallFileTestAsync()
		{
			var progressEncrypt = new Progress<StreamCryptorTaskAsyncProgress>();
			var progressDecrypt = new Progress<StreamCryptorTaskAsyncProgress>();
			progressEncrypt.ProgressChanged +=
				(s, e) => { Console.WriteLine("Encrypting: " + e.ProgressPercentage + "%\n"); };
			progressDecrypt.ProgressChanged +=
				(s, e) => { Console.WriteLine("Decrypting: " + e.ProgressPercentage + "%\n"); };
			var testfileRaw = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "verysmallfile.dat");
			var testfileDecryptedFile = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles", "decrypted",
				"verysmallfile.dat");
			var testfileDecryptedOutputDirectory = Path.Combine(TestContext.CurrentContext.TestDirectory, "Testfiles",
				"decrypted");
			const string outputDirectory = "Testfiles";
			const long testfileSizeKb = 1;
			const string privateKey = "31d9040b00a170532929b37db0afcb989e4175f96e5f9667ee8cbf5706679a71";
			const string publicKey = "6d0deec730700f9f60687a4e6e8755157ca22ea2f3815b9bf14b1fe9ae6a0b4d";
			var keyPair = new KeyPair(Utilities.HexToBinary(publicKey), Utilities.HexToBinary(privateKey));
			Console.Write("Generating {0} KB testfile . . .\n", testfileSizeKb);
			var fs = new FileStream(testfileRaw, FileMode.CreateNew);
			fs.Seek(testfileSizeKb*1024, SeekOrigin.Begin);
			fs.WriteByte(0);
			fs.Close();
			Console.Write("Encrypting testfile . . .\n");
			var encryptedFile = await Cryptor.EncryptFileWithStreamAsync(keyPair, testfileRaw, progressEncrypt);
			Console.Write("Decrypting testfile . . .\n");
			await
				Cryptor.DecryptFileWithStreamAsync(keyPair,
					Path.Combine(TestContext.CurrentContext.TestDirectory, outputDirectory, encryptedFile),
					testfileDecryptedOutputDirectory, progressDecrypt);
			Console.Write("Get checksum of testfiles . . .\n");
			Assert.AreEqual(Utils.GetChecksum(testfileRaw), Utils.GetChecksum(testfileDecryptedFile));
			//clear garbage 
			File.Delete(testfileRaw);
			File.Delete(Path.Combine(TestContext.CurrentContext.TestDirectory, outputDirectory, encryptedFile));
			File.Delete(testfileDecryptedFile);
		}