public WriteAsync ( byte buffer, int offset, int count, CancellationToken cancellationToken ) : Task | ||
buffer | byte | |
offset | int | |
count | int | |
cancellationToken | CancellationToken | |
return | Task |
public async static Task<string> EncryptAsync(string plainText, string passPhrase) { var plainTextBytes = Encoding.UTF8.GetBytes(plainText); using (var password = new Rfc2898DeriveBytes(passPhrase, InitVectorBytes)) { var keyBytes = password.GetBytes(Keysize / 8); using (var symmetricKey = new RijndaelManaged()) { symmetricKey.Mode = CipherMode.CBC; symmetricKey.Padding = PaddingMode.PKCS7; using (var encryptor = symmetricKey.CreateEncryptor(keyBytes, InitVectorBytes)) { using (var memoryStream = new MemoryStream()) { using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write)) { await cryptoStream.WriteAsync(plainTextBytes, 0, plainTextBytes.Length); cryptoStream.FlushFinalBlock(); var cipherTextBytes = memoryStream.ToArray(); return Convert.ToBase64String(cipherTextBytes); } } } } } }
private async Task<byte[]> PerformCryptography(ICryptoTransform cryptoTransform, byte[] data) { using (var memoryStream = new MemoryStream()) { using (var cryptoStream = new CryptoStream(memoryStream, cryptoTransform, CryptoStreamMode.Write)) { await cryptoStream.WriteAsync(data, 0, data.Length); cryptoStream.FlushFinalBlock(); return memoryStream.ToArray(); } } }
public static async Task<string> EncryptStringAsync(string plainData, byte[] key, byte[] iv, CancellationToken cancellationToken = default(CancellationToken)) { byte[] cipherMessageBytes; using (var rijndael = Rijndael.Create()) using (var memoryStream = new MemoryStream()) using (var cryptoStream = new CryptoStream(memoryStream, rijndael.CreateEncryptor(key, iv), CryptoStreamMode.Write)) { var plainDataInBytes = Encoding.UTF8.GetBytes(plainData); await cryptoStream.WriteAsync(plainDataInBytes, 0, plainDataInBytes.Length, cancellationToken).ConfigureAwait(false); cryptoStream.FlushFinalBlock(); cipherMessageBytes = memoryStream.ToArray(); memoryStream.Close(); cryptoStream.Close(); rijndael.Clear(); } return Convert.ToBase64String(cipherMessageBytes); }
private async Task<byte[]> AliceSendsDataAsync(string message) { WriteLine($"Alice sends message: {message}"); byte[] rawData = Encoding.UTF8.GetBytes(message); byte[] encryptedData = null; using (var aliceAlgorithm = new ECDiffieHellmanCng(_aliceKey)) using (CngKey bobPubKey = CngKey.Import(_bobPubKeyBlob, CngKeyBlobFormat.EccPublicBlob)) { byte[] symmKey = aliceAlgorithm.DeriveKeyMaterial(bobPubKey); WriteLine("Alice creates this symmetric key with " + $"Bobs public key information: { Convert.ToBase64String(symmKey)}"); using (var aes = new AesCryptoServiceProvider()) { aes.Key = symmKey; aes.GenerateIV(); using (ICryptoTransform encryptor = aes.CreateEncryptor()) using (var ms = new MemoryStream()) { // create CryptoStream and encrypt data to send using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) { // write initialization vector not encrypted await ms.WriteAsync(aes.IV, 0, aes.IV.Length); await cs.WriteAsync(rawData, 0, rawData.Length); } encryptedData = ms.ToArray(); } aes.Clear(); } } WriteLine($"Alice: message is encrypted: {Convert.ToBase64String(encryptedData)}"); ; WriteLine(); return encryptedData; }
private async static Task File(string inFile, string outFile, RSACryptoServiceProvider key) { RSACryptoServiceProvider rsaPrivateKey = key; // Create instance of AesManaged for // symetric decryption of the data. using (AesManaged aesManaged = new AesManaged()) { aesManaged.KeySize = 256; aesManaged.BlockSize = 128; aesManaged.Mode = CipherMode.CBC; // Create byte arrays to get the length of // the encrypted key and IV. // These values were stored as 4 bytes each // at the beginning of the encrypted package. byte[] LenK = new byte[4]; byte[] LenIV = new byte[4]; // Consruct the file name for the decrypted file. // Use FileStream objects to read the encrypted // file (inFs) and save the decrypted file (outFs). using (FileStream inFs = new FileStream(inFile, FileMode.Open)) { inFs.Seek(0, SeekOrigin.Begin); inFs.Seek(0, SeekOrigin.Begin); await inFs.ReadAsync(LenK, 0, 3); inFs.Seek(4, SeekOrigin.Begin); await inFs.ReadAsync(LenIV, 0, 3); // Convert the lengths to integer values. int lenK = BitConverter.ToInt32(LenK, 0); int lenIV = BitConverter.ToInt32(LenIV, 0); // Determine the start postition of // the ciphter text (startC) // and its length(lenC). int startC = lenK + lenIV + 8; int lenC = (int)inFs.Length - startC; // Create the byte arrays for // the encrypted AesManaged key, // the IV, and the cipher text. byte[] KeyEncrypted = new byte[lenK]; byte[] IV = new byte[lenIV]; // Extract the key and IV // starting from index 8 // after the length values. inFs.Seek(8, SeekOrigin.Begin); await inFs.ReadAsync(KeyEncrypted, 0, lenK); inFs.Seek(8 + lenK, SeekOrigin.Begin); await inFs.ReadAsync(IV, 0, lenIV); // Use RSACryptoServiceProvider // to decrypt the AesManaged key. byte[] KeyDecrypted = rsaPrivateKey.Decrypt(KeyEncrypted, false); // Decrypt the key. using (ICryptoTransform transform = aesManaged.CreateDecryptor(KeyDecrypted, IV)) { // Decrypt the cipher text from // from the FileSteam of the encrypted // file (inFs) into the FileStream // for the decrypted file (outFs). using (FileStream outFs = new FileStream(outFile, FileMode.Create)) { int count = 0; int offset = 0; int blockSizeBytes = aesManaged.BlockSize / 8; byte[] data = new byte[blockSizeBytes]; // By decrypting a chunk a time, // you can save memory and // accommodate large files. // Start at the beginning // of the cipher text. inFs.Seek(startC, SeekOrigin.Begin); using (CryptoStream outStreamDecrypted = new CryptoStream(outFs, transform, CryptoStreamMode.Write)) { do { count = await inFs.ReadAsync(data, 0, blockSizeBytes); offset += count; await outStreamDecrypted.WriteAsync(data, 0, count); } while (count > 0); } } } } } }
private async static Task EncryptFile(string inputFilename, string outputFilename, string password) { var buffer = new byte[1024 * 1024 * 1]; var sha256 = SHA256.Create(); var hash = sha256.ComputeHash(Encoding.UTF8.GetBytes(password)); using (FileStream input = new FileStream(inputFilename, FileMode.Open, FileAccess.Read, FileShare.None)) { using (FileStream outputRaw = new FileStream(outputFilename, FileMode.CreateNew, FileAccess.Write, FileShare.None)) { var aes = Aes.Create(); var iv = aes.IV; var encryptor = aes.CreateEncryptor(hash, iv); BinaryWriter bw = new BinaryWriter(outputRaw); bw.Write(iv.Length); bw.Write(iv); bw.Flush(); int bytesRead; using (var output = new CryptoStream(outputRaw, encryptor, CryptoStreamMode.Write)) { do { bytesRead = await input.ReadAsync(buffer, 0, buffer.Length); if (bytesRead > 0) { await output.WriteAsync(buffer, 0, bytesRead); } } while (bytesRead > 0); } } } }
private async Task BobReceivesDataAsync(byte[] encryptedData) { WriteLine("Bob receives encrypted data"); byte[] rawData = null; var aes = new AesCryptoServiceProvider(); int nBytes = aes.BlockSize >> 3; byte[] iv = new byte[nBytes]; for (int i = 0; i < iv.Length; i++) iv[i] = encryptedData[i]; using (var bobAlgorithm = new ECDiffieHellmanCng(_bobKey)) using (CngKey alicePubKey = CngKey.Import(_alicePubKeyBlob, CngKeyBlobFormat.EccPublicBlob)) { byte[] symmKey = bobAlgorithm.DeriveKeyMaterial(alicePubKey); WriteLine("Bob creates this symmetric key with " + $"Alices public key information: {Convert.ToBase64String(symmKey)}"); aes.Key = symmKey; aes.IV = iv; using (ICryptoTransform decryptor = aes.CreateDecryptor()) using (MemoryStream ms = new MemoryStream()) { using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write)) { await cs.WriteAsync(encryptedData, nBytes, encryptedData.Length - nBytes); } rawData = ms.ToArray(); WriteLine($"Bob decrypts message to: {Encoding.UTF8.GetString(rawData)}"); } aes.Clear(); } }
private async static Task File(string inFile, string outFile, RSACryptoServiceProvider key) { using (AesManaged aesManaged = new AesManaged()) { // Create instance of AesManaged for // symetric encryption of the data. aesManaged.KeySize = 256; aesManaged.BlockSize = 128; aesManaged.Mode = CipherMode.CBC; using (ICryptoTransform transform = aesManaged.CreateEncryptor()) { RSAPKCS1KeyExchangeFormatter keyFormatter = new RSAPKCS1KeyExchangeFormatter(key); byte[] keyEncrypted = keyFormatter.CreateKeyExchange(aesManaged.Key, aesManaged.GetType()); // Create byte arrays to contain // the length values of the key and IV. byte[] LenK = new byte[4]; byte[] LenIV = new byte[4]; int lKey = keyEncrypted.Length; LenK = BitConverter.GetBytes(lKey); int lIV = aesManaged.IV.Length; LenIV = BitConverter.GetBytes(lIV); // Write the following to the FileStream // for the encrypted file (outFs): // - length of the key // - length of the IV // - ecrypted key // - the IV // - the encrypted cipher content using (FileStream outFs = new FileStream(outFile, FileMode.Create)) { await outFs.WriteAsync(LenK, 0, 4); await outFs.WriteAsync(LenIV, 0, 4); await outFs.WriteAsync(keyEncrypted, 0, lKey); await outFs.WriteAsync(aesManaged.IV, 0, lIV); // Now write the cipher text using // a CryptoStream for encrypting. using (CryptoStream outStreamEncrypted = new CryptoStream(outFs, transform, CryptoStreamMode.Write)) { // By encrypting a chunk at // a time, you can save memory // and accommodate large files. int count = 0; int offset = 0; // blockSizeBytes can be any arbitrary size. int blockSizeBytes = aesManaged.BlockSize / 8; byte[] data = new byte[blockSizeBytes]; int bytesRead = 0; using (FileStream inFs = new FileStream(inFile, FileMode.Open)) { do { count = await inFs.ReadAsync(data, 0, blockSizeBytes); offset += count; await outStreamEncrypted.WriteAsync(data, 0, count); bytesRead += blockSizeBytes; } while (count > 0); } } } } } }
public static void Main(string[] args) { System.Console.WriteLine( typeof(object).AssemblyQualifiedName ); // http://www.drdobbs.com/windows/programming-public-key-cryptostreams-par/184416907 // X:\jsc.svn\examples\java\hybrid\JVMCLRRSACryptoServiceProviderExport\JVMCLRRSACryptoServiceProviderExport\Program.cs //var dwKeySize = (0x100 + 0x100) * 8; var dwKeySize = 128 * 8; var MaxData = (dwKeySize - 384) / 8 + 7; var RSA = new RSACryptoServiceProvider( dwKeySize: dwKeySize, parameters: new CspParameters { } ); RSAParameters p = RSA.ExportParameters(includePrivateParameters: false); var value = RSA.Encrypt( Encoding.UTF8.GetBytes("hello from server"), fOAEP: true //Encoding.UTF8.GetBytes("hello from server"), fOAEP: false ); var data = new MemoryStream(); var goo = new CryptoStream(data, new RSAEnCryptoTransform(RSA), CryptoStreamMode.Write); var text = Encoding.UTF8.GetBytes("hello".PadRight(8000) + "world"); goo.WriteAsync(text, 0, text.Length).Wait(); goo.FlushFinalBlock(); goo.FlushAsync().Wait(); var foo = new CryptoStream(data, new RSADeCryptoTransform(RSA), CryptoStreamMode.Read); //var buffer = new byte[100]; //var buffer = new byte[MaxData]; var buffer = new byte[0x1000]; var result = foo.Read(buffer, 0, buffer.Length); //var result = foo.ReadAsync(buffer, 0, buffer.Length).Result; CLRProgram.CLRMain(); }