| public Encrypt ( byte data, RSAEncryptionPadding padding ) : byte[] | ||
| data | byte | |
| padding | RSAEncryptionPadding | |
| return | byte[] | |
/// <summary>
/// 加密
/// </summary>
/// <param name="rsa"></param>
/// <param name="data"></param>
/// <param name="padding"></param>
/// <returns></returns>
private static byte[] Encrypt(System.Security.Cryptography.RSA rsa, byte[] data, RSAEncryptionPadding padding = null)
{
padding ??= RSAEncryptionPadding.Pkcs1;
byte[] result;
var maxLength = rsa.KeySize / 8 - PaddingLength[padding];
// 长数据分割
if (maxLength < data.Length)
{
var pointer = 0;
var resBytes = new List <byte>();
while (pointer < data.Length)
{
var length = pointer + maxLength > data.Length ? data.Length - pointer : maxLength;
resBytes.AddRange(rsa.Encrypt(data.Skip(pointer).Take(length).ToArray(), padding));
pointer += maxLength;
}
result = resBytes.ToArray();
}
else
{
result = rsa.Encrypt(data, padding);
}
return(result);
}
public byte[] EncryptByPrivate(byte[] _byteArray)
{
if (_publicKeyRsaProvider == null)
{
throw new Exception("_privateKeyRsaProvider is null");
}
return(_privateKeyRsaProvider.Encrypt(_byteArray, RSAEncryptionPadding.Pkcs1));
}
public string Encrypt(string text)
{
if (_publicKeyRsaProvider == null)
{
return(null);
}
return(Convert.ToBase64String(_publicKeyRsaProvider.Encrypt(Encoding.UTF8.GetBytes(text), RSAEncryptionPadding.Pkcs1)));
}
internal static byte[] WrapSecretKey(System.Security.Cryptography.RSA publicKey, byte[] keyBytes, String oaepDigestAlgorithm)
{
try
{
return(publicKey.Encrypt(keyBytes,
"SHA-256".Equals(oaepDigestAlgorithm)
? RSAEncryptionPadding.OaepSHA256
: RSAEncryptionPadding.OaepSHA512));
}
catch (Exception e)
{
throw new EncryptionException("Failed to wrap secret key!", e);
}
}
public static string Encrypt(string encryptString, String key)
{
System.Security.Cryptography.RSA rsa = System.Security.Cryptography.RSA.Create();
RSAParameters para = new RSAParameters();
byte[] b1 = null;
byte[] b2 = null;
ResolveKey(key, out b1, out b2);
para.Exponent = b1;
para.Modulus = b2;
rsa.ImportParameters(para);
byte[] enBytes = rsa.Encrypt(Encoding.UTF8.GetBytes(encryptString), RSAEncryptionPadding.Pkcs1);
return(bytes2hex(enBytes));
}
public string Encrypt(string text)
{
if (string.IsNullOrWhiteSpace(text))
{
throw new ArgumentNullException(nameof(text));
}
if (text.Length > MaxCharsSupported)
{
throw new ArgumentOutOfRangeException(nameof(text), $"Text length of {text.Length} exceeds maximum of {MaxCharsSupported}");
}
byte[] dataToEncrypt = byteConverter.GetBytes(text);
byte[] encryptedData = rsa.Encrypt(dataToEncrypt, RSAEncryptionPadding.Pkcs1);
var cryptoText = Convert.ToBase64String(encryptedData);
return(cryptoText);
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
private static async Task EncryptBlock(SemaphoreSlim semaphore, byte[] data, Action <string, int> result, System.Security.Cryptography.RSA rsa, int iteration)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
try
{
var encbyteData = rsa.Encrypt(data, System.Security.Cryptography.RSAEncryptionPadding.Pkcs1);
var r = Convert.ToBase64String(encbyteData);
result?.Invoke(r, iteration);
}
catch (Exception e)
{
System.Diagnostics.Debugger.Break();
Log.e(e);
}
finally
{
semaphore.Release();
}
}
public static string RSAEncrypt(string publicKey, string srcString, RSAEncryptionPadding padding)
{
Check.Argument.IsNotEmpty(publicKey, nameof(publicKey));
Check.Argument.IsNotEmpty(srcString, nameof(srcString));
Check.Argument.IsNotNull(padding, nameof(padding));
using (System.Security.Cryptography.RSA rsa = System.Security.Cryptography.RSA.Create())
{
rsa.FromJsonString(publicKey);
var maxLength = GetMaxRsaEncryptLengthClass.GetMaxRsaEncryptLength(rsa, padding);
var rawBytes = Encoding.UTF8.GetBytes(srcString);
if (rawBytes.Length > maxLength)
{
throw new OutofMaxlengthException($"'{srcString}' is out of max encrypt length {maxLength}", maxLength, rsa.KeySize, padding);
}
byte[] encryptBytes = rsa.Encrypt(rawBytes, padding);
return(encryptBytes.ToHexString());
}
}
/// <summary>
/// 加密内容成base64字符串，支持超长字符串
/// </summary>
/// <param name="rsa"></param>
/// <param name="content"></param>
/// <param name="padding"></param>
/// <returns></returns>
public static string EncryptToBase64(System.Security.Cryptography.RSA rsa, byte[] content, RSAEncryptionPadding padding)
{
int KEYBIT = rsa.KeySize;
int RESERVEBYTES = 11;// 加密block需要预留11字节
int encryptBlockSize = KEYBIT / 8 - RESERVEBYTES;
List <byte> result = new List <byte>();
int total = content.Length;
int index = 0;
while (total > 0)
{
int read = Math.Min(encryptBlockSize, total);
total -= read;
byte[] bs = new byte[read];
Array.Copy(content, index, bs, 0, read);
bs = rsa.Encrypt(bs, padding);
result.AddRange(bs);
index += read;
}
return(Convert.ToBase64String(result.ToArray()));
}
/// <summary>
/// Encrypts a string
/// </summary>
/// <param name="byteData">The data to encrypt</param>
/// <param name="publicKey">The public key used to encrypt the data</param>
/// <returns>A string containing the encrypted data</returns>
public string Encrypt(byte[] byteData, System.Security.Cryptography.RSAParameters publicKey)
{
//Log.v("Encryption Hash={0}", MD5.GetMd5Hash(publicKey.AsXml<RSAParameters>()));
_rsa.ImportParameters(publicKey);
//byte[] byteData = Encoding.UTF32.GetBytes(text);
int maxLength = (_keySize / 8) - 42;// 214;
int dataLength = byteData.Length;
int iterations = dataLength / maxLength;
var sb = new StringBuilder();
for (int i = 0; i <= iterations; i++)
{
var tempBytes = new byte[(dataLength - maxLength * i > maxLength) ? maxLength : dataLength - maxLength * i];
Buffer.BlockCopy(byteData, maxLength * i, tempBytes, 0, tempBytes.Length);
var encbyteData = _rsa.Encrypt(tempBytes, RSAEncryptionPadding.Pkcs1);
sb.Append(Convert.ToBase64String(encbyteData));
}
var result = sb.ToString();
return(result);
}
public static byte[] Encrypt(byte[] data)
{
return(cryptor.Encrypt(data, RSAEncryptionPadding.Pkcs1));
}
public static Byte[] Encrypt(Byte[] data, Rsa rsa)
{
return(rsa.Encrypt(data));
}
