public Encrypt ( byte data, RSAEncryptionPadding padding ) : byte[] | ||
data | byte | |
padding | RSAEncryptionPadding | |
Résultat | 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)); }