diff --git a/auth_algo.cpp b/auth_algo.cpp
index f062b0f..0bc2555 100644
--- a/auth_algo.cpp
+++ b/auth_algo.cpp
@@ -1,5 +1,6 @@
 #include "auth_algo.hpp"
 
+#include <openssl/evp.h>
 #include <openssl/hmac.h>
 #include <openssl/sha.h>
 
diff --git a/auth_algo.hpp b/auth_algo.hpp
index 997e2c9..b6fda94 100644
--- a/auth_algo.hpp
+++ b/auth_algo.hpp
@@ -92,6 +92,27 @@
         std::vector<uint8_t> virtual generateICV(
             const std::vector<uint8_t>& input) const = 0;
 
+        /**
+         * @brief Check if the Authentication algorithm is supported
+         *
+         * @param[in] algo - authentication algorithm
+         *
+         * @return true if algorithm is supported else false
+         *
+         */
+        static bool isAlgorithmSupported(Algorithms algo)
+        {
+            if (algo == Algorithms::RAKP_NONE ||
+                algo == Algorithms::RAKP_HMAC_SHA1)
+            {
+               return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
         // User Key is hardcoded to PASSW0RD till the IPMI User account
         // management is in place.
         std::array<uint8_t, USER_KEY_MAX_LENGTH> userKey = {"0penBmc"};
diff --git a/command/open_session.cpp b/command/open_session.cpp
index d29cbf1..f33de3c 100644
--- a/command/open_session.cpp
+++ b/command/open_session.cpp
@@ -19,8 +19,8 @@
     auto response = reinterpret_cast<OpenSessionResponse*>(outPayload.data());
 
     // Check for valid Authentication Algorithms
-    if (request->authAlgo != static_cast<uint8_t>
-        (cipher::rakp_auth::Algorithms::RAKP_HMAC_SHA1))
+    if (!cipher::rakp_auth::Interface::isAlgorithmSupported(
+                static_cast<cipher::rakp_auth::Algorithms>(request->authAlgo)))
     {
         response->status_code =
             static_cast<uint8_t>(RAKP_ReturnCode::INVALID_AUTH_ALGO);
@@ -28,8 +28,8 @@
     }
 
     // Check for valid Integrity Algorithms
-    if(!cipher::integrity::Interface::isAlgorithmSupported(static_cast
-                    <cipher::integrity::Algorithms>(request->intAlgo)))
+    if (!cipher::integrity::Interface::isAlgorithmSupported(
+                static_cast<cipher::integrity::Algorithms>(request->intAlgo)))
     {
         response->status_code =
             static_cast<uint8_t>(RAKP_ReturnCode::INVALID_INTEGRITY_ALGO);
diff --git a/command/rakp34.cpp b/command/rakp34.cpp
index 8c95e95..5ba9aa1 100644
--- a/command/rakp34.cpp
+++ b/command/rakp34.cpp
@@ -8,6 +8,7 @@
 #include "endian.hpp"
 #include "guid.hpp"
 #include "main.hpp"
+#include "rmcp.hpp"
 
 namespace command
 {
@@ -44,8 +45,11 @@
     {
         case cipher::crypt::Algorithms::AES_CBC_128:
         {
-            session->setCryptAlgo(std::make_unique<cipher::crypt::AlgoAES128>(
-                                 authAlgo->sessionIntegrityKey));
+            auto intAlgo = session->getIntegrityAlgo();
+            auto k2 = intAlgo->generateKn(
+                    authAlgo->sessionIntegrityKey, rmcp::const_2);
+            session->setCryptAlgo(
+                    std::make_unique<cipher::crypt::AlgoAES128>(k2));
             break;
         }
         default:
@@ -63,7 +67,7 @@
     auto response = reinterpret_cast<RAKP4response*>(outPayload.data());
 
     // Check if the RAKP3 Payload Length is as expected
-    if(inPayload.size() != sizeof(RAKP3request))
+    if (inPayload.size() < sizeof(RAKP3request))
     {
         std::cerr << "RAKP34: Invalid RAKP3 request\n";
         response->rmcpStatusCode =
@@ -145,8 +149,8 @@
     // Generate Key Exchange Authentication Code - RAKP2
     auto output = authAlgo->generateHMAC(input);
 
-    if (std::memcmp(output.data(), request->keyExchangeAuthCode,
-                    output.size()))
+    if (inPayload.size() != (sizeof(RAKP3request) + output.size()) ||
+            std::memcmp(output.data(), request+1, output.size()))
     {
         std::cerr << "Mismatch in HMAC sent by remote console\n";
 
diff --git a/command/rakp34.hpp b/command/rakp34.hpp
index deaf2e9..2f00823 100644
--- a/command/rakp34.hpp
+++ b/command/rakp34.hpp
@@ -19,7 +19,6 @@
     uint8_t rmcpStatusCode;
     uint16_t reserved;
     uint32_t managedSystemSessionID;
-    uint8_t keyExchangeAuthCode[20];
 } __attribute__((packed));
 
 /**
diff --git a/crypt_algo.cpp b/crypt_algo.cpp
index f33bca4..a10fd56 100644
--- a/crypt_algo.cpp
+++ b/crypt_algo.cpp
@@ -12,23 +12,6 @@
 namespace crypt
 {
 
-Interface::Interface(const std::vector<uint8_t>& sik, const key& addKey)
-{
-    unsigned int mdLen = 0;
-
-    // Generated K2 for the confidentiality algorithm with the additional key
-    // keyed with SIK.
-    k2.resize(sik.size());
-    if (HMAC(EVP_sha1(), sik.data(), sik.size(), addKey.data(),
-             addKey.size(), k2.data(), &mdLen) == NULL)
-    {
-        throw std::runtime_error("Generating K2 for confidentiality algorithm"
-                                 "failed");
-    }
-}
-
-constexpr key AlgoAES128::const2;
-
 constexpr std::array<uint8_t, AlgoAES128::AESCBC128BlockSize - 1>
         AlgoAES128::confPadBytes;
 
diff --git a/crypt_algo.hpp b/crypt_algo.hpp
index ccef7d8..ca4dbca 100644
--- a/crypt_algo.hpp
+++ b/crypt_algo.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
-#include <openssl/sha.h>
 #include <array>
+#include <cstdint>
 #include <vector>
 
 namespace cipher
@@ -10,8 +10,6 @@
 namespace crypt
 {
 
-using key = std::array<uint8_t, SHA_DIGEST_LENGTH>;
-
 /**
  * @enum Confidentiality Algorithms
  *
@@ -42,11 +40,9 @@
     public:
         /**
          * @brief Constructor for Interface
-         *
-         * @param[in] - Session Integrity key to generate K2
-         * @param[in] - Additional keying material to generate K2
          */
-        explicit Interface(const std::vector<uint8_t>& sik, const key& addKey);
+        explicit Interface(const std::vector<uint8_t>& k2)
+            : k2(k2) {}
 
         Interface() = delete;
         virtual ~Interface() = default;
@@ -129,25 +125,6 @@
         static constexpr size_t AESCBC128BlockSize = 16;
 
         /**
-         * RSP needs more keying material than can be provided by session
-         * integrity key alone. As a result all keying material for the RSP
-         * confidentiality algorithms will be generated by processing a
-         * pre-defined set of constants using HMAC per [RFC2104], keyed by SIK.
-         * These constants are constructed using a hexadecimal octet value
-         * repeated up to the HMAC block size in length starting with the
-         * constant 01h. This mechanism can be used to derive up to 255
-         * HMAC-block-length pieces of keying material from a single SIK.For the
-         * mandatory confidentiality algorithm AES-CBC-128, processing the
-         * following constant will generate the required amount of keying
-         * material.
-         */
-        static constexpr key const2 = { 0x02, 0x02, 0x02, 0x02, 0x02,
-                                        0x02, 0x02, 0x02, 0x02, 0x02,
-                                        0x02, 0x02, 0x02, 0x02, 0x02,
-                                        0x02, 0x02, 0x02, 0x02, 0x02
-                                       };
-
-        /**
          * If confidentiality bytes are present, the value of the first byte is
          * one (01h). and all subsequent bytes shall have a monotonically
          * increasing value (e.g., 02h, 03h, 04h, etc). The receiver, as an
@@ -166,7 +143,7 @@
          *
          * @param[in] - Session Integrity key
          */
-        explicit AlgoAES128(const std::vector<uint8_t>& sik) : Interface(sik, const2) {}
+        explicit AlgoAES128(const std::vector<uint8_t>& k2) : Interface(k2) {}
 
         AlgoAES128() = delete;
         ~AlgoAES128() = default;
diff --git a/integrity_algo.cpp b/integrity_algo.cpp
index 3a6c34d..62c2653 100644
--- a/integrity_algo.cpp
+++ b/integrity_algo.cpp
@@ -1,3 +1,4 @@
+#include <openssl/evp.h>
 #include <openssl/hmac.h>
 #include <openssl/sha.h>
 #include "integrity_algo.hpp"
@@ -9,21 +10,10 @@
 namespace integrity
 {
 
-Interface::Interface(const std::vector<uint8_t>& sik,
-                     const Key& addKey, size_t authLength)
+AlgoSHA1::AlgoSHA1(const std::vector<uint8_t>& sik)
+    : Interface(SHA1_96_AUTHCODE_LENGTH)
 {
-    unsigned int mdLen = 0;
-
-    // Generated K1 for the integrity algorithm with the additional key keyed
-    // with SIK.
-    if (HMAC(EVP_sha1(), sik.data(), sik.size(), addKey.data(),
-             addKey.size(), K1.data(), &mdLen) == NULL)
-    {
-        throw std::runtime_error("Generating Key1 for integrity "
-                                 "algorithm failed");
-    }
-
-    authCodeLength = authLength;
+    k1 = generateKn(sik, rmcp::const_1);
 }
 
 std::vector<uint8_t> AlgoSHA1::generateHMAC(const uint8_t* input,
@@ -32,7 +22,7 @@
     std::vector<uint8_t> output(SHA_DIGEST_LENGTH);
     unsigned int mdLen = 0;
 
-    if (HMAC(EVP_sha1(), K1.data(), K1.size(), input, len,
+    if (HMAC(EVP_sha1(), k1.data(), k1.size(), input, len,
              output.data(), &mdLen) == NULL)
     {
         throw std::runtime_error("Generating integrity data failed");
@@ -70,6 +60,23 @@
             packet.size() - message::parser::RMCP_SESSION_HEADER_SIZE);
 }
 
+std::vector<uint8_t> AlgoSHA1::generateKn(const std::vector<uint8_t>& sik,
+        const rmcp::Const_n& const_n) const
+{
+    unsigned int mdLen = 0;
+    std::vector<uint8_t> Kn(sik.size());
+
+    // Generated Kn for the integrity algorithm with the additional key keyed
+    // with SIK.
+    if (HMAC(EVP_sha1(), sik.data(), sik.size(), const_n.data(),
+             const_n.size(), Kn.data(), &mdLen) == NULL)
+    {
+        throw std::runtime_error("Generating KeyN for integrity "
+                                 "algorithm failed");
+    }
+    return Kn;
+}
+
 }// namespace integrity
 
 }// namespace cipher
diff --git a/integrity_algo.hpp b/integrity_algo.hpp
index 0d869c7..3e003b6 100644
--- a/integrity_algo.hpp
+++ b/integrity_algo.hpp
@@ -1,8 +1,8 @@
 #pragma once
 
-#include <openssl/sha.h>
 #include <array>
 #include <vector>
+#include "rmcp.hpp"
 
 namespace cipher
 {
@@ -10,25 +10,6 @@
 namespace integrity
 {
 
-using Key = std::array<uint8_t, SHA_DIGEST_LENGTH>;
-
-/*
- * RSP needs more keying material than can be provided by session integrity key
- * alone. As a result all keying material for the RSP integrity algorithms
- * will be generated by processing a pre-defined set of constants using HMAC per
- * [RFC2104], keyed by SIK. These constants are constructed using a hexadecimal
- * octet value repeated up to the HMAC block size in length starting with the
- * constant 01h. This mechanism can be used to derive up to 255
- * HMAC-block-length pieces of keying material from a single SIK. For the
- * mandatory integrity algorithm HMAC-SHA1-96, processing the following
- * constant will generate the required amount of keying material.
- */
-constexpr Key const1 = { 0x01, 0x01, 0x01, 0x01, 0x01,
-                         0x01, 0x01, 0x01, 0x01, 0x01,
-                         0x01, 0x01, 0x01, 0x01, 0x01,
-                         0x01, 0x01, 0x01, 0x01, 0x01
-                       };
-
 /**
  * @enum Integrity Algorithms
  *
@@ -61,13 +42,10 @@
         /**
          * @brief Constructor for Interface
          *
-         * @param[in] - Session Integrity Key to generate K1
-         * @param[in] - Additional keying material to generate K1
          * @param[in] - AuthCode length
          */
-        explicit Interface(const std::vector<uint8_t>& sik,
-                           const Key& addKey,
-                           size_t authLength);
+        explicit Interface(size_t authLength)
+            : authCodeLength(authLength) {}
 
         Interface() = delete;
         virtual ~Interface() = default;
@@ -122,6 +100,34 @@
             }
         }
 
+        /**
+         * @brief Generate additional keying material based on SIK
+         *
+         * @note
+         * The IPMI 2.0 spec only states that the additional keying material is
+         * generated by running HMAC(constN) using SIK as the key. It does not
+         * state whether this is the integrity algorithm or the authentication
+         * algorithm. Other implementations of the RMCP+ algorithm (ipmitool
+         * and ipmiutil) are not consistent on this matter. But it does not
+         * really matter because based on any of the defined cipher suites, the
+         * integrity and authentication algorithms are both based on the same
+         * digest method (integrity::Algorithms::HMAC_SHA1_96 uses SHA1 and
+         * rakp_auth::Algorithms::RAKP_HMAC_SHA1 uses SHA1). None of the
+         * defined cipher suites mix and match digests for integrity and
+         * authentication. Generating Kn belongs in either the integrity or
+         * authentication classes, so in this implementation, integrity has
+         * been chosen.
+         *
+         * @param[in] sik - session integrity key
+         * @param[in] data - 20-byte Const_n
+         *
+         * @return on success returns the Kn based on this integrity class
+         *
+         */
+        std::vector<uint8_t> virtual generateKn(
+                const std::vector<uint8_t>& sik,
+                const rmcp::Const_n& data) const = 0;
+
         /** @brief Authcode field
          *
          *  AuthCode field length varies based on the integrity algorithm, for
@@ -133,7 +139,7 @@
     protected:
 
         /** @brief K1 key used to generated the integrity data. */
-        Key K1;
+        std::vector<uint8_t> k1;
 };
 
 /**
@@ -157,8 +163,7 @@
          *
          * @param[in] - Session Integrity Key
          */
-        explicit AlgoSHA1(const std::vector<uint8_t>& sik) :
-            Interface(sik, const1, SHA1_96_AUTHCODE_LENGTH) {}
+        explicit AlgoSHA1(const std::vector<uint8_t>& sik);
 
         AlgoSHA1() = delete;
         ~AlgoSHA1() = default;
@@ -195,6 +200,19 @@
         std::vector<uint8_t> generateIntegrityData(
                 const std::vector<uint8_t>& packet) const override;
 
+        /**
+         * @brief Generate additional keying material based on SIK
+         *
+         * @param[in] sik - session integrity key
+         * @param[in] data - 20-byte Const_n
+         *
+         * @return on success returns the Kn based on HMAC-SHA1
+         *
+         */
+        std::vector<uint8_t> generateKn(
+                const std::vector<uint8_t>& sik,
+                const rmcp::Const_n& const_n) const;
+
     private:
         /**
          * @brief Generate HMAC based on HMAC-SHA1-96 algorithm
diff --git a/rmcp.hpp b/rmcp.hpp
new file mode 100644
index 0000000..fd536cb
--- /dev/null
+++ b/rmcp.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <array>
+#include <cstdint>
+
+namespace rmcp
+{
+
+/*
+ * RSP needs more keying material than can be provided by session
+ * integrity key alone. As a result all keying material for the RSP
+ * confidentiality algorithms will be generated by processing a
+ * pre-defined set of constants using HMAC per [RFC2104], keyed by SIK.
+ * These constants are constructed using a hexadecimal octet value
+ * repeated up to the HMAC block size in length starting with the
+ * constant 01h. This mechanism can be used to derive up to 255
+ * HMAC-block-length pieces of keying material from a single SIK.For the
+ * mandatory confidentiality algorithm AES-CBC-128, processing the
+ * following constant will generate the required amount of keying
+ * material.
+ */
+constexpr size_t CONST_N_SIZE = 20;
+using Const_n = std::array<uint8_t, CONST_N_SIZE>;
+
+static constexpr Const_n const_1 = {
+    0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01
+};
+
+static constexpr Const_n const_2 = {
+    0x02, 0x02, 0x02, 0x02, 0x02,
+    0x02, 0x02, 0x02, 0x02, 0x02,
+    0x02, 0x02, 0x02, 0x02, 0x02,
+    0x02, 0x02, 0x02, 0x02, 0x02
+};
+
+} // namespace rmcp
diff --git a/sessions_manager.cpp b/sessions_manager.cpp
index ee4a35f..ddeca4c 100644
--- a/sessions_manager.cpp
+++ b/sessions_manager.cpp
@@ -64,7 +64,7 @@
         }
         while (1);
 
-        // Set the Authentication Algorithm to RAKP_HMAC_SHA1
+        // Set the Authentication Algorithm
         switch (authAlgo)
         {
             case cipher::rakp_auth::Algorithms::RAKP_HMAC_SHA1:
diff --git a/test/cipher.cpp b/test/cipher.cpp
index f10c8a0..ed8ccb7 100644
--- a/test/cipher.cpp
+++ b/test/cipher.cpp
@@ -7,6 +7,7 @@
 #include "crypt_algo.hpp"
 #include "integrity_algo.hpp"
 #include "message_parsers.hpp"
+#include "rmcp.hpp"
 #include <gtest/gtest.h>
 
 TEST(IntegrityAlgo, HMAC_SHA1_96_GenerateIntegrityDataCheck)
@@ -19,7 +20,7 @@
 
     // Hardcoded Session Integrity Key
     std::vector<uint8_t> sik = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
-                                 13, 14, 15, 16};
+                                 13, 14, 15, 16, 17, 18, 19, 20 };
 
     auto algoPtr = std::make_unique<cipher::integrity::AlgoSHA1>(sik);
 
@@ -34,18 +35,18 @@
     /*
      * Step-2 Generate Integrity data using OpenSSL SHA1 algorithm
      */
-    cipher::integrity::Key K1;
-    constexpr cipher::integrity::Key const1 = { 0x01, 0x01, 0x01, 0x01, 0x01,
-                                                0x01, 0x01, 0x01, 0x01, 0x01,
-                                                0x01, 0x01, 0x01, 0x01, 0x01,
-                                                0x01, 0x01, 0x01, 0x01, 0x01
-                                              };
+    std::vector<uint8_t> k1(SHA_DIGEST_LENGTH);
+    constexpr rmcp::Const_n const1 = { 0x01, 0x01, 0x01, 0x01, 0x01,
+                                       0x01, 0x01, 0x01, 0x01, 0x01,
+                                       0x01, 0x01, 0x01, 0x01, 0x01,
+                                       0x01, 0x01, 0x01, 0x01, 0x01
+                                     };
 
     // Generated K1 for the integrity algorithm with the additional key keyed
     // with SIK.
     unsigned int mdLen = 0;
     if (HMAC(EVP_sha1(), sik.data(), sik.size(), const1.data(),
-             const1.size(), K1.data(), &mdLen) == NULL)
+             const1.size(), k1.data(), &mdLen) == NULL)
     {
         FAIL() << "Generating Key1 failed";
     }
@@ -54,7 +55,7 @@
     std::vector<uint8_t> output(SHA_DIGEST_LENGTH);
     size_t length = packet.size() - message::parser::RMCP_SESSION_HEADER_SIZE;
 
-    if (HMAC(EVP_sha1(), K1.data(), K1.size(),
+    if (HMAC(EVP_sha1(), k1.data(), k1.size(),
              packet.data() + message::parser::RMCP_SESSION_HEADER_SIZE,
              length,
              output.data(), &mdLen) == NULL)
@@ -83,20 +84,20 @@
 
     // Hardcoded Session Integrity Key
     std::vector<uint8_t> sik = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
-                                 13, 14, 15, 16};
+                                 13, 14, 15, 16, 17, 18, 19, 20 };
 
-    cipher::integrity::Key K1;
-    constexpr cipher::integrity::Key const1 = { 0x01, 0x01, 0x01, 0x01, 0x01,
-                                                0x01, 0x01, 0x01, 0x01, 0x01,
-                                                0x01, 0x01, 0x01, 0x01, 0x01,
-                                                0x01, 0x01, 0x01, 0x01, 0x01
-                                              };
+    std::vector<uint8_t> k1(SHA_DIGEST_LENGTH);
+    constexpr rmcp::Const_n const1 = { 0x01, 0x01, 0x01, 0x01, 0x01,
+                                       0x01, 0x01, 0x01, 0x01, 0x01,
+                                       0x01, 0x01, 0x01, 0x01, 0x01,
+                                       0x01, 0x01, 0x01, 0x01, 0x01
+                                     };
 
     // Generated K1 for the integrity algorithm with the additional key keyed
     // with SIK.
     unsigned int mdLen = 0;
     if (HMAC(EVP_sha1(), sik.data(), sik.size(), const1.data(),
-             const1.size(), K1.data(), &mdLen) == NULL)
+             const1.size(), k1.data(), &mdLen) == NULL)
     {
         FAIL() << "Generating Key1 failed";
     }
@@ -105,7 +106,7 @@
     std::vector<uint8_t> output(SHA_DIGEST_LENGTH);
     size_t length = packet.size() - message::parser::RMCP_SESSION_HEADER_SIZE;
 
-    if (HMAC(EVP_sha1(), K1.data(), K1.size(),
+    if (HMAC(EVP_sha1(), k1.data(), k1.size(),
              packet.data() + message::parser::RMCP_SESSION_HEADER_SIZE,
              length,
              output.data(), &mdLen) == NULL)
@@ -163,7 +164,7 @@
 
     // Hardcoded Session Integrity Key
     std::vector<uint8_t> sik = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
-                                 13, 14, 15, 16};
+                                 13, 14, 15, 16, 17, 18, 19, 20 };
 
     auto algoPtr = std::make_unique<cipher::integrity::AlgoSHA1>(sik);
 
@@ -189,9 +190,25 @@
 
     // Hardcoded Session Integrity Key
     std::vector<uint8_t> sik = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
-                                 13, 14, 15, 16};
+                                 13, 14, 15, 16, 17, 18, 19, 20 };
 
-    auto cryptPtr = std::make_unique<cipher::crypt::AlgoAES128>(sik);
+    std::vector<uint8_t> k2(SHA_DIGEST_LENGTH);
+    unsigned int mdLen = 0;
+    constexpr rmcp::Const_n const1 = { 0x02, 0x02, 0x02, 0x02, 0x02,
+                                       0x02, 0x02, 0x02, 0x02, 0x02,
+                                       0x02, 0x02, 0x02, 0x02, 0x02,
+                                       0x02, 0x02, 0x02, 0x02, 0x02
+                                     };
+
+    // Generated K2 for the confidentiality algorithm with the additional key
+    // keyed with SIK.
+    if (HMAC(EVP_sha1(), sik.data(), sik.size(), const1.data(),
+             const1.size(), k2.data(), &mdLen) == NULL)
+    {
+        FAIL() << "Generating K2 for confidentiality algorithm failed";
+    }
+
+    auto cryptPtr = std::make_unique<cipher::crypt::AlgoAES128>(k2);
 
     ASSERT_EQ(true, (cryptPtr != NULL));
 
@@ -204,22 +221,6 @@
 
     EVP_CIPHER_CTX ctx;
     EVP_CIPHER_CTX_init(&ctx);
-    cipher::crypt::key k2;
-    unsigned int mdLen = 0;
-    constexpr cipher::crypt::key const1 = { 0x02, 0x02, 0x02, 0x02, 0x02,
-                                            0x02, 0x02, 0x02, 0x02, 0x02,
-                                            0x02, 0x02, 0x02, 0x02, 0x02,
-                                            0x02, 0x02, 0x02, 0x02, 0x02
-                                          };
-
-    // Generated K2 for the confidentiality algorithm with the additional key
-    // keyed with SIK.
-    if (HMAC(EVP_sha1(), sik.data(), sik.size(), const1.data(),
-             const1.size(), k2.data(), &mdLen) == NULL)
-    {
-        FAIL() << "Generating K2 for confidentiality algorithm failed";
-    }
-
     if (!EVP_DecryptInit_ex(&ctx, EVP_aes_128_cbc(), NULL, k2.data(),
                             cipher.data()))
     {
@@ -266,16 +267,16 @@
 
     // Hardcoded Session Integrity Key
     std::vector<uint8_t> sik = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
-                                 13, 14, 15, 16};
+                                 13, 14, 15, 16, 17, 18, 19, 20 };
     EVP_CIPHER_CTX ctx;
     EVP_CIPHER_CTX_init(&ctx);
-    cipher::crypt::key k2;
+    std::vector<uint8_t> k2(SHA_DIGEST_LENGTH);
     unsigned int mdLen = 0;
-    constexpr cipher::crypt::key const1 = { 0x02, 0x02, 0x02, 0x02, 0x02,
-                                            0x02, 0x02, 0x02, 0x02, 0x02,
-                                            0x02, 0x02, 0x02, 0x02, 0x02,
-                                            0x02, 0x02, 0x02, 0x02, 0x02
-                                          };
+    constexpr rmcp::Const_n const1 = { 0x02, 0x02, 0x02, 0x02, 0x02,
+                                       0x02, 0x02, 0x02, 0x02, 0x02,
+                                       0x02, 0x02, 0x02, 0x02, 0x02,
+                                       0x02, 0x02, 0x02, 0x02, 0x02
+                                     };
     std::vector<uint8_t> output(
             payload.size() + cipher::crypt::AlgoAES128::AESCBC128BlockSize);
 
@@ -322,7 +323,7 @@
      * AES-CBC-128
      */
 
-    auto cryptPtr = std::make_unique<cipher::crypt::AlgoAES128>(sik);
+    auto cryptPtr = std::make_unique<cipher::crypt::AlgoAES128>(k2);
 
     ASSERT_EQ(true, (cryptPtr != NULL));