MAC-ek (Message Authentication Codes), kivonatok és aláírások

Ez a cikk azt ismerteti, hogyan használhatók az üzenethitelesítési kódok (MACs), a kivonatok és az aláírások a WinUI-alkalmazásokban az üzenetek illetéktelen befolyásolásának észlelésére.

Üzenethitelesítési kódok (MACs)

A titkosítás segít megakadályozni, hogy egy jogosulatlan személy elolvassa az üzenetet, de ez nem akadályozza meg, hogy az adott személy illetéktelen beavatkozást végez az üzeneten. Egy módosított üzenetnek, még ha a módosítás eredménye pusztán értelmetlen is, valós költségei lehetnek. Az üzenethitelesítési kód (MAC) segít megakadályozni az üzenetek manipulálását. Vegyük például a következő forgatókönyvet:

• Bob és Alice megosztanak egy titkos kulcsot, és megállapodnak a használni kívánt MAC-függvényről.
• Bob létrehoz egy üzenetet, és beírja az üzenetet és a titkos kulcsot egy MAC-függvénybe egy MAC-érték lekéréséhez.
• Bob elküldi a [titkosítatlan] üzenetet és a MAC-értéket Alice-nek egy hálózaton keresztül.
• Alice a titkos kulcsot és az üzenetet használja a MAC-függvény bemeneteként. Összehasonlítja a létrehozott MAC-értéket a Bob által küldött MAC-értékkel. Ha megegyeznek, az üzenet nem módosult az átvitel során.

Vegye figyelembe, hogy Éva, egy harmadik fél, aki lehallgatta Bob és Alice beszélgetését, nem tudja hatékonyan manipulálni az üzenetet. Éva nem rendelkezik hozzáféréssel a titkos kulcshoz, ezért nem hozhat létre OLYAN MAC-értéket, amely az illetéktelen üzenetet Alice számára jogszerűnek tenné.

Az üzenethitelesítési kód létrehozása csak azt biztosítja, hogy az eredeti üzenet ne legyen módosítva, és megosztott titkos kulcs használatával azt, hogy az üzenet kivonatát valaki aláírta, aki hozzáfért a titkos kulcshoz.

A MacAlgorithmProvider használatával számba vehetők az elérhető MAC-algoritmusok, és létrehozhat egy szimmetrikus kulcsot. A CryptographicEngine osztály statikus metódusaival végrehajthatja a MAC-értéket létrehozó szükséges titkosítást.

A digitális aláírások a titkos kulcsú üzenethitelesítési kódok (MAC-k) nyilvános kulcsának megfelelői. Bár a MAC-ek titkos kulcsokat használnak annak lehetővé tételére, hogy az üzenet címzettjei ellenőrizhessék, nem-e módosult az üzenet az átvitel során, az aláírások privát/nyilvános kulcspárt használnak.

Ez a példakód bemutatja, hogyan hozhat létre kivonatolt üzenethitelesítési kódot (HMAC) a MacAlgorithmProvider osztály használatával.

using Windows.Security.Cryptography;
using Windows.Security.Cryptography.Core;
using Windows.Storage.Streams;

namespace SampleMacAlgorithmProvider
{
    sealed partial class MacAlgProviderApp : Application
    {
        public MacAlgProviderApp()
        {
            // Initialize the application.
            this.InitializeComponent();

            // Initialize the hashing process.
            String strMsg = "This is a message to be authenticated";
            String strAlgName = MacAlgorithmNames.HmacSha384;
            IBuffer buffMsg;
            CryptographicKey hmacKey;
            IBuffer buffHMAC;

            // Create a hashed message authentication code (HMAC)
            this.CreateHMAC(
                strMsg,
                strAlgName,
                out buffMsg,
                out hmacKey,
                out buffHMAC);

            // Verify the HMAC.
            this.VerifyHMAC(
                buffMsg,
                hmacKey,
                buffHMAC);
        }

        void CreateHMAC(
            String strMsg,
            String strAlgName,
            out IBuffer buffMsg,
            out CryptographicKey hmacKey,
            out IBuffer buffHMAC)
        {
            // Create a MacAlgorithmProvider object for the specified algorithm.
            MacAlgorithmProvider objMacProv = MacAlgorithmProvider.OpenAlgorithm(strAlgName);

            // Demonstrate how to retrieve the name of the algorithm used.
            String strNameUsed = objMacProv.AlgorithmName;

            // Create a buffer that contains the message to be signed.
            BinaryStringEncoding encoding = BinaryStringEncoding.Utf8;
            buffMsg = CryptographicBuffer.ConvertStringToBinary(strMsg, encoding);

            // Create a key to be signed with the message.
            IBuffer buffKeyMaterial = CryptographicBuffer.GenerateRandom(objMacProv.MacLength);
            hmacKey = objMacProv.CreateKey(buffKeyMaterial);

            // Sign the key and message together.
            buffHMAC = CryptographicEngine.Sign(hmacKey, buffMsg);

            // Verify that the HMAC length is correct for the selected algorithm
            if (buffHMAC.Length != objMacProv.MacLength)
            {
                throw new Exception("Error computing digest");
            }
         }

        public void VerifyHMAC(
            IBuffer buffMsg,
            CryptographicKey hmacKey,
            IBuffer buffHMAC)
        {
            // The input key must be securely shared between the sender of the HMAC and 
            // the recipient. The recipient uses the CryptographicEngine.VerifySignature() 
            // method as follows to verify that the message has not been altered in transit.
            Boolean IsAuthenticated = CryptographicEngine.VerifySignature(hmacKey, buffMsg, buffHMAC);
            if (!IsAuthenticated)
            {
                throw new Exception("The message cannot be verified.");
            }
        }
    }
}

Hashes

A titkosítási kivonatoló függvények tetszőlegesen hosszú adatblokkot használnak, és rögzített méretű bitsztringet ad vissza. A hash függvényeket általában adataláíráskor használják. Mivel a nyilvános kulcsok aláírási műveleteinek többsége számításigényes, általában hatékonyabb az üzenetkivonat aláírása (titkosítása), mint az eredeti üzenet aláírása. Az alábbi eljárás egy gyakori, bár leegyszerűsített forgatókönyvet jelöl:

• Alice rendelkezik nyilvános/titkos kulcspárokkal, és aláírt üzenetet szeretne küldeni Bobnak.
• Alice létrehoz egy üzenetet, és kivonatfüggvény használatával kiszámítja az üzenet kivonatát.
• Alice aláírja a kivonatot a titkos kulcsával, és elküldi a [titkosítatlan] üzenetet és az aláírást Bobnak egy hálózaton keresztül.
• Bob ugyanazt a kivonatfüggvényt használva számítja ki a kapott üzenet kivonatát. Ezután Alice nyilvános kulcsával fejti vissza az aláírást, és összehasonlítja a számított kivonatokkal. Ha megegyeznek, az üzenet nem módosult az átvitel során, és Alice-től származik.

Vegye figyelembe, hogy Alice titkosítatlan üzenetet küldött. Csak a kivonat volt titkosítva. Az eljárás csak azt biztosítja, hogy az eredeti üzenet ne legyen módosítva, és Alice nyilvános kulcsával, hogy az üzenet kivonatát valaki aláírja, aki hozzáfér Alice titkos kulcsához, feltehetően Alice-hez.

A HashAlgorithmProvider osztály használatával számba vehetők az elérhető kivonatoló algoritmusok, és létrehozhat egy CryptographicHash értéket.

A digitális aláírások a titkos kulcsú üzenethitelesítési kódok (MAC-k) nyilvános kulcsának megfelelői. Míg a MAC-ek titkos kulcsokkal teszik lehetővé az üzenet címzettjének, hogy ellenőrizze, az üzenet nem módosult-e az átvitel során, addig az aláírások privát/nyilvános kulcspárokat használnak.

A CryptographicHash objektum használatával ismétlődően kivonatolhatja a különböző adatokat anélkül, hogy minden egyes használathoz újra létre kellene hoznia az objektumot. A Hozzáfűzés metódus új adatokat ad hozzá egy kivonatolt pufferhez. A GetValueAndReset metódus kivonatozza az adatokat, és alaphelyzetbe állítja az objektumot egy másik használatra. Ezt az alábbi példa mutatja.

public void SampleReusableHash()
{
    // Create a string that contains the name of the hashing algorithm to use.
    String strAlgName = HashAlgorithmNames.Sha512;

    // Create a HashAlgorithmProvider object.
    HashAlgorithmProvider objAlgProv = HashAlgorithmProvider.OpenAlgorithm(strAlgName);

    // Create a CryptographicHash object. This object can be reused to continually
    // hash new messages.
    CryptographicHash objHash = objAlgProv.CreateHash();

    // Hash message 1.
    String strMsg1 = "This is message 1.";
    IBuffer buffMsg1 = CryptographicBuffer.ConvertStringToBinary(strMsg1, BinaryStringEncoding.Utf16BE);
    objHash.Append(buffMsg1);
    IBuffer buffHash1 = objHash.GetValueAndReset();

    // Hash message 2.
    String strMsg2 = "This is message 2.";
    IBuffer buffMsg2 = CryptographicBuffer.ConvertStringToBinary(strMsg2, BinaryStringEncoding.Utf16BE);
    objHash.Append(buffMsg2);
    IBuffer buffHash2 = objHash.GetValueAndReset();

    // Hash message 3.
    String strMsg3 = "This is message 3.";
    IBuffer buffMsg3 = CryptographicBuffer.ConvertStringToBinary(strMsg3, BinaryStringEncoding.Utf16BE);
    objHash.Append(buffMsg3);
    IBuffer buffHash3 = objHash.GetValueAndReset();

    // Convert the hashes to string values (for display);
    String strHash1 = CryptographicBuffer.EncodeToBase64String(buffHash1);
    String strHash2 = CryptographicBuffer.EncodeToBase64String(buffHash2);
    String strHash3 = CryptographicBuffer.EncodeToBase64String(buffHash3);
}

Digitális aláírások

A digitális aláírások a titkos kulcsú üzenethitelesítési kódok (MAC-k) nyilvános kulcsának megfelelői. Míg a MAC-ek privát kulcsokat használnak annak érdekében, hogy az üzenet címzettje ellenőrizhesse, hogy az üzenetet nem módosították az átvitel során, addig az aláírások privát/nyilvános kulcspárt alkalmaznak.

Mivel a nyilvános kulcsok aláírási műveleteinek többsége számításigényes, általában hatékonyabb az üzenetkivonat aláírása (titkosítása), mint az eredeti üzenet aláírása. A feladó létrehoz egy üzenetkivonatot, aláírja azt, és elküldi az aláírást és a (titkosítatlan) üzenetet is. A címzett kiszámítja az üzenet kivonatát, visszafejti az aláírást, és összehasonlítja a visszafejtött aláírást a kivonat értékével. Ha megegyeznek, a címzett meglehetősen biztos lehet abban, hogy az üzenet valójában a feladótól származik, és az átvitel során nem módosult.

Az aláírás csak azt biztosítja, hogy az eredeti üzenet ne legyen módosítva, és a feladó nyilvános kulcsának használatával az üzenet kivonatát a titkos kulcshoz hozzáféréssel rendelkező személy írta alá.

Az AsymmetricKeyAlgorithmProvider objektummal számba vehetők az elérhető aláírási algoritmusok, és kulcspárokat hozhat létre vagy importálhat. A CryptographicHash osztály statikus metódusaival aláírhat egy üzenetet, vagy ellenőrizheti az aláírást.