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