public static string Encode(byte[] data)
{
var builder = new StringBuilder();
using (var writer = new StringWriter(builder))
{
using (var transformation = new ToBase64Transform())
{
var bufferedOutputBytes = new byte[transformation.OutputBlockSize];
int i = 0;
int inputBlockSize = transformation.InputBlockSize;
while (data.Length - i > inputBlockSize)
{
transformation.TransformBlock(data, i, data.Length - i, bufferedOutputBytes, 0);
i += inputBlockSize;
writer.Write(Encoding.UTF8.GetString(bufferedOutputBytes, 0, bufferedOutputBytes.Length));
}
bufferedOutputBytes = transformation.TransformFinalBlock(data, i, data.Length - i);
writer.Write(Encoding.UTF8.GetString(bufferedOutputBytes, 0, bufferedOutputBytes.Length));
transformation.Clear();
}
writer.Close();
}
return(builder.ToString());
}
public static void RoundtripCryptoStream(int length)
{
byte[] expected = RandomNumberGenerator.GetBytes(length);
var ms = new MemoryStream();
using (var toBase64 = new ToBase64Transform())
using (var stream = new CryptoStream(ms, toBase64, CryptoStreamMode.Write, leaveOpen: true))
{
stream.Write(expected);
}
ms.Position = 0;
byte[] actual = new byte[expected.Length];
using (var fromBase64 = new FromBase64Transform())
using (var stream = new CryptoStream(ms, fromBase64, CryptoStreamMode.Read, leaveOpen: true))
{
int totalRead = 0, bytesRead;
while ((bytesRead = stream.Read(actual.AsSpan(totalRead))) != 0)
{
totalRead += bytesRead;
}
Assert.Equal(actual.Length, totalRead);
AssertExtensions.SequenceEqual(expected, actual);
}
}
public static string Encode(byte[] buffer, int offset, int length)
{
byte[] buffer2;
length += offset;
ToBase64Transform transform = new ToBase64Transform();
MemoryStream stream = new MemoryStream();
int inputOffset = offset;
int inputCount = 3;
if (length < 3)
{
inputCount = length;
}
do
{
buffer2 = transform.TransformFinalBlock(buffer, inputOffset, inputCount);
inputOffset += inputCount;
if ((length - inputOffset) < inputCount)
{
inputCount = length - inputOffset;
}
stream.Write(buffer2, 0, buffer2.Length);
}while (inputOffset < length);
buffer2 = stream.ToArray();
stream.Close();
UTF8Encoding encoding = new UTF8Encoding();
return(encoding.GetString(buffer2));
}
public void TransformFinalBlock_Input_Null()
{
using (ICryptoTransform t = new ToBase64Transform())
{
t.TransformFinalBlock(null, 0, 15);
}
}
public async Task CanEncryptAndDecryptMergedStream(MergedStream mergedStream, string expectedData)
{
using (var aes = Aes.Create())
{
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
aes.GenerateKey();
aes.GenerateIV();
using (var encryptor = aes.CreateEncryptor())
using (var encryptedStream = new CryptoStream(mergedStream, encryptor, CryptoStreamMode.Read))
using (var toBase64Transform = new ToBase64Transform())
using (var encodedStream = new CryptoStream(encryptedStream, toBase64Transform, CryptoStreamMode.Read))
using (var fromBase64Transform = new FromBase64Transform())
using (var decodedStream = new CryptoStream(encodedStream, fromBase64Transform, CryptoStreamMode.Read))
using (var decryptor = aes.CreateDecryptor())
using (var decryptedStream = new CryptoStream(encryptedStream, decryptor, CryptoStreamMode.Read))
using (var streamReader = new StreamReader(decryptedStream))
{
var data = await streamReader.ReadToEndAsync();
Assert.Equal(expectedData, data);
}
}
}
/// <summary>
/// Converts a byte array to a base64 string one block at a time.
/// </summary>
/// <param name="data">The data.</param>
/// <returns></returns>
public static string ToBase64(byte[] data)
{
StringBuilder builder = new StringBuilder();
using (StringWriter writer = new StringWriter(builder))
{
using (ToBase64Transform transformation = new ToBase64Transform())
{
// Transform the data in chunks the size of InputBlockSize.
byte[] bufferedOutputBytes = new byte[transformation.OutputBlockSize];
int i = 0;
int inputBlockSize = transformation.InputBlockSize;
while (data.Length - i > inputBlockSize)
{
transformation.TransformBlock(data, i, data.Length - i, bufferedOutputBytes, 0);
i += inputBlockSize;
writer.Write(Encoding.UTF8.GetString(bufferedOutputBytes));
}
// Transform the final block of data.
bufferedOutputBytes = transformation.TransformFinalBlock(data, i, data.Length - i);
writer.Write(Encoding.UTF8.GetString(bufferedOutputBytes));
// Free up any used resources.
transformation.Clear();
}
writer.Close();
}
return(builder.ToString());
}
public void TransformFinalBlock_InputOffset_Negative()
{
byte[] input = new byte [15];
using (ICryptoTransform t = new ToBase64Transform()) {
t.TransformFinalBlock(input, -1, input.Length);
}
}
/// <summary>
/// 加密 对用户名和密码进行加密的方法
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
private string Encrypt(string text)
{
Rijndael crypt = Rijndael.Create();
byte[] key = new byte[32] {
0XA6, 0X7D, 0XE1, 0X3F, 0X35, 0X0E, 0XE1, 0XA9, 0X83, 0XA5, 0X62, 0XAA, 0X7A, 0XAE, 0X79, 0X98, 0XA7, 0X33, 0X49, 0XFF, 0XE6, 0XAE, 0XBF, 0X8D, 0X8D, 0X20, 0X8A, 0X49, 0X31, 0X3A, 0X12, 0X40
};
byte[] iv = new byte[16] {
0XF8, 0X8B, 0X01, 0XFB, 0X08, 0X85, 0X9A, 0XA4, 0XBE, 0X45, 0X28, 0X56, 0X03, 0X42, 0XF6, 0X19
};
crypt.Key = key;
crypt.IV = iv;
MemoryStream ms = new MemoryStream();
ICryptoTransform transtormEncode = new ToBase64Transform();
//Base64编码
CryptoStream csEncode = new CryptoStream(ms, transtormEncode, CryptoStreamMode.Write);
CryptoStream csEncrypt = new CryptoStream(csEncode, crypt.CreateEncryptor(), CryptoStreamMode.Write);
System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
byte[] rawData = enc.GetBytes(text);
csEncrypt.Write(rawData, 0, rawData.Length);
csEncrypt.FlushFinalBlock();
byte[] encryptedData = new byte[ms.Length];
ms.Position = 0;
ms.Read(encryptedData, 0, (int)ms.Length);
return(enc.GetString(encryptedData));
}
public void TransformBlock_NullInput()
{
byte[] output = new byte [4];
ToBase64Transform t = new ToBase64Transform();
t.TransformBlock(null, 0, 0, output, 0);
}
/// <summary>
/// AES加密
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public static string AESEncrypt(string text)
{
Rijndael rijndael = Rijndael.Create();
byte[] buffer = new byte[] {
0xa6, 0x7d, 0xe1, 0x3f, 0x35, 14, 0xe1, 0xa9, 0x83, 0xa5, 0x62, 170, 0x7a, 0xae, 0x79, 0x98,
0xa7, 0x33, 0x49, 0xff, 230, 0xae, 0xbf, 0x8d, 0x8d, 0x20, 0x8a, 0x49, 0x31, 0x3a, 0x12, 0x40
};
byte[] buffer2 = new byte[] { 0xf8, 0x8b, 1, 0xfb, 8, 0x85, 0x9a, 0xa4, 190, 0x45, 40, 0x56, 3, 0x42, 0xf6, 0x19 };
rijndael.Key = buffer;
rijndael.IV = buffer2;
MemoryStream stream = new MemoryStream();
ICryptoTransform transform = new ToBase64Transform();
CryptoStream stream2 = new CryptoStream(stream, transform, CryptoStreamMode.Write);
CryptoStream stream3 = new CryptoStream(stream2, rijndael.CreateEncryptor(), CryptoStreamMode.Write);
UTF8Encoding encoding = new UTF8Encoding();
byte[] bytes = encoding.GetBytes(text);
stream3.Write(bytes, 0, bytes.Length);
stream3.FlushFinalBlock();
byte[] buffer4 = new byte[stream.Length];
stream.Position = 0;
stream.Read(buffer4, 0, (int)stream.Length);
return(encoding.GetString(buffer4));
}
public void TransformFinalBlock_WrongLength()
{
byte[] input = new byte [6];
ToBase64Transform t = new ToBase64Transform();
t.TransformFinalBlock(input, 0, 6);
}
public void TransformFinalBlock_SmallLength()
{
byte[] input = new byte [2]; // smaller than InputBlockSize
ToBase64Transform t = new ToBase64Transform();
t.TransformFinalBlock(input, 0, 2);
}
public void TransformFinalBlock_InputCount_Negative()
{
byte[] input = new byte [15];
using (ICryptoTransform t = new ToBase64Transform()) {
t.TransformFinalBlock(input, 0, -1);
}
}
public static void EnormousWrite()
{
// 0x6000_0000 / 3 => 0x2000_0000 * 4 => 0x8000_0000 (overflow)
// (input bytes) / (input block size) * (output block size) => (output bytes to write)
const int InputBufferLength = 0x60000000;
byte[] buffer;
try
{
buffer = new byte[InputBufferLength];
}
catch (OutOfMemoryException)
{
throw new SkipTestException("Could not create a large enough array");
}
// In the Read scenario the overflow comes from a reducing transform.
// In the Write scenario it comes from an expanding transform.
//
// When making the write not overflow change the test to use an output stream
// that isn't bounded by Array.MaxLength. e.g. a counting stream, or a stream
// that just computes some hash of the input (so total correctness can be measured)
byte[] output = Array.Empty <byte>();
using (MemoryStream stream = new MemoryStream(output))
using (ICryptoTransform transform = new ToBase64Transform())
using (CryptoStream cryptoStream = new CryptoStream(stream, transform, CryptoStreamMode.Write, leaveOpen: true))
{
Assert.Throws <OverflowException>(() => cryptoStream.Write(buffer, 0, buffer.Length));
}
}
public void TransformBlock_NullOutput()
{
byte[] input = new byte [3];
ToBase64Transform t = new ToBase64Transform();
t.TransformBlock(input, 0, 3, null, 0);
}
public static void ValidateToBase64CryptoStream(string data, string encoding)
{
using (var transform = new ToBase64Transform())
{
ValidateCryptoStream(encoding, data, transform);
}
}
/// <summary>
/// Encodes a Specific part of a Byte Array as Base64
/// </summary>
/// <param name="buffer">The Byte Array to Encode</param>
/// <param name="offset">The offset to begin encoding</param>
/// <param name="length">The number of bytes to encode</param>
/// <returns></returns>
public static String Encode(byte[] buffer, int offset, int length)
{
length += offset;
ToBase64Transform x = new ToBase64Transform();
byte[] OutBuf;
MemoryStream ms = new MemoryStream();
int pos = offset;
int size = 3;
if (length < 3)
{
size = length;
}
do
{
OutBuf = x.TransformFinalBlock(buffer, pos, size);
pos += size;
if (length - pos < size)
{
size = length - pos;
}
ms.Write(OutBuf, 0, OutBuf.Length);
}while(pos < length);
OutBuf = ms.ToArray();
ms.Close();
UTF8Encoding y = new UTF8Encoding();
return(y.GetString(OutBuf));
}
public void TransformFinalBlock_Null()
{
byte[] input = new byte [3];
ToBase64Transform t = new ToBase64Transform();
t.TransformFinalBlock(null, 0, 3);
}
// Encode inStream to outStream
public static void Encode(Stream inStream, Stream outStream, int breakCol = 0)
{
using (var base64Transform = new ToBase64Transform())
{
var col = 0;
var inputBytes = new byte[base64Transform.InputBlockSize * BucketSize];
var outputBytes = new byte[base64Transform.OutputBlockSize];
var bytesRead = inStream.Read(inputBytes, 0, inputBytes.Length);
while (bytesRead != 0)
{
var offset = 0;
while (bytesRead - offset > base64Transform.InputBlockSize)
{
base64Transform.TransformBlock(
inputBytes,
offset,
base64Transform.InputBlockSize,
outputBytes,
0);
col = Emit(outStream, outputBytes, col, breakCol);
offset += base64Transform.InputBlockSize;
}
if (bytesRead - offset > 0)
{
outputBytes = base64Transform.TransformFinalBlock(
inputBytes,
offset,
bytesRead - offset);
Emit(outStream, outputBytes, col, breakCol);
}
bytesRead = inStream.Read(inputBytes, 0, inputBytes.Length);
}
}
}
/// <summary> Encodes a FileStream using Base64 (see RFC 1521)</summary>
/// <param name="inputStream">The stream that needs to be encoded</param>
/// <param name="outputFilePath">UNC path to file will store Base64 encoded ASCII text</param>
/// <example>
/// <code>
/// MailEncoder.ConvertBase64(Stream, "file.txt");
/// </code>
/// </example>
internal static void ConvertToBase64(Stream inputStream, string outputFilePath)
{
//Create the file streams to handle the input and output files.
FileStream fout = new FileStream(outputFilePath, FileMode.OpenOrCreate, FileAccess.Write);
fout.SetLength(0);
ToBase64Transform transformer = new ToBase64Transform();
//Create variables to help with read and write below.
//This is intermediate storage for the encryption:
byte[] bin = new byte[inputStream.Length / transformer.InputBlockSize * transformer.OutputBlockSize];
long rdlen = 0; //This is the total number of bytes written.
long totlen = inputStream.Length; //This is the total length of the input file.
int len; //This is the number of bytes to be written at a time.
CryptoStream encStream = new CryptoStream(fout, transformer, CryptoStreamMode.Write);
//Read from the input file, then encrypt and write to the output file.
while (rdlen < totlen)
{
len = inputStream.Read(bin, 0, (int)inputStream.Length);
encStream.Write(bin, 0, len);
//inputBlock size(3)
rdlen = (rdlen + ((len / transformer.InputBlockSize) * transformer.OutputBlockSize));
}
encStream.Close();
fout.Close();
}
public static string SignatureMessage(string certFileName, string password, byte[] dataTobeSign, string outputFileName)
{
byte[] pfxCert = File.ReadAllBytes(certFileName);
// byte[] dataTobeSign = File.ReadAllBytes(dataFileName);
SecureString pwd = new SecureString();
char[] pwdCharArray = password.ToCharArray();
for (int i = 0; i < pwdCharArray.Length; i++)
{
pwd.AppendChar(pwdCharArray[i]);
}
X509Certificate2 cert = new X509Certificate2(pfxCert, pwd);
CmsSigner signer = new CmsSigner(cert);
signer.DigestAlgorithm = new Oid("1.3.14.3.2.26", "sha1");
signer.IncludeOption = X509IncludeOption.EndCertOnly;
ContentInfo signedData = new ContentInfo(dataTobeSign);
SignedCms cms = new SignedCms(signedData, true);
cms.ComputeSignature(signer);
byte[] signature = cms.Encode();
//base64
ToBase64Transform base64Transform = new ToBase64Transform();
byte[] inputBytes = signature;
byte[] outputBytes = new byte[base64Transform.OutputBlockSize];
int inputOffset = 0;
int inputBlockSize = base64Transform.InputBlockSize;
MemoryStream outputDataStream = new MemoryStream();
while (inputBytes.Length - inputOffset > inputBlockSize)
{
base64Transform.TransformBlock(inputBytes, inputOffset, inputBytes.Length - inputOffset, outputBytes, 0);
inputOffset += base64Transform.InputBlockSize;
outputDataStream.Write(outputBytes, 0, base64Transform.OutputBlockSize);
}
outputBytes = base64Transform.TransformFinalBlock(inputBytes, inputOffset, inputBytes.Length - inputOffset);
outputDataStream.Write(outputBytes, 0, outputBytes.Length);
outputDataStream.Position = 0;
byte[] outputData = new byte[outputDataStream.Length];
outputDataStream.Read(outputData, 0, (int)outputDataStream.Length);
outputDataStream.Close();
if (string.IsNullOrEmpty(outputFileName))
{
string outputStr = System.Text.Encoding.Default.GetString(outputData);
Console.WriteLine("输出字符");
Console.WriteLine(outputStr);
Console.ReadKey();
}
else
{
File.WriteAllBytes(outputFileName, outputData);
}
return("");
}
public void TransformFinalBlock_InputCount_Overflow()
{
byte[] input = new byte [15];
using (ICryptoTransform t = new ToBase64Transform()) {
t.TransformFinalBlock(input, 0, Int32.MaxValue);
}
}
public void TransformFinalBlock_InputOffset_Overflow()
{
byte[] input = new byte [15];
using (ICryptoTransform t = new ToBase64Transform()) {
t.TransformFinalBlock(input, Int32.MaxValue, input.Length);
}
}
//原始base64编码
public static byte[] Base64Encode(byte[] source)
{
if ((source == null) || (source.Length == 0))
{
throw new ArgumentException("source is not valid");
}
ToBase64Transform tb64 = new ToBase64Transform();
MemoryStream stm = new MemoryStream();
int pos = 0;
byte[] buff;
while (pos + 3 < source.Length)
{
buff = tb64.TransformFinalBlock(source, pos, 3);
stm.Write(buff, 0, buff.Length);
pos += 3;
}
buff = tb64.TransformFinalBlock(source, pos, source.Length - pos);
stm.Write(buff, 0, buff.Length);
return(stm.ToArray());
}
public void TransformUsageFlags_ToBase64Transform()
{
using (var transform = new ToBase64Transform())
{
Assert.False(transform.CanTransformMultipleBlocks);
Assert.True(transform.CanReuseTransform);
}
}
public void TransformBlock_OutputOffset_Overflow()
{
byte[] input = new byte [15];
byte[] output = new byte [16];
using (ICryptoTransform t = new ToBase64Transform()) {
t.TransformBlock(input, 0, input.Length, output, Int32.MaxValue);
}
}
public void TransformBlock_OutputOffset_Negative()
{
byte[] input = new byte [15];
byte[] output = new byte [16];
using (ICryptoTransform t = new ToBase64Transform()) {
t.TransformBlock(input, 0, input.Length, output, -1);
}
}
public void TransformFinalBlock_Dispose()
{
byte[] input = new byte [3];
ToBase64Transform t = new ToBase64Transform();
t.Clear();
t.TransformFinalBlock(input, 0, input.Length);
}
public void Blocksizes_ToBase64Transform()
{
using (var transform = new ToBase64Transform())
{
Assert.Equal(3, transform.InputBlockSize);
Assert.Equal(4, transform.OutputBlockSize);
}
}
public static string Encrypt_HMACSHA1(string key, byte[] data)
{
HMACSHA1 hmascha1 = new HMACSHA1(Encoding.UTF8.GetBytes(key));
ToBase64Transform tbt = new ToBase64Transform();
byte[] encrypteddata = hmascha1.ComputeHash(data);
return(Convert.ToBase64String(encrypteddata));
}
static void Main( )
{
Stream stm = new FileStream ( "foo.txt" , FileMode.Open , FileAccess.Read ) ;
ICryptoTransform ict = new ToBase64Transform ( ) ;
CryptoStream cs = new CryptoStream ( stm , ict, CryptoStreamMode.Read ) ;
TextReader tr = new StreamReader ( cs ) ;
string s = tr.ReadToEnd ( ) ;
Console.WriteLine ( s ) ;
}
public void InvalidInput_ToBase64Transform()
{
byte[] data_5bytes = Text.Encoding.ASCII.GetBytes("aaaaa");
using (var transform = new ToBase64Transform())
{
InvalidInput_Base64Transform(transform);
// These exceptions only thrown in ToBase
Assert.Throws<ArgumentOutOfRangeException>("offsetOut", () => transform.TransformFinalBlock(data_5bytes, 0, 5));
}
}
public static void ValidateToBase64TransformFinalBlock(string data, string expected)
{
using (var transform = new ToBase64Transform())
{
byte[] inputBytes = Text.Encoding.ASCII.GetBytes(data);
Assert.True(inputBytes.Length > 4);
// Test passing blocks > 4 characters to TransformFinalBlock (not supported)
Assert.Throws<ArgumentOutOfRangeException>("offsetOut", () => transform.TransformFinalBlock(inputBytes, 0, inputBytes.Length));
}
}
public static void ValidateToBase64CryptoStream(string data, string encoding)
{
using (var transform = new ToBase64Transform())
{
ValidateCryptoStream(encoding, data, transform);
}
}
