सरल असुरक्षित दो-तरफ़ा डेटा "ओफ़्फ़्यूसेशन"?

Question

मैं कुछ डेटा के लिए बहुत ही सरल ओफ़्क्यूशन (एन्क्रिप्ट और डिक्रिप्ट लेकिन जरूरी नहीं कि सुरक्षित हो) कार्यक्षमता की तलाश कर रहा हूं। यह महत्वपूर्ण मिशन नहीं है। मुझे ईमानदार लोगों को ईमानदार रखने के लिए कुछ चाहिए, लेकिन ROT13 या Base64 की तुलना में थोड़ा मजबूत ।

मैं कुछ ऐसी चीज़ पसंद करता हूँ जो पहले से ही .NET फ्रेमवर्क 2.0 में शामिल है , इसलिए मुझे किसी बाहरी निर्भरता के बारे में चिंता करने की ज़रूरत नहीं है।

मैं वास्तव में सार्वजनिक / निजी कुंजी, आदि के साथ गड़बड़ नहीं करना चाहता। मुझे एन्क्रिप्शन के बारे में ज्यादा जानकारी नहीं है, लेकिन मुझे यह जानने के लिए पर्याप्त है कि मैंने जो कुछ भी लिखा है वह बेकार से कम होगा ... वास्तव में, मैं शायद गणित को खराब कर दूंगा और इसे क्रैक करने के लिए तुच्छ बना दूंगा।

Comments

हाय मार्क - कोई बात नहीं। मुझे बुरा लगा कि मुझे रिचडिट से उत्तर को अस्वीकार करना पड़ा, क्योंकि मैंने वास्तव में उसके समाधान का उपयोग किया था और यह ठीक काम किया। हालाँकि, मैं अन्य उत्तरों को पढ़ने के लिए यहाँ वापस आता रहा, और आपका वास्तव में बेहतर है। लोगों को किसी चीज़ का उपयोग करने के लिए कहने का कोई कारण नहीं है, जबकि यह काम करता है, वास्तव में कुछ करने का एक शानदार तरीका नहीं है जब कोई बेहतर उत्तर उपलब्ध हो।

— मैट डेविड

अपने आप को घंटे बचाने के लिए और बाइट सरणियों से एक यूआरएल के अनुकूल स्ट्रिंग के लिए आगे और पीछे कन्वर्ट करने के लिए HttpServerUtility.UrlTokenEn / Decode का उपयोग करें।

— प्रागस

अपने खुद के चालाक डिजाइन को रोल करने की कोशिश नहीं करने के लिए +1। आप एन्क्रिप्शन के बारे में बहुत कुछ नहीं जानते होंगे, लेकिन यह तथ्य कि आप जानते हैं कि आपको सबसे अधिक डेवलपर्स के बारे में पता चलता है, जो मुझे मिले हैं, जो एन्क्रिप्शन के बारे में ज्यादा नहीं जानते हैं, लेकिन सोचते हैं कि वे वैसे भी अपना समाधान बना सकते हैं।

— दीना

ध्यान दें: इस प्रश्न के कई उत्तर केवल अनधिकृत एन्क्रिप्शन हैं। इसका मतलब यह है कि हमलावर ऐप नोटिंग के बिना डेटा बदल सकता है । यह अन्य गंभीर कमजोरियों की ओर जाता है (जैसे पैडिंग ओरेकल के कारण बिना डिक्रिप्शन के)। TL; DR: दिए गए उत्तरों में कोड का उपयोग न करें यदि आप उसके साथ ठीक नहीं हैं, या समझ नहीं आता है कि मैंने अभी क्या कहा है।

— usr

इस प्रश्न का एक भी उत्तर सुरक्षित एन्क्रिप्शन का वर्णन नहीं करता है। Encrypt पर jbtule के उत्तर का उपयोग करें और इसके बजाय एक स्ट्रिंग को डिक्रिप्ट करें ।

— कोडइन्चोस

Answer 1

यहां अन्य उत्तर ठीक काम करते हैं, लेकिन एईएस एक अधिक सुरक्षित और अद्यतित एन्क्रिप्शन एल्गोरिथ्म है। यह एक वर्ग है जिसे मैंने कुछ साल पहले एईएस एन्क्रिप्शन का प्रदर्शन करने के लिए प्राप्त किया था जिसे मैंने वेब अनुप्रयोगों के लिए अधिक अनुकूल होने के लिए समय के साथ संशोधित किया है (ई, जी। मैंने एनक्रिप्ट / डिक्रिप्ट विधियों का निर्माण किया है जो यूआरएल-अनुकूल स्ट्रिंग के साथ काम करते हैं)। इसमें बाइट सरणियों के साथ काम करने वाले तरीके भी हैं।

नोट: आपको कुंजी (32 बाइट्स) और वेक्टर (16 बाइट्स) सरणियों में विभिन्न मूल्यों का उपयोग करना चाहिए! आप नहीं चाहेंगे कि कोई आपकी कुंजी को यह मान कर निकाले कि आपने इस कोड का उपयोग किया है! आपको केवल कुंजी और वेक्टर सरणियों में कुछ संख्याओं को बदलना होगा (<= 255 होना चाहिए) (वेक्टर सरणी में एक अमान्य मान छोड़ दिया है ताकि आप यह सुनिश्चित कर सकें ...)। आसानी से नया सेट बनाने के लिए आप https://www.random.org/bytes/ का उपयोग कर सकते हैं:

• उत्पन्न Key
• उत्पन्न Vector

इसका उपयोग करना आसान है: बस क्लास को तत्काल करें और फिर कॉल करें (आमतौर पर) EncryptToString (स्ट्रिंग StringToEncrypt) और DecryptString (स्ट्रिंग StringToDecrypt) के तरीकों के रूप में। आपके पास इस वर्ग के होने के बाद यह कोई भी आसान (या अधिक सुरक्षित) नहीं हो सकता है।

---

using System;
using System.Data;
using System.Security.Cryptography;
using System.IO;


public class SimpleAES
{
    // Change these keys
    private byte[] Key = __Replace_Me__({ 123, 217, 19, 11, 24, 26, 85, 45, 114, 184, 27, 162, 37, 112, 222, 209, 241, 24, 175, 144, 173, 53, 196, 29, 24, 26, 17, 218, 131, 236, 53, 209 });

    // a hardcoded IV should not be used for production AES-CBC code
    // IVs should be unpredictable per ciphertext
    private byte[] Vector = __Replace_Me__({ 146, 64, 191, 111, 23, 3, 113, 119, 231, 121, 2521, 112, 79, 32, 114, 156 });


    private ICryptoTransform EncryptorTransform, DecryptorTransform;
    private System.Text.UTF8Encoding UTFEncoder;

    public SimpleAES()
    {
        //This is our encryption method
        RijndaelManaged rm = new RijndaelManaged();

        //Create an encryptor and a decryptor using our encryption method, key, and vector.
        EncryptorTransform = rm.CreateEncryptor(this.Key, this.Vector);
        DecryptorTransform = rm.CreateDecryptor(this.Key, this.Vector);

        //Used to translate bytes to text and vice versa
        UTFEncoder = new System.Text.UTF8Encoding();
    }

    /// -------------- Two Utility Methods (not used but may be useful) -----------
    /// Generates an encryption key.
    static public byte[] GenerateEncryptionKey()
    {
        //Generate a Key.
        RijndaelManaged rm = new RijndaelManaged();
        rm.GenerateKey();
        return rm.Key;
    }

    /// Generates a unique encryption vector
    static public byte[] GenerateEncryptionVector()
    {
        //Generate a Vector
        RijndaelManaged rm = new RijndaelManaged();
        rm.GenerateIV();
        return rm.IV;
    }


    /// ----------- The commonly used methods ------------------------------    
    /// Encrypt some text and return a string suitable for passing in a URL.
    public string EncryptToString(string TextValue)
    {
        return ByteArrToString(Encrypt(TextValue));
    }

    /// Encrypt some text and return an encrypted byte array.
    public byte[] Encrypt(string TextValue)
    {
        //Translates our text value into a byte array.
        Byte[] bytes = UTFEncoder.GetBytes(TextValue);

        //Used to stream the data in and out of the CryptoStream.
        MemoryStream memoryStream = new MemoryStream();

        /*
         * We will have to write the unencrypted bytes to the stream,
         * then read the encrypted result back from the stream.
         */
        #region Write the decrypted value to the encryption stream
        CryptoStream cs = new CryptoStream(memoryStream, EncryptorTransform, CryptoStreamMode.Write);
        cs.Write(bytes, 0, bytes.Length);
        cs.FlushFinalBlock();
        #endregion

        #region Read encrypted value back out of the stream
        memoryStream.Position = 0;
        byte[] encrypted = new byte[memoryStream.Length];
        memoryStream.Read(encrypted, 0, encrypted.Length);
        #endregion

        //Clean up.
        cs.Close();
        memoryStream.Close();

        return encrypted;
    }

    /// The other side: Decryption methods
    public string DecryptString(string EncryptedString)
    {
        return Decrypt(StrToByteArray(EncryptedString));
    }

    /// Decryption when working with byte arrays.    
    public string Decrypt(byte[] EncryptedValue)
    {
        #region Write the encrypted value to the decryption stream
        MemoryStream encryptedStream = new MemoryStream();
        CryptoStream decryptStream = new CryptoStream(encryptedStream, DecryptorTransform, CryptoStreamMode.Write);
        decryptStream.Write(EncryptedValue, 0, EncryptedValue.Length);
        decryptStream.FlushFinalBlock();
        #endregion

        #region Read the decrypted value from the stream.
        encryptedStream.Position = 0;
        Byte[] decryptedBytes = new Byte[encryptedStream.Length];
        encryptedStream.Read(decryptedBytes, 0, decryptedBytes.Length);
        encryptedStream.Close();
        #endregion
        return UTFEncoder.GetString(decryptedBytes);
    }

    /// Convert a string to a byte array.  NOTE: Normally we'd create a Byte Array from a string using an ASCII encoding (like so).
    //      System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
    //      return encoding.GetBytes(str);
    // However, this results in character values that cannot be passed in a URL.  So, instead, I just
    // lay out all of the byte values in a long string of numbers (three per - must pad numbers less than 100).
    public byte[] StrToByteArray(string str)
    {
        if (str.Length == 0)
            throw new Exception("Invalid string value in StrToByteArray");

        byte val;
        byte[] byteArr = new byte[str.Length / 3];
        int i = 0;
        int j = 0;
        do
        {
            val = byte.Parse(str.Substring(i, 3));
            byteArr[j++] = val;
            i += 3;
        }
        while (i < str.Length);
        return byteArr;
    }

    // Same comment as above.  Normally the conversion would use an ASCII encoding in the other direction:
    //      System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
    //      return enc.GetString(byteArr);    
    public string ByteArrToString(byte[] byteArr)
    {
        byte val;
        string tempStr = "";
        for (int i = 0; i <= byteArr.GetUpperBound(0); i++)
        {
            val = byteArr[i];
            if (val < (byte)10)
                tempStr += "00" + val.ToString();
            else if (val < (byte)100)
                tempStr += "0" + val.ToString();
            else
                tempStr += val.ToString();
        }
        return tempStr;
    }
}

Comments

@AndyMcKenna - यह उद्देश्य पर किया गया है ताकि आप सरणियों में मानों को बदल दें, जैसा कि दूसरे पैराग्राफ में मार्क नोट करता है।

— पौक

आपको इस तरह से IV का उपयोग नहीं करना चाहिए। दिए गए दो संदेशों के लिए, उन्हें एक ही कुंजी और समान IV के साथ एन्क्रिप्ट नहीं किया जाना चाहिए। IV को प्रत्येक संदेश के लिए यादृच्छिक होना चाहिए, जो क्रिप्टोस्टर पर प्रीपेन्ड किया गया है, और डिक्रिप्शन से पहले पढ़ा गया है। crypto.stackexchange.com/a/82/1934

— jbtule

प्रत्येक संदेश के लिए एक यादृच्छिक IV का उपयोग करना विदेशी या नया नहीं है, बस महत्वपूर्ण और एल्गोरिथ्म के डिजाइन का हिस्सा है। हर संदेश के लिए एक पूर्वानुमानित IV का उपयोग करना एक सामान्य क्रिप्टो गलती है जिसे हमेशा के लिए समाप्त करने की आवश्यकता नहीं है।

— jbtule

यह भी ध्यान दें कि CBC को इसके मोड के रूप में उपयोग करने का एक परिणाम यह है कि आपको पैडल ऑरेकल हमलों की चपेट में आने की संभावना है । प्रमाणित एन्क्रिप्शन का उपयोग करें, और जब भी संभव हो, क्रिप्टोग्राफी को स्वयं लागू न करें ।

— स्टीफन टॉसेट

सुरक्षा चेतावनी: इस कोड का उपयोग न करें स्वीकार किए गए उत्तर होने के बावजूद, उपरोक्त टिप्पणियों में गंभीर सुरक्षा मुद्दों का उल्लेख है जिसे लेखक ने 8 वर्षों तक अनदेखा किया है।

— jbtule

Answer 2

मैंने अपने उपयोग के लिए SimpleAES (ऊपर) को साफ किया। फिक्स्ड दृढ़ एन्क्रिप्ट / डिक्रिप्ट विधियों; बाइट बफ़र्स, स्ट्रिंग्स और URL के अनुकूल स्ट्रिंग्स को एन्कोडिंग के लिए अलग-अलग तरीके; URL एन्कोडिंग के लिए मौजूदा पुस्तकालयों का उपयोग।

कोड छोटा, सरल, तेज और आउटपुट अधिक संक्षिप्त है। उदाहरण के लिए, [e-mail]उत्पादन:

SimpleAES: "096114178117140150104121138042115022037019164188092040214235183167012211175176167001017163166152"
SimplerAES: "YHKydYyWaHmKKnMWJROkvFwo1uu3pwzTr7CnARGjppg%3d"

कोड:

public class SimplerAES
{
    private static byte[] key = __Replace_Me__({ 123, 217, 19, 11, 24, 26, 85, 45, 114, 184, 27, 162, 37, 112, 222, 209, 241, 24, 175, 144, 173, 53, 196, 29, 24, 26, 17, 218, 131, 236, 53, 209 });

    // a hardcoded IV should not be used for production AES-CBC code
    // IVs should be unpredictable per ciphertext
    private static byte[] vector = __Replace_Me_({ 146, 64, 191, 111, 23, 3, 113, 119, 231, 121, 221, 112, 79, 32, 114, 156 });

    private ICryptoTransform encryptor, decryptor;
    private UTF8Encoding encoder;

    public SimplerAES()
    {
        RijndaelManaged rm = new RijndaelManaged();
        encryptor = rm.CreateEncryptor(key, vector);
        decryptor = rm.CreateDecryptor(key, vector);
        encoder = new UTF8Encoding();
    }

    public string Encrypt(string unencrypted)
    {
        return Convert.ToBase64String(Encrypt(encoder.GetBytes(unencrypted)));
    }

    public string Decrypt(string encrypted)
    {
        return encoder.GetString(Decrypt(Convert.FromBase64String(encrypted)));
    }

    public byte[] Encrypt(byte[] buffer)
    {
        return Transform(buffer, encryptor);
    }

    public byte[] Decrypt(byte[] buffer)
    {
        return Transform(buffer, decryptor);
    }

    protected byte[] Transform(byte[] buffer, ICryptoTransform transform)
    {
        MemoryStream stream = new MemoryStream();
        using (CryptoStream cs = new CryptoStream(stream, transform, CryptoStreamMode.Write))
        {
            cs.Write(buffer, 0, buffer.Length);
        }
        return stream.ToArray();
    }
}

Comments

डिकोडिंग करते समय, मुझे क्रोम में QueryString के साथ काम करने के लिए इसे + के साथ स्थान बदलना पड़ा: (नया सिंपलएयरए ())। डिक्रिप्ट (अनुरोध।

— लाइव-लव

कभी भी लगातार इनिशियलाइज़ेशन वेक्टर का उपयोग न करें, देखें: crypto.stackexchange.com/questions/66/… क्यों अधिक जानकारी के लिए। इसके बजाय, प्रत्येक एन्क्रिप्शन के लिए एक नया IV जनरेट करें और इसे क्रिप्टोटेक्स्ट में जोड़ें, इतना बेहतर और कठिन नहीं।

— टॉम हर्ड

ध्यान रखें कि इस समाधान में EncryptToUrl पद्धति का आउटपुट (या सामान्य रूप से कोई UrlEncoded आधार 64 स्ट्रिंग का उपयोग) IIS 7 के तहत डिफ़ॉल्ट रूप से तब काम नहीं करेगा जब URL पथ (क्वेरी स्ट्रिंग नहीं) के भाग के रूप में उपयोग किया जाता है, जैसा कि IIS 7 सुरक्षा सेटिंग के कारण ASP.NET MVC मार्ग। अधिक के लिए, देखें: stackoverflow.com/a/2014121/12484

— जॉन श्नाइडर

@TomHeard उपरोक्त कोड के साथ, कोई ऐसा कैसे करेगा?

— MKII

सुरक्षा चेतावनी: इस कोड का उपयोग न करें @TomHeard द्वारा टिप्पणी देखें

— jbtule

Answer 3

हां, System.Securityअसेंबली जोड़ें , System.Security.Cryptographyनेमस्पेस आयात करें । यहाँ एक सममित (DES) एल्गोरिथ्म एन्क्रिप्शन का एक सरल उदाहरण है:

DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.GenerateKey();
byte[] key = des.Key; // save this!

ICryptoTransform encryptor = des.CreateEncryptor();
// encrypt
byte[] enc = encryptor.TransformFinalBlock(new byte[] { 1, 2, 3, 4 }, 0, 4);

ICryptoTransform decryptor = des.CreateDecryptor();

// decrypt
byte[] originalAgain = decryptor.TransformFinalBlock(enc, 0, enc.Length);
Debug.Assert(originalAgain[0] == 1);

Comments

यह एक अच्छा, कॉम्पैक्ट टू-वे एन्क्रिप्शन है। एकमात्र चेतावनी यह है कि डीईएस को अब अत्याधुनिक सुरक्षा नहीं माना जाता है। वह शीर्षक अब एईएस एल्गोरिथ्म पर जाता है जिसकी मैं नीचे चर्चा करता हूं।

— मार्क ब्रिटिंघम

@richdiet। मुझे खेद है कि मैंने आपका उत्तर अस्वीकार कर दिया। 37+ वोटों के साथ अन्य उत्तर क्योंकि यह अधिक वर्तमान है। आपके उत्तर के लिए धन्यवाद, क्योंकि यह अभी भी एक अच्छा है।

— बजे मैट डॉव

@MarkBrittingham: ब्लॉक चेनिंग फंक्शन, आरंभीकरण वेक्टर और उचित पैडिंग के बिना कोई भी ब्लॉक सिफर असुरक्षित है। इस योजना के साथ DES का उपयोग करना कम से कम महत्वपूर्ण समस्या है।

— ह्यूबर्ट करियो

तो कुंजी का उपयोग कहां किया जाता है?

— एलेक्स

सुरक्षा चेतावनी: न प्रयोग करें इस संहिता @HubertKario द्वारा टिप्पणी देखें

— jbtule

Answer 4

बस मैंने सोचा था कि मैं एक साधारण IV को जोड़कर मड के सिंपल को बेहतर बनाता हूं जो एन्क्रिप्टेड स्ट्रिंग के अंदर वापस पारित हो गया है। यह एन्क्रिप्शन को बेहतर बनाता है क्योंकि एक ही स्ट्रिंग को एन्क्रिप्ट करने से हर बार एक अलग आउटपुट मिलेगा।

public class StringEncryption
{
    private readonly Random random;
    private readonly byte[] key;
    private readonly RijndaelManaged rm;
    private readonly UTF8Encoding encoder;

    public StringEncryption()
    {
        this.random = new Random();
        this.rm = new RijndaelManaged();
        this.encoder = new UTF8Encoding();
        this.key = Convert.FromBase64String("Your+Secret+Static+Encryption+Key+Goes+Here=");
    }

    public string Encrypt(string unencrypted)
    {
        var vector = new byte[16];
        this.random.NextBytes(vector);
        var cryptogram = vector.Concat(this.Encrypt(this.encoder.GetBytes(unencrypted), vector));
        return Convert.ToBase64String(cryptogram.ToArray());
    }

    public string Decrypt(string encrypted)
    {
        var cryptogram = Convert.FromBase64String(encrypted);
        if (cryptogram.Length < 17)
        {
            throw new ArgumentException("Not a valid encrypted string", "encrypted");
        }

        var vector = cryptogram.Take(16).ToArray();
        var buffer = cryptogram.Skip(16).ToArray();
        return this.encoder.GetString(this.Decrypt(buffer, vector));
    }

    private byte[] Encrypt(byte[] buffer, byte[] vector)
    {
        var encryptor = this.rm.CreateEncryptor(this.key, vector);
        return this.Transform(buffer, encryptor);
    }

    private byte[] Decrypt(byte[] buffer, byte[] vector)
    {
        var decryptor = this.rm.CreateDecryptor(this.key, vector);
        return this.Transform(buffer, decryptor);
    }

    private byte[] Transform(byte[] buffer, ICryptoTransform transform)
    {
        var stream = new MemoryStream();
        using (var cs = new CryptoStream(stream, transform, CryptoStreamMode.Write))
        {
            cs.Write(buffer, 0, buffer.Length);
        }

        return stream.ToArray();
    }
}

और बोनस इकाई परीक्षण

[Test]
public void EncryptDecrypt()
{
    // Arrange
    var subject = new StringEncryption();
    var originalString = "Testing123!£$";

    // Act
    var encryptedString1 = subject.Encrypt(originalString);
    var encryptedString2 = subject.Encrypt(originalString);
    var decryptedString1 = subject.Decrypt(encryptedString1);
    var decryptedString2 = subject.Decrypt(encryptedString2);

    // Assert
    Assert.AreEqual(originalString, decryptedString1, "Decrypted string should match original string");
    Assert.AreEqual(originalString, decryptedString2, "Decrypted string should match original string");
    Assert.AreNotEqual(originalString, encryptedString1, "Encrypted string should not match original string");
    Assert.AreNotEqual(encryptedString1, encryptedString2, "String should never be encrypted the same twice");
}

Comments

1) System.RandomRNG के रूप में उपयोग न करें । 2) यह चुने हुए सिफरटेक्स्ट हमलों (विशेष रूप से पेडिंग-

— ऑर्कल्स में

सुरक्षा चेतावनी: इस कोड का उपयोग न करें @CodesInChaos द्वारा टिप्पणी के ऊपर देखें

— jbtule

@jbtule कृपया हर उस व्यक्ति को गुमराह न करें जो जटिलताओं को सिर्फ एन्क्रिप्ट नहीं करना चाहता है, और यह भी कि हमले के बारे में कोई सावधान नहीं है, - यदि आप सुझाव देना चाहते हैं तो कृपया आदेश न दें।

— वीरभद्रसिंह

@ वीरभद्रसिंह मेरी ओर से कोई गलतफहमी नहीं है, वास्तव में यह बिल्कुल विपरीत है। यदि आप एईएस का उपयोग करने जा रहे हैं, तो इसका सही उपयोग करना काफी महत्वपूर्ण है, इसका गलत तरीके से उपयोग करना और यह कहना कि ठीक है मैं इसे किसी महत्वपूर्ण चीज के लिए उपयोग नहीं कर रहा हूं, गुमराह है।

— jbtule

@ कोरी चिल्लाना नहीं, और स्टैक ओवरफ्लो उत्तरों में सुरक्षा मुद्दों से निपटने के लिए सर्वोत्तम अभ्यास का पालन किया था। यदि आप एक लिंक चाहते हैं, तो यह प्रश्न टिप्पणियों में पोस्ट किया गया था। लेकिन मैं इसे आपके लिए यहां भी

— रखूंगा,

Answer 5

मार्क्स का एक प्रकार (उत्कृष्ट) उत्तर

• "का उपयोग कर" जोड़ें
• क्लास को आइडीएसोपॉली बनाओ
• उदाहरण को सरल बनाने के लिए URL एन्कोडिंग कोड निकालें।
• उपयोग प्रदर्शित करने के लिए एक साधारण परीक्षण स्थिरता जोड़ें

उम्मीद है की यह मदद करेगा

[TestFixture]
public class RijndaelHelperTests
{
    [Test]
    public void UseCase()
    {
        //These two values should not be hard coded in your code.
        byte[] key = {251, 9, 67, 117, 237, 158, 138, 150, 255, 97, 103, 128, 183, 65, 76, 161, 7, 79, 244, 225, 146, 180, 51, 123, 118, 167, 45, 10, 184, 181, 202, 190};
        byte[] vector = {214, 11, 221, 108, 210, 71, 14, 15, 151, 57, 241, 174, 177, 142, 115, 137};

        using (var rijndaelHelper = new RijndaelHelper(key, vector))
        {
            var encrypt = rijndaelHelper.Encrypt("StringToEncrypt");
            var decrypt = rijndaelHelper.Decrypt(encrypt);
            Assert.AreEqual("StringToEncrypt", decrypt);
        }
    }
}

public class RijndaelHelper : IDisposable
{
    Rijndael rijndael;
    UTF8Encoding encoding;

    public RijndaelHelper(byte[] key, byte[] vector)
    {
        encoding = new UTF8Encoding();
        rijndael = Rijndael.Create();
        rijndael.Key = key;
        rijndael.IV = vector;
    }

    public byte[] Encrypt(string valueToEncrypt)
    {
        var bytes = encoding.GetBytes(valueToEncrypt);
        using (var encryptor = rijndael.CreateEncryptor())
        using (var stream = new MemoryStream())
        using (var crypto = new CryptoStream(stream, encryptor, CryptoStreamMode.Write))
        {
            crypto.Write(bytes, 0, bytes.Length);
            crypto.FlushFinalBlock();
            stream.Position = 0;
            var encrypted = new byte[stream.Length];
            stream.Read(encrypted, 0, encrypted.Length);
            return encrypted;
        }
    }

    public string Decrypt(byte[] encryptedValue)
    {
        using (var decryptor = rijndael.CreateDecryptor())
        using (var stream = new MemoryStream())
        using (var crypto = new CryptoStream(stream, decryptor, CryptoStreamMode.Write))
        {
            crypto.Write(encryptedValue, 0, encryptedValue.Length);
            crypto.FlushFinalBlock();
            stream.Position = 0;
            var decryptedBytes = new Byte[stream.Length];
            stream.Read(decryptedBytes, 0, decryptedBytes.Length);
            return encoding.GetString(decryptedBytes);
        }
    }

    public void Dispose()
    {
        if (rijndael != null)
        {
            rijndael.Dispose();
        }
    }
}

Comments

अच्छा उत्तर। डिस्पोज़ मेथड में एक चीज़ आपको रिजिन्डेल को आईडीसोफिल में डालने की आवश्यकता होगी या आप डिस्पोज़ को कॉल करके एक प्रोटेक्शन लेवल एरर प्राप्त करेंगे

— जॉन क्लियरज

कभी भी लगातार इनिशियलाइज़ेशन वेक्टर का उपयोग न करें, देखें: crypto.stackexchange.com/questions/66/… क्यों अधिक जानकारी के लिए। इसके बजाय, प्रत्येक एन्क्रिप्शन के लिए एक नया IV जनरेट करें और इसे क्रिप्टोटेक्स्ट में जोड़ें, इतना बेहतर और कठिन नहीं।

— टॉम हर्ड

@Chalky एन्क्रिप्ट पर, आप अपने लिए एक यादृच्छिक IV उत्पन्न करने के लिए Rijndael वर्ग का उपयोग करते हैं ( msdn.microsoft.com/en-us/library/… ), अपना एन्क्रिप्ट करें, और फिर IV संपत्ति का उपयोग करके Rijndael उदाहरण से IV को पकड़ो । तब आप प्रीपेन्ड (या एपेंड करते हैं, या तो जब तक आपका डिक्रिप्ट उसी ओर से पकड़ लेता है) तब तक यह आपके क्रिप्टो टेक्स्ट पर निर्भर करता है। डिक्रिप्ट करने पर आप प्राप्त डेटा से IV को खींचते हैं (IV प्रॉपर्टी का साइज 8 से विभाजित की गई प्रॉपर्टीज के समान है), फिर डिक्रिप्ट करने से पहले इसे अपने डिक्रिप्ट इंस्टेंस में पास करें।

— टॉम हर्ड

@Chalky ध्यान दें कि IV को गुप्त होने की आवश्यकता नहीं है, इसे भेजे गए प्रत्येक संदेश के लिए बस अद्वितीय होने की आवश्यकता है।

— टॉम हर्ड

सुरक्षा चेतावनी: इस कोड का उपयोग न करें @TomHeard द्वारा उपरोक्त टिप्पणियां देखें

— jbtule

Answer 6

[संपादित करें] वर्षों बाद, मैं कहने के लिए वापस आया हूँ: ऐसा मत करो! देखें XOR एन्क्रिप्शन में क्या गलत है? ब्योरा हेतु।

एक बहुत ही सरल, आसान टू-वे एनक्रिप्टेशन XOR एन्क्रिप्शन है।

1. पासवर्ड लेकर आएं। चलो यह है mypass।
   
2. पासवर्ड को बाइनरी में परिवर्तित करें (एएससीआईआई के अनुसार)। पासवर्ड 01101101 01111001 01110000 01100001 01110011 01110011 हो जाता है।
   
3. वह संदेश लें जिसे आप एन्कोड करना चाहते हैं। बाइनरी में परिवर्तित करें, यह भी।
   
4. संदेश की लंबाई को देखो। यदि संदेश की लंबाई 400 बाइट्स है, तो पासवर्ड को बार-बार दोहराकर 400 बाइट स्ट्रिंग में बदल दें। यह 01101101 01111001 01110000 01100001 01110011 01110011 011100101 01111101 01111001 01110000 011100001 01110011 0110111 01111001 011100001 011100001 01110011 01110011 ... (या mypassmypassmypass...) बन जाएगी।
   
5. संदेश को लंबे पासवर्ड के साथ XOR करें।
   
6. परिणाम भेजें।
   
7. दूसरी बार, XOR एक ही पासवर्ड के साथ एन्क्रिप्टेड संदेश ( mypassmypassmypass...)।
   
8. आपका संदेश है!

Comments

@ रेयान को हर स्थिति के लिए क्रिप्टोग्राफिक रूप से सुरक्षित हैश या रिजंडेल सिफर्स की आवश्यकता नहीं होती है। "सिंपल 2 वे एनक्रिप्शन" वास्तव में सरल का मतलब हो सकता है , जो एक्सआर या यहां तक ​​कि आरओटी 13 का सुझाव देता है।

@Ryan: AES with static एन्क्रिप्शन कुंजी, कोई इनिशियलाइज़ेशन वेक्टर और कोई ब्लॉक चेनिंग फंक्शन XOR एन्क्रिप्शन के लिए सिर्फ फैंसी नाम है, आप बस वास्तव में फैंसी KDF का उपयोग कर रहे हैं ...

— ह्यूबर्ट करियो

सुरक्षा चेतावनी: इस कोड का उपयोग न करें XOR एन्क्रिप्शन एक दोहराव कुंजी के साथ तुच्छ रूप से फटा है।

— jbtule

Answer 7

मैंने संयुक्त रूप से मुझे कई उत्तरों और टिप्पणियों से सर्वश्रेष्ठ पाया।

• रैंडम इनिशियलाइज़ेशन वेक्टर क्रिप्टो टेक्स्ट (@jbtule) से जुड़ा हुआ है
• MemoryStream (@ RenniePet) के बजाय TransformFinalBlock () का उपयोग करें
• किसी भी आपदा से बचने और कॉपी करने से पहले की-भरी हुई चाबी नहीं
• उचित निपटान और पैटर्न का उपयोग करना

कोड:

/// <summary>
/// Simple encryption/decryption using a random initialization vector
/// and prepending it to the crypto text.
/// </summary>
/// <remarks>Based on multiple answers in http://stackoverflow.com/questions/165808/simple-two-way-encryption-for-c-sharp </remarks>
public class SimpleAes : IDisposable
{
    /// <summary>
    ///     Initialization vector length in bytes.
    /// </summary>
    private const int IvBytes = 16;

    /// <summary>
    ///     Must be exactly 16, 24 or 32 bytes long.
    /// </summary>
    private static readonly byte[] Key = Convert.FromBase64String("FILL ME WITH 24 (2 pad chars), 32 OR 44 (1 pad char) RANDOM CHARS"); // Base64 has a blowup of four-thirds (33%)

    private readonly UTF8Encoding _encoder;
    private readonly ICryptoTransform _encryptor;
    private readonly RijndaelManaged _rijndael;

    public SimpleAes()
    {
        _rijndael = new RijndaelManaged {Key = Key};
        _rijndael.GenerateIV();
        _encryptor = _rijndael.CreateEncryptor();
        _encoder = new UTF8Encoding();
    }

    public string Decrypt(string encrypted)
    {
        return _encoder.GetString(Decrypt(Convert.FromBase64String(encrypted)));
    }

    public void Dispose()
    {
        _rijndael.Dispose();
        _encryptor.Dispose();
    }

    public string Encrypt(string unencrypted)
    {
        return Convert.ToBase64String(Encrypt(_encoder.GetBytes(unencrypted)));
    }

    private byte[] Decrypt(byte[] buffer)
    {
        // IV is prepended to cryptotext
        byte[] iv = buffer.Take(IvBytes).ToArray();
        using (ICryptoTransform decryptor = _rijndael.CreateDecryptor(_rijndael.Key, iv))
        {
            return decryptor.TransformFinalBlock(buffer, IvBytes, buffer.Length - IvBytes);
        }
    }

    private byte[] Encrypt(byte[] buffer)
    {
        // Prepend cryptotext with IV
        byte [] inputBuffer = _encryptor.TransformFinalBlock(buffer, 0, buffer.Length); 
        return _rijndael.IV.Concat(inputBuffer).ToArray();
    }
}

अद्यतन २०१५-० Fixed-१ Fixed: निजी एंक्रिप्ट () में @bpsilver और @Evereq की टिप्पणियों द्वारा फिक्स्ड गलती। IV गलती से एन्क्रिप्ट किया गया था, अब डिक्रिप्ट () द्वारा अपेक्षित के रूप में स्पष्ट पाठ में पूर्वनिर्मित है।

Comments

आपको IV के साथ पूरे इनपुटबफ़र को एन्क्रिप्ट करना चाहिए, अन्यथा स्ट्रिंग-टू-एन्क्रिप्ट के पहले 16 अक्षर खो गए हैं। तो आपका कोड पढ़ना चाहिए:return _encryptor.TransformFinalBlock(inputBuffer, 0, inputBuffer.Length);

— bpsilver

उस मामले में:byte [] inputBuffer = _encryptor.TransformFinalBlock(buffer, 0, buffer.Length); return _rijndael.IV.Concat(inputBuffer).ToArray();

— bpsilver

यह वर्तमान कार्यान्वयन के रूप में एक ही बात करेंगे, यह नहीं होगा?

— कोणीय काल

"फील मी विद 16, 24 या 32 चार्ज" अच्छी तरह से, नहीं, बेस 64 डिकोडिंग से पहले नहीं । और एक कुंजी यादृच्छिक होनी चाहिए। वास्तव में यादृच्छिक।

— मार्टन बॉड्यूज 22

मैंने देखा कि @bpsilver सही है, और बशर्ते कोड उसके ठीक किए बिना काम नहीं करेगा: एन्क्रिप्ट विधि IV के बिना एन्क्रिप्टेड डेटा लौटाता है (यह पहली बार IV को इनपुटबफ़र में जोड़ता है, लेकिन अगले एन्क्रिप्ट और इसके बिना डेटा वापस लौटाता है)। इसलिए यदि संभव हो तो बस उसके कोड के साथ उत्तर को अपडेट करें। (नोट: मैं केवल बाइट [] मापदंडों के साथ तरीकों का परीक्षण करता हूं, तार नहीं)। धन्यवाद!

— सदाबहार जूल

Answer 8

यदि आप केवल सरल एन्क्रिप्शन चाहते हैं (यानी, एक दृढ़ क्रैकर को तोड़ने के लिए संभव है, लेकिन अधिकांश आकस्मिक उपयोगकर्ताओं को बंद करना), तो समान लंबाई के दो पासफ़्रेज़ चुनें:

deoxyribonucleicacid
while (x>0) { x-- };

और अपने डेटा को उन दोनों के साथ जमा करें (यदि आवश्यक हो तो पासफ़्रेज़ को पाशन करें) ^(ए) । उदाहरण के लिए:

1111-2222-3333-4444-5555-6666-7777
deoxyribonucleicaciddeoxyribonucle
while (x>0) { x-- };while (x>0) { 

आपके बाइनरी को खोजने वाला कोई व्यक्ति अच्छी तरह से सोच सकता है कि डीएनए स्ट्रिंग एक कुंजी है, लेकिन वे यह सोचने की संभावना नहीं रखते हैं कि सी कोड आपके बाइनरी के साथ सहेजे गए अनैतिक रूप से मेमोरी के अलावा कुछ भी नहीं है।

---

^(ए) ध्यान रखें कि यह बहुत ही सरल एन्क्रिप्शन है और, कुछ परिभाषाओं द्वारा, एन्क्रिप्शन को बिल्कुल भी नहीं माना जा सकता है (क्योंकि एन्क्रिप्शन का इरादा रोकने के लिए है अनधिकृत पहुंच बजाय सिर्फ इसे और अधिक कठिन बनाना है)। हालांकि, निश्चित रूप से, यहां तक ​​कि सबसे मजबूत एन्क्रिप्शन असुरक्षित है जब कोई स्टील पाइप के साथ कुंजी-धारकों पर खड़ा होता है।

जैसा कि पहले वाक्य में कहा गया है, यह आकस्मिक हमलावर के लिए पर्याप्त कठिन बनाने का एक साधन है जिस पर वे आगे बढ़ेंगे। यह आपके घर पर सेंधमारी को रोकने के समान है - आपको इसे अभेद्य बनाने की आवश्यकता नहीं है, आपको बस घर के अगले दरवाजे की तुलना में इसे कम गर्भधारण करने की आवश्यकता है :-)

Comments

दिलचस्प विचार। मुझे यकीन नहीं है कि मैं एक बाइनरी में "विश्वास" स्रोत कोड - लेकिन पासफ़्रेज़ के रूप में त्रुटि संदेश का उपयोग करने के लिए विचार को कैसे स्वीकार करूं?

— जॉन स्केट

मैं कुछ क्लियरटेक्स्ट स्ट्रिंग के md5 हैश का उपयोग करना पसंद करता हूं जो पहले से ही एप्लिकेशन (त्रुटि संदेश या तो) में मौजूद है।

— ट्रेब

उन्हें समान लंबाई का होने की आवश्यकता क्यों है? यह वास्तव में बेहतर लगता है अगर वे अलग-अलग लंबाई के हों। इस तरह, आपके प्रभावी XOR ऑपरेंड की लंबाई LCM (length1, length2) है, इसके बजाय सिर्फ length1 (===2) है। यदि लंबाई अपेक्षाकृत कम है तो निश्चित रूप से लंबाई 1 * लंबाई 2 हो जाती है।

— फनटियस

सुरक्षा चेतावनी: इस कोड का उपयोग न करें दोहराए जाने वाले कुंजी XOR आसानी से डेटा के कुछ सामान्य ज्ञान के साथ एन्क्रिप्ट किए जा रहे हैं।

— jbtule

@jbtule, यदि आप प्रश्न पढ़ते हैं, तो आपको एहसास होगा कि अधिक सुरक्षित एन्क्रिप्शन किसी भी तरह से आवश्यक नहीं था। विशेष रूप से 'सरल एन्क्रिप्शन', 'मिशन क्रिटिकल नहीं' और सिर्फ 'ईमानदार लोगों को ईमानदार रखने' का संदर्भ। आपको मेरा पहला पैराग्राफ भी पढ़ना चाहिए जो स्पष्ट रूप से इस तथ्य को बताता है कि यह निर्धारित हमलावरों को बंद नहीं करेगा।

— paxdiablo

Answer 9

एन्क्रिप्शन आसान है: जैसा कि दूसरों ने बताया है, System.Security.Cryptography नामस्थान में कक्षाएं हैं जो आपके लिए सभी काम करती हैं। किसी भी घरेलू समाधान के बजाय उनका उपयोग करें।

लेकिन डिक्रिप्शन भी आसान है। आपके पास मौजूद समस्या एन्क्रिप्शन एल्गोरिथम नहीं है, लेकिन डिक्रिप्शन के लिए उपयोग की जाने वाली कुंजी तक पहुंच की रक्षा करना।

मैं निम्नलिखित समाधानों में से एक का उपयोग करूंगा:

• डीपीएपीआई करंटयूजर स्कोप के साथ प्रोटेक्टेडटा क्लास का उपयोग कर रहा है। यह आसान है क्योंकि आपको एक कुंजी के बारे में चिंता करने की आवश्यकता नहीं है। डेटा को केवल एक ही उपयोगकर्ता द्वारा डिक्रिप्ट किया जा सकता है, इसलिए उपयोगकर्ताओं या मशीनों के बीच डेटा साझा करने के लिए कोई अच्छा नहीं है।

• DPAPI LocalMachine गुंजाइश के साथ ProtectedData वर्ग का उपयोग कर। एकल सुरक्षित सर्वर पर कॉन्फ़िगरेशन डेटा की सुरक्षा के लिए अच्छा है। लेकिन जो कोई भी मशीन में लॉग इन कर सकता है, वह इसे एन्क्रिप्ट कर सकता है, इसलिए जब तक सर्वर सुरक्षित न हो, कोई अच्छा नहीं।

• किसी भी सममित एल्गोरिथ्म। अगर मैं एल्गोरिथ्म का उपयोग किया जाता है (वास्तव में यह डिफ़ॉल्ट रूप से Rijndael है) परवाह नहीं करता है, तो मैं आम तौर पर स्थिर SymmetricAlgorithm.Create () विधि का उपयोग करता हूं। इस मामले में आपको किसी तरह अपनी कुंजी की रक्षा करने की आवश्यकता है। जैसे आप इसे किसी तरह से बाधित कर सकते हैं और इसे अपने कोड में छिपा सकते हैं। लेकिन ध्यान रखें कि जो कोई भी आपके कोड को डिकंपोज करने के लिए पर्याप्त स्मार्ट है, वह संभवतः कुंजी खोजने में सक्षम होगा।

Answer 10

मैं अपने समाधान को पोस्ट करना चाहता था क्योंकि उपरोक्त समाधानों में से कोई भी मेरी तरह सरल नहीं है। आप क्या सोचते हैं मुझे बताओ:

 // This will return an encrypted string based on the unencrypted parameter
 public static string Encrypt(this string DecryptedValue)
 {
      HttpServerUtility.UrlTokenEncode(MachineKey.Protect(Encoding.UTF8.GetBytes(DecryptedValue.Trim())));
 }

 // This will return an unencrypted string based on the parameter
 public static string Decrypt(this string EncryptedValue)
 {
      Encoding.UTF8.GetString(MachineKey.Unprotect(HttpServerUtility.UrlTokenDecode(EncryptedValue)));
 }

ऐच्छिक

यह मान लेता है कि मूल्य को एन्क्रिप्ट करने के लिए उपयोग किए जाने वाले सर्वर का मशीनके मान वैसा ही है जैसा कि मूल्य को डिक्रिप्ट करने के लिए उपयोग किया जाता है। यदि वांछित है, तो आप Web.config में एक स्थैतिक MachineKey को निर्दिष्ट कर सकते हैं ताकि आपका एप्लिकेशन डेटा को डिक्रिप्ट / एन्क्रिप्ट कर सके, भले ही वह कहां चला जाए (उदाहरण विकास बनाम उत्पादन सर्वर)। आप इन निर्देशों का पालन करते हुए एक स्थैतिक मशीन कुंजी उत्पन्न कर सकते हैं ।

Comments

ध्यान दें कि इस दृष्टिकोण का उपयोग केवल ASP.NET ऐप के लिए किया जा सकता है।

— फेरू

Answer 11

नामस्थान System.Security.Cryptographyमें वर्ग TripleDESCryptoServiceProviderऔर RijndaelManagedवर्ग शामिल हैं

System.Securityविधानसभा के लिए एक संदर्भ जोड़ने के लिए मत भूलना ।

Comments

ऐसा नहीं है कि मैंने नीचा दिखाया, लेकिन मतदान करते समय प्रश्न की उम्र क्यों होनी चाहिए?

— user247702

Answer 12

System.Security.Cryptography में TripleDESCryptoServiceProvider का उपयोग करना :

public static class CryptoHelper
{
    private const string Key = "MyHashString";
    private static TripleDESCryptoServiceProvider GetCryproProvider()
    {
        var md5 = new MD5CryptoServiceProvider();
        var key = md5.ComputeHash(Encoding.UTF8.GetBytes(Key));
        return new TripleDESCryptoServiceProvider() { Key = key, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7 };
    }

    public static string Encrypt(string plainString)
    {
        var data = Encoding.UTF8.GetBytes(plainString);
        var tripleDes = GetCryproProvider();
        var transform = tripleDes.CreateEncryptor();
        var resultsByteArray = transform.TransformFinalBlock(data, 0, data.Length);
        return Convert.ToBase64String(resultsByteArray);
    }

    public static string Decrypt(string encryptedString)
    {
        var data = Convert.FromBase64String(encryptedString);
        var tripleDes = GetCryproProvider();
        var transform = tripleDes.CreateDecryptor();
        var resultsByteArray = transform.TransformFinalBlock(data, 0, data.Length);
        return Encoding.UTF8.GetString(resultsByteArray);
    }
}

Answer 13

मैं बदल गया यह :

public string ByteArrToString(byte[] byteArr)
{
    byte val;
    string tempStr = "";
    for (int i = 0; i <= byteArr.GetUpperBound(0); i++)
    {
        val = byteArr[i];
        if (val < (byte)10)
            tempStr += "00" + val.ToString();
        else if (val < (byte)100)
            tempStr += "0" + val.ToString();
        else
            tempStr += val.ToString();
    }
    return tempStr;
}

इसके लिए:

    public string ByteArrToString(byte[] byteArr)
    {
        string temp = "";
        foreach (byte b in byteArr)
            temp += b.ToString().PadLeft(3, '0');
        return temp;
    }

Answer 14

बिल्ट .Net क्रिप्टोग्राफी लाइब्रेरी का उपयोग करते हुए, यह उदाहरण दिखाता है कि उन्नत एन्क्रिप्शन स्टैंडर्ड (AES) का उपयोग कैसे करें।

using System;
using System.IO;
using System.Security.Cryptography;

namespace Aes_Example
{
    class AesExample
    {
        public static void Main()
        {
            try
            {

                string original = "Here is some data to encrypt!";

                // Create a new instance of the Aes
                // class.  This generates a new key and initialization 
                // vector (IV).
                using (Aes myAes = Aes.Create())
                {

                    // Encrypt the string to an array of bytes.
                    byte[] encrypted = EncryptStringToBytes_Aes(original, myAes.Key, myAes.IV);

                    // Decrypt the bytes to a string.
                    string roundtrip = DecryptStringFromBytes_Aes(encrypted, myAes.Key, myAes.IV);

                    //Display the original data and the decrypted data.
                    Console.WriteLine("Original:   {0}", original);
                    Console.WriteLine("Round Trip: {0}", roundtrip);
                }

            }
            catch (Exception e)
            {
                Console.WriteLine("Error: {0}", e.Message);
            }
        }
        static byte[] EncryptStringToBytes_Aes(string plainText, byte[] Key,byte[] IV)
        {
            // Check arguments.
            if (plainText == null || plainText.Length <= 0)
                throw new ArgumentNullException("plainText");
            if (Key == null || Key.Length <= 0)
                throw new ArgumentNullException("Key");
            if (IV == null || IV.Length <= 0)
                throw new ArgumentNullException("Key");
            byte[] encrypted;
            // Create an Aes object
            // with the specified key and IV.
            using (Aes aesAlg = Aes.Create())
            {
                aesAlg.Key = Key;
                aesAlg.IV = IV;

                // Create a decrytor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {

                            //Write all data to the stream.
                            swEncrypt.Write(plainText);
                        }
                        encrypted = msEncrypt.ToArray();
                    }
                }
            }


            // Return the encrypted bytes from the memory stream.
            return encrypted;

        }

        static string DecryptStringFromBytes_Aes(byte[] cipherText, byte[] Key, byte[] IV)
        {
            // Check arguments.
            if (cipherText == null || cipherText.Length <= 0)
                throw new ArgumentNullException("cipherText");
            if (Key == null || Key.Length <= 0)
                throw new ArgumentNullException("Key");
            if (IV == null || IV.Length <= 0)
                throw new ArgumentNullException("Key");

            // Declare the string used to hold
            // the decrypted text.
            string plaintext = null;

            // Create an Aes object
            // with the specified key and IV.
            using (Aes aesAlg = Aes.Create())
            {
                aesAlg.Key = Key;
                aesAlg.IV = IV;

                // Create a decrytor to perform the stream transform.
                ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for decryption.
                using (MemoryStream msDecrypt = new MemoryStream(cipherText))
                {
                    using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                        {

                            // Read the decrypted bytes from the decrypting stream
                            // and place them in a string.
                            plaintext = srDecrypt.ReadToEnd();
                        }
                    }
                }

            }

            return plaintext;

        }
    }
}

Answer 15

मुझे पता है कि आपने कहा था कि आप इस बारे में परवाह नहीं करते हैं कि यह कितना सुरक्षित है, लेकिन अगर आपने डेस चुना है तो आप एईएस ले सकते हैं यह अधिक अप-टू-डेट एन्क्रिप्शन विधि है।

Answer 16

मैं मार्क ब्रिटिंघम द्वारा स्वीकृत उत्तर का उपयोग कर रहा हूं और इसने मुझे बहुत मदद की है। हाल ही में मुझे एन्क्रिप्टेड टेक्स्ट को एक अलग संगठन में भेजना पड़ा और यहीं से कुछ मुद्दे सामने आए। ओपी को इन विकल्पों की आवश्यकता नहीं है, लेकिन चूंकि यह एक लोकप्रिय सवाल है जो मैं अपने संशोधन ( Encryptऔर यहांDecrypt से उधार लिया गया कार्य ) पोस्ट कर रहा हूं :

1. हर संदेश के लिए अलग-अलग IV - हेक्स प्राप्त करने से पहले सिफर बाइट्स को IV बाइट्स समेटता है। बेशक यह एक सम्मेलन है जिसे सिफर पाठ प्राप्त करने वाले दलों को बताना होगा।
2. दो कंस्ट्रक्टरों को अनुमति देता है - एक डिफ़ॉल्ट RijndaelManagedमानों के लिए, और एक जहां संपत्ति मूल्य निर्दिष्ट किए जा सकते हैं (एन्क्रिप्टिंग और डिक्रिप्टिंग पार्टियों के बीच आपसी समझौते के आधार पर)

यहाँ वर्ग है (अंत में परीक्षण नमूना):

/// <summary>
/// Based on https://msdn.microsoft.com/en-us/library/system.security.cryptography.rijndaelmanaged(v=vs.110).aspx
/// Uses UTF8 Encoding
///  http://security.stackexchange.com/a/90850
/// </summary>
public class AnotherAES : IDisposable
{
    private RijndaelManaged rijn;

    /// <summary>
    /// Initialize algo with key, block size, key size, padding mode and cipher mode to be known.
    /// </summary>
    /// <param name="key">ASCII key to be used for encryption or decryption</param>
    /// <param name="blockSize">block size to use for AES algorithm. 128, 192 or 256 bits</param>
    /// <param name="keySize">key length to use for AES algorithm. 128, 192, or 256 bits</param>
    /// <param name="paddingMode"></param>
    /// <param name="cipherMode"></param>
    public AnotherAES(string key, int blockSize, int keySize, PaddingMode paddingMode, CipherMode cipherMode)
    {
        rijn = new RijndaelManaged();
        rijn.Key = Encoding.UTF8.GetBytes(key);
        rijn.BlockSize = blockSize;
        rijn.KeySize = keySize;
        rijn.Padding = paddingMode;
        rijn.Mode = cipherMode;
    }

    /// <summary>
    /// Initialize algo just with key
    /// Defaults for RijndaelManaged class: 
    /// Block Size: 256 bits (32 bytes)
    /// Key Size: 128 bits (16 bytes)
    /// Padding Mode: PKCS7
    /// Cipher Mode: CBC
    /// </summary>
    /// <param name="key"></param>
    public AnotherAES(string key)
    {
        rijn = new RijndaelManaged();
        byte[] keyArray = Encoding.UTF8.GetBytes(key);
        rijn.Key = keyArray;
    }

    /// <summary>
    /// Based on https://msdn.microsoft.com/en-us/library/system.security.cryptography.rijndaelmanaged(v=vs.110).aspx
    /// Encrypt a string using RijndaelManaged encryptor.
    /// </summary>
    /// <param name="plainText">string to be encrypted</param>
    /// <param name="IV">initialization vector to be used by crypto algorithm</param>
    /// <returns></returns>
    public byte[] Encrypt(string plainText, byte[] IV)
    {
        if (rijn == null)
            throw new ArgumentNullException("Provider not initialized");

        // Check arguments.
        if (plainText == null || plainText.Length <= 0)
            throw new ArgumentNullException("plainText cannot be null or empty");
        if (IV == null || IV.Length <= 0)
            throw new ArgumentNullException("IV cannot be null or empty");
        byte[] encrypted;

        // Create a decrytor to perform the stream transform.
        using (ICryptoTransform encryptor = rijn.CreateEncryptor(rijn.Key, IV))
        {
            // Create the streams used for encryption.
            using (MemoryStream msEncrypt = new MemoryStream())
            {
                using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                {
                    using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                    {
                        //Write all data to the stream.
                        swEncrypt.Write(plainText);
                    }
                    encrypted = msEncrypt.ToArray();
                }
            }
        }
        // Return the encrypted bytes from the memory stream.
        return encrypted;
    }//end EncryptStringToBytes

    /// <summary>
    /// Based on https://msdn.microsoft.com/en-us/library/system.security.cryptography.rijndaelmanaged(v=vs.110).aspx
    /// </summary>
    /// <param name="cipherText">bytes to be decrypted back to plaintext</param>
    /// <param name="IV">initialization vector used to encrypt the bytes</param>
    /// <returns></returns>
    public string Decrypt(byte[] cipherText, byte[] IV)
    {
        if (rijn == null)
            throw new ArgumentNullException("Provider not initialized");

        // Check arguments.
        if (cipherText == null || cipherText.Length <= 0)
            throw new ArgumentNullException("cipherText cannot be null or empty");
        if (IV == null || IV.Length <= 0)
            throw new ArgumentNullException("IV cannot be null or empty");

        // Declare the string used to hold the decrypted text.
        string plaintext = null;

        // Create a decrytor to perform the stream transform.
        using (ICryptoTransform decryptor = rijn.CreateDecryptor(rijn.Key, IV))
        {
            // Create the streams used for decryption.
            using (MemoryStream msDecrypt = new MemoryStream(cipherText))
            {
                using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                    {
                        // Read the decrypted bytes from the decrypting stream and place them in a string.
                        plaintext = srDecrypt.ReadToEnd();
                    }
                }
            }
        }

        return plaintext;
    }//end DecryptStringFromBytes

    /// <summary>
    /// Generates a unique encryption vector using RijndaelManaged.GenerateIV() method
    /// </summary>
    /// <returns></returns>
    public byte[] GenerateEncryptionVector()
    {
        if (rijn == null)
            throw new ArgumentNullException("Provider not initialized");

        //Generate a Vector
        rijn.GenerateIV();
        return rijn.IV;
    }//end GenerateEncryptionVector


    /// <summary>
    /// Based on https://stackoverflow.com/a/1344255
    /// Generate a unique string given number of bytes required.
    /// This string can be used as IV. IV byte size should be equal to cipher-block byte size. 
    /// Allows seeing IV in plaintext so it can be passed along a url or some message.
    /// </summary>
    /// <param name="numBytes"></param>
    /// <returns></returns>
    public static string GetUniqueString(int numBytes)
    {
        char[] chars = new char[62];
        chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890".ToCharArray();
        byte[] data = new byte[1];
        using (RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider())
        {
            data = new byte[numBytes];
            crypto.GetBytes(data);
        }
        StringBuilder result = new StringBuilder(numBytes);
        foreach (byte b in data)
        {
            result.Append(chars[b % (chars.Length)]);
        }
        return result.ToString();
    }//end GetUniqueKey()

    /// <summary>
    /// Converts a string to byte array. Useful when converting back hex string which was originally formed from bytes.
    /// </summary>
    /// <param name="hex"></param>
    /// <returns></returns>
    public static byte[] StringToByteArray(String hex)
    {
        int NumberChars = hex.Length;
        byte[] bytes = new byte[NumberChars / 2];
        for (int i = 0; i < NumberChars; i += 2)
            bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
        return bytes;
    }//end StringToByteArray

    /// <summary>
    /// Dispose RijndaelManaged object initialized in the constructor
    /// </summary>
    public void Dispose()
    {
        if (rijn != null)
            rijn.Dispose();
    }//end Dispose()
}//end class

तथा..

यहाँ परीक्षण नमूना है:

class Program
{
    string key;
    static void Main(string[] args)
    {
        Program p = new Program();

        //get 16 byte key (just demo - typically you will have a predetermined key)
        p.key = AnotherAES.GetUniqueString(16);

        string plainText = "Hello World!";

        //encrypt
        string hex = p.Encrypt(plainText);

        //decrypt
        string roundTrip = p.Decrypt(hex);

        Console.WriteLine("Round Trip: {0}", roundTrip);
    }

    string Encrypt(string plainText)
    {
        Console.WriteLine("\nSending (encrypt side)...");
        Console.WriteLine("Plain Text: {0}", plainText);
        Console.WriteLine("Key: {0}", key);
        string hex = string.Empty;
        string ivString = AnotherAES.GetUniqueString(16);
        Console.WriteLine("IV: {0}", ivString);
        using (AnotherAES aes = new AnotherAES(key))
        {
            //encrypting side
            byte[] IV = Encoding.UTF8.GetBytes(ivString);

            //get encrypted bytes (IV bytes prepended to cipher bytes)
            byte[] encryptedBytes = aes.Encrypt(plainText, IV);
            byte[] encryptedBytesWithIV = IV.Concat(encryptedBytes).ToArray();

            //get hex string to send with url
            //this hex has both IV and ciphertext
            hex = BitConverter.ToString(encryptedBytesWithIV).Replace("-", "");
            Console.WriteLine("sending hex: {0}", hex);
        }

        return hex;
    }

    string Decrypt(string hex)
    {
        Console.WriteLine("\nReceiving (decrypt side)...");
        Console.WriteLine("received hex: {0}", hex);
        string roundTrip = string.Empty;
        Console.WriteLine("Key " + key);
        using (AnotherAES aes = new AnotherAES(key))
        {
            //get bytes from url
            byte[] encryptedBytesWithIV = AnotherAES.StringToByteArray(hex);

            byte[] IV = encryptedBytesWithIV.Take(16).ToArray();

            Console.WriteLine("IV: {0}", System.Text.Encoding.Default.GetString(IV));

            byte[] cipher = encryptedBytesWithIV.Skip(16).ToArray();

            roundTrip = aes.Decrypt(cipher, IV);
        }
        return roundTrip;
    }
}

Answer 17

मुझे लगता है कि यह दुनिया सबसे सरल है!

string encrypted = "Text".Aggregate("", (c, a) => c + (char) (a + 2));

परीक्षा

 Console.WriteLine(("Hello").Aggregate("", (c, a) => c + (char) (a + 1)));
            //Output is Ifmmp
 Console.WriteLine(("Ifmmp").Aggregate("", (c, a) => c + (char)(a - 1)));
            //Output is Hello

Comments

ROT ... 1? वास्तव में? ओपी ने ROT13 को भी बुलाया, जो वह नहीं करना चाहता था ।

— user812786