{"id":1468,"date":"2010-12-15T16:47:16","date_gmt":"2010-12-15T20:47:16","guid":{"rendered":"http:\/\/www.acarlstein.com\/?p=1468"},"modified":"2010-12-15T19:53:36","modified_gmt":"2010-12-15T23:53:36","slug":"introduction-to-network-security-part-11","status":"publish","type":"post","link":"http:\/\/blog.acarlstein.com\/?p=1468","title":{"rendered":"Introduction to Network Security – Part 11"},"content":{"rendered":"

NOTIFICATION:<\/strong> <\/strong>These examples are provided for educational purposes. The use of this code and\/or information is under your own responsibility and risk. The information and\/or code is given \u2018as is\u2019. I do not take responsibilities of how they are used. You are welcome to point out any mistakes in my posting and\/or leave a comment.<\/p>\n

Key Distribution Using Public-Key Cryptography<\/strong><\/p>\n

In the previous post, introduction to network security – part 10, we saw three main methods of public-key:<\/p>\n

    \n
  1. Public announcement,<\/li>\n
  2. Public-key authority, and<\/li>\n
  3. Public-key certificates<\/li>\n<\/ol>\n

    These methods can be used for encryption and decryption of messages (secrecy) and\/or authentication.<\/p>\n

    These methods the disadvantage of being slow; therefore, its common to use symmetric-key encryption for secrecy and distribute using public-key encryption session keys. In this way we use the advantage of the speed of symmetric-key encryption and the security of public-key encryption.<\/p>\n

    Simple Key Distribution<\/strong><\/p>\n

    In 1979,\u00a0 Ralph C. Merkle created his thesis entitled “Secrecy, authentication and public key systems” which let him receive his Ph. D. in Electrical Engineering at Stanford University <http:\/\/en.wikipedia.org\/wiki\/Ralph_Merkle<\/a>>.<\/p>\n

    For a key distribution, Merkle proposed:<\/p>\n

      \n
    1. User A will generate a new temporaty public key pair, PUa<\/em><\/span><\/li>\n
    2. User A send the public key, PUa<\/em><\/span>, to user B together with its identity, IDa
      \nPUa, IDa
      \n<\/em><\/span><\/li>\n
    3. User B generate the session key K<\/em><\/span>.<\/li>\n
    4. User B uses the public key, PUa<\/em><\/span>, supplied by user A to encrypt the session key K<\/em><\/span>. Then user B send the encrypted session to user A<\/li>\n
    5. User A decrypt the message to obtain the session key K<\/em><\/span>.<\/li>\n
    6. User A discards the public key PUa<\/span><\/em><\/li>\n
    7. User B discards user A’s public key, PUa<\/em><\/span>.<\/li>\n
    8. After the exchange of information is complete, user A and B discard the session key K<\/em><\/span>.<\/li>\n<\/ol>\n

      \"\"<\/a><\/p>\n

      The Man-In-The-Middle Attack<\/span><\/p>\n

      This type of key distribution have a disadvantage.\u00a0 Lets assume that we have an attacker that gets in the middle of the communication in a way that this attacker can intercept the messages and then replay this message, modify this message, or send another different message.<\/p>\n

      \"\"<\/a><\/p>\n

      Lets analyse this problem:<\/p>\n

        \n
      1. User A send a message to user B which holds the public key PUa<\/span>, and user A’s identifier IDa<\/span><\/li>\n
      2. The attacker T<\/span> intercept this message and create its own pair keys, public key PUt<\/span><\/em> and private key PRt<\/span><\/em>:
        \n{PUt, PRt}<\/span><\/em> <\/span>
        \n<\/span><\/li>\n
      3. The attacker T send to user B, its own public key PUt<\/em><\/span> together with the user A’s identification IDa<\/em><\/span> :
        \nPUt||IDa<\/em><\/span><\/li>\n
      4. User B generate a session key Ks<\/em><\/span>. Then user B send this session key Ks<\/span> encrypted using the public-key PUt<\/em><\/span> that he received thinking that it came from user A.
        \nCiphertext = E(PUt, Ks)<\/em><\/span><\/li>\n
      5. The attacker T intercept the message obtaining the session key Ks<\/span><\/em> by decrypting the message with his private key PRt<\/em><\/span>.
        \nKs = D(PRt, Ciphertext) = D(PRt, E(PUt, Ks))<\/em><\/span><\/li>\n
      6. Then attacker T send the key session Ks<\/em><\/span> to the user A using user A’s public key PUa<\/em><\/span><\/li>\n
      7. Without user A and B knowing, the attacket T obtained the session Ks<\/em><\/span> successfully.<\/li>\n<\/ol>\n

        \"\"<\/a><\/em><\/p>\n

        Solution to The Man-In-The-Middle Attack<\/span><\/p>\n

          \n
        1. The process begins with user A. User A encrypt the message containing the user A identification IDa<\/em><\/span> plus a nonce N1<\/span> using the user B’s public key PUb<\/span><\/li>\n
        2. User B generate a new nonce N2<\/span><\/em> and encrypts the message containing user A’s nonce N1<\/span><\/em> plus a new nonce N2<\/span><\/em> using the user A’s public key.
          \n<\/span><\/span><\/span><\/li>\n
        3. Since user B is the only one that could decrypted the first message coming from user A plus the new message send from user B to user A will contain the nonce N1<\/em><\/span> (given by\u00a0 user A in the first message<\/span><\/span>), user A will know the new message is coming from user B and not an attacker.<\/span><\/span><\/li>\n
        4. User A will encrypt nonce N2<\/em><\/span> using the public key PUb<\/em><\/span> of user B. Then user A will send then encrypted nonce N2<\/em><\/span> to user B. In this way, since nonce N2<\/span><\/em> was generated by user B, when user B find nonce N2<\/span><\/em>, user B will known the message came from user A.<\/span><\/span><\/li>\n
        5. User A generate a secret key Ks<\/em><\/span>. User A will encrypt first the secret key Ks<\/em><\/span> using the private key PUa<\/em><\/span> of user A which would provide authentication, and then it will encrypt the output of the encryption with the public key PUb<\/span><\/em> of user B to produce a new ciphertext M<\/em><\/span> which provide confidentiality.<\/span><\/span><\/li>\n
        6. User B decrypt the ciphertext M<\/span><\/em> by decrypting the ciphertext M<\/span><\/em> using the private key PUb<\/em><\/span> of userB, and the result will be decrypted again using the public key PUa<\/em><\/span> of user A. In this way the secret key Ks<\/span><\/em> is obtained.<\/span><\/span><\/li>\n<\/ol>\n

          \"\"<\/a><\/p>\n

          Hybrid Key Distribution<\/strong><\/span><\/p>\n

          Public key encryption is an algorithm that require a lot of processing. In a system that require to distribute session keys thought many users and require a frequently change of session keys, the public key encryption can slow the performance of the system as the load on the system keep increasing. One solution to this problem is to use an hybrid of different key distribution.<\/span><\/p>\n

          In an hybrid key distribution, the key distribution center (KDC) will be in charge of distributing a master key MK<\/em><\/span> to each user of the system plus perform the distribution of session keys. Before these session keys are distributed, they will be encrypted by using the master key MK<\/span><\/em>. Also, the master key is encrypted using a public key encryption. Since the master key only update in few occasions then the load of the system is reduced.<\/span><\/p>\n\n