public Encrypt ( byte data, RSAEncryptionPadding padding ) : byte[] | ||
data | byte | |
padding | RSAEncryptionPadding | |
리턴 | byte[] |
public static void EncryptionKeyRequest(MinecraftClient client, IPacket _packet) { var packet = (EncryptionKeyRequestPacket)_packet; var random = RandomNumberGenerator.Create(); client.SharedSecret = new byte[16]; random.GetBytes(client.SharedSecret); // Generate a secure AES key if (packet.ServerId != "-") // Online mode { // Authenticate with minecraft.net var data = Encoding.ASCII.GetBytes(packet.ServerId) .Concat(client.SharedSecret) .Concat(packet.PublicKey).ToArray(); var hash = Cryptography.JavaHexDigest(data); var webClient = new WebClient(); string result = webClient.DownloadString("http://session.minecraft.net/game/joinserver.jsp?user="******"&sessionId=" + Uri.EscapeUriString(client.Session.SessionId) + "&serverId=" + Uri.EscapeUriString(hash)); if (result != "OK") LogProvider.Log("Unable to verify session: " + result); } var parser = new AsnKeyParser(packet.PublicKey); var key = parser.ParseRSAPublicKey(); // Encrypt shared secret and verification token var crypto = new RSACryptoServiceProvider(); crypto.ImportParameters(key); var encryptedSharedSecret = crypto.Encrypt(client.SharedSecret, false); var encryptedVerification = crypto.Encrypt(packet.VerificationToken, false); var response = new EncryptionKeyResponsePacket(encryptedSharedSecret, encryptedVerification); client.SendPacket(response); }
static async Task MainAsync(string[] args) { var keyClient = new KeyVaultClient((authority, resource, scope) => { var adCredential = new ClientCredential(applicationId, applicationSecret); var authenticationContext = new AuthenticationContext(authority, null); return authenticationContext.AcquireToken(resource, adCredential).AccessToken; }); // Get the key details var keyIdentifier = "https://testvaultrahul.vault.azure.net/keys/rahulkey/0f653b06c1d94159bc7090596bbf7784"; var key = await keyClient.GetKeyAsync(keyIdentifier); var publicKey = Convert.ToBase64String(key.Key.N); using (var rsa = new RSACryptoServiceProvider()) { var p = new RSAParameters() { Modulus = key.Key.N, Exponent = key.Key.E }; rsa.ImportParameters(p); var byteData = Encoding.Unicode.GetBytes(textToEncrypt); // Encrypt and Decrypt var encryptedText = rsa.Encrypt(byteData, true); var decryptedData = await keyClient.DecryptDataAsync(keyIdentifier, "RSA_OAEP", encryptedText); var decryptedText = Encoding.Unicode.GetString(decryptedData.Result); // Sign and Verify var hasher = new SHA256CryptoServiceProvider(); var digest = hasher.ComputeHash(byteData); var signature = await keyClient.SignAsync(keyIdentifier, "RS256", digest); var isVerified = rsa.VerifyHash(digest, "Sha256", signature.Result); } }
/// <summary> /// Genera _bytEncriptado: Es unByte[] con el contenido de llavePublica RSA encriptada (bytes) y contenido Encriptado Simetrico /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void btnAsimEncriptar_Click(object sender, EventArgs e) { byte[] _bytEncriptado = null; System.Security.Cryptography.CspParameters csp = new CspParameters(); csp.KeyContainerName = "pepe"; //Creamos una instancia del encritador publico RSACryptoServiceProvider _objEncriptadorPublicoRSA = new RSACryptoServiceProvider(csp); //Le asignamos la llave genarada _objEncriptadorPublicoRSA.FromXmlString(this.txtAsimLlavePublica.Text); if (this.chkSimetrica.Checked) { //Se declara la memoria para almacenar la llave utilizada por nuestro Rijndael personalizado byte[] _bytKey = (Rijndael.Create()).Key; //Se encripta el texto y se obtiene la llave que se utilizó para la encriptación byte[] _contenidoEncriptadoSimetrico = MiRijndael.Encriptar(this.txtAsimAEncriptar.Text, _bytKey); //Se encripta la llave con el algoritmo RSA byte[] llaveEncriptadaRSA = _objEncriptadorPublicoRSA.Encrypt(_bytKey, false); #region Se copia en un vector la llave encriptada y el contenido encriptado Simetrico (Rijndael) _bytEncriptado = new byte[llaveEncriptadaRSA.Length + _contenidoEncriptadoSimetrico.Length]; llaveEncriptadaRSA.CopyTo(_bytEncriptado, 0); _contenidoEncriptadoSimetrico.CopyTo(_bytEncriptado, llaveEncriptadaRSA.Length); #endregion } else { _bytEncriptado = _objEncriptadorPublicoRSA.Encrypt(System.Text.Encoding.UTF8.GetBytes(this.txtAsimAEncriptar.Text), false); } this.txtAsimEncriptado.Text = Convert.ToBase64String(_bytEncriptado); }
/// <summary> /// Start network encryption. Automatically called by Login() if the server requests encryption. /// </summary> /// <returns>True if encryption was successful</returns> private bool StartEncryption(string uuid, string sessionID, byte[] token, string serverIDhash, byte[] serverKey) { System.Security.Cryptography.RSACryptoServiceProvider RSAService = CryptoHandler.DecodeRSAPublicKey(serverKey); byte[] secretKey = CryptoHandler.GenerateAESPrivateKey(); if (Settings.DebugMessages) { ConsoleIO.WriteLineFormatted("§8Crypto keys & hash generated."); } if (serverIDhash != "-") { Console.WriteLine("Checking Session..."); if (!ProtocolHandler.SessionCheck(uuid, sessionID, CryptoHandler.getServerHash(serverIDhash, serverKey, secretKey))) { handler.OnConnectionLost(ChatBot.DisconnectReason.LoginRejected, "Failed to check session."); return(false); } } //Encrypt the data byte[] key_enc = dataTypes.GetArray(RSAService.Encrypt(secretKey, false)); byte[] token_enc = dataTypes.GetArray(RSAService.Encrypt(token, false)); //Encryption Response packet SendPacket(0x01, dataTypes.ConcatBytes(key_enc, token_enc)); //Start client-side encryption socketWrapper.SwitchToEncrypted(secretKey); //Process the next packet int packetID = -1; List <byte> packetData = new List <byte>(); while (true) { ReadNextPacket(ref packetID, packetData); if (packetID == 0x00) //Login rejected { handler.OnConnectionLost(ChatBot.DisconnectReason.LoginRejected, ChatParser.ParseText(dataTypes.ReadNextString(packetData))); return(false); } else if (packetID == 0x02) //Login successful { login_phase = false; if (!pForge.CompleteForgeHandshake()) { return(false); } StartUpdating(); return(true); } else { HandlePacket(packetID, packetData); } } }
public override void HandlePacket(Proxy proxy) { // Interact with the remote server proxy.RemoteSharedKey = new byte[16]; RandomNumberGenerator random = RandomNumberGenerator.Create(); random.GetBytes(proxy.RemoteSharedKey); AsnKeyParser keyParser = new AsnKeyParser(PublicKey); var key = keyParser.ParseRSAPublicKey(); var cryptoService = new RSACryptoServiceProvider(); cryptoService.ImportParameters(key); byte[] encryptedSharedSecret = cryptoService.Encrypt(proxy.RemoteSharedKey, false); byte[] encryptedVerify = cryptoService.Encrypt(VerifyToken, false); // Construct an 0xFC packet to send the server proxy.RemoteEncryptionResponse = new byte[] { 0xFC } .Concat(DataUtility.CreateInt16((short)encryptedSharedSecret.Length)) .Concat(encryptedSharedSecret) .Concat(DataUtility.CreateInt16((short)encryptedVerify.Length)) .Concat(encryptedVerify).ToArray(); if (ServerId != "-") { // Generate session hash byte[] hashData = Encoding.ASCII.GetBytes(ServerId) .Concat(proxy.RemoteSharedKey) .Concat(PublicKey).ToArray(); var hash = Cryptography.JavaHexDigest(hashData); var webClient = new WebClient(); string result = webClient.DownloadString("http://session.minecraft.net/game/joinserver.jsp?user="******"&sessionId=" + Uri.EscapeUriString(proxy.Settings.UserSession) + "&serverId=" + Uri.EscapeUriString(hash)); if (result != "OK") Console.WriteLine("Warning: Unable to login as user " + proxy.Settings.Username + ", expect mixed results."); } // Interact with the local client var verifyToken = new byte[4]; var csp = new RNGCryptoServiceProvider(); csp.GetBytes(verifyToken); AsnKeyBuilder.AsnMessage encodedKey = AsnKeyBuilder.PublicKeyToX509(Proxy.ServerKey); // Construct an 0xFD to send the client byte[] localPacket = new[] { PacketId } .Concat(DataUtility.CreateString("-")) .Concat(DataUtility.CreateInt16((short)encodedKey.GetBytes().Length)) .Concat(encodedKey.GetBytes()) .Concat(DataUtility.CreateInt16((short)verifyToken.Length)) .Concat(verifyToken).ToArray(); proxy.LocalSocket.BeginSend(localPacket, 0, localPacket.Length, SocketFlags.None, null, null); base.HandlePacket(proxy); }
private bool StartEncryption(string uuid, string username, string sessionID, byte[] token, string serverIDhash, byte[] serverKey) { System.Security.Cryptography.RSACryptoServiceProvider RSAService = CryptoHandler.DecodeRSAPublicKey(serverKey); byte[] secretKey = CryptoHandler.GenerateAESPrivateKey(); if (Settings.DebugMessages) { ConsoleIO.WriteLineFormatted("§8Crypto keys & hash generated."); } if (serverIDhash != "-") { Console.WriteLine("Checking Session..."); if (!ProtocolHandler.SessionCheck(uuid, sessionID, CryptoHandler.getServerHash(serverIDhash, serverKey, secretKey))) { handler.OnConnectionLost(ChatBot.DisconnectReason.LoginRejected, "Failed to check session."); return(false); } } //Encrypt the data byte[] key_enc = RSAService.Encrypt(secretKey, false); byte[] token_enc = RSAService.Encrypt(token, false); byte[] keylen = BitConverter.GetBytes((short)key_enc.Length); byte[] tokenlen = BitConverter.GetBytes((short)token_enc.Length); Array.Reverse(keylen); Array.Reverse(tokenlen); //Building the packet byte[] data = new byte[5 + (short)key_enc.Length + (short)token_enc.Length]; data[0] = 0xFC; keylen.CopyTo(data, 1); key_enc.CopyTo(data, 3); tokenlen.CopyTo(data, 3 + (short)key_enc.Length); token_enc.CopyTo(data, 5 + (short)key_enc.Length); //Send it back Send(data); //Getting the next packet byte[] pid = new byte[1]; Receive(pid, 0, 1, SocketFlags.None); if (pid[0] == 0xFC) { readData(4); s = CryptoHandler.getAesStream(c.GetStream(), secretKey); encrypted = true; return(true); } else { ConsoleIO.WriteLineFormatted("§8Invalid response to StartEncryption packet"); return(false); } }
/// <summary> /// 由于RSA的rgb参数不能超过字符串长度为117,进行分截加密,获取公钥 /// </summary> /// <param name="str">The STR.</param> /// <returns></returns> public static string RSAEncrypt(string str, string publcikeypath) { string ls_str = string.Empty; string ls_temp = string.Empty; string ls_encrypt_str = string.Empty; string publickey; byte[] byte_encrypt; int ll_num = 0; ls_str = str; System.Text.Encoding utf8 = new System.Text.UTF8Encoding(); RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(); try { StreamReader reader = new StreamReader(publcikeypath); publickey = reader.ReadToEnd(); RSA.FromXmlString(publickey); } catch (Exception ex) { MessageBox.Show("加密文件没有在当前执行目录:" + ex.Message); return string.Empty; } if (ls_str == string.Empty || ls_str == "") return ls_encrypt_str; do { if (ls_str.Length > 100) { ls_temp = ls_str.Substring(0, 100); ls_str = ls_str.Substring(100); byte_encrypt = utf8.GetBytes(ls_temp); byte_encrypt = RSA.Encrypt(byte_encrypt, false); ls_temp = System.Convert.ToBase64String(byte_encrypt); ll_num = ll_num + 1; ls_encrypt_str = ls_encrypt_str + "<" + ll_num.ToString() + ">" + ls_temp + "</" + ll_num.ToString() + ">"; } else { ls_temp = ls_str; byte_encrypt = utf8.GetBytes(ls_temp); byte_encrypt = RSA.Encrypt(byte_encrypt, false); ls_temp = System.Convert.ToBase64String(byte_encrypt); ll_num = ll_num + 1; ls_encrypt_str = ls_encrypt_str + "<" + ll_num.ToString() + ">" + ls_temp + "</" + ll_num.ToString() + ">"; break; } } while (2 > 1); return ls_encrypt_str; }
/// <summary> /// Start network encryption. Automatically called by Login() if the server requests encryption. /// </summary> /// <returns>True if encryption was successful</returns> private bool StartEncryption(string uuid, string sessionID, byte[] token, string serverIDhash, byte[] serverKey) { System.Security.Cryptography.RSACryptoServiceProvider RSAService = CryptoHandler.DecodeRSAPublicKey(serverKey); byte[] secretKey = CryptoHandler.GenerateAESPrivateKey(); ConsoleIO.WriteLineFormatted("§8Crypto keys & hash generated."); if (serverIDhash != "-") { Console.WriteLine("Checking Session..."); if (!ProtocolHandler.SessionCheck(uuid, sessionID, CryptoHandler.getServerHash(serverIDhash, serverKey, secretKey))) { handler.OnConnectionLost(ChatBot.DisconnectReason.LoginRejected, "Failed to check session."); return(false); } } //Encrypt the data byte[] key_enc = RSAService.Encrypt(secretKey, false); byte[] token_enc = RSAService.Encrypt(token, false); byte[] key_len = BitConverter.GetBytes((short)key_enc.Length); Array.Reverse(key_len); byte[] token_len = BitConverter.GetBytes((short)token_enc.Length); Array.Reverse(token_len); //Encryption Response packet byte[] packet_id = getVarInt(0x01); byte[] encryption_response = concatBytes(packet_id, key_len, key_enc, token_len, token_enc); byte[] encryption_response_tosend = concatBytes(getVarInt(encryption_response.Length), encryption_response); Send(encryption_response_tosend); //Start client-side encryption s = CryptoHandler.getAesStream(c.GetStream(), secretKey, this); encrypted = true; //Read and skip the next packet int received_packet_size = readNextVarInt(); int received_packet_id = readNextVarInt(); bool encryption_success = (received_packet_id == 0x02); if (received_packet_id == 0) { handler.OnConnectionLost(ChatBot.DisconnectReason.LoginRejected, ChatParser.ParseText(readNextString())); } else { readData(received_packet_size - getVarInt(received_packet_id).Length); } if (encryption_success) { StartUpdating(); } return(encryption_success); }
public static NCryptoParms EncryptCode(string decData, string spKey) { NCryptoParms parms = new NCryptoParms(); ICryptoTransform encryptor; CryptoStream cStream; MemoryStream mStream = new MemoryStream(); try { // Generate a new RSA public/private key pair // This key will be used to signature the DES IV and Key. RSACryptoServiceProvider jRsa = new RSACryptoServiceProvider(); byte[] signature = jRsa.SignData(sign, new MD5CryptoServiceProvider()); parms.jpbkey = Convert.ToBase64String(Encoding.ASCII.GetBytes(jRsa.ToXmlString(false))); parms.jprkey = Convert.ToBase64String(Encoding.ASCII.GetBytes(jRsa.ToXmlString(true))); parms.signature = Convert.ToBase64String(signature); jRsa.Clear(); RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); rsa.FromXmlString( Encoding.ASCII.GetString(Convert.FromBase64String(spKey))); DESCryptoServiceProvider des = new DESCryptoServiceProvider(); des.GenerateIV(); des.GenerateKey(); parms.key = Convert.ToBase64String(rsa.Encrypt(des.Key, false)); parms.iv = Convert.ToBase64String(rsa.Encrypt(des.IV, false)); encryptor = des.CreateEncryptor(des.Key, des.IV); cStream = new CryptoStream(mStream, encryptor, CryptoStreamMode.Write); byte[] bytesIn = Encoding.ASCII.GetBytes(decData); cStream.Write(bytesIn, 0, bytesIn.Length); cStream.FlushFinalBlock(); cStream.Close(); byte[] bytesOut = mStream.ToArray(); mStream.Close(); parms.enc = Convert.ToBase64String(bytesOut); } catch { mStream.Close(); } return parms; }
public void DoEncryption() { // create a symmetric encryptor TripleDESCryptoServiceProvider TDES = new TripleDESCryptoServiceProvider (); // create IV and Key need for symmetric encryption TDES.GenerateIV(); TDES.GenerateKey(); // create an asymmetric encryptor RSACryptoServiceProvider RSA = new RSACryptoServiceProvider (); string AsymKeys = RSA.ToXmlString (true); // export the public and private keys to a file WriteKeyToFile(AsymKeys); // asymmetric encryption is good for // small data, hence, we use it to encrypted // IV and Key for symmetric encryption byte[] encryptedIV = RSA.Encrypt(TDES.IV, false); byte[] encryptedKey = RSA.Encrypt(TDES.Key, false); // convert the length of IV and Key (e.g. number of bytes used) // into a byte, e.g. 4 to 0000 0100 // as default length of a Integer in .NET is 32, // the result byte length should be 4 bytes, i.e. 32/8 byte[] IVSize = BitConverter.GetBytes(encryptedIV.Length); byte[] keySize = BitConverter.GetBytes(encryptedKey.Length); // write out the IV length, the key length, // the encrypted iv, the encrypted key and the actual // date to a file using the symmetric encryptor. using(FileStream ostream = new FileStream("encrypted.enc", FileMode.Create)){ ostream.Write(IVSize, 0, IVSize.Length); ostream.Write(keySize, 0, keySize.Length); ostream.Write(encryptedIV, 0, encryptedIV.Length); ostream.Write(encryptedKey, 0, encryptedKey.Length); CryptoStream cstream = new CryptoStream(ostream, TDES.CreateEncryptor(), CryptoStreamMode.Write); // encrypt the data using the crypto stream EncryptFile(cstream); // close streams cstream.Close(); ostream.Close(); } }
/// <summary> /// Metoda za asimetrično kriptiranje /// </summary> /// <param name="file"></param> public void AsymetriycCrypt(string file) { RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); StreamReader streamReader = new StreamReader("javni_kljuc.txt"); string publicKey = streamReader.ReadToEnd(); rsa.FromXmlString(publicKey); streamReader.Close(); string record = file + ".rsa"; FileStream fstreamU = File.OpenRead(file), fstreamO = new FileStream(record, FileMode.Create, FileAccess.ReadWrite); BinaryWriter bw = new BinaryWriter(fstreamO); BinaryReader binReader = new BinaryReader(fstreamU); byte[] bytes = binReader.ReadBytes((int)fstreamU.Length); binReader.Close(); byte[] crypt = rsa.Encrypt(bytes, false); bw.Write(crypt); bw.Flush(); bw.Close(); bw.Dispose(); fstreamU.Close(); fstreamU.Dispose(); }
public void Run() { var _exportKey = new RSACryptoServiceProvider(); string publicKeyXML = _exportKey.ToXmlString(false); string privateKeyXML = _exportKey.ToXmlString(true); var ByteConverter = new UnicodeEncoding(); byte[] dataToEncrypt = ByteConverter.GetBytes("My Secret Data!"); byte[] encryptedData; using (var RSA = new RSACryptoServiceProvider()) { RSA.FromXmlString(publicKeyXML); encryptedData = RSA.Encrypt(dataToEncrypt, false); } byte[] decryptedData; using (var RSA = new RSACryptoServiceProvider()) { RSA.FromXmlString(privateKeyXML); decryptedData = RSA.Decrypt(encryptedData, false); } string decryptedString = ByteConverter.GetString(decryptedData); Console.WriteLine(decryptedString); // Displays: My Secret Data! } }
public UniRx.IObservable <bool> DumpAutoLogin(string filename) { return(Observable.Range(0, 1) .Select(_ => { if (context.accept_equip == null) { throw new System.MissingFieldException("context", "accept_equip"); } var body = new AutoLoginFile(); body.token = context.token; using (var rsa = new System.Security.Cryptography.RSACryptoServiceProvider()) { rsa.FromXmlString(context.public_key); var encrypted = rsa.Encrypt(context.token_time.ToString()); body.password = Convert.ToBase64String(encrypted); } var json = Newtonsoft.Json.JsonConvert.SerializeObject(body); var pbkdf = new Rfc2898DeriveBytes(json, SecureHelper.APP_SALT.GetByte(Convert.FromBase64String), 3483); body.signature = Convert.ToBase64String(pbkdf.GetBytes(256)); JsonDB db = new JsonDB("account"); var obj = JToken.FromObject(body); db.Put(filename, obj); return true; })); }
// 暗号化 public static byte[] Encript(String publicKey, byte[] src) { RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); rsa.FromXmlString(publicKey); return rsa.Encrypt(src, false); }
/// <summary> /// RSA 加密 /// </summary> /// <param name="sSource" >明文</param> /// <param name="sPublicKey" >公钥</param> public static string EncryptString(string sSource, string sPublicKey) { RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); string plaintext = sSource; rsa.FromXmlString(sPublicKey); byte[] cipherbytes; byte[] byteEn = rsa.Encrypt(Encoding.UTF8.GetBytes("a"), false); cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(plaintext), false); StringBuilder sbString = new StringBuilder(); for (int i = 0; i < cipherbytes.Length; i++) { sbString.Append(cipherbytes[i] + ","); } return sbString.ToString(); }
private static byte[] cifrar(string texto, string xmlKeys) { RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); rsa.FromXmlString(xmlKeys); byte[] datosEnc = rsa.Encrypt(Encoding.Default.GetBytes(texto), false); return datosEnc; }
public string EncryptData(string data) { try { //initialze the byte arrays to the public key information. byte[] PublicKey = _publicKey.ToArray(); byte[] Exponent = _exponent.ToArray(); //Create a new instance of RSACryptoServiceProvider. RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(); //Create a new instance of RSAParameters. RSAParameters RSAKeyInfo = new RSAParameters(); //Set RSAKeyInfo to the public key values. RSAKeyInfo.Modulus = PublicKey; RSAKeyInfo.Exponent = Exponent; //Import key parameters into RSA. RSA.ImportParameters(RSAKeyInfo); var dataBytes = ASCIIEncoding.ASCII.GetBytes(data); var encryptedBytes = RSA.Encrypt(dataBytes, false); var encryptedValue = BitConverter.ToString(encryptedBytes).Replace("-", "").ToLower(); return encryptedValue; } catch (CryptographicException e) { Console.WriteLine(e.Message); } return null; }
public override void Encrypt() { //RSA Rsa = new RSA(); //base.Component.Text = Rsa.encode(base.Component.tp.Text); try { UnicodeEncoding ByteConverter = new UnicodeEncoding(); byte[] encryptedData; using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider()) { RSA.ImportParameters(RSA.ExportParameters(false)); byte[] Data = ByteConverter.GetBytes(base.Component.tp.Text.ToString()); encryptedData = RSA.Encrypt(Data , false); } base.Component.Text = ByteConverter.GetString(encryptedData); } //Catch and display a CryptographicException //to the console. catch (CryptographicException e) { Console.WriteLine(e.Message); base.Component.Text = base.Component.tp.Text.ToString(); } }
public string EncryptString(string inputString, int dwKeySize, string xmlString) { RSACryptoServiceProvider rsaCryptoServiceProvider = new RSACryptoServiceProvider(dwKeySize); rsaCryptoServiceProvider.FromXmlString(xmlString); int keySize = dwKeySize / 8; byte[] bytes = Encoding.UTF32.GetBytes(inputString); int maxLength = keySize - 42; int dataLength = bytes.Length; int iterations = dataLength / maxLength; StringBuilder stringBuilder = new StringBuilder(); for (int i = 0; i <= iterations; i++) { byte[] tempBytes = new byte[ (dataLength - maxLength * i > maxLength) ? maxLength : dataLength - maxLength * i]; Buffer.BlockCopy(bytes, maxLength * i, tempBytes, 0, tempBytes.Length); byte[] encryptedBytes = rsaCryptoServiceProvider.Encrypt(tempBytes, true); Array.Reverse(encryptedBytes); stringBuilder.Append(Convert.ToBase64String(encryptedBytes)); } return stringBuilder.ToString(); }
public string EncryptData(string data2Encrypt, string strPublicKey) { RSACryptoServiceProvider provider = new RSACryptoServiceProvider(); provider.FromXmlString(strPublicKey); byte[] bytes = Encoding.UTF8.GetBytes(data2Encrypt); return Convert.ToBase64String(provider.Encrypt(bytes, false)); }
/// <summary> /// 加密 /// </summary> /// <param name="publicKey">公钥</param> /// <param name="data">要加密的字串</param> /// <returns></returns> public virtual string Encode(string publicKey, string data) { var rsa = new RSACryptoServiceProvider(); rsa.FromXmlString(publicKey); var cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(data), false); return Convert.ToBase64String(cipherbytes); }
private readonly static RSAParameters PrivateParams = Rsa.ExportParameters(true); //Complete key pairs. /// <summary> /// Encrypt an input string /// </summary> /// <param name="input">the input string to be encrpty</param> /// <param name="signature">the private key signature</param> /// <returns>A Base 64 encrypted string or empty if can't encrpyt</returns> public static string Encrpyt(string input, out byte[] signature) { signature = null; try { if (string.IsNullOrEmpty(input)) return string.Empty; var provider = new RSACryptoServiceProvider(new CspParameters { Flags = CspProviderFlags.UseMachineKeyStore }); provider.ImportParameters(PublicParams); var buffer = Encoding.ASCII.GetBytes(input); var encryptedbuffer = provider.Encrypt(buffer, false); var hash = new SHA1Managed(); provider.ImportParameters(PrivateParams); var hashedData = hash.ComputeHash(encryptedbuffer); signature = provider.SignHash(hashedData, CryptoConfig.MapNameToOID("SHA1")); var stringBuilder = new StringBuilder(); stringBuilder.Append(Convert.ToBase64String(encryptedbuffer)); return stringBuilder.ToString(); } catch { return string.Empty; } }
public string EncryptString( string inputString, int dwKeySize, string xmlString ) { // TODO: Add Proper Exception Handlers RSACryptoServiceProvider rsaCryptoServiceProvider = new RSACryptoServiceProvider( dwKeySize ); rsaCryptoServiceProvider.FromXmlString( xmlString ); int keySize = dwKeySize / 8; byte[] bytes = Encoding.UTF32.GetBytes( inputString ); // The hash function in use by the .NET RSACryptoServiceProvider here is SHA1 // int maxLength = ( keySize ) - 2 - ( 2 * SHA1.Create().ComputeHash( rawBytes ).Length ); int maxLength = keySize - 42; int dataLength = bytes.Length; int iterations = dataLength / maxLength; StringBuilder stringBuilder = new StringBuilder(); for( int i = 0; i <= iterations; i++ ) { byte[] tempBytes = new byte[ ( dataLength - maxLength * i > maxLength ) ? maxLength : dataLength - maxLength * i ]; Buffer.BlockCopy( bytes, maxLength * i, tempBytes, 0, tempBytes.Length ); byte[] encryptedBytes = rsaCryptoServiceProvider.Encrypt( tempBytes, true ); // Be aware the RSACryptoServiceProvider reverses the order of encrypted bytes after encryption and before decryption. // If you do not require compatibility with Microsoft Cryptographic API (CAPI) and/or other vendors. // Comment out the next line and the corresponding one in the DecryptString function. Array.Reverse( encryptedBytes ); // Why convert to base 64? // Because it is the largest power-of-two base printable using only ASCII characters stringBuilder.Append( Convert.ToBase64String( encryptedBytes ) ); } return stringBuilder.ToString(); }
public static void EncryptSomeText() { //Init keys GeneratePublicAndPrivateKeys(); UnicodeEncoding ByteConverter = new UnicodeEncoding(); byte[] dataToEncrypt = ByteConverter.GetBytes("My ultra secret message!"); byte[] encryptedData; using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider()) { RSA.FromXmlString(publicKeyXML); encryptedData = RSA.Encrypt(dataToEncrypt, false); } byte[] decryptedData; using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider()) { RSA.FromXmlString(privateKeyXML); decryptedData = RSA.Decrypt(encryptedData, false); } string decryptedString = ByteConverter.GetString(decryptedData); Console.WriteLine(decryptedString); }
public static string Text_Encryption(string text, int bits, string encryption_key) { StringBuilder result = new StringBuilder(""); try { RSACryptoServiceProvider rsacsp = new RSACryptoServiceProvider(bits); rsacsp.FromXmlString(encryption_key); int key = bits / 8; Byte[] bites = Encoding.UTF32.GetBytes(text); int max_length = key - 42; int data_length = bites.Length; int iterations = data_length / max_length; for (int i = 0; i <= iterations; i++) { int total_bytes = (data_length - max_length * i > max_length) ? max_length : data_length - max_length * i; Byte[] temp_bytes = new Byte[total_bytes]; Buffer.BlockCopy(bites, max_length * i, temp_bytes, 0, temp_bytes.Length); Byte[] encrypted_bytes = rsacsp.Encrypt(temp_bytes, true); Array.Reverse(encrypted_bytes); result.Append(Convert.ToBase64String(encrypted_bytes)); } } catch (Exception e) { result.Append("<Error>" + e.Message + "</Error>"); } return result.ToString(); }
public static Boolean Test(int keySize) { Boolean bRes = true; Byte[] abPlain = { 0, 1, 2, 3, 4, 5, 6, 7 }; Byte[] abCipher = null; int kl = keySize; try { using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(kl)) { abCipher = rsa.Encrypt(abPlain); Log.Comment("Cipher is : "); PrintByteArray(abCipher); abCipher = rsa.Decrypt(abCipher); } Log.Comment("Decrypted plaintext is : "); PrintByteArray(abCipher); if (!Compare(abPlain, abCipher)) { bRes = false; Log.Comment("Failed to decrypt to the original plaintext"); } } catch (Exception e) { Log.Comment("Exception ocured :\n" + e.ToString()); bRes = false; } return bRes; }
public static string Encrypt(string data) { try { var rsa = new RSACryptoServiceProvider(); rsa.FromXmlString(_publicKey); var dataToEncrypt = _encoder.GetBytes(data); var encryptedByteArray = rsa.Encrypt(dataToEncrypt, false).ToArray(); var length = encryptedByteArray.Count(); var item = 0; var sb = new StringBuilder(); foreach (var x in encryptedByteArray) { item++; sb.Append(x); if (item < length) sb.Append(","); } return sb.ToString(); } catch (Exception) { throw new RSAException(); } }
public string RSAEncrypt(string xmlPublicKey, byte[] EncryptString) { System.Security.Cryptography.RSACryptoServiceProvider rSACryptoServiceProvider = new System.Security.Cryptography.RSACryptoServiceProvider(); rSACryptoServiceProvider.FromXmlString(xmlPublicKey); byte[] inArray = rSACryptoServiceProvider.Encrypt(EncryptString, false); return(System.Convert.ToBase64String(inArray)); }
static public byte[] RSAEncrypt(int bits, byte[] dataToEncrypt, RSAParameters rsaKeyInfo, bool doOAEPPadding) { try { byte[] encryptedData; //Create a new instance of RSACryptoServiceProvider. using (var rsa = new RSACryptoServiceProvider(bits)) { //Import the RSA Key information. This only needs //toinclude the public key information. rsa.ImportParameters(rsaKeyInfo); var rsaExportParameters = rsa.ExportParameters(true); var rsaFormatter = new RSAPKCS1SignatureFormatter(rsa); rsaFormatter.SetHashAlgorithm("SHA256"); //Encrypt the passed byte array and specify OAEP padding. //OAEP padding is only available on Microsoft Windows XP or //later. encryptedData = rsa.Encrypt(dataToEncrypt, doOAEPPadding); } return encryptedData; } //Catch and display a CryptographicException //to the console. catch (CryptographicException e) { Console.WriteLine(e.Message); return null; } }
static public byte[] RSAEncrypt(byte[] DataToEncrypt, RSAParameters RSAKeyInfo, bool DoOAEPPadding) { try { byte[] encryptedData; //Create a new instance of RSACryptoServiceProvider. using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider()) { //Import the RSA Key information. This only needs //toinclude the public key information. RSA.ImportParameters(RSAKeyInfo); //Encrypt the passed byte array and specify OAEP padding. //OAEP padding is only available on Microsoft Windows XP or //later. encryptedData = RSA.Encrypt(DataToEncrypt, DoOAEPPadding); } return encryptedData; } //Catch and display a CryptographicException //to the console. catch (CryptographicException e) { Console.WriteLine(e.Message); return null; } }
//static RSACryptoServiceProvider RSA; //public static void ExportParameters() //{ // var publicKey = RSA.ExportParameters(false); // // +Exponent { byte[3]} // //+Modulus { byte[256]} //} public async Task<byte[]> Encrypt(byte[] Exponent, byte[] Modulus) { // https://sites.google.com/a/jsc-solutions.net/backlog/knowledge-base/2015/201503/20150323 // encrypted state sharing. // what about import? // http://bouncy-castle.1462172.n4.nabble.com/Interoperability-issue-with-SunJCE-OAEP-td4656157.html // http://www.w3.org/TR/WebCryptoAPI/#rsa-oaep // RSA/ECB/OAEPWithSHA-1AndMGF1Padding // X:\jsc.svn\examples\java\hybrid\JVMCLRCryptoKeyExport\JVMCLRCryptoKeyExport\Program.cs //var n = new RSACryptoServiceProvider(2048); var n = new RSACryptoServiceProvider(); // can we import in java android? n.ImportParameters( new RSAParameters { Exponent = Exponent, Modulus = Modulus } ); // http://stackoverflow.com/questions/9839274/rsa-encryption-by-supplying-modulus-and-exponent var value = n.Encrypt( Encoding.UTF8.GetBytes("hello from server"), fOAEP: true ); //Array.Reverse(value); return value; }
public byte[] Encrypt(byte[] Data, int Offset, int Length) { lock (rsa) { int ExpectedSize = (KeySize / 8) * (Length / EncChunkSize); using (MemoryStream stream = new MemoryStream(Data.Length + ExpectedSize)) { int LengthLeft = Length; if (PublicKey != null && PublicKey.Length > 0) { rsa.FromXmlString(PublicKey); } for (int i = Offset; i < Length; i += EncChunkSize) { int size = i + EncChunkSize < Length ? EncChunkSize : LengthLeft; byte[] temp = new byte[size]; Array.Copy(Data, i, temp, 0, size); byte[] encrypted = rsa.Encrypt(temp, PkcsPadding); stream.Write(encrypted, 0, encrypted.Length); if (LengthLeft >= EncChunkSize) { LengthLeft -= size; } } return(stream.ToArray()); } } }
/// <summary> /// 公钥加密 /// </summary> /// <param name="publichKey"></param> /// <param name="strData"></param> public static string EncryptRSA(string publicKey, string strData) { RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); rsa.FromXmlString(publicKey); byte[] dataRSAed = rsa.Encrypt(Encoding.UTF8.GetBytes(strData), false); return CommonHelper.ByteArrayToString(dataRSAed); }
public string RSAEncrypt(string xmlPublicKey, byte[] EncryptString) { RSACryptoServiceProvider provider1 = new RSACryptoServiceProvider(); provider1.FromXmlString(xmlPublicKey); byte[] buffer1 = provider1.Encrypt(EncryptString, false); return Convert.ToBase64String(buffer1); }
/// <summary> /// 公開鍵を使って文字列を暗号化する /// </summary> /// <param name="str">暗号化する文字列</param> /// <returns>暗号化された文字列</returns> public static string ClientEncrypt(string str) { try { //RSACryptoServiceProviderオブジェクトの作成 var rsa = new System.Security.Cryptography.RSACryptoServiceProvider(KeySize); //公開鍵を指定 rsa.FromXmlString(clientPublicKey); //暗号化する文字列をバイト配列に byte[] data = System.Text.Encoding.UTF8.GetBytes(str); // データサイズのチェック if (data.Length > rsa.KeySize / 8 - 11) { throw new Exception(); } //暗号化する //(XP以降の場合のみ2項目にTrueを指定し、OAEPパディングを使用できる) // RSACryptoServiceProvider.KeySize プロパティで取得できるキーサイズが1024ビットだとすると、暗号化されるデータの最大長は、 1024/8-11=117バイト となります。 byte[] encryptedData = rsa.Encrypt(data, false); //Base64で結果を文字列に変換 return(System.Convert.ToBase64String(encryptedData)); } catch (Exception) { } return(null); }
protected void btnEncrypt_Click(object sender, EventArgs e) { try { string dataToEncrypt = "revathis"; // byte[] inputData = null; byte[] encryptedData; // inputData= Convert.ToByte(dataToEncrypt); using (RSACryptoServiceProvider rsaServiceProvider = new RSACryptoServiceProvider()) { // dataToEncrypt //inputData = rsaServiceProvider. encryptedData= rsaServiceProvider.Encrypt(Encoding.ASCII.GetBytes(dataToEncrypt), false); Response.Write("Encrypted Data: "); foreach (byte byteItem in encryptedData) { Response.Write(byteItem); } } } catch (Exception) { throw; } }
public static string RSAEncrypt(string source, string xmlKey) { using (var rsa = new RSACryptoServiceProvider(1024)) { rsa.FromXmlString(xmlKey); var encrypted = rsa.Encrypt(Encoding.UTF8.GetBytes(source), false); return BytesToHex(encrypted); } }
static void Main(string[] args) { byte[] key = Encoding.UTF8.GetBytes("fade3390ab9d49c88f2e0e69ed6e40af"); System.Security.Cryptography.RSACryptoServiceProvider RSACryp = null; RSACryp = GetPublicKey(); byte[] bytesEncrypted = RSACryp.Encrypt(key, false); var str = Convert.ToBase64String(bytesEncrypted); }
public string RSAEncrypt(string xmlPublicKey, string m_strEncryptString) { System.Security.Cryptography.RSACryptoServiceProvider rSACryptoServiceProvider = new System.Security.Cryptography.RSACryptoServiceProvider(); rSACryptoServiceProvider.FromXmlString(xmlPublicKey); byte[] bytes = new System.Text.UnicodeEncoding().GetBytes(m_strEncryptString); byte[] inArray = rSACryptoServiceProvider.Encrypt(bytes, false); return(System.Convert.ToBase64String(inArray)); }
/// <summary> /// Encrypt data by public key. /// </summary> /// <param name="dataBytes">Need to encrypt data</param> /// <param name="fOEAP"></param> /// <returns></returns> public byte[] EncryptByPublicKey(byte[] dataBytes, bool fOEAP) { if (PublicRsa is null) { throw new ArgumentException("public key can not null"); } return(PublicRsa.Encrypt(dataBytes, fOEAP)); }
/// <summary> /// 公開鍵を使って文字列を暗号化する /// </summary> /// <param name="str">暗号化する文字列</param> /// <param name="publicKey">暗号化に使用する公開鍵(XML形式)</param> /// <returns>暗号化された文字列</returns> public static string Encrypt(string str, string publicKey) { System.Security.Cryptography.RSACryptoServiceProvider rsa = new System.Security.Cryptography.RSACryptoServiceProvider(); rsa.FromXmlString(publicKey); byte[] data = System.Text.Encoding.UTF8.GetBytes(str); byte[] encryptedData = rsa.Encrypt(data, false); return(System.Convert.ToBase64String(encryptedData)); }
public string UseSystemRsaDataEncrypt(string needEncryptContent) { #region Use System Default Encrypt Mether Handler Data RSAParameters rsaDefineRap = ConvertPublicKeyToRsaInfo(); string modulus = Convert.ToBase64String(rsaDefineRap.Modulus); string exponent = Convert.ToBase64String(rsaDefineRap.Exponent); string publickey = @"<RSAKeyValue><Modulus>" + modulus + "</Modulus><Exponent>" + exponent + "</Exponent></RSAKeyValue>"; RSACryptoServiceProvider rsaCrypt = new System.Security.Cryptography.RSACryptoServiceProvider(); rsaCrypt.FromXmlString(publickey); byte[] contentBytes = System.Text.Encoding.UTF8.GetBytes(needEncryptContent); int maxBlockSize = rsaCrypt.KeySize / 8 - 11; if (contentBytes.Length <= maxBlockSize) { return(Convert.ToBase64String(rsaCrypt.Encrypt(contentBytes, false))); } using (MemoryStream PlaiStream = new MemoryStream(contentBytes)) using (MemoryStream CrypStream = new MemoryStream()) { Byte[] Buffer = new Byte[maxBlockSize]; int BlockSize = PlaiStream.Read(Buffer, 0, maxBlockSize); while (BlockSize > 0) { #region Merge Spilt More Part About Rsa Encrypt String Byte[] ToEncrypt = new Byte[BlockSize]; Array.Copy(Buffer, 0, ToEncrypt, 0, BlockSize); Byte[] Cryptograph = DataEncryptWithRsa(ToEncrypt); CrypStream.Write(Cryptograph, 0, Cryptograph.Length); BlockSize = PlaiStream.Read(Buffer, 0, maxBlockSize); #endregion } byte[] encryBytes = rsaCrypt.Encrypt(System.Text.Encoding.UTF8.GetBytes("Hello World"), false); return(Convert.ToBase64String(encryBytes)); } #endregion }
/// <summary> /// RSA加密数据 /// </summary> /// <param name="express">要加密数据</param> /// <param name="KeyContainerName">密匙容器的名称</param> /// <returns></returns> public static string RSAEncryption(string express, string KeyContainerName = null) { System.Security.Cryptography.CspParameters param = new System.Security.Cryptography.CspParameters(); param.KeyContainerName = KeyContainerName ?? "default"; //密匙容器的名称,保持加密解密一致才能解密成功 using (System.Security.Cryptography.RSACryptoServiceProvider rsa = new System.Security.Cryptography.RSACryptoServiceProvider(param)) { byte[] plaindata = System.Text.Encoding.ASCII.GetBytes(express); //将要加密的字符串转换为字节数组 byte[] encryptdata = rsa.Encrypt(plaindata, false); //将加密后的字节数据转换为新的加密字节数组 return(Convert.ToBase64String(encryptdata)); //将加密后的字节数组转换为字符串 } }
public static string encrypt(string elementToEncrypt, string pathPrivateKey) { string pem = System.IO.File.ReadAllText(pathPrivateKey); byte[] Buffer = getBytesFromPEMFile(pem, "PUBLIC KEY"); System.Security.Cryptography.RSACryptoServiceProvider rsa = new System.Security.Cryptography.RSACryptoServiceProvider(); System.Security.Cryptography.RSAParameters rsaParam = rsa.ExportParameters(false); rsaParam.Modulus = Buffer; rsa.ImportParameters(rsaParam); byte[] text = Encoding.UTF8.GetBytes(elementToEncrypt); // Convert.FromBase64String(elementToEncrypt); byte[] encryptedMessageByte = rsa.Encrypt(text, false); return(Convert.ToBase64String(encryptedMessageByte)); }
/// <summary> /// 公開鍵を使って暗号化する /// </summary> /// <param name="str">暗号化するデータ</param> /// <returns>暗号化されたデータ</returns> public static byte[] EncryptBigData(byte[] targetData) { try { //RSACryptoServiceProviderオブジェクトの作成 var rsa = new System.Security.Cryptography.RSACryptoServiceProvider(KeySize); //公開鍵を指定 rsa.FromXmlString(publicKey); int blockNumber = targetData.Length; blockNumber /= rsa.KeySize / 8 - 11; if (targetData.Length % (rsa.KeySize / 8 - 11) != 0) { blockNumber++; } int totalSize = blockNumber * (rsa.KeySize / 8); byte[] resultData = new byte[totalSize]; for (int index = 0; index < blockNumber; index++) { //暗号化する //(XP以降の場合のみ2項目にTrueを指定し、OAEPパディングを使用できる) // RSACryptoServiceProvider.KeySize プロパティで取得できるキーサイズが1024ビットだとすると、暗号化されるデータの最大長は、 1024/8-11=117バイト となります。 int tempSize = rsa.KeySize / 8 - 11; if (targetData.Length - index * tempSize < tempSize) { tempSize = targetData.Length - index * tempSize; } byte[] tempData = new byte[tempSize]; Buffer.BlockCopy(targetData, index * (rsa.KeySize / 8 - 11), tempData, 0, tempSize); byte[] encryptedData = rsa.Encrypt(tempData, false); Buffer.BlockCopy(encryptedData, 0, resultData, index * (rsa.KeySize / 8), encryptedData.Length); } return(resultData); } catch (Exception) { } return(null); }
public void RSA_SendString(String _TxData) { //Pad the string length with whitespace to make a size evenly divisible into blocks: int toAdd = _TxData.Length % BlockSize; for (int i = 0; i < toAdd; i++) { _TxData = _TxData.Insert(_TxData.Length, " "); } //Figure out how many blocks need to be transmitted: int numBlocks = _TxData.Length / BlockSize; //Start the message transmit: m_CommStack.StartEncryptedMessage(numBlocks); //Encrypt the blocks and dump into the output stream: for (int i = 0; i < numBlocks; i++) { char[] temp = _TxData.ToCharArray(i * BlockSize, BlockSize); byte[] bytes = new byte[BlockSize]; int j = 0; foreach (char c in temp) { bytes[j++] = Convert.ToByte(c); } byte[] encrypted = m_RSAEncryptSvc.Encrypt(bytes, false); //Transmit the encrypted block. m_CommStack.TransmitEncryptedBlock(BlockSize, encrypted); } //Transmit end encrypted message m_CommStack.EndEncryptedMessage(); }
public string Encrypt(string publicKey, string plainText) { System.Security.Cryptography.CspParameters cspParams = null; System.Security.Cryptography.RSACryptoServiceProvider rsaProvider = null; byte[] plainBytes = null; byte[] encryptedBytes = null; string result = ""; try { cspParams = new System.Security.Cryptography.CspParameters(); cspParams.ProviderType = 1; rsaProvider = new System.Security.Cryptography.RSACryptoServiceProvider(cspParams); rsaProvider.FromXmlString(publicKey); plainBytes = System.Text.Encoding.UTF8.GetBytes(plainText); encryptedBytes = rsaProvider.Encrypt(plainBytes, false); result = Convert.ToBase64String(encryptedBytes); } catch (Exception ex) { Log(ex.Message); } return(result); }