llblowfish_tut.cpp

Go to the documentation of this file.

#include "linden_common.h"
#include "lltut.h"

#include "llblowfishcipher.h"

#include "lluuid.h"

namespace tut
{
        class LLData
        {
        public:
                unsigned char* mInput;
                int mInputSize;

                LLData()
                {
                        // \n to make it easier to create text files
                        // for testing with command line openssl
                        mInput = (unsigned char*)"01234567890123456789012345678901234\n";
                        mInputSize = 36;
                }

                bool matchFile(const char* filename,
                                const std::string& data)
                {
                        FILE* fp = fopen(filename, "rb");
                        if (!fp) 
                        {
                                // sometimes test is run inside the indra directory
                                std::string path = "test/";
                                path += filename;
                                fp = fopen(path.c_str(), "rb");
                        }
                        if (!fp)
                        {
                                llwarns << "unabled to open " << filename << llendl;
                                return false;
                        }

                        std::string good;
                        good.resize(256);
                        size_t got = fread(&good[0], 1, 256, fp);
                        lldebugs << "matchFile read " << got << llendl;
                        fclose(fp);
                        good.resize(got);
                
                        return (good == data);
                }
        };
        typedef test_group<LLData> blowfish_test;
        typedef blowfish_test::object blowfish_object;
        // Create test with name that can be selected on
        // command line of test app.
        tut::blowfish_test blowfish("blowfish");

        template<> template<>
        void blowfish_object::test<1>()
        {
                LLUUID blank;
                LLBlowfishCipher cipher(&blank.mData[0], UUID_BYTES);

                U32 dst_len = cipher.requiredEncryptionSpace(36);
                ensure("encryption space 36",
                                (dst_len == 40) );

                // Blowfish adds an additional 8-byte block if your
                // input is an exact multiple of 8
                dst_len = cipher.requiredEncryptionSpace(8);
                ensure("encryption space 8",
                                (dst_len == 16)  );
        }

        template<> template<>
        void blowfish_object::test<2>()
        {
                LLUUID blank;
                LLBlowfishCipher cipher(&blank.mData[0], UUID_BYTES);

                std::string result;
                result.resize(256);
                U32 count = cipher.encrypt(mInput, mInputSize,
                                (U8*) &result[0], 256);

                ensure("encrypt output count",
                                (count == 40) );
                result.resize(count);

                ensure("encrypt null key", matchFile("blowfish.1.bin", result));
        }

        template<> template<>
        void blowfish_object::test<3>()
        {
                // same as base64 test id
                LLUUID id("526a1e07-a19d-baed-84c4-ff08a488d15e");
                LLBlowfishCipher cipher(&id.mData[0], UUID_BYTES);

                std::string result;
                result.resize(256);
                U32 count = cipher.encrypt(mInput, mInputSize,
                                (U8*) &result[0], 256);

                ensure("encrypt output count",
                                (count == 40) );
                result.resize(count);

                ensure("encrypt real key", matchFile("blowfish.2.bin", result));
        }
}

---