RFC2898DeriveBytes एईएस कुंजी कैसे उत्पन्न करता है?

Question

मैं की तरह

string password = "11111111"; 
byte[] salt = Encoding.ASCII.GetBytes("22222222"); 
Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(password, salt); 
RijndaelAlg.Key = key.GetBytes(RijndaelAlg.KeySize/8); 

कुछ कोड देखा मैं देख सकता हूँ कुंजी पदबंध और नमक के साथ Rfc2898DeriveBytes द्वारा उत्पन्न होता है। फिर एईएस GetBytes द्वारा कुंजी पुनर्प्राप्त करता है।

लेकिन सवाल यह है कि आरएफसी 28 9 8 डेरिवेट्स और क्या कुंजी है। गेटबाइट्स (सीबी) क्या करते हैं? क्या कोई इसे विस्तारित कर सकता है? मैं इसे दस्तावेज़ीकरण से नहीं प्राप्त कर सका।

Answer 1

आरएफसी 28 9 8 सितंबर 2000 में प्रकाशित पासवर्ड-आधारित क्रिप्टोग्राफी विनिर्देश को संदर्भित करता है। प्रभावी रूप से, Rfc2898DeriveBytes कुंजी उत्पन्न करने के लिए एक पासवर्ड और नमक लेता है। जिस विधि का उपयोग वह पीबीकेडीएफ 2 (पासवर्ड आधारित कुंजी व्युत्पन्न समारोह # 2) के रूप में जाना जाता है और आरएफसी 28 9 8 की धारा 5.2 में परिभाषित किया गया है। सेक्शन 5.2:

पीबीकेडीएफ 2 एक छद्म यादृच्छिक फ़ंक्शन लागू करता है (उदाहरण के लिए परिशिष्ट बी .1 देखें) कुंजी प्राप्त करने के लिए। व्युत्पन्न कुंजी की लंबाई अनिवार्य रूप से असंबद्ध है। (हालांकि, व्युत्पन्न कुंजी के लिए अधिकतम प्रभावी खोज स्थान अंतर्निहित छद्म यादृच्छिक फ़ंक्शन की संरचना द्वारा सीमित हो सकता है। आगे की चर्चा के लिए परिशिष्ट बी .1 देखें।) नए अनुप्रयोगों के लिए पीबीकेडीएफ 2 की अनुशंसा की जाती है।

अधिक जानकारी के लिए, RFC2898 देखें।

Rfc2898DeriveBytes.GetBytes क्या करता है, यह प्रत्येक आमंत्रण पर एक अलग कुंजी देता है; यह प्रभावी ढंग से उसी पासवर्ड और नमक के साथ पीबीकेडीएफ 2 को बार-बार लागू करता है लेकिन एक पुनरावृत्ति गणना भी करता है।

यह आरएफसी दस्तावेज़ में उल्लिखित है जहां PBKDF2

PBKDF2 (P, S, c, dkLen) 

जहां P पासवर्ड के रूप में परिभाषित किया गया है, S, नमक है c पुनरावृत्ति संख्या है और dkLen इच्छित कुंजी की लंबाई है।

RFCs सामान्य रूप से बहुत ही रोचक और ऐतिहासिक रूप से काफी महत्वपूर्ण हैं। RFC 1149 काफी महत्वपूर्ण है, जैसा कि RFC 2324 है।

Answer 2

परावर्तक में कार्यान्वयन को देखकर से:

public Rfc2898DeriveBytes(string password, byte[] salt) : this(password, salt, 0x3e8) 
{ 
} 

public Rfc2898DeriveBytes(string password, int saltSize, int iterations) 
{ 
    if (saltSize < 0) 
    { 
     throw new ArgumentOutOfRangeException("saltSize", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); 
    } 
    byte[] data = new byte[saltSize]; 
    Utils.StaticRandomNumberGenerator.GetBytes(data); 
    this.Salt = data; 
    this.IterationCount = iterations; 
    this.m_hmacsha1 = new HMACSHA1(new UTF8Encoding(false).GetBytes(password)); 
    this.Initialize(); 
} 


public override byte[] GetBytes(int cb) 
{ 
    if (cb <= 0) 
    { 
     throw new ArgumentOutOfRangeException("cb", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); 
    } 
    byte[] dst = new byte[cb]; 
    int dstOffset = 0; 
    int count = this.m_endIndex - this.m_startIndex; 
    if (count > 0) 
    { 
     if (cb < count) 
     { 
      Buffer.InternalBlockCopy(this.m_buffer, this.m_startIndex, dst, 0, cb); 
      this.m_startIndex += cb; 
      return dst; 
     } 
     Buffer.InternalBlockCopy(this.m_buffer, this.m_startIndex, dst, 0, count); 
     this.m_startIndex = this.m_endIndex = 0; 
     dstOffset += count; 
    } 
    while (dstOffset < cb) 
    { 
     byte[] src = this.Func(); 
     int num3 = cb - dstOffset; 
     if (num3 > 20) 
     { 
      Buffer.InternalBlockCopy(src, 0, dst, dstOffset, 20); 
      dstOffset += 20; 
     } 
     else 
     { 
      Buffer.InternalBlockCopy(src, 0, dst, dstOffset, num3); 
      dstOffset += num3; 
      Buffer.InternalBlockCopy(src, num3, this.m_buffer, this.m_startIndex, 20 - num3); 
      this.m_endIndex += 20 - num3; 
      return dst; 
     } 
    } 
    return dst; 
}