DesTest.cs | searchcode

/base/Applications/Security/CryptoBvt/DesTest.cs

#
C# | 308 lines | 245 code | 50 blank | 13 comment | 26 complexity | 6982a7208dffe2da72ef47711d336802 MD5 | raw file

///////////////////////////////////////////////////////////////////////////////

//

//  Microsoft Research Singularity

//

//  Copyright (c) Microsoft Corporation.  All rights reserved.

//



using System;

using System.Security.Cryptography;



interface IDes

{

    void EncryptBlock(byte[] key, byte[] input, byte[] output);

    void DecryptBlock(byte[] key, byte[] input, byte[] output);

}



class ManagedDes : IDes

{

    public void EncryptBlock(byte[] key, byte[] input, byte[] output)

    {

        Des.EncryptDecrypt(key, input, output, true);

    }



    public void DecryptBlock(byte[] key, byte[] input, byte[] output)

    {

        Des.EncryptDecrypt(key, input, output, false);

    }

}



class DesTest

{

    public static void RunTests()

    {

        IDes![]! implementations = {

            new ManagedDes(),

            // no other implementations are available on Singularity yet

        };



        TestKnownCiphers(implementations);



        TestInterop(implementations);



        foreach (IDes! des in implementations) {

            TestRandomCiphers(des);

        }



        Console.WriteLine("DES TEST: All tests complete.");

    }



    static void TestRandomCiphers(IDes! des)

    {

        Console.WriteLine("DES TEST: Testing implementation '{0}' for roundtrip encrypt/decrypt.", des.GetType().Name);

        int tickStarted = Environment.TickCount;

        int tickStopped;

        int cipherCount = 0;



        Random random = new Random();



        for (;;) {

            for (int pass = 0; pass < 0x100; pass++) {

                byte[] key = new byte[8];

                for (int i = 0; i < 8; i++)

                    key[i] = (byte)random.Next(0, 0x100);



                byte[] message = new byte[8];

                for (int i = 0; i < 8; i++)

                    message[i] = (byte)random.Next(0, 0x100);



                byte[] cipher = new byte[8];

                byte[] roundtrip_clear = new byte[8];

                des.EncryptBlock(key, message, cipher);

                cipherCount++;

                des.DecryptBlock(key, cipher, roundtrip_clear);

                cipherCount++;



                if (Util.CompareArraySpans(message, 0, roundtrip_clear, 0, 8) != 0) {

                    Console.WriteLine("DES ERROR: DES implementation '{0}' FAILED an encrypt/decrypt roundtrip test.", des.GetType().Name);

                    Console.WriteLine("    key:                " + Util.ByteArrayToStringHex(key));

                    Console.WriteLine("    clear text (input): " + Util.ByteArrayToStringHex(message));

                    Console.WriteLine("    cipher text:        " + Util.ByteArrayToStringHex(cipher));

                    Console.WriteLine("    clear text (output): " + Util.ByteArrayToStringHex(roundtrip_clear));

                    return;

                }

            }



            int now = Environment.TickCount;

            int elapsed = now - tickStarted;



            if (elapsed > 5000) {

                tickStopped = now;

                break;

            }

        }



        Console.WriteLine("    PASSED.");

        if (cipherCount > 0) {

            int totalElapsedMs = tickStopped - tickStarted;

            double ciphersPerSecond = cipherCount / ((double)totalElapsedMs) * 1000.0;

            Console.WriteLine("    Approx ciphers/sec: {0}", ciphersPerSecond);

        }

    }



    static void TestInterop(IDes![]! imps)

    {

        Console.WriteLine("TEST: Testing interoperability between different implementations.");

        Random random = new Random();

        int failureCount = 0;



        for (int pass = 0; pass < 10; pass++) {

            byte[] key = new byte[8];

            for (int i = 0; i < 8; i++)

                key[i] = (byte)random.Next(0, 0x100);



            byte[] message = new byte[8];

            for (int i = 0; i < 8; i++)

                message[i] = (byte)random.Next(0, 0x100);



            for (int i = 0; i < imps.Length; i++) {

                for (int j = 0; j < imps.Length; j++) {

                    IDes! encrypt = imps[i];

                    IDes! decrypt = imps[j];

                    byte[] cipher = new byte[message.Length];

                    byte[] clear = new byte[message.Length];

                    encrypt.EncryptBlock(key, message, cipher);

                    decrypt.DecryptBlock(key, cipher, clear);



                    int c = Util.CompareArraySpans(message, 0, clear, 0, message.Length);

                    if (c != 0) {

                        Console.WriteLine("DECRYPTED VALUES ARE DIFFERENT!");

                        Console.WriteLine("Encryptor: " + encrypt.GetType().FullName);

                        Console.WriteLine("Decryptor: " + decrypt.GetType().FullName);

                        Console.WriteLine("Clear text:");

                        Util.DumpBuffer(message);

                        Console.WriteLine("Cipher text:");

                        Util.DumpBuffer(cipher);

                        Console.WriteLine("Output text");

                        Util.DumpBuffer(clear);

                        failureCount++;



                        i = imps.Length; break;

                    }

                    else {

                        // Console.WriteLine("TEST: encrypt {0,-20} decrypt {1,-20} - ok", encrypt.GetType().Name, decrypt.GetType().Name));

                    }

                }

            }

        }



        if (failureCount == 0) {

            Console.WriteLine("    PASSED: All interoperability tests succeeded.");

        }

        else {

            Console.WriteLine("    FAILED: At least one interop test failed.");

        }

    }



    static void EmitRandomKnownCiphers()

    {

        Random random = new Random();



        Console.WriteLine("static readonly KnownCipher[] _knownCiphers = {");

        for (int i = 0; i < 0x20; i++) {

            byte[] key = new byte[8];

            random.NextBytes(key);



            byte[] message = new byte[8];

            random.NextBytes(message);



            byte[] cipher = new byte[8];

            Des.Encrypt(key, message, cipher);



            Console.WriteLine("new KnownCipher(\"{0}\", \"{1}\", \"{2}\"),",

                Util.ByteArrayToStringHex(key),

                Util.ByteArrayToStringHex(message),

                Util.ByteArrayToStringHex(cipher));

        }

        Console.WriteLine("}");

    }



    /// <summary>

    /// This method verifies that a DES implementation correctly encrypts and decrypts all of the

    /// values in the table of known ciphers.

    /// </summary>

    /// <param name="des">The implementation to test.</param>

    static void TestKnownCiphers(IDes![]! implementations)

    {

        Console.WriteLine("TEST: Testing all DES implementations against {0} known ciphers:", _knownCiphers.Length);

        foreach (IDes! des in implementations) {

            string! implementationName = (!)des.GetType().Name;



            bool passed = true;



            foreach (KnownCipher known in _knownCiphers) {

                byte[] cipher = new byte[8];

                des.EncryptBlock(known.Key, known.ClearText, cipher);



                if (Util.CompareArraySpans(cipher, 0, known.Cipher, 0, 8) != 0) {

                    Console.WriteLine("*** DES implementation '{0}' FAILED to correctly ENCIPHER a block.", implementationName);

                    Console.WriteLine("    key:                     " + Util.ByteArrayToStringHex(known.Key));

                    Console.WriteLine("    clear text:              " + Util.ByteArrayToStringHex(known.ClearText));

                    Console.WriteLine("    known good cipher text:  " + Util.ByteArrayToStringHex(known.Cipher));

                    Console.WriteLine("    failed cipher text:      " + Util.ByteArrayToStringHex(cipher));

                    passed = false;

                    break;

                }



                byte[] cleartext = new byte[8];

                des.DecryptBlock(known.Key, known.Cipher, cleartext);



                if (Util.CompareArraySpans(cipher, 0, known.Cipher, 0, 8) != 0) {

                    Console.WriteLine("*** DES implementation '{0}' FAILED to correctly DECIPHER a block.", implementationName);

                    Console.WriteLine("    key:                    " + Util.ByteArrayToStringHex(known.Key));

                    Console.WriteLine("    cipher text:            " + Util.ByteArrayToStringHex(known.ClearText));

                    Console.WriteLine("    known good clear text:  " + Util.ByteArrayToStringHex(known.Cipher));

                    Console.WriteLine("    failed clear text:      " + Util.ByteArrayToStringHex(cipher));

                    passed = false;

                    break;

                }

            }



            if (passed) {

                Console.WriteLine("    PASSED: " + implementationName);

            }

            else {

                Console.WriteLine("    FAILED: " + implementationName);

            }

        }

    }



#if false

    void TestPerformance(DesImplementation[] imps)

    {

        Console.WriteLine("TEST: Estimating performance of implementations:");



        Random random = new Random();



        foreach (DesImplementation des in imps) {

            byte[] key = new byte[0];

            random.NextBytes(key);



            byte[] cleartext = new byte[0];

        }

    }

#endif



    struct KnownCipher

    {

        public KnownCipher(string! key, string! cleartext, string! cipher)

            : this(

            Util.HexStringToByteArray(key),

            Util.HexStringToByteArray(cleartext),

            Util.HexStringToByteArray(cipher))

        {

        }



        public KnownCipher(byte[]! key, byte[]! cleartext, byte[]! cipher)

        {

            this.Key = key;

            this.ClearText = cleartext;

            this.Cipher = cipher;

        }



        public readonly byte[]! Key;

        public readonly byte[]! ClearText;

        public readonly byte[]! Cipher;

    }





    static readonly KnownCipher[] _knownCiphers =

        {

            new KnownCipher("26e9fc83852311d8", "e1402d0f9442d85c", "c0e394fd6490aa0f"),

            new KnownCipher("c95e9d039d732b6c", "2eee2417b69692a8", "bcb78b4a1215d78a"),

            new KnownCipher("7b331146c590b1d3", "6e376932bb2c030f", "555127f9a4111092"),

            new KnownCipher("e83a28ea550972b3", "be905596fff9224b", "f9656d3ec8fbab2d"),

            new KnownCipher("ae85936030929638", "adc9946509f9b101", "6b90762b582cad2d"),

            new KnownCipher("eb142f7b6da75271", "c05e88353b1ad474", "349b95d1d20d26c1"),

            new KnownCipher("141d833598a2df55", "a4f03d8b740ca9c4", "74507d68be5a8638"),

            new KnownCipher("df53abeacaa7de06", "3222a0d10961fd92", "c366707e826f47f1"),

            new KnownCipher("f52050eb757b6948", "35d9d77c6ac7fdb4", "738b39e892f934fd"),

            new KnownCipher("b5c356e76ee9aa6d", "3f7d0376020e4c42", "3b85c78032007603"),

            new KnownCipher("f3aa9654bbbd4f63", "ea63b4f0d0619c6a", "75609fcade3f50a3"),

            new KnownCipher("25ec1b450b15240b", "75e3acf777f24627", "72021f00c2d5d1ba"),

            new KnownCipher("8d9489bf31a8f8f8", "74f2fd0b35ba9cdd", "47b36b2a63ee1625"),

            new KnownCipher("e1985116f20637dd", "868aded81057ecf7", "0ef7b7b9e9253675"),

            new KnownCipher("1c8d623bd7dd397c", "f322d1181818d6bb", "5d9e33944c860522"),

            new KnownCipher("46cf16dea1303487", "5cac38a6ca1fe81d", "b665aef92e365f88"),

            new KnownCipher("0605eea757600504", "5ed422d0351fc46e", "744b0036d03d4d9b"),

            new KnownCipher("b4229141400d56ec", "59dadf2ba493b2d4", "c480de721320b5a8"),

            new KnownCipher("3ab31212292f63e5", "c9127fcc0d64523d", "d45e4fd7fbe7b1fe"),

            new KnownCipher("e7caf2a78ea6dcf8", "af024d7d81da5fcb", "37e340853ffde534"),

            new KnownCipher("224e95810cb24485", "beab772d8d89def5", "f5f9847dd156ab1b"),

            new KnownCipher("88a143daa10a4693", "d6196327e1e664ef", "e752f30bd985b91e"),

            new KnownCipher("b3b4aabfced03135", "856de9e22eaf6b26", "627247191de4454e"),

            new KnownCipher("2358f4e096852a17", "0801aaf24e1da3d7", "55da1f2d460c0d43"),

            new KnownCipher("47887ad8de1e26b7", "6f0e543321636427", "e04edfab22c74acc"),

            new KnownCipher("ae3c0389f283592d", "8a93b7cd263ee668", "50889aa8dbafb44c"),

            new KnownCipher("c9119ba635924704", "313c708731f6f6a4", "7637d6adbc64209a"),

            new KnownCipher("9c834311191ae5c3", "2f4c4e4b67599130", "6ba0e036c4584386"),

            new KnownCipher("28eb6a10c8bef21c", "f5fe57b512d1fc93", "e0a4ff1c86883af1"),

            new KnownCipher("9d1330a2fbd44fae", "2cd777e843fc9dd7", "54091b5227549171"),

            new KnownCipher("aa3f5f468ce5dcdd", "91261c1ac32fb05d", "dd5fe1a60c3fa9ed"),

            new KnownCipher("50bbae5428ef3553", "9bbbe3f04709d9f8", "ad28c355c1b48107"),

        };









}