Decrypt() public method

public Decrypt ( byte data, RSAEncryptionPadding padding ) : byte[]
data byte
padding RSAEncryptionPadding
return byte[]
        public RecordType AddRecord(string OName, string OPoint)
        {
            byte[] Name = Convert.FromBase64String(OName);
            byte[] Point = Convert.FromBase64String(OPoint);
            StreamReader sr = new StreamReader(Server.MapPath("App_Data\rightcolor_private.xml"));
            string ALL = sr.ReadToEnd();
            sr.Close();

            RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(2048);
            RSA.FromXmlString(ALL);

            string RealName = System.Text.Encoding.UTF8.GetString(RSA.Decrypt(Name, false));
            long RealPoint = long.Parse(System.Text.Encoding.UTF8.GetString(RSA.Decrypt(Point, false)));

            RecordType AllowInsert = RecordType.None;
            long ForeverMax = (from inc in Data.Records orderby inc.Point descending select inc.Point).Skip(9).Take(1).SingleOrDefault();
            if (RealPoint > ForeverMax)
            {
                AllowInsert = RecordType.Forever;
                goto Insert;
            }
            long MonthMax = (from inc in Data.Records where inc.AddDate > DateTime.Now.AddMonths(-1) orderby inc.Point descending select inc.Point).Skip(9).Take(1).SingleOrDefault();
            if (RealPoint > MonthMax)
            {
                AllowInsert = RecordType.Month;
                goto Insert;
            }
            long WeekMax = (from inc in Data.Records where inc.AddDate > DateTime.Now.AddDays(-7) orderby inc.Point descending select inc.Point).Skip(9).Take(1).SingleOrDefault();
            if (RealPoint > WeekMax)
            {
                AllowInsert = RecordType.Week;
                goto Insert;
            }
            long DayMax = (from inc in Data.Records where inc.AddDate > DateTime.Now.AddDays(-1) orderby inc.Point descending select inc.Point).Skip(9).Take(1).SingleOrDefault();
            if (RealPoint > DayMax)
            {
                AllowInsert = RecordType.Day;
            }
            Insert:
            if (AllowInsert != RecordType.None)
            {
                Record NewRecord = new Record();
                NewRecord.Person = RealName;
                NewRecord.Point = RealPoint;
                NewRecord.AddDate = DateTime.Now;
                Data.Records.InsertOnSubmit(NewRecord);
                Data.SubmitChanges();
            }
            return AllowInsert;
        }
Example #2
0
        public UsrNamePassword(string encUsername, string encPassword)
        {
            CspParameters cspParams = new CspParameters();
            cspParams.Flags = CspProviderFlags.UseMachineKeyStore;
            var myRSA = new RSACryptoServiceProvider(cspParams);

            if (HttpContext.Current.Session == null || HttpContext.Current.Session[CfcWebService.CertificateKey] == null)
                this.UserName = this.Password = null;
            else
            {
                myRSA.FromXmlString((string)HttpContext.Current.Session[CfcWebService.CertificateKey]);
                this.UserName = Encoding.UTF8.GetString(myRSA.Decrypt(CfcWebService.ToHexByte(encUsername), false));
                this.Password = Encoding.UTF8.GetString(myRSA.Decrypt(CfcWebService.ToHexByte(encPassword), false));
            }
        }
Example #3
0
        public byte[] Decrypt(byte[] key, byte[] cypher)
        {
            if (key == null || key.Length == 0) return new byte[0];
            if (cypher == null || cypher.Length == 0) return new byte[0];

            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(RSA_KEY_SIZE))
            {
                rsa.ImportCspBlob(key);
                using (MemoryStream ms = new MemoryStream(cypher.Length))
                {
                    int pos = 0;
                    byte[] buffer = new byte[DECRYPT_BUFFER_SIZE];
                    int copyLength = buffer.Length;
                    while (true)
                    {
                        Array.Copy(cypher, pos, buffer, 0, copyLength);
                        pos += copyLength;
                        var plaintText = rsa.Decrypt(buffer, false);
                        ms.Write(plaintText, 0, plaintText.Length);
                        Array.Clear(plaintText, 0, plaintText.Length);
                        Array.Clear(buffer, 0, copyLength);
                        if (pos >= cypher.Length) break;
                    }
                    return ms.ToArray();
                }
            }
        }
Example #4
0
        static void Main(string[] args)
        {
            var rsa = new RSACryptoServiceProvider();
            _publicKey = rsa.ExportParameters(false);
            _privateKey = rsa.ExportParameters(true);
            Console.WriteLine("\n********* Public key info *******************");
            printInfo(_publicKey);
            Console.WriteLine("\n********* Private key info *******************");
            printInfo(_privateKey);

            var message = "I am a plain text message";
            var messageContent = Encoding.UTF8.GetBytes(message.ToCharArray());

            Console.WriteLine("**** Plain Message ****");
            Console.WriteLine(Encoding.UTF8.GetString(messageContent));

            var encrypter = new RSACryptoServiceProvider();
            encrypter.ImportParameters(_publicKey);
            var encryptedMessage = encrypter.Encrypt(messageContent, true);

            Console.WriteLine("**** Encrypted Message ****");
            Console.WriteLine(Convert.ToBase64String(encryptedMessage));

            var decrypter = new RSACryptoServiceProvider();
            decrypter.ImportParameters(_privateKey);
            var decryptedMessage = decrypter.Decrypt(encryptedMessage, true);

            Console.WriteLine("**** Decrypted Message ****");
            Console.WriteLine(Encoding.UTF8.GetString(decryptedMessage));
        }
Example #5
0
        public static string Decrypt(byte [] data)
        {
            if (data == null) 
                return null;

            using (RSACryptoServiceProvider provider = new RSACryptoServiceProvider(Container))
            {
                byte[] buf = null;

                try
                {
                    buf = provider.Decrypt(
                        data,
                        false
                    );
                }

                catch { }

                if (buf == null)
                    return null;
                else
                    return Encoding.UTF8.GetString(buf);
            }
        }
Example #6
0
        public byte[] Decrypt(byte[] DataToDecrypt, RSAParameters RSAKeyInfo, bool DoOAEPPadding)
        {
            RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
                RSA.ImportParameters(RSAKeyInfo);

                return RSA.Decrypt(DataToDecrypt, DoOAEPPadding);
        }
        static void Main()
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(File.ReadAllText("public.key"));

            if (!rsa.PublicOnly)
                Console.WriteLine("Otworzyłeś klucz prywatny!");

            //szyfracja kluczem prywatnym lub publicznym
            byte[] encrypt = rsa.Encrypt(Encoding.UTF8.GetBytes("Test"), false);

            if (!rsa.PublicOnly)
            {
                byte[] decrypt = rsa.Decrypt(encrypt, false);

                string result = Encoding.UTF8.GetString(decrypt);

                Console.WriteLine(result);

            }
            else{
                File.WriteAllBytes("out.f", encrypt);
                Console.WriteLine("Deszyfracja jest niemożliwa gdyź posiadasz tylko klucz publiczny");
                Console.WriteLine("Wynik końcowy został zapisany do pliku \"out.f\"");
            }
            Console.ReadKey();
        }
        public DigitalSignatureVerificationResult VerifySignature(DigitalSignatureVerificationArguments arguments)
        {
            var res = new DigitalSignatureVerificationResult();
            try
            {
                var rsaProviderSender = new RSACryptoServiceProvider();
                rsaProviderSender.FromXmlString(arguments.PublicKeyForSignatureVerification.ToString());
                var deformatter = new RSAPKCS1SignatureDeformatter(rsaProviderSender);
                deformatter.SetHashAlgorithm(_hashingService.HashAlgorithmCode());
                var hashResult = _hashingService.Hash(arguments.CipherText);
                res.SignaturesMatch = deformatter.VerifySignature(hashResult.HashedBytes, arguments.Signature);
                if (res.SignaturesMatch)
                {
                    var rsaProviderReceiver = new RSACryptoServiceProvider();
                    rsaProviderReceiver.FromXmlString(arguments.FullKeyForDecryption.ToString());
                    var decryptedBytes = rsaProviderReceiver.Decrypt(Convert.FromBase64String(arguments.CipherText), false);
                    res.DecodedText = Encoding.UTF8.GetString(decryptedBytes);
                }

                res.Success = true;
            }
            catch (Exception ex)
            {
                res.ExceptionMessage = ex.Message;
            }

            return res;
        }
Example #9
0
 /// <summary>
 /// 从base64字符串解密
 /// </summary>
 /// <param name="privateKey"></param>
 /// <param name="content"></param>
 /// <param name="size"></param>
 /// <returns></returns>
 public static string DecryptFromBase64(RSAParameters privateKey, string content, int size = 1024)
 {
     var rsa = new RSACryptoServiceProvider(size);
     rsa.ImportParameters(privateKey);
     var cipherbytes = rsa.Decrypt(content.Base64ToBytes(), false);
     return cipherbytes.FromUtf8Bytes();
 }
        /// <summary>
        /// Metoda za asimetrično dekriptiranje
        /// </summary>
        /// <param name="file"></param>
        public void AsymetriycDecrypt(string file)
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            RSACryptoServiceProvider.UseMachineKeyStore = false;
            StreamReader streamReader = new StreamReader("privatni_kljuc.txt");
            string privateKey = streamReader.ReadToEnd();
            rsa.FromXmlString(privateKey);
            streamReader.Close();

            int indexEcb = file.LastIndexOf(".rsa");
            string zapis = file.Substring(0, indexEcb);

            FileStream fstreamU = File.OpenRead(file),
            fstreamO = new FileStream(zapis, FileMode.Create, FileAccess.ReadWrite);

            BinaryWriter bw = new BinaryWriter(fstreamO);
            BinaryReader binReader = new BinaryReader(fstreamU);
            byte[] bytes = binReader.ReadBytes((int)fstreamU.Length);

            binReader.Close();

            byte[] decrypt = rsa.Decrypt(bytes, false);
            bw.Write(decrypt);

            bw.Flush();
            bw.Close();
            bw.Dispose();

            fstreamU.Close();
            fstreamU.Dispose();
        }
        public static string Decrypt(this string stringToDecrypt, string key)
        {
            if (string.IsNullOrEmpty(stringToDecrypt))
            {
                throw new ArgumentException("An empty string value cannot be encrypted.");
            }

            if (string.IsNullOrEmpty(key))
            {
                throw new ArgumentException("Cannot decrypt using an empty key. Please supply a decryption key.");
            }

            //var cspp = new CspParameters { KeyContainerName = key };
            var cspp = new CspParameters { KeyContainerName = key, Flags = CspProviderFlags.UseMachineKeyStore };

            var rsa = new RSACryptoServiceProvider(cspp) { PersistKeyInCsp = true };

            var decryptArray = stringToDecrypt.Split(new[] { "-" }, StringSplitOptions.None);
            var decryptByteArray = Array.ConvertAll(decryptArray, (s => Convert.ToByte(byte.Parse(s, System.Globalization.NumberStyles.HexNumber))));


            byte[] bytes = rsa.Decrypt(decryptByteArray, true);

            string result = System.Text.Encoding.UTF8.GetString(bytes);

            return result;
        }
        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!        }
        }
Example #13
0
        // 複合化
        public static byte[] Decript(String privateKey, byte[] src)
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(privateKey);

            return rsa.Decrypt(src, false);
        }
Example #14
0
        // Decrypt method
        public string Decrypt( string b64String )
        {
            try
            {
                byte[] ciphertext = Convert.FromBase64String(b64String);

                CspParameters RSAParams = new CspParameters();
                RSAParams.Flags = CspProviderFlags.UseMachineKeyStore;
                //create new instance of  RSACryptoServiceProvider
                RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(RSAParams);

                //import public and private RSA parameters from Xml file
                //StreamReader reader = new StreamReader("PublicPrivateKey.xml");
                //string publicPrivateKeyXml = reader.ReadToEnd();
                //reader.Close();
                rsa.FromXmlString(this.publicPrivateKeyXml);

                //read ciphertext, decrypt it to plaintext
                byte[] plainbytes = rsa.Decrypt( ciphertext, false); //fOAEP needs high encryption pack
                return Encoding.ASCII.GetString(plainbytes) ;
            }
            catch ( CryptographicException cx )
            {
                throw new CryptographicException( cx.Message) ;
            }
        }
Example #15
0
        public static string Decrypt(string encryptedText)
        {
            StringBuilder stringBuilder = new StringBuilder();

            RSACryptoServiceProvider.UseMachineKeyStore = true;

            using (RSACryptoServiceProvider rsaProvider = new RSACryptoServiceProvider())
            {
                mojoEncryptionConfiguration config = mojoEncryptionConfiguration.GetConfig();
                if (config.RsaKey.Length == 0)
                {
                    log.Error("CryptoHelper.LoadRsaKey failed to load key from config, key was an empty string.");
                    throw new ArgumentException("CryptoHelper.LoadRsaKey failed to load key from config, key was an empty string.");
                }

                rsaProvider.FromXmlString(config.RsaKey);

                byte[] decryptedStr = rsaProvider.Decrypt(StringToByteArray(encryptedText.Trim()), false);

                for (int i = 0; i <= decryptedStr.Length - 1; i++)
                {
                    stringBuilder.Append(Convert.ToChar(decryptedStr[i]));
                }
            }

            return stringBuilder.ToString();
        }
Example #16
0
 public string RSADecrypt(string xmlPrivateKey, byte[] DecryptString)
 {
     System.Security.Cryptography.RSACryptoServiceProvider rSACryptoServiceProvider = new System.Security.Cryptography.RSACryptoServiceProvider();
     rSACryptoServiceProvider.FromXmlString(xmlPrivateKey);
     byte[] bytes = rSACryptoServiceProvider.Decrypt(DecryptString, false);
     return(new System.Text.UnicodeEncoding().GetString(bytes));
 }
Example #17
0
        /// <summary>
        /// decrypts a string with a key inside the xmlstring
        /// </summary>
        /// <param name="DataToDecrypt">data to decrypt</param>
        /// <param name="xml">xmlstring taken from an RSACryptoServiceProvider object</param>
        /// <returns>decrypted string</returns>
        public static string RSADecrypt(string DataToDecrypt, string xml)
        {
            try
            {
                byte[] decryptedData;
                //Create a new instance of RSACryptoServiceProvider.
                using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
                {
                    RSA.FromXmlString(xml);

                    //Decrypt the passed byte array and specify OAEP padding.
                    //OAEP padding is only available on Microsoft Windows XP or
                    //later.
                    decryptedData = RSA.Decrypt(Convert.FromBase64String(DataToDecrypt), false);
                }
                return Encoding.UTF8.GetString(decryptedData);
            }
            //Catch and display a CryptographicException
            //to the console.
            catch (CryptographicException e)
            {
                Console.WriteLine(e.ToString());

                return null;
            }
        }
Example #18
0
        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 byte[] DecryptRSA(byte[] data, byte[] key)
        {
            var csp     = new CspParameters();
            csp.Flags   = CspProviderFlags.UseMachineKeyStore;

            using (var rsa  = new RSACryptoServiceProvider(_dwSize, csp))
            using (var ms   = new MemoryStream())
            {
                //Create seed, create RSA blob, replace logic
                rsa.ImportCspBlob(key);

                for (int i = 0; i < data.Length; i += _chunkSize)
                {
                    int amount = Math.Min(_chunkSize, data.Length - i);
                    byte[] buffer = new byte[amount];

                    Buffer.BlockCopy(data, i, buffer, 0, amount);

                    byte[] decrypted = rsa.Decrypt(buffer, false);
                    ms.Write(decrypted, 0, decrypted.Length);
                }

                return ms.ToArray();
            }
        }
Example #20
0
        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);
        }
Example #21
0
        /// <summary>
        /// Decrypt a base 64 string hash
        /// </summary>
        /// <param name="hash">The encrypted hash</param>
        /// <param name="signature">the private key signature</param>
        /// <returns>If is valid return decrypt hash, else return empty string</returns>
        public static string Decrypt(string hash, byte[] signature)
        {
            if (!VerifyHash(hash, signature)) return string.Empty;
            try
            {
                var provider = new RSACryptoServiceProvider();
                provider.ImportParameters(PrivateParams);

                var encryptedbuffer = Convert.FromBase64String(hash);

                var decryptedbuffer = provider.Decrypt(encryptedbuffer, false);
                var arrayList = new ArrayList();

                arrayList.AddRange(decryptedbuffer);
                var converted = arrayList.ToArray(typeof(byte)) as byte[];

                if (converted != null) return Encoding.ASCII.GetString(converted);

                return string.Empty;
            }
            catch 
            {
                return string.Empty;
            }
        }
Example #22
0
 /// <summary>
 /// 解密
 /// </summary>
 /// <param name="privateKey">私钥</param>
 /// <param name="data">要解密的数据</param>
 /// <returns></returns>
 public virtual string Decode(string privateKey, string data)
 {
     var rsa = new RSACryptoServiceProvider();
     rsa.FromXmlString(privateKey);
     var cipherbytes = rsa.Decrypt(Convert.FromBase64String(data), false);
     return Encoding.UTF8.GetString(cipherbytes);
 }
Example #23
0
 public string RSADecrypt(string xmlPrivateKey, byte[] DecryptString)
 {
     RSACryptoServiceProvider provider1 = new RSACryptoServiceProvider();
     provider1.FromXmlString(xmlPrivateKey);
     byte[] buffer1 = provider1.Decrypt(DecryptString, false);
     return new UnicodeEncoding().GetString(buffer1);
 }
Example #24
0
        static void Main(string[] args)
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            string publicKeyXML = rsa.ToXmlString(false);
            string privateKeyXML = rsa.ToXmlString(true);

            UnicodeEncoding ByteConverter = new UnicodeEncoding();
            byte[] dataToEncrypt = ByteConverter.GetBytes("My secret data!");
            Console.WriteLine("Encrypting: {0}", ByteConverter.GetString(dataToEncrypt));

            byte[] encryptedData;
            using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
            {
                RSA.FromXmlString(publicKeyXML);
                encryptedData = RSA.Encrypt(dataToEncrypt, false);
            }

            Console.WriteLine("Encrypted data: {0}", ByteConverter.GetString(encryptedData));

            byte[] decryptedData;
            using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
            {
                RSA.FromXmlString(privateKeyXML);
                decryptedData = RSA.Decrypt(encryptedData, false);
            }

            string decryptedString = ByteConverter.GetString(decryptedData);
            Console.WriteLine("Decrypted data: {0}", decryptedString);

            Console.WriteLine("Press a key to exit");
            Console.ReadKey();
        }
        private static byte[] ExchangeKeys(string sesskey, Socket sock)
        {
            try
            {
                using(RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
                {
                    rsa.FromXmlString(sesskey);
                    var b = BitConverter.GetBytes(0);
                    Utilities.Receive_Exact(sock, b, 0, b.Length);
                    var len = BitConverter.ToInt32(b, 0);
                    if(len > 4000)
                        throw new ArgumentException("Buffer Overlflow in Encryption key exchange!");
                    byte[] sessionkey = new byte[len];

                    Utilities.Receive_Exact(sock, sessionkey, 0, len);
                    sessionkey = rsa.Decrypt(sessionkey, true);//decrypt the session key
                    //hash the key and send it back to prove that I received it correctly
                    byte[] sessionkeyhash = SHA256.Create().ComputeHash(sessionkey);
                    //send it back to the client
                    byte[] intBytes = BitConverter.GetBytes(sessionkeyhash.Length);
                    sock.Send(intBytes);
                    sock.Send(sessionkeyhash);

                    Debug.WriteLine("Key Exchange completed!");
                    return sessionkey;

                }
            } catch(Exception e)
            {
                Debug.WriteLine(e.Message);
                return null;
            }
        }
Example #26
0
        public static bool TryDecryptStream(Stream inputStream, Stream outputStream, Stream keyStream)
        {
            try
            {
                string keyXml;
                using (StreamReader keyStreamReader = new StreamReader(CloneStream(keyStream)))//Create new stream as to not dispose keyStream
                {
                    keyXml = keyStreamReader.ReadToEnd();
                }

                using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
                {
                    rsa.FromXmlString(keyXml);

                    var bytes = rsa.Decrypt(StreamUtility.GetBytes(inputStream), false);

                    outputStream.Write(bytes, 0, bytes.Length);
                    outputStream.Position = 0;
                }
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }
Example #27
0
        static public byte[] RSADecrypt(byte[] DataToDecrypt, RSAParameters RSAKeyInfo, bool DoOAEPPadding)
        {
            try
            {
                byte[] decryptedData;
                //Create a new instance of RSACryptoServiceProvider. 
                using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
                {
                    //Import the RSA Key information. This needs 
                    //to include the private key information.
                    RSA.ImportParameters(RSAKeyInfo);

                    //Decrypt the passed byte array and specify OAEP padding.   
                    //OAEP padding is only available on Microsoft Windows XP or 
                    //later.  
                    decryptedData = RSA.Decrypt(DataToDecrypt, DoOAEPPadding);
                }
                return decryptedData;
            }
            //Catch and display a CryptographicException   
            //to the console. 
            catch (CryptographicException e)
            {
                Console.WriteLine(e.ToString());
                return null;
            }

        }
 public static string DecryptData(byte[] data, string keyFile)
 {
     RSACryptoServiceProvider Algorithm = new RSACryptoServiceProvider();
     ReadKey(Algorithm, keyFile);
     byte[] ClearData = Algorithm.Decrypt(data, true);
     return Convert.ToString(Encoding.UTF8.GetString(ClearData));
 }
Example #29
0
        public static string Text_Decryption(string text, int bits, string encryption_key)
        {
            string result = String.Empty;
            ArrayList list = new ArrayList();

            try
            {
                RSACryptoServiceProvider rsacsp = new RSACryptoServiceProvider(bits);
                rsacsp.FromXmlString(encryption_key);
                int blockSizeBase64 = (bits / 8 % 3 != 0) ?  (((bits / 8) / 3) * 4) + 4 : ((bits / 8) / 3) * 4;
                int iterations = text.Length / blockSizeBase64;

                for (int i = 0; i < iterations; i++)
                {
                    Byte[] encrypted_bytes = Convert.FromBase64String(text.Substring(blockSizeBase64 * i, blockSizeBase64));
                    Array.Reverse(encrypted_bytes);
                    list.AddRange(rsacsp.Decrypt(encrypted_bytes, true));
                }

            }
            catch (Exception e)
            {
                result = "<Error>" + e.Message + "</Error>";
            }

            result = Encoding.UTF32.GetString((Byte[])list.ToArray(typeof(Byte)));

            return result;
        }
Example #30
0
        public byte[] Decrypt(byte[] Data, int Offset, int Length)
        {
            if (Length % DecChunkSize != 0)
            {
                throw new Exception("Invalid length");
            }

            using (MemoryStream stream = new MemoryStream(Data.Length))
            {
                int LengthLeft = Length;

                if (PrivateKey != null && PrivateKey.Length > 0)
                {
                    rsa.FromXmlString(PrivateKey);
                }

                for (int i = Offset; i < Length; i += DecChunkSize)
                {
                    byte[] temp = new byte[DecChunkSize];
                    Array.Copy(Data, i, temp, 0, DecChunkSize);
                    byte[] decrypted = rsa.Decrypt(temp, PkcsPadding);
                    stream.Write(decrypted, 0, decrypted.Length);

                    if (LengthLeft >= DecChunkSize)
                    {
                        LengthLeft -= DecChunkSize;
                    }
                }
                return(stream.ToArray());
            }
        }
Example #31
0
 public static string DecryptString(string inputString, int dwKeySize,
                              string xmlString)
 {
     // TODO: Add Proper Exception Handlers
     RSACryptoServiceProvider rsaCryptoServiceProvider
                              = new RSACryptoServiceProvider(dwKeySize);
     rsaCryptoServiceProvider.FromXmlString(xmlString);
     int base64BlockSize = ((dwKeySize / 8) % 3 != 0) ?
       (((dwKeySize / 8) / 3) * 4) + 4 : ((dwKeySize / 8) / 3) * 4;
     int iterations = inputString.Length / base64BlockSize;
     ArrayList arrayList = new ArrayList();
     for (int i = 0; i < iterations; i++)
     {
         byte[] encryptedBytes = Convert.FromBase64String(
              inputString.Substring(base64BlockSize * i, base64BlockSize));
         // 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
         // EncryptString function.
         Array.Reverse(encryptedBytes);
         arrayList.AddRange(rsaCryptoServiceProvider.Decrypt(
                             encryptedBytes, true));
     }
     return Encoding.UTF32.GetString(arrayList.ToArray(
                               Type.GetType("System.Byte")) as byte[]);
 }
Example #32
0
 /// <summary>
 /// Decrypts a string which was previously encrypted with the Encrypt method
 /// </summary>
 /// <param name="cipher">The encrypted byte array</param>
 /// <param name="privateKey">The private key used to decrypt the data</param>
 /// <returns>A byte array containing the decrypted value</returns>
 public static string Decrypt(string cipher, RSAParameters privateKey)
 {
     using (var rsa = new System.Security.Cryptography.RSACryptoServiceProvider())
     {
         //ImportParameters sets the keySize according to the size used to create the privateKey
         rsa.ImportParameters(privateKey);
         int base64BlockSize = ((rsa.KeySize / 8) % 3 != 0) ? (((rsa.KeySize / 8) / 3) * 4) + 4 : ((rsa.KeySize / 8) / 3) * 4;
         int iterations      = cipher.Length / base64BlockSize;
         //var arrayList = new ArrayList();
         var fullBytes = new byte[0];
         for (int i = 0; i < iterations; i++)
         {
             byte[] encryptedBytes = Convert.FromBase64String(cipher.Substring(base64BlockSize * i, base64BlockSize));
             // 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
             // EncryptString function.
             Array.Reverse(encryptedBytes);
             var bytes = rsa.Decrypt(encryptedBytes, true);
             var len   = fullBytes.Length;
             Array.Resize(ref fullBytes, len + bytes.Length);
             Array.Copy(bytes, 0, fullBytes, len, bytes.Length);
             //arrayList.AddRange(bytes);
         }
         return(Encoding.UTF32.GetString(fullBytes));
         //return Encoding.UTF32.GetString(arrayList.ToArray(Type.GetType("System.Byte")) as byte[]);
     }
 }
Example #33
0
 /// <summary>
 /// Decrypt cipher by private key.
 /// </summary>
 /// <param name="dataBytes">Need to decrypt the data</param>
 /// <param name="fOEAP"></param>
 /// <returns></returns>
 public byte[] DecryptByPrivateKey(byte[] dataBytes, bool fOEAP)
 {
     if (PrivateRsa is null)
     {
         throw new ArgumentException("private key can not null");
     }
     return(PrivateRsa.Decrypt(dataBytes, fOEAP));
 }
Example #34
0
 public string RSADecrypt(string xmlPrivateKey, string m_strDecryptString)
 {
     System.Security.Cryptography.RSACryptoServiceProvider rSACryptoServiceProvider = new System.Security.Cryptography.RSACryptoServiceProvider();
     rSACryptoServiceProvider.FromXmlString(xmlPrivateKey);
     byte[] rgb   = System.Convert.FromBase64String(m_strDecryptString);
     byte[] bytes = rSACryptoServiceProvider.Decrypt(rgb, false);
     return(new System.Text.UnicodeEncoding().GetString(bytes));
 }
Example #35
0
 /// <summary>
 /// RSA解密数据
 /// </summary>
 /// <param name="ciphertext">要解密数据</param>
 /// <param name="KeyContainerName">密匙容器的名称</param>
 /// <returns></returns>
 public static string RSADecrypt(string ciphertext, 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[] encryptdata = Convert.FromBase64String(ciphertext);
         byte[] decryptdata = rsa.Decrypt(encryptdata, false);
         return(System.Text.Encoding.ASCII.GetString(decryptdata));
     }
 }
Example #36
0
        public static string decrypt(string elementToDesencrypt, string pathPublicKey)
        {
            string pem = System.IO.File.ReadAllText(pathPublicKey);

            byte[] Buffer = getBytesFromPEMFile(pem, "RSA PRIVATE 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(elementToDesencrypt); //Convert.FromBase64String(elementToDesencrypt)
            byte[] encryptedMessageByte = rsa.Decrypt(text, false);
            return(Convert.ToBase64String(encryptedMessageByte));
        }
Example #37
0
        /// <summary>
        /// キーコンテナに格納された秘密鍵を使って、文字列を復号化する
        /// </summary>
        /// <param name="str">Encryptメソッドにより暗号化された文字列</param>
        /// <param name="containerName">キーコンテナ名</param>
        /// <returns>復号化された文字列</returns>
        public static string DecryptByContainer(string str, string containerName)
        {
            //CspParametersオブジェクトの作成
            System.Security.Cryptography.CspParameters cp =
                new System.Security.Cryptography.CspParameters();
            //キーコンテナ名を指定する
            cp.KeyContainerName = containerName;
            //CspParametersを指定してRSACryptoServiceProviderオブジェクトを作成
            System.Security.Cryptography.RSACryptoServiceProvider rsa =
                new System.Security.Cryptography.RSACryptoServiceProvider(cp);

            //復号化する
            byte[] data          = System.Convert.FromBase64String(str);
            byte[] decryptedData = rsa.Decrypt(data, false);
            return(System.Text.Encoding.UTF8.GetString(decryptedData));
        }
Example #38
0
    static public string RSADecrypt(string sValue, string sPrvKey)
    {
        // RSA 복호화.

        byte [] inbuf = Convert.FromBase64String(sPrvKey);
        sPrvKey = (new UTF8Encoding()).GetString(inbuf);

        System.Security.Cryptography.RSACryptoServiceProvider oDec = new System.Security.Cryptography.RSACryptoServiceProvider();         //복호화
        oDec.FromXmlString(sPrvKey);

        byte [] srcbuf = Convert.FromBase64String(sValue);
        byte [] decbuf = oDec.Decrypt(srcbuf, false);

        string sDec = (new UTF8Encoding()).GetString(decbuf, 0, decbuf.Length);

        return(sDec);
    }
Example #39
0
        /// <summary>
        /// 公開鍵を使って復号化する
        /// </summary>
        /// <param name="str">復号化するデータ</param>
        /// <returns>復号化されたデータ</returns>
        public static byte[] DecryptBigData(byte[] targetData)
        {
            try
            {
                //RSACryptoServiceProviderオブジェクトの作成
                var rsa = new System.Security.Cryptography.RSACryptoServiceProvider(KeySize);

                //秘密鍵を指定
                rsa.FromXmlString(privateKey);

                int blockNumber = targetData.Length;
                blockNumber /= rsa.KeySize / 8;
                if (targetData.Length % (rsa.KeySize / 8) != 0)
                {
                    blockNumber++;
                }

                byte[] resultData   = new byte[targetData.Length];
                int    resultOffset = 0;
                for (int index = 0; index < blockNumber; index++)
                {
                    //復号化する
                    int tempSize = rsa.KeySize / 8;
                    if (targetData.Length - index * tempSize < tempSize)
                    {
                        tempSize = targetData.Length - index * tempSize;
                    }
                    byte[] tempData = new byte[tempSize];
                    Buffer.BlockCopy(targetData, index * (rsa.KeySize / 8), tempData, 0, tempSize);
                    byte[] decryptedData = rsa.Decrypt(tempData, false);
                    Buffer.BlockCopy(decryptedData, 0, resultData, resultOffset, decryptedData.Length);
                    resultOffset += decryptedData.Length;
                }
                Array.Resize(ref resultData, resultOffset);

                //結果を文字列に変換
                return(resultData);
            }
            catch (Exception ex)
            {
                string exe = ex.Message;
            }

            return(null);
        }
Example #40
0
        /// <summary>
        /// 秘密鍵を使って文字列を復号化する
        /// </summary>
        /// <param name="str">Encryptメソッドにより暗号化された文字列</param>
        /// <returns>復号化された文字列</returns>
        public static string ClientDecrypt(string str)
        {
            try
            {
                //RSACryptoServiceProviderオブジェクトの作成
                var rsa = new System.Security.Cryptography.RSACryptoServiceProvider(KeySize);

                //秘密鍵を指定
                rsa.FromXmlString(clientPrivateKey);

                //復号化する文字列をバイト配列に
                byte[] data = System.Convert.FromBase64String(str);
                //復号化する
                byte[] decryptedData = rsa.Decrypt(data, false);

                //結果を文字列に変換
                return(System.Text.Encoding.UTF8.GetString(decryptedData));
            }
            catch (Exception)
            {
            }

            return(null);
        }
Example #41
0
        public static byte[] RSADecrypt(byte[] privateKey, byte[] dataToDecrypt)
        {
            // helper to RSA decrypt a given blob

            // PROV_RSA_AES == 24
            var cspParameters = new System.Security.Cryptography.CspParameters(24);

            using (var rsaProvider = new System.Security.Cryptography.RSACryptoServiceProvider(cspParameters))
            {
                try
                {
                    rsaProvider.PersistKeyInCsp = false;
                    rsaProvider.ImportCspBlob(privateKey);

                    byte[] dataToDecryptRev = new byte[256];

                    Buffer.BlockCopy(dataToDecrypt, 0, dataToDecryptRev, 0, dataToDecrypt.Length); // ... Array.Copy? naw... :(

                    Array.Reverse(dataToDecryptRev);                                               // ... don't ask me how long it took to realize this :(

                    byte[] dec = rsaProvider.Decrypt(dataToDecryptRev, false);                     // no padding
                    return(dec);
                }
                catch (Exception e)
                {
                    Console.WriteLine("Error decryption domain key: {0}", e.Message);
                }
                finally
                {
                    rsaProvider.PersistKeyInCsp = false;
                    rsaProvider.Clear();
                }
            }

            return(new byte[0]);
        }
Example #42
0
 private static byte[] decrypt(byte[] data, string privateKey, string input_charset)
 {
     System.Security.Cryptography.RSACryptoServiceProvider rSACryptoServiceProvider = RSAFromPkcs8.DecodePemPrivateKey(privateKey);
     new System.Security.Cryptography.SHA1CryptoServiceProvider();
     return(rSACryptoServiceProvider.Decrypt(data, false));
 }
Example #43
-1
 public static byte[] Decrypt(byte[] privKey, byte[] data)
 {
     RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
     rsa.ImportCspBlob(privKey);
     byte[] x = rsa.Decrypt(data, false);
     return x;
 }